// File: /workspace/github_c_makefile_star2_O1/nh13[P]ksw/src/parasail/src/sw_striped_avx2_256_64.c
// Function: parasail_sw_table_striped_profile_avx2_256_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 end_query = 0;
    int32_t end_ref = 0;
    int32_t s1Len = 0;
    const parasail_matrix_t *matrix = NULL;
    int32_t segWidth = 0;
    int32_t segLen = 0;
#ifdef PARASAIL_ROWCOL
    int32_t offset = 0;
    int32_t position = 0;
#endif
    __m256i* restrict vProfile = NULL;
    __m256i* restrict pvHStore = NULL;
    __m256i* restrict pvHLoad = NULL;
    __m256i* restrict pvHMax = NULL;
    __m256i* restrict pvE = NULL;
    __m256i vGapO;
    __m256i vGapE;
    __m256i vZero;
    __m256i vNegInf;
    int64_t score = 0;
    __m256i vMaxH;
    __m256i vMaxHUnit;
    int64_t maxp = 0;
    /*int64_t stop = 0;*/
    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;
    end_query = 0;
    end_ref = 0;
    s1Len = profile->s1Len;
    matrix = profile->matrix;
    segWidth = 4; /* number of values in vector unit */
    segLen = (s1Len + segWidth - 1) / segWidth;
#ifdef PARASAIL_ROWCOL
    offset = (s1Len - 1) % segLen;
    position = (segWidth - 1) - (s1Len - 1) / segLen;
#endif
    vProfile = (__m256i*)profile->profile64.score;
    vGapO = _mm256_set1_epi64x_rpl(open);
    vGapE = _mm256_set1_epi64x_rpl(gap);
    vZero = _mm256_setzero_si256();
    vNegInf = _mm256_set1_epi64x_rpl(NEG_INF);
    score = NEG_INF;
    vMaxH = vNegInf;
    vMaxHUnit = vNegInf;
    maxp = INT64_MAX - (int64_t)(matrix->max+1);
    /*stop = profile->stop == INT32_MAX ?  INT64_MAX : (int64_t)profile->stop;*/

    /* 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_SW | PARASAIL_FLAG_STRIPED
        | PARASAIL_FLAG_BITS_64 | 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 */
    pvHStore = parasail_memalign___m256i(32, segLen);
    pvHLoad =  parasail_memalign___m256i(32, segLen);
    pvHMax = parasail_memalign___m256i(32, segLen);
    pvE = parasail_memalign___m256i(32, segLen);

    /* validate heap variables */
    if (!pvHStore) return NULL;
    if (!pvHLoad) return NULL;
    if (!pvHMax) return NULL;
    if (!pvE) return NULL;

    /* initialize H and E */
    parasail_memset___m256i(pvHStore, vZero, segLen);
    parasail_memset___m256i(pvE, _mm256_set1_epi64x_rpl(-open), segLen);

    /* outer loop over database sequence */
    for (j=0; j<s2Len; ++j) {
        __m256i vE;
        __m256i vF;
        __m256i vH;
        const __m256i* vP = NULL;
        __m256i* pv = NULL;

        /* Initialize F value to 0.  Any errors to vH values will be
         * corrected in the Lazy_F loop. */
        vF = vZero;

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

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

        if (end_ref == j-2) {
            /* Swap in the max buffer. */
            pv = pvHMax;
            pvHMax = pvHLoad;
            pvHLoad = pvHStore;
            pvHStore = pv;
        }
        else {
            /* Swap the 2 H buffers. */
            pv = pvHLoad;
            pvHLoad = pvHStore;
            pvHStore = pv;
        }

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

            /* Get max from vH, vE and vF. */
            vH = _mm256_max_epi64_rpl(vH, vE);
            vH = _mm256_max_epi64_rpl(vH, vF);
            vH = _mm256_max_epi64_rpl(vH, vZero);
            /* Save vH values. */
            _mm256_store_si256(pvHStore + i, vH);
#ifdef PARASAIL_TABLE
            arr_store_si256(result->tables->score_table, vH, i, segLen, j, s2Len);
#endif
            vMaxH = _mm256_max_epi64_rpl(vH, vMaxH);

            /* Update vE value. */
            vH = _mm256_sub_epi64(vH, vGapO);
            vE = _mm256_sub_epi64(vE, vGapE);
            vE = _mm256_max_epi64_rpl(vE, vH);
            _mm256_store_si256(pvE + i, vE);

            /* Update vF value. */
            vF = _mm256_sub_epi64(vF, vGapE);
            vF = _mm256_max_epi64_rpl(vF, vH);

            /* Load the next vH. */
            vH = _mm256_load_si256(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) {
            vF = _mm256_slli_si256_rpl(vF, 8);
            for (i=0; i<segLen; ++i) {
                vH = _mm256_load_si256(pvHStore + i);
                vH = _mm256_max_epi64_rpl(vH,vF);
                _mm256_store_si256(pvHStore + i, vH);
#ifdef PARASAIL_TABLE
                arr_store_si256(result->tables->score_table, vH, i, segLen, j, s2Len);
#endif
                vMaxH = _mm256_max_epi64_rpl(vH, vMaxH);
                vH = _mm256_sub_epi64(vH, vGapO);
                vF = _mm256_sub_epi64(vF, vGapE);
                if (! _mm256_movemask_epi8(_mm256_cmpgt_epi64(vF, vH))) goto end;
                /*vF = _mm256_max_epi64_rpl(vF, vH);*/
            }
        }
end:
        {
        }

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

        {
            __m256i vCompare = _mm256_cmpgt_epi64(vMaxH, vMaxHUnit);
            if (_mm256_movemask_epi8(vCompare)) {
                score = _mm256_hmax_epi64_rpl(vMaxH);
                /* if score has potential to overflow, abort early */
                if (score > maxp) {
                    result->flag |= PARASAIL_FLAG_SATURATED;
                    break;
                }
                vMaxHUnit = _mm256_set1_epi64x_rpl(score);
                end_ref = j;
            }
        }

        /*if (score == stop) break;*/
    }

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

    if (score == INT64_MAX) {
        result->flag |= PARASAIL_FLAG_SATURATED;
    }

    if (parasail_result_is_saturated(result)) {
        score = INT64_MAX;
        end_query = 0;
        end_ref = 0;
    }
    else {
        if (end_ref == j-1) {
            /* end_ref was the last store column */
            __m256i *pv = pvHMax;
            pvHMax = pvHStore;
            pvHStore = pv;
        }
        else if (end_ref == j-2) {
            /* end_ref was the last load column */
            __m256i *pv = pvHMax;
            pvHMax = pvHLoad;
            pvHLoad = pv;
        }
        /* Trace the alignment ending position on read. */
        {
            int64_t *t = (int64_t*)pvHMax;
            int32_t column_len = segLen * segWidth;
            end_query = s1Len - 1;
            for (i = 0; i<column_len; ++i, ++t) {
                if (*t == score) {
                    int32_t temp = i / segWidth + i % segWidth * segLen;
                    if (temp < end_query) {
                        end_query = temp;
                    }
                }
            }
        }
    }

    result->score = score;
    result->end_query = end_query;
    result->end_ref = end_ref;

    parasail_free(pvE);
    parasail_free(pvHMax);
    parasail_free(pvHLoad);
    parasail_free(pvHStore);

    return result;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x108, %rsp            # imm = 0x108
movq %rsi, 0x68(%rsp)
testq %rdi, %rdi
je 0x4e0a33
movq 0x60(%rdi), %rax
movq %rax, 0xb8(%rsp)
testq %rax, %rax
je 0x4e0a3a
movq 0x10(%rdi), %rax
movq %rax, 0x60(%rsp)
testq %rax, %rax
je 0x4e0a41
movl 0x8(%rdi), %eax
testl %eax, %eax
jle 0x4e0a48
cmpq $0x0, 0x68(%rsp)
je 0x4e0a4f
movl %edx, %r15d
testl %edx, %edx
jle 0x4e0a56
movl %ecx, %r14d
testl %ecx, %ecx
js 0x4e0a5d
movl %r8d, %r12d
testl %r8d, %r8d
js 0x4e0a64
movq %rax, 0x98(%rsp)
leaq 0x3(%rax), %rbx
movq 0x60(%rsp), %rax
movslq 0x1c(%rax), %rax
movq %rax, 0x30(%rsp)
movl %ebx, %ebp
andl $0x7ffffffc, %ebp       # imm = 0x7FFFFFFC
movl %ebp, %edi
movl %r15d, %esi
callq 0x20959f
testq %rax, %rax
je 0x4e0a69
movl %r12d, 0x28(%rsp)
movl %ebp, 0x4c(%rsp)
movq %r15, 0x50(%rsp)
shrq $0x2, %rbx
movq %rax, (%rsp)
orl $0x4820804, 0xc(%rax)   # imm = 0x4820804
movl $0x20, %edi
movq %rbx, %rsi
callq 0x4c5e3c
movq %rax, %r13
movl $0x20, %edi
movq %rbx, %rsi
callq 0x4c5e3c
movq %rax, %r12
movl $0x20, %edi
movq %rbx, %rsi
callq 0x4c5e3c
movq %rax, %rbp
movl $0x20, %edi
movq %rbx, %rsi
callq 0x4c5e3c
testq %r13, %r13
sete %dl
testq %r12, %r12
sete %cl
orb %dl, %cl
testq %rbp, %rbp
sete %sil
testq %rax, %rax
sete %dl
orb %sil, %dl
orb %cl, %dl
jne 0x4e0a69
movabsq $0x7fffffffffffffff, %rcx # imm = 0x7FFFFFFFFFFFFFFF
movl %r14d, %edx
vmovq %rdx, %xmm0
vpbroadcastq %xmm0, %ymm0
vmovdqu %ymm0, 0xe0(%rsp)
movl 0x28(%rsp), %edx
vmovq %rdx, %xmm0
vpbroadcastq %xmm0, %ymm0
vmovdqu %ymm0, 0xc0(%rsp)
movq 0x30(%rsp), %rdx
notq %rdx
addq %rcx, %rdx
movq %rdx, 0x30(%rsp)
vpxor %xmm0, %xmm0, %xmm0
movq %r13, %rdi
movq %rbx, %rsi
movq %rax, %r15
callq 0x4c5e45
negl %r14d
movslq %r14d, %rax
vmovq %rax, %xmm0
vpbroadcastq %xmm0, %ymm0
movq %r15, 0x58(%rsp)
movq %r15, %rdi
movq %rbx, %rsi
callq 0x4c5e45
vmovdqu 0xc0(%rsp), %ymm14
vmovdqu 0xe0(%rsp), %ymm13
xorl %edi, %edi
leal -0x1(%rbx), %ecx
movl 0x50(%rsp), %eax
movq %rbx, 0x90(%rsp)
movl %ebx, %edx
movq %rdx, %r9
imulq %rax, %r9
leaq (,%r9,4), %rsi
movq %rax, 0xa0(%rsp)
leaq (,%rax,4), %r8
shlq $0x3, %r9
movq %r9, 0x28(%rsp)
movq %rsi, 0x80(%rsp)
leaq (%rsi,%rsi,2), %rbx
movq %rdx, 0xa8(%rsp)
shlq $0x5, %rdx
movabsq $-0x4000000000000000, %rax # imm = 0xC000000000000000
vpbroadcastq 0x117455(%rip), %ymm0 # 0x5f7880
shlq $0x5, %rcx
movq %rcx, 0xb0(%rsp)
xorl %r14d, %r14d
xorl %r11d, %r11d
vmovdqa %ymm0, %ymm1
movq (%rsp), %r9
movq %r13, %rsi
movq %rdx, 0x88(%rsp)
movq %rbx, 0x78(%rsp)
movq %rax, 0x10(%rsp)
movq %rsi, %r10
movq 0x60(%rsp), %rax
movq 0x10(%rax), %rax
movq 0x68(%rsp), %rcx
movzbl (%rcx,%r11), %ecx
movslq (%rax,%rcx,4), %rax
movq 0xa8(%rsp), %rdx
imulq %rax, %rdx
shlq $0x5, %rdx
addq 0xb8(%rsp), %rdx
movq %r11, 0x38(%rsp)
leal -0x2(%r11), %eax
movq %rdi, 0x70(%rsp)
cmpl %eax, %edi
movq %r12, %rax
cmoveq %rbp, %rax
movq %rax, 0x20(%rsp)
cmoveq %r12, %rbp
movq %rbp, 0x40(%rsp)
movq 0xb0(%rsp), %rax
vmovdqa (%rsi,%rax), %ymm2
vperm2i128 $0x8, %ymm2, %ymm2, %ymm3 # ymm3 = zero,zero,ymm2[0,1]
vpalignr $0x8, %ymm3, %ymm2, %ymm3 # ymm3 = ymm3[8,9,10,11,12,13,14,15],ymm2[0,1,2,3,4,5,6,7],ymm3[24,25,26,27,28,29,30,31],ymm2[16,17,18,19,20,21,22,23]
movq %r14, 0x18(%rsp)
movq %r14, %r12
xorl %eax, %eax
vpxor %xmm2, %xmm2, %xmm2
movq 0x58(%rsp), %rsi
vpaddq (%rdx,%rax), %ymm3, %ymm3
vmovq %xmm3, %rdi
movq (%rsi,%rax), %rcx
cmpq %rcx, %rdi
cmovgq %rdi, %rcx
movq 0x8(%rsi,%rax), %r11
vpextrq $0x1, %xmm3, %rdi
cmpq %r11, %rdi
cmovgq %rdi, %r11
vextracti128 $0x1, %ymm3, %xmm3
vmovq %xmm3, %rdi
movq %r8, %r15
movq 0x10(%rsi,%rax), %r8
cmpq %r8, %rdi
cmovgq %rdi, %r8
movq 0x18(%rsi,%rax), %r14
vpextrq $0x1, %xmm3, %rdi
cmpq %r14, %rdi
cmovgq %rdi, %r14
vmovq %xmm2, %rdi
cmpq %rdi, %rcx
cmovleq %rdi, %rcx
vpextrq $0x1, %xmm2, %rdi
cmpq %rdi, %r11
cmovleq %rdi, %r11
vextracti128 $0x1, %ymm2, %xmm3
vmovq %xmm3, %rdi
cmpq %rdi, %r8
cmovleq %rdi, %r8
vpextrq $0x1, %xmm3, %rdi
vmovdqa (%rsi,%rax), %ymm3
cmpq %rdi, %r14
cmovleq %rdi, %r14
movq %rcx, %rdi
sarq $0x3f, %rdi
andnq %rcx, %rdi, %rbx
movq %r11, %rcx
sarq $0x3f, %rcx
andnq %r11, %rcx, %rbp
movq %r8, %rcx
sarq $0x3f, %rcx
andnq %r8, %rcx, %rcx
vmovq %rbp, %xmm4
vmovq %rbx, %xmm5
vpunpcklqdq %xmm4, %xmm5, %xmm4 # xmm4 = xmm5[0],xmm4[0]
vmovq %rcx, %xmm5
vinserti128 $0x1, %xmm5, %ymm4, %ymm4
movq %r14, %rdi
sarq $0x3f, %rdi
andnq %r14, %rdi, %r8
vmovq %r8, %xmm5
vpbroadcastq %xmm5, %ymm5
vpblendd $0xc0, %ymm5, %ymm4, %ymm4 # ymm4 = ymm4[0,1,2,3,4,5],ymm5[6,7]
movq 0x20(%rsp), %rdi
vmovdqa %ymm4, (%rdi,%rax)
movq 0x10(%r9), %rdi
movq (%rdi), %rdi
movl %ebx, (%rdi,%r12)
addq %r12, %rdi
vmovq %xmm1, %r11
cmpq %r11, %rbx
cmovgq %rbx, %r11
vpextrq $0x1, %xmm1, %rbx
movq 0x80(%rsp), %r9
movl %ebp, (%r9,%rdi)
cmpq %rbx, %rbp
cmovgq %rbp, %rbx
movq 0x28(%rsp), %r9
movl %ecx, (%r9,%rdi)
vextracti128 $0x1, %ymm1, %xmm1
movq %r10, %r13
vmovq %xmm1, %r10
cmpq %r10, %rcx
cmovgq %rcx, %r10
vpextrq $0x1, %xmm1, %rcx
movq 0x78(%rsp), %r9
movl %r8d, (%r9,%rdi)
cmpq %rcx, %r8
cmovgq %r8, %rcx
vmovq %rcx, %xmm1
vpsubq %ymm13, %ymm4, %ymm5
vpsubq %ymm14, %ymm3, %ymm6
vmovq %xmm6, %rbp
vmovq %xmm5, %rcx
cmpq %rcx, %rbp
cmovleq %rcx, %rbp
vpextrq $0x1, %xmm6, %r9
vpextrq $0x1, %xmm5, %r14
vmovq %r10, %xmm3
cmpq %r14, %r9
cmovleq %r14, %r9
vmovq %rbx, %xmm4
vextracti128 $0x1, %ymm6, %xmm6
vmovq %xmm6, %r8
vextracti128 $0x1, %ymm5, %xmm5
vmovq %xmm5, %rbx
cmpq %rbx, %r8
cmovleq %rbx, %r8
vpextrq $0x1, %xmm6, %r10
vpextrq $0x1, %xmm5, %rdi
vmovq %r11, %xmm5
cmpq %rdi, %r10
cmovleq %rdi, %r10
vmovq %r9, %xmm6
vpsubq %ymm14, %ymm2, %ymm2
vmovq %xmm2, %r9
cmpq %rcx, %r9
cmovgq %r9, %rcx
vpextrq $0x1, %xmm2, %r9
vmovq %rbp, %xmm7
cmpq %r14, %r9
cmovgq %r9, %r14
vmovq %r10, %xmm8
movq %r13, %r10
vextracti128 $0x1, %ymm2, %xmm2
vmovq %xmm2, %r9
cmpq %rbx, %r9
cmovgq %r9, %rbx
vpextrq $0x1, %xmm2, %r9
vmovq %r8, %xmm2
movq %r15, %r8
cmpq %rdi, %r9
cmovgq %r9, %rdi
movq (%rsp), %r9
vmovq %rdi, %xmm9
vmovq %rbx, %xmm10
vmovq %r14, %xmm11
vmovq %rcx, %xmm12
vpunpcklqdq %xmm1, %xmm3, %xmm1 # xmm1 = xmm3[0],xmm1[0]
vpunpcklqdq %xmm4, %xmm5, %xmm3 # xmm3 = xmm5[0],xmm4[0]
vpunpcklqdq %xmm6, %xmm7, %xmm4 # xmm4 = xmm7[0],xmm6[0]
vpunpcklqdq %xmm8, %xmm2, %xmm2 # xmm2 = xmm2[0],xmm8[0]
vmovdqa %xmm2, 0x10(%rsi,%rax)
vmovdqa %xmm4, (%rsi,%rax)
vinserti128 $0x1, %xmm1, %ymm3, %ymm1
vpunpcklqdq %xmm9, %xmm10, %xmm2 # xmm2 = xmm10[0],xmm9[0]
vpunpcklqdq %xmm11, %xmm12, %xmm3 # xmm3 = xmm12[0],xmm11[0]
vinserti128 $0x1, %xmm2, %ymm3, %ymm2
vmovapd (%r13,%rax), %ymm3
addq $0x20, %rax
addq %r15, %r12
cmpq %rax, 0x88(%rsp)
jne 0x4e04dd
movq 0x78(%rsp), %rbx
movl $0x0, 0xc(%rsp)
movq 0x20(%rsp), %rsi
movq 0x80(%rsp), %rbp
vperm2i128 $0x8, %ymm2, %ymm2, %ymm3 # ymm3 = zero,zero,ymm2[0,1]
vpalignr $0x8, %ymm3, %ymm2, %ymm2 # ymm2 = ymm3[8,9,10,11,12,13,14,15],ymm2[0,1,2,3,4,5,6,7],ymm3[24,25,26,27,28,29,30,31],ymm2[16,17,18,19,20,21,22,23]
movq 0x18(%rsp), %rcx
xorl %r14d, %r14d
vmovq %xmm2, %rdx
movq (%rsi,%r14), %rax
cmpq %rdx, %rax
cmovgq %rax, %rdx
movq 0x8(%rsi,%r14), %rax
vpextrq $0x1, %xmm2, %r12
cmpq %r12, %rax
cmovgq %rax, %r12
movq 0x10(%rsi,%r14), %rax
vextracti128 $0x1, %ymm2, %xmm3
vmovq %xmm3, %r11
cmpq %r11, %rax
cmovgq %rax, %r11
vmovq %r12, %xmm4
vmovq %rdx, %xmm5
vpunpcklqdq %xmm4, %xmm5, %xmm4 # xmm4 = xmm5[0],xmm4[0]
vmovq %r11, %xmm5
vinserti128 $0x1, %xmm5, %ymm4, %ymm4
movq 0x18(%rsi,%r14), %rdi
vpextrq $0x1, %xmm3, %rax
cmpq %rax, %rdi
cmovgq %rdi, %rax
vmovq %rax, %xmm3
vpbroadcastq %xmm3, %ymm3
vpblendd $0xc0, %ymm3, %ymm4, %ymm3 # ymm3 = ymm4[0,1,2,3,4,5],ymm3[6,7]
vmovdqa %ymm3, (%rsi,%r14)
movq 0x10(%r9), %rdi
movq (%rdi), %rdi
movl %edx, (%rdi,%rcx)
addq %rcx, %rdi
movl %r12d, (%rbp,%rdi)
movq 0x28(%rsp), %r8
movl %r11d, (%r8,%rdi)
vmovq %xmm1, %r8
cmpq %r8, %rdx
cmovleq %r8, %rdx
vpextrq $0x1, %xmm1, %r8
cmpq %r8, %r12
cmovleq %r8, %r12
vextracti128 $0x1, %ymm1, %xmm1
vmovq %xmm1, %r8
cmpq %r8, %r11
cmovleq %r8, %r11
movl %eax, (%rbx,%rdi)
vpextrq $0x1, %xmm1, %rdi
cmpq %rdi, %rax
jg 0x4e0865
movq %rdi, %rax
vmovq %rax, %xmm1
vmovq %r11, %xmm4
vpunpcklqdq %xmm1, %xmm4, %xmm1 # xmm1 = xmm4[0],xmm1[0]
vmovq %r12, %xmm4
vmovq %rdx, %xmm5
vpunpcklqdq %xmm4, %xmm5, %xmm4 # xmm4 = xmm5[0],xmm4[0]
vinserti128 $0x1, %xmm1, %ymm4, %ymm1
vpsubq %ymm13, %ymm3, %ymm3
vpsubq %ymm14, %ymm2, %ymm2
vpcmpgtq %ymm3, %ymm2, %ymm3
vtestpd %ymm3, %ymm3
movq %r15, %r8
je 0x4e08c8
addq $0x20, %r14
addq %r8, %rcx
cmpq %r14, 0x88(%rsp)
jne 0x4e0794
movl 0xc(%rsp), %ecx
incl %ecx
movl %ecx, 0xc(%rsp)
cmpl $0x4, %ecx
jne 0x4e0780
vpcmpgtq %ymm0, %ymm1, %ymm2
movb $0x1, %cl
vtestpd %ymm2, %ymm2
je 0x4e0908
cmpq %rdx, %r11
cmovgq %r11, %rdx
cmpq %r12, %rax
cmovgq %rax, %r12
cmpq %rdx, %r12
movq %r12, %rax
cmovleq %rdx, %rax
cmpq 0x30(%rsp), %rax
jle 0x4e091e
orb $0x40, 0xc(%r9)
xorl %ecx, %ecx
movq 0x40(%rsp), %rbp
movq 0x70(%rsp), %rdi
jmp 0x4e0917
movq 0x40(%rsp), %rbp
movq 0x70(%rsp), %rdi
movq 0x10(%rsp), %rax
movq 0x38(%rsp), %r11
jmp 0x4e0935
vmovq %rax, %xmm0
vpbroadcastq %xmm0, %ymm0
movq 0x38(%rsp), %r11
movl %r11d, %edi
movq 0x40(%rsp), %rbp
movq 0x18(%rsp), %r14
testb %cl, %cl
je 0x4e095d
incq %r11
addq $0x4, %r14
movq %r10, %r12
cmpq 0xa0(%rsp), %r11
jne 0x4e0455
movq 0x50(%rsp), %rbx
jmp 0x4e0960
movl %r11d, %ebx
movq %rdi, %r14
movq %rax, 0x10(%rsp)
movabsq $0x7fffffffffffffff, %rcx # imm = 0x7FFFFFFFFFFFFFFF
cmpq %rcx, %rax
jne 0x4e097c
orb $0x40, 0xc(%r9)
movq %r9, %rdi
vzeroupper
callq 0x20a805
testl %eax, %eax
je 0x4e09ab
xorl %r10d, %r10d
movl $0xffffffff, %r11d      # imm = 0xFFFFFFFF
movq %r13, %rbx
movq %rbp, %r12
xorl %r8d, %r8d
movq (%rsp), %rdi
movq 0x20(%rsp), %rbp
jmp 0x4e0a86
leal -0x1(%rbx), %eax
addl $-0x2, %ebx
movq %r14, %r10
cmpl %ebx, %r10d
movq %r13, %rbx
cmoveq %rbp, %rbx
movq %rbp, %r12
cmoveq %r13, %r12
cmpl %eax, %r10d
movq 0x20(%rsp), %rax
cmovneq %rax, %rbp
cmoveq %r13, %rbx
cmoveq %rax, %r12
movq 0x98(%rsp), %r8
decl %r8d
cmpl $0x0, 0x4c(%rsp)
je 0x4e0a7d
movq 0x90(%rsp), %r9
movl %r9d, %eax
andl $0x1fffffff, %eax       # imm = 0x1FFFFFFF
shll $0x2, %eax
xorl %ecx, %ecx
movq (%rsp), %rdi
movq 0x10(%rsp), %r11
cmpq %r11, (%r12,%rcx,8)
jne 0x4e0a2a
movl %ecx, %edx
shrl $0x2, %edx
movl %ecx, %esi
andl $0x3, %esi
imull %r9d, %esi
addl %edx, %esi
cmpl %r8d, %esi
cmovll %esi, %r8d
incq %rcx
cmpl %ecx, %eax
jne 0x4e0a0d
jmp 0x4e0a86
callq 0x1e93f1
jmp 0x4e0a69
callq 0x1e93cb
jmp 0x4e0a69
callq 0x1e93a5
jmp 0x4e0a69
callq 0x1e937f
jmp 0x4e0a69
callq 0x1e9359
jmp 0x4e0a69
callq 0x1e9333
jmp 0x4e0a69
callq 0x1e930d
jmp 0x4e0a69
callq 0x1e92e7
xorl %eax, %eax
addq $0x108, %rsp            # imm = 0x108
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq (%rsp), %rdi
movq 0x10(%rsp), %r11
movl %r11d, (%rdi)
movl %r8d, 0x4(%rdi)
movl %r10d, 0x8(%rdi)
movq 0x58(%rsp), %rdi
callq 0x2094b5
movq %r12, %rdi
callq 0x2094b5
movq %rbx, %rdi
callq 0x2094b5
movq %rbp, %rdi
callq 0x2094b5
movq (%rsp), %rax
jmp 0x4e0a6b
nopl (%rax)