// File: /workspace/github_c_makefile_star2_O1/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
movq $-0x4, %rax
movzbl -0x3df(%rdx,%rax), %ecx
movzbl -0x3bf(%rdx,%rax), %r8d
shll $0x8, %r8d
orq %rcx, %r8
movzbl -0x39f(%rdx,%rax), %ecx
shll $0x10, %ecx
orq %r8, %rcx
movzbl -0x37f(%rdx,%rax), %r8d
shll $0x18, %r8d
movzbl -0x35f(%rdx,%rax), %r9d
orq %rcx, %r8
shlq $0x20, %r9
movzbl -0x33f(%rdx,%rax), %ecx
shlq $0x28, %rcx
orq %r8, %r9
orq %r9, %rcx
movzbl -0x31f(%rdx,%rax), %r8d
shlq $0x30, %r8
orq %rcx, %r8
movzbl -0x2ff(%rdx,%rax), %ecx
shlq $0x38, %rcx
movslq 0x10(%rsi,%rax,4), %r9
addq %r8, %rcx
movq %rcx, (%rdi,%r9)
movzbl -0x3de(%rdx,%rax), %ecx
movzbl -0x3be(%rdx,%rax), %r8d
shll $0x8, %r8d
orq %rcx, %r8
movzbl -0x39e(%rdx,%rax), %ecx
shll $0x10, %ecx
orq %r8, %rcx
movzbl -0x37e(%rdx,%rax), %r8d
shll $0x18, %r8d
movzbl -0x35e(%rdx,%rax), %r9d
orq %rcx, %r8
shlq $0x20, %r9
movzbl -0x33e(%rdx,%rax), %ecx
shlq $0x28, %rcx
orq %r8, %r9
orq %r9, %rcx
movzbl -0x31e(%rdx,%rax), %r8d
shlq $0x30, %r8
orq %rcx, %r8
movzbl -0x2fe(%rdx,%rax), %ecx
shlq $0x38, %rcx
movslq 0x14(%rsi,%rax,4), %r9
addq %r8, %rcx
movq %rcx, (%rdi,%r9)
movzbl -0x3dd(%rdx,%rax), %ecx
movzbl -0x3bd(%rdx,%rax), %r8d
shll $0x8, %r8d
orq %rcx, %r8
movzbl -0x39d(%rdx,%rax), %ecx
shll $0x10, %ecx
orq %r8, %rcx
movzbl -0x37d(%rdx,%rax), %r8d
shll $0x18, %r8d
movzbl -0x35d(%rdx,%rax), %r9d
orq %rcx, %r8
shlq $0x20, %r9
movzbl -0x33d(%rdx,%rax), %ecx
shlq $0x28, %rcx
orq %r8, %r9
orq %r9, %rcx
movzbl -0x31d(%rdx,%rax), %r8d
shlq $0x30, %r8
orq %rcx, %r8
movzbl -0x2fd(%rdx,%rax), %ecx
shlq $0x38, %rcx
movslq 0x18(%rsi,%rax,4), %r9
addq %r8, %rcx
movq %rcx, (%rdi,%r9)
movzbl -0x3dc(%rdx,%rax), %ecx
movzbl -0x3bc(%rdx,%rax), %r8d
shll $0x8, %r8d
orq %rcx, %r8
movzbl -0x39c(%rdx,%rax), %ecx
shll $0x10, %ecx
orq %r8, %rcx
movzbl -0x37c(%rdx,%rax), %r8d
shll $0x18, %r8d
movzbl -0x35c(%rdx,%rax), %r9d
orq %rcx, %r8
shlq $0x20, %r9
movzbl -0x33c(%rdx,%rax), %ecx
shlq $0x28, %rcx
orq %r8, %r9
orq %r9, %rcx
movzbl -0x31c(%rdx,%rax), %r8d
shlq $0x30, %r8
orq %rcx, %r8
movzbl -0x2fc(%rdx,%rax), %ecx
shlq $0x38, %rcx
movslq 0x1c(%rsi,%rax,4), %r9
addq %r8, %rcx
movq %rcx, (%rdi,%r9)
movzbl -0x2df(%rdx,%rax), %ecx
movzbl -0x2bf(%rdx,%rax), %r8d
shll $0x8, %r8d
orq %rcx, %r8
movzbl -0x29f(%rdx,%rax), %ecx
shll $0x10, %ecx
orq %r8, %rcx
movzbl -0x27f(%rdx,%rax), %r8d
shll $0x18, %r8d
movzbl -0x25f(%rdx,%rax), %r9d
orq %rcx, %r8
shlq $0x20, %r9
movzbl -0x23f(%rdx,%rax), %ecx
shlq $0x28, %rcx
orq %r8, %r9
orq %r9, %rcx
movzbl -0x21f(%rdx,%rax), %r8d
shlq $0x30, %r8
orq %rcx, %r8
movzbl -0x1ff(%rdx,%rax), %ecx
shlq $0x38, %rcx
movslq 0x10(%rsi,%rax,4), %r9
addq %r8, %rcx
movq %rcx, 0x8(%rdi,%r9)
movzbl -0x2de(%rdx,%rax), %ecx
movzbl -0x2be(%rdx,%rax), %r8d
shll $0x8, %r8d
orq %rcx, %r8
movzbl -0x29e(%rdx,%rax), %ecx
shll $0x10, %ecx
orq %r8, %rcx
movzbl -0x27e(%rdx,%rax), %r8d
shll $0x18, %r8d
movzbl -0x25e(%rdx,%rax), %r9d
orq %rcx, %r8
shlq $0x20, %r9
movzbl -0x23e(%rdx,%rax), %ecx
shlq $0x28, %rcx
orq %r8, %r9
orq %r9, %rcx
movzbl -0x21e(%rdx,%rax), %r8d
shlq $0x30, %r8
orq %rcx, %r8
movzbl -0x1fe(%rdx,%rax), %ecx
shlq $0x38, %rcx
movslq 0x14(%rsi,%rax,4), %r9
addq %r8, %rcx
movq %rcx, 0x8(%rdi,%r9)
movzbl -0x2dd(%rdx,%rax), %ecx
movzbl -0x2bd(%rdx,%rax), %r8d
shll $0x8, %r8d
orq %rcx, %r8
movzbl -0x29d(%rdx,%rax), %ecx
shll $0x10, %ecx
orq %r8, %rcx
movzbl -0x27d(%rdx,%rax), %r8d
shll $0x18, %r8d
movzbl -0x25d(%rdx,%rax), %r9d
orq %rcx, %r8
shlq $0x20, %r9
movzbl -0x23d(%rdx,%rax), %ecx
shlq $0x28, %rcx
orq %r8, %r9
orq %r9, %rcx
movzbl -0x21d(%rdx,%rax), %r8d
shlq $0x30, %r8
orq %rcx, %r8
movzbl -0x1fd(%rdx,%rax), %ecx
shlq $0x38, %rcx
movslq 0x18(%rsi,%rax,4), %r9
addq %r8, %rcx
movq %rcx, 0x8(%rdi,%r9)
movzbl -0x2dc(%rdx,%rax), %ecx
movzbl -0x2bc(%rdx,%rax), %r8d
shll $0x8, %r8d
orq %rcx, %r8
movzbl -0x29c(%rdx,%rax), %ecx
shll $0x10, %ecx
orq %r8, %rcx
movzbl -0x27c(%rdx,%rax), %r8d
shll $0x18, %r8d
movzbl -0x25c(%rdx,%rax), %r9d
orq %rcx, %r8
shlq $0x20, %r9
movzbl -0x23c(%rdx,%rax), %ecx
shlq $0x28, %rcx
orq %r8, %r9
orq %r9, %rcx
movzbl -0x21c(%rdx,%rax), %r8d
shlq $0x30, %r8
orq %rcx, %r8
movzbl -0x1fc(%rdx,%rax), %ecx
shlq $0x38, %rcx
movslq 0x1c(%rsi,%rax,4), %r9
addq %r8, %rcx
movq %rcx, 0x8(%rdi,%r9)
movzbl -0x1df(%rdx,%rax), %ecx
movzbl -0x1bf(%rdx,%rax), %r8d
shll $0x8, %r8d
orq %rcx, %r8
movzbl -0x19f(%rdx,%rax), %ecx
shll $0x10, %ecx
orq %r8, %rcx
movzbl -0x17f(%rdx,%rax), %r8d
shll $0x18, %r8d
movzbl -0x15f(%rdx,%rax), %r9d
orq %rcx, %r8
shlq $0x20, %r9
movzbl -0x13f(%rdx,%rax), %ecx
shlq $0x28, %rcx
orq %r8, %r9
orq %r9, %rcx
movzbl -0x11f(%rdx,%rax), %r8d
shlq $0x30, %r8
orq %rcx, %r8
movzbl -0xff(%rdx,%rax), %ecx
shlq $0x38, %rcx
movslq 0x10(%rsi,%rax,4), %r9
addq %r8, %rcx
movq %rcx, 0x10(%rdi,%r9)
movzbl -0x1de(%rdx,%rax), %ecx
movzbl -0x1be(%rdx,%rax), %r8d
shll $0x8, %r8d
orq %rcx, %r8
movzbl -0x19e(%rdx,%rax), %ecx
shll $0x10, %ecx
orq %r8, %rcx
movzbl -0x17e(%rdx,%rax), %r8d
shll $0x18, %r8d
movzbl -0x15e(%rdx,%rax), %r9d
orq %rcx, %r8
shlq $0x20, %r9
movzbl -0x13e(%rdx,%rax), %ecx
shlq $0x28, %rcx
orq %r8, %r9
orq %r9, %rcx
movzbl -0x11e(%rdx,%rax), %r8d
shlq $0x30, %r8
orq %rcx, %r8
movzbl -0xfe(%rdx,%rax), %ecx
shlq $0x38, %rcx
movslq 0x14(%rsi,%rax,4), %r9
addq %r8, %rcx
movq %rcx, 0x10(%rdi,%r9)
movzbl -0x1dd(%rdx,%rax), %ecx
movzbl -0x1bd(%rdx,%rax), %r8d
shll $0x8, %r8d
orq %rcx, %r8
movzbl -0x19d(%rdx,%rax), %ecx
shll $0x10, %ecx
orq %r8, %rcx
movzbl -0x17d(%rdx,%rax), %r8d
shll $0x18, %r8d
movzbl -0x15d(%rdx,%rax), %r9d
orq %rcx, %r8
shlq $0x20, %r9
movzbl -0x13d(%rdx,%rax), %ecx
shlq $0x28, %rcx
orq %r8, %r9
orq %r9, %rcx
movzbl -0x11d(%rdx,%rax), %r8d
shlq $0x30, %r8
orq %rcx, %r8
movzbl -0xfd(%rdx,%rax), %ecx
shlq $0x38, %rcx
movslq 0x18(%rsi,%rax,4), %r9
addq %r8, %rcx
movq %rcx, 0x10(%rdi,%r9)
movzbl -0x1dc(%rdx,%rax), %ecx
movzbl -0x1bc(%rdx,%rax), %r8d
shll $0x8, %r8d
orq %rcx, %r8
movzbl -0x19c(%rdx,%rax), %ecx
shll $0x10, %ecx
orq %r8, %rcx
movzbl -0x17c(%rdx,%rax), %r8d
shll $0x18, %r8d
movzbl -0x15c(%rdx,%rax), %r9d
orq %rcx, %r8
shlq $0x20, %r9
movzbl -0x13c(%rdx,%rax), %ecx
shlq $0x28, %rcx
orq %r8, %r9
orq %r9, %rcx
movzbl -0x11c(%rdx,%rax), %r8d
shlq $0x30, %r8
orq %rcx, %r8
movzbl -0xfc(%rdx,%rax), %ecx
shlq $0x38, %rcx
movslq 0x1c(%rsi,%rax,4), %r9
addq %r8, %rcx
movq %rcx, 0x10(%rdi,%r9)
movzbl -0xdf(%rdx,%rax), %ecx
movzbl -0xbf(%rdx,%rax), %r8d
shll $0x8, %r8d
orq %rcx, %r8
movzbl -0x9f(%rdx,%rax), %ecx
shll $0x10, %ecx
orq %r8, %rcx
movzbl -0x7f(%rdx,%rax), %r8d
shll $0x18, %r8d
movzbl -0x5f(%rdx,%rax), %r9d
orq %rcx, %r8
shlq $0x20, %r9
movzbl -0x3f(%rdx,%rax), %ecx
shlq $0x28, %rcx
orq %r8, %r9
orq %r9, %rcx
movzbl -0x1f(%rdx,%rax), %r8d
shlq $0x30, %r8
orq %rcx, %r8
movzbl 0x1(%rdx,%rax), %ecx
shlq $0x38, %rcx
movslq 0x10(%rsi,%rax,4), %r9
addq %r8, %rcx
movq %rcx, 0x18(%rdi,%r9)
movzbl -0xde(%rdx,%rax), %ecx
movzbl -0xbe(%rdx,%rax), %r8d
shll $0x8, %r8d
orq %rcx, %r8
movzbl -0x9e(%rdx,%rax), %ecx
shll $0x10, %ecx
orq %r8, %rcx
movzbl -0x7e(%rdx,%rax), %r8d
shll $0x18, %r8d
movzbl -0x5e(%rdx,%rax), %r9d
orq %rcx, %r8
shlq $0x20, %r9
movzbl -0x3e(%rdx,%rax), %ecx
shlq $0x28, %rcx
orq %r8, %r9
orq %r9, %rcx
movzbl -0x1e(%rdx,%rax), %r8d
shlq $0x30, %r8
orq %rcx, %r8
movzbl 0x2(%rdx,%rax), %ecx
shlq $0x38, %rcx
movslq 0x14(%rsi,%rax,4), %r9
addq %r8, %rcx
movq %rcx, 0x18(%rdi,%r9)
movzbl -0xdd(%rdx,%rax), %ecx
movzbl -0xbd(%rdx,%rax), %r8d
shll $0x8, %r8d
orq %rcx, %r8
movzbl -0x9d(%rdx,%rax), %ecx
shll $0x10, %ecx
orq %r8, %rcx
movzbl -0x7d(%rdx,%rax), %r8d
shll $0x18, %r8d
movzbl -0x5d(%rdx,%rax), %r9d
orq %rcx, %r8
shlq $0x20, %r9
movzbl -0x3d(%rdx,%rax), %ecx
shlq $0x28, %rcx
orq %r8, %r9
orq %r9, %rcx
movzbl -0x1d(%rdx,%rax), %r8d
shlq $0x30, %r8
orq %rcx, %r8
movzbl 0x3(%rdx,%rax), %ecx
shlq $0x38, %rcx
movslq 0x18(%rsi,%rax,4), %r9
addq %r8, %rcx
movq %rcx, 0x18(%rdi,%r9)
movzbl -0xdc(%rdx,%rax), %ecx
movzbl -0xbc(%rdx,%rax), %r8d
shll $0x8, %r8d
orq %rcx, %r8
movzbl -0x9c(%rdx,%rax), %ecx
shll $0x10, %ecx
orq %r8, %rcx
movzbl -0x7c(%rdx,%rax), %r8d
shll $0x18, %r8d
movzbl -0x5c(%rdx,%rax), %r9d
orq %rcx, %r8
shlq $0x20, %r9
movzbl -0x3c(%rdx,%rax), %ecx
shlq $0x28, %rcx
orq %r8, %r9
orq %r9, %rcx
movzbl -0x1c(%rdx,%rax), %r8d
shlq $0x30, %r8
orq %rcx, %r8
movzbl 0x4(%rdx,%rax), %ecx
shlq $0x38, %rcx
movslq 0x1c(%rsi,%rax,4), %r9
addq %r8, %rcx
movq %rcx, 0x18(%rdi,%r9)
addl $0x20, 0x10(%rsi,%rax,4)
addl $0x20, 0x14(%rsi,%rax,4)
addl $0x20, 0x18(%rsi,%rax,4)
addl $0x20, 0x1c(%rsi,%rax,4)
addq $0x4, %rax
cmpq $0x1c, %rax
jb 0x767d4
retq
nop