// File: /workspace/github_c_makefile_star2_O1/nh13[P]ksw/src/parasail/src/nw_trace_scan_sse2_128_64.c
// Function: parasail_nw_trace_scan_profile_sse2_128_64
parasail_result_t* PNAME(
        const parasail_profile_t * const restrict profile,
        const char * const restrict s2, const int s2Len,
        const int open, const int gap)
{
    /* declare local variables */
    int32_t i = 0;
    int32_t j = 0;
    int32_t k = 0;
    int32_t s1Len = 0;
    int32_t end_query = 0;
    int32_t end_ref = 0;
    const parasail_matrix_t *matrix = NULL;
    int32_t segWidth = 0;
    int32_t segLen = 0;
    int32_t offset = 0;
    int32_t position = 0;
    __m128i* restrict pvP = NULL;
    __m128i* restrict pvE = NULL;
    int64_t* restrict boundary = NULL;
    __m128i* restrict pvHt = NULL;
    __m128i* restrict pvH = NULL;
    __m128i* restrict pvGapper = NULL;
    __m128i vGapO;
    __m128i vGapE;
    int64_t NEG_LIMIT = 0;
    int64_t POS_LIMIT = 0;
    __m128i vZero;
    int64_t score = 0;
    __m128i vNegLimit;
    __m128i vPosLimit;
    __m128i vSaturationCheckMin;
    __m128i vSaturationCheckMax;
    __m128i vNegInfFront;
    __m128i vSegLenXgap;
    parasail_result_t *result = NULL;
    __m128i vTIns;
    __m128i vTDel;
    __m128i vTDiag;
    __m128i vTDiagE;
    __m128i vTInsE;
    __m128i vTDiagF;
    __m128i vTDelF;

    /* validate inputs */
    PARASAIL_CHECK_NULL(profile);
    PARASAIL_CHECK_NULL(profile->profile64.score);
    PARASAIL_CHECK_NULL(profile->matrix);
    PARASAIL_CHECK_GT0(profile->s1Len);
    PARASAIL_CHECK_NULL(s2);
    PARASAIL_CHECK_GT0(s2Len);
    PARASAIL_CHECK_GE0(open);
    PARASAIL_CHECK_GE0(gap);

    /* initialize stack variables */
    i = 0;
    j = 0;
    k = 0;
    s1Len = profile->s1Len;
    end_query = s1Len-1;
    end_ref = s2Len-1;
    matrix = profile->matrix;
    segWidth = 2; /* number of values in vector unit */
    segLen = (s1Len + segWidth - 1) / segWidth;
    offset = (s1Len - 1) % segLen;
    position = (segWidth - 1) - (s1Len - 1) / segLen;
    pvP = (__m128i*)profile->profile64.score;
    vGapO = _mm_set1_epi64x_rpl(open);
    vGapE = _mm_set1_epi64x_rpl(gap);
    NEG_LIMIT = (-open < matrix->min ? INT64_MIN + open : INT64_MIN - matrix->min) + 1;
    POS_LIMIT = INT64_MAX - matrix->max - 1;
    vZero = _mm_setzero_si128();
    score = NEG_LIMIT;
    vNegLimit = _mm_set1_epi64x_rpl(NEG_LIMIT);
    vPosLimit = _mm_set1_epi64x_rpl(POS_LIMIT);
    vSaturationCheckMin = vPosLimit;
    vSaturationCheckMax = vNegLimit;
    vNegInfFront = vZero;
    vTIns  = _mm_set1_epi64x_rpl(PARASAIL_INS);
    vTDel  = _mm_set1_epi64x_rpl(PARASAIL_DEL);
    vTDiag = _mm_set1_epi64x_rpl(PARASAIL_DIAG);
    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);
    vNegInfFront = _mm_insert_epi64_rpl(vNegInfFront, NEG_LIMIT, 0);
    vSegLenXgap = _mm_add_epi64(vNegInfFront,
            _mm_slli_si128(_mm_set1_epi64x_rpl(-segLen*gap), 8));

    /* initialize result */
    result = parasail_result_new_trace(segLen, s2Len, 16, sizeof(__m128i));
    if (!result) return NULL;

    /* set known flags */
    result->flag |= PARASAIL_FLAG_NW | PARASAIL_FLAG_SCAN
        | PARASAIL_FLAG_TRACE
        | PARASAIL_FLAG_BITS_64 | PARASAIL_FLAG_LANES_2;

    /* initialize heap variables */
    pvE = parasail_memalign___m128i(16, segLen);
    boundary = parasail_memalign_int64_t(16, s2Len+1);
    pvHt= parasail_memalign___m128i(16, segLen);
    pvH = parasail_memalign___m128i(16, segLen);
    pvGapper = parasail_memalign___m128i(16, segLen);

    /* validate heap variables */
    if (!pvE) return NULL;
    if (!boundary) return NULL;
    if (!pvHt) return NULL;
    if (!pvH) return NULL;
    if (!pvGapper) return NULL;

    /* initialize H and E */
    {
        int32_t index = 0;
        for (i=0; i<segLen; ++i) {
            int32_t segNum = 0;
            __m128i_64_t h;
            __m128i_64_t e;
            for (segNum=0; segNum<segWidth; ++segNum) {
                int64_t tmp = -open-gap*(segNum*segLen+i);
                h.v[segNum] = tmp < INT64_MIN ? INT64_MIN : tmp;
                tmp = tmp - open;
                e.v[segNum] = tmp < INT64_MIN ? INT64_MIN : tmp;
            }
            _mm_store_si128(&pvH[index], h.m);
            _mm_store_si128(&pvE[index], e.m);
            ++index;
        }
    }

    /* initialize uppder boundary */
    {
        boundary[0] = 0;
        for (i=1; i<=s2Len; ++i) {
            int64_t tmp = -open-gap*(i-1);
            boundary[i] = tmp < INT64_MIN ? INT64_MIN : tmp;
        }
    }

    {
        __m128i vGapper = _mm_sub_epi64(vZero,vGapO);
        for (i=segLen-1; i>=0; --i) {
            _mm_store_si128(pvGapper+i, vGapper);
            vGapper = _mm_sub_epi64(vGapper, vGapE);
        }
    }

    /* outer loop over database sequence */
    for (j=0; j<s2Len; ++j) {
        __m128i vE;
        __m128i vE_ext;
        __m128i vE_opn;
        __m128i vHt;
        __m128i vF;
        __m128i vF_ext;
        __m128i vF_opn;
        __m128i vH;
        __m128i vHp;
        __m128i *pvW;
        __m128i vW;
        __m128i case1;
        __m128i case2;
        __m128i vGapper;
        __m128i vT;
        __m128i vET;
        __m128i vFT;

        /* calculate E */
        /* calculate Ht */
        /* calculate F and H first pass */
        vHp = _mm_load_si128(pvH+(segLen-1));
        vHp = _mm_slli_si128(vHp, 8);
        vHp = _mm_insert_epi64_rpl(vHp, boundary[j], 0);
        pvW = pvP + matrix->mapper[(unsigned char)s2[j]]*segLen;
        vHt = _mm_sub_epi64(vNegLimit, pvGapper[0]);
        vF = vNegLimit;
        for (i=0; i<segLen; ++i) {
            vH = _mm_load_si128(pvH+i);
            vE = _mm_load_si128(pvE+i);
            vW = _mm_load_si128(pvW+i);
            vGapper = _mm_load_si128(pvGapper+i);
            vE_opn = _mm_sub_epi64(vH, vGapO);
            vE_ext = _mm_sub_epi64(vE, vGapE);
            case1 = _mm_cmpgt_epi64_rpl(vE_opn, vE_ext);
            vET = _mm_blendv_epi8_rpl(vTInsE, vTDiagE, case1);
            arr_store(result->trace->trace_table, vET, i, segLen, j);
            vE = _mm_max_epi64_rpl(vE_opn, vE_ext);
            vSaturationCheckMin = _mm_min_epi64_rpl(vSaturationCheckMin, vE);
            vGapper = _mm_add_epi64(vHt, vGapper);
            vF = _mm_max_epi64_rpl(vF, vGapper);
            vHp = _mm_add_epi64(vHp, vW);
            vHt = _mm_max_epi64_rpl(vE, vHp);
            _mm_store_si128(pvE+i, vE);
            _mm_store_si128(pvHt+i, vHt);
            _mm_store_si128(pvH+i, vHp);
            vHp = vH;
        }

        /* pseudo prefix scan on F and H */
        vHt = _mm_slli_si128(vHt, 8);
        vHt = _mm_insert_epi64_rpl(vHt, boundary[j+1], 0);
        vGapper = _mm_load_si128(pvGapper);
        vGapper = _mm_add_epi64(vHt, vGapper);
        vF = _mm_max_epi64_rpl(vF, vGapper);
        for (i=0; i<segWidth-2; ++i) {
            __m128i vFt = _mm_slli_si128(vF, 8);
            vFt = _mm_add_epi64(vFt, vSegLenXgap);
            vF = _mm_max_epi64_rpl(vF, vFt);
        }

        /* calculate final H */
        vF = _mm_slli_si128(vF, 8);
        vF = _mm_add_epi64(vF, vNegInfFront);
        vH = _mm_max_epi64_rpl(vF, vHt);
        for (i=0; i<segLen; ++i) {
            vET = arr_load(result->trace->trace_table, i, segLen, j);
            vHp = _mm_load_si128(pvH+i);
            vHt = _mm_load_si128(pvHt+i);
            vF_opn = _mm_sub_epi64(vH, vGapO);
            vF_ext = _mm_sub_epi64(vF, vGapE);
            vF = _mm_max_epi64_rpl(vF_opn, vF_ext);
            case1 = _mm_cmpgt_epi64_rpl(vF_opn, vF_ext);
            vFT = _mm_blendv_epi8_rpl(vTDelF, vTDiagF, case1);
            vH = _mm_max_epi64_rpl(vHt, vF);
            case1 = _mm_cmpeq_epi64_rpl(vH, vHp);
            case2 = _mm_cmpeq_epi64_rpl(vH, vF);
            vT = _mm_blendv_epi8_rpl(
                    _mm_blendv_epi8_rpl(vTIns, vTDel, case2),
                    vTDiag, case1);
            vT = _mm_or_si128(vT, vET);
            vT = _mm_or_si128(vT, vFT);
            arr_store(result->trace->trace_table, vT, i, segLen, j);
            _mm_store_si128(pvH+i, vH);
            vSaturationCheckMin = _mm_min_epi64_rpl(vSaturationCheckMin, vH);
            vSaturationCheckMin = _mm_min_epi64_rpl(vSaturationCheckMin, vF);
            vSaturationCheckMax = _mm_max_epi64_rpl(vSaturationCheckMax, vH);
        }
    }

    /* extract last value from the last column */
    {
        __m128i vH = _mm_load_si128(pvH + offset);
        for (k=0; k<position; ++k) {
            vH = _mm_slli_si128(vH, 8);
        }
        score = (int64_t) _mm_extract_epi64_rpl (vH, 1);
    }

    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(pvGapper);
    parasail_free(pvH);
    parasail_free(pvHt);
    parasail_free(boundary);
    parasail_free(pvE);

    return result;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0xd8, %rsp
movq %rsi, 0x68(%rsp)
testq %rdi, %rdi
je 0x385e4c
movq 0x60(%rdi), %rax
movq %rax, 0x98(%rsp)
testq %rax, %rax
je 0x385e53
movq 0x10(%rdi), %rax
movq %rax, 0x60(%rsp)
testq %rax, %rax
je 0x385e5a
movl 0x8(%rdi), %r14d
testl %r14d, %r14d
jle 0x385e61
cmpq $0x0, 0x68(%rsp)
je 0x385e68
movl %edx, %r13d
testl %edx, %edx
jle 0x385e6f
testl %ecx, %ecx
js 0x385e76
testl %r8d, %r8d
js 0x385e7d
movl %r8d, 0x38(%rsp)
leal -0x1(%r14), %eax
incq %r14
shrq %r14
movl %eax, 0x14(%rsp)
cltd
idivl %r14d
movl %eax, 0x4c(%rsp)
movl %edx, %ebp
movl %ecx, %r15d
negl %ecx
movq 0x60(%rsp), %rsi
movslq 0x20(%rsi), %rax
movq %r15, %rdi
btsq $0x3f, %rdi
movabsq $-0x8000000000000000, %r12 # imm = 0x8000000000000000
subq %rax, %r12
movl %ecx, 0x8(%rsp)
cmpl %ecx, %eax
cmovgq %rdi, %r12
movslq 0x1c(%rsi), %rax
movq %rax, 0x70(%rsp)
movl $0x10, %edx
movl $0x10, %ecx
movl %r14d, %edi
movl %r13d, %esi
callq 0x2097d1
testq %rax, %rax
je 0x385e82
movq %rax, %rbx
movl %ebp, 0x48(%rsp)
movq %r12, 0x58(%rsp)
orl $0x2880401, 0xc(%rax)   # imm = 0x2880401
movl $0x10, %edi
movq %r14, %rsi
callq 0x2ea474
movq %rax, %r12
leal 0x1(%r13), %esi
movl $0x10, %edi
movq %rsi, 0x30(%rsp)
callq 0x2094de
movq %rax, 0x28(%rsp)
movl $0x10, %edi
movq %r14, %rsi
callq 0x2ea474
movq %r13, 0x18(%rsp)
movq %rax, %r13
movl $0x10, %edi
movq %r14, %rsi
callq 0x2ea474
movq %rax, %rbp
movl $0x10, %edi
movq %r14, 0x80(%rsp)
movq %r14, %rsi
callq 0x2ea474
movq 0x28(%rsp), %rdx
testq %r12, %r12
sete %cl
testq %rdx, %rdx
sete %dl
orb %cl, %dl
testq %r13, %r13
sete %cl
testq %rbp, %rbp
sete %sil
orb %cl, %sil
orb %dl, %sil
testq %rax, %rax
sete %cl
orb %sil, %cl
jne 0x385e82
movq %rax, 0x20(%rsp)
movq 0x18(%rsp), %rax
decl %eax
movl %eax, 0x44(%rsp)
movq %r15, %xmm0
pshufd $0x44, %xmm0, %xmm0     # xmm0 = xmm0[0,1,0,1]
movl 0x38(%rsp), %edx
movd %edx, %xmm1
pshufd $0x44, %xmm1, %xmm1     # xmm1 = xmm1[0,1,0,1]
movq 0x58(%rsp), %rax
leaq 0x1(%rax), %rcx
movabsq $-0x8000000000000000, %r11 # imm = 0x8000000000000000
subq 0x70(%rsp), %r11
addq $-0x2, %r11
movq %rcx, %xmm2
movdqa %xmm2, 0xa0(%rsp)
pshufd $0x44, %xmm2, %xmm2     # xmm2 = xmm2[0,1,0,1]
movdqa %xmm2, 0x70(%rsp)
movq %r11, %xmm2
pshufd $0x44, %xmm2, %xmm4     # xmm4 = xmm2[0,1,0,1]
movl %edx, %ecx
movslq 0x8(%rsp), %rdx
movq 0x80(%rsp), %r14
movl %r14d, %eax
negq %r15
movq %rax, %rsi
imulq %rcx, %rsi
xorl %edi, %edi
movq %rdx, %r8
xorl %r9d, %r9d
movq %r8, 0xc0(%rsp,%r9,8)
leaq (%r15,%r8), %r10
movq %r10, 0xb0(%rsp,%r9,8)
incq %r9
subq %rsi, %r8
cmpq $0x1, %r9
je 0x385842
movq %rdi, %r8
shlq $0x4, %r8
movaps 0xc0(%rsp), %xmm2
movaps %xmm2, (%rbp,%r8)
movdqa 0xb0(%rsp), %xmm2
movdqa %xmm2, (%r12,%r8)
incq %rdi
subq %rcx, %rdx
cmpq %rax, %rdi
jne 0x38583c
movq 0x28(%rsp), %r10
movq $0x0, (%r10)
movslq 0x8(%rsp), %rdx
movl $0x1, %esi
movq 0x30(%rsp), %rdi
movq %rdx, (%r10,%rsi,8)
incq %rsi
subq %rcx, %rdx
cmpq %rsi, %rdi
jne 0x3858ac
movq %r11, 0x50(%rsp)
pxor %xmm2, %xmm2
psubq %xmm0, %xmm2
leal -0x1(%r14), %ecx
movq %rcx, %rsi
shlq $0x4, %rsi
movq 0x20(%rsp), %r9
movq %r9, %rdx
addq %rsi, %rdx
movl %r14d, %esi
movdqa %xmm2, (%rdx)
psubq %xmm1, %xmm2
addq $-0x10, %rdx
decl %esi
jg 0x3858e1
movl %ecx, %ecx
shlq $0x4, %rcx
movq %rbp, %rdx
addq %rcx, %rdx
movq %rdx, 0x30(%rsp)
cmpl $0x1, %r14d
movslq %r14d, %rcx
movq %rcx, 0x88(%rsp)
adcl $0x0, %r14d
movq 0x18(%rsp), %rdx
cmpl $0x2, %edx
movl $0x1, %ecx
cmovgel %edx, %ecx
movq %rcx, 0x18(%rsp)
shlq $0x4, %rax
movq %rax, 0x38(%rsp)
shlq $0x4, %r14
xorl %eax, %eax
movdqa 0x271b3e(%rip), %xmm8   # 0x5f7480
movdqa 0x271b45(%rip), %xmm9   # 0x5f7490
movdqa 0x27057c(%rip), %xmm10  # 0x5f5ed0
movdqa 0x271b43(%rip), %xmm11  # 0x5f74a0
xorl %esi, %esi
movdqa 0x70(%rsp), %xmm12
movq %r12, 0x90(%rsp)
movdqa 0x271aea(%rip), %xmm7   # 0x5f7460
movq (%r10,%rsi,8), %xmm13
movq 0x30(%rsp), %rcx
punpcklqdq (%rcx), %xmm13  # xmm13 = xmm13[0],mem[0]
movq 0x60(%rsp), %rcx
movq 0x10(%rcx), %rcx
movq 0x68(%rsp), %rdx
movq %rsi, 0x8(%rsp)
movzbl (%rdx,%rsi), %edx
movslq (%rcx,%rdx,4), %rcx
imulq 0x88(%rsp), %rcx
shlq $0x4, %rcx
addq 0x98(%rsp), %rcx
movdqa 0x70(%rsp), %xmm14
movdqa %xmm14, %xmm15
psubq (%r9), %xmm15
xorl %r15d, %r15d
movdqa 0x271a7e(%rip), %xmm6   # 0x5f7450
movdqa (%rbp,%r15), %xmm5
movdqa (%r12,%r15), %xmm3
movdqa %xmm5, %xmm2
psubq %xmm0, %xmm2
psubq %xmm1, %xmm3
movq %xmm2, %rdx
movq %xmm3, %r11
pshufd $0xee, %xmm2, %xmm2     # xmm2 = xmm2[2,3,2,3]
movq %xmm2, %rdi
pshufd $0xee, %xmm3, %xmm2     # xmm2 = xmm3[2,3,2,3]
movq %xmm2, %rsi
xorl %r8d, %r8d
cmpq %rsi, %rdi
setg %r8b
cmovgq %rdi, %rsi
xorl %edi, %edi
cmpq %r11, %rdx
cmovgq %rdx, %r11
setg %dil
negq %rdi
negq %r8
movq %rdi, %xmm2
movq %r8, %xmm3
punpcklqdq %xmm3, %xmm2    # xmm2 = xmm2[0],xmm3[0]
pand %xmm6, %xmm2
pxor %xmm7, %xmm2
movq 0x10(%rbx), %rdx
movq (%rdx), %rdx
paddq (%r9,%r15), %xmm15
addq %rax, %rdx
paddq (%rcx,%r15), %xmm13
movdqa %xmm2, (%r15,%rdx)
movq %r11, %xmm3
movq %rsi, %xmm2
punpcklqdq %xmm2, %xmm3    # xmm3 = xmm3[0],xmm2[0]
movq %xmm4, %rdx
cmpq %r11, %rdx
cmovgeq %r11, %rdx
pshufd $0xee, %xmm4, %xmm2     # xmm2 = xmm4[2,3,2,3]
movq %xmm2, %rdi
cmpq %rsi, %rdi
cmovgeq %rsi, %rdi
movq %rdx, %xmm4
movq %rdi, %xmm2
punpcklqdq %xmm2, %xmm4    # xmm4 = xmm4[0],xmm2[0]
movq %xmm14, %rdi
movq %xmm15, %rdx
cmpq %rdx, %rdi
cmovgq %rdi, %rdx
pshufd $0xee, %xmm14, %xmm2    # xmm2 = xmm14[2,3,2,3]
movq %xmm2, %rdi
pshufd $0xee, %xmm15, %xmm2    # xmm2 = xmm15[2,3,2,3]
movq %xmm2, %r8
cmpq %r8, %rdi
cmovgq %rdi, %r8
movq %rdx, %xmm14
movq %r8, %xmm2
punpcklqdq %xmm2, %xmm14   # xmm14 = xmm14[0],xmm2[0]
movq %xmm13, %rdi
cmpq %rdi, %r11
cmovleq %rdi, %r11
pshufd $0xee, %xmm13, %xmm2    # xmm2 = xmm13[2,3,2,3]
movq %xmm2, %rdi
cmpq %rdi, %rsi
cmovleq %rdi, %rsi
movq %r11, %xmm15
movq %rsi, %xmm2
punpcklqdq %xmm2, %xmm15   # xmm15 = xmm15[0],xmm2[0]
movdqa %xmm3, (%r12,%r15)
movdqa %xmm15, (%r13,%r15)
movdqa %xmm13, (%rbp,%r15)
addq $0x10, %r15
movdqa %xmm5, %xmm13
cmpq %r15, %r14
jne 0x3859d2
movq 0x8(%rsp), %rsi
movq 0x8(%r10,%rsi,8), %rcx
incq %rsi
movq %rsi, 0x8(%rsp)
movq (%r9), %rsi
addq %rcx, %rsi
cmpq %rsi, %rdx
cmovgq %rdx, %rsi
movq %rsi, %xmm13
pslldq $0x8, %xmm13            # xmm13 = zero,zero,zero,zero,zero,zero,zero,zero,xmm13[0,1,2,3,4,5,6,7]
paddq 0xa0(%rsp), %xmm13
movq %xmm13, %rdx
cmpq %rcx, %rdx
cmovgq %rdx, %rcx
pshufd $0xee, %xmm13, %xmm2    # xmm2 = xmm13[2,3,2,3]
movq %xmm2, %rdx
cmpq %r11, %rdx
cmovgq %rdx, %r11
movq %rcx, %xmm14
movq %r11, %xmm2
punpcklqdq %xmm2, %xmm14   # xmm14 = xmm14[0],xmm2[0]
xorl %r15d, %r15d
movdqa 0x2718df(%rip), %xmm6   # 0x5f7470
movq 0x10(%rbx), %rcx
movq (%rcx), %r8
addq %rax, %r8
psubq %xmm0, %xmm14
psubq %xmm1, %xmm13
movq %xmm14, %rcx
movq %xmm13, %rdi
xorl %edx, %edx
cmpq %rdi, %rcx
cmovgq %rcx, %rdi
pshufd $0xee, %xmm14, %xmm2    # xmm2 = xmm14[2,3,2,3]
movq %xmm2, %rcx
pshufd $0xee, %xmm13, %xmm2    # xmm2 = xmm13[2,3,2,3]
movq %xmm2, %rsi
setg %dl
negq %rdx
xorl %r10d, %r10d
cmpq %rsi, %rcx
cmovgq %rcx, %rsi
movq %rdi, %xmm13
movq %rsi, %xmm2
punpcklqdq %xmm2, %xmm13   # xmm13 = xmm13[0],xmm2[0]
setg %r10b
negq %r10
movq %rdx, %xmm2
movq %r10, %xmm3
punpcklqdq %xmm3, %xmm2    # xmm2 = xmm2[0],xmm3[0]
pand %xmm6, %xmm2
pxor %xmm8, %xmm2
movq (%r13,%r15), %r10
movq 0x8(%r13,%r15), %rdx
cmpq %rdi, %r10
movq %rdi, %rcx
cmovgq %r10, %rcx
cmpq %rsi, %rdx
movq %rsi, %r11
cmovgq %rdx, %r11
movq %rcx, %xmm14
movq %r11, %xmm3
movq %rbx, %r12
xorl %ebx, %ebx
cmpq (%rbp,%r15), %rcx
sete %bl
negq %rbx
movq %r13, %r9
movq %r14, %r13
xorl %r14d, %r14d
cmpq 0x8(%rbp,%r15), %r11
punpcklqdq %xmm3, %xmm14   # xmm14 = xmm14[0],xmm3[0]
sete %r14b
negq %r14
movq %rbx, %xmm3
movq %r14, %xmm5
movq %r13, %r14
movq %r9, %r13
punpcklqdq %xmm5, %xmm3    # xmm3 = xmm3[0],xmm5[0]
xorl %ebx, %ebx
cmpq %r10, %rdi
setge %bl
negq %rbx
xorl %r10d, %r10d
cmpq %rdx, %rsi
setge %r10b
negq %r10
movq %rbx, %xmm5
movq %r12, %rbx
movq %r10, %xmm15
punpcklqdq %xmm15, %xmm5   # xmm5 = xmm5[0],xmm15[0]
pand %xmm9, %xmm5
pxor %xmm10, %xmm5
movdqa %xmm3, %xmm15
pandn %xmm5, %xmm15
pand %xmm11, %xmm3
por (%r15,%r8), %xmm2
por %xmm15, %xmm2
por %xmm3, %xmm2
movdqa %xmm2, (%r15,%r8)
movq %xmm4, %rdx
cmpq %rcx, %rdx
cmovgeq %rcx, %rdx
pshufd $0xee, %xmm4, %xmm2     # xmm2 = xmm4[2,3,2,3]
movq %xmm2, %r8
cmpq %r11, %r8
cmovgeq %r11, %r8
movdqa %xmm14, (%rbp,%r15)
cmpq %rdi, %rdx
cmovgeq %rdi, %rdx
cmpq %rsi, %r8
cmovgeq %rsi, %r8
movq %rdx, %xmm4
movq %r8, %xmm2
punpcklqdq %xmm2, %xmm4    # xmm4 = xmm4[0],xmm2[0]
movq %xmm12, %rsi
cmpq %rcx, %rsi
cmovgq %rsi, %rcx
pshufd $0xee, %xmm12, %xmm2    # xmm2 = xmm12[2,3,2,3]
movq %xmm2, %rsi
cmpq %r11, %rsi
cmovgq %rsi, %r11
movq %rcx, %xmm12
movq %r11, %xmm2
punpcklqdq %xmm2, %xmm12   # xmm12 = xmm12[0],xmm2[0]
addq $0x10, %r15
cmpq %r15, %r14
jne 0x385b91
addq 0x38(%rsp), %rax
movq 0x8(%rsp), %rsi
cmpq 0x18(%rsp), %rsi
movq 0x90(%rsp), %r12
movq 0x28(%rsp), %r10
movq 0x20(%rsp), %r9
jne 0x385976
movl 0x48(%rsp), %esi
shlq $0x4, %rsi
movdqa (%rbp,%rsi), %xmm0
movl 0x4c(%rsp), %esi
testl %esi, %esi
jle 0x385d8b
movl 0x14(%rsp), %eax
movq 0x50(%rsp), %r9
jmp 0x385d9d
movl 0x14(%rsp), %eax
movq 0x50(%rsp), %r9
pslldq $0x8, %xmm0             # xmm0 = zero,zero,zero,zero,zero,zero,zero,zero,xmm0[0,1,2,3,4,5,6,7]
testl %esi, %esi
js 0x385d94
xorl %esi, %esi
movq 0x58(%rsp), %rdi
cmpq %rdi, %rdx
setle %sil
negq %rsi
xorl %edx, %edx
cmpq %rdi, %r8
setle %dl
negq %rdx
movq %rdx, %xmm1
movq %rsi, %xmm2
punpcklqdq %xmm1, %xmm2    # xmm2 = xmm2[0],xmm1[0]
xorl %edx, %edx
cmpq %r9, %rcx
setg %dl
negq %rdx
xorl %ecx, %ecx
cmpq %r9, %r11
setg %cl
negq %rcx
movq %rcx, %xmm1
movq %rdx, %xmm3
punpcklqdq %xmm1, %xmm3    # xmm3 = xmm3[0],xmm1[0]
por %xmm2, %xmm3
pmovmskb %xmm3, %ecx
testl %ecx, %ecx
je 0x385e08
orb $0x40, 0xc(%rbx)
xorl %ecx, %ecx
xorl %edx, %edx
xorl %eax, %eax
movq 0x20(%rsp), %rdi
jmp 0x385e1b
pshufd $0xee, %xmm0, %xmm0     # xmm0 = xmm0[2,3,2,3]
movq %xmm0, %rcx
movq 0x20(%rsp), %rdi
movl 0x44(%rsp), %edx
movl %ecx, (%rbx)
movl %eax, 0x4(%rbx)
movl %edx, 0x8(%rbx)
callq 0x2094b5
movq %rbp, %rdi
callq 0x2094b5
movq %r13, %rdi
callq 0x2094b5
movq 0x28(%rsp), %rdi
callq 0x2094b5
movq %r12, %rdi
callq 0x2094b5
jmp 0x385e84
callq 0x1bc16d
jmp 0x385e82
callq 0x1bc147
jmp 0x385e82
callq 0x1bc121
jmp 0x385e82
callq 0x1bc0fb
jmp 0x385e82
callq 0x1bc0d5
jmp 0x385e82
callq 0x1bc0af
jmp 0x385e82
callq 0x1bc089
jmp 0x385e82
callq 0x1bc063
xorl %ebx, %ebx
movq %rbx, %rax
addq $0xd8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
nopl (%rax)