// File: /workspace/github_c_makefile_star2_O1/nh13[P]ksw/src/parasail/src/nw_striped_sse41_128_64.c
// Function: parasail_nw_table_striped_profile_sse41_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;
    int 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 vProfile = NULL;
    __m128i* restrict pvHStore = NULL;
    __m128i* restrict pvHLoad = NULL;
    __m128i* restrict pvE = NULL;
    int64_t* restrict boundary = NULL;
    __m128i vGapO;
    __m128i vGapE;
    int64_t NEG_LIMIT = 0;
    int64_t POS_LIMIT = 0;
    int64_t score = 0;
    __m128i vNegLimit;
    __m128i vPosLimit;
    __m128i vSaturationCheckMin;
    __m128i vSaturationCheckMax;
    parasail_result_t *result = NULL;

    /* 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;
    vProfile = (__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;
    score = NEG_LIMIT;
    vNegLimit = _mm_set1_epi64x_rpl(NEG_LIMIT);
    vPosLimit = _mm_set1_epi64x_rpl(POS_LIMIT);
    vSaturationCheckMin = vPosLimit;
    vSaturationCheckMax = vNegLimit;

    /* initialize result */
#ifdef PARASAIL_TABLE
    result = parasail_result_new_table1(segLen*segWidth, s2Len);
#else
#ifdef PARASAIL_ROWCOL
    result = parasail_result_new_rowcol1(segLen*segWidth, s2Len);
#else
    result = parasail_result_new();
#endif
#endif
    if (!result) return NULL;

    /* set known flags */
    result->flag |= PARASAIL_FLAG_NW | PARASAIL_FLAG_STRIPED
        | 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 */
    pvHStore = parasail_memalign___m128i(16, segLen);
    pvHLoad  = parasail_memalign___m128i(16, segLen);
    pvE      = parasail_memalign___m128i(16, segLen);
    boundary = parasail_memalign_int64_t(16, s2Len+1);

    /* validate heap variables */
    if (!pvHStore) return NULL;
    if (!pvHLoad) return NULL;
    if (!pvE) return NULL;
    if (!boundary) 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(&pvHStore[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;
        }
    }

    /* outer loop over database sequence */
    for (j=0; j<s2Len; ++j) {
        __m128i vE;
        /* Initialize F value to -inf.  Any errors to vH values will be
         * corrected in the Lazy_F loop.  */
        __m128i vF = vNegLimit;

        /* load final segment of pvHStore and shift left by 2 bytes */
        __m128i vH = _mm_slli_si128(pvHStore[segLen - 1], 8);

        /* Correct part of the vProfile */
        const __m128i* vP = vProfile + matrix->mapper[(unsigned char)s2[j]] * segLen;

        /* Swap the 2 H buffers. */
        __m128i* pv = pvHLoad;
        pvHLoad = pvHStore;
        pvHStore = pv;

        /* insert upper boundary condition */
        vH = _mm_insert_epi64_rpl(vH, boundary[j], 0);

        /* inner loop to process the query sequence */
        for (i=0; i<segLen; ++i) {
            vH = _mm_add_epi64(vH, _mm_load_si128(vP + i));
            vE = _mm_load_si128(pvE + i);

            /* Get max from vH, vE and vF. */
            vH = _mm_max_epi64_rpl(vH, vE);
            vH = _mm_max_epi64_rpl(vH, vF);
            /* Save vH values. */
            _mm_store_si128(pvHStore + i, vH);
            vSaturationCheckMax = _mm_max_epi64_rpl(vSaturationCheckMax, vH);
            vSaturationCheckMin = _mm_min_epi64_rpl(vSaturationCheckMin, vH);
            vSaturationCheckMin = _mm_min_epi64_rpl(vSaturationCheckMin, vE);
            vSaturationCheckMin = _mm_min_epi64_rpl(vSaturationCheckMin, vF);
#ifdef PARASAIL_TABLE
            arr_store_si128(result->tables->score_table, vH, i, segLen, j, s2Len);
#endif

            /* Update vE value. */
            vH = _mm_sub_epi64(vH, vGapO);
            vE = _mm_sub_epi64(vE, vGapE);
            vE = _mm_max_epi64_rpl(vE, vH);
            _mm_store_si128(pvE + i, vE);

            /* Update vF value. */
            vF = _mm_sub_epi64(vF, vGapE);
            vF = _mm_max_epi64_rpl(vF, vH);

            /* Load the next vH. */
            vH = _mm_load_si128(pvHLoad + i);
        }

        /* Lazy_F loop: has been revised to disallow adjecent insertion and
         * then deletion, so don't update E(i, i), learn from SWPS3 */
        for (k=0; k<segWidth; ++k) {
            int64_t tmp = boundary[j+1]-open;
            int64_t tmp2 = tmp < INT64_MIN ? INT64_MIN : tmp;
            vF = _mm_slli_si128(vF, 8);
            vF = _mm_insert_epi64_rpl(vF, tmp2, 0);
            for (i=0; i<segLen; ++i) {
                vH = _mm_load_si128(pvHStore + i);
                vH = _mm_max_epi64_rpl(vH,vF);
                _mm_store_si128(pvHStore + i, vH);
                vSaturationCheckMin = _mm_min_epi64_rpl(vSaturationCheckMin, vH);
                vSaturationCheckMax = _mm_max_epi64_rpl(vSaturationCheckMax, vH);
#ifdef PARASAIL_TABLE
                arr_store_si128(result->tables->score_table, vH, i, segLen, j, s2Len);
#endif
                vH = _mm_sub_epi64(vH, vGapO);
                vF = _mm_sub_epi64(vF, vGapE);
                if (! _mm_movemask_epi8(_mm_cmpgt_epi64_rpl(vF, vH))) goto end;
                /*vF = _mm_max_epi64_rpl(vF, vH);*/
            }
        }
end:
        {
        }

#ifdef PARASAIL_ROWCOL
        /* extract last value from the column */
        {
            vH = _mm_load_si128(pvHStore + offset);
            for (k=0; k<position; ++k) {
                vH = _mm_slli_si128(vH, 8);
            }
            result->rowcols->score_row[j] = (int64_t) _mm_extract_epi64_rpl (vH, 1);
        }
#endif
    }

#ifdef PARASAIL_ROWCOL
    for (i=0; i<segLen; ++i) {
        __m128i vH = _mm_load_si128(pvHStore+i);
        arr_store_col(result->rowcols->score_col, vH, i, segLen);
    }
#endif

    /* extract last value from the last column */
    {
        __m128i vH = _mm_load_si128(pvHStore + 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(boundary);
    parasail_free(pvE);
    parasail_free(pvHLoad);
    parasail_free(pvHStore);

    return result;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0xd8, %rsp
movq %rsi, 0x60(%rsp)
testq %rdi, %rdi
je 0x3ecf34
movq 0x60(%rdi), %rax
movq %rax, 0xa8(%rsp)
testq %rax, %rax
je 0x3ecf3b
movq 0x10(%rdi), %rax
movq %rax, 0x58(%rsp)
testq %rax, %rax
je 0x3ecf42
movl 0x8(%rdi), %edi
testl %edi, %edi
jle 0x3ecf49
cmpq $0x0, 0x60(%rsp)
je 0x3ecf50
movl %edx, %r13d
testl %edx, %edx
jle 0x3ecf57
movl %ecx, %r15d
testl %ecx, %ecx
js 0x3ecf5e
testl %r8d, %r8d
js 0x3ecf65
movl %r8d, 0x30(%rsp)
leal -0x1(%rdi), %eax
incq %rdi
movq %rdi, %rbx
shrq %rbx
movl %eax, 0x1c(%rsp)
cltd
idivl %ebx
movl %eax, %ebp
movl %edx, %r12d
movl %r15d, %ecx
negl %r15d
movq 0x58(%rsp), %rsi
movslq 0x20(%rsi), %rax
movq %rcx, 0x68(%rsp)
btsq $0x3f, %rcx
movabsq $-0x8000000000000000, %r14 # imm = 0x8000000000000000
subq %rax, %r14
cmpl %r15d, %eax
cmovgq %rcx, %r14
movslq 0x1c(%rsi), %rax
movq %rax, 0x10(%rsp)
andl $0x7ffffffe, %edi       # imm = 0x7FFFFFFE
movl %r13d, %esi
callq 0x20959f
testq %rax, %rax
je 0x3ecf6a
movl %r15d, 0x8(%rsp)
movl %r12d, 0x48(%rsp)
movl %ebp, 0x4c(%rsp)
movq %r14, 0x50(%rsp)
movq %rax, 0x38(%rsp)
orl $0x2820801, 0xc(%rax)   # imm = 0x2820801
movl $0x10, %edi
movq %rbx, %rsi
callq 0x2ea474
movq %rax, %r14
movl $0x10, %edi
movq %rbx, %rsi
callq 0x2ea474
movq %r13, %r15
movq %rax, %r13
movl $0x10, %edi
movq %rbx, %rsi
callq 0x2ea474
movq %rax, %r12
leal 0x1(%r15), %ebp
movl $0x10, %edi
movq %rbp, %rsi
callq 0x2094de
movq %rax, %r11
testq %r14, %r14
sete %al
testq %r13, %r13
sete %cl
orb %al, %cl
testq %r12, %r12
sete %al
testq %r11, %r11
sete %dl
orb %al, %dl
orb %cl, %dl
jne 0x3ecf6a
movq %r12, 0x28(%rsp)
movq %r15, 0x20(%rsp)
leal -0x1(%r15), %eax
movl %eax, 0x44(%rsp)
movq 0x68(%rsp), %rsi
movq %rsi, %xmm0
pshufd $0x44, %xmm0, %xmm0     # xmm0 = xmm0[0,1,0,1]
movl 0x30(%rsp), %edx
movd %edx, %xmm1
pshufd $0x44, %xmm1, %xmm1     # xmm1 = xmm1[0,1,0,1]
movq 0x50(%rsp), %rax
incq %rax
movabsq $-0x8000000000000000, %rcx # imm = 0x8000000000000000
subq 0x10(%rsp), %rcx
addq $-0x2, %rcx
movq %rax, %xmm2
pshufd $0x44, %xmm2, %xmm2     # xmm2 = xmm2[0,1,0,1]
movq %rcx, 0x88(%rsp)
movq %rcx, %xmm3
pshufd $0x44, %xmm3, %xmm3     # xmm3 = xmm3[0,1,0,1]
movl %edx, %eax
movl 0x8(%rsp), %r15d
movslq %r15d, %rcx
movq %rbx, %r12
movl %ebx, %edi
negq %rsi
movq %rdi, 0x10(%rsp)
imulq %rax, %rdi
xorl %r8d, %r8d
movq %rcx, %rdx
xorl %r9d, %r9d
movq %rdx, 0xc0(%rsp,%r9,8)
leaq (%rsi,%rdx), %r10
movq %r10, 0xb0(%rsp,%r9,8)
incq %r9
subq %rdi, %rdx
cmpq $0x1, %r9
je 0x3eca0b
movq %r8, %rdx
shlq $0x4, %rdx
movaps 0xc0(%rsp), %xmm4
movaps %xmm4, (%r14,%rdx)
movaps 0xb0(%rsp), %xmm4
movq 0x28(%rsp), %r9
movaps %xmm4, (%r9,%rdx)
incq %r8
subq %rax, %rcx
cmpq 0x10(%rsp), %r8
jne 0x3eca05
movq $0x0, (%r11)
movslq %r15d, %rcx
movl $0x1, %edx
movq %rcx, (%r11,%rdx,8)
incq %rdx
subq %rax, %rcx
cmpq %rdx, %rbp
jne 0x3eca6d
movq %r12, %r8
leal -0x1(%r12), %eax
movq 0x20(%rsp), %r12
movl %r12d, %edx
cmpl $0x1, %r8d
movl %r8d, %edi
adcl $0x0, %edi
cmpl $0x2, %r12d
movl $0x1, %ecx
cmovgel %r12d, %ecx
movq %rcx, 0x98(%rsp)
movq 0x10(%rsp), %rbx
imulq %rdx, %rbx
shlq $0x2, %rbx
shlq $0x2, %rdx
shlq $0x4, %rdi
xorl %esi, %esi
shlq $0x4, %rax
movq %rax, 0xa0(%rsp)
movslq %r8d, %rax
movq %rax, 0x90(%rsp)
xorl %r8d, %r8d
movdqa %xmm2, %xmm4
movq %r11, 0x70(%rsp)
movq %rbx, 0x30(%rsp)
movq 0xa0(%rsp), %rax
movq %r14, 0x20(%rsp)
pshufd $0x44, (%r14,%rax), %xmm6 # xmm6 = mem[0,1,0,1]
movq %r13, %r14
movq 0x58(%rsp), %rax
movq 0x10(%rax), %rax
movq 0x60(%rsp), %rcx
movzbl (%rcx,%r8), %ecx
movslq (%rax,%rcx,4), %rax
imulq 0x90(%rsp), %rax
shlq $0x4, %rax
movq %r8, 0x78(%rsp)
pinsrq $0x0, (%r11,%r8,8), %xmm6
addq 0xa8(%rsp), %rax
movq %rax, 0x8(%rsp)
movq %rsi, 0x80(%rsp)
movq %rsi, %rcx
xorl %r9d, %r9d
movdqa %xmm2, %xmm5
movq 0x8(%rsp), %rax
paddq (%rax,%r9), %xmm6
movq 0x28(%rsp), %rsi
movq (%rsi,%r9), %r15
movq %xmm6, %rax
cmpq %r15, %rax
cmovleq %r15, %rax
movq 0x8(%rsi,%r9), %rbx
pextrq $0x1, %xmm6, %rsi
cmpq %rbx, %rsi
cmovleq %rbx, %rsi
movq %xmm5, %r13
cmpq %r13, %rax
cmovleq %r13, %rax
pextrq $0x1, %xmm5, %rbp
cmpq %rbp, %rsi
cmovleq %rbp, %rsi
movq %rdx, %r8
movq %xmm4, %rdx
cmpq %rax, %rdx
cmovleq %rax, %rdx
movq %rdi, %r10
pextrq $0x1, %xmm4, %rdi
cmpq %rsi, %rdi
cmovleq %rsi, %rdi
movq %xmm3, %r11
cmpq %rax, %r11
cmovgeq %rax, %r11
pextrq $0x1, %xmm3, %r12
cmpq %rsi, %r12
cmovgeq %rsi, %r12
cmpq %r15, %r11
cmovgeq %r15, %r11
movq %rdi, %xmm6
cmpq %rbx, %r12
cmovgeq %rbx, %r12
movq 0x30(%rsp), %rbx
cmpq %r13, %r11
cmovgeq %r13, %r11
movq 0x28(%rsp), %r15
movdqa (%r15,%r9), %xmm3
movq %rax, %xmm7
pinsrq $0x1, %rsi, %xmm7
movdqa %xmm7, (%r14,%r9)
movq %rdx, %xmm4
cmpq %rbp, %r12
cmovgeq %rbp, %r12
movq 0x38(%rsp), %rdx
movq 0x10(%rdx), %rdx
movq (%rdx), %rdx
movl %eax, (%rdx,%rcx)
addq %rcx, %rdx
movl %esi, (%rbx,%rdx)
psubq %xmm0, %xmm7
psubq %xmm1, %xmm3
movq %xmm3, %rax
movq %xmm7, %rdx
cmpq %rdx, %rax
cmovleq %rdx, %rax
pextrq $0x1, %xmm3, %rsi
pextrq $0x1, %xmm7, %rdi
movq %r12, %xmm7
cmpq %rdi, %rsi
cmovleq %rdi, %rsi
movq %r11, %xmm3
psubq %xmm1, %xmm5
movq %xmm5, %r11
cmpq %rdx, %r11
cmovgq %r11, %rdx
pextrq $0x1, %xmm5, %r11
movq %rsi, %xmm8
cmpq %rdi, %r11
cmovgq %r11, %rdi
movq %rax, %xmm9
movq %rdi, %xmm10
movq %r10, %rdi
movq %rdx, %xmm5
movq %r8, %rdx
punpcklqdq %xmm6, %xmm4    # xmm4 = xmm4[0],xmm6[0]
punpcklqdq %xmm7, %xmm3    # xmm3 = xmm3[0],xmm7[0]
punpcklqdq %xmm8, %xmm9    # xmm9 = xmm9[0],xmm8[0]
movdqa %xmm9, (%r15,%r9)
punpcklqdq %xmm10, %xmm5   # xmm5 = xmm5[0],xmm10[0]
movq 0x20(%rsp), %rax
movdqa (%rax,%r9), %xmm6
addq $0x10, %r9
addq %r8, %rcx
cmpq %r9, %r10
jne 0x3ecb51
movq $0x0, 0x8(%rsp)
movq 0x70(%rsp), %rax
movq 0x78(%rsp), %rcx
movq 0x8(%rax,%rcx,8), %rax
subq 0x68(%rsp), %rax
pshufd $0x44, %xmm5, %xmm5     # xmm5 = xmm5[0,1,0,1]
pinsrq $0x0, %rax, %xmm5
movb $0x1, %r11b
movl $0x1, %eax
movq 0x80(%rsp), %rsi
xorl %r12d, %r12d
movq %xmm5, %rbx
movq (%r14,%r12), %rcx
movq 0x8(%r14,%r12), %rdx
cmpq %rbx, %rcx
cmovgq %rcx, %rbx
pextrq $0x1, %xmm5, %r13
movq %rbx, %xmm6
cmpq %r13, %rdx
cmovgq %rdx, %r13
pinsrq $0x1, %r13, %xmm6
movq %xmm3, %rbp
cmpq %rbx, %rbp
cmovgeq %rbx, %rbp
pextrq $0x1, %xmm3, %r15
movdqa %xmm6, (%r14,%r12)
cmpq %r13, %r15
cmovgeq %r13, %r15
movq %r15, %xmm7
movq %rbp, %xmm3
movq %xmm4, %r9
cmpq %rbx, %r9
cmovleq %rbx, %r9
pextrq $0x1, %xmm4, %rcx
punpcklqdq %xmm7, %xmm3    # xmm3 = xmm3[0],xmm7[0]
cmpq %r13, %rcx
cmovleq %r13, %rcx
movq %rcx, %xmm7
movq %r9, %xmm4
punpcklqdq %xmm7, %xmm4    # xmm4 = xmm4[0],xmm7[0]
movq 0x38(%rsp), %rdx
movq 0x10(%rdx), %rdx
movq (%rdx), %rdx
movl %ebx, (%rdx,%rsi)
movq 0x30(%rsp), %rbx
addq %rsi, %rdx
movl %r13d, (%rbx,%rdx)
psubq %xmm0, %xmm6
psubq %xmm1, %xmm5
movdqa %xmm5, %xmm7
pcmpgtq %xmm6, %xmm7
movmskpd %xmm7, %edx
movl %edx, %edi
shrb %dil
andl $0x1, %edx
negq %rdx
movzbl %dil, %edi
negq %rdi
movq %rdx, %xmm6
movq %rdi, %xmm7
movq %r10, %rdi
punpcklqdq %xmm7, %xmm6    # xmm6 = xmm6[0],xmm7[0]
pmovmskb %xmm6, %edx
testl %edx, %edx
movq %r8, %rdx
je 0x3ece13
cmpq 0x10(%rsp), %rax
setb %r11b
addq $0x10, %r12
addq %rdx, %rsi
incq %rax
cmpq %r12, %rdi
jne 0x3ecd14
testb $0x1, %r11b
jne 0x3ece2e
movq 0x8(%rsp), %rsi
leal 0x1(%rsi), %eax
testl %esi, %esi
movq %rax, 0x8(%rsp)
je 0x3ecce1
movq 0x78(%rsp), %r8
incq %r8
movq 0x80(%rsp), %rsi
addq $0x4, %rsi
movq 0x20(%rsp), %r12
movq %r12, %r13
cmpq 0x98(%rsp), %r8
movq 0x70(%rsp), %r11
jne 0x3ecaea
movl 0x48(%rsp), %eax
shlq $0x4, %rax
movdqa (%r14,%rax), %xmm0
movl 0x4c(%rsp), %eax
testl %eax, %eax
jle 0x3ece7e
movq 0x38(%rsp), %rbx
movl 0x1c(%rsp), %esi
jmp 0x3ece90
movq 0x38(%rsp), %rbx
movl 0x1c(%rsp), %esi
pslldq $0x8, %xmm0             # xmm0 = zero,zero,zero,zero,zero,zero,zero,zero,xmm0[0,1,2,3,4,5,6,7]
testl %eax, %eax
js 0x3ece87
xorl %eax, %eax
movq 0x50(%rsp), %rdi
cmpq %rdi, %rbp
setle %al
negq %rax
xorl %edx, %edx
cmpq %rdi, %r15
setle %dl
negq %rdx
movq %rdx, %xmm1
movq %rax, %xmm2
punpcklqdq %xmm1, %xmm2    # xmm2 = xmm2[0],xmm1[0]
xorl %eax, %eax
movq 0x88(%rsp), %rdi
cmpq %rdi, %r9
setg %al
negq %rax
xorl %edx, %edx
cmpq %rdi, %rcx
setg %dl
negq %rdx
movq %rdx, %xmm1
movq %rax, %xmm3
punpcklqdq %xmm1, %xmm3    # xmm3 = xmm3[0],xmm1[0]
por %xmm2, %xmm3
pmovmskb %xmm3, %eax
testl %eax, %eax
je 0x3ecefd
orb $0x40, 0xc(%rbx)
xorl %eax, %eax
xorl %ecx, %ecx
xorl %esi, %esi
jmp 0x3ecf08
pextrq $0x1, %xmm0, %rax
movl 0x44(%rsp), %ecx
movl %eax, (%rbx)
movl %esi, 0x4(%rbx)
movl %ecx, 0x8(%rbx)
movq %r11, %rdi
callq 0x2094b5
movq 0x28(%rsp), %rdi
callq 0x2094b5
movq %r12, %rdi
callq 0x2094b5
movq %r14, %rdi
callq 0x2094b5
jmp 0x3ecf6c
callq 0x1cb2b1
jmp 0x3ecf6a
callq 0x1cb28b
jmp 0x3ecf6a
callq 0x1cb265
jmp 0x3ecf6a
callq 0x1cb23f
jmp 0x3ecf6a
callq 0x1cb219
jmp 0x3ecf6a
callq 0x1cb1f3
jmp 0x3ecf6a
callq 0x1cb1cd
jmp 0x3ecf6a
callq 0x1cb1a7
xorl %ebx, %ebx
movq %rbx, %rax
addq $0xd8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
nopl (%rax)