// File: /workspace/github_c_makefile_star2_O3/nh13[P]ksw/src/parasail/src/nw_trace_striped_avx2_256_16.c
// Function: parasail_nw_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 s1Len = 0;
    int32_t end_query = 0;
    int32_t end_ref = 0;
    const parasail_matrix_t *matrix = NULL;
    int32_t segWidth = 0;
    int32_t segLen = 0;
    int32_t offset = 0;
    int32_t position = 0;
    __m256i* restrict vProfile = NULL;
    __m256i* restrict pvHStore = NULL;
    __m256i* restrict pvHLoad = NULL;
    __m256i* restrict pvE = NULL;
    __m256i* restrict pvEaStore = NULL;
    __m256i* restrict pvEaLoad = NULL;
    __m256i* restrict pvHT = NULL;
    int16_t* restrict boundary = NULL;
    __m256i vGapO;
    __m256i vGapE;
    int16_t NEG_LIMIT = 0;
    int16_t POS_LIMIT = 0;
    int16_t score = 0;
    __m256i vNegLimit;
    __m256i vPosLimit;
    __m256i vSaturationCheckMin;
    __m256i vSaturationCheckMax;
    parasail_result_t *result = NULL;
    __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;
    s1Len = profile->s1Len;
    end_query = s1Len-1;
    end_ref = s2Len-1;
    matrix = profile->matrix;
    segWidth = 16; /* number of values in vector unit */
    segLen = (s1Len + segWidth - 1) / segWidth;
    offset = (s1Len - 1) % segLen;
    position = (segWidth - 1) - (s1Len - 1) / segLen;
    vProfile = (__m256i*)profile->profile16.score;
    vGapO = _mm256_set1_epi16(open);
    vGapE = _mm256_set1_epi16(gap);
    NEG_LIMIT = (-open < matrix->min ? INT16_MIN + open : INT16_MIN - matrix->min) + 1;
    POS_LIMIT = INT16_MAX - matrix->max - 1;
    score = NEG_LIMIT;
    vNegLimit = _mm256_set1_epi16(NEG_LIMIT);
    vPosLimit = _mm256_set1_epi16(POS_LIMIT);
    vSaturationCheckMin = vPosLimit;
    vSaturationCheckMax = vNegLimit;
    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_NW | 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);
    boundary = parasail_memalign_int16_t(32, s2Len+1);

    /* 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 (!boundary) return NULL;

    /* initialize H and E */
    {
        int32_t index = 0;
        for (i=0; i<segLen; ++i) {
            int32_t segNum = 0;
            __m256i_16_t h;
            __m256i_16_t e;
            for (segNum=0; segNum<segWidth; ++segNum) {
                int64_t tmp = -open-gap*(segNum*segLen+i);
                h.v[segNum] = tmp < INT16_MIN ? INT16_MIN : tmp;
                tmp = tmp - open;
                e.v[segNum] = tmp < INT16_MIN ? INT16_MIN : tmp;
            }
            _mm256_store_si256(&pvHStore[index], h.m);
            _mm256_store_si256(&pvE[index], e.m);
            _mm256_store_si256(&pvEaStore[index], e.m);
            ++index;
        }
    }

    /* initialize uppder boundary */
    {
        boundary[0] = 0;
        for (i=1; i<=s2Len; ++i) {
            int64_t tmp = -open-gap*(i-1);
            boundary[i] = tmp < INT16_MIN ? INT16_MIN : tmp;
        }
    }

    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 -inf.  Any errors to vH values will be
         * corrected in the Lazy_F loop.  */
        vF = vNegLimit;

        /* 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);

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

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

        /* 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 = _mm256_max_epi16(vH_dag, vE);
            vH = _mm256_max_epi16(vH, vF);
            /* Save vH values. */
            _mm256_store_si256(pvHStore + i, vH);
            vSaturationCheckMax = _mm256_max_epi16(vSaturationCheckMax, vH);
            vSaturationCheckMin = _mm256_min_epi16(vSaturationCheckMin, vH);
            vSaturationCheckMin = _mm256_min_epi16(vSaturationCheckMin, vE);
            vSaturationCheckMin = _mm256_min_epi16(vSaturationCheckMin, vF);

            {
                __m256i vTAll = arr_load(result->trace->trace_table, i, segLen, j);
                __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),
                        vTDiag, case1);
                _mm256_store_si256(pvHT + i, vT);
                vT = _mm256_or_si256(vT, vTAll);
                arr_store(result->trace->trace_table, vT, i, segLen, j);
            }

            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) {
            int64_t tmp = boundary[j+1]-open;
            int16_t tmp2 = tmp < INT16_MIN ? INT16_MIN : tmp;
            __m256i vHp = _mm256_load_si256(&pvHLoad[segLen - 1]);
            vHp = _mm256_slli_si256_rpl(vHp, 2);
            vHp = _mm256_insert_epi16_rpl(vHp, boundary[j], 0);
            vEF_opn = _mm256_slli_si256_rpl(vEF_opn, 2);
            vEF_opn = _mm256_insert_epi16_rpl(vEF_opn, tmp2, 0);
            vF_ext = _mm256_slli_si256_rpl(vF_ext, 2);
            vF_ext = _mm256_insert_epi16_rpl(vF_ext, NEG_LIMIT, 0);
            vF = _mm256_slli_si256_rpl(vF, 2);
            vF = _mm256_insert_epi16_rpl(vF, tmp2, 0);
            vFa_ext = _mm256_slli_si256_rpl(vFa_ext, 2);
            vFa_ext = _mm256_insert_epi16_rpl(vFa_ext, NEG_LIMIT, 0);
            vFa = _mm256_slli_si256_rpl(vFa, 2);
            vFa = _mm256_insert_epi16_rpl(vFa, tmp2, 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);
                vSaturationCheckMin = _mm256_min_epi16(vSaturationCheckMin, vH);
                vSaturationCheckMax = _mm256_max_epi16(vSaturationCheckMax, vH);
                {
                    __m256i vTAll;
                    __m256i vT;
                    __m256i case1;
                    __m256i case2;
                    __m256i cond;
                    vHp = _mm256_adds_epi16(vHp, _mm256_load_si256(vP + i));
                    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);
                }
                /* 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:
        {
        }
    }

    /* extract last value from the last column */
    {
        __m256i vH = _mm256_load_si256(pvHStore + offset);
        for (k=0; k<position; ++k) {
            vH = _mm256_slli_si256_rpl (vH, 2);
        }
        score = (int16_t) _mm256_extract_epi16_rpl (vH, 15);
    }

    if (_mm256_movemask_epi8(_mm256_or_si256(
            _mm256_cmplt_epi16_rpl(vSaturationCheckMin, vNegLimit),
            _mm256_cmpgt_epi16(vSaturationCheckMax, vPosLimit)))) {
        result->flag |= PARASAIL_FLAG_SATURATED;
        score = 0;
        end_query = 0;
        end_ref = 0;
    }

    result->score = score;
    result->end_query = end_query;
    result->end_ref = end_ref;

    parasail_free(boundary);
    parasail_free(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 $0x158, %rsp            # imm = 0x158
movl %ecx, 0x8(%rsp)
movq %rsi, 0x48(%rsp)
testq %rdi, %rdi
je 0x5c366a
movq 0x30(%rdi), %rax
movq %rax, 0x88(%rsp)
testq %rax, %rax
je 0x5c3671
movq 0x10(%rdi), %rax
movq %rax, 0x40(%rsp)
testq %rax, %rax
je 0x5c3678
movl 0x8(%rdi), %r13d
testl %r13d, %r13d
jle 0x5c367f
cmpq $0x0, 0x48(%rsp)
je 0x5c3686
movl %edx, %r12d
testl %edx, %edx
jle 0x5c368d
cmpl $0x0, 0x8(%rsp)
js 0x5c3694
testl %r8d, %r8d
js 0x5c369b
movl %r8d, 0x90(%rsp)
leal -0x1(%r13), %ebp
addq $0xf, %r13
shrq $0x4, %r13
movl %ebp, %eax
xorl %edx, %edx
divl %r13d
movl %eax, %r14d
movl %edx, %r15d
movl 0x8(%rsp), %ecx
movl %ecx, %r8d
negl %r8d
movq 0x40(%rsp), %rdx
movl 0x20(%rdx), %eax
movl %eax, %esi
negl %esi
movl %r8d, 0xb0(%rsp)
cmpl %r8d, %eax
cmovgl %ecx, %esi
movl %esi, 0xc(%rsp)
movw $0x7ffe, %ax            # imm = 0x7FFE
subw 0x1c(%rdx), %ax
movl %eax, 0x50(%rsp)
movl $0x20, %edx
movl $0x20, %ecx
movl %r13d, %edi
movl %r12d, %esi
callq 0x20adf4
testq %rax, %rax
je 0x5c36a0
movq %rax, %rbx
movl %r15d, 0x34(%rsp)
movl %r14d, 0x1c(%rsp)
movl %ebp, 0x30(%rsp)
orl $0x10280801, 0xc(%rax)  # imm = 0x10280801
movl $0x20, %edi
movq %r13, %rsi
callq 0x4f1904
movq %rax, 0x78(%rsp)
movl $0x20, %edi
movq %r13, %rsi
callq 0x4f1904
movq %rax, %r15
movl $0x20, %edi
movq %r13, %rsi
callq 0x4f1904
movq %rax, 0x20(%rsp)
movl $0x20, %edi
movq %r13, %rsi
callq 0x4f1904
movq %rax, 0x70(%rsp)
movl $0x20, %edi
movq %r13, %rsi
callq 0x4f1904
movq %rax, %rbp
movl $0x20, %edi
movq %r13, %rsi
callq 0x4f1904
movq %rax, %r14
movq %r12, 0xd0(%rsp)
leal 0x1(%r12), %esi
movl $0x20, %edi
callq 0x20a625
movq 0x70(%rsp), %rdi
movq 0x78(%rsp), %r11
movq 0x20(%rsp), %r9
testq %r11, %r11
sete %dl
movq %r15, 0x10(%rsp)
testq %r15, %r15
sete %cl
orb %dl, %cl
testq %r9, %r9
sete %sil
testq %rdi, %rdi
sete %dl
orb %sil, %dl
orb %cl, %dl
testq %rbp, %rbp
sete %sil
testq %r14, %r14
sete %cl
orb %sil, %cl
testq %rax, %rax
sete %sil
orb %cl, %sil
orb %dl, %sil
testb $0x1, %sil
jne 0x5c36a0
movq %rax, 0x38(%rsp)
movq 0xd0(%rsp), %r10
leal -0x1(%r10), %eax
movl %eax, 0x18(%rsp)
movl $0xf, %eax
subl 0x1c(%rsp), %eax
movl %eax, 0x2c(%rsp)
movl 0x8(%rsp), %eax
vmovd %eax, %xmm0
vpbroadcastw %xmm0, %ymm0
vmovdqu %ymm0, 0x130(%rsp)
movl 0x90(%rsp), %r8d
vmovd %r8d, %xmm0
vpbroadcastw %xmm0, %ymm3
movl 0xc(%rsp), %ecx
addl $0xffff8001, %ecx       # imm = 0xFFFF8001
movl %ecx, 0xc(%rsp)
vmovd %ecx, %xmm0
vpbroadcastw %xmm0, %ymm0
vmovdqu %ymm0, 0x110(%rsp)
vmovd 0x50(%rsp), %xmm0
vpbroadcastw %xmm0, %ymm0
vmovdqu %ymm0, 0xf0(%rsp)
movl %eax, %eax
movl %r13d, %esi
movl %r8d, %ecx
movl 0xb0(%rsp), %r12d
movslq %r12d, %rdx
vmovq %rcx, %xmm0
vpbroadcastq %xmm0, %ymm0
vmovq %rdx, %xmm1
vpbroadcastq %xmm1, %ymm1
vmovq %rax, %xmm8
movq %rsi, 0x80(%rsp)
vmovq %rsi, %xmm4
vpbroadcastq %xmm4, %ymm7
vpmuldq 0x6b27c(%rip), %ymm7, %ymm2 # 0x62dde0
vpmuldq 0x6b293(%rip), %ymm7, %ymm4 # 0x62de00
vmovdqu %ymm4, 0x50(%rsp)
vpmuldq 0x6b0c4(%rip), %ymm7, %ymm6 # 0x62dc40
vpmuldq 0x6afbb(%rip), %ymm7, %ymm7 # 0x62db40
vpbroadcastq %xmm8, %ymm8
xorl %ecx, %ecx
vpbroadcastq 0x6b2ab(%rip), %ymm9 # 0x62de40
vpxor %xmm10, %xmm10, %xmm10
movq %r11, %rdx
movq %r9, %rsi
movq %rdi, %r15
vmovq %rcx, %xmm11
vpbroadcastq %xmm11, %ymm11
vpaddq %ymm6, %ymm11, %ymm12
vpaddq %ymm7, %ymm11, %ymm13
vpaddq 0x50(%rsp), %ymm11, %ymm14
vpaddq %ymm2, %ymm11, %ymm11
vpmuludq %ymm0, %ymm11, %ymm15
vpsrlq $0x20, %ymm11, %ymm11
vpmuludq %ymm0, %ymm11, %ymm11
vpsllq $0x20, %ymm11, %ymm11
vpaddq %ymm11, %ymm15, %ymm11
vpmuludq %ymm0, %ymm14, %ymm15
vpsrlq $0x20, %ymm14, %ymm14
vpmuludq %ymm0, %ymm14, %ymm14
vpsllq $0x20, %ymm14, %ymm14
vpaddq %ymm14, %ymm15, %ymm14
vpmuludq %ymm0, %ymm13, %ymm15
vpsrlq $0x20, %ymm13, %ymm13
vpmuludq %ymm0, %ymm13, %ymm13
vpsllq $0x20, %ymm13, %ymm13
vpaddq %ymm13, %ymm15, %ymm13
vpmuludq %ymm0, %ymm12, %ymm15
vpsrlq $0x20, %ymm12, %ymm12
vpmuludq %ymm0, %ymm12, %ymm12
vpsllq $0x20, %ymm12, %ymm12
vpaddq %ymm12, %ymm15, %ymm12
vpsubq %ymm11, %ymm1, %ymm11
vpcmpgtq %ymm9, %ymm11, %ymm15
vblendvpd %ymm15, %ymm11, %ymm9, %ymm15
vpsubq %ymm13, %ymm1, %ymm13
vpcmpgtq %ymm9, %ymm13, %ymm4
vblendvpd %ymm4, %ymm13, %ymm9, %ymm4
vpsubq %ymm12, %ymm1, %ymm12
vpcmpgtq %ymm9, %ymm12, %ymm5
vblendvpd %ymm5, %ymm12, %ymm9, %ymm5
vpsubq %ymm14, %ymm1, %ymm14
vpblendw $0x11, %ymm5, %ymm10, %ymm5 # ymm5 = ymm5[0],ymm10[1,2,3],ymm5[4],ymm10[5,6,7],ymm5[8],ymm10[9,10,11],ymm5[12],ymm10[13,14,15]
vpblendw $0x11, %ymm4, %ymm10, %ymm4 # ymm4 = ymm4[0],ymm10[1,2,3],ymm4[4],ymm10[5,6,7],ymm4[8],ymm10[9,10,11],ymm4[12],ymm10[13,14,15]
vpackusdw %ymm5, %ymm4, %ymm4
vpcmpgtq %ymm9, %ymm14, %ymm5
vblendvpd %ymm5, %ymm14, %ymm9, %ymm5
vpblendw $0x11, %ymm5, %ymm10, %ymm5 # ymm5 = ymm5[0],ymm10[1,2,3],ymm5[4],ymm10[5,6,7],ymm5[8],ymm10[9,10,11],ymm5[12],ymm10[13,14,15]
vpblendw $0x11, %ymm15, %ymm10, %ymm15 # ymm15 = ymm15[0],ymm10[1,2,3],ymm15[4],ymm10[5,6,7],ymm15[8],ymm10[9,10,11],ymm15[12],ymm10[13,14,15]
vpackusdw %ymm15, %ymm5, %ymm5
vpsubq %ymm8, %ymm12, %ymm12
vpsubq %ymm8, %ymm13, %ymm13
vpsubq %ymm8, %ymm11, %ymm11
vpcmpgtq %ymm9, %ymm11, %ymm15
vblendvpd %ymm15, %ymm11, %ymm9, %ymm11
vpsubq %ymm8, %ymm14, %ymm14
vpcmpgtq %ymm9, %ymm14, %ymm15
vblendvpd %ymm15, %ymm14, %ymm9, %ymm14
vpcmpgtq %ymm9, %ymm13, %ymm15
vblendvpd %ymm15, %ymm13, %ymm9, %ymm13
vpcmpgtq %ymm9, %ymm12, %ymm15
vblendvpd %ymm15, %ymm12, %ymm9, %ymm12
vpermq $0xd8, %ymm4, %ymm4     # ymm4 = ymm4[0,2,1,3]
vpermq $0xd8, %ymm5, %ymm5     # ymm5 = ymm5[0,2,1,3]
vpackusdw %ymm5, %ymm4, %ymm4
vpblendw $0x11, %ymm12, %ymm10, %ymm5 # ymm5 = ymm12[0],ymm10[1,2,3],ymm12[4],ymm10[5,6,7],ymm12[8],ymm10[9,10,11],ymm12[12],ymm10[13,14,15]
vpblendw $0x11, %ymm13, %ymm10, %ymm12 # ymm12 = ymm13[0],ymm10[1,2,3],ymm13[4],ymm10[5,6,7],ymm13[8],ymm10[9,10,11],ymm13[12],ymm10[13,14,15]
vpackusdw %ymm5, %ymm12, %ymm5
vpblendw $0x11, %ymm14, %ymm10, %ymm12 # ymm12 = ymm14[0],ymm10[1,2,3],ymm14[4],ymm10[5,6,7],ymm14[8],ymm10[9,10,11],ymm14[12],ymm10[13,14,15]
vpblendw $0x11, %ymm11, %ymm10, %ymm11 # ymm11 = ymm11[0],ymm10[1,2,3],ymm11[4],ymm10[5,6,7],ymm11[8],ymm10[9,10,11],ymm11[12],ymm10[13,14,15]
vpackusdw %ymm11, %ymm12, %ymm11
vpermq $0xd8, %ymm4, %ymm4     # ymm4 = ymm4[0,2,1,3]
vmovdqa %ymm4, (%rdx)
vpermq $0xd8, %ymm5, %ymm4     # ymm4 = ymm5[0,2,1,3]
vpermq $0xd8, %ymm11, %ymm5    # ymm5 = ymm11[0,2,1,3]
vpackusdw %ymm5, %ymm4, %ymm4
vpermq $0xd8, %ymm4, %ymm4     # ymm4 = ymm4[0,2,1,3]
vmovdqa %ymm4, (%rsi)
vmovdqa %ymm4, (%rdi)
incq %rcx
addq $0x20, %rdi
addq $0x20, %rsi
addq $0x20, %rdx
cmpq %rcx, %r13
jne 0x5c2ba3
movq 0x38(%rsp), %rdi
movw $0x0, (%rdi)
movl %r10d, %eax
addl $0xf, %r10d
andl $-0x10, %r10d
movq %rax, 0x50(%rsp)
decq %rax
vmovq %rax, %xmm0
vpbroadcastq %xmm0, %ymm4
vmovd %r8d, %xmm0
vpbroadcastd %xmm0, %ymm0
vmovdqu %ymm0, 0xd0(%rsp)
vmovd %r12d, %xmm0
vpbroadcastd %xmm0, %ymm0
vmovdqu %ymm0, 0xb0(%rsp)
vpmovsxbd 0x6b0b9(%rip), %ymm7 # 0x62de48
vpmovsxbd 0x6af38(%rip), %ymm8 # 0x62dcd0
xorl %r8d, %r8d
vpbroadcastq 0x6addc(%rip), %xmm13 # 0x62db80
vpcmpeqd %xmm14, %xmm14, %xmm14
vpcmpeqd %ymm15, %ymm15, %ymm15
vpbroadcastd 0x6b099(%rip), %ymm2 # 0x62de50
vpbroadcastq 0x6adc0(%rip), %ymm9 # 0x62db80
vpbroadcastd 0x6adf7(%rip), %xmm0 # 0x62dbc0
vmovdqu %ymm0, 0x90(%rsp)
vpbroadcastd 0x6b079(%rip), %ymm11 # 0x62de54
vmovq %r8, %xmm0
vpbroadcastq %xmm0, %ymm12
vpor 0x6ad53(%rip), %ymm12, %ymm6 # 0x62db40
vpxor %xmm4, %xmm13, %xmm0
vpxor %xmm6, %xmm13, %xmm5
vpcmpgtq %xmm0, %xmm5, %xmm0
vpackssdw %xmm0, %xmm0, %xmm0
vpxor %xmm0, %xmm14, %xmm0
vpackssdw %xmm0, %xmm0, %xmm0
vpacksswb %xmm0, %xmm0, %xmm0
vpaddd %ymm15, %ymm8, %ymm5
vpaddd %ymm7, %ymm15, %ymm1
vmovdqu 0xd0(%rsp), %ymm10
vpmulld %ymm10, %ymm1, %ymm1
vpmulld %ymm10, %ymm5, %ymm5
vmovdqu 0xb0(%rsp), %ymm10
vpsubd %ymm5, %ymm10, %ymm5
vpsubd %ymm1, %ymm10, %ymm1
vpmaxsd %ymm2, %ymm1, %ymm1
vpmaxsd %ymm2, %ymm5, %ymm5
vpxor %xmm10, %xmm10, %xmm10
vpblendw $0xaa, %ymm10, %ymm5, %ymm5 # ymm5 = ymm5[0],ymm10[1],ymm5[2],ymm10[3],ymm5[4],ymm10[5],ymm5[6],ymm10[7],ymm5[8],ymm10[9],ymm5[10],ymm10[11],ymm5[12],ymm10[13],ymm5[14],ymm10[15]
vpblendw $0xaa, %ymm10, %ymm1, %ymm1 # ymm1 = ymm1[0],ymm10[1],ymm1[2],ymm10[3],ymm1[4],ymm10[5],ymm1[6],ymm10[7],ymm1[8],ymm10[9],ymm1[10],ymm10[11],ymm1[12],ymm10[13],ymm1[14],ymm10[15]
vpackusdw %ymm1, %ymm5, %ymm1
vpermq $0xd8, %ymm1, %ymm5     # ymm5 = ymm1[0,2,1,3]
vmovd %xmm0, %eax
testb $0x1, %al
je 0x5c2e6d
vpextrw $0x0, %xmm5, 0x2(%rdi,%r8,2)
vpxor %xmm4, %xmm13, %xmm0
vpxor %xmm6, %xmm13, %xmm1
vpcmpgtq %xmm0, %xmm1, %xmm0
vpackssdw %xmm0, %xmm0, %xmm0
vpxor %xmm0, %xmm14, %xmm0
vpackssdw %xmm0, %xmm0, %xmm0
vpacksswb %xmm0, %xmm0, %xmm0
vpextrb $0x1, %xmm0, %eax
testb $0x1, %al
je 0x5c2e9c
vpextrw $0x1, %xmm5, 0x4(%rdi,%r8,2)
vpxor %ymm4, %ymm9, %ymm0
vpxor %ymm6, %ymm9, %ymm1
vpcmpgtq %ymm0, %ymm1, %ymm6
vpshuflw $0xe8, %ymm6, %ymm1     # ymm1 = ymm6[0,2,2,3,4,5,6,7,8,10,10,11,12,13,14,15]
vpxor %ymm1, %ymm15, %ymm1
vmovdqu 0x90(%rsp), %ymm10
vpermd %ymm1, %ymm10, %ymm1
vpackssdw %xmm1, %xmm1, %xmm1
vpacksswb %xmm1, %xmm1, %xmm1
vpextrb $0x2, %xmm1, %eax
testb $0x1, %al
je 0x5c2eda
vpextrw $0x2, %xmm5, 0x6(%rdi,%r8,2)
vextracti128 $0x1, %ymm6, %xmm1
vpackssdw %xmm1, %xmm1, %xmm1
vpxor %xmm1, %xmm14, %xmm1
vpackssdw %xmm1, %xmm1, %xmm1
vpacksswb %xmm1, %xmm1, %xmm1
vpextrb $0x3, %xmm1, %eax
testb $0x1, %al
je 0x5c2f02
vpextrw $0x3, %xmm5, 0x8(%rdi,%r8,2)
vpor 0x6ad36(%rip), %ymm12, %ymm6 # 0x62dc40
vpxor %xmm4, %xmm13, %xmm1
vpxor %xmm6, %xmm13, %xmm10
vpcmpgtq %xmm1, %xmm10, %xmm1
vpackssdw %xmm1, %xmm1, %xmm1
vpxor %xmm1, %xmm14, %xmm1
vpermq $0x55, %ymm1, %ymm1     # ymm1 = ymm1[1,1,1,1]
vpackssdw %ymm0, %ymm1, %ymm1
vextracti128 $0x1, %ymm1, %xmm1
vpacksswb %xmm1, %xmm1, %xmm1
vpextrb $0x8, %xmm1, %eax
testb $0x1, %al
je 0x5c2f45
vpextrw $0x4, %xmm5, 0xa(%rdi,%r8,2)
vpxor %xmm4, %xmm13, %xmm1
vpxor %xmm6, %xmm13, %xmm10
vpcmpgtq %xmm1, %xmm10, %xmm1
vpshufhw $0x84, %xmm1, %xmm1     # xmm1 = xmm1[0,1,2,3,4,5,4,6]
vpxor %xmm1, %xmm14, %xmm1
vpermq $0x55, %ymm1, %ymm1     # ymm1 = ymm1[1,1,1,1]
vpackssdw %ymm0, %ymm1, %ymm1
vextracti128 $0x1, %ymm1, %xmm1
vpacksswb %xmm1, %xmm1, %xmm1
vpextrb $0x9, %xmm1, %eax
testb $0x1, %al
je 0x5c2f81
vpextrw $0x5, %xmm5, 0xc(%rdi,%r8,2)
vpxor %ymm6, %ymm9, %ymm1
vpcmpgtq %ymm0, %ymm1, %ymm6
vpackssdw %ymm6, %ymm0, %ymm1
vpxor %ymm1, %ymm15, %ymm1
vpackssdw %ymm0, %ymm1, %ymm1
vextracti128 $0x1, %ymm1, %xmm1
vpacksswb %xmm1, %xmm1, %xmm1
vpextrb $0xa, %xmm1, %eax
testb $0x1, %al
je 0x5c2fb2
vpextrw $0x6, %xmm5, 0xe(%rdi,%r8,2)
vpackssdw %ymm6, %ymm0, %ymm1
vpxor %ymm1, %ymm15, %ymm1
vpackssdw %ymm0, %ymm1, %ymm1
vextracti128 $0x1, %ymm1, %xmm1
vpacksswb %xmm1, %xmm1, %xmm1
vpextrb $0xb, %xmm1, %eax
testb $0x1, %al
je 0x5c2fda
vpextrw $0x7, %xmm5, 0x10(%rdi,%r8,2)
vpor 0x6ae1e(%rip), %ymm12, %ymm6 # 0x62de00
vpxor %xmm4, %xmm13, %xmm1
vpxor %xmm6, %xmm13, %xmm10
vpcmpgtq %xmm1, %xmm10, %xmm1
vpackssdw %xmm1, %xmm1, %xmm1
vpxor %xmm1, %xmm14, %xmm1
vpackssdw %xmm1, %xmm1, %xmm1
vpacksswb %xmm1, %xmm1, %xmm1
vpextrb $0x4, %xmm1, %eax
vextracti128 $0x1, %ymm5, %xmm5
testb $0x1, %al
je 0x5c3017
vpextrw $0x0, %xmm5, 0x12(%rdi,%r8,2)
vpxor %xmm4, %xmm13, %xmm1
vpxor %xmm6, %xmm13, %xmm10
vpcmpgtq %xmm1, %xmm10, %xmm1
vpackssdw %xmm1, %xmm1, %xmm1
vpxor %xmm1, %xmm14, %xmm1
vpackssdw %xmm1, %xmm1, %xmm1
vpacksswb %xmm1, %xmm1, %xmm1
vpextrb $0x5, %xmm1, %eax
testb $0x1, %al
je 0x5c3046
vpextrw $0x1, %xmm5, 0x14(%rdi,%r8,2)
vpxor %ymm6, %ymm9, %ymm1
vpcmpgtq %ymm0, %ymm1, %ymm6
vpshuflw $0xe8, %ymm6, %ymm1     # ymm1 = ymm6[0,2,2,3,4,5,6,7,8,10,10,11,12,13,14,15]
vpxor %ymm1, %ymm15, %ymm1
vmovdqu 0x90(%rsp), %ymm10
vpermd %ymm1, %ymm10, %ymm1
vpackssdw %xmm1, %xmm1, %xmm1
vpacksswb %xmm1, %xmm1, %xmm1
vpextrb $0x6, %xmm1, %eax
testb $0x1, %al
je 0x5c3080
vpextrw $0x2, %xmm5, 0x16(%rdi,%r8,2)
vextracti128 $0x1, %ymm6, %xmm1
vpackssdw %xmm1, %xmm1, %xmm1
vpxor %xmm1, %xmm14, %xmm1
vpackssdw %xmm1, %xmm1, %xmm1
vpacksswb %xmm1, %xmm1, %xmm1
vpextrb $0x7, %xmm1, %eax
testb $0x1, %al
je 0x5c30a8
vpextrw $0x3, %xmm5, 0x18(%rdi,%r8,2)
vpor 0x6ad30(%rip), %ymm12, %ymm6 # 0x62dde0
vpxor %xmm4, %xmm13, %xmm1
vpxor %xmm6, %xmm13, %xmm10
vpcmpgtq %xmm1, %xmm10, %xmm1
vpackssdw %xmm1, %xmm1, %xmm1
vpxor %xmm1, %xmm14, %xmm1
vpermq $0x55, %ymm1, %ymm1     # ymm1 = ymm1[1,1,1,1]
vpackssdw %ymm1, %ymm0, %ymm1
vextracti128 $0x1, %ymm1, %xmm1
vpacksswb %xmm1, %xmm1, %xmm1
vpextrb $0xc, %xmm1, %eax
testb $0x1, %al
je 0x5c30eb
vpextrw $0x4, %xmm5, 0x1a(%rdi,%r8,2)
vpxor %xmm4, %xmm13, %xmm1
vpxor %xmm6, %xmm13, %xmm10
vpcmpgtq %xmm1, %xmm10, %xmm1
vpshufhw $0x84, %xmm1, %xmm1     # xmm1 = xmm1[0,1,2,3,4,5,4,6]
vpxor %xmm1, %xmm14, %xmm1
vpermq $0x55, %ymm1, %ymm1     # ymm1 = ymm1[1,1,1,1]
vpackssdw %ymm1, %ymm0, %ymm1
vextracti128 $0x1, %ymm1, %xmm1
vpacksswb %xmm1, %xmm1, %xmm1
vpextrb $0xd, %xmm1, %eax
testb $0x1, %al
je 0x5c3127
vpextrw $0x5, %xmm5, 0x1c(%rdi,%r8,2)
vpxor %ymm6, %ymm9, %ymm1
vpcmpgtq %ymm0, %ymm1, %ymm0
vpackssdw %ymm0, %ymm0, %ymm1
vpxor %ymm1, %ymm15, %ymm1
vpackssdw %ymm1, %ymm0, %ymm1
vextracti128 $0x1, %ymm1, %xmm1
vpacksswb %xmm1, %xmm1, %xmm1
vpextrb $0xe, %xmm1, %eax
testb $0x1, %al
je 0x5c3158
vpextrw $0x6, %xmm5, 0x1e(%rdi,%r8,2)
vpackssdw %ymm0, %ymm0, %ymm0
vpxor %ymm0, %ymm15, %ymm0
vpackssdw %ymm0, %ymm0, %ymm0
vextracti128 $0x1, %ymm0, %xmm0
vpacksswb %xmm0, %xmm0, %xmm0
vpextrb $0xf, %xmm0, %eax
testb $0x1, %al
je 0x5c3180
vpextrw $0x7, %xmm5, 0x20(%rdi,%r8,2)
addq $0x10, %r8
vpaddd %ymm11, %ymm8, %ymm8
vpaddd %ymm7, %ymm11, %ymm7
cmpq %r8, %r10
jne 0x5c2ddb
movq %r13, %r8
shlq $0x5, %r8
xorl %eax, %eax
vpbroadcastq 0x6ce98(%rip), %ymm0 # 0x630040
movq 0x10(%rbx), %rcx
movq (%rcx), %rcx
vmovdqa %ymm0, (%rcx,%rax)
addq $0x20, %rax
cmpq %rax, %r8
jne 0x5c31a8
vpbroadcastw 0x6ce92(%rip), %ymm6 # 0x630058
movq %r13, %r12
leal -0x1(%r13), %eax
vpbroadcastw 0x6ce84(%rip), %ymm7 # 0x63005a
xorl %r10d, %r10d
vpbroadcastw 0x6ce7e(%rip), %ymm8 # 0x630060
shlq $0x5, %rax
movq %rax, 0xb0(%rsp)
vpbroadcastw 0x6ce6b(%rip), %ymm9 # 0x630062
vpbroadcastq 0x6ce48(%rip), %ymm10 # 0x630048
vpbroadcastq 0x6ce47(%rip), %ymm11 # 0x630050
movq %r8, %rcx
xorl %edx, %edx
vmovdqu 0xf0(%rsp), %ymm5
vmovdqu 0x110(%rsp), %ymm4
movq %r15, %rax
movq %rbp, %r15
movq %rax, %rbp
movq 0x10(%rsp), %r13
movq %r11, %rax
movq %rdx, %r11
movq 0xb0(%rsp), %rdx
leaq (%rax,%rdx), %rsi
movq %rsi, 0xd0(%rsp)
movq %rax, 0x10(%rsp)
vmovdqa (%rax,%rdx), %ymm0
vinserti128 $0x1, %xmm0, %ymm0, %ymm1
vpalignr $0xe, %ymm1, %ymm0, %ymm0 # ymm0 = ymm1[14,15],ymm0[0,1,2,3,4,5,6,7,8,9,10,11,12,13],ymm1[30,31],ymm0[16,17,18,19,20,21,22,23,24,25,26,27,28,29]
vpinsrw $0x0, (%rdi,%r11,2), %xmm0, %xmm1
vpblendd $0xf, %ymm1, %ymm0, %ymm14 # ymm14 = ymm1[0,1,2,3],ymm0[4,5,6,7]
movq 0x40(%rsp), %rax
movq 0x10(%rax), %rdx
movq 0x48(%rsp), %rax
movzbl (%rax,%r11), %esi
movslq (%rdx,%rsi,4), %r9
imulq 0x80(%rsp), %r9
shlq $0x5, %r9
addq 0x88(%rsp), %r9
movq %r11, 0x90(%rsp)
leaq 0x1(%r11), %rdx
movl $0x1, %esi
xorl %r11d, %r11d
vmovdqu 0x110(%rsp), %ymm0
movq %rbp, %rdi
movq 0x20(%rsp), %rbp
vmovdqa (%rbp,%r11), %ymm13
vpaddsw (%r9,%r11), %ymm14, %ymm1
vpmaxsw %ymm1, %ymm13, %ymm12
vpmaxsw %ymm0, %ymm12, %ymm14
vmovdqa %ymm14, (%r13,%r11)
movq 0x10(%rbx), %rax
movq (%rax), %rax
addq %r10, %rax
vpcmpeqw %ymm1, %ymm14, %ymm1
vpcmpgtw %ymm0, %ymm12, %ymm12
vpaddw %ymm6, %ymm12, %ymm12
vpblendvb %ymm1, %ymm7, %ymm12, %ymm1
vpor (%r11,%rax), %ymm1, %ymm12
vmovdqa %ymm1, (%r14,%r11)
movq 0x10(%rbx), %rax
movq (%rax), %rax
addq %r10, %rax
vmovdqa %ymm12, (%r11,%rax)
vpsubsw 0x130(%rsp), %ymm14, %ymm1
vpsubsw %ymm3, %ymm13, %ymm12
vpmaxsw %ymm1, %ymm12, %ymm12
vmovdqa %ymm12, (%rbp,%r11)
movq %rdi, %rbp
vmovdqa (%rdi,%r11), %ymm12
vpsubsw %ymm3, %ymm12, %ymm12
vpmaxsw %ymm1, %ymm12, %ymm15
vmovdqa %ymm15, (%r15,%r11)
cmpq 0x50(%rsp), %rdx
jae 0x5c3373
vpbroadcastw 0x6cd0d(%rip), %ymm15 # 0x63005c
vpbroadcastw 0x6cd06(%rip), %ymm2 # 0x63005e
vpcmpgtw %ymm12, %ymm1, %ymm12
vpblendvb %ymm12, %ymm15, %ymm2, %ymm2
movq 0x10(%rbx), %rax
movq (%rax), %rax
addq %rcx, %rax
vmovdqa %ymm2, (%r11,%rax)
vpsubsw %ymm3, %ymm0, %ymm12
cmpq %r12, %rsi
jae 0x5c339f
movq 0x10(%rbx), %rax
movq (%rax), %rax
addq %r10, %rax
vpcmpgtw %ymm12, %ymm1, %ymm2
vpblendvb %ymm2, %ymm8, %ymm9, %ymm2
vpor 0x20(%r11,%rax), %ymm2, %ymm2
vmovdqa %ymm2, 0x20(%r11,%rax)
vpmaxsw %ymm4, %ymm14, %ymm4
vpminsw %ymm5, %ymm13, %ymm2
vpminsw %ymm0, %ymm2, %ymm0
vpminsw %ymm0, %ymm14, %ymm5
vpmaxsw %ymm1, %ymm12, %ymm0
movq 0x10(%rsp), %rax
vmovdqa (%rax,%r11), %ymm14
addq $0x20, %r11
incq %rsi
cmpq %r11, %r8
jne 0x5c32b4
xorl %r11d, %r11d
vmovdqa %ymm0, %ymm13
movq 0x38(%rsp), %rdi
movswl (%rdi,%rdx,2), %esi
subl 0x8(%rsp), %esi
cmpl $0xffff8001, %esi       # imm = 0xFFFF8001
movl $0xffff8000, %eax       # imm = 0xFFFF8000
cmovll %eax, %esi
movq 0xd0(%rsp), %rax
vmovdqa (%rax), %ymm2
vinserti128 $0x1, %xmm2, %ymm0, %ymm14
vpalignr $0xe, %ymm14, %ymm2, %ymm2 # ymm2 = ymm14[14,15],ymm2[0,1,2,3,4,5,6,7,8,9,10,11,12,13],ymm14[30,31],ymm2[16,17,18,19,20,21,22,23,24,25,26,27,28,29]
movq 0x90(%rsp), %rax
vpinsrw $0x0, (%rdi,%rax,2), %xmm2, %xmm14
vpblendd $0xf, %ymm14, %ymm2, %ymm14 # ymm14 = ymm14[0,1,2,3],ymm2[4,5,6,7]
vinserti128 $0x1, %xmm1, %ymm0, %ymm2
vpalignr $0xe, %ymm2, %ymm1, %ymm1 # ymm1 = ymm2[14,15],ymm1[0,1,2,3,4,5,6,7,8,9,10,11,12,13],ymm2[30,31],ymm1[16,17,18,19,20,21,22,23,24,25,26,27,28,29]
vpinsrw $0x0, %esi, %xmm1, %xmm2
vpblendd $0xf, %ymm2, %ymm1, %ymm1 # ymm1 = ymm2[0,1,2,3],ymm1[4,5,6,7]
vinserti128 $0x1, %xmm13, %ymm0, %ymm2
vpalignr $0xe, %ymm2, %ymm13, %ymm2 # ymm2 = ymm2[14,15],ymm13[0,1,2,3,4,5,6,7,8,9,10,11,12,13],ymm2[30,31],ymm13[16,17,18,19,20,21,22,23,24,25,26,27,28,29]
vpinsrw $0x0, %esi, %xmm2, %xmm13
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]
vpinsrw $0x0, 0xc(%rsp), %xmm12, %xmm15
vpblendd $0xf, %ymm13, %ymm2, %ymm13 # ymm13 = ymm13[0,1,2,3],ymm2[4,5,6,7]
vpblendd $0xf, %ymm15, %ymm12, %ymm12 # ymm12 = ymm15[0,1,2,3],ymm12[4,5,6,7]
vinserti128 $0x1, %xmm0, %ymm0, %ymm2
vpalignr $0xe, %ymm2, %ymm0, %ymm0 # ymm0 = ymm2[14,15],ymm0[0,1,2,3,4,5,6,7,8,9,10,11,12,13],ymm2[30,31],ymm0[16,17,18,19,20,21,22,23,24,25,26,27,28,29]
vpinsrw $0x0, %esi, %xmm0, %xmm2
vpblendd $0xf, %ymm2, %ymm0, %ymm0 # ymm0 = ymm2[0,1,2,3],ymm0[4,5,6,7]
xorl %esi, %esi
vmovdqa (%r13,%rsi), %ymm2
vpmaxsw %ymm2, %ymm13, %ymm15
vmovdqa %ymm15, (%r13,%rsi)
vpaddsw (%r9,%rsi), %ymm14, %ymm14
vpcmpeqw %ymm14, %ymm15, %ymm14
vpcmpgtw %ymm13, %ymm2, %ymm2
vpor %ymm2, %ymm14, %ymm2
movq 0x10(%rbx), %rax
vpblendvb %ymm2, (%r14,%rsi), %ymm6, %ymm2
movq (%rax), %rax
addq %r10, %rax
vpand (%rsi,%rax), %ymm10, %ymm14
vmovdqa %ymm2, (%r14,%rsi)
vpor %ymm2, %ymm14, %ymm2
movq 0x10(%rbx), %rax
movq (%rax), %rax
addq %r10, %rax
vmovdqa %ymm2, (%rsi,%rax)
vpcmpgtw %ymm12, %ymm1, %ymm1
movq 0x10(%rbx), %rax
movq (%rax), %rax
addq %r10, %rax
vpblendvb %ymm1, %ymm8, %ymm9, %ymm1
vpand (%rsi,%rax), %ymm11, %ymm2
vpor %ymm1, %ymm2, %ymm1
vmovdqa %ymm1, (%rsi,%rax)
vpsubsw 0x130(%rsp), %ymm15, %ymm1
vmovdqa (%rbp,%rsi), %ymm2
vpsubsw %ymm3, %ymm2, %ymm12
vpmaxsw %ymm1, %ymm12, %ymm2
vmovdqa %ymm2, (%r15,%rsi)
cmpq 0x50(%rsp), %rdx
jae 0x5c3544
vpbroadcastw 0x6cb3b(%rip), %ymm2 # 0x63005c
vpbroadcastw 0x6cb34(%rip), %ymm14 # 0x63005e
vpcmpgtw %ymm12, %ymm1, %ymm12
vpblendvb %ymm12, %ymm2, %ymm14, %ymm2
movq 0x10(%rbx), %rax
movq (%rax), %rax
addq %rcx, %rax
vmovdqa %ymm2, (%rsi,%rax)
vpminsw %ymm5, %ymm15, %ymm5
vpmaxsw %ymm4, %ymm15, %ymm4
vpsubsw %ymm3, %ymm13, %ymm13
vpcmpgtw %ymm13, %ymm1, %ymm2
vpmovmskb %ymm2, %eax
cmpl $-0x1, %eax
je 0x5c358a
vpsubsw %ymm3, %ymm0, %ymm12
vpmaxsw %ymm1, %ymm12, %ymm0
movq 0x10(%rsp), %rax
vmovdqa (%rax,%rsi), %ymm14
addq $0x20, %rsi
cmpq %rsi, %r8
jne 0x5c347c
incl %r11d
cmpl $0x10, %r11d
jne 0x5c33da
addq %r8, %rcx
addq %r8, %r10
movq %r13, %r11
movq %r15, %rax
cmpq 0x50(%rsp), %rdx
jne 0x5c3223
movl 0x34(%rsp), %eax
shlq $0x5, %rax
vmovdqa (%r13,%rax), %ymm0
cmpl $0xe, 0x1c(%rsp)
jg 0x5c35de
xorl %eax, %eax
movl 0x18(%rsp), %edx
movl 0x2c(%rsp), %ecx
vmovdqu 0xf0(%rsp), %ymm2
vperm2i128 $0x28, %ymm0, %ymm0, %ymm1 # ymm1 = zero,zero,ymm0[0,1]
vpalignr $0xe, %ymm1, %ymm0, %ymm0 # ymm0 = ymm1[14,15],ymm0[0,1,2,3,4,5,6,7,8,9,10,11,12,13],ymm1[30,31],ymm0[16,17,18,19,20,21,22,23,24,25,26,27,28,29]
incl %eax
cmpl %ecx, %eax
jl 0x5c35ca
jmp 0x5c35eb
movl 0x18(%rsp), %edx
vmovdqu 0xf0(%rsp), %ymm2
vmovdqu 0x110(%rsp), %ymm1
vpcmpgtw %ymm5, %ymm1, %ymm1
vpcmpgtw %ymm2, %ymm4, %ymm2
vpor %ymm2, %ymm1, %ymm1
vpmovmskb %ymm1, %eax
testl %eax, %eax
je 0x5c3614
orb $0x40, 0xc(%rbx)
xorl %eax, %eax
xorl %edx, %edx
xorl %ecx, %ecx
jmp 0x5c3623
vextracti128 $0x1, %ymm0, %xmm0
vpextrw $0x7, %xmm0, %eax
movl 0x30(%rsp), %ecx
cwtl
movl %eax, (%rbx)
movl %ecx, 0x4(%rbx)
movl %edx, 0x8(%rbx)
vzeroupper
callq 0x20a60d
movq %r14, %rdi
callq 0x20a60d
movq %rbp, %rdi
callq 0x20a60d
movq %r15, %rdi
callq 0x20a60d
movq 0x20(%rsp), %rdi
callq 0x20a60d
movq 0x10(%rsp), %rdi
callq 0x20a60d
movq %r13, %rdi
callq 0x20a60d
jmp 0x5c36a2
callq 0x1fad25
jmp 0x5c36a0
callq 0x1facff
jmp 0x5c36a0
callq 0x1facd9
jmp 0x5c36a0
callq 0x1facb3
jmp 0x5c36a0
callq 0x1fac8d
jmp 0x5c36a0
callq 0x1fac67
jmp 0x5c36a0
callq 0x1fac41
jmp 0x5c36a0
callq 0x1fac1b
xorl %ebx, %ebx
movq %rbx, %rax
addq $0x158, %rsp            # imm = 0x158
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
nop