// File: /workspace/github_c_makefile_star2_O1/nh13[P]ksw/src/parasail/src/sg_trace_scan_avx2_256_8.c
// Function: parasail_sg_flags_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,
        int s1_beg, int s1_end, int s2_beg, int s2_end)
{
    /* 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;
    int8_t* restrict boundary = NULL;
    __m256i* restrict pvHt = NULL;
    __m256i* restrict pvH = 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 vPosMask;
    __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->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;
    k = 0;
    s1Len = profile->s1Len;
    end_query = s1Len-1;
    end_ref = s2Len-1;
    matrix = profile->matrix;
    segWidth = 32; /* number of values in vector unit */
    segLen = (s1Len + segWidth - 1) / segWidth;
    offset = (s1Len - 1) % segLen;
    position = (segWidth - 1) - (s1Len - 1) / segLen;
    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;
    vPosMask = _mm256_cmpeq_epi8(_mm256_set1_epi8(position),
            _mm256_set_epi8(0,1,2,3,4,5,6,7,8,9,10,11,12,13,14,15,16,17,18,19,20,21,22,23,24,25,26,27,28,29,30,31));
    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));
    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_SG | PARASAIL_FLAG_SCAN
        | PARASAIL_FLAG_TRACE
        | PARASAIL_FLAG_BITS_8 | PARASAIL_FLAG_LANES_32;
    result->flag |= s1_beg ? PARASAIL_FLAG_SG_S1_BEG : 0;
    result->flag |= s1_end ? PARASAIL_FLAG_SG_S1_END : 0;
    result->flag |= s2_beg ? PARASAIL_FLAG_SG_S2_BEG : 0;
    result->flag |= s2_end ? PARASAIL_FLAG_SG_S2_END : 0;

    /* initialize heap variables */
    pvE = parasail_memalign___m256i(32, segLen);
    boundary = parasail_memalign_int8_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_8_t h;
            __m256i_8_t e;
            for (segNum=0; segNum<segWidth; ++segNum) {
                int64_t tmp = s1_beg ? 0 : (-open-gap*(segNum*segLen+i));
                h.v[segNum] = tmp < INT8_MIN ? INT8_MIN : tmp;
                tmp = tmp - open;
                e.v[segNum] = tmp < INT8_MIN ? INT8_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 = s2_beg ? 0 : (-open-gap*(i-1));
            boundary[i] = tmp < INT8_MIN ? INT8_MIN : tmp;
        }
    }

    {
        __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);
            /* long queries and/or large penalties will break the pseudo prefix scan */
            vSaturationCheckMin = _mm256_min_epi8(vSaturationCheckMin, vGapper);
        }
    }

    /* 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, 1);
        vHp = _mm256_insert_epi8_rpl(vHp, boundary[j], 0);
        pvW = pvP + matrix->mapper[(unsigned char)s2[j]]*segLen;
        vHt = _mm256_subs_epi8(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_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);
            vSaturationCheckMin = _mm256_min_epi8(vSaturationCheckMin, vE);
            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);
        vHt = _mm256_insert_epi8_rpl(vHt, boundary[j+1], 0);
        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);
        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);
            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_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);
            vSaturationCheckMin = _mm256_min_epi8(vSaturationCheckMin, vF);
            vSaturationCheckMax = _mm256_max_epi8(vSaturationCheckMax, vH);
        }

        /* extract vector containing last value from column */
        {
            __m256i vCompare;
            vH = _mm256_load_si256(pvH + offset);
            vCompare = _mm256_and_si256(vPosMask, _mm256_cmpgt_epi8(vH, vMaxH));
            vMaxH = _mm256_max_epi8(vH, vMaxH);
            if (_mm256_movemask_epi8(vCompare)) {
                end_ref = j;
            }
        }
    } 

    /* max last value from all columns */
    if (s2_end)
    {
        for (k=0; k<position; ++k) {
            vMaxH = _mm256_slli_si256_rpl(vMaxH, 1);
        }
        score = (int8_t) _mm256_extract_epi8_rpl(vMaxH, 31);
        end_query = s1Len-1;
    }

    /* max of last column */
    if (s1_end)
    {
        /* Trace the alignment ending position on read. */
        int8_t *t = (int8_t*)pvH;
        int32_t column_len = segLen * segWidth;
        for (i = 0; i<column_len; ++i, ++t) {
            int32_t temp = i / segWidth + i % segWidth * segLen;
            if (temp >= s1Len) continue;
            if (*t > score) {
                score = *t;
                end_query = temp;
                end_ref = s2Len-1;
            }
            else if (*t == score && end_ref == s2Len-1 && temp < end_query) {
                end_query = temp;
            }
        }
    }

    if (!s1_end && !s2_end) {
        /* 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, 1);
            }
            score = (int8_t) _mm256_extract_epi8_rpl (vH, 31);
            end_ref = s2Len - 1;
            end_query = s1Len - 1;
        }
    }

    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(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 $0x1c0, %rsp            # imm = 0x1C0
movq %rsi, 0x58(%rsp)
testq %rdi, %rdi
je 0x57bc33
movq 0x18(%rdi), %rax
movq %rax, 0x78(%rsp)
testq %rax, %rax
je 0x57bc3a
movq 0x10(%rdi), %rax
movq %rax, 0x50(%rsp)
testq %rax, %rax
je 0x57bc41
movl %edx, %r15d
movl 0x8(%rdi), %edx
testl %edx, %edx
jle 0x57bc48
cmpq $0x0, 0x58(%rsp)
je 0x57bc4f
testl %r15d, %r15d
jle 0x57bc56
testl %ecx, %ecx
js 0x57bc5d
testl %r8d, %r8d
js 0x57bc64
movl %r9d, %r13d
movl %r8d, 0x38(%rsp)
leal -0x1(%rdx), %eax
movq %rdx, 0x70(%rsp)
leaq 0x1f(%rdx), %r14
movq %r14, %rdi
shrq $0x5, %rdi
movl %eax, 0x4c(%rsp)
cltd
idivl %edi
movl %eax, 0x10(%rsp)
movl %edx, %r12d
movq 0x50(%rsp), %rdx
movl 0x20(%rdx), %eax
movl %eax, %esi
negb %sil
movzbl %sil, %r8d
movl %ecx, %esi
negl %esi
movl %esi, 0x30(%rsp)
cmpl %esi, %eax
movl %ecx, 0x18(%rsp)
cmovgl %ecx, %r8d
movl %r8d, 0x14(%rsp)
movb $0x7e, %al
subb 0x1c(%rdx), %al
movl %eax, 0x80(%rsp)
movl $0x20, %edx
movl $0x20, %ecx
movq %rdi, 0x8(%rsp)
movl %r15d, %esi
callq 0x2097d1
testq %rax, %rax
je 0x57bc69
movq %rax, %rbx
movl %r12d, 0xe0(%rsp)
movq %r14, 0x68(%rsp)
movl 0x20(%rbp), %edi
xorl %eax, %eax
testl %r13d, %r13d
setne %al
xorl %ecx, %ecx
cmpl $0x0, 0x10(%rbp)
setne %cl
shll $0x4, %ecx
xorl %edx, %edx
cmpl $0x0, 0x18(%rbp)
setne %dl
shll $0xe, %edx
xorl %esi, %esi
movl %edi, 0x48(%rsp)
testl %edi, %edi
setne %sil
shll $0xf, %esi
leal (%rcx,%rax,8), %eax
orl %edx, %eax
orl %esi, %eax
orl 0xc(%rbx), %eax
orl $0x20180402, %eax       # imm = 0x20180402
movl %eax, 0xc(%rbx)
movl $0x20, %edi
movq 0x8(%rsp), %r14
movq %r14, %rsi
callq 0x4c5e3c
movq %rax, %r12
leal 0x1(%r15), %esi
movl $0x20, %edi
movq %rsi, 0xc0(%rsp)
callq 0x2094c8
movq %rax, 0x20(%rsp)
movl $0x20, %edi
movq %r14, %rsi
movq %r15, 0xa0(%rsp)
movq %r14, %r15
callq 0x4c5e3c
movq %rax, %r14
movl $0x20, %edi
movq %r15, %rsi
callq 0x4c5e3c
movq %rax, %r15
movl $0x20, %edi
movq 0x8(%rsp), %rsi
callq 0x4c5e3c
testq %r12, %r12
sete %cl
cmpq $0x0, 0x20(%rsp)
sete %dl
orb %cl, %dl
testq %r14, %r14
sete %cl
testq %r15, %r15
sete %sil
orb %cl, %sil
orb %dl, %sil
testq %rax, %rax
sete %cl
orb %sil, %cl
jne 0x57bc69
movq %rax, 0x40(%rsp)
movq 0xa0(%rsp), %rax
decl %eax
movl %eax, 0x4(%rsp)
movl $0x1f, %ecx
subl 0x10(%rsp), %ecx
movl 0x18(%rsp), %esi
vmovd %esi, %xmm0
vpbroadcastb %xmm0, %ymm3
movl 0x38(%rsp), %edx
vmovd %edx, %xmm0
vpbroadcastb %xmm0, %ymm4
movl 0x14(%rsp), %eax
addb $-0x7f, %al
vmovd %eax, %xmm0
vpbroadcastb %xmm0, %ymm0
vmovdqa %ymm0, 0x100(%rsp)
vmovd 0x80(%rsp), %xmm0
vpbroadcastb %xmm0, %ymm2
movl %ecx, 0x2c(%rsp)
vmovd %ecx, %xmm0
vpbroadcastb %xmm0, %ymm7
movl %eax, 0x14(%rsp)
movzbl %al, %ecx
vmovd %ecx, %xmm1
movq 0x8(%rsp), %rdi
movl %edi, %ecx
imull %edx, %ecx
negb %cl
vmovd %ecx, %xmm0
vpbroadcastb %xmm0, %ymm0
vpand 0x7e211(%rip), %ymm0, %ymm0 # 0x5f98c0
vmovdqa %ymm1, 0x140(%rsp)
vpaddsb %ymm0, %ymm1, %ymm9
movl %esi, %ecx
movl %edx, %edx
movslq 0x30(%rsp), %rax
movl %edi, %r8d
movq %r8, 0x18(%rsp)
movq %rdx, 0x80(%rsp)
imulq %rdx, %r8
xorl %r9d, %r9d
movq $-0x80, %r10
movq %rax, %rsi
xorl %edi, %edi
testl %r13d, %r13d
je 0x57b6f2
xorl %r11d, %r11d
jmp 0x57b6f5
movq %rsi, %r11
cmpq $-0x7f, %r11
movq $-0x80, %rdx
cmovgeq %r11, %rdx
movb %dl, 0x180(%rsp,%rdi)
subq %rcx, %r11
cmpq $-0x7f, %r11
cmovlq %r10, %r11
movb %r11b, 0x160(%rsp,%rdi)
incq %rdi
subq %r8, %rsi
cmpq $0x20, %rdi
jne 0x57b6e8
movq %r9, %rdx
shlq $0x5, %rdx
vmovaps 0x180(%rsp), %ymm0
vmovaps %ymm0, (%r15,%rdx)
vmovdqa 0x160(%rsp), %ymm0
vmovdqa %ymm0, (%r12,%rdx)
incq %r9
subq 0x80(%rsp), %rax
cmpq 0x18(%rsp), %r9
jne 0x57b6e3
movq 0x20(%rsp), %rsi
movb $0x0, (%rsi)
movl $0x1, %ecx
xorl %edx, %edx
movl 0x38(%rsp), %edi
movl 0x30(%rsp), %r8d
movl 0x18(%rbp), %r9d
movq 0xc0(%rsp), %r10
cmpl $-0x7f, %r8d
movl $0xffffff80, %eax       # imm = 0xFFFFFF80
cmovgel %r8d, %eax
testl %r9d, %r9d
cmovnel %edx, %eax
movb %al, (%rsi,%rcx)
incq %rcx
subl %edi, %r8d
cmpq %rcx, %r10
jne 0x57b785
vpxor %xmm0, %xmm0, %xmm0
vpsubsb %ymm3, %ymm0, %ymm0
movq 0x8(%rsp), %r11
leal -0x1(%r11), %ecx
movq %rcx, %rax
shlq $0x5, %rax
movq 0x40(%rsp), %rdx
addq %rax, %rdx
movl %r11d, %esi
vmovdqa %ymm2, 0xc0(%rsp)
vmovdqa %ymm0, (%rdx)
vpsubsb %ymm4, %ymm0, %ymm0
vpminsb %ymm0, %ymm2, %ymm2
addq $-0x20, %rdx
decl %esi
jg 0x57b7d2
movl %ecx, %eax
shlq $0x5, %rax
addq %r15, %rax
movq %rax, 0x38(%rsp)
movl 0xe0(%rsp), %r10d
movq %r10, 0x60(%rsp)
shlq $0x5, %r10
addq %r15, %r10
cmpl $0x1, %r11d
adcl $0x0, %r11d
movq 0xa0(%rsp), %rax
cmpl $0x2, %eax
movl $0x1, %ecx
cmovgel %eax, %ecx
movq %rcx, 0x30(%rsp)
vpbroadcastb 0x7fcc4(%rip), %ymm15 # 0x5fb4f6
vpbroadcastb 0x7fcbc(%rip), %ymm10 # 0x5fb4f7
vpbroadcastb 0x7fcb4(%rip), %ymm11 # 0x5fb4f8
movq 0x18(%rsp), %rsi
vpbroadcastb 0x7fca7(%rip), %ymm12 # 0x5fb4f9
shlq $0x5, %rsi
vpbroadcastb 0x7fc9b(%rip), %ymm13 # 0x5fb4fa
shlq $0x5, %r11
vpbroadcastb 0x7fc8f(%rip), %ymm14 # 0x5fb4fb
xorl %edx, %edx
vpcmpeqb 0x7e06a(%rip), %ymm7, %ymm0 # 0x5f98e0
vmovdqa %ymm0, 0xe0(%rsp)
xorl %ecx, %ecx
movl 0x4(%rsp), %r8d
vmovdqa 0x100(%rsp), %ymm0
vmovdqa %ymm0, %ymm7
vmovdqa %ymm0, %ymm5
vmovdqa %ymm9, 0x120(%rsp)
vmovdqa %ymm11, 0xa0(%rsp)
vmovdqa %ymm5, 0x80(%rsp)
movq 0x38(%rsp), %rax
vmovdqa (%rax), %ymm0
vinserti128 $0x1, %xmm0, %ymm0, %ymm1
vpalignr $0xf, %ymm1, %ymm0, %ymm0 # ymm0 = 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]
movq 0x20(%rsp), %rax
vpinsrb $0x0, (%rax,%rcx), %xmm0, %xmm1
vpblendd $0xf, %ymm1, %ymm0, %ymm1 # ymm1 = ymm1[0,1,2,3],ymm0[4,5,6,7]
movq 0x50(%rsp), %rax
movq 0x10(%rax), %rax
movq 0x58(%rsp), %rdi
movzbl (%rdi,%rcx), %edi
movslq (%rax,%rdi,4), %r9
imulq 0x18(%rsp), %r9
shlq $0x5, %r9
addq 0x78(%rsp), %r9
movq 0x40(%rsp), %rdi
vmovdqa 0x100(%rsp), %ymm0
vpsubsb (%rdi), %ymm0, %ymm5
xorl %r13d, %r13d
vmovdqa %ymm10, %ymm11
vmovdqa %ymm15, %ymm10
vpaddsb (%r9,%r13), %ymm1, %ymm1
vmovdqa (%r15,%r13), %ymm15
vmovdqa (%r12,%r13), %ymm8
vpsubsb %ymm3, %ymm15, %ymm6
vpsubsb %ymm4, %ymm8, %ymm8
vpcmpgtb %ymm8, %ymm6, %ymm9
vpblendvb %ymm9, %ymm10, %ymm11, %ymm9
movq 0x10(%rbx), %rax
movq (%rax), %rax
addq %rdx, %rax
vpaddsb (%rdi,%r13), %ymm5, %ymm5
vmovdqa %ymm9, (%r13,%rax)
vpmaxsb %ymm5, %ymm0, %ymm0
vpmaxsb %ymm8, %ymm6, %ymm6
vpminsb %ymm6, %ymm2, %ymm2
vpmaxsb %ymm1, %ymm6, %ymm5
vmovdqa %ymm6, (%r12,%r13)
vmovdqa %ymm5, (%r14,%r13)
vmovdqa %ymm1, (%r15,%r13)
addq $0x20, %r13
vmovdqa %ymm15, %ymm1
cmpq %r13, %r11
jne 0x57b91d
vinserti128 $0x1, %xmm5, %ymm0, %ymm1
vpalignr $0xf, %ymm1, %ymm5, %ymm1 # ymm1 = ymm1[15],ymm5[0,1,2,3,4,5,6,7,8,9,10,11,12,13,14],ymm1[31],ymm5[16,17,18,19,20,21,22,23,24,25,26,27,28,29,30]
leaq 0x1(%rcx), %r9
movq 0x20(%rsp), %rax
vpinsrb $0x0, 0x1(%rax,%rcx), %xmm1, %xmm5
vpblendd $0xf, %ymm5, %ymm1, %ymm1 # ymm1 = ymm5[0,1,2,3],ymm1[4,5,6,7]
vpaddsb (%rdi), %ymm1, %ymm5
vpmaxsb %ymm5, %ymm0, %ymm0
movl $0x1e, %edi
vmovdqa 0x120(%rsp), %ymm9
vperm2i128 $0x28, %ymm0, %ymm0, %ymm5 # ymm5 = zero,zero,ymm0[0,1]
vpalignr $0xf, %ymm5, %ymm0, %ymm5 # ymm5 = ymm5[15],ymm0[0,1,2,3,4,5,6,7,8,9,10,11,12,13,14],ymm5[31],ymm0[16,17,18,19,20,21,22,23,24,25,26,27,28,29,30]
vpaddsb %ymm5, %ymm9, %ymm5
vpmaxsb %ymm5, %ymm0, %ymm0
decl %edi
jne 0x57b9c6
vperm2i128 $0x28, %ymm0, %ymm0, %ymm5 # ymm5 = zero,zero,ymm0[0,1]
vpalignr $0xf, %ymm5, %ymm0, %ymm0 # ymm0 = ymm5[15],ymm0[0,1,2,3,4,5,6,7,8,9,10,11,12,13,14],ymm5[31],ymm0[16,17,18,19,20,21,22,23,24,25,26,27,28,29,30]
vpaddsb 0x140(%rsp), %ymm0, %ymm0
vpmaxsb %ymm1, %ymm0, %ymm1
xorl %r13d, %r13d
vmovdqa %ymm10, %ymm15
vmovdqa %ymm11, %ymm10
vmovdqa 0xa0(%rsp), %ymm11
movq 0x10(%rbx), %rax
movq (%rax), %rax
addq %rdx, %rax
vmovdqa (%r14,%r13), %ymm5
vpsubsb %ymm3, %ymm1, %ymm1
vpsubsb %ymm4, %ymm0, %ymm6
vpmaxsb %ymm6, %ymm1, %ymm0
vpcmpgtb %ymm6, %ymm1, %ymm1
vpblendvb %ymm1, %ymm11, %ymm12, %ymm6
vpmaxsb %ymm0, %ymm5, %ymm1
vpcmpeqb (%r15,%r13), %ymm1, %ymm8
vpcmpgtb %ymm0, %ymm5, %ymm5
vpaddb %ymm5, %ymm13, %ymm5
vpblendvb %ymm8, %ymm14, %ymm5, %ymm5
vpor (%r13,%rax), %ymm6, %ymm6
vpor %ymm5, %ymm6, %ymm5
vmovdqa %ymm5, (%r13,%rax)
vmovdqa %ymm1, (%r15,%r13)
vpminsb %ymm0, %ymm2, %ymm2
vpminsb %ymm1, %ymm2, %ymm2
vpmaxsb %ymm1, %ymm7, %ymm7
addq $0x20, %r13
cmpq %r13, %r11
jne 0x57ba0f
vmovdqa (%r10), %ymm0
vmovdqa 0x80(%rsp), %ymm5
vpcmpgtb %ymm5, %ymm0, %ymm1
vpand 0xe0(%rsp), %ymm1, %ymm1
vpmaxsb %ymm5, %ymm0, %ymm5
vpmovmskb %ymm1, %eax
testl %eax, %eax
cmovnel %ecx, %r8d
addq %rsi, %rdx
movq %r9, %rcx
cmpq 0x30(%rsp), %r9
jne 0x57b8a9
cmpl $0x0, 0x20(%rbp)
movl 0x4c(%rsp), %r10d
movq 0x70(%rsp), %r11
movl 0x14(%rsp), %r13d
je 0x57bb01
cmpl $0x1e, 0x10(%rsp)
jg 0x57baf5
movl 0x2c(%rsp), %eax
cmpl $0x2, %eax
movl $0x1, %ecx
cmovgel %eax, %ecx
vperm2i128 $0x8, %ymm5, %ymm5, %ymm0 # ymm0 = zero,zero,ymm5[0,1]
vpalignr $0xf, %ymm0, %ymm5, %ymm5 # ymm5 = ymm0[15],ymm5[0,1,2,3,4,5,6,7,8,9,10,11,12,13,14],ymm0[31],ymm5[16,17,18,19,20,21,22,23,24,25,26,27,28,29,30]
decl %ecx
jne 0x57bae5
vextracti128 $0x1, %ymm5, %xmm0
vpextrb $0xf, %xmm0, %r13d
cmpl $0x0, 0x10(%rbp)
je 0x57bb72
testl $0x7fffffe0, 0x68(%rsp) # imm = 0x7FFFFFE0
je 0x57bb72
movq 0x8(%rsp), %r9
movl %r9d, %edx
andl $0x3ffffff, %edx        # imm = 0x3FFFFFF
shll $0x5, %edx
xorl %esi, %esi
movl %r10d, %ecx
movl %esi, %eax
shrl $0x5, %eax
movl %esi, %edi
andl $0x1f, %edi
imull %r9d, %edi
addl %eax, %edi
cmpl %r11d, %edi
jge 0x57bb69
movb (%r15,%rsi), %r9b
cmpb %r13b, %r9b
jle 0x57bb51
movl %r9d, %r13d
movl 0x4(%rsp), %r8d
movl %edi, %ecx
jmp 0x57bb64
cmpl %ecx, %edi
cmovgel %ecx, %edi
cmpl 0x4(%rsp), %r8d
cmovnel %ecx, %edi
cmpb %r13b, %r9b
cmovel %edi, %ecx
movq 0x8(%rsp), %r9
incq %rsi
cmpl %esi, %edx
jne 0x57bb27
jmp 0x57bb75
movl %r10d, %ecx
movl 0x10(%rbp), %eax
orl %eax, 0x48(%rsp)
movq 0x40(%rsp), %rdi
jne 0x57bbcc
movq 0x60(%rsp), %rax
shlq $0x5, %rax
vmovdqa (%r15,%rax), %ymm0
cmpl $0x1e, 0x10(%rsp)
jg 0x57bbb8
movl 0x2c(%rsp), %eax
cmpl $0x2, %eax
movl $0x1, %ecx
cmovgel %eax, %ecx
vperm2i128 $0x28, %ymm0, %ymm0, %ymm1 # ymm1 = zero,zero,ymm0[0,1]
vpalignr $0xf, %ymm1, %ymm0, %ymm0 # ymm0 = 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]
decl %ecx
jne 0x57bba8
vextracti128 $0x1, %ymm0, %xmm0
vpextrb $0xf, %xmm0, %r13d
movl 0x4(%rsp), %r8d
movl %r10d, %ecx
vmovdqa 0x100(%rsp), %ymm0
vpcmpgtb %ymm2, %ymm0, %ymm0
vpcmpgtb 0xc0(%rsp), %ymm7, %ymm1
vpor %ymm1, %ymm0, %ymm0
vpmovmskb %ymm0, %eax
testl %eax, %eax
je 0x57bbfa
orb $0x40, 0xc(%rbx)
xorl %r13d, %r13d
xorl %r8d, %r8d
xorl %ecx, %ecx
movsbl %r13b, %eax
movl %eax, (%rbx)
movl %ecx, 0x4(%rbx)
movl %r8d, 0x8(%rbx)
vzeroupper
callq 0x2094b5
movq %r15, %rdi
callq 0x2094b5
movq %r14, %rdi
callq 0x2094b5
movq 0x20(%rsp), %rdi
callq 0x2094b5
movq %r12, %rdi
callq 0x2094b5
jmp 0x57bc6b
callq 0x1f8ee9
jmp 0x57bc69
callq 0x1f8ec3
jmp 0x57bc69
callq 0x1f8e9d
jmp 0x57bc69
callq 0x1f8e77
jmp 0x57bc69
callq 0x1f8e51
jmp 0x57bc69
callq 0x1f8e2b
jmp 0x57bc69
callq 0x1f8e05
jmp 0x57bc69
callq 0x1f8ddf
xorl %ebx, %ebx
movq %rbx, %rax
leaq -0x28(%rbp), %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq