// File: /workspace/github_c_makefile_star2_O1/nh13[P]ksw/src/parasail/src/sg_trace_scan_avx2_256_64.c
// Function: parasail_sg_flags_trace_scan_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,
        int s1_beg, int s1_end, int s2_beg, int s2_end)
{
    /* 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;
    __m256i* restrict pvP = NULL;
    __m256i* restrict pvE = NULL;
    int64_t* restrict boundary = NULL;
    __m256i* restrict pvHt = NULL;
    __m256i* restrict pvH = NULL;
    __m256i* restrict pvGapper = NULL;
    __m256i vGapO;
    __m256i vGapE;
    int64_t NEG_LIMIT = 0;
    int64_t POS_LIMIT = 0;
    __m256i vZero;
    int64_t score = 0;
    __m256i vNegLimit;
    __m256i vPosLimit;
    __m256i vSaturationCheckMin;
    __m256i vSaturationCheckMax;
    __m256i vMaxH;
    __m256i vPosMask;
    __m256i vNegInfFront;
    __m256i vSegLenXgap;
    parasail_result_t *result = NULL;
    __m256i vTIns;
    __m256i vTDel;
    __m256i vTDiag;
    __m256i vTDiagE;
    __m256i vTInsE;
    __m256i vTDiagF;
    __m256i 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 = 4; /* number of values in vector unit */
    segLen = (s1Len + segWidth - 1) / segWidth;
    offset = (s1Len - 1) % segLen;
    position = (segWidth - 1) - (s1Len - 1) / segLen;
    pvP = (__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;
    vZero = _mm256_setzero_si256();
    score = NEG_LIMIT;
    vNegLimit = _mm256_set1_epi64x_rpl(NEG_LIMIT);
    vPosLimit = _mm256_set1_epi64x_rpl(POS_LIMIT);
    vSaturationCheckMin = vPosLimit;
    vSaturationCheckMax = vNegLimit;
    vMaxH = vNegLimit;
    vPosMask = _mm256_cmpeq_epi64(_mm256_set1_epi64x_rpl(position),
            _mm256_set_epi64x_rpl(0,1,2,3));
    vNegInfFront = vZero;
    vNegInfFront = _mm256_insert_epi64_rpl(vNegInfFront, NEG_LIMIT, 0);
    vSegLenXgap = _mm256_add_epi64(vNegInfFront,
            _mm256_slli_si256_rpl(_mm256_set1_epi64x_rpl(-segLen*gap), 8));
    vTIns  = _mm256_set1_epi64x_rpl(PARASAIL_INS);
    vTDel  = _mm256_set1_epi64x_rpl(PARASAIL_DEL);
    vTDiag = _mm256_set1_epi64x_rpl(PARASAIL_DIAG);
    vTDiagE= _mm256_set1_epi64x_rpl(PARASAIL_DIAG_E);
    vTInsE = _mm256_set1_epi64x_rpl(PARASAIL_INS_E);
    vTDiagF= _mm256_set1_epi64x_rpl(PARASAIL_DIAG_F);
    vTDelF = _mm256_set1_epi64x_rpl(PARASAIL_DEL_F);

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

    /* set known flags */
    result->flag |= PARASAIL_FLAG_SG | PARASAIL_FLAG_SCAN
        | PARASAIL_FLAG_TRACE
        | PARASAIL_FLAG_BITS_64 | PARASAIL_FLAG_LANES_4;
    result->flag |= s1_beg ? PARASAIL_FLAG_SG_S1_BEG : 0;
    result->flag |= s1_end ? PARASAIL_FLAG_SG_S1_END : 0;
    result->flag |= s2_beg ? PARASAIL_FLAG_SG_S2_BEG : 0;
    result->flag |= s2_end ? PARASAIL_FLAG_SG_S2_END : 0;

    /* initialize heap variables */
    pvE = parasail_memalign___m256i(32, segLen);
    boundary = parasail_memalign_int64_t(32, s2Len+1);
    pvHt= parasail_memalign___m256i(32, segLen);
    pvH = parasail_memalign___m256i(32, segLen);
    pvGapper = parasail_memalign___m256i(32, 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;
            __m256i_64_t h;
            __m256i_64_t e;
            for (segNum=0; segNum<segWidth; ++segNum) {
                int64_t tmp = s1_beg ? 0 : (-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(&pvH[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 = s2_beg ? 0 : (-open-gap*(i-1));
            boundary[i] = tmp < INT64_MIN ? INT64_MIN : tmp;
        }
    }

    {
        __m256i vGapper = _mm256_sub_epi64(vZero,vGapO);
        for (i=segLen-1; i>=0; --i) {
            _mm256_store_si256(pvGapper+i, vGapper);
            vGapper = _mm256_sub_epi64(vGapper, vGapE);
            /* long queries and/or large penalties will break the pseudo prefix scan */
            vSaturationCheckMin = _mm256_min_epi64_rpl(vSaturationCheckMin, vGapper);
        }
    }

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

        /* calculate E */
        /* calculate Ht */
        /* calculate F and H first pass */
        vHp = _mm256_load_si256(pvH+(segLen-1));
        vHp = _mm256_slli_si256_rpl(vHp, 8);
        vHp = _mm256_insert_epi64_rpl(vHp, boundary[j], 0);
        pvW = pvP + matrix->mapper[(unsigned char)s2[j]]*segLen;
        vHt = _mm256_sub_epi64(vNegLimit, pvGapper[0]);
        vF = vNegLimit;
        for (i=0; i<segLen; ++i) {
            vH = _mm256_load_si256(pvH+i);
            vE = _mm256_load_si256(pvE+i);
            vW = _mm256_load_si256(pvW+i);
            vGapper = _mm256_load_si256(pvGapper+i);
            vE_opn = _mm256_sub_epi64(vH, vGapO);
            vE_ext = _mm256_sub_epi64(vE, vGapE);
            case1 = _mm256_cmpgt_epi64(vE_opn, vE_ext);
            vET = _mm256_blendv_epi8(vTInsE, vTDiagE, case1);
            arr_store(result->trace->trace_table, vET, i, segLen, j);
            vE = _mm256_max_epi64_rpl(vE_opn, vE_ext);
            vSaturationCheckMin = _mm256_min_epi64_rpl(vSaturationCheckMin, vE);
            vGapper = _mm256_add_epi64(vHt, vGapper);
            vF = _mm256_max_epi64_rpl(vF, vGapper);
            vHp = _mm256_add_epi64(vHp, vW);
            vHt = _mm256_max_epi64_rpl(vE, vHp);
            _mm256_store_si256(pvE+i, vE);
            _mm256_store_si256(pvHt+i, vHt);
            _mm256_store_si256(pvH+i, vHp);
            vHp = vH;
        }

        /* pseudo prefix scan on F and H */
        vHt = _mm256_slli_si256_rpl(vHt, 8);
        vHt = _mm256_insert_epi64_rpl(vHt, boundary[j+1], 0);
        vGapper = _mm256_load_si256(pvGapper);
        vGapper = _mm256_add_epi64(vHt, vGapper);
        vF = _mm256_max_epi64_rpl(vF, vGapper);
        for (i=0; i<segWidth-2; ++i) {
            __m256i vFt = _mm256_slli_si256_rpl(vF, 8);
            vFt = _mm256_add_epi64(vFt, vSegLenXgap);
            vF = _mm256_max_epi64_rpl(vF, vFt);
        }

        /* calculate final H */
        vF = _mm256_slli_si256_rpl(vF, 8);
        vF = _mm256_add_epi64(vF, vNegInfFront);
        vH = _mm256_max_epi64_rpl(vF, vHt);
        for (i=0; i<segLen; ++i) {
            vET = arr_load(result->trace->trace_table, i, segLen, j);
            vHp = _mm256_load_si256(pvH+i);
            vHt = _mm256_load_si256(pvHt+i);
            vF_opn = _mm256_sub_epi64(vH, vGapO);
            vF_ext = _mm256_sub_epi64(vF, vGapE);
            vF = _mm256_max_epi64_rpl(vF_opn, vF_ext);
            case1 = _mm256_cmpgt_epi64(vF_opn, vF_ext);
            vFT = _mm256_blendv_epi8(vTDelF, vTDiagF, case1);
            vH = _mm256_max_epi64_rpl(vHt, vF);
            case1 = _mm256_cmpeq_epi64(vH, vHp);
            case2 = _mm256_cmpeq_epi64(vH, vF);
            vT = _mm256_blendv_epi8(
                    _mm256_blendv_epi8(vTIns, vTDel, case2),
                    vTDiag, case1);
            vT = _mm256_or_si256(vT, vET);
            vT = _mm256_or_si256(vT, vFT);
            arr_store(result->trace->trace_table, vT, i, segLen, j);
            _mm256_store_si256(pvH+i, vH);
            vSaturationCheckMin = _mm256_min_epi64_rpl(vSaturationCheckMin, vH);
            vSaturationCheckMin = _mm256_min_epi64_rpl(vSaturationCheckMin, vF);
            vSaturationCheckMax = _mm256_max_epi64_rpl(vSaturationCheckMax, vH);
        }

        /* extract vector containing last value from column */
        {
            __m256i vCompare;
            vH = _mm256_load_si256(pvH + offset);
            vCompare = _mm256_and_si256(vPosMask, _mm256_cmpgt_epi64(vH, vMaxH));
            vMaxH = _mm256_max_epi64_rpl(vH, vMaxH);
            if (_mm256_movemask_epi8(vCompare)) {
                end_ref = j;
            }
        }
    } 

    /* max last value from all columns */
    if (s2_end)
    {
        for (k=0; k<position; ++k) {
            vMaxH = _mm256_slli_si256_rpl(vMaxH, 8);
        }
        score = (int64_t) _mm256_extract_epi64_rpl(vMaxH, 3);
        end_query = s1Len-1;
    }

    /* max of last column */
    if (s1_end)
    {
        /* Trace the alignment ending position on read. */
        int64_t *t = (int64_t*)pvH;
        int32_t column_len = segLen * segWidth;
        for (i = 0; i<column_len; ++i, ++t) {
            int32_t temp = i / segWidth + i % segWidth * segLen;
            if (temp >= s1Len) continue;
            if (*t > score) {
                score = *t;
                end_query = temp;
                end_ref = s2Len-1;
            }
            else if (*t == score && end_ref == s2Len-1 && temp < end_query) {
                end_query = temp;
            }
        }
    }

    if (!s1_end && !s2_end) {
        /* extract last value from the last column */
        {
            __m256i vH = _mm256_load_si256(pvH + offset);
            for (k=0; k<position; ++k) {
                vH = _mm256_slli_si256_rpl(vH, 8);
            }
            score = (int64_t) _mm256_extract_epi64_rpl (vH, 3);
            end_ref = s2Len - 1;
            end_query = s1Len - 1;
        }
    }

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

    return result;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
andq $-0x20, %rsp
subq $0x2a0, %rsp            # imm = 0x2A0
movq %rsi, 0x88(%rsp)
testq %rdi, %rdi
je 0x57674b
movq 0x60(%rdi), %rax
movq %rax, 0xd8(%rsp)
testq %rax, %rax
je 0x576752
movq 0x10(%rdi), %rax
movq %rax, 0x80(%rsp)
testq %rax, %rax
je 0x576759
movl %r9d, %r13d
movl %edx, %r9d
movl 0x8(%rdi), %edx
testl %edx, %edx
jle 0x576760
cmpq $0x0, 0x88(%rsp)
je 0x576767
testl %r9d, %r9d
jle 0x57676e
testl %ecx, %ecx
js 0x576775
testl %r8d, %r8d
js 0x57677c
movl %r8d, 0x38(%rsp)
leal -0x1(%rdx), %eax
movq %rdx, 0xb0(%rsp)
leaq 0x3(%rdx), %r14
movq %r14, %r12
shrq $0x2, %r12
movl %eax, 0x74(%rsp)
cltd
idivl %r12d
movl %eax, 0x24(%rsp)
movl %edx, 0x100(%rsp)
movl %ecx, %ebx
negl %ecx
movq 0x80(%rsp), %rsi
movslq 0x20(%rsi), %rax
movq %rbx, %rdi
btsq $0x3f, %rdi
movabsq $-0x8000000000000000, %rdx # imm = 0x8000000000000000
subq %rax, %rdx
movl %ecx, 0x28(%rsp)
cmpl %ecx, %eax
cmovgq %rdi, %rdx
movq %rdx, 0x50(%rsp)
movslq 0x1c(%rsi), %rax
movq %rax, 0xe0(%rsp)
movl $0x20, %edx
movl $0x20, %ecx
movl %r12d, %edi
movl %r9d, %esi
movq %r9, 0x18(%rsp)
callq 0x2097d1
testq %rax, %rax
je 0x576781
movq %rax, %r15
movq %r14, 0xa8(%rsp)
xorl %eax, %eax
testl %r13d, %r13d
setne %al
xorl %ecx, %ecx
cmpl $0x0, 0x10(%rbp)
setne %cl
shll $0x4, %ecx
xorl %edx, %edx
cmpl $0x0, 0x18(%rbp)
setne %dl
shll $0xe, %edx
xorl %esi, %esi
cmpl $0x0, 0x20(%rbp)
setne %sil
shll $0xf, %esi
leal (%rcx,%rax,8), %eax
orl %edx, %eax
orl %esi, %eax
orl 0xc(%r15), %eax
orl $0x4880402, %eax        # imm = 0x4880402
movl %eax, 0xc(%r15)
movl $0x20, %edi
movq %r12, %rsi
callq 0x4c5e3c
movq %rax, %r14
movq 0x18(%rsp), %rax
leal 0x1(%rax), %esi
movl $0x20, %edi
movq %rsi, 0x30(%rsp)
callq 0x2094de
movq %rax, 0x68(%rsp)
movl $0x20, %edi
movq %r12, %rsi
callq 0x4c5e3c
movq %rax, 0x48(%rsp)
movl $0x20, %edi
movq %r12, %rsi
callq 0x4c5e3c
movq %rax, 0x10(%rsp)
movl $0x20, %edi
movq %r12, 0x78(%rsp)
movq %r12, %rsi
callq 0x4c5e3c
movq %r14, 0x60(%rsp)
testq %r14, %r14
movq 0x68(%rsp), %r14
sete %dl
testq %r14, %r14
sete %cl
orb %dl, %cl
cmpq $0x0, 0x48(%rsp)
sete %sil
cmpq $0x0, 0x10(%rsp)
sete %dl
orb %sil, %dl
orb %cl, %dl
testq %rax, %rax
sete %cl
orb %dl, %cl
jne 0x576781
movq 0x18(%rsp), %rcx
decl %ecx
movl %ecx, 0xc(%rsp)
movl $0x3, %ecx
subl 0x24(%rsp), %ecx
vmovq %rbx, %xmm0
vpbroadcastq %xmm0, %ymm2
movl 0x38(%rsp), %edx
movl %edx, %r11d
vmovq %r11, %xmm0
vpbroadcastq %xmm0, %ymm3
movq 0x50(%rsp), %r10
incq %r10
movabsq $-0x8000000000000000, %rsi # imm = 0x8000000000000000
subq 0xe0(%rsp), %rsi
addq $-0x2, %rsi
vmovq %r10, %xmm0
vpbroadcastq %xmm0, %ymm1
vmovq %rsi, %xmm0
vpbroadcastq %xmm0, %ymm7
movl %ecx, 0x44(%rsp)
movslq %ecx, %rcx
vmovq %rcx, %xmm0
vpbroadcastq %xmm0, %ymm0
vmovdqa %ymm1, 0x120(%rsp)
vmovq %xmm1, %xmm5            # xmm5 = xmm1[0],zero
movq 0x78(%rsp), %r12
movl %r12d, %ecx
imull %edx, %ecx
negl %ecx
movslq %ecx, %rcx
vmovq %rcx, %xmm1
vpbroadcastq %xmm1, %ymm1
vpxor %xmm4, %xmm4, %xmm4
vpblendd $0x3, %ymm4, %ymm1, %ymm1 # ymm1 = ymm4[0,1],ymm1[2,3,4,5,6,7]
vmovdqa %ymm5, 0x1e0(%rsp)
vpaddq %ymm1, %ymm5, %ymm8
movslq 0x28(%rsp), %rcx
movl %r12d, %edx
movq %rdx, 0x58(%rsp)
imulq %r11, %rdx
xorl %esi, %esi
movq %rcx, %rdi
xorl %r8d, %r8d
testl %r13d, %r13d
je 0x575bbf
xorl %r9d, %r9d
jmp 0x575bc2
movq %rdi, %r9
movq %r9, 0x260(%rsp,%r8,8)
subq %rbx, %r9
movq %r9, 0x240(%rsp,%r8,8)
incq %r8
subq %rdx, %rdi
cmpq $0x4, %r8
jne 0x575bb5
movq %rsi, %rdi
shlq $0x5, %rdi
vmovaps 0x260(%rsp), %ymm1
movq 0x10(%rsp), %r8
vmovaps %ymm1, (%r8,%rdi)
vmovdqa 0x240(%rsp), %ymm1
movq 0x60(%rsp), %r8
vmovdqa %ymm1, (%r8,%rdi)
incq %rsi
subq %r11, %rcx
cmpq 0x58(%rsp), %rsi
jne 0x575baf
movq $0x0, (%r14)
movl $0x1, %edx
movl 0x38(%rsp), %esi
movl 0x28(%rsp), %edi
movl 0x18(%rbp), %r8d
movq 0x30(%rsp), %r9
testl %r8d, %r8d
movl $0x0, %ecx
cmovel %edi, %ecx
movslq %ecx, %rcx
movq %rcx, (%r14,%rdx,8)
incq %rdx
subl %esi, %edi
cmpq %rdx, %r9
jne 0x575c3a
movq %r10, 0x50(%rsp)
vpxor %xmm1, %xmm1, %xmm1
vpsubq %ymm2, %ymm1, %ymm1
leal -0x1(%r12), %r11d
movq %r11, %rdx
shlq $0x5, %rdx
movq %rax, %rcx
addq %rdx, %rcx
movl %r12d, %edx
vmovdqa %ymm7, 0x140(%rsp)
vmovdqa %ymm1, (%rcx)
vpsubq %ymm3, %ymm1, %ymm1
vmovq %xmm7, %rsi
vmovq %xmm1, %rdi
cmpq %rdi, %rsi
cmovlq %rsi, %rdi
vpextrq $0x1, %xmm7, %rsi
vpextrq $0x1, %xmm1, %r8
cmpq %r8, %rsi
cmovlq %rsi, %r8
vextracti128 $0x1, %ymm7, %xmm4
vmovq %xmm4, %rsi
vextracti128 $0x1, %ymm1, %xmm5
vmovq %xmm5, %r9
cmpq %r9, %rsi
cmovlq %rsi, %r9
vpextrq $0x1, %xmm4, %rsi
vpextrq $0x1, %xmm5, %r10
cmpq %r10, %rsi
cmovlq %rsi, %r10
vmovq %r10, %xmm4
vmovq %r9, %xmm5
vpunpcklqdq %xmm4, %xmm5, %xmm4 # xmm4 = xmm5[0],xmm4[0]
vmovq %r8, %xmm5
vmovq %rdi, %xmm6
vpunpcklqdq %xmm5, %xmm6, %xmm5 # xmm5 = xmm6[0],xmm5[0]
vinserti128 $0x1, %xmm4, %ymm5, %ymm7
addq $-0x20, %rcx
decl %edx
jg 0x575c81
movq %rax, 0x28(%rsp)
movl %r11d, %ecx
shlq $0x5, %rcx
movq 0x10(%rsp), %rax
addq %rax, %rcx
movq %rcx, 0xd0(%rsp)
movl 0x100(%rsp), %ecx
movq %rcx, 0xa0(%rsp)
shlq $0x5, %rcx
addq %rax, %rcx
movq %rcx, 0xc8(%rsp)
cmpl $0x1, %r12d
movl %r12d, %r11d
adcl $0x0, %r11d
movq 0x18(%rsp), %rcx
cmpl $0x2, %ecx
movl $0x1, %eax
cmovgel %ecx, %eax
movq %rax, 0xc0(%rsp)
movq 0x58(%rsp), %rax
shlq $0x5, %rax
movq %rax, 0xb8(%rsp)
shlq $0x5, %r11
xorl %ecx, %ecx
vbroadcastsd 0x85600(%rip), %ymm13 # 0x5fb388
vbroadcastsd 0x855ff(%rip), %ymm14 # 0x5fb390
vbroadcastsd 0x855fe(%rip), %ymm15 # 0x5fb398
vpbroadcastq 0x855fd(%rip), %ymm9 # 0x5fb3a0
vpbroadcastq 0x80354(%rip), %ymm10 # 0x5f6100
vbroadcastsd 0x83bcb(%rip), %ymm1 # 0x5f9980
vmovaps %ymm1, 0x180(%rsp)
vpcmpeqq 0x838f9(%rip), %ymm0, %ymm0 # 0x5f96c0
vmovdqa %ymm0, 0x160(%rsp)
xorl %edx, %edx
movl 0xc(%rsp), %eax
movl %eax, 0x8(%rsp)
vmovapd 0x120(%rsp), %ymm0
vmovapd %ymm0, %ymm6
vmovapd %ymm0, %ymm1
movq %r15, 0x98(%rsp)
vmovdqa %ymm8, 0x1c0(%rsp)
movq %r11, 0x38(%rsp)
vmovapd %ymm15, 0x1a0(%rsp)
vmovdqa %ymm9, 0x100(%rsp)
vmovdqa %ymm10, 0xe0(%rsp)
movq %rcx, 0x18(%rsp)
vmovapd %ymm6, 0x200(%rsp)
vmovapd %ymm1, 0x220(%rsp)
movq 0xd0(%rsp), %rax
vmovdqa (%rax), %ymm0
vinserti128 $0x1, %xmm0, %ymm0, %ymm1
vpalignr $0x8, %ymm1, %ymm0, %ymm0 # ymm0 = ymm1[8,9,10,11,12,13,14,15],ymm0[0,1,2,3,4,5,6,7],ymm1[24,25,26,27,28,29,30,31],ymm0[16,17,18,19,20,21,22,23]
vmovq (%r14,%rdx,8), %xmm1
vpblendd $0x3, %ymm1, %ymm0, %ymm11 # ymm11 = ymm1[0,1],ymm0[2,3,4,5,6,7]
movq 0x80(%rsp), %rax
movq 0x10(%rax), %rax
movq 0x88(%rsp), %rcx
movq %rdx, 0x90(%rsp)
movzbl (%rcx,%rdx), %ecx
movslq (%rax,%rcx,4), %rax
imulq 0x58(%rsp), %rax
shlq $0x5, %rax
addq 0xd8(%rsp), %rax
movq %rax, 0x30(%rsp)
movq 0x28(%rsp), %rdx
vmovdqa 0x120(%rsp), %ymm0
vpsubq (%rdx), %ymm0, %ymm1
xorl %r13d, %r13d
movq 0x60(%rsp), %rbx
movq 0x10(%rsp), %r14
movq 0x30(%rsp), %rax
vpaddq (%rax,%r13), %ymm11, %ymm4
vmovdqa (%r14,%r13), %ymm11
vmovdqa (%rbx,%r13), %ymm5
vpsubq %ymm2, %ymm11, %ymm8
vpsubq %ymm3, %ymm5, %ymm5
vpcmpgtq %ymm5, %ymm8, %ymm9
vblendvpd %ymm9, %ymm13, %ymm14, %ymm9
movq 0x10(%r15), %rax
movq (%rax), %rax
vpaddq (%rdx,%r13), %ymm1, %ymm1
addq 0x18(%rsp), %rax
vmovapd %ymm9, (%r13,%rax)
vmovq %xmm8, %rax
vmovq %xmm5, %rdi
cmpq %rdi, %rax
cmovgq %rax, %rdi
vpextrq $0x1, %xmm8, %rax
vpextrq $0x1, %xmm5, %r9
cmpq %r9, %rax
cmovgq %rax, %r9
vextracti128 $0x1, %ymm8, %xmm8
vmovq %xmm8, %rax
vextracti128 $0x1, %ymm5, %xmm5
vmovq %xmm5, %rsi
cmpq %rsi, %rax
cmovgq %rax, %rsi
vpextrq $0x1, %xmm8, %rax
vpextrq $0x1, %xmm5, %r11
cmpq %r11, %rax
cmovgq %rax, %r11
vmovq %xmm7, %rax
cmpq %rdi, %rax
cmovgeq %rdi, %rax
vpextrq $0x1, %xmm7, %rdx
cmpq %r9, %rdx
cmovgeq %r9, %rdx
vextracti128 $0x1, %ymm7, %xmm5
vmovq %xmm5, %r12
cmpq %rsi, %r12
cmovgeq %rsi, %r12
vmovq %rdi, %xmm7
vpextrq $0x1, %xmm5, %rcx
cmpq %r11, %rcx
cmovgeq %r11, %rcx
vmovq %rcx, %xmm8
vmovq %xmm0, %rcx
vmovq %xmm1, %r10
cmpq %r10, %rcx
cmovgq %rcx, %r10
vpextrq $0x1, %xmm0, %rcx
vpextrq $0x1, %xmm1, %r8
cmpq %r8, %rcx
cmovgq %rcx, %r8
vextracti128 $0x1, %ymm0, %xmm0
vmovq %xmm0, %r15
vextracti128 $0x1, %ymm1, %xmm1
vmovq %xmm1, %rcx
cmpq %rcx, %r15
cmovgq %r15, %rcx
vpextrq $0x1, %xmm0, %r15
vmovq %r12, %xmm0
vpextrq $0x1, %xmm1, %r12
cmpq %r12, %r15
cmovgq %r15, %r12
vmovq %xmm4, %r15
cmpq %r15, %rdi
cmovleq %r15, %rdi
movq 0x98(%rsp), %r15
vmovq %r9, %xmm1
vmovq %rsi, %xmm5
vmovq %rdx, %xmm9
vpextrq $0x1, %xmm4, %rdx
cmpq %rdx, %r9
cmovleq %rdx, %r9
vextracti128 $0x1, %ymm4, %xmm10
vmovq %xmm10, %rdx
cmpq %rdx, %rsi
cmovleq %rdx, %rsi
vmovq %r11, %xmm12
vmovapd %ymm13, %ymm15
vmovq %rax, %xmm13
vpextrq $0x1, %xmm10, %rax
cmpq %rax, %r11
cmovleq %rax, %r11
vmovq %r11, %xmm10
movq 0x38(%rsp), %r11
movq 0x28(%rsp), %rdx
vmovdqa %ymm3, %ymm6
vmovdqa %ymm2, %ymm3
vmovapd %ymm14, %ymm2
vpunpcklqdq %xmm1, %xmm7, %xmm14 # xmm14 = xmm7[0],xmm1[0]
vpunpcklqdq %xmm12, %xmm5, %xmm12 # xmm12 = xmm5[0],xmm12[0]
vpunpcklqdq %xmm8, %xmm0, %xmm0 # xmm0 = xmm0[0],xmm8[0]
vpunpcklqdq %xmm9, %xmm13, %xmm1 # xmm1 = xmm13[0],xmm9[0]
vmovapd %ymm15, %ymm13
vinserti128 $0x1, %xmm0, %ymm1, %ymm7
vmovq %r12, %xmm0
vmovq %rcx, %xmm1
vpunpcklqdq %xmm0, %xmm1, %xmm0 # xmm0 = xmm1[0],xmm0[0]
vmovq %r8, %xmm1
vmovq %r10, %xmm5
vpunpcklqdq %xmm1, %xmm5, %xmm1 # xmm1 = xmm5[0],xmm1[0]
vinserti128 $0x1, %xmm0, %ymm1, %ymm0
vmovq %r9, %xmm8
vmovq %rdi, %xmm1
vpunpcklqdq %xmm8, %xmm1, %xmm1 # xmm1 = xmm1[0],xmm8[0]
vmovq %rsi, %xmm5
vinserti128 $0x1, %xmm5, %ymm1, %ymm5
vpbroadcastq %xmm10, %ymm1
vpblendd $0xc0, %ymm1, %ymm5, %ymm1 # ymm1 = ymm5[0,1,2,3,4,5],ymm1[6,7]
vmovdqa %xmm12, 0x10(%rbx,%r13)
vmovdqa %xmm14, (%rbx,%r13)
vmovapd %ymm2, %ymm14
vmovdqa %ymm3, %ymm2
vmovdqa %ymm6, %ymm3
movq 0x48(%rsp), %rax
vmovdqa %ymm1, (%rax,%r13)
vmovdqa %ymm4, (%r14,%r13)
addq $0x20, %r13
cmpq %r13, %r11
jne 0x575eb1
vpbroadcastq %xmm8, %ymm0
vpunpcklqdq %ymm5, %ymm0, %ymm0 # ymm0 = ymm0[0],ymm5[0],ymm0[2],ymm5[2]
movq 0x68(%rsp), %rax
movq 0x90(%rsp), %r14
movq 0x8(%rax,%r14,8), %rbx
vmovq %rbx, %xmm1
vpblendd $0x3, %ymm1, %ymm0, %ymm0 # ymm0 = ymm1[0,1],ymm0[2,3,4,5,6,7]
vpaddq (%rdx), %ymm0, %ymm0
vmovq %xmm0, %rax
cmpq %rax, %r10
cmovgq %r10, %rax
vpextrq $0x1, %xmm0, %rdx
cmpq %rdx, %r8
cmovgq %r8, %rdx
vextracti128 $0x1, %ymm0, %xmm0
vmovq %xmm0, %r8
cmpq %r8, %rcx
cmovgq %rcx, %r8
vpextrq $0x1, %xmm0, %rcx
leaq 0x1(%r14), %r10
movq %r10, 0x30(%rsp)
cmpq %rcx, %r12
cmovgq %r12, %rcx
vmovq %rcx, %xmm0
vmovq %r8, %xmm1
vpunpcklqdq %xmm0, %xmm1, %xmm0 # xmm0 = xmm1[0],xmm0[0]
vmovq %rdx, %xmm1
vmovq %rax, %xmm4
vpunpcklqdq %xmm1, %xmm4, %xmm1 # xmm1 = xmm4[0],xmm1[0]
vinserti128 $0x1, %xmm0, %ymm1, %ymm0
movl $0x1, %eax
vmovdqa 0x1c0(%rsp), %ymm6
vperm2i128 $0x8, %ymm0, %ymm0, %ymm1 # ymm1 = zero,zero,ymm0[0,1]
vpalignr $0x8, %ymm1, %ymm0, %ymm1 # ymm1 = ymm1[8,9,10,11,12,13,14,15],ymm0[0,1,2,3,4,5,6,7],ymm1[24,25,26,27,28,29,30,31],ymm0[16,17,18,19,20,21,22,23]
vpaddq %ymm1, %ymm6, %ymm1
vmovq %xmm0, %rcx
vmovq %xmm1, %rdx
cmpq %rdx, %rcx
cmovgq %rcx, %rdx
vpextrq $0x1, %xmm0, %rcx
vpextrq $0x1, %xmm1, %r8
cmpq %r8, %rcx
cmovgq %rcx, %r8
vextracti128 $0x1, %ymm0, %xmm0
vmovq %xmm0, %rcx
vextracti128 $0x1, %ymm1, %xmm4
vmovq %xmm4, %r10
cmpq %r10, %rcx
cmovgq %rcx, %r10
vmovq %r8, %xmm1
vmovq %rdx, %xmm5
vpunpcklqdq %xmm1, %xmm5, %xmm5 # xmm5 = xmm5[0],xmm1[0]
vmovq %r10, %xmm8
vpextrq $0x1, %xmm0, %rcx
vpextrq $0x1, %xmm4, %rdx
vinserti128 $0x1, %xmm8, %ymm5, %ymm4
cmpq %rdx, %rcx
cmovgq %rcx, %rdx
vmovq %rdx, %xmm0
vpbroadcastq %xmm0, %ymm0
vpblendd $0xc0, %ymm0, %ymm4, %ymm0 # ymm0 = ymm4[0,1,2,3,4,5],ymm0[6,7]
decl %eax
je 0x576193
vpbroadcastq %xmm1, %xmm0
vpxor %xmm1, %xmm1, %xmm1
vinserti128 $0x1, %xmm0, %ymm1, %ymm0
vpalignr $0x8, %ymm0, %ymm4, %ymm0 # ymm0 = ymm0[8,9,10,11,12,13,14,15],ymm4[0,1,2,3,4,5,6,7],ymm0[24,25,26,27,28,29,30,31],ymm4[16,17,18,19,20,21,22,23]
vpaddq 0x1e0(%rsp), %ymm0, %ymm11
vmovq %xmm11, %rax
cmpq %rbx, %rax
cmovgq %rax, %rbx
vpextrq $0x1, %xmm11, %rax
cmpq %rdi, %rax
cmovgq %rax, %rdi
vextracti128 $0x1, %ymm11, %xmm0
vmovq %xmm0, %rax
cmpq %r9, %rax
cmovgq %rax, %r9
vpextrq $0x1, %xmm0, %rax
cmpq %rsi, %rax
cmovgq %rax, %rsi
vmovq %rsi, %xmm0
vmovq %r9, %xmm1
vpunpcklqdq %xmm0, %xmm1, %xmm0 # xmm0 = xmm1[0],xmm0[0]
vmovq %rdi, %xmm1
vmovq %rbx, %xmm4
vpunpcklqdq %xmm1, %xmm4, %xmm1 # xmm1 = xmm4[0],xmm1[0]
vinserti128 $0x1, %xmm0, %ymm1, %ymm0
xorl %esi, %esi
vmovdqa 0x200(%rsp), %ymm6
vmovapd 0x1a0(%rsp), %ymm15
vmovapd 0x100(%rsp), %ymm9
vmovdqa 0xe0(%rsp), %ymm10
vmovapd 0x180(%rsp), %ymm12
movq 0x10(%r15), %rax
movq (%rax), %r12
addq 0x18(%rsp), %r12
vpsubq %ymm2, %ymm0, %ymm0
vpsubq %ymm3, %ymm11, %ymm1
vmovq %xmm0, %rax
vmovq %xmm1, %r8
cmpq %r8, %rax
cmovgq %rax, %r8
vpextrq $0x1, %xmm0, %rax
vpextrq $0x1, %xmm1, %r10
cmpq %r10, %rax
cmovgq %rax, %r10
vextracti128 $0x1, %ymm0, %xmm4
vmovq %xmm4, %rcx
vextracti128 $0x1, %ymm1, %xmm5
vmovq %xmm5, %rax
cmpq %rax, %rcx
cmovgq %rcx, %rax
vpextrq $0x1, %xmm4, %rcx
vpextrq $0x1, %xmm5, %rbx
cmpq %rbx, %rcx
cmovgq %rcx, %rbx
vmovq %rbx, %xmm4
vmovq %rax, %xmm5
vpunpcklqdq %xmm4, %xmm5, %xmm4 # xmm4 = xmm5[0],xmm4[0]
vmovq %r10, %xmm5
vmovq %r8, %xmm8
vpunpcklqdq %xmm5, %xmm8, %xmm5 # xmm5 = xmm8[0],xmm5[0]
vinserti128 $0x1, %xmm4, %ymm5, %ymm11
vpcmpgtq %ymm1, %ymm0, %ymm0
vblendvpd %ymm0, %ymm15, %ymm9, %ymm1
movq 0x48(%rsp), %rdx
movq (%rdx,%rsi), %rcx
movq 0x8(%rdx,%rsi), %rdi
cmpq %r8, %rcx
cmovleq %r8, %rcx
cmpq %r10, %rdi
cmovleq %r10, %rdi
movq 0x10(%rdx,%rsi), %r9
cmpq %rax, %r9
cmovleq %rax, %r9
movq 0x18(%rdx,%rsi), %r11
cmpq %rbx, %r11
cmovleq %rbx, %r11
vmovq %r11, %xmm0
vmovq %r9, %xmm4
vpunpcklqdq %xmm0, %xmm4, %xmm0 # xmm0 = xmm4[0],xmm0[0]
vmovq %rdi, %xmm4
vmovq %rcx, %xmm5
vpunpcklqdq %xmm4, %xmm5, %xmm4 # xmm4 = xmm5[0],xmm4[0]
vinserti128 $0x1, %xmm0, %ymm4, %ymm0
movq 0x10(%rsp), %r14
vpcmpeqq (%r14,%rsi), %ymm0, %ymm4
vpcmpeqq %ymm11, %ymm0, %ymm5
vpsubq %ymm5, %ymm10, %ymm5
vblendvpd %ymm4, %ymm12, %ymm5, %ymm4
vorpd (%rsi,%r12), %ymm1, %ymm1
vorpd %ymm4, %ymm1, %ymm1
vmovapd %ymm1, (%rsi,%r12)
vmovq %xmm7, %rdx
cmpq %rcx, %rdx
cmovgeq %rcx, %rdx
vpextrq $0x1, %xmm7, %r15
cmpq %rdi, %r15
cmovgeq %rdi, %r15
vextracti128 $0x1, %ymm7, %xmm1
vmovq %xmm1, %r12
cmpq %r9, %r12
cmovgeq %r9, %r12
vpextrq $0x1, %xmm1, %r13
cmpq %r11, %r13
cmovgeq %r11, %r13
cmpq %r8, %rdx
cmovgeq %r8, %rdx
cmpq %r10, %r15
cmovgeq %r10, %r15
cmpq %rax, %r12
cmovgeq %rax, %r12
cmpq %rbx, %r13
cmovgeq %rbx, %r13
vmovq %r13, %xmm1
vmovq %r12, %xmm4
vmovq %r15, %xmm5
movq 0x98(%rsp), %r15
vmovq %xmm6, %rax
cmpq %rcx, %rax
cmovgq %rax, %rcx
vpextrq $0x1, %xmm6, %rax
cmpq %rdi, %rax
cmovgq %rax, %rdi
vextracti128 $0x1, %ymm6, %xmm6
vmovq %xmm6, %rax
cmpq %r9, %rax
cmovgq %rax, %r9
vmovq %rdx, %xmm7
vpextrq $0x1, %xmm6, %rax
cmpq %r11, %rax
cmovgq %rax, %r11
vmovq %r11, %xmm6
movq 0x38(%rsp), %r11
vmovq %r9, %xmm8
vmovq %rdi, %xmm9
vmovq %rcx, %xmm10
vpunpcklqdq %xmm1, %xmm4, %xmm1 # xmm1 = xmm4[0],xmm1[0]
vpunpcklqdq %xmm5, %xmm7, %xmm4 # xmm4 = xmm7[0],xmm5[0]
vinserti128 $0x1, %xmm1, %ymm4, %ymm7
vmovdqa %ymm0, (%r14,%rsi)
vpunpcklqdq %xmm6, %xmm8, %xmm1 # xmm1 = xmm8[0],xmm6[0]
vpunpcklqdq %xmm9, %xmm10, %xmm4 # xmm4 = xmm10[0],xmm9[0]
vmovdqa 0xe0(%rsp), %ymm10
vmovdqa 0x100(%rsp), %ymm9
vinserti128 $0x1, %xmm1, %ymm4, %ymm6
addq $0x20, %rsi
cmpq %rsi, %r11
jne 0x5762cf
movq 0xc8(%rsp), %rdi
vmovdqa (%rdi), %ymm0
vmovdqa 0x220(%rsp), %ymm1
vpcmpgtq %ymm1, %ymm0, %ymm0
movq (%rdi), %rax
vmovq %xmm1, %rcx
cmpq %rcx, %rax
cmovgq %rax, %rcx
vpextrq $0x1, %xmm1, %rax
movq 0x8(%rdi), %rdx
cmpq %rax, %rdx
cmovgq %rdx, %rax
movq 0x10(%rdi), %rdx
vextracti128 $0x1, %ymm1, %xmm1
vmovq %xmm1, %rsi
cmpq %rsi, %rdx
cmovgq %rdx, %rsi
vpextrq $0x1, %xmm1, %rdx
movq 0x18(%rdi), %rdi
cmpq %rdx, %rdi
cmovgq %rdi, %rdx
vmovq %rdx, %xmm1
vmovq %rsi, %xmm4
vpunpcklqdq %xmm1, %xmm4, %xmm1 # xmm1 = xmm4[0],xmm1[0]
vmovq %rax, %xmm4
vmovq %rcx, %xmm5
vpunpcklqdq %xmm4, %xmm5, %xmm4 # xmm4 = xmm5[0],xmm4[0]
vinserti128 $0x1, %xmm1, %ymm4, %ymm1
vtestpd 0x160(%rsp), %ymm0
movl 0x8(%rsp), %eax
cmovnel 0x90(%rsp), %eax
movl %eax, 0x8(%rsp)
movq 0x18(%rsp), %rcx
addq 0xb8(%rsp), %rcx
movq 0x30(%rsp), %rax
movq %rax, %rdx
cmpq 0xc0(%rsp), %rax
movq 0x68(%rsp), %r14
jne 0x575e1c
movl 0x20(%rbp), %r13d
testl %r13d, %r13d
movl 0x74(%rsp), %r8d
movq 0xb0(%rsp), %r9
movq 0x78(%rsp), %r10
movq 0x50(%rsp), %r11
movq 0x48(%rsp), %r12
je 0x576603
cmpl $0x2, 0x24(%rsp)
jg 0x5765f7
movl 0x44(%rsp), %ecx
cmpl $0x2, %ecx
movl $0x1, %eax
cmovgel %ecx, %eax
vperm2f128 $0x8, %ymm1, %ymm1, %ymm0 # ymm0 = zero,zero,ymm1[0,1]
vpalignr $0x8, %ymm0, %ymm1, %ymm1 # ymm1 = ymm0[8,9,10,11,12,13,14,15],ymm1[0,1,2,3,4,5,6,7],ymm0[24,25,26,27,28,29,30,31],ymm1[16,17,18,19,20,21,22,23]
decl %eax
jne 0x5765e7
vextracti128 $0x1, %ymm1, %xmm0
vpextrq $0x1, %xmm0, %r11
cmpl $0x0, 0x10(%rbp)
je 0x576678
testl $0x7ffffffc, 0xa8(%rsp) # imm = 0x7FFFFFFC
je 0x576678
movl %r10d, %ecx
andl $0x1fffffff, %ecx       # imm = 0x1FFFFFFF
shll $0x2, %ecx
xorl %edx, %edx
movl %r8d, %eax
movl %edx, %edi
shrl $0x2, %edi
movl %edx, %esi
andl $0x3, %esi
imull %r10d, %esi
addl %edi, %esi
cmpl %r9d, %esi
jge 0x57666f
movq 0x10(%rsp), %rdi
movq (%rdi,%rdx,8), %rdi
cmpq %r11, %rdi
jle 0x576659
movq %rdi, %r11
movl 0xc(%rsp), %eax
movl %eax, 0x8(%rsp)
movl %esi, %eax
jmp 0x57666f
cmpl %eax, %esi
cmovgel %eax, %esi
movl 0x8(%rsp), %ebx
cmpl 0xc(%rsp), %ebx
cmovnel %eax, %esi
cmpq %r11, %rdi
cmovel %esi, %eax
incq %rdx
cmpl %edx, %ecx
jne 0x576627
jmp 0x57667b
movl %r8d, %eax
orl 0x10(%rbp), %r13d
jne 0x5766d4
movq 0xa0(%rsp), %rcx
shlq $0x5, %rcx
movq 0x10(%rsp), %rax
vmovdqa (%rax,%rcx), %ymm0
cmpl $0x2, 0x24(%rsp)
jg 0x5766bd
movl 0x44(%rsp), %ecx
cmpl $0x2, %ecx
movl $0x1, %eax
cmovgel %ecx, %eax
vperm2i128 $0x8, %ymm0, %ymm0, %ymm1 # ymm1 = zero,zero,ymm0[0,1]
vpalignr $0x8, %ymm1, %ymm0, %ymm0 # ymm0 = ymm1[8,9,10,11,12,13,14,15],ymm0[0,1,2,3,4,5,6,7],ymm1[24,25,26,27,28,29,30,31],ymm0[16,17,18,19,20,21,22,23]
decl %eax
jne 0x5766ad
vextracti128 $0x1, %ymm0, %xmm0
vpextrq $0x1, %xmm0, %r11
movl 0xc(%rsp), %eax
movl %eax, 0x8(%rsp)
movl %r8d, %eax
vmovdqa 0x120(%rsp), %ymm0
vpcmpgtq %ymm7, %ymm0, %ymm0
vpcmpgtq 0x140(%rsp), %ymm6, %ymm1
vpor %ymm1, %ymm0, %ymm0
vtestpd %ymm0, %ymm0
je 0x576709
orb $0x40, 0xc(%r15)
xorl %r11d, %r11d
movl $0x0, 0x8(%rsp)
xorl %eax, %eax
movl %r11d, (%r15)
movl %eax, 0x4(%r15)
movl 0x8(%rsp), %eax
movl %eax, 0x8(%r15)
movq 0x28(%rsp), %rdi
vzeroupper
callq 0x2094b5
movq 0x10(%rsp), %rdi
callq 0x2094b5
movq %r12, %rdi
callq 0x2094b5
movq %r14, %rdi
callq 0x2094b5
movq 0x60(%rsp), %rdi
callq 0x2094b5
jmp 0x576784
callq 0x1f7adf
jmp 0x576781
callq 0x1f7ab9
jmp 0x576781
callq 0x1f7a93
jmp 0x576781
callq 0x1f7a6d
jmp 0x576781
callq 0x1f7a47
jmp 0x576781
callq 0x1f7a21
jmp 0x576781
callq 0x1f79fb
jmp 0x576781
callq 0x1f79d5
xorl %r15d, %r15d
movq %r15, %rax
leaq -0x28(%rbp), %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq