// File: /workspace/github_c_makefile_star2_O3/nh13[P]ksw/src/parasail/src/sw_diag_sse2_128_64.c
// Function: parasail_sw_rowcol_diag_sse2_128_64
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;
    int64_t * restrict s1 = NULL;
    int64_t * restrict s2B = NULL;
    int64_t * restrict _H_pr = NULL;
    int64_t * restrict _F_pr = NULL;
    int64_t * restrict s2 = NULL;
    int64_t * restrict H_pr = NULL;
    int64_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;
    int64_t NEG_LIMIT = 0;
    int64_t POS_LIMIT = 0;
    int64_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 = 2; /* 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 ? INT64_MIN + open : INT64_MIN - matrix->min) + 1;
    POS_LIMIT = INT64_MAX - matrix->max - 1;
    score = NEG_LIMIT;
    vNegLimit = _mm_set1_epi64x_rpl(NEG_LIMIT);
    vPosLimit = _mm_set1_epi64x_rpl(POS_LIMIT);
    vSaturationCheckMin = vPosLimit;
    vSaturationCheckMax = vNegLimit;
    vNegInf = _mm_set1_epi64x_rpl(NEG_LIMIT);
    vNegInf0 = _mm_srli_si128(vNegInf, 8); /* shift in a 0 */
    vOpen = _mm_set1_epi64x_rpl(open);
    vGap  = _mm_set1_epi64x_rpl(gap);
    vZero = _mm_set1_epi64x_rpl(0);
    vOne = _mm_set1_epi64x_rpl(1);
    vN = _mm_set1_epi64x_rpl(N);
    vNegOne = _mm_set1_epi64x_rpl(-1);
    vI = _mm_set_epi64x_rpl(0,1);
    vJreset = _mm_set_epi64x_rpl(0,-1);
    vMaxH = vNegInf;
    vEndI = vNegInf;
    vEndJ = vNegInf;
    vILimit = _mm_set1_epi64x_rpl(s1Len);
    vJLimit = _mm_set1_epi64x_rpl(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_64 | PARASAIL_FLAG_LANES_2;
#ifdef PARASAIL_TABLE
    result->flag |= PARASAIL_FLAG_TABLE;
#endif
#ifdef PARASAIL_ROWCOL
    result->flag |= PARASAIL_FLAG_ROWCOL;
#endif

    /* initialize heap variables */
    s2B= parasail_memalign_int64_t(16, s2Len+PAD2);
    _H_pr = parasail_memalign_int64_t(16, s2Len+PAD2);
    _F_pr = parasail_memalign_int64_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_int64_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))];
        __m128i vIltLimit = _mm_cmplt_epi64_rpl(vI, vILimit);
        /* iterate over database sequence */
        for (j=0; j<s2Len+PAD; ++j) {
            __m128i vMat;
            __m128i vNWH = vNH;
            vNH = _mm_srli_si128(vWH, 8);
            vNH = _mm_insert_epi64_rpl(vNH, H_pr[j], 1);
            vF = _mm_srli_si128(vF, 8);
            vF = _mm_insert_epi64_rpl(vF, F_pr[j], 1);
            vF = _mm_max_epi64_rpl(
                    _mm_sub_epi64(vNH, vOpen),
                    _mm_sub_epi64(vF, vGap));
            vE = _mm_max_epi64_rpl(
                    _mm_sub_epi64(vWH, vOpen),
                    _mm_sub_epi64(vE, vGap));
            vMat = _mm_set_epi64x_rpl(
                    matrow0[s2[j-0]],
                    matrow1[s2[j-1]]
                    );
            vNWH = _mm_add_epi64(vNWH, vMat);
            vWH = _mm_max_epi64_rpl(vNWH, vE);
            vWH = _mm_max_epi64_rpl(vWH, vF);
            vWH = _mm_max_epi64_rpl(vWH, vZero);
            /* as minor diagonal vector passes across the j=-1 boundary,
             * assign the appropriate boundary conditions */
            {
                __m128i cond = _mm_cmpeq_epi64_rpl(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_epi64_rpl(vSaturationCheckMin, vWH);
                vSaturationCheckMax = _mm_max_epi64_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-1] = (int64_t)_mm_extract_epi64_rpl(vWH,0);
            F_pr[j-1] = (int64_t)_mm_extract_epi64_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_epi64_rpl(vJ, vNegOne),
                        _mm_cmplt_epi64_rpl(vJ, vJLimit));
                __m128i cond_valid_IJ = _mm_and_si128(cond_valid_J, vIltLimit);
                __m128i cond_eq = _mm_cmpeq_epi64_rpl(vWH, vMaxH);
                __m128i cond_max = _mm_cmpgt_epi64_rpl(vWH, vMaxH);
                __m128i cond_all = _mm_and_si128(cond_max, cond_valid_IJ);
                __m128i cond_Jlt = _mm_cmplt_epi64_rpl(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_epi64(vJ, vOne);
        }
        vI = _mm_add_epi64(vI, vN);
    }

    /* alignment ending position */
    {
        int64_t *t = (int64_t*)&vMaxH;
        int64_t *i = (int64_t*)&vEndI;
        int64_t *j = (int64_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_epi64_rpl(vSaturationCheckMin, vNegLimit),
            _mm_cmpgt_epi64_rpl(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 $0x128, %rsp            # imm = 0x128
testq %rdx, %rdx
je 0x358c8e
movl %ecx, %ebp
testl %ecx, %ecx
jle 0x358c95
testl %r8d, %r8d
js 0x358c9c
movl %r9d, %r15d
testl %r9d, %r9d
js 0x358ca3
movq 0x160(%rsp), %rbx
testq %rbx, %rbx
je 0x358caa
cmpl $0x0, 0x30(%rbx)
je 0x3582d1
movl 0x34(%rbx), %esi
jmp 0x3582e2
testq %rdi, %rdi
je 0x358cb1
testl %esi, %esi
jle 0x358cb8
movq %rdi, 0xa0(%rsp)
movq %rdx, 0x40(%rsp)
movslq 0x20(%rbx), %rax
movl %r8d, %r12d
negl %r8d
movq %r12, %rcx
btsq $0x3f, %rcx
movabsq $-0x8000000000000000, %r14 # imm = 0x8000000000000000
subq %rax, %r14
cmpl %r8d, %eax
cmovgq %rcx, %r14
leaq 0x1(%r14), %rax
movslq 0x1c(%rbx), %rcx
movq %rcx, 0x10(%rsp)
movq %rax, 0x28(%rsp)
movq %rax, %xmm0
pshufd $0x44, %xmm0, %xmm0     # xmm0 = xmm0[0,1,0,1]
movdqa %xmm0, 0xe0(%rsp)
movdqa %xmm0, 0x80(%rsp)
movdqa %xmm0, 0x50(%rsp)
movdqa %xmm0, 0xb0(%rsp)
movq %rsi, 0x60(%rsp)
movl %esi, %edi
movl %ebp, %esi
callq 0x20ac53
testq %rax, %rax
je 0x358cbd
movq %rax, %r13
movq %r12, 0x30(%rsp)
movl %r15d, 0x90(%rsp)
movq %r14, 0xc8(%rsp)
orl $0x2841004, 0xc(%rax)   # imm = 0x2841004
leal 0x2(%rbp), %r12d
movl $0x10, %edi
movq %r12, %rsi
callq 0x20a636
movq %rax, %r14
movl $0x10, %edi
movq %r12, %rsi
callq 0x20a636
movq %rax, %r15
movl $0x10, %edi
movq %r12, %rsi
callq 0x20a636
movq %rax, %r12
movq %r14, 0x8(%rsp)
testq %r14, %r14
sete %al
testq %r15, %r15
sete %cl
orb %al, %cl
testq %r12, %r12
sete %al
orb %cl, %al
jne 0x358cbd
movq 0x60(%rsp), %r10
movslq %r10d, %r9
cmpl $0x0, 0x30(%rbx)
movq %r9, 0x38(%rsp)
je 0x3583fe
xorl %eax, %eax
movq 0x28(%rsp), %rdi
movq 0x40(%rsp), %r11
jmp 0x35845d
leal 0x1(%r10), %eax
movslq %eax, %rsi
movl $0x10, %edi
movq %r10, %r14
callq 0x20a636
testq %rax, %rax
je 0x358cbd
testl %r14d, %r14d
movq 0x28(%rsp), %rdi
movq 0x38(%rsp), %r9
movq %r14, %r10
movq 0x40(%rsp), %r11
movq 0xa0(%rsp), %r8
jle 0x358455
movq 0x10(%rbx), %rsi
xorl %ecx, %ecx
movzbl (%r8,%rcx), %edx
movslq (%rsi,%rdx,4), %rdx
movq %rdx, (%rax,%rcx,8)
incq %rcx
cmpq %rcx, %r9
jne 0x358440
movq $0x0, (%rax,%r9,8)
movabsq $-0x8000000000000000, %rcx # imm = 0x8000000000000000
movq 0x10(%rsp), %rdx
subq %rdx, %rcx
addq $-0x2, %rcx
movq %rcx, %xmm0
movdqa %xmm0, 0xf0(%rsp)
pshufd $0x44, %xmm0, %xmm0     # xmm0 = xmm0[0,1,0,1]
movdqa %xmm0, 0x40(%rsp)
movdqa 0x50(%rsp), %xmm0
psrldq $0x8, %xmm0             # xmm0 = xmm0[8,9,10,11,12,13,14,15],zero,zero,zero,zero,zero,zero,zero,zero
movdqa %xmm0, 0x100(%rsp)
movq 0x30(%rsp), %xmm0
pshufd $0x44, %xmm0, %xmm0     # xmm0 = xmm0[0,1,0,1]
movdqa %xmm0, 0xa0(%rsp)
movd 0x90(%rsp), %xmm0
pshufd $0x44, %xmm0, %xmm0     # xmm0 = xmm0[0,1,0,1]
movdqa %xmm0, 0x90(%rsp)
movl %ebp, %r14d
movq 0x10(%rbx), %rcx
xorl %edx, %edx
movq 0x8(%rsp), %r8
movzbl (%r11,%rdx), %esi
movslq (%rcx,%rsi,4), %rsi
movq %rsi, 0x8(%r8,%rdx,8)
incq %rdx
cmpq %rdx, %r14
jne 0x3584d9
xorl %ecx, %ecx
movq %rcx, (%r8)
movq %rcx, 0x8(%r8,%r14,8)
movq $0x0, 0x8(%r15,%rcx,8)
movq %rdi, 0x8(%r12,%rcx,8)
incq %rcx
cmpq %rcx, %r14
jne 0x3584f9
movq %rdi, (%r15)
movq %rdi, (%r12)
movq %rdi, 0x8(%r15,%r14,8)
movq %rdi, 0x8(%r12,%r14,8)
testl %r10d, %r10d
movq %rax, 0x78(%rsp)
jle 0x358b00
movq 0x8(%rbx), %rax
movq %rax, 0xd0(%rsp)
leal -0x1(%r10), %edx
leal -0x1(%rbp), %eax
movq %rax, 0xd8(%rsp)
incl %ebp
movq %rbp, 0x30(%rsp)
movd %r10d, %xmm0
pshufd $0x50, %xmm0, %xmm1     # xmm1 = xmm0[0,0,1,1]
pxor %xmm0, %xmm0
punpckldq %xmm0, %xmm1    # xmm1 = xmm1[0],xmm0[0],xmm1[1],xmm0[1]
movd 0x2d1776(%rip), %xmm0   # 0x629ce0
movdqa %xmm0, 0x60(%rsp)
xorl %edi, %edi
movdqa 0x2d1415(%rip), %xmm9   # 0x629990
pxor %xmm9, %xmm1
movdqa %xmm1, 0x110(%rsp)
movdqa 0x50(%rsp), %xmm13
movdqa %xmm13, 0x10(%rsp)
movdqa %xmm13, %xmm10
movdqa %xmm13, %xmm14
movq 0x8(%rsp), %rax
cmpl $0x0, 0x30(%rbx)
je 0x3585c1
movq %rdi, %rcx
orq $0x1, %rcx
cmpq %r9, %rcx
cmovgel %edx, %ecx
movslq %ecx, %rcx
movq %rdi, %r8
jmp 0x3585d4
movq 0x78(%rsp), %rax
movq (%rax,%rdi,8), %r8
movq 0x8(%rax,%rdi,8), %rcx
movq 0x8(%rsp), %rax
movslq 0x18(%rbx), %r9
imulq %r9, %r8
movq 0xd0(%rsp), %rsi
leaq (%rsi,%r8,4), %r8
imulq %r9, %rcx
leaq (%rsi,%rcx,4), %r9
movq %rdi, %r10
orq $0x1, %r10
xorl %r11d, %r11d
movq 0x2d16e5(%rip), %xmm15  # 0x629ce8
movdqa 0x50(%rsp), %xmm8
movdqa %xmm8, %xmm1
movdqa 0x100(%rsp), %xmm3
movdqa %xmm3, %xmm0
pcmpeqd %xmm7, %xmm7
movq (%rax,%r11,8), %rcx
movq 0x8(%rax,%r11,8), %rbx
movslq (%r8,%rbx,4), %rbx
movslq (%r9,%rcx,4), %rcx
movq %rbx, %xmm4
movq %rcx, %xmm5
punpcklqdq %xmm4, %xmm5    # xmm5 = xmm5[0],xmm4[0]
paddq %xmm3, %xmm5
pshufd $0xee, %xmm0, %xmm3     # xmm3 = xmm0[2,3,2,3]
movq 0x8(%r15,%r11,8), %xmm4
punpcklqdq %xmm4, %xmm3    # xmm3 = xmm3[0],xmm4[0]
pshufd $0xee, %xmm1, %xmm1     # xmm1 = xmm1[2,3,2,3]
movq 0x8(%r12,%r11,8), %xmm4
punpcklqdq %xmm4, %xmm1    # xmm1 = xmm1[0],xmm4[0]
movdqa %xmm3, %xmm4
movdqa 0xa0(%rsp), %xmm2
psubq %xmm2, %xmm4
movdqa 0x90(%rsp), %xmm6
psubq %xmm6, %xmm1
psubq %xmm2, %xmm0
psubq %xmm6, %xmm8
movdqa %xmm1, %xmm11
pxor %xmm9, %xmm11
movdqa %xmm4, %xmm12
pxor %xmm9, %xmm12
movdqa %xmm12, %xmm6
pcmpgtd %xmm11, %xmm6
pshufd $0xa0, %xmm6, %xmm2     # xmm2 = xmm6[0,0,2,2]
pcmpeqd %xmm11, %xmm12
pshufd $0xf5, %xmm12, %xmm12   # xmm12 = xmm12[1,1,3,3]
pand %xmm2, %xmm12
pshufd $0xf5, %xmm6, %xmm11    # xmm11 = xmm6[1,1,3,3]
por %xmm12, %xmm11
pand %xmm11, %xmm4
pandn %xmm1, %xmm11
por %xmm4, %xmm11
movdqa %xmm8, %xmm1
pxor %xmm9, %xmm1
movdqa %xmm0, %xmm2
pxor %xmm9, %xmm2
movdqa %xmm2, %xmm4
pcmpgtd %xmm1, %xmm4
pshufd $0xa0, %xmm4, %xmm6     # xmm6 = xmm4[0,0,2,2]
pcmpeqd %xmm1, %xmm2
pshufd $0xf5, %xmm2, %xmm1     # xmm1 = xmm2[1,1,3,3]
pand %xmm6, %xmm1
pshufd $0xf5, %xmm4, %xmm4     # xmm4 = xmm4[1,1,3,3]
por %xmm1, %xmm4
pand %xmm4, %xmm0
pandn %xmm8, %xmm4
por %xmm0, %xmm4
movdqa %xmm4, %xmm0
pxor %xmm9, %xmm0
movdqa %xmm5, %xmm1
pxor %xmm9, %xmm1
movdqa %xmm1, %xmm2
pcmpgtd %xmm0, %xmm2
pshufd $0xa0, %xmm2, %xmm6     # xmm6 = xmm2[0,0,2,2]
pcmpeqd %xmm0, %xmm1
pshufd $0xf5, %xmm1, %xmm0     # xmm0 = xmm1[1,1,3,3]
pand %xmm6, %xmm0
pshufd $0xf5, %xmm2, %xmm1     # xmm1 = xmm2[1,1,3,3]
por %xmm0, %xmm1
pand %xmm1, %xmm5
pandn %xmm4, %xmm1
por %xmm5, %xmm1
movdqa %xmm1, %xmm0
pxor %xmm9, %xmm0
movdqa %xmm11, %xmm2
pxor %xmm9, %xmm2
movdqa %xmm0, %xmm5
pcmpgtd %xmm2, %xmm5
pshufd $0xa0, %xmm5, %xmm6     # xmm6 = xmm5[0,0,2,2]
pcmpeqd %xmm0, %xmm2
pshufd $0xf5, %xmm2, %xmm0     # xmm0 = xmm2[1,1,3,3]
pand %xmm6, %xmm0
pshufd $0xf5, %xmm5, %xmm2     # xmm2 = xmm5[1,1,3,3]
por %xmm0, %xmm2
pand %xmm2, %xmm1
pandn %xmm11, %xmm2
por %xmm1, %xmm2
movdqa %xmm2, %xmm0
pxor %xmm9, %xmm0
movdqa %xmm0, %xmm1
pcmpgtd %xmm9, %xmm1
pshufd $0xa0, %xmm1, %xmm5     # xmm5 = xmm1[0,0,2,2]
pcmpeqd %xmm9, %xmm0
pshufd $0xf5, %xmm0, %xmm0     # xmm0 = xmm0[1,1,3,3]
pand %xmm5, %xmm0
pshufd $0xf5, %xmm1, %xmm1     # xmm1 = xmm1[1,1,3,3]
por %xmm0, %xmm1
pand %xmm2, %xmm1
movdqa %xmm15, %xmm0
pcmpeqd %xmm7, %xmm0
pshufd $0xb1, %xmm0, %xmm12    # xmm12 = xmm0[1,0,3,2]
pand %xmm0, %xmm12
movdqa %xmm12, %xmm0
pandn %xmm1, %xmm0
movdqa %xmm0, %xmm5
pxor %xmm9, %xmm5
cmpq $0x2, %r11
jb 0x358892
movdqa 0x40(%rsp), %xmm8
movdqa %xmm8, %xmm1
pxor %xmm9, %xmm1
movdqa %xmm5, %xmm2
pcmpgtd %xmm1, %xmm2
pshufd $0xa0, %xmm2, %xmm6     # xmm6 = xmm2[0,0,2,2]
pcmpeqd %xmm5, %xmm1
pshufd $0xf5, %xmm1, %xmm1     # xmm1 = xmm1[1,1,3,3]
pand %xmm6, %xmm1
pshufd $0xf5, %xmm2, %xmm2     # xmm2 = xmm2[1,1,3,3]
por %xmm1, %xmm2
pand %xmm2, %xmm8
pandn %xmm0, %xmm2
por %xmm2, %xmm8
movdqa %xmm8, 0x40(%rsp)
movdqa 0x10(%rsp), %xmm8
movdqa %xmm8, %xmm1
pxor %xmm9, %xmm1
movdqa %xmm1, %xmm2
pcmpgtd %xmm5, %xmm2
pshufd $0xa0, %xmm2, %xmm6     # xmm6 = xmm2[0,0,2,2]
pcmpeqd %xmm5, %xmm1
pshufd $0xf5, %xmm1, %xmm1     # xmm1 = xmm1[1,1,3,3]
pand %xmm6, %xmm1
pshufd $0xf5, %xmm2, %xmm2     # xmm2 = xmm2[1,1,3,3]
por %xmm1, %xmm2
pand %xmm2, %xmm8
pandn %xmm0, %xmm2
por %xmm2, %xmm8
movdqa %xmm8, 0x10(%rsp)
cmpq %rdx, %rdi
setne %bpl
movq %r13, %rsi
movq 0x10(%r13), %rcx
movq (%rcx), %rbx
movq 0x8(%rcx), %rcx
cmpq %r14, %r11
setae %r13b
orb %bpl, %r13b
pshufd $0xee, %xmm0, %xmm1     # xmm1 = xmm0[2,3,2,3]
jne 0x3588be
movd %xmm1, (%rbx,%r11,4)
cmpq %r11, 0xd8(%rsp)
jne 0x3588cd
movd %xmm1, (%rcx,%rdi,4)
cmpq %rdx, %r10
setne %bpl
testq %r11, %r11
sete %r13b
orb %bpl, %r13b
jne 0x3588e7
movd %xmm0, -0x4(%rbx,%r11,4)
movdqa %xmm12, %xmm1
pandn %xmm11, %xmm1
movdqa 0x50(%rsp), %xmm8
pand %xmm12, %xmm8
por %xmm8, %xmm1
pandn %xmm4, %xmm12
cmpq 0x38(%rsp), %r10
setge %bl
cmpq %r11, %r14
setne %bpl
orb %bl, %bpl
jne 0x358921
movd %xmm0, (%rcx,%r10,4)
por %xmm12, %xmm8
movdqa 0x60(%rsp), %xmm7
movdqa %xmm7, %xmm2
pxor %xmm9, %xmm2
movdqa 0x110(%rsp), %xmm11
movdqa %xmm11, %xmm4
pcmpgtd %xmm2, %xmm4
pshufd $0xa0, %xmm4, %xmm6     # xmm6 = xmm4[0,0,2,2]
pcmpeqd %xmm11, %xmm2
pshufd $0xf5, %xmm2, %xmm2     # xmm2 = xmm2[1,1,3,3]
pand %xmm6, %xmm2
pshufd $0xf5, %xmm4, %xmm4     # xmm4 = xmm4[1,1,3,3]
por %xmm2, %xmm4
movq %xmm15, %rcx
xorl %ebx, %ebx
cmpq %r14, %rcx
setl %bl
negq %rbx
pshufd $0xee, %xmm15, %xmm2    # xmm2 = xmm15[2,3,2,3]
movq %xmm2, %rcx
xorl %r13d, %r13d
cmpq %r14, %rcx
setl %r13b
negq %r13
movq %rbx, %xmm2
movq %r13, %xmm6
punpcklqdq %xmm6, %xmm2    # xmm2 = xmm2[0],xmm6[0]
pand %xmm4, %xmm2
pshufd $0xf5, %xmm15, %xmm4    # xmm4 = xmm15[1,1,3,3]
pcmpeqd %xmm6, %xmm6
pcmpgtd %xmm6, %xmm4
pand %xmm2, %xmm4
movdqa %xmm10, %xmm2
pxor %xmm9, %xmm2
movdqa %xmm5, %xmm6
pcmpgtd %xmm2, %xmm6
pshufd $0xa0, %xmm6, %xmm11    # xmm11 = xmm6[0,0,2,2]
pcmpeqd %xmm5, %xmm2
pshufd $0xf5, %xmm2, %xmm2     # xmm2 = xmm2[1,1,3,3]
pand %xmm11, %xmm2
pshufd $0xf5, %xmm6, %xmm5     # xmm5 = xmm6[1,1,3,3]
por %xmm2, %xmm5
pand %xmm4, %xmm5
movdqa %xmm15, %xmm11
pxor %xmm9, %xmm11
movdqa %xmm5, %xmm2
pandn %xmm14, %xmm2
pxor %xmm9, %xmm14
movdqa %xmm14, %xmm6
pcmpgtd %xmm11, %xmm6
pcmpeqd %xmm11, %xmm14
pshufd $0xa0, %xmm6, %xmm11    # xmm11 = xmm6[0,0,2,2]
pshufd $0xf5, %xmm14, %xmm12   # xmm12 = xmm14[1,1,3,3]
pand %xmm11, %xmm12
movdqa %xmm0, %xmm11
pcmpeqd %xmm10, %xmm11
pshufd $0xf5, %xmm6, %xmm14    # xmm14 = xmm6[1,1,3,3]
por %xmm12, %xmm14
movdqa %xmm5, %xmm6
pandn %xmm10, %xmm6
movdqa %xmm5, %xmm10
pand %xmm0, %xmm10
por %xmm6, %xmm10
movdqa %xmm5, %xmm6
pandn %xmm13, %xmm6
movdqa %xmm5, %xmm12
pand %xmm7, %xmm12
por %xmm6, %xmm12
pand %xmm15, %xmm5
por %xmm2, %xmm5
pand %xmm11, %xmm14
pshufd $0xb1, %xmm11, %xmm2    # xmm2 = xmm11[1,0,3,2]
pand %xmm2, %xmm14
pand %xmm4, %xmm14
movdqa %xmm14, %xmm2
pandn %xmm12, %xmm2
movdqa %xmm14, %xmm13
pand %xmm7, %xmm13
pcmpeqd %xmm7, %xmm7
por %xmm2, %xmm13
movdqa %xmm14, %xmm2
pandn %xmm5, %xmm2
pand %xmm15, %xmm14
por %xmm2, %xmm14
movq %xmm0, (%r15,%r11,8)
movq %xmm1, (%r12,%r11,8)
psubq %xmm7, %xmm15
incq %r11
cmpq %r11, 0x30(%rsp)
movq %rsi, %r13
jne 0x358620
movdqa 0x60(%rsp), %xmm0
paddq 0x2d0412(%rip), %xmm0   # 0x628ef0
movdqa %xmm0, 0x60(%rsp)
addq $0x2, %rdi
movq 0x38(%rsp), %r9
cmpq %r9, %rdi
movq 0x160(%rsp), %rbx
jl 0x3585a6
jmp 0x358b1b
movdqa 0x50(%rsp), %xmm0
movdqa %xmm0, %xmm13
movdqa %xmm0, %xmm14
movdqa %xmm0, %xmm10
movdqa %xmm0, 0x10(%rsp)
movdqa %xmm10, 0xe0(%rsp)
movdqa %xmm14, 0xb0(%rsp)
movdqa %xmm13, 0x80(%rsp)
xorl %edx, %edx
movb $0x1, %sil
xorl %eax, %eax
xorl %ecx, %ecx
movq 0x28(%rsp), %r8
movq 0xc8(%rsp), %r11
movq 0xe0(%rsp,%rdx), %rdi
cmpq %r8, %rdi
jle 0x358b6f
movl 0x80(%rsp,%rdx), %eax
movl 0xb0(%rsp,%rdx), %ecx
movq %rdi, %r8
jmp 0x358ba9
jne 0x358ba9
movq %r8, %r10
movq 0xb0(%rsp,%rdx), %rdi
movslq %ecx, %r8
cmpq %r8, %rdi
jge 0x358b8f
movl 0x80(%rsp,%rdx), %eax
movl %edi, %ecx
jmp 0x358ba6
jne 0x358ba6
movq 0x80(%rsp,%rdx), %r8
movslq %eax, %r9
cmpq %r9, %r8
jge 0x358ba6
movl %edi, %ecx
movl %r8d, %eax
movq %r10, %r8
addq $0x8, %rdx
testb $0x1, %sil
movl $0x0, %esi
jne 0x358b4f
movq %r11, %xmm0
pshufd $0x44, %xmm0, %xmm0     # xmm0 = xmm0[0,1,0,1]
movdqa 0x2d0dc6(%rip), %xmm1   # 0x629990
movdqa 0x40(%rsp), %xmm4
pxor %xmm1, %xmm4
pxor %xmm1, %xmm0
movdqa %xmm4, %xmm2
pcmpgtd %xmm0, %xmm2
pshufd $0xa0, %xmm2, %xmm3     # xmm3 = xmm2[0,0,2,2]
pcmpeqd %xmm4, %xmm0
pshufd $0xf5, %xmm0, %xmm0     # xmm0 = xmm0[1,1,3,3]
pand %xmm3, %xmm0
pshufd $0xf5, %xmm2, %xmm2     # xmm2 = xmm2[1,1,3,3]
por %xmm0, %xmm2
pcmpeqd %xmm0, %xmm0
pxor %xmm2, %xmm0
pshufd $0x44, 0xf0(%rsp), %xmm2 # xmm2 = mem[0,1,0,1]
movdqa 0x10(%rsp), %xmm4
pxor %xmm1, %xmm4
pxor %xmm1, %xmm2
movdqa %xmm4, %xmm1
pcmpgtd %xmm2, %xmm1
pshufd $0xa0, %xmm1, %xmm3     # xmm3 = xmm1[0,0,2,2]
pcmpeqd %xmm4, %xmm2
pshufd $0xf5, %xmm2, %xmm2     # xmm2 = xmm2[1,1,3,3]
pand %xmm3, %xmm2
pshufd $0xf5, %xmm1, %xmm1     # xmm1 = xmm1[1,1,3,3]
por %xmm2, %xmm1
por %xmm0, %xmm1
pmovmskb %xmm1, %edx
testl %edx, %edx
je 0x358c56
orb $0x40, 0xc(%r13)
xorl %r8d, %r8d
xorl %ecx, %ecx
xorl %eax, %eax
movl %r8d, (%r13)
movl %eax, 0x4(%r13)
movl %ecx, 0x8(%r13)
movq %r12, %rdi
callq 0x20a60d
movq %r15, %rdi
callq 0x20a60d
movq 0x8(%rsp), %rdi
callq 0x20a60d
cmpl $0x0, 0x30(%rbx)
jne 0x358cc0
movq 0x78(%rsp), %rdi
callq 0x20a60d
jmp 0x358cc0
callq 0x1b54d1
jmp 0x358cbd
callq 0x1b54ab
jmp 0x358cbd
callq 0x1b5485
jmp 0x358cbd
callq 0x1b545f
jmp 0x358cbd
callq 0x1b5439
jmp 0x358cbd
callq 0x1b5413
jmp 0x358cbd
callq 0x1b53ed
xorl %r13d, %r13d
movq %r13, %rax
addq $0x128, %rsp            # imm = 0x128
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
nopl (%rax)