// File: /workspace/github_c_makefile_star2_O1/nh13[P]ksw/src/parasail/src/nw_trace_striped_avx2_256_64.c
// Function: parasail_nw_trace_striped_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 vProfile = NULL;
    __m256i* restrict pvHStore = NULL;
    __m256i* restrict pvHLoad = NULL;
    __m256i* restrict pvE = NULL;
    __m256i* restrict pvEaStore = NULL;
    __m256i* restrict pvEaLoad = NULL;
    __m256i* restrict pvHT = NULL;
    int64_t* restrict boundary = NULL;
    __m256i vGapO;
    __m256i vGapE;
    int64_t NEG_LIMIT = 0;
    int64_t POS_LIMIT = 0;
    int64_t score = 0;
    __m256i vNegLimit;
    __m256i vPosLimit;
    __m256i vSaturationCheckMin;
    __m256i vSaturationCheckMax;
    parasail_result_t *result = NULL;
    __m256i vTIns;
    __m256i vTDel;
    __m256i vTDiag;
    __m256i vTDiagE;
    __m256i vTInsE;
    __m256i vTDiagF;
    __m256i vTDelF;
    __m256i vTMask;
    __m256i vFTMask;

    /* 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;
    vProfile = (__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;
    score = NEG_LIMIT;
    vNegLimit = _mm256_set1_epi64x_rpl(NEG_LIMIT);
    vPosLimit = _mm256_set1_epi64x_rpl(POS_LIMIT);
    vSaturationCheckMin = vPosLimit;
    vSaturationCheckMax = vNegLimit;
    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);
    vTMask = _mm256_set1_epi64x_rpl(PARASAIL_ZERO_MASK);
    vFTMask = _mm256_set1_epi64x_rpl(PARASAIL_F_MASK);

    /* 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_STRIPED
        | PARASAIL_FLAG_TRACE
        | PARASAIL_FLAG_BITS_64 | PARASAIL_FLAG_LANES_4;

    /* initialize heap variables */
    pvHStore = parasail_memalign___m256i(32, segLen);
    pvHLoad = parasail_memalign___m256i(32, segLen);
    pvE = parasail_memalign___m256i(32, segLen);
    pvEaStore = parasail_memalign___m256i(32, segLen);
    pvEaLoad = parasail_memalign___m256i(32, segLen);
    pvHT = parasail_memalign___m256i(32, segLen);
    boundary = parasail_memalign_int64_t(32, s2Len+1);

    /* validate heap variables */
    if (!pvHStore) return NULL;
    if (!pvHLoad) return NULL;
    if (!pvE) return NULL;
    if (!pvEaStore) return NULL;
    if (!pvEaLoad) return NULL;
    if (!pvHT) return NULL;
    if (!boundary) 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(&pvHStore[index], h.m);
            _mm256_store_si256(&pvE[index], e.m);
            _mm256_store_si256(&pvEaStore[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;
        }
    }

    for (i=0; i<segLen; ++i) {
        arr_store(result->trace->trace_table, vTDiagE, i, segLen, 0);
    }

    /* outer loop over database sequence */
    for (j=0; j<s2Len; ++j) {
        __m256i vEF_opn;
        __m256i vE;
        __m256i vE_ext;
        __m256i vF;
        __m256i vF_ext;
        __m256i vFa;
        __m256i vFa_ext;
        __m256i vH;
        __m256i vH_dag;
        const __m256i* vP = NULL;

        /* Initialize F value to -inf.  Any errors to vH values will be
         * corrected in the Lazy_F loop.  */
        vF = vNegLimit;

        /* load final segment of pvHStore and shift left by 8 bytes */
        vH = _mm256_load_si256(&pvHStore[segLen - 1]);
        vH = _mm256_slli_si256_rpl(vH, 8);

        /* insert upper boundary condition */
        vH = _mm256_insert_epi64_rpl(vH, boundary[j], 0);

        /* Correct part of the vProfile */
        vP = vProfile + matrix->mapper[(unsigned char)s2[j]] * segLen;

        /* Swap the 2 H buffers. */
        SWAP(pvHLoad, pvHStore)
        SWAP(pvEaLoad, pvEaStore)

        /* inner loop to process the query sequence */
        for (i=0; i<segLen; ++i) {
            vE = _mm256_load_si256(pvE + i);

            /* Get max from vH, vE and vF. */
            vH_dag = _mm256_add_epi64(vH, _mm256_load_si256(vP + i));
            vH = _mm256_max_epi64_rpl(vH_dag, vE);
            vH = _mm256_max_epi64_rpl(vH, vF);
            /* Save vH values. */
            _mm256_store_si256(pvHStore + i, vH);
            vSaturationCheckMax = _mm256_max_epi64_rpl(vSaturationCheckMax, vH);
            vSaturationCheckMin = _mm256_min_epi64_rpl(vSaturationCheckMin, vH);
            vSaturationCheckMin = _mm256_min_epi64_rpl(vSaturationCheckMin, vE);
            vSaturationCheckMin = _mm256_min_epi64_rpl(vSaturationCheckMin, vF);

            {
                __m256i vTAll = arr_load(result->trace->trace_table, i, segLen, j);
                __m256i case1 = _mm256_cmpeq_epi64(vH, vH_dag);
                __m256i case2 = _mm256_cmpeq_epi64(vH, vF);
                __m256i vT = _mm256_blendv_epi8(
                        _mm256_blendv_epi8(vTIns, vTDel, case2),
                        vTDiag, case1);
                _mm256_store_si256(pvHT + i, vT);
                vT = _mm256_or_si256(vT, vTAll);
                arr_store(result->trace->trace_table, vT, i, segLen, j);
            }

            vEF_opn = _mm256_sub_epi64(vH, vGapO);

            /* Update vE value. */
            vE_ext = _mm256_sub_epi64(vE, vGapE);
            vE = _mm256_max_epi64_rpl(vEF_opn, vE_ext);
            _mm256_store_si256(pvE + i, vE);
            {
                __m256i vEa = _mm256_load_si256(pvEaLoad + i);
                __m256i vEa_ext = _mm256_sub_epi64(vEa, vGapE);
                vEa = _mm256_max_epi64_rpl(vEF_opn, vEa_ext);
                _mm256_store_si256(pvEaStore + i, vEa);
                if (j+1<s2Len) {
                    __m256i cond = _mm256_cmpgt_epi64(vEF_opn, vEa_ext);
                    __m256i vT = _mm256_blendv_epi8(vTInsE, vTDiagE, cond);
                    arr_store(result->trace->trace_table, vT, i, segLen, j+1);
                }
            }

            /* Update vF value. */
            vF_ext = _mm256_sub_epi64(vF, vGapE);
            vF = _mm256_max_epi64_rpl(vEF_opn, vF_ext);
            if (i+1<segLen) {
                __m256i vTAll = arr_load(result->trace->trace_table, i+1, segLen, j);
                __m256i cond = _mm256_cmpgt_epi64(vEF_opn, vF_ext);
                __m256i vT = _mm256_blendv_epi8(vTDelF, vTDiagF, cond);
                vT = _mm256_or_si256(vT, vTAll);
                arr_store(result->trace->trace_table, vT, i+1, segLen, j);
            }

            /* Load the next vH. */
            vH = _mm256_load_si256(pvHLoad + i);
        }


        /* Lazy_F loop: has been revised to disallow adjecent insertion and
         * then deletion, so don't update E(i, i), learn from SWPS3 */
        vFa_ext = vF_ext;
        vFa = vF;
        for (k=0; k<segWidth; ++k) {
            int64_t tmp = boundary[j+1]-open;
            int64_t tmp2 = tmp < INT64_MIN ? INT64_MIN : tmp;
            __m256i vHp = _mm256_load_si256(&pvHLoad[segLen - 1]);
            vHp = _mm256_slli_si256_rpl(vHp, 8);
            vHp = _mm256_insert_epi64_rpl(vHp, boundary[j], 0);
            vEF_opn = _mm256_slli_si256_rpl(vEF_opn, 8);
            vEF_opn = _mm256_insert_epi64_rpl(vEF_opn, tmp2, 0);
            vF_ext = _mm256_slli_si256_rpl(vF_ext, 8);
            vF_ext = _mm256_insert_epi64_rpl(vF_ext, NEG_LIMIT, 0);
            vF = _mm256_slli_si256_rpl(vF, 8);
            vF = _mm256_insert_epi64_rpl(vF, tmp2, 0);
            vFa_ext = _mm256_slli_si256_rpl(vFa_ext, 8);
            vFa_ext = _mm256_insert_epi64_rpl(vFa_ext, NEG_LIMIT, 0);
            vFa = _mm256_slli_si256_rpl(vFa, 8);
            vFa = _mm256_insert_epi64_rpl(vFa, tmp2, 0);
            for (i=0; i<segLen; ++i) {
                vH = _mm256_load_si256(pvHStore + i);
                vH = _mm256_max_epi64_rpl(vH,vF);
                _mm256_store_si256(pvHStore + i, vH);
                vSaturationCheckMin = _mm256_min_epi64_rpl(vSaturationCheckMin, vH);
                vSaturationCheckMax = _mm256_max_epi64_rpl(vSaturationCheckMax, vH);
                {
                    __m256i vTAll;
                    __m256i vT;
                    __m256i case1;
                    __m256i case2;
                    __m256i cond;
                    vHp = _mm256_add_epi64(vHp, _mm256_load_si256(vP + i));
                    case1 = _mm256_cmpeq_epi64(vH, vHp);
                    case2 = _mm256_cmpeq_epi64(vH, vF);
                    cond = _mm256_andnot_si256(case1,case2);
                    vTAll = arr_load(result->trace->trace_table, i, segLen, j);
                    vT = _mm256_load_si256(pvHT + i);
                    vT = _mm256_blendv_epi8(vT, vTDel, cond);
                    _mm256_store_si256(pvHT + i, vT);
                    vTAll = _mm256_and_si256(vTAll, vTMask);
                    vTAll = _mm256_or_si256(vTAll, vT);
                    arr_store(result->trace->trace_table, vTAll, i, segLen, j);
                }
                /* Update vF value. */
                {
                    __m256i vTAll = arr_load(result->trace->trace_table, i, segLen, j);
                    __m256i cond = _mm256_cmpgt_epi64(vEF_opn, vFa_ext);
                    __m256i vT = _mm256_blendv_epi8(vTDelF, vTDiagF, cond);
                    vTAll = _mm256_and_si256(vTAll, vFTMask);
                    vTAll = _mm256_or_si256(vTAll, vT);
                    arr_store(result->trace->trace_table, vTAll, i, segLen, j);
                }
                vEF_opn = _mm256_sub_epi64(vH, vGapO);
                vF_ext = _mm256_sub_epi64(vF, vGapE);
                {
                    __m256i vEa = _mm256_load_si256(pvEaLoad + i);
                    __m256i vEa_ext = _mm256_sub_epi64(vEa, vGapE);
                    vEa = _mm256_max_epi64_rpl(vEF_opn, vEa_ext);
                    _mm256_store_si256(pvEaStore + i, vEa);
                    if (j+1<s2Len) {
                        __m256i cond = _mm256_cmpgt_epi64(vEF_opn, vEa_ext);
                        __m256i vT = _mm256_blendv_epi8(vTInsE, vTDiagE, cond);
                        arr_store(result->trace->trace_table, vT, i, segLen, j+1);
                    }
                }
                if (! _mm256_movemask_epi8(
                            _mm256_or_si256(
                                _mm256_cmpgt_epi64(vF_ext, vEF_opn),
                                _mm256_cmpeq_epi64(vF_ext, vEF_opn))))
                    goto end;
                /*vF = _mm256_max_epi64_rpl(vEF_opn, vF_ext);*/
                vF = vF_ext;
                vFa_ext = _mm256_sub_epi64(vFa, vGapE);
                vFa = _mm256_max_epi64_rpl(vEF_opn, vFa_ext);
                vHp = _mm256_load_si256(pvHLoad + i);
            }
        }
end:
        {
        }
    }

    /* extract last value from the last column */
    {
        __m256i vH = _mm256_load_si256(pvHStore + 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(boundary);
    parasail_free(pvHT);
    parasail_free(pvEaLoad);
    parasail_free(pvEaStore);
    parasail_free(pvE);
    parasail_free(pvHLoad);
    parasail_free(pvHStore);

    return result;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
andq $-0x20, %rsp
subq $0x2e0, %rsp            # imm = 0x2E0
movq %rsi, 0xa8(%rsp)
testq %rdi, %rdi
je 0x58c76d
movq 0x60(%rdi), %rax
movq %rax, 0xf0(%rsp)
testq %rax, %rax
je 0x58c774
movq 0x10(%rdi), %rax
movq %rax, 0xa0(%rsp)
testq %rax, %rax
je 0x58c77b
movl 0x8(%rdi), %r12d
testl %r12d, %r12d
jle 0x58c782
cmpq $0x0, 0xa8(%rsp)
je 0x58c789
movl %edx, %r15d
testl %edx, %edx
jle 0x58c790
movl %ecx, %r9d
testl %ecx, %ecx
js 0x58c797
testl %r8d, %r8d
js 0x58c79e
movl %r8d, 0x58(%rsp)
leal -0x1(%r12), %eax
addq $0x3, %r12
shrq $0x2, %r12
movl %eax, 0x64(%rsp)
cltd
idivl %r12d
movl %eax, %ebx
movl %edx, %r14d
movl %r9d, %ecx
negl %r9d
movq 0xa0(%rsp), %rdx
movslq 0x20(%rdx), %rax
movq %rcx, 0xb0(%rsp)
btsq $0x3f, %rcx
movabsq $-0x8000000000000000, %r13 # imm = 0x8000000000000000
subq %rax, %r13
movl %r9d, 0x20(%rsp)
cmpl %r9d, %eax
cmovgq %rcx, %r13
movslq 0x1c(%rdx), %rax
movq %rax, 0x50(%rsp)
movl $0x20, %edx
movl $0x20, %ecx
movl %r12d, %edi
movl %r15d, %esi
callq 0x2097d1
testq %rax, %rax
je 0x58c7a3
movl %r14d, 0x9c(%rsp)
movl %ebx, 0x60(%rsp)
movq %rax, 0x70(%rsp)
orl $0x4880801, 0xc(%rax)   # imm = 0x4880801
movl $0x20, %edi
movq %r12, %rsi
callq 0x4c5e3c
movq %rax, 0x40(%rsp)
movl $0x20, %edi
movq %r12, %rsi
callq 0x4c5e3c
movq %rax, 0x10(%rsp)
movl $0x20, %edi
movq %r12, %rsi
callq 0x4c5e3c
movq %rax, 0x28(%rsp)
movl $0x20, %edi
movq %r12, %rsi
callq 0x4c5e3c
movq %rax, 0x18(%rsp)
movl $0x20, %edi
movq %r12, %rsi
callq 0x4c5e3c
movq %rax, %rbx
movl $0x20, %edi
movq %r12, %rsi
callq 0x4c5e3c
movq %r15, %rcx
movq %rax, %r15
movq %rcx, 0x38(%rsp)
leal 0x1(%rcx), %r14d
movl $0x20, %edi
movq %r14, %rsi
callq 0x2094de
movq 0x18(%rsp), %r9
movq %rax, %r11
movq 0x40(%rsp), %rax
movq %rax, %r8
testq %rax, %rax
sete %al
cmpq $0x0, 0x10(%rsp)
sete %cl
orb %al, %cl
cmpq $0x0, 0x28(%rsp)
sete %al
testq %r9, %r9
sete %dl
orb %al, %dl
orb %cl, %dl
movq %rbx, 0x48(%rsp)
testq %rbx, %rbx
sete %al
movq %r15, 0x88(%rsp)
testq %r15, %r15
sete %cl
orb %al, %cl
testq %r11, %r11
sete %al
orb %cl, %al
orb %dl, %al
testb $0x1, %al
jne 0x58c7a3
movq 0x38(%rsp), %rbx
leal -0x1(%rbx), %eax
movl %eax, 0x98(%rsp)
movl $0x3, %eax
subl 0x60(%rsp), %eax
movl %eax, 0x94(%rsp)
movq 0xb0(%rsp), %rdx
vmovq %rdx, %xmm0
vpbroadcastq %xmm0, %ymm8
movl 0x58(%rsp), %eax
vmovq %rax, %xmm0
vpbroadcastq %xmm0, %ymm3
incq %r13
movabsq $-0x8000000000000000, %rcx # imm = 0x8000000000000000
subq 0x50(%rsp), %rcx
addq $-0x2, %rcx
vmovq %r13, %xmm0
vmovdqa %ymm0, 0x220(%rsp)
vpbroadcastq %xmm0, %ymm0
vmovdqa %ymm0, 0x120(%rsp)
vmovq %rcx, %xmm0
vpbroadcastq %xmm0, %ymm1
movslq 0x20(%rsp), %rcx
movl %r12d, %esi
negq %rdx
movq %rsi, 0x30(%rsp)
imulq %rax, %rsi
xorl %edi, %edi
movq %r8, %r13
movq %r9, %r15
movq %rcx, %r8
xorl %r9d, %r9d
movq %r8, 0x2a0(%rsp,%r9,8)
leaq (%rdx,%r8), %r10
movq %r10, 0x280(%rsp,%r9,8)
incq %r9
subq %rsi, %r8
cmpq $0x4, %r9
jne 0x58bb89
movq %rdi, %r8
shlq $0x5, %r8
vmovaps 0x2a0(%rsp), %ymm0
vmovaps %ymm0, (%r13,%r8)
vmovdqa 0x280(%rsp), %ymm0
movq 0x28(%rsp), %r9
vmovdqa %ymm0, (%r9,%r8)
movq %r15, %r9
vmovdqa %ymm0, (%r15,%r8)
incq %rdi
subq %rax, %rcx
cmpq 0x30(%rsp), %rdi
jne 0x58bb80
movq $0x0, (%r11)
movslq 0x20(%rsp), %rcx
movl $0x1, %edx
movq %rcx, (%r11,%rdx,8)
incq %rdx
subq %rax, %rcx
cmpq %rdx, %r14
jne 0x58bbfb
cmpl $0x1, %r12d
movl %r12d, %esi
adcl $0x0, %esi
shlq $0x5, %rsi
xorl %eax, %eax
vbroadcastsd 0x6f765(%rip), %ymm9 # 0x5fb388
movq 0x70(%rsp), %rdx
movq 0x10(%rdx), %rcx
movq (%rcx), %rcx
vmovapd %ymm9, (%rcx,%rax)
addq $0x20, %rax
cmpq %rax, %rsi
jne 0x58bc28
movq %rsi, 0xc0(%rsp)
leal -0x1(%r12), %eax
movl %ebx, %ecx
movq %rcx, 0xc8(%rsp)
cmpl $0x2, %ebx
movl $0x1, %ecx
cmovgel %ebx, %ecx
movq %rcx, 0xe0(%rsp)
movq 0x30(%rsp), %rcx
shlq $0x5, %rcx
movq $0x0, 0x18(%rsp)
shlq $0x5, %rax
movq %rax, 0xe8(%rsp)
vbroadcastsd 0x6a472(%rip), %ymm0 # 0x5f6100
vmovaps %ymm0, 0x1e0(%rsp)
vbroadcastsd 0x6dce0(%rip), %ymm0 # 0x5f9980
vmovaps %ymm0, 0x1c0(%rsp)
vbroadcastsd 0x6f98e(%rip), %ymm10 # 0x5fb640
vbroadcastsd 0x6f98d(%rip), %ymm12 # 0x5fb648
vbroadcastsd 0x6f6d4(%rip), %ymm0 # 0x5fb398
vmovaps %ymm0, 0x140(%rsp)
vbroadcastsd 0x6f6ca(%rip), %ymm11 # 0x5fb3a0
vbroadcastsd 0x6f971(%rip), %ymm0 # 0x5fb650
vmovaps %ymm0, 0x260(%rsp)
movq %rcx, 0xd8(%rsp)
movq %rcx, 0x78(%rsp)
xorl %r15d, %r15d
vmovdqa %ymm1, 0x160(%rsp)
vmovdqa 0x120(%rsp), %ymm0
movq %rdx, %r12
movq %r11, 0xb8(%rsp)
vmovdqa %ymm8, 0x240(%rsp)
vmovapd %ymm9, 0x200(%rsp)
vmovapd %ymm10, 0x1a0(%rsp)
vmovapd %ymm12, 0x180(%rsp)
movq 0x48(%rsp), %rax
movq %rax, 0x40(%rsp)
movq %r9, 0x48(%rsp)
movq 0x10(%rsp), %rbx
movq 0xe8(%rsp), %rcx
leaq (%r13,%rcx), %rdx
movq %rdx, 0xf8(%rsp)
movq %r13, 0x10(%rsp)
vmovdqa (%r13,%rcx), %ymm4
vinserti128 $0x1, %xmm4, %ymm0, %ymm6
vpalignr $0x8, %ymm6, %ymm4, %ymm4 # ymm4 = ymm6[8,9,10,11,12,13,14,15],ymm4[0,1,2,3,4,5,6,7],ymm6[24,25,26,27,28,29,30,31],ymm4[16,17,18,19,20,21,22,23]
vmovq (%r11,%r15,8), %xmm6
vpblendd $0x3, %ymm6, %ymm4, %ymm6 # ymm6 = ymm6[0,1],ymm4[2,3,4,5,6,7]
movq 0xa0(%rsp), %rax
movq 0x10(%rax), %rax
movq 0xa8(%rsp), %rcx
movzbl (%rcx,%r15), %ecx
movslq (%rax,%rcx,4), %rax
movq 0x30(%rsp), %rcx
imulq %rax, %rcx
shlq $0x5, %rcx
addq 0xf0(%rsp), %rcx
movq %rcx, 0xd0(%rsp)
movq %r15, 0x100(%rsp)
incq %r15
movl $0x1, %r14d
xorl %r11d, %r11d
vmovdqa 0x120(%rsp), %ymm14
movq %rbx, 0x38(%rsp)
movq %r15, 0x50(%rsp)
movq %r14, 0x20(%rsp)
movq 0xd0(%rsp), %rax
vpaddq (%rax,%r11), %ymm6, %ymm4
vmovq %xmm4, %rax
movq 0x28(%rsp), %rcx
movq (%rcx,%r11), %rdx
movq %rdx, 0x110(%rsp)
cmpq %rdx, %rax
cmovleq %rdx, %rax
movq 0x8(%rcx,%r11), %rdx
movq %rdx, 0x108(%rsp)
vpextrq $0x1, %xmm4, %r13
cmpq %rdx, %r13
cmovleq %rdx, %r13
vextracti128 $0x1, %ymm4, %xmm6
vmovq %xmm6, %rdx
movq 0x10(%rcx,%r11), %r15
cmpq %r15, %rdx
cmovleq %r15, %rdx
movq 0x18(%rcx,%r11), %r10
vpextrq $0x1, %xmm6, %r8
cmpq %r10, %r8
cmovleq %r10, %r8
vmovq %xmm14, %r14
cmpq %r14, %rax
cmovleq %r14, %rax
vpextrq $0x1, %xmm14, %r9
cmpq %r9, %r13
cmovleq %r9, %r13
vextracti128 $0x1, %ymm14, %xmm6
vmovq %xmm6, %rdi
cmpq %rdi, %rdx
cmovleq %rdi, %rdx
vpextrq $0x1, %xmm6, %rsi
cmpq %rsi, %r8
cmovleq %rsi, %r8
vmovq %xmm0, %rcx
cmpq %rax, %rcx
cmovleq %rax, %rcx
movq %rcx, 0x58(%rsp)
vpextrq $0x1, %xmm0, %rcx
cmpq %r13, %rcx
cmovleq %r13, %rcx
movq %rcx, 0x80(%rsp)
vextracti128 $0x1, %ymm0, %xmm6
vmovq %xmm6, %rcx
cmpq %rdx, %rcx
cmovleq %rdx, %rcx
movq %rcx, 0x68(%rsp)
vmovq %rax, %xmm0
vpextrq $0x1, %xmm6, %rcx
cmpq %r8, %rcx
cmovleq %r8, %rcx
movq %rcx, 0x118(%rsp)
vmovq %xmm1, %rcx
cmpq %rax, %rcx
cmovlq %rcx, %rax
vpextrq $0x1, %xmm1, %rcx
vmovq %r13, %xmm6
cmpq %r13, %rcx
cmovlq %rcx, %r13
vmovq %rdx, %xmm7
vextracti128 $0x1, %ymm1, %xmm1
vmovq %xmm1, %rcx
cmpq %rdx, %rcx
cmovlq %rcx, %rdx
vpextrq $0x1, %xmm1, %rcx
vmovq %r8, %xmm13
cmpq %r8, %rcx
cmovlq %rcx, %r8
movq 0x110(%rsp), %rcx
cmpq %rcx, %rax
cmovgeq %rcx, %rax
movq 0x108(%rsp), %rcx
cmpq %rcx, %r13
cmovgeq %rcx, %r13
cmpq %r15, %rdx
cmovgeq %r15, %rdx
movq 0x28(%rsp), %r15
vmovdqa (%r15,%r11), %ymm1
vpunpcklqdq %xmm13, %xmm7, %xmm7 # xmm7 = xmm7[0],xmm13[0]
vpunpcklqdq %xmm6, %xmm0, %xmm0 # xmm0 = xmm0[0],xmm6[0]
vinserti128 $0x1, %xmm7, %ymm0, %ymm0
vmovdqa %ymm0, (%rbx,%r11)
cmpq %r10, %r8
cmovgeq %r10, %r8
cmpq %r14, %rax
cmovgeq %r14, %rax
cmpq %r9, %r13
cmovgeq %r9, %r13
cmpq %rdi, %rdx
cmovgeq %rdi, %rdx
cmpq %rsi, %r8
cmovgeq %rsi, %r8
movq 0x10(%r12), %rcx
movq (%rcx), %rcx
movq 0x18(%rsp), %rsi
addq %rsi, %rcx
vpcmpeqq %ymm4, %ymm0, %ymm4
vpcmpeqq %ymm14, %ymm0, %ymm6
vmovdqa 0x1e0(%rsp), %ymm2
vpsubq %ymm6, %ymm2, %ymm6
vblendvpd %ymm4, 0x1c0(%rsp), %ymm6, %ymm4
vorpd (%r11,%rcx), %ymm4, %ymm6
movq 0x88(%rsp), %rcx
vmovapd %ymm4, (%rcx,%r11)
movq 0x10(%r12), %rcx
movq (%rcx), %rcx
addq %rsi, %rcx
vmovapd %ymm6, (%r11,%rcx)
vpsubq %ymm8, %ymm0, %ymm15
vpsubq %ymm3, %ymm1, %ymm0
vmovq %xmm15, %rsi
vmovq %xmm0, %rcx
cmpq %rcx, %rsi
cmovgq %rsi, %rcx
vpextrq $0x1, %xmm15, %r9
vpextrq $0x1, %xmm0, %rdi
cmpq %rdi, %r9
cmovgq %r9, %rdi
vextracti128 $0x1, %ymm15, %xmm1
vmovq %xmm1, %r10
vextracti128 $0x1, %ymm0, %xmm0
vmovq %rdi, %xmm4
vmovq %xmm0, %rbx
cmpq %rbx, %r10
cmovgq %r10, %rbx
vpextrq $0x1, %xmm1, %rdi
vpextrq $0x1, %xmm0, %r14
vmovq %rcx, %xmm0
cmpq %r14, %rdi
cmovgq %rdi, %r14
vmovq %r14, %xmm1
vpunpcklqdq %xmm4, %xmm0, %xmm0 # xmm0 = xmm0[0],xmm4[0]
vmovq %rbx, %xmm4
vpunpcklqdq %xmm1, %xmm4, %xmm1 # xmm1 = xmm4[0],xmm1[0]
movq %r15, %rcx
movq 0x50(%rsp), %r15
vmovdqa %xmm1, 0x10(%rcx,%r11)
vmovdqa %xmm0, (%rcx,%r11)
movq 0x48(%rsp), %rcx
vmovdqa (%rcx,%r11), %ymm0
vpsubq %ymm3, %ymm0, %ymm0
vmovq %xmm0, %rcx
cmpq %rcx, %rsi
cmovgq %rsi, %rcx
vpextrq $0x1, %xmm0, %rbx
cmpq %rbx, %r9
cmovgq %r9, %rbx
vmovq %rbx, %xmm1
vextracti128 $0x1, %ymm0, %xmm4
vmovq %rcx, %xmm6
vmovq %xmm4, %rcx
cmpq %rcx, %r10
cmovgq %r10, %rcx
vpextrq $0x1, %xmm4, %rbx
cmpq %rbx, %rdi
cmovgq %rdi, %rbx
vmovq %rbx, %xmm4
vmovq %rcx, %xmm7
vpunpcklqdq %xmm4, %xmm7, %xmm4 # xmm4 = xmm7[0],xmm4[0]
movq 0x40(%rsp), %rcx
vmovdqa %xmm4, 0x10(%rcx,%r11)
vpunpcklqdq %xmm1, %xmm6, %xmm1 # xmm1 = xmm6[0],xmm1[0]
vmovdqa %xmm1, (%rcx,%r11)
cmpq 0xc8(%rsp), %r15
jae 0x58c123
vpcmpgtq %ymm0, %ymm15, %ymm0
vbroadcastsd 0x6f286(%rip), %ymm1 # 0x5fb390
vblendvpd %ymm0, %ymm9, %ymm1, %ymm0
movq 0x10(%r12), %rcx
movq (%rcx), %rcx
addq 0x78(%rsp), %rcx
vmovapd %ymm0, (%r11,%rcx)
vpsubq %ymm3, %ymm14, %ymm4
vmovq %xmm4, %rcx
cmpq %rcx, %rsi
cmovgq %rsi, %rcx
vpextrq $0x1, %xmm4, %rsi
cmpq %rsi, %r9
cmovgq %r9, %rsi
vextracti128 $0x1, %ymm4, %xmm0
vmovq %xmm0, %r9
cmpq %r9, %r10
cmovgq %r10, %r9
vpextrq $0x1, %xmm0, %r10
cmpq %r10, %rdi
cmovgq %rdi, %r10
movq 0x20(%rsp), %r14
cmpq 0x30(%rsp), %r14
movq 0xc0(%rsp), %rbx
jae 0x58c19e
movq 0x10(%r12), %rdi
movq (%rdi), %rdi
addq 0x18(%rsp), %rdi
vpcmpgtq %ymm4, %ymm15, %ymm0
vblendvpd %ymm0, 0x140(%rsp), %ymm11, %ymm0
vorpd 0x20(%r11,%rdi), %ymm0, %ymm0
vmovapd %ymm0, 0x20(%r11,%rdi)
vmovq 0x118(%rsp), %xmm0
vmovq 0x68(%rsp), %xmm1
vmovq 0x80(%rsp), %xmm6
vmovq 0x58(%rsp), %xmm7
vmovq %r8, %xmm13
vmovq %rdx, %xmm14
vmovq %r13, %xmm5
vmovq %rax, %xmm2
vmovq %r10, %xmm8
vmovq %r9, %xmm9
vmovq %rsi, %xmm12
vmovq %rcx, %xmm10
vpunpcklqdq %xmm0, %xmm1, %xmm0 # xmm0 = xmm1[0],xmm0[0]
vpunpcklqdq %xmm6, %xmm7, %xmm1 # xmm1 = xmm7[0],xmm6[0]
vinserti128 $0x1, %xmm0, %ymm1, %ymm0
vpunpcklqdq %xmm13, %xmm14, %xmm1 # xmm1 = xmm14[0],xmm13[0]
vpunpcklqdq %xmm5, %xmm2, %xmm2 # xmm2 = xmm2[0],xmm5[0]
vinserti128 $0x1, %xmm1, %ymm2, %ymm1
vpunpcklqdq %xmm8, %xmm9, %xmm2 # xmm2 = xmm9[0],xmm8[0]
vpunpcklqdq %xmm12, %xmm10, %xmm5 # xmm5 = xmm10[0],xmm12[0]
vinserti128 $0x1, %xmm2, %ymm5, %ymm14
movq 0x10(%rsp), %rax
vmovdqa (%rax,%r11), %ymm6
addq $0x20, %r11
incq %r14
cmpq %r11, %rbx
vmovdqa 0x240(%rsp), %ymm8
movq 0x38(%rsp), %rbx
vmovapd 0x200(%rsp), %ymm9
vmovapd 0x1a0(%rsp), %ymm10
vmovapd 0x180(%rsp), %ymm12
jne 0x58bde7
movq $0x0, 0x68(%rsp)
vmovdqa %ymm14, %ymm6
movq 0xb8(%rsp), %rcx
movq (%rcx,%r15,8), %rax
subq 0xb0(%rsp), %rax
movq 0xf8(%rsp), %rdx
vmovdqa (%rdx), %ymm2
vinserti128 $0x1, %xmm2, %ymm0, %ymm5
vpalignr $0x8, %ymm5, %ymm2, %ymm2 # ymm2 = ymm5[8,9,10,11,12,13,14,15],ymm2[0,1,2,3,4,5,6,7],ymm5[24,25,26,27,28,29,30,31],ymm2[16,17,18,19,20,21,22,23]
movq 0x100(%rsp), %rdx
vmovq (%rcx,%rdx,8), %xmm5
vpblendd $0x3, %ymm5, %ymm2, %ymm7 # ymm7 = ymm5[0,1],ymm2[2,3,4,5,6,7]
vpermq $0x90, %ymm15, %ymm2    # ymm2 = ymm15[0,0,1,2]
vmovq %rax, %xmm5
vpblendd $0x3, %ymm5, %ymm2, %ymm15 # ymm15 = ymm5[0,1],ymm2[2,3,4,5,6,7]
vpermq $0x90, %ymm6, %ymm2     # ymm2 = ymm6[0,0,1,2]
vpblendd $0x3, %ymm5, %ymm2, %ymm13 # ymm13 = ymm5[0,1],ymm2[2,3,4,5,6,7]
vpermq $0x90, %ymm4, %ymm2     # ymm2 = ymm4[0,0,1,2]
vpblendd $0x3, 0x220(%rsp), %ymm2, %ymm4 # ymm4 = mem[0,1],ymm2[2,3,4,5,6,7]
vpermq $0x90, %ymm14, %ymm2    # ymm2 = ymm14[0,0,1,2]
vpblendd $0x3, %ymm5, %ymm2, %ymm14 # ymm14 = ymm5[0,1],ymm2[2,3,4,5,6,7]
movb $0x1, %al
movl $0x1, %r8d
xorl %edx, %edx
movb %al, 0x80(%rsp)
movq %r8, 0x20(%rsp)
vmovq %xmm13, %rdi
movq (%rbx,%rdx), %rcx
cmpq %rdi, %rcx
cmovgq %rcx, %rdi
vpextrq $0x1, %xmm13, %r13
movq 0x8(%rbx,%rdx), %rcx
cmpq %r13, %rcx
cmovgq %rcx, %r13
movq 0x10(%rbx,%rdx), %rcx
vextracti128 $0x1, %ymm13, %xmm2
vmovq %xmm2, %r8
cmpq %r8, %rcx
cmovgq %rcx, %r8
vpextrq $0x1, %xmm2, %r9
movq 0x18(%rbx,%rdx), %rcx
cmpq %r9, %rcx
cmovgq %rcx, %r9
vmovq %r9, %xmm2
vmovq %r8, %xmm5
vpunpcklqdq %xmm2, %xmm5, %xmm2 # xmm2 = xmm5[0],xmm2[0]
vmovq %r13, %xmm5
vmovq %rdi, %xmm6
vpunpcklqdq %xmm5, %xmm6, %xmm5 # xmm5 = xmm6[0],xmm5[0]
vinserti128 $0x1, %xmm2, %ymm5, %ymm6
vmovdqa %ymm6, (%rbx,%rdx)
vmovq %xmm1, %rax
cmpq %rdi, %rax
cmovgeq %rdi, %rax
movq %rax, 0x58(%rsp)
vpextrq $0x1, %xmm1, %r10
cmpq %r13, %r10
cmovgeq %r13, %r10
vextracti128 $0x1, %ymm1, %xmm1
vmovq %xmm1, %r15
cmpq %r8, %r15
cmovgeq %r8, %r15
vpextrq $0x1, %xmm1, %r14
cmpq %r9, %r14
cmovgeq %r9, %r14
vmovq %xmm0, %rcx
cmpq %rdi, %rcx
cmovgq %rcx, %rdi
vpextrq $0x1, %xmm0, %rcx
cmpq %r13, %rcx
cmovgq %rcx, %r13
vextracti128 $0x1, %ymm0, %xmm0
vmovq %xmm0, %rcx
cmpq %r8, %rcx
cmovgq %rcx, %r8
vpextrq $0x1, %xmm0, %rcx
cmpq %r9, %rcx
cmovgq %rcx, %r9
movq 0xd0(%rsp), %rax
vpaddq (%rax,%rdx), %ymm7, %ymm0
vpcmpeqq %ymm13, %ymm6, %ymm1
vpcmpeqq %ymm0, %ymm6, %ymm0
vpandn %ymm1, %ymm0, %ymm0
movq 0x10(%r12), %rcx
movq (%rcx), %rcx
movq 0x18(%rsp), %rsi
addq %rsi, %rcx
movq 0x88(%rsp), %rax
vmovapd (%rax,%rdx), %ymm1
vblendvpd %ymm0, %ymm10, %ymm1, %ymm0
vandpd (%rdx,%rcx), %ymm12, %ymm1
vmovapd %ymm0, (%rax,%rdx)
vorpd %ymm1, %ymm0, %ymm0
movq 0x10(%r12), %rcx
movq (%rcx), %rcx
addq %rsi, %rcx
vmovapd %ymm0, (%rdx,%rcx)
movq 0x10(%r12), %rcx
movq (%rcx), %rcx
addq %rsi, %rcx
vpcmpgtq %ymm4, %ymm15, %ymm0
vblendvpd %ymm0, 0x140(%rsp), %ymm11, %ymm0
vmovapd 0x260(%rsp), %ymm1
vandpd (%rdx,%rcx), %ymm1, %ymm1
vorpd %ymm0, %ymm1, %ymm0
vmovapd %ymm0, (%rdx,%rcx)
vpsubq %ymm8, %ymm6, %ymm15
movq 0x48(%rsp), %rax
vmovdqa (%rax,%rdx), %ymm0
vpsubq %ymm3, %ymm0, %ymm0
vmovq %xmm15, %rbx
vmovq %xmm0, %r11
cmpq %r11, %rbx
cmovgq %rbx, %r11
vpextrq $0x1, %xmm15, %rcx
vpextrq $0x1, %xmm0, %rax
cmpq %rax, %rcx
cmovgq %rcx, %rax
vextracti128 $0x1, %ymm15, %xmm1
vmovq %xmm1, %r12
vextracti128 $0x1, %ymm0, %xmm2
vmovq %rax, %xmm5
vmovq %xmm2, %rax
cmpq %rax, %r12
cmovgq %r12, %rax
vmovq %r11, %xmm6
vpextrq $0x1, %xmm1, %r11
vpextrq $0x1, %xmm2, %rsi
cmpq %rsi, %r11
cmovgq %r11, %rsi
vmovq %rsi, %xmm1
vmovq %rax, %xmm2
vpunpcklqdq %xmm1, %xmm2, %xmm1 # xmm1 = xmm2[0],xmm1[0]
movq 0x40(%rsp), %rax
vmovdqa %xmm1, 0x10(%rax,%rdx)
vpunpcklqdq %xmm5, %xmm6, %xmm1 # xmm1 = xmm6[0],xmm5[0]
vmovdqa %xmm1, (%rax,%rdx)
movq 0x50(%rsp), %rax
cmpq 0xc8(%rsp), %rax
jae 0x58c532
vpcmpgtq %ymm0, %ymm15, %ymm0
vbroadcastsd 0x6ee7a(%rip), %ymm1 # 0x5fb390
vblendvpd %ymm0, %ymm9, %ymm1, %ymm0
movq 0x70(%rsp), %rax
movq 0x10(%rax), %rax
movq (%rax), %rax
addq 0x78(%rsp), %rax
vmovapd %ymm0, (%rdx,%rax)
vmovq %r14, %xmm0
vmovq %r15, %xmm1
vpunpcklqdq %xmm0, %xmm1, %xmm0 # xmm0 = xmm1[0],xmm0[0]
vmovq %r10, %xmm1
vmovq 0x58(%rsp), %xmm2
vpunpcklqdq %xmm1, %xmm2, %xmm1 # xmm1 = xmm2[0],xmm1[0]
vinserti128 $0x1, %xmm0, %ymm1, %ymm1
vmovq %r9, %xmm0
vmovq %r8, %xmm2
vpunpcklqdq %xmm0, %xmm2, %xmm0 # xmm0 = xmm2[0],xmm0[0]
vmovq %r13, %xmm2
vmovq %rdi, %xmm5
vpunpcklqdq %xmm2, %xmm5, %xmm2 # xmm2 = xmm5[0],xmm2[0]
vinserti128 $0x1, %xmm0, %ymm2, %ymm0
vpsubq %ymm3, %ymm13, %ymm6
vpcmpgtq %ymm6, %ymm15, %ymm2
vtestpd 0x6d517(%rip), %ymm2    # 0x5f9aa0
movq 0x20(%rsp), %r8
jb 0x58c629
vpsubq %ymm3, %ymm14, %ymm4
vmovq %xmm4, %rax
cmpq %rax, %rbx
cmovgq %rbx, %rax
vpextrq $0x1, %xmm4, %rsi
cmpq %rsi, %rcx
cmovgq %rcx, %rsi
vextracti128 $0x1, %ymm4, %xmm2
vmovq %xmm2, %rcx
cmpq %rcx, %r12
cmovgq %r12, %rcx
vpextrq $0x1, %xmm2, %rdi
cmpq %rdi, %r11
cmovgq %r11, %rdi
vmovq %rdi, %xmm2
vmovq %rcx, %xmm5
vpunpcklqdq %xmm2, %xmm5, %xmm2 # xmm2 = xmm5[0],xmm2[0]
vmovq %rsi, %xmm5
vmovq %rax, %xmm7
vpunpcklqdq %xmm5, %xmm7, %xmm5 # xmm5 = xmm7[0],xmm5[0]
vinserti128 $0x1, %xmm2, %ymm5, %ymm14
movq 0x10(%rsp), %rax
vmovdqa (%rax,%rdx), %ymm7
cmpq 0x30(%rsp), %r8
setb %al
addq $0x20, %rdx
incq %r8
vmovdqa %ymm6, %ymm13
cmpq %rdx, 0xc0(%rsp)
movq 0x70(%rsp), %r12
movq 0x38(%rsp), %rbx
jne 0x58c2e5
jmp 0x58c63e
vmovdqa %ymm13, %ymm6
movq 0x70(%rsp), %r12
movq 0x38(%rsp), %rbx
movb 0x80(%rsp), %al
testb $0x1, %al
movq 0x50(%rsp), %r15
jne 0x58c65d
movq 0x68(%rsp), %rcx
leal 0x1(%rcx), %eax
cmpl $0x3, %ecx
movq %rax, 0x68(%rsp)
jb 0x58c262
movq 0xd8(%rsp), %rax
addq %rax, 0x78(%rsp)
addq %rax, 0x18(%rsp)
movq %rbx, %r13
movq 0x40(%rsp), %r14
movq %r14, %r9
cmpq 0xe0(%rsp), %r15
movq 0xb8(%rsp), %r11
jne 0x58bd39
movl 0x9c(%rsp), %eax
shlq $0x5, %rax
vmovdqa (%rbx,%rax), %ymm2
cmpl $0x2, 0x60(%rsp)
movl 0x98(%rsp), %edx
jg 0x58c6d6
movl 0x94(%rsp), %ecx
cmpl $0x2, %ecx
movl $0x1, %eax
cmovgel %ecx, %eax
movl 0x64(%rsp), %ecx
vperm2i128 $0x8, %ymm2, %ymm2, %ymm3 # ymm3 = zero,zero,ymm2[0,1]
vpalignr $0x8, %ymm3, %ymm2, %ymm2 # ymm2 = ymm3[8,9,10,11,12,13,14,15],ymm2[0,1,2,3,4,5,6,7],ymm3[24,25,26,27,28,29,30,31],ymm2[16,17,18,19,20,21,22,23]
decl %eax
jne 0x58c6c4
jmp 0x58c6da
movl 0x64(%rsp), %ecx
vmovdqa 0x120(%rsp), %ymm3
vpcmpgtq %ymm1, %ymm3, %ymm1
vpcmpgtq 0x160(%rsp), %ymm0, %ymm0
vpor %ymm0, %ymm1, %ymm0
vtestpd %ymm0, %ymm0
je 0x58c70b
orb $0x40, 0xc(%r12)
xorl %eax, %eax
xorl %edx, %edx
xorl %ecx, %ecx
jmp 0x58c717
vextracti128 $0x1, %ymm2, %xmm0
vpextrq $0x1, %xmm0, %rax
movl %eax, (%r12)
movl %ecx, 0x4(%r12)
movl %edx, 0x8(%r12)
movq %r11, %rdi
vzeroupper
callq 0x2094b5
movq 0x88(%rsp), %rdi
callq 0x2094b5
movq 0x48(%rsp), %rdi
callq 0x2094b5
movq %r14, %rdi
callq 0x2094b5
movq 0x28(%rsp), %rdi
callq 0x2094b5
movq 0x10(%rsp), %rdi
callq 0x2094b5
movq %rbx, %rdi
callq 0x2094b5
jmp 0x58c7a6
callq 0x1f9fd5
jmp 0x58c7a3
callq 0x1f9faf
jmp 0x58c7a3
callq 0x1f9f89
jmp 0x58c7a3
callq 0x1f9f63
jmp 0x58c7a3
callq 0x1f9f3d
jmp 0x58c7a3
callq 0x1f9f17
jmp 0x58c7a3
callq 0x1f9ef1
jmp 0x58c7a3
callq 0x1f9ecb
xorl %r12d, %r12d
movq %r12, %rax
leaq -0x28(%rbp), %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq