// File: /workspace/github_c_makefile_star2_O2/samtools[P]htslib/htscodecs/htscodecs/rANS_static32x16pr_sse4.c
// Function: transpose_and_copy
static inline void transpose_and_copy(uint8_t *out, int iN[32],
                                      uint8_t t[32][32]) {
    int z;

    // Simplified version from below.
    // This is pretty good with zig cc, but slow on clang and very slow on
    // gcc, even with -O3
    /*
    for (z = 0; z < NX; z++) {
        int k;
        for (k = 0; k < 32; k++)
            out[iN[z]+k] = t[k][z];
        iN[z] += 32;
    }
    */


    // A better approach for clang and gcc can be had with some manual
    // restructuring to attempt to do the two loops in explcit blocks.
    // With gcc -O3 or -O2 -ftree-vectorize this is quite fast, as is clang
    // and zig but neither beat the version below (or, for zig, the basic
    // code above).
    //
    // It's left here incase we ever want to move to tidier code and
    // to understand what auto-vectorises and what doesn't.
    /*
#define NZ 2
#define NK 8
    for (z = 0; z < 32; z+=NZ) {
        for (int k = 0; k < 32; k+=NK) {
            for (int z0 = z; z0 < z+NZ; z0++) {
                uint8_t tmp[NK];// __attribute__((aligned(32)));
                //uint8_t (*RESTRICT t0)[32] = &t[k];
                for (int k0 = 0; k0 < NK; k0++)
                    //tmp[k0] = t0[k0][z0];
                    tmp[k0] = t[k+k0][z0];
                memcpy(&out[iN[z0]+k], tmp, NK);
            }
        }
        for (int z0 = z; z0 < z+NZ; z0++)
            iN[z0] += 32;
    }
    */

    // Manually unrolled code.
    // This is fastest on gcc and clang and not far behind with zig cc.
    // It also doesn't need aggressive gcc optimisation levels to be
    // efficient.
    //
    // It works by constructing 64-bit ints and copying them with a single
    // memory write.  The fixed size memcpys just boil down to a memory write,
    // but unlike the earlier versions that did this direct, this isn't
    // exploiting undefined behaviour.
    for (z = 0; z < 32; z+=4) {
        uint64_t i64;
        i64 =
            ((uint64_t)(t[0][z])<< 0) +
            ((uint64_t)(t[1][z])<< 8) +
            ((uint64_t)(t[2][z])<<16) +
            ((uint64_t)(t[3][z])<<24) +
            ((uint64_t)(t[4][z])<<32) +
            ((uint64_t)(t[5][z])<<40) +
            ((uint64_t)(t[6][z])<<48) +
            ((uint64_t)(t[7][z])<<56);
        memcpy(&out[iN[z]], &i64, 8);
        i64 =
            ((uint64_t)(t[0][z+1])<< 0) +
            ((uint64_t)(t[1][z+1])<< 8) +
            ((uint64_t)(t[2][z+1])<<16) +
            ((uint64_t)(t[3][z+1])<<24) +
            ((uint64_t)(t[4][z+1])<<32) +
            ((uint64_t)(t[5][z+1])<<40) +
            ((uint64_t)(t[6][z+1])<<48) +
            ((uint64_t)(t[7][z+1])<<56);
        memcpy(&out[iN[z+1]], &i64, 8);
        i64 =
            ((uint64_t)(t[0][z+2])<< 0) +
            ((uint64_t)(t[1][z+2])<< 8) +
            ((uint64_t)(t[2][z+2])<<16) +
            ((uint64_t)(t[3][z+2])<<24) +
            ((uint64_t)(t[4][z+2])<<32) +
            ((uint64_t)(t[5][z+2])<<40) +
            ((uint64_t)(t[6][z+2])<<48) +
            ((uint64_t)(t[7][z+2])<<56);
        memcpy(&out[iN[z+2]], &i64, 8);
        i64 =
            ((uint64_t)(t[0][z+3])<< 0) +
            ((uint64_t)(t[1][z+3])<< 8) +
            ((uint64_t)(t[2][z+3])<<16) +
            ((uint64_t)(t[3][z+3])<<24) +
            ((uint64_t)(t[4][z+3])<<32) +
            ((uint64_t)(t[5][z+3])<<40) +
            ((uint64_t)(t[6][z+3])<<48) +
            ((uint64_t)(t[7][z+3])<<56);
        memcpy(&out[iN[z+3]], &i64, 8);

        i64 =
            ((uint64_t)(t[8+0][z])<< 0) +
            ((uint64_t)(t[8+1][z])<< 8) +
            ((uint64_t)(t[8+2][z])<<16) +
            ((uint64_t)(t[8+3][z])<<24) +
            ((uint64_t)(t[8+4][z])<<32) +
            ((uint64_t)(t[8+5][z])<<40) +
            ((uint64_t)(t[8+6][z])<<48) +
            ((uint64_t)(t[8+7][z])<<56);
        memcpy(&out[iN[z]+8], &i64, 8);
        i64 =
            ((uint64_t)(t[8+0][z+1])<< 0) +
            ((uint64_t)(t[8+1][z+1])<< 8) +
            ((uint64_t)(t[8+2][z+1])<<16) +
            ((uint64_t)(t[8+3][z+1])<<24) +
            ((uint64_t)(t[8+4][z+1])<<32) +
            ((uint64_t)(t[8+5][z+1])<<40) +
            ((uint64_t)(t[8+6][z+1])<<48) +
            ((uint64_t)(t[8+7][z+1])<<56);
        memcpy(&out[iN[z+1]+8], &i64, 8);
        i64 =
            ((uint64_t)(t[8+0][z+2])<< 0) +
            ((uint64_t)(t[8+1][z+2])<< 8) +
            ((uint64_t)(t[8+2][z+2])<<16) +
            ((uint64_t)(t[8+3][z+2])<<24) +
            ((uint64_t)(t[8+4][z+2])<<32) +
            ((uint64_t)(t[8+5][z+2])<<40) +
            ((uint64_t)(t[8+6][z+2])<<48) +
            ((uint64_t)(t[8+7][z+2])<<56);
        memcpy(&out[iN[z+2]+8], &i64, 8);
        i64 =
            ((uint64_t)(t[8+0][z+3])<< 0) +
            ((uint64_t)(t[8+1][z+3])<< 8) +
            ((uint64_t)(t[8+2][z+3])<<16) +
            ((uint64_t)(t[8+3][z+3])<<24) +
            ((uint64_t)(t[8+4][z+3])<<32) +
            ((uint64_t)(t[8+5][z+3])<<40) +
            ((uint64_t)(t[8+6][z+3])<<48) +
            ((uint64_t)(t[8+7][z+3])<<56);
        memcpy(&out[iN[z+3]+8], &i64, 8);

        i64 =
            ((uint64_t)(t[16+0][z])<< 0) +
            ((uint64_t)(t[16+1][z])<< 8) +
            ((uint64_t)(t[16+2][z])<<16) +
            ((uint64_t)(t[16+3][z])<<24) +
            ((uint64_t)(t[16+4][z])<<32) +
            ((uint64_t)(t[16+5][z])<<40) +
            ((uint64_t)(t[16+6][z])<<48) +
            ((uint64_t)(t[16+7][z])<<56);
        memcpy(&out[iN[z]+16], &i64, 8);
        i64 =
            ((uint64_t)(t[16+0][z+1])<< 0) +
            ((uint64_t)(t[16+1][z+1])<< 8) +
            ((uint64_t)(t[16+2][z+1])<<16) +
            ((uint64_t)(t[16+3][z+1])<<24) +
            ((uint64_t)(t[16+4][z+1])<<32) +
            ((uint64_t)(t[16+5][z+1])<<40) +
            ((uint64_t)(t[16+6][z+1])<<48) +
            ((uint64_t)(t[16+7][z+1])<<56);
        memcpy(&out[iN[z+1]+16], &i64, 8);
        i64 =
            ((uint64_t)(t[16+0][z+2])<< 0) +
            ((uint64_t)(t[16+1][z+2])<< 8) +
            ((uint64_t)(t[16+2][z+2])<<16) +
            ((uint64_t)(t[16+3][z+2])<<24) +
            ((uint64_t)(t[16+4][z+2])<<32) +
            ((uint64_t)(t[16+5][z+2])<<40) +
            ((uint64_t)(t[16+6][z+2])<<48) +
            ((uint64_t)(t[16+7][z+2])<<56);
        memcpy(&out[iN[z+2]+16], &i64, 8);
        i64 =
            ((uint64_t)(t[16+0][z+3])<< 0) +
            ((uint64_t)(t[16+1][z+3])<< 8) +
            ((uint64_t)(t[16+2][z+3])<<16) +
            ((uint64_t)(t[16+3][z+3])<<24) +
            ((uint64_t)(t[16+4][z+3])<<32) +
            ((uint64_t)(t[16+5][z+3])<<40) +
            ((uint64_t)(t[16+6][z+3])<<48) +
            ((uint64_t)(t[16+7][z+3])<<56);
        memcpy(&out[iN[z+3]+16], &i64, 8);

        i64 =
            ((uint64_t)(t[24+0][z])<< 0) +
            ((uint64_t)(t[24+1][z])<< 8) +
            ((uint64_t)(t[24+2][z])<<16) +
            ((uint64_t)(t[24+3][z])<<24) +
            ((uint64_t)(t[24+4][z])<<32) +
            ((uint64_t)(t[24+5][z])<<40) +
            ((uint64_t)(t[24+6][z])<<48) +
            ((uint64_t)(t[24+7][z])<<56);
        memcpy(&out[iN[z]+24], &i64, 8);
        i64 =
            ((uint64_t)(t[24+0][z+1])<< 0) +
            ((uint64_t)(t[24+1][z+1])<< 8) +
            ((uint64_t)(t[24+2][z+1])<<16) +
            ((uint64_t)(t[24+3][z+1])<<24) +
            ((uint64_t)(t[24+4][z+1])<<32) +
            ((uint64_t)(t[24+5][z+1])<<40) +
            ((uint64_t)(t[24+6][z+1])<<48) +
            ((uint64_t)(t[24+7][z+1])<<56);
        memcpy(&out[iN[z+1]+24], &i64, 8);
        i64 =
            ((uint64_t)(t[24+0][z+2])<< 0) +
            ((uint64_t)(t[24+1][z+2])<< 8) +
            ((uint64_t)(t[24+2][z+2])<<16) +
            ((uint64_t)(t[24+3][z+2])<<24) +
            ((uint64_t)(t[24+4][z+2])<<32) +
            ((uint64_t)(t[24+5][z+2])<<40) +
            ((uint64_t)(t[24+6][z+2])<<48) +
            ((uint64_t)(t[24+7][z+2])<<56);
        memcpy(&out[iN[z+2]+24], &i64, 8);
        i64 =
            ((uint64_t)(t[24+0][z+3])<< 0) +
            ((uint64_t)(t[24+1][z+3])<< 8) +
            ((uint64_t)(t[24+2][z+3])<<16) +
            ((uint64_t)(t[24+3][z+3])<<24) +
            ((uint64_t)(t[24+4][z+3])<<32) +
            ((uint64_t)(t[24+5][z+3])<<40) +
            ((uint64_t)(t[24+6][z+3])<<48) +
            ((uint64_t)(t[24+7][z+3])<<56);
        memcpy(&out[iN[z+3]+24], &i64, 8);

        iN[z+0] += 32;
        iN[z+1] += 32;
        iN[z+2] += 32;
        iN[z+3] += 32;
    }
}

// Assembly:
addq $0x3e3, %rdx            # imm = 0x3E3
xorl %eax, %eax
pmovsxbd 0x260b9(%rip), %xmm0    # 0x81dfc
cmpq $0x1f, %rax
ja 0x5c508
movzbl -0x3e3(%rdx,%rax), %ecx
movzbl -0x3c3(%rdx,%rax), %r8d
shll $0x8, %r8d
orq %rcx, %r8
movzbl -0x3a3(%rdx,%rax), %ecx
shll $0x10, %ecx
orq %r8, %rcx
movzbl -0x383(%rdx,%rax), %r8d
shll $0x18, %r8d
orq %rcx, %r8
movzbl -0x363(%rdx,%rax), %ecx
shlq $0x20, %rcx
orq %r8, %rcx
movzbl -0x343(%rdx,%rax), %r8d
shlq $0x28, %r8
orq %rcx, %r8
movzbl -0x323(%rdx,%rax), %ecx
shlq $0x30, %rcx
orq %r8, %rcx
movzbl -0x303(%rdx,%rax), %r8d
shlq $0x38, %r8
addq %rcx, %r8
movslq (%rsi,%rax,4), %rcx
movq %r8, (%rdi,%rcx)
movzbl -0x3e2(%rdx,%rax), %ecx
movzbl -0x3c2(%rdx,%rax), %r8d
shll $0x8, %r8d
orq %rcx, %r8
movzbl -0x3a2(%rdx,%rax), %ecx
shll $0x10, %ecx
orq %r8, %rcx
movzbl -0x382(%rdx,%rax), %r8d
shll $0x18, %r8d
orq %rcx, %r8
movzbl -0x362(%rdx,%rax), %ecx
shlq $0x20, %rcx
orq %r8, %rcx
movzbl -0x342(%rdx,%rax), %r8d
shlq $0x28, %r8
orq %rcx, %r8
movzbl -0x322(%rdx,%rax), %ecx
shlq $0x30, %rcx
orq %r8, %rcx
movzbl -0x302(%rdx,%rax), %r8d
shlq $0x38, %r8
addq %rcx, %r8
movslq 0x4(%rsi,%rax,4), %rcx
movq %r8, (%rdi,%rcx)
movzbl -0x3e1(%rdx,%rax), %ecx
movzbl -0x3c1(%rdx,%rax), %r8d
shll $0x8, %r8d
orq %rcx, %r8
movzbl -0x3a1(%rdx,%rax), %ecx
shll $0x10, %ecx
orq %r8, %rcx
movzbl -0x381(%rdx,%rax), %r8d
shll $0x18, %r8d
orq %rcx, %r8
movzbl -0x361(%rdx,%rax), %ecx
shlq $0x20, %rcx
orq %r8, %rcx
movzbl -0x341(%rdx,%rax), %r8d
shlq $0x28, %r8
orq %rcx, %r8
movzbl -0x321(%rdx,%rax), %ecx
shlq $0x30, %rcx
orq %r8, %rcx
movzbl -0x301(%rdx,%rax), %r8d
shlq $0x38, %r8
addq %rcx, %r8
movslq 0x8(%rsi,%rax,4), %rcx
movq %r8, (%rdi,%rcx)
movzbl -0x3e0(%rdx,%rax), %ecx
movzbl -0x3c0(%rdx,%rax), %r8d
shll $0x8, %r8d
orq %rcx, %r8
movzbl -0x3a0(%rdx,%rax), %ecx
shll $0x10, %ecx
orq %r8, %rcx
movzbl -0x380(%rdx,%rax), %r8d
shll $0x18, %r8d
orq %rcx, %r8
movzbl -0x360(%rdx,%rax), %ecx
shlq $0x20, %rcx
orq %r8, %rcx
movzbl -0x340(%rdx,%rax), %r8d
shlq $0x28, %r8
orq %rcx, %r8
movzbl -0x320(%rdx,%rax), %ecx
shlq $0x30, %rcx
orq %r8, %rcx
movzbl -0x300(%rdx,%rax), %r8d
shlq $0x38, %r8
addq %rcx, %r8
movslq 0xc(%rsi,%rax,4), %rcx
movq %r8, (%rdi,%rcx)
movzbl -0x2e3(%rdx,%rax), %ecx
movzbl -0x2c3(%rdx,%rax), %r8d
shll $0x8, %r8d
orq %rcx, %r8
movzbl -0x2a3(%rdx,%rax), %ecx
shll $0x10, %ecx
orq %r8, %rcx
movzbl -0x283(%rdx,%rax), %r8d
shll $0x18, %r8d
orq %rcx, %r8
movzbl -0x263(%rdx,%rax), %ecx
shlq $0x20, %rcx
orq %r8, %rcx
movzbl -0x243(%rdx,%rax), %r8d
shlq $0x28, %r8
orq %rcx, %r8
movzbl -0x223(%rdx,%rax), %ecx
shlq $0x30, %rcx
orq %r8, %rcx
movzbl -0x203(%rdx,%rax), %r8d
shlq $0x38, %r8
addq %rcx, %r8
movslq (%rsi,%rax,4), %rcx
movq %r8, 0x8(%rdi,%rcx)
movzbl -0x2e2(%rdx,%rax), %ecx
movzbl -0x2c2(%rdx,%rax), %r8d
shll $0x8, %r8d
orq %rcx, %r8
movzbl -0x2a2(%rdx,%rax), %ecx
shll $0x10, %ecx
orq %r8, %rcx
movzbl -0x282(%rdx,%rax), %r8d
shll $0x18, %r8d
orq %rcx, %r8
movzbl -0x262(%rdx,%rax), %ecx
shlq $0x20, %rcx
orq %r8, %rcx
movzbl -0x242(%rdx,%rax), %r8d
shlq $0x28, %r8
orq %rcx, %r8
movzbl -0x222(%rdx,%rax), %ecx
shlq $0x30, %rcx
orq %r8, %rcx
movzbl -0x202(%rdx,%rax), %r8d
shlq $0x38, %r8
addq %rcx, %r8
movslq 0x4(%rsi,%rax,4), %rcx
movq %r8, 0x8(%rdi,%rcx)
movzbl -0x2e1(%rdx,%rax), %ecx
movzbl -0x2c1(%rdx,%rax), %r8d
shll $0x8, %r8d
orq %rcx, %r8
movzbl -0x2a1(%rdx,%rax), %ecx
shll $0x10, %ecx
orq %r8, %rcx
movzbl -0x281(%rdx,%rax), %r8d
shll $0x18, %r8d
orq %rcx, %r8
movzbl -0x261(%rdx,%rax), %ecx
shlq $0x20, %rcx
orq %r8, %rcx
movzbl -0x241(%rdx,%rax), %r8d
shlq $0x28, %r8
orq %rcx, %r8
movzbl -0x221(%rdx,%rax), %ecx
shlq $0x30, %rcx
orq %r8, %rcx
movzbl -0x201(%rdx,%rax), %r8d
shlq $0x38, %r8
addq %rcx, %r8
movslq 0x8(%rsi,%rax,4), %rcx
movq %r8, 0x8(%rdi,%rcx)
movzbl -0x2e0(%rdx,%rax), %ecx
movzbl -0x2c0(%rdx,%rax), %r8d
shll $0x8, %r8d
orq %rcx, %r8
movzbl -0x2a0(%rdx,%rax), %ecx
shll $0x10, %ecx
orq %r8, %rcx
movzbl -0x280(%rdx,%rax), %r8d
shll $0x18, %r8d
orq %rcx, %r8
movzbl -0x260(%rdx,%rax), %ecx
shlq $0x20, %rcx
orq %r8, %rcx
movzbl -0x240(%rdx,%rax), %r8d
shlq $0x28, %r8
orq %rcx, %r8
movzbl -0x220(%rdx,%rax), %ecx
shlq $0x30, %rcx
orq %r8, %rcx
movzbl -0x200(%rdx,%rax), %r8d
shlq $0x38, %r8
addq %rcx, %r8
movslq 0xc(%rsi,%rax,4), %rcx
movq %r8, 0x8(%rdi,%rcx)
movzbl -0x1e3(%rdx,%rax), %ecx
movzbl -0x1c3(%rdx,%rax), %r8d
shll $0x8, %r8d
orq %rcx, %r8
movzbl -0x1a3(%rdx,%rax), %ecx
shll $0x10, %ecx
orq %r8, %rcx
movzbl -0x183(%rdx,%rax), %r8d
shll $0x18, %r8d
orq %rcx, %r8
movzbl -0x163(%rdx,%rax), %ecx
shlq $0x20, %rcx
orq %r8, %rcx
movzbl -0x143(%rdx,%rax), %r8d
shlq $0x28, %r8
orq %rcx, %r8
movzbl -0x123(%rdx,%rax), %ecx
shlq $0x30, %rcx
orq %r8, %rcx
movzbl -0x103(%rdx,%rax), %r8d
shlq $0x38, %r8
addq %rcx, %r8
movslq (%rsi,%rax,4), %rcx
movq %r8, 0x10(%rdi,%rcx)
movzbl -0x1e2(%rdx,%rax), %ecx
movzbl -0x1c2(%rdx,%rax), %r8d
shll $0x8, %r8d
orq %rcx, %r8
movzbl -0x1a2(%rdx,%rax), %ecx
shll $0x10, %ecx
orq %r8, %rcx
movzbl -0x182(%rdx,%rax), %r8d
shll $0x18, %r8d
orq %rcx, %r8
movzbl -0x162(%rdx,%rax), %ecx
shlq $0x20, %rcx
orq %r8, %rcx
movzbl -0x142(%rdx,%rax), %r8d
shlq $0x28, %r8
orq %rcx, %r8
movzbl -0x122(%rdx,%rax), %ecx
shlq $0x30, %rcx
orq %r8, %rcx
movzbl -0x102(%rdx,%rax), %r8d
shlq $0x38, %r8
addq %rcx, %r8
movslq 0x4(%rsi,%rax,4), %rcx
movq %r8, 0x10(%rdi,%rcx)
movzbl -0x1e1(%rdx,%rax), %ecx
movzbl -0x1c1(%rdx,%rax), %r8d
shll $0x8, %r8d
orq %rcx, %r8
movzbl -0x1a1(%rdx,%rax), %ecx
shll $0x10, %ecx
orq %r8, %rcx
movzbl -0x181(%rdx,%rax), %r8d
shll $0x18, %r8d
orq %rcx, %r8
movzbl -0x161(%rdx,%rax), %ecx
shlq $0x20, %rcx
orq %r8, %rcx
movzbl -0x141(%rdx,%rax), %r8d
shlq $0x28, %r8
orq %rcx, %r8
movzbl -0x121(%rdx,%rax), %ecx
shlq $0x30, %rcx
orq %r8, %rcx
movzbl -0x101(%rdx,%rax), %r8d
shlq $0x38, %r8
addq %rcx, %r8
movslq 0x8(%rsi,%rax,4), %rcx
movq %r8, 0x10(%rdi,%rcx)
movzbl -0x1e0(%rdx,%rax), %ecx
movzbl -0x1c0(%rdx,%rax), %r8d
shll $0x8, %r8d
orq %rcx, %r8
movzbl -0x1a0(%rdx,%rax), %ecx
shll $0x10, %ecx
orq %r8, %rcx
movzbl -0x180(%rdx,%rax), %r8d
shll $0x18, %r8d
orq %rcx, %r8
movzbl -0x160(%rdx,%rax), %ecx
shlq $0x20, %rcx
orq %r8, %rcx
movzbl -0x140(%rdx,%rax), %r8d
shlq $0x28, %r8
orq %rcx, %r8
movzbl -0x120(%rdx,%rax), %ecx
shlq $0x30, %rcx
orq %r8, %rcx
movzbl -0x100(%rdx,%rax), %r8d
shlq $0x38, %r8
addq %rcx, %r8
movslq 0xc(%rsi,%rax,4), %rcx
movq %r8, 0x10(%rdi,%rcx)
movzbl -0xe3(%rdx,%rax), %ecx
movzbl -0xc3(%rdx,%rax), %r8d
shll $0x8, %r8d
orq %rcx, %r8
movzbl -0xa3(%rdx,%rax), %ecx
shll $0x10, %ecx
orq %r8, %rcx
movzbl -0x83(%rdx,%rax), %r8d
shll $0x18, %r8d
orq %rcx, %r8
movzbl -0x63(%rdx,%rax), %ecx
shlq $0x20, %rcx
orq %r8, %rcx
movzbl -0x43(%rdx,%rax), %r8d
shlq $0x28, %r8
orq %rcx, %r8
movzbl -0x23(%rdx,%rax), %ecx
shlq $0x30, %rcx
orq %r8, %rcx
movzbl -0x3(%rdx,%rax), %r8d
shlq $0x38, %r8
addq %rcx, %r8
movslq (%rsi,%rax,4), %rcx
movq %r8, 0x18(%rdi,%rcx)
movzbl -0xe2(%rdx,%rax), %ecx
movzbl -0xc2(%rdx,%rax), %r8d
shll $0x8, %r8d
orq %rcx, %r8
movzbl -0xa2(%rdx,%rax), %ecx
shll $0x10, %ecx
orq %r8, %rcx
movzbl -0x82(%rdx,%rax), %r8d
shll $0x18, %r8d
orq %rcx, %r8
movzbl -0x62(%rdx,%rax), %ecx
shlq $0x20, %rcx
orq %r8, %rcx
movzbl -0x42(%rdx,%rax), %r8d
shlq $0x28, %r8
orq %rcx, %r8
movzbl -0x22(%rdx,%rax), %ecx
shlq $0x30, %rcx
orq %r8, %rcx
movzbl -0x2(%rdx,%rax), %r8d
shlq $0x38, %r8
addq %rcx, %r8
movslq 0x4(%rsi,%rax,4), %rcx
movq %r8, 0x18(%rdi,%rcx)
movzbl -0xe1(%rdx,%rax), %ecx
movzbl -0xc1(%rdx,%rax), %r8d
shll $0x8, %r8d
orq %rcx, %r8
movzbl -0xa1(%rdx,%rax), %ecx
shll $0x10, %ecx
orq %r8, %rcx
movzbl -0x81(%rdx,%rax), %r8d
shll $0x18, %r8d
orq %rcx, %r8
movzbl -0x61(%rdx,%rax), %ecx
shlq $0x20, %rcx
orq %r8, %rcx
movzbl -0x41(%rdx,%rax), %r8d
shlq $0x28, %r8
orq %rcx, %r8
movzbl -0x21(%rdx,%rax), %ecx
shlq $0x30, %rcx
orq %r8, %rcx
movzbl -0x1(%rdx,%rax), %r8d
shlq $0x38, %r8
addq %rcx, %r8
movslq 0x8(%rsi,%rax,4), %rcx
movq %r8, 0x18(%rdi,%rcx)
movzbl -0xe0(%rdx,%rax), %ecx
movzbl -0xc0(%rdx,%rax), %r8d
shll $0x8, %r8d
orq %rcx, %r8
movzbl -0xa0(%rdx,%rax), %ecx
shll $0x10, %ecx
orq %r8, %rcx
movzbl -0x80(%rdx,%rax), %r8d
shll $0x18, %r8d
orq %rcx, %r8
movzbl -0x60(%rdx,%rax), %ecx
shlq $0x20, %rcx
orq %r8, %rcx
movzbl -0x40(%rdx,%rax), %r8d
shlq $0x28, %r8
orq %rcx, %r8
movzbl -0x20(%rdx,%rax), %ecx
shlq $0x30, %rcx
orq %r8, %rcx
movzbl (%rdx,%rax), %r8d
shlq $0x38, %r8
addq %rcx, %r8
movslq 0xc(%rsi,%rax,4), %rcx
movq %r8, 0x18(%rdi,%rcx)
movdqu (%rsi,%rax,4), %xmm1
paddd %xmm0, %xmm1
movdqu %xmm1, (%rsi,%rax,4)
addq $0x4, %rax
jmp 0x5bd43
retq