// File: /workspace/github_c_makefile_star2_O3/nh13[P]ksw/src/parasail/src/sg_scan_avx2_256_16.c
// Function: parasail_sg_flags_rowcol_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 end_query = 0;
    int32_t end_ref = 0;
    int32_t s1Len = 0;
    const parasail_matrix_t *matrix = NULL;
    int32_t segWidth = 0;
    int32_t segLen = 0;
    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;

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

    /* 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_SCAN
        | 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 */
    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 vHt;
        __m256i vF;
        __m256i vH;
        __m256i vHp;
        __m256i *pvW;
        __m256i vW;

        /* 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);
            vE = _mm256_max_epi16(
                    _mm256_subs_epi16(vE, vGapE),
                    _mm256_subs_epi16(vH, vGapO));
            vHp = _mm256_adds_epi16(vHp, vW);
            vF = _mm256_max_epi16(vF, _mm256_adds_epi16(vHt, pvGapper[i]));
            vHt = _mm256_max_epi16(vE, vHp);
            _mm256_store_si256(pvE+i, vE);
            _mm256_store_si256(pvHt+i, vHt);
            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);
        vF = _mm256_max_epi16(vF, _mm256_adds_epi16(vHt, pvGapper[0]));
        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(vHt, vF);
        for (i=0; i<segLen; ++i) {
            vHt = _mm256_load_si256(pvHt+i);
            vF = _mm256_max_epi16(
                    _mm256_subs_epi16(vF, vGapE),
                    _mm256_subs_epi16(vH, vGapO));
            vH = _mm256_max_epi16(vHt, vF);
            _mm256_store_si256(pvH+i, vH);
            vSaturationCheckMin = _mm256_min_epi16(vSaturationCheckMin, vH);
            vSaturationCheckMin = _mm256_min_epi16(vSaturationCheckMin, vF);
            vSaturationCheckMax = _mm256_max_epi16(vSaturationCheckMax, vH);
#ifdef PARASAIL_TABLE
            arr_store_si256(result->tables->score_table, vH, i, segLen, j, s2Len);
#endif
        } 

        /* 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;
            }
#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(pvH + 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*)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, 0x28(%rsp)
testq %rdi, %rdi
je 0x55345a
movq 0x30(%rdi), %rax
movq %rax, 0x38(%rsp)
testq %rax, %rax
je 0x553461
movq 0x10(%rdi), %rax
movq %rax, 0x20(%rsp)
testq %rax, %rax
je 0x553468
movl 0x8(%rdi), %eax
testl %eax, %eax
jle 0x55346f
cmpq $0x0, 0x28(%rsp)
je 0x553476
movl %edx, %r13d
testl %edx, %edx
jle 0x55347d
testl %ecx, %ecx
js 0x553484
testl %r8d, %r8d
js 0x55348b
movl %r9d, %r12d
movl %r8d, 0x10(%rsp)
leal -0x1(%rax), %ebp
movq %rax, 0xa8(%rsp)
leaq 0xf(%rax), %r14
movq %r14, %rbx
shrq $0x4, %rbx
movl %ebp, %eax
xorl %edx, %edx
divl %ebx
movl %eax, 0x4(%rsp)
movl %edx, %r15d
movl %ecx, %esi
negl %esi
movq 0x20(%rsp), %rdx
movl 0x20(%rdx), %eax
movl %eax, %edi
negl %edi
movl %esi, 0x30(%rsp)
cmpl %esi, %eax
movl %ecx, 0x50(%rsp)
cmovgl %ecx, %edi
movl %edi, 0xc(%rsp)
movw $0x7ffe, %ax            # imm = 0x7FFE
subw 0x1c(%rdx), %ax
movl %eax, 0x70(%rsp)
andl $0x7ffffff0, %r14d      # imm = 0x7FFFFFF0
movl %r14d, %edi
movl %r13d, %esi
callq 0x20ac53
testq %rax, %rax
je 0x553490
movl %r15d, 0x44(%rsp)
movl %ebp, 0x4c(%rsp)
movq %r14, 0x98(%rsp)
movl 0x240(%rsp), %edi
xorl %r8d, %r8d
testl %r12d, %r12d
setne %r8b
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, 0x48(%rsp)
testl %edi, %edi
setne %sil
shll $0xf, %esi
leal (%rcx,%r8,8), %ecx
orl %edx, %ecx
orl %esi, %ecx
orl 0xc(%rax), %ecx
orl $0x10240402, %ecx       # imm = 0x10240402
movq %rax, 0xa0(%rsp)
movl %ecx, 0xc(%rax)
movl $0x20, %edi
movq %rbx, %rsi
callq 0x4f1904
movq %rax, %r15
leal 0x1(%r13), %esi
movl $0x20, %edi
callq 0x20a625
movl %r12d, 0x18(%rsp)
movq %rax, %r12
movl $0x20, %edi
movq %rbx, %rsi
callq 0x4f1904
movq %rax, %rbp
movl $0x20, %edi
movq %rbx, %rsi
callq 0x4f1904
movq %rax, %r14
movl $0x20, %edi
movq %rbx, %rsi
callq 0x4f1904
testq %r15, %r15
sete %cl
testq %r12, %r12
sete %dl
orb %cl, %dl
testq %rbp, %rbp
sete %cl
testq %r14, %r14
sete %sil
orb %cl, %sil
orb %dl, %sil
testq %rax, %rax
sete %cl
orb %sil, %cl
jne 0x553490
movq %r13, %r11
leal -0x1(%r13), %ecx
movl %ecx, 0x8(%rsp)
movl $0xf, %edx
subl 0x4(%rsp), %edx
movl 0x50(%rsp), %edi
vmovd %edi, %xmm0
vpbroadcastw %xmm0, %ymm2
movl 0x10(%rsp), %r8d
vmovd %r8d, %xmm0
vpbroadcastw %xmm0, %ymm3
movl 0xc(%rsp), %r13d
addl $0xffff8001, %r13d      # imm = 0xFFFF8001
vmovd %r13d, %xmm0
vpbroadcastw %xmm0, %ymm0
vmovdqu %ymm0, 0x1d0(%rsp)
vmovd 0x70(%rsp), %xmm0
vpbroadcastw %xmm0, %ymm0
vmovdqu %ymm0, 0x190(%rsp)
vmovd %edx, %xmm0
vpbroadcastw %xmm0, %ymm0
vmovdqu %ymm0, 0x1b0(%rsp)
movl %r13d, 0xc(%rsp)
movzwl %r13w, %ecx
movl %ebx, %esi
imull %r8d, %esi
negl %esi
vmovd %esi, %xmm0
vpbroadcastw %xmm0, %ymm0
vpand 0xdb6ba(%rip), %ymm0, %ymm0 # 0x62ddc0
vmovd %ecx, %xmm1
vmovdqu %ymm1, 0x170(%rsp)
vpaddsw %ymm0, %ymm1, %ymm5
cmpl $0x0, 0x18(%rsp)
setne %cl
movl %edi, %edi
movl %ebx, %esi
movl %r8d, %r8d
movl 0x30(%rsp), %r13d
movslq %r13d, %r9
vmovq %r8, %xmm0
vpbroadcastq %xmm0, %ymm0
vmovq %r9, %xmm1
vpbroadcastq %xmm1, %ymm1
vmovq %rdi, %xmm4
vpbroadcastq %xmm4, %ymm4
movq %rsi, 0x18(%rsp)
vmovq %rsi, %xmm6
vpbroadcastq %xmm6, %ymm6
vpmuldq 0xdb67c(%rip), %ymm6, %ymm7 # 0x62dde0
vmovdqu %ymm7, 0x50(%rsp)
vpmuldq 0xdb68d(%rip), %ymm6, %ymm7 # 0x62de00
vmovdqu %ymm7, 0x70(%rsp)
vpmuldq 0xdb4be(%rip), %ymm6, %ymm7 # 0x62dc40
vmovdqu %ymm7, 0xf0(%rsp)
vpmuldq 0xdb3ac(%rip), %ymm6, %ymm6 # 0x62db40
vmovdqu %ymm6, 0xd0(%rsp)
vmovd %ecx, %xmm6
vpbroadcastb %xmm6, %xmm7
vpshufb 0xd7351(%rip), %xmm7, %xmm6 # 0x629b00
xorl %ecx, %ecx
vpslld $0x1f, %xmm6, %xmm6
vpsrad $0x1f, %xmm6, %xmm6
vpmovsxdq %xmm6, %ymm6
vmovdqu %ymm6, 0x150(%rsp)
vpshufb 0xd741e(%rip), %xmm7, %xmm6 # 0x629bf0
vpslld $0x1f, %xmm6, %xmm6
vpsrad $0x1f, %xmm6, %xmm6
vpmovsxdq %xmm6, %ymm6
vmovdqu %ymm6, 0x130(%rsp)
vmovdqa %xmm7, 0xb0(%rsp)
vpshufb 0xd7404(%rip), %xmm7, %xmm6 # 0x629c00
vpslld $0x1f, %xmm6, %xmm6
vpsrad $0x1f, %xmm6, %xmm6
vpmovsxdq %xmm6, %ymm6
vmovdqu %ymm6, 0x110(%rsp)
movq %r14, %rdi
movq %r15, %r8
vpbroadcastq 0xdb61d(%rip), %ymm14 # 0x62de40
vpxor %xmm15, %xmm15, %xmm15
movq %rbx, %r10
vmovdqu 0x130(%rsp), %ymm13
vmovq %rcx, %xmm6
vpbroadcastq %xmm6, %ymm6
vpaddq 0x50(%rsp), %ymm6, %ymm7
vpaddq 0x70(%rsp), %ymm6, %ymm8
vpaddq 0xd0(%rsp), %ymm6, %ymm9
vpaddq 0xf0(%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
vmovdqu 0x110(%rsp), %ymm7
vpandn %ymm6, %ymm7, %ymm6
vpsubq %ymm8, %ymm1, %ymm7
vpsubq %ymm9, %ymm1, %ymm8
vpsubq %ymm11, %ymm1, %ymm9
vpmovzxbd 0xb0(%rsp), %xmm11
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 0x150(%rsp), %ymm10
vpandn %ymm9, %ymm10, %ymm9
vpcmpgtq %ymm14, %ymm9, %ymm10
vblendvpd %ymm10, %ymm9, %ymm14, %ymm10
vpandn %ymm7, %ymm13, %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, %r10
jne 0x552834
movw $0x0, (%r12)
movl %r11d, %esi
addl $0xf, %r11d
andl $-0x10, %r11d
leaq -0x1(%rsi), %rcx
vmovq %rcx, %xmm0
vpbroadcastq %xmm0, %ymm7
vmovss 0x10(%rsp), %xmm0
vbroadcastss %xmm0, %ymm0
vmovups %ymm0, 0xf0(%rsp)
vmovd %r13d, %xmm0
vpbroadcastd %xmm0, %ymm0
vmovdqu %ymm0, 0xd0(%rsp)
vpmovsxbd 0xdb3f7(%rip), %ymm10 # 0x62de48
vpmovsxbd 0xdb276(%rip), %ymm11 # 0x62dcd0
xorl %r8d, %r8d
vpbroadcastq 0xdb11a(%rip), %xmm1 # 0x62db80
vpcmpeqd %xmm6, %xmm6, %xmm6
vpcmpeqd %ymm4, %ymm4, %ymm4
vbroadcastss 0xdb3d9(%rip), %ymm0 # 0x62de50
vmovups %ymm0, 0xb0(%rsp)
vpbroadcastq 0xdb0f7(%rip), %ymm13 # 0x62db80
vpbroadcastd 0xdb12e(%rip), %xmm15 # 0x62dbc0
vpbroadcastd 0xdb3b9(%rip), %ymm0 # 0x62de54
vmovdqu %ymm0, 0x70(%rsp)
movl 0x238(%rsp), %edi
vmovdqu %ymm15, 0x50(%rsp)
vpxor %xmm9, %xmm9, %xmm9
testl %edi, %edi
jne 0x552b19
vpcmpeqd %ymm8, %ymm8, %ymm8
vpaddd %ymm8, %ymm11, %ymm0
vpcmpeqd %ymm4, %ymm4, %ymm4
vpaddd %ymm8, %ymm10, %ymm8
vmovdqu 0xf0(%rsp), %ymm12
vpmulld %ymm12, %ymm8, %ymm8
vpmulld %ymm12, %ymm0, %ymm0
vmovdqu 0xd0(%rsp), %ymm12
vpsubd %ymm0, %ymm12, %ymm0
vpsubd %ymm8, %ymm12, %ymm8
vmovdqu 0xb0(%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 0xdb015(%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 0x552b59
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 0x552b89
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, %ymm15, %ymm14
vpackssdw %xmm14, %xmm14, %xmm14
vpacksswb %xmm14, %xmm14, %xmm14
vpextrb $0x2, %xmm14, %ecx
testb $0x1, %cl
je 0x552bc3
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 0x552bef
vpextrw $0x3, %xmm9, 0x8(%r12,%r8,2)
vpor 0xdb049(%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 0x552c35
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 0x552c74
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 0x552ca9
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 0x552cd4
vpextrw $0x7, %xmm9, 0x10(%r12,%r8,2)
vpor 0xdb124(%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 0x552d15
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 0x552d48
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
vmovdqu 0x50(%rsp), %ymm15
vpermd %ymm14, %ymm15, %ymm14
vpackssdw %xmm14, %xmm14, %xmm14
vpacksswb %xmm14, %xmm14, %xmm14
vpextrb $0x6, %xmm14, %ecx
testb $0x1, %cl
je 0x552d84
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 0x552db0
vpextrw $0x3, %xmm9, 0x18(%r12,%r8,2)
vpor 0xdb028(%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 0x552df7
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 0x552e37
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
je 0x552e6c
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 0x552e95
vpextrw $0x7, %xmm9, 0x20(%r12,%r8,2)
addq $0x10, %r8
vmovdqu 0x70(%rsp), %ymm0
vpaddd %ymm0, %ymm11, %ymm11
vpaddd %ymm0, %ymm10, %ymm10
cmpq %r8, %r11
jne 0x552aae
movq %r12, 0x70(%rsp)
movq 0xa0(%rsp), %rdi
vpxor %xmm0, %xmm0, %xmm0
vpsubsw %ymm2, %ymm0, %ymm0
leal -0x1(%r10), %r11d
shlq $0x5, %r11
movq %rax, %rcx
addq %r11, %rcx
movl %r10d, %r8d
vmovdqu 0x190(%rsp), %ymm7
vmovdqa %ymm0, (%rcx)
vpsubsw %ymm3, %ymm0, %ymm0
vpminsw %ymm0, %ymm7, %ymm7
addq $-0x20, %rcx
decl %r8d
jg 0x552edf
addq %r14, %r11
movl 0x44(%rsp), %ebx
movq %rbx, 0x30(%rsp)
shlq $0x5, %rbx
addq %r14, %rbx
movq %r10, 0x10(%rsp)
shlq $0x5, %r10
xorl %ecx, %ecx
vmovdqu 0x1b0(%rsp), %ymm0
vpcmpeqw 0xdaf3d(%rip), %ymm0, %ymm0 # 0x62de60
movl 0x8(%rsp), %r8d
movl %r8d, 0x50(%rsp)
vmovdqu 0x1d0(%rsp), %ymm13
vmovdqa %ymm13, %ymm8
vmovdqa %ymm13, %ymm6
movl 0x4(%rsp), %r12d
movq %rcx, %r9
vmovdqa (%r11), %ymm1
vinserti128 $0x1, %xmm1, %ymm0, %ymm4
vpalignr $0xe, %ymm4, %ymm1, %ymm1 # ymm1 = ymm4[14,15],ymm1[0,1,2,3,4,5,6,7,8,9,10,11,12,13],ymm4[30,31],ymm1[16,17,18,19,20,21,22,23,24,25,26,27,28,29]
movq 0x70(%rsp), %rcx
vpinsrw $0x0, (%rcx,%r9,2), %xmm1, %xmm4
vpblendd $0xf, %ymm4, %ymm1, %ymm9 # ymm9 = ymm4[0,1,2,3],ymm1[4,5,6,7]
movq 0x20(%rsp), %rcx
movq 0x10(%rcx), %rcx
movq 0x28(%rsp), %r8
movzbl (%r8,%r9), %r8d
movslq (%rcx,%r8,4), %rcx
imulq 0x18(%rsp), %rcx
shlq $0x5, %rcx
addq 0x38(%rsp), %rcx
vpsubsw (%rax), %ymm13, %ymm4
xorl %r8d, %r8d
vmovdqa %ymm13, %ymm1
vpaddsw (%rcx,%r8), %ymm9, %ymm9
vmovdqa (%r14,%r8), %ymm10
vmovdqa (%r15,%r8), %ymm11
vpsubsw %ymm3, %ymm11, %ymm11
vpsubsw %ymm2, %ymm10, %ymm12
vpmaxsw %ymm12, %ymm11, %ymm11
vpaddsw (%rax,%r8), %ymm4, %ymm4
vpmaxsw %ymm4, %ymm1, %ymm1
vpmaxsw %ymm9, %ymm11, %ymm4
vmovdqa %ymm11, (%r15,%r8)
vmovdqa %ymm4, (%rbp,%r8)
addq $0x20, %r8
vmovdqa %ymm10, %ymm9
cmpq %r8, %r10
jne 0x552f9b
vinserti128 $0x1, %xmm4, %ymm0, %ymm9
vpalignr $0xe, %ymm9, %ymm4, %ymm4 # ymm4 = ymm9[14,15],ymm4[0,1,2,3,4,5,6,7,8,9,10,11,12,13],ymm9[30,31],ymm4[16,17,18,19,20,21,22,23,24,25,26,27,28,29]
leaq 0x1(%r9), %rcx
movq 0x70(%rsp), %r8
vpinsrw $0x0, 0x2(%r8,%r9,2), %xmm4, %xmm9
vpblendd $0xf, %ymm9, %ymm4, %ymm4 # ymm4 = ymm9[0,1,2,3],ymm4[4,5,6,7]
vpaddsw (%rax), %ymm4, %ymm9
vpmaxsw %ymm1, %ymm9, %ymm1
movl $0xe, %r8d
movq %rdi, %r13
vperm2i128 $0x28, %ymm1, %ymm1, %ymm9 # ymm9 = zero,zero,ymm1[0,1]
vpalignr $0xe, %ymm9, %ymm1, %ymm9 # ymm9 = ymm9[14,15],ymm1[0,1,2,3,4,5,6,7,8,9,10,11,12,13],ymm9[30,31],ymm1[16,17,18,19,20,21,22,23,24,25,26,27,28,29]
vpaddsw %ymm5, %ymm9, %ymm9
vpmaxsw %ymm1, %ymm9, %ymm1
decl %r8d
jne 0x553018
vperm2i128 $0x28, %ymm1, %ymm1, %ymm9 # ymm9 = zero,zero,ymm1[0,1]
vpalignr $0xe, %ymm9, %ymm1, %ymm1 # ymm1 = ymm9[14,15],ymm1[0,1,2,3,4,5,6,7,8,9,10,11,12,13],ymm9[30,31],ymm1[16,17,18,19,20,21,22,23,24,25,26,27,28,29]
vpaddsw 0x170(%rsp), %ymm1, %ymm1
vpmaxsw %ymm1, %ymm4, %ymm4
xorl %r8d, %r8d
vpsubsw %ymm3, %ymm1, %ymm1
vpsubsw %ymm2, %ymm4, %ymm4
vpmaxsw %ymm4, %ymm1, %ymm1
vpmaxsw (%rbp,%r8), %ymm1, %ymm4
vmovdqa %ymm4, (%r14,%r8)
vpminsw %ymm1, %ymm7, %ymm7
vpminsw %ymm4, %ymm7, %ymm7
vpmaxsw %ymm4, %ymm6, %ymm6
addq $0x20, %r8
cmpq %r8, %r10
jne 0x55304d
vmovdqa (%rbx), %ymm1
vpcmpgtw %ymm8, %ymm1, %ymm4
vpand %ymm0, %ymm4, %ymm4
vpmovmskb %ymm4, %r8d
testl %r8d, %r8d
movl 0x50(%rsp), %r8d
cmovnel %r9d, %r8d
movl %r8d, 0x50(%rsp)
vmovdqa %ymm1, %ymm4
cmpl $0xe, %r12d
jg 0x5530c2
xorl %r8d, %r8d
vmovdqa %ymm1, %ymm4
vperm2i128 $0x28, %ymm4, %ymm4, %ymm9 # ymm9 = zero,zero,ymm4[0,1]
vpalignr $0xe, %ymm9, %ymm4, %ymm4 # ymm4 = ymm9[14,15],ymm4[0,1,2,3,4,5,6,7,8,9,10,11,12,13],ymm9[30,31],ymm4[16,17,18,19,20,21,22,23,24,25,26,27,28,29]
incl %r8d
cmpl %edx, %r8d
jl 0x5530ae
vpmaxsw %ymm1, %ymm8, %ymm8
vextracti128 $0x1, %ymm4, %xmm1
vpextrw $0x7, %xmm1, %r8d
movswl %r8w, %r8d
movq 0x10(%r13), %r13
movq (%r13), %r13
movl %r8d, (%r13,%r9,4)
cmpq %rsi, %rcx
jne 0x552f44
movq 0x10(%rsp), %rbx
leal (,%rbx,4), %ecx
leal (,%rbx,8), %esi
movq %rsi, 0x28(%rsp)
leaq (%rcx,%rcx,2), %rsi
movq %rsi, 0x20(%rsp)
imulq $0x3c, %rbx, %rsi
movq %rsi, 0x38(%rsp)
imulq $0x38, %rbx, %rsi
movq %rsi, 0x170(%rsp)
imulq $0x34, %rbx, %rsi
movq %rsi, 0x18(%rsp)
movq %rbx, %rsi
shlq $0x4, %rsi
movq %rsi, 0xf0(%rsp)
leaq (%rsi,%rsi,2), %rsi
movq %rsi, 0xd0(%rsp)
imulq $0x2c, %rbx, %rsi
movq %rsi, 0xb0(%rsp)
leal (,%rbx,8), %esi
leaq (%rsi,%rsi,4), %r8
movq %r8, 0x150(%rsp)
leal (,%rbx,4), %r9d
leaq (%r9,%r9,8), %r8
movq %r8, 0x130(%rsp)
leaq (%rbx,%rbx,8), %r8
leaq (%r8,%r8,2), %r11
addq %rbx, %r11
leaq (%rsi,%rsi,2), %rsi
movq %rsi, 0x110(%rsp)
leaq (%r9,%r9,4), %r8
xorl %esi, %esi
movq %rdi, %rbx
movq 0x10(%rbx), %rdi
movq 0x8(%rdi), %rdi
vmovdqa (%r14,%rsi,8), %xmm1
vmovdqa 0x10(%r14,%rsi,8), %xmm0
vmovd %xmm1, %r9d
movswl %r9w, %r9d
movl %r9d, (%rdi,%rsi)
vpextrw $0x1, %xmm1, %r9d
addq %rsi, %rdi
movswl %r9w, %r9d
vpextrw $0x2, %xmm1, %r13d
movl %r9d, (%rcx,%rdi)
movswl %r13w, %r9d
vpextrw $0x3, %xmm1, %r13d
movq 0x28(%rsp), %r12
movl %r9d, (%r12,%rdi)
movswl %r13w, %r9d
vpextrw $0x4, %xmm1, %r13d
movq 0x20(%rsp), %r12
movl %r9d, (%r12,%rdi)
movswl %r13w, %r9d
vpextrw $0x5, %xmm1, %r13d
movq 0xf0(%rsp), %r12
movl %r9d, (%r12,%rdi)
movswl %r13w, %r9d
vpextrw $0x6, %xmm1, %r13d
movl %r9d, (%r8,%rdi)
movswl %r13w, %r9d
vpextrw $0x7, %xmm1, %r13d
movq 0x110(%rsp), %r12
movl %r9d, (%r12,%rdi)
movswl %r13w, %r9d
movl %r9d, (%r11,%rdi)
vmovd %xmm0, %r9d
movswl %r9w, %r9d
movl %r9d, (%r10,%rdi)
vpextrw $0x1, %xmm0, %r9d
movswl %r9w, %r9d
movq 0x130(%rsp), %r12
movl %r9d, (%r12,%rdi)
vpextrw $0x2, %xmm0, %r9d
movswl %r9w, %r9d
movq 0x150(%rsp), %r12
movl %r9d, (%r12,%rdi)
vpextrw $0x3, %xmm0, %r9d
movswl %r9w, %r9d
movq 0xb0(%rsp), %r12
movl %r9d, (%r12,%rdi)
vpextrw $0x4, %xmm0, %r9d
movswl %r9w, %r9d
movq 0xd0(%rsp), %r12
movl %r9d, (%r12,%rdi)
vpextrw $0x5, %xmm0, %r9d
movswl %r9w, %r9d
movq 0x18(%rsp), %r12
movl %r9d, (%r12,%rdi)
vpextrw $0x6, %xmm0, %r9d
movswl %r9w, %r9d
movq 0x170(%rsp), %r12
movl %r9d, (%r12,%rdi)
vpextrw $0x7, %xmm0, %r9d
movswl %r9w, %r9d
movq 0x38(%rsp), %r12
movl %r9d, (%r12,%rdi)
addq $0x4, %rsi
cmpq %rsi, %rcx
jne 0x553198
cmpl $0x0, 0x240(%rsp)
movl 0x4c(%rsp), %r10d
movq 0xa8(%rsp), %r11
movl 0x4(%rsp), %esi
movl 0xc(%rsp), %r13d
je 0x55331d
cmpl $0xe, %esi
jg 0x553312
xorl %ecx, %ecx
vperm2i128 $0x28, %ymm8, %ymm8, %ymm0 # ymm0 = zero,zero,ymm8[0,1]
vpalignr $0xe, %ymm0, %ymm8, %ymm8 # ymm8 = ymm0[14,15],ymm8[0,1,2,3,4,5,6,7,8,9,10,11,12,13],ymm0[30,31],ymm8[16,17,18,19,20,21,22,23,24,25,26,27,28,29]
incl %ecx
cmpl %edx, %ecx
jl 0x553300
vextracti128 $0x1, %ymm8, %xmm0
vpextrw $0x7, %xmm0, %r13d
cmpl $0x0, 0x230(%rsp)
je 0x5533a1
cmpl $0x0, 0x98(%rsp)
je 0x5533a1
movq 0x10(%rsp), %rsi
andl $0x7ffffff, %esi        # imm = 0x7FFFFFF
shll $0x4, %esi
xorl %edi, %edi
movl %r10d, %ecx
movl %edi, %r9d
shrl $0x4, %r9d
movl %edi, %r8d
andl $0xf, %r8d
imull 0x10(%rsp), %r8d
addl %r9d, %r8d
cmpl %r11d, %r8d
jge 0x553398
movzwl (%r14,%rdi,2), %r9d
cmpw %r13w, %r9w
jle 0x55337b
movl %r9d, %r13d
movl 0x8(%rsp), %ecx
movl %ecx, 0x50(%rsp)
movl %r8d, %ecx
jmp 0x553398
cmpl %ecx, %r8d
cmovgel %ecx, %r8d
movl 0x50(%rsp), %r12d
cmpl 0x8(%rsp), %r12d
cmovnel %ecx, %r8d
cmpw %r13w, %r9w
cmovel %r8d, %ecx
incq %rdi
cmpl %edi, %esi
jne 0x553344
jmp 0x5533a4
movl %r10d, %ecx
movl 0x230(%rsp), %esi
orl %esi, 0x48(%rsp)
jne 0x5533f1
movq 0x30(%rsp), %rcx
shlq $0x5, %rcx
vmovdqa (%r14,%rcx), %ymm0
cmpl $0xe, 0x4(%rsp)
jg 0x5533db
xorl %ecx, %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 %ecx
cmpl %edx, %ecx
jl 0x5533c9
vextracti128 $0x1, %ymm0, %xmm0
vpextrw $0x7, %xmm0, %r13d
movl 0x8(%rsp), %ecx
movl %ecx, 0x50(%rsp)
movl %r10d, %ecx
vpcmpgtw %ymm7, %ymm13, %ymm0
vpcmpgtw 0x190(%rsp), %ymm6, %ymm1
vpor %ymm0, %ymm1, %ymm0
vpmovmskb %ymm0, %edx
testl %edx, %edx
je 0x55341b
orb $0x40, 0xc(%rbx)
xorl %r13d, %r13d
movl $0x0, 0x50(%rsp)
xorl %ecx, %ecx
movswl %r13w, %edx
movl %edx, (%rbx)
movl %ecx, 0x4(%rbx)
movl 0x50(%rsp), %ecx
movl %ecx, 0x8(%rbx)
movq %rax, %rdi
vzeroupper
callq 0x20a60d
movq %r14, %rdi
callq 0x20a60d
movq %rbp, %rdi
callq 0x20a60d
movq 0x70(%rsp), %rdi
callq 0x20a60d
movq %r15, %rdi
callq 0x20a60d
jmp 0x553492
callq 0x1f0003
jmp 0x553490
callq 0x1effdd
jmp 0x553490
callq 0x1effb7
jmp 0x553490
callq 0x1eff91
jmp 0x553490
callq 0x1eff6b
jmp 0x553490
callq 0x1eff45
jmp 0x553490
callq 0x1eff1f
jmp 0x553490
callq 0x1efef9
xorl %ebx, %ebx
movq %rbx, %rax
addq $0x1f8, %rsp            # imm = 0x1F8
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq