// File: /workspace/github_c_makefile_star2_O1/nh13[P]ksw/src/parasail/src/nw_striped_avx2_256_64.c
// Function: parasail_nw_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;
    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;
    __m256i* restrict vProfile = NULL;
    __m256i* restrict pvHStore = NULL;
    __m256i* restrict pvHLoad = NULL;
    __m256i* restrict pvE = NULL;
    int64_t* restrict boundary = NULL;
    __m256i vGapO;
    __m256i vGapE;
    int64_t NEG_LIMIT = 0;
    int64_t POS_LIMIT = 0;
    int64_t score = 0;
    __m256i vNegLimit;
    __m256i vPosLimit;
    __m256i vSaturationCheckMin;
    __m256i 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 = 4; /* number of values in vector unit */
    segLen = (s1Len + segWidth - 1) / segWidth;
    offset = (s1Len - 1) % segLen;
    position = (segWidth - 1) - (s1Len - 1) / segLen;
    vProfile = (__m256i*)profile->profile64.score;
    vGapO = _mm256_set1_epi64x_rpl(open);
    vGapE = _mm256_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 = _mm256_set1_epi64x_rpl(NEG_LIMIT);
    vPosLimit = _mm256_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_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);
    pvE      = parasail_memalign___m256i(32, segLen);
    boundary = parasail_memalign_int64_t(32, 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;
            __m256i_64_t h;
            __m256i_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;
            }
            _mm256_store_si256(&pvHStore[index], h.m);
            _mm256_store_si256(&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) {
        __m256i vE;
        /* Initialize F value to -inf.  Any errors to vH values will be
         * corrected in the Lazy_F loop.  */
        __m256i vF = vNegLimit;

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

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

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

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

        /* 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);
            /* Save vH values. */
            _mm256_store_si256(pvHStore + i, vH);
            vSaturationCheckMax = _mm256_max_epi64_rpl(vSaturationCheckMax, vH);
            vSaturationCheckMin = _mm256_min_epi64_rpl(vSaturationCheckMin, vH);
            vSaturationCheckMin = _mm256_min_epi64_rpl(vSaturationCheckMin, vE);
            vSaturationCheckMin = _mm256_min_epi64_rpl(vSaturationCheckMin, vF);
#ifdef PARASAIL_TABLE
            arr_store_si256(result->tables->score_table, vH, i, segLen, j, s2Len);
#endif

            /* 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) {
            int64_t tmp = boundary[j+1]-open;
            int64_t tmp2 = tmp < INT64_MIN ? INT64_MIN : tmp;
            vF = _mm256_slli_si256_rpl(vF, 8);
            vF = _mm256_insert_epi64_rpl(vF, tmp2, 0);
            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);
                vSaturationCheckMin = _mm256_min_epi64_rpl(vSaturationCheckMin, vH);
                vSaturationCheckMax = _mm256_max_epi64_rpl(vSaturationCheckMax, vH);
#ifdef PARASAIL_TABLE
                arr_store_si256(result->tables->score_table, vH, i, segLen, j, s2Len);
#endif
                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
    }

#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

    /* extract last value from the last column */
    {
        __m256i vH = _mm256_load_si256(pvHStore + offset);
        for (k=0; k<position; ++k) {
            vH = _mm256_slli_si256_rpl (vH, 8);
        }
        score = (int64_t) _mm256_extract_epi64_rpl (vH, 3);
    }

    if (_mm256_movemask_epi8(_mm256_or_si256(
            _mm256_cmplt_epi64_rpl(vSaturationCheckMin, vNegLimit),
            _mm256_cmpgt_epi64(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
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
andq $-0x20, %rsp
subq $0x1c0, %rsp            # imm = 0x1C0
movq %rsi, 0x98(%rsp)
testq %rdi, %rdi
je 0x4df050
movq 0x60(%rdi), %rax
movq %rax, 0xf8(%rsp)
testq %rax, %rax
je 0x4df057
movq 0x10(%rdi), %rax
movq %rax, 0x90(%rsp)
testq %rax, %rax
je 0x4df05e
movl 0x8(%rdi), %edi
testl %edi, %edi
jle 0x4df065
cmpq $0x0, 0x98(%rsp)
je 0x4df06c
movl %r8d, %ebx
movl %edx, %r8d
testl %edx, %edx
jle 0x4df073
movl %ecx, %r9d
testl %ecx, %ecx
js 0x4df07a
testl %ebx, %ebx
js 0x4df081
leal -0x1(%rdi), %r15d
addq $0x3, %rdi
movq %rdi, %r13
shrq $0x2, %r13
movl %r15d, %eax
cltd
idivl %r13d
movl %eax, %r12d
movl %edx, 0x8c(%rsp)
movl %r9d, %ecx
negl %r9d
movq 0x90(%rsp), %rdx
movslq 0x20(%rdx), %rax
movq %rcx, 0xa0(%rsp)
btsq $0x3f, %rcx
movabsq $-0x8000000000000000, %r14 # imm = 0x8000000000000000
subq %rax, %r14
movl %r9d, 0x20(%rsp)
cmpl %r9d, %eax
cmovgq %rcx, %r14
movslq 0x1c(%rdx), %rax
movq %rax, 0x70(%rsp)
andl $0x7ffffffc, %edi       # imm = 0x7FFFFFFC
movl %r8d, %esi
movq %r8, 0x18(%rsp)
callq 0x20959f
testq %rax, %rax
je 0x4df086
movl %ebx, 0x30(%rsp)
movl %r12d, 0x3c(%rsp)
movl %r15d, 0x88(%rsp)
movq %rax, 0x50(%rsp)
orl $0x4820801, 0xc(%rax)   # imm = 0x4820801
movl $0x20, %edi
movq %r13, %rsi
callq 0x4c5e3c
movq %r13, %r15
movq %rax, %r13
movl $0x20, %edi
movq %r15, %rsi
callq 0x4c5e3c
movq %rax, %rbx
movl $0x20, %edi
movq %r15, 0x58(%rsp)
movq %r15, %rsi
callq 0x4c5e3c
movq %rax, %r12
movq 0x18(%rsp), %rax
leal 0x1(%rax), %r15d
movl $0x20, %edi
movq %r15, %rsi
callq 0x2094de
movq %rax, %r11
testq %r13, %r13
sete %al
movq %rbx, 0x60(%rsp)
testq %rbx, %rbx
sete %cl
orb %al, %cl
testq %r12, %r12
sete %al
testq %r11, %r11
sete %dl
orb %al, %dl
orb %cl, %dl
jne 0x4df086
movq %r13, %r8
movq 0x18(%rsp), %rax
decl %eax
movl %eax, 0x84(%rsp)
movl $0x3, %eax
subl 0x3c(%rsp), %eax
movl %eax, 0x80(%rsp)
movq 0xa0(%rsp), %rdx
vmovq %rdx, %xmm0
vpbroadcastq %xmm0, %ymm13
movl 0x30(%rsp), %eax
vmovq %rax, %xmm0
vpbroadcastq %xmm0, %ymm3
incq %r14
movabsq $-0x8000000000000000, %rcx # imm = 0x8000000000000000
subq 0x70(%rsp), %rcx
addq $-0x2, %rcx
vmovq %r14, %xmm0
vpbroadcastq %xmm0, %ymm0
vmovdqa %ymm0, 0x120(%rsp)
vmovq %rcx, %xmm1
vpbroadcastq %xmm1, %ymm6
movslq 0x20(%rsp), %rcx
movq 0x58(%rsp), %r13
movl %r13d, %esi
negq %rdx
movq %rsi, 0x48(%rsp)
imulq %rax, %rsi
xorl %edi, %edi
movq %r8, %r14
movq %rcx, %r8
xorl %r9d, %r9d
movq %r8, 0x180(%rsp,%r9,8)
leaq (%rdx,%r8), %r10
movq %r10, 0x160(%rsp,%r9,8)
incq %r9
subq %rsi, %r8
cmpq $0x4, %r9
jne 0x4de7dc
movq %rdi, %r8
shlq $0x5, %r8
vmovaps 0x180(%rsp), %ymm4
vmovaps %ymm4, (%r14,%r8)
vmovdqa 0x160(%rsp), %ymm4
vmovdqa %ymm4, (%r12,%r8)
incq %rdi
subq %rax, %rcx
cmpq 0x48(%rsp), %rdi
jne 0x4de7d6
movq $0x0, (%r11)
movslq 0x20(%rsp), %rcx
movl $0x1, %edx
movq %rcx, (%r11,%rdx,8)
incq %rdx
subq %rax, %rcx
cmpq %rdx, %r15
jne 0x4de83f
leal -0x1(%r13), %eax
movq 0x18(%rsp), %rsi
movl %esi, %edx
cmpl $0x1, %r13d
adcl $0x0, %r13d
cmpl $0x2, %esi
movl $0x1, %ecx
cmovgel %esi, %ecx
movq %rcx, 0xe8(%rsp)
movq 0x48(%rsp), %rsi
imulq %rdx, %rsi
leaq (,%rsi,4), %rbx
shlq $0x2, %rdx
shlq $0x3, %rsi
leaq (%rbx,%rbx,2), %rcx
shlq $0x5, %r13
xorl %edi, %edi
shlq $0x5, %rax
movq %rax, 0xf0(%rsp)
xorl %r8d, %r8d
vmovdqa 0x120(%rsp), %ymm5
vmovdqa %ymm6, 0x140(%rsp)
movq 0x60(%rsp), %rax
movq %r12, 0x28(%rsp)
movq %r13, 0x58(%rsp)
movq %r11, 0xa8(%rsp)
movq %rdx, 0xe0(%rsp)
movq %rsi, 0xd8(%rsp)
movq %rbx, 0xd0(%rsp)
movq %rcx, 0xc8(%rsp)
movq %rax, 0x30(%rsp)
movq 0xf0(%rsp), %rax
movq %r14, 0xc0(%rsp)
vmovdqa (%r14,%rax), %ymm4
vinserti128 $0x1, %xmm4, %ymm0, %ymm7
vpalignr $0x8, %ymm7, %ymm4, %ymm4 # ymm4 = ymm7[8,9,10,11,12,13,14,15],ymm4[0,1,2,3,4,5,6,7],ymm7[24,25,26,27,28,29,30,31],ymm4[16,17,18,19,20,21,22,23]
movq 0x90(%rsp), %rax
movq 0x10(%rax), %rax
movq 0x98(%rsp), %rcx
movzbl (%rcx,%r8), %ecx
movslq (%rax,%rcx,4), %rax
movq 0x48(%rsp), %rcx
imulq %rax, %rcx
shlq $0x5, %rcx
addq 0xf8(%rsp), %rcx
movq %rcx, 0x100(%rsp)
movq %r8, 0xb0(%rsp)
vmovq (%r11,%r8,8), %xmm7
vpblendd $0x3, %ymm7, %ymm4, %ymm7 # ymm7 = ymm7[0,1],ymm4[2,3,4,5,6,7]
movq %rdi, 0xb8(%rsp)
movq %rdi, %r15
xorl %ecx, %ecx
vmovdqa 0x120(%rsp), %ymm4
movq %rcx, 0x18(%rsp)
movq %r15, 0x20(%rsp)
movq 0x100(%rsp), %rax
vpaddq (%rax,%rcx), %ymm7, %ymm7
vmovq %xmm7, %r9
movq (%r12,%rcx), %r10
cmpq %r10, %r9
cmovleq %r10, %r9
movq 0x8(%r12,%rcx), %rax
movq %rax, 0x70(%rsp)
vpextrq $0x1, %xmm7, %r13
cmpq %rax, %r13
cmovleq %rax, %r13
vextracti128 $0x1, %ymm7, %xmm7
vmovq %xmm7, %rax
movq 0x28(%rsp), %rcx
movq 0x18(%rsp), %rdx
movq 0x10(%rcx,%rdx), %rcx
movq %rcx, 0x60(%rsp)
cmpq %rcx, %rax
cmovleq %rcx, %rax
movq 0x28(%rsp), %rcx
movq 0x18(%rsp), %rdx
movq 0x18(%rcx,%rdx), %rcx
movq %rcx, 0x110(%rsp)
vpextrq $0x1, %xmm7, %rdi
cmpq %rcx, %rdi
cmovleq %rcx, %rdi
vmovq %xmm4, %r8
cmpq %r8, %r9
cmovleq %r8, %r9
vpextrq $0x1, %xmm4, %rcx
movq %rcx, 0x108(%rsp)
cmpq %rcx, %r13
cmovleq %rcx, %r13
vextracti128 $0x1, %ymm4, %xmm7
vmovq %xmm7, %rcx
movq %rcx, 0x40(%rsp)
cmpq %rcx, %rax
cmovleq %rcx, %rax
vpextrq $0x1, %xmm7, %rcx
movq %rcx, 0x118(%rsp)
cmpq %rcx, %rdi
cmovleq %rcx, %rdi
vmovq %xmm5, %rsi
cmpq %r9, %rsi
cmovleq %r9, %rsi
vpextrq $0x1, %xmm5, %rcx
cmpq %r13, %rcx
cmovleq %r13, %rcx
vextracti128 $0x1, %ymm5, %xmm5
vmovq %xmm5, %r12
cmpq %rax, %r12
cmovleq %rax, %r12
vpextrq $0x1, %xmm5, %r14
cmpq %rdi, %r14
cmovleq %rdi, %r14
vmovq %xmm6, %rbx
cmpq %r9, %rbx
cmovgeq %r9, %rbx
vpextrq $0x1, %xmm6, %rdx
cmpq %r13, %rdx
cmovgeq %r13, %rdx
vextracti128 $0x1, %ymm6, %xmm5
vmovq %xmm5, %r15
cmpq %rax, %r15
cmovgeq %rax, %r15
vpextrq $0x1, %xmm5, %r11
cmpq %rdi, %r11
cmovgeq %rdi, %r11
cmpq %r10, %rbx
cmovgeq %r10, %rbx
movq 0x70(%rsp), %r10
cmpq %r10, %rdx
cmovgeq %r10, %rdx
movq 0x60(%rsp), %r10
cmpq %r10, %r15
cmovgeq %r10, %r15
vmovq %r14, %xmm0
vmovdqa %xmm0, 0x70(%rsp)
movq 0x110(%rsp), %r10
cmpq %r10, %r11
cmovgeq %r10, %r11
vmovq %r12, %xmm6
cmpq %r8, %rbx
cmovgeq %r8, %rbx
vmovq %rcx, %xmm0
vmovdqa %xmm0, 0x60(%rsp)
movq 0x108(%rsp), %rcx
cmpq %rcx, %rdx
cmovgeq %rcx, %rdx
vmovq %rsi, %xmm5
movq 0x28(%rsp), %rcx
movq 0x18(%rsp), %rsi
vmovdqa (%rcx,%rsi), %ymm11
vmovq %r13, %xmm9
vmovq %r9, %xmm10
vpunpcklqdq %xmm9, %xmm10, %xmm9 # xmm9 = xmm10[0],xmm9[0]
vmovq %rax, %xmm10
vinserti128 $0x1, %xmm10, %ymm9, %ymm9
vmovq %rdi, %xmm10
vpbroadcastq %xmm10, %ymm10
vpblendd $0xc0, %ymm10, %ymm9, %ymm12 # ymm12 = ymm9[0,1,2,3,4,5],ymm10[6,7]
movq 0x30(%rsp), %rcx
movq 0x18(%rsp), %rsi
vmovdqa %ymm12, (%rcx,%rsi)
movq 0x40(%rsp), %rcx
cmpq %rcx, %r15
cmovgeq %rcx, %r15
movq 0x118(%rsp), %rcx
cmpq %rcx, %r11
cmovgeq %rcx, %r11
vmovq %r11, %xmm9
vmovq %r15, %xmm7
movq 0x20(%rsp), %r15
movq 0x50(%rsp), %rcx
movq 0x10(%rcx), %rcx
movq (%rcx), %r14
movl %r9d, (%r14,%r15)
addq %r15, %r14
movq 0xd0(%rsp), %rcx
movl %r13d, (%rcx,%r14)
movq 0x58(%rsp), %r13
movq 0x28(%rsp), %r12
vpsubq %ymm13, %ymm12, %ymm12
vpsubq %ymm3, %ymm11, %ymm11
vmovq %xmm11, %r8
vmovq %xmm12, %rcx
cmpq %rcx, %r8
cmovleq %rcx, %r8
vpextrq $0x1, %xmm11, %r11
vpextrq $0x1, %xmm12, %rsi
movq 0xd8(%rsp), %r9
movl %eax, (%r9,%r14)
cmpq %rsi, %r11
cmovleq %rsi, %r11
movq 0xc8(%rsp), %rax
movl %edi, (%rax,%r14)
vextracti128 $0x1, %ymm11, %xmm11
vmovq %xmm11, %rax
vextracti128 $0x1, %ymm12, %xmm12
vmovq %xmm12, %rdi
cmpq %rdi, %rax
cmovleq %rdi, %rax
vpextrq $0x1, %xmm11, %r14
vpextrq $0x1, %xmm12, %r9
vmovq %rdx, %xmm11
cmpq %r9, %r14
cmovleq %r9, %r14
vmovq %rbx, %xmm12
vpsubq %ymm3, %ymm4, %ymm4
vmovq %xmm4, %rdx
cmpq %rcx, %rdx
cmovgq %rdx, %rcx
vpextrq $0x1, %xmm4, %rdx
vmovdqa %ymm3, %ymm10
vmovdqa %ymm13, %ymm3
vmovq %r11, %xmm13
cmpq %rsi, %rdx
cmovgq %rdx, %rsi
vmovq %r8, %xmm14
vextracti128 $0x1, %ymm4, %xmm4
vmovq %xmm4, %rdx
cmpq %rdi, %rdx
cmovgq %rdx, %rdi
vpextrq $0x1, %xmm4, %rdx
vmovq %r14, %xmm4
cmpq %r9, %rdx
cmovgq %rdx, %r9
movq 0xe0(%rsp), %rdx
vmovq %rax, %xmm15
vmovq %r9, %xmm1
vmovq %rdi, %xmm0
vmovq %rsi, %xmm2
vmovq %rcx, %xmm8
movq 0x18(%rsp), %rcx
vpunpcklqdq 0x70(%rsp), %xmm6, %xmm6 # xmm6 = xmm6[0],mem[0]
vpunpcklqdq 0x60(%rsp), %xmm5, %xmm5 # xmm5 = xmm5[0],mem[0]
vinserti128 $0x1, %xmm6, %ymm5, %ymm5
vpunpcklqdq %xmm9, %xmm7, %xmm6 # xmm6 = xmm7[0],xmm9[0]
vpunpcklqdq %xmm11, %xmm12, %xmm7 # xmm7 = xmm12[0],xmm11[0]
vpunpcklqdq %xmm13, %xmm14, %xmm9 # xmm9 = xmm14[0],xmm13[0]
vmovdqa %ymm3, %ymm13
vmovdqa %ymm10, %ymm3
vpunpcklqdq %xmm4, %xmm15, %xmm4 # xmm4 = xmm15[0],xmm4[0]
vmovdqa %xmm4, 0x10(%r12,%rcx)
vmovdqa %xmm9, (%r12,%rcx)
vinserti128 $0x1, %xmm6, %ymm7, %ymm6
vpunpcklqdq %xmm1, %xmm0, %xmm0 # xmm0 = xmm0[0],xmm1[0]
vpunpcklqdq %xmm2, %xmm8, %xmm1 # xmm1 = xmm8[0],xmm2[0]
vinserti128 $0x1, %xmm0, %ymm1, %ymm4
movq 0xc0(%rsp), %rax
vmovdqa (%rax,%rcx), %ymm7
addq $0x20, %rcx
addq %rdx, %r15
cmpq %rcx, %r13
jne 0x4de97a
movq $0x0, 0x40(%rsp)
movq 0x30(%rsp), %r14
movq 0xa8(%rsp), %rax
movq 0xb0(%rsp), %rdx
movq 0x8(%rax,%rdx,8), %rax
subq 0xa0(%rsp), %rax
vpermq $0x90, %ymm4, %ymm0     # ymm0 = ymm4[0,0,1,2]
vmovq %rax, %xmm1
vpblendd $0x3, %ymm1, %ymm0, %ymm4 # ymm4 = ymm1[0,1],ymm0[2,3,4,5,6,7]
movb $0x1, 0x60(%rsp)
movl $0x1, %eax
movq 0xb8(%rsp), %r8
xorl %edi, %edi
movq %r8, 0x20(%rsp)
vmovq %xmm4, %rbx
movq (%r14,%rdi), %rcx
cmpq %rbx, %rcx
cmovgq %rcx, %rbx
vpextrq $0x1, %xmm4, %rsi
movq 0x8(%r14,%rdi), %rcx
cmpq %rsi, %rcx
cmovgq %rcx, %rsi
movq 0x10(%r14,%rdi), %rcx
vextracti128 $0x1, %ymm4, %xmm0
vmovq %xmm0, %r8
cmpq %r8, %rcx
cmovgq %rcx, %r8
vmovq %rsi, %xmm1
vmovq %rbx, %xmm2
vpunpcklqdq %xmm1, %xmm2, %xmm1 # xmm1 = xmm2[0],xmm1[0]
vmovq %r8, %xmm2
vpextrq $0x1, %xmm0, %rcx
movq 0x18(%r14,%rdi), %rdx
cmpq %rcx, %rdx
cmovgq %rdx, %rcx
vinserti128 $0x1, %xmm2, %ymm1, %ymm0
vmovq %rcx, %xmm1
vpbroadcastq %xmm1, %ymm1
vpblendd $0xc0, %ymm1, %ymm0, %ymm7 # ymm7 = ymm0[0,1,2,3,4,5],ymm1[6,7]
vmovdqa %ymm7, (%r14,%rdi)
vmovq %xmm6, %r10
cmpq %rbx, %r10
cmovgeq %rbx, %r10
vpextrq $0x1, %xmm6, %r11
cmpq %rsi, %r11
cmovgeq %rsi, %r11
vextracti128 $0x1, %ymm6, %xmm0
vmovq %xmm0, %r14
cmpq %r8, %r14
cmovgeq %r8, %r14
vpextrq $0x1, %xmm0, %rdx
cmpq %rcx, %rdx
jl 0x4dee29
movq %rcx, %rdx
movq %rdx, 0x70(%rsp)
movq %rax, 0x18(%rsp)
vmovq %xmm5, %rdx
cmpq %rbx, %rdx
cmovleq %rbx, %rdx
vpextrq $0x1, %xmm5, %r12
cmpq %rsi, %r12
cmovleq %rsi, %r12
vextracti128 $0x1, %ymm5, %xmm0
vmovq %xmm0, %r9
cmpq %r8, %r9
cmovleq %r8, %r9
vpextrq $0x1, %xmm0, %r15
cmpq %rcx, %r15
jg 0x4dee6c
movq %rcx, %r15
movq 0x50(%rsp), %rax
movq 0x10(%rax), %rax
movq (%rax), %rax
movq 0x20(%rsp), %r13
movl %ebx, (%rax,%r13)
addq %r13, %rax
movq 0xd0(%rsp), %rbx
movl %esi, (%rbx,%rax)
movq 0xd8(%rsp), %rsi
movl %r8d, (%rsi,%rax)
movq 0xc8(%rsp), %r8
movl %ecx, (%r8,%rax)
vmovq 0x70(%rsp), %xmm0
vmovq %r14, %xmm1
vmovq %r11, %xmm2
vmovq %r10, %xmm5
vmovq %r15, %xmm8
vmovq %r9, %xmm9
movq %r13, %r8
vmovq %r12, %xmm10
vmovq %rdx, %xmm11
vpunpcklqdq %xmm0, %xmm1, %xmm0 # xmm0 = xmm1[0],xmm0[0]
vpunpcklqdq %xmm2, %xmm5, %xmm1 # xmm1 = xmm5[0],xmm2[0]
vinserti128 $0x1, %xmm0, %ymm1, %ymm6
vpunpcklqdq %xmm8, %xmm9, %xmm0 # xmm0 = xmm9[0],xmm8[0]
vpunpcklqdq %xmm10, %xmm11, %xmm1 # xmm1 = xmm11[0],xmm10[0]
vinserti128 $0x1, %xmm0, %ymm1, %ymm5
vpsubq %ymm13, %ymm7, %ymm0
vpsubq %ymm3, %ymm4, %ymm4
vpcmpgtq %ymm0, %ymm4, %ymm0
vtestpd %ymm0, %ymm0
movq 0x30(%rsp), %r14
movq 0x58(%rsp), %r13
movq 0xe0(%rsp), %rdx
movq 0x18(%rsp), %rax
je 0x4def3a
cmpq 0x48(%rsp), %rax
setb 0x60(%rsp)
addq $0x20, %rdi
addq %rdx, %r8
incq %rax
cmpq %rdi, %r13
jne 0x4ded71
testb $0x1, 0x60(%rsp)
jne 0x4def57
movq 0x40(%rsp), %rdi
leal 0x1(%rdi), %eax
cmpl $0x3, %edi
movq %rax, 0x40(%rsp)
jb 0x4ded2f
movq 0xb0(%rsp), %r8
incq %r8
movq 0xb8(%rsp), %rdi
addq $0x4, %rdi
movq 0xc0(%rsp), %r15
movq %r15, %rax
cmpq 0xe8(%rsp), %r8
movq 0x28(%rsp), %r12
movq 0xa8(%rsp), %r11
jne 0x4de8ef
movl 0x8c(%rsp), %eax
shlq $0x5, %rax
vmovdqa (%r14,%rax), %ymm2
cmpl $0x2, 0x3c(%rsp)
movl 0x88(%rsp), %ecx
movl 0x84(%rsp), %edx
jg 0x4defe3
movl 0x80(%rsp), %esi
cmpl $0x2, %esi
movl $0x1, %eax
cmovgel %esi, %eax
movq 0x50(%rsp), %rbx
vperm2i128 $0x8, %ymm2, %ymm2, %ymm0 # ymm0 = zero,zero,ymm2[0,1]
vpalignr $0x8, %ymm0, %ymm2, %ymm2 # ymm2 = ymm0[8,9,10,11,12,13,14,15],ymm2[0,1,2,3,4,5,6,7],ymm0[24,25,26,27,28,29,30,31],ymm2[16,17,18,19,20,21,22,23]
decl %eax
jne 0x4defd1
jmp 0x4defe8
movq 0x50(%rsp), %rbx
vmovdqa 0x120(%rsp), %ymm0
vpcmpgtq %ymm6, %ymm0, %ymm0
vpcmpgtq 0x140(%rsp), %ymm5, %ymm1
vpor %ymm0, %ymm1, %ymm0
vtestpd %ymm0, %ymm0
je 0x4df017
orb $0x40, 0xc(%rbx)
xorl %eax, %eax
xorl %edx, %edx
xorl %ecx, %ecx
jmp 0x4df023
vextracti128 $0x1, %ymm2, %xmm0
vpextrq $0x1, %xmm0, %rax
movl %eax, (%rbx)
movl %ecx, 0x4(%rbx)
movl %edx, 0x8(%rbx)
movq %r11, %rdi
vzeroupper
callq 0x2094b5
movq %r12, %rdi
callq 0x2094b5
movq %r15, %rdi
callq 0x2094b5
movq %r14, %rdi
callq 0x2094b5
jmp 0x4df088
callq 0x1e8f7d
jmp 0x4df086
callq 0x1e8f57
jmp 0x4df086
callq 0x1e8f31
jmp 0x4df086
callq 0x1e8f0b
jmp 0x4df086
callq 0x1e8ee5
jmp 0x4df086
callq 0x1e8ebf
jmp 0x4df086
callq 0x1e8e99
jmp 0x4df086
callq 0x1e8e73
xorl %ebx, %ebx
movq %rbx, %rax
leaq -0x28(%rbp), %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
nop