// File: /workspace/github_c_makefile_star2_O1/nh13[P]ksw/src/parasail/src/nw_striped_avx2_256_16.c
// Function: parasail_nw_rowcol_striped_profile_avx2_256_16
parasail_result_t* PNAME(
        const parasail_profile_t * const restrict profile,
        const char * const restrict s2, const int s2Len,
        const int open, const int gap)
{
    /* declare local variables */
    int32_t i = 0;
    int32_t j = 0;
    int32_t k = 0;
    int 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;
    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;

    /* 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_NW | PARASAIL_FLAG_STRIPED
        | PARASAIL_FLAG_BITS_16 | PARASAIL_FLAG_LANES_16;
#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 = -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 = -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 = 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:
        {
        }

#ifdef PARASAIL_ROWCOL
        /* extract last value from the column */
        {
            vH = _mm256_load_si256(pvHStore + offset);
            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

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

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

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

    parasail_free(boundary);
    parasail_free(pvE);
    parasail_free(pvHLoad);
    parasail_free(pvHStore);

    return result;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
andq $-0x20, %rsp
subq $0xe0, %rsp
movq %rsi, 0x48(%rsp)
testq %rdi, %rdi
je 0x53b3d1
movq 0x30(%rdi), %rax
movq %rax, 0x68(%rsp)
testq %rax, %rax
je 0x53b3d8
movq 0x10(%rdi), %rax
movq %rax, 0x40(%rsp)
testq %rax, %rax
je 0x53b3df
movl 0x8(%rdi), %edi
testl %edi, %edi
jle 0x53b3e6
cmpq $0x0, 0x48(%rsp)
je 0x53b3ed
movl %edx, %r13d
testl %edx, %edx
jle 0x53b3f4
movl %ecx, %r14d
testl %ecx, %ecx
js 0x53b3fb
testl %r8d, %r8d
js 0x53b402
movl %r8d, 0x18(%rsp)
leal -0x1(%rdi), %eax
addq $0xf, %rdi
movq %rdi, %r12
shrq $0x4, %r12
movl %eax, 0x74(%rsp)
cltd
idivl %r12d
movl %eax, 0x14(%rsp)
movl %edx, %r15d
movl %r14d, %ebx
negl %ebx
movq 0x40(%rsp), %rcx
movl 0x20(%rcx), %eax
movl %eax, %edx
negl %edx
cmpl %ebx, %eax
cmovgl %r14d, %edx
movl %edx, 0x8(%rsp)
movw $0x7ffe, %ax            # imm = 0x7FFE
subw 0x1c(%rcx), %ax
movl %eax, 0x28(%rsp)
andl $0x7ffffff0, %edi       # imm = 0x7FFFFFF0
movl %r13d, %esi
movq %r13, (%rsp)
callq 0x209630
testq %rax, %rax
je 0x53b407
movq %rax, %r13
movl %ebx, 0x38(%rsp)
movl %r15d, 0x60(%rsp)
orl $0x10240801, 0xc(%rax)  # imm = 0x10240801
movl $0x20, %edi
movq %r12, %rsi
callq 0x4c5e3c
movq %rax, %r15
movl $0x20, %edi
movq %r12, %rsi
callq 0x4c5e3c
movq %rax, %rbx
movl $0x20, %edi
movq %r12, %rsi
callq 0x4c5e3c
movq %r12, 0x20(%rsp)
movq %rax, %r12
movq (%rsp), %rax
leal 0x1(%rax), %esi
movl $0x20, %edi
callq 0x2094cd
testq %r15, %r15
sete %cl
movq %rbx, 0x58(%rsp)
testq %rbx, %rbx
sete %dl
orb %cl, %dl
testq %r12, %r12
sete %cl
testq %rax, %rax
sete %sil
orb %cl, %sil
orb %dl, %sil
jne 0x53b407
movq %r13, 0x50(%rsp)
movq (%rsp), %rcx
decl %ecx
movl %ecx, 0x30(%rsp)
movl $0xf, %ecx
subl 0x14(%rsp), %ecx
movl %ecx, 0x34(%rsp)
vmovd %r14d, %xmm0
vpbroadcastw %xmm0, %ymm4
movl 0x18(%rsp), %edx
vmovd %edx, %xmm0
vpbroadcastw %xmm0, %ymm5
movl 0x8(%rsp), %ecx
addl $0xffff8001, %ecx       # imm = 0xFFFF8001
vmovd %ecx, %xmm0
vpbroadcastw %xmm0, %ymm0
vmovd 0x28(%rsp), %xmm1
vpbroadcastw %xmm1, %ymm1
movl %r14d, %ecx
movl %edx, %esi
movslq 0x38(%rsp), %rdx
movl 0x20(%rsp), %edi
negq %rcx
movq %rdi, %r8
movq %rsi, 0x8(%rsp)
imulq %rsi, %r8
xorl %r9d, %r9d
movq $-0x7fff, %r10          # imm = 0x8001
movq $-0x8000, %r11          # imm = 0x8000
movq %rdx, %rsi
xorl %ebx, %ebx
cmpq %r10, %rsi
movq $-0x8000, %r13          # imm = 0x8000
cmovgeq %rsi, %r13
movw %r13w, 0xa0(%rsp,%rbx,2)
leaq (%rcx,%rsi), %r13
cmpq %r10, %r13
cmovlq %r11, %r13
movw %r13w, 0x80(%rsp,%rbx,2)
incq %rbx
subq %r8, %rsi
cmpq $0x10, %rbx
jne 0x53aea7
movq %r9, %rsi
shlq $0x5, %rsi
vmovaps 0xa0(%rsp), %ymm2
vmovaps %ymm2, (%r15,%rsi)
vmovaps 0x80(%rsp), %ymm2
vmovaps %ymm2, (%r12,%rsi)
incq %r9
subq 0x8(%rsp), %rdx
cmpq %rdi, %r9
jne 0x53aea2
movw $0x0, (%rax)
movq (%rsp), %r8
cmpl $0x2, %r8d
movl $0x1, %ecx
cmovgel %r8d, %ecx
xorl %edx, %edx
movl 0x18(%rsp), %r9d
movl 0x38(%rsp), %r10d
cmpl $0xffff8001, %r10d      # imm = 0xFFFF8001
movl $0xffff8000, %esi       # imm = 0xFFFF8000
cmovgel %r10d, %esi
movw %si, 0x2(%rax,%rdx,2)
subl %r9d, %r10d
incq %rdx
cmpq %rdx, %rcx
jne 0x53af32
movq 0x20(%rsp), %r10
leal -0x1(%r10), %edx
movl 0x60(%rsp), %esi
movl $0x1, %r9d
cmpl %r9d, %r10d
adcl $0x0, %r10d
movl 0x34(%rsp), %ecx
cmpl $0x2, %ecx
movl $0x1, %r11d
cmovgel %ecx, %r11d
movl %r11d, 0x28(%rsp)
cmpl $0x2, %r8d
cmovgel %r8d, %r9d
movq %r9, (%rsp)
shlq $0x5, %r10
xorl %ecx, %ecx
shlq $0x5, %rdx
movq %rdx, 0x8(%rsp)
movl $0xffff8000, %edx       # imm = 0xFFFF8000
movq %rsi, 0x78(%rsp)
shlq $0x5, %rsi
movq %rsi, 0x18(%rsp)
vmovdqa %ymm0, %ymm2
vmovdqa %ymm1, %ymm3
movq 0x58(%rsp), %rsi
movq %r15, %r13
movq %rsi, %r15
movq 0x40(%rsp), %rsi
movq 0x10(%rsi), %r8
movq 0x48(%rsp), %rsi
movzbl (%rsi,%rcx), %r9d
movslq (%r8,%r9,4), %r8
movq %rdi, %rbx
imulq %r8, %rbx
shlq $0x5, %rbx
addq 0x68(%rsp), %rbx
movq 0x8(%rsp), %rsi
vmovdqa (%r13,%rsi), %ymm6
vinserti128 $0x1, %xmm6, %ymm0, %ymm7
vpalignr $0xe, %ymm7, %ymm6, %ymm6 # ymm6 = ymm7[14,15],ymm6[0,1,2,3,4,5,6,7,8,9,10,11,12,13],ymm7[30,31],ymm6[16,17,18,19,20,21,22,23,24,25,26,27,28,29]
vpinsrw $0x0, (%rax,%rcx,2), %xmm6, %xmm7
vpblendd $0xf, %ymm7, %ymm6, %ymm7 # ymm7 = ymm7[0,1,2,3],ymm6[4,5,6,7]
xorl %r8d, %r8d
vmovdqa %ymm0, %ymm6
vpaddsw (%rbx,%r8), %ymm7, %ymm7
vmovdqa (%r12,%r8), %ymm8
vpmaxsw %ymm6, %ymm8, %ymm9
vpmaxsw %ymm7, %ymm9, %ymm7
vmovdqa %ymm7, (%r15,%r8)
vpmaxsw %ymm7, %ymm2, %ymm2
vpminsw %ymm3, %ymm8, %ymm3
vpminsw %ymm6, %ymm3, %ymm3
vpminsw %ymm7, %ymm3, %ymm3
vpsubsw %ymm4, %ymm7, %ymm7
vpsubsw %ymm5, %ymm8, %ymm8
vpmaxsw %ymm7, %ymm8, %ymm8
vmovdqa %ymm8, (%r12,%r8)
vpsubsw %ymm5, %ymm6, %ymm6
vpmaxsw %ymm7, %ymm6, %ymm6
vmovdqa (%r13,%r8), %ymm7
addq $0x20, %r8
cmpq %r8, %r10
jne 0x53b015
xorl %ebx, %ebx
vinserti128 $0x1, %xmm6, %ymm0, %ymm7
vpalignr $0xe, %ymm7, %ymm6, %ymm6 # ymm6 = ymm7[14,15],ymm6[0,1,2,3,4,5,6,7,8,9,10,11,12,13],ymm7[30,31],ymm6[16,17,18,19,20,21,22,23,24,25,26,27,28,29]
movswl 0x2(%rax,%rcx,2), %r8d
subl %r14d, %r8d
cmpl $0xffff8001, %r8d       # imm = 0xFFFF8001
cmovll %edx, %r8d
vpinsrw $0x0, %r8d, %xmm6, %xmm7
vpblendd $0xf, %ymm7, %ymm6, %ymm6 # ymm6 = ymm7[0,1,2,3],ymm6[4,5,6,7]
movb $0x1, %r11b
movl $0x1, %r8d
xorl %r9d, %r9d
vpmaxsw (%r15,%r9), %ymm6, %ymm7
vmovdqa %ymm7, (%r15,%r9)
vpminsw %ymm7, %ymm3, %ymm3
vpmaxsw %ymm7, %ymm2, %ymm2
vpsubsw %ymm4, %ymm7, %ymm7
vpsubsw %ymm5, %ymm6, %ymm6
vpcmpgtw %ymm7, %ymm6, %ymm7
vpmovmskb %ymm7, %esi
testl %esi, %esi
je 0x53b0de
cmpq %rdi, %r8
setb %r11b
addq $0x20, %r9
incq %r8
cmpq %r9, %r10
jne 0x53b0a3
testb $0x1, %r11b
jne 0x53b0f2
leal 0x1(%rbx), %esi
cmpl $0xf, %ebx
movl %esi, %ebx
jb 0x53b06b
movq 0x18(%rsp), %rsi
vmovdqa (%r15,%rsi), %ymm6
cmpl $0xe, 0x14(%rsp)
jg 0x53b121
movl 0x28(%rsp), %r8d
movq 0x50(%rsp), %r9
vperm2i128 $0x28, %ymm6, %ymm6, %ymm7 # ymm7 = zero,zero,ymm6[0,1]
vpalignr $0xe, %ymm7, %ymm6, %ymm6 # ymm6 = ymm7[14,15],ymm6[0,1,2,3,4,5,6,7,8,9,10,11,12,13],ymm7[30,31],ymm6[16,17,18,19,20,21,22,23,24,25,26,27,28,29]
decl %r8d
jne 0x53b10e
jmp 0x53b126
movq 0x50(%rsp), %r9
vextracti128 $0x1, %ymm6, %xmm6
vpextrw $0x7, %xmm6, %esi
movswl %si, %esi
movq 0x10(%r9), %r8
movq (%r8), %r8
movl %esi, (%r8,%rcx,4)
incq %rcx
movq %r13, %rsi
cmpq (%rsp), %rcx
jne 0x53afbd
movq 0x20(%rsp), %r8
leal (,%r8,4), %r9d
leal (,%r8,8), %ecx
movq %rcx, 0x48(%rsp)
cmpl $0x1, %r8d
adcl $0x0, %r8d
imulq $0x3c, %rdi, %rcx
movq %rcx, 0x40(%rsp)
imulq $0x38, %rdi, %rcx
movq %rcx, 0x68(%rsp)
imulq $0x34, %rdi, %rcx
movq %rcx, 0x8(%rsp)
movq %rdi, %r10
shlq $0x4, %r10
imulq $0x2c, %rdi, %rcx
movq %rcx, (%rsp)
leal (,%rdi,8), %ecx
leaq (%rcx,%rcx,4), %rdx
movq %rdx, 0x18(%rsp)
leal (,%rdi,4), %esi
leaq (%rsi,%rsi,8), %rdx
movq %rdx, 0x28(%rsp)
leaq (%rdi,%rdi,8), %rdx
leaq (%rdx,%rdx,2), %rdx
addq %rdi, %rdx
movq %rdx, 0x20(%rsp)
shlq $0x5, %rdi
leaq (%rcx,%rcx,2), %rcx
movq %rcx, 0x38(%rsp)
leaq (%rsi,%rsi,4), %rcx
movq %rcx, 0x60(%rsp)
shll $0x2, %r8d
movq %r8, %rcx
movq %r9, %rsi
leaq (%r9,%r9,2), %rdx
movq %rdx, 0x58(%rsp)
movq %r10, %r8
leaq (%r10,%r10,2), %r9
xorl %r11d, %r11d
movq 0x50(%rsp), %r10
movq 0x10(%r10), %rbx
movq 0x8(%rbx), %rbx
vmovdqa (%r15,%r11,8), %xmm5
vmovdqa 0x10(%r15,%r11,8), %xmm4
vmovd %xmm5, %r14d
movswl %r14w, %r14d
movl %r14d, (%rbx,%r11)
vpextrw $0x1, %xmm5, %r14d
addq %r11, %rbx
movswl %r14w, %r14d
vpextrw $0x2, %xmm5, %r10d
movl %r14d, (%rsi,%rbx)
movswl %r10w, %r10d
vpextrw $0x3, %xmm5, %r14d
movq 0x48(%rsp), %rdx
movl %r10d, (%rdx,%rbx)
movswl %r14w, %r10d
vpextrw $0x4, %xmm5, %r14d
movq 0x58(%rsp), %rdx
movl %r10d, (%rdx,%rbx)
movswl %r14w, %r10d
vpextrw $0x5, %xmm5, %r14d
movl %r10d, (%r8,%rbx)
movswl %r14w, %r10d
vpextrw $0x6, %xmm5, %r14d
movq 0x60(%rsp), %rdx
movl %r10d, (%rdx,%rbx)
movswl %r14w, %r10d
vpextrw $0x7, %xmm5, %r14d
movq 0x38(%rsp), %rdx
movl %r10d, (%rdx,%rbx)
movswl %r14w, %r10d
movq 0x20(%rsp), %rdx
movl %r10d, (%rdx,%rbx)
vmovd %xmm4, %r10d
movswl %r10w, %r10d
movl %r10d, (%rdi,%rbx)
vpextrw $0x1, %xmm4, %r10d
movswl %r10w, %r10d
movq 0x28(%rsp), %rdx
movl %r10d, (%rdx,%rbx)
vpextrw $0x2, %xmm4, %r10d
movswl %r10w, %r10d
movq 0x18(%rsp), %rdx
movl %r10d, (%rdx,%rbx)
vpextrw $0x3, %xmm4, %r10d
movswl %r10w, %r10d
movq (%rsp), %rdx
movl %r10d, (%rdx,%rbx)
vpextrw $0x4, %xmm4, %r10d
movswl %r10w, %r10d
movl %r10d, (%r9,%rbx)
vpextrw $0x5, %xmm4, %r10d
movswl %r10w, %r10d
movq 0x8(%rsp), %rdx
movl %r10d, (%rdx,%rbx)
vpextrw $0x6, %xmm4, %r10d
movswl %r10w, %r10d
movq 0x68(%rsp), %rdx
movl %r10d, (%rdx,%rbx)
vpextrw $0x7, %xmm4, %r10d
movswl %r10w, %r10d
movq 0x40(%rsp), %rdx
movl %r10d, (%rdx,%rbx)
movq 0x50(%rsp), %rbx
addq $0x4, %r11
cmpq %r11, %rcx
jne 0x53b1fe
movq 0x78(%rsp), %rcx
shlq $0x5, %rcx
vmovdqa (%r15,%rcx), %ymm4
cmpl $0xe, 0x14(%rsp)
jg 0x53b36e
movl 0x34(%rsp), %edx
cmpl $0x2, %edx
movl $0x1, %ecx
cmovgel %edx, %ecx
movl 0x30(%rsp), %esi
vperm2i128 $0x28, %ymm4, %ymm4, %ymm5 # ymm5 = zero,zero,ymm4[0,1]
vpalignr $0xe, %ymm5, %ymm4, %ymm4 # ymm4 = ymm5[14,15],ymm4[0,1,2,3,4,5,6,7,8,9,10,11,12,13],ymm5[30,31],ymm4[16,17,18,19,20,21,22,23,24,25,26,27,28,29]
decl %ecx
jne 0x53b35c
jmp 0x53b372
movl 0x30(%rsp), %esi
vpcmpgtw %ymm3, %ymm0, %ymm0
vpcmpgtw %ymm1, %ymm2, %ymm1
vpor %ymm0, %ymm1, %ymm0
vpmovmskb %ymm0, %ecx
testl %ecx, %ecx
je 0x53b392
orb $0x40, 0xc(%rbx)
xorl %ecx, %ecx
xorl %esi, %esi
xorl %edx, %edx
jmp 0x53b3a1
vextracti128 $0x1, %ymm4, %xmm0
vpextrw $0x7, %xmm0, %ecx
movl 0x74(%rsp), %edx
movswl %cx, %ecx
movl %ecx, (%rbx)
movl %edx, 0x4(%rbx)
movl %esi, 0x8(%rbx)
movq %rax, %rdi
vzeroupper
callq 0x2094b5
movq %r12, %rdi
callq 0x2094b5
movq %r13, %rdi
callq 0x2094b5
movq %r15, %rdi
callq 0x2094b5
jmp 0x53b409
callq 0x1f2505
jmp 0x53b407
callq 0x1f24df
jmp 0x53b407
callq 0x1f24b9
jmp 0x53b407
callq 0x1f2493
jmp 0x53b407
callq 0x1f246d
jmp 0x53b407
callq 0x1f2447
jmp 0x53b407
callq 0x1f2421
jmp 0x53b407
callq 0x1f23fb
xorl %ebx, %ebx
movq %rbx, %rax
leaq -0x28(%rbp), %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
nop