// File: /workspace/github_c_makefile_star2_O1/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 $0x138, %rsp            # imm = 0x138
testq %rdx, %rdx
je 0x38fd46
movl %r8d, %r13d
movl %ecx, %r8d
testl %ecx, %ecx
jle 0x38fd4d
testl %r13d, %r13d
js 0x38fd54
testl %r9d, %r9d
js 0x38fd5b
movq 0x170(%rsp), %r12
testq %r12, %r12
je 0x38fd62
movl 0x30(%r12), %eax
testl %eax, %eax
jne 0x38f477
testq %rdi, %rdi
je 0x38fd69
movl %esi, %ebx
testl %esi, %esi
jle 0x38fd70
testl %eax, %eax
je 0x38f47c
movl 0x34(%r12), %ebx
movq %rdi, 0x80(%rsp)
movq %rdx, 0x30(%rsp)
movq %r9, 0x60(%rsp)
movl %r13d, %edx
negl %edx
movl 0x20(%r12), %eax
movl $0x80000000, %ebp       # imm = 0x80000000
movl %r13d, %ecx
orl %ebp, %ecx
subl %eax, %ebp
movl %edx, 0x1c(%rsp)
cmpl %edx, %eax
cmovgl %ecx, %ebp
movl $0x7ffffffe, %r14d      # imm = 0x7FFFFFFE
subl 0x1c(%r12), %r14d
movl $0x10, %edx
movl $0x1, %ecx
movl %ebx, %edi
movl %r8d, %esi
movq %r8, %r15
callq 0x2097d1
testq %rax, %rax
je 0x38fd75
movl %r13d, 0x40(%rsp)
movq %rbx, 0x10(%rsp)
movq %rax, 0x48(%rsp)
orl $0x4481001, 0xc(%rax)   # imm = 0x4481001
movq %r15, 0x28(%rsp)
leal 0x6(%r15), %r13d
movl $0x10, %edi
movq %r13, %rsi
callq 0x2094d5
movq %rax, %r15
movl $0x10, %edi
movq %r13, %rsi
callq 0x2094d5
movq %rax, %rbx
movl $0x10, %edi
movq %r13, %rsi
callq 0x2094d5
testq %r15, %r15
sete %dl
testq %rbx, %rbx
sete %cl
orb %dl, %cl
testq %rax, %rax
sete %dl
orb %cl, %dl
jne 0x38fd75
cmpl $0x0, 0x30(%r12)
movq %rbx, 0x58(%rsp)
movq %rax, 0x50(%rsp)
je 0x38f563
xorl %eax, %eax
movq 0x48(%rsp), %r13
movq 0x10(%rsp), %rbx
jmp 0x38f5e9
movq 0x10(%rsp), %rbx
leal 0x3(%rbx), %r13d
movslq %r13d, %rsi
movl $0x10, %edi
callq 0x2094d5
testq %rax, %rax
je 0x38fd75
movl %r13d, %r9d
testl %ebx, %ebx
movq 0x48(%rsp), %r13
movq 0x80(%rsp), %r8
jle 0x38f5b4
movq 0x10(%r12), %rdi
movl 0x10(%rsp), %ecx
xorl %edx, %edx
movzbl (%r8,%rdx), %esi
movl (%rdi,%rsi,4), %esi
movl %esi, (%rax,%rdx,4)
incq %rdx
cmpq %rdx, %rcx
jne 0x38f5a1
movq 0x10(%rsp), %rbx
movslq %ebx, %rcx
leaq (%rax,%rcx,4), %rdi
leal 0x1(%rbx), %edx
cmpl %edx, %r9d
cmovgl %r9d, %edx
movl %ebx, %ecx
notl %ecx
addl %edx, %ecx
leaq 0x4(,%rcx,4), %rdx
xorl %esi, %esi
movq %rax, 0x20(%rsp)
callq 0x19e090
movq 0x20(%rsp), %rax
movq %rax, 0x20(%rsp)
movq 0x28(%rsp), %r8
leal 0x3(%r8), %r10d
leal -0x1(%rbx), %ecx
leal -0x1(%r8), %eax
incl %ebp
movl %ebp, 0x3c(%rsp)
movd %ebp, %xmm0
pshufd $0x0, %xmm0, %xmm0      # xmm0 = xmm0[0,0,0,0]
movdqa %xmm0, 0x70(%rsp)
movd %r14d, %xmm0
pshufd $0x0, %xmm0, %xmm0      # xmm0 = xmm0[0,0,0,0]
movdqa %xmm0, 0xa0(%rsp)
movl 0x40(%rsp), %r9d
movd %r9d, %xmm0
pshufd $0x0, %xmm0, %xmm0      # xmm0 = xmm0[0,0,0,0]
movdqa %xmm0, 0x120(%rsp)
movq 0x60(%rsp), %rsi
movd %esi, %xmm0
pshufd $0x0, %xmm0, %xmm0      # xmm0 = xmm0[0,0,0,0]
movdqa %xmm0, 0x110(%rsp)
pslld $0x2, %xmm0
movdqa %xmm0, 0xe0(%rsp)
movl %ecx, 0xc(%rsp)
movd %ecx, %xmm0
pshufd $0x0, %xmm0, %xmm0      # xmm0 = xmm0[0,0,0,0]
movdqa %xmm0, 0xd0(%rsp)
movl %eax, 0x6c(%rsp)
movd %eax, %xmm0
pshufd $0x0, %xmm0, %xmm0      # xmm0 = xmm0[0,0,0,0]
movdqa %xmm0, 0x100(%rsp)
movl 0x1c(%rsp), %edi
movl %edi, %eax
subl %esi, %eax
movl %edi, %edx
subl %esi, %edx
subl %esi, %edx
leal (%rsi,%rsi,2), %ecx
addl %r9d, %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, 0x80(%rsp)
movq 0x10(%r12), %rax
cmpl $0x2, %r8d
movl $0x1, %ebx
cmovgel %r8d, %ebx
xorl %ecx, %ecx
movq 0x30(%rsp), %rsi
movzbl (%rsi,%rcx), %edx
movl (%rax,%rdx,4), %edx
movl %edx, 0xc(%r15,%rcx,4)
incq %rcx
cmpq %rcx, %rbx
jne 0x38f6e3
movl $0x0, 0x8(%r15)
movq $0x0, (%r15)
movl %r8d, %r14d
leaq (%r15,%r14,4), %rdi
addq $0xc, %rdi
leal 0x1(%r8), %eax
cmpl %eax, %r10d
movl %r10d, 0x30(%rsp)
cmovgl %r10d, %eax
movl %r8d, %ecx
notl %ecx
addl %eax, %ecx
leaq 0x4(,%rcx,4), %rdx
xorl %ebp, %ebp
xorl %esi, %esi
callq 0x19e090
movl 0x1c(%rsp), %eax
movq 0x60(%rsp), %rcx
movl 0x3c(%rsp), %edx
movq 0x58(%rsp), %rsi
movq 0x50(%rsp), %rdi
movl %eax, 0xc(%rsi,%rbp,4)
movl %edx, 0xc(%rdi,%rbp,4)
incq %rbp
subl %ecx, %eax
cmpq %rbp, %rbx
jne 0x38f750
xorl %eax, %eax
movl %edx, (%rsi,%rax,4)
movl %edx, (%rdi,%rax,4)
incq %rax
cmpq $0x3, %rax
jne 0x38f764
leaq 0x3(%r14), %rax
movq 0x20(%rsp), %r10
movq 0x10(%rsp), %rcx
movq 0x28(%rsp), %r8
movl 0x30(%rsp), %r9d
movl %edx, (%rsi,%rax,4)
movl %edx, (%rdi,%rax,4)
incq %rax
incl %r8d
cmpl %r8d, %r9d
jg 0x38f78b
movl $0x0, 0x8(%rsi)
movdqa 0x70(%rsp), %xmm0
movdqa %xmm0, %xmm2
movdqa 0xa0(%rsp), %xmm3
testl %ecx, %ecx
jle 0x38fcb3
movdqa 0x70(%rsp), %xmm2
movdqa %xmm2, %xmm0
psrldq $0x4, %xmm0             # xmm0 = xmm0[4,5,6,7,8,9,10,11,12,13,14,15],zero,zero,zero,zero
movdqa %xmm0, 0xc0(%rsp)
cmpl $0x2, %r9d
movl $0x1, %eax
cmovgel %r9d, %eax
movq %rax, 0x30(%rsp)
movl %ecx, %ecx
leaq (,%r14,4), %rax
movq %rax, 0xb0(%rsp)
leaq -0x1(%r14), %rax
movq %rax, 0x28(%rsp)
leaq -0x3(%r14,%r14,2), %rax
movq %rax, 0x98(%rsp)
leaq -0x2(%r14,%r14), %rax
movq %rax, 0x90(%rsp)
movdqa 0x26617a(%rip), %xmm12  # 0x5f59a0
movq $0x0, 0x40(%rsp)
xorl %esi, %esi
movdqa 0xa0(%rsp), %xmm3
movdqa %xmm2, %xmm0
movl 0x30(%r12), %r8d
movl %esi, %edx
testl %r8d, %r8d
jne 0x38f84e
movl (%r10,%rsi,4), %edx
movq %rsi, %rax
orq $0x1, %rax
testl %r8d, %r8d
je 0x38f866
cmpq %rcx, %rax
movl 0xc(%rsp), %edi
cmovbl %eax, %edi
jmp 0x38f86a
movl (%r10,%rax,4), %edi
movq %rsi, %r11
orq $0x2, %r11
testl %r8d, %r8d
je 0x38f884
cmpq %rcx, %r11
movl 0xc(%rsp), %r9d
cmovbl %r11d, %r9d
jmp 0x38f888
movl (%r10,%r11,4), %r9d
movq %rsi, %r13
movq %rsi, %rbp
orq $0x3, %rbp
testl %r8d, %r8d
movq %rax, 0x10(%rsp)
je 0x38f8a8
cmpq %rcx, %rbp
movl 0xc(%rsp), %ebx
cmovbl %ebp, %ebx
jmp 0x38f8ac
movl (%r10,%rbp,4), %ebx
movq 0x8(%r12), %rax
movl 0x18(%r12), %esi
imull %esi, %edx
movslq %edx, %rdx
leaq (%rax,%rdx,4), %rdx
imull %esi, %edi
movslq %edi, %rdi
leaq (%rax,%rdi,4), %rdi
imull %esi, %r9d
movslq %r9d, %r8
leaq (%rax,%r8,4), %r8
imull %esi, %ebx
movslq %ebx, %rsi
leaq (%rax,%rsi,4), %rbx
leaq 0x4(%r13), %rax
movq %rax, 0xb8(%rsp)
movq 0x60(%rsp), %r9
imull %r9d, %eax
movl 0x1c(%rsp), %r10d
movl %r10d, %esi
subl %eax, %esi
movq 0x58(%rsp), %rax
movss 0x8(%rax), %xmm1
movl %esi, 0x8(%rax)
imull %r9d, %r13d
movq %rax, %r9
movl %r10d, %eax
subl %r13d, %eax
movd %eax, %xmm4
movaps 0xc0(%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]
movdqa %xmm12, 0xf0(%rsp)
pcmpeqd 0xd0(%rsp), %xmm12
xorl %esi, %esi
movdqa 0x266224(%rip), %xmm10  # 0x5f5b80
movaps 0x70(%rsp), %xmm5
movaps %xmm5, %xmm1
movq 0x50(%rsp), %r10
movss 0xc(%r9,%rsi,4), %xmm4
shufps $0xf4, %xmm9, %xmm4     # xmm4 = xmm4[0,1],xmm9[3,3]
movslq 0xc(%r15,%rsi,4), %rax
movslq 0x8(%r15,%rsi,4), %r9
movslq 0x4(%r15,%rsi,4), %r13
movslq (%r15,%rsi,4), %r12
movd (%rdx,%rax,4), %xmm7
movd (%rdi,%r9,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(%r10,%rsi,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 0x120(%rsp), %xmm6
psubd %xmm6, %xmm4
movdqa 0x110(%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 0x80(%rsp), %xmm9
pand %xmm13, %xmm9
por %xmm1, %xmm9
cmpq $0x4, %rsi
jb 0x38fac5
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 0x48(%rsp), %r13
movdqa %xmm13, %xmm1
pandn %xmm4, %xmm1
movdqa 0x70(%rsp), %xmm5
pand %xmm13, %xmm5
por %xmm5, %xmm1
pcmpeqd %xmm9, %xmm11
movdqa %xmm9, %xmm4
pcmpeqd %xmm1, %xmm4
movdqa 0x266448(%rip), %xmm6   # 0x5f5f40
psubd %xmm4, %xmm6
movdqa %xmm11, %xmm4
pandn %xmm6, %xmm4
pand 0x266082(%rip), %xmm11  # 0x5f5b90
por %xmm4, %xmm11
pand 0x2679f4(%rip), %xmm14  # 0x5f7510
pand 0x267a0b(%rip), %xmm8   # 0x5f7530
por %xmm14, %xmm8
por %xmm11, %xmm8
pxor 0x267bf8(%rip), %xmm8   # 0x5f7730
movq 0x10(%r13), %rax
movq (%rax), %r9
cmpq %r14, %rsi
jae 0x38fb57
pextrw $0x6, %xmm8, %eax
movq 0x40(%rsp), %r10
leaq (%r9,%r10), %r12
movb %al, (%rsi,%r12)
cmpq %rcx, 0x10(%rsp)
setae %al
leaq -0x1(%rsi), %r12
cmpq %r14, %r12
setae %r12b
orb %al, %r12b
jne 0x38fb82
pextrw $0x4, %xmm8, %eax
movq 0x28(%rsp), %r10
leaq (%r9,%r10), %r12
movb %al, (%rsi,%r12)
cmpq %rcx, %r11
jae 0x38fbb6
leaq -0x2(%rsi), %rax
cmpq $0x2, %rsi
setae %r12b
cmpq %r14, %rax
setl %al
andb %r12b, %al
cmpb $0x1, %al
jne 0x38fbb6
pextrw $0x2, %xmm8, %eax
movq 0x90(%rsp), %r10
leaq (%r9,%r10), %r12
movb %al, (%rsi,%r12)
cmpq %rcx, %rbp
jae 0x38fbe3
leaq -0x3(%rsi), %rax
cmpq $0x3, %rsi
setb %r12b
cmpq %r14, %rax
setge %al
orb %r12b, %al
jne 0x38fbe3
movd %xmm8, %eax
addq 0x98(%rsp), %r9
movb %al, (%rsi,%r9)
pandn %xmm7, %xmm13
por %xmm13, %xmm5
movq 0x58(%rsp), %r9
movd %xmm9, (%r9,%rsi,4)
movq 0x50(%rsp), %r10
movd %xmm1, (%r10,%rsi,4)
movdqa %xmm10, %xmm4
pcmpeqd 0x100(%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 %rsi
cmpq %rsi, 0x30(%rsp)
jne 0x38f969
movdqa 0xf0(%rsp), %xmm12
paddd 0x265f3b(%rip), %xmm12  # 0x5f5b90
movdqa 0x80(%rsp), %xmm1
psubd 0xe0(%rsp), %xmm1
movdqa %xmm1, 0x80(%rsp)
movq 0xb0(%rsp), %rax
addq %rax, 0x40(%rsp)
addq %rax, 0x28(%rsp)
addq %rax, 0x98(%rsp)
addq %rax, 0x90(%rsp)
movq 0xb8(%rsp), %rax
movq %rax, %rsi
cmpq %rcx, %rax
movq 0x170(%rsp), %r12
movq 0x20(%rsp), %r10
jb 0x38f83e
movl $0x4, %eax
movl 0x3c(%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 0x38fcbc
movdqa 0x70(%rsp), %xmm1
pcmpgtd %xmm3, %xmm1
pcmpgtd 0xa0(%rsp), %xmm0
por %xmm1, %xmm0
movmskps %xmm0, %eax
testl %eax, %eax
movq 0x50(%rsp), %rdi
movl 0x6c(%rsp), %eax
je 0x38fd0b
orb $0x40, 0xc(%r13)
xorl %edx, %edx
xorl %eax, %eax
movl $0x0, 0xc(%rsp)
movl %edx, (%r13)
movl 0xc(%rsp), %ecx
movl %ecx, 0x4(%r13)
movl %eax, 0x8(%r13)
callq 0x2094b5
movq 0x58(%rsp), %rdi
callq 0x2094b5
movq %r15, %rdi
callq 0x2094b5
cmpl $0x0, 0x30(%r12)
jne 0x38fd78
movq 0x20(%rsp), %rdi
callq 0x2094b5
jmp 0x38fd78
callq 0x1bde13
jmp 0x38fd75
callq 0x1bdded
jmp 0x38fd75
callq 0x1bddc7
jmp 0x38fd75
callq 0x1bdda1
jmp 0x38fd75
callq 0x1bdd7b
jmp 0x38fd75
callq 0x1bdd55
jmp 0x38fd75
callq 0x1bdd2f
xorl %r13d, %r13d
movq %r13, %rax
addq $0x138, %rsp            # imm = 0x138
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
nopl (%rax)