// File: /workspace/github_c_makefile_star2_O3/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
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x58, %rsp
movq %rsi, 0x40(%rsp)
testq %rdi, %rdi
je 0x550142
movq 0x48(%rdi), %rax
movq %rax, 0x50(%rsp)
testq %rax, %rax
je 0x550149
movq 0x10(%rdi), %rax
movq %rax, 0x38(%rsp)
testq %rax, %rax
je 0x550150
movl 0x8(%rdi), %edi
testl %edi, %edi
jle 0x550157
cmpq $0x0, 0x40(%rsp)
je 0x55015e
movl %edx, %r13d
testl %edx, %edx
jle 0x550165
movl %ecx, %r15d
testl %ecx, %ecx
js 0x55016c
movl %r8d, %r12d
testl %r8d, %r8d
js 0x550173
leal -0x1(%rdi), %ebp
addq $0x7, %rdi
movq %rdi, %rcx
shrq $0x3, %rcx
movl %ebp, %eax
xorl %edx, %edx
movq %rcx, 0x18(%rsp)
divl %ecx
movl %eax, 0x4(%rsp)
movl %edx, %r14d
movl %r15d, %esi
negl %esi
movq 0x38(%rsp), %rdx
movl 0x20(%rdx), %eax
movl $0x80000000, %ebx       # imm = 0x80000000
movl %r15d, %ecx
orl %ebx, %ecx
subl %eax, %ebx
movl %esi, 0x10(%rsp)
cmpl %esi, %eax
cmovgl %ecx, %ebx
movl $0x7ffffffe, %eax       # imm = 0x7FFFFFFE
subl 0x1c(%rdx), %eax
movl %eax, 0x34(%rsp)
andl $0x7ffffff8, %edi       # imm = 0x7FFFFFF8
movl %r13d, %esi
callq 0x20ac53
testq %rax, %rax
je 0x550178
movl %r12d, 0x28(%rsp)
movl %r15d, 0x2c(%rsp)
movl %r14d, 0x30(%rsp)
movl %ebp, 0x24(%rsp)
movq %rax, 0x8(%rsp)
orl $0x8440401, 0xc(%rax)   # imm = 0x8440401
movl $0x20, %edi
movq %r13, %r15
movq 0x18(%rsp), %r13
movq %r13, %rsi
callq 0x4f1904
movq %rax, %r14
movq %r15, 0x48(%rsp)
leal 0x1(%r15), %esi
movl $0x20, %edi
callq 0x20a62d
movq %rax, %r15
movl $0x20, %edi
movq %r13, %rsi
callq 0x4f1904
movq %rax, %r12
movl $0x20, %edi
movq %r13, %rsi
callq 0x4f1904
movq %rax, %rbp
movl $0x20, %edi
movq %r13, %rsi
callq 0x4f1904
testq %r14, %r14
sete %cl
testq %r15, %r15
sete %dl
orb %cl, %dl
testq %r12, %r12
sete %cl
testq %rbp, %rbp
sete %sil
orb %cl, %sil
orb %dl, %sil
testq %rax, %rax
sete %cl
orb %sil, %cl
jne 0x550178
movq 0x48(%rsp), %r9
leal -0x1(%r9), %ecx
movl %ecx, 0x20(%rsp)
movl $0x7, %edx
subl 0x4(%rsp), %edx
movl 0x2c(%rsp), %ecx
vmovd %ecx, %xmm0
vpbroadcastd %xmm0, %ymm2
movl 0x28(%rsp), %esi
vmovd %esi, %xmm0
vpbroadcastd %xmm0, %ymm3
incl %ebx
vmovd %ebx, %xmm0
vpbroadcastd %xmm0, %ymm0
vmovd 0x34(%rsp), %xmm1
vpbroadcastd %xmm1, %ymm1
vxorps %xmm4, %xmm4, %xmm4
vmovss %xmm0, %xmm4, %xmm4     # xmm4 = xmm0[0],xmm4[1,2,3]
movq 0x18(%rsp), %r10
imull %r10d, %esi
negl %esi
vmovd %esi, %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 %ecx, %ecx
movl %r10d, %esi
vmovd 0x10(%rsp), %xmm6
vpbroadcastd %xmm6, %ymm6
vmovq %rcx, %xmm9
vmovq %rsi, %xmm7
vpbroadcastq %xmm7, %ymm8
vpmuldq 0xddf56(%rip), %ymm8, %ymm7 # 0x62dc40
vpmuldq 0xdde4d(%rip), %ymm8, %ymm8 # 0x62db40
vpbroadcastq %xmm9, %ymm9
xorl %ecx, %ecx
vpmovsxbd 0xddfc5(%rip), %ymm10 # 0x62dcc8
vpbroadcastq 0xddfb4(%rip), %ymm11 # 0x62dcc0
movq %rbp, %rdi
movq %r14, %r8
vmovq %rcx, %xmm12
vpbroadcastq %xmm12, %ymm12
vpaddq %ymm7, %ymm12, %ymm13
vpaddq %ymm12, %ymm8, %ymm12
vpermd %ymm12, %ymm10, %ymm12
vpermd %ymm13, %ymm10, %ymm13
vinserti128 $0x1, %xmm13, %ymm12, %ymm12
vpmulld %ymm12, %ymm3, %ymm12
vpsubd %ymm12, %ymm6, %ymm12
vextracti128 $0x1, %ymm12, %xmm13
vpmovsxdq %xmm13, %ymm13
vpmovsxdq %xmm12, %ymm14
vpsubq %ymm9, %ymm13, %ymm13
vpcmpgtq %ymm11, %ymm13, %ymm15
vblendvpd %ymm15, %ymm13, %ymm11, %ymm13
vpsubq %ymm9, %ymm14, %ymm14
vpcmpgtq %ymm11, %ymm14, %ymm15
vblendvpd %ymm15, %ymm14, %ymm11, %ymm14
vpermd %ymm14, %ymm10, %ymm14
vpermd %ymm13, %ymm10, %ymm13
vmovdqa %ymm12, (%rdi)
vmovdqa %xmm13, 0x10(%r8)
vmovdqa %xmm14, (%r8)
incq %rcx
addq $0x20, %r8
addq $0x20, %rdi
cmpq %rcx, %r10
jne 0x54fd12
movl $0x0, (%r15)
movl %r9d, %edi
addl $0x7, %r9d
andl $-0x8, %r9d
leaq -0x1(%rdi), %rcx
vmovq %rcx, %xmm7
vpbroadcastq %xmm7, %ymm11
vpmovsxbd 0xddf0b(%rip), %ymm7 # 0x62dcd0
xorl %ecx, %ecx
vpmovsxbq 0xdddf8(%rip), %ymm8 # 0x62dbc8
vpmovsxbq 0xddf0b(%rip), %ymm9 # 0x62dce4
vpbroadcastq 0xddd9e(%rip), %ymm10 # 0x62db80
vpxor %ymm10, %ymm11, %ymm11
vpcmpeqd %ymm12, %ymm12, %ymm12
vpbroadcastd 0xddeeb(%rip), %ymm13 # 0x62dce0
vmovq %rcx, %xmm14
vpbroadcastq %xmm14, %ymm14
vpor %ymm8, %ymm14, %ymm15
vpor %ymm9, %ymm14, %ymm14
vpxor %ymm10, %ymm14, %ymm14
vpcmpgtq %ymm11, %ymm14, %ymm14
vpxor %ymm10, %ymm15, %ymm15
vpcmpgtq %ymm11, %ymm15, %ymm15
vpackssdw %ymm14, %ymm15, %ymm14
vpxor %ymm12, %ymm14, %ymm14
vextracti128 $0x1, %ymm14, %xmm15
vpackssdw %xmm15, %xmm14, %xmm14
vpshufd $0xd8, %xmm14, %xmm14   # xmm14 = xmm14[0,2,1,3]
vpmovzxwd %xmm14, %ymm14  # ymm14 = xmm14[0],zero,xmm14[1],zero,xmm14[2],zero,xmm14[3],zero,xmm14[4],zero,xmm14[5],zero,xmm14[6],zero,xmm14[7],zero
vpslld $0x1f, %ymm14, %ymm14
vpaddd %ymm7, %ymm12, %ymm15
vpmulld %ymm3, %ymm15, %ymm15
vpsubd %ymm15, %ymm6, %ymm15
vpmaskmovd %ymm15, %ymm14, 0x4(%r15,%rcx,4)
addq $0x8, %rcx
vpaddd %ymm7, %ymm13, %ymm7
cmpq %rcx, %r9
jne 0x54fdf5
vpxor %xmm6, %xmm6, %xmm6
vpsubd %ymm2, %ymm6, %ymm6
leal -0x1(%r10), %r9d
shlq $0x5, %r9
movq %rax, %rcx
addq %r9, %rcx
movl %r10d, %r8d
vmovdqa %ymm6, (%rcx)
vpsubd %ymm3, %ymm6, %ymm6
addq $-0x20, %rcx
decl %r8d
jg 0x54fe7e
addq %rbp, %r9
movl 0x30(%rsp), %r10d
movq %r10, 0x10(%rsp)
shlq $0x5, %r10
addq %rbp, %r10
movq %rsi, %r11
shlq $0x5, %r11
xorl %ecx, %ecx
vpmovsxbd 0xdde23(%rip), %ymm8 # 0x62dcd8
vmovdqa %ymm0, %ymm6
vmovdqa %ymm1, %ymm7
movq 0x8(%rsp), %r8
vpermd (%r9), %ymm8, %ymm9
movq %rcx, %r13
vmovd (%r15,%rcx,4), %xmm10
vpblendd $0x1, %ymm10, %ymm9, %ymm11 # ymm11 = ymm10[0],ymm9[1,2,3,4,5,6,7]
movq 0x38(%rsp), %rcx
movq 0x10(%rcx), %rcx
movq 0x40(%rsp), %rbx
movzbl (%rbx,%r13), %ebx
movslq (%rcx,%rbx,4), %rbx
movq %rsi, %rcx
imulq %rbx, %rcx
shlq $0x5, %rcx
addq 0x50(%rsp), %rcx
vpsubd (%rax), %ymm0, %ymm10
xorl %ebx, %ebx
vmovdqa %ymm0, %ymm9
vpaddd (%rcx,%rbx), %ymm11, %ymm11
vmovdqa (%rbp,%rbx), %ymm12
vmovdqa (%r14,%rbx), %ymm13
vpsubd %ymm3, %ymm13, %ymm13
vpsubd %ymm2, %ymm12, %ymm14
vpmaxsd %ymm14, %ymm13, %ymm13
vpaddd (%rax,%rbx), %ymm10, %ymm10
vpmaxsd %ymm10, %ymm9, %ymm9
vpmaxsd %ymm11, %ymm13, %ymm10
vmovdqa %ymm13, (%r14,%rbx)
vmovdqa %ymm10, (%r12,%rbx)
addq $0x20, %rbx
vmovdqa %ymm12, %ymm11
cmpq %rbx, %r11
jne 0x54ff07
vpermd %ymm10, %ymm8, %ymm10
leaq 0x1(%r13), %rcx
vmovd 0x4(%r15,%r13,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, %ebx
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 %ebx
jne 0x54ff72
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 %ebx, %ebx
vpsubd %ymm3, %ymm9, %ymm9
vpsubd %ymm2, %ymm10, %ymm10
vpmaxsd %ymm10, %ymm9, %ymm9
vpmaxsd (%r12,%rbx), %ymm9, %ymm10
vmovdqa %ymm10, (%rbp,%rbx)
vpminsd %ymm10, %ymm7, %ymm7
vpmaxsd %ymm10, %ymm6, %ymm6
addq $0x20, %rbx
cmpq %rbx, %r11
jne 0x54ffa2
vmovdqa (%r10), %ymm9
cmpl $0x6, 0x4(%rsp)
jg 0x54ffee
xorl %ebx, %ebx
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]
incl %ebx
cmpl %edx, %ebx
jl 0x54ffdc
vextracti128 $0x1, %ymm9, %xmm9
movq 0x10(%r8), %rbx
movq (%rbx), %rbx
vpextrd $0x3, %xmm9, (%rbx,%r13,4)
cmpq %rdi, %rcx
jne 0x54fec2
movq 0x18(%rsp), %rcx
leal (,%rcx,4), %ecx
leaq (%rsi,%rsi,8), %rdi
leaq (%rdi,%rdi,2), %rdi
addq %rsi, %rdi
leaq (,%rsi,8), %r9
leaq (%r9,%r9,2), %r10
leal (,%rsi,4), %ebx
leaq (%rbx,%rbx,4), %r11
shlq $0x4, %rsi
leaq (%rbx,%rbx,2), %rbx
xorl %r13d, %r13d
movq 0x8(%rsp), %r8
movq 0x10(%r8), %r8
movq 0x8(%r8), %r8
vmovdqa (%rbp,%r13,8), %xmm2
vmovdqa 0x10(%rbp,%r13,8), %xmm3
vmovd %xmm2, (%r8,%r13)
addq %r13, %r8
vpextrd $0x1, %xmm2, (%rcx,%r8)
vpextrd $0x2, %xmm2, (%r9,%r8)
vpextrd $0x3, %xmm2, (%rbx,%r8)
vmovd %xmm3, (%rsi,%r8)
vpextrd $0x1, %xmm3, (%r11,%r8)
vpextrd $0x2, %xmm3, (%r10,%r8)
vpextrd $0x3, %xmm3, (%rdi,%r8)
movq 0x8(%rsp), %r8
addq $0x4, %r13
cmpq %r13, %rcx
jne 0x550044
movq 0x10(%rsp), %rcx
shlq $0x5, %rcx
vmovdqa (%rbp,%rcx), %ymm2
cmpl $0x6, 0x4(%rsp)
jg 0x5500d0
xorl %ecx, %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 %ecx
cmpl %edx, %ecx
jl 0x5500be
vpcmpgtd %ymm7, %ymm0, %ymm0
vpcmpgtd %ymm1, %ymm6, %ymm1
vpor %ymm0, %ymm1, %ymm0
vtestps %ymm0, %ymm0
je 0x5500f0
orb $0x40, 0xc(%r8)
vpxor %xmm0, %xmm0, %xmm0
xorl %ecx, %ecx
jmp 0x550107
vpermq $0xff, %ymm2, %ymm0     # ymm0 = ymm2[3,3,3,3]
vpshufd $0x55, %xmm0, %xmm0     # xmm0 = xmm0[1,1,1,1]
vpinsrd $0x1, 0x24(%rsp), %xmm0, %xmm0
movl 0x20(%rsp), %ecx
vmovq %xmm0, (%r8)
movl %ecx, 0x8(%r8)
movq %rax, %rdi
vzeroupper
callq 0x20a60d
movq %rbp, %rdi
callq 0x20a60d
movq %r12, %rdi
callq 0x20a60d
movq %r15, %rdi
callq 0x20a60d
movq %r14, %rdi
callq 0x20a60d
movq 0x8(%rsp), %rax
jmp 0x55017a
callq 0x1ef71b
jmp 0x550178
callq 0x1ef6f5
jmp 0x550178
callq 0x1ef6cf
jmp 0x550178
callq 0x1ef6a9
jmp 0x550178
callq 0x1ef683
jmp 0x550178
callq 0x1ef65d
jmp 0x550178
callq 0x1ef637
jmp 0x550178
callq 0x1ef611
xorl %eax, %eax
addq $0x58, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
nopl (%rax)