// File: /workspace/github_c_makefile_star2_O3/nh13[P]ksw/src/parasail/src/nw_trace_scan_avx2_256_64.c
// Function: parasail_nw_trace_scan_profile_avx2_256_64
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;
    int64_t* restrict boundary = NULL;
    __m256i* restrict pvHt = NULL;
    __m256i* restrict pvH = NULL;
    __m256i* restrict pvGapper = NULL;
    __m256i vGapO;
    __m256i vGapE;
    int64_t NEG_LIMIT = 0;
    int64_t POS_LIMIT = 0;
    __m256i vZero;
    int64_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->profile64.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 = 4; /* number of values in vector unit */
    segLen = (s1Len + segWidth - 1) / segWidth;
    offset = (s1Len - 1) % segLen;
    position = (segWidth - 1) - (s1Len - 1) / segLen;
    pvP = (__m256i*)profile->profile64.score;
    vGapO = _mm256_set1_epi64x_rpl(open);
    vGapE = _mm256_set1_epi64x_rpl(gap);
    NEG_LIMIT = (-open < matrix->min ? INT64_MIN + open : INT64_MIN - matrix->min) + 1;
    POS_LIMIT = INT64_MAX - matrix->max - 1;
    vZero = _mm256_setzero_si256();
    score = NEG_LIMIT;
    vNegLimit = _mm256_set1_epi64x_rpl(NEG_LIMIT);
    vPosLimit = _mm256_set1_epi64x_rpl(POS_LIMIT);
    vSaturationCheckMin = vPosLimit;
    vSaturationCheckMax = vNegLimit;
    vNegInfFront = vZero;
    vTIns  = _mm256_set1_epi64x_rpl(PARASAIL_INS);
    vTDel  = _mm256_set1_epi64x_rpl(PARASAIL_DEL);
    vTDiag = _mm256_set1_epi64x_rpl(PARASAIL_DIAG);
    vTDiagE = _mm256_set1_epi64x_rpl(PARASAIL_DIAG_E);
    vTInsE = _mm256_set1_epi64x_rpl(PARASAIL_INS_E);
    vTDiagF = _mm256_set1_epi64x_rpl(PARASAIL_DIAG_F);
    vTDelF = _mm256_set1_epi64x_rpl(PARASAIL_DEL_F);
    vNegInfFront = _mm256_insert_epi64_rpl(vNegInfFront, NEG_LIMIT, 0);
    vSegLenXgap = _mm256_add_epi64(vNegInfFront,
            _mm256_slli_si256_rpl(_mm256_set1_epi64x_rpl(-segLen*gap), 8));

    /* 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_64 | PARASAIL_FLAG_LANES_4;

    /* initialize heap variables */
    pvE = parasail_memalign___m256i(32, segLen);
    boundary = parasail_memalign_int64_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_64_t h;
            __m256i_64_t e;
            for (segNum=0; segNum<segWidth; ++segNum) {
                int64_t tmp = -open-gap*(segNum*segLen+i);
                h.v[segNum] = tmp < INT64_MIN ? INT64_MIN : tmp;
                tmp = tmp - open;
                e.v[segNum] = tmp < INT64_MIN ? INT64_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 < INT64_MIN ? INT64_MIN : tmp;
        }
    }

    {
        __m256i vGapper = _mm256_sub_epi64(vZero,vGapO);
        for (i=segLen-1; i>=0; --i) {
            _mm256_store_si256(pvGapper+i, vGapper);
            vGapper = _mm256_sub_epi64(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, 8);
        vHp = _mm256_insert_epi64_rpl(vHp, boundary[j], 0);
        pvW = pvP + matrix->mapper[(unsigned char)s2[j]]*segLen;
        vHt = _mm256_sub_epi64(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_epi64(vH, vGapO);
            vE_ext = _mm256_sub_epi64(vE, vGapE);
            case1 = _mm256_cmpgt_epi64(vE_opn, vE_ext);
            vET = _mm256_blendv_epi8(vTInsE, vTDiagE, case1);
            arr_store(result->trace->trace_table, vET, i, segLen, j);
            vE = _mm256_max_epi64_rpl(vE_opn, vE_ext);
            vSaturationCheckMin = _mm256_min_epi64_rpl(vSaturationCheckMin, vE);
            vGapper = _mm256_add_epi64(vHt, vGapper);
            vF = _mm256_max_epi64_rpl(vF, vGapper);
            vHp = _mm256_add_epi64(vHp, vW);
            vHt = _mm256_max_epi64_rpl(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, 8);
        vHt = _mm256_insert_epi64_rpl(vHt, boundary[j+1], 0);
        vGapper = _mm256_load_si256(pvGapper);
        vGapper = _mm256_add_epi64(vHt, vGapper);
        vF = _mm256_max_epi64_rpl(vF, vGapper);
        for (i=0; i<segWidth-2; ++i) {
            __m256i vFt = _mm256_slli_si256_rpl(vF, 8);
            vFt = _mm256_add_epi64(vFt, vSegLenXgap);
            vF = _mm256_max_epi64_rpl(vF, vFt);
        }

        /* calculate final H */
        vF = _mm256_slli_si256_rpl(vF, 8);
        vF = _mm256_add_epi64(vF, vNegInfFront);
        vH = _mm256_max_epi64_rpl(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_epi64(vH, vGapO);
            vF_ext = _mm256_sub_epi64(vF, vGapE);
            vF = _mm256_max_epi64_rpl(vF_opn, vF_ext);
            case1 = _mm256_cmpgt_epi64(vF_opn, vF_ext);
            vFT = _mm256_blendv_epi8(vTDelF, vTDiagF, case1);
            vH = _mm256_max_epi64_rpl(vHt, vF);
            case1 = _mm256_cmpeq_epi64(vH, vHp);
            case2 = _mm256_cmpeq_epi64(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_epi64_rpl(vSaturationCheckMin, vH);
            vSaturationCheckMin = _mm256_min_epi64_rpl(vSaturationCheckMin, vF);
            vSaturationCheckMax = _mm256_max_epi64_rpl(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, 8);
        }
        score = (int64_t) _mm256_extract_epi64_rpl (vH, 3);
    }

    if (_mm256_movemask_epi8(_mm256_or_si256(
            _mm256_cmplt_epi64_rpl(vSaturationCheckMin, vNegLimit),
            _mm256_cmpgt_epi64(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 0x5a777a
movq 0x60(%rdi), %rax
movq %rax, 0x28(%rsp)
testq %rax, %rax
je 0x5a7781
movq 0x10(%rdi), %rax
movq %rax, 0x18(%rsp)
testq %rax, %rax
je 0x5a7788
movl 0x8(%rdi), %r14d
testl %r14d, %r14d
jle 0x5a778f
cmpq $0x0, 0x20(%rsp)
je 0x5a7796
movl %edx, %r9d
testl %edx, %edx
jle 0x5a779d
movl %ecx, %r13d
testl %ecx, %ecx
js 0x5a77a4
testl %r8d, %r8d
js 0x5a77ab
movl %r8d, 0xd0(%rsp)
leal -0x1(%r14), %ebp
addq $0x3, %r14
shrq $0x2, %r14
movl %ebp, %eax
xorl %edx, %edx
divl %r14d
movl %eax, %r15d
movl %edx, %r12d
movl %r13d, %ecx
negl %r13d
movq 0x18(%rsp), %rdx
movslq 0x20(%rdx), %rax
movq %rcx, 0xb0(%rsp)
btsq $0x3f, %rcx
movabsq $-0x8000000000000000, %rsi # imm = 0x8000000000000000
subq %rax, %rsi
cmpl %r13d, %eax
cmovgq %rcx, %rsi
movq %rsi, 0x30(%rsp)
movslq 0x1c(%rdx), %rax
movq %rax, 0x90(%rsp)
movl $0x20, %edx
movl $0x20, %ecx
movl %r14d, %edi
movl %r9d, %esi
movq %r9, 0x70(%rsp)
callq 0x20adf4
testq %rax, %rax
je 0x5a77b0
movq %rax, %rbx
movl %r13d, 0x50(%rsp)
movl %r12d, 0x14(%rsp)
movl %r15d, 0x8(%rsp)
movl %ebp, 0x10(%rsp)
orl $0x4880401, 0xc(%rax)   # imm = 0x4880401
movl $0x20, %edi
movq %r14, %rsi
callq 0x4f1904
movq %rax, %r15
movq 0x70(%rsp), %rax
leal 0x1(%rax), %esi
movl $0x20, %edi
callq 0x20a636
movq %rax, %r12
movl $0x20, %edi
movq %r14, %rsi
callq 0x4f1904
movq %rax, %r13
movl $0x20, %edi
movq %r14, %rsi
callq 0x4f1904
movq %rax, %rbp
movl $0x20, %edi
movq %r14, %rsi
callq 0x4f1904
testq %r15, %r15
sete %cl
testq %r12, %r12
sete %dl
orb %cl, %dl
testq %r13, %r13
sete %cl
testq %rbp, %rbp
sete %sil
orb %cl, %sil
orb %dl, %sil
testq %rax, %rax
sete %cl
orb %sil, %cl
jne 0x5a77b0
movq 0x70(%rsp), %r8
leal -0x1(%r8), %ecx
movl %ecx, 0x4(%rsp)
movl $0x3, %edx
subl 0x8(%rsp), %edx
vmovq 0xb0(%rsp), %xmm0
vpbroadcastq %xmm0, %ymm2
movl 0xd0(%rsp), %esi
movl %esi, %ecx
vmovq %rcx, %xmm0
vpbroadcastq %xmm0, %ymm3
movq 0x30(%rsp), %r9
incq %r9
movabsq $-0x8000000000000000, %rdi # imm = 0x8000000000000000
subq 0x90(%rsp), %rdi
addq $-0x2, %rdi
vmovq %r9, %xmm0
vpbroadcastq %xmm0, %ymm0
vmovq %rdi, %xmm1
vpbroadcastq %xmm1, %ymm4
vmovdqu %ymm0, 0x30(%rsp)
vmovq %xmm0, %xmm0            # xmm0 = xmm0[0],zero
imull %r14d, %esi
negl %esi
movslq %esi, %rsi
vmovq %rsi, %xmm1
vpbroadcastq %xmm1, %ymm1
vpxor %xmm5, %xmm5, %xmm5
vpblendd $0x3, %ymm5, %ymm1, %ymm1 # ymm1 = ymm5[0,1],ymm1[2,3,4,5,6,7]
vmovdqu %ymm0, 0xd0(%rsp)
vpaddq %ymm1, %ymm0, %ymm0
movslq 0x50(%rsp), %rsi
vmovd %r14d, %xmm1
vpbroadcastd %xmm1, %ymm1
vmovq %rcx, %xmm6
vpbroadcastq %xmm6, %ymm7
vmovq %rsi, %xmm6
vpbroadcastq %xmm6, %ymm8
vpmuldq 0x867fe(%rip), %ymm1, %ymm1 # 0x62db40
xorl %ecx, %ecx
movq %rbp, %rsi
movq %r15, %rdi
vmovq %rcx, %xmm6
vpbroadcastq %xmm6, %ymm6
vpaddq %ymm6, %ymm1, %ymm6
vpmuludq %ymm7, %ymm6, %ymm9
vpsrlq $0x20, %ymm6, %ymm6
vpmuludq %ymm7, %ymm6, %ymm6
vpsllq $0x20, %ymm6, %ymm6
vpaddq %ymm6, %ymm9, %ymm6
vpsubq %ymm6, %ymm8, %ymm6
vpsubq %ymm2, %ymm6, %ymm9
vmovdqa %ymm6, (%rsi)
vmovdqa %ymm9, (%rdi)
incq %rcx
addq $0x20, %rdi
addq $0x20, %rsi
cmpq %rcx, %r14
jne 0x5a734a
movq $0x0, (%r12)
movl %r8d, %esi
addl $0x3, %r8d
andl $-0x4, %r8d
leaq -0x1(%rsi), %rcx
vmovq %rcx, %xmm1
vpbroadcastq %xmm1, %ymm6
vpmovsxbq 0x84aa4(%rip), %ymm1 # 0x62be5c
xorl %ecx, %ecx
vpmovsxbq 0x849c5(%rip), %ymm9 # 0x62bd88
vpbroadcastq 0x867b4(%rip), %ymm10 # 0x62db80
vpxor %ymm6, %ymm10, %ymm11
vpcmpeqd %ymm12, %ymm12, %ymm12
vpbroadcastq 0x867aa(%rip), %ymm6 # 0x62db88
vmovq %rcx, %xmm13
vpbroadcastq %xmm13, %ymm13
vpor %ymm9, %ymm13, %ymm13
vpxor %ymm10, %ymm13, %ymm13
vpcmpgtq %ymm11, %ymm13, %ymm13
vpxor %ymm12, %ymm13, %ymm13
vpaddq %ymm1, %ymm12, %ymm14
vpmuludq %ymm7, %ymm14, %ymm15
vpsrlq $0x20, %ymm14, %ymm14
vpmuludq %ymm7, %ymm14, %ymm14
vpsllq $0x20, %ymm14, %ymm14
vpaddq %ymm14, %ymm15, %ymm14
vpsubq %ymm14, %ymm8, %ymm14
vpmaskmovq %ymm14, %ymm13, 0x8(%r12,%rcx,8)
addq $0x4, %rcx
vpaddq %ymm6, %ymm1, %ymm1
cmpq %rcx, %r8
jne 0x5a73de
vmovdqu %ymm0, 0x70(%rsp)
movl %edx, 0xc(%rsp)
vpxor %xmm1, %xmm1, %xmm1
vpsubq %ymm2, %ymm1, %ymm1
leal -0x1(%r14), %ecx
shlq $0x5, %rcx
movq %rax, %rdi
addq %rcx, %rdi
movl %r14d, %r8d
vmovdqa %ymm1, (%rdi)
vpsubq %ymm3, %ymm1, %ymm1
addq $-0x20, %rdi
decl %r8d
jg 0x5a7455
movq %rbp, %rdi
addq %rcx, %rdi
movq %r14, %r8
shlq $0x5, %r8
xorl %r9d, %r9d
movl %r14d, %r10d
vbroadcastsd 0x88826(%rip), %ymm9 # 0x62fca8
vbroadcastsd 0x88825(%rip), %ymm10 # 0x62fcb0
vbroadcastsd 0x88824(%rip), %ymm11 # 0x62fcb8
vbroadcastsd 0x88823(%rip), %ymm12 # 0x62fcc0
vpbroadcastq 0x88822(%rip), %ymm13 # 0x62fcc8
xorl %r11d, %r11d
vmovdqu 0x30(%rsp), %ymm7
vmovdqu %ymm4, 0x50(%rsp)
vmovdqa %ymm4, %ymm8
vmovdqu %ymm6, 0xb0(%rsp)
vmovupd %ymm11, 0x90(%rsp)
vmovdqa (%rdi), %ymm1
vinserti128 $0x1, %xmm1, %ymm0, %ymm14
vpalignr $0x8, %ymm14, %ymm1, %ymm1 # ymm1 = ymm14[8,9,10,11,12,13,14,15],ymm1[0,1,2,3,4,5,6,7],ymm14[24,25,26,27,28,29,30,31],ymm1[16,17,18,19,20,21,22,23]
vmovq (%r12,%r11,8), %xmm14
vpblendd $0x3, %ymm14, %ymm1, %ymm4 # ymm4 = ymm14[0,1],ymm1[2,3,4,5,6,7]
movq 0x18(%rsp), %rcx
movq 0x10(%rcx), %rcx
movq 0x20(%rsp), %rdx
movzbl (%rdx,%r11), %r14d
movslq (%rcx,%r14,4), %r14
imulq %r10, %r14
shlq $0x5, %r14
addq 0x28(%rsp), %r14
vmovdqu 0x30(%rsp), %ymm14
vpsubq (%rax), %ymm14, %ymm15
xorl %ecx, %ecx
vmovapd %ymm10, %ymm11
vpaddq (%r14,%rcx), %ymm4, %ymm1
vmovdqa (%rbp,%rcx), %ymm4
vmovdqa (%r15,%rcx), %ymm0
vpsubq %ymm2, %ymm4, %ymm5
vpsubq %ymm3, %ymm0, %ymm0
vpcmpgtq %ymm0, %ymm5, %ymm6
vmovapd %ymm9, %ymm10
vblendvpd %ymm6, %ymm9, %ymm11, %ymm9
movq 0x10(%rbx), %rdx
movq (%rdx), %rdx
vpaddq (%rax,%rcx), %ymm15, %ymm15
addq %r9, %rdx
vmovapd %ymm9, (%rcx,%rdx)
vpcmpgtq %ymm15, %ymm14, %ymm9
vblendvpd %ymm9, %ymm14, %ymm15, %ymm14
vmovapd %ymm10, %ymm9
vblendvpd %ymm6, %ymm5, %ymm0, %ymm0
vpcmpgtq %ymm8, %ymm0, %ymm5
vblendvpd %ymm5, %ymm8, %ymm0, %ymm8
vpcmpgtq %ymm1, %ymm0, %ymm5
vblendvpd %ymm5, %ymm0, %ymm1, %ymm15
vmovaps %ymm0, (%r15,%rcx)
vmovapd %ymm15, (%r13,%rcx)
vmovaps %ymm1, (%rbp,%rcx)
addq $0x20, %rcx
cmpq %rcx, %r8
jne 0x5a751c
vpermpd $0x90, %ymm15, %ymm1    # ymm1 = ymm15[0,0,1,2]
vmovsd 0x8(%r12,%r11,8), %xmm15
incq %r11
vblendpd $0x1, %ymm15, %ymm1, %ymm0 # ymm0 = ymm15[0],ymm1[1,2,3]
vpaddq (%rax), %ymm0, %ymm0
vpcmpgtq %ymm0, %ymm14, %ymm4
vblendvpd %ymm4, %ymm14, %ymm0, %ymm14
movb $0x1, %cl
vmovdqu 0x70(%rsp), %ymm5
vperm2f128 $0x8, %ymm14, %ymm14, %ymm0 # ymm0 = zero,zero,ymm14[0,1]
vpalignr $0x8, %ymm0, %ymm14, %ymm0 # ymm0 = ymm0[8,9,10,11,12,13,14,15],ymm14[0,1,2,3,4,5,6,7],ymm0[24,25,26,27,28,29,30,31],ymm14[16,17,18,19,20,21,22,23]
vpaddq %ymm0, %ymm5, %ymm0
vpcmpgtq %ymm0, %ymm14, %ymm4
vblendvpd %ymm4, %ymm14, %ymm0, %ymm14
testb $0x1, %cl
movl $0x0, %ecx
jne 0x5a75d3
vperm2f128 $0x8, %ymm14, %ymm14, %ymm0 # ymm0 = zero,zero,ymm14[0,1]
vpalignr $0x8, %ymm0, %ymm14, %ymm0 # ymm0 = ymm0[8,9,10,11,12,13,14,15],ymm14[0,1,2,3,4,5,6,7],ymm0[24,25,26,27,28,29,30,31],ymm14[16,17,18,19,20,21,22,23]
vpaddq 0xd0(%rsp), %ymm0, %ymm14
vblendpd $0x1, %ymm15, %ymm1, %ymm0 # ymm0 = ymm15[0],ymm1[1,2,3]
vpcmpgtq %ymm0, %ymm14, %ymm1
vblendvpd %ymm1, %ymm14, %ymm0, %ymm15
xorl %ecx, %ecx
vmovupd 0xb0(%rsp), %ymm6
vmovapd %ymm11, %ymm10
vmovupd 0x90(%rsp), %ymm11
movq 0x10(%rbx), %rdx
vpsubq %ymm2, %ymm15, %ymm0
vpsubq %ymm3, %ymm14, %ymm1
vpcmpgtq %ymm1, %ymm0, %ymm4
vblendvpd %ymm4, %ymm11, %ymm12, %ymm5
vblendvpd %ymm4, %ymm0, %ymm1, %ymm14
vmovdqa (%r13,%rcx), %ymm0
vpcmpgtq %ymm14, %ymm0, %ymm1
vblendvpd %ymm1, %ymm0, %ymm14, %ymm15
vpcmpeqq (%rbp,%rcx), %ymm15, %ymm0
movq (%rdx), %rdx
vpaddq %ymm1, %ymm13, %ymm1
vblendvpd %ymm0, %ymm6, %ymm1, %ymm0
addq %r9, %rdx
vorpd (%rcx,%rdx), %ymm5, %ymm1
vorpd %ymm0, %ymm1, %ymm0
vmovapd %ymm0, (%rcx,%rdx)
vmovaps %ymm15, (%rbp,%rcx)
vpcmpgtq %ymm8, %ymm15, %ymm0
vblendvpd %ymm0, %ymm8, %ymm15, %ymm0
vpcmpgtq %ymm0, %ymm14, %ymm1
vblendvpd %ymm1, %ymm0, %ymm14, %ymm8
vpcmpgtq %ymm15, %ymm7, %ymm0
vblendvpd %ymm0, %ymm7, %ymm15, %ymm7
addq $0x20, %rcx
cmpq %rcx, %r8
jne 0x5a7637
addq %r8, %r9
cmpq %rsi, %r11
jne 0x5a74cb
movl 0x14(%rsp), %ecx
shlq $0x5, %rcx
vmovdqa (%rbp,%rcx), %ymm1
cmpl $0x2, 0x8(%rsp)
jg 0x5a7704
xorl %ecx, %ecx
movl 0x4(%rsp), %esi
movl 0xc(%rsp), %edx
vmovdqu 0x50(%rsp), %ymm2
vperm2i128 $0x8, %ymm1, %ymm1, %ymm0 # ymm0 = zero,zero,ymm1[0,1]
vpalignr $0x8, %ymm0, %ymm1, %ymm1 # ymm1 = ymm0[8,9,10,11,12,13,14,15],ymm1[0,1,2,3,4,5,6,7],ymm0[24,25,26,27,28,29,30,31],ymm1[16,17,18,19,20,21,22,23]
incl %ecx
cmpl %edx, %ecx
jl 0x5a76f0
jmp 0x5a770e
movl 0x4(%rsp), %esi
vmovdqu 0x50(%rsp), %ymm2
vmovdqu 0x30(%rsp), %ymm0
vpcmpgtq %ymm8, %ymm0, %ymm0
vpcmpgtq %ymm2, %ymm7, %ymm2
vpor %ymm0, %ymm2, %ymm0
vtestpd %ymm0, %ymm0
je 0x5a7735
orb $0x40, 0xc(%rbx)
xorl %ecx, %ecx
xorl %esi, %esi
xorl %edx, %edx
jmp 0x5a7745
vextracti128 $0x1, %ymm1, %xmm0
vpextrq $0x1, %xmm0, %rcx
movl 0x10(%rsp), %edx
movl %ecx, (%rbx)
movl %edx, 0x4(%rbx)
movl %esi, 0x8(%rbx)
movq %rax, %rdi
vzeroupper
callq 0x20a60d
movq %rbp, %rdi
callq 0x20a60d
movq %r13, %rdi
callq 0x20a60d
movq %r12, %rdi
callq 0x20a60d
movq %r15, %rdi
callq 0x20a60d
jmp 0x5a77b2
callq 0x1f7899
jmp 0x5a77b0
callq 0x1f7873
jmp 0x5a77b0
callq 0x1f784d
jmp 0x5a77b0
callq 0x1f7827
jmp 0x5a77b0
callq 0x1f7801
jmp 0x5a77b0
callq 0x1f77db
jmp 0x5a77b0
callq 0x1f77b5
jmp 0x5a77b0
callq 0x1f778f
xorl %ebx, %ebx
movq %rbx, %rax
addq $0xf8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
nop