// File: /workspace/github_c_makefile_star2_O3/nh13[P]ksw/src/parasail/src/sw_trace_diag_sse2_128_64.c
// Function: parasail_sw_trace_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_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 s1Len = 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;
    __m128i vTDiag;
    __m128i vTIns;
    __m128i vTDel;
    __m128i vTZero;
    __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 = 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);
    vTDiag = _mm_set1_epi64x_rpl(PARASAIL_DIAG);
    vTIns = _mm_set1_epi64x_rpl(PARASAIL_INS);
    vTDel = _mm_set1_epi64x_rpl(PARASAIL_DEL);
    vTZero = _mm_set1_epi64x_rpl(PARASAIL_ZERO);
    vTDiagE = _mm_set1_epi64x_rpl(PARASAIL_DIAG_E);
    vTInsE = _mm_set1_epi64x_rpl(PARASAIL_INS_E);
    vTDiagF = _mm_set1_epi64x_rpl(PARASAIL_DIAG_F);
    vTDelF = _mm_set1_epi64x_rpl(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_SW | PARASAIL_FLAG_DIAG
        | PARASAIL_FLAG_TRACE
        | PARASAIL_FLAG_BITS_64 | PARASAIL_FLAG_LANES_2;

    /* 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 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))];
        __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_opn = _mm_sub_epi64(vNH, vOpen);
            vF_ext = _mm_sub_epi64(vF, vGap);
            vF = _mm_max_epi64_rpl(vF_opn, vF_ext);
            vE_opn = _mm_sub_epi64(vWH, vOpen);
            vE_ext = _mm_sub_epi64(vE, vGap);
            vE = _mm_max_epi64_rpl(vE_opn, vE_ext);
            vMat = _mm_set_epi64x_rpl(
                    matrow0[s2[j-0]],
                    matrow1[s2[j-1]]
                    );
            vNWH = _mm_add_epi64(vNWH, vMat);
            vNWH = _mm_max_epi64_rpl(vNWH, vZero);
            vWH = _mm_max_epi64_rpl(vNWH, vE);
            vWH = _mm_max_epi64_rpl(vWH, vF);
            /* 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);
            }
            /* trace table */
            {
                __m128i cond_zero = _mm_cmpeq_epi64_rpl(vWH, vZero);
                __m128i case1 = _mm_cmpeq_epi64_rpl(vWH, vNWH);
                __m128i case2 = _mm_cmpeq_epi64_rpl(vWH, vF);
                __m128i vT = _mm_blendv_epi8_rpl(
                        _mm_blendv_epi8_rpl(vTIns, vTDel, case2),
                        _mm_blendv_epi8_rpl(vTDiag, vTZero, cond_zero),
                        case1);
                __m128i condE = _mm_cmpgt_epi64_rpl(vE_opn, vE_ext);
                __m128i condF = _mm_cmpgt_epi64_rpl(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-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 $0x178, %rsp            # imm = 0x178
testq %rdx, %rdx
je 0x3ad2bf
movl %ecx, %r14d
testl %ecx, %ecx
jle 0x3ad2c6
testl %r8d, %r8d
js 0x3ad2cd
movl %r9d, %r12d
testl %r9d, %r9d
js 0x3ad2d4
movl %esi, %r15d
movq 0x1b0(%rsp), %rsi
testq %rsi, %rsi
je 0x3ad2db
cmpl $0x0, 0x30(%rsi)
je 0x3ac756
movl 0x34(%rsi), %r15d
jmp 0x3ac768
testq %rdi, %rdi
je 0x3ad2e2
testl %r15d, %r15d
jle 0x3ad2e9
movq %rdi, 0xc0(%rsp)
movq %rdx, 0x30(%rsp)
movslq 0x20(%rsi), %rax
movl %r8d, %ecx
negl %r8d
movq %rcx, 0x20(%rsp)
btsq $0x3f, %rcx
movabsq $-0x8000000000000000, %r13 # imm = 0x8000000000000000
subq %rax, %r13
cmpl %r8d, %eax
cmovgq %rcx, %r13
leaq 0x1(%r13), %rbp
movslq 0x1c(%rsi), %rax
movq %rax, 0xd0(%rsp)
movq %rbp, %xmm0
pshufd $0x44, %xmm0, %xmm0     # xmm0 = xmm0[0,1,0,1]
movdqa %xmm0, 0x110(%rsp)
movdqa %xmm0, 0x80(%rsp)
movdqa %xmm0, 0x10(%rsp)
movdqa %xmm0, 0xe0(%rsp)
movl $0x10, %edx
movl $0x1, %ecx
movl %r15d, %edi
movl %r14d, %esi
callq 0x20adf4
testq %rax, %rax
je 0x3ad2ee
movq %rax, %rbx
movl %r12d, 0xb0(%rsp)
movq %r15, (%rsp)
orl $0x2881004, 0xc(%rax)   # imm = 0x2881004
movq %r14, 0x70(%rsp)
leal 0x2(%r14), %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
testq %r14, %r14
sete %al
testq %r15, %r15
sete %cl
orb %al, %cl
testq %r12, %r12
sete %al
orb %cl, %al
jne 0x3ad2ee
movq (%rsp), %rax
movslq %eax, %rdi
movq 0x1b0(%rsp), %r8
cmpl $0x0, 0x30(%r8)
movq %rdi, 0x8(%rsp)
je 0x3ac88f
movq %r13, 0x40(%rsp)
xorl %eax, %eax
movq 0x30(%rsp), %r9
movq 0x20(%rsp), %r11
jmp 0x3ac8f4
incl %eax
movslq %eax, %rsi
movl $0x10, %edi
callq 0x20a636
testq %rax, %rax
je 0x3ad2ee
cmpl $0x0, (%rsp)
movq 0x1b0(%rsp), %r8
movq 0x8(%rsp), %rdi
movq 0x30(%rsp), %r9
movq 0xc0(%rsp), %r10
movq 0x20(%rsp), %r11
jle 0x3ac8e7
movq 0x10(%r8), %rsi
xorl %ecx, %ecx
movzbl (%r10,%rcx), %edx
movslq (%rsi,%rdx,4), %rdx
movq %rdx, (%rax,%rcx,8)
incq %rcx
cmpq %rcx, %rdi
jne 0x3ac8d2
movq %r13, 0x40(%rsp)
movq $0x0, (%rax,%rdi,8)
movabsq $-0x8000000000000000, %rcx # imm = 0x8000000000000000
subq 0xd0(%rsp), %rcx
addq $-0x2, %rcx
movq %rcx, %xmm0
movdqa %xmm0, 0x120(%rsp)
pshufd $0x44, %xmm0, %xmm0     # xmm0 = xmm0[0,1,0,1]
movdqa %xmm0, 0x90(%rsp)
movdqa 0x10(%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, 0x130(%rsp)
movq %r11, %xmm0
pshufd $0x44, %xmm0, %xmm0     # xmm0 = xmm0[0,1,0,1]
movdqa %xmm0, 0x160(%rsp)
movd 0xb0(%rsp), %xmm0
pshufd $0x44, %xmm0, %xmm0     # xmm0 = xmm0[0,1,0,1]
movdqa %xmm0, 0x150(%rsp)
movl 0x70(%rsp), %r13d
movq 0x10(%r8), %rcx
xorl %edx, %edx
movzbl (%r9,%rdx), %esi
movslq (%rcx,%rsi,4), %rsi
movq %rsi, 0x8(%r14,%rdx,8)
incq %rdx
cmpq %rdx, %r13
jne 0x3ac96f
xorl %ecx, %ecx
movq %rcx, (%r14)
movq %rcx, 0x8(%r14,%r13,8)
movq $0x0, 0x8(%r15,%rcx,8)
movq %rbp, 0x8(%r12,%rcx,8)
incq %rcx
cmpq %rcx, %r13
jne 0x3ac98f
movq %rbp, (%r15)
movq %rbp, (%r12)
movq %rbp, 0x8(%r15,%r13,8)
movq %rbp, 0xf8(%rsp)
movq %rbp, 0x8(%r12,%r13,8)
movq (%rsp), %rcx
testl %ecx, %ecx
movq %rax, 0x48(%rsp)
jle 0x3ad138
movq 0x70(%rsp), %rax
incl %eax
movd %ecx, %xmm0
decl %ecx
movq %rcx, (%rsp)
pshufd $0x50, %xmm0, %xmm0     # xmm0 = xmm0[0,0,1,1]
pxor %xmm1, %xmm1
punpckldq %xmm1, %xmm0    # xmm0 = xmm0[0],xmm1[0],xmm0[1],xmm1[1]
leaq (%r13,%r13), %rcx
movq %rcx, 0x100(%rsp)
leaq -0x1(%r13), %rcx
movq %rcx, 0x58(%rsp)
movss 0x27d2d5(%rip), %xmm1   # 0x629ce0
movaps %xmm1, 0xa0(%rsp)
movq $0x0, 0x50(%rsp)
pxor 0x27cf6c(%rip), %xmm0   # 0x629990
movdqa %xmm0, 0x140(%rsp)
xorl %esi, %esi
movdqa 0x10(%rsp), %xmm7
movdqa %xmm7, 0x60(%rsp)
movdqa %xmm7, %xmm3
movdqa %xmm7, %xmm4
movq %rbx, %rbp
movdqa 0x27cf41(%rip), %xmm14  # 0x629990
cmpl $0x0, 0x30(%r8)
je 0x3aca6c
movq %rsi, %rcx
orq $0x1, %rcx
cmpq %rdi, %rcx
cmovgel (%rsp), %ecx
movslq %ecx, %rcx
movq %rsi, %rdi
jmp 0x3aca80
movq %rax, %rdx
movq 0x48(%rsp), %rax
movq (%rax,%rsi,8), %rdi
movq 0x8(%rax,%rsi,8), %rcx
movq %rdx, %rax
movq 0x8(%r8), %r9
movslq 0x18(%r8), %r10
imulq %r10, %rdi
leaq (%r9,%rdi,4), %r8
imulq %r10, %rcx
leaq (%r9,%rcx,4), %r9
movq %rsi, 0x108(%rsp)
movq %rsi, %r10
orq $0x1, %r10
xorl %r11d, %r11d
movsd 0x27d235(%rip), %xmm11  # 0x629ce8
movdqa 0x10(%rsp), %xmm13
movdqa %xmm13, %xmm1
movdqa 0x130(%rsp), %xmm0
movdqa %xmm0, %xmm12
movaps %xmm11, 0x30(%rsp)
movdqa %xmm4, 0xd0(%rsp)
movq (%r14,%r11,8), %rcx
movq 0x8(%r14,%r11,8), %rdi
movslq (%r8,%rdi,4), %rdi
movslq (%r9,%rcx,4), %rcx
movq %rdi, %xmm2
movq %rcx, %xmm9
punpcklqdq %xmm2, %xmm9    # xmm9 = xmm9[0],xmm2[0]
paddq %xmm0, %xmm9
pshufd $0xee, %xmm12, %xmm6    # xmm6 = xmm12[2,3,2,3]
movq 0x8(%r15,%r11,8), %xmm0
punpcklqdq %xmm0, %xmm6    # xmm6 = xmm6[0],xmm0[0]
pshufd $0xee, %xmm1, %xmm2     # xmm2 = xmm1[2,3,2,3]
movq 0x8(%r12,%r11,8), %xmm0
punpcklqdq %xmm0, %xmm2    # xmm2 = xmm2[0],xmm0[0]
movdqa %xmm6, 0xc0(%rsp)
movdqa 0x160(%rsp), %xmm1
psubq %xmm1, %xmm6
movdqa 0x150(%rsp), %xmm4
psubq %xmm4, %xmm2
movdqa %xmm12, %xmm0
psubq %xmm1, %xmm0
psubq %xmm4, %xmm13
movdqa %xmm2, %xmm1
pxor %xmm14, %xmm1
movdqa %xmm6, %xmm4
pxor %xmm14, %xmm4
movdqa %xmm4, %xmm5
pcmpgtd %xmm1, %xmm5
pshufd $0xa0, %xmm5, %xmm8     # xmm8 = xmm5[0,0,2,2]
pcmpeqd %xmm1, %xmm4
pshufd $0xf5, %xmm4, %xmm4     # xmm4 = xmm4[1,1,3,3]
pand %xmm4, %xmm8
pshufd $0xf5, %xmm5, %xmm1     # xmm1 = xmm5[1,1,3,3]
movdqa %xmm1, 0xb0(%rsp)
por %xmm1, %xmm8
pand %xmm8, %xmm6
pandn %xmm2, %xmm8
por %xmm6, %xmm8
movdqa %xmm9, %xmm1
movsd %xmm0, %xmm1            # xmm1 = xmm0[0],xmm1[1]
movq %xmm13, %xmm6           # xmm6 = xmm13[0],zero
movapd %xmm1, %xmm2
xorpd %xmm14, %xmm2
pcmpeqd %xmm12, %xmm12
movdqa %xmm6, %xmm10
pxor %xmm14, %xmm10
movapd %xmm2, %xmm11
pcmpgtd %xmm10, %xmm11
pcmpeqd %xmm2, %xmm10
pshufd $0xa0, %xmm11, %xmm2    # xmm2 = xmm11[0,0,2,2]
pshufd $0xf5, %xmm10, %xmm10   # xmm10 = xmm10[1,1,3,3]
pand %xmm2, %xmm10
pshufd $0xf5, %xmm11, %xmm2    # xmm2 = xmm11[1,1,3,3]
por %xmm10, %xmm2
andpd %xmm2, %xmm1
pandn %xmm6, %xmm2
por %xmm1, %xmm2
shufpd $0x2, %xmm0, %xmm9      # xmm9 = xmm9[0],xmm0[1]
movdqa %xmm13, %xmm1
movlpd 0x27ed7d(%rip), %xmm1   # xmm1 = mem[0],xmm1[1]
movapd %xmm9, %xmm6
xorpd %xmm14, %xmm6
movapd %xmm1, %xmm10
xorpd %xmm14, %xmm10
movapd %xmm6, %xmm11
pcmpgtd %xmm10, %xmm11
pcmpeqd %xmm6, %xmm10
pshufd $0xa0, %xmm11, %xmm6    # xmm6 = xmm11[0,0,2,2]
pshufd $0xf5, %xmm10, %xmm10   # xmm10 = xmm10[1,1,3,3]
pand %xmm6, %xmm10
pshufd $0xf5, %xmm11, %xmm15   # xmm15 = xmm11[1,1,3,3]
por %xmm10, %xmm15
andpd %xmm15, %xmm9
andnpd %xmm1, %xmm15
orpd %xmm9, %xmm15
movapd %xmm15, %xmm1
xorpd %xmm14, %xmm1
movdqa %xmm2, %xmm6
pxor %xmm14, %xmm6
movdqa %xmm6, %xmm9
pcmpgtd %xmm1, %xmm9
pshufd $0xa0, %xmm9, %xmm10    # xmm10 = xmm9[0,0,2,2]
pcmpeqd %xmm1, %xmm6
pshufd $0xf5, %xmm6, %xmm1     # xmm1 = xmm6[1,1,3,3]
pand %xmm10, %xmm1
pshufd $0xf5, %xmm9, %xmm6     # xmm6 = xmm9[1,1,3,3]
por %xmm1, %xmm6
movdqa %xmm2, %xmm1
pand %xmm6, %xmm1
pandn %xmm15, %xmm6
por %xmm1, %xmm6
movdqa %xmm6, %xmm1
pxor %xmm14, %xmm1
movdqa %xmm8, %xmm9
pxor %xmm14, %xmm9
movdqa %xmm1, %xmm10
pcmpgtd %xmm9, %xmm10
pcmpeqd %xmm1, %xmm9
pshufd $0xa0, %xmm10, %xmm1    # xmm1 = xmm10[0,0,2,2]
pshufd $0xf5, %xmm9, %xmm9     # xmm9 = xmm9[1,1,3,3]
pand %xmm1, %xmm9
pshufd $0xf5, %xmm10, %xmm10   # xmm10 = xmm10[1,1,3,3]
por %xmm9, %xmm10
pand %xmm10, %xmm6
pandn %xmm8, %xmm10
por %xmm6, %xmm10
movdqa 0x30(%rsp), %xmm1
pcmpeqd %xmm12, %xmm1
pshufd $0xb1, %xmm1, %xmm9     # xmm9 = xmm1[1,0,3,2]
pand %xmm1, %xmm9
movdqa %xmm9, %xmm12
pandn %xmm10, %xmm12
movdqa %xmm9, %xmm1
pandn %xmm8, %xmm1
movdqa 0x10(%rsp), %xmm6
pand %xmm9, %xmm6
movdqa %xmm6, 0x70(%rsp)
por %xmm6, %xmm1
movdqa %xmm12, %xmm8
pxor %xmm14, %xmm8
cmpq $0x2, %r11
movdqa %xmm1, 0x20(%rsp)
jb 0x3acdfb
movdqa 0x90(%rsp), %xmm1
movdqa %xmm1, %xmm10
pxor %xmm14, %xmm10
movdqa %xmm8, %xmm11
pcmpgtd %xmm10, %xmm11
pshufd $0xa0, %xmm11, %xmm6    # xmm6 = xmm11[0,0,2,2]
pcmpeqd %xmm8, %xmm10
pshufd $0xf5, %xmm10, %xmm10   # xmm10 = xmm10[1,1,3,3]
pand %xmm6, %xmm10
pshufd $0xf5, %xmm11, %xmm6    # xmm6 = xmm11[1,1,3,3]
por %xmm10, %xmm6
pand %xmm6, %xmm1
pandn %xmm12, %xmm6
por %xmm6, %xmm1
movdqa %xmm1, 0x90(%rsp)
movdqa 0x60(%rsp), %xmm1
movdqa %xmm1, %xmm6
pxor %xmm14, %xmm6
movdqa %xmm6, %xmm10
pcmpgtd %xmm8, %xmm10
pshufd $0xa0, %xmm10, %xmm11   # xmm11 = xmm10[0,0,2,2]
pcmpeqd %xmm8, %xmm6
pshufd $0xf5, %xmm6, %xmm6     # xmm6 = xmm6[1,1,3,3]
pand %xmm11, %xmm6
pshufd $0xf5, %xmm10, %xmm10   # xmm10 = xmm10[1,1,3,3]
por %xmm6, %xmm10
pand %xmm10, %xmm1
pandn %xmm12, %xmm10
por %xmm10, %xmm1
movdqa %xmm1, 0x60(%rsp)
movdqa 0x20(%rsp), %xmm1
movq %xmm12, %rcx
movq %xmm15, %rdi
xorl %ebx, %ebx
cmpq %rdi, %rcx
sete %bl
negq %rbx
pshufd $0xee, %xmm12, %xmm6    # xmm6 = xmm12[2,3,2,3]
movq %xmm6, %rdi
pshufd $0xee, %xmm2, %xmm6     # xmm6 = xmm2[2,3,2,3]
movq %xmm6, %rdx
xorl %esi, %esi
cmpq %rdx, %rdi
sete %sil
negq %rsi
movq %rbx, %xmm10
movq %rsi, %xmm6
punpcklqdq %xmm6, %xmm10   # xmm10 = xmm10[0],xmm6[0]
movdqa %xmm12, %xmm6
pcmpeqd %xmm1, %xmm6
pshufd $0xb1, %xmm6, %xmm11    # xmm11 = xmm6[1,0,3,2]
pand %xmm6, %xmm11
movdqa 0x27d2c4(%rip), %xmm6   # 0x62a120
psubq %xmm11, %xmm6
movdqa %xmm12, %xmm1
pcmpeqd 0x27cef2(%rip), %xmm1   # 0x629d60
pshufd $0xb1, %xmm1, %xmm11    # xmm11 = xmm1[1,0,3,2]
pand %xmm1, %xmm11
pandn %xmm10, %xmm11
pandn %xmm6, %xmm10
pxor %xmm14, %xmm13
pxor %xmm14, %xmm0
movdqa %xmm0, %xmm1
pcmpgtd %xmm13, %xmm1
pcmpeqd %xmm13, %xmm0
pshufd $0xf5, %xmm0, %xmm0     # xmm0 = xmm0[1,1,3,3]
pand %xmm1, %xmm0
pshufd $0xf5, %xmm1, %xmm1     # xmm1 = xmm1[1,1,3,3]
por %xmm0, %xmm1
pand %xmm5, %xmm4
por 0xb0(%rsp), %xmm4
pand 0x27ea6e(%rip), %xmm1   # 0x62b930
pand 0x27ea76(%rip), %xmm4   # 0x62b940
por %xmm1, %xmm4
por %xmm10, %xmm4
pand 0x27bfd4(%rip), %xmm11  # 0x628eb0
por %xmm11, %xmm4
pxor 0x27ea67(%rip), %xmm4   # 0x62b950
movq %rbp, %rbx
movq 0x10(%rbp), %rdx
movq (%rdx), %rdi
cmpq %r13, %r11
jae 0x3acf09
pextrw $0x4, %xmm4, %edx
movq 0x50(%rsp), %rsi
addq %rdi, %rsi
movb %dl, (%r11,%rsi)
movsd %xmm2, %xmm15           # xmm15 = xmm2[0],xmm15[1]
pandn %xmm15, %xmm9
cmpq 0x8(%rsp), %r10
setge %dl
testq %r11, %r11
sete %sil
orb %dl, %sil
pcmpeqd %xmm10, %xmm10
movdqa 0x30(%rsp), %xmm11
jne 0x3acf40
movd %xmm4, %edx
addq 0x58(%rsp), %rdi
movb %dl, (%r11,%rdi)
movq %xmm11, %rdx
xorl %esi, %esi
cmpq %r13, %rdx
setl %sil
negq %rsi
pshufd $0xee, %xmm11, %xmm0    # xmm0 = xmm11[2,3,2,3]
movq %xmm0, %rdx
xorl %edi, %edi
cmpq %r13, %rdx
movdqa 0x70(%rsp), %xmm13
por %xmm9, %xmm13
movdqa 0xa0(%rsp), %xmm9
movdqa %xmm9, %xmm0
pxor %xmm14, %xmm0
movdqa 0x140(%rsp), %xmm4
movdqa %xmm4, %xmm1
pcmpgtd %xmm0, %xmm1
pshufd $0xa0, %xmm1, %xmm2     # xmm2 = xmm1[0,0,2,2]
pcmpeqd %xmm4, %xmm0
pshufd $0xf5, %xmm0, %xmm0     # xmm0 = xmm0[1,1,3,3]
pand %xmm2, %xmm0
pshufd $0xf5, %xmm1, %xmm1     # xmm1 = xmm1[1,1,3,3]
por %xmm0, %xmm1
setl %dil
negq %rdi
movq %rsi, %xmm2
movq %rdi, %xmm0
punpcklqdq %xmm0, %xmm2    # xmm2 = xmm2[0],xmm0[0]
pand %xmm1, %xmm2
pshufd $0xf5, %xmm11, %xmm0    # xmm0 = xmm11[1,1,3,3]
pcmpgtd %xmm10, %xmm0
pand %xmm2, %xmm0
movdqa %xmm3, %xmm1
pxor %xmm14, %xmm1
movdqa %xmm8, %xmm2
pcmpgtd %xmm1, %xmm2
pshufd $0xa0, %xmm2, %xmm4     # xmm4 = xmm2[0,0,2,2]
pcmpeqd %xmm8, %xmm1
pshufd $0xf5, %xmm1, %xmm1     # xmm1 = xmm1[1,1,3,3]
pand %xmm4, %xmm1
pshufd $0xf5, %xmm2, %xmm2     # xmm2 = xmm2[1,1,3,3]
por %xmm1, %xmm2
pand %xmm0, %xmm2
movdqa %xmm11, %xmm4
pxor %xmm14, %xmm4
movdqa %xmm2, %xmm1
movdqa 0xd0(%rsp), %xmm5
pandn %xmm5, %xmm1
pxor %xmm14, %xmm5
movdqa %xmm5, %xmm6
pcmpgtd %xmm4, %xmm6
pcmpeqd %xmm4, %xmm5
pshufd $0xa0, %xmm6, %xmm4     # xmm4 = xmm6[0,0,2,2]
pshufd $0xf5, %xmm5, %xmm5     # xmm5 = xmm5[1,1,3,3]
pand %xmm4, %xmm5
movdqa %xmm12, %xmm8
pcmpeqd %xmm3, %xmm8
pshufd $0xf5, %xmm6, %xmm4     # xmm4 = xmm6[1,1,3,3]
por %xmm5, %xmm4
movdqa %xmm2, %xmm5
pandn %xmm3, %xmm5
movdqa %xmm2, %xmm3
pand %xmm12, %xmm3
por %xmm5, %xmm3
movdqa %xmm2, %xmm5
pandn %xmm7, %xmm5
movdqa %xmm2, %xmm6
pand %xmm9, %xmm6
por %xmm5, %xmm6
pand %xmm11, %xmm2
por %xmm1, %xmm2
pand %xmm8, %xmm4
pshufd $0xb1, %xmm8, %xmm1     # xmm1 = xmm8[1,0,3,2]
pand %xmm1, %xmm4
pand %xmm0, %xmm4
movdqa %xmm4, %xmm0
pandn %xmm6, %xmm0
movdqa %xmm4, %xmm7
pand %xmm9, %xmm7
por %xmm0, %xmm7
movdqa %xmm4, %xmm0
pandn %xmm2, %xmm0
pand %xmm11, %xmm4
por %xmm0, %xmm4
movq %rcx, (%r15,%r11,8)
movaps 0x20(%rsp), %xmm1
movlps %xmm1, (%r12,%r11,8)
psubq %xmm10, %xmm11
incq %r11
cmpq %r11, %rax
movdqa 0xc0(%rsp), %xmm0
jne 0x3acacd
movdqa 0xa0(%rsp), %xmm0
paddq 0x27bdf7(%rip), %xmm0   # 0x628ef0
movdqa %xmm0, 0xa0(%rsp)
movq 0x108(%rsp), %rsi
addq $0x2, %rsi
movq 0x100(%rsp), %rcx
addq %rcx, 0x50(%rsp)
addq %rcx, 0x58(%rsp)
movq 0x8(%rsp), %rdi
cmpq %rdi, %rsi
movq 0x1b0(%rsp), %r8
jl 0x3aca4f
jmp 0x3ad150
movdqa 0x10(%rsp), %xmm0
movdqa %xmm0, %xmm7
movdqa %xmm0, %xmm4
movdqa %xmm0, %xmm3
movdqa %xmm0, 0x60(%rsp)
movdqa %xmm3, 0x110(%rsp)
movdqa %xmm4, 0xe0(%rsp)
movdqa %xmm7, 0x80(%rsp)
xorl %edx, %edx
movb $0x1, %sil
xorl %eax, %eax
xorl %ecx, %ecx
movq 0xf8(%rsp), %r10
movq 0x40(%rsp), %r11
movq 0x110(%rsp,%rdx), %rdi
cmpq %r10, %rdi
jle 0x3ad1a1
movl 0x80(%rsp,%rdx), %eax
movl 0xe0(%rsp,%rdx), %ecx
movq %rdi, %r10
jmp 0x3ad1d5
jne 0x3ad1d5
movq 0xe0(%rsp,%rdx), %rdi
movslq %ecx, %r8
cmpq %r8, %rdi
jge 0x3ad1be
movl 0x80(%rsp,%rdx), %eax
movl %edi, %ecx
jmp 0x3ad1d5
jne 0x3ad1d5
movq 0x80(%rsp,%rdx), %r8
movslq %eax, %r9
cmpq %r9, %r8
jge 0x3ad1d5
movl %edi, %ecx
movl %r8d, %eax
addq $0x8, %rdx
testb $0x1, %sil
movl $0x0, %esi
jne 0x3ad181
movq %r11, %xmm0
pshufd $0x44, %xmm0, %xmm0     # xmm0 = xmm0[0,1,0,1]
movdqa 0x27c79a(%rip), %xmm1   # 0x629990
movdqa 0x90(%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, 0x120(%rsp), %xmm2 # xmm2 = mem[0,1,0,1]
movdqa 0x60(%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 0x3ad284
orb $0x40, 0xc(%rbx)
xorl %r10d, %r10d
xorl %ecx, %ecx
xorl %eax, %eax
movl %r10d, (%rbx)
movl %eax, 0x4(%rbx)
movl %ecx, 0x8(%rbx)
movq %r12, %rdi
callq 0x20a60d
movq %r15, %rdi
callq 0x20a60d
movq %r14, %rdi
callq 0x20a60d
movq 0x1b0(%rsp), %rax
cmpl $0x0, 0x30(%rax)
jne 0x3ad2f0
movq 0x48(%rsp), %rdi
callq 0x20a60d
jmp 0x3ad2f0
callq 0x1bdcfd
jmp 0x3ad2ee
callq 0x1bdcd7
jmp 0x3ad2ee
callq 0x1bdcb1
jmp 0x3ad2ee
callq 0x1bdc8b
jmp 0x3ad2ee
callq 0x1bdc65
jmp 0x3ad2ee
callq 0x1bdc3f
jmp 0x3ad2ee
callq 0x1bdc19
xorl %ebx, %ebx
movq %rbx, %rax
addq $0x178, %rsp            # imm = 0x178
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
nopl (%rax)