// File: /workspace/github_c_makefile_star2_O3/nh13[P]ksw/src/parasail/src/nw_trace_diag_sse2_128_32.c
// Function: parasail_nw_trace_diag_sse2_128_32
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;
    int32_t * restrict s1 = NULL;
    int32_t * restrict s2B = NULL;
    int32_t * restrict _H_pr = NULL;
    int32_t * restrict _F_pr = NULL;
    int32_t * restrict s2 = NULL;
    int32_t * restrict H_pr = NULL;
    int32_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;
    int32_t NEG_LIMIT = 0;
    int32_t POS_LIMIT = 0;
    int32_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 = 4; /* 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 ? INT32_MIN + open : INT32_MIN - matrix->min) + 1;
    POS_LIMIT = INT32_MAX - matrix->max - 1;
    score = NEG_LIMIT;
    vNegLimit = _mm_set1_epi32(NEG_LIMIT);
    vPosLimit = _mm_set1_epi32(POS_LIMIT);
    vSaturationCheckMin = vPosLimit;
    vSaturationCheckMax = vNegLimit;
    vNegInf = _mm_set1_epi32(NEG_LIMIT);
    vOpen = _mm_set1_epi32(open);
    vGap  = _mm_set1_epi32(gap);
    vOne = _mm_set1_epi32(1);
    vN = _mm_set1_epi32(N);
    vGapN = _mm_set1_epi32(gap*N);
    vNegOne = _mm_set1_epi32(-1);
    vI = _mm_set_epi32(0,1,2,3);
    vJreset = _mm_set_epi32(0,-1,-2,-3);
    vMax = vNegInf;
    vILimit = _mm_set1_epi32(s1Len);
    vILimit1 = _mm_sub_epi32(vILimit, vOne);
    vJLimit = _mm_set1_epi32(s2Len);
    vJLimit1 = _mm_sub_epi32(vJLimit, vOne);
    vIBoundary = _mm_set_epi32(
            -open-0*gap,
            -open-1*gap,
            -open-2*gap,
            -open-3*gap);
    vTDiag = _mm_set1_epi32(PARASAIL_DIAG);
    vTIns = _mm_set1_epi32(PARASAIL_INS);
    vTDel = _mm_set1_epi32(PARASAIL_DEL);
    vTDiagE = _mm_set1_epi32(PARASAIL_DIAG_E);
    vTInsE = _mm_set1_epi32(PARASAIL_INS_E);
    vTDiagF = _mm_set1_epi32(PARASAIL_DIAG_F);
    vTDelF = _mm_set1_epi32(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_32 | PARASAIL_FLAG_LANES_4;

    /* initialize heap variables */
    s2B= parasail_memalign_int32_t(16, s2Len+PAD2);
    _H_pr = parasail_memalign_int32_t(16, s2Len+PAD2);
    _F_pr = parasail_memalign_int32_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_int32_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))];
        vNH = _mm_srli_si128(vNH, 4);
        vNH = _mm_insert_epi32_rpl(vNH, H_pr[-1], 3);
        vWH = _mm_srli_si128(vWH, 4);
        vWH = _mm_insert_epi32_rpl(vWH, -open - i*gap, 3);
        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, 4);
            vNH = _mm_insert_epi32_rpl(vNH, H_pr[j], 3);
            vF = _mm_srli_si128(vF, 4);
            vF = _mm_insert_epi32_rpl(vF, F_pr[j], 3);
            vF_opn = _mm_sub_epi32(vNH, vOpen);
            vF_ext = _mm_sub_epi32(vF, vGap);
            vF = _mm_max_epi32_rpl(vF_opn, vF_ext);
            vE_opn = _mm_sub_epi32(vWH, vOpen);
            vE_ext = _mm_sub_epi32(vE, vGap);
            vE = _mm_max_epi32_rpl(vE_opn, vE_ext);
            vMat = _mm_set_epi32(
                    matrow0[s2[j-0]],
                    matrow1[s2[j-1]],
                    matrow2[s2[j-2]],
                    matrow3[s2[j-3]]
                    );
            vNWH = _mm_add_epi32(vNWH, vMat);
            vWH = _mm_max_epi32_rpl(vNWH, vE);
            vWH = _mm_max_epi32_rpl(vWH, vF);
            /* as minor diagonal vector passes across the j=-1 boundary,
             * assign the appropriate boundary conditions */
            {
                __m128i cond = _mm_cmpeq_epi32(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_epi32_rpl(vSaturationCheckMin, vWH);
                vSaturationCheckMax = _mm_max_epi32_rpl(vSaturationCheckMax, vWH);
            }
            /* trace table */
            {
                __m128i case1 = _mm_cmpeq_epi32(vWH, vNWH);
                __m128i case2 = _mm_cmpeq_epi32(vWH, vF);
                __m128i vT = _mm_blendv_epi8_rpl(
                        _mm_blendv_epi8_rpl(vTIns, vTDel, case2),
                        vTDiag,
                        case1);
                __m128i condE = _mm_cmpgt_epi32(vE_opn, vE_ext);
                __m128i condF = _mm_cmpgt_epi32(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-3] = (int32_t)_mm_extract_epi32_rpl(vWH,0);
            F_pr[j-3] = (int32_t)_mm_extract_epi32_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_epi32(vI, vILimit1);
                __m128i cond_valid_J = _mm_cmpeq_epi32(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_add_epi32(vJ, vOne);
        }
        vI = _mm_add_epi32(vI, vN);
        vIBoundary = _mm_sub_epi32(vIBoundary, vGapN);
    }

    /* max in vMax */
    for (i=0; i<N; ++i) {
        int32_t value;
        value = (int32_t) _mm_extract_epi32_rpl(vMax, 3);
        if (value > score) {
            score = value;
        }
        vMax = _mm_slli_si128(vMax, 4);
    }

    if (_mm_movemask_epi8(_mm_or_si128(
            _mm_cmplt_epi32(vSaturationCheckMin, vNegLimit),
            _mm_cmpgt_epi32(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 $0x148, %rsp            # imm = 0x148
testq %rdx, %rdx
je 0x3adc18
movl %ecx, %ebp
testl %ecx, %ecx
jle 0x3adc1f
movl %r8d, %r15d
testl %r8d, %r8d
js 0x3adc26
testl %r9d, %r9d
js 0x3adc2d
movq 0x180(%rsp), %r12
testq %r12, %r12
je 0x3adc34
cmpl $0x0, 0x30(%r12)
je 0x3ad361
movl 0x34(%r12), %r14d
jmp 0x3ad375
testq %rdi, %rdi
je 0x3adc3b
movl %esi, %r14d
testl %esi, %esi
jle 0x3adc42
movq %rdi, 0x70(%rsp)
movq %rdx, 0x18(%rsp)
movq %r9, 0x48(%rsp)
movl %r15d, %edx
negl %edx
movl 0x20(%r12), %eax
movl $0x80000000, %ebx       # imm = 0x80000000
movl %r15d, %ecx
orl %ebx, %ecx
subl %eax, %ebx
movl %edx, 0xc(%rsp)
cmpl %edx, %eax
cmovgl %ecx, %ebx
movl $0x7ffffffe, %r13d      # imm = 0x7FFFFFFE
subl 0x1c(%r12), %r13d
movl $0x10, %edx
movl $0x1, %ecx
movl %r14d, %edi
movl %ebp, %esi
callq 0x20adf4
testq %rax, %rax
je 0x3adc47
movl %r13d, 0xc0(%rsp)
movl %r15d, 0x50(%rsp)
movq %r14, 0x10(%rsp)
movq %rax, 0x28(%rsp)
orl $0x4481001, 0xc(%rax)   # imm = 0x4481001
leal 0x6(%rbp), %r13d
movl $0x10, %edi
movq %r13, %rsi
callq 0x20a62d
movq %rax, %r15
movl $0x10, %edi
movq %r13, %rsi
callq 0x20a62d
movq %rax, %r14
movl $0x10, %edi
movq %r13, %rsi
callq 0x20a62d
testq %r15, %r15
sete %dl
testq %r14, %r14
sete %cl
orb %dl, %cl
testq %rax, %rax
sete %dl
orb %cl, %dl
jne 0x3adc47
cmpl $0x0, 0x30(%r12)
movq %r14, 0x38(%rsp)
movq %rax, 0x30(%rsp)
je 0x3ad45d
movq $0x0, 0x40(%rsp)
movq 0x28(%rsp), %r13
movq 0x10(%rsp), %r14
jmp 0x3ad4d8
movq 0x10(%rsp), %r14
leal 0x3(%r14), %r13d
movslq %r13d, %rsi
movl $0x10, %edi
callq 0x20a62d
testq %rax, %rax
je 0x3adc47
movl %r13d, %r9d
testl %r14d, %r14d
movq 0x28(%rsp), %r13
movq 0x70(%rsp), %r8
jle 0x3ad4ab
movq 0x10(%r12), %rdi
movl %r14d, %ecx
xorl %edx, %edx
movzbl (%r8,%rdx), %esi
movl (%rdi,%rsi,4), %esi
movl %esi, (%rax,%rdx,4)
incq %rdx
cmpq %rdx, %rcx
jne 0x3ad498
movslq %r14d, %rdx
movq %rax, 0x40(%rsp)
leaq (%rax,%rdx,4), %rdi
leal 0x1(%r14), %eax
cmpl %eax, %r9d
cmovgl %r9d, %eax
movl %r14d, %ecx
notl %ecx
addl %eax, %ecx
leaq 0x4(,%rcx,4), %rdx
xorl %esi, %esi
callq 0x19e090
leal 0x3(%rbp), %r9d
movd %ebp, %xmm0
movd %r14d, %xmm1
punpckldq %xmm0, %xmm1    # xmm1 = xmm1[0],xmm0[0],xmm1[1],xmm0[1]
pcmpeqd %xmm2, %xmm2
paddd %xmm1, %xmm2
incl %ebx
movl %ebx, 0x24(%rsp)
movd %ebx, %xmm0
pshufd $0x0, %xmm0, %xmm0      # xmm0 = xmm0[0,0,0,0]
movdqa %xmm0, 0x60(%rsp)
movd 0xc0(%rsp), %xmm0
pshufd $0x0, %xmm0, %xmm0      # xmm0 = xmm0[0,0,0,0]
movdqa %xmm0, 0xb0(%rsp)
movl 0x50(%rsp), %r8d
movd %r8d, %xmm0
pshufd $0x0, %xmm0, %xmm0      # xmm0 = xmm0[0,0,0,0]
movdqa %xmm0, 0xc0(%rsp)
movq 0x48(%rsp), %rsi
movd %esi, %xmm0
pshufd $0x0, %xmm0, %xmm0      # xmm0 = xmm0[0,0,0,0]
movdqa %xmm0, 0x130(%rsp)
pslld $0x2, %xmm0
movdqa %xmm0, 0x100(%rsp)
pshufd $0x0, %xmm2, %xmm0      # xmm0 = xmm2[0,0,0,0]
movdqa %xmm0, 0xf0(%rsp)
movdqa %xmm2, 0xa0(%rsp)
pshufd $0x55, %xmm2, %xmm0     # xmm0 = xmm2[1,1,1,1]
movdqa %xmm0, 0x120(%rsp)
movl 0xc(%rsp), %edi
movl %edi, %eax
subl %esi, %eax
movl %edi, %edx
subl %esi, %edx
subl %esi, %edx
leal (%rsi,%rsi,2), %ecx
addl %r8d, %ecx
negl %ecx
movd %edx, %xmm0
movd %ecx, %xmm2
punpckldq %xmm0, %xmm2    # xmm2 = xmm2[0],xmm0[0],xmm2[1],xmm0[1]
movd %eax, %xmm0
movd %edi, %xmm1
punpckldq %xmm1, %xmm0    # xmm0 = xmm0[0],xmm1[0],xmm0[1],xmm1[1]
punpcklqdq %xmm0, %xmm2    # xmm2 = xmm2[0],xmm0[0]
movdqa %xmm2, 0x70(%rsp)
movq 0x10(%r12), %rax
movl %ebp, %r14d
xorl %ecx, %ecx
movq 0x18(%rsp), %rsi
movzbl (%rsi,%rcx), %edx
movl (%rax,%rdx,4), %edx
movl %edx, 0xc(%r15,%rcx,4)
incq %rcx
cmpq %rcx, %r14
jne 0x3ad5c6
movl $0x0, 0x8(%r15)
movq $0x0, (%r15)
leaq (%r15,%r14,4), %rdi
addq $0xc, %rdi
leal 0x1(%rbp), %eax
cmpl %eax, %r9d
movl %r9d, 0x18(%rsp)
cmovgl %r9d, %eax
movl %ebp, %ecx
notl %ecx
addl %eax, %ecx
leaq 0x4(,%rcx,4), %rdx
xorl %ebx, %ebx
xorl %esi, %esi
callq 0x19e090
movl 0xc(%rsp), %eax
movl 0x24(%rsp), %ecx
movq 0x48(%rsp), %rdx
movq 0x38(%rsp), %rsi
movq 0x30(%rsp), %rdi
movl %eax, 0xc(%rsi,%rbx,4)
movl %ecx, 0xc(%rdi,%rbx,4)
incq %rbx
subl %edx, %eax
cmpq %rbx, %r14
jne 0x3ad62e
xorl %eax, %eax
movl %ecx, (%rsi,%rax,4)
movl %ecx, (%rdi,%rax,4)
incq %rax
cmpq $0x3, %rax
jne 0x3ad642
leaq 0x3(%r14), %rax
movl 0x18(%rsp), %edx
movl %ecx, (%rsi,%rax,4)
movl %ecx, (%rdi,%rax,4)
incq %rax
incl %ebp
cmpl %ebp, %edx
jg 0x3ad659
movl $0x0, 0x8(%rsi)
movdqa 0x60(%rsp), %xmm0
movdqa %xmm0, %xmm2
movdqa 0xb0(%rsp), %xmm3
movq 0x10(%rsp), %rcx
testl %ecx, %ecx
jle 0x3adb84
movdqa 0x60(%rsp), %xmm2
movdqa %xmm2, %xmm0
cmpl $0x2, %edx
movl $0x1, %eax
cmovgel %edx, %eax
movq %rax, 0x50(%rsp)
psrldq $0x4, %xmm0             # xmm0 = xmm0[4,5,6,7,8,9,10,11,12,13,14,15],zero,zero,zero,zero
movdqa %xmm0, 0xe0(%rsp)
movl %ecx, %ecx
movaps 0xa0(%rsp), %xmm0
movss %xmm0, 0x5c(%rsp)
leaq -0x3(%r14,%r14,2), %rax
movq %rax, 0x10(%rsp)
leaq (,%r14,4), %rax
movq %rax, 0xd0(%rsp)
leaq -0x2(%r14,%r14), %rax
movq %rax, 0x88(%rsp)
leaq -0x1(%r14), %rax
movq %rax, 0x98(%rsp)
movdqa 0x27c36d(%rip), %xmm12  # 0x629a70
movq $0x0, 0x90(%rsp)
xorl %ebp, %ebp
movdqa 0xb0(%rsp), %xmm3
movdqa %xmm2, %xmm0
movq %rbp, %rsi
orq $0x3, %rsi
cmpl $0x0, 0x30(%r12)
movq %rsi, 0x18(%rsp)
je 0x3ad760
movq %rbp, %rdx
orq $0x1, %rdx
cmpq %rcx, %rdx
movl 0x5c(%rsp), %eax
cmovael %eax, %edx
movq %rbp, %r8
orq $0x2, %r8
cmpq %rcx, %r8
cmovael %eax, %r8d
cmpq %rcx, %rsi
movl %esi, %r9d
cmovael %eax, %r9d
movl %ebp, %r10d
jmp 0x3ad776
movq 0x40(%rsp), %rax
movl (%rax,%rbp,4), %r10d
movl 0x4(%rax,%rbp,4), %edx
movl 0x8(%rax,%rbp,4), %r8d
movl (%rax,%rsi,4), %r9d
movq 0x8(%r12), %r11
movl 0x18(%r12), %ebx
imull %ebx, %edx
movslq %edx, %rdx
leaq (%r11,%rdx,4), %rdi
imull %ebx, %r10d
movslq %r10d, %rdx
leaq (%r11,%rdx,4), %rdx
imull %ebx, %r8d
movslq %r8d, %r8
leaq (%r11,%r8,4), %r8
imull %ebx, %r9d
movslq %r9d, %r9
leaq (%r11,%r9,4), %rbx
leaq 0x4(%rbp), %rax
movq %rax, 0xd8(%rsp)
movl %eax, %r9d
movq 0x48(%rsp), %rax
imull %eax, %r9d
movl 0xc(%rsp), %esi
movl %esi, %r10d
subl %r9d, %r10d
movq 0x38(%rsp), %r11
movss 0x8(%r11), %xmm1
movl %r10d, 0x8(%r11)
movl %ebp, %r9d
imull %eax, %r9d
movl %esi, %r10d
subl %r9d, %r10d
movd %r10d, %xmm4
movq %r11, %rax
movaps 0xe0(%rsp), %xmm15
shufps $0xe4, %xmm15, %xmm4    # xmm4 = xmm4[0,1],xmm15[2,3]
movaps %xmm15, %xmm9
shufps $0x24, %xmm4, %xmm9     # xmm9 = xmm9[0,1],xmm4[2,0]
shufps $0xe4, %xmm15, %xmm1    # xmm1 = xmm1[0,1],xmm15[2,3]
shufps $0x24, %xmm1, %xmm15    # xmm15 = xmm15[0,1],xmm1[2,0]
movq %rbp, %r11
orq $0x1, %r11
orq $0x2, %rbp
movdqa %xmm12, 0x110(%rsp)
pcmpeqd 0xf0(%rsp), %xmm12
xorl %r9d, %r9d
movdqa 0x27c4e3(%rip), %xmm10  # 0x629d20
movaps 0x60(%rsp), %xmm5
movaps %xmm5, %xmm1
movq 0x30(%rsp), %rsi
movss 0xc(%rax,%r9,4), %xmm4
shufps $0xf4, %xmm9, %xmm4     # xmm4 = xmm4[0,1],xmm9[3,3]
movslq 0xc(%r15,%r9,4), %r10
movslq 0x8(%r15,%r9,4), %rax
movslq 0x4(%r15,%r9,4), %r13
movslq (%r15,%r9,4), %r12
movd (%rdx,%r10,4), %xmm7
movd (%rdi,%rax,4), %xmm8
punpckldq %xmm7, %xmm8    # xmm8 = xmm8[0],xmm7[0],xmm8[1],xmm7[1]
movd (%r8,%r13,4), %xmm7
movd (%rbx,%r12,4), %xmm11
punpckldq %xmm7, %xmm11   # xmm11 = xmm11[0],xmm7[0],xmm11[1],xmm7[1]
punpcklqdq %xmm8, %xmm11   # xmm11 = xmm11[0],xmm8[0]
paddd %xmm15, %xmm11
movaps %xmm9, %xmm15
shufps $0x29, %xmm4, %xmm15    # xmm15 = xmm15[1,2],xmm4[2,0]
movss 0xc(%rsi,%r9,4), %xmm4
shufps $0xf4, %xmm1, %xmm4     # xmm4 = xmm4[0,1],xmm1[3,3]
shufps $0x29, %xmm4, %xmm1     # xmm1 = xmm1[1,2],xmm4[2,0]
movaps %xmm15, %xmm4
movdqa 0xc0(%rsp), %xmm6
psubd %xmm6, %xmm4
movdqa 0x130(%rsp), %xmm13
psubd %xmm13, %xmm1
movdqa %xmm4, %xmm8
pcmpgtd %xmm1, %xmm8
movdqa %xmm8, %xmm7
pandn %xmm1, %xmm7
pand %xmm8, %xmm4
por %xmm7, %xmm4
psubd %xmm6, %xmm9
pcmpeqd %xmm6, %xmm6
psubd %xmm13, %xmm5
movdqa %xmm9, %xmm14
pcmpgtd %xmm5, %xmm14
movdqa %xmm14, %xmm1
pandn %xmm5, %xmm1
pand %xmm14, %xmm9
movdqa %xmm9, %xmm7
por %xmm1, %xmm7
movdqa %xmm11, %xmm1
pcmpgtd %xmm7, %xmm1
movdqa %xmm11, %xmm5
pand %xmm1, %xmm5
pandn %xmm7, %xmm1
por %xmm5, %xmm1
movdqa %xmm1, %xmm5
pcmpgtd %xmm4, %xmm5
pand %xmm5, %xmm1
pandn %xmm4, %xmm5
por %xmm1, %xmm5
movdqa %xmm10, %xmm13
pcmpeqd %xmm6, %xmm13
movdqa %xmm13, %xmm1
pandn %xmm5, %xmm1
movdqa 0x70(%rsp), %xmm9
pand %xmm13, %xmm9
por %xmm1, %xmm9
cmpq $0x4, %r9
jb 0x3ad9a4
movdqa %xmm3, %xmm1
pcmpgtd %xmm9, %xmm1
movdqa %xmm9, %xmm5
pand %xmm1, %xmm5
pandn %xmm3, %xmm1
por %xmm5, %xmm1
movdqa %xmm0, %xmm3
pcmpgtd %xmm9, %xmm3
pand %xmm3, %xmm0
pandn %xmm9, %xmm3
por %xmm3, %xmm0
movdqa %xmm1, %xmm3
movq 0x28(%rsp), %r13
movdqa %xmm13, %xmm1
pandn %xmm4, %xmm1
movdqa 0x60(%rsp), %xmm5
pand %xmm13, %xmm5
por %xmm5, %xmm1
pcmpeqd %xmm9, %xmm11
movdqa %xmm9, %xmm4
pcmpeqd %xmm1, %xmm4
movdqa 0x27c7b9(%rip), %xmm6   # 0x62a190
psubd %xmm4, %xmm6
movdqa %xmm11, %xmm4
pandn %xmm6, %xmm4
pand 0x27c103(%rip), %xmm11  # 0x629af0
por %xmm4, %xmm11
pand 0x27dd55(%rip), %xmm14  # 0x62b750
pand 0x27dd6c(%rip), %xmm8   # 0x62b770
por %xmm14, %xmm8
por %xmm11, %xmm8
pxor 0x27df89(%rip), %xmm8   # 0x62b9a0
movq 0x10(%r13), %rax
movq (%rax), %r10
cmpq %r14, %r9
jae 0x3ada39
pextrw $0x6, %xmm8, %eax
movq 0x90(%rsp), %rsi
leaq (%r10,%rsi), %r12
movb %al, (%r9,%r12)
cmpq %rcx, %r11
setae %al
leaq -0x1(%r9), %r12
cmpq %r14, %r12
setae %r12b
orb %al, %r12b
jne 0x3ada65
pextrw $0x4, %xmm8, %eax
movq 0x98(%rsp), %rsi
leaq (%r10,%rsi), %r12
movb %al, (%r9,%r12)
cmpq %rcx, %rbp
jae 0x3ada99
leaq -0x2(%r9), %rax
cmpq $0x2, %r9
setae %r12b
cmpq %r14, %rax
setl %al
andb %r12b, %al
cmpb $0x1, %al
jne 0x3ada99
pextrw $0x2, %xmm8, %eax
movq 0x88(%rsp), %rsi
leaq (%r10,%rsi), %r12
movb %al, (%r9,%r12)
cmpq %rcx, 0x18(%rsp)
setae %al
cmpq $0x3, %r9
setb %r12b
orb %al, %r12b
jne 0x3adabc
movd %xmm8, %eax
addq 0x10(%rsp), %r10
movb %al, (%r9,%r10)
pandn %xmm7, %xmm13
por %xmm13, %xmm5
movq 0x38(%rsp), %rax
movd %xmm9, (%rax,%r9,4)
movq 0x30(%rsp), %rsi
movd %xmm1, (%rsi,%r9,4)
movdqa %xmm10, %xmm4
pcmpeqd 0x120(%rsp), %xmm4
pand %xmm12, %xmm4
movdqa %xmm9, %xmm6
pand %xmm4, %xmm6
pandn %xmm2, %xmm4
movdqa %xmm4, %xmm2
por %xmm6, %xmm2
pcmpeqd %xmm4, %xmm4
psubd %xmm4, %xmm10
incq %r9
cmpq %r9, 0x50(%rsp)
jne 0x3ad84a
movdqa 0x110(%rsp), %xmm12
paddd 0x27bfc2(%rip), %xmm12  # 0x629af0
movdqa 0x70(%rsp), %xmm1
psubd 0x100(%rsp), %xmm1
movdqa %xmm1, 0x70(%rsp)
movq 0xd0(%rsp), %rax
addq %rax, 0x10(%rsp)
addq %rax, 0x90(%rsp)
addq %rax, 0x98(%rsp)
addq %rax, 0x88(%rsp)
movq 0xd8(%rsp), %rax
movq %rax, %rbp
cmpq %rcx, %rax
movq 0x180(%rsp), %r12
jb 0x3ad71e
movl $0x4, %eax
movl 0x24(%rsp), %edx
pshufd $0xff, %xmm2, %xmm1     # xmm1 = xmm2[3,3,3,3]
movd %xmm1, %ecx
cmpl %edx, %ecx
cmovgl %ecx, %edx
pslldq $0x4, %xmm2             # xmm2 = zero,zero,zero,zero,xmm2[0,1,2,3,4,5,6,7,8,9,10,11]
decl %eax
jne 0x3adb8d
movdqa 0x60(%rsp), %xmm1
pcmpgtd %xmm3, %xmm1
pcmpgtd 0xb0(%rsp), %xmm0
por %xmm1, %xmm0
movmskps %xmm0, %eax
testl %eax, %eax
movq 0x30(%rsp), %rdi
movq 0x40(%rsp), %rbx
je 0x3adbde
orb $0x40, 0xc(%r13)
xorps %xmm0, %xmm0
movaps %xmm0, 0xa0(%rsp)
xorl %edx, %edx
movl %edx, (%r13)
movaps 0xa0(%rsp), %xmm0
movlps %xmm0, 0x4(%r13)
callq 0x20a60d
movq 0x38(%rsp), %rdi
callq 0x20a60d
movq %r15, %rdi
callq 0x20a60d
cmpl $0x0, 0x30(%r12)
jne 0x3adc4a
movq %rbx, %rdi
callq 0x20a60d
jmp 0x3adc4a
callq 0x1bde07
jmp 0x3adc47
callq 0x1bdde1
jmp 0x3adc47
callq 0x1bddbb
jmp 0x3adc47
callq 0x1bdd95
jmp 0x3adc47
callq 0x1bdd6f
jmp 0x3adc47
callq 0x1bdd49
jmp 0x3adc47
callq 0x1bdd23
xorl %r13d, %r13d
movq %r13, %rax
addq $0x148, %rsp            # imm = 0x148
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
nop