// File: /workspace/github_c_makefile_star2_O3/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
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0xf8, %rsp
movq %rsi, 0x20(%rsp)
testq %rdi, %rdi
je 0x5a9442
movq 0x48(%rdi), %rax
movq %rax, 0x28(%rsp)
testq %rax, %rax
je 0x5a9449
movq 0x10(%rdi), %rax
movq %rax, 0x18(%rsp)
testq %rax, %rax
je 0x5a9450
movl 0x8(%rdi), %r15d
testl %r15d, %r15d
jle 0x5a9457
cmpq $0x0, 0x20(%rsp)
je 0x5a945e
movl %edx, %r9d
testl %edx, %edx
jle 0x5a9465
movl %ecx, %r13d
testl %ecx, %ecx
js 0x5a946c
testl %r8d, %r8d
js 0x5a9473
movl %r8d, 0xd0(%rsp)
leal -0x1(%r15), %ebp
addq $0x7, %r15
shrq $0x3, %r15
movl %ebp, %eax
xorl %edx, %edx
divl %r15d
movl %eax, %r14d
movl %edx, %r12d
movl %r13d, %esi
negl %esi
movq 0x18(%rsp), %rdx
movl 0x20(%rdx), %eax
movl $0x80000000, %edi       # imm = 0x80000000
movl %r13d, %ecx
orl %edi, %ecx
subl %eax, %edi
movl %esi, 0x90(%rsp)
cmpl %esi, %eax
cmovgl %ecx, %edi
movl %edi, 0x30(%rsp)
movl $0x7ffffffe, %eax       # imm = 0x7FFFFFFE
subl 0x1c(%rdx), %eax
movl %eax, 0xb0(%rsp)
movl $0x20, %edx
movl $0x20, %ecx
movl %r15d, %edi
movl %r9d, %esi
movq %r9, 0x70(%rsp)
callq 0x20adf4
testq %rax, %rax
je 0x5a9478
movq %rax, %rbx
movl %r13d, 0x50(%rsp)
movl %r12d, 0x14(%rsp)
movl %r14d, 0x4(%rsp)
movl %ebp, 0x10(%rsp)
orl $0x8480401, 0xc(%rax)   # imm = 0x8480401
movl $0x20, %edi
movq %r15, %rsi
callq 0x4f1904
movq %rax, %r12
movq 0x70(%rsp), %rax
leal 0x1(%rax), %esi
movl $0x20, %edi
callq 0x20a62d
movq %rax, %r13
movl $0x20, %edi
movq %r15, %rsi
callq 0x4f1904
movq %rax, %rbp
movl $0x20, %edi
movq %r15, %rsi
callq 0x4f1904
movq %rax, %r14
movl $0x20, %edi
movq %r15, %rsi
callq 0x4f1904
testq %r12, %r12
sete %cl
testq %r13, %r13
sete %dl
orb %cl, %dl
testq %rbp, %rbp
sete %cl
testq %r14, %r14
sete %sil
orb %cl, %sil
orb %dl, %sil
testq %rax, %rax
sete %cl
orb %sil, %cl
jne 0x5a9478
movq 0x70(%rsp), %r9
leal -0x1(%r9), %ecx
movl %ecx, 0x8(%rsp)
movl $0x7, %edx
subl 0x4(%rsp), %edx
movl 0x50(%rsp), %ecx
vmovd %ecx, %xmm0
vpbroadcastd %xmm0, %ymm2
movl 0xd0(%rsp), %esi
vmovd %esi, %xmm0
vpbroadcastd %xmm0, %ymm3
movl 0x30(%rsp), %edi
incl %edi
vmovd %edi, %xmm0
vpbroadcastd %xmm0, %ymm0
vmovss 0xb0(%rsp), %xmm1
vbroadcastss %xmm1, %ymm5
vxorps %xmm1, %xmm1, %xmm1
vmovdqu %ymm0, 0x30(%rsp)
vmovss %xmm0, %xmm1, %xmm0     # xmm0 = xmm0[0],xmm1[1,2,3]
imull %r15d, %esi
negl %esi
vmovd %esi, %xmm1
vpbroadcastd %xmm1, %ymm1
vpxor %xmm4, %xmm4, %xmm4
vpblendd $0x1, %ymm4, %ymm1, %ymm1 # ymm1 = ymm4[0],ymm1[1,2,3,4,5,6,7]
vmovups %ymm0, 0xd0(%rsp)
vpaddd %ymm1, %ymm0, %ymm15
movl %ecx, %ecx
movl %r15d, %esi
vmovd 0x90(%rsp), %xmm1
vpbroadcastd %xmm1, %ymm7
vmovq %rcx, %xmm1
vmovq %rsi, %xmm4
vpbroadcastq %xmm4, %ymm4
vpmuldq 0x84c59(%rip), %ymm4, %ymm6 # 0x62dc40
vpmuldq 0x84b50(%rip), %ymm4, %ymm8 # 0x62db40
vpbroadcastq %xmm1, %ymm9
xorl %ecx, %ecx
vpmovsxbd 0x84cc8(%rip), %ymm1 # 0x62dcc8
vpbroadcastq 0x84cb7(%rip), %ymm10 # 0x62dcc0
movq %r14, %rdi
movq %r12, %r8
vmovq %rcx, %xmm4
vpbroadcastq %xmm4, %ymm4
vpaddq %ymm4, %ymm6, %ymm11
vpaddq %ymm4, %ymm8, %ymm4
vpermd %ymm4, %ymm1, %ymm4
vpermd %ymm11, %ymm1, %ymm11
vinserti128 $0x1, %xmm11, %ymm4, %ymm4
vpmulld %ymm4, %ymm3, %ymm4
vpsubd %ymm4, %ymm7, %ymm4
vextracti128 $0x1, %ymm4, %xmm11
vpmovsxdq %xmm11, %ymm11
vpmovsxdq %xmm4, %ymm12
vpsubq %ymm9, %ymm11, %ymm11
vpcmpgtq %ymm10, %ymm11, %ymm13
vblendvpd %ymm13, %ymm11, %ymm10, %ymm11
vpsubq %ymm9, %ymm12, %ymm12
vpcmpgtq %ymm10, %ymm12, %ymm13
vblendvpd %ymm13, %ymm12, %ymm10, %ymm12
vpermd %ymm12, %ymm1, %ymm12
vpermd %ymm11, %ymm1, %ymm11
vmovdqa %ymm4, (%rdi)
vmovdqa %xmm11, 0x10(%r8)
vmovdqa %xmm12, (%r8)
incq %rcx
addq $0x20, %r8
addq $0x20, %rdi
cmpq %rcx, %r15
jne 0x5a900f
movl $0x0, (%r13)
movl %r9d, %edi
addl $0x7, %r9d
andl $-0x8, %r9d
leaq -0x1(%rdi), %rcx
vmovq %rcx, %xmm1
vpbroadcastq %xmm1, %ymm6
vpmovsxbd 0x84c0f(%rip), %ymm1 # 0x62dcd0
xorl %ecx, %ecx
vpmovsxbq 0x84afc(%rip), %ymm4 # 0x62dbc8
vpmovsxbq 0x84c0f(%rip), %ymm8 # 0x62dce4
vpbroadcastq 0x84aa2(%rip), %ymm9 # 0x62db80
vpxor %ymm6, %ymm9, %ymm10
vpcmpeqd %ymm11, %ymm11, %ymm11
vpbroadcastd 0x84bf0(%rip), %ymm0 # 0x62dce0
vmovq %rcx, %xmm12
vpbroadcastq %xmm12, %ymm12
vpor %ymm4, %ymm12, %ymm13
vpor %ymm8, %ymm12, %ymm12
vpxor %ymm9, %ymm12, %ymm12
vpcmpgtq %ymm10, %ymm12, %ymm12
vpxor %ymm9, %ymm13, %ymm13
vpcmpgtq %ymm10, %ymm13, %ymm13
vpackssdw %ymm12, %ymm13, %ymm12
vpxor %ymm11, %ymm12, %ymm12
vextracti128 $0x1, %ymm12, %xmm13
vpackssdw %xmm13, %xmm12, %xmm12
vpshufd $0xd8, %xmm12, %xmm12   # xmm12 = xmm12[0,2,1,3]
vpmovzxwd %xmm12, %ymm12  # ymm12 = xmm12[0],zero,xmm12[1],zero,xmm12[2],zero,xmm12[3],zero,xmm12[4],zero,xmm12[5],zero,xmm12[6],zero,xmm12[7],zero
vpslld $0x1f, %ymm12, %ymm12
vpaddd %ymm1, %ymm11, %ymm13
vpmulld %ymm3, %ymm13, %ymm13
vpsubd %ymm13, %ymm7, %ymm13
vpmaskmovd %ymm13, %ymm12, 0x4(%r13,%rcx,4)
addq $0x8, %rcx
vpaddd %ymm0, %ymm1, %ymm1
cmpq %rcx, %r9
jne 0x5a90f0
vmovdqu %ymm0, 0x70(%rsp)
movl %edx, 0xc(%rsp)
vpxor %xmm1, %xmm1, %xmm1
vpsubd %ymm2, %ymm1, %ymm1
leal -0x1(%r15), %ecx
shlq $0x5, %rcx
movq %rax, %r8
addq %rcx, %r8
movl %r15d, %r9d
vmovdqa %ymm1, (%r8)
vpsubd %ymm3, %ymm1, %ymm1
addq $-0x20, %r8
decl %r9d
jg 0x5a9182
movq %r14, %r8
addq %rcx, %r8
shlq $0x5, %r15
xorl %r9d, %r9d
vpmovsxbd 0x84b2e(%rip), %ymm9 # 0x62dcd8
vbroadcastss 0x84ca1(%rip), %ymm10 # 0x62de54
vbroadcastss 0x84e24(%rip), %ymm11 # 0x62dfe0
vbroadcastss 0x86b67(%rip), %ymm12 # 0x62fd2c
vpbroadcastd 0x86b62(%rip), %ymm13 # 0x62fd30
vbroadcastss 0x849e9(%rip), %ymm14 # 0x62dbc0
xorl %r10d, %r10d
vmovdqu 0x30(%rsp), %ymm7
vmovups %ymm5, 0x50(%rsp)
vmovaps %ymm5, %ymm8
vmovdqu %ymm15, 0xb0(%rsp)
vmovups %ymm11, 0x90(%rsp)
vpermd (%r8), %ymm9, %ymm1
vmovd (%r13,%r10,4), %xmm4
vpblendd $0x1, %ymm4, %ymm1, %ymm9 # ymm9 = ymm4[0],ymm1[1,2,3,4,5,6,7]
movq 0x18(%rsp), %rcx
movq 0x10(%rcx), %rcx
movq 0x20(%rsp), %rdx
movzbl (%rdx,%r10), %r11d
movslq (%rcx,%r11,4), %r11
imulq %rsi, %r11
shlq $0x5, %r11
addq 0x28(%rsp), %r11
vmovdqu 0x30(%rsp), %ymm15
vpsubd (%rax), %ymm15, %ymm1
xorl %ecx, %ecx
vmovups 0x70(%rsp), %ymm11
vpaddd (%r11,%rcx), %ymm9, %ymm4
vmovdqa (%r14,%rcx), %ymm9
vmovdqa (%r12,%rcx), %ymm0
vpsubd %ymm2, %ymm9, %ymm5
vpsubd %ymm3, %ymm0, %ymm0
vpcmpgtd %ymm0, %ymm5, %ymm6
vblendvps %ymm6, %ymm11, %ymm10, %ymm6
movq 0x10(%rbx), %rdx
movq (%rdx), %rdx
addq %r9, %rdx
vpaddd (%rax,%rcx), %ymm1, %ymm1
vmovaps %ymm6, (%rcx,%rdx)
vpmaxsd %ymm1, %ymm15, %ymm15
vpmaxsd %ymm0, %ymm5, %ymm0
vpminsd %ymm0, %ymm8, %ymm8
vpmaxsd %ymm4, %ymm0, %ymm1
vmovdqa %ymm0, (%r12,%rcx)
vmovdqa %ymm1, (%rbp,%rcx)
vmovdqa %ymm4, (%r14,%rcx)
addq $0x20, %rcx
cmpq %rcx, %r15
jne 0x5a9244
vpmovsxbd 0x84a24(%rip), %ymm9 # 0x62dcd8
vpermd %ymm1, %ymm9, %ymm0
vmovd 0x4(%r13,%r10,4), %xmm1
incq %r10
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
vmovdqu 0xb0(%rsp), %ymm15
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, %ymm15, %ymm0
vpmaxsd %ymm0, %ymm1, %ymm1
decl %ecx
jne 0x5a92e0
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 0xd0(%rsp), %ymm0, %ymm1
vpmaxsd %ymm4, %ymm1, %ymm4
xorl %ecx, %ecx
vmovups 0x90(%rsp), %ymm11
movq 0x10(%rbx), %rdx
movq (%rdx), %rdx
addq %r9, %rdx
vmovdqa (%rbp,%rcx), %ymm0
vpsubd %ymm2, %ymm4, %ymm4
vpsubd %ymm3, %ymm1, %ymm5
vpmaxsd %ymm5, %ymm4, %ymm1
vpcmpgtd %ymm5, %ymm4, %ymm4
vblendvps %ymm4, %ymm11, %ymm12, %ymm5
vpmaxsd %ymm1, %ymm0, %ymm4
vpcmpeqd (%r14,%rcx), %ymm4, %ymm6
vpcmpgtd %ymm1, %ymm0, %ymm0
vpaddd %ymm0, %ymm13, %ymm0
vblendvps %ymm6, %ymm14, %ymm0, %ymm0
vorps (%rcx,%rdx), %ymm5, %ymm5
vorps %ymm0, %ymm5, %ymm0
vmovaps %ymm0, (%rcx,%rdx)
vmovdqa %ymm4, (%r14,%rcx)
vpminsd %ymm1, %ymm8, %ymm0
vpminsd %ymm4, %ymm0, %ymm8
vpmaxsd %ymm4, %ymm7, %ymm7
addq $0x20, %rcx
cmpq %rcx, %r15
jne 0x5a931e
addq %r15, %r9
cmpq %rdi, %r10
jne 0x5a91fc
movl 0x14(%rsp), %ecx
shlq $0x5, %rcx
vmovdqa (%r14,%rcx), %ymm1
cmpl $0x6, 0x4(%rsp)
jg 0x5a93cb
xorl %ecx, %ecx
movl 0xc(%rsp), %edx
vmovdqu 0x50(%rsp), %ymm2
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]
incl %ecx
cmpl %edx, %ecx
jl 0x5a93b7
jmp 0x5a93d1
vmovdqu 0x50(%rsp), %ymm2
vmovdqu 0x30(%rsp), %ymm0
vpcmpgtd %ymm8, %ymm0, %ymm0
vpcmpgtd %ymm2, %ymm7, %ymm2
vpor %ymm0, %ymm2, %ymm0
vtestps %ymm0, %ymm0
je 0x5a93f7
orb $0x40, 0xc(%rbx)
vpxor %xmm0, %xmm0, %xmm0
xorl %ecx, %ecx
jmp 0x5a940e
vpermq $0xff, %ymm1, %ymm0     # ymm0 = ymm1[3,3,3,3]
vpshufd $0x55, %xmm0, %xmm0     # xmm0 = xmm0[1,1,1,1]
vpinsrd $0x1, 0x10(%rsp), %xmm0, %xmm0
movl 0x8(%rsp), %ecx
vmovq %xmm0, (%rbx)
movl %ecx, 0x8(%rbx)
movq %rax, %rdi
vzeroupper
callq 0x20a60d
movq %r14, %rdi
callq 0x20a60d
movq %rbp, %rdi
callq 0x20a60d
movq %r13, %rdi
callq 0x20a60d
movq %r12, %rdi
callq 0x20a60d
jmp 0x5a947a
callq 0x1f7f47
jmp 0x5a9478
callq 0x1f7f21
jmp 0x5a9478
callq 0x1f7efb
jmp 0x5a9478
callq 0x1f7ed5
jmp 0x5a9478
callq 0x1f7eaf
jmp 0x5a9478
callq 0x1f7e89
jmp 0x5a9478
callq 0x1f7e63
jmp 0x5a9478
callq 0x1f7e3d
xorl %ebx, %ebx
movq %rbx, %rax
addq $0xf8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
nop