// File: /workspace/github_c_makefile_star2_O3/nh13[P]ksw/src/parasail/src/sw_trace_striped_avx2_256_16.c
// Function: parasail_sw_trace_striped_profile_avx2_256_16
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;
    int16_t score = 0;
    __m256i vMaxH;
    __m256i vMaxHUnit;
    int16_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->profile16.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 = 16; /* number of values in vector unit */
    segLen = (s1Len + segWidth - 1) / segWidth;
    vProfile = (__m256i*)profile->profile16.score;
    vGapO = _mm256_set1_epi16(open);
    vGapE = _mm256_set1_epi16(gap);
    vZero = _mm256_setzero_si256();
    score = NEG_INF;
    vMaxH = vZero;
    vMaxHUnit = vZero;
    maxp = INT16_MAX - (int16_t)(matrix->max+1);
    vTZero = _mm256_set1_epi16(PARASAIL_ZERO);
    vTIns  = _mm256_set1_epi16(PARASAIL_INS);
    vTDel  = _mm256_set1_epi16(PARASAIL_DEL);
    vTDiag = _mm256_set1_epi16(PARASAIL_DIAG);
    vTDiagE= _mm256_set1_epi16(PARASAIL_DIAG_E);
    vTInsE = _mm256_set1_epi16(PARASAIL_INS_E);
    vTDiagF= _mm256_set1_epi16(PARASAIL_DIAG_F);
    vTDelF = _mm256_set1_epi16(PARASAIL_DEL_F);
    vTMask = _mm256_set1_epi16(PARASAIL_ZERO_MASK);
    vFTMask= _mm256_set1_epi16(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_16 | PARASAIL_FLAG_LANES_16;

    /* 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_epi16(-open), segLen);
    parasail_memset___m256i(pvEaStore, _mm256_set1_epi16(-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_subs_epi16(vZero,vGapO);

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

        /* 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_adds_epi16(vH, _mm256_load_si256(vP + i));
            vH_dag = _mm256_max_epi16(vH_dag, vZero);
            vH = _mm256_max_epi16(vH_dag, vE);
            vH = _mm256_max_epi16(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_epi16(vH, vZero);
                __m256i case1 = _mm256_cmpeq_epi16(vH, vH_dag);
                __m256i case2 = _mm256_cmpeq_epi16(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_epi16(vH, vMaxH);
            vEF_opn = _mm256_subs_epi16(vH, vGapO);

            /* Update vE value. */
            vE_ext = _mm256_subs_epi16(vE, vGapE);
            vE = _mm256_max_epi16(vEF_opn, vE_ext);
            _mm256_store_si256(pvE + i, vE);
            {
                __m256i vEa = _mm256_load_si256(pvEaLoad + i);
                __m256i vEa_ext = _mm256_subs_epi16(vEa, vGapE);
                vEa = _mm256_max_epi16(vEF_opn, vEa_ext);
                _mm256_store_si256(pvEaStore + i, vEa);
                if (j+1<s2Len) {
                    __m256i cond = _mm256_cmpgt_epi16(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_subs_epi16(vF, vGapE);
            vF = _mm256_max_epi16(vEF_opn, vF_ext);
            if (i+1<segLen) {
                __m256i vTAll = arr_load(result->trace->trace_table, i+1, segLen, j);
                __m256i cond = _mm256_cmpgt_epi16(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, 2);
            vEF_opn = _mm256_slli_si256_rpl(vEF_opn, 2);
            vEF_opn = _mm256_insert_epi16_rpl(vEF_opn, -open, 0);
            vF_ext = _mm256_slli_si256_rpl(vF_ext, 2);
            vF_ext = _mm256_insert_epi16_rpl(vF_ext, NEG_INF, 0);
            vF = _mm256_slli_si256_rpl(vF, 2);
            vF = _mm256_insert_epi16_rpl(vF, -open, 0);
            vFa_ext = _mm256_slli_si256_rpl(vFa_ext, 2);
            vFa_ext = _mm256_insert_epi16_rpl(vFa_ext, NEG_INF, 0);
            vFa = _mm256_slli_si256_rpl(vFa, 2);
            vFa = _mm256_insert_epi16_rpl(vFa, -open, 0);
            for (i=0; i<segLen; ++i) {
                vH = _mm256_load_si256(pvHStore + i);
                vH = _mm256_max_epi16(vH,vF);
                _mm256_store_si256(pvHStore + i, vH);
                {
                    __m256i vTAll;
                    __m256i vT;
                    __m256i case1;
                    __m256i case2;
                    __m256i cond;
                    vHp = _mm256_adds_epi16(vHp, _mm256_load_si256(vP + i));
                    vHp = _mm256_max_epi16(vHp, vZero);
                    case1 = _mm256_cmpeq_epi16(vH, vHp);
                    case2 = _mm256_cmpeq_epi16(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_epi16(vH, vMaxH);
                /* Update vF value. */
                {
                    __m256i vTAll = arr_load(result->trace->trace_table, i, segLen, j);
                    __m256i cond = _mm256_cmpgt_epi16(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_subs_epi16(vH, vGapO);
                vF_ext = _mm256_subs_epi16(vF, vGapE);
                {
                    __m256i vEa = _mm256_load_si256(pvEaLoad + i);
                    __m256i vEa_ext = _mm256_subs_epi16(vEa, vGapE);
                    vEa = _mm256_max_epi16(vEF_opn, vEa_ext);
                    _mm256_store_si256(pvEaStore + i, vEa);
                    if (j+1<s2Len) {
                        __m256i cond = _mm256_cmpgt_epi16(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_epi16(vF_ext, vEF_opn),
                                _mm256_cmpeq_epi16(vF_ext, vEF_opn))))
                    goto end;
                /*vF = _mm256_max_epi16(vEF_opn, vF_ext);*/
                vF = vF_ext;
                vFa_ext = _mm256_subs_epi16(vFa, vGapE);
                vFa = _mm256_max_epi16(vEF_opn, vFa_ext);
                vHp = _mm256_load_si256(pvHLoad + i);
            }
        }
end:
        {
        }

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

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

    if (score == INT16_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. */
        {
            int16_t *t = (int16_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 $0x138, %rsp            # imm = 0x138
movq %rsi, 0x58(%rsp)
testq %rdi, %rdi
je 0x5c53c9
movq 0x30(%rdi), %rax
movq %rax, 0xa0(%rsp)
testq %rax, %rax
je 0x5c53d0
movq 0x10(%rdi), %rax
movq %rax, 0x50(%rsp)
testq %rax, %rax
je 0x5c53d7
movl 0x8(%rdi), %ebp
testl %ebp, %ebp
jle 0x5c53de
cmpq $0x0, 0x58(%rsp)
je 0x5c53e5
movl %edx, %r13d
testl %edx, %edx
jle 0x5c53ec
testl %ecx, %ecx
js 0x5c53f3
testl %r8d, %r8d
js 0x5c53fa
movl %r8d, 0x60(%rsp)
movl %ecx, 0x10(%rsp)
leaq 0xf(%rbp), %r15
movq %r15, %r14
shrq $0x4, %r14
movq 0x50(%rsp), %rax
movl 0x1c(%rax), %r12d
movl $0x20, %edx
movl $0x20, %ecx
movl %r14d, %edi
movl %r13d, %esi
callq 0x20adf4
testq %rax, %rax
je 0x5c53ff
movq %rax, %rbx
movq %r13, 0x40(%rsp)
movq %r15, 0x80(%rsp)
movq %rbp, 0x88(%rsp)
orl $0x10280804, 0xc(%rax)  # imm = 0x10280804
movl $0x20, %edi
movq %r14, %rsi
callq 0x4f1904
movq %rax, %r15
movl $0x20, %edi
movq %r14, %rsi
callq 0x4f1904
movq %rax, %rbp
movl $0x20, %edi
movq %r14, %rsi
callq 0x4f1904
movq %rax, 0x38(%rsp)
movl $0x20, %edi
movq %r14, %rsi
callq 0x4f1904
movq %rax, 0x20(%rsp)
movl $0x20, %edi
movq %r14, %rsi
callq 0x4f1904
movq %rax, 0x18(%rsp)
movl $0x20, %edi
movq %r14, %rsi
callq 0x4f1904
movq %rax, %r13
movl $0x20, %edi
movq %r14, %rsi
callq 0x4f1904
movq %rax, %rcx
xorl %eax, %eax
testq %r15, %r15
je 0x5c5471
testq %rbp, %rbp
je 0x5c5471
cmpq $0x0, 0x38(%rsp)
je 0x5c5471
movq 0x20(%rsp), %rdx
testq %rdx, %rdx
je 0x5c5471
cmpq $0x0, 0x18(%rsp)
je 0x5c5471
testq %r13, %r13
je 0x5c5471
testq %rcx, %rcx
je 0x5c5471
movl %r12d, 0xb0(%rsp)
movq %rcx, 0x30(%rsp)
movl 0x10(%rsp), %r12d
vmovd %r12d, %xmm0
vpbroadcastw %xmm0, %ymm0
vmovdqu %ymm0, 0xf0(%rsp)
vmovd 0x60(%rsp), %xmm0
vpbroadcastw %xmm0, %ymm0
vmovdqu %ymm0, 0xd0(%rsp)
vpxor %xmm0, %xmm0, %xmm0
movq %r15, %rdi
movq %r14, %rsi
callq 0x4f190d
negl %r12d
movl %r12d, 0x10(%rsp)
vmovd %r12d, %xmm0
vpbroadcastw %xmm0, %ymm0
vmovdqu %ymm0, 0x60(%rsp)
movq 0x38(%rsp), %rdi
movq %r14, %rsi
callq 0x4f190d
movq 0x20(%rsp), %rdi
vmovups 0x60(%rsp), %ymm0
movq %r14, %rsi
callq 0x4f190d
movq %r14, %rax
shlq $0x5, %rax
xorl %ecx, %ecx
vpbroadcastq 0x6b28f(%rip), %ymm0 # 0x630040
movq 0x10(%rbx), %rdx
movq (%rdx), %rdx
vmovdqa %ymm0, (%rdx,%rcx)
addq $0x20, %rcx
cmpq %rcx, %rax
jne 0x5c4db1
vpxor %xmm0, %xmm0, %xmm0
vpsubsw 0xf0(%rsp), %ymm0, %ymm1
vmovdqu %ymm1, 0x110(%rsp)
leal -0x1(%r14), %ecx
movl $0x7ffe, %eax           # imm = 0x7FFE
subl 0xb0(%rsp), %eax
cwtl
movl %eax, 0x4c(%rsp)
movl 0x40(%rsp), %edx
movl %r14d, %edi
movq %rdi, 0x90(%rsp)
shlq $0x5, %rdi
movw $0x8000, %ax            # imm = 0x8000
movl %eax, 0xc(%rsp)
xorl %r8d, %r8d
shlq $0x5, %rcx
movq %rcx, 0x98(%rsp)
vpbroadcastw 0x6b2ac(%rip), %ymm2 # 0x6300d0
vpbroadcastw 0x6b2a5(%rip), %ymm3 # 0x6300d2
vpbroadcastq 0x6b212(%rip), %ymm4 # 0x630048
vpbroadcastw 0x6b299(%rip), %ymm5 # 0x6300d8
vpbroadcastw 0x6b292(%rip), %ymm6 # 0x6300da
vpbroadcastq 0x6b1ff(%rip), %ymm7 # 0x630050
movq %rdi, 0x60(%rsp)
xorl %r11d, %r11d
movl $0x0, 0x14(%rsp)
vpxor %xmm8, %xmm8, %xmm8
vpxor %xmm9, %xmm9, %xmm9
vmovdqu 0xd0(%rsp), %ymm1
movq 0x20(%rsp), %rax
vmovdqu %ymm9, 0xb0(%rsp)
movq 0x30(%rsp), %r10
movq %r10, 0x28(%rsp)
movq 0x18(%rsp), %r12
movq %rax, 0x18(%rsp)
movq %rbp, 0xa8(%rsp)
movq %r15, %rbp
movq %r11, %rax
movq 0x98(%rsp), %r9
leaq (%r15,%r9), %rcx
movq %rcx, 0x20(%rsp)
movq 0x50(%rsp), %rcx
movq 0x10(%rcx), %rsi
movq 0x58(%rsp), %rcx
movzbl (%rcx,%r11), %r11d
movslq (%rsi,%r11,4), %r11
movq 0x90(%rsp), %rsi
imulq %r11, %rsi
shlq $0x5, %rsi
addq 0xa0(%rsp), %rsi
leal -0x2(%rax), %r11d
cmpl %r11d, 0x14(%rsp)
movq 0xa8(%rsp), %r15
cmoveq %r15, %r10
movq %r10, 0x30(%rsp)
cmoveq 0x28(%rsp), %r15
vmovdqa (%rbp,%r9), %ymm10
vperm2i128 $0x28, %ymm10, %ymm10, %ymm11 # ymm11 = zero,zero,ymm10[0,1]
vpalignr $0xe, %ymm11, %ymm10, %ymm13 # ymm13 = ymm11[14,15],ymm10[0,1,2,3,4,5,6,7,8,9,10,11,12,13],ymm11[30,31],ymm10[16,17,18,19,20,21,22,23,24,25,26,27,28,29]
movq %rax, 0x28(%rsp)
leaq 0x1(%rax), %r11
movl $0x1, %eax
xorl %r9d, %r9d
vmovdqu 0x110(%rsp), %ymm10
movq %r14, %r10
movq 0x38(%rsp), %r14
vmovdqa (%r14,%r9), %ymm12
vpaddsw (%rsi,%r9), %ymm13, %ymm11
vpmaxsw %ymm0, %ymm11, %ymm11
vpmaxsw %ymm12, %ymm11, %ymm14
vpmaxsw %ymm10, %ymm14, %ymm13
vmovdqa %ymm13, (%r15,%r9)
movq 0x10(%rbx), %rcx
movq (%rcx), %rcx
addq %r8, %rcx
vpcmpeqw %ymm11, %ymm13, %ymm11
vpcmpgtw %ymm10, %ymm14, %ymm14
vpaddw %ymm2, %ymm14, %ymm14
vpcmpgtw %ymm0, %ymm13, %ymm15
vpand %ymm3, %ymm15, %ymm15
vpblendvb %ymm11, %ymm15, %ymm14, %ymm11
vpor (%r9,%rcx), %ymm11, %ymm14
vmovdqa %ymm11, (%r13,%r9)
movq 0x10(%rbx), %rcx
movq (%rcx), %rcx
addq %r8, %rcx
vmovdqa %ymm14, (%r9,%rcx)
vpsubsw 0xf0(%rsp), %ymm13, %ymm11
vpsubsw %ymm1, %ymm12, %ymm12
vpmaxsw %ymm12, %ymm11, %ymm12
vmovdqa %ymm12, (%r14,%r9)
movq 0x18(%rsp), %rcx
vmovdqa (%rcx,%r9), %ymm12
vpsubsw %ymm1, %ymm12, %ymm12
vpmaxsw %ymm12, %ymm11, %ymm14
vmovdqa %ymm14, (%r12,%r9)
cmpq %rdx, %r11
jae 0x5c5002
vpbroadcastw 0x6b0f8(%rip), %ymm14 # 0x6300d4
vpbroadcastw 0x6b0f1(%rip), %ymm15 # 0x6300d6
vpcmpgtw %ymm12, %ymm11, %ymm12
vpblendvb %ymm12, %ymm14, %ymm15, %ymm12
movq 0x10(%rbx), %rcx
movq (%rcx), %rcx
addq 0x60(%rsp), %rcx
vmovdqa %ymm12, (%r9,%rcx)
vpsubsw %ymm1, %ymm10, %ymm12
movq %r10, %r14
cmpq %r10, %rax
jae 0x5c5031
movq 0x10(%rbx), %rcx
movq (%rcx), %rcx
addq %r8, %rcx
vpcmpgtw %ymm12, %ymm11, %ymm10
vpblendvb %ymm10, %ymm5, %ymm6, %ymm10
vpor 0x20(%r9,%rcx), %ymm10, %ymm10
vmovdqa %ymm10, 0x20(%r9,%rcx)
vpmaxsw %ymm8, %ymm13, %ymm8
vpmaxsw %ymm12, %ymm11, %ymm10
vmovdqa (%rbp,%r9), %ymm13
addq $0x20, %r9
incq %rax
cmpq %r9, %rdi
jne 0x5c4f31
xorl %eax, %eax
vmovdqa %ymm10, %ymm13
movl 0x10(%rsp), %r10d
vinserti128 $0x1, %xmm13, %ymm0, %ymm14
vpalignr $0xe, %ymm14, %ymm13, %ymm13 # ymm13 = ymm14[14,15],ymm13[0,1,2,3,4,5,6,7,8,9,10,11,12,13],ymm14[30,31],ymm13[16,17,18,19,20,21,22,23,24,25,26,27,28,29]
vpinsrw $0x0, %r10d, %xmm13, %xmm14
vinserti128 $0x1, %xmm12, %ymm0, %ymm15
vpalignr $0xe, %ymm15, %ymm12, %ymm12 # ymm12 = ymm15[14,15],ymm12[0,1,2,3,4,5,6,7,8,9,10,11,12,13],ymm15[30,31],ymm12[16,17,18,19,20,21,22,23,24,25,26,27,28,29]
movl $0x8000, %ecx           # imm = 0x8000
vpinsrw $0x0, %ecx, %xmm12, %xmm15
vpblendd $0xf, %ymm14, %ymm13, %ymm13 # ymm13 = ymm14[0,1,2,3],ymm13[4,5,6,7]
vpblendd $0xf, %ymm15, %ymm12, %ymm12 # ymm12 = ymm15[0,1,2,3],ymm12[4,5,6,7]
vinserti128 $0x1, %xmm10, %ymm0, %ymm14
vpalignr $0xe, %ymm14, %ymm10, %ymm10 # ymm10 = ymm14[14,15],ymm10[0,1,2,3,4,5,6,7,8,9,10,11,12,13],ymm14[30,31],ymm10[16,17,18,19,20,21,22,23,24,25,26,27,28,29]
vpinsrw $0x0, %r10d, %xmm10, %xmm14
vpblendd $0xf, %ymm14, %ymm10, %ymm10 # ymm10 = ymm14[0,1,2,3],ymm10[4,5,6,7]
vinserti128 $0x1, %xmm11, %ymm0, %ymm14
vpalignr $0xe, %ymm14, %ymm11, %ymm11 # ymm11 = ymm14[14,15],ymm11[0,1,2,3,4,5,6,7,8,9,10,11,12,13],ymm14[30,31],ymm11[16,17,18,19,20,21,22,23,24,25,26,27,28,29]
vpinsrw $0x0, %r10d, %xmm11, %xmm14
vpblendd $0xf, %ymm14, %ymm11, %ymm11 # ymm11 = ymm14[0,1,2,3],ymm11[4,5,6,7]
movq 0x20(%rsp), %rcx
vmovdqa (%rcx), %ymm14
vperm2i128 $0x28, %ymm14, %ymm14, %ymm15 # ymm15 = zero,zero,ymm14[0,1]
vpalignr $0xe, %ymm15, %ymm14, %ymm15 # ymm15 = ymm15[14,15],ymm14[0,1,2,3,4,5,6,7,8,9,10,11,12,13],ymm15[30,31],ymm14[16,17,18,19,20,21,22,23,24,25,26,27,28,29]
xorl %r9d, %r9d
vmovdqa %ymm1, %ymm9
vmovdqa (%r15,%r9), %ymm1
vpmaxsw %ymm1, %ymm10, %ymm14
vmovdqa %ymm14, (%r15,%r9)
vpaddsw (%rsi,%r9), %ymm15, %ymm15
vpmaxsw %ymm0, %ymm15, %ymm15
vpcmpeqw %ymm15, %ymm14, %ymm15
vpcmpgtw %ymm10, %ymm1, %ymm1
vpor %ymm1, %ymm15, %ymm1
movq 0x10(%rbx), %rcx
vpblendvb %ymm1, (%r13,%r9), %ymm2, %ymm1
movq (%rcx), %rcx
addq %r8, %rcx
vpand (%r9,%rcx), %ymm4, %ymm15
vmovdqa %ymm1, (%r13,%r9)
vpor %ymm1, %ymm15, %ymm1
movq 0x10(%rbx), %rcx
movq (%rcx), %rcx
addq %r8, %rcx
vmovdqa %ymm1, (%r9,%rcx)
vpcmpgtw %ymm12, %ymm11, %ymm1
movq 0x10(%rbx), %rcx
movq (%rcx), %rcx
addq %r8, %rcx
vpblendvb %ymm1, %ymm5, %ymm6, %ymm1
vpand (%r9,%rcx), %ymm7, %ymm11
vpor %ymm1, %ymm11, %ymm1
vmovdqa %ymm1, (%r9,%rcx)
vpsubsw 0xf0(%rsp), %ymm14, %ymm11
movq 0x18(%rsp), %rcx
vmovdqa (%rcx,%r9), %ymm1
vpsubsw %ymm9, %ymm1, %ymm12
vpmaxsw %ymm12, %ymm11, %ymm1
vmovdqa %ymm1, (%r12,%r9)
cmpq %rdx, %r11
jae 0x5c51b6
vpbroadcastw 0x6af44(%rip), %ymm1 # 0x6300d4
vpbroadcastw 0x6af3d(%rip), %ymm15 # 0x6300d6
vpcmpgtw %ymm12, %ymm11, %ymm12
vpblendvb %ymm12, %ymm1, %ymm15, %ymm1
movq 0x10(%rbx), %rcx
movq (%rcx), %rcx
addq 0x60(%rsp), %rcx
vmovdqa %ymm1, (%r9,%rcx)
vpmaxsw %ymm8, %ymm14, %ymm8
vmovdqu 0xd0(%rsp), %ymm9
vpsubsw %ymm9, %ymm10, %ymm10
vpcmpgtw %ymm10, %ymm11, %ymm1
vpmovmskb %ymm1, %ecx
cmpl $-0x1, %ecx
je 0x5c5204
vmovdqa %ymm9, %ymm1
vpsubsw %ymm9, %ymm13, %ymm12
vpmaxsw %ymm12, %ymm11, %ymm13
vmovdqa (%rbp,%r9), %ymm15
addq $0x20, %r9
cmpq %r9, %rdi
jne 0x5c50da
incl %eax
cmpl $0x10, %eax
jne 0x5c505e
vmovdqu 0xb0(%rsp), %ymm9
vpcmpgtw %ymm9, %ymm8, %ymm1
vpmovmskb %ymm1, %eax
testl %eax, %eax
je 0x5c5272
vpermq $0x44, %ymm8, %ymm1     # ymm1 = ymm8[0,1,0,1]
vpmaxsw %ymm1, %ymm8, %ymm1
vpslldq $0x8, %ymm1, %ymm9      # ymm9 = 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]
vpmaxsw %ymm1, %ymm9, %ymm1
vpslldq $0x4, %ymm1, %ymm9      # ymm9 = 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]
vpmaxsw %ymm1, %ymm9, %ymm1
vpslldq $0x2, %ymm1, %ymm9      # ymm9 = zero,zero,ymm1[0,1,2,3,4,5,6,7,8,9,10,11,12,13],zero,zero,ymm1[16,17,18,19,20,21,22,23,24,25,26,27,28,29]
vpmaxsw %ymm1, %ymm9, %ymm9
vextracti128 $0x1, %ymm9, %xmm1
vpextrw $0x7, %xmm1, %eax
movl %eax, 0xc(%rsp)
cwtl
cmpl %eax, 0x4c(%rsp)
jl 0x5c5291
vpshufhw $0xff, %ymm9, %ymm1     # ymm1 = ymm9[0,1,2,3,7,7,7,7,8,9,10,11,15,15,15,15]
vpbroadcastd 0x68c6c(%rip), %ymm9 # 0x62ded0
vpermd %ymm1, %ymm9, %ymm9
movq 0x28(%rsp), %rax
movl %eax, 0x14(%rsp)
addq %rdi, 0x60(%rsp)
addq %rdi, %r8
movq %r12, %rax
cmpq %rdx, %r11
vmovdqu 0xd0(%rsp), %ymm1
jne 0x5c4e79
jmp 0x5c529f
orb $0x40, 0xc(%rbx)
movq 0x28(%rsp), %rax
movq %rax, 0x40(%rsp)
movzwl 0xc(%rsp), %eax
cmpl $0x7fff, %eax           # imm = 0x7FFF
jne 0x5c52af
orb $0x40, 0xc(%rbx)
movq %rbx, %rdi
vzeroupper
callq 0x20be2e
xorl %ecx, %ecx
testl %eax, %eax
je 0x5c52cf
movq 0x30(%rsp), %rdi
xorl %r8d, %r8d
xorl %edx, %edx
jmp 0x5c5429
movq 0x40(%rsp), %rcx
leal -0x1(%rcx), %eax
addl $-0x2, %ecx
movl 0x14(%rsp), %r8d
cmpl %ecx, %r8d
movq 0x30(%rsp), %rcx
movq %rcx, %rdi
cmoveq %rbp, %rdi
movq %rbp, %rdx
cmoveq %rcx, %rdx
cmpl %eax, %r8d
cmoveq %r15, %rdi
cmoveq %rbp, %rdx
movq %rdx, %rbp
cmoveq %rcx, %r15
movq 0x88(%rsp), %rdx
decl %edx
movq 0x80(%rsp), %rsi
testl $0x7ffffff0, %esi       # imm = 0x7FFFFFF0
je 0x5c5403
andl $0x7ffffff0, %esi       # imm = 0x7FFFFFF0
movl 0xc(%rsp), %r9d
je 0x5c540a
vmovd %edx, %xmm0
vpbroadcastd %xmm0, %ymm0
vmovd %r9d, %xmm1
vpbroadcastw %xmm1, %xmm1
vmovd %r14d, %xmm2
vpbroadcastd %xmm2, %ymm2
vpmovsxbd 0x6921c(%rip), %ymm3 # 0x62e578
xorl %eax, %eax
vpbroadcastd 0x68b6d(%rip), %ymm4 # 0x62ded4
vpbroadcastd 0x68970(%rip), %ymm5 # 0x62dce0
vpcmpeqw (%rdi,%rax,2), %xmm1, %xmm6
vpmovsxwd %xmm6, %ymm6
vpsrld $0x4, %ymm3, %ymm7
vpand %ymm4, %ymm3, %ymm8
vpmulld %ymm2, %ymm8, %ymm8
vpaddd %ymm7, %ymm8, %ymm7
vpminsd %ymm0, %ymm7, %ymm7
vblendvps %ymm6, %ymm7, %ymm0, %ymm0
addq $0x8, %rax
vpaddd %ymm5, %ymm3, %ymm3
cmpq %rax, %rsi
jne 0x5c5370
vextracti128 $0x1, %ymm0, %xmm1
vpminsd %xmm1, %xmm0, %xmm0
vpshufd $0xee, %xmm0, %xmm1     # xmm1 = xmm0[2,3,2,3]
vpminsd %xmm1, %xmm0, %xmm0
vpshufd $0x55, %xmm0, %xmm1     # xmm1 = xmm0[1,1,1,1]
vpminsd %xmm1, %xmm0, %xmm0
vmovd %xmm0, %edx
jmp 0x5c5425
callq 0x1fb199
jmp 0x5c53ff
callq 0x1fb173
jmp 0x5c53ff
callq 0x1fb14d
jmp 0x5c53ff
callq 0x1fb127
jmp 0x5c53ff
callq 0x1fb101
jmp 0x5c53ff
callq 0x1fb0db
jmp 0x5c53ff
callq 0x1fb0b5
jmp 0x5c53ff
callq 0x1fb08f
xorl %eax, %eax
jmp 0x5c5471
movl 0xc(%rsp), %r9d
jmp 0x5c5425
xorl %eax, %eax
movl %eax, %ecx
shrl $0x4, %ecx
cmpl %edx, %ecx
cmovgel %edx, %ecx
cmpw %r9w, (%rdi,%rax,2)
cmovel %ecx, %edx
incq %rax
cmpl %eax, %esi
jne 0x5c540c
movswl %r9w, %ecx
movl %ecx, (%rbx)
movl %edx, 0x4(%rbx)
movl %r8d, 0x8(%rbx)
vzeroupper
callq 0x20a60d
movq %r13, %rdi
callq 0x20a60d
movq 0x18(%rsp), %rdi
callq 0x20a60d
movq %r12, %rdi
callq 0x20a60d
movq 0x38(%rsp), %rdi
callq 0x20a60d
movq %rbp, %rdi
callq 0x20a60d
movq %r15, %rdi
callq 0x20a60d
movq %rbx, %rax
addq $0x138, %rsp            # imm = 0x138
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
nop