// File: /workspace/github_c_makefile_star2_O1/nh13[P]ksw/src/parasail/src/nw_scan_avx2_256_32.c
// Function: parasail_nw_rowcol_scan_profile_avx2_256_32
parasail_result_t* PNAME(
        const parasail_profile_t * const restrict profile,
        const char * const restrict s2, const int s2Len,
        const int open, const int gap)
{
    /* declare local variables */
    int32_t i = 0;
    int32_t j = 0;
    int32_t k = 0;
    int32_t s1Len = 0;
    int32_t end_query = 0;
    int32_t end_ref = 0;
    const parasail_matrix_t *matrix = NULL;
    int32_t segWidth = 0;
    int32_t segLen = 0;
    int32_t offset = 0;
    int32_t position = 0;
    __m256i* restrict pvP = NULL;
    __m256i* restrict pvE = NULL;
    int32_t* restrict boundary = NULL;
    __m256i* restrict pvHt = NULL;
    __m256i* restrict pvH = NULL;
    __m256i* restrict pvGapper = NULL;
    __m256i vGapO;
    __m256i vGapE;
    int32_t NEG_LIMIT = 0;
    int32_t POS_LIMIT = 0;
    __m256i vZero;
    int32_t score = 0;
    __m256i vNegLimit;
    __m256i vPosLimit;
    __m256i vSaturationCheckMin;
    __m256i vSaturationCheckMax;
    __m256i vNegInfFront;
    __m256i vSegLenXgap;
    parasail_result_t *result = NULL;

    /* validate inputs */
    PARASAIL_CHECK_NULL(profile);
    PARASAIL_CHECK_NULL(profile->profile32.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 = 8; /* number of values in vector unit */
    segLen = (s1Len + segWidth - 1) / segWidth;
    offset = (s1Len - 1) % segLen;
    position = (segWidth - 1) - (s1Len - 1) / segLen;
    pvP = (__m256i*)profile->profile32.score;
    vGapO = _mm256_set1_epi32(open);
    vGapE = _mm256_set1_epi32(gap);
    NEG_LIMIT = (-open < matrix->min ? INT32_MIN + open : INT32_MIN - matrix->min) + 1;
    POS_LIMIT = INT32_MAX - matrix->max - 1;
    vZero = _mm256_setzero_si256();
    score = NEG_LIMIT;
    vNegLimit = _mm256_set1_epi32(NEG_LIMIT);
    vPosLimit = _mm256_set1_epi32(POS_LIMIT);
    vSaturationCheckMin = vPosLimit;
    vSaturationCheckMax = vNegLimit;
    vNegInfFront = vZero;
    vNegInfFront = _mm256_insert_epi32_rpl(vNegInfFront, NEG_LIMIT, 0);
    vSegLenXgap = _mm256_add_epi32(vNegInfFront,
            _mm256_slli_si256_rpl(_mm256_set1_epi32(-segLen*gap), 4));

    /* 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_SCAN
        | PARASAIL_FLAG_BITS_32 | PARASAIL_FLAG_LANES_8;
#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_int32_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_32_t h;
            __m256i_32_t e;
            for (segNum=0; segNum<segWidth; ++segNum) {
                int64_t tmp = -open-gap*(segNum*segLen+i);
                h.v[segNum] = tmp < INT32_MIN ? INT32_MIN : tmp;
                tmp = tmp - open;
                e.v[segNum] = tmp < INT32_MIN ? INT32_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 = -open-gap*(i-1);
            boundary[i] = tmp < INT32_MIN ? INT32_MIN : tmp;
        }
    }

    {
        __m256i vGapper = _mm256_sub_epi32(vZero,vGapO);
        for (i=segLen-1; i>=0; --i) {
            _mm256_store_si256(pvGapper+i, vGapper);
            vGapper = _mm256_sub_epi32(vGapper, vGapE);
        }
    }

    /* 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, 4);
        vHp = _mm256_insert_epi32_rpl(vHp, boundary[j], 0);
        pvW = pvP + matrix->mapper[(unsigned char)s2[j]]*segLen;
        vHt = _mm256_sub_epi32(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_epi32(
                    _mm256_sub_epi32(vE, vGapE),
                    _mm256_sub_epi32(vH, vGapO));
            vHp = _mm256_add_epi32(vHp, vW);
            vF = _mm256_max_epi32(vF, _mm256_add_epi32(vHt, pvGapper[i]));
            vHt = _mm256_max_epi32(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, 4);
        vHt = _mm256_insert_epi32_rpl(vHt, boundary[j+1], 0);
        vF = _mm256_max_epi32(vF, _mm256_add_epi32(vHt, pvGapper[0]));
        for (i=0; i<segWidth-2; ++i) {
            __m256i vFt = _mm256_slli_si256_rpl(vF, 4);
            vFt = _mm256_add_epi32(vFt, vSegLenXgap);
            vF = _mm256_max_epi32(vF, vFt);
        }

        /* calculate final H */
        vF = _mm256_slli_si256_rpl(vF, 4);
        vF = _mm256_add_epi32(vF, vNegInfFront);
        vH = _mm256_max_epi32(vHt, vF);
        for (i=0; i<segLen; ++i) {
            vHt = _mm256_load_si256(pvHt+i);
            vF = _mm256_max_epi32(
                    _mm256_sub_epi32(vF, vGapE),
                    _mm256_sub_epi32(vH, vGapO));
            vH = _mm256_max_epi32(vHt, vF);
            _mm256_store_si256(pvH+i, vH);
            vSaturationCheckMin = _mm256_min_epi32(vSaturationCheckMin, vH);
            vSaturationCheckMax = _mm256_max_epi32(vSaturationCheckMax, vH);
#ifdef PARASAIL_TABLE
            arr_store_si256(result->tables->score_table, vH, i, segLen, j, s2Len);
#endif
        } 


#ifdef PARASAIL_ROWCOL
        /* extract last value from the column */
        {
            vH = _mm256_load_si256(pvH + offset);
            for (k=0; k<position; ++k) {
                vH = _mm256_slli_si256_rpl(vH, 4);
            }
            result->rowcols->score_row[j] = (int32_t) _mm256_extract_epi32_rpl (vH, 7);
        }
#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

    /* 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, 4);
        }
        score = (int32_t) _mm256_extract_epi32_rpl (vH, 7);
    }

    if (_mm256_movemask_epi8(_mm256_or_si256(
            _mm256_cmplt_epi32_rpl(vSaturationCheckMin, vNegLimit),
            _mm256_cmpgt_epi32(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
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
andq $-0x20, %rsp
subq $0xe0, %rsp
movq %rsi, 0x50(%rsp)
testq %rdi, %rdi
je 0x521a68
movq 0x48(%rdi), %rax
movq %rax, 0x78(%rsp)
testq %rax, %rax
je 0x521a6f
movq 0x10(%rdi), %rax
movq %rax, 0x48(%rsp)
testq %rax, %rax
je 0x521a76
movl 0x8(%rdi), %edi
testl %edi, %edi
jle 0x521a7d
cmpq $0x0, 0x50(%rsp)
je 0x521a84
movl %edx, %r13d
testl %edx, %edx
jle 0x521a8b
testl %ecx, %ecx
js 0x521a92
testl %r8d, %r8d
js 0x521a99
movl %r8d, 0x40(%rsp)
leal -0x1(%rdi), %r14d
addq $0x7, %rdi
movq %rdi, %rbx
shrq $0x3, %rbx
movl %r14d, %eax
cltd
idivl %ebx
movl %eax, 0x14(%rsp)
movl %edx, 0x64(%rsp)
movl %ecx, %r12d
negl %r12d
movq 0x48(%rsp), %rdx
movl 0x20(%rdx), %eax
movl $0x80000000, %esi       # imm = 0x80000000
movl %ecx, 0x18(%rsp)
orl %esi, %ecx
subl %eax, %esi
cmpl %r12d, %eax
cmovgl %ecx, %esi
movl %esi, 0x10(%rsp)
movl $0x7ffffffe, %eax       # imm = 0x7FFFFFFE
subl 0x1c(%rdx), %eax
movl %eax, 0x60(%rsp)
andl $0x7ffffff8, %edi       # imm = 0x7FFFFFF8
movl %r13d, %esi
callq 0x209630
testq %rax, %rax
je 0x521a9e
movl %r14d, 0x5c(%rsp)
movq %rax, 0x38(%rsp)
orl $0x8440401, 0xc(%rax)   # imm = 0x8440401
movl $0x20, %edi
movq %rbx, %rsi
callq 0x4c5e3c
movq %rax, %r15
leal 0x1(%r13), %esi
movl $0x20, %edi
movq %rsi, 0x70(%rsp)
callq 0x2094d5
movq %rax, 0x30(%rsp)
movl $0x20, %edi
movq %rbx, %rsi
callq 0x4c5e3c
movq %r13, 0x68(%rsp)
movq %rax, %r13
movl $0x20, %edi
movq %rbx, %rsi
callq 0x4c5e3c
movq %rax, %r14
movl $0x20, %edi
movq %rbx, 0x28(%rsp)
movq %rbx, %rsi
callq 0x4c5e3c
movq 0x30(%rsp), %rdx
testq %r15, %r15
sete %cl
testq %rdx, %rdx
sete %dl
orb %cl, %dl
testq %r13, %r13
sete %cl
testq %r14, %r14
sete %sil
orb %cl, %sil
orb %dl, %sil
testq %rax, %rax
sete %cl
orb %sil, %cl
jne 0x521a9e
movq 0x68(%rsp), %rcx
leal -0x1(%rcx), %esi
movl $0x7, %ecx
subl 0x14(%rsp), %ecx
movl %ecx, 0x24(%rsp)
movl 0x18(%rsp), %edi
vmovd %edi, %xmm0
vpbroadcastd %xmm0, %ymm2
movl 0x40(%rsp), %edx
vmovd %edx, %xmm0
vpbroadcastd %xmm0, %ymm3
movl 0x10(%rsp), %ecx
incl %ecx
vmovd %ecx, %xmm0
vpbroadcastd %xmm0, %ymm0
vmovd 0x60(%rsp), %xmm1
vpbroadcastd %xmm1, %ymm1
vxorps %xmm4, %xmm4, %xmm4
vmovss %xmm0, %xmm4, %xmm4     # xmm4 = xmm0[0],xmm4[1,2,3]
movq 0x28(%rsp), %r8
movl %r8d, %ecx
imull %edx, %ecx
movl %ecx, %edx
negl %edx
vmovd %edx, %xmm5
vpbroadcastd %xmm5, %ymm5
vpxor %xmm6, %xmm6, %xmm6
vpblendd $0x1, %ymm6, %ymm5, %ymm5 # ymm5 = ymm6[0],ymm5[1,2,3,4,5,6,7]
vpaddd %ymm5, %ymm4, %ymm5
movl %edi, %edi
movl %r8d, %edx
xorl %r8d, %r8d
movq $-0x80000000, %r9       # imm = 0x80000000
movl %r12d, %r10d
movq %rdx, 0x18(%rsp)
movl %r10d, %edx
xorl %r11d, %r11d
movslq %edx, %rdx
movl %edx, 0xa0(%rsp,%r11,4)
movq %rdx, %rbx
subq %rdi, %rbx
cmpq $-0x7fffffff, %rbx      # imm = 0x80000001
cmovlq %r9, %rbx
movl %ebx, 0x80(%rsp,%r11,4)
incq %r11
subl %ecx, %edx
cmpq $0x8, %r11
jne 0x52168e
movq %r8, %rdx
shlq $0x5, %rdx
vmovaps 0xa0(%rsp), %ymm6
vmovaps %ymm6, (%r14,%rdx)
vmovdqa 0x80(%rsp), %ymm6
vmovdqa %ymm6, (%r15,%rdx)
incq %r8
movl 0x40(%rsp), %r11d
subl %r11d, %r10d
movq 0x18(%rsp), %rdx
cmpq %rdx, %r8
jne 0x521688
movl %esi, 0x10(%rsp)
movq 0x30(%rsp), %rdx
movl $0x0, (%rdx)
movl $0x1, %ecx
movq 0x70(%rsp), %rsi
movl %r12d, (%rdx,%rcx,4)
incq %rcx
subl %r11d, %r12d
cmpq %rcx, %rsi
jne 0x521710
vpxor %xmm6, %xmm6, %xmm6
vpsubd %ymm2, %ymm6, %ymm6
movq 0x28(%rsp), %rsi
leal -0x1(%rsi), %ecx
movq %rcx, %rdi
shlq $0x5, %rdi
movq %rax, %rdx
addq %rdi, %rdx
movl %esi, %edi
vmovdqa %ymm6, (%rdx)
vpsubd %ymm3, %ymm6, %ymm6
addq $-0x20, %rdx
decl %edi
jg 0x52173e
movl %ecx, %r8d
shlq $0x5, %r8
addq %r14, %r8
movl 0x64(%rsp), %r9d
movq %r9, 0x40(%rsp)
shlq $0x5, %r9
addq %r14, %r9
movl $0x1, %r10d
movq 0x28(%rsp), %r11
cmpl %r10d, %r11d
adcl $0x0, %r11d
movl 0x24(%rsp), %ecx
cmpl $0x2, %ecx
movl $0x1, %ebx
cmovgel %ecx, %ebx
movq 0x68(%rsp), %rcx
cmpl $0x2, %ecx
cmovgel %ecx, %r10d
shlq $0x5, %r11
xorl %ecx, %ecx
vpmovsxbd 0xd7fdb(%rip), %ymm8 # 0x5f9780
vmovdqa %ymm0, %ymm6
vmovdqa %ymm1, %ymm7
movq 0x30(%rsp), %rdi
movl 0x14(%rsp), %esi
vpermd (%r8), %ymm8, %ymm9
movq %rcx, %r12
vmovd (%rdi,%rcx,4), %xmm10
vpblendd $0x1, %ymm10, %ymm9, %ymm11 # ymm11 = ymm10[0],ymm9[1,2,3,4,5,6,7]
movq 0x48(%rsp), %rcx
movq 0x10(%rcx), %rcx
movq 0x50(%rsp), %rdx
movzbl (%rdx,%r12), %edx
movslq (%rcx,%rdx,4), %rcx
imulq 0x18(%rsp), %rcx
shlq $0x5, %rcx
addq 0x78(%rsp), %rcx
vpsubd (%rax), %ymm0, %ymm10
xorl %edx, %edx
vmovdqa %ymm0, %ymm9
vpaddd (%rcx,%rdx), %ymm11, %ymm11
vmovdqa (%r14,%rdx), %ymm12
vmovdqa (%r15,%rdx), %ymm13
vpsubd %ymm3, %ymm13, %ymm13
vpsubd %ymm2, %ymm12, %ymm14
vpmaxsd %ymm14, %ymm13, %ymm13
vpaddd (%rax,%rdx), %ymm10, %ymm10
vpmaxsd %ymm10, %ymm9, %ymm9
vpmaxsd %ymm11, %ymm13, %ymm10
vmovdqa %ymm13, (%r15,%rdx)
vmovdqa %ymm10, (%r13,%rdx)
addq $0x20, %rdx
vmovdqa %ymm12, %ymm11
cmpq %rdx, %r11
jne 0x5217f9
vpermd %ymm10, %ymm8, %ymm10
leaq 0x1(%r12), %rcx
vmovd 0x4(%rdi,%r12,4), %xmm11
vpblendd $0x1, %ymm11, %ymm10, %ymm10 # ymm10 = ymm11[0],ymm10[1,2,3,4,5,6,7]
vpaddd (%rax), %ymm10, %ymm11
vpmaxsd %ymm11, %ymm9, %ymm9
movl $0x6, %edx
vperm2i128 $0x28, %ymm9, %ymm9, %ymm11 # ymm11 = zero,zero,ymm9[0,1]
vpalignr $0xc, %ymm11, %ymm9, %ymm11 # ymm11 = ymm11[12,13,14,15],ymm9[0,1,2,3,4,5,6,7,8,9,10,11],ymm11[28,29,30,31],ymm9[16,17,18,19,20,21,22,23,24,25,26,27]
vpaddd %ymm5, %ymm11, %ymm11
vpmaxsd %ymm11, %ymm9, %ymm9
decl %edx
jne 0x521866
vperm2i128 $0x28, %ymm9, %ymm9, %ymm11 # ymm11 = zero,zero,ymm9[0,1]
vpalignr $0xc, %ymm11, %ymm9, %ymm9 # ymm9 = ymm11[12,13,14,15],ymm9[0,1,2,3,4,5,6,7,8,9,10,11],ymm11[28,29,30,31],ymm9[16,17,18,19,20,21,22,23,24,25,26,27]
vpaddd %ymm4, %ymm9, %ymm9
vpmaxsd %ymm9, %ymm10, %ymm10
xorl %edx, %edx
vpsubd %ymm3, %ymm9, %ymm9
vpsubd %ymm2, %ymm10, %ymm10
vpmaxsd %ymm10, %ymm9, %ymm9
vpmaxsd (%r13,%rdx), %ymm9, %ymm10
vmovdqa %ymm10, (%r14,%rdx)
vpminsd %ymm10, %ymm7, %ymm7
vpmaxsd %ymm10, %ymm6, %ymm6
addq $0x20, %rdx
cmpq %rdx, %r11
jne 0x521896
vmovdqa (%r9), %ymm9
cmpl $0x6, %esi
jg 0x5218df
movl %ebx, %edx
vperm2i128 $0x28, %ymm9, %ymm9, %ymm10 # ymm10 = zero,zero,ymm9[0,1]
vpalignr $0xc, %ymm10, %ymm9, %ymm9 # ymm9 = ymm10[12,13,14,15],ymm9[0,1,2,3,4,5,6,7,8,9,10,11],ymm10[28,29,30,31],ymm9[16,17,18,19,20,21,22,23,24,25,26,27]
decl %edx
jne 0x5218cf
vextracti128 $0x1, %ymm9, %xmm9
movq 0x38(%rsp), %rdx
movq 0x10(%rdx), %rdx
movq (%rdx), %rdx
vpextrd $0x3, %xmm9, (%rdx,%r12,4)
cmpq %r10, %rcx
jne 0x5217b6
movq 0x28(%rsp), %rsi
leal (,%rsi,4), %ecx
movq %rcx, 0x50(%rsp)
cmpl $0x1, %esi
adcl $0x0, %esi
movq 0x18(%rsp), %rcx
leaq (%rcx,%rcx,8), %rdx
leaq (%rdx,%rdx,2), %rdx
addq %rcx, %rdx
movq %rdx, 0x48(%rsp)
leaq (,%rcx,8), %r9
leaq (%r9,%r9,2), %r10
leal (,%rcx,4), %r11d
leaq (%r11,%r11,4), %rdx
shlq $0x4, %rcx
leaq (%r11,%r11,2), %r11
shll $0x2, %esi
xorl %ebx, %ebx
movq 0x38(%rsp), %rdi
movq 0x10(%rdi), %r12
movq 0x8(%r12), %r12
vmovdqa (%r14,%rbx,8), %xmm2
vmovdqa 0x10(%r14,%rbx,8), %xmm3
vmovd %xmm2, (%r12,%rbx)
addq %rbx, %r12
movq 0x50(%rsp), %r8
vpextrd $0x1, %xmm2, (%r8,%r12)
vpextrd $0x2, %xmm2, (%r9,%r12)
vpextrd $0x3, %xmm2, (%r11,%r12)
vmovd %xmm3, (%rcx,%r12)
vpextrd $0x1, %xmm3, (%rdx,%r12)
vpextrd $0x2, %xmm3, (%r10,%r12)
movq 0x48(%rsp), %r8
vpextrd $0x3, %xmm3, (%r8,%r12)
addq $0x4, %rbx
cmpq %rbx, %rsi
jne 0x521957
movq 0x40(%rsp), %rcx
shlq $0x5, %rcx
vmovdqa (%r14,%rcx), %ymm2
cmpl $0x6, 0x14(%rsp)
jg 0x5219f9
movl 0x24(%rsp), %edx
cmpl $0x2, %edx
movl $0x1, %ecx
cmovgel %edx, %ecx
movq 0x38(%rsp), %rbx
movl 0x10(%rsp), %esi
vperm2i128 $0x28, %ymm2, %ymm2, %ymm3 # ymm3 = zero,zero,ymm2[0,1]
vpalignr $0xc, %ymm3, %ymm2, %ymm2 # ymm2 = ymm3[12,13,14,15],ymm2[0,1,2,3,4,5,6,7,8,9,10,11],ymm3[28,29,30,31],ymm2[16,17,18,19,20,21,22,23,24,25,26,27]
decl %ecx
jne 0x5219e7
jmp 0x521a02
movq 0x38(%rsp), %rbx
movl 0x10(%rsp), %esi
vpcmpgtd %ymm7, %ymm0, %ymm0
vpcmpgtd %ymm1, %ymm6, %ymm1
vpor %ymm0, %ymm1, %ymm0
vtestps %ymm0, %ymm0
je 0x521a21
orb $0x40, 0xc(%rbx)
xorl %ecx, %ecx
xorl %esi, %esi
xorl %edx, %edx
jmp 0x521a31
vextracti128 $0x1, %ymm2, %xmm0
vpextrd $0x3, %xmm0, %ecx
movl 0x5c(%rsp), %edx
movl %ecx, (%rbx)
movl %edx, 0x4(%rbx)
movl %esi, 0x8(%rbx)
movq %rax, %rdi
vzeroupper
callq 0x2094b5
movq %r14, %rdi
callq 0x2094b5
movq %r13, %rdi
callq 0x2094b5
movq 0x30(%rsp), %rdi
callq 0x2094b5
movq %r15, %rdi
callq 0x2094b5
jmp 0x521aa0
callq 0x1ef727
jmp 0x521a9e
callq 0x1ef701
jmp 0x521a9e
callq 0x1ef6db
jmp 0x521a9e
callq 0x1ef6b5
jmp 0x521a9e
callq 0x1ef68f
jmp 0x521a9e
callq 0x1ef669
jmp 0x521a9e
callq 0x1ef643
jmp 0x521a9e
callq 0x1ef61d
xorl %ebx, %ebx
movq %rbx, %rax
leaq -0x28(%rbp), %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
nop