// File: /workspace/github_c_makefile_star2_O3/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
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x178, %rsp            # imm = 0x178
movq %rsi, 0x40(%rsp)
testq %rdi, %rdi
je 0x5a8149
movq 0x60(%rdi), %rax
movq %rax, 0x68(%rsp)
testq %rax, %rax
je 0x5a8150
movq 0x10(%rdi), %rax
movq %rax, 0x38(%rsp)
testq %rax, %rax
je 0x5a8157
movl %edx, %r12d
movl 0x8(%rdi), %edx
testl %edx, %edx
jle 0x5a815e
cmpq $0x0, 0x40(%rsp)
je 0x5a8165
testl %r12d, %r12d
jle 0x5a816c
testl %ecx, %ecx
js 0x5a8173
testl %r8d, %r8d
js 0x5a817a
movl %r9d, %r15d
movl %r8d, 0x10(%rsp)
leal -0x1(%rdx), %eax
movq %rdx, 0x60(%rsp)
leaq 0x3(%rdx), %r14
movq %r14, %r13
shrq $0x2, %r13
movl %eax, 0x34(%rsp)
xorl %edx, %edx
divl %r13d
movl %eax, 0x8(%rsp)
movl %edx, %ebp
movl %ecx, %edi
negl %ecx
movq 0x38(%rsp), %rsi
movslq 0x20(%rsi), %rax
movq %rdi, 0x70(%rsp)
btsq $0x3f, %rdi
movabsq $-0x8000000000000000, %rdx # imm = 0x8000000000000000
subq %rax, %rdx
movl %ecx, 0xd0(%rsp)
cmpl %ecx, %eax
cmovgq %rdi, %rdx
movq %rdx, 0x18(%rsp)
movslq 0x1c(%rsi), %rax
movq %rax, 0xb0(%rsp)
movl $0x20, %edx
movl $0x20, %ecx
movl %r13d, %edi
movl %r12d, %esi
callq 0x20adf4
testq %rax, %rax
je 0x5a817f
movq %rax, %rbx
movl %ebp, 0x90(%rsp)
movq %r14, 0x50(%rsp)
movl 0x1c0(%rsp), %edi
xorl %eax, %eax
testl %r15d, %r15d
setne %al
xorl %ecx, %ecx
cmpl $0x0, 0x1b0(%rsp)
setne %cl
shll $0x4, %ecx
xorl %edx, %edx
cmpl $0x0, 0x1b8(%rsp)
setne %dl
shll $0xe, %edx
xorl %esi, %esi
movl %edi, 0x30(%rsp)
testl %edi, %edi
setne %sil
shll $0xf, %esi
leal (%rcx,%rax,8), %eax
orl %edx, %eax
orl %esi, %eax
orl 0xc(%rbx), %eax
orl $0x4880402, %eax        # imm = 0x4880402
movl %eax, 0xc(%rbx)
movl $0x20, %edi
movq %r13, %rsi
callq 0x4f1904
movl %r15d, 0x28(%rsp)
movq %rax, %r15
leal 0x1(%r12), %esi
movl $0x20, %edi
callq 0x20a636
movq %rax, 0x58(%rsp)
movl $0x20, %edi
movq %r13, %rsi
callq 0x4f1904
movq %rax, %r14
movl $0x20, %edi
movq %r13, %rsi
callq 0x4f1904
movq %rax, %rbp
movl $0x20, %edi
movq %r13, 0x20(%rsp)
movq %r13, %rsi
movq 0x58(%rsp), %r13
callq 0x4f1904
testq %r15, %r15
sete %cl
testq %r13, %r13
sete %dl
orb %cl, %dl
testq %r14, %r14
sete %cl
testq %rbp, %rbp
sete %sil
orb %cl, %sil
orb %dl, %sil
testq %rax, %rax
sete %cl
orb %sil, %cl
jne 0x5a817f
leal -0x1(%r12), %ecx
movl %ecx, 0x4(%rsp)
movl $0x3, %esi
subl 0x8(%rsp), %esi
vmovq 0x70(%rsp), %xmm0
vpbroadcastq %xmm0, %ymm3
movl 0x10(%rsp), %r9d
movl %r9d, %ecx
vmovq %rcx, %xmm0
vpbroadcastq %xmm0, %ymm4
movq 0x18(%rsp), %rdx
incq %rdx
movabsq $-0x8000000000000000, %rdi # imm = 0x8000000000000000
subq 0xb0(%rsp), %rdi
addq $-0x2, %rdi
movq %rdx, 0x18(%rsp)
vmovq %rdx, %xmm0
vpbroadcastq %xmm0, %ymm1
vmovq %rdi, %xmm0
vpbroadcastq %xmm0, %ymm6
movl %esi, 0xc(%rsp)
movslq %esi, %rdx
vmovq %rdx, %xmm0
vpbroadcastq %xmm0, %ymm7
vmovdqu %ymm1, 0x70(%rsp)
vmovq %xmm1, %xmm2            # xmm2 = xmm1[0],zero
movq 0x20(%rsp), %rdi
movl %edi, %edx
imull %r9d, %edx
negl %edx
movslq %edx, %rdx
vmovq %rdx, %xmm0
vpbroadcastq %xmm0, %ymm0
vpxor %xmm1, %xmm1, %xmm1
vpblendd $0x3, %ymm1, %ymm0, %ymm0 # ymm0 = ymm1[0,1],ymm0[2,3,4,5,6,7]
vmovdqu %ymm2, 0xb0(%rsp)
vpaddq %ymm0, %ymm2, %ymm15
cmpl $0x0, 0x28(%rsp)
setne %dl
movl 0xd0(%rsp), %r8d
movslq %r8d, %rsi
vmovd %edi, %xmm0
vpbroadcastd %xmm0, %ymm1
vmovq %rcx, %xmm0
vpbroadcastq %xmm0, %ymm0
vmovq %rsi, %xmm2
vpbroadcastq %xmm2, %ymm2
vpmuldq 0x85fc3(%rip), %ymm1, %ymm1 # 0x62db40
vmovd %edx, %xmm5
vpbroadcastb %xmm5, %xmm5
xorl %ecx, %ecx
vpslld $0x1f, %xmm5, %xmm5
vpsrad $0x1f, %xmm5, %xmm5
vpmovsxdq %xmm5, %ymm5
movq %rbp, %rdx
movq %r15, %rsi
vmovq %rcx, %xmm8
vpbroadcastq %xmm8, %ymm8
vpaddq %ymm1, %ymm8, %ymm8
vpmuludq %ymm0, %ymm8, %ymm9
vpsrlq $0x20, %ymm8, %ymm8
vpmuludq %ymm0, %ymm8, %ymm8
vpsllq $0x20, %ymm8, %ymm8
vpaddq %ymm8, %ymm9, %ymm8
vpsubq %ymm8, %ymm2, %ymm8
vpandn %ymm8, %ymm5, %ymm8
vpsubq %ymm3, %ymm8, %ymm9
vmovdqa %ymm8, (%rdx)
vmovdqa %ymm9, (%rsi)
incq %rcx
addq $0x20, %rsi
addq $0x20, %rdx
cmpq %rcx, %rdi
jne 0x5a7b9d
movq $0x0, (%r13)
movl %r12d, %ecx
addl $0x3, %r12d
andl $-0x4, %r12d
movq %rcx, 0x28(%rsp)
decq %rcx
vmovq %rcx, %xmm0
vpbroadcastq %xmm0, %ymm9
vmovd %r9d, %xmm0
vpbroadcastd %xmm0, %xmm0
vmovd %r8d, %xmm1
vpbroadcastd %xmm1, %xmm2
vpmovsxbd 0x85f98(%rip), %xmm5 # 0x62dbc4
xorl %ecx, %ecx
vpmovsxbq 0x85f91(%rip), %ymm1 # 0x62dbc8
vpbroadcastq 0x85f40(%rip), %ymm8 # 0x62db80
vpxor %ymm8, %ymm9, %ymm9
vpcmpeqd %ymm10, %ymm10, %ymm10
vpcmpeqd %xmm11, %xmm11, %xmm11
vpbroadcastd 0x85f68(%rip), %xmm12 # 0x62dbc0
movl 0x1b8(%rsp), %edx
testl %edx, %edx
je 0x5a7c6a
vpxor %xmm13, %xmm13, %xmm13
jmp 0x5a7c7d
vpaddd %xmm5, %xmm11, %xmm13
vpmulld %xmm0, %xmm13, %xmm13
vpsubd %xmm13, %xmm2, %xmm13
vpmovsxdq %xmm13, %ymm13
vmovq %rcx, %xmm14
vpbroadcastq %xmm14, %ymm14
vpor %ymm1, %ymm14, %ymm14
vpxor %ymm8, %ymm14, %ymm14
vpcmpgtq %ymm9, %ymm14, %ymm14
vpxor %ymm10, %ymm14, %ymm14
vpmaskmovq %ymm13, %ymm14, 0x8(%r13,%rcx,8)
addq $0x4, %rcx
vpaddd %xmm5, %xmm12, %xmm5
cmpq %rcx, %r12
jne 0x5a7c5f
vpxor %xmm0, %xmm0, %xmm0
vpsubq %ymm3, %ymm0, %ymm0
leal -0x1(%rdi), %edx
shlq $0x5, %rdx
movq %rax, %rcx
movq %rdx, 0x10(%rsp)
addq %rdx, %rcx
movl %edi, %edx
vmovdqu %ymm6, 0xf0(%rsp)
vmovdqa %ymm6, %ymm2
vmovdqa %ymm0, (%rcx)
vpsubq %ymm4, %ymm0, %ymm0
vpcmpgtq %ymm2, %ymm0, %ymm1
vblendvpd %ymm1, %ymm2, %ymm0, %ymm2
addq $-0x20, %rcx
decl %edx
jg 0x5a7cd7
addq %rbp, 0x10(%rsp)
movl 0x90(%rsp), %r10d
movq %r10, 0x48(%rsp)
shlq $0x5, %r10
addq %rbp, %r10
movq %rdi, %r11
shlq $0x5, %r11
xorl %r12d, %r12d
movl %edi, %esi
vbroadcastsd 0x87f88(%rip), %ymm10 # 0x62fca8
vbroadcastsd 0x87f87(%rip), %ymm9 # 0x62fcb0
vbroadcastsd 0x87f86(%rip), %ymm11 # 0x62fcb8
vbroadcastsd 0x87f85(%rip), %ymm12 # 0x62fcc0
vpbroadcastq 0x87f84(%rip), %ymm13 # 0x62fcc8
vbroadcastsd 0x85e3b(%rip), %ymm14 # 0x62db88
vpcmpeqq 0x85e4a(%rip), %ymm7, %ymm0 # 0x62dba0
vmovdqu %ymm0, 0x110(%rsp)
xorl %ecx, %ecx
movl 0x4(%rsp), %edi
vmovdqu 0x70(%rsp), %ymm0
vmovdqa %ymm0, %ymm7
vmovdqa %ymm0, %ymm5
vmovdqu %ymm15, 0x150(%rsp)
vmovupd %ymm11, 0x90(%rsp)
vmovupd %ymm12, 0x130(%rsp)
vmovdqu %ymm5, 0xd0(%rsp)
movq 0x10(%rsp), %rdx
vmovdqa (%rdx), %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 (%r13,%rcx,8), %xmm1
vpblendd $0x3, %ymm1, %ymm0, %ymm15 # ymm15 = ymm1[0,1],ymm0[2,3,4,5,6,7]
movq 0x38(%rsp), %rdx
movq 0x10(%rdx), %rdx
movq 0x40(%rsp), %r8
movzbl (%r8,%rcx), %r8d
movslq (%rdx,%r8,4), %rdx
imulq %rsi, %rdx
shlq $0x5, %rdx
addq 0x68(%rsp), %rdx
vmovdqu 0x70(%rsp), %ymm0
vpsubq (%rax), %ymm0, %ymm5
xorl %r8d, %r8d
vmovapd %ymm9, %ymm12
vpaddq (%rdx,%r8), %ymm15, %ymm1
vmovdqa (%rbp,%r8), %ymm15
vmovdqa (%r15,%r8), %ymm8
vpsubq %ymm3, %ymm15, %ymm6
vpsubq %ymm4, %ymm8, %ymm8
vpcmpgtq %ymm8, %ymm6, %ymm9
vmovapd %ymm10, %ymm11
vblendvpd %ymm9, %ymm10, %ymm12, %ymm10
movq 0x10(%rbx), %r9
movq (%r9), %r9
vpaddq (%rax,%r8), %ymm5, %ymm5
addq %r12, %r9
vmovapd %ymm10, (%r8,%r9)
vpcmpgtq %ymm5, %ymm0, %ymm10
vblendvpd %ymm10, %ymm0, %ymm5, %ymm0
vmovapd %ymm11, %ymm10
vblendvpd %ymm9, %ymm6, %ymm8, %ymm6
vpcmpgtq %ymm2, %ymm6, %ymm5
vblendvpd %ymm5, %ymm2, %ymm6, %ymm2
vpcmpgtq %ymm1, %ymm6, %ymm5
vblendvpd %ymm5, %ymm6, %ymm1, %ymm5
vmovaps %ymm6, (%r15,%r8)
vmovapd %ymm5, (%r14,%r8)
vmovaps %ymm1, (%rbp,%r8)
addq $0x20, %r8
cmpq %r8, %r11
jne 0x5a7def
vpermpd $0x90, %ymm5, %ymm1     # ymm1 = ymm5[0,0,1,2]
leaq 0x1(%rcx), %rdx
vmovsd 0x8(%r13,%rcx,8), %xmm5
vblendpd $0x1, %ymm5, %ymm1, %ymm6 # ymm6 = ymm5[0],ymm1[1,2,3]
vpaddq (%rax), %ymm6, %ymm6
vpcmpgtq %ymm6, %ymm0, %ymm8
vblendvpd %ymm8, %ymm0, %ymm6, %ymm0
movb $0x1, %r8b
vmovdqu 0x150(%rsp), %ymm15
vperm2f128 $0x8, %ymm0, %ymm0, %ymm6 # ymm6 = zero,zero,ymm0[0,1]
vpalignr $0x8, %ymm6, %ymm0, %ymm6 # ymm6 = ymm6[8,9,10,11,12,13,14,15],ymm0[0,1,2,3,4,5,6,7],ymm6[24,25,26,27,28,29,30,31],ymm0[16,17,18,19,20,21,22,23]
vpaddq %ymm6, %ymm15, %ymm6
vpcmpgtq %ymm6, %ymm0, %ymm8
vblendvpd %ymm8, %ymm0, %ymm6, %ymm0
testb $0x1, %r8b
movl $0x0, %r8d
jne 0x5a7eae
vperm2f128 $0x8, %ymm0, %ymm0, %ymm6 # ymm6 = zero,zero,ymm0[0,1]
vpalignr $0x8, %ymm6, %ymm0, %ymm0 # ymm0 = ymm6[8,9,10,11,12,13,14,15],ymm0[0,1,2,3,4,5,6,7],ymm6[24,25,26,27,28,29,30,31],ymm0[16,17,18,19,20,21,22,23]
vpaddq 0xb0(%rsp), %ymm0, %ymm0
vblendpd $0x1, %ymm5, %ymm1, %ymm1 # ymm1 = ymm5[0],ymm1[1,2,3]
vpcmpgtq %ymm1, %ymm0, %ymm5
vblendvpd %ymm5, %ymm0, %ymm1, %ymm5
xorl %r8d, %r8d
vmovapd %ymm12, %ymm9
vmovupd 0x90(%rsp), %ymm11
vmovupd 0x130(%rsp), %ymm12
movq 0x10(%rbx), %r9
vpsubq %ymm3, %ymm5, %ymm1
vpsubq %ymm4, %ymm0, %ymm0
vpcmpgtq %ymm0, %ymm1, %ymm5
vblendvpd %ymm5, %ymm11, %ymm12, %ymm6
vblendvpd %ymm5, %ymm1, %ymm0, %ymm0
vmovdqa (%r14,%r8), %ymm1
vpcmpgtq %ymm0, %ymm1, %ymm8
vblendvpd %ymm8, %ymm1, %ymm0, %ymm5
vpcmpeqq (%rbp,%r8), %ymm5, %ymm1
movq (%r9), %r9
vpaddq %ymm13, %ymm8, %ymm8
vblendvpd %ymm1, %ymm14, %ymm8, %ymm1
addq %r12, %r9
vorpd (%r8,%r9), %ymm6, %ymm6
vorpd %ymm1, %ymm6, %ymm1
vmovapd %ymm1, (%r8,%r9)
vmovaps %ymm5, (%rbp,%r8)
vpcmpgtq %ymm2, %ymm5, %ymm1
vblendvpd %ymm1, %ymm2, %ymm5, %ymm1
vpcmpgtq %ymm1, %ymm0, %ymm2
vblendvpd %ymm2, %ymm1, %ymm0, %ymm2
vpcmpgtq %ymm5, %ymm7, %ymm1
vblendvpd %ymm1, %ymm7, %ymm5, %ymm7
addq $0x20, %r8
cmpq %r8, %r11
jne 0x5a7f15
vmovdqa (%r10), %ymm0
vmovdqu 0xd0(%rsp), %ymm5
vpcmpgtq %ymm5, %ymm0, %ymm1
vblendvpd %ymm1, %ymm0, %ymm5, %ymm5
vtestpd 0x110(%rsp), %ymm1
cmovnel %ecx, %edi
addq %r11, %r12
movq %rdx, %rcx
cmpq 0x28(%rsp), %rdx
jne 0x5a7d8e
cmpl $0x0, 0x1c0(%rsp)
movl 0x34(%rsp), %r10d
movq 0x60(%rsp), %r11
movq 0x18(%rsp), %r12
vmovdqu 0xf0(%rsp), %ymm3
je 0x5a8024
cmpl $0x2, 0x8(%rsp)
jg 0x5a8018
xorl %ecx, %ecx
movl 0xc(%rsp), %edx
vperm2i128 $0x8, %ymm5, %ymm5, %ymm0 # ymm0 = zero,zero,ymm5[0,1]
vpalignr $0x8, %ymm0, %ymm5, %ymm5 # ymm5 = ymm0[8,9,10,11,12,13,14,15],ymm5[0,1,2,3,4,5,6,7],ymm0[24,25,26,27,28,29,30,31],ymm5[16,17,18,19,20,21,22,23]
incl %ecx
cmpl %edx, %ecx
jl 0x5a8006
vextracti128 $0x1, %ymm5, %xmm0
vpextrq $0x1, %xmm0, %r12
cmpl $0x0, 0x1b0(%rsp)
je 0x5a809c
testl $0x7ffffffc, 0x50(%rsp) # imm = 0x7FFFFFFC
je 0x5a809c
movq 0x20(%rsp), %rdx
andl $0x1fffffff, %edx       # imm = 0x1FFFFFFF
shll $0x2, %edx
xorl %esi, %esi
movl %r10d, %ecx
movl %esi, %r9d
shrl $0x2, %r9d
movl %esi, %r8d
andl $0x3, %r8d
imull 0x20(%rsp), %r8d
addl %r9d, %r8d
cmpl %r11d, %r8d
jge 0x5a8093
movq (%rbp,%rsi,8), %r9
cmpq %r12, %r9
jle 0x5a807d
movq %r9, %r12
movl 0x4(%rsp), %edi
movl %r8d, %ecx
jmp 0x5a8093
cmpl %ecx, %r8d
cmovgel %ecx, %r8d
cmpl 0x4(%rsp), %edi
cmovnel %ecx, %r8d
cmpq %r12, %r9
cmovel %r8d, %ecx
incq %rsi
cmpl %esi, %edx
jne 0x5a804b
jmp 0x5a809f
movl %r10d, %ecx
movl 0x1b0(%rsp), %edx
orl %edx, 0x30(%rsp)
jne 0x5a80ed
movq 0x48(%rsp), %rcx
shlq $0x5, %rcx
vmovdqa (%rbp,%rcx), %ymm0
cmpl $0x2, 0x8(%rsp)
jg 0x5a80da
xorl %ecx, %ecx
movl 0xc(%rsp), %edx
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]
incl %ecx
cmpl %edx, %ecx
jl 0x5a80c8
vextracti128 $0x1, %ymm0, %xmm0
vpextrq $0x1, %xmm0, %r12
movl 0x4(%rsp), %edi
movl %r10d, %ecx
vmovdqu 0x70(%rsp), %ymm0
vpcmpgtq %ymm2, %ymm0, %ymm0
vpcmpgtq %ymm3, %ymm7, %ymm1
vpor %ymm1, %ymm0, %ymm0
vtestpd %ymm0, %ymm0
je 0x5a8113
orb $0x40, 0xc(%rbx)
xorl %r12d, %r12d
xorl %edi, %edi
xorl %ecx, %ecx
movl %r12d, (%rbx)
movl %ecx, 0x4(%rbx)
movl %edi, 0x8(%rbx)
movq %rax, %rdi
vzeroupper
callq 0x20a60d
movq %rbp, %rdi
callq 0x20a60d
movq %r14, %rdi
callq 0x20a60d
movq %r13, %rdi
callq 0x20a60d
movq %r15, %rdi
callq 0x20a60d
jmp 0x5a8181
callq 0x1f7ad3
jmp 0x5a817f
callq 0x1f7aad
jmp 0x5a817f
callq 0x1f7a87
jmp 0x5a817f
callq 0x1f7a61
jmp 0x5a817f
callq 0x1f7a3b
jmp 0x5a817f
callq 0x1f7a15
jmp 0x5a817f
callq 0x1f79ef
jmp 0x5a817f
callq 0x1f79c9
xorl %ebx, %ebx
movq %rbx, %rax
addq $0x178, %rsp            # imm = 0x178
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq