// File: /workspace/github_c_makefile_star2_O3/nh13[P]ksw/src/parasail/src/nw_stats.c
// Function: parasail_nw_stats_rowcol
parasail_result_t* ENAME(
        const char * const restrict _s1, const int _s1Len,
        const char * const restrict _s2, const int s2Len,
        const int open, const int gap, const parasail_matrix_t *matrix)
{
    /* declare local variables */
    parasail_result_t *result = NULL;
    int * restrict s1 = NULL;
    int * restrict s2 = NULL;
    int * restrict H = NULL;
    int * restrict HM = NULL;
    int * restrict HS = NULL;
    int * restrict HL = NULL;
    int * restrict F = NULL;
    int * restrict FM = NULL;
    int * restrict FS = NULL;
    int * restrict FL = NULL;
    int i = 0;
    int j = 0;
    int s1Len = 0;

    /* validate inputs */
    PARASAIL_CHECK_NULL(_s2);
    PARASAIL_CHECK_GT0(s2Len);
    PARASAIL_CHECK_GE0(open);
    PARASAIL_CHECK_GE0(gap);
    PARASAIL_CHECK_NULL(matrix);
    if (matrix->type == PARASAIL_MATRIX_TYPE_PSSM) {
        PARASAIL_CHECK_NULL_PSSM_STATS(_s1);
    }
    else {
        PARASAIL_CHECK_NULL(_s1);
        PARASAIL_CHECK_GT0(_s1Len);
    }

    /* initialize stack variables */
    s1Len = matrix->type == PARASAIL_MATRIX_TYPE_SQUARE ? _s1Len : matrix->length;

    /* initialize result */
#ifdef PARASAIL_TABLE
    result = parasail_result_new_table3(s1Len, s2Len);
#else
#ifdef PARASAIL_ROWCOL
    result = parasail_result_new_rowcol3(s1Len, s2Len);
#else
    result = parasail_result_new_stats();
#endif
#endif
    if (!result) return NULL;

    /* set known flags */
    result->flag |= PARASAIL_FLAG_NW | PARASAIL_FLAG_NOVEC
        | PARASAIL_FLAG_STATS
        | PARASAIL_FLAG_BITS_INT | PARASAIL_FLAG_LANES_1;
#ifdef PARASAIL_TABLE
    result->flag |= PARASAIL_FLAG_TABLE;
#endif
#ifdef PARASAIL_ROWCOL
    result->flag |= PARASAIL_FLAG_ROWCOL;
#endif

    /* initialize heap variables */
    s1 = parasail_memalign_int(16, s1Len);
    s2 = parasail_memalign_int(16, s2Len);
    H = parasail_memalign_int(16, s2Len+1);
    HM = parasail_memalign_int(16, s2Len+1);
    HS = parasail_memalign_int(16, s2Len+1);
    HL = parasail_memalign_int(16, s2Len+1);
    F = parasail_memalign_int(16, s2Len+1);
    FM = parasail_memalign_int(16, s2Len+1);
    FS = parasail_memalign_int(16, s2Len+1);
    FL = parasail_memalign_int(16, s2Len+1);

    /* validate heap variables */
    if (!s1) return NULL;
    if (!s2) return NULL;
    if (!H) return NULL;
    if (!HM) return NULL;
    if (!HS) return NULL;
    if (!HL) return NULL;
    if (!F) return NULL;
    if (!FM) return NULL;
    if (!FS) return NULL;
    if (!FL) return NULL;

    for (i=0; i<s1Len; ++i) {
        s1[i] = matrix->mapper[(unsigned char)_s1[i]];
    }
    for (j=0; j<s2Len; ++j) {
        s2[j] = matrix->mapper[(unsigned char)_s2[j]];
    }

    /* upper left corner */
    H[0] = 0;
    HM[0] = 0;
    HS[0] = 0;
    HL[0] = 0;
    F[0] = NEG_INF_32;
    FM[0] = 0;
    FS[0] = 0;
    FL[0] = 0;
    
    /* first row */
    for (j=1; j<=s2Len; ++j) {
        H[j] = -open - (j-1)*gap;
        HM[j] = 0;
        HS[j] = 0;
        HL[j] = 0;
        F[j] = NEG_INF_32;
        FM[j] = 0;
        FS[j] = 0;
        FL[j] = 0;
    }

    /* iter over first sequence */
    for (i=1; i<=s1Len; ++i) {
        const int * const restrict matrow =
            matrix->type == PARASAIL_MATRIX_TYPE_SQUARE ?
            &matrix->matrix[matrix->size*s1[i-1]] :
            &matrix->matrix[matrix->size*(i-1)];
        /* init first column */
        int NH = H[0];
        int NHM = HM[0];
        int NHS = HS[0];
        int NHL = HL[0];
        int WH = -open - (i-1)*gap;
        int WHM = 0;
        int WHS = 0;
        int WHL = 0;
        int E = NEG_INF_32;
        int EM = 0;
        int ES = 0;
        int EL = 0;
        H[0] = WH;
        HM[0] = WHM;
        HS[0] = WHS;
        HL[0] = WHL;
        for (j=1; j<=s2Len; ++j) {
            int H_dag;
            int H_new;
            int E_opn;
            int E_ext;
            int F_opn;
            int F_ext;
            int NWH = NH;
            int NWM = NHM;
            int NWS = NHS;
            int NWL = NHL;
            NH = H[j];
            NHM = HM[j];
            NHS = HS[j];
            NHL = HL[j];
            F_opn = NH - open;
            F_ext  = F[j] - gap;
            F[j]  = MAX(F_opn, F_ext);
            E_opn = WH - open;
            E_ext = E - gap;
            E = MAX(E_opn, E_ext);
            H_dag = NWH + matrow[s2[j-1]];
            H_new = MAX(H_dag, E);
            H_new = MAX(H_new, F[j]);
            if (F_opn > F_ext) {
                FM[j] = NHM;
                FS[j] = NHS;
                FL[j] = NHL;
            }
            FL[j] += 1;
            if (E_opn > E_ext) {
                EM = WHM;
                ES = WHS;
                EL = WHL;
            }
            EL += 1;
            WH = H_new;
            if (H_new == H_dag) {
                WHM  = NWM + (s1[i-1] == s2[j-1]);
                WHS  = NWS + (matrow[s2[j-1]] > 0);
                WHL  = NWL + 1;
            }
            else if (H_new == F[j]) {
                WHM  = FM[j];
                WHS  = FS[j];
                WHL  = FL[j];
            }
            else {
                WHM  = EM;
                WHS  = ES;
                WHL  = EL;
            }
            H[j] = WH;
            HM[j] = WHM;
            HS[j] = WHS;
            HL[j] = WHL;
#ifdef PARASAIL_TABLE
            result->stats->tables->score_table[1LL*(i-1)*s2Len + (j-1)] = WH;
            result->stats->tables->matches_table[1LL*(i-1)*s2Len + (j-1)] = WHM;
            result->stats->tables->similar_table[1LL*(i-1)*s2Len + (j-1)] = WHS;
            result->stats->tables->length_table[1LL*(i-1)*s2Len + (j-1)] = WHL;
#endif
        }
#ifdef PARASAIL_ROWCOL
        result->stats->rowcols->score_col[i-1] = WH;
        result->stats->rowcols->matches_col[i-1] = WHM;
        result->stats->rowcols->similar_col[i-1] = WHS;
        result->stats->rowcols->length_col[i-1] = WHL;
#endif
    }
#ifdef PARASAIL_ROWCOL
    for (j=1; j<=s2Len; ++j) {
        result->stats->rowcols->score_row[j-1] = H[j];
        result->stats->rowcols->matches_row[j-1] = HM[j];
        result->stats->rowcols->similar_row[j-1] = HS[j];
        result->stats->rowcols->length_row[j-1] = HL[j];
    }
#endif

    result->score = H[s2Len];
    result->end_query = s1Len-1;
    result->end_ref = s2Len-1;
    result->stats->matches = HM[s2Len];
    result->stats->similar = HS[s2Len];
    result->stats->length = HL[s2Len];

    parasail_free(FL);
    parasail_free(FS);
    parasail_free(FM);
    parasail_free(F);
    parasail_free(HL);
    parasail_free(HS);
    parasail_free(HM);
    parasail_free(H);
    parasail_free(s2);
    parasail_free(s1);

    return result;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0xe8, %rsp
movl %r8d, 0x8(%rsp)
testq %rdx, %rdx
je 0x2a85a9
testl %ecx, %ecx
jle 0x2a85b0
cmpl $0x0, 0x8(%rsp)
js 0x2a85b7
movl %r9d, %ebp
testl %r9d, %r9d
js 0x2a85be
movq %rdx, %r15
movq 0x120(%rsp), %rdx
testq %rdx, %rdx
je 0x2a85c5
movl 0x30(%rdx), %eax
cmpl $0x1, %eax
jne 0x2a7e91
testq %rdi, %rdi
jne 0x2a7ea8
callq 0x1a1783
jmp 0x2a85d8
testq %rdi, %rdi
je 0x2a85cc
movl %esi, %ebx
testl %esi, %esi
jle 0x2a85d3
testl %eax, %eax
je 0x2a7eab
movl 0x34(%rdx), %ebx
movq %rdi, 0x38(%rsp)
movl %ebx, %edi
movl %ecx, %esi
movq %rcx, %r14
callq 0x20ae7d
testq %rax, %rax
je 0x2a85d8
movq %rbx, %rcx
movq %rax, %rbx
movl %ebp, 0xc(%rsp)
movq %r15, 0x30(%rsp)
orl $0x1450101, 0xc(%rax)   # imm = 0x1450101
movq %rcx, 0x20(%rsp)
movslq %ecx, %rsi
movl $0x10, %edi
callq 0x20a617
movq %rax, %r12
movl %r14d, %esi
movl $0x10, %edi
movq %rsi, 0xa0(%rsp)
callq 0x20a617
movq %rax, %rbp
movq %r14, 0xc0(%rsp)
leal 0x1(%r14), %r15d
movl $0x10, %edi
movq %r15, %rsi
callq 0x20a617
movq %rax, %r14
movl $0x10, %edi
movq %r15, %rsi
callq 0x20a617
movq %rax, 0x80(%rsp)
movl $0x10, %edi
movq %r15, %rsi
callq 0x20a617
movq %rax, %r13
movl $0x10, %edi
movq %r15, %rsi
callq 0x20a617
movq %rax, 0x78(%rsp)
movl $0x10, %edi
movq %r15, %rsi
callq 0x20a617
movq %rax, 0x60(%rsp)
movl $0x10, %edi
movq %r15, %rsi
callq 0x20a617
movq %rax, 0x50(%rsp)
movl $0x10, %edi
movq %r15, %rsi
callq 0x20a617
movq %rax, 0x28(%rsp)
movl $0x10, %edi
movq %r15, 0x98(%rsp)
movq %r15, %rsi
movq 0x50(%rsp), %r15
callq 0x20a617
movq 0x28(%rsp), %rcx
movq 0x60(%rsp), %r10
movq 0x78(%rsp), %r11
movq 0x80(%rsp), %r8
movq %r10, %xmm0
movq %r15, %xmm1
punpcklqdq %xmm1, %xmm0    # xmm0 = xmm0[0],xmm1[0]
movq %r13, 0x10(%rsp)
movq %r13, %xmm1
movq %r11, %xmm2
punpcklqdq %xmm2, %xmm1    # xmm1 = xmm1[0],xmm2[0]
movq %r14, 0x18(%rsp)
movq %r14, %xmm2
movq %r8, %xmm3
punpcklqdq %xmm3, %xmm2    # xmm2 = xmm2[0],xmm3[0]
movq %r12, %xmm3
movq %rbp, %xmm4
punpcklqdq %xmm4, %xmm3    # xmm3 = xmm3[0],xmm4[0]
pxor %xmm4, %xmm4
testq %rcx, %rcx
sete %cl
movq %rax, 0x58(%rsp)
testq %rax, %rax
sete %al
pcmpeqd %xmm4, %xmm3
pshufd $0xb1, %xmm3, %xmm5     # xmm5 = xmm3[1,0,3,2]
pand %xmm3, %xmm5
pcmpeqd %xmm4, %xmm2
pshufd $0xb1, %xmm2, %xmm3     # xmm3 = xmm2[1,0,3,2]
pand %xmm2, %xmm3
packssdw %xmm3, %xmm5
pcmpeqd %xmm4, %xmm1
pshufd $0xb1, %xmm1, %xmm2     # xmm2 = xmm1[1,0,3,2]
pand %xmm1, %xmm2
pcmpeqd %xmm4, %xmm0
pshufd $0xb1, %xmm0, %xmm1     # xmm1 = xmm0[1,0,3,2]
pand %xmm0, %xmm1
packssdw %xmm1, %xmm2
packssdw %xmm2, %xmm5
pmovmskb %xmm5, %edx
testl $0xaaaa, %edx           # imm = 0xAAAA
setne %dl
orb %cl, %al
orb %dl, %al
jne 0x2a85d8
cmpl $0x0, 0x20(%rsp)
movq 0x120(%rsp), %rdi
movq 0x38(%rsp), %r9
jle 0x2a80a2
movq 0x10(%rdi), %rax
movl 0x20(%rsp), %ecx
xorl %edx, %edx
movzbl (%r9,%rdx), %esi
movl (%rax,%rsi,4), %esi
movl %esi, (%r12,%rdx,4)
incq %rdx
cmpq %rdx, %rcx
jne 0x2a808e
movq %r12, 0x70(%rsp)
movq 0x10(%rdi), %rax
xorl %ecx, %ecx
movq 0xa0(%rsp), %rsi
movq 0x30(%rsp), %r9
movzbl (%r9,%rcx), %edx
movl (%rax,%rdx,4), %edx
movl %edx, (%rbp,%rcx,4)
incq %rcx
cmpq %rcx, %rsi
jne 0x2a80ba
movq %rbp, 0x68(%rsp)
xorl %eax, %eax
movq 0x18(%rsp), %rcx
movl %eax, (%rcx)
movl %eax, (%r8)
movq 0x10(%rsp), %rcx
movl %eax, (%rcx)
movl %eax, (%r11)
movl $0xc0000000, (%r10)     # imm = 0xC0000000
movl %eax, (%r15)
movq %r15, %rbp
movq 0x28(%rsp), %r15
movl %eax, (%r15)
movq %r10, %r13
movq 0x58(%rsp), %r10
movl %eax, (%r10)
movl 0x8(%rsp), %ecx
negl %ecx
movq 0x98(%rsp), %rdx
leaq -0x1(%rdx), %r12
xorl %edx, %edx
movl 0xc(%rsp), %r9d
movq 0x18(%rsp), %r14
movl %ecx, 0x4(%r14,%rdx,4)
movl %eax, 0x4(%r8,%rdx,4)
movq 0x10(%rsp), %r14
movl %eax, 0x4(%r14,%rdx,4)
movl %eax, 0x4(%r11,%rdx,4)
movl $0xc0000000, 0x4(%r13,%rdx,4) # imm = 0xC0000000
movl %eax, 0x4(%rbp,%rdx,4)
movl %eax, 0x4(%r15,%rdx,4)
movl %eax, 0x4(%r10,%rdx,4)
subl %r9d, %ecx
incq %rdx
cmpq %rdx, %r12
jne 0x2a8122
movq %r12, 0xb0(%rsp)
cmpl $0x0, 0x20(%rsp)
movq 0x70(%rsp), %r12
movq 0x68(%rsp), %rbp
jle 0x2a849b
movq 0x20(%rsp), %rax
incl %eax
movq %rax, 0xd0(%rsp)
movq 0x8(%rdi), %rax
movq %rax, 0xc8(%rsp)
movl $0x1, %edx
movq %rbx, 0xd8(%rsp)
cmpl $0x0, 0x30(%rdi)
movslq 0x18(%rdi), %rax
je 0x2a81be
leaq -0x1(%rdx), %rdi
imulq %rdi, %rax
movq %rax, %rcx
jmp 0x2a81cb
movslq -0x4(%r12,%rdx,4), %rcx
imulq %rax, %rcx
leaq -0x1(%rdx), %rdi
movq 0x18(%rsp), %rbp
movq %rdx, 0xe0(%rsp)
movq 0xc8(%rsp), %rax
leaq (%rax,%rcx,4), %rax
movq %rax, 0xb8(%rsp)
movl (%rbp), %ebx
movl (%r8), %eax
movl %eax, 0x38(%rsp)
movq 0x10(%rsp), %rsi
movl (%rsi), %eax
movl %eax, 0x30(%rsp)
movl (%r11), %r14d
movq %rdi, 0xa8(%rsp)
imull %r9d, %edi
addl 0x8(%rsp), %edi
negl %edi
movl %edi, (%rbp)
xorl %r10d, %r10d
movl %r10d, (%r8)
movl %r10d, (%rsi)
movl %r10d, (%r11)
movl $0xc0000000, %r9d       # imm = 0xC0000000
movl $0x0, 0x48(%rsp)
movl $0x0, 0x4c(%rsp)
movl $0x0, 0x44(%rsp)
xorl %ecx, %ecx
xorl %eax, %eax
xorl %r15d, %r15d
movl 0x38(%rsp), %edx
movl %edx, 0x90(%rsp)
movl 0x30(%rsp), %edx
movl %edx, 0x8c(%rsp)
movl %r14d, 0x88(%rsp)
movl 0x4(%rbp,%r10,4), %r13d
movl 0x4(%r8,%r10,4), %edx
movl %edx, 0x38(%rsp)
movl 0x4(%rsi,%r10,4), %edx
movl %edx, 0x30(%rsp)
movl %r13d, 0x94(%rsp)
movl 0x8(%rsp), %r14d
subl %r14d, %r13d
movq 0x60(%rsp), %r8
movl 0x4(%r8,%r10,4), %edx
movl 0xc(%rsp), %esi
subl %esi, %edx
cmpl %edx, %r13d
movl %edx, %r12d
cmovgl %r13d, %r12d
movl 0x4(%r11,%r10,4), %r11d
movl %r12d, 0x4(%r8,%r10,4)
movl %edi, %r8d
subl %r14d, %r8d
movl %r9d, %r14d
subl %esi, %r14d
movl %r8d, %r9d
cmpl %r14d, %r8d
jg 0x2a82ca
movl %r14d, %r9d
movq 0x68(%rsp), %rdi
movslq (%rdi,%r10,4), %rdi
movq 0xb8(%rsp), %rsi
addl (%rsi,%rdi,4), %ebx
cmpl %r9d, %ebx
movl %r9d, %edi
cmovgl %ebx, %edi
cmpl %r12d, %edi
jg 0x2a82ef
movl %r12d, %edi
cmpl %edx, %r13d
jle 0x2a831f
movq 0x50(%rsp), %rdx
movl 0x38(%rsp), %esi
movl %esi, 0x4(%rdx,%r10,4)
movq 0x28(%rsp), %rdx
movl 0x30(%rsp), %esi
movl %esi, 0x4(%rdx,%r10,4)
movl %r11d, %r13d
movq 0x10(%rsp), %rsi
movq 0x58(%rsp), %rdx
jmp 0x2a832e
movq 0x58(%rsp), %rdx
movl 0x4(%rdx,%r10,4), %r13d
movq 0x10(%rsp), %rsi
movq 0xb0(%rsp), %r12
incl %r13d
movl %r13d, 0x4(%rdx,%r10,4)
cmpl %r14d, %r8d
jg 0x2a8350
movl 0x44(%rsp), %r15d
movl 0x4c(%rsp), %eax
movl 0x48(%rsp), %ecx
movl %r11d, %r14d
incl %ecx
cmpl %ebx, %edi
movq 0x80(%rsp), %r8
movl %eax, 0x4c(%rsp)
movl %ecx, 0x48(%rsp)
movl %r15d, 0x44(%rsp)
jne 0x2a83c2
movq 0x68(%rsp), %rax
movslq (%rax,%r10,4), %rax
xorl %ecx, %ecx
movq 0x70(%rsp), %rdx
movq 0xa8(%rsp), %r11
cmpl %eax, (%rdx,%r11,4)
sete %cl
movl 0x90(%rsp), %r15d
addl %ecx, %r15d
xorl %ecx, %ecx
movq 0xb8(%rsp), %rdx
cmpl $0x0, (%rdx,%rax,4)
setg %cl
movl 0x8c(%rsp), %eax
addl %ecx, %eax
movl 0x88(%rsp), %ecx
incl %ecx
movq 0x78(%rsp), %r11
jmp 0x2a83ea
movq 0x60(%rsp), %rdx
cmpl 0x4(%rdx,%r10,4), %edi
movq 0x78(%rsp), %r11
jne 0x2a83ea
movq 0x50(%rsp), %rax
movl 0x4(%rax,%r10,4), %r15d
movq 0x28(%rsp), %rax
movl 0x4(%rax,%r10,4), %eax
movl %r13d, %ecx
movq 0x18(%rsp), %rbp
movl %edi, 0x4(%rbp,%r10,4)
movl %r15d, 0x4(%r8,%r10,4)
movl %eax, 0x4(%rsi,%r10,4)
movl %ecx, 0x4(%r11,%r10,4)
incq %r10
cmpq %r10, %r12
movl 0x94(%rsp), %ebx
jne 0x2a824a
movq 0xd8(%rsp), %rbx
movq 0x10(%rbx), %rdx
movq 0x10(%rdx), %rdx
movq 0x20(%rdx), %rdx
movq 0xa8(%rsp), %rsi
movl %edi, (%rdx,%rsi,4)
movq 0x10(%rbx), %rdx
movq 0x10(%rdx), %rdx
movq 0x28(%rdx), %rdx
movl %r15d, (%rdx,%rsi,4)
movq 0x10(%rbx), %rdx
movq 0x10(%rdx), %rdx
movq 0x30(%rdx), %rdx
movl %eax, (%rdx,%rsi,4)
movq 0x10(%rbx), %rax
movq 0x10(%rax), %rax
movq 0x38(%rax), %rax
movl %ecx, (%rax,%rsi,4)
movq 0xe0(%rsp), %rdx
incq %rdx
cmpq 0xd0(%rsp), %rdx
movq 0x70(%rsp), %r12
movq 0x68(%rsp), %rbp
movl 0xc(%rsp), %r9d
movq 0xa0(%rsp), %rsi
movq 0x120(%rsp), %rdi
jne 0x2a81a7
movq 0x98(%rsp), %rdi
decq %rdi
xorl %eax, %eax
movq 0x10(%rsp), %r13
movq 0x18(%rsp), %r14
movl 0x4(%r14,%rax,4), %ecx
movq 0x10(%rbx), %rdx
movq 0x10(%rdx), %rdx
movq (%rdx), %rdx
movl %ecx, (%rdx,%rax,4)
movl 0x4(%r8,%rax,4), %ecx
movq 0x10(%rbx), %rdx
movq 0x10(%rdx), %rdx
movq 0x8(%rdx), %rdx
movl %ecx, (%rdx,%rax,4)
movl 0x4(%r13,%rax,4), %ecx
movq 0x10(%rbx), %rdx
movq 0x10(%rdx), %rdx
movq 0x10(%rdx), %rdx
movl %ecx, (%rdx,%rax,4)
movl 0x4(%r11,%rax,4), %ecx
movq 0x10(%rbx), %rdx
movq 0x10(%rdx), %rdx
movq 0x18(%rdx), %rdx
movl %ecx, (%rdx,%rax,4)
incq %rax
cmpq %rax, %rdi
jne 0x2a84b2
movl (%r14,%rsi,4), %eax
movl %eax, (%rbx)
movq 0x20(%rsp), %rax
decl %eax
movl %eax, 0x4(%rbx)
movq 0xc0(%rsp), %rax
decl %eax
movl %eax, 0x8(%rbx)
movl (%r8,%rsi,4), %eax
movq 0x10(%rbx), %rcx
movl %eax, (%rcx)
movl (%r13,%rsi,4), %eax
movq 0x10(%rbx), %rcx
movl %eax, 0x4(%rcx)
movl (%r11,%rsi,4), %eax
movq 0x10(%rbx), %rcx
movl %eax, 0x8(%rcx)
movq 0x58(%rsp), %rdi
movq %r11, %r15
callq 0x20a60d
movq 0x28(%rsp), %rdi
callq 0x20a60d
movq 0x50(%rsp), %rdi
callq 0x20a60d
movq 0x60(%rsp), %rdi
callq 0x20a60d
movq %r15, %rdi
callq 0x20a60d
movq %r13, %rdi
callq 0x20a60d
movq 0x80(%rsp), %rdi
callq 0x20a60d
movq %r14, %rdi
callq 0x20a60d
movq %rbp, %rdi
callq 0x20a60d
movq %r12, %rdi
callq 0x20a60d
jmp 0x2a85da
callq 0x1a183a
jmp 0x2a85d8
callq 0x1a1814
jmp 0x2a85d8
callq 0x1a17ee
jmp 0x2a85d8
callq 0x1a17c8
jmp 0x2a85d8
callq 0x1a17a2
jmp 0x2a85d8
callq 0x1a175d
jmp 0x2a85d8
callq 0x1a1737
xorl %ebx, %ebx
movq %rbx, %rax
addq $0xe8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
nop