// File: /workspace/github_c_makefile_star2_O3/nh13[P]ksw/src/parasail/src/sg_trace_scan_avx2_256_16.c
// Function: parasail_sg_flags_trace_scan_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,
        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;
    int16_t* restrict boundary = NULL;
    __m256i* restrict pvHt = NULL;
    __m256i* restrict pvH = NULL;
    __m256i* restrict pvGapper = NULL;
    __m256i vGapO;
    __m256i vGapE;
    int16_t NEG_LIMIT = 0;
    int16_t POS_LIMIT = 0;
    __m256i vZero;
    int16_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->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;
    pvP = (__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;
    vZero = _mm256_setzero_si256();
    score = NEG_LIMIT;
    vNegLimit = _mm256_set1_epi16(NEG_LIMIT);
    vPosLimit = _mm256_set1_epi16(POS_LIMIT);
    vSaturationCheckMin = vPosLimit;
    vSaturationCheckMax = vNegLimit;
    vMaxH = vNegLimit;
    vPosMask = _mm256_cmpeq_epi16(_mm256_set1_epi16(position),
            _mm256_set_epi16(0,1,2,3,4,5,6,7,8,9,10,11,12,13,14,15));
    vNegInfFront = vZero;
    vNegInfFront = _mm256_insert_epi16_rpl(vNegInfFront, NEG_LIMIT, 0);
    vSegLenXgap = _mm256_adds_epi16(vNegInfFront,
            _mm256_slli_si256_rpl(_mm256_set1_epi16(-segLen*gap), 2));
    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);

    /* 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_16 | PARASAIL_FLAG_LANES_16;
    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_int16_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_16_t h;
            __m256i_16_t e;
            for (segNum=0; segNum<segWidth; ++segNum) {
                int64_t tmp = s1_beg ? 0 : (-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(&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 < INT16_MIN ? INT16_MIN : tmp;
        }
    }

    {
        __m256i vGapper = _mm256_subs_epi16(vZero,vGapO);
        for (i=segLen-1; i>=0; --i) {
            _mm256_store_si256(pvGapper+i, vGapper);
            vGapper = _mm256_subs_epi16(vGapper, vGapE);
            /* long queries and/or large penalties will break the pseudo prefix scan */
            vSaturationCheckMin = _mm256_min_epi16(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, 2);
        vHp = _mm256_insert_epi16_rpl(vHp, boundary[j], 0);
        pvW = pvP + matrix->mapper[(unsigned char)s2[j]]*segLen;
        vHt = _mm256_subs_epi16(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_subs_epi16(vH, vGapO);
            vE_ext = _mm256_subs_epi16(vE, vGapE);
            case1 = _mm256_cmpgt_epi16(vE_opn, vE_ext);
            vET = _mm256_blendv_epi8(vTInsE, vTDiagE, case1);
            arr_store(result->trace->trace_table, vET, i, segLen, j);
            vE = _mm256_max_epi16(vE_opn, vE_ext);
            vSaturationCheckMin = _mm256_min_epi16(vSaturationCheckMin, vE);
            vGapper = _mm256_adds_epi16(vHt, vGapper);
            vF = _mm256_max_epi16(vF, vGapper);
            vHp = _mm256_adds_epi16(vHp, vW);
            vHt = _mm256_max_epi16(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, 2);
        vHt = _mm256_insert_epi16_rpl(vHt, boundary[j+1], 0);
        vGapper = _mm256_load_si256(pvGapper);
        vGapper = _mm256_adds_epi16(vHt, vGapper);
        vF = _mm256_max_epi16(vF, vGapper);
        for (i=0; i<segWidth-2; ++i) {
            __m256i vFt = _mm256_slli_si256_rpl(vF, 2);
            vFt = _mm256_adds_epi16(vFt, vSegLenXgap);
            vF = _mm256_max_epi16(vF, vFt);
        }

        /* calculate final H */
        vF = _mm256_slli_si256_rpl(vF, 2);
        vF = _mm256_adds_epi16(vF, vNegInfFront);
        vH = _mm256_max_epi16(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_subs_epi16(vH, vGapO);
            vF_ext = _mm256_subs_epi16(vF, vGapE);
            vF = _mm256_max_epi16(vF_opn, vF_ext);
            case1 = _mm256_cmpgt_epi16(vF_opn, vF_ext);
            vFT = _mm256_blendv_epi8(vTDelF, vTDiagF, case1);
            vH = _mm256_max_epi16(vHt, vF);
            case1 = _mm256_cmpeq_epi16(vH, vHp);
            case2 = _mm256_cmpeq_epi16(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_epi16(vSaturationCheckMin, vH);
            vSaturationCheckMin = _mm256_min_epi16(vSaturationCheckMin, vF);
            vSaturationCheckMax = _mm256_max_epi16(vSaturationCheckMax, vH);
        }

        /* extract vector containing last value from column */
        {
            __m256i vCompare;
            vH = _mm256_load_si256(pvH + offset);
            vCompare = _mm256_and_si256(vPosMask, _mm256_cmpgt_epi16(vH, vMaxH));
            vMaxH = _mm256_max_epi16(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, 2);
        }
        score = (int16_t) _mm256_extract_epi16_rpl(vMaxH, 15);
        end_query = s1Len-1;
    }

    /* max of last column */
    if (s1_end)
    {
        /* Trace the alignment ending position on read. */
        int16_t *t = (int16_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, 2);
            }
            score = (int16_t) _mm256_extract_epi16_rpl (vH, 15);
            end_ref = s2Len - 1;
            end_query = s1Len - 1;
        }
    }

    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(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 $0x1f8, %rsp            # imm = 0x1F8
movq %rsi, 0x48(%rsp)
testq %rdi, %rdi
je 0x5ac506
movq 0x30(%rdi), %rax
movq %rax, 0x88(%rsp)
testq %rax, %rax
je 0x5ac50d
movq 0x10(%rdi), %rax
movq %rax, 0x40(%rsp)
testq %rax, %rax
je 0x5ac514
movl %ecx, %r12d
movl 0x8(%rdi), %ecx
testl %ecx, %ecx
jle 0x5ac51b
cmpq $0x0, 0x48(%rsp)
je 0x5ac522
movl %r9d, %r15d
movl %edx, %r9d
testl %edx, %edx
jle 0x5ac529
testl %r12d, %r12d
js 0x5ac530
testl %r8d, %r8d
js 0x5ac537
movl %r8d, 0x30(%rsp)
leal -0x1(%rcx), %eax
movq %rcx, 0x80(%rsp)
leaq 0xf(%rcx), %r14
movq %r14, %r13
shrq $0x4, %r13
movl %eax, 0x34(%rsp)
xorl %edx, %edx
divl %r13d
movl %eax, 0xc(%rsp)
movl %edx, %ebp
movl %r12d, %esi
negl %esi
movq 0x40(%rsp), %rdx
movl 0x20(%rdx), %eax
movl %eax, %ecx
negl %ecx
movl %esi, 0x2c(%rsp)
cmpl %esi, %eax
cmovgl %r12d, %ecx
movl %ecx, 0x10(%rsp)
movw $0x7ffe, %ax            # imm = 0x7FFE
subw 0x1c(%rdx), %ax
movl %eax, 0x50(%rsp)
movl $0x20, %edx
movl $0x20, %ecx
movl %r13d, %edi
movl %r9d, %esi
movq %r9, 0x38(%rsp)
callq 0x20adf4
testq %rax, %rax
je 0x5ac53c
movq %rax, %rbx
movl %r12d, 0x18(%rsp)
movl %ebp, 0x24(%rsp)
movq %r14, 0x78(%rsp)
movl 0x240(%rsp), %edi
xorl %eax, %eax
testl %r15d, %r15d
setne %al
xorl %ecx, %ecx
cmpl $0x0, 0x230(%rsp)
setne %cl
shll $0x4, %ecx
xorl %edx, %edx
cmpl $0x0, 0x238(%rsp)
setne %dl
shll $0xe, %edx
xorl %esi, %esi
movl %edi, 0x28(%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 $0x10280402, %eax       # imm = 0x10280402
movl %eax, 0xc(%rbx)
movl $0x20, %edi
movq %r13, %rsi
callq 0x4f1904
movl %r15d, 0xd0(%rsp)
movq %rax, %r15
movq 0x38(%rsp), %rax
leal 0x1(%rax), %esi
movl $0x20, %edi
callq 0x20a625
movq %rax, %r12
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, %rsi
callq 0x4f1904
testq %r15, %r15
sete %cl
testq %r12, %r12
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 0x5ac53c
movq 0x38(%rsp), %r11
leal -0x1(%r11), %ecx
movl %ecx, 0x8(%rsp)
movl $0xf, %edx
subl 0xc(%rsp), %edx
movl 0x18(%rsp), %esi
vmovd %esi, %xmm0
vpbroadcastw %xmm0, %ymm0
vmovdqu %ymm0, 0x170(%rsp)
movl 0x30(%rsp), %r9d
vmovd %r9d, %xmm0
vpbroadcastw %xmm0, %ymm3
movl 0x10(%rsp), %ecx
addl $0xffff8001, %ecx       # imm = 0xFFFF8001
vmovd %ecx, %xmm0
vpbroadcastw %xmm0, %ymm0
vmovdqu %ymm0, 0x130(%rsp)
vmovd 0x50(%rsp), %xmm0
vpbroadcastw %xmm0, %ymm0
vmovdqu %ymm0, 0x150(%rsp)
movl %edx, 0x14(%rsp)
vmovd %edx, %xmm0
vpbroadcastw %xmm0, %ymm0
vmovdqu %ymm0, 0x190(%rsp)
movl %ecx, 0x10(%rsp)
movzwl %cx, %ecx
movl %r13d, %edx
imull %r9d, %edx
negl %edx
vmovd %edx, %xmm0
vpbroadcastw %xmm0, %ymm0
vpand 0x82481(%rip), %ymm0, %ymm0 # 0x62ddc0
vmovd %ecx, %xmm1
vmovdqu %ymm1, 0x1d0(%rsp)
vpaddsw %ymm0, %ymm1, %ymm0
vmovdqu %ymm0, 0x1b0(%rsp)
cmpl $0x0, 0xd0(%rsp)
setne %cl
movl %esi, %edx
movl %r13d, %r8d
movl %r9d, %esi
movl 0x2c(%rsp), %r10d
movslq %r10d, %rdi
vmovq %rsi, %xmm0
vpbroadcastq %xmm0, %ymm0
vmovq %rdi, %xmm1
vpbroadcastq %xmm1, %ymm1
vmovq %rdx, %xmm4
vpbroadcastq %xmm4, %ymm4
movq %r8, 0x18(%rsp)
vmovq %r8, %xmm6
vpbroadcastq %xmm6, %ymm6
vpmuldq 0x82436(%rip), %ymm6, %ymm2 # 0x62dde0
vmovdqu %ymm2, 0xb0(%rsp)
vpmuldq 0x82444(%rip), %ymm6, %ymm2 # 0x62de00
vmovdqu %ymm2, 0x110(%rsp)
vpmuldq 0x82272(%rip), %ymm6, %ymm7 # 0x62dc40
vmovdqu %ymm7, 0x50(%rsp)
vpmuldq 0x82163(%rip), %ymm6, %ymm6 # 0x62db40
vmovdqu %ymm6, 0xd0(%rsp)
vmovd %ecx, %xmm6
vpbroadcastb %xmm6, %xmm7
vpshufb 0x7e108(%rip), %xmm7, %xmm6 # 0x629b00
xorl %ecx, %ecx
vpslld $0x1f, %xmm6, %xmm6
vpsrad $0x1f, %xmm6, %xmm6
vpmovsxdq %xmm6, %ymm2
vmovdqu %ymm2, 0x90(%rsp)
vpshufb 0x7e1d5(%rip), %xmm7, %xmm6 # 0x629bf0
vpslld $0x1f, %xmm6, %xmm6
vpsrad $0x1f, %xmm6, %xmm6
vpmovsxdq %xmm6, %ymm2
vmovdqu %ymm2, 0xf0(%rsp)
vmovdqa %xmm7, %xmm2
vpshufb 0x7e1c0(%rip), %xmm7, %xmm6 # 0x629c00
vpslld $0x1f, %xmm6, %xmm6
vpsrad $0x1f, %xmm6, %xmm6
vpmovsxdq %xmm6, %ymm13
movq %rbp, %rdi
movq %r15, %r8
vpbroadcastq 0x823e2(%rip), %ymm14 # 0x62de40
vpxor %xmm15, %xmm15, %xmm15
movq %r11, %rdx
vmovdqu 0xf0(%rsp), %ymm5
vmovq %rcx, %xmm6
vpbroadcastq %xmm6, %ymm6
vpaddq 0xb0(%rsp), %ymm6, %ymm7
vpaddq 0x110(%rsp), %ymm6, %ymm8
vpaddq 0xd0(%rsp), %ymm6, %ymm9
vpaddq 0x50(%rsp), %ymm6, %ymm6
vpmuludq %ymm0, %ymm6, %ymm11
vpsrlq $0x20, %ymm6, %ymm6
vpmuludq %ymm0, %ymm6, %ymm6
vpsllq $0x20, %ymm6, %ymm6
vpaddq %ymm6, %ymm11, %ymm11
vpmuludq %ymm0, %ymm9, %ymm6
vpsrlq $0x20, %ymm9, %ymm9
vpmuludq %ymm0, %ymm9, %ymm9
vpsllq $0x20, %ymm9, %ymm9
vpaddq %ymm6, %ymm9, %ymm9
vpmuludq %ymm0, %ymm8, %ymm6
vpsrlq $0x20, %ymm8, %ymm8
vpmuludq %ymm0, %ymm8, %ymm8
vpsllq $0x20, %ymm8, %ymm8
vpaddq %ymm6, %ymm8, %ymm8
vpmuludq %ymm0, %ymm7, %ymm6
vpsrlq $0x20, %ymm7, %ymm7
vpmuludq %ymm0, %ymm7, %ymm7
vpsllq $0x20, %ymm7, %ymm7
vpaddq %ymm7, %ymm6, %ymm6
vpsubq %ymm6, %ymm1, %ymm6
vpandn %ymm6, %ymm13, %ymm6
vpsubq %ymm8, %ymm1, %ymm7
vpsubq %ymm9, %ymm1, %ymm8
vpsubq %ymm11, %ymm1, %ymm9
vpmovzxbd %xmm2, %xmm11   # xmm11 = xmm2[0],zero,zero,zero,xmm2[1],zero,zero,zero,xmm2[2],zero,zero,zero,xmm2[3],zero,zero,zero
vpslld $0x1f, %xmm11, %xmm11
vpsrad $0x1f, %xmm11, %xmm11
vpmovsxdq %xmm11, %ymm11
vpcmpgtq %ymm14, %ymm6, %ymm12
vblendvpd %ymm12, %ymm6, %ymm14, %ymm12
vpandn %ymm8, %ymm11, %ymm8
vpcmpgtq %ymm14, %ymm8, %ymm11
vblendvpd %ymm11, %ymm8, %ymm14, %ymm11
vmovdqu 0x90(%rsp), %ymm10
vpandn %ymm9, %ymm10, %ymm9
vpcmpgtq %ymm14, %ymm9, %ymm10
vblendvpd %ymm10, %ymm9, %ymm14, %ymm10
vpandn %ymm7, %ymm5, %ymm7
vpblendw $0x11, %ymm10, %ymm15, %ymm10 # ymm10 = ymm10[0],ymm15[1,2,3],ymm10[4],ymm15[5,6,7],ymm10[8],ymm15[9,10,11],ymm10[12],ymm15[13,14,15]
vpblendw $0x11, %ymm11, %ymm15, %ymm11 # ymm11 = ymm11[0],ymm15[1,2,3],ymm11[4],ymm15[5,6,7],ymm11[8],ymm15[9,10,11],ymm11[12],ymm15[13,14,15]
vpackusdw %ymm10, %ymm11, %ymm10
vpcmpgtq %ymm14, %ymm7, %ymm11
vblendvpd %ymm11, %ymm7, %ymm14, %ymm11
vpblendw $0x11, %ymm11, %ymm15, %ymm11 # ymm11 = ymm11[0],ymm15[1,2,3],ymm11[4],ymm15[5,6,7],ymm11[8],ymm15[9,10,11],ymm11[12],ymm15[13,14,15]
vpblendw $0x11, %ymm12, %ymm15, %ymm12 # ymm12 = ymm12[0],ymm15[1,2,3],ymm12[4],ymm15[5,6,7],ymm12[8],ymm15[9,10,11],ymm12[12],ymm15[13,14,15]
vpackusdw %ymm12, %ymm11, %ymm11
vpsubq %ymm4, %ymm9, %ymm9
vpsubq %ymm4, %ymm8, %ymm8
vpsubq %ymm4, %ymm6, %ymm6
vpcmpgtq %ymm14, %ymm6, %ymm12
vblendvpd %ymm12, %ymm6, %ymm14, %ymm6
vpsubq %ymm4, %ymm7, %ymm7
vpcmpgtq %ymm14, %ymm7, %ymm12
vblendvpd %ymm12, %ymm7, %ymm14, %ymm7
vpcmpgtq %ymm14, %ymm8, %ymm12
vblendvpd %ymm12, %ymm8, %ymm14, %ymm8
vpcmpgtq %ymm14, %ymm9, %ymm12
vblendvpd %ymm12, %ymm9, %ymm14, %ymm9
vpermq $0xd8, %ymm10, %ymm10   # ymm10 = ymm10[0,2,1,3]
vpermq $0xd8, %ymm11, %ymm11   # ymm11 = ymm11[0,2,1,3]
vpackusdw %ymm11, %ymm10, %ymm10
vpblendw $0x11, %ymm9, %ymm15, %ymm9 # ymm9 = ymm9[0],ymm15[1,2,3],ymm9[4],ymm15[5,6,7],ymm9[8],ymm15[9,10,11],ymm9[12],ymm15[13,14,15]
vpblendw $0x11, %ymm8, %ymm15, %ymm8 # ymm8 = ymm8[0],ymm15[1,2,3],ymm8[4],ymm15[5,6,7],ymm8[8],ymm15[9,10,11],ymm8[12],ymm15[13,14,15]
vpackusdw %ymm9, %ymm8, %ymm8
vpblendw $0x11, %ymm7, %ymm15, %ymm7 # ymm7 = ymm7[0],ymm15[1,2,3],ymm7[4],ymm15[5,6,7],ymm7[8],ymm15[9,10,11],ymm7[12],ymm15[13,14,15]
vpblendw $0x11, %ymm6, %ymm15, %ymm6 # ymm6 = ymm6[0],ymm15[1,2,3],ymm6[4],ymm15[5,6,7],ymm6[8],ymm15[9,10,11],ymm6[12],ymm15[13,14,15]
vpackusdw %ymm6, %ymm7, %ymm6
vpermq $0xd8, %ymm10, %ymm7    # ymm7 = ymm10[0,2,1,3]
vmovdqa %ymm7, (%rdi)
vpermq $0xd8, %ymm8, %ymm7     # ymm7 = ymm8[0,2,1,3]
vpermq $0xd8, %ymm6, %ymm6     # ymm6 = ymm6[0,2,1,3]
vpackusdw %ymm6, %ymm7, %ymm6
vpermq $0xd8, %ymm6, %ymm6     # ymm6 = ymm6[0,2,1,3]
vmovdqa %ymm6, (%r8)
incq %rcx
addq $0x20, %r8
addq $0x20, %rdi
cmpq %rcx, %r13
jne 0x5aba6f
movw $0x0, (%r12)
movl %edx, %ecx
addl $0xf, %edx
andl $-0x10, %edx
movq %rcx, 0xd0(%rsp)
decq %rcx
vmovq %rcx, %xmm0
vpbroadcastq %xmm0, %ymm7
vmovd %r9d, %xmm0
vpbroadcastd %xmm0, %ymm0
vmovdqu %ymm0, 0x50(%rsp)
vmovd %r10d, %xmm0
vpbroadcastd %xmm0, %ymm0
vmovdqu %ymm0, 0xb0(%rsp)
vpmovsxbd 0x821c7(%rip), %ymm10 # 0x62de48
vpmovsxbd 0x82046(%rip), %ymm11 # 0x62dcd0
xorl %r8d, %r8d
vpbroadcastq 0x81eea(%rip), %xmm1 # 0x62db80
vpcmpeqd %xmm6, %xmm6, %xmm6
vpcmpeqd %ymm4, %ymm4, %ymm4
vpbroadcastd 0x821a9(%rip), %ymm0 # 0x62de50
vmovdqu %ymm0, 0x90(%rsp)
vpbroadcastq 0x81ec7(%rip), %ymm13 # 0x62db80
vpbroadcastd 0x81efe(%rip), %xmm2 # 0x62dbc0
vpbroadcastd 0x82189(%rip), %ymm5 # 0x62de54
movl 0x238(%rsp), %edi
vpxor %xmm9, %xmm9, %xmm9
testl %edi, %edi
jne 0x5abd2f
vpaddd %ymm4, %ymm11, %ymm0
vpaddd %ymm4, %ymm10, %ymm8
vmovdqu 0x50(%rsp), %ymm12
vpmulld %ymm12, %ymm8, %ymm8
vpmulld %ymm12, %ymm0, %ymm0
vmovdqu 0xb0(%rsp), %ymm12
vpsubd %ymm0, %ymm12, %ymm0
vpsubd %ymm8, %ymm12, %ymm8
vmovdqu 0x90(%rsp), %ymm12
vpmaxsd %ymm12, %ymm8, %ymm8
vpmaxsd %ymm12, %ymm0, %ymm0
vpblendw $0xaa, %ymm9, %ymm0, %ymm0 # ymm0 = ymm0[0],ymm9[1],ymm0[2],ymm9[3],ymm0[4],ymm9[5],ymm0[6],ymm9[7],ymm0[8],ymm9[9],ymm0[10],ymm9[11],ymm0[12],ymm9[13],ymm0[14],ymm9[15]
vpblendw $0xaa, %ymm9, %ymm8, %ymm8 # ymm8 = ymm8[0],ymm9[1],ymm8[2],ymm9[3],ymm8[4],ymm9[5],ymm8[6],ymm9[7],ymm8[8],ymm9[9],ymm8[10],ymm9[11],ymm8[12],ymm9[13],ymm8[14],ymm9[15]
vpackusdw %ymm8, %ymm0, %ymm0
vpermq $0xd8, %ymm0, %ymm9     # ymm9 = ymm0[0,2,1,3]
vmovq %r8, %xmm0
vpbroadcastq %xmm0, %ymm8
vpor 0x81dff(%rip), %ymm8, %ymm12 # 0x62db40
vpxor %xmm1, %xmm7, %xmm0
vpxor %xmm1, %xmm12, %xmm14
vpcmpgtq %xmm0, %xmm14, %xmm0
vpackssdw %xmm0, %xmm0, %xmm0
vpxor %xmm6, %xmm0, %xmm0
vpackssdw %xmm0, %xmm0, %xmm0
vpacksswb %xmm0, %xmm0, %xmm0
vmovd %xmm0, %ecx
testb $0x1, %cl
je 0x5abd6f
vpextrw $0x0, %xmm9, 0x2(%r12,%r8,2)
vpxor %xmm1, %xmm7, %xmm0
vpxor %xmm1, %xmm12, %xmm14
vpcmpgtq %xmm0, %xmm14, %xmm0
vpackssdw %xmm0, %xmm0, %xmm0
vpxor %xmm6, %xmm0, %xmm0
vpackssdw %xmm0, %xmm0, %xmm0
vpacksswb %xmm0, %xmm0, %xmm0
vpextrb $0x1, %xmm0, %ecx
testb $0x1, %cl
je 0x5abd9f
vpextrw $0x1, %xmm9, 0x4(%r12,%r8,2)
vpxor %ymm7, %ymm13, %ymm0
vpxor %ymm13, %ymm12, %ymm12
vpcmpgtq %ymm0, %ymm12, %ymm12
vpshuflw $0xe8, %ymm12, %ymm14   # ymm14 = ymm12[0,2,2,3,4,5,6,7,8,10,10,11,12,13,14,15]
vpxor %ymm4, %ymm14, %ymm14
vpermd %ymm14, %ymm2, %ymm14
vpackssdw %xmm14, %xmm14, %xmm14
vpacksswb %xmm14, %xmm14, %xmm14
vpextrb $0x2, %xmm14, %ecx
testb $0x1, %cl
je 0x5abdd9
vpextrw $0x2, %xmm9, 0x6(%r12,%r8,2)
vextracti128 $0x1, %ymm12, %xmm12
vpackssdw %xmm12, %xmm12, %xmm12
vpxor %xmm6, %xmm12, %xmm12
vpackssdw %xmm12, %xmm12, %xmm12
vpacksswb %xmm12, %xmm12, %xmm12
vpextrb $0x3, %xmm12, %ecx
testb $0x1, %cl
je 0x5abe05
vpextrw $0x3, %xmm9, 0x8(%r12,%r8,2)
vpor 0x81e33(%rip), %ymm8, %ymm12 # 0x62dc40
vpxor %xmm1, %xmm7, %xmm14
vpxor %xmm1, %xmm12, %xmm15
vpcmpgtq %xmm14, %xmm15, %xmm14
vpackssdw %xmm14, %xmm14, %xmm14
vpxor %xmm6, %xmm14, %xmm14
vpermq $0x55, %ymm14, %ymm14   # ymm14 = ymm14[1,1,1,1]
vpackssdw %ymm0, %ymm14, %ymm14
vextracti128 $0x1, %ymm14, %xmm14
vpacksswb %xmm14, %xmm14, %xmm14
vpextrb $0x8, %xmm14, %ecx
testb $0x1, %cl
je 0x5abe4b
vpextrw $0x4, %xmm9, 0xa(%r12,%r8,2)
vpxor %xmm1, %xmm7, %xmm14
vpxor %xmm1, %xmm12, %xmm15
vpcmpgtq %xmm14, %xmm15, %xmm14
vpshufhw $0x84, %xmm14, %xmm14   # xmm14 = xmm14[0,1,2,3,4,5,4,6]
vpxor %xmm6, %xmm14, %xmm14
vpermq $0x55, %ymm14, %ymm14   # ymm14 = ymm14[1,1,1,1]
vpackssdw %ymm0, %ymm14, %ymm14
vextracti128 $0x1, %ymm14, %xmm14
vpacksswb %xmm14, %xmm14, %xmm14
vpextrb $0x9, %xmm14, %ecx
testb $0x1, %cl
je 0x5abe8a
vpextrw $0x5, %xmm9, 0xc(%r12,%r8,2)
vpxor %ymm13, %ymm12, %ymm12
vpcmpgtq %ymm0, %ymm12, %ymm12
vpackssdw %ymm12, %ymm0, %ymm14
vpxor %ymm4, %ymm14, %ymm14
vpackssdw %ymm0, %ymm14, %ymm14
vextracti128 $0x1, %ymm14, %xmm14
vpacksswb %xmm14, %xmm14, %xmm14
vpextrb $0xa, %xmm14, %ecx
testb $0x1, %cl
je 0x5abebf
vpextrw $0x6, %xmm9, 0xe(%r12,%r8,2)
vpackssdw %ymm12, %ymm0, %ymm12
vpxor %ymm4, %ymm12, %ymm12
vpackssdw %ymm0, %ymm12, %ymm12
vextracti128 $0x1, %ymm12, %xmm12
vpacksswb %xmm12, %xmm12, %xmm12
vpextrb $0xb, %xmm12, %ecx
testb $0x1, %cl
je 0x5abeea
vpextrw $0x7, %xmm9, 0x10(%r12,%r8,2)
vpor 0x81f0e(%rip), %ymm8, %ymm12 # 0x62de00
vpxor %xmm1, %xmm7, %xmm14
vpxor %xmm1, %xmm12, %xmm15
vpcmpgtq %xmm14, %xmm15, %xmm14
vpackssdw %xmm14, %xmm14, %xmm14
vpxor %xmm6, %xmm14, %xmm14
vpackssdw %xmm14, %xmm14, %xmm14
vpacksswb %xmm14, %xmm14, %xmm14
vpextrb $0x4, %xmm14, %ecx
vextracti128 $0x1, %ymm9, %xmm9
testb $0x1, %cl
je 0x5abf2b
vpextrw $0x0, %xmm9, 0x12(%r12,%r8,2)
vpxor %xmm1, %xmm7, %xmm14
vpxor %xmm1, %xmm12, %xmm15
vpcmpgtq %xmm14, %xmm15, %xmm14
vpackssdw %xmm14, %xmm14, %xmm14
vpxor %xmm6, %xmm14, %xmm14
vpackssdw %xmm14, %xmm14, %xmm14
vpacksswb %xmm14, %xmm14, %xmm14
vpextrb $0x5, %xmm14, %ecx
testb $0x1, %cl
je 0x5abf5e
vpextrw $0x1, %xmm9, 0x14(%r12,%r8,2)
vpxor %ymm13, %ymm12, %ymm12
vpcmpgtq %ymm0, %ymm12, %ymm12
vpshuflw $0xe8, %ymm12, %ymm14   # ymm14 = ymm12[0,2,2,3,4,5,6,7,8,10,10,11,12,13,14,15]
vpxor %ymm4, %ymm14, %ymm14
vpermd %ymm14, %ymm2, %ymm14
vpackssdw %xmm14, %xmm14, %xmm14
vpacksswb %xmm14, %xmm14, %xmm14
vpextrb $0x6, %xmm14, %ecx
testb $0x1, %cl
je 0x5abf94
vpextrw $0x2, %xmm9, 0x16(%r12,%r8,2)
vextracti128 $0x1, %ymm12, %xmm12
vpackssdw %xmm12, %xmm12, %xmm12
vpxor %xmm6, %xmm12, %xmm12
vpackssdw %xmm12, %xmm12, %xmm12
vpacksswb %xmm12, %xmm12, %xmm12
vpextrb $0x7, %xmm12, %ecx
testb $0x1, %cl
je 0x5abfc0
vpextrw $0x3, %xmm9, 0x18(%r12,%r8,2)
vpor 0x81e18(%rip), %ymm8, %ymm8 # 0x62dde0
vpxor %xmm1, %xmm7, %xmm12
vpxor %xmm1, %xmm8, %xmm14
vpcmpgtq %xmm12, %xmm14, %xmm12
vpackssdw %xmm12, %xmm12, %xmm12
vpxor %xmm6, %xmm12, %xmm12
vpermq $0x55, %ymm12, %ymm12   # ymm12 = ymm12[1,1,1,1]
vpackssdw %ymm12, %ymm0, %ymm12
vextracti128 $0x1, %ymm12, %xmm12
vpacksswb %xmm12, %xmm12, %xmm12
vpextrb $0xc, %xmm12, %ecx
testb $0x1, %cl
je 0x5ac007
vpextrw $0x4, %xmm9, 0x1a(%r12,%r8,2)
vpxor %xmm1, %xmm7, %xmm12
vpxor %xmm1, %xmm8, %xmm14
vpcmpgtq %xmm12, %xmm14, %xmm12
vpshufhw $0x84, %xmm12, %xmm12   # xmm12 = xmm12[0,1,2,3,4,5,4,6]
vpxor %xmm6, %xmm12, %xmm12
vpermq $0x55, %ymm12, %ymm12   # ymm12 = ymm12[1,1,1,1]
vpackssdw %ymm12, %ymm0, %ymm12
vextracti128 $0x1, %ymm12, %xmm12
vpacksswb %xmm12, %xmm12, %xmm12
vpextrb $0xd, %xmm12, %ecx
testb $0x1, %cl
je 0x5ac047
vpextrw $0x5, %xmm9, 0x1c(%r12,%r8,2)
vpxor %ymm13, %ymm8, %ymm8
vpcmpgtq %ymm0, %ymm8, %ymm0
vpackssdw %ymm0, %ymm0, %ymm8
vpxor %ymm4, %ymm8, %ymm8
vpackssdw %ymm8, %ymm0, %ymm8
vextracti128 $0x1, %ymm8, %xmm8
vpacksswb %xmm8, %xmm8, %xmm8
vpextrb $0xe, %xmm8, %ecx
testb $0x1, %cl
vmovupd 0x170(%rsp), %ymm12
je 0x5ac085
vpextrw $0x6, %xmm9, 0x1e(%r12,%r8,2)
vpackssdw %ymm0, %ymm0, %ymm0
vpxor %ymm4, %ymm0, %ymm0
vpackssdw %ymm0, %ymm0, %ymm0
vextracti128 $0x1, %ymm0, %xmm0
vpacksswb %xmm0, %xmm0, %xmm0
vpextrb $0xf, %xmm0, %ecx
testb $0x1, %cl
je 0x5ac0ae
vpextrw $0x7, %xmm9, 0x20(%r12,%r8,2)
addq $0x10, %r8
vpaddd %ymm5, %ymm11, %ymm11
vpaddd %ymm5, %ymm10, %ymm10
cmpq %r8, %rdx
jne 0x5abcd2
vpxor %xmm0, %xmm0, %xmm0
vpsubsw %ymm12, %ymm0, %ymm0
leal -0x1(%r13), %r10d
shlq $0x5, %r10
movq %rax, %rcx
addq %r10, %rcx
movl %r13d, %edx
vmovdqu 0x150(%rsp), %ymm7
vmovdqa %ymm0, (%rcx)
vpsubsw %ymm3, %ymm0, %ymm0
vpminsw %ymm0, %ymm7, %ymm7
addq $-0x20, %rcx
decl %edx
jg 0x5ac0e6
vpbroadcastw 0x83c97(%rip), %ymm15 # 0x62fd9a
addq %rbp, %r10
vpbroadcastw 0x83c8d(%rip), %ymm4 # 0x62fd9c
movl 0x24(%rsp), %r11d
movq %r11, 0x110(%rsp)
vpbroadcastw 0x83c79(%rip), %ymm8 # 0x62fd9e
shlq $0x5, %r11
vpbroadcastw 0x83c6e(%rip), %ymm9 # 0x62fda0
addq %rbp, %r11
movq %r13, 0xf0(%rsp)
vpbroadcastw 0x83c5c(%rip), %ymm10 # 0x62fda2
shlq $0x5, %r13
vpbroadcastw 0x83c51(%rip), %ymm11 # 0x62fda4
xorl %r9d, %r9d
vmovdqu 0x190(%rsp), %ymm0
vpcmpeqw 0x81cf9(%rip), %ymm0, %ymm0 # 0x62de60
vmovdqu %ymm0, 0x90(%rsp)
xorl %ecx, %ecx
movl 0x8(%rsp), %r8d
vmovdqu 0x130(%rsp), %ymm1
vmovdqa %ymm1, %ymm6
vmovdqa %ymm1, %ymm5
vmovdqu %ymm8, 0xb0(%rsp)
vmovdqu %ymm5, 0x50(%rsp)
vmovdqa (%r10), %ymm13
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, (%r12,%rcx,2), %xmm13, %xmm14
vmovdqa %ymm4, %ymm8
vmovdqa %ymm15, %ymm4
vpblendd $0xf, %ymm14, %ymm13, %ymm15 # ymm15 = ymm14[0,1,2,3],ymm13[4,5,6,7]
movq 0x40(%rsp), %rdx
movq 0x10(%rdx), %rdx
movq 0x48(%rsp), %rsi
movzbl (%rsi,%rcx), %esi
movslq (%rdx,%rsi,4), %rdx
imulq 0x18(%rsp), %rdx
shlq $0x5, %rdx
addq 0x88(%rsp), %rdx
vmovdqu 0x130(%rsp), %ymm13
vpsubsw (%rax), %ymm13, %ymm14
xorl %esi, %esi
vmovdqa %ymm12, %ymm0
vpaddsw (%rdx,%rsi), %ymm15, %ymm15
vmovdqa (%rbp,%rsi), %ymm12
vmovdqa (%r15,%rsi), %ymm1
vpsubsw %ymm0, %ymm12, %ymm5
vpsubsw %ymm3, %ymm1, %ymm1
vpcmpgtw %ymm1, %ymm5, %ymm2
vpblendvb %ymm2, %ymm4, %ymm8, %ymm2
movq 0x10(%rbx), %rdi
movq (%rdi), %rdi
addq %r9, %rdi
vpaddsw (%rax,%rsi), %ymm14, %ymm14
vmovdqa %ymm2, (%rsi,%rdi)
vpmaxsw %ymm14, %ymm13, %ymm13
vpmaxsw %ymm1, %ymm5, %ymm1
vpminsw %ymm1, %ymm7, %ymm7
vpmaxsw %ymm1, %ymm15, %ymm14
vmovdqa %ymm1, (%r15,%rsi)
vmovdqa %ymm14, (%r14,%rsi)
vmovdqa %ymm15, (%rbp,%rsi)
addq $0x20, %rsi
vmovdqa %ymm12, %ymm15
cmpq %rsi, %r13
jne 0x5ac1f8
vinserti128 $0x1, %xmm14, %ymm0, %ymm1
vpalignr $0xe, %ymm1, %ymm14, %ymm1 # ymm1 = ymm1[14,15],ymm14[0,1,2,3,4,5,6,7,8,9,10,11,12,13],ymm1[30,31],ymm14[16,17,18,19,20,21,22,23,24,25,26,27,28,29]
leaq 0x1(%rcx), %rdx
vpinsrw $0x0, 0x2(%r12,%rcx,2), %xmm1, %xmm2
vpblendd $0xf, %ymm2, %ymm1, %ymm14 # ymm14 = ymm2[0,1,2,3],ymm1[4,5,6,7]
vpaddsw (%rax), %ymm14, %ymm1
vpmaxsw %ymm1, %ymm13, %ymm13
movl $0xe, %esi
vmovdqu 0x1b0(%rsp), %ymm0
vperm2i128 $0x28, %ymm13, %ymm13, %ymm1 # ymm1 = zero,zero,ymm13[0,1]
vpalignr $0xe, %ymm1, %ymm13, %ymm1 # ymm1 = ymm1[14,15],ymm13[0,1,2,3,4,5,6,7,8,9,10,11,12,13],ymm1[30,31],ymm13[16,17,18,19,20,21,22,23,24,25,26,27,28,29]
vpaddsw %ymm0, %ymm1, %ymm1
vpmaxsw %ymm1, %ymm13, %ymm13
decl %esi
jne 0x5ac294
vperm2i128 $0x28, %ymm13, %ymm13, %ymm1 # ymm1 = zero,zero,ymm13[0,1]
vpalignr $0xe, %ymm1, %ymm13, %ymm1 # ymm1 = ymm1[14,15],ymm13[0,1,2,3,4,5,6,7,8,9,10,11,12,13],ymm1[30,31],ymm13[16,17,18,19,20,21,22,23,24,25,26,27,28,29]
vpaddsw 0x1d0(%rsp), %ymm1, %ymm13
vpmaxsw %ymm14, %ymm13, %ymm14
xorl %esi, %esi
vmovdqu 0x170(%rsp), %ymm12
vmovdqa %ymm4, %ymm15
vmovdqa %ymm8, %ymm4
vmovdqu 0xb0(%rsp), %ymm8
movq 0x10(%rbx), %rdi
movq (%rdi), %rdi
addq %r9, %rdi
vmovdqa (%r14,%rsi), %ymm1
vpsubsw %ymm12, %ymm14, %ymm2
vpsubsw %ymm3, %ymm13, %ymm5
vpmaxsw %ymm5, %ymm2, %ymm13
vpcmpgtw %ymm5, %ymm2, %ymm2
vpblendvb %ymm2, %ymm8, %ymm9, %ymm2
vpmaxsw %ymm1, %ymm13, %ymm14
vpcmpeqw (%rbp,%rsi), %ymm14, %ymm5
vpcmpgtw %ymm13, %ymm1, %ymm1
vpaddw %ymm1, %ymm10, %ymm1
vpblendvb %ymm5, %ymm11, %ymm1, %ymm1
vpor (%rsi,%rdi), %ymm2, %ymm2
vpor %ymm1, %ymm2, %ymm1
vmovdqa %ymm1, (%rsi,%rdi)
vmovdqa %ymm14, (%rbp,%rsi)
vpminsw %ymm7, %ymm13, %ymm1
vpminsw %ymm1, %ymm14, %ymm7
vpmaxsw %ymm6, %ymm14, %ymm6
addq $0x20, %rsi
cmpq %rsi, %r13
jne 0x5ac2e2
vmovdqa (%r11), %ymm1
vmovdqu 0x50(%rsp), %ymm5
vpcmpgtw %ymm5, %ymm1, %ymm2
vpand 0x90(%rsp), %ymm2, %ymm2
vpmaxsw %ymm5, %ymm1, %ymm5
vpmovmskb %ymm2, %esi
testl %esi, %esi
cmovnel %ecx, %r8d
addq %r13, %r9
movq %rdx, %rcx
cmpq 0xd0(%rsp), %rdx
jne 0x5ac191
cmpl $0x0, 0x240(%rsp)
movl 0x34(%rsp), %r10d
movq 0x80(%rsp), %r11
movl 0x10(%rsp), %r13d
vmovdqu 0x150(%rsp), %ymm2
je 0x5ac3d4
cmpl $0xe, 0xc(%rsp)
jg 0x5ac3c9
xorl %ecx, %ecx
movl 0x14(%rsp), %edx
vperm2i128 $0x28, %ymm5, %ymm5, %ymm0 # ymm0 = zero,zero,ymm5[0,1]
vpalignr $0xe, %ymm0, %ymm5, %ymm5 # ymm5 = ymm0[14,15],ymm5[0,1,2,3,4,5,6,7,8,9,10,11,12,13],ymm0[30,31],ymm5[16,17,18,19,20,21,22,23,24,25,26,27,28,29]
incl %ecx
cmpl %edx, %ecx
jl 0x5ac3b7
vextracti128 $0x1, %ymm5, %xmm0
vpextrw $0x7, %xmm0, %r13d
cmpl $0x0, 0x230(%rsp)
je 0x5ac44f
testl $0x7ffffff0, 0x78(%rsp) # imm = 0x7FFFFFF0
je 0x5ac44f
movq 0xf0(%rsp), %rdx
andl $0x7ffffff, %edx        # imm = 0x7FFFFFF
shll $0x4, %edx
xorl %esi, %esi
movl %r10d, %ecx
movl %esi, %r9d
shrl $0x4, %r9d
movl %esi, %edi
andl $0xf, %edi
imull 0xf0(%rsp), %edi
addl %r9d, %edi
cmpl %r11d, %edi
jge 0x5ac446
movzwl (%rbp,%rsi,2), %r9d
cmpw %r13w, %r9w
jle 0x5ac432
movl %r9d, %r13d
movl 0x8(%rsp), %r8d
movl %edi, %ecx
jmp 0x5ac446
cmpl %ecx, %edi
cmovgel %ecx, %edi
cmpl 0x8(%rsp), %r8d
cmovnel %ecx, %edi
cmpw %r13w, %r9w
cmovel %edi, %ecx
incq %rsi
cmpl %esi, %edx
jne 0x5ac3fe
jmp 0x5ac452
movl %r10d, %ecx
movl 0x230(%rsp), %edx
orl %edx, 0x28(%rsp)
jne 0x5ac4a3
movq 0x110(%rsp), %rcx
shlq $0x5, %rcx
vmovdqa (%rbp,%rcx), %ymm0
cmpl $0xe, 0xc(%rsp)
jg 0x5ac490
xorl %ecx, %ecx
movl 0x14(%rsp), %edx
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 %ecx
cmpl %edx, %ecx
jl 0x5ac47e
vextracti128 $0x1, %ymm0, %xmm0
vpextrw $0x7, %xmm0, %r13d
movl 0x8(%rsp), %r8d
movl %r10d, %ecx
vmovdqu 0x130(%rsp), %ymm0
vpcmpgtw %ymm7, %ymm0, %ymm0
vpcmpgtw %ymm2, %ymm6, %ymm1
vpor %ymm1, %ymm0, %ymm0
vpmovmskb %ymm0, %edx
testl %edx, %edx
je 0x5ac4cc
orb $0x40, 0xc(%rbx)
xorl %r13d, %r13d
xorl %r8d, %r8d
xorl %ecx, %ecx
movswl %r13w, %edx
movl %edx, (%rbx)
movl %ecx, 0x4(%rbx)
movl %r8d, 0x8(%rbx)
movq %rax, %rdi
vzeroupper
callq 0x20a60d
movq %rbp, %rdi
callq 0x20a60d
movq %r14, %rdi
callq 0x20a60d
movq %r12, %rdi
callq 0x20a60d
movq %r15, %rdi
callq 0x20a60d
jmp 0x5ac53e
callq 0x1f882f
jmp 0x5ac53c
callq 0x1f8809
jmp 0x5ac53c
callq 0x1f87e3
jmp 0x5ac53c
callq 0x1f87bd
jmp 0x5ac53c
callq 0x1f8797
jmp 0x5ac53c
callq 0x1f8771
jmp 0x5ac53c
callq 0x1f874b
jmp 0x5ac53c
callq 0x1f8725
xorl %ebx, %ebx
movq %rbx, %rax
addq $0x1f8, %rsp            # imm = 0x1F8
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq