// File: /workspace/github_c_makefile_star2_O3/nh13[P]ksw/src/parasail/src/sw_striped_avx2_256_32.c
// Function: parasail_sw_rowcol_striped_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 end_query = 0;
    int32_t end_ref = 0;
    int32_t s1Len = 0;
    const parasail_matrix_t *matrix = NULL;
    int32_t segWidth = 0;
    int32_t segLen = 0;
#ifdef PARASAIL_ROWCOL
    int32_t offset = 0;
    int32_t position = 0;
#endif
    __m256i* restrict vProfile = NULL;
    __m256i* restrict pvHStore = NULL;
    __m256i* restrict pvHLoad = NULL;
    __m256i* restrict pvHMax = NULL;
    __m256i* restrict pvE = NULL;
    __m256i vGapO;
    __m256i vGapE;
    __m256i vZero;
    __m256i vNegInf;
    int32_t score = 0;
    __m256i vMaxH;
    __m256i vMaxHUnit;
    int32_t maxp = 0;
    /*int32_t stop = 0;*/
    parasail_result_t *result = NULL;

    /* 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;
    end_query = 0;
    end_ref = 0;
    s1Len = profile->s1Len;
    matrix = profile->matrix;
    segWidth = 8; /* number of values in vector unit */
    segLen = (s1Len + segWidth - 1) / segWidth;
#ifdef PARASAIL_ROWCOL
    offset = (s1Len - 1) % segLen;
    position = (segWidth - 1) - (s1Len - 1) / segLen;
#endif
    vProfile = (__m256i*)profile->profile32.score;
    vGapO = _mm256_set1_epi32(open);
    vGapE = _mm256_set1_epi32(gap);
    vZero = _mm256_setzero_si256();
    vNegInf = _mm256_set1_epi32(NEG_INF);
    score = NEG_INF;
    vMaxH = vNegInf;
    vMaxHUnit = vNegInf;
    maxp = INT32_MAX - (int32_t)(matrix->max+1);
    /*stop = profile->stop == INT32_MAX ?  INT32_MAX : (int32_t)profile->stop;*/

    /* initialize result */
#ifdef PARASAIL_TABLE
    result = parasail_result_new_table1(segLen*segWidth, s2Len);
#else
#ifdef PARASAIL_ROWCOL
    result = parasail_result_new_rowcol1(segLen*segWidth, s2Len);
#else
    result = parasail_result_new();
#endif
#endif
    if (!result) return NULL;

    /* set known flags */
    result->flag |= PARASAIL_FLAG_SW | PARASAIL_FLAG_STRIPED
        | PARASAIL_FLAG_BITS_32 | PARASAIL_FLAG_LANES_8;
#ifdef PARASAIL_TABLE
    result->flag |= PARASAIL_FLAG_TABLE;
#endif
#ifdef PARASAIL_ROWCOL
    result->flag |= PARASAIL_FLAG_ROWCOL;
#endif

    /* initialize heap variables */
    pvHStore = parasail_memalign___m256i(32, segLen);
    pvHLoad =  parasail_memalign___m256i(32, segLen);
    pvHMax = parasail_memalign___m256i(32, segLen);
    pvE = parasail_memalign___m256i(32, segLen);

    /* validate heap variables */
    if (!pvHStore) return NULL;
    if (!pvHLoad) return NULL;
    if (!pvHMax) return NULL;
    if (!pvE) return NULL;

    /* initialize H and E */
    parasail_memset___m256i(pvHStore, vZero, segLen);
    parasail_memset___m256i(pvE, _mm256_set1_epi32(-open), segLen);

    /* outer loop over database sequence */
    for (j=0; j<s2Len; ++j) {
        __m256i vE;
        __m256i vF;
        __m256i vH;
        const __m256i* vP = NULL;
        __m256i* pv = NULL;

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

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

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

        if (end_ref == j-2) {
            /* Swap in the max buffer. */
            pv = pvHMax;
            pvHMax = pvHLoad;
            pvHLoad = pvHStore;
            pvHStore = pv;
        }
        else {
            /* Swap the 2 H buffers. */
            pv = pvHLoad;
            pvHLoad = pvHStore;
            pvHStore = pv;
        }

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

            /* Get max from vH, vE and vF. */
            vH = _mm256_max_epi32(vH, vE);
            vH = _mm256_max_epi32(vH, vF);
            vH = _mm256_max_epi32(vH, vZero);
            /* Save vH values. */
            _mm256_store_si256(pvHStore + i, vH);
#ifdef PARASAIL_TABLE
            arr_store_si256(result->tables->score_table, vH, i, segLen, j, s2Len);
#endif
            vMaxH = _mm256_max_epi32(vH, vMaxH);

            /* Update vE value. */
            vH = _mm256_sub_epi32(vH, vGapO);
            vE = _mm256_sub_epi32(vE, vGapE);
            vE = _mm256_max_epi32(vE, vH);
            _mm256_store_si256(pvE + i, vE);

            /* Update vF value. */
            vF = _mm256_sub_epi32(vF, vGapE);
            vF = _mm256_max_epi32(vF, vH);

            /* 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 */
        for (k=0; k<segWidth; ++k) {
            vF = _mm256_slli_si256_rpl(vF, 4);
            for (i=0; i<segLen; ++i) {
                vH = _mm256_load_si256(pvHStore + i);
                vH = _mm256_max_epi32(vH,vF);
                _mm256_store_si256(pvHStore + i, vH);
#ifdef PARASAIL_TABLE
                arr_store_si256(result->tables->score_table, vH, i, segLen, j, s2Len);
#endif
                vMaxH = _mm256_max_epi32(vH, vMaxH);
                vH = _mm256_sub_epi32(vH, vGapO);
                vF = _mm256_sub_epi32(vF, vGapE);
                if (! _mm256_movemask_epi8(_mm256_cmpgt_epi32(vF, vH))) goto end;
                /*vF = _mm256_max_epi32(vF, vH);*/
            }
        }
end:
        {
        }

#ifdef PARASAIL_ROWCOL
        /* extract last value from the column */
        {
            vH = _mm256_load_si256(pvHStore + offset);
            for (k=0; k<position; ++k) {
                vH = _mm256_slli_si256_rpl(vH, 4);
            }
            result->rowcols->score_row[j] = (int32_t) _mm256_extract_epi32_rpl (vH, 7);
        }
#endif

        {
            __m256i vCompare = _mm256_cmpgt_epi32(vMaxH, vMaxHUnit);
            if (_mm256_movemask_epi8(vCompare)) {
                score = _mm256_hmax_epi32_rpl(vMaxH);
                /* if score has potential to overflow, abort early */
                if (score > maxp) {
                    result->flag |= PARASAIL_FLAG_SATURATED;
                    break;
                }
                vMaxHUnit = _mm256_set1_epi32(score);
                end_ref = j;
            }
        }

        /*if (score == stop) break;*/
    }

#ifdef PARASAIL_ROWCOL
    for (i=0; i<segLen; ++i) {
        __m256i vH = _mm256_load_si256(pvHStore+i);
        arr_store_col(result->rowcols->score_col, vH, i, segLen);
    }
#endif

    if (score == INT32_MAX) {
        result->flag |= PARASAIL_FLAG_SATURATED;
    }

    if (parasail_result_is_saturated(result)) {
        score = INT32_MAX;
        end_query = 0;
        end_ref = 0;
    }
    else {
        if (end_ref == j-1) {
            /* end_ref was the last store column */
            __m256i *pv = pvHMax;
            pvHMax = pvHStore;
            pvHStore = pv;
        }
        else if (end_ref == j-2) {
            /* end_ref was the last load column */
            __m256i *pv = pvHMax;
            pvHMax = pvHLoad;
            pvHLoad = pv;
        }
        /* Trace the alignment ending position on read. */
        {
            int32_t *t = (int32_t*)pvHMax;
            int32_t column_len = segLen * segWidth;
            end_query = s1Len - 1;
            for (i = 0; i<column_len; ++i, ++t) {
                if (*t == score) {
                    int32_t temp = i / segWidth + i % segWidth * segLen;
                    if (temp < end_query) {
                        end_query = temp;
                    }
                }
            }
        }
    }

    result->score = score;
    result->end_query = end_query;
    result->end_ref = end_ref;

    parasail_free(pvE);
    parasail_free(pvHMax);
    parasail_free(pvHLoad);
    parasail_free(pvHStore);

    return result;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0xa8, %rsp
movq %rsi, 0x48(%rsp)
testq %rdi, %rdi
je 0x5696b1
movq 0x48(%rdi), %rax
movq %rax, 0x58(%rsp)
testq %rax, %rax
je 0x5696b8
movq 0x10(%rdi), %rax
movq %rax, 0x40(%rsp)
testq %rax, %rax
je 0x5696bf
movl 0x8(%rdi), %eax
testl %eax, %eax
jle 0x5696c6
cmpq $0x0, 0x48(%rsp)
je 0x5696cd
movl %edx, %ebp
testl %edx, %edx
jle 0x5696d4
movl %ecx, %r12d
testl %ecx, %ecx
js 0x5696db
movl %r8d, %r13d
testl %r8d, %r8d
js 0x5696e2
movq %rax, %rbx
addq $0x7, %rbx
movq %rbx, %r14
shrq $0x3, %r14
decl %eax
movl %eax, 0x10(%rsp)
xorl %edx, %edx
divl %r14d
movl %eax, 0x14(%rsp)
movl %edx, 0x20(%rsp)
movl $0x7ffffffe, %ecx       # imm = 0x7FFFFFFE
movq 0x40(%rsp), %rax
subl 0x1c(%rax), %ecx
movl %ecx, 0x34(%rsp)
andl $0x7ffffff8, %ebx       # imm = 0x7FFFFFF8
movl %ebx, %edi
movl %ebp, %esi
callq 0x20ac53
testq %rax, %rax
je 0x5696e7
movq %rax, %r15
movl %r13d, 0x8(%rsp)
movl %r12d, 0x4(%rsp)
movq %rbx, 0x50(%rsp)
orl $0x8440804, 0xc(%rax)   # imm = 0x8440804
movl $0x20, %edi
movq %r14, %rsi
callq 0x4f1904
movq %rax, %r13
movl $0x20, %edi
movq %r14, %rsi
callq 0x4f1904
movq %rax, %rbx
movl $0x20, %edi
movq %r14, %rsi
callq 0x4f1904
movq %rax, %r12
movl $0x20, %edi
movq %r14, %rsi
callq 0x4f1904
movq %r12, %r8
movq %rax, %r12
testq %r13, %r13
sete %al
testq %rbx, %rbx
sete %cl
orb %al, %cl
testq %r8, %r8
sete %al
testq %r12, %r12
sete %dl
orb %al, %dl
orb %cl, %dl
jne 0x5696e7
movq %r15, 0x28(%rsp)
movl $0x7, %r15d
subl 0x14(%rsp), %r15d
movq %rbp, 0x18(%rsp)
movl 0x4(%rsp), %ebp
vmovd %ebp, %xmm0
vpbroadcastd %xmm0, %ymm0
vmovdqu %ymm0, 0x80(%rsp)
vmovss 0x8(%rsp), %xmm0
vbroadcastss %xmm0, %ymm0
vmovups %ymm0, 0x60(%rsp)
vxorps %xmm0, %xmm0, %xmm0
movq %r13, %rdi
movq %r14, %rsi
movq %r8, 0x8(%rsp)
callq 0x4f190d
negl %ebp
vmovd %ebp, %xmm0
vpbroadcastd %xmm0, %ymm0
movq %r12, %rdi
movq %r14, %rsi
callq 0x4f190d
vpxor %xmm8, %xmm8, %xmm8
vmovdqu 0x60(%rsp), %ymm7
vmovdqu 0x80(%rsp), %ymm6
xorl %esi, %esi
movq 0x8(%rsp), %r11
leal -0x1(%r14), %ecx
movl 0x20(%rsp), %edx
movl 0x18(%rsp), %eax
movq %rax, 0x20(%rsp)
movq %r14, %rdi
shlq $0x5, %rdi
movl $0xc0000000, 0x4(%rsp)  # imm = 0xC0000000
vpbroadcastd 0xc284b(%rip), %ymm1 # 0x62bb80
shlq $0x5, %rcx
movq %r14, 0x38(%rsp)
movl %r14d, %eax
shlq $0x5, %rdx
xorl %r8d, %r8d
vmovdqa %ymm1, %ymm0
movq %r13, %r14
vmovdqa (%r13,%rcx), %ymm2
vperm2i128 $0x28, %ymm2, %ymm2, %ymm3 # ymm3 = zero,zero,ymm2[0,1]
vpalignr $0xc, %ymm3, %ymm2, %ymm3 # ymm3 = ymm3[12,13,14,15],ymm2[0,1,2,3,4,5,6,7,8,9,10,11],ymm3[28,29,30,31],ymm2[16,17,18,19,20,21,22,23,24,25,26,27]
movq 0x40(%rsp), %r9
movq 0x10(%r9), %r9
movq 0x48(%rsp), %r10
movzbl (%r10,%r8), %r10d
movslq (%r9,%r10,4), %r9
imulq %rax, %r9
shlq $0x5, %r9
addq 0x58(%rsp), %r9
leal -0x2(%r8), %r10d
movq %rsi, %rbp
cmpl %r10d, %esi
movq %rbx, %r13
movq %r11, %rsi
cmoveq %r11, %r13
xorl %r11d, %r11d
vpxor %xmm2, %xmm2, %xmm2
vpaddd (%r9,%r11), %ymm3, %ymm3
vmovdqa (%r12,%r11), %ymm4
vpmaxsd %ymm2, %ymm4, %ymm5
vpmaxsd %ymm5, %ymm3, %ymm3
vpmaxsd %ymm8, %ymm3, %ymm3
vmovdqa %ymm3, (%r13,%r11)
vpmaxsd %ymm0, %ymm3, %ymm0
vpsubd %ymm6, %ymm3, %ymm3
vpsubd %ymm7, %ymm4, %ymm4
vpmaxsd %ymm3, %ymm4, %ymm4
vmovdqa %ymm4, (%r12,%r11)
vpsubd %ymm7, %ymm2, %ymm2
vpmaxsd %ymm3, %ymm2, %ymm2
vmovdqa (%r14,%r11), %ymm3
addq $0x20, %r11
cmpq %r11, %rdi
jne 0x5693a1
cmpl %r10d, %ebp
movq %rsi, %r11
cmoveq %rbx, %r11
xorl %r9d, %r9d
vperm2i128 $0x8, %ymm2, %ymm2, %ymm3 # ymm3 = zero,zero,ymm2[0,1]
vpalignr $0xc, %ymm3, %ymm2, %ymm2 # ymm2 = ymm3[12,13,14,15],ymm2[0,1,2,3,4,5,6,7,8,9,10,11],ymm3[28,29,30,31],ymm2[16,17,18,19,20,21,22,23,24,25,26,27]
xorl %r10d, %r10d
vpmaxsd (%r13,%r10), %ymm2, %ymm3
vmovdqa %ymm3, (%r13,%r10)
vpmaxsd %ymm0, %ymm3, %ymm0
vpsubd %ymm6, %ymm3, %ymm3
vpsubd %ymm7, %ymm2, %ymm2
vpcmpgtd %ymm3, %ymm2, %ymm3
vtestps %ymm3, %ymm3
je 0x569447
addq $0x20, %r10
cmpq %r10, %rdi
jne 0x56940f
incl %r9d
cmpl $0x8, %r9d
jne 0x569400
vmovdqa (%r13,%rdx), %ymm2
cmpl $0x6, 0x14(%rsp)
ja 0x569471
xorl %r9d, %r9d
movq %rbp, %rsi
vperm2i128 $0x28, %ymm2, %ymm2, %ymm3 # ymm3 = zero,zero,ymm2[0,1]
vpalignr $0xc, %ymm3, %ymm2, %ymm2 # ymm2 = ymm3[12,13,14,15],ymm2[0,1,2,3,4,5,6,7,8,9,10,11],ymm3[28,29,30,31],ymm2[16,17,18,19,20,21,22,23,24,25,26,27]
incl %r9d
cmpl %r15d, %r9d
jl 0x56945b
jmp 0x569474
movq %rbp, %rsi
vextracti128 $0x1, %ymm2, %xmm2
movq 0x28(%rsp), %r9
movq 0x10(%r9), %r9
movq (%r9), %r9
vpextrd $0x3, %xmm2, (%r9,%r8,4)
vpcmpgtd %ymm1, %ymm0, %ymm2
vtestps %ymm2, %ymm2
je 0x5694de
vpermq $0x44, %ymm0, %ymm1     # ymm1 = ymm0[0,1,0,1]
vpmaxsd %ymm1, %ymm0, %ymm1
vpslldq $0x8, %ymm1, %ymm2      # ymm2 = zero,zero,zero,zero,zero,zero,zero,zero,ymm1[0,1,2,3,4,5,6,7],zero,zero,zero,zero,zero,zero,zero,zero,ymm1[16,17,18,19,20,21,22,23]
vpmaxsd %ymm2, %ymm1, %ymm1
vpslldq $0x4, %ymm1, %ymm2      # ymm2 = zero,zero,zero,zero,ymm1[0,1,2,3,4,5,6,7,8,9,10,11],zero,zero,zero,zero,ymm1[16,17,18,19,20,21,22,23,24,25,26,27]
vpmaxsd %ymm2, %ymm1, %ymm1
vextracti128 $0x1, %ymm1, %xmm2
vpextrd $0x3, %xmm2, %esi
movl %esi, 0x4(%rsp)
cmpl 0x34(%rsp), %esi
jg 0x5694fe
vpbroadcastd 0xc489a(%rip), %ymm2 # 0x62dd70
vpermd %ymm1, %ymm2, %ymm1
movl %r8d, %esi
incq %r8
movq %r14, %rbx
cmpq 0x20(%rsp), %r8
jne 0x56934c
movq %rsi, %rbp
movq %r11, 0x8(%rsp)
movq 0x28(%rsp), %r15
jmp 0x569512
movq %r11, 0x8(%rsp)
movq 0x28(%rsp), %r15
orb $0x40, 0xc(%r15)
movq %r8, 0x18(%rsp)
movq 0x38(%rsp), %rcx
leal (,%rcx,4), %ecx
leaq (%rax,%rax,8), %rdx
leaq (%rdx,%rdx,2), %rdx
addq %rax, %rdx
leaq (,%rax,8), %rsi
leaq (%rsi,%rsi,2), %rdi
leaq (%rcx,%rcx,4), %r8
movq %rax, %r9
shlq $0x4, %r9
leaq (%rcx,%rcx,2), %r10
xorl %r11d, %r11d
movq 0x10(%r15), %rbx
movq 0x8(%rbx), %rbx
vmovdqa (%r13,%r11,8), %xmm0
vmovdqa 0x10(%r13,%r11,8), %xmm1
vmovd %xmm0, (%rbx,%r11)
addq %r11, %rbx
vpextrd $0x1, %xmm0, (%rcx,%rbx)
vpextrd $0x2, %xmm0, (%rsi,%rbx)
vpextrd $0x3, %xmm0, (%r10,%rbx)
vmovd %xmm1, (%r9,%rbx)
vpextrd $0x1, %xmm1, (%r8,%rbx)
vpextrd $0x2, %xmm1, (%rdi,%rbx)
vpextrd $0x3, %xmm1, (%rdx,%rbx)
addq $0x4, %r11
decq %rax
jne 0x569547
cmpl $0x7fffffff, 0x4(%rsp)  # imm = 0x7FFFFFFF
jne 0x5695ae
orb $0x40, 0xc(%r15)
movq %r15, %rdi
vzeroupper
callq 0x20be2e
testl %eax, %eax
je 0x5695d2
xorl %ebp, %ebp
movl $0x7fffffff, %r9d       # imm = 0x7FFFFFFF
xorl %r8d, %r8d
movq 0x8(%rsp), %rbx
jmp 0x569733
movq 0x18(%rsp), %rax
leal -0x1(%rax), %ecx
addl $-0x2, %eax
movq %rbp, %rsi
cmpl %eax, %esi
movq %r14, %rdx
movq 0x8(%rsp), %rdi
cmoveq %rdi, %rdx
movq %rdi, %rbx
cmoveq %r14, %rbx
cmpl %ecx, %esi
cmovneq %r13, %rdi
cmovneq %rdx, %r14
cmoveq %r13, %rbx
movq 0x50(%rsp), %rsi
testl %esi, %esi
je 0x5696ff
movl 0x10(%rsp), %r8d
movl 0x4(%rsp), %r9d
je 0x56970e
vmovd %r8d, %xmm0
vpbroadcastd %xmm0, %ymm0
vmovd %r9d, %xmm1
vpbroadcastd %xmm1, %ymm1
vmovd 0x38(%rsp), %xmm2
vpbroadcastd %xmm2, %ymm2
vpmovsxbd 0xc4758(%rip), %ymm3 # 0x62dda0
xorl %ecx, %ecx
vpbroadcastd 0xc471d(%rip), %ymm4 # 0x62dd70
vpbroadcastd 0xc4684(%rip), %ymm5 # 0x62dce0
vpcmpeqd (%rbx,%rcx,4), %ymm1, %ymm6
vpsrld $0x3, %ymm3, %ymm7
vpand %ymm4, %ymm3, %ymm8
vpmulld %ymm2, %ymm8, %ymm8
vpaddd %ymm7, %ymm8, %ymm7
vpminsd %ymm0, %ymm7, %ymm7
vblendvps %ymm6, %ymm7, %ymm0, %ymm0
addq $0x8, %rcx
vpaddd %ymm5, %ymm3, %ymm3
cmpq %rcx, %rsi
jne 0x56965c
vextracti128 $0x1, %ymm0, %xmm1
vpminsd %xmm1, %xmm0, %xmm0
vpshufd $0xee, %xmm0, %xmm1     # xmm1 = xmm0[2,3,2,3]
vpminsd %xmm1, %xmm0, %xmm0
vpshufd $0x55, %xmm0, %xmm1     # xmm1 = xmm0[1,1,1,1]
vpminsd %xmm1, %xmm0, %xmm0
vmovd %xmm0, %r8d
jmp 0x569730
callq 0x1f22bf
jmp 0x5696e7
callq 0x1f2299
jmp 0x5696e7
callq 0x1f2273
jmp 0x5696e7
callq 0x1f224d
jmp 0x5696e7
callq 0x1f2227
jmp 0x5696e7
callq 0x1f2201
jmp 0x5696e7
callq 0x1f21db
jmp 0x5696e7
callq 0x1f21b5
xorl %r15d, %r15d
movq %r15, %rax
addq $0xa8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rdi, %r13
movl 0x10(%rsp), %r8d
movl 0x4(%rsp), %r9d
jmp 0x569733
xorl %ecx, %ecx
movl %r8d, %edx
movl %ecx, %r8d
shrl $0x3, %r8d
cmpl %edx, %r8d
cmovgel %edx, %r8d
cmpl %r9d, (%rbx,%rcx,4)
cmovnel %edx, %r8d
incq %rcx
cmpl %ecx, %esi
jne 0x569710
movq %rdi, %r13
movl %r9d, (%r15)
movl %r8d, 0x4(%r15)
movl %ebp, 0x8(%r15)
movq %r12, %rdi
vzeroupper
callq 0x20a60d
movq %rbx, %rdi
callq 0x20a60d
movq %r14, %rdi
callq 0x20a60d
movq %r13, %rdi
callq 0x20a60d
jmp 0x5696ea
nop