// File: /workspace/github_c_makefile_star2_O1/nh13[P]ksw/src/parasail/src/nw_trace_scan_avx2_256_32.c
// Function: parasail_nw_trace_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;
    __m256i vTIns;
    __m256i vTDel;
    __m256i vTDiag;
    __m256i vTDiagE;
    __m256i vTInsE;
    __m256i vTDiagF;
    __m256i vTDelF;

    /* 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;
    vTIns  = _mm256_set1_epi32(PARASAIL_INS);
    vTDel  = _mm256_set1_epi32(PARASAIL_DEL);
    vTDiag = _mm256_set1_epi32(PARASAIL_DIAG);
    vTDiagE = _mm256_set1_epi32(PARASAIL_DIAG_E);
    vTInsE = _mm256_set1_epi32(PARASAIL_INS_E);
    vTDiagF = _mm256_set1_epi32(PARASAIL_DIAG_F);
    vTDelF = _mm256_set1_epi32(PARASAIL_DEL_F);
    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 */
    result = parasail_result_new_trace(segLen, s2Len, 32, sizeof(__m256i));
    if (!result) return NULL;

    /* set known flags */
    result->flag |= PARASAIL_FLAG_NW | PARASAIL_FLAG_SCAN
        | PARASAIL_FLAG_TRACE
        | PARASAIL_FLAG_BITS_32 | PARASAIL_FLAG_LANES_8;

    /* 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 vE_ext;
        __m256i vE_opn;
        __m256i vHt;
        __m256i vF;
        __m256i vF_ext;
        __m256i vF_opn;
        __m256i vH;
        __m256i vHp;
        __m256i *pvW;
        __m256i vW;
        __m256i case1;
        __m256i case2;
        __m256i vGapper;
        __m256i vT;
        __m256i vET;
        __m256i vFT;

        /* 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);
            vGapper = _mm256_load_si256(pvGapper+i);
            vE_opn = _mm256_sub_epi32(vH, vGapO);
            vE_ext = _mm256_sub_epi32(vE, vGapE);
            case1 = _mm256_cmpgt_epi32(vE_opn, vE_ext);
            vET = _mm256_blendv_epi8(vTInsE, vTDiagE, case1);
            arr_store(result->trace->trace_table, vET, i, segLen, j);
            vE = _mm256_max_epi32(vE_opn, vE_ext);
            vSaturationCheckMin = _mm256_min_epi32(vSaturationCheckMin, vE);
            vGapper = _mm256_add_epi32(vHt, vGapper);
            vF = _mm256_max_epi32(vF, vGapper);
            vHp = _mm256_add_epi32(vHp, vW);
            vHt = _mm256_max_epi32(vE, vHp);
            _mm256_store_si256(pvE+i, vE);
            _mm256_store_si256(pvHt+i, vHt);
            _mm256_store_si256(pvH+i, vHp);
            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);
        vGapper = _mm256_load_si256(pvGapper);
        vGapper = _mm256_add_epi32(vHt, vGapper);
        vF = _mm256_max_epi32(vF, vGapper);
        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(vF, vHt);
        for (i=0; i<segLen; ++i) {
            vET = arr_load(result->trace->trace_table, i, segLen, j);
            vHp = _mm256_load_si256(pvH+i);
            vHt = _mm256_load_si256(pvHt+i);
            vF_opn = _mm256_sub_epi32(vH, vGapO);
            vF_ext = _mm256_sub_epi32(vF, vGapE);
            vF = _mm256_max_epi32(vF_opn, vF_ext);
            case1 = _mm256_cmpgt_epi32(vF_opn, vF_ext);
            vFT = _mm256_blendv_epi8(vTDelF, vTDiagF, case1);
            vH = _mm256_max_epi32(vHt, vF);
            case1 = _mm256_cmpeq_epi32(vH, vHp);
            case2 = _mm256_cmpeq_epi32(vH, vF);
            vT = _mm256_blendv_epi8(
                    _mm256_blendv_epi8(vTIns, vTDel, case2),
                    vTDiag, case1);
            vT = _mm256_or_si256(vT, vET);
            vT = _mm256_or_si256(vT, vFT);
            arr_store(result->trace->trace_table, vT, i, segLen, j);
            _mm256_store_si256(pvH+i, vH);
            vSaturationCheckMin = _mm256_min_epi32(vSaturationCheckMin, vH);
            vSaturationCheckMin = _mm256_min_epi32(vSaturationCheckMin, vF);
            vSaturationCheckMax = _mm256_max_epi32(vSaturationCheckMax, vH);
        }
    }

    /* 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 $0x180, %rsp            # imm = 0x180
movq %rsi, 0x48(%rsp)
testq %rdi, %rdi
je 0x577db2
movq 0x48(%rdi), %rax
movq %rax, 0x58(%rsp)
testq %rax, %rax
je 0x577db9
movq 0x10(%rdi), %rax
movq %rax, 0x40(%rsp)
testq %rax, %rax
je 0x577dc0
movl 0x8(%rdi), %r12d
testl %r12d, %r12d
jle 0x577dc7
cmpq $0x0, 0x48(%rsp)
je 0x577dce
movl %edx, %r9d
testl %edx, %edx
jle 0x577dd5
testl %ecx, %ecx
js 0x577ddc
testl %r8d, %r8d
js 0x577de3
movl %r8d, 0xc0(%rsp)
leal -0x1(%r12), %r14d
addq $0x7, %r12
shrq $0x3, %r12
movl %r14d, %eax
cltd
idivl %r12d
movl %eax, %r15d
movl %edx, %r13d
movl %ecx, %esi
negl %esi
movq 0x40(%rsp), %rdx
movl 0x20(%rdx), %eax
movl $0x80000000, %edi       # imm = 0x80000000
movl %ecx, 0x20(%rsp)
orl %edi, %ecx
subl %eax, %edi
movl %esi, 0xa0(%rsp)
cmpl %esi, %eax
cmovgl %ecx, %edi
movl %edi, 0x80(%rsp)
movl $0x7ffffffe, %eax       # imm = 0x7FFFFFFE
subl 0x1c(%rdx), %eax
movl %eax, 0xe0(%rsp)
movl $0x20, %edx
movl $0x20, %ecx
movl %r12d, %edi
movl %r9d, %esi
movq %r9, 0x60(%rsp)
callq 0x2097d1
testq %rax, %rax
je 0x577de8
movq %rax, %rbx
movl %r13d, 0x3c(%rsp)
movl %r15d, 0x30(%rsp)
movl %r14d, 0x38(%rsp)
orl $0x8480401, 0xc(%rax)   # imm = 0x8480401
movl $0x20, %edi
movq %r12, %rsi
callq 0x4c5e3c
movq %rax, %r13
movq 0x60(%rsp), %rax
leal 0x1(%rax), %esi
movl $0x20, %edi
movq %rsi, 0x50(%rsp)
callq 0x2094d5
movq %rax, 0x18(%rsp)
movl $0x20, %edi
movq %r12, %rsi
callq 0x4c5e3c
movq %rax, %r15
movl $0x20, %edi
movq %r12, %rsi
callq 0x4c5e3c
movq %rax, %r14
movl $0x20, %edi
movq %r12, %rsi
callq 0x4c5e3c
testq %r13, %r13
sete %cl
cmpq $0x0, 0x18(%rsp)
sete %dl
orb %cl, %dl
testq %r15, %r15
sete %cl
testq %r14, %r14
sete %sil
orb %cl, %sil
orb %dl, %sil
testq %rax, %rax
sete %cl
orb %sil, %cl
jne 0x577de8
movq 0x60(%rsp), %rcx
decl %ecx
movl %ecx, 0x2c(%rsp)
movl $0x7, %ecx
subl 0x30(%rsp), %ecx
movl %ecx, 0x34(%rsp)
movl 0x20(%rsp), %edx
vmovd %edx, %xmm0
vpbroadcastd %xmm0, %ymm2
movl 0xc0(%rsp), %ecx
vmovd %ecx, %xmm0
vpbroadcastd %xmm0, %ymm3
movl 0x80(%rsp), %esi
incl %esi
vmovd %esi, %xmm0
vpbroadcastd %xmm0, %ymm0
vmovss 0xe0(%rsp), %xmm1
vbroadcastss %xmm1, %ymm7
vxorps %xmm1, %xmm1, %xmm1
vmovdqa %ymm0, 0x80(%rsp)
vmovss %xmm0, %xmm1, %xmm0     # xmm0 = xmm0[0],xmm1[1,2,3]
movl %r12d, %edi
imull %ecx, %edi
movl %edi, %ecx
negl %ecx
vmovd %ecx, %xmm1
vpbroadcastd %xmm1, %ymm1
vpxor %xmm4, %xmm4, %xmm4
vpblendd $0x1, %ymm4, %ymm1, %ymm1 # ymm1 = ymm4[0],ymm1[1,2,3,4,5,6,7]
vmovaps %ymm0, 0xe0(%rsp)
vpaddd %ymm1, %ymm0, %ymm9
movl %edx, %ecx
movl %r12d, %edx
movq %rdx, 0x20(%rsp)
xorl %edx, %edx
movq $-0x80000000, %r8       # imm = 0x80000000
movl 0xa0(%rsp), %r9d
movl %r9d, %r10d
xorl %r11d, %r11d
movslq %r10d, %r10
movl %r10d, 0x140(%rsp,%r11,4)
movq %r10, %rsi
subq %rcx, %rsi
cmpq $-0x7fffffff, %rsi      # imm = 0x80000001
cmovlq %r8, %rsi
movl %esi, 0x120(%rsp,%r11,4)
incq %r11
subl %edi, %r10d
cmpq $0x8, %r11
jne 0x5779eb
movq %rdx, %rsi
shlq $0x5, %rsi
vmovaps 0x140(%rsp), %ymm1
vmovaps %ymm1, (%r14,%rsi)
vmovdqa 0x120(%rsp), %ymm1
vmovdqa %ymm1, (%r13,%rsi)
incq %rdx
movl 0xc0(%rsp), %esi
subl %esi, %r9d
cmpq 0x20(%rsp), %rdx
jne 0x5779e5
movq 0x18(%rsp), %rdx
movl $0x0, (%rdx)
movl $0x1, %ecx
movl 0xa0(%rsp), %edi
movq 0x50(%rsp), %r8
movl %edi, (%rdx,%rcx,4)
incq %rcx
subl %esi, %edi
cmpq %rcx, %r8
jne 0x577a71
vpxor %xmm1, %xmm1, %xmm1
vpsubd %ymm2, %ymm1, %ymm1
leal -0x1(%r12), %ecx
movq %rcx, %rsi
shlq $0x5, %rsi
movq %rax, %rdx
addq %rsi, %rdx
movl %r12d, %edi
movq 0x60(%rsp), %rsi
vmovdqa %ymm1, (%rdx)
vpsubd %ymm3, %ymm1, %ymm1
addq $-0x20, %rdx
decl %edi
jg 0x577aa0
movl %ecx, %ecx
shlq $0x5, %rcx
movq %r14, %rdi
addq %rcx, %rdi
cmpl $0x1, %r12d
adcl $0x0, %r12d
cmpl $0x2, %esi
movl $0x1, %r8d
cmovgel %esi, %r8d
movq 0x20(%rsp), %r9
shlq $0x5, %r9
shlq $0x5, %r12
xorl %r10d, %r10d
vbroadcastss 0x81f16(%rip), %ymm15 # 0x5f9a00
vpbroadcastd 0x83911(%rip), %ymm0 # 0x5fb404
vmovdqa %ymm0, 0xc0(%rsp)
vbroadcastss 0x83903(%rip), %ymm10 # 0x5fb408
vbroadcastss 0x838fe(%rip), %ymm12 # 0x5fb40c
vpbroadcastd 0x838f9(%rip), %ymm13 # 0x5fb410
vbroadcastss 0x838f4(%rip), %ymm14 # 0x5fb414
xorl %r11d, %r11d
vmovdqa 0x80(%rsp), %ymm6
vmovaps %ymm7, 0xa0(%rsp)
movq 0x18(%rsp), %rsi
vmovdqa %ymm9, 0x100(%rsp)
vmovaps %ymm10, 0x60(%rsp)
vmovaps 0xc0(%rsp), %ymm11
vpmovsxbd 0x81c25(%rip), %ymm0 # 0x5f9780
vpermd (%rdi), %ymm0, %ymm1
vmovd (%rsi,%r11,4), %xmm4
vpblendd $0x1, %ymm4, %ymm1, %ymm8 # ymm8 = ymm4[0],ymm1[1,2,3,4,5,6,7]
movq 0x40(%rsp), %rcx
movq 0x10(%rcx), %rcx
movq 0x48(%rsp), %rdx
movzbl (%rdx,%r11), %edx
movslq (%rcx,%rdx,4), %rcx
imulq 0x20(%rsp), %rcx
shlq $0x5, %rcx
addq 0x58(%rsp), %rcx
vmovaps %ymm15, %ymm10
vmovdqa 0x80(%rsp), %ymm15
vpsubd (%rax), %ymm15, %ymm1
xorl %edx, %edx
vpaddd (%rcx,%rdx), %ymm8, %ymm4
vmovdqa (%r14,%rdx), %ymm8
vmovdqa (%r13,%rdx), %ymm0
vpsubd %ymm2, %ymm8, %ymm5
vpsubd %ymm3, %ymm0, %ymm0
vpcmpgtd %ymm0, %ymm5, %ymm9
vblendvps %ymm9, %ymm10, %ymm11, %ymm9
movq 0x10(%rbx), %rsi
movq (%rsi), %rsi
addq %r10, %rsi
vpaddd (%rax,%rdx), %ymm1, %ymm1
vmovaps %ymm9, (%rdx,%rsi)
vpmaxsd %ymm1, %ymm15, %ymm15
vpmaxsd %ymm0, %ymm5, %ymm0
vpminsd %ymm0, %ymm7, %ymm7
vpmaxsd %ymm4, %ymm0, %ymm1
vmovdqa %ymm0, (%r13,%rdx)
vmovdqa %ymm1, (%r15,%rdx)
vmovdqa %ymm4, (%r14,%rdx)
addq $0x20, %rdx
cmpq %rdx, %r12
jne 0x577ba6
vpmovsxbd 0x81b69(%rip), %ymm0 # 0x5f9780
vpermd %ymm1, %ymm0, %ymm0
movq 0x18(%rsp), %rsi
vmovd 0x4(%rsi,%r11,4), %xmm1
incq %r11
vpblendd $0x1, %ymm1, %ymm0, %ymm4 # ymm4 = ymm1[0],ymm0[1,2,3,4,5,6,7]
vpaddd (%rax), %ymm4, %ymm0
vpmaxsd %ymm0, %ymm15, %ymm1
movl $0x6, %ecx
vmovdqa 0x100(%rsp), %ymm9
vperm2i128 $0x28, %ymm1, %ymm1, %ymm0 # ymm0 = zero,zero,ymm1[0,1]
vpalignr $0xc, %ymm0, %ymm1, %ymm0 # ymm0 = ymm0[12,13,14,15],ymm1[0,1,2,3,4,5,6,7,8,9,10,11],ymm0[28,29,30,31],ymm1[16,17,18,19,20,21,22,23,24,25,26,27]
vpaddd %ymm0, %ymm9, %ymm0
vpmaxsd %ymm0, %ymm1, %ymm1
decl %ecx
jne 0x577c48
vperm2i128 $0x28, %ymm1, %ymm1, %ymm0 # ymm0 = zero,zero,ymm1[0,1]
vpalignr $0xc, %ymm0, %ymm1, %ymm0 # ymm0 = ymm0[12,13,14,15],ymm1[0,1,2,3,4,5,6,7,8,9,10,11],ymm0[28,29,30,31],ymm1[16,17,18,19,20,21,22,23,24,25,26,27]
vpaddd 0xe0(%rsp), %ymm0, %ymm1
vpmaxsd %ymm4, %ymm1, %ymm4
xorl %ecx, %ecx
vmovaps %ymm10, %ymm15
vmovaps 0x60(%rsp), %ymm10
movq 0x10(%rbx), %rdx
movq (%rdx), %rdx
addq %r10, %rdx
vmovdqa (%r15,%rcx), %ymm0
vpsubd %ymm2, %ymm4, %ymm4
vpsubd %ymm3, %ymm1, %ymm5
vpmaxsd %ymm5, %ymm4, %ymm1
vpcmpgtd %ymm5, %ymm4, %ymm4
vblendvps %ymm4, %ymm10, %ymm12, %ymm5
vpmaxsd %ymm1, %ymm0, %ymm4
vpcmpeqd (%r14,%rcx), %ymm4, %ymm8
vpcmpgtd %ymm1, %ymm0, %ymm0
vpaddd %ymm0, %ymm13, %ymm0
vblendvps %ymm8, %ymm14, %ymm0, %ymm0
vorps (%rcx,%rdx), %ymm5, %ymm5
vorps %ymm0, %ymm5, %ymm0
vmovaps %ymm0, (%rcx,%rdx)
vmovdqa %ymm4, (%r14,%rcx)
vpminsd %ymm1, %ymm7, %ymm0
vpminsd %ymm4, %ymm0, %ymm7
vpmaxsd %ymm4, %ymm6, %ymm6
addq $0x20, %rcx
cmpq %rcx, %r12
jne 0x577c88
addq %r9, %r10
cmpq %r8, %r11
jne 0x577b52
movl 0x3c(%rsp), %ecx
shlq $0x5, %rcx
vmovdqa (%r14,%rcx), %ymm1
cmpl $0x6, 0x30(%rsp)
jg 0x577d3a
movl 0x34(%rsp), %edx
cmpl $0x2, %edx
movl $0x1, %ecx
cmovgel %edx, %ecx
movl 0x2c(%rsp), %esi
vperm2i128 $0x28, %ymm1, %ymm1, %ymm0 # ymm0 = zero,zero,ymm1[0,1]
vpalignr $0xc, %ymm0, %ymm1, %ymm1 # ymm1 = ymm0[12,13,14,15],ymm1[0,1,2,3,4,5,6,7,8,9,10,11],ymm0[28,29,30,31],ymm1[16,17,18,19,20,21,22,23,24,25,26,27]
decl %ecx
jne 0x577d28
jmp 0x577d3e
movl 0x2c(%rsp), %esi
vmovdqa 0x80(%rsp), %ymm0
vpcmpgtd %ymm7, %ymm0, %ymm0
vpcmpgtd 0xa0(%rsp), %ymm6, %ymm2
vpor %ymm0, %ymm2, %ymm0
vtestps %ymm0, %ymm0
je 0x577d6b
orb $0x40, 0xc(%rbx)
xorl %ecx, %ecx
xorl %esi, %esi
xorl %edx, %edx
jmp 0x577d7b
vextracti128 $0x1, %ymm1, %xmm0
vpextrd $0x3, %xmm0, %ecx
movl 0x38(%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 %r15, %rdi
callq 0x2094b5
movq 0x18(%rsp), %rdi
callq 0x2094b5
movq %r13, %rdi
callq 0x2094b5
jmp 0x577dea
callq 0x1f7f53
jmp 0x577de8
callq 0x1f7f2d
jmp 0x577de8
callq 0x1f7f07
jmp 0x577de8
callq 0x1f7ee1
jmp 0x577de8
callq 0x1f7ebb
jmp 0x577de8
callq 0x1f7e95
jmp 0x577de8
callq 0x1f7e6f
jmp 0x577de8
callq 0x1f7e49
xorl %ebx, %ebx
movq %rbx, %rax
leaq -0x28(%rbp), %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq