// File: /workspace/github_c_makefile_star2_O3/nh13[P]ksw/src/parasail/src/sg_striped_avx2_256_16.c
// Function: parasail_sg_flags_table_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,
        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 vProfile = NULL;
    __m256i* restrict pvHStore = NULL;
    __m256i* restrict pvHLoad = NULL;
    __m256i* restrict pvE = 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;
    __m256i vMaxH;
    __m256i vPosMask;
    parasail_result_t *result = NULL;

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

    /* initialize result */
#ifdef PARASAIL_TABLE
    result = parasail_result_new_table1(segLen*segWidth, s2Len);
#else
#ifdef PARASAIL_ROWCOL
    result = parasail_result_new_rowcol1(segLen*segWidth, s2Len);
#else
    result = parasail_result_new();
#endif
#endif
    if (!result) return NULL;

    /* set known flags */
    result->flag |= PARASAIL_FLAG_SG | PARASAIL_FLAG_STRIPED
        | 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;
#ifdef PARASAIL_TABLE
    result->flag |= PARASAIL_FLAG_TABLE;
#endif
#ifdef PARASAIL_ROWCOL
    result->flag |= PARASAIL_FLAG_ROWCOL;
#endif

    /* initialize heap variables */
    pvHStore = parasail_memalign___m256i(32, segLen);
    pvHLoad =  parasail_memalign___m256i(32, segLen);
    pvE      = 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 (!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 = 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(&pvHStore[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;
        }
    }

    /* outer loop over database sequence */
    for (j=0; j<s2Len; ++j) {
        __m256i vE;
        /* Initialize F value to -inf.  Any errors to vH values will be
         * corrected in the Lazy_F loop.  */
        __m256i vF = vNegLimit;

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

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

        /* Swap the 2 H buffers. */
        __m256i* pv = pvHLoad;
        pvHLoad = pvHStore;
        pvHStore = pv;

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

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

            /* Get max from vH, vE and vF. */
            vH = _mm256_max_epi16(vH, 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);
#ifdef PARASAIL_TABLE
            arr_store_si256(result->tables->score_table, vH, i, segLen, j, s2Len);
#endif

            /* Update vE value. */
            vH = _mm256_subs_epi16(vH, vGapO);
            vE = _mm256_subs_epi16(vE, vGapE);
            vE = _mm256_max_epi16(vE, vH);
            _mm256_store_si256(pvE + i, vE);

            /* Update vF value. */
            vF = _mm256_subs_epi16(vF, vGapE);
            vF = _mm256_max_epi16(vF, vH);

            /* 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 */
        for (k=0; k<segWidth; ++k) {
            int64_t tmp = s2_beg ? -open : (boundary[j+1]-open);
            int16_t tmp2 = tmp < INT16_MIN ? INT16_MIN : tmp;
            vF = _mm256_slli_si256_rpl(vF, 2);
            vF = _mm256_insert_epi16_rpl(vF, 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);
#ifdef PARASAIL_TABLE
                arr_store_si256(result->tables->score_table, vH, i, segLen, j, s2Len);
#endif
                vH = _mm256_subs_epi16(vH, vGapO);
                vF = _mm256_subs_epi16(vF, vGapE);
                if (! _mm256_movemask_epi8(_mm256_cmpgt_epi16(vF, vH))) goto end;
                /*vF = _mm256_max_epi16(vF, vH);*/
            }
        }
end:
        {
            /* extract vector containing last value from the column */
            __m256i vCompare;
            vH = _mm256_load_si256(pvHStore + 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;
            }
#ifdef PARASAIL_ROWCOL
            for (k=0; k<position; ++k) {
                vH = _mm256_slli_si256_rpl(vH, 2);
            }
            result->rowcols->score_row[j] = (int16_t) _mm256_extract_epi16_rpl (vH, 15);
#endif
        }
    }

#ifdef PARASAIL_ROWCOL
    for (i=0; i<segLen; ++i) {
        __m256i vH = _mm256_load_si256(pvHStore + i);
        arr_store_col(result->rowcols->score_col, vH, i, segLen);
    }
#endif

    /* 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*)pvHStore;
        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(pvHStore + 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(boundary);
    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 $0x228, %rsp            # imm = 0x228
movl %ecx, 0x8(%rsp)
movq %rsi, 0x68(%rsp)
testq %rdi, %rdi
je 0x5102f9
movq 0x30(%rdi), %rax
movq %rax, 0x118(%rsp)
testq %rax, %rax
je 0x510300
movq 0x10(%rdi), %rax
movq %rax, 0x60(%rsp)
testq %rax, %rax
je 0x510307
movl 0x8(%rdi), %ecx
testl %ecx, %ecx
jle 0x51030e
cmpq $0x0, 0x68(%rsp)
je 0x510315
movl %edx, %r10d
testl %edx, %edx
jle 0x51031c
cmpl $0x0, 0x8(%rsp)
js 0x510323
testl %r8d, %r8d
js 0x51032a
movl %r9d, %ebx
movl %r8d, 0x28(%rsp)
leal -0x1(%rcx), %eax
movq %rcx, 0xf8(%rsp)
leaq 0xf(%rcx), %rbp
movq %rbp, %r15
shrq $0x4, %r15
movl %eax, 0x4c(%rsp)
xorl %edx, %edx
divl %r15d
movl %eax, 0x10(%rsp)
movl %edx, 0x30(%rsp)
movl 0x8(%rsp), %ecx
movl %ecx, %esi
negl %esi
movq 0x60(%rsp), %rdx
movl 0x20(%rdx), %eax
movl %eax, %r13d
negl %r13d
movl %esi, 0x14(%rsp)
cmpl %esi, %eax
cmovgl %ecx, %r13d
movw $0x7ffe, %ax            # imm = 0x7FFE
subw 0x1c(%rdx), %ax
movl %eax, 0xc0(%rsp)
andl $0x7ffffff0, %ebp       # imm = 0x7FFFFFF0
movl %ebp, %edi
movl %r10d, %esi
movq %r10, 0x18(%rsp)
callq 0x20abc2
testq %rax, %rax
je 0x51032f
movq %rax, %r12
movq %rbp, 0xf0(%rsp)
movl %r13d, 0xc(%rsp)
xorl %eax, %eax
testl %ebx, %ebx
setne %al
xorl %ecx, %ecx
cmpl $0x0, 0x260(%rsp)
setne %cl
shll $0x4, %ecx
xorl %edx, %edx
cmpl $0x0, 0x268(%rsp)
setne %dl
shll $0xe, %edx
xorl %esi, %esi
cmpl $0x0, 0x270(%rsp)
setne %sil
shll $0xf, %esi
leal (%rcx,%rax,8), %eax
orl %edx, %eax
orl %esi, %eax
orl 0xc(%r12), %eax
orl $0x10220802, %eax       # imm = 0x10220802
movl %eax, 0xc(%r12)
movl $0x20, %edi
movq %r15, %rsi
callq 0x4f1904
movq %rax, %r14
movl $0x20, %edi
movq %r15, %rsi
callq 0x4f1904
movq %rax, %r13
movl $0x20, %edi
movq %r15, %rsi
callq 0x4f1904
movq %rax, %rbp
movq 0x18(%rsp), %rax
leal 0x1(%rax), %esi
movl $0x20, %edi
callq 0x20a625
movq %rax, %r9
testq %r14, %r14
sete %al
testq %r13, %r13
sete %cl
orb %al, %cl
testq %rbp, %rbp
sete %al
testq %r9, %r9
sete %dl
orb %al, %dl
orb %cl, %dl
jne 0x51032f
movq %r14, %r10
movq %r13, %rsi
movq 0x18(%rsp), %rax
movq %rax, %r13
decl %eax
movl %eax, 0x4(%rsp)
movl $0xf, %r14d
movl 0x10(%rsp), %eax
subl %eax, %r14d
movl 0x8(%rsp), %ecx
vmovd %ecx, %xmm0
vpbroadcastw %xmm0, %ymm2
movl 0x28(%rsp), %r11d
vmovd %r11d, %xmm0
vpbroadcastw %xmm0, %ymm3
movl 0xc(%rsp), %edi
addl $0xffff8001, %edi       # imm = 0xFFFF8001
vmovd %edi, %xmm0
vpbroadcastw %xmm0, %ymm0
vmovdqu %ymm0, 0x200(%rsp)
vmovd 0xc0(%rsp), %xmm0
vpbroadcastw %xmm0, %ymm0
vmovdqu %ymm0, 0x1e0(%rsp)
vmovd %r14d, %xmm0
vpbroadcastw %xmm0, %ymm0
vmovdqu %ymm0, 0x180(%rsp)
testl %ebx, %ebx
setne %al
movl %ecx, %ecx
movl %r15d, %r8d
movl %r11d, %edx
vmovq %rdx, %xmm0
movslq 0x14(%rsp), %rdx
vpbroadcastq %xmm0, %ymm0
vmovq %rdx, %xmm1
vpbroadcastq %xmm1, %ymm1
vmovq %rcx, %xmm4
vpbroadcastq %xmm4, %ymm4
movq %r8, 0x110(%rsp)
vmovq %r8, %xmm5
vpbroadcastq %xmm5, %ymm8
vpmuldq 0x11e9a5(%rip), %ymm8, %ymm5 # 0x62dde0
vmovdqu %ymm5, 0xc0(%rsp)
vpmuldq 0x11e9b3(%rip), %ymm8, %ymm5 # 0x62de00
vmovdqu %ymm5, 0x160(%rsp)
vpmuldq 0x11e7e1(%rip), %ymm8, %ymm5 # 0x62dc40
vmovdqu %ymm5, 0x140(%rsp)
vpmuldq 0x11e6cf(%rip), %ymm8, %ymm5 # 0x62db40
vmovdqu %ymm5, 0x120(%rsp)
vmovd %eax, %xmm9
vpbroadcastb %xmm9, %xmm6
vpshufb 0x11a674(%rip), %xmm6, %xmm10 # 0x629b00
xorl %eax, %eax
vpslld $0x1f, %xmm10, %xmm10
vpsrad $0x1f, %xmm10, %xmm10
vpmovsxdq %xmm10, %ymm5
vmovdqu %ymm5, 0x1c0(%rsp)
vpshufb 0x11a73f(%rip), %xmm6, %xmm11 # 0x629bf0
vpslld $0x1f, %xmm11, %xmm11
vpsrad $0x1f, %xmm11, %xmm11
vpmovsxdq %xmm11, %ymm5
vmovdqu %ymm5, 0x1a0(%rsp)
vmovdqa %xmm6, 0xb0(%rsp)
vpshufb 0x11a723(%rip), %xmm6, %xmm12 # 0x629c00
vpslld $0x1f, %xmm12, %xmm12
vpsrad $0x1f, %xmm12, %xmm12
vpmovsxdq %xmm12, %ymm12
movq %r10, 0x40(%rsp)
movq %rbp, 0x58(%rsp)
vpbroadcastq 0x11e93f(%rip), %ymm13 # 0x62de40
vpxor %xmm14, %xmm14, %xmm14
vmovdqu 0x1a0(%rsp), %ymm9
vmovq %rax, %xmm15
vpbroadcastq %xmm15, %ymm15
vpaddq 0xc0(%rsp), %ymm15, %ymm5
vpaddq 0x160(%rsp), %ymm15, %ymm6
vpaddq 0x120(%rsp), %ymm15, %ymm7
vpaddq 0x140(%rsp), %ymm15, %ymm15
vpmuludq %ymm0, %ymm15, %ymm8
vpsrlq $0x20, %ymm15, %ymm15
vpmuludq %ymm0, %ymm15, %ymm15
vpsllq $0x20, %ymm15, %ymm15
vpaddq %ymm15, %ymm8, %ymm8
vpmuludq %ymm0, %ymm7, %ymm15
vpsrlq $0x20, %ymm7, %ymm7
vpmuludq %ymm0, %ymm7, %ymm7
vpsllq $0x20, %ymm7, %ymm7
vpaddq %ymm7, %ymm15, %ymm7
vpmuludq %ymm0, %ymm6, %ymm15
vpsrlq $0x20, %ymm6, %ymm6
vpmuludq %ymm0, %ymm6, %ymm6
vpsllq $0x20, %ymm6, %ymm6
vpaddq %ymm6, %ymm15, %ymm6
vpmuludq %ymm0, %ymm5, %ymm15
vpsrlq $0x20, %ymm5, %ymm5
vpmuludq %ymm0, %ymm5, %ymm5
vpsllq $0x20, %ymm5, %ymm5
vpaddq %ymm5, %ymm15, %ymm5
vpsubq %ymm5, %ymm1, %ymm5
vpandn %ymm5, %ymm12, %ymm15
vpsubq %ymm6, %ymm1, %ymm5
vpsubq %ymm7, %ymm1, %ymm6
vpsubq %ymm8, %ymm1, %ymm7
vpmovzxbd 0xb0(%rsp), %xmm8
vpslld $0x1f, %xmm8, %xmm8
vpsrad $0x1f, %xmm8, %xmm8
vpmovsxdq %xmm8, %ymm8
vpcmpgtq %ymm13, %ymm15, %ymm10
vblendvpd %ymm10, %ymm15, %ymm13, %ymm10
vpandn %ymm6, %ymm8, %ymm6
vpcmpgtq %ymm13, %ymm6, %ymm8
vblendvpd %ymm8, %ymm6, %ymm13, %ymm8
vmovdqu 0x1c0(%rsp), %ymm11
vpandn %ymm7, %ymm11, %ymm7
vpcmpgtq %ymm13, %ymm7, %ymm11
vblendvpd %ymm11, %ymm7, %ymm13, %ymm11
vpandn %ymm5, %ymm9, %ymm5
vpblendw $0x11, %ymm11, %ymm14, %ymm11 # ymm11 = ymm11[0],ymm14[1,2,3],ymm11[4],ymm14[5,6,7],ymm11[8],ymm14[9,10,11],ymm11[12],ymm14[13,14,15]
vpblendw $0x11, %ymm8, %ymm14, %ymm8 # ymm8 = ymm8[0],ymm14[1,2,3],ymm8[4],ymm14[5,6,7],ymm8[8],ymm14[9,10,11],ymm8[12],ymm14[13,14,15]
vpackusdw %ymm11, %ymm8, %ymm8
vpcmpgtq %ymm13, %ymm5, %ymm11
vblendvpd %ymm11, %ymm5, %ymm13, %ymm11
vpblendw $0x11, %ymm11, %ymm14, %ymm11 # ymm11 = ymm11[0],ymm14[1,2,3],ymm11[4],ymm14[5,6,7],ymm11[8],ymm14[9,10,11],ymm11[12],ymm14[13,14,15]
vpblendw $0x11, %ymm10, %ymm14, %ymm10 # ymm10 = ymm10[0],ymm14[1,2,3],ymm10[4],ymm14[5,6,7],ymm10[8],ymm14[9,10,11],ymm10[12],ymm14[13,14,15]
vpackusdw %ymm10, %ymm11, %ymm10
vpsubq %ymm4, %ymm7, %ymm7
vpsubq %ymm4, %ymm6, %ymm6
vpsubq %ymm4, %ymm15, %ymm11
vpcmpgtq %ymm13, %ymm11, %ymm15
vblendvpd %ymm15, %ymm11, %ymm13, %ymm11
vpsubq %ymm4, %ymm5, %ymm5
vpcmpgtq %ymm13, %ymm5, %ymm15
vblendvpd %ymm15, %ymm5, %ymm13, %ymm5
vpcmpgtq %ymm13, %ymm6, %ymm15
vblendvpd %ymm15, %ymm6, %ymm13, %ymm6
vpcmpgtq %ymm13, %ymm7, %ymm15
vblendvpd %ymm15, %ymm7, %ymm13, %ymm7
vpermq $0xd8, %ymm8, %ymm8     # ymm8 = ymm8[0,2,1,3]
vpermq $0xd8, %ymm10, %ymm10   # ymm10 = ymm10[0,2,1,3]
vpackusdw %ymm10, %ymm8, %ymm8
vpblendw $0x11, %ymm7, %ymm14, %ymm7 # ymm7 = ymm7[0],ymm14[1,2,3],ymm7[4],ymm14[5,6,7],ymm7[8],ymm14[9,10,11],ymm7[12],ymm14[13,14,15]
vpblendw $0x11, %ymm6, %ymm14, %ymm6 # ymm6 = ymm6[0],ymm14[1,2,3],ymm6[4],ymm14[5,6,7],ymm6[8],ymm14[9,10,11],ymm6[12],ymm14[13,14,15]
vpackusdw %ymm7, %ymm6, %ymm6
vpblendw $0x11, %ymm5, %ymm14, %ymm5 # ymm5 = ymm5[0],ymm14[1,2,3],ymm5[4],ymm14[5,6,7],ymm5[8],ymm14[9,10,11],ymm5[12],ymm14[13,14,15]
vpblendw $0x11, %ymm11, %ymm14, %ymm7 # ymm7 = ymm11[0],ymm14[1,2,3],ymm11[4],ymm14[5,6,7],ymm11[8],ymm14[9,10,11],ymm11[12],ymm14[13,14,15]
vpackusdw %ymm7, %ymm5, %ymm5
vpermq $0xd8, %ymm8, %ymm7     # ymm7 = ymm8[0,2,1,3]
vmovdqa %ymm7, (%r10)
vpermq $0xd8, %ymm6, %ymm6     # ymm6 = ymm6[0,2,1,3]
vpermq $0xd8, %ymm5, %ymm5     # ymm5 = ymm5[0,2,1,3]
vpackusdw %ymm5, %ymm6, %ymm5
vpermq $0xd8, %ymm5, %ymm5     # ymm5 = ymm5[0,2,1,3]
vmovdqa %ymm5, (%rbp)
incq %rax
addq $0x20, %rbp
addq $0x20, %r10
cmpq %rax, %r15
jne 0x50f50f
movw $0x0, (%r9)
movq %r13, %r10
movl %r10d, %eax
addl $0xf, %r10d
andl $-0x10, %r10d
movq %rax, 0x50(%rsp)
decq %rax
vmovq %rax, %xmm0
vpbroadcastq %xmm0, %ymm5
vmovd %r11d, %xmm0
vpbroadcastd %xmm0, %ymm0
vmovdqu %ymm0, 0x160(%rsp)
vmovss 0x14(%rsp), %xmm0
vbroadcastss %xmm0, %ymm0
vmovups %ymm0, 0x140(%rsp)
vpmovsxbd 0x11e71d(%rip), %ymm8 # 0x62de48
vpmovsxbd 0x11e59c(%rip), %ymm9 # 0x62dcd0
xorl %eax, %eax
vpbroadcastq 0x11e441(%rip), %xmm14 # 0x62db80
vpcmpeqd %xmm15, %xmm15, %xmm15
vpcmpeqd %ymm1, %ymm1, %ymm1
vbroadcastss 0x11e6ff(%rip), %ymm0 # 0x62de50
vmovups %ymm0, 0x120(%rsp)
vpbroadcastq 0x11e41d(%rip), %ymm0 # 0x62db80
vpbroadcastd 0x11e454(%rip), %xmm4 # 0x62dbc0
vmovdqu %ymm4, 0xc0(%rsp)
vpbroadcastd 0x11e6d6(%rip), %ymm11 # 0x62de54
movq %rsi, %rbp
movl 0x268(%rsp), %edx
vpxor %xmm6, %xmm6, %xmm6
testl %edx, %edx
jne 0x50f7e7
vpaddd %ymm1, %ymm9, %ymm7
vpaddd %ymm1, %ymm8, %ymm12
vmovdqu 0x160(%rsp), %ymm4
vpmulld %ymm4, %ymm12, %ymm12
vpmulld %ymm4, %ymm7, %ymm7
vmovdqu 0x140(%rsp), %ymm4
vpsubd %ymm7, %ymm4, %ymm7
vpsubd %ymm12, %ymm4, %ymm12
vmovdqu 0x120(%rsp), %ymm4
vpmaxsd %ymm4, %ymm12, %ymm12
vpmaxsd %ymm4, %ymm7, %ymm7
vpblendw $0xaa, %ymm6, %ymm7, %ymm7 # ymm7 = ymm7[0],ymm6[1],ymm7[2],ymm6[3],ymm7[4],ymm6[5],ymm7[6],ymm6[7],ymm7[8],ymm6[9],ymm7[10],ymm6[11],ymm7[12],ymm6[13],ymm7[14],ymm6[15]
vpblendw $0xaa, %ymm6, %ymm12, %ymm6 # ymm6 = ymm12[0],ymm6[1],ymm12[2],ymm6[3],ymm12[4],ymm6[5],ymm12[6],ymm6[7],ymm12[8],ymm6[9],ymm12[10],ymm6[11],ymm12[12],ymm6[13],ymm12[14],ymm6[15]
vpackusdw %ymm6, %ymm7, %ymm6
vpermq $0xd8, %ymm6, %ymm6     # ymm6 = ymm6[0,2,1,3]
vmovq %rax, %xmm7
vpbroadcastq %xmm7, %ymm13
vpor 0x11e347(%rip), %ymm13, %ymm7 # 0x62db40
vpxor %xmm5, %xmm14, %xmm12
vpxor %xmm7, %xmm14, %xmm4
vpcmpgtq %xmm12, %xmm4, %xmm4
vpackssdw %xmm4, %xmm4, %xmm4
vpxor %xmm4, %xmm15, %xmm4
vpackssdw %xmm4, %xmm4, %xmm4
vpacksswb %xmm4, %xmm4, %xmm4
vmovd %xmm4, %ecx
testb $0x1, %cl
je 0x50f827
vpextrw $0x0, %xmm6, 0x2(%r9,%rax,2)
vpxor %xmm5, %xmm14, %xmm4
vpxor %xmm7, %xmm14, %xmm12
vpcmpgtq %xmm4, %xmm12, %xmm4
vpackssdw %xmm4, %xmm4, %xmm4
vpxor %xmm4, %xmm15, %xmm4
vpackssdw %xmm4, %xmm4, %xmm4
vpacksswb %xmm4, %xmm4, %xmm4
vpextrb $0x1, %xmm4, %ecx
testb $0x1, %cl
je 0x50f857
vpextrw $0x1, %xmm6, 0x4(%r9,%rax,2)
vpxor %ymm0, %ymm5, %ymm12
vpxor %ymm0, %ymm7, %ymm4
vpcmpgtq %ymm12, %ymm4, %ymm7
vpshuflw $0xe8, %ymm7, %ymm4     # ymm4 = ymm7[0,2,2,3,4,5,6,7,8,10,10,11,12,13,14,15]
vpxor %ymm1, %ymm4, %ymm4
vmovdqu 0xc0(%rsp), %ymm10
vpermd %ymm4, %ymm10, %ymm4
vpackssdw %xmm4, %xmm4, %xmm4
vpacksswb %xmm4, %xmm4, %xmm4
vpextrb $0x2, %xmm4, %ecx
testb $0x1, %cl
je 0x50f896
vpextrw $0x2, %xmm6, 0x6(%r9,%rax,2)
vextracti128 $0x1, %ymm7, %xmm4
vpackssdw %xmm4, %xmm4, %xmm4
vpxor %xmm4, %xmm15, %xmm4
vpackssdw %xmm4, %xmm4, %xmm4
vpacksswb %xmm4, %xmm4, %xmm4
vpextrb $0x3, %xmm4, %ecx
testb $0x1, %cl
je 0x50f8bf
vpextrw $0x3, %xmm6, 0x8(%r9,%rax,2)
vpor 0x11e379(%rip), %ymm13, %ymm7 # 0x62dc40
vpxor %xmm5, %xmm14, %xmm4
vpxor %xmm7, %xmm14, %xmm10
vpcmpgtq %xmm4, %xmm10, %xmm4
vpackssdw %xmm4, %xmm4, %xmm4
vpxor %xmm4, %xmm15, %xmm4
vpermq $0x55, %ymm4, %ymm4     # ymm4 = ymm4[1,1,1,1]
vpackssdw %ymm0, %ymm4, %ymm4
vextracti128 $0x1, %ymm4, %xmm4
vpacksswb %xmm4, %xmm4, %xmm4
vpextrb $0x8, %xmm4, %ecx
testb $0x1, %cl
je 0x50f903
vpextrw $0x4, %xmm6, 0xa(%r9,%rax,2)
vpxor %xmm5, %xmm14, %xmm4
vpxor %xmm7, %xmm14, %xmm10
vpcmpgtq %xmm4, %xmm10, %xmm4
vpshufhw $0x84, %xmm4, %xmm4     # xmm4 = xmm4[0,1,2,3,4,5,4,6]
vpxor %xmm4, %xmm15, %xmm4
vpermq $0x55, %ymm4, %ymm4     # ymm4 = ymm4[1,1,1,1]
vpackssdw %ymm0, %ymm4, %ymm4
vextracti128 $0x1, %ymm4, %xmm4
vpacksswb %xmm4, %xmm4, %xmm4
vpextrb $0x9, %xmm4, %ecx
testb $0x1, %cl
je 0x50f940
vpextrw $0x5, %xmm6, 0xc(%r9,%rax,2)
vpxor %ymm0, %ymm7, %ymm4
vpcmpgtq %ymm12, %ymm4, %ymm7
vpackssdw %ymm7, %ymm0, %ymm4
vpxor %ymm1, %ymm4, %ymm4
vpackssdw %ymm0, %ymm4, %ymm4
vextracti128 $0x1, %ymm4, %xmm4
vpacksswb %xmm4, %xmm4, %xmm4
vpextrb $0xa, %xmm4, %ecx
testb $0x1, %cl
je 0x50f972
vpextrw $0x6, %xmm6, 0xe(%r9,%rax,2)
vpackssdw %ymm7, %ymm0, %ymm4
vpxor %ymm1, %ymm4, %ymm4
vpackssdw %ymm0, %ymm4, %ymm4
vextracti128 $0x1, %ymm4, %xmm4
vpacksswb %xmm4, %xmm4, %xmm4
vpextrb $0xb, %xmm4, %ecx
testb $0x1, %cl
je 0x50f99b
vpextrw $0x7, %xmm6, 0x10(%r9,%rax,2)
vpor 0x11e45d(%rip), %ymm13, %ymm7 # 0x62de00
vpxor %xmm5, %xmm14, %xmm4
vpxor %xmm7, %xmm14, %xmm10
vpcmpgtq %xmm4, %xmm10, %xmm4
vpackssdw %xmm4, %xmm4, %xmm4
vpxor %xmm4, %xmm15, %xmm4
vpackssdw %xmm4, %xmm4, %xmm4
vpacksswb %xmm4, %xmm4, %xmm4
vpextrb $0x4, %xmm4, %ecx
vextracti128 $0x1, %ymm6, %xmm6
testb $0x1, %cl
je 0x50f9d9
vpextrw $0x0, %xmm6, 0x12(%r9,%rax,2)
vpxor %xmm5, %xmm14, %xmm4
vpxor %xmm7, %xmm14, %xmm10
vpcmpgtq %xmm4, %xmm10, %xmm4
vpackssdw %xmm4, %xmm4, %xmm4
vpxor %xmm4, %xmm15, %xmm4
vpackssdw %xmm4, %xmm4, %xmm4
vpacksswb %xmm4, %xmm4, %xmm4
vpextrb $0x5, %xmm4, %ecx
testb $0x1, %cl
je 0x50fa09
vpextrw $0x1, %xmm6, 0x14(%r9,%rax,2)
vpxor %ymm0, %ymm7, %ymm4
vpcmpgtq %ymm12, %ymm4, %ymm7
vpshuflw $0xe8, %ymm7, %ymm4     # ymm4 = ymm7[0,2,2,3,4,5,6,7,8,10,10,11,12,13,14,15]
vpxor %ymm1, %ymm4, %ymm4
vmovdqu 0xc0(%rsp), %ymm10
vpermd %ymm4, %ymm10, %ymm4
vpackssdw %xmm4, %xmm4, %xmm4
vpacksswb %xmm4, %xmm4, %xmm4
vpextrb $0x6, %xmm4, %ecx
testb $0x1, %cl
je 0x50fa44
vpextrw $0x2, %xmm6, 0x16(%r9,%rax,2)
vextracti128 $0x1, %ymm7, %xmm4
vpackssdw %xmm4, %xmm4, %xmm4
vpxor %xmm4, %xmm15, %xmm4
vpackssdw %xmm4, %xmm4, %xmm4
vpacksswb %xmm4, %xmm4, %xmm4
vpextrb $0x7, %xmm4, %ecx
testb $0x1, %cl
je 0x50fa6d
vpextrw $0x3, %xmm6, 0x18(%r9,%rax,2)
vpor 0x11e36b(%rip), %ymm13, %ymm7 # 0x62dde0
vpxor %xmm5, %xmm14, %xmm4
vpxor %xmm7, %xmm14, %xmm10
vpcmpgtq %xmm4, %xmm10, %xmm4
vpackssdw %xmm4, %xmm4, %xmm4
vpxor %xmm4, %xmm15, %xmm4
vpermq $0x55, %ymm4, %ymm4     # ymm4 = ymm4[1,1,1,1]
vpackssdw %ymm4, %ymm0, %ymm4
vextracti128 $0x1, %ymm4, %xmm4
vpacksswb %xmm4, %xmm4, %xmm4
vpextrb $0xc, %xmm4, %ecx
testb $0x1, %cl
je 0x50fab1
vpextrw $0x4, %xmm6, 0x1a(%r9,%rax,2)
vpxor %xmm5, %xmm14, %xmm4
vpxor %xmm7, %xmm14, %xmm10
vpcmpgtq %xmm4, %xmm10, %xmm4
vpshufhw $0x84, %xmm4, %xmm4     # xmm4 = xmm4[0,1,2,3,4,5,4,6]
vpxor %xmm4, %xmm15, %xmm4
vpermq $0x55, %ymm4, %ymm4     # ymm4 = ymm4[1,1,1,1]
vpackssdw %ymm4, %ymm0, %ymm4
vextracti128 $0x1, %ymm4, %xmm4
vpacksswb %xmm4, %xmm4, %xmm4
vpextrb $0xd, %xmm4, %ecx
testb $0x1, %cl
je 0x50faee
vpextrw $0x5, %xmm6, 0x1c(%r9,%rax,2)
vpxor %ymm0, %ymm7, %ymm4
vpcmpgtq %ymm12, %ymm4, %ymm7
vpackssdw %ymm7, %ymm0, %ymm4
vpxor %ymm1, %ymm4, %ymm4
vpackssdw %ymm4, %ymm0, %ymm4
vextracti128 $0x1, %ymm4, %xmm4
vpacksswb %xmm4, %xmm4, %xmm4
vpextrb $0xe, %xmm4, %ecx
testb $0x1, %cl
je 0x50fb20
vpextrw $0x6, %xmm6, 0x1e(%r9,%rax,2)
vpackssdw %ymm7, %ymm0, %ymm4
vpxor %ymm1, %ymm4, %ymm4
vpackssdw %ymm4, %ymm0, %ymm4
vextracti128 $0x1, %ymm4, %xmm4
vpacksswb %xmm4, %xmm4, %xmm4
vpextrb $0xf, %xmm4, %ecx
testb $0x1, %cl
je 0x50fb49
vpextrw $0x7, %xmm6, 0x20(%r9,%rax,2)
addq $0x10, %rax
vpaddd %ymm11, %ymm9, %ymm9
vpaddd %ymm11, %ymm8, %ymm8
cmpq %rax, %r10
jne 0x50f788
movl %r14d, 0x24(%rsp)
movl %edi, 0xc(%rsp)
leal -0x1(%r15), %esi
movl 0x30(%rsp), %edx
movq %r15, %rax
movq 0x50(%rsp), %rcx
imulq %rcx, %rax
leaq (,%rax,4), %rdi
leaq (,%rcx,4), %r14
leaq (,%rax,8), %r10
leaq (%rdi,%rdi,2), %r13
leaq (%rax,%rax,8), %rcx
leaq (%rcx,%rcx,2), %rcx
addq %rax, %rcx
movq %rcx, 0x160(%rsp)
movq %rax, %r11
imulq $0x2c, %rax, %rcx
imulq $0x34, %rax, %rbx
movq %rbx, 0x140(%rsp)
imulq $0x38, %rax, %rbx
movq %rbx, 0x120(%rsp)
imulq $0x3c, %rax, %rbx
movq %rbx, 0x1c0(%rsp)
movq %rax, %rbx
shlq $0x4, %rbx
shlq $0x5, %r11
movq %r15, 0xe8(%rsp)
shlq $0x5, %r15
shlq $0x5, %rsi
movq %rsi, 0x108(%rsp)
vmovdqu 0x180(%rsp), %ymm0
vpcmpeqw 0x11e255(%rip), %ymm0, %ymm7 # 0x62de60
movq %rdx, 0xe0(%rsp)
shlq $0x5, %rdx
movq %rdx, 0x100(%rsp)
vmovdqu 0x200(%rsp), %ymm10
vmovdqa %ymm10, %ymm6
vmovdqa %ymm10, %ymm4
vmovdqu 0x1e0(%rsp), %ymm11
vmovdqa %ymm11, %ymm5
leaq (%rdi,%rdi,4), %rdx
movq %rdx, 0xa0(%rsp)
leaq (%r10,%r10,2), %rdx
movq %rdx, 0x98(%rsp)
movq %rdi, 0xc0(%rsp)
leaq (%rdi,%rdi,8), %rdx
movq %rdx, 0x90(%rsp)
leaq (%r10,%r10,4), %rdx
movq %rdx, 0x88(%rsp)
movq %rbx, 0x180(%rsp)
leaq (%rbx,%rbx,2), %rdx
movq %rdx, 0x80(%rsp)
xorl %edi, %edi
xorl %esi, %esi
movl 0x4(%rsp), %edx
movl %edx, (%rsp)
movq 0x40(%rsp), %rdx
movq %r9, 0x38(%rsp)
movq %r13, 0x1a0(%rsp)
movq %rcx, 0xb0(%rsp)
movq %r10, 0x18(%rsp)
movq %r11, 0x30(%rsp)
movq %r14, 0x28(%rsp)
movq %r15, 0xa8(%rsp)
movq %rbp, %r10
movq %rdx, %rbp
movq 0x108(%rsp), %rdx
vmovdqa (%rbp,%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]
movq 0x60(%rsp), %rdx
movq 0x10(%rdx), %rdx
movq %rsi, %rbx
movq 0x68(%rsp), %rsi
movzbl (%rsi,%rbx), %esi
movslq (%rdx,%rsi,4), %rsi
movq 0x110(%rsp), %rdx
imulq %rsi, %rdx
shlq $0x5, %rdx
addq 0x118(%rsp), %rdx
movq %rdx, 0x40(%rsp)
movq %rbx, 0x70(%rsp)
vpinsrw $0x0, (%r9,%rbx,2), %xmm0, %xmm1
vpblendd $0xf, %ymm1, %ymm0, %ymm1 # ymm1 = ymm1[0,1,2,3],ymm0[4,5,6,7]
movq %rdi, 0x78(%rsp)
movq %rdi, %rsi
xorl %edi, %edi
vmovdqa %ymm10, %ymm0
movq 0x58(%rsp), %r15
movq 0x180(%rsp), %r8
movq 0xa0(%rsp), %r14
movq 0x98(%rsp), %r11
movq 0x90(%rsp), %rax
movq 0x88(%rsp), %r13
movq 0x80(%rsp), %rdx
movq 0x40(%rsp), %r9
vpaddsw (%r9,%rdi), %ymm1, %ymm8
vmovdqa (%r15,%rdi), %ymm1
vpmaxsw %ymm0, %ymm1, %ymm9
vpmaxsw %ymm9, %ymm8, %ymm8
vmovdqa %ymm8, (%r10,%rdi)
movq %rbp, %r9
movq %r12, %rbp
movq 0x10(%r12), %r12
movq (%r12), %r12
movq %r10, %rbx
vmovd %xmm8, %r10d
movswl %r10w, %r10d
movl %r10d, (%r12,%rsi)
addq %rsi, %r12
vpextrw $0x1, %xmm8, %r10d
movswl %r10w, %r10d
movq 0xc0(%rsp), %rcx
movl %r10d, (%rcx,%r12)
vpextrw $0x2, %xmm8, %r10d
movswl %r10w, %r10d
movq 0x18(%rsp), %rcx
movl %r10d, (%rcx,%r12)
vpextrw $0x3, %xmm8, %r10d
movswl %r10w, %r10d
movq 0x1a0(%rsp), %rcx
movl %r10d, (%rcx,%r12)
vpextrw $0x4, %xmm8, %r10d
movswl %r10w, %r10d
movl %r10d, (%r8,%r12)
vpextrw $0x5, %xmm8, %r10d
movswl %r10w, %r10d
movl %r10d, (%r14,%r12)
vpextrw $0x6, %xmm8, %r10d
movswl %r10w, %r10d
movl %r10d, (%r11,%r12)
vpextrw $0x7, %xmm8, %r10d
movswl %r10w, %r10d
movq 0x160(%rsp), %rcx
movl %r10d, (%rcx,%r12)
vextracti128 $0x1, %ymm8, %xmm9
vmovd %xmm9, %r10d
movswl %r10w, %r10d
movq 0x30(%rsp), %rcx
movl %r10d, (%rcx,%r12)
vpextrw $0x1, %xmm9, %r10d
movswl %r10w, %r10d
movl %r10d, (%rax,%r12)
vpextrw $0x2, %xmm9, %r10d
movswl %r10w, %r10d
movl %r10d, (%r13,%r12)
vpextrw $0x3, %xmm9, %r10d
movswl %r10w, %r10d
movq 0xb0(%rsp), %rcx
movl %r10d, (%rcx,%r12)
vpextrw $0x4, %xmm9, %r10d
movswl %r10w, %r10d
movl %r10d, (%rdx,%r12)
vpextrw $0x5, %xmm9, %r10d
movswl %r10w, %r10d
movq 0x140(%rsp), %rcx
movl %r10d, (%rcx,%r12)
vpextrw $0x6, %xmm9, %r10d
movswl %r10w, %r10d
movq 0x120(%rsp), %rcx
movl %r10d, (%rcx,%r12)
vpextrw $0x7, %xmm9, %r10d
movswl %r10w, %r10d
movq 0x1c0(%rsp), %rcx
movl %r10d, (%rcx,%r12)
movq %rbx, %r10
movq %rbp, %r12
movq %r9, %rbp
vpmaxsw %ymm4, %ymm8, %ymm4
vpminsw %ymm1, %ymm5, %ymm5
vpminsw %ymm0, %ymm5, %ymm5
vpminsw %ymm5, %ymm8, %ymm5
vpsubsw %ymm2, %ymm8, %ymm8
vpsubsw %ymm3, %ymm1, %ymm1
vpmaxsw %ymm1, %ymm8, %ymm1
vmovdqa %ymm1, (%r15,%rdi)
vpsubsw %ymm3, %ymm0, %ymm0
vpmaxsw %ymm0, %ymm8, %ymm0
vmovdqa (%r9,%rdi), %ymm1
addq $0x20, %rdi
addq 0x28(%rsp), %rsi
cmpq %rdi, 0xa8(%rsp)
jne 0x50fd70
xorl %r9d, %r9d
movq 0x28(%rsp), %r14
movq 0x18(%rsp), %rax
movq 0x1a0(%rsp), %r13
movq 0x30(%rsp), %r11
movq 0xb0(%rsp), %rcx
movq 0xa8(%rsp), %r15
movl 0x14(%rsp), %edx
cmpl $0x0, 0x268(%rsp)
jne 0x50ff67
movq 0x70(%rsp), %rdx
movq 0x38(%rsp), %rsi
movswl 0x2(%rsi,%rdx,2), %edx
subl 0x8(%rsp), %edx
cmpl $0xffff8001, %edx       # imm = 0xFFFF8001
movl $0xffff8000, %esi       # imm = 0xFFFF8000
cmovll %esi, %edx
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, %edx, %xmm0, %xmm1
vpblendd $0xf, %ymm1, %ymm0, %ymm0 # ymm0 = ymm1[0,1,2,3],ymm0[4,5,6,7]
movq 0x78(%rsp), %rdx
xorl %esi, %esi
vpmaxsw (%r10,%rsi), %ymm0, %ymm1
vmovdqa %ymm1, (%r10,%rsi)
movq 0x10(%r12), %rdi
movq (%rdi), %rdi
vmovd %xmm1, %r10d
movswl %r10w, %r10d
movl %r10d, (%rdi,%rdx)
addq %rdx, %rdi
vpextrw $0x1, %xmm1, %r10d
movswl %r10w, %r10d
movq %r13, %r8
movq %rax, %r13
movq %r14, %rax
movq 0xc0(%rsp), %r14
movl %r10d, (%r14,%rdi)
movq %rax, %r14
movq %r13, %rax
movq %r8, %r13
vpextrw $0x2, %xmm1, %r10d
movswl %r10w, %r10d
movl %r10d, (%rax,%rdi)
vpextrw $0x3, %xmm1, %r10d
movswl %r10w, %r10d
movl %r10d, (%r8,%rdi)
vpextrw $0x4, %xmm1, %r10d
movswl %r10w, %r10d
movq 0x180(%rsp), %r8
movl %r10d, (%r8,%rdi)
vpextrw $0x5, %xmm1, %r10d
movswl %r10w, %r10d
movq 0xa0(%rsp), %r8
movl %r10d, (%r8,%rdi)
vpextrw $0x6, %xmm1, %r10d
movswl %r10w, %r10d
movq 0x98(%rsp), %r8
movl %r10d, (%r8,%rdi)
vpextrw $0x7, %xmm1, %r10d
movswl %r10w, %r10d
movq 0x160(%rsp), %r8
movl %r10d, (%r8,%rdi)
vextracti128 $0x1, %ymm1, %xmm8
vmovd %xmm8, %r10d
movswl %r10w, %r10d
movl %r10d, (%r11,%rdi)
vpextrw $0x1, %xmm8, %r10d
movswl %r10w, %r10d
movq 0x90(%rsp), %r8
movl %r10d, (%r8,%rdi)
vpextrw $0x2, %xmm8, %r10d
movswl %r10w, %r10d
movq 0x88(%rsp), %r8
movl %r10d, (%r8,%rdi)
vpextrw $0x3, %xmm8, %r10d
movswl %r10w, %r10d
movl %r10d, (%rcx,%rdi)
vpextrw $0x4, %xmm8, %r10d
movswl %r10w, %r10d
movq 0x80(%rsp), %r8
movl %r10d, (%r8,%rdi)
vpextrw $0x5, %xmm8, %r10d
movswl %r10w, %r10d
movq 0x140(%rsp), %r8
movl %r10d, (%r8,%rdi)
vpextrw $0x6, %xmm8, %r10d
movswl %r10w, %r10d
movq 0x120(%rsp), %r8
movl %r10d, (%r8,%rdi)
vpextrw $0x7, %xmm8, %r10d
movswl %r10w, %r10d
movq 0x1c0(%rsp), %r8
movl %r10d, (%r8,%rdi)
movq %rbx, %r10
vpminsw %ymm1, %ymm5, %ymm5
vpmaxsw %ymm1, %ymm4, %ymm4
vpsubsw %ymm2, %ymm1, %ymm1
vpsubsw %ymm3, %ymm0, %ymm0
vpcmpgtw %ymm1, %ymm0, %ymm1
vpmovmskb %ymm1, %edi
testl %edi, %edi
je 0x510131
addq $0x20, %rsi
addq %r14, %rdx
cmpq %rsi, %r15
jne 0x50ff93
movl %r9d, %edx
incl %edx
movl %edx, %r9d
cmpl $0x10, %edx
jne 0x50ff46
movq 0x100(%rsp), %rdx
vmovdqa (%r10,%rdx), %ymm0
vpcmpgtw %ymm6, %ymm0, %ymm1
vpand %ymm7, %ymm1, %ymm1
vpmovmskb %ymm1, %edx
testl %edx, %edx
movl (%rsp), %edx
movq 0x70(%rsp), %rsi
cmovnel %esi, %edx
movl %edx, (%rsp)
vpmaxsw %ymm6, %ymm0, %ymm6
incq %rsi
movq 0x78(%rsp), %rdi
addq $0x4, %rdi
movq %r10, %rdx
cmpq 0x50(%rsp), %rsi
movq 0x38(%rsp), %r9
jne 0x50fcc5
movl 0x270(%rsp), %r15d
testl %r15d, %r15d
movl 0x4c(%rsp), %r8d
movq 0xf8(%rsp), %r9
movl 0x10(%rsp), %edx
movl 0xc(%rsp), %r11d
movq 0xe8(%rsp), %r14
movl 0x260(%rsp), %r10d
je 0x5101d9
cmpl $0xe, %edx
jg 0x5101ce
xorl %eax, %eax
movl 0x24(%rsp), %ecx
vperm2i128 $0x28, %ymm6, %ymm6, %ymm0 # ymm0 = zero,zero,ymm6[0,1]
vpalignr $0xe, %ymm0, %ymm6, %ymm6 # ymm6 = ymm0[14,15],ymm6[0,1,2,3,4,5,6,7,8,9,10,11,12,13],ymm0[30,31],ymm6[16,17,18,19,20,21,22,23,24,25,26,27,28,29]
incl %eax
cmpl %ecx, %eax
jl 0x5101bc
vextracti128 $0x1, %ymm6, %xmm0
vpextrw $0x7, %xmm0, %r11d
testl %r10d, %r10d
je 0x510247
cmpl $0x0, 0xf0(%rsp)
je 0x510247
movl %r14d, %ecx
andl $0x7ffffff, %ecx        # imm = 0x7FFFFFF
shll $0x4, %ecx
xorl %edx, %edx
movl %r8d, %eax
movl %edx, %edi
shrl $0x4, %edi
movl %edx, %esi
andl $0xf, %esi
imull %r14d, %esi
addl %edi, %esi
cmpl %r9d, %esi
jge 0x51023e
movzwl (%rbx,%rdx,2), %edi
cmpw %r11w, %di
jle 0x510226
movl %edi, %r11d
movl 0x4(%rsp), %eax
movl %eax, (%rsp)
movl %esi, %eax
jmp 0x51023e
cmpl %eax, %esi
cmovgel %eax, %esi
movl (%rsp), %r13d
cmpl 0x4(%rsp), %r13d
cmovnel %eax, %esi
cmpw %r11w, %di
cmovel %esi, %eax
incq %rdx
cmpl %edx, %ecx
jne 0x5101f9
jmp 0x51024a
movl %r8d, %eax
orl %r10d, %r15d
movq 0x38(%rsp), %rdi
jne 0x510299
movq 0xe0(%rsp), %rax
shlq $0x5, %rax
vmovdqa (%rbx,%rax), %ymm0
cmpl $0xe, 0x10(%rsp)
jg 0x510284
xorl %eax, %eax
movl 0x24(%rsp), %ecx
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 0x510272
vextracti128 $0x1, %ymm0, %xmm0
vpextrw $0x7, %xmm0, %r11d
movl 0x4(%rsp), %eax
movl %eax, (%rsp)
movl %r8d, %eax
vpcmpgtw %ymm5, %ymm10, %ymm0
vpcmpgtw %ymm11, %ymm4, %ymm1
vpor %ymm0, %ymm1, %ymm0
vpmovmskb %ymm0, %ecx
testl %ecx, %ecx
je 0x5102c0
orb $0x40, 0xc(%r12)
xorl %r11d, %r11d
movl $0x0, (%rsp)
xorl %eax, %eax
movswl %r11w, %ecx
movl %ecx, (%r12)
movl %eax, 0x4(%r12)
movl (%rsp), %eax
movl %eax, 0x8(%r12)
vzeroupper
callq 0x20a60d
movq 0x58(%rsp), %rdi
callq 0x20a60d
movq %rbp, %rdi
callq 0x20a60d
movq %rbx, %rdi
callq 0x20a60d
jmp 0x510332
callq 0x1e9f07
jmp 0x51032f
callq 0x1e9ee1
jmp 0x51032f
callq 0x1e9ebb
jmp 0x51032f
callq 0x1e9e95
jmp 0x51032f
callq 0x1e9e6f
jmp 0x51032f
callq 0x1e9e49
jmp 0x51032f
callq 0x1e9e23
jmp 0x51032f
callq 0x1e9dfd
xorl %r12d, %r12d
movq %r12, %rax
addq $0x228, %rsp            # imm = 0x228
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq