// File: /workspace/github_c_makefile_star2_O3/nh13[P]ksw/src/parasail/src/nw_striped_avx2_256_32.c
// Function: parasail_nw_table_striped_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;
    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;
    int32_t* restrict boundary = NULL;
    __m256i vGapO;
    __m256i vGapE;
    int32_t NEG_LIMIT = 0;
    int32_t POS_LIMIT = 0;
    int32_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->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;
    vProfile = (__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;
    score = NEG_LIMIT;
    vNegLimit = _mm256_set1_epi32(NEG_LIMIT);
    vPosLimit = _mm256_set1_epi32(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_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 */
    pvHStore = parasail_memalign___m256i(32, segLen);
    pvHLoad  = parasail_memalign___m256i(32, segLen);
    pvE      = parasail_memalign___m256i(32, segLen);
    boundary = parasail_memalign_int32_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_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(&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 < INT32_MIN ? INT32_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], 4);

        /* 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_epi32_rpl(vH, boundary[j], 0);

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

            /* Get max from vH, vE and vF. */
            vH = _mm256_max_epi32(vH, vE);
            vH = _mm256_max_epi32(vH, vF);
            /* Save vH values. */
            _mm256_store_si256(pvHStore + i, vH);
            vSaturationCheckMax = _mm256_max_epi32(vSaturationCheckMax, vH);
            vSaturationCheckMin = _mm256_min_epi32(vSaturationCheckMin, vH);
            vSaturationCheckMin = _mm256_min_epi32(vSaturationCheckMin, vE);
            vSaturationCheckMin = _mm256_min_epi32(vSaturationCheckMin, vF);
#ifdef PARASAIL_TABLE
            arr_store_si256(result->tables->score_table, vH, i, segLen, j, s2Len);
#endif

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

            /* Update vF value. */
            vF = _mm256_sub_epi32(vF, vGapE);
            vF = _mm256_max_epi32(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;
            int32_t tmp2 = tmp < INT32_MIN ? INT32_MIN : tmp;
            vF = _mm256_slli_si256_rpl(vF, 4);
            vF = _mm256_insert_epi32_rpl(vF, tmp2, 0);
            for (i=0; i<segLen; ++i) {
                vH = _mm256_load_si256(pvHStore + i);
                vH = _mm256_max_epi32(vH,vF);
                _mm256_store_si256(pvHStore + 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
                vH = _mm256_sub_epi32(vH, vGapO);
                vF = _mm256_sub_epi32(vF, vGapE);
                if (! _mm256_movemask_epi8(_mm256_cmpgt_epi32(vF, vH))) goto end;
                /*vF = _mm256_max_epi32(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, 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(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, 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(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 $0xa8, %rsp
movl %ecx, (%rsp)
movq %rsi, 0x58(%rsp)
testq %rdi, %rdi
je 0x50cd05
movq 0x48(%rdi), %rax
movq %rax, 0xa0(%rsp)
testq %rax, %rax
je 0x50cd0c
movq 0x10(%rdi), %rax
movq %rax, 0x50(%rsp)
testq %rax, %rax
je 0x50cd13
movl 0x8(%rdi), %edi
testl %edi, %edi
jle 0x50cd1a
cmpq $0x0, 0x58(%rsp)
je 0x50cd21
movl %edx, %r14d
testl %edx, %edx
jle 0x50cd28
cmpl $0x0, (%rsp)
js 0x50cd2f
movl %r8d, %r15d
testl %r8d, %r8d
js 0x50cd36
leal -0x1(%rdi), %r12d
addq $0x7, %rdi
movq %rdi, %rbx
shrq $0x3, %rbx
movl %r12d, %eax
xorl %edx, %edx
divl %ebx
movl %eax, 0x4(%rsp)
movl %edx, 0x3c(%rsp)
movl (%rsp), %ecx
movl %ecx, %r13d
negl %r13d
movq 0x50(%rsp), %rdx
movl 0x20(%rdx), %eax
movl $0x80000000, %ebp       # imm = 0x80000000
orl %ebp, %ecx
subl %eax, %ebp
cmpl %r13d, %eax
cmovgl %ecx, %ebp
movl $0x7ffffffe, %eax       # imm = 0x7FFFFFFE
subl 0x1c(%rdx), %eax
movl %eax, 0x20(%rsp)
andl $0x7ffffff8, %edi       # imm = 0x7FFFFFF8
movl %r14d, %esi
callq 0x20abc2
testq %rax, %rax
je 0x50cd3b
movl %r13d, 0x18(%rsp)
movl %r12d, 0x38(%rsp)
movq %rax, 0x10(%rsp)
orl $0x8420801, 0xc(%rax)   # imm = 0x8420801
movl $0x20, %edi
movq %rbx, %rsi
callq 0x4f1904
movq %rax, %r12
movl $0x20, %edi
movq %rbx, %rsi
callq 0x4f1904
movq %rax, %r13
movl $0x20, %edi
movq %rbx, %rsi
callq 0x4f1904
movq %rax, 0x28(%rsp)
leal 0x1(%r14), %esi
movl $0x20, %edi
callq 0x20a62d
movq 0x28(%rsp), %rdi
testq %r12, %r12
sete %dl
movq %r13, 0x8(%rsp)
testq %r13, %r13
sete %cl
orb %dl, %cl
testq %rdi, %rdi
sete %sil
movq %rax, 0x48(%rsp)
testq %rax, %rax
sete %dl
orb %sil, %dl
orb %cl, %dl
jne 0x50cd3b
leal -0x1(%r14), %eax
movl %eax, 0x30(%rsp)
movl $0x7, %eax
subl 0x4(%rsp), %eax
movl %eax, 0x34(%rsp)
movl (%rsp), %eax
vmovd %eax, %xmm0
vpbroadcastd %xmm0, %ymm2
vmovd %r15d, %xmm0
vpbroadcastd %xmm0, %ymm3
incl %ebp
vmovd %ebp, %xmm0
vpbroadcastd %xmm0, %ymm0
vmovd 0x20(%rsp), %xmm1
vpbroadcastd %xmm1, %ymm1
movl %eax, %eax
movl %ebx, %ecx
vmovd 0x18(%rsp), %xmm4
vpbroadcastd %xmm4, %ymm4
vmovq %rax, %xmm7
movq %rcx, 0x98(%rsp)
vmovq %rcx, %xmm5
vpbroadcastq %xmm5, %ymm6
vpmuldq 0x12140d(%rip), %ymm6, %ymm5 # 0x62dc40
vpmuldq 0x121304(%rip), %ymm6, %ymm6 # 0x62db40
vpbroadcastq %xmm7, %ymm7
xorl %eax, %eax
vpmovsxbd 0x12147c(%rip), %ymm8 # 0x62dcc8
vpbroadcastq 0x12146b(%rip), %ymm9 # 0x62dcc0
movq %r12, %rcx
movq %rdi, %rdx
vmovq %rax, %xmm10
vpbroadcastq %xmm10, %ymm10
vpaddq %ymm5, %ymm10, %ymm11
vpaddq %ymm6, %ymm10, %ymm10
vpermd %ymm10, %ymm8, %ymm10
vpermd %ymm11, %ymm8, %ymm11
vinserti128 $0x1, %xmm11, %ymm10, %ymm10
vpmulld %ymm10, %ymm3, %ymm10
vpsubd %ymm10, %ymm4, %ymm10
vextracti128 $0x1, %ymm10, %xmm11
vpmovsxdq %xmm11, %ymm11
vpmovsxdq %xmm10, %ymm12
vpsubq %ymm7, %ymm11, %ymm11
vpcmpgtq %ymm9, %ymm11, %ymm13
vblendvpd %ymm13, %ymm11, %ymm9, %ymm11
vpsubq %ymm7, %ymm12, %ymm12
vpcmpgtq %ymm9, %ymm12, %ymm13
vblendvpd %ymm13, %ymm12, %ymm9, %ymm12
vpermd %ymm12, %ymm8, %ymm12
vpermd %ymm11, %ymm8, %ymm11
vmovdqa %ymm10, (%rcx)
vmovdqa %xmm11, 0x10(%rdx)
vmovdqa %xmm12, (%rdx)
incq %rax
addq $0x20, %rdx
addq $0x20, %rcx
cmpq %rax, %rbx
jne 0x50c85b
movq 0x48(%rsp), %rdi
movl $0x0, (%rdi)
movl %r14d, %eax
addl $0x7, %r14d
andl $-0x8, %r14d
movq %rax, 0x40(%rsp)
decq %rax
vmovq %rax, %xmm5
vpbroadcastq %xmm5, %ymm9
vpmovsxbd 0x1213bf(%rip), %ymm5 # 0x62dcd0
xorl %eax, %eax
vpmovsxbq 0x1212ac(%rip), %ymm6 # 0x62dbc8
vpmovsxbq 0x1213bf(%rip), %ymm7 # 0x62dce4
vpbroadcastq 0x121252(%rip), %ymm8 # 0x62db80
vpxor %ymm8, %ymm9, %ymm9
vpcmpeqd %ymm10, %ymm10, %ymm10
vpbroadcastd 0x12139f(%rip), %ymm11 # 0x62dce0
vmovq %rax, %xmm12
vpbroadcastq %xmm12, %ymm12
vpor %ymm6, %ymm12, %ymm13
vpor %ymm7, %ymm12, %ymm12
vpxor %ymm8, %ymm12, %ymm12
vpcmpgtq %ymm9, %ymm12, %ymm12
vpxor %ymm8, %ymm13, %ymm13
vpcmpgtq %ymm9, %ymm13, %ymm13
vpackssdw %ymm12, %ymm13, %ymm12
vpxor %ymm10, %ymm12, %ymm12
vextracti128 $0x1, %ymm12, %xmm13
vpackssdw %xmm13, %xmm12, %xmm12
vpshufd $0xd8, %xmm12, %xmm12   # xmm12 = xmm12[0,2,1,3]
vpmovzxwd %xmm12, %ymm12  # ymm12 = xmm12[0],zero,xmm12[1],zero,xmm12[2],zero,xmm12[3],zero,xmm12[4],zero,xmm12[5],zero,xmm12[6],zero,xmm12[7],zero
vpslld $0x1f, %ymm12, %ymm12
vpaddd %ymm5, %ymm10, %ymm13
vpmulld %ymm3, %ymm13, %ymm13
vpsubd %ymm13, %ymm4, %ymm13
vpmaskmovd %ymm13, %ymm12, 0x4(%rdi,%rax,4)
addq $0x8, %rax
vpaddd %ymm5, %ymm11, %ymm5
cmpq %rax, %r14
jne 0x50c941
leal -0x1(%rbx), %r10d
movq %rbx, %rsi
movq 0x40(%rsp), %rax
imulq %rax, %rsi
leaq (,%rsi,4), %r8
leaq (,%rax,4), %r11
leaq (,%rsi,8), %rcx
leaq (%r8,%r8,2), %rdx
leaq (%rsi,%rsi,8), %rax
leaq (%rax,%rax,2), %r9
addq %rsi, %r9
shlq $0x4, %rsi
movq %rsi, 0x80(%rsp)
movq %r8, 0x88(%rsp)
leaq (%r8,%r8,4), %rsi
leaq (%rcx,%rcx,2), %rax
movq %rax, 0x70(%rsp)
shlq $0x5, %rbx
movq %rbx, 0x68(%rsp)
xorl %ebp, %ebp
shlq $0x5, %r10
movq %r10, 0x90(%rsp)
vpmovsxbd 0x1212b1(%rip), %ymm6 # 0x62dcd8
xorl %r8d, %r8d
vmovdqa %ymm0, %ymm4
vmovdqa %ymm1, %ymm5
movq 0x8(%rsp), %rax
movq %rcx, 0x20(%rsp)
movq %rdx, 0x18(%rsp)
movq %r11, 0x78(%rsp)
movq 0x88(%rsp), %r10
movq %rax, %rdx
movq 0x90(%rsp), %rax
vpermd (%r12,%rax), %ymm6, %ymm7
movq 0x50(%rsp), %rax
movq 0x10(%rax), %rax
movq 0x58(%rsp), %rbx
movzbl (%rbx,%r8), %ebx
movslq (%rax,%rbx,4), %rax
imulq 0x98(%rsp), %rax
shlq $0x5, %rax
addq 0xa0(%rsp), %rax
movq %r8, 0x60(%rsp)
vmovd (%rdi,%r8,4), %xmm8
movq %r12, %rdi
vpblendd $0x1, %ymm8, %ymm7, %ymm8 # ymm8 = ymm8[0],ymm7[1,2,3,4,5,6,7]
movq %rbp, 0x8(%rsp)
xorl %ebx, %ebx
vmovdqa %ymm0, %ymm7
movq 0x10(%rsp), %r15
movq 0x68(%rsp), %r13
movq 0x28(%rsp), %r12
movq 0x80(%rsp), %r8
movq 0x70(%rsp), %rcx
vpaddd (%rax,%rbx), %ymm8, %ymm8
vmovdqa (%r12,%rbx), %ymm9
vpmaxsd %ymm7, %ymm9, %ymm10
vpmaxsd %ymm10, %ymm8, %ymm8
vmovdqa %ymm8, (%rdx,%rbx)
movq 0x10(%r15), %r14
movq (%r14), %r14
vmovd %xmm8, (%r14,%rbp)
addq %rbp, %r14
vpextrd $0x1, %xmm8, (%r10,%r14)
movq 0x20(%rsp), %r11
vpextrd $0x2, %xmm8, (%r11,%r14)
movq 0x18(%rsp), %r11
vpextrd $0x3, %xmm8, (%r11,%r14)
vextracti128 $0x1, %ymm8, %xmm10
vmovd %xmm10, (%r8,%r14)
vpextrd $0x1, %xmm10, (%rsi,%r14)
vpextrd $0x2, %xmm10, (%rcx,%r14)
vpextrd $0x3, %xmm10, (%r9,%r14)
vpmaxsd %ymm8, %ymm4, %ymm4
vpminsd %ymm9, %ymm5, %ymm5
vpminsd %ymm7, %ymm5, %ymm5
vpminsd %ymm8, %ymm5, %ymm5
vpsubd %ymm2, %ymm8, %ymm8
vpsubd %ymm3, %ymm9, %ymm9
vpmaxsd %ymm8, %ymm9, %ymm9
vmovdqa %ymm9, (%r12,%rbx)
vpsubd %ymm3, %ymm7, %ymm7
vpmaxsd %ymm8, %ymm7, %ymm7
vmovdqa (%rdi,%rbx), %ymm8
addq $0x20, %rbx
addq 0x78(%rsp), %rbp
cmpq %rbx, %r13
jne 0x50cac6
movq %rdi, %r13
xorl %eax, %eax
movq %rdx, %r12
movq 0x48(%rsp), %rdi
movq 0x78(%rsp), %r11
movq 0x20(%rsp), %rcx
movq 0x18(%rsp), %rdx
movq 0x60(%rsp), %rbx
movl 0x4(%rdi,%rbx,4), %ebx
subl (%rsp), %ebx
vpermd %ymm7, %ymm6, %ymm7
vmovd %ebx, %xmm8
vpblendd $0x1, %ymm8, %ymm7, %ymm7 # ymm7 = ymm8[0],ymm7[1,2,3,4,5,6,7]
movq 0x8(%rsp), %rbx
xorl %ebp, %ebp
vpmaxsd (%r12,%rbp), %ymm7, %ymm8
vmovdqa %ymm8, (%r12,%rbp)
movq 0x10(%rsp), %r14
movq 0x10(%r14), %r14
movq (%r14), %r14
vmovd %xmm8, (%r14,%rbx)
addq %rbx, %r14
vpextrd $0x1, %xmm8, (%r10,%r14)
vpextrd $0x2, %xmm8, (%rcx,%r14)
vpextrd $0x3, %xmm8, (%rdx,%r14)
vextracti128 $0x1, %ymm8, %xmm9
vmovd %xmm9, (%r8,%r14)
vpextrd $0x1, %xmm9, (%rsi,%r14)
vpminsd %ymm8, %ymm5, %ymm5
movq 0x70(%rsp), %r15
vpextrd $0x2, %xmm9, (%r15,%r14)
vpmaxsd %ymm8, %ymm4, %ymm4
vpextrd $0x3, %xmm9, (%r9,%r14)
vpsubd %ymm2, %ymm8, %ymm8
vpsubd %ymm3, %ymm7, %ymm7
vpcmpgtd %ymm8, %ymm7, %ymm8
vtestps %ymm8, %ymm8
je 0x50cc4c
addq $0x20, %rbp
addq %r11, %rbx
cmpq %rbp, 0x68(%rsp)
jne 0x50cbb5
incl %eax
cmpl $0x8, %eax
jne 0x50cb93
movq 0x60(%rsp), %r8
incq %r8
movq 0x8(%rsp), %rbp
addq $0x4, %rbp
movq %r13, %rax
cmpq 0x40(%rsp), %r8
jne 0x50ca4e
movl 0x3c(%rsp), %eax
shlq $0x5, %rax
vmovdqa (%r12,%rax), %ymm2
cmpl $0x6, 0x4(%rsp)
jg 0x50cc9f
xorl %eax, %eax
movq 0x10(%rsp), %rbx
movl 0x34(%rsp), %ecx
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]
incl %eax
cmpl %ecx, %eax
jl 0x50cc8b
jmp 0x50cca4
movq 0x10(%rsp), %rbx
vpcmpgtd %ymm5, %ymm0, %ymm0
vpcmpgtd %ymm1, %ymm4, %ymm1
vpor %ymm0, %ymm1, %ymm0
vtestps %ymm0, %ymm0
je 0x50ccc3
orb $0x40, 0xc(%rbx)
vpxor %xmm0, %xmm0, %xmm0
xorl %eax, %eax
jmp 0x50ccda
vpermq $0xff, %ymm2, %ymm0     # ymm0 = ymm2[3,3,3,3]
vpshufd $0x55, %xmm0, %xmm0     # xmm0 = xmm0[1,1,1,1]
vpinsrd $0x1, 0x38(%rsp), %xmm0, %xmm0
movl 0x30(%rsp), %eax
vmovq %xmm0, (%rbx)
movl %eax, 0x8(%rbx)
vzeroupper
callq 0x20a60d
movq 0x28(%rsp), %rdi
callq 0x20a60d
movq %r13, %rdi
callq 0x20a60d
movq %r12, %rdi
callq 0x20a60d
jmp 0x50cd3d
callq 0x1e961f
jmp 0x50cd3b
callq 0x1e95f9
jmp 0x50cd3b
callq 0x1e95d3
jmp 0x50cd3b
callq 0x1e95ad
jmp 0x50cd3b
callq 0x1e9587
jmp 0x50cd3b
callq 0x1e9561
jmp 0x50cd3b
callq 0x1e953b
jmp 0x50cd3b
callq 0x1e9515
xorl %ebx, %ebx
movq %rbx, %rax
addq $0xa8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
nop