// File: /workspace/github_c_makefile_star2_O3/nh13[P]ksw/src/parasail/src/nw_scan_avx2_256_64.c
// Function: parasail_nw_rowcol_scan_profile_avx2_256_64
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;
    int64_t* restrict boundary = NULL;
    __m256i* restrict pvHt = NULL;
    __m256i* restrict pvH = NULL;
    __m256i* restrict pvGapper = NULL;
    __m256i vGapO;
    __m256i vGapE;
    int64_t NEG_LIMIT = 0;
    int64_t POS_LIMIT = 0;
    __m256i vZero;
    int64_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->profile64.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 = 4; /* number of values in vector unit */
    segLen = (s1Len + segWidth - 1) / segWidth;
    offset = (s1Len - 1) % segLen;
    position = (segWidth - 1) - (s1Len - 1) / segLen;
    pvP = (__m256i*)profile->profile64.score;
    vGapO = _mm256_set1_epi64x_rpl(open);
    vGapE = _mm256_set1_epi64x_rpl(gap);
    NEG_LIMIT = (-open < matrix->min ? INT64_MIN + open : INT64_MIN - matrix->min) + 1;
    POS_LIMIT = INT64_MAX - matrix->max - 1;
    vZero = _mm256_setzero_si256();
    score = NEG_LIMIT;
    vNegLimit = _mm256_set1_epi64x_rpl(NEG_LIMIT);
    vPosLimit = _mm256_set1_epi64x_rpl(POS_LIMIT);
    vSaturationCheckMin = vPosLimit;
    vSaturationCheckMax = vNegLimit;
    vNegInfFront = vZero;
    vNegInfFront = _mm256_insert_epi64_rpl(vNegInfFront, NEG_LIMIT, 0);
    vSegLenXgap = _mm256_add_epi64(vNegInfFront,
            _mm256_slli_si256_rpl(_mm256_set1_epi64x_rpl(-segLen*gap), 8));

    /* 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_64 | PARASAIL_FLAG_LANES_4;
#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_int64_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_64_t h;
            __m256i_64_t e;
            for (segNum=0; segNum<segWidth; ++segNum) {
                int64_t tmp = -open-gap*(segNum*segLen+i);
                h.v[segNum] = tmp < INT64_MIN ? INT64_MIN : tmp;
                tmp = tmp - open;
                e.v[segNum] = tmp < INT64_MIN ? INT64_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 < INT64_MIN ? INT64_MIN : tmp;
        }
    }

    {
        __m256i vGapper = _mm256_sub_epi64(vZero,vGapO);
        for (i=segLen-1; i>=0; --i) {
            _mm256_store_si256(pvGapper+i, vGapper);
            vGapper = _mm256_sub_epi64(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, 8);
        vHp = _mm256_insert_epi64_rpl(vHp, boundary[j], 0);
        pvW = pvP + matrix->mapper[(unsigned char)s2[j]]*segLen;
        vHt = _mm256_sub_epi64(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_epi64_rpl(
                    _mm256_sub_epi64(vE, vGapE),
                    _mm256_sub_epi64(vH, vGapO));
            vHp = _mm256_add_epi64(vHp, vW);
            vF = _mm256_max_epi64_rpl(vF, _mm256_add_epi64(vHt, pvGapper[i]));
            vHt = _mm256_max_epi64_rpl(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, 8);
        vHt = _mm256_insert_epi64_rpl(vHt, boundary[j+1], 0);
        vF = _mm256_max_epi64_rpl(vF, _mm256_add_epi64(vHt, pvGapper[0]));
        for (i=0; i<segWidth-2; ++i) {
            __m256i vFt = _mm256_slli_si256_rpl(vF, 8);
            vFt = _mm256_add_epi64(vFt, vSegLenXgap);
            vF = _mm256_max_epi64_rpl(vF, vFt);
        }

        /* calculate final H */
        vF = _mm256_slli_si256_rpl(vF, 8);
        vF = _mm256_add_epi64(vF, vNegInfFront);
        vH = _mm256_max_epi64_rpl(vHt, vF);
        for (i=0; i<segLen; ++i) {
            vHt = _mm256_load_si256(pvHt+i);
            vF = _mm256_max_epi64_rpl(
                    _mm256_sub_epi64(vF, vGapE),
                    _mm256_sub_epi64(vH, vGapO));
            vH = _mm256_max_epi64_rpl(vHt, vF);
            _mm256_store_si256(pvH+i, vH);
            vSaturationCheckMin = _mm256_min_epi64_rpl(vSaturationCheckMin, vH);
            vSaturationCheckMax = _mm256_max_epi64_rpl(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, 8);
            }
            result->rowcols->score_row[j] = (int64_t) _mm256_extract_epi64_rpl (vH, 3);
        }
#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, 8);
        }
        score = (int64_t) _mm256_extract_epi64_rpl (vH, 3);
    }

    if (_mm256_movemask_epi8(_mm256_or_si256(
            _mm256_cmplt_epi64_rpl(vSaturationCheckMin, vNegLimit),
            _mm256_cmpgt_epi64(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 $0x78, %rsp
movq %rsi, 0x30(%rsp)
testq %rdi, %rdi
je 0x54e5cc
movq 0x60(%rdi), %rax
movq %rax, 0x48(%rsp)
testq %rax, %rax
je 0x54e5d3
movq 0x10(%rdi), %rax
movq %rax, 0x28(%rsp)
testq %rax, %rax
je 0x54e5da
movl 0x8(%rdi), %edi
testl %edi, %edi
jle 0x54e5e1
cmpq $0x0, 0x30(%rsp)
je 0x54e5e8
movl %edx, %r15d
testl %edx, %edx
jle 0x54e5ef
movl %ecx, %r14d
testl %ecx, %ecx
js 0x54e5f6
movl %r8d, %r12d
testl %r8d, %r8d
js 0x54e5fd
leal -0x1(%rdi), %eax
addq $0x3, %rdi
movq %rdi, %rbx
shrq $0x2, %rbx
movl %eax, 0x24(%rsp)
xorl %edx, %edx
divl %ebx
movl %eax, 0x8(%rsp)
movl %edx, %ebp
movl %r14d, %ecx
negl %r14d
movq 0x28(%rsp), %rdx
movslq 0x20(%rdx), %rax
movq %rcx, 0x50(%rsp)
btsq $0x3f, %rcx
movabsq $-0x8000000000000000, %r13 # imm = 0x8000000000000000
subq %rax, %r13
cmpl %r14d, %eax
cmovgq %rcx, %r13
movslq 0x1c(%rdx), %rax
movq %rax, 0x40(%rsp)
andl $0x7ffffffc, %edi       # imm = 0x7FFFFFFC
movl %r15d, %esi
callq 0x20ac53
testq %rax, %rax
je 0x54e602
movq %r13, 0x38(%rsp)
movl %r12d, 0x18(%rsp)
movl %r14d, 0x1c(%rsp)
movl %ebp, 0x20(%rsp)
movq %rax, 0x10(%rsp)
orl $0x4840401, 0xc(%rax)   # imm = 0x4840401
movl $0x20, %edi
movq %rbx, %rsi
callq 0x4f1904
movq %rax, %r14
leal 0x1(%r15), %esi
movl $0x20, %edi
callq 0x20a636
movq %rax, %r12
movl $0x20, %edi
movq %rbx, %rsi
callq 0x4f1904
movq %rax, %r13
movl $0x20, %edi
movq %rbx, %rsi
callq 0x4f1904
movq %rax, %rbp
movl $0x20, %edi
movq %rbx, %rsi
callq 0x4f1904
testq %r14, %r14
sete %cl
testq %r12, %r12
sete %dl
orb %cl, %dl
testq %r13, %r13
sete %cl
testq %rbp, %rbp
sete %sil
orb %cl, %sil
orb %dl, %sil
testq %rax, %rax
sete %cl
orb %sil, %cl
jne 0x54e602
leal -0x1(%r15), %ecx
movl %ecx, 0xc(%rsp)
movl $0x3, %edx
subl 0x8(%rsp), %edx
vmovq 0x50(%rsp), %xmm0
vpbroadcastq %xmm0, %ymm2
movl 0x18(%rsp), %esi
movl %esi, %ecx
vmovq %rcx, %xmm0
vpbroadcastq %xmm0, %ymm3
movq 0x38(%rsp), %r8
incq %r8
movabsq $-0x8000000000000000, %rdi # imm = 0x8000000000000000
subq 0x40(%rsp), %rdi
addq $-0x2, %rdi
vmovq %r8, %xmm0
vpbroadcastq %xmm0, %ymm0
vmovq %rdi, %xmm1
vpbroadcastq %xmm1, %ymm1
vmovdqu %ymm1, 0x50(%rsp)
vmovq %xmm0, %xmm4            # xmm4 = xmm0[0],zero
imull %ebx, %esi
negl %esi
movslq %esi, %rsi
vmovq %rsi, %xmm5
vpbroadcastq %xmm5, %ymm5
vpxor %xmm6, %xmm6, %xmm6
vpblendd $0x3, %ymm6, %ymm5, %ymm5 # ymm5 = ymm6[0,1],ymm5[2,3,4,5,6,7]
vpaddq %ymm5, %ymm4, %ymm5
movslq 0x1c(%rsp), %rsi
vmovd %ebx, %xmm6
vpbroadcastd %xmm6, %ymm8
vmovq %rcx, %xmm6
vpbroadcastq %xmm6, %ymm6
vmovq %rsi, %xmm7
vpbroadcastq %xmm7, %ymm7
vpmuldq 0xdf957(%rip), %ymm8, %ymm8 # 0x62db40
xorl %ecx, %ecx
movq %rbp, %rsi
movq %r14, %rdi
vmovq %rcx, %xmm9
vpbroadcastq %xmm9, %ymm9
vpaddq %ymm9, %ymm8, %ymm9
vpmuludq %ymm6, %ymm9, %ymm10
vpsrlq $0x20, %ymm9, %ymm9
vpmuludq %ymm6, %ymm9, %ymm9
vpsllq $0x20, %ymm9, %ymm9
vpaddq %ymm9, %ymm10, %ymm9
vpsubq %ymm9, %ymm7, %ymm9
vpsubq %ymm2, %ymm9, %ymm10
vmovdqa %ymm9, (%rsi)
vmovdqa %ymm10, (%rdi)
incq %rcx
addq $0x20, %rdi
addq $0x20, %rsi
cmpq %rcx, %rbx
jne 0x54e1f1
movq $0x0, (%r12)
movl %r15d, %esi
addl $0x3, %r15d
andl $-0x4, %r15d
leaq -0x1(%rsi), %rcx
vmovq %rcx, %xmm8
vpbroadcastq %xmm8, %ymm11
vpmovsxbq 0xddbf8(%rip), %ymm8 # 0x62be5c
xorl %ecx, %ecx
vpmovsxbq 0xddb19(%rip), %ymm9 # 0x62bd88
vpbroadcastq 0xdf908(%rip), %ymm10 # 0x62db80
vpxor %ymm10, %ymm11, %ymm11
vpcmpeqd %ymm12, %ymm12, %ymm12
vpbroadcastq 0xdf8fd(%rip), %ymm13 # 0x62db88
vmovq %rcx, %xmm14
vpbroadcastq %xmm14, %ymm14
vpor %ymm9, %ymm14, %ymm14
vpxor %ymm10, %ymm14, %ymm14
vpcmpgtq %ymm11, %ymm14, %ymm14
vpxor %ymm12, %ymm14, %ymm14
vpaddq %ymm12, %ymm8, %ymm15
vpmuludq %ymm6, %ymm15, %ymm1
vpsrlq $0x20, %ymm15, %ymm15
vpmuludq %ymm6, %ymm15, %ymm15
vpsllq $0x20, %ymm15, %ymm15
vpaddq %ymm1, %ymm15, %ymm1
vpsubq %ymm1, %ymm7, %ymm1
vpmaskmovq %ymm1, %ymm14, 0x8(%r12,%rcx,8)
addq $0x4, %rcx
vpaddq %ymm13, %ymm8, %ymm8
cmpq %rcx, %r15
jne 0x54e28b
vpxor %xmm1, %xmm1, %xmm1
vpsubq %ymm2, %ymm1, %ymm6
leal -0x1(%rbx), %r8d
shlq $0x5, %r8
movq %rax, %rcx
addq %r8, %rcx
movl %ebx, %edi
vmovdqa %ymm6, (%rcx)
vpsubq %ymm3, %ymm6, %ymm6
addq $-0x20, %rcx
decl %edi
jg 0x54e2f7
addq %rbp, %r8
movl 0x20(%rsp), %edi
movq %rdi, %r9
shlq $0x5, %r9
addq %rbp, %r9
movl %ebx, %r10d
movq %r10, %r11
shlq $0x5, %r11
xorl %r15d, %r15d
vmovdqa %ymm0, %ymm6
vmovdqu 0x50(%rsp), %ymm14
vmovdqa %ymm14, %ymm7
movq %r15, %rbx
vmovdqa (%r8), %ymm1
vinserti128 $0x1, %xmm1, %ymm0, %ymm8
vpalignr $0x8, %ymm8, %ymm1, %ymm1 # ymm1 = ymm8[8,9,10,11,12,13,14,15],ymm1[0,1,2,3,4,5,6,7],ymm8[24,25,26,27,28,29,30,31],ymm1[16,17,18,19,20,21,22,23]
vmovq (%r12,%r15,8), %xmm8
vpblendd $0x3, %ymm8, %ymm1, %ymm10 # ymm10 = ymm8[0,1],ymm1[2,3,4,5,6,7]
movq 0x28(%rsp), %rcx
movq 0x10(%rcx), %rcx
movq 0x30(%rsp), %r15
movzbl (%r15,%rbx), %r15d
movslq (%rcx,%r15,4), %rcx
movq %r10, %r15
imulq %rcx, %r15
shlq $0x5, %r15
addq 0x48(%rsp), %r15
vpsubq (%rax), %ymm0, %ymm9
xorl %ecx, %ecx
vmovdqa %ymm0, %ymm8
vpaddq (%r15,%rcx), %ymm10, %ymm1
vmovdqa (%rbp,%rcx), %ymm10
vmovdqa (%r14,%rcx), %ymm11
vpsubq %ymm3, %ymm11, %ymm11
vpaddq (%rax,%rcx), %ymm9, %ymm9
vpsubq %ymm2, %ymm10, %ymm12
vpcmpgtq %ymm9, %ymm8, %ymm13
vblendvpd %ymm13, %ymm8, %ymm9, %ymm8
vpcmpgtq %ymm12, %ymm11, %ymm9
vblendvpd %ymm9, %ymm11, %ymm12, %ymm11
vpcmpgtq %ymm1, %ymm11, %ymm9
vblendvpd %ymm9, %ymm11, %ymm1, %ymm9
vmovaps %ymm11, (%r14,%rcx)
vmovapd %ymm9, (%r13,%rcx)
addq $0x20, %rcx
cmpq %rcx, %r11
jne 0x54e384
vpermpd $0x90, %ymm9, %ymm9     # ymm9 = ymm9[0,0,1,2]
leaq 0x1(%rbx), %r15
vmovsd 0x8(%r12,%rbx,8), %xmm10
vblendpd $0x1, %ymm10, %ymm9, %ymm1 # ymm1 = ymm10[0],ymm9[1,2,3]
vpaddq (%rax), %ymm1, %ymm1
vpcmpgtq %ymm1, %ymm8, %ymm11
vblendvpd %ymm11, %ymm8, %ymm1, %ymm8
movb $0x1, %cl
vperm2f128 $0x8, %ymm8, %ymm8, %ymm1 # ymm1 = zero,zero,ymm8[0,1]
vpalignr $0x8, %ymm1, %ymm8, %ymm1 # ymm1 = ymm1[8,9,10,11,12,13,14,15],ymm8[0,1,2,3,4,5,6,7],ymm1[24,25,26,27,28,29,30,31],ymm8[16,17,18,19,20,21,22,23]
vpaddq %ymm1, %ymm5, %ymm1
vpcmpgtq %ymm1, %ymm8, %ymm11
vblendvpd %ymm11, %ymm8, %ymm1, %ymm8
testb $0x1, %cl
movl $0x0, %ecx
jne 0x54e402
vperm2f128 $0x8, %ymm8, %ymm8, %ymm1 # ymm1 = zero,zero,ymm8[0,1]
vpalignr $0x8, %ymm1, %ymm8, %ymm1 # ymm1 = ymm1[8,9,10,11,12,13,14,15],ymm8[0,1,2,3,4,5,6,7],ymm1[24,25,26,27,28,29,30,31],ymm8[16,17,18,19,20,21,22,23]
vpaddq %ymm1, %ymm4, %ymm8
vblendpd $0x1, %ymm10, %ymm9, %ymm1 # ymm1 = ymm10[0],ymm9[1,2,3]
vpcmpgtq %ymm8, %ymm1, %ymm9
vblendvpd %ymm9, %ymm1, %ymm8, %ymm9
xorl %ecx, %ecx
vpsubq %ymm3, %ymm8, %ymm1
vpsubq %ymm2, %ymm9, %ymm8
vpcmpgtq %ymm8, %ymm1, %ymm9
vblendvpd %ymm9, %ymm1, %ymm8, %ymm8
vmovdqa (%r13,%rcx), %ymm1
vpcmpgtq %ymm8, %ymm1, %ymm9
vblendvpd %ymm9, %ymm1, %ymm8, %ymm9
vmovapd %ymm9, (%rbp,%rcx)
vpcmpgtq %ymm7, %ymm9, %ymm1
vblendvpd %ymm1, %ymm7, %ymm9, %ymm7
vpcmpgtq %ymm9, %ymm6, %ymm1
vblendvpd %ymm1, %ymm6, %ymm9, %ymm6
addq $0x20, %rcx
cmpq %rcx, %r11
jne 0x54e44a
vmovdqa (%r9), %ymm8
cmpl $0x2, 0x8(%rsp)
jg 0x54e4b4
xorl %ecx, %ecx
vperm2i128 $0x8, %ymm8, %ymm8, %ymm1 # ymm1 = zero,zero,ymm8[0,1]
vpalignr $0x8, %ymm1, %ymm8, %ymm8 # ymm8 = ymm1[8,9,10,11,12,13,14,15],ymm8[0,1,2,3,4,5,6,7],ymm1[24,25,26,27,28,29,30,31],ymm8[16,17,18,19,20,21,22,23]
incl %ecx
cmpl %edx, %ecx
jl 0x54e4a2
vextracti128 $0x1, %ymm8, %xmm1
movq 0x10(%rsp), %rcx
movq 0x10(%rcx), %rcx
movq (%rcx), %rcx
vpextrd $0x2, %xmm1, (%rcx,%rbx,4)
cmpq %rsi, %r15
jne 0x54e333
leaq (,%r10,4), %rcx
leaq (%rcx,%rcx,2), %rsi
leaq (,%r10,8), %r8
xorl %r9d, %r9d
movq 0x10(%rsp), %r11
movq 0x10(%r11), %r10
movq 0x8(%r10), %r10
vmovdqa (%rbp,%r9,8), %xmm1
vmovdqa 0x10(%rbp,%r9,8), %xmm2
vmovd %xmm1, (%r10,%r9)
addq %r9, %r10
vpextrd $0x2, %xmm1, (%rcx,%r10)
vmovd %xmm2, (%r8,%r10)
vpextrd $0x2, %xmm2, (%rsi,%r10)
addq $0x4, %r9
cmpq %r9, %rcx
jne 0x54e4f2
shlq $0x5, %rdi
vmovdqa (%rbp,%rdi), %ymm2
cmpl $0x2, 0x8(%rsp)
jg 0x54e559
xorl %ecx, %ecx
movl 0xc(%rsp), %esi
vperm2i128 $0x8, %ymm2, %ymm2, %ymm1 # ymm1 = zero,zero,ymm2[0,1]
vpalignr $0x8, %ymm1, %ymm2, %ymm2 # ymm2 = ymm1[8,9,10,11,12,13,14,15],ymm2[0,1,2,3,4,5,6,7],ymm1[24,25,26,27,28,29,30,31],ymm2[16,17,18,19,20,21,22,23]
incl %ecx
cmpl %edx, %ecx
jl 0x54e545
jmp 0x54e55d
movl 0xc(%rsp), %esi
vpcmpgtq %ymm7, %ymm0, %ymm0
vpcmpgtq %ymm14, %ymm6, %ymm1
vpor %ymm0, %ymm1, %ymm0
vtestpd %ymm0, %ymm0
je 0x54e57f
orb $0x40, 0xc(%r11)
xorl %ecx, %ecx
xorl %esi, %esi
xorl %edx, %edx
jmp 0x54e58f
vextracti128 $0x1, %ymm2, %xmm0
vpextrq $0x1, %xmm0, %rcx
movl 0x24(%rsp), %edx
movl %ecx, (%r11)
movl %edx, 0x4(%r11)
movl %esi, 0x8(%r11)
movq %rax, %rdi
vzeroupper
callq 0x20a60d
movq %rbp, %rdi
callq 0x20a60d
movq %r13, %rdi
callq 0x20a60d
movq %r12, %rdi
callq 0x20a60d
movq %r14, %rdi
callq 0x20a60d
movq 0x10(%rsp), %rax
jmp 0x54e604
callq 0x1ef06d
jmp 0x54e602
callq 0x1ef047
jmp 0x54e602
callq 0x1ef021
jmp 0x54e602
callq 0x1eeffb
jmp 0x54e602
callq 0x1eefd5
jmp 0x54e602
callq 0x1eefaf
jmp 0x54e602
callq 0x1eef89
jmp 0x54e602
callq 0x1eef63
xorl %eax, %eax
addq $0x78, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
nop