LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O0/diaxen[P]fft-garden/./ct_bf.h
// Function: ct_dit_bf2_pi2
static inline void
ct_dit_bf2_pi2(unsigned s,
           complex double * restrict out)
{
  complex double a = out[0];
  complex double b = out[s];
  complex double t = CMPLX(cimag(b), -creal(b));
  out[0] = a + t;
  out[s] = a - t;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movl %edi, -0x4(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x10(%rbp), %rax
movsd (%rax), %xmm1
movsd 0x8(%rax), %xmm0
movsd %xmm1, -0x20(%rbp)
movsd %xmm0, -0x18(%rbp)
movq -0x10(%rbp), %rax
movl -0x4(%rbp), %ecx
shlq $0x4, %rcx
addq %rcx, %rax
movsd (%rax), %xmm1
movsd 0x8(%rax), %xmm0
movsd %xmm1, -0x30(%rbp)
movsd %xmm0, -0x28(%rbp)
movsd -0x28(%rbp), %xmm1
movsd -0x30(%rbp), %xmm0
movq %xmm0, %rax
movabsq $-0x8000000000000000, %rcx # imm = 0x8000000000000000
xorq %rcx, %rax
movq %rax, %xmm0
movsd %xmm1, -0x50(%rbp)
movsd %xmm0, -0x48(%rbp)
movsd -0x50(%rbp), %xmm1
movsd -0x48(%rbp), %xmm0
movsd %xmm1, -0x40(%rbp)
movsd %xmm0, -0x38(%rbp)
movsd -0x20(%rbp), %xmm1
movsd -0x18(%rbp), %xmm0
movsd -0x40(%rbp), %xmm3
movsd -0x38(%rbp), %xmm2
addsd %xmm3, %xmm1
addsd %xmm2, %xmm0
movq -0x10(%rbp), %rax
movsd %xmm1, (%rax)
movsd %xmm0, 0x8(%rax)
movsd -0x20(%rbp), %xmm1
movsd -0x18(%rbp), %xmm0
movsd -0x40(%rbp), %xmm3
movsd -0x38(%rbp), %xmm2
subsd %xmm3, %xmm1
subsd %xmm2, %xmm0
movq -0x10(%rbp), %rax
movl -0x4(%rbp), %ecx
shlq $0x4, %rcx
addq %rcx, %rax
movsd %xmm1, (%rax)
movsd %xmm0, 0x8(%rax)
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O0/diaxen[P]fft-garden/./ct_bf.h
// Function: ct_dit_bf2_pi4
static inline void
ct_dit_bf2_pi4(unsigned s,
           complex double * restrict out)
{
  complex double a = out[0];
  complex double b = out[s];
  complex double t = CMPLX(M_SQRT1_2 * (creal(b) + cimag(b)),
                           M_SQRT1_2 * (cimag(b) - creal(b)));
  out[0] = a + t;
  out[s] = a - t;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movl %edi, -0x4(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x10(%rbp), %rax
movsd (%rax), %xmm1
movsd 0x8(%rax), %xmm0
movsd %xmm1, -0x20(%rbp)
movsd %xmm0, -0x18(%rbp)
movq -0x10(%rbp), %rax
movl -0x4(%rbp), %ecx
shlq $0x4, %rcx
addq %rcx, %rax
movsd (%rax), %xmm1
movsd 0x8(%rax), %xmm0
movsd %xmm1, -0x30(%rbp)
movsd %xmm0, -0x28(%rbp)
movsd -0x30(%rbp), %xmm0
addsd -0x28(%rbp), %xmm0
movsd 0xe4b(%rip), %xmm1      # 0x3240
mulsd %xmm0, %xmm1
movsd -0x28(%rbp), %xmm2
subsd -0x30(%rbp), %xmm2
movsd 0xe35(%rip), %xmm0      # 0x3240
mulsd %xmm2, %xmm0
movsd %xmm1, -0x50(%rbp)
movsd %xmm0, -0x48(%rbp)
movsd -0x50(%rbp), %xmm1
movsd -0x48(%rbp), %xmm0
movsd %xmm1, -0x40(%rbp)
movsd %xmm0, -0x38(%rbp)
movsd -0x20(%rbp), %xmm1
movsd -0x18(%rbp), %xmm0
movsd -0x40(%rbp), %xmm3
movsd -0x38(%rbp), %xmm2
addsd %xmm3, %xmm1
addsd %xmm2, %xmm0
movq -0x10(%rbp), %rax
movsd %xmm1, (%rax)
movsd %xmm0, 0x8(%rax)
movsd -0x20(%rbp), %xmm1
movsd -0x18(%rbp), %xmm0
movsd -0x40(%rbp), %xmm3
movsd -0x38(%rbp), %xmm2
subsd %xmm3, %xmm1
subsd %xmm2, %xmm0
movq -0x10(%rbp), %rax
movl -0x4(%rbp), %ecx
shlq $0x4, %rcx
addq %rcx, %rax
movsd %xmm1, (%rax)
movsd %xmm0, 0x8(%rax)
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/diaxen[P]fft-garden/./ct_bf.h
// Function: ct_dit_bf2_3pi4
static inline void
ct_dit_bf2_3pi4(unsigned s,
             complex double * restrict out)
{
  complex double a = out[0];
  complex double b = out[s];
  complex double t = CMPLX(M_SQRT1_2 * (-creal(b) + cimag(b)),
                           M_SQRT1_2 * (-cimag(b) - creal(b)));
  out[0] = a + t;
  out[s] = a - t;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movl %edi, -0x4(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x10(%rbp), %rax
movsd (%rax), %xmm1
movsd 0x8(%rax), %xmm0
movsd %xmm1, -0x20(%rbp)
movsd %xmm0, -0x18(%rbp)
movq -0x10(%rbp), %rax
movl -0x4(%rbp), %ecx
shlq $0x4, %rcx
addq %rcx, %rax
movsd (%rax), %xmm1
movsd 0x8(%rax), %xmm0
movsd %xmm1, -0x30(%rbp)
movsd %xmm0, -0x28(%rbp)
movsd -0x30(%rbp), %xmm0
movq %xmm0, %rax
movabsq $-0x8000000000000000, %rcx # imm = 0x8000000000000000
xorq %rcx, %rax
movq %rax, %xmm0
addsd -0x28(%rbp), %xmm0
movsd 0xd44(%rip), %xmm1      # 0x3240
mulsd %xmm0, %xmm1
movsd -0x28(%rbp), %xmm0
movq %xmm0, %rax
movabsq $-0x8000000000000000, %rcx # imm = 0x8000000000000000
xorq %rcx, %rax
movq %rax, %xmm2
subsd -0x30(%rbp), %xmm2
movsd 0xd17(%rip), %xmm0      # 0x3240
mulsd %xmm2, %xmm0
movsd %xmm1, -0x50(%rbp)
movsd %xmm0, -0x48(%rbp)
movsd -0x50(%rbp), %xmm1
movsd -0x48(%rbp), %xmm0
movsd %xmm1, -0x40(%rbp)
movsd %xmm0, -0x38(%rbp)
movsd -0x20(%rbp), %xmm1
movsd -0x18(%rbp), %xmm0
movsd -0x40(%rbp), %xmm3
movsd -0x38(%rbp), %xmm2
addsd %xmm3, %xmm1
addsd %xmm2, %xmm0
movq -0x10(%rbp), %rax
movsd %xmm1, (%rax)
movsd %xmm0, 0x8(%rax)
movsd -0x20(%rbp), %xmm1
movsd -0x18(%rbp), %xmm0
movsd -0x40(%rbp), %xmm3
movsd -0x38(%rbp), %xmm2
subsd %xmm3, %xmm1
subsd %xmm2, %xmm0
movq -0x10(%rbp), %rax
movl -0x4(%rbp), %ecx
shlq $0x4, %rcx
addq %rcx, %rax
movsd %xmm1, (%rax)
movsd %xmm0, 0x8(%rax)
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/diaxen[P]fft-garden/./ct_bf.h
// Function: ct_dit_bf2
static inline void
ct_dit_bf2(unsigned s,
       complex double * restrict out,
       complex double w)
{
  complex double a = out[0];
  complex double b = out[s] * w;
  out[0] = a + b;
  out[s] = a - b;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x80, %rsp
movsd %xmm0, -0x10(%rbp)
movsd %xmm1, -0x8(%rbp)
movl %edi, -0x14(%rbp)
movq %rsi, -0x20(%rbp)
movq -0x20(%rbp), %rax
movsd (%rax), %xmm1
movsd 0x8(%rax), %xmm0
movsd %xmm1, -0x30(%rbp)
movsd %xmm0, -0x28(%rbp)
movq -0x20(%rbp), %rax
movl -0x14(%rbp), %ecx
shlq $0x4, %rcx
addq %rcx, %rax
movsd (%rax), %xmm1
movsd %xmm1, -0x80(%rbp)
movsd 0x8(%rax), %xmm2
movsd %xmm2, -0x78(%rbp)
movsd -0x10(%rbp), %xmm4
movsd %xmm4, -0x70(%rbp)
movsd -0x8(%rbp), %xmm5
movsd %xmm5, -0x68(%rbp)
movaps %xmm1, %xmm0
mulsd %xmm4, %xmm0
movaps %xmm2, %xmm3
mulsd %xmm5, %xmm3
mulsd %xmm5, %xmm1
mulsd %xmm4, %xmm2
subsd %xmm3, %xmm0
movsd %xmm0, -0x60(%rbp)
addsd %xmm2, %xmm1
movsd %xmm1, -0x58(%rbp)
ucomisd %xmm0, %xmm0
movsd %xmm0, -0x50(%rbp)
movsd %xmm1, -0x48(%rbp)
jnp 0x268d
movsd -0x58(%rbp), %xmm1
movsd -0x60(%rbp), %xmm0
ucomisd %xmm1, %xmm1
movsd %xmm0, -0x50(%rbp)
movsd %xmm1, -0x48(%rbp)
jnp 0x268d
movsd -0x68(%rbp), %xmm3
movsd -0x70(%rbp), %xmm2
movsd -0x78(%rbp), %xmm1
movsd -0x80(%rbp), %xmm0
callq 0x2750
movsd %xmm0, -0x50(%rbp)
movsd %xmm1, -0x48(%rbp)
movsd -0x50(%rbp), %xmm1
movsd -0x48(%rbp), %xmm0
movsd %xmm1, -0x40(%rbp)
movsd %xmm0, -0x38(%rbp)
movsd -0x30(%rbp), %xmm1
movsd -0x28(%rbp), %xmm0
movsd -0x40(%rbp), %xmm3
movsd -0x38(%rbp), %xmm2
addsd %xmm3, %xmm1
addsd %xmm2, %xmm0
movq -0x20(%rbp), %rax
movsd %xmm1, (%rax)
movsd %xmm0, 0x8(%rax)
movsd -0x30(%rbp), %xmm1
movsd -0x28(%rbp), %xmm0
movsd -0x40(%rbp), %xmm3
movsd -0x38(%rbp), %xmm2
subsd %xmm3, %xmm1
subsd %xmm2, %xmm0
movq -0x20(%rbp), %rax
movl -0x14(%rbp), %ecx
shlq $0x4, %rcx
addq %rcx, %rax
movsd %xmm1, (%rax)
movsd %xmm0, 0x8(%rax)
addq $0x80, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/tkln[P]mcwm/hidden.c
// Function: main
int main(int argc, char **argv)
{
    int ch;                     /* Option character */

    while (1)
    {
        ch = getopt(argc, argv, "c");
        if (-1 == ch)
        {
            /* No more options, break out of while loop. */
            break;
        }
        switch (ch)
        {
        case 'c':
            printcommand = true;
            break;
            
        default:
            printhelp();
            exit(0);            
        } /* switch ch */
    } /* while 1 */
    
    init();
    wm_state = getatom("WM_STATE");
    findhidden();
    cleanup();
    exit(0);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movl $0x0, -0x4(%rbp)
movl %edi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl -0x8(%rbp), %edi
movq -0x10(%rbp), %rsi
leaq 0xd10(%rip), %rdx       # 0x2004
callq 0x11a0
movl %eax, -0x14(%rbp)
movl $0xffffffff, %eax       # imm = 0xFFFFFFFF
cmpl -0x14(%rbp), %eax
jne 0x1308
jmp 0x1329
movl -0x14(%rbp), %eax
subl $0x63, %eax
jne 0x131b
jmp 0x1312
movb $0x1, 0x2de7(%rip)      # 0x4100
jmp 0x1327
callq 0x1360
xorl %edi, %edi
callq 0x11c0
jmp 0x12e6
callq 0x1390
leaq 0xcd1(%rip), %rdi       # 0x2006
callq 0x1470
movl %eax, 0x2dc4(%rip)      # 0x4104
callq 0x1500
callq 0x16d0
xorl %edi, %edi
callq 0x11c0
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/tkln[P]mcwm/hidden.c
// Function: init
void init(void)
{
    int scrno;
    xcb_screen_iterator_t iter;
    
    conn = xcb_connect(NULL, &scrno);
    if (!conn)
    {
        fprintf(stderr, "can't connect to an X server\n");
        exit(1);
    }

    iter = xcb_setup_roots_iterator(xcb_get_setup(conn));

    for (int i = 0; i < scrno; ++i)
    {
        xcb_screen_next(&iter);
    }

    screen = iter.data;

    if (!screen)
    {
        fprintf(stderr, "can't get the current screen\n");
        xcb_disconnect(conn);
        exit(1);
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
xorl %eax, %eax
movl %eax, %edi
leaq -0x4(%rbp), %rsi
callq 0x1070
movq %rax, 0x2d5c(%rip)      # 0x4108
cmpq $0x0, 0x2d54(%rip)      # 0x4108
jne 0x13d8
movq 0x2c3b(%rip), %rax      # 0x3ff8
movq (%rax), %rdi
leaq 0xc91(%rip), %rsi       # 0x2058
movb $0x0, %al
callq 0x1130
movl $0x1, %edi
callq 0x11c0
movq 0x2d29(%rip), %rdi      # 0x4108
callq 0x11b0
movq %rax, %rdi
callq 0x1120
movq %rax, -0x28(%rbp)
movq %rdx, -0x20(%rbp)
movq -0x28(%rbp), %rax
movq %rax, -0x18(%rbp)
movq -0x20(%rbp), %rax
movq %rax, -0x10(%rbp)
movl $0x0, -0x2c(%rbp)
movl -0x2c(%rbp), %eax
cmpl -0x4(%rbp), %eax
jge 0x1427
leaq -0x18(%rbp), %rdi
callq 0x1100
movl -0x2c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x2c(%rbp)
jmp 0x140b
movq -0x18(%rbp), %rax
movq %rax, 0x2cde(%rip)      # 0x4110
cmpq $0x0, 0x2cd6(%rip)      # 0x4110
jne 0x146a
movq 0x2bb5(%rip), %rax      # 0x3ff8
movq (%rax), %rdi
leaq 0xc29(%rip), %rsi       # 0x2076
movb $0x0, %al
callq 0x1130
movq 0x2cad(%rip), %rdi      # 0x4108
callq 0x1190
movl $0x1, %edi
callq 0x11c0
addq $0x30, %rsp
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O0/tkln[P]mcwm/hidden.c
// Function: getatom
xcb_atom_t getatom(char *atom_name)
{
    xcb_intern_atom_cookie_t atom_cookie;
    xcb_atom_t atom;
    xcb_intern_atom_reply_t *rep;
    
    atom_cookie = xcb_intern_atom(conn, 0, strlen(atom_name), atom_name);
    rep = xcb_intern_atom_reply(conn, atom_cookie, NULL);
    if (NULL != rep)
    {
        atom = rep->atom;
        free(rep);
        return atom;
    }

    /*
     * XXX Note that we return 0 as an atom if anything goes wrong.
     * Might become interesting.
     */
    return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movq 0x2c85(%rip), %rax      # 0x4108
movq %rax, -0x30(%rbp)
movq -0x10(%rbp), %rdi
callq 0x1090
movq -0x30(%rbp), %rdi
movq -0x10(%rbp), %rcx
xorl %esi, %esi
movzwl %ax, %edx
callq 0x10e0
movl %eax, -0x24(%rbp)
movl -0x24(%rbp), %eax
movl %eax, -0x14(%rbp)
movq 0x2c56(%rip), %rdi      # 0x4108
movl -0x14(%rbp), %esi
xorl %eax, %eax
movl %eax, %edx
callq 0x1170
movq %rax, -0x20(%rbp)
xorl %eax, %eax
cmpq -0x20(%rbp), %rax
je 0x14e5
movq -0x20(%rbp), %rax
movl 0x8(%rax), %eax
movl %eax, -0x18(%rbp)
movq -0x20(%rbp), %rdi
callq 0x1030
movl -0x18(%rbp), %eax
movl %eax, -0x4(%rbp)
jmp 0x14ec
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/tkln[P]mcwm/hidden.c
// Function: get_wm_state
uint32_t get_wm_state(xcb_drawable_t win)
{
    xcb_get_property_reply_t *reply;
    xcb_get_property_cookie_t cookie;
    uint32_t *statep;
    uint32_t state = 0;
    
    cookie = xcb_get_property(conn, false, win, wm_state, wm_state, 0,
                              sizeof (int32_t));

    reply = xcb_get_property_reply(conn, cookie, NULL);
    if (NULL == reply)
    {
        fprintf(stderr, "mcwm: Couldn't get properties for win %d\n", win);
        return -1;
    }

    /* Length is 0 if we didn't find it. */
    if (0 == xcb_get_property_value_length(reply))
    {
        goto bad;
    }
        
    statep = xcb_get_property_value(reply);
    state = *statep;

bad:
    free(reply);
    return state;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movl %edi, -0x8(%rbp)
movl $0x0, -0x24(%rbp)
movq 0x29ff(%rip), %rdi      # 0x4108
movl -0x8(%rbp), %edx
movl 0x29f2(%rip), %ecx      # 0x4104
movl 0x29eb(%rip), %r8d      # 0x4104
xorl %r9d, %r9d
movl %r9d, %esi
movl $0x4, (%rsp)
callq 0x1040
movl %eax, -0x28(%rbp)
movl -0x28(%rbp), %eax
movl %eax, -0x14(%rbp)
movq 0x29cd(%rip), %rdi      # 0x4108
movl -0x14(%rbp), %esi
xorl %eax, %eax
movl %eax, %edx
callq 0x1180
movq %rax, -0x10(%rbp)
xorl %eax, %eax
cmpq -0x10(%rbp), %rax
jne 0x1777
movq 0x289e(%rip), %rax      # 0x3ff8
movq (%rax), %rdi
movl -0x8(%rbp), %edx
leaq 0x984(%rip), %rsi       # 0x20eb
movb $0x0, %al
callq 0x1130
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
jmp 0x17af
movq -0x10(%rbp), %rdi
callq 0x1160
movl %eax, %ecx
xorl %eax, %eax
cmpl %ecx, %eax
jne 0x178a
jmp 0x17a0
movq -0x10(%rbp), %rdi
callq 0x1060
movq %rax, -0x20(%rbp)
movq -0x20(%rbp), %rax
movl (%rax), %eax
movl %eax, -0x24(%rbp)
movq -0x10(%rbp), %rdi
callq 0x1030
movl -0x24(%rbp), %eax
movl %eax, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x30, %rsp
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O0/diaxen[P]fft-garden/./twiddles.h
// Function: get_twiddle
static inline complex double
get_twiddle(unsigned i, unsigned log2_N)
{
#if defined(NO_TW)
  return cexp(-2 * M_PI * I * i / (1 << log2_N));

#elif defined(SHORT_TW)
  unsigned m = 1 << (log2_N - 3);
  unsigned q = i & (m - 1);

  i >>= log2_N - 3;

  if (i & 1)
    q = m - q;

  /*
     i == 0 : ( r,  i)
     i == 1 : (-i, -r)
     i == 2 : ( i, -r)
     i == 3 : (-r,  i)
  */

  switch (sizeof(twiddles[0]))
    {
    case 16: {
      union {
        double d;
        uint64_t u;
      } vr, vi;

      uint64_t nw = (i ^ (i >> 1)) & 1;
      uint64_t *x = (uint64_t*)(twiddles + q);
      vi.u = x[nw ^ 1] ^ (nw << 63);
      vr.u = x[nw] ^ ((i & 1ULL) << 63);

      return CMPLX(vr.d, vi.d);
    }

    case 8: {
      union {
        float d;
        uint32_t u;
      } vr, vi;

      uint32_t nw = (i ^ (i >> 1)) & 1;
      uint32_t *x = (uint32_t*)(twiddles + q);
      vi.u = x[nw ^ 1] ^ (nw << 31);
      vr.u = x[nw] ^ ((i & 1) << 31);

      return CMPLXF(vr.d, vi.d);
    }

    }

#else

  return twiddles[i];

#endif
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movl %edi, -0x14(%rbp)
movl %esi, -0x18(%rbp)
movl -0x18(%rbp), %ecx
subl $0x3, %ecx
movl $0x1, %eax
shll %cl, %eax
movl %eax, -0x1c(%rbp)
movl -0x14(%rbp), %eax
movl -0x1c(%rbp), %ecx
subl $0x1, %ecx
andl %ecx, %eax
movl %eax, -0x20(%rbp)
movl -0x18(%rbp), %ecx
subl $0x3, %ecx
movl -0x14(%rbp), %eax
shrl %cl, %eax
movl %eax, -0x14(%rbp)
movl -0x14(%rbp), %eax
andl $0x1, %eax
cmpl $0x0, %eax
je 0x2b9a
movl -0x1c(%rbp), %eax
subl -0x20(%rbp), %eax
movl %eax, -0x20(%rbp)
movl -0x14(%rbp), %eax
movl %eax, %ecx
shrl %ecx
xorl %ecx, %eax
andl $0x1, %eax
movq %rax, -0x38(%rbp)
leaq 0x34c7(%rip), %rax      # 0x6078
movq (%rax), %rax
movl -0x20(%rbp), %ecx
shlq $0x4, %rcx
addq %rcx, %rax
movq %rax, -0x40(%rbp)
movq -0x40(%rbp), %rax
movq -0x38(%rbp), %rcx
movq %rcx, %rdx
xorq $0x1, %rdx
movq (%rax,%rdx,8), %rax
shlq $0x3f, %rcx
xorq %rcx, %rax
movq %rax, -0x30(%rbp)
movq -0x40(%rbp), %rax
movq -0x38(%rbp), %rcx
movq (%rax,%rcx,8), %rax
movl -0x14(%rbp), %ecx
shlq $0x3f, %rcx
xorq %rcx, %rax
movq %rax, -0x28(%rbp)
movsd -0x28(%rbp), %xmm1
movsd -0x30(%rbp), %xmm0
movsd %xmm1, -0x50(%rbp)
movsd %xmm0, -0x48(%rbp)
movsd -0x50(%rbp), %xmm1
movsd -0x48(%rbp), %xmm0
movsd %xmm1, -0x10(%rbp)
movsd %xmm0, -0x8(%rbp)
movsd -0x10(%rbp), %xmm0
movsd -0x8(%rbp), %xmm1
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/nh13[P]ksw/src/ksw2/kalloc.c
// Function: km_destroy
void km_destroy(void *_km)
{
	kmem_t *km = (kmem_t*)_km;
	allocated_t *p, *q;
	if (km == 0) return;
	p = &km->list_head;
	do {
		q = p->next;
		free(p->ptr);
		if (p != &km->list_head) free(p);
		p = q;
	} while (p && p->next);
	if (p != &km->list_head) free(p);
	free(km);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x10(%rbp)
cmpq $0x0, -0x10(%rbp)
jne 0x19e360
jmp 0x19e3ea
movq -0x10(%rbp), %rax
addq $0x18, %rax
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x20(%rbp)
movq -0x18(%rbp), %rax
movq 0x8(%rax), %rdi
callq 0x19e120
movq -0x18(%rbp), %rax
movq -0x10(%rbp), %rcx
addq $0x18, %rcx
cmpq %rcx, %rax
je 0x19e39e
movq -0x18(%rbp), %rdi
callq 0x19e120
movq -0x20(%rbp), %rax
movq %rax, -0x18(%rbp)
xorl %eax, %eax
cmpq $0x0, -0x18(%rbp)
movb %al, -0x21(%rbp)
je 0x19e3c0
movq -0x18(%rbp), %rax
cmpq $0x0, (%rax)
setne %al
movb %al, -0x21(%rbp)
movb -0x21(%rbp), %al
testb $0x1, %al
jne 0x19e36c
movq -0x18(%rbp), %rax
movq -0x10(%rbp), %rcx
addq $0x18, %rcx
cmpq %rcx, %rax
je 0x19e3e1
movq -0x18(%rbp), %rdi
callq 0x19e120
movq -0x10(%rbp), %rdi
callq 0x19e120
addq $0x30, %rsp
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O0/nh13[P]ksw/src/ksw2/kalloc.c
// Function: krealloc
void *krealloc(void *_km, void *ap, size_t n_bytes)
{
	kmem_t *km = (kmem_t*)_km;
	size_t n_units, *p, *q;

	if (n_bytes == 0) {
		kfree(km, ap); return 0;
	}
	if (km == 0) return realloc(ap, n_bytes);
	if (!ap) return kmalloc(km, n_bytes);
	n_units = 1 + (n_bytes + sizeof(size_t) - 1) / sizeof(size_t);
	p = (size_t*)ap - 1;
	if (*p >= n_units) return ap; /* TODO: this prevents shrinking */
	q = (size_t*)kmalloc(km, n_bytes);
	memcpy(q, ap, (*p - 1) * sizeof(size_t));
	kfree(km, ap);
	return q;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x28(%rbp)
cmpq $0x0, -0x20(%rbp)
jne 0x19e65d
movq -0x28(%rbp), %rdi
movq -0x18(%rbp), %rsi
callq 0x19e3f0
movq $0x0, -0x8(%rbp)
jmp 0x19e711
cmpq $0x0, -0x28(%rbp)
jne 0x19e67a
movq -0x18(%rbp), %rdi
movq -0x20(%rbp), %rsi
callq 0x19e1f0
movq %rax, -0x8(%rbp)
jmp 0x19e711
cmpq $0x0, -0x18(%rbp)
jne 0x19e694
movq -0x28(%rbp), %rdi
movq -0x20(%rbp), %rsi
callq 0x19e720
movq %rax, -0x8(%rbp)
jmp 0x19e711
movq -0x20(%rbp), %rax
addq $0x8, %rax
subq $0x1, %rax
shrq $0x3, %rax
addq $0x1, %rax
movq %rax, -0x30(%rbp)
movq -0x18(%rbp), %rax
addq $-0x8, %rax
movq %rax, -0x38(%rbp)
movq -0x38(%rbp), %rax
movq (%rax), %rax
cmpq -0x30(%rbp), %rax
jb 0x19e6cf
movq -0x18(%rbp), %rax
movq %rax, -0x8(%rbp)
jmp 0x19e711
movq -0x28(%rbp), %rdi
movq -0x20(%rbp), %rsi
callq 0x19e720
movq %rax, -0x40(%rbp)
movq -0x40(%rbp), %rdi
movq -0x18(%rbp), %rsi
movq -0x38(%rbp), %rax
movq (%rax), %rdx
subq $0x1, %rdx
shlq $0x3, %rdx
callq 0x19e0a0
movq -0x28(%rbp), %rdi
movq -0x18(%rbp), %rsi
callq 0x19e3f0
movq -0x40(%rbp), %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x40, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/nh13[P]ksw/src/ksw2/kalloc.c
// Function: morecore
static size_t *morecore(kmem_t *km, size_t nu)
{
	size_t rnu, *up;

	rnu = (nu + 0xfffff) & (~(size_t)0xfffff);
	up = (size_t*)malloc(rnu * sizeof(size_t));
	if (!up) { /* fail to allocate memory */
		km_stat(km);
		fprintf(stderr, "[morecore] %lu bytes requested but not available.\n", rnu * sizeof(size_t));
		exit(1);
	}
	/* put the pointer in km->list_head */
	if (km->list_tail == 0) km->list_tail = &km->list_head;
	km->list_tail->ptr = up;
	km->list_tail->next = (allocated_t*)calloc(1, sizeof(allocated_t));
	km->list_tail = km->list_tail->next;

	km->total_allocated += rnu * sizeof(size_t);
	*up = rnu; /* the size of the current block, and in this case the block is the same as the new core */
	kfree(km, up + 1); /* initialize the new "core" */
	return km->loop_head;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x10(%rbp), %rax
addq $0xfffff, %rax          # imm = 0xFFFFF
andq $-0x100000, %rax        # imm = 0xFFF00000
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rdi
shlq $0x3, %rdi
callq 0x19e150
movq %rax, -0x20(%rbp)
cmpq $0x0, -0x20(%rbp)
jne 0x19e91f
movq -0x8(%rbp), %rdi
callq 0x19ea50
movq 0xc886dc(%rip), %rax    # 0xe26fd8
movq (%rax), %rdi
movq -0x18(%rbp), %rdx
shlq $0x3, %rdx
leaq 0xaee807(%rip), %rsi    # 0xc8d115
movb $0x0, %al
callq 0x19e180
movl $0x1, %edi
callq 0x19e130
movq -0x8(%rbp), %rax
cmpq $0x0, 0x28(%rax)
jne 0x19e93a
movq -0x8(%rbp), %rcx
addq $0x18, %rcx
movq -0x8(%rbp), %rax
movq %rcx, 0x28(%rax)
movq -0x20(%rbp), %rcx
movq -0x8(%rbp), %rax
movq 0x28(%rax), %rax
movq %rcx, 0x8(%rax)
movl $0x1, %edi
movl $0x10, %esi
callq 0x19e090
movq %rax, %rcx
movq -0x8(%rbp), %rax
movq 0x28(%rax), %rax
movq %rcx, (%rax)
movq -0x8(%rbp), %rax
movq 0x28(%rax), %rax
movq (%rax), %rcx
movq -0x8(%rbp), %rax
movq %rcx, 0x28(%rax)
movq -0x18(%rbp), %rcx
shlq $0x3, %rcx
movq -0x8(%rbp), %rax
addq 0x30(%rax), %rcx
movq %rcx, 0x30(%rax)
movq -0x18(%rbp), %rcx
movq -0x20(%rbp), %rax
movq %rcx, (%rax)
movq -0x8(%rbp), %rdi
movq -0x20(%rbp), %rsi
addq $0x8, %rsi
callq 0x19e3f0
movq -0x8(%rbp), %rax
movq 0x10(%rax), %rax
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/nh13[P]ksw/src/ksw2/kalloc.c
// Function: kcalloc
void *kcalloc(void *_km, size_t count, size_t size)
{
	kmem_t *km = (kmem_t*)_km;
	void *p;
	if (size == 0 || count == 0) return 0;
	if (km == 0) return calloc(count, size);
	p = kmalloc(km, count * size);
	memset(p, 0, count * size);
	return p;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x28(%rbp)
cmpq $0x0, -0x20(%rbp)
je 0x19e9ea
cmpq $0x0, -0x18(%rbp)
jne 0x19e9f4
movq $0x0, -0x8(%rbp)
jmp 0x19ea40
cmpq $0x0, -0x28(%rbp)
jne 0x19ea0e
movq -0x18(%rbp), %rdi
movq -0x20(%rbp), %rsi
callq 0x19e090
movq %rax, -0x8(%rbp)
jmp 0x19ea40
movq -0x28(%rbp), %rdi
movq -0x18(%rbp), %rsi
imulq -0x20(%rbp), %rsi
callq 0x19e720
movq %rax, -0x30(%rbp)
movq -0x30(%rbp), %rdi
movq -0x18(%rbp), %rdx
imulq -0x20(%rbp), %rdx
xorl %esi, %esi
callq 0x19e070
movq -0x30(%rbp), %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x30, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/nh13[P]ksw/src/ksw2/kalloc.c
// Function: km_stat
void km_stat(const void *_km)
{
	kmem_t *km = (kmem_t*)_km;
	unsigned n_blocks, n_units;
	size_t max_block = 0, *p, *q;
	float frag;

	if (km == 0 || !(p = km->loop_head)) return;
	n_blocks = n_units = 0;
	do {
		q = PTR(p);
		if (*p > max_block) max_block = *p;
		n_units += *p;
		if (p + (*p) > q && q > p)
			kerror("[kr_stat] The end of a free block enters another free block.");
		p = q;
		++n_blocks;
	} while (p != km->loop_head);
	
	--n_blocks;
	frag = 1.0/1024.0 * n_units * sizeof(size_t) / n_blocks;
	fprintf(stderr, "[kr_stat] tot=%lu, free=%lu, n_block=%u, max_block=%lu, frag_len=%.3fK\n",
			km->total_allocated, n_units * sizeof(size_t), n_blocks, max_block * sizeof(size_t), frag);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x10(%rbp)
movq $0x0, -0x20(%rbp)
cmpq $0x0, -0x10(%rbp)
je 0x19ea85
movq -0x10(%rbp), %rax
movq 0x10(%rax), %rax
movq %rax, -0x28(%rbp)
cmpq $0x0, %rax
jne 0x19ea8a
jmp 0x19eb98
movl $0x0, -0x18(%rbp)
movl $0x0, -0x14(%rbp)
movq -0x28(%rbp), %rax
movq 0x8(%rax), %rax
movq %rax, -0x30(%rbp)
movq -0x28(%rbp), %rax
movq (%rax), %rax
cmpq -0x20(%rbp), %rax
jbe 0x19eabc
movq -0x28(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x20(%rbp)
movq -0x28(%rbp), %rax
movq (%rax), %rcx
movl -0x18(%rbp), %eax
addq %rcx, %rax
movl %eax, -0x18(%rbp)
movq -0x28(%rbp), %rax
movq -0x28(%rbp), %rcx
movq (%rcx), %rcx
shlq $0x3, %rcx
addq %rcx, %rax
cmpq -0x30(%rbp), %rax
jbe 0x19eafa
movq -0x30(%rbp), %rax
cmpq -0x28(%rbp), %rax
jbe 0x19eafa
leaq 0xaee59b(%rip), %rdi    # 0xc8d090
callq 0x19e5e0
movq -0x30(%rbp), %rax
movq %rax, -0x28(%rbp)
movl -0x14(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x14(%rbp)
movq -0x28(%rbp), %rax
movq -0x10(%rbp), %rcx
cmpq 0x10(%rcx), %rax
jne 0x19ea98
movl -0x14(%rbp), %eax
decl %eax
movl %eax, -0x14(%rbp)
movl -0x18(%rbp), %eax
cvtsi2sd %rax, %xmm0
movsd 0xaee4d3(%rip), %xmm1   # 0xc8d008
mulsd %xmm1, %xmm0
movsd 0xaee4cf(%rip), %xmm1   # 0xc8d010
mulsd %xmm1, %xmm0
movl -0x14(%rbp), %eax
cvtsi2sd %rax, %xmm1
divsd %xmm1, %xmm0
cvtsd2ss %xmm0, %xmm0
movss %xmm0, -0x34(%rbp)
movq 0xc88477(%rip), %rax    # 0xe26fd8
movq (%rax), %rdi
movq -0x10(%rbp), %rax
movq 0x30(%rax), %rdx
movl -0x18(%rbp), %eax
movl %eax, %ecx
shlq $0x3, %rcx
movl -0x14(%rbp), %r8d
movq -0x20(%rbp), %r9
shlq $0x3, %r9
movss -0x34(%rbp), %xmm0
cvtss2sd %xmm0, %xmm0
leaq 0xaee53c(%rip), %rsi    # 0xc8d0cd
movb $0x1, %al
callq 0x19e180
addq $0x40, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/nh13[P]ksw/src/ksw2/./ksw2.h
// Function: ksw_apply_zdrop
static inline int ksw_apply_zdrop(ksw_extz_t *ez, int is_rot, int32_t H, int a, int b, int zdrop, int8_t e)
{
	int r, t;
	if (is_rot) r = a, t = b;
	else r = a + b, t = a;
	if (H > (int32_t)ez->max) {
		ez->max = H, ez->max_t = t, ez->max_q = r - t;
	} else if (t >= ez->max_t && r - t >= ez->max_q) {
		int tl = t - ez->max_t, ql = (r - t) - ez->max_q, l;
		l = tl > ql? tl - ql : ql - tl;
		if (zdrop >= 0 && ez->max - H > zdrop + l * e) {
			ez->zdropped = 1;
			return 1;
		}
	}
	return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movb 0x10(%rbp), %al
movq %rdi, -0x10(%rbp)
movl %esi, -0x14(%rbp)
movl %edx, -0x18(%rbp)
movl %ecx, -0x1c(%rbp)
movl %r8d, -0x20(%rbp)
movl %r9d, -0x24(%rbp)
cmpl $0x0, -0x14(%rbp)
je 0x1a0130
movl -0x1c(%rbp), %eax
movl %eax, -0x28(%rbp)
movl -0x20(%rbp), %eax
movl %eax, -0x2c(%rbp)
jmp 0x1a013f
movl -0x1c(%rbp), %eax
addl -0x20(%rbp), %eax
movl %eax, -0x28(%rbp)
movl -0x1c(%rbp), %eax
movl %eax, -0x2c(%rbp)
movl -0x18(%rbp), %eax
movq -0x10(%rbp), %rcx
movl (%rcx), %ecx
andl $0x7fffffff, %ecx       # imm = 0x7FFFFFFF
cmpl %ecx, %eax
jle 0x1a0187
movl -0x18(%rbp), %edx
movq -0x10(%rbp), %rax
movl (%rax), %ecx
andl $0x7fffffff, %edx       # imm = 0x7FFFFFFF
andl $0x80000000, %ecx       # imm = 0x80000000
orl %edx, %ecx
movl %ecx, (%rax)
movl -0x2c(%rbp), %ecx
movq -0x10(%rbp), %rax
movl %ecx, 0x8(%rax)
movl -0x28(%rbp), %ecx
subl -0x2c(%rbp), %ecx
movq -0x10(%rbp), %rax
movl %ecx, 0x4(%rax)
jmp 0x1a0231
movl -0x2c(%rbp), %eax
movq -0x10(%rbp), %rcx
cmpl 0x8(%rcx), %eax
jl 0x1a022f
movl -0x28(%rbp), %eax
subl -0x2c(%rbp), %eax
movq -0x10(%rbp), %rcx
cmpl 0x4(%rcx), %eax
jl 0x1a022f
movl -0x2c(%rbp), %eax
movq -0x10(%rbp), %rcx
subl 0x8(%rcx), %eax
movl %eax, -0x30(%rbp)
movl -0x28(%rbp), %eax
subl -0x2c(%rbp), %eax
movq -0x10(%rbp), %rcx
subl 0x4(%rcx), %eax
movl %eax, -0x34(%rbp)
movl -0x30(%rbp), %eax
cmpl -0x34(%rbp), %eax
jle 0x1a01da
movl -0x30(%rbp), %eax
subl -0x34(%rbp), %eax
movl %eax, -0x3c(%rbp)
jmp 0x1a01e3
movl -0x34(%rbp), %eax
subl -0x30(%rbp), %eax
movl %eax, -0x3c(%rbp)
movl -0x3c(%rbp), %eax
movl %eax, -0x38(%rbp)
cmpl $0x0, -0x24(%rbp)
jl 0x1a022d
movq -0x10(%rbp), %rax
movl (%rax), %eax
andl $0x7fffffff, %eax       # imm = 0x7FFFFFFF
subl -0x18(%rbp), %eax
movl -0x24(%rbp), %ecx
movl -0x38(%rbp), %edx
movsbl 0x10(%rbp), %esi
imull %esi, %edx
addl %edx, %ecx
cmpl %ecx, %eax
jle 0x1a022d
movq -0x10(%rbp), %rax
movl (%rax), %ecx
andl $0x7fffffff, %ecx       # imm = 0x7FFFFFFF
orl $0x80000000, %ecx       # imm = 0x80000000
movl %ecx, (%rax)
movl $0x1, -0x4(%rbp)
jmp 0x1a0238
jmp 0x1a022f
jmp 0x1a0231
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/nh13[P]ksw/src/ksw2/./ksw2.h
// Function: ksw_push_cigar
static inline uint32_t *ksw_push_cigar(void *km, int *n_cigar, int *m_cigar, uint32_t *cigar, uint32_t op, int len)
{
	if (*n_cigar == 0 || op != (cigar[(*n_cigar) - 1]&0xf)) {
		if (*n_cigar == *m_cigar) {
			*m_cigar = *m_cigar? (*m_cigar)<<1 : 4;
			cigar = (uint32_t*)krealloc(km, cigar, (*m_cigar) << 2);
		}
		cigar[(*n_cigar)++] = len<<4 | op;
	} else cigar[(*n_cigar)-1] += len<<4;
	return cigar;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq %rcx, -0x20(%rbp)
movl %r8d, -0x24(%rbp)
movl %r9d, -0x28(%rbp)
movq -0x10(%rbp), %rax
cmpl $0x0, (%rax)
je 0x1a0626
movl -0x24(%rbp), %eax
movq -0x20(%rbp), %rcx
movq -0x10(%rbp), %rdx
movl (%rdx), %edx
subl $0x1, %edx
movslq %edx, %rdx
movl (%rcx,%rdx,4), %ecx
andl $0xf, %ecx
cmpl %ecx, %eax
je 0x1a069c
movq -0x10(%rbp), %rax
movl (%rax), %eax
movq -0x18(%rbp), %rcx
cmpl (%rcx), %eax
jne 0x1a067a
movq -0x18(%rbp), %rax
cmpl $0x0, (%rax)
je 0x1a064a
movq -0x18(%rbp), %rax
movl (%rax), %eax
shll %eax
movl %eax, -0x2c(%rbp)
jmp 0x1a0654
movl $0x4, %eax
movl %eax, -0x2c(%rbp)
jmp 0x1a0654
movl -0x2c(%rbp), %ecx
movq -0x18(%rbp), %rax
movl %ecx, (%rax)
movq -0x8(%rbp), %rdi
movq -0x20(%rbp), %rsi
movq -0x18(%rbp), %rax
movl (%rax), %eax
shll $0x2, %eax
movslq %eax, %rdx
callq 0x19e620
movq %rax, -0x20(%rbp)
movl -0x28(%rbp), %edx
shll $0x4, %edx
orl -0x24(%rbp), %edx
movq -0x20(%rbp), %rax
movq -0x10(%rbp), %rsi
movl (%rsi), %ecx
movl %ecx, %edi
addl $0x1, %edi
movl %edi, (%rsi)
movslq %ecx, %rcx
movl %edx, (%rax,%rcx,4)
jmp 0x1a06b8
movl -0x28(%rbp), %edx
shll $0x4, %edx
movq -0x20(%rbp), %rax
movq -0x10(%rbp), %rcx
movl (%rcx), %ecx
subl $0x1, %ecx
movslq %ecx, %rcx
addl (%rax,%rcx,4), %edx
movl %edx, (%rax,%rcx,4)
movq -0x20(%rbp), %rax
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/nh13[P]ksw/src/main.c
// Function: fill_matrix
void fill_matrix(int8_t *matrix, char *fn) {
	FILE *fp = fopen(fn, "r");
	char buffer[256];
	char *pch;
	int i = 0;

	while (0 < fgets(buffer, 256, fp)) {
		pch = strtok(buffer, ",\t");
		while (pch != NULL) {
			if (25 <= i) {
				fprintf(stderr, "Too many values in %s\n", fn);
				exit(1);
			}
			matrix[i] = atoi(pch);
			i++;
		}
	}
	if (i != 16 || i != 25) {
		fprintf(stderr, "Incorrect # of values (found %d, want 16 or 25) in %s\n", i, fn);
		exit(1);
	}

	fclose(fp);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x130, %rsp            # imm = 0x130
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x10(%rbp), %rdi
leaq 0xad64b5(%rip), %rsi    # 0xc8dce3
callq 0x19e110
movq %rax, -0x18(%rbp)
movl $0x0, -0x12c(%rbp)
leaq -0x120(%rbp), %rdi
movq -0x18(%rbp), %rdx
movl $0x100, %esi            # imm = 0x100
callq 0x19e1d0
movq %rax, %rcx
xorl %eax, %eax
cmpq %rcx, %rax
jae 0x1b78ed
leaq -0x120(%rbp), %rdi
leaq 0xad5c42(%rip), %rsi    # 0xc8d4b4
callq 0x19e1c0
movq %rax, -0x128(%rbp)
cmpq $0x0, -0x128(%rbp)
je 0x1b78e8
movl $0x19, %eax
cmpl -0x12c(%rbp), %eax
jg 0x1b78bb
movq 0xc6f73c(%rip), %rax    # 0xe26fd8
movq (%rax), %rdi
movq -0x10(%rbp), %rdx
leaq 0xad5c0d(%rip), %rsi    # 0xc8d4b7
movb $0x0, %al
callq 0x19e180
movl $0x1, %edi
callq 0x19e130
movq -0x128(%rbp), %rdi
callq 0x19e1b0
movb %al, %dl
movq -0x8(%rbp), %rax
movslq -0x12c(%rbp), %rcx
movb %dl, (%rax,%rcx)
movl -0x12c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x12c(%rbp)
jmp 0x1b787e
jmp 0x1b7841
cmpl $0x10, -0x12c(%rbp)
jne 0x1b78ff
cmpl $0x19, -0x12c(%rbp)
je 0x1b792b
movq 0xc6f6d2(%rip), %rax    # 0xe26fd8
movq (%rax), %rdi
movl -0x12c(%rbp), %edx
movq -0x10(%rbp), %rcx
leaq 0xad5bb4(%rip), %rsi    # 0xc8d4ce
movb $0x0, %al
callq 0x19e180
movl $0x1, %edi
callq 0x19e130
movq -0x18(%rbp), %rdi
callq 0x19e0d0
addq $0x130, %rsp            # imm = 0x130
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/nh13[P]ksw/src/main.c
// Function: alignment_mode_to_str
char *alignment_mode_to_str(int mode)
{
	switch (mode) {
		case Local: return "local";
		case Glocal: return "glocal";
		case Extension: return "extend";
		case Global: return "global";
		default: return "unknown";
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movl %edi, -0xc(%rbp)
movl -0xc(%rbp), %eax
movq %rax, -0x18(%rbp)
subq $0x3, %rax
ja 0x1b799c
movq -0x18(%rbp), %rax
leaq 0xad59f5(%rip), %rcx    # 0xc8d354
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
leaq 0xad5b97(%rip), %rax    # 0xc8d506
movq %rax, -0x8(%rbp)
jmp 0x1b79a7
leaq 0xad5b89(%rip), %rax    # 0xc8d505
movq %rax, -0x8(%rbp)
jmp 0x1b79a7
leaq 0xad5b83(%rip), %rax    # 0xc8d50c
movq %rax, -0x8(%rbp)
jmp 0x1b79a7
leaq 0xad5b7d(%rip), %rax    # 0xc8d513
movq %rax, -0x8(%rbp)
jmp 0x1b79a7
leaq 0xad5b77(%rip), %rax    # 0xc8d51a
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/nh13[P]ksw/src/main.c
// Function: library_to_str
char *library_to_str(int mode)
{
	switch (mode) {
		case AutoLibrary: return "auto";
		case Ksw2: return "ksw2";
		case Parasail: return "parasail";
		default: return "unknown";
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movl %edi, -0xc(%rbp)
movl -0xc(%rbp), %eax
movl %eax, -0x10(%rbp)
testl %eax, %eax
je 0x1b79d7
jmp 0x1b79c3
movl -0x10(%rbp), %eax
subl $0x1, %eax
je 0x1b79e4
jmp 0x1b79cd
movl -0x10(%rbp), %eax
subl $0x2, %eax
je 0x1b79f1
jmp 0x1b79fe
leaq 0xad5b44(%rip), %rax    # 0xc8d522
movq %rax, -0x8(%rbp)
jmp 0x1b7a09
leaq 0xad5e93(%rip), %rax    # 0xc8d87e
movq %rax, -0x8(%rbp)
jmp 0x1b7a09
leaq 0xad5b2f(%rip), %rax    # 0xc8d527
movq %rax, -0x8(%rbp)
jmp 0x1b7a09
leaq 0xad5b15(%rip), %rax    # 0xc8d51a
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/nh13[P]ksw/src/main.c
// Function: ksw2_data_init
ksw2_data_t *ksw2_data_init(main_opt_t *opt, const int8_t *matrix)
{
	ksw2_data_t *data = calloc(1, sizeof(ksw2_data_t));

	data->ksw2_flags = (opt->right_align_gaps == 1) ? KSW_EZ_RIGHT : 0;
	if (opt->add_cigar != 1) data->ksw2_flags |= KSW_EZ_SCORE_ONLY;
	memset(&data->ez, 0, sizeof(ksw_extz_t));
	
	//data->km = km_init(); FIXME

	data->matrix = calloc(1, sizeof(int8_t)*25);
	memcpy(data->matrix, matrix, sizeof(int8_t)*25);
	
	return data;

}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl $0x1, %edi
movl $0x48, %esi
callq 0x19e090
movq %rax, -0x18(%rbp)
movq -0x8(%rbp), %rax
movl 0x30(%rax), %edx
xorl %ecx, %ecx
movl $0x2, %eax
cmpl $0x1, %edx
cmovel %eax, %ecx
movq -0x18(%rbp), %rax
movl %ecx, 0x8(%rax)
movq -0x8(%rbp), %rax
cmpl $0x1, 0x24(%rax)
je 0x1b7a65
movq -0x18(%rbp), %rax
movl 0x8(%rax), %ecx
orl $0x1, %ecx
movl %ecx, 0x8(%rax)
movq -0x18(%rbp), %rdi
addq $0x10, %rdi
xorl %esi, %esi
movl $0x30, %edx
callq 0x19e070
movl $0x1, %edi
movl $0x19, %esi
callq 0x19e090
movq %rax, %rcx
movq -0x18(%rbp), %rax
movq %rcx, (%rax)
movq -0x18(%rbp), %rax
movq (%rax), %rax
movq -0x10(%rbp), %rcx
movq (%rcx), %rdx
movq %rdx, (%rax)
movq 0x8(%rcx), %rdx
movq %rdx, 0x8(%rax)
movq 0x10(%rcx), %rdx
movq %rdx, 0x10(%rax)
movb 0x18(%rcx), %cl
movb %cl, 0x18(%rax)
movq -0x18(%rbp), %rax
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/nh13[P]ksw/src/main.c
// Function: parasail_to_func_name
void parasail_to_func_name(char *parasail_func_name, int alignment_mode, int add_cigar, int vec_strategy)
{
	parasail_func_name[0] = '\0';
	strcat(parasail_func_name, "parasail");


	// Vectorized
	switch (alignment_mode) {
		case Local: strcat(parasail_func_name, "_sw"); break; // local
		case Glocal: strcat(parasail_func_name, "_sg_dx"); break; // glocal
		case Extension: fprintf(stderr, "Parasail does not support extension\n"); exit(1);
		case Global: strcat(parasail_func_name, "_nw"); break; // global
		default: fprintf(stderr, "Unknown alignment mode: %d\n", alignment_mode); exit(1);
	}
	if (add_cigar == 1) strcat(parasail_func_name, "_trace");
	switch (vec_strategy) {
		case 0: strcat(parasail_func_name, "_striped"); break;
		case 1: strcat(parasail_func_name, "_scan"); break;
		case 2: strcat(parasail_func_name, "_diag"); break;
		default: fprintf(stderr, "Unknown parasail vectorization strategy: %d\n", vec_strategy); exit(1);
	}
	strcat(parasail_func_name, "_32"); // TODO: add this as a command line option?
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movl %edx, -0x10(%rbp)
movl %ecx, -0x14(%rbp)
movq -0x8(%rbp), %rax
movb $0x0, (%rax)
movq -0x8(%rbp), %rdi
leaq 0xad59f0(%rip), %rsi    # 0xc8d527
callq 0x19e200
movl -0xc(%rbp), %eax
movq %rax, -0x20(%rbp)
subq $0x3, %rax
ja 0x1b7bb5
movq -0x20(%rbp), %rax
leaq 0xad5810(%rip), %rcx    # 0xc8d364
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
movq -0x8(%rbp), %rdi
leaq 0xad70dd(%rip), %rsi    # 0xc8ec45
callq 0x19e200
jmp 0x1b7bda
movq -0x8(%rbp), %rdi
leaq 0xad9cbd(%rip), %rsi    # 0xc91837
callq 0x19e200
jmp 0x1b7bda
movq 0xc6f450(%rip), %rax    # 0xe26fd8
movq (%rax), %rdi
leaq 0xad599e(%rip), %rsi    # 0xc8d530
movb $0x0, %al
callq 0x19e180
movl $0x1, %edi
callq 0x19e130
movq -0x8(%rbp), %rdi
leaq 0xad631c(%rip), %rsi    # 0xc8deca
callq 0x19e200
jmp 0x1b7bda
movq 0xc6f41c(%rip), %rax    # 0xe26fd8
movq (%rax), %rdi
movl -0xc(%rbp), %edx
leaq 0xad598c(%rip), %rsi    # 0xc8d555
movb $0x0, %al
callq 0x19e180
movl $0x1, %edi
callq 0x19e130
cmpl $0x1, -0x10(%rbp)
jne 0x1b7bf0
movq -0x8(%rbp), %rdi
leaq 0xb094de(%rip), %rsi    # 0xcc10c9
callq 0x19e200
movl -0x14(%rbp), %eax
movl %eax, -0x24(%rbp)
testl %eax, %eax
je 0x1b7c10
jmp 0x1b7bfc
movl -0x24(%rbp), %eax
subl $0x1, %eax
je 0x1b7c22
jmp 0x1b7c06
movl -0x24(%rbp), %eax
subl $0x2, %eax
je 0x1b7c34
jmp 0x1b7c46
movq -0x8(%rbp), %rdi
leaq 0xb3460b(%rip), %rsi    # 0xcec226
callq 0x19e200
jmp 0x1b7c6b
movq -0x8(%rbp), %rdi
leaq 0xadb3ce(%rip), %rsi    # 0xc92ffb
callq 0x19e200
jmp 0x1b7c6b
movq -0x8(%rbp), %rdi
leaq 0xb34602(%rip), %rsi    # 0xcec241
callq 0x19e200
jmp 0x1b7c6b
movq 0xc6f38b(%rip), %rax    # 0xe26fd8
movq (%rax), %rdi
movl -0x14(%rbp), %edx
leaq 0xad5917(%rip), %rsi    # 0xc8d571
movb $0x0, %al
callq 0x19e180
movl $0x1, %edi
callq 0x19e130
movq -0x8(%rbp), %rdi
leaq 0xadb8c9(%rip), %rsi    # 0xc9353f
callq 0x19e200
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/nh13[P]ksw/src/main.c
// Function: parasail_data_init
parasail_data_t *parasail_data_init(main_opt_t *opt, const int8_t *matrix)
{
	int i, j, l;
	parasail_data_t *data = calloc(1, sizeof(parasail_data_t));
	char parasail_func_name[128];
	
	// create a matrix, don't care about the valukes
	data->matrix = parasail_matrix_create("ACGTN", matrix[0], matrix[1]); 
	// update the matrix with the correct values
	for (i = l = 0; i < 5; ++i) {
		for (j = 0; j < 5; ++j, ++l) {
			parasail_matrix_set_value(data->matrix, i, j, matrix[l]);
		}
	}

	parasail_to_func_name(parasail_func_name, opt->alignment_mode, opt->add_cigar, opt->parasail_vec_strat);
	data->func = parasail_lookup_function(parasail_func_name);

	// the global alignment function is needed for glocal when we don't align the full query
	if (opt->alignment_mode == Glocal) {
		data->func_global = data->func;
	}
	else {
		parasail_to_func_name(parasail_func_name, Global, opt->add_cigar, opt->parasail_vec_strat);
		data->func_global = parasail_lookup_function(parasail_func_name);
	}

	return data;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0xb0, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl $0x1, %edi
movl $0x18, %esi
callq 0x19e090
movq %rax, -0x28(%rbp)
movq -0x10(%rbp), %rax
movsbl (%rax), %esi
movq -0x10(%rbp), %rax
movsbl 0x1(%rax), %edx
leaq 0xad58d2(%rip), %rdi    # 0xc8d59e
callq 0x1c4850
movq %rax, %rcx
movq -0x28(%rbp), %rax
movq %rcx, (%rax)
movl $0x0, -0x1c(%rbp)
movl $0x0, -0x14(%rbp)
cmpl $0x5, -0x14(%rbp)
jge 0x1b7d3b
movl $0x0, -0x18(%rbp)
cmpl $0x5, -0x18(%rbp)
jge 0x1b7d2e
movq -0x28(%rbp), %rax
movq (%rax), %rdi
movl -0x14(%rbp), %esi
movl -0x18(%rbp), %edx
movq -0x10(%rbp), %rax
movslq -0x1c(%rbp), %rcx
movsbl (%rax,%rcx), %ecx
callq 0x1c5b70
movl -0x18(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x18(%rbp)
movl -0x1c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x1c(%rbp)
jmp 0x1b7cf6
jmp 0x1b7d30
movl -0x14(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x14(%rbp)
jmp 0x1b7ce9
leaq -0xb0(%rbp), %rdi
movq -0x8(%rbp), %rax
movl 0x20(%rax), %esi
movq -0x8(%rbp), %rax
movl 0x24(%rax), %edx
movq -0x8(%rbp), %rax
movl 0x3c(%rax), %ecx
callq 0x1b7b10
leaq -0xb0(%rbp), %rdi
callq 0x1c30c0
movq %rax, %rcx
movq -0x28(%rbp), %rax
movq %rcx, 0x8(%rax)
movq -0x8(%rbp), %rax
cmpl $0x1, 0x20(%rax)
jne 0x1b7d8f
movq -0x28(%rbp), %rax
movq 0x8(%rax), %rcx
movq -0x28(%rbp), %rax
movq %rcx, 0x10(%rax)
jmp 0x1b7dc5
leaq -0xb0(%rbp), %rdi
movq -0x8(%rbp), %rax
movl 0x24(%rax), %edx
movq -0x8(%rbp), %rax
movl 0x3c(%rax), %ecx
movl $0x3, %esi
callq 0x1b7b10
leaq -0xb0(%rbp), %rdi
callq 0x1c30c0
movq %rax, %rcx
movq -0x28(%rbp), %rax
movq %rcx, 0x10(%rax)
movq -0x28(%rbp), %rax
addq $0xb0, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/nh13[P]ksw/src/main.c
// Function: main_opt_init
main_opt_t *main_opt_init()
{
	main_opt_t *opt = calloc(1, sizeof(main_opt_t));

	opt->match_score = 1;
	opt->mismatch_score = 3;
	opt->gap_open = 5;
	opt->gap_extend = 2;
	opt->band_width = INT_MAX / 4; // divide by four since in some places we multiply by two
	opt->matrix_fn = NULL;
	opt->alignment_mode = Local;
	opt->add_cigar = 0;
	opt->add_seq = 0;
	opt->add_header = 0;
	opt->right_align_gaps = 0;
	opt->offset_and_length = 0;
	opt->parasail_vec_strat = 0; // TODO: set on the command line
	opt->library = AutoLibrary;

	return opt;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movl $0x1, %edi
movl $0x50, %esi
callq 0x19e090
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
movl $0x1, (%rax)
movq -0x8(%rbp), %rax
movl $0x3, 0x4(%rax)
movq -0x8(%rbp), %rax
movl $0x5, 0x8(%rax)
movq -0x8(%rbp), %rax
movl $0x2, 0xc(%rax)
movq -0x8(%rbp), %rax
movl $0x1fffffff, 0x10(%rax) # imm = 0x1FFFFFFF
movq -0x8(%rbp), %rax
movq $0x0, 0x18(%rax)
movq -0x8(%rbp), %rax
movl $0x0, 0x20(%rax)
movq -0x8(%rbp), %rax
movl $0x0, 0x24(%rax)
movq -0x8(%rbp), %rax
movl $0x0, 0x28(%rax)
movq -0x8(%rbp), %rax
movl $0x0, 0x2c(%rax)
movq -0x8(%rbp), %rax
movl $0x0, 0x30(%rax)
movq -0x8(%rbp), %rax
movl $0x0, 0x34(%rax)
movq -0x8(%rbp), %rax
movl $0x0, 0x3c(%rax)
movq -0x8(%rbp), %rax
movl $0x0, 0x38(%rax)
movq -0x8(%rbp), %rax
addq $0x10, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/nh13[P]ksw/src/main.c
// Function: main_opt_destroy
void main_opt_destroy(main_opt_t *opt)
{
	switch (opt->library) {
		case Ksw2: ksw2_data_destroy((ksw2_data_t*)opt->_library_data); break;
		case Parasail: parasail_data_destroy((parasail_data_t*)opt->_library_data); break;
		default:
			fprintf(stderr, "Unknown library in %s: %d", __func__, opt->library);
			exit(1);
	}
	free(opt);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movl 0x38(%rax), %eax
movl %eax, -0xc(%rbp)
subl $0x1, %eax
je 0x1b8837
jmp 0x1b882d
movl -0xc(%rbp), %eax
subl $0x2, %eax
je 0x1b8846
jmp 0x1b8855
movq -0x8(%rbp), %rax
movq 0x48(%rax), %rdi
callq 0x1b7ad0
jmp 0x1b8885
movq -0x8(%rbp), %rax
movq 0x48(%rax), %rdi
callq 0x1b7de0
jmp 0x1b8885
movq 0xc6e77c(%rip), %rax    # 0xe26fd8
movq (%rax), %rdi
movq -0x8(%rbp), %rax
movl 0x38(%rax), %ecx
leaq 0xad4d6f(%rip), %rsi    # 0xc8d5dc
leaq 0xad4d82(%rip), %rdx    # 0xc8d5f6
movb $0x0, %al
callq 0x19e180
movl $0x1, %edi
callq 0x19e130
movq -0x8(%rbp), %rdi
callq 0x19e120
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/nh13[P]ksw/src/main.c
// Function: assert_or_exit
void assert_or_exit(int condition, const char *fmt, ...)
{
	if (condition == 0) {
		fprintf(stderr, "Error: ");
		va_list args;
		va_start(args, fmt);
		vfprintf(stderr, fmt, args);
		va_end(args);
		fprintf(stderr, "\n");
		exit(1);
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0xe0, %rsp
testb %al, %al
je 0x1b88d8
movaps %xmm0, -0xb0(%rbp)
movaps %xmm1, -0xa0(%rbp)
movaps %xmm2, -0x90(%rbp)
movaps %xmm3, -0x80(%rbp)
movaps %xmm4, -0x70(%rbp)
movaps %xmm5, -0x60(%rbp)
movaps %xmm6, -0x50(%rbp)
movaps %xmm7, -0x40(%rbp)
movq %r9, -0xb8(%rbp)
movq %r8, -0xc0(%rbp)
movq %rcx, -0xc8(%rbp)
movq %rdx, -0xd0(%rbp)
movl %edi, -0x4(%rbp)
movq %rsi, -0x10(%rbp)
cmpl $0x0, -0x4(%rbp)
jne 0x1b897a
movq 0xc6e6d0(%rip), %rax    # 0xe26fd8
movq (%rax), %rdi
leaq 0xad4cf5(%rip), %rsi    # 0xc8d607
movb $0x0, %al
callq 0x19e180
leaq -0x30(%rbp), %rax
leaq -0xe0(%rbp), %rcx
movq %rcx, 0x10(%rax)
leaq 0x10(%rbp), %rcx
movq %rcx, 0x8(%rax)
movl $0x30, 0x4(%rax)
movl $0x10, (%rax)
movq 0xc6e694(%rip), %rax    # 0xe26fd8
movq (%rax), %rdi
movq -0x10(%rbp), %rsi
leaq -0x30(%rbp), %rdx
callq 0x19e160
leaq -0x30(%rbp), %rax
movq 0xc6e679(%rip), %rax    # 0xe26fd8
movq (%rax), %rdi
leaq 0xad4f93(%rip), %rsi    # 0xc8d8fc
movb $0x0, %al
callq 0x19e180
movl $0x1, %edi
callq 0x19e130
addq $0xe0, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/nh13[P]ksw/src/main.c
// Function: align
void align(char *query, char *target, main_opt_t *opt, alignment_t *alignment) 
{
	int ql = strlen(query); // query length
	int tl = strlen(target); // target length

	// remove ending newlines
	if (query[ql-1] == '\n') { query[ql-1] = '\0'; ql--; }
	if (target[tl-1] == '\n') { target[tl-1] = '\0'; tl--; }

	// reset the alignment
	alignment_reset(alignment);

	// do the alignment
	opt->_library_func(query, ql, target, tl, opt, opt->_library_data, alignment);

	// print it
	alignment_print(stdout, query, target, opt, alignment);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq %rcx, -0x20(%rbp)
movq -0x8(%rbp), %rdi
callq 0x19e050
movl %eax, -0x24(%rbp)
movq -0x10(%rbp), %rdi
callq 0x19e050
movl %eax, -0x28(%rbp)
movq -0x8(%rbp), %rax
movl -0x24(%rbp), %ecx
subl $0x1, %ecx
movslq %ecx, %rcx
movsbl (%rax,%rcx), %eax
cmpl $0xa, %eax
jne 0x1b8e80
movq -0x8(%rbp), %rax
movl -0x24(%rbp), %ecx
subl $0x1, %ecx
movslq %ecx, %rcx
movb $0x0, (%rax,%rcx)
movl -0x24(%rbp), %eax
addl $-0x1, %eax
movl %eax, -0x24(%rbp)
movq -0x10(%rbp), %rax
movl -0x28(%rbp), %ecx
subl $0x1, %ecx
movslq %ecx, %rcx
movsbl (%rax,%rcx), %eax
cmpl $0xa, %eax
jne 0x1b8eb0
movq -0x10(%rbp), %rax
movl -0x28(%rbp), %ecx
subl $0x1, %ecx
movslq %ecx, %rcx
movb $0x0, (%rax,%rcx)
movl -0x28(%rbp), %eax
addl $-0x1, %eax
movl %eax, -0x28(%rbp)
movq -0x20(%rbp), %rdi
callq 0x1b8c00
movq -0x18(%rbp), %rax
movq 0x40(%rax), %rax
movq -0x8(%rbp), %rdi
movl -0x24(%rbp), %esi
movq -0x10(%rbp), %rdx
movl -0x28(%rbp), %ecx
movq -0x18(%rbp), %r8
movq -0x18(%rbp), %r9
movq 0x48(%r9), %r9
movq -0x20(%rbp), %r10
movq %r10, (%rsp)
callq *%rax
movq 0xc6e0c4(%rip), %rax    # 0xe26fb0
movq (%rax), %rdi
movq -0x8(%rbp), %rsi
movq -0x10(%rbp), %rdx
movq -0x18(%rbp), %rcx
movq -0x20(%rbp), %r8
callq 0x1b8c50
addq $0x30, %rsp
popq %rbp
retq
nopw (%rax,%rax)