// File: /workspace/github_c_makefile_star2_O1/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
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
andq $-0x20, %rsp
subq $0x220, %rsp            # imm = 0x220
movq %rsi, 0x68(%rsp)
testq %rdi, %rdi
je 0x5757bc
movq 0x60(%rdi), %rax
movq %rax, 0x98(%rsp)
testq %rax, %rax
je 0x5757c3
movq 0x10(%rdi), %rax
movq %rax, 0x60(%rsp)
testq %rax, %rax
je 0x5757ca
movl 0x8(%rdi), %r15d
testl %r15d, %r15d
jle 0x5757d1
cmpq $0x0, 0x68(%rsp)
je 0x5757d8
movl %edx, %r9d
testl %edx, %edx
jle 0x5757df
testl %ecx, %ecx
js 0x5757e6
testl %r8d, %r8d
js 0x5757ed
movl %r8d, 0xe0(%rsp)
leal -0x1(%r15), %eax
addq $0x3, %r15
shrq $0x2, %r15
movl %eax, 0x24(%rsp)
cltd
idivl %r15d
movl %eax, %r12d
movl %edx, 0x5c(%rsp)
movl %ecx, %ebx
negl %ecx
movq 0x60(%rsp), %rdx
movslq 0x20(%rdx), %rax
movq %rbx, %rsi
btsq $0x3f, %rsi
movabsq $-0x8000000000000000, %r13 # imm = 0x8000000000000000
subq %rax, %r13
movl %ecx, 0xa0(%rsp)
cmpl %ecx, %eax
cmovgq %rsi, %r13
movslq 0x1c(%rdx), %rax
movq %rax, 0xc0(%rsp)
movl $0x20, %edx
movl $0x20, %ecx
movl %r15d, %edi
movl %r9d, %esi
movq %r9, 0x8(%rsp)
callq 0x2097d1
testq %rax, %rax
je 0x5757f2
movq %rax, %r14
movl %r12d, 0x20(%rsp)
orl $0x4880401, 0xc(%rax)   # imm = 0x4880401
movl $0x20, %edi
movq %r15, %rsi
callq 0x4c5e3c
movq %rax, %r12
movq 0x8(%rsp), %rax
leal 0x1(%rax), %esi
movl $0x20, %edi
movq %rsi, 0x10(%rsp)
callq 0x2094de
movq %rax, 0x38(%rsp)
movl $0x20, %edi
movq %r15, %rsi
callq 0x4c5e3c
movq %rax, 0x18(%rsp)
movl $0x20, %edi
movq %r15, %rsi
callq 0x4c5e3c
movq %rax, 0x48(%rsp)
movl $0x20, %edi
movq %r15, 0x30(%rsp)
movq %r15, %rsi
callq 0x4c5e3c
movq %r12, 0x40(%rsp)
testq %r12, %r12
movq 0x38(%rsp), %r12
sete %dl
testq %r12, %r12
sete %cl
orb %dl, %cl
cmpq $0x0, 0x18(%rsp)
movq 0x48(%rsp), %r15
sete %sil
testq %r15, %r15
sete %dl
orb %sil, %dl
orb %cl, %dl
testq %rax, %rax
sete %cl
orb %dl, %cl
jne 0x5757f2
movq %rax, 0x28(%rsp)
movq 0x8(%rsp), %rax
decl %eax
movl %eax, 0x58(%rsp)
movl $0x3, %eax
subl 0x20(%rsp), %eax
movl %eax, 0x54(%rsp)
vmovq %rbx, %xmm0
vpbroadcastq %xmm0, %ymm2
movl 0xe0(%rsp), %eax
movl %eax, %ecx
vmovq %rcx, %xmm0
vpbroadcastq %xmm0, %ymm3
incq %r13
movabsq $-0x8000000000000000, %rdx # imm = 0x8000000000000000
subq 0xc0(%rsp), %rdx
addq $-0x2, %rdx
vmovq %r13, %xmm0
vpbroadcastq %xmm0, %ymm1
vmovq %rdx, %xmm0
vpbroadcastq %xmm0, %ymm14
vmovdqa %ymm1, 0x100(%rsp)
vmovq %xmm1, %xmm4            # xmm4 = xmm1[0],zero
movq 0x30(%rsp), %rdx
imull %edx, %eax
negl %eax
cltq
vmovq %rax, %xmm0
vpbroadcastq %xmm0, %ymm0
vpxor %xmm1, %xmm1, %xmm1
vpblendd $0x3, %ymm1, %ymm0, %ymm0 # ymm0 = ymm1[0,1],ymm0[2,3,4,5,6,7]
vmovdqa %ymm4, 0x180(%rsp)
vpaddq %ymm0, %ymm4, %ymm1
movslq 0xa0(%rsp), %rax
movq %rdx, %r10
movl %edx, %r11d
negq %rbx
movq %r11, %rdx
imulq %rcx, %rdx
xorl %esi, %esi
movq 0x40(%rsp), %r13
movq %rax, %rdi
xorl %r8d, %r8d
movq %rdi, 0x1e0(%rsp,%r8,8)
leaq (%rbx,%rdi), %r9
movq %r9, 0x1c0(%rsp,%r8,8)
incq %r8
subq %rdx, %rdi
cmpq $0x4, %r8
jne 0x574ea4
movq %rsi, %rdi
shlq $0x5, %rdi
vmovaps 0x1e0(%rsp), %ymm0
vmovaps %ymm0, (%r15,%rdi)
vmovdqa 0x1c0(%rsp), %ymm0
vmovdqa %ymm0, (%r13,%rdi)
incq %rsi
subq %rcx, %rax
cmpq %r11, %rsi
jne 0x574e9e
movq $0x0, (%r12)
movslq 0xa0(%rsp), %rax
movl $0x1, %edx
movq 0x10(%rsp), %rsi
movq %rax, (%r12,%rdx,8)
incq %rdx
subq %rcx, %rax
cmpq %rdx, %rsi
jne 0x574f0f
vpxor %xmm0, %xmm0, %xmm0
vpsubq %ymm2, %ymm0, %ymm0
leal -0x1(%r10), %eax
movq %rax, %rdx
shlq $0x5, %rdx
movq 0x28(%rsp), %rcx
addq %rdx, %rcx
movl %r10d, %edx
movq 0x8(%rsp), %rdi
vmovdqa %ymm0, (%rcx)
vpsubq %ymm3, %ymm0, %ymm0
addq $-0x20, %rcx
decl %edx
jg 0x574f41
movl %eax, %eax
shlq $0x5, %rax
movq %r15, %rsi
movq %r15, %rcx
addq %rax, %rcx
movq %rcx, 0x88(%rsp)
cmpl $0x1, %r10d
adcl $0x0, %r10d
cmpl $0x2, %edi
movl $0x1, %eax
cmovgel %edi, %eax
movq %rax, 0x80(%rsp)
movq %r11, %rax
shlq $0x5, %rax
movq %rax, 0x78(%rsp)
shlq $0x5, %r10
movq %r10, 0x30(%rsp)
xorl %eax, %eax
vbroadcastsd 0x863e5(%rip), %ymm12 # 0x5fb388
vbroadcastsd 0x863e4(%rip), %ymm13 # 0x5fb390
vpbroadcastq 0x863e3(%rip), %ymm8 # 0x5fb398
vpbroadcastq 0x863e2(%rip), %ymm9 # 0x5fb3a0
vpbroadcastq 0x81139(%rip), %ymm10 # 0x5f6100
vpbroadcastq 0x849b0(%rip), %ymm0 # 0x5f9980
vmovdqa %ymm0, 0x140(%rsp)
xorl %edx, %edx
vmovdqa 0x100(%rsp), %ymm6
vmovdqa %ymm14, 0x120(%rsp)
movq %r14, 0x70(%rsp)
vmovdqa %ymm1, 0x160(%rsp)
movq %r11, 0x90(%rsp)
vmovdqa %ymm8, 0xa0(%rsp)
vmovdqa %ymm9, 0xe0(%rsp)
vmovdqa %ymm10, 0xc0(%rsp)
movq %rax, 0x8(%rsp)
vmovdqa %ymm6, 0x1a0(%rsp)
movq 0x88(%rsp), %rax
vmovdqa (%rax), %ymm0
vinserti128 $0x1, %xmm0, %ymm0, %ymm1
vpalignr $0x8, %ymm1, %ymm0, %ymm0 # ymm0 = ymm1[8,9,10,11,12,13,14,15],ymm0[0,1,2,3,4,5,6,7],ymm1[24,25,26,27,28,29,30,31],ymm0[16,17,18,19,20,21,22,23]
vmovq (%r12,%rdx,8), %xmm1
vpblendd $0x3, %ymm1, %ymm0, %ymm15 # ymm15 = ymm1[0,1],ymm0[2,3,4,5,6,7]
movq 0x60(%rsp), %rax
movq 0x10(%rax), %rax
movq 0x68(%rsp), %rcx
movq %rdx, 0x10(%rsp)
movzbl (%rcx,%rdx), %ecx
movslq (%rax,%rcx,4), %r8
imulq %r11, %r8
shlq $0x5, %r8
addq 0x98(%rsp), %r8
movq 0x28(%rsp), %r10
vmovdqa 0x100(%rsp), %ymm0
vpsubq (%r10), %ymm0, %ymm4
xorl %r9d, %r9d
movq %rsi, %r15
vpaddq (%r8,%r9), %ymm15, %ymm1
vmovdqa (%r15,%r9), %ymm15
vmovdqa (%r13,%r9), %ymm5
vpsubq %ymm2, %ymm15, %ymm9
vpsubq %ymm3, %ymm5, %ymm5
vpcmpgtq %ymm5, %ymm9, %ymm7
vblendvpd %ymm7, %ymm12, %ymm13, %ymm7
movq 0x10(%r14), %rax
movq (%rax), %rax
vpaddq (%r10,%r9), %ymm4, %ymm4
addq 0x8(%rsp), %rax
vmovapd %ymm7, (%r9,%rax)
vmovq %xmm9, %rax
vmovq %xmm5, %rcx
cmpq %rcx, %rax
cmovgq %rax, %rcx
vpextrq $0x1, %xmm9, %rax
vpextrq $0x1, %xmm5, %rdx
cmpq %rdx, %rax
cmovgq %rax, %rdx
vextracti128 $0x1, %ymm9, %xmm7
vmovq %xmm7, %rax
vextracti128 $0x1, %ymm5, %xmm5
vmovq %xmm5, %rdi
cmpq %rdi, %rax
cmovgq %rax, %rdi
vpextrq $0x1, %xmm7, %rax
vpextrq $0x1, %xmm5, %r13
cmpq %r13, %rax
cmovgq %rax, %r13
vmovq %xmm14, %r10
cmpq %rcx, %r10
cmovgeq %rcx, %r10
vpextrq $0x1, %xmm14, %rax
cmpq %rdx, %rax
cmovgeq %rdx, %rax
vextracti128 $0x1, %ymm14, %xmm5
vmovq %xmm5, %r12
cmpq %rdi, %r12
cmovgeq %rdi, %r12
vmovq %rcx, %xmm14
vpextrq $0x1, %xmm5, %rsi
cmpq %r13, %rsi
cmovgeq %r13, %rsi
vmovq %rsi, %xmm9
vmovq %xmm0, %rsi
vmovq %xmm4, %rbx
cmpq %rbx, %rsi
cmovgq %rsi, %rbx
vpextrq $0x1, %xmm0, %r11
vpextrq $0x1, %xmm4, %rsi
cmpq %rsi, %r11
cmovgq %r11, %rsi
vextracti128 $0x1, %ymm0, %xmm0
vmovq %xmm0, %r14
vextracti128 $0x1, %ymm4, %xmm4
vmovq %xmm4, %r11
cmpq %r11, %r14
cmovgq %r14, %r11
vpextrq $0x1, %xmm0, %r14
vmovq %r12, %xmm0
vpextrq $0x1, %xmm4, %r12
cmpq %r12, %r14
cmovgq %r14, %r12
vmovq %xmm1, %r14
cmpq %r14, %rcx
cmovleq %r14, %rcx
movq 0x70(%rsp), %r14
vmovq %rdx, %xmm4
vmovq %rdi, %xmm5
vmovq %rax, %xmm7
vpextrq $0x1, %xmm1, %rax
cmpq %rax, %rdx
cmovleq %rax, %rdx
vextracti128 $0x1, %ymm1, %xmm8
vmovq %xmm8, %rax
cmpq %rax, %rdi
cmovleq %rax, %rdi
vmovq %r13, %xmm10
vmovq %r10, %xmm11
movq 0x28(%rsp), %r10
vpextrq $0x1, %xmm8, %rax
cmpq %rax, %r13
cmovleq %rax, %r13
vmovq %r13, %xmm8
movq 0x40(%rsp), %r13
vmovdqa %ymm3, %ymm6
vmovdqa %ymm2, %ymm3
vmovapd %ymm13, %ymm2
vmovapd %ymm12, %ymm13
vpunpcklqdq %xmm4, %xmm14, %xmm12 # xmm12 = xmm14[0],xmm4[0]
vpunpcklqdq %xmm10, %xmm5, %xmm10 # xmm10 = xmm5[0],xmm10[0]
vpunpcklqdq %xmm9, %xmm0, %xmm0 # xmm0 = xmm0[0],xmm9[0]
vpunpcklqdq %xmm7, %xmm11, %xmm4 # xmm4 = xmm11[0],xmm7[0]
vinserti128 $0x1, %xmm0, %ymm4, %ymm14
vmovq %r12, %xmm0
vmovq %r11, %xmm4
vpunpcklqdq %xmm0, %xmm4, %xmm0 # xmm0 = xmm4[0],xmm0[0]
vmovq %rsi, %xmm4
vmovq %rbx, %xmm5
vpunpcklqdq %xmm4, %xmm5, %xmm4 # xmm4 = xmm5[0],xmm4[0]
vinserti128 $0x1, %xmm0, %ymm4, %ymm0
vmovq %rdx, %xmm9
vmovq %rcx, %xmm4
vpunpcklqdq %xmm9, %xmm4, %xmm4 # xmm4 = xmm4[0],xmm9[0]
vmovq %rdi, %xmm5
vinserti128 $0x1, %xmm5, %ymm4, %ymm5
vpbroadcastq %xmm8, %ymm4
vpblendd $0xc0, %ymm4, %ymm5, %ymm4 # ymm4 = ymm5[0,1,2,3,4,5],ymm4[6,7]
vmovdqa %xmm10, 0x10(%r13,%r9)
vmovdqa %xmm12, (%r13,%r9)
vmovapd %ymm13, %ymm12
vmovapd %ymm2, %ymm13
vmovdqa %ymm3, %ymm2
vmovdqa %ymm6, %ymm3
movq 0x18(%rsp), %rax
vmovdqa %ymm4, (%rax,%r9)
vmovdqa %ymm1, (%r15,%r9)
addq $0x20, %r9
cmpq %r9, 0x30(%rsp)
jne 0x575094
vpbroadcastq %xmm9, %ymm0
vpunpcklqdq %ymm5, %ymm0, %ymm0 # ymm0 = ymm0[0],ymm5[0],ymm0[2],ymm5[2]
movq 0x38(%rsp), %rax
movq 0x10(%rsp), %r9
movq 0x8(%rax,%r9,8), %r8
incq %r9
movq %r9, 0x10(%rsp)
vmovq %r8, %xmm1
vpblendd $0x3, %ymm1, %ymm0, %ymm0 # ymm0 = ymm1[0,1],ymm0[2,3,4,5,6,7]
vpaddq (%r10), %ymm0, %ymm0
vmovq %xmm0, %rax
cmpq %rax, %rbx
cmovgq %rbx, %rax
vpextrq $0x1, %xmm0, %r9
cmpq %r9, %rsi
cmovgq %rsi, %r9
vextracti128 $0x1, %ymm0, %xmm0
vmovq %xmm0, %rsi
cmpq %rsi, %r11
cmovgq %r11, %rsi
vpextrq $0x1, %xmm0, %r10
cmpq %r10, %r12
cmovgq %r12, %r10
vmovq %r10, %xmm0
vmovq %rsi, %xmm1
vpunpcklqdq %xmm0, %xmm1, %xmm0 # xmm0 = xmm1[0],xmm0[0]
vmovq %r9, %xmm1
vmovq %rax, %xmm4
vpunpcklqdq %xmm1, %xmm4, %xmm1 # xmm1 = xmm4[0],xmm1[0]
vinserti128 $0x1, %xmm0, %ymm1, %ymm0
movl $0x1, %eax
vmovdqa 0x160(%rsp), %ymm6
vperm2i128 $0x8, %ymm0, %ymm0, %ymm1 # ymm1 = zero,zero,ymm0[0,1]
vpalignr $0x8, %ymm1, %ymm0, %ymm1 # ymm1 = ymm1[8,9,10,11,12,13,14,15],ymm0[0,1,2,3,4,5,6,7],ymm1[24,25,26,27,28,29,30,31],ymm0[16,17,18,19,20,21,22,23]
vpaddq %ymm1, %ymm6, %ymm1
vmovq %xmm0, %rsi
vmovq %xmm1, %r9
cmpq %r9, %rsi
cmovgq %rsi, %r9
vpextrq $0x1, %xmm0, %rsi
vpextrq $0x1, %xmm1, %r10
cmpq %r10, %rsi
cmovgq %rsi, %r10
vextracti128 $0x1, %ymm0, %xmm0
vmovq %xmm0, %rsi
vextracti128 $0x1, %ymm1, %xmm4
vmovq %xmm4, %r11
cmpq %r11, %rsi
cmovgq %rsi, %r11
vmovq %r10, %xmm1
vmovq %r9, %xmm5
vpunpcklqdq %xmm1, %xmm5, %xmm5 # xmm5 = xmm5[0],xmm1[0]
vmovq %r11, %xmm7
vpextrq $0x1, %xmm0, %rsi
vpextrq $0x1, %xmm4, %r9
vinserti128 $0x1, %xmm7, %ymm5, %ymm4
cmpq %r9, %rsi
cmovgq %rsi, %r9
vmovq %r9, %xmm0
vpbroadcastq %xmm0, %ymm0
vpblendd $0xc0, %ymm0, %ymm4, %ymm0 # ymm0 = ymm4[0,1,2,3,4,5],ymm0[6,7]
decl %eax
je 0x57536d
vpbroadcastq %xmm1, %xmm0
vpxor %xmm1, %xmm1, %xmm1
vinserti128 $0x1, %xmm0, %ymm1, %ymm0
vpalignr $0x8, %ymm0, %ymm4, %ymm0 # ymm0 = ymm0[8,9,10,11,12,13,14,15],ymm4[0,1,2,3,4,5,6,7],ymm0[24,25,26,27,28,29,30,31],ymm4[16,17,18,19,20,21,22,23]
vpaddq 0x180(%rsp), %ymm0, %ymm15
vmovq %xmm15, %rax
cmpq %r8, %rax
cmovgq %rax, %r8
vpextrq $0x1, %xmm15, %rax
cmpq %rcx, %rax
cmovgq %rax, %rcx
vextracti128 $0x1, %ymm15, %xmm0
vmovq %xmm0, %rax
cmpq %rdx, %rax
cmovgq %rax, %rdx
vpextrq $0x1, %xmm0, %rax
cmpq %rdi, %rax
cmovgq %rax, %rdi
vmovq %rdi, %xmm0
vmovq %rdx, %xmm1
vpunpcklqdq %xmm0, %xmm1, %xmm0 # xmm0 = xmm1[0],xmm0[0]
vmovq %rcx, %xmm1
vmovq %r8, %xmm4
vpunpcklqdq %xmm1, %xmm4, %xmm1 # xmm1 = xmm4[0],xmm1[0]
vinserti128 $0x1, %xmm0, %ymm1, %ymm0
xorl %ecx, %ecx
vmovdqa 0x1a0(%rsp), %ymm6
vmovapd 0xa0(%rsp), %ymm8
vmovapd 0xe0(%rsp), %ymm9
vmovdqa 0xc0(%rsp), %ymm10
vmovapd 0x140(%rsp), %ymm11
movq 0x10(%r14), %rax
movq (%rax), %r12
addq 0x8(%rsp), %r12
vpsubq %ymm2, %ymm0, %ymm0
vpsubq %ymm3, %ymm15, %ymm1
vmovq %xmm0, %rax
vmovq %xmm1, %rdi
cmpq %rdi, %rax
cmovgq %rax, %rdi
vpextrq $0x1, %xmm0, %rax
vpextrq $0x1, %xmm1, %r9
cmpq %r9, %rax
cmovgq %rax, %r9
vextracti128 $0x1, %ymm0, %xmm4
vmovq %xmm4, %rax
vextracti128 $0x1, %ymm1, %xmm5
vmovq %xmm5, %r10
cmpq %r10, %rax
cmovgq %rax, %r10
vpextrq $0x1, %xmm4, %rax
vpextrq $0x1, %xmm5, %rbx
cmpq %rbx, %rax
cmovgq %rax, %rbx
vmovq %rbx, %xmm4
vmovq %r10, %xmm5
vpunpcklqdq %xmm4, %xmm5, %xmm4 # xmm4 = xmm5[0],xmm4[0]
vmovq %r9, %xmm5
vmovq %rdi, %xmm7
vpunpcklqdq %xmm5, %xmm7, %xmm5 # xmm5 = xmm7[0],xmm5[0]
vinserti128 $0x1, %xmm4, %ymm5, %ymm15
vpcmpgtq %ymm1, %ymm0, %ymm0
vblendvpd %ymm0, %ymm8, %ymm9, %ymm1
movq 0x18(%rsp), %rax
movq (%rax,%rcx), %rdx
movq 0x8(%rax,%rcx), %rsi
cmpq %rdi, %rdx
cmovleq %rdi, %rdx
cmpq %r9, %rsi
cmovleq %r9, %rsi
movq 0x10(%rax,%rcx), %r8
cmpq %r10, %r8
cmovleq %r10, %r8
movq 0x18(%rax,%rcx), %r11
cmpq %rbx, %r11
cmovleq %rbx, %r11
vmovq %r11, %xmm0
vmovq %r8, %xmm4
vpunpcklqdq %xmm0, %xmm4, %xmm0 # xmm0 = xmm4[0],xmm0[0]
vmovq %rsi, %xmm4
vmovq %rdx, %xmm5
vpunpcklqdq %xmm4, %xmm5, %xmm4 # xmm4 = xmm5[0],xmm4[0]
vinserti128 $0x1, %xmm0, %ymm4, %ymm0
movq 0x48(%rsp), %r15
vpcmpeqq (%r15,%rcx), %ymm0, %ymm4
vpcmpeqq %ymm15, %ymm0, %ymm5
vpsubq %ymm5, %ymm10, %ymm5
vblendvpd %ymm4, %ymm11, %ymm5, %ymm4
vorpd (%rcx,%r12), %ymm1, %ymm1
vorpd %ymm4, %ymm1, %ymm1
vmovapd %ymm1, (%rcx,%r12)
vmovq %xmm14, %rax
cmpq %rdx, %rax
cmovgeq %rdx, %rax
vpextrq $0x1, %xmm14, %r14
cmpq %rsi, %r14
cmovgeq %rsi, %r14
vextracti128 $0x1, %ymm14, %xmm1
vmovq %xmm1, %r12
cmpq %r8, %r12
cmovgeq %r8, %r12
vpextrq $0x1, %xmm1, %r13
cmpq %r11, %r13
cmovgeq %r11, %r13
cmpq %rdi, %rax
cmovgeq %rdi, %rax
cmpq %r9, %r14
cmovgeq %r9, %r14
cmpq %r10, %r12
cmovgeq %r10, %r12
cmpq %rbx, %r13
cmovgeq %rbx, %r13
vmovq %r13, %xmm1
vmovq %r12, %xmm4
vmovq %r14, %xmm5
movq 0x70(%rsp), %r14
vmovq %xmm6, %rdi
cmpq %rdx, %rdi
cmovgq %rdi, %rdx
vpextrq $0x1, %xmm6, %rdi
cmpq %rsi, %rdi
cmovgq %rdi, %rsi
vextracti128 $0x1, %ymm6, %xmm6
vmovq %xmm6, %rdi
cmpq %r8, %rdi
cmovgq %rdi, %r8
vmovq %rax, %xmm7
vpextrq $0x1, %xmm6, %rax
cmpq %r11, %rax
cmovgq %rax, %r11
vmovq %r11, %xmm6
vmovq %r8, %xmm8
vmovq %rsi, %xmm9
vmovq %rdx, %xmm10
vpunpcklqdq %xmm1, %xmm4, %xmm1 # xmm1 = xmm4[0],xmm1[0]
vpunpcklqdq %xmm5, %xmm7, %xmm4 # xmm4 = xmm7[0],xmm5[0]
vinserti128 $0x1, %xmm1, %ymm4, %ymm14
vmovdqa %ymm0, (%r15,%rcx)
vpunpcklqdq %xmm6, %xmm8, %xmm1 # xmm1 = xmm8[0],xmm6[0]
vmovdqa 0xa0(%rsp), %ymm8
vpunpcklqdq %xmm9, %xmm10, %xmm4 # xmm4 = xmm10[0],xmm9[0]
vmovdqa 0xc0(%rsp), %ymm10
vmovdqa 0xe0(%rsp), %ymm9
vinserti128 $0x1, %xmm1, %ymm4, %ymm6
addq $0x20, %rcx
cmpq %rcx, 0x30(%rsp)
jne 0x5754a9
movq 0x8(%rsp), %rax
addq 0x78(%rsp), %rax
movq 0x10(%rsp), %rdx
cmpq 0x80(%rsp), %rdx
movq 0x40(%rsp), %r13
movq 0x38(%rsp), %r12
movq 0x48(%rsp), %rsi
movq 0x90(%rsp), %r11
jne 0x57501e
movl 0x5c(%rsp), %eax
shlq $0x5, %rax
movq %rsi, %r15
vmovdqa (%rsi,%rax), %ymm0
cmpl $0x2, 0x20(%rsp)
movq 0x28(%rsp), %rdi
movl 0x58(%rsp), %edx
jg 0x575742
movl 0x54(%rsp), %ecx
cmpl $0x2, %ecx
movl $0x1, %eax
cmovgel %ecx, %eax
movl 0x24(%rsp), %ecx
movq 0x18(%rsp), %rbx
vperm2i128 $0x8, %ymm0, %ymm0, %ymm1 # ymm1 = zero,zero,ymm0[0,1]
vpalignr $0x8, %ymm1, %ymm0, %ymm0 # ymm0 = ymm1[8,9,10,11,12,13,14,15],ymm0[0,1,2,3,4,5,6,7],ymm1[24,25,26,27,28,29,30,31],ymm0[16,17,18,19,20,21,22,23]
decl %eax
jne 0x575730
jmp 0x57574b
movl 0x24(%rsp), %ecx
movq 0x18(%rsp), %rbx
vmovdqa 0x100(%rsp), %ymm1
vpcmpgtq %ymm14, %ymm1, %ymm1
vpcmpgtq 0x120(%rsp), %ymm6, %ymm2
vpor %ymm1, %ymm2, %ymm1
vtestpd %ymm1, %ymm1
je 0x57577b
orb $0x40, 0xc(%r14)
xorl %eax, %eax
xorl %edx, %edx
xorl %ecx, %ecx
jmp 0x575787
vextracti128 $0x1, %ymm0, %xmm0
vpextrq $0x1, %xmm0, %rax
movl %eax, (%r14)
movl %ecx, 0x4(%r14)
movl %edx, 0x8(%r14)
vzeroupper
callq 0x2094b5
movq %r15, %rdi
callq 0x2094b5
movq %rbx, %rdi
callq 0x2094b5
movq %r12, %rdi
callq 0x2094b5
movq %r13, %rdi
callq 0x2094b5
jmp 0x5757f5
callq 0x1f78a5
jmp 0x5757f2
callq 0x1f787f
jmp 0x5757f2
callq 0x1f7859
jmp 0x5757f2
callq 0x1f7833
jmp 0x5757f2
callq 0x1f780d
jmp 0x5757f2
callq 0x1f77e7
jmp 0x5757f2
callq 0x1f77c1
jmp 0x5757f2
callq 0x1f779b
xorl %r14d, %r14d
movq %r14, %rax
leaq -0x28(%rbp), %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
nop