// File: /workspace/github_c_makefile_star2_O1/nh13[P]ksw/src/parasail/src/sw_trace_striped_avx2_256_32.c
// Function: parasail_sw_trace_striped_profile_avx2_256_32
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;
    __m256i* restrict vProfile = NULL;
    __m256i* restrict pvHStore = NULL;
    __m256i* restrict pvHLoad = NULL;
    __m256i* restrict pvE = NULL;
    __m256i* restrict pvEaStore = NULL;
    __m256i* restrict pvEaLoad = NULL;
    __m256i* restrict pvHT = NULL;
    __m256i* restrict pvHMax = NULL;
    __m256i vGapO;
    __m256i vGapE;
    __m256i vZero;
    int32_t score = 0;
    __m256i vMaxH;
    __m256i vMaxHUnit;
    int32_t maxp = 0;
    parasail_result_t *result = NULL;
    __m256i vTZero;
    __m256i vTIns;
    __m256i vTDel;
    __m256i vTDiag;
    __m256i vTDiagE;
    __m256i vTInsE;
    __m256i vTDiagF;
    __m256i vTDelF;
    __m256i vTMask;
    __m256i vFTMask;

    /* validate inputs */
    PARASAIL_CHECK_NULL(profile);
    PARASAIL_CHECK_NULL(profile->profile32.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 = 8; /* number of values in vector unit */
    segLen = (s1Len + segWidth - 1) / segWidth;
    vProfile = (__m256i*)profile->profile32.score;
    vGapO = _mm256_set1_epi32(open);
    vGapE = _mm256_set1_epi32(gap);
    vZero = _mm256_setzero_si256();
    score = NEG_INF;
    vMaxH = vZero;
    vMaxHUnit = vZero;
    maxp = INT32_MAX - (int32_t)(matrix->max+1);
    vTZero = _mm256_set1_epi32(PARASAIL_ZERO);
    vTIns  = _mm256_set1_epi32(PARASAIL_INS);
    vTDel  = _mm256_set1_epi32(PARASAIL_DEL);
    vTDiag = _mm256_set1_epi32(PARASAIL_DIAG);
    vTDiagE= _mm256_set1_epi32(PARASAIL_DIAG_E);
    vTInsE = _mm256_set1_epi32(PARASAIL_INS_E);
    vTDiagF= _mm256_set1_epi32(PARASAIL_DIAG_F);
    vTDelF = _mm256_set1_epi32(PARASAIL_DEL_F);
    vTMask = _mm256_set1_epi32(PARASAIL_ZERO_MASK);
    vFTMask= _mm256_set1_epi32(PARASAIL_F_MASK);

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

    /* set known flags */
    result->flag |= PARASAIL_FLAG_SW | PARASAIL_FLAG_STRIPED
        | PARASAIL_FLAG_TRACE
        | PARASAIL_FLAG_BITS_32 | PARASAIL_FLAG_LANES_8;

    /* initialize heap variables */
    pvHStore = parasail_memalign___m256i(32, segLen);
    pvHLoad =  parasail_memalign___m256i(32, segLen);
    pvE = parasail_memalign___m256i(32, segLen);
    pvEaStore = parasail_memalign___m256i(32, segLen);
    pvEaLoad = parasail_memalign___m256i(32, segLen);
    pvHT = parasail_memalign___m256i(32, segLen);
    pvHMax = parasail_memalign___m256i(32, segLen);

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

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

    for (i=0; i<segLen; ++i) {
        arr_store(result->trace->trace_table, vTDiagE, i, segLen, 0);
    }

    /* outer loop over database sequence */
    for (j=0; j<s2Len; ++j) {
        __m256i vEF_opn;
        __m256i vE;
        __m256i vE_ext;
        __m256i vF;
        __m256i vF_ext;
        __m256i vFa;
        __m256i vFa_ext;
        __m256i vH;
        __m256i vH_dag;
        const __m256i* vP = NULL;

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

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

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

        if (end_ref == j-2) {
            /* Swap in the max buffer. */
            SWAP3(pvHMax,  pvHLoad,  pvHStore)
            SWAP(pvEaLoad,  pvEaStore)
        }
        else {
            /* Swap the 2 H buffers. */
            SWAP(pvHLoad,  pvHStore)
            SWAP(pvEaLoad,  pvEaStore)
        }

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

            /* Get max from vH, vE and vF. */
            vH_dag = _mm256_add_epi32(vH, _mm256_load_si256(vP + i));
            vH_dag = _mm256_max_epi32(vH_dag, vZero);
            vH = _mm256_max_epi32(vH_dag, vE);
            vH = _mm256_max_epi32(vH, vF);
            /* Save vH values. */
            _mm256_store_si256(pvHStore + i, vH);

            {
                __m256i vTAll = arr_load(result->trace->trace_table, i, segLen, j);
                __m256i cond_zero = _mm256_cmpeq_epi32(vH, vZero);
                __m256i case1 = _mm256_cmpeq_epi32(vH, vH_dag);
                __m256i case2 = _mm256_cmpeq_epi32(vH, vF);
                __m256i vT = _mm256_blendv_epi8(
                        _mm256_blendv_epi8(vTIns, vTDel, case2),
                        _mm256_blendv_epi8(vTDiag, vTZero, cond_zero),
                        case1);
                _mm256_store_si256(pvHT + i, vT);
                vT = _mm256_or_si256(vT, vTAll);
                arr_store(result->trace->trace_table, vT, i, segLen, j);
            }
            vMaxH = _mm256_max_epi32(vH, vMaxH);
            vEF_opn = _mm256_sub_epi32(vH, vGapO);

            /* Update vE value. */
            vE_ext = _mm256_sub_epi32(vE, vGapE);
            vE = _mm256_max_epi32(vEF_opn, vE_ext);
            _mm256_store_si256(pvE + i, vE);
            {
                __m256i vEa = _mm256_load_si256(pvEaLoad + i);
                __m256i vEa_ext = _mm256_sub_epi32(vEa, vGapE);
                vEa = _mm256_max_epi32(vEF_opn, vEa_ext);
                _mm256_store_si256(pvEaStore + i, vEa);
                if (j+1<s2Len) {
                    __m256i cond = _mm256_cmpgt_epi32(vEF_opn, vEa_ext);
                    __m256i vT = _mm256_blendv_epi8(vTInsE, vTDiagE, cond);
                    arr_store(result->trace->trace_table, vT, i, segLen, j+1);
                }
            }

            /* Update vF value. */
            vF_ext = _mm256_sub_epi32(vF, vGapE);
            vF = _mm256_max_epi32(vEF_opn, vF_ext);
            if (i+1<segLen) {
                __m256i vTAll = arr_load(result->trace->trace_table, i+1, segLen, j);
                __m256i cond = _mm256_cmpgt_epi32(vEF_opn, vF_ext);
                __m256i vT = _mm256_blendv_epi8(vTDelF, vTDiagF, cond);
                vT = _mm256_or_si256(vT, vTAll);
                arr_store(result->trace->trace_table, vT, i+1, segLen, j);
            }

            /* 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 */
        vFa_ext = vF_ext;
        vFa = vF;
        for (k=0; k<segWidth; ++k) {
            __m256i vHp = _mm256_load_si256(&pvHLoad[segLen - 1]);
            vHp = _mm256_slli_si256_rpl(vHp, 4);
            vEF_opn = _mm256_slli_si256_rpl(vEF_opn, 4);
            vEF_opn = _mm256_insert_epi32_rpl(vEF_opn, -open, 0);
            vF_ext = _mm256_slli_si256_rpl(vF_ext, 4);
            vF_ext = _mm256_insert_epi32_rpl(vF_ext, NEG_INF, 0);
            vF = _mm256_slli_si256_rpl(vF, 4);
            vF = _mm256_insert_epi32_rpl(vF, -open, 0);
            vFa_ext = _mm256_slli_si256_rpl(vFa_ext, 4);
            vFa_ext = _mm256_insert_epi32_rpl(vFa_ext, NEG_INF, 0);
            vFa = _mm256_slli_si256_rpl(vFa, 4);
            vFa = _mm256_insert_epi32_rpl(vFa, -open, 0);
            for (i=0; i<segLen; ++i) {
                vH = _mm256_load_si256(pvHStore + i);
                vH = _mm256_max_epi32(vH,vF);
                _mm256_store_si256(pvHStore + i, vH);
                {
                    __m256i vTAll;
                    __m256i vT;
                    __m256i case1;
                    __m256i case2;
                    __m256i cond;
                    vHp = _mm256_add_epi32(vHp, _mm256_load_si256(vP + i));
                    vHp = _mm256_max_epi32(vHp, vZero);
                    case1 = _mm256_cmpeq_epi32(vH, vHp);
                    case2 = _mm256_cmpeq_epi32(vH, vF);
                    cond = _mm256_andnot_si256(case1,case2);
                    vTAll = arr_load(result->trace->trace_table, i, segLen, j);
                    vT = _mm256_load_si256(pvHT + i);
                    vT = _mm256_blendv_epi8(vT, vTDel, cond);
                    _mm256_store_si256(pvHT + i, vT);
                    vTAll = _mm256_and_si256(vTAll, vTMask);
                    vTAll = _mm256_or_si256(vTAll, vT);
                    arr_store(result->trace->trace_table, vTAll, i, segLen, j);
                }
                vMaxH = _mm256_max_epi32(vH, vMaxH);
                /* Update vF value. */
                {
                    __m256i vTAll = arr_load(result->trace->trace_table, i, segLen, j);
                    __m256i cond = _mm256_cmpgt_epi32(vEF_opn, vFa_ext);
                    __m256i vT = _mm256_blendv_epi8(vTDelF, vTDiagF, cond);
                    vTAll = _mm256_and_si256(vTAll, vFTMask);
                    vTAll = _mm256_or_si256(vTAll, vT);
                    arr_store(result->trace->trace_table, vTAll, i, segLen, j);
                }
                vEF_opn = _mm256_sub_epi32(vH, vGapO);
                vF_ext = _mm256_sub_epi32(vF, vGapE);
                {
                    __m256i vEa = _mm256_load_si256(pvEaLoad + i);
                    __m256i vEa_ext = _mm256_sub_epi32(vEa, vGapE);
                    vEa = _mm256_max_epi32(vEF_opn, vEa_ext);
                    _mm256_store_si256(pvEaStore + i, vEa);
                    if (j+1<s2Len) {
                        __m256i cond = _mm256_cmpgt_epi32(vEF_opn, vEa_ext);
                        __m256i vT = _mm256_blendv_epi8(vTInsE, vTDiagE, cond);
                        arr_store(result->trace->trace_table, vT, i, segLen, j+1);
                    }
                }
                if (! _mm256_movemask_epi8(
                            _mm256_or_si256(
                                _mm256_cmpgt_epi32(vF_ext, vEF_opn),
                                _mm256_cmpeq_epi32(vF_ext, vEF_opn))))
                    goto end;
                /*vF = _mm256_max_epi32(vEF_opn, vF_ext);*/
                vF = vF_ext;
                vFa_ext = _mm256_sub_epi32(vFa, vGapE);
                vFa = _mm256_max_epi32(vEF_opn, vFa_ext);
                vHp = _mm256_load_si256(pvHLoad + i);
            }
        }
end:
        {
        }

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

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

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

    if (parasail_result_is_saturated(result)) {
        score = 0;
        end_query = 0;
        end_ref = 0;
    }
    else {
        if (end_ref == j-1) {
            /* end_ref was the last store column */
            SWAP(pvHMax,  pvHStore)
        }
        else if (end_ref == j-2) {
            /* end_ref was the last load column */
            SWAP(pvHMax,  pvHLoad)
        }
        /* Trace the alignment ending position on read. */
        {
            int32_t *t = (int32_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(pvHMax);
    parasail_free(pvHT);
    parasail_free(pvEaLoad);
    parasail_free(pvEaStore);
    parasail_free(pvE);
    parasail_free(pvHLoad);
    parasail_free(pvHStore);

    return result;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x178, %rsp            # imm = 0x178
movq %rsi, 0x50(%rsp)
testq %rdi, %rdi
je 0x590af4
movq 0x48(%rdi), %rax
movq %rax, 0xa0(%rsp)
testq %rax, %rax
je 0x590afb
movq 0x10(%rdi), %rax
movq %rax, 0x48(%rsp)
testq %rax, %rax
je 0x590b02
movl 0x8(%rdi), %r15d
testl %r15d, %r15d
jle 0x590b09
cmpq $0x0, 0x50(%rsp)
je 0x590b10
movl %edx, %ebp
testl %edx, %edx
jle 0x590b17
movl %ecx, %r13d
testl %ecx, %ecx
js 0x590b1e
testl %r8d, %r8d
js 0x590b25
movl %r8d, 0xb0(%rsp)
leaq 0x7(%r15), %r12
movq %r12, %r14
shrq $0x3, %r14
movl $0x7ffffffe, %ecx       # imm = 0x7FFFFFFE
movq 0x48(%rsp), %rax
subl 0x1c(%rax), %ecx
movl %ecx, 0x44(%rsp)
movl $0x20, %edx
movl $0x20, %ecx
movl %r14d, %edi
movl %ebp, %esi
callq 0x2097d1
testq %rax, %rax
je 0x590b2a
movq %rax, %rbx
movl %r13d, 0x60(%rsp)
movl %ebp, 0xf0(%rsp)
movq %r12, 0x80(%rsp)
movq %r15, 0x88(%rsp)
orl $0x8480804, 0xc(%rax)   # imm = 0x8480804
movl $0x20, %edi
movq %r14, %rsi
callq 0x4c5e3c
movq %rax, %r15
movl $0x20, %edi
movq %r14, %rsi
callq 0x4c5e3c
movq %r14, %r13
movq %rax, %r12
movl $0x20, %edi
movq %r14, %rsi
callq 0x4c5e3c
movq %rax, 0x28(%rsp)
movl $0x20, %edi
movq %r14, %rsi
callq 0x4c5e3c
movq %rax, 0x10(%rsp)
movl $0x20, %edi
movq %r14, %rsi
callq 0x4c5e3c
movq %rax, %r14
movl $0x20, %edi
movq %r13, %rsi
callq 0x4c5e3c
movq %rax, %rbp
movl $0x20, %edi
movq %r13, 0x30(%rsp)
movq %r13, %rsi
callq 0x4c5e3c
movq %rax, %rcx
xorl %eax, %eax
testq %r15, %r15
je 0x590b77
testq %r12, %r12
je 0x590b77
cmpq $0x0, 0x28(%rsp)
je 0x590b77
movq 0x10(%rsp), %rdx
testq %rdx, %rdx
je 0x590b77
testq %r14, %r14
je 0x590b77
testq %rbp, %rbp
je 0x590b77
testq %rcx, %rcx
je 0x590b77
movq %rcx, 0x20(%rsp)
vmovss 0x60(%rsp), %xmm0
vbroadcastss %xmm0, %ymm0
vmovups %ymm0, 0xd0(%rsp)
vmovss 0xb0(%rsp), %xmm0
vbroadcastss %xmm0, %ymm0
vmovups %ymm0, 0xb0(%rsp)
vxorps %xmm0, %xmm0, %xmm0
movq %r15, %rdi
movq 0x30(%rsp), %r13
movq %r13, %rsi
callq 0x4c5e45
movl 0x60(%rsp), %eax
negl %eax
vmovd %eax, %xmm0
vmovdqu %ymm0, 0x150(%rsp)
vpbroadcastd %xmm0, %ymm0
vmovdqu %ymm0, 0x60(%rsp)
movq 0x28(%rsp), %rdi
movq %r13, %rsi
callq 0x4c5e45
movq 0x10(%rsp), %rdi
vmovups 0x60(%rsp), %ymm0
movq %r13, %rsi
callq 0x4c5e45
movl %r13d, %eax
movq %rax, 0x58(%rsp)
movq %rax, %rdx
shlq $0x5, %rdx
xorl %eax, %eax
vpbroadcastq 0x6b195(%rip), %ymm0 # 0x5fb6b8
movq 0x10(%rbx), %rcx
movq (%rcx), %rcx
vmovdqa %ymm0, (%rcx,%rax)
addq $0x20, %rax
cmpq %rax, %rdx
jne 0x590523
vpxor %xmm0, %xmm0, %xmm0
vmovdqu 0xd0(%rsp), %ymm4
vpsubd %ymm4, %ymm0, %ymm1
vmovdqu %ymm1, 0x130(%rsp)
movq 0x30(%rsp), %rsi
leal -0x1(%rsi), %ecx
cmpl $0x1, %esi
adcl $0x0, %esi
movl 0xf0(%rsp), %r8d
movl %r8d, %edi
cmpl $0x2, %r8d
movl $0x1, %eax
cmovgel %r8d, %eax
movq %rax, 0x38(%rsp)
shlq $0x5, %rsi
xorl %r9d, %r9d
shlq $0x5, %rcx
movq %rcx, 0x98(%rsp)
vpbroadcastd 0x6ae77(%rip), %ymm2 # 0x5fb410
vpbroadcastd 0x6ae72(%rip), %ymm3 # 0x5fb414
vbroadcastsd 0x6b115(%rip), %ymm5 # 0x5fb6c0
vbroadcastss 0x6ae54(%rip), %ymm6 # 0x5fb408
vbroadcastss 0x6ae4f(%rip), %ymm7 # 0x5fb40c
vbroadcastsd 0x6b102(%rip), %ymm8 # 0x5fb6c8
movq %rdx, 0x60(%rsp)
xorl %eax, %eax
xorl %r11d, %r11d
movl $0xc0000000, 0x8(%rsp)  # imm = 0xC0000000
vpxor %xmm9, %xmm9, %xmm9
vpxor %xmm1, %xmm1, %xmm1
vmovdqu %ymm1, 0x110(%rsp)
movq 0x10(%rsp), %rcx
movq %rdx, 0x90(%rsp)
vmovdqu %ymm3, 0xf0(%rsp)
movq 0x20(%rsp), %r10
movq %r10, 0x18(%rsp)
movq %r14, %r13
movq %rcx, %r14
movq %r12, 0xa8(%rsp)
movq %r15, %r12
movq 0x98(%rsp), %rdx
leaq (%r15,%rdx), %rcx
movq %rcx, 0x10(%rsp)
movq %rax, %rcx
movq 0x48(%rsp), %rax
movq 0x10(%rax), %rax
movq 0x50(%rsp), %r8
movzbl (%r8,%rcx), %r8d
movslq (%rax,%r8,4), %r8
movq 0x58(%rsp), %rax
imulq %r8, %rax
shlq $0x5, %rax
addq 0xa0(%rsp), %rax
leal -0x2(%rcx), %r8d
movl %r11d, 0xc(%rsp)
cmpl %r8d, %r11d
movq 0xa8(%rsp), %r15
cmoveq %r15, %r10
movq %r10, 0x20(%rsp)
cmoveq 0x18(%rsp), %r15
vmovdqa (%r12,%rdx), %ymm10
vperm2i128 $0x28, %ymm10, %ymm10, %ymm11 # ymm11 = zero,zero,ymm10[0,1]
vpalignr $0xc, %ymm11, %ymm10, %ymm10 # ymm10 = ymm11[12,13,14,15],ymm10[0,1,2,3,4,5,6,7,8,9,10,11],ymm11[28,29,30,31],ymm10[16,17,18,19,20,21,22,23,24,25,26,27]
movq %rcx, 0x18(%rsp)
leaq 0x1(%rcx), %r11
movl $0x1, %ecx
xorl %edx, %edx
vmovdqu 0x130(%rsp), %ymm11
movq 0x28(%rsp), %r10
vmovdqa (%r10,%rdx), %ymm13
vpaddd (%rax,%rdx), %ymm10, %ymm10
vpmaxsd %ymm0, %ymm10, %ymm10
vpmaxsd %ymm13, %ymm10, %ymm12
vpmaxsd %ymm11, %ymm12, %ymm14
vmovdqa %ymm14, (%r15,%rdx)
movq 0x10(%rbx), %r8
movq (%r8), %r8
addq %r9, %r8
vpcmpeqd %ymm10, %ymm14, %ymm10
vpcmpgtd %ymm11, %ymm12, %ymm12
vpaddd %ymm2, %ymm12, %ymm12
vpcmpgtd %ymm0, %ymm14, %ymm15
vpand %ymm3, %ymm15, %ymm15
vblendvps %ymm10, %ymm15, %ymm12, %ymm10
vorps (%rdx,%r8), %ymm10, %ymm12
vmovaps %ymm10, (%rbp,%rdx)
movq 0x10(%rbx), %r8
movq (%r8), %r8
addq %r9, %r8
vmovaps %ymm12, (%rdx,%r8)
vpsubd %ymm4, %ymm14, %ymm12
vmovdqu 0xb0(%rsp), %ymm1
vpsubd %ymm1, %ymm13, %ymm10
vpmaxsd %ymm10, %ymm12, %ymm10
vmovdqa %ymm10, (%r10,%rdx)
vmovdqa (%r14,%rdx), %ymm10
vpsubd %ymm1, %ymm10, %ymm10
vpmaxsd %ymm10, %ymm12, %ymm13
vmovdqa %ymm13, (%r13,%rdx)
cmpq %rdi, %r11
jae 0x590776
vpcmpgtd %ymm10, %ymm12, %ymm10
vbroadcastss 0x692ab(%rip), %ymm13 # 0x5f9a00
vbroadcastss 0x6aca6(%rip), %ymm15 # 0x5fb404
vblendvps %ymm10, %ymm13, %ymm15, %ymm10
movq 0x10(%rbx), %r8
movq (%r8), %r8
addq 0x60(%rsp), %r8
vmovaps %ymm10, (%rdx,%r8)
vpsubd 0xb0(%rsp), %ymm11, %ymm13
cmpq 0x58(%rsp), %rcx
jae 0x5907a9
movq 0x10(%rbx), %r8
movq (%r8), %r8
addq %r9, %r8
vpcmpgtd %ymm13, %ymm12, %ymm10
vblendvps %ymm10, %ymm6, %ymm7, %ymm10
vorps 0x20(%rdx,%r8), %ymm10, %ymm10
vmovaps %ymm10, 0x20(%rdx,%r8)
vpmaxsd %ymm9, %ymm14, %ymm9
vpmaxsd %ymm13, %ymm12, %ymm11
vmovdqa (%r12,%rdx), %ymm10
addq $0x20, %rdx
incq %rcx
cmpq %rdx, %rsi
jne 0x5906a9
xorl %edx, %edx
vmovdqa %ymm11, %ymm14
movl $0xc0000000, %r10d      # imm = 0xC0000000
vpmovsxbd 0x69871(%rip), %ymm3 # 0x5fa050
vpermd %ymm14, %ymm3, %ymm10
vmovdqu 0x150(%rsp), %ymm1
vpblendd $0x1, %ymm1, %ymm10, %ymm14 # ymm14 = ymm1[0],ymm10[1,2,3,4,5,6,7]
vpermd %ymm13, %ymm3, %ymm10
vmovd %r10d, %xmm13
vpblendd $0x1, %ymm13, %ymm10, %ymm13 # ymm13 = ymm13[0],ymm10[1,2,3,4,5,6,7]
vpermd %ymm11, %ymm3, %ymm10
vpblendd $0x1, %ymm1, %ymm10, %ymm11 # ymm11 = ymm1[0],ymm10[1,2,3,4,5,6,7]
vpermd %ymm12, %ymm3, %ymm10
vpblendd $0x1, %ymm1, %ymm10, %ymm12 # ymm12 = ymm1[0],ymm10[1,2,3,4,5,6,7]
movq 0x10(%rsp), %rcx
vmovdqa (%rcx), %ymm10
vperm2i128 $0x28, %ymm10, %ymm10, %ymm15 # ymm15 = zero,zero,ymm10[0,1]
vpalignr $0xc, %ymm15, %ymm10, %ymm10 # ymm10 = ymm15[12,13,14,15],ymm10[0,1,2,3,4,5,6,7,8,9,10,11],ymm15[28,29,30,31],ymm10[16,17,18,19,20,21,22,23,24,25,26,27]
xorl %ecx, %ecx
vmovdqu 0xb0(%rsp), %ymm3
vmovdqa (%r15,%rcx), %ymm1
vpmaxsd %ymm11, %ymm1, %ymm15
vmovdqa %ymm15, (%r15,%rcx)
vpaddd (%rax,%rcx), %ymm10, %ymm10
vpmaxsd %ymm0, %ymm10, %ymm10
vpcmpeqd %ymm10, %ymm15, %ymm10
vpcmpgtd %ymm11, %ymm1, %ymm1
vpor %ymm1, %ymm10, %ymm1
movq 0x10(%rbx), %r8
vblendvps %ymm1, (%rbp,%rcx), %ymm2, %ymm1
movq (%r8), %r8
addq %r9, %r8
vandps (%rcx,%r8), %ymm5, %ymm10
vmovaps %ymm1, (%rbp,%rcx)
vorps %ymm1, %ymm10, %ymm1
movq 0x10(%rbx), %r8
movq (%r8), %r8
addq %r9, %r8
vmovaps %ymm1, (%rcx,%r8)
movq 0x10(%rbx), %r8
movq (%r8), %r8
addq %r9, %r8
vpcmpgtd %ymm13, %ymm12, %ymm1
vblendvps %ymm1, %ymm6, %ymm7, %ymm1
vandps (%rcx,%r8), %ymm8, %ymm10
vorps %ymm1, %ymm10, %ymm1
vmovaps %ymm1, (%rcx,%r8)
vpsubd %ymm4, %ymm15, %ymm12
vmovdqa (%r14,%rcx), %ymm1
vpsubd %ymm3, %ymm1, %ymm10
vpmaxsd %ymm10, %ymm12, %ymm1
vmovdqa %ymm1, (%r13,%rcx)
cmpq %rdi, %r11
jae 0x590910
vpcmpgtd %ymm10, %ymm12, %ymm1
vbroadcastss 0x6911a(%rip), %ymm10 # 0x5f9a00
vbroadcastss 0x6ab15(%rip), %ymm4 # 0x5fb404
vblendvps %ymm1, %ymm10, %ymm4, %ymm1
vmovdqu 0xd0(%rsp), %ymm4
movq 0x10(%rbx), %r8
movq (%r8), %r8
addq 0x60(%rsp), %r8
vmovaps %ymm1, (%rcx,%r8)
vpmaxsd %ymm9, %ymm15, %ymm9
vmovdqu 0xb0(%rsp), %ymm3
vpsubd %ymm3, %ymm11, %ymm15
vpcmpgtd %ymm15, %ymm12, %ymm1
vpmovmskb %ymm1, %r8d
xorl $-0x1, %r8d
setne %r8b
je 0x59095f
vpsubd %ymm3, %ymm14, %ymm13
vpmaxsd %ymm13, %ymm12, %ymm14
vmovdqa (%r12,%rcx), %ymm10
addq $0x20, %rcx
vmovdqa %ymm15, %ymm11
cmpq %rcx, %rsi
jne 0x590839
xorl %ecx, %ecx
vmovdqa %ymm15, %ymm11
jmp 0x590964
movl $0x21, %ecx
testl %ecx, %ecx
vmovdqu 0xf0(%rsp), %ymm3
jne 0x59097e
incl %edx
cmpl $0x8, %edx
jne 0x5907d6
jmp 0x590983
cmpl $0x21, %ecx
jne 0x5909fd
vpcmpgtd 0x110(%rsp), %ymm9, %ymm1
movb $0x1, %r8b
vtestps %ymm1, %ymm1
je 0x5909fd
vpermq $0x44, %ymm9, %ymm1     # ymm1 = ymm9[0,1,0,1]
vpmaxsd %ymm1, %ymm9, %ymm1
vpslldq $0x8, %ymm1, %ymm4      # ymm4 = zero,zero,zero,zero,zero,zero,zero,zero,ymm1[0,1,2,3,4,5,6,7],zero,zero,zero,zero,zero,zero,zero,zero,ymm1[16,17,18,19,20,21,22,23]
vpmaxsd %ymm4, %ymm1, %ymm1
vpslldq $0x4, %ymm1, %ymm4      # ymm4 = zero,zero,zero,zero,ymm1[0,1,2,3,4,5,6,7,8,9,10,11],zero,zero,zero,zero,ymm1[16,17,18,19,20,21,22,23,24,25,26,27]
vpmaxsd %ymm4, %ymm1, %ymm10
vextracti128 $0x1, %ymm10, %xmm1
vpextrd $0x3, %xmm1, %eax
movl %eax, 0x8(%rsp)
cmpl 0x44(%rsp), %eax
jle 0x5909d4
orb $0x40, 0xc(%rbx)
xorl %r8d, %r8d
jmp 0x5909f4
vpbroadcastd 0x68e33(%rip), %ymm1 # 0x5f9810
vpermd %ymm10, %ymm1, %ymm1
vmovdqu %ymm1, 0x110(%rsp)
movq 0x18(%rsp), %rax
movl %eax, 0xc(%rsp)
vmovdqu 0xd0(%rsp), %ymm4
testb %r8b, %r8b
je 0x590a2a
movq 0x90(%rsp), %rdx
addq %rdx, 0x60(%rsp)
addq %rdx, %r9
movq %r11, %rax
movq %r13, %rcx
cmpq 0x38(%rsp), %r11
movl 0xc(%rsp), %r11d
jne 0x590600
jmp 0x590a34
movq 0x18(%rsp), %rax
movq %rax, 0x38(%rsp)
cmpl $0x7fffffff, 0x8(%rsp)  # imm = 0x7FFFFFFF
jne 0x590a42
orb $0x40, 0xc(%rbx)
movq %rbx, %rdi
vzeroupper
callq 0x20a805
xorl %ecx, %ecx
testl %eax, %eax
je 0x590a63
xorl %r11d, %r11d
movq 0x20(%rsp), %rdi
xorl %r10d, %r10d
jmp 0x590b33
movq 0x38(%rsp), %rcx
leal -0x1(%rcx), %eax
addl $-0x2, %ecx
movl 0xc(%rsp), %r10d
cmpl %ecx, %r10d
movq 0x20(%rsp), %rcx
movq %rcx, %rdi
cmoveq %r12, %rdi
movq %r12, %rdx
cmoveq %rcx, %rdx
cmpl %eax, %r10d
cmoveq %r15, %rdi
cmoveq %r12, %rdx
movq %rdx, %r12
cmoveq %rcx, %r15
movq 0x88(%rsp), %rax
movl %eax, %ecx
decl %ecx
testl $0x7ffffff8, 0x80(%rsp) # imm = 0x7FFFFFF8
je 0x590b2e
movq 0x30(%rsp), %r9
movl %r9d, %eax
andl $0xfffffff, %eax        # imm = 0xFFFFFFF
shll $0x3, %eax
xorl %edx, %edx
movl 0x8(%rsp), %r11d
cmpl %r11d, (%rdi,%rdx,4)
jne 0x590aeb
movl %edx, %esi
shrl $0x3, %esi
movl %edx, %r8d
andl $0x7, %r8d
imull %r9d, %r8d
addl %esi, %r8d
cmpl %ecx, %r8d
cmovll %r8d, %ecx
incq %rdx
cmpl %edx, %eax
jne 0x590acb
jmp 0x590b33
callq 0x1faaf7
jmp 0x590b2a
callq 0x1faad1
jmp 0x590b2a
callq 0x1faaab
jmp 0x590b2a
callq 0x1faa85
jmp 0x590b2a
callq 0x1faa5f
jmp 0x590b2a
callq 0x1faa39
jmp 0x590b2a
callq 0x1faa13
jmp 0x590b2a
callq 0x1fa9ed
xorl %eax, %eax
jmp 0x590b77
movl 0x8(%rsp), %r11d
movl %r11d, (%rbx)
movl %ecx, 0x4(%rbx)
movl %r10d, 0x8(%rbx)
callq 0x2094b5
movq %rbp, %rdi
callq 0x2094b5
movq %r14, %rdi
callq 0x2094b5
movq %r13, %rdi
callq 0x2094b5
movq 0x28(%rsp), %rdi
callq 0x2094b5
movq %r12, %rdi
callq 0x2094b5
movq %r15, %rdi
callq 0x2094b5
movq %rbx, %rax
addq $0x178, %rsp            # imm = 0x178
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
nopl (%rax)