// File: /workspace/github_c_makefile_star2_O3/nh13[P]ksw/src/parasail/src/sw_diag_sse2_128_32.c
// Function: parasail_sw_rowcol_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 = 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_rpl(vNH, H_pr[j], 3);
            vF = _mm_srli_si128(vF, 4);
            vF = _mm_insert_epi32_rpl(vF, F_pr[j], 3);
            vF = _mm_max_epi32_rpl(
                    _mm_sub_epi32(vNH, vOpen),
                    _mm_sub_epi32(vF, vGap));
            vE = _mm_max_epi32_rpl(
                    _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_rpl(vNWH, vE);
            vWH = _mm_max_epi32_rpl(vWH, vF);
            vWH = _mm_max_epi32_rpl(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_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);
            }
#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_rpl(vWH,0);
            F_pr[j-3] = (int32_t)_mm_extract_epi32_rpl(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_rpl(vMaxH, vWH, cond_all);
                vEndI = _mm_blendv_epi8_rpl(vEndI, vI, cond_all);
                vEndJ = _mm_blendv_epi8_rpl(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_rpl(vEndI, vI, cond_all);
                vEndJ = _mm_blendv_epi8_rpl(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 $0x148, %rsp            # imm = 0x148
testq %rdx, %rdx
je 0x35acf4
movl %ecx, %r14d
testl %ecx, %ecx
jle 0x35acfb
movl %r8d, %r12d
testl %r8d, %r8d
js 0x35ad02
movl %r9d, %ebp
testl %r9d, %r9d
js 0x35ad09
movq 0x180(%rsp), %r13
testq %r13, %r13
je 0x35ad10
cmpl $0x0, 0x30(%r13)
je 0x35a42f
movl 0x34(%r13), %esi
jmp 0x35a440
testq %rdi, %rdi
je 0x35ad17
testl %esi, %esi
jle 0x35ad1e
movq %rdi, 0x50(%rsp)
movq %rdx, 0x58(%rsp)
movl %r12d, %eax
negl %eax
movl 0x20(%r13), %ecx
movl $0x80000000, %edi       # imm = 0x80000000
movl %r12d, %edx
orl %edi, %edx
subl %ecx, %edi
cmpl %eax, %ecx
cmovgl %edx, %edi
incl %edi
movl $0x7ffffffe, %ebx       # imm = 0x7FFFFFFE
subl 0x1c(%r13), %ebx
movl %edi, 0x1c(%rsp)
movd %edi, %xmm0
pshufd $0x0, %xmm0, %xmm0      # xmm0 = xmm0[0,0,0,0]
movdqa %xmm0, 0xd0(%rsp)
movdqa %xmm0, 0x80(%rsp)
movdqa %xmm0, 0x60(%rsp)
movdqa %xmm0, 0xa0(%rsp)
movq %rsi, 0x20(%rsp)
movl %esi, %edi
movl %r14d, %esi
callq 0x20ac53
testq %rax, %rax
je 0x35ad23
movq %rax, %r15
movl %r12d, 0x40(%rsp)
movl %ebp, 0x48(%rsp)
orl $0x4441004, 0xc(%rax)   # imm = 0x4441004
movq %r14, 0x8(%rsp)
leal 0x6(%r14), %r12d
movl $0x10, %edi
movq %r12, %rsi
callq 0x20a62d
movq %rax, %r14
movl $0x10, %edi
movq %r12, %rsi
callq 0x20a62d
movq %rax, %rbp
movl $0x10, %edi
movq %r12, %rsi
callq 0x20a62d
movq %rax, %r12
testq %r14, %r14
sete %al
movq %rbp, 0x10(%rsp)
testq %rbp, %rbp
sete %cl
orb %al, %cl
testq %r12, %r12
sete %al
orb %cl, %al
jne 0x35ad23
cmpl $0x0, 0x30(%r13)
je 0x35a53f
movq %r15, 0x38(%rsp)
xorl %eax, %eax
movq 0x10(%rsp), %r15
movq 0x20(%rsp), %rdx
jmp 0x35a5cd
movq 0x20(%rsp), %r13
leal 0x3(%r13), %ebp
movslq %ebp, %rsi
movl $0x10, %edi
callq 0x20a62d
testq %rax, %rax
je 0x35ad23
movq %rax, %rdi
movq %r15, 0x38(%rsp)
testl %r13d, %r13d
movq %r13, %r8
movq 0x50(%rsp), %r9
jle 0x35a597
movq 0x180(%rsp), %rax
movq 0x10(%rax), %rax
movl %r8d, %ecx
xorl %edx, %edx
movzbl (%r9,%rdx), %esi
movl (%rax,%rsi,4), %esi
movl %esi, (%rdi,%rdx,4)
incq %rdx
cmpq %rdx, %rcx
jne 0x35a584
movslq %r8d, %rax
movq %rdi, %r15
leaq (%rdi,%rax,4), %rdi
leal 0x1(%r8), %eax
cmpl %eax, %ebp
cmovgl %ebp, %eax
movl %r8d, %ecx
notl %ecx
addl %eax, %ecx
leaq 0x4(,%rcx,4), %rdx
xorl %esi, %esi
callq 0x19e090
movq 0x20(%rsp), %rdx
movq %r15, %rax
movq 0x10(%rsp), %r15
movq %rax, 0x78(%rsp)
movq 0x8(%rsp), %rcx
leal 0x3(%rcx), %ebp
movd %ebx, %xmm0
pshufd $0x0, %xmm0, %xmm0      # xmm0 = xmm0[0,0,0,0]
movdqa %xmm0, 0x90(%rsp)
movdqa 0x60(%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 0x40(%rsp), %xmm0
pshufd $0x0, %xmm0, %xmm0      # xmm0 = xmm0[0,0,0,0]
movdqa %xmm0, 0x120(%rsp)
movd 0x48(%rsp), %xmm0
pshufd $0x0, %xmm0, %xmm0      # xmm0 = xmm0[0,0,0,0]
movdqa %xmm0, 0x110(%rsp)
movd %edx, %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 0x180(%rsp), %rax
movq 0x10(%rax), %rax
movl %ecx, %r13d
xorl %ecx, %ecx
movq 0x58(%rsp), %rsi
movzbl (%rsi,%rcx), %edx
movl (%rax,%rdx,4), %edx
movl %edx, 0xc(%r14,%rcx,4)
incq %rcx
cmpq %rcx, %r13
jne 0x35a662
movl $0x0, 0x8(%r14)
movq $0x0, (%r14)
leaq (%r14,%r13,4), %rdi
addq $0xc, %rdi
movq 0x8(%rsp), %rcx
leal 0x1(%rcx), %eax
cmpl %eax, %ebp
cmovgl %ebp, %eax
notl %ecx
addl %eax, %ecx
leaq 0x4(,%rcx,4), %rdx
xorl %ebx, %ebx
xorl %esi, %esi
callq 0x19e090
movl 0x1c(%rsp), %edi
movl $0x0, 0xc(%r15,%rbx,4)
movl %edi, 0xc(%r12,%rbx,4)
incq %rbx
cmpq %rbx, %r13
jne 0x35a6b3
xorl %eax, %eax
movl %edi, (%r15,%rax,4)
movl %edi, (%r12,%rax,4)
incq %rax
cmpq $0x3, %rax
jne 0x35a6cb
leaq 0x3(%r13), %rax
movq 0x8(%rsp), %rcx
movq 0x20(%rsp), %rdx
movl %edi, (%r15,%rax,4)
movl %edi, (%r12,%rax,4)
incq %rax
incl %ecx
cmpl %ecx, %ebp
jg 0x35a6ea
movdqa 0x60(%rsp), %xmm0
movdqa %xmm0, %xmm10
movdqa 0x90(%rsp), %xmm1
testl %edx, %edx
jle 0x35ac2f
movq 0x180(%rsp), %rax
movq 0x8(%rax), %rax
movq %rax, 0xb0(%rsp)
leal -0x1(%rdx), %ecx
movq 0x8(%rsp), %rax
decl %eax
movq %rax, 0x8(%rsp)
cmpl $0x2, %ebp
movl $0x1, %eax
cmovgel %ebp, %eax
movq %rax, 0xc8(%rsp)
movl %edx, %esi
leaq 0x1(%r13), %rax
movq %rax, 0xc0(%rsp)
leaq 0x2(%r13), %rax
movq %rax, 0xb8(%rsp)
movaps 0x2cf302(%rip), %xmm0   # 0x629a70
movaps %xmm0, 0x20(%rsp)
xorl %edi, %edi
pcmpeqd %xmm14, %xmm14
movdqa 0x60(%rsp), %xmm10
movdqa %xmm10, %xmm7
movdqa %xmm10, %xmm9
movdqa 0x90(%rsp), %xmm1
movdqa %xmm10, %xmm0
movq %rdi, %r10
orq $0x3, %r10
movq 0x180(%rsp), %r11
cmpl $0x0, 0x30(%r11)
je 0x35a7d8
movq %rdi, %rdx
orq $0x1, %rdx
cmpq %rsi, %rdx
cmovael %ecx, %edx
movq %rdi, %rax
orq $0x2, %rax
cmpq %rsi, %rax
cmovael %ecx, %eax
cmpq %rsi, %r10
movl %r10d, %r8d
cmovael %ecx, %r8d
movl %edi, %r9d
jmp 0x35a7ef
movq 0x78(%rsp), %r8
movl (%r8,%rdi,4), %r9d
movl 0x4(%r8,%rdi,4), %edx
movl 0x8(%r8,%rdi,4), %eax
movl (%r8,%r10,4), %r8d
movl 0x18(%r11), %r11d
imull %r11d, %edx
movslq %edx, %rdx
movq 0xb0(%rsp), %rbx
leaq (%rbx,%rdx,4), %rdx
movq %rdx, 0x58(%rsp)
imull %r11d, %r9d
movslq %r9d, %rdx
leaq (%rbx,%rdx,4), %rdx
movq %rdx, 0x50(%rsp)
imull %r11d, %eax
cltq
leaq (%rbx,%rax,4), %rax
movq %rax, 0x48(%rsp)
imull %r11d, %r8d
movslq %r8d, %rax
leaq (%rbx,%rax,4), %rax
movq %rax, 0x40(%rsp)
movq %rdi, %r9
orq $0x1, %r9
movq %rdi, %rdx
orq $0x2, %rdx
movdqa 0xe0(%rsp), %xmm2
pcmpgtd 0x20(%rsp), %xmm2
movdqa %xmm2, 0x130(%rsp)
xorl %r8d, %r8d
movdqa 0x2cf4b5(%rip), %xmm4   # 0x629d20
movaps 0x60(%rsp), %xmm11
movaps %xmm11, %xmm12
movaps 0xf0(%rsp), %xmm3
movaps %xmm3, %xmm6
movslq 0xc(%r14,%r8,4), %rax
movslq 0x8(%r14,%r8,4), %r11
movslq 0x4(%r14,%r8,4), %r15
movslq (%r14,%r8,4), %rbx
movq %r12, %rbp
movq 0x50(%rsp), %r12
movd (%r12,%rax,4), %xmm8
movq %rbp, %r12
movq 0x58(%rsp), %rax
movd (%rax,%r11,4), %xmm13
punpckldq %xmm8, %xmm13   # xmm13 = xmm13[0],xmm8[0],xmm13[1],xmm8[1]
movq 0x48(%rsp), %rax
movd (%rax,%r15,4), %xmm8
movq 0x40(%rsp), %rax
movd (%rax,%rbx,4), %xmm15
punpckldq %xmm8, %xmm15   # xmm15 = xmm15[0],xmm8[0],xmm15[1],xmm8[1]
movq 0x10(%rsp), %rax
movss 0xc(%rax,%r8,4), %xmm8
shufps $0xf4, %xmm6, %xmm8     # xmm8 = xmm8[0,1],xmm6[3,3]
punpcklqdq %xmm13, %xmm15  # xmm15 = xmm15[0],xmm13[0]
paddd %xmm3, %xmm15
movaps %xmm6, %xmm3
shufps $0x29, %xmm8, %xmm3     # xmm3 = xmm3[1,2],xmm8[2,0]
movss 0xc(%rbp,%r8,4), %xmm8
shufps $0xf4, %xmm12, %xmm8    # xmm8 = xmm8[0,1],xmm12[3,3]
shufps $0x29, %xmm8, %xmm12    # xmm12 = xmm12[1,2],xmm8[2,0]
movaps %xmm3, %xmm13
movdqa 0x120(%rsp), %xmm2
psubd %xmm2, %xmm13
movdqa 0x110(%rsp), %xmm5
psubd %xmm5, %xmm12
movdqa %xmm13, %xmm8
pcmpgtd %xmm12, %xmm8
pand %xmm8, %xmm13
pandn %xmm12, %xmm8
por %xmm13, %xmm8
psubd %xmm2, %xmm6
psubd %xmm5, %xmm11
movdqa %xmm6, %xmm13
pcmpgtd %xmm11, %xmm13
pand %xmm13, %xmm6
pandn %xmm11, %xmm13
por %xmm6, %xmm13
movdqa %xmm15, %xmm11
pcmpgtd %xmm13, %xmm11
pand %xmm11, %xmm15
pandn %xmm13, %xmm11
por %xmm15, %xmm11
movdqa %xmm11, %xmm12
pcmpgtd %xmm8, %xmm12
pand %xmm12, %xmm11
pandn %xmm8, %xmm12
por %xmm11, %xmm12
movdqa %xmm12, %xmm15
pcmpgtd 0x2cf3c2(%rip), %xmm15  # 0x629d60
pand %xmm12, %xmm15
movdqa %xmm4, %xmm11
pcmpeqd %xmm14, %xmm11
movdqa %xmm11, %xmm6
pandn %xmm15, %xmm6
cmpq $0x4, %r8
jb 0x35a9f4
movdqa %xmm1, %xmm12
pcmpgtd %xmm6, %xmm12
movdqa %xmm6, %xmm14
pand %xmm12, %xmm14
pandn %xmm1, %xmm12
por %xmm14, %xmm12
movdqa %xmm0, %xmm1
pcmpgtd %xmm6, %xmm1
pand %xmm1, %xmm0
pandn %xmm6, %xmm1
por %xmm1, %xmm0
movdqa %xmm12, %xmm1
cmpq %rcx, %rdi
setne %bl
movq 0x38(%rsp), %rax
movq 0x10(%rax), %r11
movq (%r11), %rax
movq 0x8(%r11), %r11
cmpq %r13, %r8
setae %r15b
orb %bl, %r15b
pshufd $0xff, %xmm6, %xmm12    # xmm12 = xmm6[3,3,3,3]
jne 0x35aa22
movd %xmm12, (%rax,%r8,4)
cmpq %r8, 0x8(%rsp)
jne 0x35aa2f
movd %xmm12, (%r11,%rdi,4)
cmpq %rcx, %r9
setne %bl
leaq -0x1(%r8), %r15
cmpq %r13, %r15
setae %r15b
orb %bl, %r15b
pshufd $0xee, %xmm6, %xmm12    # xmm12 = xmm6[2,3,2,3]
jne 0x35aa52
movd %xmm12, -0x4(%rax,%r8,4)
cmpq %rsi, %r9
setae %bl
cmpq %r8, %r13
setne %r15b
orb %bl, %r15b
jne 0x35aa6a
movd %xmm12, (%r11,%r9,4)
cmpq %rcx, %rdx
jne 0x35aa96
leaq -0x2(%r8), %rbx
cmpq $0x2, %r8
setae %r15b
cmpq %r13, %rbx
setl %bl
andb %r15b, %bl
cmpb $0x1, %bl
jne 0x35aa96
pshufd $0x55, %xmm6, %xmm12    # xmm12 = xmm6[1,1,1,1]
movd %xmm12, -0x8(%rax,%r8,4)
cmpq %rsi, %rdx
setae %bl
cmpq %r8, 0xc0(%rsp)
setne %r15b
orb %bl, %r15b
jne 0x35aab9
pshufd $0x55, %xmm6, %xmm12    # xmm12 = xmm6[1,1,1,1]
movd %xmm12, (%r11,%rdx,4)
cmpq %rcx, %r10
setne %bl
cmpq $0x3, %r8
setb %r15b
orb %bl, %r15b
jne 0x35aad3
movd %xmm6, -0xc(%rax,%r8,4)
cmpq %rsi, %r10
setae %bl
cmpq %r8, 0xb8(%rsp)
setne %r15b
movd %xmm6, %eax
orb %bl, %r15b
jne 0x35aaf2
movl %eax, (%r11,%r10,4)
movdqa %xmm11, %xmm12
pandn %xmm8, %xmm12
movdqa 0x60(%rsp), %xmm8
pand %xmm11, %xmm8
por %xmm8, %xmm12
pandn %xmm13, %xmm11
por %xmm8, %xmm11
movdqa 0x100(%rsp), %xmm13
pcmpgtd %xmm4, %xmm13
pand 0x130(%rsp), %xmm13
movdqa %xmm4, %xmm8
psrad $0x1f, %xmm8
pandn %xmm13, %xmm8
movdqa %xmm6, %xmm14
pcmpeqd %xmm9, %xmm14
movdqa %xmm6, %xmm5
pcmpgtd %xmm9, %xmm5
movdqa %xmm7, %xmm13
pcmpgtd %xmm4, %xmm13
pand %xmm14, %xmm13
movdqa %xmm8, %xmm14
pand %xmm13, %xmm14
movdqa %xmm13, %xmm2
por %xmm5, %xmm13
pand %xmm8, %xmm5
pand %xmm5, %xmm15
pandn %xmm5, %xmm2
pandn %xmm9, %xmm5
movdqa %xmm15, %xmm9
por %xmm5, %xmm9
por %xmm14, %xmm2
movdqa 0x20(%rsp), %xmm5
pand %xmm2, %xmm5
pandn %xmm10, %xmm2
movdqa %xmm2, %xmm10
por %xmm5, %xmm10
pand %xmm8, %xmm13
movdqa %xmm4, %xmm2
pand %xmm13, %xmm2
pandn %xmm7, %xmm13
movdqa %xmm13, %xmm7
por %xmm2, %xmm7
movq 0x10(%rsp), %r11
movl %eax, (%r11,%r8,4)
movd %xmm12, (%r12,%r8,4)
pcmpeqd %xmm14, %xmm14
psubd %xmm14, %xmm4
incq %r8
cmpq %r8, 0xc8(%rsp)
jne 0x35a880
movdqa 0x20(%rsp), %xmm2
paddd 0x2ceeeb(%rip), %xmm2   # 0x629af0
movdqa %xmm2, 0x20(%rsp)
addq $0x4, %rdi
cmpq %rsi, %rdi
jb 0x35a799
movdqa %xmm9, 0xd0(%rsp)
movdqa %xmm7, 0xa0(%rsp)
movl 0x1c(%rsp), %edi
movdqa %xmm10, 0x80(%rsp)
xorl %edx, %edx
xorl %eax, %eax
xorl %ecx, %ecx
movq 0x38(%rsp), %rbx
movq 0x180(%rsp), %r15
movl 0xd0(%rsp,%rdx,4), %esi
cmpl %edi, %esi
jle 0x35ac69
movl 0x80(%rsp,%rdx,4), %eax
movl 0xa0(%rsp,%rdx,4), %ecx
movl %esi, %edi
jmp 0x35ac8f
jne 0x35ac8f
movl 0xa0(%rsp,%rdx,4), %esi
cmpl %ecx, %esi
jge 0x35ac81
movl 0x80(%rsp,%rdx,4), %eax
movl %esi, %ecx
jmp 0x35ac8f
jne 0x35ac8f
movl 0x80(%rsp,%rdx,4), %esi
cmpl %eax, %esi
cmovll %esi, %eax
incq %rdx
cmpl $0x4, %edx
jne 0x35ac4c
movdqa 0x60(%rsp), %xmm2
pcmpgtd %xmm1, %xmm2
pcmpgtd 0x90(%rsp), %xmm0
por %xmm2, %xmm0
movmskps %xmm0, %edx
testl %edx, %edx
je 0x35acbf
orb $0x40, 0xc(%rbx)
xorl %edi, %edi
xorl %ecx, %ecx
xorl %eax, %eax
movl %edi, (%rbx)
movl %eax, 0x4(%rbx)
movl %ecx, 0x8(%rbx)
movq %r12, %rdi
callq 0x20a60d
movq 0x10(%rsp), %rdi
callq 0x20a60d
movq %r14, %rdi
callq 0x20a60d
cmpl $0x0, 0x30(%r15)
jne 0x35ad25
movq 0x78(%rsp), %rdi
callq 0x20a60d
jmp 0x35ad25
callq 0x1b57ef
jmp 0x35ad23
callq 0x1b57c9
jmp 0x35ad23
callq 0x1b57a3
jmp 0x35ad23
callq 0x1b577d
jmp 0x35ad23
callq 0x1b5757
jmp 0x35ad23
callq 0x1b5731
jmp 0x35ad23
callq 0x1b570b
xorl %ebx, %ebx
movq %rbx, %rax
addq $0x148, %rsp            # imm = 0x148
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
nop