// File: /workspace/github_c_makefile_star2_O1/nh13[P]ksw/src/parasail/src/sw_diag_sse41_128_32.c
// Function: parasail_sw_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 vNegInf0;
    __m128i vOpen;
    __m128i vGap;
    __m128i vZero;
    __m128i vOne;
    __m128i vN;
    __m128i vNegOne;
    __m128i vI;
    __m128i vJreset;
    __m128i vMaxH;
    __m128i vEndI;
    __m128i vEndJ;
    __m128i vILimit;
    __m128i vJLimit;

    /* 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 = 0;
    end_ref = 0;
    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);
    vNegInf0 = _mm_srli_si128(vNegInf, 4); /* shift in a 0 */
    vOpen = _mm_set1_epi32(open);
    vGap  = _mm_set1_epi32(gap);
    vZero = _mm_set1_epi32(0);
    vOne = _mm_set1_epi32(1);
    vN = _mm_set1_epi32(N);
    vNegOne = _mm_set1_epi32(-1);
    vI = _mm_set_epi32(0,1,2,3);
    vJreset = _mm_set_epi32(0,-1,-2,-3);
    vMaxH = vNegInf;
    vEndI = vNegInf;
    vEndJ = vNegInf;
    vILimit = _mm_set1_epi32(s1Len);
    vJLimit = _mm_set1_epi32(s2Len);

    /* 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_SW | 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] = 0;
        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;
    }

    /* iterate over query sequence */
    for (i=0; i<s1Len; i+=N) {
        __m128i vNH = vNegInf0;
        __m128i vWH = vNegInf0;
        __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))];
        __m128i vIltLimit = _mm_cmplt_epi32(vI, vILimit);
        /* 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);
            vWH = _mm_max_epi32(vWH, vZero);
            /* as minor diagonal vector passes across the j=-1 boundary,
             * assign the appropriate boundary conditions */
            {
                __m128i cond = _mm_cmpeq_epi32(vJ,vNegOne);
                vWH = _mm_andnot_si128(cond, vWH);
                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
             * max values within the i,j bounds */
            {
                __m128i cond_valid_J = _mm_and_si128(
                        _mm_cmpgt_epi32(vJ, vNegOne),
                        _mm_cmplt_epi32(vJ, vJLimit));
                __m128i cond_valid_IJ = _mm_and_si128(cond_valid_J, vIltLimit);
                __m128i cond_eq = _mm_cmpeq_epi32(vWH, vMaxH);
                __m128i cond_max = _mm_cmpgt_epi32(vWH, vMaxH);
                __m128i cond_all = _mm_and_si128(cond_max, cond_valid_IJ);
                __m128i cond_Jlt = _mm_cmplt_epi32(vJ, vEndJ);
                vMaxH = _mm_blendv_epi8(vMaxH, vWH, cond_all);
                vEndI = _mm_blendv_epi8(vEndI, vI, cond_all);
                vEndJ = _mm_blendv_epi8(vEndJ, vJ, cond_all);
                cond_all = _mm_and_si128(cond_Jlt, cond_eq);
                cond_all = _mm_and_si128(cond_all, cond_valid_IJ);
                vEndI = _mm_blendv_epi8(vEndI, vI, cond_all);
                vEndJ = _mm_blendv_epi8(vEndJ, vJ, cond_all);
            }
            vJ = _mm_add_epi32(vJ, vOne);
        }
        vI = _mm_add_epi32(vI, vN);
    }

    /* alignment ending position */
    {
        int32_t *t = (int32_t*)&vMaxH;
        int32_t *i = (int32_t*)&vEndI;
        int32_t *j = (int32_t*)&vEndJ;
        int32_t k;
        for (k=0; k<N; ++k, ++t, ++i, ++j) {
            if (*t > score) {
                score = *t;
                end_query = *i;
                end_ref = *j;
            }
            else if (*t == score) {
                if (*j < end_ref) {
                    end_query = *i;
                    end_ref = *j;
                }
                else if (*j == end_ref && *i < end_query) {
                    end_query = *i;
                    end_ref = *j;
                }
            }
        }
    }

    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 0x42e46f
movl %ecx, %ebx
testl %ecx, %ecx
jle 0x42e476
testl %r8d, %r8d
js 0x42e47d
testl %r9d, %r9d
js 0x42e484
movq 0x170(%rsp), %r15
testq %r15, %r15
je 0x42e48b
movq %rdx, %r12
movl 0x30(%r15), %eax
testl %eax, %eax
jne 0x42dc76
testq %rdi, %rdi
je 0x42e492
movl %esi, %r14d
testl %esi, %esi
jle 0x42e499
testl %eax, %eax
je 0x42dc7a
movl 0x34(%r15), %r14d
movq %rdi, 0x28(%rsp)
movl %r9d, 0x40(%rsp)
movl %r8d, %eax
negl %eax
movl 0x20(%r15), %ecx
movl $0x80000000, %esi       # imm = 0x80000000
movl %r8d, 0x38(%rsp)
movl %r8d, %edx
orl %esi, %edx
subl %ecx, %esi
cmpl %eax, %ecx
cmovgl %edx, %esi
incl %esi
movl $0x7ffffffe, %ebp       # imm = 0x7FFFFFFE
subl 0x1c(%r15), %ebp
movl %esi, 0x1c(%rsp)
movd %esi, %xmm0
pshufd $0x0, %xmm0, %xmm0      # xmm0 = xmm0[0,0,0,0]
movdqa %xmm0, 0xb0(%rsp)
movdqa %xmm0, 0x70(%rsp)
movdqa %xmm0, 0x50(%rsp)
movdqa %xmm0, 0x80(%rsp)
movl %r14d, %edi
movl %ebx, %esi
callq 0x209630
testq %rax, %rax
je 0x42e49e
movq %rax, %r13
movq %r12, 0x60(%rsp)
movq %r14, 0x10(%rsp)
orl $0x4441004, 0xc(%rax)   # imm = 0x4441004
movq %rbx, 0x8(%rsp)
leal 0x6(%rbx), %r12d
movl $0x10, %edi
movq %r12, %rsi
callq 0x2094d5
movq %rax, %r14
movl $0x10, %edi
movq %r12, %rsi
callq 0x2094d5
movq %rax, %rbx
movl $0x10, %edi
movq %r12, %rsi
callq 0x2094d5
testq %r14, %r14
sete %dl
movq %rbx, 0x48(%rsp)
testq %rbx, %rbx
sete %cl
orb %dl, %cl
testq %rax, %rax
sete %dl
orb %cl, %dl
jne 0x42e49e
cmpl $0x0, 0x30(%r15)
movq %rax, 0x30(%rsp)
je 0x42dd73
movq $0x0, 0x20(%rsp)
movq 0x10(%rsp), %r12
jmp 0x42ddea
movq 0x10(%rsp), %r12
leal 0x3(%r12), %ebx
movslq %ebx, %rsi
movl $0x10, %edi
callq 0x2094d5
movq %rax, 0x20(%rsp)
testq %rax, %rax
je 0x42e49e
testl %r12d, %r12d
movq 0x20(%rsp), %rdi
movq 0x28(%rsp), %r8
jle 0x42ddc3
movq 0x10(%r15), %rax
movl %r12d, %ecx
xorl %edx, %edx
movzbl (%r8,%rdx), %esi
movl (%rax,%rsi,4), %esi
movl %esi, (%rdi,%rdx,4)
incq %rdx
cmpq %rdx, %rcx
jne 0x42ddb0
movslq %r12d, %rax
leaq (%rdi,%rax,4), %rdi
leal 0x1(%r12), %eax
cmpl %eax, %ebx
cmovgl %ebx, %eax
movl %r12d, %ecx
notl %ecx
addl %eax, %ecx
leaq 0x4(,%rcx,4), %rdx
xorl %esi, %esi
callq 0x19e090
movq %r13, 0x28(%rsp)
movq 0x8(%rsp), %rcx
leal 0x3(%rcx), %ebx
movd %ebp, %xmm0
pshufd $0x0, %xmm0, %xmm0      # xmm0 = xmm0[0,0,0,0]
movdqa %xmm0, 0x90(%rsp)
movdqa 0x50(%rsp), %xmm0
psrldq $0x4, %xmm0             # xmm0 = xmm0[4,5,6,7,8,9,10,11,12,13,14,15],zero,zero,zero,zero
movdqa %xmm0, 0xf0(%rsp)
movd 0x38(%rsp), %xmm0
pshufd $0x0, %xmm0, %xmm0      # xmm0 = xmm0[0,0,0,0]
movdqa %xmm0, 0x120(%rsp)
movd 0x40(%rsp), %xmm0
pshufd $0x0, %xmm0, %xmm0      # xmm0 = xmm0[0,0,0,0]
movdqa %xmm0, 0x110(%rsp)
movd %r12d, %xmm0
pshufd $0x0, %xmm0, %xmm0      # xmm0 = xmm0[0,0,0,0]
movdqa %xmm0, 0xe0(%rsp)
movd %ecx, %xmm0
pshufd $0x0, %xmm0, %xmm0      # xmm0 = xmm0[0,0,0,0]
movdqa %xmm0, 0x100(%rsp)
movq 0x10(%r15), %rax
cmpl $0x2, %ecx
movl $0x1, %r15d
cmovgel %ecx, %r15d
xorl %ecx, %ecx
movq 0x60(%rsp), %rsi
movzbl (%rsi,%rcx), %edx
movl (%rax,%rdx,4), %edx
movl %edx, 0xc(%r14,%rcx,4)
incq %rcx
cmpq %rcx, %r15
jne 0x42de82
movl $0x0, 0x8(%r14)
movq $0x0, (%r14)
movq 0x8(%rsp), %rcx
movl %ecx, %r13d
leaq 0xc(%r14,%r13,4), %rdi
leal 0x1(%rcx), %eax
cmpl %eax, %ebx
cmovgl %ebx, %eax
notl %ecx
addl %eax, %ecx
leaq 0x4(,%rcx,4), %rdx
xorl %r12d, %r12d
xorl %esi, %esi
callq 0x19e090
movl 0x1c(%rsp), %r8d
movq 0x48(%rsp), %rbp
movq 0x30(%rsp), %rdi
movl $0x0, 0xc(%rbp,%r12,4)
movl %r8d, 0xc(%rdi,%r12,4)
incq %r12
cmpq %r12, %r15
jne 0x42dedf
xorl %eax, %eax
movl %r8d, (%rbp,%rax,4)
movl %r8d, (%rdi,%rax,4)
incq %rax
cmpq $0x3, %rax
jne 0x42def7
leaq 0x3(%r13), %rax
movq 0x8(%rsp), %rcx
movq 0x170(%rsp), %r15
movq 0x10(%rsp), %rsi
movl %r8d, (%rbp,%rax,4)
movl %r8d, (%rdi,%rax,4)
incq %rax
incl %ecx
cmpl %ecx, %ebx
jg 0x42df1f
movaps 0x70(%rsp), %xmm5
testl %esi, %esi
jle 0x42e3ac
movq 0x8(%r15), %rax
movq %rax, 0xc0(%rsp)
movq 0x8(%rsp), %rax
decl %eax
movq %rax, 0x8(%rsp)
cmpl $0x2, %ebx
movl $0x1, %eax
cmovgel %ebx, %eax
movq %rax, 0xd8(%rsp)
leal -0x1(%rsi), %edx
movl %esi, %esi
leaq 0x1(%r13), %rax
movq %rax, 0xd0(%rsp)
leaq 0x2(%r13), %rax
movq %rax, 0xc8(%rsp)
pmovsxbd 0x1c9c1f(%rip), %xmm6   # 0x5f7bae
xorl %eax, %eax
pcmpeqd %xmm9, %xmm9
movaps 0x90(%rsp), %xmm0
movaps %xmm0, 0xa0(%rsp)
movdqa 0x50(%rsp), %xmm0
movdqa %xmm0, 0x60(%rsp)
movl 0x30(%r15), %r8d
movl %eax, %ecx
testl %r8d, %r8d
movq 0x20(%rsp), %r12
jne 0x42dfc6
movl (%r12,%rax,4), %ecx
movq %rax, %r10
orq $0x1, %r10
testl %r8d, %r8d
je 0x42dfdd
cmpq %rsi, %r10
movl %edx, %edi
cmovbl %r10d, %edi
jmp 0x42dfe1
movl (%r12,%r10,4), %edi
movq %rax, %r11
orq $0x2, %r11
testl %r8d, %r8d
je 0x42dff8
cmpq %rsi, %r11
movl %edx, %ebx
cmovbl %r11d, %ebx
jmp 0x42dffc
movl (%r12,%r11,4), %ebx
movq %rax, %r9
orq $0x3, %r9
testl %r8d, %r8d
je 0x42e014
cmpq %rsi, %r9
movl %edx, %r8d
cmovbl %r9d, %r8d
jmp 0x42e018
movl (%r12,%r9,4), %r8d
movl 0x18(%r15), %r15d
imull %r15d, %ecx
movslq %ecx, %rcx
movq 0xc0(%rsp), %r12
leaq (%r12,%rcx,4), %rcx
movq %rcx, 0x40(%rsp)
imull %r15d, %edi
movslq %edi, %rcx
leaq (%r12,%rcx,4), %rcx
movq %rcx, 0x38(%rsp)
imull %r15d, %ebx
movslq %ebx, %rcx
leaq (%r12,%rcx,4), %rcx
movq %rcx, 0x10(%rsp)
imull %r15d, %r8d
movslq %r8d, %rdi
leaq (%r12,%rdi,4), %rdi
movdqa 0xe0(%rsp), %xmm11
pcmpgtd %xmm6, %xmm11
xorl %r8d, %r8d
pmovsxbd 0x1c9b37(%rip), %xmm8   # 0x5f7bb2
movdqa 0x50(%rsp), %xmm7
movdqa %xmm7, %xmm13
movdqa 0xf0(%rsp), %xmm10
movdqa %xmm10, %xmm4
movq 0x30(%rsp), %rcx
cmpq %rdx, %rax
setne %r12b
movslq 0x8(%r14,%r8,4), %rbx
movslq 0x4(%r14,%r8,4), %r15
movslq (%r14,%r8,4), %rbp
movd (%rdi,%rbp,4), %xmm0
movq 0x10(%rsp), %rbp
pinsrd $0x1, (%rbp,%r15,4), %xmm0
movq 0x38(%rsp), %r15
pinsrd $0x2, (%r15,%rbx,4), %xmm0
movslq 0xc(%r14,%r8,4), %rbx
movq 0x40(%rsp), %r15
pinsrd $0x3, (%r15,%rbx,4), %xmm0
paddd %xmm10, %xmm0
pshufd $0xf9, %xmm4, %xmm10    # xmm10 = xmm4[1,2,3,3]
movq 0x48(%rsp), %rbx
pinsrd $0x3, 0xc(%rbx,%r8,4), %xmm10
pshufd $0xf9, %xmm13, %xmm13   # xmm13 = xmm13[1,2,3,3]
pinsrd $0x3, 0xc(%rcx,%r8,4), %xmm13
movdqa %xmm10, %xmm1
movdqa 0x120(%rsp), %xmm2
psubd %xmm2, %xmm1
movdqa 0x110(%rsp), %xmm3
psubd %xmm3, %xmm13
pmaxsd %xmm1, %xmm13
psubd %xmm2, %xmm4
psubd %xmm3, %xmm7
pmaxsd %xmm4, %xmm7
movdqa %xmm7, %xmm14
pmaxsd %xmm13, %xmm14
pmaxsd 0x16813f(%rip), %xmm14  # 0x596290
pmaxsd %xmm0, %xmm14
movdqa %xmm8, %xmm0
pcmpeqd %xmm9, %xmm0
movdqa %xmm0, %xmm4
pandn %xmm14, %xmm4
movaps 0x50(%rsp), %xmm1
blendvps %xmm0, %xmm1, %xmm13
blendvps %xmm0, %xmm1, %xmm7
cmpq $0x4, %r8
jb 0x42e1a8
movdqa 0xa0(%rsp), %xmm0
pminsd %xmm4, %xmm0
movdqa %xmm0, 0xa0(%rsp)
movdqa 0x60(%rsp), %xmm0
pmaxsd %xmm4, %xmm0
movdqa %xmm0, 0x60(%rsp)
movq 0x28(%rsp), %rbx
movq 0x10(%rbx), %r15
movq (%r15), %rbx
movq 0x8(%r15), %r15
cmpq %r13, %r8
setae %bpl
orb %bpl, %r12b
jne 0x42e1cc
pextrd $0x3, %xmm4, (%rbx,%r8,4)
cmpq %r8, 0x8(%rsp)
jne 0x42e1db
pextrd $0x3, %xmm4, (%r15,%rax,4)
cmpq %rdx, %r10
setne %bpl
leaq -0x1(%r8), %r12
cmpq %r13, %r12
setae %r12b
orb %bpl, %r12b
jne 0x42e1fb
pextrd $0x2, %xmm4, -0x4(%rbx,%r8,4)
cmpq %rsi, %r10
setae %bpl
cmpq %r8, %r13
setne %r12b
orb %bpl, %r12b
jne 0x42e216
pextrd $0x2, %xmm4, (%r15,%r10,4)
cmpq %rdx, %r11
jne 0x42e240
leaq -0x2(%r8), %r12
cmpq $0x2, %r8
setae %bpl
cmpq %r13, %r12
setl %r12b
andb %bpl, %r12b
cmpb $0x1, %r12b
jne 0x42e240
pextrd $0x1, %xmm4, -0x8(%rbx,%r8,4)
cmpq %rsi, %r11
setae %bpl
cmpq %r8, 0xd0(%rsp)
setne %r12b
orb %bpl, %r12b
jne 0x42e260
pextrd $0x1, %xmm4, (%r15,%r11,4)
cmpq %rdx, %r9
jne 0x42e284
leaq -0x3(%r8), %r12
cmpq $0x3, %r8
setb %bpl
cmpq %r13, %r12
setge %r12b
orb %bpl, %r12b
jne 0x42e284
movd %xmm4, -0xc(%rbx,%r8,4)
cmpq %rsi, %r9
setae %bl
cmpq %r8, 0xc8(%rsp)
setne %bpl
orb %bl, %bpl
jne 0x42e2a1
movd %xmm4, (%r15,%r9,4)
movq 0x48(%rsp), %rbp
movd %xmm4, (%rbp,%r8,4)
movq 0x30(%rsp), %rcx
movss %xmm13, (%rcx,%r8,4)
movdqa 0x100(%rsp), %xmm0
pcmpgtd %xmm8, %xmm0
pand %xmm11, %xmm0
movdqa %xmm8, %xmm12
psrad $0x1f, %xmm12
pandn %xmm0, %xmm12
movdqa 0xb0(%rsp), %xmm3
movdqa %xmm4, %xmm0
pcmpeqd %xmm3, %xmm0
movdqa %xmm4, %xmm15
pcmpgtd %xmm3, %xmm15
movdqa %xmm15, %xmm1
pand %xmm12, %xmm1
movdqa 0x80(%rsp), %xmm9
movdqa %xmm9, %xmm2
pcmpgtd %xmm8, %xmm2
pand %xmm0, %xmm2
movdqa %xmm1, %xmm0
blendvps %xmm0, %xmm14, %xmm3
movaps %xmm3, 0xb0(%rsp)
movdqa %xmm2, %xmm0
blendvps %xmm0, %xmm12, %xmm1
movaps %xmm1, %xmm0
blendvps %xmm0, %xmm6, %xmm5
por %xmm15, %xmm2
pand %xmm12, %xmm2
movdqa %xmm2, %xmm0
blendvps %xmm0, %xmm8, %xmm9
movaps %xmm9, 0x80(%rsp)
pcmpeqd %xmm9, %xmm9
psubd %xmm9, %xmm8
incq %r8
cmpq %r8, 0xd8(%rsp)
jne 0x42e09a
paddd 0x1c7814(%rip), %xmm6   # 0x5f5b90
addq $0x4, %rax
cmpq %rsi, %rax
movq 0x170(%rsp), %r15
jb 0x42dfb2
movl 0x1c(%rsp), %r8d
movq 0x30(%rsp), %rdi
movdqa 0x60(%rsp), %xmm1
movdqa 0xa0(%rsp), %xmm2
jmp 0x42e3bb
movdqa 0x50(%rsp), %xmm1
movdqa 0x90(%rsp), %xmm2
movaps %xmm5, 0x70(%rsp)
xorl %edx, %edx
xorl %eax, %eax
xorl %ecx, %ecx
movq 0x28(%rsp), %rbx
movl 0xb0(%rsp,%rdx,4), %esi
cmpl %r8d, %esi
jle 0x42e3e7
movl 0x70(%rsp,%rdx,4), %eax
movl 0x80(%rsp,%rdx,4), %ecx
movl %esi, %r8d
jmp 0x42e40d
jne 0x42e40d
movl 0x80(%rsp,%rdx,4), %esi
cmpl %ecx, %esi
jge 0x42e3fc
movl 0x70(%rsp,%rdx,4), %eax
movl %esi, %ecx
jmp 0x42e40d
jne 0x42e40d
movl 0x70(%rsp,%rdx,4), %r9d
cmpl %eax, %r9d
cmovll %esi, %ecx
cmovll %r9d, %eax
incq %rdx
cmpl $0x4, %edx
jne 0x42e3cb
movdqa 0x50(%rsp), %xmm0
pcmpgtd %xmm2, %xmm0
pcmpgtd 0x90(%rsp), %xmm1
por %xmm0, %xmm1
movmskps %xmm1, %edx
testl %edx, %edx
je 0x42e43e
orb $0x40, 0xc(%rbx)
xorl %r8d, %r8d
xorl %ecx, %ecx
xorl %eax, %eax
movl %r8d, (%rbx)
movl %eax, 0x4(%rbx)
movl %ecx, 0x8(%rbx)
callq 0x2094b5
movq %rbp, %rdi
callq 0x2094b5
movq %r14, %rdi
callq 0x2094b5
cmpl $0x0, 0x30(%r15)
jne 0x42e4a0
movq 0x20(%rsp), %rdi
callq 0x2094b5
jmp 0x42e4a0
callq 0x1d3267
jmp 0x42e49e
callq 0x1d3241
jmp 0x42e49e
callq 0x1d321b
jmp 0x42e49e
callq 0x1d31f5
jmp 0x42e49e
callq 0x1d31cf
jmp 0x42e49e
callq 0x1d31a9
jmp 0x42e49e
callq 0x1d3183
xorl %ebx, %ebx
movq %rbx, %rax
addq $0x138, %rsp            # imm = 0x138
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
nopl (%rax)