// File: /workspace/github_c_makefile_star2_O3/nh13[P]ksw/src/parasail/src/nw_diag_sse41_128_32.c
// Function: parasail_nw_rowcol_diag_sse41_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 = 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 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;

    /* 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);

    /* initialize result */
#ifdef PARASAIL_TABLE
    result = parasail_result_new_table1(s1Len, s2Len);
#else
#ifdef PARASAIL_ROWCOL
    result = parasail_result_new_rowcol1(s1Len, s2Len);
#else
    result = parasail_result_new();
#endif
#endif
    if (!result) return NULL;

    /* set known flags */
    result->flag |= PARASAIL_FLAG_NW | PARASAIL_FLAG_DIAG
        | PARASAIL_FLAG_BITS_32 | PARASAIL_FLAG_LANES_4;
#ifdef PARASAIL_TABLE
    result->flag |= PARASAIL_FLAG_TABLE;
#endif
#ifdef PARASAIL_ROWCOL
    result->flag |= PARASAIL_FLAG_ROWCOL;
#endif

    /* 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 vF = 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(vNH, H_pr[-1], 3);
        vWH = _mm_srli_si128(vWH, 4);
        vWH = _mm_insert_epi32(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(vNH, H_pr[j], 3);
            vF = _mm_srli_si128(vF, 4);
            vF = _mm_insert_epi32(vF, F_pr[j], 3);
            vF = _mm_max_epi32(
                    _mm_sub_epi32(vNH, vOpen),
                    _mm_sub_epi32(vF, vGap));
            vE = _mm_max_epi32(
                    _mm_sub_epi32(vWH, vOpen),
                    _mm_sub_epi32(vE, vGap));
            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(vNWH, vE);
            vWH = _mm_max_epi32(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(vWH, vIBoundary, cond);
                vF = _mm_blendv_epi8(vF, vNegInf, cond);
                vE = _mm_blendv_epi8(vE, vNegInf, cond);
            }
            /* cannot start checking sat until after J clears boundary */
            if (j > PAD) {
                vSaturationCheckMin = _mm_min_epi32(vSaturationCheckMin, vWH);
                vSaturationCheckMax = _mm_max_epi32(vSaturationCheckMax, vWH);
            }
#ifdef PARASAIL_TABLE
            arr_store_si128(result->tables->score_table, vWH, i, s1Len, j, s2Len);
#endif
#ifdef PARASAIL_ROWCOL
            arr_store_rowcol(result->rowcols->score_row, result->rowcols->score_col, vWH, i, s1Len, j, s2Len);
#endif
            H_pr[j-3] = (int32_t)_mm_extract_epi32(vWH,0);
            F_pr[j-3] = (int32_t)_mm_extract_epi32(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(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(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 $0x118, %rsp            # imm = 0x118
testq %rdx, %rdx
je 0x452711
movl %ecx, %ebp
testl %ecx, %ecx
jle 0x452718
movl %r8d, %r13d
testl %r8d, %r8d
js 0x45271f
movl %r9d, %r15d
testl %r9d, %r9d
js 0x452726
movq 0x150(%rsp), %r8
testq %r8, %r8
je 0x45272d
movq %rdx, %r12
cmpl $0x0, 0x30(%r8)
je 0x451f5d
movl 0x34(%r8), %esi
jmp 0x451f6e
testq %rdi, %rdi
je 0x452734
testl %esi, %esi
jle 0x45273b
movq %rdi, 0x60(%rsp)
movl %r13d, %edi
negl %edi
movl 0x20(%r8), %eax
movl $0x80000000, %edx       # imm = 0x80000000
movl %r13d, %ecx
orl %edx, %ecx
subl %eax, %edx
movl %edi, 0x14(%rsp)
cmpl %edi, %eax
cmovgl %ecx, %edx
movl %edx, 0x8(%rsp)
movl $0x7ffffffe, %r14d      # imm = 0x7FFFFFFE
subl 0x1c(%r8), %r14d
movq %rsi, 0x18(%rsp)
movl %esi, %edi
movl %ebp, %esi
callq 0x20ac53
testq %rax, %rax
je 0x452740
movq %rax, %rbx
movl %r13d, 0x50(%rsp)
movq %r12, 0x58(%rsp)
movq %r15, 0x40(%rsp)
orl $0x4441001, 0xc(%rax)   # imm = 0x4441001
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, %r12
movl $0x10, %edi
movq %r13, %rsi
callq 0x20a62d
testq %r15, %r15
sete %dl
movq %r12, 0x28(%rsp)
testq %r12, %r12
sete %cl
orb %dl, %cl
testq %rax, %rax
sete %dl
orb %cl, %dl
jne 0x452740
movq %rbx, 0x48(%rsp)
movq 0x150(%rsp), %r8
cmpl $0x0, 0x30(%r8)
movq %rax, 0x20(%rsp)
je 0x45204c
xorl %r12d, %r12d
movq 0x40(%rsp), %r13
movq 0x18(%rsp), %rax
jmp 0x4520d7
movq 0x18(%rsp), %rbx
leal 0x3(%rbx), %eax
movl %eax, 0x30(%rsp)
movslq %eax, %rsi
movl $0x10, %edi
callq 0x20a62d
testq %rax, %rax
movq 0x40(%rsp), %r13
je 0x452740
movq %rax, %r12
testl %ebx, %ebx
movq 0x60(%rsp), %rdi
jle 0x4520a2
movq 0x150(%rsp), %rax
movq 0x10(%rax), %rax
movl %ebx, %ecx
xorl %edx, %edx
movzbl (%rdi,%rdx), %esi
movl (%rax,%rsi,4), %esi
movl %esi, (%r12,%rdx,4)
incq %rdx
cmpq %rdx, %rcx
jne 0x45208f
movslq %ebx, %rax
leaq (%r12,%rax,4), %rdi
leal 0x1(%rbx), %eax
movl 0x30(%rsp), %ecx
cmpl %eax, %ecx
cmovgl %ecx, %eax
movl %ebx, %ecx
notl %ecx
addl %eax, %ecx
leaq 0x4(,%rcx,4), %rdx
xorl %esi, %esi
callq 0x19e090
movq 0x18(%rsp), %rax
movq 0x150(%rsp), %r8
movq %r12, 0x78(%rsp)
leal 0x3(%rbp), %ebx
leal -0x1(%rax), %edx
leal -0x1(%rbp), %ecx
movl 0x8(%rsp), %eax
incl %eax
movl %eax, 0x8(%rsp)
movd %eax, %xmm0
pshufd $0x0, %xmm0, %xmm0      # xmm0 = xmm0[0,0,0,0]
movdqa %xmm0, 0x30(%rsp)
movd %r14d, %xmm0
pshufd $0x0, %xmm0, %xmm0      # xmm0 = xmm0[0,0,0,0]
movdqa %xmm0, 0x80(%rsp)
movl 0x50(%rsp), %edi
movd %edi, %xmm0
pshufd $0x0, %xmm0, %xmm0      # xmm0 = xmm0[0,0,0,0]
movdqa %xmm0, 0x100(%rsp)
movd %r13d, %xmm0
pshufd $0x0, %xmm0, %xmm0      # xmm0 = xmm0[0,0,0,0]
movdqa %xmm0, 0xf0(%rsp)
pslld $0x2, %xmm0
movdqa %xmm0, 0xd0(%rsp)
movl %edx, 0xc(%rsp)
movd %edx, %xmm0
pshufd $0x0, %xmm0, %xmm0      # xmm0 = xmm0[0,0,0,0]
movdqa %xmm0, 0xc0(%rsp)
movl %ecx, 0x10(%rsp)
movd %ecx, %xmm0
movl 0x14(%rsp), %esi
movl %esi, %eax
subl %r13d, %eax
movl %esi, %edx
subl %r13d, %edx
subl %r13d, %edx
leal (%r13,%r13,2), %ecx
addl %edi, %ecx
negl %ecx
movd %ecx, %xmm1
pinsrd $0x1, %edx, %xmm1
pinsrd $0x2, %eax, %xmm1
pinsrd $0x3, %esi, %xmm1
movdqa %xmm1, 0x60(%rsp)
pshufd $0x0, %xmm0, %xmm0      # xmm0 = xmm0[0,0,0,0]
movdqa %xmm0, 0xe0(%rsp)
movq 0x10(%r8), %rax
movl %ebp, %r14d
xorl %ecx, %ecx
movq 0x58(%rsp), %rsi
movzbl (%rsi,%rcx), %edx
movl (%rax,%rdx,4), %edx
movl %edx, 0xc(%r15,%rcx,4)
incq %rcx
cmpq %rcx, %r14
jne 0x4521b8
movl $0x0, 0x8(%r15)
movq $0x0, (%r15)
leaq 0xc(%r15,%r14,4), %rdi
leal 0x1(%rbp), %eax
cmpl %eax, %ebx
cmovgl %ebx, %eax
movl %ebp, %ecx
notl %ecx
addl %eax, %ecx
leaq 0x4(,%rcx,4), %rdx
xorl %r12d, %r12d
xorl %esi, %esi
callq 0x19e090
movl 0x14(%rsp), %eax
movl 0x8(%rsp), %edx
movq 0x28(%rsp), %rcx
movq 0x20(%rsp), %rdi
movl %eax, 0xc(%rcx,%r12,4)
movl %edx, 0xc(%rdi,%r12,4)
incq %r12
subl %r13d, %eax
cmpq %r12, %r14
jne 0x452212
xorl %eax, %eax
movl %edx, (%rcx,%rax,4)
movl %edx, (%rdi,%rax,4)
incq %rax
cmpq $0x3, %rax
jne 0x452229
leaq 0x3(%r14), %rax
movq 0x150(%rsp), %r12
movq 0x18(%rsp), %rsi
movl %edx, (%rcx,%rax,4)
movl %edx, (%rdi,%rax,4)
incq %rax
incl %ebp
cmpl %ebp, %ebx
jg 0x452249
movl $0x0, 0x8(%rcx)
testl %esi, %esi
jle 0x452671
movq 0x8(%r12), %rax
movq %rax, 0x90(%rsp)
movdqa 0x30(%rsp), %xmm1
movdqa %xmm1, %xmm4
psrldq $0x4, %xmm4             # xmm4 = xmm4[4,5,6,7,8,9,10,11,12,13,14,15],zero,zero,zero,zero
movl 0x10(%rsp), %eax
movq %rax, 0xb8(%rsp)
cmpl $0x2, %ebx
movl $0x1, %eax
cmovgel %ebx, %eax
movq %rax, 0xb0(%rsp)
movl %esi, %esi
movl 0xc(%rsp), %edi
leaq 0x1(%r14), %rax
movq %rax, 0xa8(%rsp)
leaq 0x2(%r14), %rax
movq %rax, 0xa0(%rsp)
pmovsxbd 0x1d9c21(%rip), %xmm5   # 0x62beea
xorl %r8d, %r8d
pcmpeqd %xmm7, %xmm7
movdqa %xmm1, %xmm3
movdqa 0x80(%rsp), %xmm2
movdqa 0x100(%rsp), %xmm8
movdqa 0xf0(%rsp), %xmm6
movq %r8, %r11
orq $0x3, %r11
cmpl $0x0, 0x30(%r12)
je 0x45232f
movq %r8, %rax
orq $0x1, %rax
cmpq %rsi, %rax
movl 0xc(%rsp), %r9d
cmovael %r9d, %eax
movq %r8, %rcx
orq $0x2, %rcx
cmpq %rsi, %rcx
cmovael %r9d, %ecx
cmpq %rsi, %r11
movl %r11d, %edx
cmovael %r9d, %edx
movl %r8d, %r9d
jmp 0x452346
movq 0x78(%rsp), %rdx
movl (%rdx,%r8,4), %r9d
movl 0x4(%rdx,%r8,4), %eax
movl 0x8(%rdx,%r8,4), %ecx
movl (%rdx,%r11,4), %edx
movl 0x18(%r12), %r10d
imull %r10d, %eax
cltq
movq 0x90(%rsp), %rbx
leaq (%rbx,%rax,4), %rax
movq %rax, 0x18(%rsp)
imull %r10d, %r9d
movslq %r9d, %rax
leaq (%rbx,%rax,4), %rax
movq %rax, 0x58(%rsp)
imull %r10d, %ecx
movslq %ecx, %rcx
leaq (%rbx,%rcx,4), %rax
movq %rax, 0x50(%rsp)
imull %r10d, %edx
movslq %edx, %rcx
leaq (%rbx,%rcx,4), %rcx
leaq 0x4(%r8), %rax
movq %rax, 0x98(%rsp)
movl %eax, %edx
imull %r13d, %edx
movl 0x14(%rsp), %r10d
movl %r10d, %r9d
subl %edx, %r9d
movdqa %xmm4, %xmm9
movq 0x28(%rsp), %rax
pinsrd $0x3, 0x8(%rax), %xmm9
movl %r9d, 0x8(%rax)
movl %r8d, %edx
imull %r13d, %edx
movl %r10d, %r9d
subl %edx, %r9d
movdqa %xmm4, %xmm10
pinsrd $0x3, %r9d, %xmm10
movq %r8, %r10
orq $0x1, %r10
movq %r8, %rdx
orq $0x2, %rdx
movdqa %xmm5, %xmm11
pcmpeqd 0xc0(%rsp), %xmm11
xorl %r9d, %r9d
pmovsxbd 0x1d9aeb(%rip), %xmm12  # 0x62beee
movdqa 0x30(%rsp), %xmm14
movdqa %xmm14, %xmm13
movq 0x20(%rsp), %rbx
movdqa %xmm9, %xmm0
pshufd $0xf9, %xmm10, %xmm9    # xmm9 = xmm10[1,2,3,3]
pinsrd $0x3, 0xc(%rax,%r9,4), %xmm9
movslq 0xc(%r15,%r9,4), %r12
movslq 0x8(%r15,%r9,4), %r13
movslq 0x4(%r15,%r9,4), %rbp
movslq (%r15,%r9,4), %rax
movd (%rcx,%rax,4), %xmm15
movq 0x50(%rsp), %rax
pinsrd $0x1, (%rax,%rbp,4), %xmm15
movq 0x18(%rsp), %rax
pinsrd $0x2, (%rax,%r13,4), %xmm15
movq 0x58(%rsp), %rax
pinsrd $0x3, (%rax,%r12,4), %xmm15
paddd %xmm0, %xmm15
pshufd $0xf9, %xmm13, %xmm13   # xmm13 = xmm13[1,2,3,3]
pinsrd $0x3, 0xc(%rbx,%r9,4), %xmm13
cmpq %rdi, %r8
movdqa %xmm9, %xmm0
psubd %xmm8, %xmm0
psubd %xmm6, %xmm13
pmaxsd %xmm0, %xmm13
psubd %xmm8, %xmm10
psubd %xmm6, %xmm14
pmaxsd %xmm10, %xmm14
movdqa %xmm14, %xmm10
pmaxsd %xmm13, %xmm10
pmaxsd %xmm15, %xmm10
movdqa %xmm12, %xmm0
pcmpeqd %xmm7, %xmm0
blendvps %xmm0, 0x60(%rsp), %xmm10
setne %bpl
movaps 0x30(%rsp), %xmm15
blendvps %xmm0, %xmm15, %xmm13
blendvps %xmm0, %xmm15, %xmm14
cmpq $0x4, %r9
jb 0x4524ee
pminsd %xmm10, %xmm2
pmaxsd %xmm10, %xmm1
movq 0x48(%rsp), %rax
movq 0x10(%rax), %rax
movq (%rax), %r12
movq 0x8(%rax), %r13
cmpq %r14, %r9
setae %al
orb %al, %bpl
jne 0x452511
pextrd $0x3, %xmm10, (%r12,%r9,4)
cmpq %r9, 0xb8(%rsp)
jne 0x452524
pextrd $0x3, %xmm10, (%r13,%r8,4)
cmpq %rdi, %r10
setne %al
leaq -0x1(%r9), %rbp
cmpq %r14, %rbp
setae %bpl
orb %al, %bpl
jne 0x452543
pextrd $0x2, %xmm10, -0x4(%r12,%r9,4)
cmpq %rsi, %r10
setae %al
cmpq %r9, %r14
setne %bpl
orb %al, %bpl
jne 0x45255e
pextrd $0x2, %xmm10, (%r13,%r10,4)
cmpq %rdi, %rdx
jne 0x452585
leaq -0x2(%r9), %rax
cmpq $0x2, %r9
setae %bpl
cmpq %r14, %rax
setl %al
andb %bpl, %al
cmpb $0x1, %al
jne 0x452585
pextrd $0x1, %xmm10, -0x8(%r12,%r9,4)
cmpq %rsi, %rdx
setae %al
cmpq %r9, 0xa8(%rsp)
setne %bpl
orb %al, %bpl
jne 0x4525a5
pextrd $0x1, %xmm10, (%r13,%rdx,4)
cmpq %rdi, %r11
setne %al
cmpq $0x3, %r9
setb %bpl
orb %al, %bpl
jne 0x4525bf
movd %xmm10, -0xc(%r12,%r9,4)
cmpq %rsi, %r11
setae %al
cmpq %r9, 0xa0(%rsp)
setne %r12b
movd %xmm10, %ebp
orb %al, %r12b
jne 0x4525e0
movl %ebp, (%r13,%r11,4)
movq 0x28(%rsp), %rax
movl %ebp, (%rax,%r9,4)
movdqa %xmm12, %xmm0
pcmpeqd 0xe0(%rsp), %xmm0
pand %xmm11, %xmm0
blendvps %xmm0, %xmm10, %xmm3
movq 0x20(%rsp), %rbx
movss %xmm13, (%rbx,%r9,4)
psubd %xmm7, %xmm12
incq %r9
cmpq %r9, 0xb0(%rsp)
jne 0x452414
paddd 0x1d74c5(%rip), %xmm5   # 0x629af0
movdqa 0x60(%rsp), %xmm0
psubd 0xd0(%rsp), %xmm0
movdqa %xmm0, 0x60(%rsp)
movq 0x98(%rsp), %rax
movq %rax, %r8
cmpq %rsi, %rax
movq 0x150(%rsp), %r12
movq 0x40(%rsp), %r13
jb 0x4522f0
movq 0x48(%rsp), %rbx
movl 0x8(%rsp), %edx
movq 0x20(%rsp), %rdi
jmp 0x452689
movdqa 0x30(%rsp), %xmm3
movdqa %xmm3, %xmm1
movdqa 0x80(%rsp), %xmm2
movq 0x48(%rsp), %rbx
movl $0x4, %eax
pextrd $0x3, %xmm3, %ecx
cmpl %edx, %ecx
cmovgl %ecx, %edx
pslldq $0x4, %xmm3             # xmm3 = zero,zero,zero,zero,xmm3[0,1,2,3,4,5,6,7,8,9,10,11]
decl %eax
jne 0x45268e
movdqa 0x30(%rsp), %xmm0
pcmpgtd %xmm2, %xmm0
pcmpgtd 0x80(%rsp), %xmm1
por %xmm0, %xmm1
movmskps %xmm1, %eax
testl %eax, %eax
je 0x4526d6
orb $0x40, 0xc(%rbx)
xorl %edx, %edx
movl $0x0, 0x10(%rsp)
movl $0x0, 0xc(%rsp)
movl %edx, (%rbx)
movl 0xc(%rsp), %eax
movl %eax, 0x4(%rbx)
movl 0x10(%rsp), %eax
movl %eax, 0x8(%rbx)
callq 0x20a60d
movq 0x28(%rsp), %rdi
callq 0x20a60d
movq %r15, %rdi
callq 0x20a60d
cmpl $0x0, 0x30(%r12)
jne 0x452742
movq 0x78(%rsp), %rdi
callq 0x20a60d
jmp 0x452742
callq 0x1d3047
jmp 0x452740
callq 0x1d3021
jmp 0x452740
callq 0x1d2ffb
jmp 0x452740
callq 0x1d2fd5
jmp 0x452740
callq 0x1d2faf
jmp 0x452740
callq 0x1d2f89
jmp 0x452740
callq 0x1d2f63
xorl %ebx, %ebx
movq %rbx, %rax
addq $0x118, %rsp            # imm = 0x118
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
nop