// File: /workspace/github_c_makefile_star2_O1/nh13[P]ksw/src/parasail/src/nw_scan_sse2_128_32.c
// Function: parasail_nw_rowcol_scan_profile_sse2_128_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 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;
    __m128i* restrict pvP = NULL;
    __m128i* restrict pvE = NULL;
    int32_t* restrict boundary = NULL;
    __m128i* restrict pvHt = NULL;
    __m128i* restrict pvH = NULL;
    __m128i* restrict pvGapper = NULL;
    __m128i vGapO;
    __m128i vGapE;
    int32_t NEG_LIMIT = 0;
    int32_t POS_LIMIT = 0;
    __m128i vZero;
    int32_t score = 0;
    __m128i vNegLimit;
    __m128i vPosLimit;
    __m128i vSaturationCheckMin;
    __m128i vSaturationCheckMax;
    __m128i vNegInfFront;
    __m128i vSegLenXgap;
    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;
    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 = (__m128i*)profile->profile32.score;
    vGapO = _mm_set1_epi32(open);
    vGapE = _mm_set1_epi32(gap);
    NEG_LIMIT = (-open < matrix->min ? INT32_MIN + open : INT32_MIN - matrix->min) + 1;
    POS_LIMIT = INT32_MAX - matrix->max - 1;
    vZero = _mm_setzero_si128();
    score = NEG_LIMIT;
    vNegLimit = _mm_set1_epi32(NEG_LIMIT);
    vPosLimit = _mm_set1_epi32(POS_LIMIT);
    vSaturationCheckMin = vPosLimit;
    vSaturationCheckMax = vNegLimit;
    vNegInfFront = vZero;
    vNegInfFront = _mm_insert_epi32_rpl(vNegInfFront, NEG_LIMIT, 0);
    vSegLenXgap = _mm_add_epi32(vNegInfFront,
            _mm_slli_si128(_mm_set1_epi32(-segLen*gap), 4));

    /* 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_NW | PARASAIL_FLAG_SCAN
        | PARASAIL_FLAG_BITS_32 | 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 */
    pvE = parasail_memalign___m128i(16, segLen);
    boundary = parasail_memalign_int32_t(16, s2Len+1);
    pvHt= parasail_memalign___m128i(16, segLen);
    pvH = parasail_memalign___m128i(16, segLen);
    pvGapper = parasail_memalign___m128i(16, 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;
            __m128i_32_t h;
            __m128i_32_t e;
            for (segNum=0; segNum<segWidth; ++segNum) {
                int64_t tmp = -open-gap*(segNum*segLen+i);
                h.v[segNum] = tmp < INT32_MIN ? INT32_MIN : tmp;
                tmp = tmp - open;
                e.v[segNum] = tmp < INT32_MIN ? INT32_MIN : tmp;
            }
            _mm_store_si128(&pvH[index], h.m);
            _mm_store_si128(&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 < INT32_MIN ? INT32_MIN : tmp;
        }
    }

    {
        __m128i vGapper = _mm_sub_epi32(vZero,vGapO);
        for (i=segLen-1; i>=0; --i) {
            _mm_store_si128(pvGapper+i, vGapper);
            vGapper = _mm_sub_epi32(vGapper, vGapE);
        }
    }

    /* outer loop over database sequence */
    for (j=0; j<s2Len; ++j) {
        __m128i vE;
        __m128i vHt;
        __m128i vF;
        __m128i vH;
        __m128i vHp;
        __m128i *pvW;
        __m128i vW;

        /* calculate E */
        /* calculate Ht */
        /* calculate F and H first pass */
        vHp = _mm_load_si128(pvH+(segLen-1));
        vHp = _mm_slli_si128(vHp, 4);
        vHp = _mm_insert_epi32_rpl(vHp, boundary[j], 0);
        pvW = pvP + matrix->mapper[(unsigned char)s2[j]]*segLen;
        vHt = _mm_sub_epi32(vNegLimit, pvGapper[0]);
        vF = vNegLimit;
        for (i=0; i<segLen; ++i) {
            vH = _mm_load_si128(pvH+i);
            vE = _mm_load_si128(pvE+i);
            vW = _mm_load_si128(pvW+i);
            vE = _mm_max_epi32_rpl(
                    _mm_sub_epi32(vE, vGapE),
                    _mm_sub_epi32(vH, vGapO));
            vHp = _mm_add_epi32(vHp, vW);
            vF = _mm_max_epi32_rpl(vF, _mm_add_epi32(vHt, pvGapper[i]));
            vHt = _mm_max_epi32_rpl(vE, vHp);
            _mm_store_si128(pvE+i, vE);
            _mm_store_si128(pvHt+i, vHt);
            vHp = vH;
        }

        /* pseudo prefix scan on F and H */
        vHt = _mm_slli_si128(vHt, 4);
        vHt = _mm_insert_epi32_rpl(vHt, boundary[j+1], 0);
        vF = _mm_max_epi32_rpl(vF, _mm_add_epi32(vHt, pvGapper[0]));
        for (i=0; i<segWidth-2; ++i) {
            __m128i vFt = _mm_slli_si128(vF, 4);
            vFt = _mm_add_epi32(vFt, vSegLenXgap);
            vF = _mm_max_epi32_rpl(vF, vFt);
        }

        /* calculate final H */
        vF = _mm_slli_si128(vF, 4);
        vF = _mm_add_epi32(vF, vNegInfFront);
        vH = _mm_max_epi32_rpl(vHt, vF);
        for (i=0; i<segLen; ++i) {
            vHt = _mm_load_si128(pvHt+i);
            vF = _mm_max_epi32_rpl(
                    _mm_sub_epi32(vF, vGapE),
                    _mm_sub_epi32(vH, vGapO));
            vH = _mm_max_epi32_rpl(vHt, vF);
            _mm_store_si128(pvH+i, vH);
            vSaturationCheckMin = _mm_min_epi32_rpl(vSaturationCheckMin, vH);
            vSaturationCheckMax = _mm_max_epi32_rpl(vSaturationCheckMax, vH);
#ifdef PARASAIL_TABLE
            arr_store_si128(result->tables->score_table, vH, i, segLen, j, s2Len);
#endif
        } 


#ifdef PARASAIL_ROWCOL
        /* extract last value from the column */
        {
            vH = _mm_load_si128(pvH + offset);
            for (k=0; k<position; ++k) {
                vH = _mm_slli_si128(vH, 4);
            }
            result->rowcols->score_row[j] = (int32_t) _mm_extract_epi32_rpl (vH, 3);
        }
#endif
    }

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

    /* extract last value from the last column */
    {
        __m128i vH = _mm_load_si128(pvH + offset);
        for (k=0; k<position; ++k) {
            vH = _mm_slli_si128(vH, 4);
        }
        score = (int32_t) _mm_extract_epi32_rpl (vH, 3);
    }

    if (_mm_movemask_epi8(_mm_or_si128(
            _mm_cmplt_epi32(vSaturationCheckMin, vNegLimit),
            _mm_cmpgt_epi32(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 $0x88, %rsp
movq %rsi, 0x50(%rsp)
testq %rdi, %rdi
je 0x33b4b5
movq 0x48(%rdi), %rax
movq %rax, 0x58(%rsp)
testq %rax, %rax
je 0x33b4bc
movq 0x10(%rdi), %rax
movq %rax, 0x48(%rsp)
testq %rax, %rax
je 0x33b4c3
movl 0x8(%rdi), %edi
testl %edi, %edi
jle 0x33b4ca
cmpq $0x0, 0x50(%rsp)
je 0x33b4d1
movl %edx, %r12d
testl %edx, %edx
jle 0x33b4d8
movl %ecx, %r14d
testl %ecx, %ecx
js 0x33b4df
movl %r8d, %r13d
testl %r8d, %r8d
js 0x33b4e6
leal -0x1(%rdi), %ebx
addq $0x3, %rdi
movq %rdi, %rcx
shrq $0x2, %rcx
movl %ebx, %eax
cltd
movq %rcx, 0x8(%rsp)
idivl %ecx
movl %eax, 0x4(%rsp)
movl %edx, %ebp
movl %r14d, %r15d
negl %r15d
movq 0x48(%rsp), %rdx
movl 0x20(%rdx), %eax
movl $0x80000000, %esi       # imm = 0x80000000
movl %r14d, %ecx
orl %esi, %ecx
subl %eax, %esi
cmpl %r15d, %eax
cmovgl %ecx, %esi
movl %esi, 0x10(%rsp)
movl $0x7ffffffe, %eax       # imm = 0x7FFFFFFE
subl 0x1c(%rdx), %eax
movl %eax, 0x34(%rsp)
andl $0x7ffffffc, %edi       # imm = 0x7FFFFFFC
movl %r12d, %esi
callq 0x209630
testq %rax, %rax
je 0x33b4eb
movl %r14d, 0x2c(%rsp)
movl %ebp, 0x30(%rsp)
movl %ebx, 0x28(%rsp)
movq %rax, 0x40(%rsp)
orl $0x4440401, 0xc(%rax)   # imm = 0x4440401
movl $0x10, %edi
movq 0x8(%rsp), %rbp
movq %rbp, %rsi
callq 0x2ea474
movq %rax, %r14
leal 0x1(%r12), %ebx
movl $0x10, %edi
movq %rbx, %rsi
callq 0x2094d5
movq %rax, 0x20(%rsp)
movl $0x10, %edi
movq %rbp, %rsi
callq 0x2ea474
movq %r12, 0x38(%rsp)
movq %rax, %r12
movl $0x10, %edi
movq %rbp, %rsi
callq 0x2ea474
movq %rax, %rbp
movl $0x10, %edi
movq 0x8(%rsp), %rsi
callq 0x2ea474
testq %r14, %r14
sete %cl
cmpq $0x0, 0x20(%rsp)
sete %dl
orb %cl, %dl
testq %r12, %r12
sete %cl
testq %rbp, %rbp
sete %sil
orb %cl, %sil
orb %dl, %sil
testq %rax, %rax
sete %cl
orb %sil, %cl
jne 0x33b4eb
movq 0x38(%rsp), %rcx
decl %ecx
movl %ecx, 0x18(%rsp)
movl $0x3, %ecx
subl 0x4(%rsp), %ecx
movl %ecx, 0x1c(%rsp)
movl 0x2c(%rsp), %edx
movd %edx, %xmm0
pshufd $0x0, %xmm0, %xmm2      # xmm2 = xmm0[0,0,0,0]
movd %r13d, %xmm0
pshufd $0x0, %xmm0, %xmm3      # xmm3 = xmm0[0,0,0,0]
movl 0x10(%rsp), %ecx
incl %ecx
movd %ecx, %xmm4
pshufd $0x0, %xmm4, %xmm0      # xmm0 = xmm4[0,0,0,0]
movd 0x34(%rsp), %xmm1
pshufd $0x0, %xmm1, %xmm1      # xmm1 = xmm1[0,0,0,0]
movq 0x8(%rsp), %rsi
movl %esi, %edi
imull %r13d, %edi
movl %edi, %ecx
negl %ecx
movd %ecx, %xmm5
pshufd $0x0, %xmm5, %xmm5      # xmm5 = xmm5[0,0,0,0]
pslldq $0x4, %xmm5             # xmm5 = zero,zero,zero,zero,xmm5[0,1,2,3,4,5,6,7,8,9,10,11]
paddd %xmm4, %xmm5
movl %edx, %ecx
movl %esi, %edx
movq %rdx, 0x10(%rsp)
xorl %r8d, %r8d
movq $-0x80000000, %r9       # imm = 0x80000000
movl %r15d, %r10d
movl %r10d, %r11d
xorl %edx, %edx
movslq %r11d, %r11
movl %r11d, 0x70(%rsp,%rdx,4)
movq %r11, %rsi
subq %rcx, %rsi
cmpq $-0x7fffffff, %rsi      # imm = 0x80000001
cmovlq %r9, %rsi
movl %esi, 0x60(%rsp,%rdx,4)
incq %rdx
subl %edi, %r11d
cmpq $0x4, %rdx
jne 0x33b07c
movq %r8, %rdx
shlq $0x4, %rdx
movaps 0x70(%rsp), %xmm6
movaps %xmm6, (%rbp,%rdx)
movdqa 0x60(%rsp), %xmm6
movdqa %xmm6, (%r14,%rdx)
incq %r8
subl %r13d, %r10d
cmpq 0x10(%rsp), %r8
jne 0x33b077
movq 0x20(%rsp), %rdx
movl $0x0, (%rdx)
movl $0x1, %ecx
movl %r15d, (%rdx,%rcx,4)
incq %rcx
subl %r13d, %r15d
cmpq %rcx, %rbx
jne 0x33b0df
pxor %xmm6, %xmm6
psubd %xmm2, %xmm6
movq 0x8(%rsp), %r11
leal -0x1(%r11), %ecx
movq %rcx, %rsi
shlq $0x4, %rsi
movq %rax, %rdx
addq %rsi, %rdx
movl %r11d, %edi
movdqa %xmm6, (%rdx)
psubd %xmm3, %xmm6
addq $-0x10, %rdx
decl %edi
jg 0x33b10f
movl %ecx, %r8d
shlq $0x4, %r8
addq %rbp, %r8
movl 0x30(%rsp), %edi
movq %rdi, %r9
shlq $0x4, %r9
addq %rbp, %r9
movl $0x1, %r10d
cmpl %r10d, %r11d
adcl $0x0, %r11d
movl 0x1c(%rsp), %ecx
cmpl $0x2, %ecx
movl $0x1, %ebx
cmovgel %ecx, %ebx
movq 0x38(%rsp), %rcx
cmpl $0x2, %ecx
cmovgel %ecx, %r10d
shlq $0x4, %r11
xorl %r15d, %r15d
movdqa %xmm0, %xmm6
movdqa %xmm1, %xmm7
movq 0x20(%rsp), %rsi
movq %r15, %r13
pshufd $0x90, (%r8), %xmm8     # xmm8 = mem[0,0,1,2]
movss (%rsi,%r15,4), %xmm9
movss %xmm9, %xmm8            # xmm8 = xmm9[0],xmm8[1,2,3]
movq 0x48(%rsp), %rcx
movq 0x10(%rcx), %rcx
movq 0x50(%rsp), %rdx
movzbl (%rdx,%r15), %edx
movslq (%rcx,%rdx,4), %r15
imulq 0x10(%rsp), %r15
shlq $0x4, %r15
addq 0x58(%rsp), %r15
movdqa %xmm0, %xmm10
psubd (%rax), %xmm10
xorl %ecx, %ecx
movdqa %xmm0, %xmm9
movdqa (%rbp,%rcx), %xmm11
movdqa (%r14,%rcx), %xmm12
psubd %xmm3, %xmm12
movdqa %xmm11, %xmm13
psubd %xmm2, %xmm13
movdqa %xmm12, %xmm14
pcmpgtd %xmm13, %xmm14
pand %xmm14, %xmm12
pandn %xmm13, %xmm14
por %xmm12, %xmm14
paddd (%r15,%rcx), %xmm8
paddd (%rax,%rcx), %xmm10
movdqa %xmm9, %xmm12
pcmpgtd %xmm10, %xmm9
pand %xmm9, %xmm12
pandn %xmm10, %xmm9
por %xmm12, %xmm9
movdqa %xmm14, %xmm10
pcmpgtd %xmm8, %xmm10
movdqa %xmm14, (%r14,%rcx)
pand %xmm10, %xmm14
pandn %xmm8, %xmm10
por %xmm14, %xmm10
movdqa %xmm10, (%r12,%rcx)
addq $0x10, %rcx
movdqa %xmm11, %xmm8
cmpq %rcx, %r11
jne 0x33b1be
leaq 0x1(%r13), %r15
pshufd $0x90, %xmm10, %xmm10   # xmm10 = xmm10[0,0,1,2]
movss 0x4(%rsi,%r13,4), %xmm8
movss %xmm8, %xmm10           # xmm10 = xmm8[0],xmm10[1,2,3]
movdqa (%rax), %xmm11
paddd %xmm10, %xmm11
movdqa %xmm9, %xmm8
pcmpgtd %xmm11, %xmm8
pand %xmm8, %xmm9
pandn %xmm11, %xmm8
por %xmm9, %xmm8
movl $0x1, %ecx
movdqa %xmm8, %xmm9
movdqa %xmm8, %xmm11
pslldq $0x4, %xmm8             # xmm8 = zero,zero,zero,zero,xmm8[0,1,2,3,4,5,6,7,8,9,10,11]
paddd %xmm5, %xmm8
pcmpgtd %xmm8, %xmm9
pand %xmm9, %xmm11
pandn %xmm8, %xmm9
movdqa %xmm9, %xmm8
por %xmm11, %xmm8
decl %ecx
je 0x33b28d
pslldq $0x4, %xmm8             # xmm8 = zero,zero,zero,zero,xmm8[0,1,2,3,4,5,6,7,8,9,10,11]
paddd %xmm4, %xmm8
movdqa %xmm10, %xmm9
pcmpgtd %xmm8, %xmm9
pand %xmm9, %xmm10
pandn %xmm8, %xmm9
por %xmm10, %xmm9
xorl %ecx, %ecx
movdqa (%r12,%rcx), %xmm10
psubd %xmm3, %xmm8
psubd %xmm2, %xmm9
movdqa %xmm8, %xmm11
pcmpgtd %xmm9, %xmm11
pand %xmm11, %xmm8
pandn %xmm9, %xmm11
por %xmm11, %xmm8
movdqa %xmm10, %xmm9
pcmpgtd %xmm8, %xmm9
pand %xmm9, %xmm10
pandn %xmm8, %xmm9
por %xmm10, %xmm9
movdqa %xmm9, (%rbp,%rcx)
movdqa %xmm7, %xmm10
pcmpgtd %xmm9, %xmm10
movdqa %xmm9, %xmm11
pand %xmm10, %xmm11
pandn %xmm7, %xmm10
movdqa %xmm10, %xmm7
por %xmm11, %xmm7
movdqa %xmm6, %xmm10
pcmpgtd %xmm9, %xmm6
pand %xmm6, %xmm10
pandn %xmm9, %xmm6
por %xmm10, %xmm6
addq $0x10, %rcx
cmpq %rcx, %r11
jne 0x33b2e5
movdqa (%r9), %xmm8
cmpl $0x2, 0x4(%rsp)
jg 0x33b38f
movl %ebx, %ecx
pslldq $0x4, %xmm8             # xmm8 = zero,zero,zero,zero,xmm8[0,1,2,3,4,5,6,7,8,9,10,11]
decl %ecx
jne 0x33b385
pshufd $0xff, %xmm8, %xmm8     # xmm8 = xmm8[3,3,3,3]
movq 0x40(%rsp), %rcx
movq 0x10(%rcx), %rcx
movq (%rcx), %rcx
movd %xmm8, (%rcx,%r13,4)
cmpq %r10, %r15
jne 0x33b173
movq 0x8(%rsp), %r10
cmpl $0x1, %r10d
adcl $0x0, %r10d
movq 0x10(%rsp), %rdx
leaq (,%rdx,4), %rcx
leaq (%rcx,%rcx,2), %r8
leaq (,%rdx,8), %rsi
shlq $0x2, %r10
xorl %r9d, %r9d
movq 0x40(%rsp), %rbx
movdqa (%rbp,%r9,4), %xmm2
movq 0x10(%rbx), %rdx
movq 0x8(%rdx), %rdx
movd %xmm2, (%rdx,%r9)
addq %r9, %rdx
pshufd $0x55, %xmm2, %xmm3     # xmm3 = xmm2[1,1,1,1]
movd %xmm3, (%rcx,%rdx)
pshufd $0xee, %xmm2, %xmm3     # xmm3 = xmm2[2,3,2,3]
movd %xmm3, (%rsi,%rdx)
pshufd $0xff, %xmm2, %xmm2     # xmm2 = xmm2[3,3,3,3]
movd %xmm2, (%r8,%rdx)
addq $0x4, %r9
cmpq %r9, %r10
jne 0x33b3e2
shlq $0x4, %rdi
movdqa (%rbp,%rdi), %xmm2
cmpl $0x2, 0x4(%rsp)
jg 0x33b451
movl 0x1c(%rsp), %edx
cmpl $0x2, %edx
movl $0x1, %ecx
cmovgel %edx, %ecx
movl 0x18(%rsp), %esi
pslldq $0x4, %xmm2             # xmm2 = zero,zero,zero,zero,xmm2[0,1,2,3,4,5,6,7,8,9,10,11]
decl %ecx
jne 0x33b446
jmp 0x33b455
movl 0x18(%rsp), %esi
pcmpgtd %xmm7, %xmm0
pcmpgtd %xmm1, %xmm6
por %xmm0, %xmm6
movmskps %xmm6, %ecx
testl %ecx, %ecx
je 0x33b474
orb $0x40, 0xc(%rbx)
xorl %ecx, %ecx
xorl %esi, %esi
xorl %edx, %edx
jmp 0x33b481
pshufd $0xff, %xmm2, %xmm0     # xmm0 = xmm2[3,3,3,3]
movd %xmm0, %ecx
movl 0x28(%rsp), %edx
movl %ecx, (%rbx)
movl %edx, 0x4(%rbx)
movl %esi, 0x8(%rbx)
movq %rax, %rdi
callq 0x2094b5
movq %rbp, %rdi
callq 0x2094b5
movq %r12, %rdi
callq 0x2094b5
movq 0x20(%rsp), %rdi
callq 0x2094b5
movq %r14, %rdi
callq 0x2094b5
jmp 0x33b4ed
callq 0x1b3fef
jmp 0x33b4eb
callq 0x1b3fc9
jmp 0x33b4eb
callq 0x1b3fa3
jmp 0x33b4eb
callq 0x1b3f7d
jmp 0x33b4eb
callq 0x1b3f57
jmp 0x33b4eb
callq 0x1b3f31
jmp 0x33b4eb
callq 0x1b3f0b
jmp 0x33b4eb
callq 0x1b3ee5
xorl %ebx, %ebx
movq %rbx, %rax
addq $0x88, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
nop