// File: /workspace/github_c_makefile_star2_O3/nh13[P]ksw/src/parasail/src/nw_trace_diag_sse2_128_8.c
// Function: parasail_nw_trace_diag_sse2_128_8
parasail_result_t* FNAME(
        const char * const restrict _s1, const int _s1Len,
        const char * const restrict _s2, const int s2Len,
        const int open, const int gap, const parasail_matrix_t *matrix)
{
    /* declare local variables */
    int32_t N = 0;
    int32_t PAD = 0;
    int32_t PAD2 = 0;
    int32_t s1Len_PAD = 0;
    int32_t s2Len_PAD = 0;
    int8_t * restrict s1 = NULL;
    int8_t * restrict s2B = NULL;
    int8_t * restrict _H_pr = NULL;
    int8_t * restrict _F_pr = NULL;
    int8_t * restrict s2 = NULL;
    int8_t * restrict H_pr = NULL;
    int8_t * restrict F_pr = NULL;
    parasail_result_t *result = NULL;
    int32_t i = 0;
    int32_t j = 0;
    int32_t s1Len = 0;
    int32_t end_query = 0;
    int32_t end_ref = 0;
    int8_t NEG_LIMIT = 0;
    int8_t POS_LIMIT = 0;
    int8_t score = 0;
    __m128i vNegLimit;
    __m128i vPosLimit;
    __m128i vSaturationCheckMin;
    __m128i vSaturationCheckMax;
    __m128i vNegInf;
    __m128i vOpen;
    __m128i vGap;
    __m128i vOne;
    __m128i vN;
    __m128i vGapN;
    __m128i vNegOne;
    __m128i vI;
    __m128i vJreset;
    __m128i vMax;
    __m128i vILimit;
    __m128i vILimit1;
    __m128i vJLimit;
    __m128i vJLimit1;
    __m128i vIBoundary;
    __m128i vTDiag;
    __m128i vTIns;
    __m128i vTDel;
    __m128i vTDiagE;
    __m128i vTInsE;
    __m128i vTDiagF;
    __m128i vTDelF;

    /* validate inputs */
    PARASAIL_CHECK_NULL(_s2);
    PARASAIL_CHECK_GT0(s2Len);
    PARASAIL_CHECK_GE0(open);
    PARASAIL_CHECK_GE0(gap);
    PARASAIL_CHECK_NULL(matrix);
    if (matrix->type == PARASAIL_MATRIX_TYPE_SQUARE) {
        PARASAIL_CHECK_NULL(_s1);
        PARASAIL_CHECK_GT0(_s1Len);
    }

    /* initialize stack variables */
    N = 16; /* number of values in vector */
    PAD = N-1;
    PAD2 = PAD*2;
    s1Len = matrix->type == PARASAIL_MATRIX_TYPE_SQUARE ? _s1Len : matrix->length;
    s1Len_PAD = s1Len+PAD;
    s2Len_PAD = s2Len+PAD;
    i = 0;
    j = 0;
    end_query = s1Len-1;
    end_ref = s2Len-1;
    NEG_LIMIT = (-open < matrix->min ? INT8_MIN + open : INT8_MIN - matrix->min) + 1;
    POS_LIMIT = INT8_MAX - matrix->max - 1;
    score = NEG_LIMIT;
    vNegLimit = _mm_set1_epi8(NEG_LIMIT);
    vPosLimit = _mm_set1_epi8(POS_LIMIT);
    vSaturationCheckMin = vPosLimit;
    vSaturationCheckMax = vNegLimit;
    vNegInf = _mm_set1_epi8(NEG_LIMIT);
    vOpen = _mm_set1_epi8(open);
    vGap  = _mm_set1_epi8(gap);
    vOne = _mm_set1_epi8(1);
    vN = _mm_set1_epi8(N);
    vGapN = _mm_set1_epi8(gap*N);
    vNegOne = _mm_set1_epi8(-1);
    vI = _mm_set_epi8(0,1,2,3,4,5,6,7,8,9,10,11,12,13,14,15);
    vJreset = _mm_set_epi8(0,-1,-2,-3,-4,-5,-6,-7,-8,-9,-10,-11,-12,-13,-14,-15);
    vMax = vNegInf;
    vILimit = _mm_set1_epi8(s1Len);
    vILimit1 = _mm_subs_epi8(vILimit, vOne);
    vJLimit = _mm_set1_epi8(s2Len);
    vJLimit1 = _mm_subs_epi8(vJLimit, vOne);
    vIBoundary = _mm_set_epi8(
            -open-0*gap,
            -open-1*gap,
            -open-2*gap,
            -open-3*gap,
            -open-4*gap,
            -open-5*gap,
            -open-6*gap,
            -open-7*gap,
            -open-8*gap,
            -open-9*gap,
            -open-10*gap,
            -open-11*gap,
            -open-12*gap,
            -open-13*gap,
            -open-14*gap,
            -open-15*gap);
    vTDiag = _mm_set1_epi8(PARASAIL_DIAG);
    vTIns = _mm_set1_epi8(PARASAIL_INS);
    vTDel = _mm_set1_epi8(PARASAIL_DEL);
    vTDiagE = _mm_set1_epi8(PARASAIL_DIAG_E);
    vTInsE = _mm_set1_epi8(PARASAIL_INS_E);
    vTDiagF = _mm_set1_epi8(PARASAIL_DIAG_F);
    vTDelF = _mm_set1_epi8(PARASAIL_DEL_F);

    /* initialize result */
    result = parasail_result_new_trace(s1Len, s2Len, 16, sizeof(int8_t));
    if (!result) return NULL;

    /* set known flags */
    result->flag |= PARASAIL_FLAG_NW | PARASAIL_FLAG_DIAG
        | PARASAIL_FLAG_TRACE
        | PARASAIL_FLAG_BITS_8 | PARASAIL_FLAG_LANES_16;

    /* initialize heap variables */
    s2B= parasail_memalign_int8_t(16, s2Len+PAD2);
    _H_pr = parasail_memalign_int8_t(16, s2Len+PAD2);
    _F_pr = parasail_memalign_int8_t(16, s2Len+PAD2);
    s2 = s2B+PAD; /* will allow later for negative indices */
    H_pr = _H_pr+PAD;
    F_pr = _F_pr+PAD;

    /* validate heap variables */
    if (!s2B) return NULL;
    if (!_H_pr) return NULL;
    if (!_F_pr) return NULL;

    /* convert _s1 from char to int in range 0-23 */
    if (matrix->type == PARASAIL_MATRIX_TYPE_SQUARE) {
        s1 = parasail_memalign_int8_t(16, s1Len+PAD);
        if (!s1) return NULL;
        for (i=0; i<s1Len; ++i) {
            s1[i] = matrix->mapper[(unsigned char)_s1[i]];
        }
        /* pad back of s1 with dummy values */
        for (i=s1Len; i<s1Len_PAD; ++i) {
            s1[i] = 0; /* point to first matrix row because we don't care */
        }
    }

    /* convert _s2 from char to int in range 0-23 */
    for (j=0; j<s2Len; ++j) {
        s2[j] = matrix->mapper[(unsigned char)_s2[j]];
    }
    /* pad front of s2 with dummy values */
    for (j=-PAD; j<0; ++j) {
        s2[j] = 0; /* point to first matrix row because we don't care */
    }
    /* pad back of s2 with dummy values */
    for (j=s2Len; j<s2Len_PAD; ++j) {
        s2[j] = 0; /* point to first matrix row because we don't care */
    }

    /* set initial values for stored row */
    for (j=0; j<s2Len; ++j) {
        H_pr[j] = -open - j*gap;
        F_pr[j] = NEG_LIMIT;
    }
    /* pad front of stored row values */
    for (j=-PAD; j<0; ++j) {
        H_pr[j] = NEG_LIMIT;
        F_pr[j] = NEG_LIMIT;
    }
    /* pad back of stored row values */
    for (j=s2Len; j<s2Len+PAD; ++j) {
        H_pr[j] = NEG_LIMIT;
        F_pr[j] = NEG_LIMIT;
    }
    H_pr[-1] = 0; /* upper left corner */

    /* iterate over query sequence */
    for (i=0; i<s1Len; i+=N) {
        __m128i vNH = vNegInf;
        __m128i vWH = vNegInf;
        __m128i vE = vNegInf;
        __m128i vE_opn = vNegInf;
        __m128i vE_ext = vNegInf;
        __m128i vF = vNegInf;
        __m128i vF_opn = vNegInf;
        __m128i vF_ext = vNegInf;
        __m128i vJ = vJreset;
        const int * const restrict matrow0 = &matrix->matrix[matrix->size * ((matrix->type == PARASAIL_MATRIX_TYPE_SQUARE) ? s1[i+0] : ((i+0 >= s1Len) ? s1Len-1 : i+0))];
        const int * const restrict matrow1 = &matrix->matrix[matrix->size * ((matrix->type == PARASAIL_MATRIX_TYPE_SQUARE) ? s1[i+1] : ((i+1 >= s1Len) ? s1Len-1 : i+1))];
        const int * const restrict matrow2 = &matrix->matrix[matrix->size * ((matrix->type == PARASAIL_MATRIX_TYPE_SQUARE) ? s1[i+2] : ((i+2 >= s1Len) ? s1Len-1 : i+2))];
        const int * const restrict matrow3 = &matrix->matrix[matrix->size * ((matrix->type == PARASAIL_MATRIX_TYPE_SQUARE) ? s1[i+3] : ((i+3 >= s1Len) ? s1Len-1 : i+3))];
        const int * const restrict matrow4 = &matrix->matrix[matrix->size * ((matrix->type == PARASAIL_MATRIX_TYPE_SQUARE) ? s1[i+4] : ((i+4 >= s1Len) ? s1Len-1 : i+4))];
        const int * const restrict matrow5 = &matrix->matrix[matrix->size * ((matrix->type == PARASAIL_MATRIX_TYPE_SQUARE) ? s1[i+5] : ((i+5 >= s1Len) ? s1Len-1 : i+5))];
        const int * const restrict matrow6 = &matrix->matrix[matrix->size * ((matrix->type == PARASAIL_MATRIX_TYPE_SQUARE) ? s1[i+6] : ((i+6 >= s1Len) ? s1Len-1 : i+6))];
        const int * const restrict matrow7 = &matrix->matrix[matrix->size * ((matrix->type == PARASAIL_MATRIX_TYPE_SQUARE) ? s1[i+7] : ((i+7 >= s1Len) ? s1Len-1 : i+7))];
        const int * const restrict matrow8 = &matrix->matrix[matrix->size * ((matrix->type == PARASAIL_MATRIX_TYPE_SQUARE) ? s1[i+8] : ((i+8 >= s1Len) ? s1Len-1 : i+8))];
        const int * const restrict matrow9 = &matrix->matrix[matrix->size * ((matrix->type == PARASAIL_MATRIX_TYPE_SQUARE) ? s1[i+9] : ((i+9 >= s1Len) ? s1Len-1 : i+9))];
        const int * const restrict matrow10 = &matrix->matrix[matrix->size * ((matrix->type == PARASAIL_MATRIX_TYPE_SQUARE) ? s1[i+10] : ((i+10 >= s1Len) ? s1Len-1 : i+10))];
        const int * const restrict matrow11 = &matrix->matrix[matrix->size * ((matrix->type == PARASAIL_MATRIX_TYPE_SQUARE) ? s1[i+11] : ((i+11 >= s1Len) ? s1Len-1 : i+11))];
        const int * const restrict matrow12 = &matrix->matrix[matrix->size * ((matrix->type == PARASAIL_MATRIX_TYPE_SQUARE) ? s1[i+12] : ((i+12 >= s1Len) ? s1Len-1 : i+12))];
        const int * const restrict matrow13 = &matrix->matrix[matrix->size * ((matrix->type == PARASAIL_MATRIX_TYPE_SQUARE) ? s1[i+13] : ((i+13 >= s1Len) ? s1Len-1 : i+13))];
        const int * const restrict matrow14 = &matrix->matrix[matrix->size * ((matrix->type == PARASAIL_MATRIX_TYPE_SQUARE) ? s1[i+14] : ((i+14 >= s1Len) ? s1Len-1 : i+14))];
        const int * const restrict matrow15 = &matrix->matrix[matrix->size * ((matrix->type == PARASAIL_MATRIX_TYPE_SQUARE) ? s1[i+15] : ((i+15 >= s1Len) ? s1Len-1 : i+15))];
        vNH = _mm_srli_si128(vNH, 1);
        vNH = _mm_insert_epi8_rpl(vNH, H_pr[-1], 15);
        vWH = _mm_srli_si128(vWH, 1);
        vWH = _mm_insert_epi8_rpl(vWH, -open - i*gap, 15);
        H_pr[-1] = -open - (i+N)*gap;
        /* iterate over database sequence */
        for (j=0; j<s2Len+PAD; ++j) {
            __m128i vMat;
            __m128i vNWH = vNH;
            vNH = _mm_srli_si128(vWH, 1);
            vNH = _mm_insert_epi8_rpl(vNH, H_pr[j], 15);
            vF = _mm_srli_si128(vF, 1);
            vF = _mm_insert_epi8_rpl(vF, F_pr[j], 15);
            vF_opn = _mm_subs_epi8(vNH, vOpen);
            vF_ext = _mm_subs_epi8(vF, vGap);
            vF = _mm_max_epi8_rpl(vF_opn, vF_ext);
            vE_opn = _mm_subs_epi8(vWH, vOpen);
            vE_ext = _mm_subs_epi8(vE, vGap);
            vE = _mm_max_epi8_rpl(vE_opn, vE_ext);
            vMat = _mm_set_epi8(
                    matrow0[s2[j-0]],
                    matrow1[s2[j-1]],
                    matrow2[s2[j-2]],
                    matrow3[s2[j-3]],
                    matrow4[s2[j-4]],
                    matrow5[s2[j-5]],
                    matrow6[s2[j-6]],
                    matrow7[s2[j-7]],
                    matrow8[s2[j-8]],
                    matrow9[s2[j-9]],
                    matrow10[s2[j-10]],
                    matrow11[s2[j-11]],
                    matrow12[s2[j-12]],
                    matrow13[s2[j-13]],
                    matrow14[s2[j-14]],
                    matrow15[s2[j-15]]
                    );
            vNWH = _mm_adds_epi8(vNWH, vMat);
            vWH = _mm_max_epi8_rpl(vNWH, vE);
            vWH = _mm_max_epi8_rpl(vWH, vF);
            /* as minor diagonal vector passes across the j=-1 boundary,
             * assign the appropriate boundary conditions */
            {
                __m128i cond = _mm_cmpeq_epi8(vJ,vNegOne);
                vWH = _mm_blendv_epi8_rpl(vWH, vIBoundary, cond);
                vF = _mm_blendv_epi8_rpl(vF, vNegInf, cond);
                vE = _mm_blendv_epi8_rpl(vE, vNegInf, cond);
            }
            /* cannot start checking sat until after J clears boundary */
            if (j > PAD) {
                vSaturationCheckMin = _mm_min_epi8_rpl(vSaturationCheckMin, vWH);
                vSaturationCheckMax = _mm_max_epi8_rpl(vSaturationCheckMax, vWH);
            }
            /* trace table */
            {
                __m128i case1 = _mm_cmpeq_epi8(vWH, vNWH);
                __m128i case2 = _mm_cmpeq_epi8(vWH, vF);
                __m128i vT = _mm_blendv_epi8_rpl(
                        _mm_blendv_epi8_rpl(vTIns, vTDel, case2),
                        vTDiag,
                        case1);
                __m128i condE = _mm_cmpgt_epi8(vE_opn, vE_ext);
                __m128i condF = _mm_cmpgt_epi8(vF_opn, vF_ext);
                __m128i vET = _mm_blendv_epi8_rpl(vTInsE, vTDiagE, condE);
                __m128i vFT = _mm_blendv_epi8_rpl(vTDelF, vTDiagF, condF);
                vT = _mm_or_si128(vT, vET);
                vT = _mm_or_si128(vT, vFT);
                arr_store_si128(result->trace->trace_table, vT, i, s1Len, j, s2Len);
            }
            H_pr[j-15] = (int8_t)_mm_extract_epi8_rpl(vWH,0);
            F_pr[j-15] = (int8_t)_mm_extract_epi8_rpl(vF,0);
            /* as minor diagonal vector passes across table, extract
               last table value at the i,j bound */
            {
                __m128i cond_valid_I = _mm_cmpeq_epi8(vI, vILimit1);
                __m128i cond_valid_J = _mm_cmpeq_epi8(vJ, vJLimit1);
                __m128i cond_all = _mm_and_si128(cond_valid_I, cond_valid_J);
                vMax = _mm_blendv_epi8_rpl(vMax, vWH, cond_all);
            }
            vJ = _mm_adds_epi8(vJ, vOne);
        }
        vI = _mm_adds_epi8(vI, vN);
        vIBoundary = _mm_subs_epi8(vIBoundary, vGapN);
    }

    /* max in vMax */
    for (i=0; i<N; ++i) {
        int8_t value;
        value = (int8_t) _mm_extract_epi8_rpl(vMax, 15);
        if (value > score) {
            score = value;
        }
        vMax = _mm_slli_si128(vMax, 1);
    }

    if (_mm_movemask_epi8(_mm_or_si128(
            _mm_cmplt_epi8(vSaturationCheckMin, vNegLimit),
            _mm_cmpgt_epi8(vSaturationCheckMax, vPosLimit)))) {
        result->flag |= PARASAIL_FLAG_SATURATED;
        score = 0;
        end_query = 0;
        end_ref = 0;
    }

    result->score = score;
    result->end_query = end_query;
    result->end_ref = end_ref;

    parasail_free(_F_pr);
    parasail_free(_H_pr);
    parasail_free(s2B);
    if (matrix->type == PARASAIL_MATRIX_TYPE_SQUARE) {
        parasail_free(s1);
    }

    return result;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x2c8, %rsp            # imm = 0x2C8
testq %rdx, %rdx
je 0x3b3179
movl %ecx, %r14d
testl %ecx, %ecx
jle 0x3b3180
movl %r8d, %ebp
testl %r8d, %r8d
js 0x3b3187
testl %r9d, %r9d
js 0x3b318e
movq %rdx, %r15
movq 0x300(%rsp), %rdx
testq %rdx, %rdx
je 0x3b3195
cmpl $0x0, 0x30(%rdx)
je 0x3b1d69
movl 0x34(%rdx), %ebx
jmp 0x3b1d7c
testq %rdi, %rdi
je 0x3b319c
movl %esi, %ebx
testl %esi, %esi
jle 0x3b31a3
movq %rdi, 0xd0(%rsp)
movq %r9, 0x78(%rsp)
movl %ebp, %esi
negl %esi
movl 0x20(%rdx), %eax
movl %eax, %ecx
negb %cl
movl %esi, 0xc(%rsp)
cmpl %esi, %eax
movzbl %cl, %eax
cmovgl %ebp, %eax
movl %eax, 0x4(%rsp)
movb $0x7e, %r13b
subb 0x1c(%rdx), %r13b
movl $0x10, %edx
movl $0x1, %ecx
movl %ebx, %edi
movl %r14d, %esi
callq 0x20adf4
testq %rax, %rax
je 0x3b31a8
movq %rax, %r12
movb %r13b, 0x60(%rsp)
movq %r15, 0xc0(%rsp)
movq %rbx, 0x10(%rsp)
orl $0x10181001, 0xc(%rax)  # imm = 0x10181001
leal 0x1e(%r14), %r13d
movl $0x10, %edi
movq %r13, %rsi
callq 0x20a620
movq %rax, %r15
movl $0x10, %edi
movq %r13, %rsi
callq 0x20a620
movq %rax, %rbx
movl $0x10, %edi
movq %r13, %rsi
callq 0x20a620
testq %r15, %r15
sete %dl
movq %rbx, 0xb0(%rsp)
testq %rbx, %rbx
sete %cl
orb %dl, %cl
movq %rax, 0xa8(%rsp)
testq %rax, %rax
sete %al
orb %cl, %al
jne 0x3b31a8
movq %r12, 0x168(%rsp)
movq 0x300(%rsp), %rdi
cmpl $0x0, 0x30(%rdi)
je 0x3b1e72
movq $0x0, 0x70(%rsp)
movq 0x10(%rsp), %rbx
movq 0xc0(%rsp), %r13
jmp 0x3b1ef9
movq 0x10(%rsp), %rbx
leal 0xf(%rbx), %r12d
movslq %r12d, %rsi
movl $0x10, %edi
callq 0x20a620
testq %rax, %rax
movq 0xc0(%rsp), %r13
je 0x3b31a8
testl %ebx, %ebx
movq 0x300(%rsp), %rdi
movq 0xd0(%rsp), %r9
jle 0x3b1ec9
movl %ebx, %r8d
xorl %ecx, %ecx
movq 0x10(%rdi), %rdx
movzbl (%r9,%rcx), %esi
movb (%rdx,%rsi,4), %dl
movb %dl, (%rax,%rcx)
incq %rcx
cmpq %rcx, %r8
jne 0x3b1eb2
movslq %ebx, %rdx
movq %rax, 0x70(%rsp)
movq %rax, %rdi
addq %rdx, %rdi
leal 0x1(%rbx), %eax
cmpl %eax, %r12d
cmovgl %r12d, %eax
movl %ebx, %edx
notl %edx
addl %eax, %edx
incq %rdx
xorl %esi, %esi
callq 0x19e090
movq 0x300(%rsp), %rdi
leal 0xf(%r14), %r12d
movl 0x4(%rsp), %eax
addb $-0x7f, %al
movl %eax, 0x4(%rsp)
movzbl %al, %eax
movd %eax, %xmm0
movzbl 0x60(%rsp), %eax
movd %eax, %xmm1
movq 0x78(%rsp), %r8
movl 0xc(%rsp), %r9d
movl %r9d, %eax
subl %r8d, %eax
subl %r8d, %eax
leal (,%r8,4), %edx
movl %r9d, %ecx
subl %edx, %ecx
leal (,%r8,8), %esi
movl %r9d, %edx
subl %esi, %edx
imull $0xf5, %r8d, %esi
subl %ebp, %esi
movd %esi, %xmm6
imull $0xf6, %r8d, %esi
subl %ebp, %esi
movd %esi, %xmm5
imull $0xf7, %r8d, %esi
subl %ebp, %esi
movd %esi, %xmm4
leal -0x1(%rbx), %esi
movl %esi, 0x8(%rsp)
movd %r8d, %xmm2
movd %ebx, %xmm3
punpcklbw %xmm3, %xmm3    # xmm3 = xmm3[0,0,1,1,2,2,3,3,4,4,5,5,6,6,7,7]
pshuflw $0x0, %xmm3, %xmm3      # xmm3 = xmm3[0,0,0,0,4,5,6,7]
pshufd $0x0, %xmm3, %xmm7      # xmm7 = xmm3[0,0,0,0]
pcmpeqd %xmm3, %xmm3
paddsb %xmm3, %xmm7
movdqa %xmm7, 0x240(%rsp)
movd %r14d, %xmm7
punpcklbw %xmm7, %xmm7    # xmm7 = xmm7[0,0,1,1,2,2,3,3,4,4,5,5,6,6,7,7]
pshuflw $0x0, %xmm7, %xmm7      # xmm7 = xmm7[0,0,0,0,4,5,6,7]
pshufd $0x0, %xmm7, %xmm7      # xmm7 = xmm7[0,0,0,0]
paddsb %xmm3, %xmm7
movdqa %xmm7, 0x280(%rsp)
pshufd $0x0, %xmm2, %xmm7      # xmm7 = xmm2[0,0,0,0]
movdqa 0x277e39(%rip), %xmm3   # 0x629e00
pshufd $0xf5, %xmm3, %xmm8     # xmm8 = xmm3[1,1,3,3]
pmuludq %xmm7, %xmm8
pmuludq %xmm3, %xmm7
movd %ebp, %xmm3
pshufd $0xe8, %xmm8, %xmm8     # xmm8 = xmm8[0,2,2,3]
pshufd $0xe8, %xmm7, %xmm9     # xmm9 = xmm7[0,2,2,3]
punpckldq %xmm8, %xmm9    # xmm9 = xmm9[0],xmm8[0],xmm9[1],xmm8[1]
pshufd $0x0, %xmm3, %xmm7      # xmm7 = xmm3[0,0,0,0]
psubd %xmm7, %xmm9
pand 0x277e12(%rip), %xmm9   # 0x629e10
packuswb %xmm9, %xmm9
packuswb %xmm9, %xmm9
movdqa 0x277e0f(%rip), %xmm8   # 0x629e20
pand %xmm8, %xmm9
pshufd $0x50, %xmm6, %xmm6     # xmm6 = xmm6[0,0,1,1]
pandn %xmm6, %xmm8
movd %edx, %xmm7
imull $0xf9, %r8d, %edx
subl %ebp, %edx
por %xmm9, %xmm8
movdqa 0x277df5(%rip), %xmm9   # 0x629e30
pand %xmm9, %xmm8
psllq $0x28, %xmm5
pandn %xmm5, %xmm9
movd %edx, %xmm5
imull $0xfa, %r8d, %edx
subl %ebp, %edx
por %xmm8, %xmm9
movdqa 0x277ddc(%rip), %xmm6   # 0x629e40
pand %xmm6, %xmm9
psllq $0x30, %xmm4
pandn %xmm4, %xmm6
movd %edx, %xmm4
imull $0xfb, %r8d, %edx
subl %ebp, %edx
por %xmm9, %xmm6
movdqa 0x277dc3(%rip), %xmm8   # 0x629e50
pand %xmm8, %xmm6
psllq $0x38, %xmm7
pandn %xmm7, %xmm8
movd %edx, %xmm7
leal -0x1(%r14), %edx
movl %edx, 0xbc(%rsp)
punpcklbw %xmm0, %xmm0    # xmm0 = xmm0[0,0,1,1,2,2,3,3,4,4,5,5,6,6,7,7]
pshuflw $0x0, %xmm0, %xmm0      # xmm0 = xmm0[0,0,0,0,4,5,6,7]
pshufd $0x0, %xmm0, %xmm0      # xmm0 = xmm0[0,0,0,0]
movdqa %xmm0, 0x60(%rsp)
punpcklbw %xmm1, %xmm1    # xmm1 = xmm1[0,0,1,1,2,2,3,3,4,4,5,5,6,6,7,7]
pshuflw $0x0, %xmm1, %xmm0      # xmm0 = xmm1[0,0,0,0,4,5,6,7]
pshufd $0x0, %xmm0, %xmm0      # xmm0 = xmm0[0,0,0,0]
movdqa %xmm0, 0x190(%rsp)
punpcklbw %xmm3, %xmm3    # xmm3 = xmm3[0,0,1,1,2,2,3,3,4,4,5,5,6,6,7,7]
pshuflw $0x0, %xmm3, %xmm0      # xmm0 = xmm3[0,0,0,0,4,5,6,7]
pshufd $0x0, %xmm0, %xmm0      # xmm0 = xmm0[0,0,0,0]
movdqa %xmm0, 0x270(%rsp)
punpcklbw %xmm2, %xmm2    # xmm2 = xmm2[0,0,1,1,2,2,3,3,4,4,5,5,6,6,7,7]
pshuflw $0x0, %xmm2, %xmm0      # xmm0 = xmm2[0,0,0,0,4,5,6,7]
pshufd $0x0, %xmm0, %xmm2      # xmm2 = xmm0[0,0,0,0]
por %xmm6, %xmm8
movdqa 0x277d58(%rip), %xmm1   # 0x629e60
pand %xmm1, %xmm8
pshufd $0x44, %xmm5, %xmm0     # xmm0 = xmm5[0,1,0,1]
pandn %xmm0, %xmm1
movdqa %xmm2, 0x260(%rsp)
psllw $0x4, %xmm2
pand 0x277cc4(%rip), %xmm2   # 0x629df0
movdqa %xmm2, 0x230(%rsp)
por %xmm8, %xmm1
movdqa 0x277d2e(%rip), %xmm0   # 0x629e70
pand %xmm0, %xmm1
pslldq $0x9, %xmm4             # xmm4 = zero,zero,zero,zero,zero,zero,zero,zero,zero,xmm4[0,1,2,3,4,5,6]
pandn %xmm4, %xmm0
movd %ecx, %xmm2
imull $0xfd, %r8d, %ecx
subl %ebp, %ecx
por %xmm1, %xmm0
movdqa 0x277d18(%rip), %xmm1   # 0x629e80
pand %xmm1, %xmm0
pslldq $0xa, %xmm7             # xmm7 = zero,zero,zero,zero,zero,zero,zero,zero,zero,zero,xmm7[0,1,2,3,4,5]
pandn %xmm7, %xmm1
movd %ecx, %xmm3
movl %r9d, %ecx
subl %r8d, %ecx
por %xmm0, %xmm1
movdqa 0x277d05(%rip), %xmm0   # 0x629e90
pand %xmm0, %xmm1
pslldq $0xb, %xmm2             # xmm2 = zero,zero,zero,zero,zero,zero,zero,zero,zero,zero,zero,xmm2[0,1,2,3,4]
pandn %xmm2, %xmm0
por %xmm1, %xmm0
movdqa 0x277cfc(%rip), %xmm1   # 0x629ea0
pand %xmm1, %xmm0
pshufd $0x0, %xmm3, %xmm2      # xmm2 = xmm3[0,0,0,0]
pandn %xmm2, %xmm1
por %xmm0, %xmm1
movdqa 0x277cf3(%rip), %xmm0   # 0x629eb0
pand %xmm0, %xmm1
movd %eax, %xmm2
pslldq $0xd, %xmm2             # xmm2 = zero,zero,zero,zero,zero,zero,zero,zero,zero,zero,zero,zero,zero,xmm2[0,1,2]
pandn %xmm2, %xmm0
por %xmm1, %xmm0
pand 0x277ce6(%rip), %xmm0   # 0x629ec0
movd %ecx, %xmm1
pslldq $0xe, %xmm1             # xmm1 = zero,zero,zero,zero,zero,zero,zero,zero,zero,zero,zero,zero,zero,zero,xmm1[0,1]
por %xmm0, %xmm1
pand 0x277ce1(%rip), %xmm1   # 0x629ed0
movd %r9d, %xmm0
pslldq $0xf, %xmm0             # xmm0 = zero,zero,zero,zero,zero,zero,zero,zero,zero,zero,zero,zero,zero,zero,zero,xmm0[0]
por %xmm1, %xmm0
movdqa %xmm0, 0xc0(%rsp)
movl %r14d, %ebx
xorl %eax, %eax
movq 0x10(%rdi), %rcx
movzbl (%r13,%rax), %edx
movb (%rcx,%rdx,4), %cl
movb %cl, 0xf(%r15,%rax)
incq %rax
cmpq %rax, %rbx
jne 0x3b220b
xorl %r13d, %r13d
movq %r13, 0x7(%r15)
movq %r13, (%r15)
leaq (%r15,%rbx), %rdi
addq $0xf, %rdi
leal 0x1(%r14), %eax
cmpl %eax, %r12d
cmovgl %r12d, %eax
movl %r14d, %edx
notl %edx
addl %eax, %edx
incq %rdx
xorl %esi, %esi
callq 0x19e090
negb %bpl
movl 0x4(%rsp), %ecx
movq 0x78(%rsp), %rax
movq 0xb0(%rsp), %rdx
movq 0xa8(%rsp), %rdi
movb %bpl, 0xf(%rdx,%r13)
movb %cl, 0xf(%rdi,%r13)
incq %r13
subb %al, %bpl
cmpq %r13, %rbx
jne 0x3b226f
xorl %eax, %eax
movq %rdx, %r13
movb %cl, (%r13,%rax)
movb %cl, (%rdi,%rax)
incq %rax
cmpq $0xf, %rax
jne 0x3b2289
leaq 0xf(%rbx), %rax
movq 0x300(%rsp), %r8
movb %cl, (%r13,%rax)
movb %cl, (%rdi,%rax)
incq %rax
incl %r14d
cmpl %r14d, %r12d
jg 0x3b22a6
movb $0x0, 0xe(%r13)
movdqa 0x60(%rsp), %xmm0
movdqa %xmm0, %xmm1
movdqa %xmm0, 0x180(%rsp)
movdqa 0x190(%rsp), %xmm0
movdqa %xmm0, 0x170(%rsp)
movq 0x10(%rsp), %rcx
testl %ecx, %ecx
jle 0x3b30c4
movdqa 0x60(%rsp), %xmm0
movdqa %xmm0, %xmm1
psrldq $0x1, %xmm1             # xmm1 = xmm1[1,2,3,4,5,6,7,8,9,10,11,12,13,14,15],zero
cmpl $0x2, %r12d
movl $0x1, %eax
cmovgel %r12d, %eax
movq %rax, 0x1b0(%rsp)
movl %ecx, %ecx
leaq (%rbx,%rbx,4), %rax
leaq (%rax,%rax,2), %rdx
addq $-0xf, %rdx
movq %rdx, 0x160(%rsp)
movq %rbx, %rsi
shlq $0x4, %rsi
leaq -0x1(%rbx), %rdx
movq %rdx, 0x158(%rsp)
leaq (%rbx,%rbx), %rdx
negq %rdx
movq %rsi, 0x1a0(%rsp)
addq %rsi, %rdx
addq $-0xe, %rdx
movq %rdx, 0x148(%rsp)
leaq (%rbx,%rbx,2), %rdx
leaq -0xd(%rbx,%rdx,4), %rsi
movq %rsi, 0x140(%rsp)
leaq -0xc(,%rdx,4), %rsi
movq %rsi, 0x138(%rsp)
leaq -0xb(%rbx,%rax,2), %rsi
movq %rsi, 0x130(%rsp)
leaq -0xa(%rax,%rax), %rax
movq %rax, 0x128(%rsp)
leaq -0x9(%rbx,%rbx,8), %rax
movq %rax, 0x120(%rsp)
leaq (,%rbx,8), %rax
leaq -0x8(,%rbx,8), %rsi
movq %rsi, 0x110(%rsp)
subq %rbx, %rax
addq $-0x7, %rax
movq %rax, 0x118(%rsp)
leaq -0x6(,%rdx,2), %rax
movq %rax, 0x108(%rsp)
leaq (%rbx,%rbx,4), %rax
addq $-0x5, %rax
movq %rax, 0x100(%rsp)
movdqa 0x27785e(%rip), %xmm2   # 0x629c50
pand 0x277ad6(%rip), %xmm1   # 0x629ed0
movdqa %xmm1, 0x220(%rsp)
movaps 0x190(%rsp), %xmm1
movaps %xmm1, 0x170(%rsp)
movdqa %xmm0, 0x180(%rsp)
movdqa %xmm0, %xmm1
leaq -0x4(,%rbx,4), %rax
movq %rax, 0xf8(%rsp)
leaq -0x3(%rbx,%rbx,2), %rax
movq %rax, 0xf0(%rsp)
leaq -0x2(,%rbx,2), %rax
movq %rax, 0xe8(%rsp)
movq $0x0, 0x150(%rsp)
xorl %r11d, %r11d
cmpl $0x0, 0x30(%r8)
je 0x3b2576
movq %r11, %rax
orq $0x1, %rax
cmpq %rcx, %rax
movl 0x8(%rsp), %r9d
cmovael %r9d, %eax
movq %rax, 0x10(%rsp)
movq %r11, %rax
orq $0x2, %rax
cmpq %rcx, %rax
cmovael %r9d, %eax
movq %rax, 0xd0(%rsp)
movq %r11, %r10
orq $0x3, %r10
cmpq %rcx, %r10
cmovael %r9d, %r10d
movq %r11, %rax
orq $0x4, %rax
cmpq %rcx, %rax
cmovael %r9d, %eax
movq %rax, 0x58(%rsp)
movq %r11, %r14
orq $0x5, %r14
cmpq %rcx, %r14
cmovael %r9d, %r14d
movq %r11, %rax
orq $0x6, %rax
cmpq %rcx, %rax
cmovael %r9d, %eax
movq %rax, 0x50(%rsp)
movq %r11, %r12
orq $0x7, %r12
cmpq %rcx, %r12
cmovael %r9d, %r12d
movq %r11, %rax
orq $0x8, %rax
cmpq %rcx, %rax
cmovael %r9d, %eax
movq %rax, 0x48(%rsp)
movq %r11, %r13
orq $0x9, %r13
cmpq %rcx, %r13
cmovael %r9d, %r13d
movq %r11, %rax
orq $0xa, %rax
cmpq %rcx, %rax
cmovael %r9d, %eax
movq %rax, 0x40(%rsp)
movq %r11, %rdx
orq $0xb, %rdx
cmpq %rcx, %rdx
cmovael %r9d, %edx
movq %r11, %rax
orq $0xc, %rax
cmpq %rcx, %rax
cmovael %r9d, %eax
movq %rax, 0x38(%rsp)
movq %r11, %rdi
orq $0xd, %rdi
cmpq %rcx, %rdi
cmovael %r9d, %edi
movq %r11, %rax
orq $0xe, %rax
cmpq %rcx, %rax
cmovael %r9d, %eax
movq %rax, 0x30(%rsp)
movq %r11, %rax
orq $0xf, %rax
cmpq %rcx, %rax
cmovael %r9d, %eax
movq %rax, 0x28(%rsp)
movl %r11d, %r9d
jmp 0x3b260a
movq 0x70(%rsp), %rsi
movsbl (%rsi,%r11), %r9d
movsbl 0x1(%rsi,%r11), %eax
movq %rax, 0x10(%rsp)
movsbl 0x2(%rsi,%r11), %eax
movq %rax, 0xd0(%rsp)
movsbl 0x3(%rsi,%r11), %r10d
movsbl 0x4(%rsi,%r11), %eax
movq %rax, 0x58(%rsp)
movsbl 0x5(%rsi,%r11), %r14d
movsbl 0x6(%rsi,%r11), %eax
movq %rax, 0x50(%rsp)
movsbl 0x7(%rsi,%r11), %r12d
movsbl 0x8(%rsi,%r11), %eax
movq %rax, 0x48(%rsp)
movsbl 0x9(%rsi,%r11), %r13d
movsbl 0xa(%rsi,%r11), %eax
movq %rax, 0x40(%rsp)
movsbl 0xb(%rsi,%r11), %edx
movsbl 0xc(%rsi,%r11), %eax
movq %rax, 0x38(%rsp)
movsbl 0xd(%rsi,%r11), %edi
movsbl 0xe(%rsi,%r11), %eax
movq %rax, 0x30(%rsp)
movsbl 0xf(%rsi,%r11), %eax
movq %rax, 0x28(%rsp)
movl 0x18(%r8), %r8d
imull %r8d, %edi
imull %r8d, %edx
imull %r8d, %r13d
movq %r13, 0x88(%rsp)
imull %r8d, %r12d
movq %r12, 0x90(%rsp)
imull %r8d, %r14d
movq %r14, 0x98(%rsp)
imull %r8d, %r10d
movq %r10, 0xa0(%rsp)
movq 0x10(%rsp), %rax
imull %r8d, %eax
movq %rax, 0x10(%rsp)
imull %r8d, %r9d
movl %r9d, 0x80(%rsp)
movq 0xd0(%rsp), %r14
imull %r8d, %r14d
movq 0x58(%rsp), %r12
imull %r8d, %r12d
movq 0x50(%rsp), %r13
imull %r8d, %r13d
movq 0x48(%rsp), %rbp
imull %r8d, %ebp
movq 0x40(%rsp), %r10
imull %r8d, %r10d
movq 0x38(%rsp), %r9
imull %r8d, %r9d
movq 0x30(%rsp), %rax
imull %r8d, %eax
movq 0x28(%rsp), %rsi
imull %r8d, %esi
movslq %edi, %r8
movq 0x300(%rsp), %rdi
movq 0x8(%rdi), %rdi
leaq (%rdi,%r8,4), %r8
movq %r8, 0x58(%rsp)
movslq %edx, %rdx
leaq (%rdi,%rdx,4), %rdx
movq %rdx, 0x50(%rsp)
movslq 0x88(%rsp), %rdx
leaq (%rdi,%rdx,4), %rdx
movq %rdx, 0x48(%rsp)
movslq 0x90(%rsp), %rdx
leaq (%rdi,%rdx,4), %rdx
movq %rdx, 0x40(%rsp)
movslq 0x98(%rsp), %rdx
leaq (%rdi,%rdx,4), %rdx
movq %rdx, 0x38(%rsp)
movslq 0xa0(%rsp), %rdx
leaq (%rdi,%rdx,4), %rdx
movq %rdx, 0x30(%rsp)
movslq 0x10(%rsp), %rdx
leaq (%rdi,%rdx,4), %rdx
movq %rdx, 0x28(%rsp)
movslq 0x80(%rsp), %rdx
leaq (%rdi,%rdx,4), %rdx
movq %rdx, 0xa0(%rsp)
movslq %r14d, %rdx
leaq (%rdi,%rdx,4), %rdx
movq %rdx, 0x98(%rsp)
movslq %r12d, %rdx
leaq (%rdi,%rdx,4), %rdx
movq %rdx, 0x90(%rsp)
movslq %r13d, %rdx
leaq (%rdi,%rdx,4), %rdx
movq %rdx, 0x88(%rsp)
movslq %ebp, %rdx
leaq (%rdi,%rdx,4), %rdx
movq %rdx, 0x80(%rsp)
movslq %r10d, %rdx
leaq (%rdi,%rdx,4), %rdx
movq %rdx, 0x218(%rsp)
movslq %r9d, %rdx
leaq (%rdi,%rdx,4), %rdx
movq %rdx, 0x210(%rsp)
cltq
leaq (%rdi,%rax,4), %rax
movq %rax, 0x208(%rsp)
movslq %esi, %rax
leaq (%rdi,%rax,4), %rax
movq %rax, 0x200(%rsp)
leaq 0x10(%r11), %rax
movq %rax, 0x1a8(%rsp)
movq 0x78(%rsp), %rsi
imull %esi, %eax
movl 0xc(%rsp), %edi
movl %edi, %edx
subl %eax, %edx
movq 0xb0(%rsp), %r13
movzbl 0xe(%r13), %eax
movb %dl, 0xe(%r13)
movl %r11d, %edx
imull %esi, %edx
movl %edi, %esi
subl %edx, %esi
movd %esi, %xmm6
movd %eax, %xmm5
pslldq $0xf, %xmm6             # xmm6 = zero,zero,zero,zero,zero,zero,zero,zero,zero,zero,zero,zero,zero,zero,zero,xmm6[0]
movdqa 0x220(%rsp), %xmm0
por %xmm0, %xmm6
pslldq $0xf, %xmm5             # xmm5 = zero,zero,zero,zero,zero,zero,zero,zero,zero,zero,zero,zero,zero,zero,zero,xmm5[0]
por %xmm0, %xmm5
movq %r11, %rax
orq $0x1, %rax
movq %rax, 0x1f8(%rsp)
movq %r11, %rax
orq $0x2, %rax
movq %rax, 0x1f0(%rsp)
movq %r11, %rax
orq $0x3, %rax
movq %rax, 0x1e8(%rsp)
movq %r11, %rax
orq $0x4, %rax
movq %rax, 0x1e0(%rsp)
movq %r11, %rax
orq $0x5, %rax
movq %rax, 0x1d8(%rsp)
movq %r11, %rax
orq $0x6, %rax
movq %rax, 0x1d0(%rsp)
movq %r11, %rax
orq $0x7, %rax
movq %rax, 0x1c8(%rsp)
movq %r11, %rax
orq $0x8, %rax
movq %rax, 0x1c0(%rsp)
movq %r11, %rax
orq $0x9, %rax
movq %rax, 0x1b8(%rsp)
movq %r11, %r9
orq $0xa, %r9
movq %r11, %rsi
orq $0xb, %rsi
movq %r11, %r12
orq $0xc, %r12
movq %r11, %r8
orq $0xd, %r8
movq %r11, %r10
orq $0xe, %r10
orq $0xf, %r11
movdqa %xmm2, 0x250(%rsp)
pcmpeqb 0x240(%rsp), %xmm2
movdqa %xmm2, 0x290(%rsp)
movdqa 0x277608(%rip), %xmm8   # 0x629ee0
movdqa 0x60(%rsp), %xmm12
movdqa %xmm12, %xmm0
xorl %eax, %eax
movq 0xa8(%rsp), %rdi
movdqa %xmm1, 0x10(%rsp)
movdqa %xmm5, 0xd0(%rsp)
movzbl 0xf(%r13,%rax), %edx
movd %edx, %xmm3
movzbl 0xf(%rdi,%rax), %edx
movd %edx, %xmm4
movsbq 0xf(%r15,%rax), %rdx
movq 0xa0(%rsp), %rdi
movd (%rdi,%rdx,4), %xmm5
movsbq 0xe(%r15,%rax), %rdx
movq 0x28(%rsp), %rdi
movd (%rdi,%rdx,4), %xmm14
movsbq 0xd(%r15,%rax), %rdx
movq 0x98(%rsp), %rdi
movd (%rdi,%rdx,4), %xmm15
movsbq 0xc(%r15,%rax), %rdx
movq 0x30(%rsp), %rdi
movd (%rdi,%rdx,4), %xmm10
movsbq 0xb(%r15,%rax), %rdx
movq 0x90(%rsp), %rdi
movd (%rdi,%rdx,4), %xmm7
movsbq 0xa(%r15,%rax), %rdx
movq 0x38(%rsp), %rdi
movd (%rdi,%rdx,4), %xmm9
movsbq 0x9(%r15,%rax), %rdx
movq 0x88(%rsp), %rdi
movd (%rdi,%rdx,4), %xmm1
movsbq 0x8(%r15,%rax), %rdx
movq 0x40(%rsp), %rdi
movd (%rdi,%rdx,4), %xmm11
movsbq 0x7(%r15,%rax), %rdx
movq 0x80(%rsp), %rdi
movd (%rdi,%rdx,4), %xmm2
movsbq 0x6(%r15,%rax), %rdx
movq 0x48(%rsp), %rdi
movd (%rdi,%rdx,4), %xmm13
movsbq 0x5(%r15,%rax), %rdx
punpcklbw %xmm5, %xmm14   # xmm14 = xmm14[0],xmm5[0],xmm14[1],xmm5[1],xmm14[2],xmm5[2],xmm14[3],xmm5[3],xmm14[4],xmm5[4],xmm14[5],xmm5[5],xmm14[6],xmm5[6],xmm14[7],xmm5[7]
movq 0x218(%rsp), %rdi
movd (%rdi,%rdx,4), %xmm5
movsbq 0x4(%r15,%rax), %rdx
punpcklbw %xmm15, %xmm10  # xmm10 = xmm10[0],xmm15[0],xmm10[1],xmm15[1],xmm10[2],xmm15[2],xmm10[3],xmm15[3],xmm10[4],xmm15[4],xmm10[5],xmm15[5],xmm10[6],xmm15[6],xmm10[7],xmm15[7]
movq 0x50(%rsp), %rdi
movd (%rdi,%rdx,4), %xmm15
movsbq 0x3(%r15,%rax), %rdx
punpcklwd %xmm14, %xmm10  # xmm10 = xmm10[0],xmm14[0],xmm10[1],xmm14[1],xmm10[2],xmm14[2],xmm10[3],xmm14[3]
movq 0x210(%rsp), %rdi
movd (%rdi,%rdx,4), %xmm14
movsbq 0x2(%r15,%rax), %rdx
punpcklbw %xmm7, %xmm9    # xmm9 = xmm9[0],xmm7[0],xmm9[1],xmm7[1],xmm9[2],xmm7[2],xmm9[3],xmm7[3],xmm9[4],xmm7[4],xmm9[5],xmm7[5],xmm9[6],xmm7[6],xmm9[7],xmm7[7]
movq 0x58(%rsp), %rdi
movd (%rdi,%rdx,4), %xmm7
movsbq 0x1(%r15,%rax), %rdx
punpcklbw %xmm1, %xmm11   # xmm11 = xmm11[0],xmm1[0],xmm11[1],xmm1[1],xmm11[2],xmm1[2],xmm11[3],xmm1[3],xmm11[4],xmm1[4],xmm11[5],xmm1[5],xmm11[6],xmm1[6],xmm11[7],xmm1[7]
movq 0x208(%rsp), %rdi
movd (%rdi,%rdx,4), %xmm1
movsbq (%r15,%rax), %rdx
punpcklwd %xmm9, %xmm11   # xmm11 = xmm11[0],xmm9[0],xmm11[1],xmm9[1],xmm11[2],xmm9[2],xmm11[3],xmm9[3]
movq 0x200(%rsp), %rdi
movd (%rdi,%rdx,4), %xmm9
punpckldq %xmm10, %xmm11  # xmm11 = xmm11[0],xmm10[0],xmm11[1],xmm10[1]
punpcklbw %xmm2, %xmm13   # xmm13 = xmm13[0],xmm2[0],xmm13[1],xmm2[1],xmm13[2],xmm2[2],xmm13[3],xmm2[3],xmm13[4],xmm2[4],xmm13[5],xmm2[5],xmm13[6],xmm2[6],xmm13[7],xmm2[7]
punpcklbw %xmm5, %xmm15   # xmm15 = xmm15[0],xmm5[0],xmm15[1],xmm5[1],xmm15[2],xmm5[2],xmm15[3],xmm5[3],xmm15[4],xmm5[4],xmm15[5],xmm5[5],xmm15[6],xmm5[6],xmm15[7],xmm5[7]
movdqa %xmm3, %xmm5
punpcklwd %xmm13, %xmm15  # xmm15 = xmm15[0],xmm13[0],xmm15[1],xmm13[1],xmm15[2],xmm13[2],xmm15[3],xmm13[3]
punpcklbw %xmm14, %xmm7   # xmm7 = xmm7[0],xmm14[0],xmm7[1],xmm14[1],xmm7[2],xmm14[2],xmm7[3],xmm14[3],xmm7[4],xmm14[4],xmm7[5],xmm14[5],xmm7[6],xmm14[6],xmm7[7],xmm14[7]
punpcklbw %xmm1, %xmm9    # xmm9 = xmm9[0],xmm1[0],xmm9[1],xmm1[1],xmm9[2],xmm1[2],xmm9[3],xmm1[3],xmm9[4],xmm1[4],xmm9[5],xmm1[5],xmm9[6],xmm1[6],xmm9[7],xmm1[7]
punpcklwd %xmm7, %xmm9    # xmm9 = xmm9[0],xmm7[0],xmm9[1],xmm7[1],xmm9[2],xmm7[2],xmm9[3],xmm7[3]
punpckldq %xmm15, %xmm9   # xmm9 = xmm9[0],xmm15[0],xmm9[1],xmm15[1]
punpcklqdq %xmm11, %xmm9   # xmm9 = xmm9[0],xmm11[0]
paddsb 0xd0(%rsp), %xmm9
movdqa %xmm6, %xmm1
psrldq $0x1, %xmm1             # xmm1 = xmm1[1,2,3,4,5,6,7,8,9,10,11,12,13,14,15],zero
pslldq $0xf, %xmm5             # xmm5 = zero,zero,zero,zero,zero,zero,zero,zero,zero,zero,zero,zero,zero,zero,zero,xmm5[0]
por %xmm1, %xmm5
psrldq $0x1, %xmm0             # xmm0 = xmm0[1,2,3,4,5,6,7,8,9,10,11,12,13,14,15],zero
pslldq $0xf, %xmm4             # xmm4 = zero,zero,zero,zero,zero,zero,zero,zero,zero,zero,zero,zero,zero,zero,zero,xmm4[0]
por %xmm0, %xmm4
movdqa %xmm5, %xmm3
movdqa 0x270(%rsp), %xmm1
psubsb %xmm1, %xmm3
movdqa 0x260(%rsp), %xmm2
psubsb %xmm2, %xmm4
movdqa %xmm3, %xmm11
pcmpgtb %xmm4, %xmm11
movdqa %xmm11, %xmm0
pandn %xmm4, %xmm0
pand %xmm11, %xmm3
por %xmm0, %xmm3
psubsb %xmm1, %xmm6
psubsb %xmm2, %xmm12
movdqa %xmm6, %xmm14
pcmpgtb %xmm12, %xmm14
movdqa %xmm14, %xmm0
pandn %xmm12, %xmm0
pand %xmm14, %xmm6
movdqa %xmm6, %xmm10
por %xmm0, %xmm10
movdqa %xmm9, %xmm0
pcmpgtb %xmm10, %xmm0
movdqa %xmm9, %xmm1
pand %xmm0, %xmm1
pandn %xmm10, %xmm0
por %xmm1, %xmm0
movdqa %xmm0, %xmm1
pcmpgtb %xmm3, %xmm1
pand %xmm1, %xmm0
pandn %xmm3, %xmm1
por %xmm0, %xmm1
movdqa %xmm8, %xmm4
pcmpeqb 0x277251(%rip), %xmm4   # 0x629da0
movdqa %xmm4, %xmm0
pandn %xmm1, %xmm0
movdqa 0xc0(%rsp), %xmm6
pand %xmm4, %xmm6
por %xmm0, %xmm6
cmpq $0x10, %rax
jb 0x3b2bbe
movdqa 0x170(%rsp), %xmm2
movdqa %xmm2, %xmm0
pcmpgtb %xmm6, %xmm0
movdqa %xmm6, %xmm1
pand %xmm0, %xmm1
pandn %xmm2, %xmm0
por %xmm1, %xmm0
movdqa 0x180(%rsp), %xmm2
movdqa %xmm2, %xmm1
pcmpgtb %xmm6, %xmm1
pand %xmm1, %xmm2
pandn %xmm6, %xmm1
por %xmm1, %xmm2
movdqa %xmm2, 0x180(%rsp)
movdqa %xmm0, 0x170(%rsp)
movdqa %xmm4, %xmm0
pandn %xmm3, %xmm0
movdqa 0x60(%rsp), %xmm12
pand %xmm4, %xmm12
por %xmm12, %xmm0
pcmpeqb %xmm6, %xmm9
movdqa %xmm6, %xmm1
pcmpeqb %xmm0, %xmm1
movdqa 0x217774(%rip), %xmm3   # 0x5ca360
movdqa %xmm3, %xmm2
psubb %xmm1, %xmm2
movdqa %xmm9, %xmm1
pandn %xmm2, %xmm1
pand 0x21759a(%rip), %xmm9   # 0x5ca1a0
por %xmm1, %xmm9
pand 0x278c9c(%rip), %xmm14  # 0x62b8b0
pand 0x278ca3(%rip), %xmm11  # 0x62b8c0
por %xmm14, %xmm11
por %xmm9, %xmm11
pxor 0x278df0(%rip), %xmm11  # 0x62ba20
movq 0x168(%rsp), %rdx
movq 0x10(%rdx), %rdx
movq (%rdx), %r13
pextrw $0x7, %xmm11, %edx
cmpq %rbx, %rax
jae 0x3b2c59
movq 0x150(%rsp), %rdi
leaq (%rdi,%r13), %rbp
movb %dh, (%rax,%rbp)
cmpq %rcx, 0x1f8(%rsp)
setae %bpl
leaq -0x1(%rax), %r14
cmpq %rbx, %r14
setae %r14b
orb %bpl, %r14b
jne 0x3b2c85
movq 0x158(%rsp), %rdi
leaq (%rdi,%r13), %r14
movb %dl, (%rax,%r14)
cmpq %rcx, 0x1f0(%rsp)
jae 0x3b2cbe
leaq -0x2(%rax), %rdx
cmpq $0x2, %rax
setae %bpl
cmpq %rbx, %rdx
setl %dl
andb %bpl, %dl
cmpb $0x1, %dl
jne 0x3b2cbe
pextrw $0x6, %xmm11, %edx
movq 0xe8(%rsp), %rdi
leaq (%rdi,%r13), %rbp
movb %dh, (%rax,%rbp)
cmpq %rcx, 0x1e8(%rsp)
jae 0x3b2cf8
leaq -0x3(%rax), %rdx
cmpq $0x3, %rax
setae %bpl
cmpq %rbx, %rdx
setl %dl
andb %bpl, %dl
cmpb $0x1, %dl
jne 0x3b2cf8
pextrw $0x6, %xmm11, %edx
movq 0xf0(%rsp), %rdi
leaq (%rdi,%r13), %r14
movb %dl, (%rax,%r14)
cmpq %rcx, 0x1e0(%rsp)
jae 0x3b2d31
leaq -0x4(%rax), %rdx
cmpq $0x4, %rax
setae %bpl
cmpq %rbx, %rdx
setl %dl
andb %bpl, %dl
cmpb $0x1, %dl
jne 0x3b2d31
pextrw $0x5, %xmm11, %edx
movq 0xf8(%rsp), %rdi
leaq (%rdi,%r13), %rbp
movb %dh, (%rax,%rbp)
cmpq %rcx, 0x1d8(%rsp)
jae 0x3b2d6b
leaq -0x5(%rax), %rdx
cmpq $0x5, %rax
setae %bpl
cmpq %rbx, %rdx
setl %dl
andb %bpl, %dl
cmpb $0x1, %dl
jne 0x3b2d6b
pextrw $0x5, %xmm11, %edx
movq 0x100(%rsp), %rdi
leaq (%rdi,%r13), %r14
movb %dl, (%rax,%r14)
cmpq %rcx, 0x1d0(%rsp)
jae 0x3b2da4
leaq -0x6(%rax), %rdx
cmpq $0x6, %rax
setae %bpl
cmpq %rbx, %rdx
setl %dl
andb %bpl, %dl
cmpb $0x1, %dl
jne 0x3b2da4
pextrw $0x4, %xmm11, %edx
movq 0x108(%rsp), %rdi
leaq (%rdi,%r13), %rbp
movb %dh, (%rax,%rbp)
cmpq %rcx, 0x1c8(%rsp)
jae 0x3b2dde
leaq -0x7(%rax), %rdx
cmpq $0x7, %rax
setae %bpl
cmpq %rbx, %rdx
setl %dl
andb %bpl, %dl
cmpb $0x1, %dl
jne 0x3b2dde
pextrw $0x4, %xmm11, %edx
movq 0x118(%rsp), %rdi
leaq (%rdi,%r13), %r14
movb %dl, (%rax,%r14)
cmpq %rcx, 0x1c0(%rsp)
jae 0x3b2e17
leaq -0x8(%rax), %rdx
cmpq $0x8, %rax
setae %bpl
cmpq %rbx, %rdx
setl %dl
andb %bpl, %dl
cmpb $0x1, %dl
jne 0x3b2e17
pextrw $0x3, %xmm11, %edx
movq 0x110(%rsp), %rdi
leaq (%rdi,%r13), %rbp
movb %dh, (%rax,%rbp)
cmpq %rcx, 0x1b8(%rsp)
jae 0x3b2e51
leaq -0x9(%rax), %rdx
cmpq $0x9, %rax
setae %bpl
cmpq %rbx, %rdx
setl %dl
andb %bpl, %dl
cmpb $0x1, %dl
jne 0x3b2e51
pextrw $0x3, %xmm11, %edx
movq 0x120(%rsp), %rdi
leaq (%rdi,%r13), %r14
movb %dl, (%rax,%r14)
cmpq %rcx, %r9
jae 0x3b2e85
leaq -0xa(%rax), %rdx
cmpq $0xa, %rax
setae %bpl
cmpq %rbx, %rdx
setl %dl
andb %bpl, %dl
cmpb $0x1, %dl
jne 0x3b2e85
pextrw $0x2, %xmm11, %edx
movq 0x128(%rsp), %rdi
leaq (%rdi,%r13), %rbp
movb %dh, (%rax,%rbp)
cmpq %rcx, %rsi
jae 0x3b2eba
leaq -0xb(%rax), %rdx
cmpq $0xb, %rax
setae %bpl
cmpq %rbx, %rdx
setl %dl
andb %bpl, %dl
cmpb $0x1, %dl
jne 0x3b2eba
pextrw $0x2, %xmm11, %edx
movq 0x130(%rsp), %rdi
leaq (%rdi,%r13), %r14
movb %dl, (%rax,%r14)
cmpq %rcx, %r12
jae 0x3b2ef1
leaq -0xc(%rax), %rdx
cmpq $0xc, %rax
setae %bpl
cmpq %rbx, %rdx
setl %dl
andb %bpl, %dl
cmpb $0x1, %dl
jne 0x3b2ef1
movd %xmm11, %edx
shrl $0x18, %edx
movq 0x138(%rsp), %rdi
leaq (%rdi,%r13), %r14
movb %dl, (%rax,%r14)
cmpq %rcx, %r8
jae 0x3b2f28
leaq -0xd(%rax), %rdx
cmpq $0xd, %rax
setae %bpl
cmpq %rbx, %rdx
setl %dl
andb %bpl, %dl
cmpb $0x1, %dl
jne 0x3b2f28
movd %xmm11, %edx
shrl $0x10, %edx
movq 0x140(%rsp), %rdi
leaq (%rdi,%r13), %r14
movb %dl, (%rax,%r14)
cmpq %rcx, %r10
jae 0x3b2f5b
leaq -0xe(%rax), %rdx
cmpq $0xe, %rax
setae %bpl
cmpq %rbx, %rdx
setl %dl
andb %bpl, %dl
cmpb $0x1, %dl
jne 0x3b2f5b
movd %xmm11, %edx
movq 0x148(%rsp), %rdi
leaq (%rdi,%r13), %rbp
movb %dh, (%rax,%rbp)
cmpq %rcx, %r11
setae %dl
cmpq $0xf, %rax
setb %bpl
orb %dl, %bpl
jne 0x3b2f7f
movd %xmm11, %edx
addq 0x160(%rsp), %r13
movb %dl, (%rax,%r13)
pandn %xmm10, %xmm4
por %xmm4, %xmm12
movdqa %xmm6, 0x2b0(%rsp)
movb 0x2b0(%rsp), %dl
movq 0xb0(%rsp), %r13
movb %dl, (%r13,%rax)
movd %xmm0, %edx
movq 0xa8(%rsp), %rdi
movb %dl, (%rdi,%rax)
movdqa %xmm8, %xmm1
pcmpeqb 0x280(%rsp), %xmm1
pand 0x290(%rsp), %xmm1
movdqa %xmm6, %xmm2
pand %xmm1, %xmm2
pandn 0x10(%rsp), %xmm1
por %xmm2, %xmm1
paddsb %xmm3, %xmm8
incq %rax
cmpq %rax, 0x1b0(%rsp)
jne 0x3b28ee
movdqa 0x250(%rsp), %xmm2
paddsb 0x2171bb(%rip), %xmm2   # 0x5ca1c0
movdqa 0xc0(%rsp), %xmm0
psubsb 0x230(%rsp), %xmm0
movdqa %xmm0, 0xc0(%rsp)
movq 0x1a0(%rsp), %rax
addq %rax, 0x160(%rsp)
addq %rax, 0x150(%rsp)
addq %rax, 0x158(%rsp)
addq %rax, 0x148(%rsp)
addq %rax, 0x140(%rsp)
addq %rax, 0x138(%rsp)
addq %rax, 0x130(%rsp)
addq %rax, 0x128(%rsp)
addq %rax, 0x120(%rsp)
addq %rax, 0x110(%rsp)
addq %rax, 0x118(%rsp)
addq %rax, 0x108(%rsp)
addq %rax, 0x100(%rsp)
addq %rax, 0xf8(%rsp)
addq %rax, 0xf0(%rsp)
addq %rax, 0xe8(%rsp)
movq 0x1a8(%rsp), %rax
movq %rax, %r11
cmpq %rcx, %rax
movq 0x300(%rsp), %r8
jb 0x3b245c
movl $0x10, %eax
movl 0x4(%rsp), %edx
movdqa %xmm1, 0x2a0(%rsp)
movzbl 0x2af(%rsp), %ecx
movzbl %dl, %edx
cmpb %dl, %cl
cmovgl %ecx, %edx
pslldq $0x1, %xmm1             # xmm1 = zero,xmm1[0,1,2,3,4,5,6,7,8,9,10,11,12,13,14]
decl %eax
jne 0x3b30cd
movdqa 0x60(%rsp), %xmm0
pcmpgtb 0x170(%rsp), %xmm0
movdqa 0x180(%rsp), %xmm1
pcmpgtb 0x190(%rsp), %xmm1
por %xmm0, %xmm1
pmovmskb %xmm1, %eax
testl %eax, %eax
movq 0x168(%rsp), %rbx
movl 0xbc(%rsp), %ecx
je 0x3b313b
orb $0x40, 0xc(%rbx)
xorl %edx, %edx
xorl %ecx, %ecx
movl $0x0, 0x8(%rsp)
movsbl %dl, %eax
movl %eax, (%rbx)
movl 0x8(%rsp), %eax
movl %eax, 0x4(%rbx)
movl %ecx, 0x8(%rbx)
callq 0x20a60d
movq %r13, %rdi
callq 0x20a60d
movq %r15, %rdi
callq 0x20a60d
movq 0x300(%rsp), %rax
cmpl $0x0, 0x30(%rax)
jne 0x3b31aa
movq 0x70(%rsp), %rdi
callq 0x20a60d
jmp 0x3b31aa
callq 0x1be443
jmp 0x3b31a8
callq 0x1be41d
jmp 0x3b31a8
callq 0x1be3f7
jmp 0x3b31a8
callq 0x1be3d1
jmp 0x3b31a8
callq 0x1be3ab
jmp 0x3b31a8
callq 0x1be385
jmp 0x3b31a8
callq 0x1be35f
xorl %ebx, %ebx
movq %rbx, %rax
addq $0x2c8, %rsp            # imm = 0x2C8
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
nop