// File: /workspace/github_c_makefile_star2_O1/nh13[P]ksw/src/parasail/src/sw_trace_scan_avx2_256_32.c
// Function: parasail_sw_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 end_query = 0;
    int32_t end_ref = 0;
    int32_t s1Len = 0;
    const parasail_matrix_t *matrix = NULL;
    int32_t segWidth = 0;
    int32_t segLen = 0;
    __m256i* restrict pvP = NULL;
    __m256i* restrict pvE = NULL;
    __m256i* restrict pvHt = NULL;
    __m256i* restrict pvH = NULL;
    __m256i* restrict pvHMax = 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 vMaxH;
    __m256i vMaxHUnit;
    __m256i vNegInfFront;
    __m256i vSegLenXgap;
    parasail_result_t *result = NULL;
    __m256i vTZero;
    __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;
    end_query = 0;
    end_ref = 0;
    s1Len = profile->s1Len;
    matrix = profile->matrix;
    segWidth = 8; /* number of values in vector unit */
    segLen = (s1Len + segWidth - 1) / segWidth;
    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;
    vMaxH = vNegLimit;
    vMaxHUnit = 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));
    vTZero = _mm256_set1_epi32(PARASAIL_ZERO);
    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);


    /* initialize result */
    result = parasail_result_new_trace(segLen, s2Len, 32, sizeof(__m256i));
    if (!result) return NULL;

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

    /* initialize heap variables */
    pvE    = parasail_memalign___m256i(32, segLen);
    pvHt   = parasail_memalign___m256i(32, segLen);
    pvH    = parasail_memalign___m256i(32, segLen);
    pvHMax = parasail_memalign___m256i(32, segLen);
    pvGapper = parasail_memalign___m256i(32, segLen);

    /* validate heap variables */
    if (!pvE) return NULL;
    if (!pvHt) return NULL;
    if (!pvH) return NULL;
    if (!pvHMax) return NULL;
    if (!pvGapper) return NULL;

    parasail_memset___m256i(pvH, vZero, segLen);
    parasail_memset___m256i(pvE, vNegLimit, segLen);
    {
        __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 case0;
        __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);
        pvW = pvP + matrix->mapper[(unsigned char)s2[j]]*segLen;
        vHt = vZero;
        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);
            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);
        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);
        vH = _mm256_max_epi32(vH, vZero);
        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);
            vH = _mm256_max_epi32(vH, vZero);
            case0 = _mm256_cmpeq_epi32(vH, vZero);
            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_blendv_epi8(vT, vTZero, case0);
            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);
            vSaturationCheckMax = _mm256_max_epi32(vSaturationCheckMax, vH);
            {
                vMaxH = _mm256_max_epi32(vH, vMaxH);
            }
        } 

        {
            __m256i vCompare = _mm256_cmpgt_epi32(vMaxH, vMaxHUnit);
            if (_mm256_movemask_epi8(vCompare)) {
                score = _mm256_hmax_epi32_rpl(vMaxH);
                vMaxHUnit = _mm256_set1_epi32(score);
                end_ref = j;
                (void)memcpy(pvHMax, pvH, sizeof(__m256i)*segLen);
            }
        }
    }

    /* Trace the alignment ending position on read. */
    {
        int32_t *t = (int32_t*)pvHMax;
        int32_t column_len = segLen * segWidth;
        end_query = s1Len;
        for (i = 0; i<column_len; ++i, ++t) {
            if (*t == score) {
                int32_t temp = i / segWidth + i % segWidth * segLen;
                if (temp < end_query) {
                    end_query = temp;
                }
            }
        }
    }

    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(pvHMax);
    parasail_free(pvH);
    parasail_free(pvHt);
    parasail_free(pvE);

    return result;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x278, %rsp            # imm = 0x278
movq %rsi, 0x28(%rsp)
testq %rdi, %rdi
je 0x579117
movq 0x48(%rdi), %rax
movq %rax, 0x60(%rsp)
testq %rax, %rax
je 0x57911e
movq 0x10(%rdi), %rax
movq %rax, 0x20(%rsp)
testq %rax, %rax
je 0x579125
movl 0x8(%rdi), %eax
testl %eax, %eax
jle 0x57912c
cmpq $0x0, 0x28(%rsp)
je 0x579133
movl %edx, %ebp
testl %edx, %edx
jle 0x57913a
movl %ecx, %r13d
testl %ecx, %ecx
js 0x579141
movl %r8d, %r12d
testl %r8d, %r8d
js 0x579148
movq %rax, 0x10(%rsp)
leaq 0x7(%rax), %r14
movq %r14, %r15
shrq $0x3, %r15
movl %r13d, %eax
negl %eax
movq 0x20(%rsp), %rdi
movl 0x20(%rdi), %ecx
movl $0x80000000, %esi       # imm = 0x80000000
movl %r13d, %edx
orl %esi, %edx
subl %ecx, %esi
cmpl %eax, %ecx
cmovgl %edx, %esi
movl %esi, 0x4(%rsp)
movl $0x7ffffffe, %eax       # imm = 0x7FFFFFFE
subl 0x1c(%rdi), %eax
movl %eax, 0xf0(%rsp)
movl $0x20, %edx
movl $0x20, %ecx
movl %r15d, %edi
movl %ebp, %esi
callq 0x2097d1
testq %rax, %rax
je 0x57914d
movq %rax, %rbx
movl %r13d, 0x70(%rsp)
movl %r12d, 0xb0(%rsp)
movl %ebp, 0xd0(%rsp)
movq %r14, 0x38(%rsp)
orl $0x8480404, 0xc(%rax)   # imm = 0x8480404
movl $0x20, %edi
movq %r15, %rsi
callq 0x4c5e3c
movq %rax, %r14
movl $0x20, %edi
movq %r15, %rsi
callq 0x4c5e3c
movq %rax, %r12
movl $0x20, %edi
movq %r15, %rsi
callq 0x4c5e3c
movq %rax, %rbp
movl $0x20, %edi
movq %r15, %rsi
callq 0x4c5e3c
movq %rax, %r13
movl $0x20, %edi
movq %r15, %rsi
callq 0x4c5e3c
testq %r14, %r14
sete %dl
testq %r12, %r12
sete %cl
orb %dl, %cl
testq %rbp, %rbp
sete %sil
movq %r13, 0x8(%rsp)
testq %r13, %r13
sete %dl
orb %sil, %dl
orb %cl, %dl
testq %rax, %rax
sete %cl
orb %dl, %cl
jne 0x57914d
vmovss 0x70(%rsp), %xmm0
vbroadcastss %xmm0, %ymm0
vmovups %ymm0, 0x170(%rsp)
movl 0xb0(%rsp), %edx
vmovd %edx, %xmm0
vpbroadcastd %xmm0, %ymm0
vmovdqu %ymm0, 0x150(%rsp)
movl 0x4(%rsp), %ecx
incl %ecx
movl %ecx, 0x4(%rsp)
vmovd %ecx, %xmm0
vpbroadcastd %xmm0, %ymm1
vmovdqu %ymm1, 0x90(%rsp)
vmovss 0xf0(%rsp), %xmm0
vbroadcastss %xmm0, %ymm0
vmovups %ymm0, 0x110(%rsp)
vxorps %xmm0, %xmm0, %xmm0
vmovss %xmm1, %xmm0, %xmm2     # xmm2 = xmm1[0],xmm0[1,2,3]
imull %r15d, %edx
negl %edx
vmovd %edx, %xmm0
vpbroadcastd %xmm0, %ymm0
vpxor %xmm1, %xmm1, %xmm1
vpblendd $0x1, %ymm1, %ymm0, %ymm0 # ymm0 = ymm1[0],ymm0[1,2,3,4,5,6,7]
vmovups %ymm2, 0x210(%rsp)
vpaddd %ymm0, %ymm2, %ymm0
vmovdqu %ymm0, 0x130(%rsp)
vpxor %xmm0, %xmm0, %xmm0
movq %rbp, %rdi
movq %r15, %rsi
movq %rax, 0x18(%rsp)
callq 0x4c5e45
movq %r14, %rdi
vmovdqu 0x90(%rsp), %ymm0
movq %r15, %rsi
callq 0x4c5e45
vmovdqu 0x150(%rsp), %ymm8
vmovdqu 0x170(%rsp), %ymm7
movq 0x18(%rsp), %rdi
leal -0x1(%r15), %eax
vpxor %xmm0, %xmm0, %xmm0
vpsubd %ymm7, %ymm0, %ymm0
movq %rax, %rcx
shlq $0x5, %rcx
addq %rdi, %rcx
movl %r15d, %edx
vmovdqa %ymm0, (%rcx)
vpsubd %ymm8, %ymm0, %ymm0
addq $-0x20, %rcx
decl %edx
jg 0x578cb5
movl %eax, %eax
shlq $0x5, %rax
movq %rbp, %rcx
addq %rax, %rcx
movq %rcx, 0x58(%rsp)
movq %r15, %r8
shlq $0x5, %r8
cmpl $0x1, %r15d
movq %r15, %rax
movl %eax, %r13d
adcl $0x0, %r13d
movl 0xd0(%rsp), %edx
cmpl $0x2, %edx
movl $0x1, %ecx
cmovgel %edx, %ecx
movq %rcx, 0x50(%rsp)
shlq $0x5, %r13
xorl %r15d, %r15d
movq %rax, 0x30(%rsp)
movl %eax, %eax
movq %rax, 0x48(%rsp)
vbroadcastss 0x80ce1(%rip), %ymm0 # 0x5f9a00
vmovups %ymm0, 0xf0(%rsp)
vbroadcastss 0x826d3(%rip), %ymm0 # 0x5fb404
vmovups %ymm0, 0xd0(%rsp)
vpxor %xmm14, %xmm14, %xmm14
vbroadcastss 0x826c0(%rip), %ymm0 # 0x5fb408
vmovups %ymm0, 0xb0(%rsp)
vbroadcastss 0x826b2(%rip), %ymm6 # 0x5fb40c
vbroadcastss 0x7cddd(%rip), %ymm0 # 0x5f5b40
vmovups %ymm0, 0x1d0(%rsp)
vpbroadcastd 0x8269f(%rip), %ymm12 # 0x5fb414
xorl %r9d, %r9d
xorl %eax, %eax
vmovdqu 0x110(%rsp), %ymm10
vmovdqu 0x90(%rsp), %ymm0
vmovdqa %ymm0, %ymm11
vmovdqa %ymm0, %ymm15
vmovdqu %ymm0, 0x190(%rsp)
vmovdqu 0x130(%rsp), %ymm9
movq %r8, 0x40(%rsp)
vmovups %ymm6, 0x1f0(%rsp)
vmovdqu %ymm12, 0x1b0(%rsp)
vmovdqu %ymm15, 0x70(%rsp)
movq 0x20(%rsp), %rcx
movq 0x10(%rcx), %rcx
movq 0x28(%rsp), %rdx
movzbl (%rdx,%r9), %edx
movslq (%rcx,%rdx,4), %rcx
imulq 0x48(%rsp), %rcx
shlq $0x5, %rcx
addq 0x60(%rsp), %rcx
movq 0x58(%rsp), %rdx
vmovdqa (%rdx), %ymm0
vperm2i128 $0x28, %ymm0, %ymm0, %ymm1 # ymm1 = zero,zero,ymm0[0,1]
vpalignr $0xc, %ymm1, %ymm0, %ymm2 # ymm2 = ymm1[12,13,14,15],ymm0[0,1,2,3,4,5,6,7,8,9,10,11],ymm1[28,29,30,31],ymm0[16,17,18,19,20,21,22,23,24,25,26,27]
xorl %edx, %edx
vmovdqu 0x90(%rsp), %ymm0
vpxor %xmm1, %xmm1, %xmm1
vpaddd (%rcx,%rdx), %ymm2, %ymm2
vmovdqa (%rbp,%rdx), %ymm3
vmovdqa (%r14,%rdx), %ymm4
vpsubd %ymm7, %ymm3, %ymm5
vpsubd %ymm8, %ymm4, %ymm4
vpcmpgtd %ymm4, %ymm5, %ymm6
vmovups 0xd0(%rsp), %ymm13
vblendvps %ymm6, 0xf0(%rsp), %ymm13, %ymm6
movq 0x10(%rbx), %rsi
movq (%rsi), %rsi
addq %r15, %rsi
vpaddd (%rdi,%rdx), %ymm1, %ymm1
vpmaxsd %ymm1, %ymm0, %ymm0
vmovaps %ymm6, (%rdx,%rsi)
vpmaxsd %ymm4, %ymm5, %ymm4
vpmaxsd %ymm2, %ymm4, %ymm1
vmovdqa %ymm4, (%r14,%rdx)
vmovdqa %ymm1, (%r12,%rdx)
vmovdqa %ymm2, (%rbp,%rdx)
addq $0x20, %rdx
vmovdqa %ymm3, %ymm2
cmpq %rdx, %r13
jne 0x578e0d
vperm2i128 $0x8, %ymm1, %ymm1, %ymm2 # ymm2 = zero,zero,ymm1[0,1]
vpalignr $0xc, %ymm2, %ymm1, %ymm1 # ymm1 = ymm2[12,13,14,15],ymm1[0,1,2,3,4,5,6,7,8,9,10,11],ymm2[28,29,30,31],ymm1[16,17,18,19,20,21,22,23,24,25,26,27]
vpaddd (%rdi), %ymm1, %ymm2
vpmaxsd %ymm2, %ymm0, %ymm0
movl $0x6, %ecx
vperm2i128 $0x28, %ymm0, %ymm0, %ymm2 # ymm2 = zero,zero,ymm0[0,1]
vpalignr $0xc, %ymm2, %ymm0, %ymm2 # ymm2 = ymm2[12,13,14,15],ymm0[0,1,2,3,4,5,6,7,8,9,10,11],ymm2[28,29,30,31],ymm0[16,17,18,19,20,21,22,23,24,25,26,27]
vpaddd %ymm2, %ymm9, %ymm2
vpmaxsd %ymm2, %ymm0, %ymm0
decl %ecx
jne 0x578e9b
vperm2i128 $0x28, %ymm0, %ymm0, %ymm2 # ymm2 = zero,zero,ymm0[0,1]
vpalignr $0xc, %ymm2, %ymm0, %ymm0 # ymm0 = ymm2[12,13,14,15],ymm0[0,1,2,3,4,5,6,7,8,9,10,11],ymm2[28,29,30,31],ymm0[16,17,18,19,20,21,22,23,24,25,26,27]
vpaddd 0x210(%rsp), %ymm0, %ymm0
vpmaxsd %ymm14, %ymm1, %ymm1
vpmaxsd %ymm1, %ymm0, %ymm1
xorl %ecx, %ecx
vmovups 0x1f0(%rsp), %ymm6
vmovdqu 0x1d0(%rsp), %ymm12
vmovups 0x1b0(%rsp), %ymm13
vmovdqu 0x70(%rsp), %ymm15
movq 0x10(%rbx), %rdx
vpsubd %ymm7, %ymm1, %ymm1
vpsubd %ymm8, %ymm0, %ymm2
vpmaxsd %ymm2, %ymm1, %ymm0
vpcmpgtd %ymm2, %ymm1, %ymm1
vblendvps %ymm1, 0xb0(%rsp), %ymm6, %ymm2
vpmaxsd (%r12,%rcx), %ymm0, %ymm3
movq (%rdx), %rdx
vpmaxsd %ymm14, %ymm3, %ymm1
vpcmpeqd (%rbp,%rcx), %ymm1, %ymm4
vpcmpeqd %ymm0, %ymm1, %ymm5
vpsubd %ymm5, %ymm12, %ymm5
vblendvps %ymm4, %ymm13, %ymm5, %ymm4
addq %r15, %rdx
vpcmpgtd %ymm14, %ymm3, %ymm3
vorps (%rcx,%rdx), %ymm2, %ymm2
vpand %ymm4, %ymm3, %ymm3
vorps %ymm3, %ymm2, %ymm2
vmovaps %ymm2, (%rcx,%rdx)
vmovdqa %ymm1, (%rbp,%rcx)
vpminsd %ymm1, %ymm10, %ymm10
vpmaxsd %ymm1, %ymm11, %ymm11
vpmaxsd %ymm15, %ymm1, %ymm15
addq $0x20, %rcx
cmpq %rcx, %r13
jne 0x578ef6
vpcmpgtd 0x190(%rsp), %ymm15, %ymm0
vtestps %ymm0, %ymm0
je 0x579043
vpermq $0x44, %ymm15, %ymm0    # ymm0 = ymm15[0,1,0,1]
vpmaxsd %ymm0, %ymm15, %ymm0
vmovdqu %ymm15, 0x70(%rsp)
vpslldq $0x8, %ymm0, %ymm1      # ymm1 = zero,zero,zero,zero,zero,zero,zero,zero,ymm0[0,1,2,3,4,5,6,7],zero,zero,zero,zero,zero,zero,zero,zero,ymm0[16,17,18,19,20,21,22,23]
vpmaxsd %ymm1, %ymm0, %ymm0
vpslldq $0x4, %ymm0, %ymm1      # ymm1 = zero,zero,zero,zero,ymm0[0,1,2,3,4,5,6,7,8,9,10,11],zero,zero,zero,zero,ymm0[16,17,18,19,20,21,22,23,24,25,26,27]
vpmaxsd %ymm1, %ymm0, %ymm0
vextracti128 $0x1, %ymm0, %xmm1
vpextrd $0x3, %xmm1, 0x4(%rsp)
vpbroadcastd 0x8084f(%rip), %ymm1 # 0x5f9810
vpermd %ymm0, %ymm1, %ymm0
vmovdqu %ymm0, 0x190(%rsp)
movq 0x8(%rsp), %rdi
movq %rbp, %rsi
movq %r8, %rdx
vmovdqu %ymm10, 0x250(%rsp)
vmovdqu %ymm11, 0x230(%rsp)
movq %r9, 0x68(%rsp)
vzeroupper
callq 0x19e0c0
vmovdqu 0x70(%rsp), %ymm15
movq 0x68(%rsp), %r9
vpxor %xmm14, %xmm14, %xmm14
movq 0x40(%rsp), %r8
vmovdqu 0x230(%rsp), %ymm11
vmovdqu 0x250(%rsp), %ymm10
vmovdqu 0x130(%rsp), %ymm9
vmovdqu 0x150(%rsp), %ymm8
vmovdqu 0x170(%rsp), %ymm7
movq 0x18(%rsp), %rdi
movl %r9d, %eax
incq %r9
addq %r8, %r15
cmpq 0x50(%rsp), %r9
jne 0x578dbd
testl $0x7ffffff8, 0x38(%rsp) # imm = 0x7FFFFFF8
je 0x5790a9
movq 0x30(%rsp), %r10
movl %r10d, %ecx
andl $0xfffffff, %ecx        # imm = 0xFFFFFFF
shll $0x3, %ecx
xorl %edx, %edx
movq 0x10(%rsp), %r8
movl 0x4(%rsp), %r9d
movq 0x8(%rsp), %rsi
cmpl %r9d, (%rsi,%rdx,4)
jne 0x5790a0
movl %edx, %esi
shrl $0x3, %esi
movl %edx, %r11d
andl $0x7, %r11d
imull %r10d, %r11d
addl %esi, %r11d
cmpl %r8d, %r11d
cmovll %r11d, %r8d
incq %rdx
cmpl %edx, %ecx
jne 0x57907b
jmp 0x5790b3
movq 0x10(%rsp), %r8
movl 0x4(%rsp), %r9d
vmovdqu 0x90(%rsp), %ymm0
vpcmpgtd %ymm10, %ymm0, %ymm0
vpcmpgtd 0x110(%rsp), %ymm11, %ymm1
vpor %ymm1, %ymm0, %ymm0
vtestps %ymm0, %ymm0
je 0x5790e1
orb $0x40, 0xc(%rbx)
xorl %r9d, %r9d
xorl %eax, %eax
xorl %r8d, %r8d
movl %r9d, (%rbx)
movl %r8d, 0x4(%rbx)
movl %eax, 0x8(%rbx)
vzeroupper
callq 0x2094b5
movq 0x8(%rsp), %rdi
callq 0x2094b5
movq %rbp, %rdi
callq 0x2094b5
movq %r12, %rdi
callq 0x2094b5
movq %r14, %rdi
callq 0x2094b5
jmp 0x57914f
callq 0x1f83c7
jmp 0x57914d
callq 0x1f83a1
jmp 0x57914d
callq 0x1f837b
jmp 0x57914d
callq 0x1f8355
jmp 0x57914d
callq 0x1f832f
jmp 0x57914d
callq 0x1f8309
jmp 0x57914d
callq 0x1f82e3
jmp 0x57914d
callq 0x1f82bd
xorl %ebx, %ebx
movq %rbx, %rax
addq $0x278, %rsp            # imm = 0x278
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq