// File: /workspace/github_c_makefile_star2_O1/nh13[P]ksw/src/parasail/src/sw_trace_scan_avx2_256_8.c
// Function: parasail_sw_trace_scan_profile_avx2_256_8
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;
    int8_t NEG_LIMIT = 0;
    int8_t POS_LIMIT = 0;
    __m256i vZero;
    int8_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->profile8.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 = 32; /* number of values in vector unit */
    segLen = (s1Len + segWidth - 1) / segWidth;
    pvP = (__m256i*)profile->profile8.score;
    vGapO = _mm256_set1_epi8(open);
    vGapE = _mm256_set1_epi8(gap);
    NEG_LIMIT = (-open < matrix->min ? INT8_MIN + open : INT8_MIN - matrix->min) + 1;
    POS_LIMIT = INT8_MAX - matrix->max - 1;
    vZero = _mm256_setzero_si256();
    score = NEG_LIMIT;
    vNegLimit = _mm256_set1_epi8(NEG_LIMIT);
    vPosLimit = _mm256_set1_epi8(POS_LIMIT);
    vSaturationCheckMin = vPosLimit;
    vSaturationCheckMax = vNegLimit;
    vMaxH = vNegLimit;
    vMaxHUnit = vNegLimit;
    vNegInfFront = vZero;
    vNegInfFront = _mm256_insert_epi8_rpl(vNegInfFront, NEG_LIMIT, 0);
    vSegLenXgap = _mm256_adds_epi8(vNegInfFront,
            _mm256_slli_si256_rpl(_mm256_set1_epi8(-segLen*gap), 1));
    vTZero = _mm256_set1_epi8(PARASAIL_ZERO);
    vTIns  = _mm256_set1_epi8(PARASAIL_INS);
    vTDel  = _mm256_set1_epi8(PARASAIL_DEL);
    vTDiag = _mm256_set1_epi8(PARASAIL_DIAG);
    vTDiagE = _mm256_set1_epi8(PARASAIL_DIAG_E);
    vTInsE = _mm256_set1_epi8(PARASAIL_INS_E);
    vTDiagF = _mm256_set1_epi8(PARASAIL_DIAG_F);
    vTDelF = _mm256_set1_epi8(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_8 | PARASAIL_FLAG_LANES_32;

    /* 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_subs_epi8(vZero,vGapO);
        for (i=segLen-1; i>=0; --i) {
            _mm256_store_si256(pvGapper+i, vGapper);
            vGapper = _mm256_subs_epi8(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, 1);
        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_subs_epi8(vH, vGapO);
            vE_ext = _mm256_subs_epi8(vE, vGapE);
            case1 = _mm256_cmpgt_epi8(vE_opn, vE_ext);
            vET = _mm256_blendv_epi8(vTInsE, vTDiagE, case1);
            arr_store(result->trace->trace_table, vET, i, segLen, j);
            vE = _mm256_max_epi8(vE_opn, vE_ext);
            vGapper = _mm256_adds_epi8(vHt, vGapper);
            vF = _mm256_max_epi8(vF, vGapper);
            vHp = _mm256_adds_epi8(vHp, vW);
            vHt = _mm256_max_epi8(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, 1);
        vGapper = _mm256_load_si256(pvGapper);
        vGapper = _mm256_adds_epi8(vHt, vGapper);
        vF = _mm256_max_epi8(vF, vGapper);
        for (i=0; i<segWidth-2; ++i) {
            __m256i vFt = _mm256_slli_si256_rpl(vF, 1);
            vFt = _mm256_adds_epi8(vFt, vSegLenXgap);
            vF = _mm256_max_epi8(vF, vFt);
        }

        /* calculate final H */
        vF = _mm256_slli_si256_rpl(vF, 1);
        vF = _mm256_adds_epi8(vF, vNegInfFront);
        vH = _mm256_max_epi8(vF, vHt);
        vH = _mm256_max_epi8(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_subs_epi8(vH, vGapO);
            vF_ext = _mm256_subs_epi8(vF, vGapE);
            vF = _mm256_max_epi8(vF_opn, vF_ext);
            case1 = _mm256_cmpgt_epi8(vF_opn, vF_ext);
            vFT = _mm256_blendv_epi8(vTDelF, vTDiagF, case1);
            vH = _mm256_max_epi8(vHt, vF);
            vH = _mm256_max_epi8(vH, vZero);
            case0 = _mm256_cmpeq_epi8(vH, vZero);
            case1 = _mm256_cmpeq_epi8(vH, vHp);
            case2 = _mm256_cmpeq_epi8(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_epi8(vSaturationCheckMin, vH);
            vSaturationCheckMax = _mm256_max_epi8(vSaturationCheckMax, vH);
            {
                vMaxH = _mm256_max_epi8(vH, vMaxH);
            }
        } 

        {
            __m256i vCompare = _mm256_cmpgt_epi8(vMaxH, vMaxHUnit);
            if (_mm256_movemask_epi8(vCompare)) {
                score = _mm256_hmax_epi8_rpl(vMaxH);
                vMaxHUnit = _mm256_set1_epi8(score);
                end_ref = j;
                (void)memcpy(pvHMax, pvH, sizeof(__m256i)*segLen);
            }
        }
    }

    /* Trace the alignment ending position on read. */
    {
        int8_t *t = (int8_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_epi8_rpl(vSaturationCheckMin, vNegLimit),
            _mm256_cmpgt_epi8(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 0x57c694
movq 0x18(%rdi), %rax
movq %rax, 0x60(%rsp)
testq %rax, %rax
je 0x57c69b
movq 0x10(%rdi), %rax
movq %rax, 0x20(%rsp)
testq %rax, %rax
je 0x57c6a2
movl 0x8(%rdi), %eax
testl %eax, %eax
jle 0x57c6a9
cmpq $0x0, 0x28(%rsp)
je 0x57c6b0
movl %edx, %ebp
testl %edx, %edx
jle 0x57c6b7
movl %ecx, %r13d
testl %ecx, %ecx
js 0x57c6be
movl %r8d, %r12d
testl %r8d, %r8d
js 0x57c6c5
movq %rax, 0x10(%rsp)
leaq 0x1f(%rax), %r14
movq %r14, %r15
shrq $0x5, %r15
movl %r13d, %eax
negl %eax
movq 0x20(%rsp), %rsi
movl 0x20(%rsi), %ecx
movl %ecx, %edx
negb %dl
cmpl %eax, %ecx
movzbl %dl, %eax
cmovgl %r13d, %eax
movl %eax, 0x4(%rsp)
movb $0x7e, %al
subb 0x1c(%rsi), %al
movl %eax, 0xf0(%rsp)
movl $0x20, %edx
movl $0x20, %ecx
movl %r15d, %edi
movl %ebp, %esi
callq 0x2097d1
testq %rax, %rax
je 0x57c6ca
movq %rax, %rbx
movl %r13d, 0x70(%rsp)
movl %r12d, 0xb0(%rsp)
movl %ebp, 0xd0(%rsp)
movq %r14, 0x38(%rsp)
orl $0x20180404, 0xc(%rax)  # imm = 0x20180404
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 0x57c6ca
vmovd 0x70(%rsp), %xmm0
vpbroadcastb %xmm0, %ymm0
vmovdqu %ymm0, 0x170(%rsp)
movl 0xb0(%rsp), %edx
vmovd %edx, %xmm0
vpbroadcastb %xmm0, %ymm0
vmovdqu %ymm0, 0x150(%rsp)
movl 0x4(%rsp), %ecx
addb $-0x7f, %cl
vmovd %ecx, %xmm0
vpbroadcastb %xmm0, %ymm0
vmovdqu %ymm0, 0x90(%rsp)
vmovd 0xf0(%rsp), %xmm0
vpbroadcastb %xmm0, %ymm0
vmovdqu %ymm0, 0x110(%rsp)
movl %ecx, 0x4(%rsp)
movzbl %cl, %ecx
vmovd %ecx, %xmm1
imull %r15d, %edx
negb %dl
vmovd %edx, %xmm0
vpbroadcastb %xmm0, %ymm0
vpand 0x7d722(%rip), %ymm0, %ymm0 # 0x5f98c0
vmovdqu %ymm1, 0x210(%rsp)
vpaddsb %ymm0, %ymm1, %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
vpsubsb %ymm7, %ymm0, %ymm0
movq %rax, %rcx
shlq $0x5, %rcx
addq %rdi, %rcx
movl %r15d, %edx
vmovdqa %ymm0, (%rcx)
vpsubsb %ymm8, %ymm0, %ymm0
addq $-0x20, %rcx
decl %edx
jg 0x57c20c
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)
vpbroadcastb 0x7f2f1(%rip), %ymm0 # 0x5fb554
vmovdqu %ymm0, 0xf0(%rsp)
vpbroadcastb 0x7f2e0(%rip), %ymm0 # 0x5fb555
vmovdqu %ymm0, 0xd0(%rsp)
vpbroadcastb 0x7f2cf(%rip), %ymm0 # 0x5fb556
vmovdqu %ymm0, 0xb0(%rsp)
vpbroadcastb 0x7f2be(%rip), %ymm15 # 0x5fb557
shlq $0x5, %r13
vpbroadcastb 0x7f2b2(%rip), %ymm6 # 0x5fb558
xorl %r15d, %r15d
vpbroadcastb 0x7f2a7(%rip), %ymm0 # 0x5fb559
vmovdqu %ymm0, 0x1d0(%rsp)
movq %rax, 0x30(%rsp)
movl %eax, %eax
movq %rax, 0x48(%rsp)
vpxor %xmm12, %xmm12, %xmm12
xorl %r9d, %r9d
xorl %eax, %eax
vmovdqu 0x110(%rsp), %ymm10
vmovdqu 0x90(%rsp), %ymm0
vmovdqa %ymm0, %ymm11
vmovdqa %ymm0, %ymm14
vmovdqu %ymm0, 0x190(%rsp)
vmovdqu 0x130(%rsp), %ymm9
movq %r8, 0x40(%rsp)
vmovdqu %ymm15, 0x1b0(%rsp)
vmovdqu %ymm6, 0x1f0(%rsp)
vmovdqu %ymm14, 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 $0xf, %ymm1, %ymm0, %ymm2 # ymm2 = ymm1[15],ymm0[0,1,2,3,4,5,6,7,8,9,10,11,12,13,14],ymm1[31],ymm0[16,17,18,19,20,21,22,23,24,25,26,27,28,29,30]
xorl %edx, %edx
vmovdqu 0x90(%rsp), %ymm0
vpxor %xmm1, %xmm1, %xmm1
vpaddsb (%rcx,%rdx), %ymm2, %ymm2
vmovdqa (%rbp,%rdx), %ymm3
vmovdqa (%r14,%rdx), %ymm4
vpsubsb %ymm7, %ymm3, %ymm5
vpsubsb %ymm8, %ymm4, %ymm4
vpcmpgtb %ymm4, %ymm5, %ymm6
vmovdqu 0xd0(%rsp), %ymm13
vpblendvb %ymm6, 0xf0(%rsp), %ymm13, %ymm6
movq 0x10(%rbx), %rsi
movq (%rsi), %rsi
addq %r15, %rsi
vpaddsb (%rdi,%rdx), %ymm1, %ymm1
vpmaxsb %ymm1, %ymm0, %ymm0
vmovdqa %ymm6, (%rdx,%rsi)
vpmaxsb %ymm4, %ymm5, %ymm4
vpmaxsb %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 0x57c364
vperm2i128 $0x8, %ymm1, %ymm1, %ymm2 # ymm2 = zero,zero,ymm1[0,1]
vpalignr $0xf, %ymm2, %ymm1, %ymm1 # ymm1 = ymm2[15],ymm1[0,1,2,3,4,5,6,7,8,9,10,11,12,13,14],ymm2[31],ymm1[16,17,18,19,20,21,22,23,24,25,26,27,28,29,30]
vpaddsb (%rdi), %ymm1, %ymm2
vpmaxsb %ymm2, %ymm0, %ymm0
movl $0x1e, %ecx
vperm2i128 $0x28, %ymm0, %ymm0, %ymm2 # ymm2 = zero,zero,ymm0[0,1]
vpalignr $0xf, %ymm2, %ymm0, %ymm2 # ymm2 = ymm2[15],ymm0[0,1,2,3,4,5,6,7,8,9,10,11,12,13,14],ymm2[31],ymm0[16,17,18,19,20,21,22,23,24,25,26,27,28,29,30]
vpaddsb %ymm2, %ymm9, %ymm2
vpmaxsb %ymm2, %ymm0, %ymm0
decl %ecx
jne 0x57c3f2
vperm2i128 $0x28, %ymm0, %ymm0, %ymm2 # ymm2 = zero,zero,ymm0[0,1]
vpalignr $0xf, %ymm2, %ymm0, %ymm0 # ymm0 = ymm2[15],ymm0[0,1,2,3,4,5,6,7,8,9,10,11,12,13,14],ymm2[31],ymm0[16,17,18,19,20,21,22,23,24,25,26,27,28,29,30]
vpaddsb 0x210(%rsp), %ymm0, %ymm0
vpmaxsb %ymm12, %ymm1, %ymm1
vpmaxsb %ymm1, %ymm0, %ymm1
xorl %ecx, %ecx
vmovdqu 0x1f0(%rsp), %ymm6
vpxor %xmm13, %xmm13, %xmm13
vmovdqu 0x1d0(%rsp), %ymm12
vmovdqu 0x70(%rsp), %ymm14
movq 0x10(%rbx), %rdx
vpsubsb %ymm7, %ymm1, %ymm1
vpsubsb %ymm8, %ymm0, %ymm2
vpmaxsb %ymm2, %ymm1, %ymm0
vpcmpgtb %ymm2, %ymm1, %ymm1
vpblendvb %ymm1, 0xb0(%rsp), %ymm15, %ymm2
vpmaxsb (%r12,%rcx), %ymm0, %ymm3
movq (%rdx), %rdx
vpmaxsb %ymm13, %ymm3, %ymm1
vpcmpeqb (%rbp,%rcx), %ymm1, %ymm4
vpcmpeqb %ymm0, %ymm1, %ymm5
vpsubb %ymm5, %ymm6, %ymm5
vpblendvb %ymm4, %ymm12, %ymm5, %ymm4
addq %r15, %rdx
vpcmpgtb %ymm13, %ymm3, %ymm3
vpor (%rcx,%rdx), %ymm2, %ymm2
vpand %ymm4, %ymm3, %ymm3
vpor %ymm3, %ymm2, %ymm2
vmovdqa %ymm2, (%rcx,%rdx)
vmovdqa %ymm1, (%rbp,%rcx)
vpminsb %ymm1, %ymm10, %ymm10
vpmaxsb %ymm1, %ymm11, %ymm11
vpmaxsb %ymm14, %ymm1, %ymm14
addq $0x20, %rcx
cmpq %rcx, %r13
jne 0x57c449
vpcmpgtb 0x190(%rsp), %ymm14, %ymm0
vpmovmskb %ymm0, %ecx
testl %ecx, %ecx
je 0x57c5b7
vpermq $0x44, %ymm14, %ymm0    # ymm0 = ymm14[0,1,0,1]
vpmaxsb %ymm0, %ymm14, %ymm0
vmovdqu %ymm14, 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]
vpmaxsb %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]
vpmaxsb %ymm1, %ymm0, %ymm0
vpslldq $0x2, %ymm0, %ymm1      # ymm1 = zero,zero,ymm0[0,1,2,3,4,5,6,7,8,9,10,11,12,13],zero,zero,ymm0[16,17,18,19,20,21,22,23,24,25,26,27,28,29]
vpmaxsb %ymm1, %ymm0, %ymm0
vpslldq $0x1, %ymm0, %ymm1      # ymm1 = zero,ymm0[0,1,2,3,4,5,6,7,8,9,10,11,12,13,14],zero,ymm0[16,17,18,19,20,21,22,23,24,25,26,27,28,29,30]
vpmaxsb %ymm1, %ymm0, %ymm0
vextracti128 $0x1, %ymm0, %xmm1
vpbroadcastb 0x7f039(%rip), %ymm2 # 0x5fb55a
vpextrb $0xf, %xmm1, %eax
movl %eax, 0x4(%rsp)
vpshufb %ymm2, %ymm0, %ymm0
vpermq $0xaa, %ymm0, %ymm0     # ymm0 = ymm0[2,2,2,2]
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), %ymm14
movq 0x68(%rsp), %r9
vmovdqu 0x1b0(%rsp), %ymm15
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
vpxor %xmm12, %xmm12, %xmm12
jne 0x57c314
testl $0x7fffffe0, 0x38(%rsp) # imm = 0x7FFFFFE0
je 0x57c622
movq 0x30(%rsp), %r9
movl %r9d, %ecx
andl $0x3ffffff, %ecx        # imm = 0x3FFFFFF
shll $0x5, %ecx
xorl %edx, %edx
movq 0x10(%rsp), %r8
movl 0x4(%rsp), %r10d
movq 0x8(%rsp), %rsi
cmpb %r10b, (%rsi,%rdx)
jne 0x57c619
movl %edx, %esi
shrl $0x5, %esi
movl %edx, %r11d
andl $0x1f, %r11d
imull %r9d, %r11d
addl %esi, %r11d
cmpl %r8d, %r11d
cmovll %r11d, %r8d
incq %rdx
cmpl %edx, %ecx
jne 0x57c5f4
jmp 0x57c62c
movq 0x10(%rsp), %r8
movl 0x4(%rsp), %r10d
vmovdqu 0x90(%rsp), %ymm0
vpcmpgtb %ymm10, %ymm0, %ymm0
vpcmpgtb 0x110(%rsp), %ymm11, %ymm1
vpor %ymm1, %ymm0, %ymm0
vpmovmskb %ymm0, %ecx
testl %ecx, %ecx
je 0x57c65b
orb $0x40, 0xc(%rbx)
xorl %r10d, %r10d
xorl %eax, %eax
xorl %r8d, %r8d
movsbl %r10b, %ecx
movl %ecx, (%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 0x57c6cc
callq 0x1f9123
jmp 0x57c6ca
callq 0x1f90fd
jmp 0x57c6ca
callq 0x1f90d7
jmp 0x57c6ca
callq 0x1f90b1
jmp 0x57c6ca
callq 0x1f908b
jmp 0x57c6ca
callq 0x1f9065
jmp 0x57c6ca
callq 0x1f903f
jmp 0x57c6ca
callq 0x1f9019
xorl %ebx, %ebx
movq %rbx, %rax
addq $0x278, %rsp            # imm = 0x278
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
nopl (%rax)