// File: /workspace/github_c_makefile_star2_O3/nh13[P]ksw/src/parasail/src/sw_striped_avx2_256_64.c
// Function: parasail_sw_rowcol_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 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;
    int64_t score = 0;
    __m256i vMaxH;
    __m256i vMaxHUnit;
    int64_t maxp = 0;
    /*int64_t stop = 0;*/
    parasail_result_t *result = NULL;

    /* 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;
    end_query = 0;
    end_ref = 0;
    s1Len = profile->s1Len;
    matrix = profile->matrix;
    segWidth = 4; /* 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->profile64.score;
    vGapO = _mm256_set1_epi64x_rpl(open);
    vGapE = _mm256_set1_epi64x_rpl(gap);
    vZero = _mm256_setzero_si256();
    vNegInf = _mm256_set1_epi64x_rpl(NEG_INF);
    score = NEG_INF;
    vMaxH = vNegInf;
    vMaxHUnit = vNegInf;
    maxp = INT64_MAX - (int64_t)(matrix->max+1);
    /*stop = profile->stop == INT32_MAX ?  INT64_MAX : (int64_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_64 | PARASAIL_FLAG_LANES_4;
#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_epi64x_rpl(-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 8 bytes */
        vH = _mm256_load_si256(&pvHStore[segLen - 1]);
        vH = _mm256_slli_si256_rpl(vH, 8);

        /* 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_epi64(vH, _mm256_load_si256(vP + i));
            vE = _mm256_load_si256(pvE + i);

            /* Get max from vH, vE and vF. */
            vH = _mm256_max_epi64_rpl(vH, vE);
            vH = _mm256_max_epi64_rpl(vH, vF);
            vH = _mm256_max_epi64_rpl(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_epi64_rpl(vH, vMaxH);

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

            /* Update vF value. */
            vF = _mm256_sub_epi64(vF, vGapE);
            vF = _mm256_max_epi64_rpl(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, 8);
            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);
#ifdef PARASAIL_TABLE
                arr_store_si256(result->tables->score_table, vH, i, segLen, j, s2Len);
#endif
                vMaxH = _mm256_max_epi64_rpl(vH, vMaxH);
                vH = _mm256_sub_epi64(vH, vGapO);
                vF = _mm256_sub_epi64(vF, vGapE);
                if (! _mm256_movemask_epi8(_mm256_cmpgt_epi64(vF, vH))) goto end;
                /*vF = _mm256_max_epi64_rpl(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, 8);
            }
            result->rowcols->score_row[j] = (int64_t) _mm256_extract_epi64_rpl (vH, 3);
        }
#endif

        {
            __m256i vCompare = _mm256_cmpgt_epi64(vMaxH, vMaxHUnit);
            if (_mm256_movemask_epi8(vCompare)) {
                score = _mm256_hmax_epi64_rpl(vMaxH);
                /* if score has potential to overflow, abort early */
                if (score > maxp) {
                    result->flag |= PARASAIL_FLAG_SATURATED;
                    break;
                }
                vMaxHUnit = _mm256_set1_epi64x_rpl(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 == INT64_MAX) {
        result->flag |= PARASAIL_FLAG_SATURATED;
    }

    if (parasail_result_is_saturated(result)) {
        score = INT64_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. */
        {
            int64_t *t = (int64_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, 0x40(%rsp)
testq %rdi, %rdi
je 0x567dfa
movq 0x60(%rdi), %rax
movq %rax, 0x58(%rsp)
testq %rax, %rax
je 0x567e01
movq 0x10(%rdi), %rax
movq %rax, 0x38(%rsp)
testq %rax, %rax
je 0x567e08
movl 0x8(%rdi), %eax
testl %eax, %eax
jle 0x567e0f
cmpq $0x0, 0x40(%rsp)
je 0x567e16
movl %edx, %ebx
testl %edx, %edx
jle 0x567e1d
movl %ecx, %r14d
testl %ecx, %ecx
js 0x567e24
movl %r8d, %r12d
testl %r8d, %r8d
js 0x567e2b
movq %rax, %r13
addq $0x3, %r13
movq %r13, %rbp
shrq $0x2, %rbp
decl %eax
movl %eax, 0x8(%rsp)
xorl %edx, %edx
divl %ebp
movl %eax, 0xc(%rsp)
movl %edx, (%rsp)
movq 0x38(%rsp), %rax
movslq 0x1c(%rax), %rax
movq %rax, 0x20(%rsp)
andl $0x7ffffffc, %r13d      # imm = 0x7FFFFFFC
movl %r13d, %edi
movl %ebx, %esi
callq 0x20ac53
testq %rax, %rax
je 0x567e30
movq %rax, %r15
movl %r12d, 0x10(%rsp)
movl %r14d, 0x28(%rsp)
movq %rbx, 0x18(%rsp)
orl $0x4840804, 0xc(%rax)   # imm = 0x4840804
movl $0x20, %edi
movq %rbp, %rsi
callq 0x4f1904
movq %rax, %r14
movl $0x20, %edi
movq %rbp, %rsi
callq 0x4f1904
movq %rax, %rbx
movl $0x20, %edi
movq %rbp, %rsi
callq 0x4f1904
movq %rax, %r12
movl $0x20, %edi
movq %rbp, %rsi
callq 0x4f1904
movq %r12, %r8
movq %rax, %r12
testq %r14, %r14
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 0x567e30
movq %r13, 0x50(%rsp)
movq %r15, 0x30(%rsp)
movabsq $0x7fffffffffffffff, %rcx # imm = 0x7FFFFFFFFFFFFFFF
movl $0x3, %r15d
subl 0xc(%rsp), %r15d
movl 0x28(%rsp), %r13d
movl %r13d, %eax
vmovq %rax, %xmm0
vpbroadcastq %xmm0, %ymm0
vmovdqu %ymm0, 0x80(%rsp)
movl 0x10(%rsp), %eax
vmovq %rax, %xmm0
vpbroadcastq %xmm0, %ymm0
vmovdqu %ymm0, 0x60(%rsp)
movq 0x20(%rsp), %rax
notq %rax
addq %rcx, %rax
movq %rax, 0x20(%rsp)
vpxor %xmm0, %xmm0, %xmm0
movq %r14, %rdi
movq %rbp, %rsi
movq %r8, 0x10(%rsp)
callq 0x4f190d
negl %r13d
movslq %r13d, %rax
vmovq %rax, %xmm0
vpbroadcastq %xmm0, %ymm0
movq %r12, %rdi
movq %rbp, %rsi
callq 0x4f190d
vpxor %xmm8, %xmm8, %xmm8
vmovdqu 0x60(%rsp), %ymm7
vmovdqu 0x80(%rsp), %ymm6
xorl %esi, %esi
movq 0x10(%rsp), %r11
leal -0x1(%rbp), %ecx
movl (%rsp), %edx
movl 0x18(%rsp), %eax
movq %rax, 0x28(%rsp)
movq %rbp, %rdi
shlq $0x5, %rdi
movabsq $-0x4000000000000000, %r13 # imm = 0xC000000000000000
vpbroadcastq 0xc404f(%rip), %ymm1 # 0x62bae0
shlq $0x5, %rcx
movq %rbp, 0x48(%rsp)
movl %ebp, %eax
shlq $0x5, %rdx
xorl %r8d, %r8d
vmovdqa %ymm1, %ymm0
movq %r14, %rbp
vmovdqa (%r14,%rcx), %ymm2
vperm2i128 $0x8, %ymm2, %ymm2, %ymm3 # ymm3 = zero,zero,ymm2[0,1]
vpalignr $0x8, %ymm3, %ymm2, %ymm3 # ymm3 = 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]
movq 0x38(%rsp), %r9
movq 0x10(%r9), %r9
movq 0x40(%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, (%rsp)
cmpl %r10d, %esi
movq %rbx, %r14
movq %r11, %rsi
cmoveq %r11, %r14
xorl %r11d, %r11d
vpxor %xmm2, %xmm2, %xmm2
vpaddq (%r9,%r11), %ymm3, %ymm3
vmovdqa (%r12,%r11), %ymm4
vpcmpgtq %ymm4, %ymm3, %ymm5
vblendvpd %ymm5, %ymm3, %ymm4, %ymm3
vpcmpgtq %ymm2, %ymm3, %ymm5
vblendvpd %ymm5, %ymm3, %ymm2, %ymm3
vpcmpgtq %ymm8, %ymm3, %ymm5
vpand %ymm3, %ymm5, %ymm3
vmovdqa %ymm3, (%r14,%r11)
vpcmpgtq %ymm0, %ymm3, %ymm5
vblendvpd %ymm5, %ymm3, %ymm0, %ymm0
vpsubq %ymm6, %ymm3, %ymm3
vpsubq %ymm7, %ymm4, %ymm4
vpcmpgtq %ymm3, %ymm4, %ymm5
vblendvpd %ymm5, %ymm4, %ymm3, %ymm4
vmovapd %ymm4, (%r12,%r11)
vpsubq %ymm7, %ymm2, %ymm2
vpcmpgtq %ymm3, %ymm2, %ymm4
vblendvpd %ymm4, %ymm2, %ymm3, %ymm2
vmovapd (%rbp,%r11), %ymm3
addq $0x20, %r11
cmpq %r11, %rdi
jne 0x567afc
cmpl %r10d, (%rsp)
movq %rsi, %r11
cmoveq %rbx, %r11
xorl %r9d, %r9d
vperm2f128 $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]
xorl %r10d, %r10d
vmovdqa (%r14,%r10), %ymm3
vpcmpgtq %ymm2, %ymm3, %ymm4
vblendvpd %ymm4, %ymm3, %ymm2, %ymm3
vmovapd %ymm3, (%r14,%r10)
vpcmpgtq %ymm0, %ymm3, %ymm4
vblendvpd %ymm4, %ymm3, %ymm0, %ymm0
vpsubq %ymm6, %ymm3, %ymm3
vpsubq %ymm7, %ymm2, %ymm2
vpcmpgtq %ymm3, %ymm2, %ymm3
vtestpd %ymm3, %ymm3
je 0x567bd5
addq $0x20, %r10
cmpq %r10, %rdi
jne 0x567b8d
incl %r9d
cmpl $0x4, %r9d
jne 0x567b7e
vmovapd (%r14,%rdx), %ymm2
cmpl $0x2, 0xc(%rsp)
ja 0x567bff
xorl %r9d, %r9d
movq (%rsp), %rsi
vperm2f128 $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]
incl %r9d
cmpl %r15d, %r9d
jl 0x567be9
jmp 0x567c03
movq (%rsp), %rsi
vextracti128 $0x1, %ymm2, %xmm2
movq 0x30(%rsp), %r9
movq 0x10(%r9), %r9
movq (%r9), %r9
vpextrd $0x2, %xmm2, (%r9,%r8,4)
vpcmpgtq %ymm1, %ymm0, %ymm2
vtestpd %ymm2, %ymm2
je 0x567c6d
vmovq %xmm0, %r9
vextracti128 $0x1, %ymm0, %xmm1
vmovq %xmm1, %r10
cmpq %r9, %r10
cmovgq %r10, %r9
vpextrq $0x1, %xmm0, %r13
vpextrq $0x1, %xmm1, %r10
cmpq %r13, %r10
cmovgq %r10, %r13
cmpq %r9, %r13
cmovleq %r9, %r13
cmpq 0x20(%rsp), %r13
jg 0x567c89
vmovq %r13, %xmm1
vpbroadcastq %xmm1, %ymm1
movl %r8d, %esi
incq %r8
movq %rbp, %rbx
cmpq 0x28(%rsp), %r8
jne 0x567aa7
movq %rsi, (%rsp)
movq 0x30(%rsp), %r15
jmp 0x567c98
movq 0x30(%rsp), %r15
orb $0x40, 0xc(%r15)
movq %r8, 0x18(%rsp)
leaq (,%rax,4), %rcx
leaq (%rcx,%rcx,2), %rdx
leaq (,%rax,8), %rsi
xorl %edi, %edi
movq 0x10(%r15), %r8
movq 0x8(%r8), %r8
vmovdqa (%r14,%rdi,8), %xmm0
vmovdqa 0x10(%r14,%rdi,8), %xmm1
vmovd %xmm0, (%r8,%rdi)
addq %rdi, %r8
vpextrd $0x2, %xmm0, (%rcx,%r8)
vmovd %xmm1, (%rsi,%r8)
vpextrd $0x2, %xmm1, (%rdx,%r8)
addq $0x4, %rdi
decq %rax
jne 0x567cae
movq %r11, %rbx
movabsq $0x7fffffffffffffff, %rax # imm = 0x7FFFFFFFFFFFFFFF
cmpq %rax, %r13
jne 0x567d00
orb $0x40, 0xc(%r15)
movq %r15, %rdi
vzeroupper
callq 0x20be2e
testl %eax, %eax
je 0x567d1e
xorl %eax, %eax
movl $0xffffffff, %r13d      # imm = 0xFFFFFFFF
xorl %edi, %edi
jmp 0x567e6f
movq 0x18(%rsp), %rcx
leal -0x1(%rcx), %eax
addl $-0x2, %ecx
movq (%rsp), %rdx
cmpl %ecx, %edx
movq %rbp, %rdi
cmoveq %rbx, %rdi
movq %rbx, %rsi
cmoveq %rbp, %rbx
cmpl %eax, %edx
cmovneq %r14, %rsi
movq %rsi, %rax
cmoveq %rbp, %rdi
movq %rdi, %rbp
cmoveq %r14, %rbx
movq 0x50(%rsp), %rdx
testl %edx, %edx
je 0x567e48
movl 0x8(%rsp), %edi
movq %rax, %r14
je 0x567e51
vmovd %edi, %xmm0
vpbroadcastd %xmm0, %xmm0
vmovq %r13, %xmm1
vpbroadcastq %xmm1, %ymm1
vmovd 0x48(%rsp), %xmm2
vpbroadcastd %xmm2, %xmm2
vpmovsxbd 0xc5e36(%rip), %xmm3 # 0x62dbc8
xorl %eax, %eax
vpbroadcastd 0xc5e7f(%rip), %xmm4 # 0x62dc1c
vpbroadcastd 0xc5e1a(%rip), %xmm5 # 0x62dbc0
vpcmpeqq (%rbx,%rax,8), %ymm1, %ymm6
vextracti128 $0x1, %ymm6, %xmm7
vpackssdw %xmm7, %xmm6, %xmm6
vpsrld $0x2, %xmm3, %xmm7
vpand %xmm4, %xmm3, %xmm8
vpmulld %xmm2, %xmm8, %xmm8
vpaddd %xmm7, %xmm8, %xmm7
vpminsd %xmm0, %xmm7, %xmm7
vblendvps %xmm6, %xmm7, %xmm0, %xmm0
addq $0x4, %rax
vpaddd %xmm5, %xmm3, %xmm3
cmpq %rax, %rdx
jne 0x567da6
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, %edi
jmp 0x567e6b
callq 0x1f1c11
jmp 0x567e30
callq 0x1f1beb
jmp 0x567e30
callq 0x1f1bc5
jmp 0x567e30
callq 0x1f1b9f
jmp 0x567e30
callq 0x1f1b79
jmp 0x567e30
callq 0x1f1b53
jmp 0x567e30
callq 0x1f1b2d
jmp 0x567e30
callq 0x1f1b07
xorl %r15d, %r15d
movq %r15, %rax
addq $0xa8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movl 0x8(%rsp), %edi
movq %rax, %r14
jmp 0x567e6b
xorl %eax, %eax
movl %eax, %ecx
shrl $0x2, %ecx
cmpl %edi, %ecx
cmovgel %edi, %ecx
cmpq %r13, (%rbx,%rax,8)
cmovel %ecx, %edi
incq %rax
cmpl %eax, %edx
jne 0x567e53
movq (%rsp), %rax
movl %r13d, (%r15)
movl %edi, 0x4(%r15)
movl %eax, 0x8(%r15)
movq %r12, %rdi
vzeroupper
callq 0x20a60d
movq %rbx, %rdi
callq 0x20a60d
movq %rbp, %rdi
callq 0x20a60d
movq %r14, %rdi
callq 0x20a60d
jmp 0x567e33
nop