LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O1/wuxb45[P]SLB/ibperfcli.c
// Function: test_ibperf
int
test_ibperf(const int argc, char ** const argv)
{
  if (argc < 6 || (strcmp(argv[0], "api") != 0)) {
    return -1;
  }
  const u64 pid = strtoull(argv[1], NULL, 10);
  char * const host = argv[2];
  const int pn = atoi(argv[3]);
  const u64 depth = strtoull(argv[4], NULL, 10);
  const u64 unit = strtoull(argv[5], NULL, 10);

  char *pref[64] = {};
  for (int i = 0; i < 6; i++) {
    pref[i] = argv[i];
  }
  pref[6] = NULL;

  struct worker_info wi = {};
  wi.port = ib_port_create(pid);
  wi.host = host;
  wi.pn = pn;
  wi.depth = depth;
  wi.unit = unit;

  struct pass_info pi = {};
  pi.api = &wi;
  pi.vctr_size = 1;
  pi.wf = ibperf_worker;
  pi.af = ibperf_analyze;

  const int n2 = maptest_passes(argc - 6, argv + 6, pref, &pi);
  ib_port_destroy(wi.port);
  if (n2 < 0) {
    return n2;
  }
  return 6 + n2;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x278, %rsp            # imm = 0x278
movl $0xffffffff, %r15d      # imm = 0xFFFFFFFF
cmpl $0x6, %edi
jl 0x711e
movq %rsi, %rbx
movl %edi, %r14d
movq (%rsi), %rdi
leaq 0xe059(%rip), %rsi      # 0x15048
callq 0x64b0
testl %eax, %eax
jne 0x711e
movq 0x8(%rbx), %rdi
xorl %esi, %esi
movl $0xa, %edx
callq 0x6580
movq %rax, -0x38(%rbp)
movq 0x10(%rbx), %rax
movq %rax, -0x40(%rbp)
movq 0x18(%rbx), %rdi
callq 0x63e0
movl %eax, -0x2c(%rbp)
movq 0x20(%rbx), %rdi
xorl %esi, %esi
movl $0xa, %edx
callq 0x6580
movq %rax, %r13
movq 0x28(%rbx), %rdi
xorl %esi, %esi
movl $0xa, %edx
callq 0x6580
movq %rax, %r15
leaq -0x270(%rbp), %r12
movl $0x1d0, %edx            # imm = 0x1D0
movq %r12, %rdi
xorl %esi, %esi
callq 0x6080
vmovups (%rbx), %ymm0
vmovups 0x10(%rbx), %ymm1
vmovups %ymm0, -0x30(%r12)
vmovups %ymm1, -0x20(%r12)
xorl %eax, %eax
movq %rax, (%r12)
leaq -0xa0(%rbp), %r12
movq %rax, 0x20(%r12)
vxorps %xmm0, %xmm0, %xmm0
vmovups %ymm0, (%r12)
movq -0x38(%rbp), %rdi
vzeroupper
callq 0x14424
movq %rax, (%r12)
movq -0x40(%rbp), %rax
movq %rax, 0x8(%r12)
movl -0x2c(%rbp), %eax
movl %eax, 0x10(%r12)
movq %r13, 0x18(%r12)
movq %r15, 0x20(%r12)
leaq -0x70(%rbp), %rcx
vxorps %xmm0, %xmm0, %xmm0
vmovups %ymm0, (%rcx)
movq %r12, 0x8(%rcx)
movq $0x1, 0x10(%rcx)
leaq 0x56(%rip), %rax        # 0x7133
movq %rax, 0x18(%rcx)
leaq 0x3c5(%rip), %rax       # 0x74ad
movq %rax, 0x20(%rcx)
addl $-0x6, %r14d
addq $0x30, %rbx
leaq -0x2a0(%rbp), %rdx
movl %r14d, %edi
movq %rbx, %rsi
vzeroupper
callq 0x13859
movl %eax, %ebx
movq (%r12), %rdi
callq 0x145bd
leal 0x6(%rbx), %r15d
testl %ebx, %ebx
cmovsl %ebx, %r15d
movl %r15d, %eax
addq $0x278, %rsp            # imm = 0x278
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/wuxb45[P]SLB/ibperfcli.c
// Function: ibperf_analyze
static bool
ibperf_analyze(struct vctr * const va, const double dt, struct damp * const damp, char * const out)
{
  const u64 nb = vctr_get(va, 0);
  const double mbps = ((double)nb) / (dt * (1024.0*1024.0));
  const bool done = damp_add_test(damp, mbps);
  const double havg = damp_average(damp);
  const char * const pat = " bytes %"PRIu64" mbps %.4lf havg %.4lf\n";
  sprintf(out, pat, nb, mbps, havg);
  return done;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x10, %rsp
movq %rdx, %rbx
movq %rsi, %r14
vmovsd %xmm0, -0x28(%rbp)
xorl %esi, %esi
callq 0x9dd9
movq %rax, %r15
vcvtusi2sd %rax, %xmm1, %xmm0
vmovsd -0x28(%rbp), %xmm1
vmulsd 0xdb5c(%rip), %xmm1, %xmm1 # 0x15040
vdivsd %xmm1, %xmm0, %xmm0
vmovsd %xmm0, -0x28(%rbp)
movq %r14, %rdi
callq 0x9bfe
movl %eax, %r12d
movq %r14, %rdi
callq 0x9b12
vmovapd %xmm0, %xmm1
leaq 0xdb41(%rip), %rsi      # 0x1504c
movq %rbx, %rdi
movq %r15, %rdx
vmovsd -0x28(%rbp), %xmm0
movb $0x2, %al
callq 0x6300
movl %r12d, %eax
addq $0x10, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/wuxb45[P]SLB/ib1.c
// Function: ib_port_create
struct ib_port *
ib_port_create(const u64 index)
{
  int num = 0;
  struct ibv_device ** const list = ibv_get_device_list(&num);
  u64 base = 0;
  for (int i = 0; i < num; i++) {
    struct ibv_context * const ctx = ibv_open_device(list[i]);
    if (ctx == NULL) {
      ibv_free_device_list(list);
      return NULL;
    }
    struct ibv_device_attr attr = {};
    const int q = ibv_query_device(ctx, &attr);
    debug_assert(q == 0);

    const u8 np = attr.phys_port_cnt;
    if ((base + np) > index) {
      struct ib_port * const port = (typeof(port))malloc(sizeof(*port));
      debug_assert(port);
      port->ctx = ctx;
      port->port_id = index - base + 1;
      port->pd = ibv_alloc_pd(ctx);
      debug_assert(port->pd);
      ibv_free_device_list(list);
      return port;
    }
    ibv_close_device(ctx);
    base += np;
  }
  ibv_free_device_list(list);
  return NULL;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x118, %rsp            # imm = 0x118
movq %rdi, %rbx
leaq -0x30(%rbp), %r15
movl $0x0, (%r15)
movq %r15, %rdi
callq 0x6460
movq %rax, %r12
cmpl $0x0, (%r15)
setg -0x29(%rbp)
jle 0x14597
movq %rbx, -0x50(%rbp)
xorl %r14d, %r14d
xorl %r15d, %r15d
movq %r12, -0x38(%rbp)
movq (%r12,%r14,8), %rdi
callq 0x6230
testq %rax, %rax
je 0x1450a
movq %rax, %r13
vxorps %xmm0, %xmm0, %xmm0
vmovups %ymm0, -0x80(%rbp)
vmovups %ymm0, -0xa0(%rbp)
vmovups %ymm0, -0xc0(%rbp)
vmovups %ymm0, -0xe0(%rbp)
vmovups %ymm0, -0x100(%rbp)
vmovups %ymm0, -0x120(%rbp)
vmovups %ymm0, -0x140(%rbp)
movq $0x0, -0x60(%rbp)
movq %rax, %rdi
leaq -0x140(%rbp), %rsi
vzeroupper
callq 0x62c0
xorl %edi, %edi
testl %eax, %eax
sete %dil
callq 0x78fa
movzbl -0x5d(%rbp), %r12d
addq %r15, %r12
movq %r15, %rax
movq -0x50(%rbp), %r15
cmpq %r15, %r12
setbe %bl
ja 0x1451e
movq %r13, %rdi
callq 0x63b0
movq %r12, %r15
movq -0x38(%rbp), %r12
jmp 0x1457d
movq %r12, %rdi
callq 0x60e0
xorl %ebx, %ebx
movq $0x0, -0x40(%rbp)
jmp 0x1457d
movl $0x18, %edi
movq %rax, -0x48(%rbp)
callq 0x61b0
movq %rax, %r12
xorl %edi, %edi
testq %rax, %rax
setne %dil
callq 0x78fa
movq %r13, (%r12)
movl %r15d, %eax
movq -0x48(%rbp), %r15
subl %r15d, %eax
incb %al
movb %al, 0x8(%r12)
movq %r13, %rdi
callq 0x6610
movq %r12, -0x40(%rbp)
movq %rax, 0x10(%r12)
xorl %edi, %edi
testq %rax, %rax
setne %dil
callq 0x78fa
movq -0x38(%rbp), %r12
movq %r12, %rdi
callq 0x60e0
testb %bl, %bl
je 0x14597
incq %r14
movslq -0x30(%rbp), %rax
cmpq %rax, %r14
setl -0x29(%rbp)
jl 0x1446d
jmp 0x14597
testb $0x1, -0x29(%rbp)
movq -0x40(%rbp), %rax
jne 0x145ab
movq %r12, %rdi
callq 0x60e0
xorl %eax, %eax
addq $0x118, %rsp            # imm = 0x118
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/wuxb45[P]SLB/ib1.c
// Function: ib_sge_refill_off
void *
ib_sge_refill_off(struct ibv_sge * const sg, struct ibv_mr * const mr, const size_t offset, const size_t size)
{
  debug_assert((offset + size) <= mr->length);
  sg->addr = ((u64)mr->addr) + offset;
  sg->length = size;
  sg->lkey = mr->lkey;
  return (void *)sg->addr;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movq %rcx, %rbx
movq %rdx, %r14
movq %rsi, %r15
movq %rdi, %r12
leaq (%rcx,%rdx), %rax
xorl %edi, %edi
cmpq 0x18(%rsi), %rax
setbe %dil
callq 0x78fa
addq 0x10(%r15), %r14
movq %r14, (%r12)
movl %ebx, 0x8(%r12)
movl 0x24(%r15), %eax
movl %eax, 0xc(%r12)
movq %r14, %rax
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/wuxb45[P]SLB/ib1.c
// Function: ib_sge_refill_ptr
u64
ib_sge_refill_ptr(struct ibv_sge * const sg, struct ibv_mr * const mr, void * const ptr, const size_t size)
{
  debug_assert((((u64)ptr) + size - ((u64)mr->addr)) <= mr->length);
  debug_assert(ptr >= mr->addr);
  sg->addr = (u64)ptr;
  sg->length = size;
  sg->lkey = mr->lkey;
  return ptr - mr->addr;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movq %rcx, %r15
movq %rdx, %rbx
movq %rsi, %r14
leaq (%rdx,%rcx), %rax
subq 0x10(%rsi), %rax
movq %rdi, %r12
xorl %edi, %edi
cmpq 0x18(%rsi), %rax
setbe %dil
callq 0x78fa
xorl %edi, %edi
cmpq %rbx, 0x10(%r14)
setbe %dil
callq 0x78fa
movq %rbx, (%r12)
movl %r15d, 0x8(%r12)
movl 0x24(%r14), %eax
movl %eax, 0xc(%r12)
subq 0x10(%r14), %rbx
movq %rbx, %rax
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/wuxb45[P]SLB/ib1.c
// Function: ib_socket_create
struct ib_socket *
ib_socket_create(struct ib_port * const port, const u64 depth)
{
  struct ib_socket * const s = (typeof(s))calloc(1, sizeof(*s));
  debug_assert(s);
  s->port = port;

  struct ibv_cq * const cqs = ibv_create_cq(port->ctx, depth, NULL, NULL, 0);
  struct ibv_cq * const cqr = ibv_create_cq(port->ctx, depth, NULL, NULL, 0);
  debug_assert(cqs);
  debug_assert(cqr);
  s->cqs = cqs;
  s->cqr = cqr;

  // qp
  struct ibv_qp_init_attr iattr = {};
  iattr.send_cq = cqs;
  iattr.recv_cq = cqr;
  iattr.qp_type = IBV_QPT_RC;
  iattr.sq_sig_all = 0;

  iattr.cap.max_send_wr = depth;
  iattr.cap.max_recv_wr = depth;
  iattr.cap.max_send_sge = IB1_SGE_DEPTH;
  iattr.cap.max_recv_sge = IB1_SGE_DEPTH;
  iattr.cap.max_inline_data = 60;

  s->qp = ibv_create_qp(port->pd, &iattr);
  debug_assert(s->qp);

  // qp init state
  struct ibv_qp_attr qattr = {};
  qattr.qp_state = IBV_QPS_INIT;
  qattr.pkey_index = 0;
  qattr.port_num = port->port_id;
  qattr.qp_access_flags = IB1_MR_FLAGS;
  const int r = ibv_modify_qp(s->qp, &qattr, IB1_SOCKET_QP_INIT);
  debug_assert(r == 0);

  // wc
  s->wc = (typeof(s->wc))calloc(depth, sizeof(s->wc[0]));
  debug_assert(s->wc);

  // wr/sg
  s->swr.num_sge = 1;
  s->rwr.num_sge = 1;
  s->depth = depth;
  return s;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0xd8, %rsp
movq %rsi, %rbx
movq %rdi, %r15
movl $0x1, %edi
movl $0xe8, %esi
callq 0x64f0
movq %rax, %r14
xorl %edi, %edi
testq %rax, %rax
setne %dil
callq 0x78fa
movq %r15, (%r14)
movq (%r15), %rdi
movl %ebx, %esi
xorl %edx, %edx
xorl %ecx, %ecx
xorl %r8d, %r8d
callq 0x6170
movq %rax, %r12
movq (%r15), %rdi
movl %ebx, %esi
xorl %edx, %edx
xorl %ecx, %ecx
xorl %r8d, %r8d
callq 0x6170
movq %rax, %r13
xorl %edi, %edi
testq %r12, %r12
setne %dil
callq 0x78fa
xorl %edi, %edi
testq %r13, %r13
setne %dil
callq 0x78fa
movq %r12, 0x10(%r14)
vxorps %xmm0, %xmm0, %xmm0
leaq -0x70(%rbp), %rsi
vmovups %ymm0, (%rsi)
movq %r13, 0x18(%r14)
vmovups %ymm0, 0x20(%rsi)
movq %r12, 0x8(%rsi)
movq %r13, 0x10(%rsi)
movq $0x2, 0x34(%rsi)
movl %ebx, 0x20(%rsi)
movl %ebx, 0x24(%rsi)
movabsq $0x100000001, %rax      # imm = 0x100000001
movq %rax, 0x28(%rsi)
movl $0x3c, 0x30(%rsi)
movq 0x10(%r15), %rdi
vzeroupper
callq 0x6100
movq %rax, %r12
movq %rax, 0x8(%r14)
xorl %edi, %edi
testq %rax, %rax
setne %dil
callq 0x78fa
leaq -0x100(%rbp), %rsi
vxorps %xmm0, %xmm0, %xmm0
vmovups %ymm0, (%rsi)
vmovups %ymm0, 0x70(%rsi)
vmovups %ymm0, 0x60(%rsi)
vmovups %ymm0, 0x40(%rsi)
vmovups %ymm0, 0x20(%rsi)
movl $0x1, %r13d
movl %r13d, (%rsi)
movw $0x0, 0x78(%rsi)
movb 0x8(%r15), %al
movb %al, 0x81(%rsi)
movl $0xf, 0x20(%rsi)
movq %r12, %rdi
movl $0x39, %edx
vzeroupper
callq 0x62b0
xorl %edi, %edi
testl %eax, %eax
sete %dil
callq 0x78fa
movl $0x30, %esi
movq %rbx, %rdi
callq 0x64f0
movq %rax, 0x20(%r14)
xorl %edi, %edi
testq %rax, %rax
setne %dil
callq 0x78fa
movl %r13d, 0x40(%r14)
movl %r13d, 0xc0(%r14)
movq %rbx, 0xc8(%r14)
movq %r14, %rax
addq $0xd8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/wuxb45[P]SLB/ib1.c
// Function: ib_socket_export
bool
ib_socket_export(struct ib_socket * const s, struct ib_remote * const r)
{
  struct ibv_port_attr attr = {};
  if (ibv_query_port(s->port->ctx, s->port->port_id, &attr) != 0) {
    return false;
  }
  r->lid = attr.lid;
  r->qpn = s->qp->qp_num;
  return true;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
subq $0x40, %rsp
movq %rsi, %rbx
movq %rdi, %r14
vxorps %xmm0, %xmm0, %xmm0
vmovups %ymm0, -0x3c(%rbp)
vmovups %ymm0, -0x50(%rbp)
movq (%rdi), %rcx
movq (%rcx), %rdi
leaq -0x140(%rdi), %rdx
xorl %eax, %eax
cmpq $-0x1, 0x140(%rdi)
cmovneq %rax, %rdx
jne 0x14889
cmpq $0x288, 0x138(%rdx) # imm = 0x288
jae 0x1487c
xorl %eax, %eax
jmp 0x14889
movq (%rdx), %rax
testq %rax, %rax
cmoveq %rax, %rdx
movq %rdx, %rax
movb 0x8(%rcx), %cl
testq %rax, %rax
je 0x148a4
movzbl %cl, %esi
leaq -0x50(%rbp), %rdx
movl $0x34, %ecx
vzeroupper
callq *(%rax)
jmp 0x148bc
leaq -0x50(%rbp), %rdx
vmovups %ymm0, 0x14(%rdx)
vmovups %ymm0, (%rdx)
movzbl %cl, %esi
vzeroupper
callq 0x64c0
testl %eax, %eax
jne 0x148d0
movzwl -0x2e(%rbp), %ecx
movl %ecx, (%rbx)
movq 0x8(%r14), %rcx
movl 0x34(%rcx), %ecx
movl %ecx, 0x4(%rbx)
testl %eax, %eax
sete %al
addq $0x40, %rsp
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/wuxb45[P]SLB/ib1.c
// Function: ib_socket_connect
bool
ib_socket_connect(struct ib_socket * const s, struct ib_remote * const r)
{
  // RTR
  struct ibv_qp_attr qattr = {};
  qattr.qp_state = IBV_QPS_RTR;
  qattr.path_mtu = IBV_MTU_4096;
  qattr.dest_qp_num = r->qpn;
  qattr.rq_psn = IB1_PSN;

  qattr.ah_attr.is_global = 0;
  qattr.ah_attr.dlid = r->lid;
  qattr.ah_attr.sl = 0;
  qattr.ah_attr.src_path_bits = 0;
  qattr.ah_attr.port_num = s->port->port_id;

  // RC only
  qattr.max_dest_rd_atomic = 16;
  qattr.min_rnr_timer = 12;
  const int mask1 = IB1_SOCKET_QP_RTR_RC;
  const int r1 = ibv_modify_qp(s->qp, &qattr, mask1);
  if (r1 != 0) return false;

  // RTS
  qattr.qp_state = IBV_QPS_RTS;
  qattr.sq_psn = IB1_PSN;
  // RC only
  qattr.timeout = 14;
  qattr.retry_cnt = 7;
  qattr.rnr_retry = 7;
  qattr.max_rd_atomic = 16;
  qattr.max_dest_rd_atomic = 16;
  const int mask2 = IB1_SOCKET_QP_RTS_RC;
  const int r2 = ibv_modify_qp(s->qp, &qattr, mask2);
  if (r2 != 0) return false;
  return true;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %rbx
subq $0x98, %rsp
movq %rdi, %rbx
vxorps %xmm0, %xmm0, %xmm0
leaq -0xa0(%rbp), %rax
vmovups %ymm0, (%rax)
vmovups %ymm0, 0x70(%rax)
vmovups %ymm0, 0x60(%rax)
vmovups %ymm0, 0x40(%rax)
vmovups %ymm0, 0x20(%rax)
movl $0x2, (%rax)
movl $0x5, 0x8(%rax)
movl 0x4(%rsi), %ecx
movl %ecx, 0x1c(%rax)
movl $0x3e8, 0x14(%rax)      # imm = 0x3E8
movb $0x0, 0x55(%rax)
movzwl (%rsi), %ecx
movw %cx, 0x50(%rax)
movw $0x0, 0x52(%rax)
movq (%rdi), %rcx
movb 0x8(%rcx), %cl
movb %cl, 0x56(%rax)
movw $0xc10, 0x7f(%rax)      # imm = 0xC10
movq 0x8(%rdi), %rdi
movq %rax, %rsi
movl $0x129181, %edx         # imm = 0x129181
vzeroupper
callq 0x62b0
testl %eax, %eax
je 0x14966
xorl %eax, %eax
jmp 0x149a3
leaq -0xa0(%rbp), %rsi
movl $0x3, (%rsi)
movl $0x3e8, 0x18(%rsi)      # imm = 0x3E8
movw $0x70e, 0x82(%rsi)      # imm = 0x70E
movb $0x7, 0x84(%rsi)
movw $0x1010, 0x7e(%rsi)     # imm = 0x1010
movq 0x8(%rbx), %rdi
movl $0x12e01, %edx          # imm = 0x12E01
callq 0x62b0
testl %eax, %eax
sete %al
addq $0x98, %rsp
popq %rbx
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/wuxb45[P]SLB/ib1.c
// Function: ib_socket_connect_stream2
bool
ib_socket_connect_stream2(struct ib_socket * const s, struct stream2 * const s2)
{
  struct ib_remote local = {};
  if (ib_socket_export(s, &local) == false) {
    fprintf(stderr, "export failed\n");
    return false;
  }
  fwrite(&local, sizeof(local), 1, s2->w);
  fflush(s2->w);

  struct ib_remote remote = {};
  if (1 != fread(&remote, sizeof(remote), 1, s2->r)) {
    fprintf(stderr, "read remote failed\n");
    return false;
  }

  const bool rc = ib_socket_connect(s, &remote);
  if (rc == false) {
    fprintf(stderr, "connect failed\n");
  }
  return rc;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
subq $0x10, %rsp
movq %rsi, %r14
movq %rdi, %rbx
leaq -0x20(%rbp), %rsi
movq $0x0, (%rsi)
callq 0x1482f
testb %al, %al
je 0x14a31
movq (%r14), %rcx
leaq -0x20(%rbp), %rdi
movl $0x8, %esi
movl $0x1, %edx
callq 0x65d0
movq (%r14), %rdi
callq 0x66f0
leaq -0x18(%rbp), %rdi
movq $0x0, (%rdi)
movq 0x8(%r14), %rcx
movl $0x8, %esi
movl $0x1, %edx
callq 0x6440
cmpq $0x1, %rax
jne 0x14a38
leaq -0x18(%rbp), %rsi
movq %rbx, %rdi
callq 0x148de
movl %eax, %ebx
testb %al, %al
je 0x14a41
movl %ebx, %eax
addq $0x10, %rsp
popq %rbx
popq %r14
popq %rbp
retq
callq 0x6e41
jmp 0x14a3d
callq 0x6e70
xorl %ebx, %ebx
jmp 0x14a26
callq 0x6e9f
jmp 0x14a26
// File: /workspace/github_c_makefile_star2_O1/wuxb45[P]SLB/ib1.c
// Function: ib_socket_post_send
bool
ib_socket_post_send(struct ib_socket * const s, struct ibv_sge * const sg, const bool signaled)
{
  if (s->nr_sending >= s->depth) return false;
  struct ibv_send_wr * const wr = &(s->swr);
  wr->wr_id = s->wid++;
  wr->sg_list = sg;
  wr->opcode = IBV_WR_SEND;
  wr->send_flags = signaled ? IBV_SEND_SIGNALED : 0;
  if (signaled) s->nr_sending++;
  struct ibv_send_wr * bad_wr = NULL;
  const int r = ibv_post_send(s->qp, wr, &bad_wr);
  return r == 0 ? true : false;
}

// Assembly:
movq 0xd8(%rdi), %rcx
cmpq 0xc8(%rdi), %rcx
jae 0x14ac2
movq %rsi, %rax
leaq 0x28(%rdi), %rsi
movq 0xd0(%rdi), %r8
leaq 0x1(%r8), %r9
movq %r9, 0xd0(%rdi)
movq %r8, 0x28(%rdi)
movq %rax, 0x38(%rdi)
movl $0x2, 0x44(%rdi)
movzbl %dl, %eax
leal (%rax,%rax), %edx
movl %edx, 0x48(%rdi)
testb %al, %al
je 0x14a97
incq %rcx
movq %rcx, 0xd8(%rdi)
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
leaq -0x8(%rbp), %rdx
movq $0x0, (%rdx)
movq 0x8(%rdi), %rdi
movq (%rdi), %rax
callq *0xd0(%rax)
testl %eax, %eax
sete %al
addq $0x10, %rsp
popq %rbp
retq
xorl %eax, %eax
retq
// File: /workspace/github_c_makefile_star2_O1/wuxb45[P]SLB/ib1.c
// Function: ib_socket_post_recv
bool
ib_socket_post_recv(struct ib_socket * const s, struct ibv_sge * const sg)
{
  if (s->nr_recving >= s->depth) return false;
  struct ibv_recv_wr * const wr = &(s->rwr);
  wr->wr_id = s->wid++;
  wr->sg_list = sg;
  struct ibv_recv_wr * bad_wr = NULL;
  const int r = ibv_post_recv(s->qp, wr, &bad_wr);
  s->nr_recving++;
  return r == 0 ? true : false;
}

// Assembly:
movq 0xe0(%rdi), %rax
cmpq 0xc8(%rdi), %rax
jae 0x14b33
pushq %rbp
movq %rsp, %rbp
pushq %rbx
pushq %rax
movq %rdi, %rbx
leaq 0xa8(%rdi), %rax
movq 0xd0(%rdi), %rcx
leaq 0x1(%rcx), %rdx
movq %rdx, 0xd0(%rdi)
movq %rcx, 0xa8(%rdi)
movq %rsi, 0xb8(%rdi)
leaq -0x10(%rbp), %rdx
movq $0x0, (%rdx)
movq 0x8(%rdi), %rdi
movq (%rdi), %rcx
movq %rax, %rsi
callq *0xd8(%rcx)
incq 0xe0(%rbx)
testl %eax, %eax
sete %al
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
xorl %eax, %eax
retq
// File: /workspace/github_c_makefile_star2_O1/wuxb45[P]SLB/ib1.c
// Function: ib_socket_flush_send
bool
ib_socket_flush_send(struct ib_socket * const s)
{
  while (s->nr_sending) {
    const int n = ibv_poll_cq(s->cqs, s->depth, s->wc);
    if (n < 0) {
      return false;
    }
    if (n == 0) continue;
    for (int i = 0; i < n; i++) {
      if (s->wc[i].status != IBV_WC_SUCCESS) {
        return false;
      }
    }
    s->nr_sending -= n;
  }
  return true;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
movq %rdi, %rbx
movq 0xd8(%rbx), %r14
testq %r14, %r14
je 0x14bd3
movl 0xc8(%rbx), %esi
movq 0x10(%rbx), %rdi
movq 0x20(%rbx), %rdx
movq (%rdi), %rax
callq *0x60(%rax)
testl %eax, %eax
js 0x14b7f
je 0x14b86
movq 0x20(%rbx), %rcx
movl %eax, %eax
cmpl $0x0, 0x8(%rcx)
je 0x14b8d
movl $0x1, %ecx
movb $0x1, %dl
jmp 0x14bbd
movl $0x1, %ecx
jmp 0x14bca
movl $0x2, %ecx
jmp 0x14bca
addq $0x38, %rcx
movl $0x1, %esi
movq %rsi, %rdx
cmpq %rsi, %rax
je 0x14bb2
leaq 0x1(%rdx), %rsi
cmpl $0x0, (%rcx)
leaq 0x30(%rcx), %rcx
je 0x14b96
movl $0x1, %ecx
jmp 0x14bb7
movl $0x4, %ecx
cmpq %rax, %rdx
setb %dl
testb %dl, %dl
jne 0x14bca
subq %rax, 0xd8(%rbx)
xorl %ecx, %ecx
cmpl $0x1, %ecx
jne 0x14b40
testq %r14, %r14
sete %al
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/wuxb45[P]SLB/ib1.c
// Function: ib_socket_flush_recv
bool
ib_socket_flush_recv(struct ib_socket * const s)
{
  while (s->nr_recving) {
    const int n = ibv_poll_cq(s->cqr, s->depth, s->wc);
    if (n < 0) {
      return false;
    }
    if (n == 0) continue;
    for (int i = 0; i < n; i++) {
      if (s->wc[i].status != IBV_WC_SUCCESS) {
        return false;
      }
    }
    s->nr_recving -= n;
  }
  return true;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
movq %rdi, %rbx
movq 0xe0(%rbx), %r14
testq %r14, %r14
je 0x14c7b
movl 0xc8(%rbx), %esi
movq 0x18(%rbx), %rdi
movq 0x20(%rbx), %rdx
movq (%rdi), %rax
callq *0x60(%rax)
testl %eax, %eax
js 0x14c27
je 0x14c2e
movq 0x20(%rbx), %rcx
movl %eax, %eax
cmpl $0x0, 0x8(%rcx)
je 0x14c35
movl $0x1, %ecx
movb $0x1, %dl
jmp 0x14c65
movl $0x1, %ecx
jmp 0x14c72
movl $0x2, %ecx
jmp 0x14c72
addq $0x38, %rcx
movl $0x1, %esi
movq %rsi, %rdx
cmpq %rsi, %rax
je 0x14c5a
leaq 0x1(%rdx), %rsi
cmpl $0x0, (%rcx)
leaq 0x30(%rcx), %rcx
je 0x14c3e
movl $0x1, %ecx
jmp 0x14c5f
movl $0x4, %ecx
cmpq %rax, %rdx
setb %dl
testb %dl, %dl
jne 0x14c72
subq %rax, 0xe0(%rbx)
xorl %ecx, %ecx
cmpl $0x1, %ecx
jne 0x14be8
testq %r14, %r14
sete %al
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/wuxb45[P]SLB/ib1.c
// Function: ib_socket_poll_send
bool
ib_socket_poll_send(struct ib_socket * const s, u64 * const nr)
{
  const int n = ibv_poll_cq(s->cqs, s->depth, s->wc);
  if (n >= 0) {
    *nr = n;
    s->nr_sending -= n;
    return true;
  } else {
    return false;
  }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
movq %rsi, %r14
movq %rdi, %rbx
movl 0xc8(%rdi), %esi
movq 0x10(%rdi), %rdi
movq 0x20(%rbx), %rdx
movq (%rdi), %rax
callq *0x60(%rax)
testl %eax, %eax
js 0x14cb7
movl %eax, %ecx
movq %rcx, (%r14)
subq %rcx, 0xd8(%rbx)
testl %eax, %eax
setns %al
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/wuxb45[P]SLB/ib1.c
// Function: ib_socket_poll_recv
bool
ib_socket_poll_recv(struct ib_socket * const s, u64 * const nr)
{
  const int n = ibv_poll_cq(s->cqr, s->depth, s->wc);
  if (n >= 0) {
    *nr = n;
    s->nr_recving -= n;
    return true;
  } else {
    return false;
  }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
movq %rsi, %r14
movq %rdi, %rbx
movl 0xc8(%rdi), %esi
movq 0x18(%rdi), %rdi
movq 0x20(%rbx), %rdx
movq (%rdi), %rax
callq *0x60(%rax)
testl %eax, %eax
js 0x14cf2
movl %eax, %ecx
movq %rcx, (%r14)
subq %rcx, 0xe0(%rbx)
testl %eax, %eax
setns %al
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/wuxb45[P]SLB/ib1.c
// Function: ib_socket_destroy
void
ib_socket_destroy(struct ib_socket * const s)
{
  free(s->wc);
  ibv_destroy_qp(s->qp);
  ibv_destroy_cq(s->cqr);
  ibv_destroy_cq(s->cqs);
  free(s);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %rbx
pushq %rax
movq %rdi, %rbx
movq 0x20(%rdi), %rdi
callq 0x6290
movq 0x8(%rbx), %rdi
callq 0x6670
movq 0x18(%rbx), %rdi
callq 0x6530
movq 0x10(%rbx), %rdi
callq 0x6530
movq %rbx, %rdi
addq $0x8, %rsp
popq %rbx
popq %rbp
jmp 0x6290
// File: /workspace/github_c_makefile_star2_O1/xtanitfy[P]Murphy/test/test_tree.c
// Function: main
int main(void)
{
	MTREE_s *pTree = MTREE_create(NULL);

	for (int i = 0;i < DIM_OF(gArr);i++) {
		MTREE_addItem(pTree,gArr[i][0],gArr[i][1]);
	}

	printf("MTREE_forward:\n");
	MTREE_forward(pTree,forwardPrint);

	printf("MTREE_backward:\n");
	MTREE_backward(pTree,backwardPrint);

	MTREE_printByList(pTree);

	printf("MTREE_forward:\n");
	MTREE_forward(pTree,forwardPrint);

	printf("MTREE_backward:\n");
	MTREE_backward(pTree,backwardPrint);

	
	return 0;
}

// Assembly:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
xorl %r14d, %r14d
xorl %edi, %edi
callq 0x1268
movq %rax, %rbx
leaq 0xe61(%rip), %r15       # 0x2030
movl (%r15,%r14,8), %esi
movl 0x4(%r15,%r14,8), %edx
movq %rbx, %rdi
callq 0x1349
incq %r14
cmpq $0x1a, %r14
jne 0x11cf
leaq 0xe1d(%rip), %r14       # 0x200d
movq %r14, %rdi
callq 0x1080
leaq -0x73(%rip), %r15       # 0x118c
movq %rbx, %rdi
movq %r15, %rsi
callq 0x16a9
leaq 0xe0b(%rip), %r12       # 0x201c
movq %r12, %rdi
callq 0x1080
leaq -0x81(%rip), %r13       # 0x119f
movq %rbx, %rdi
movq %r13, %rsi
callq 0x1974
movq %rbx, %rdi
callq 0x1869
movq %r14, %rdi
callq 0x1080
movq %rbx, %rdi
movq %r15, %rsi
callq 0x16a9
movq %r12, %rdi
callq 0x1080
movq %rbx, %rdi
movq %r13, %rsi
callq 0x1974
xorl %eax, %eax
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O1/xtanitfy[P]Murphy/src/muti_tree.c
// Function: MTREE_create
MTREE_s *MTREE_create(void *usr)
{
	MTREE_s *pTree = (MTREE_s *)malloc(sizeof(MTREE_s));
	CHECK_EXPR_RET(pTree == NULL,NULL);
	memset(pTree,0,sizeof(MTREE_s));
	
	pTree->root = NULL;
	pTree->pQAdd = QUEUE_create(sizeof(MTREE_ITEM_s *),QUEUE_MAX_N);
	pTree->pQForward = QUEUE_create(sizeof(MTREE_ITEM_s *),QUEUE_MAX_N);
	pTree->pQBackward = QUEUE_create(sizeof(MTREE_ITEM_s *),QUEUE_MAX_N);
	pTree->num = 0;
	pTree->rootInverse = (MTREE_ITEM_s *)malloc(sizeof(MTREE_ITEM_s));
	CHECK_EXPR_RET(pTree->rootInverse == NULL,NULL);
	pTree->usr = usr;
	
	INIT_LIST_HEAD(&pTree->head);
	
	return pTree;
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %r14
movl $0x90, %edi
callq 0x1070
testq %rax, %rax
je 0x12fd
movq %rax, %rbx
movl $0x90, %edx
movq %rax, %rdi
xorl %esi, %esi
callq 0x1040
movl $0x8, %edi
movl $0x40, %esi
callq 0x1b9c
movq %rax, 0x10(%rbx)
movl $0x8, %edi
movl $0x40, %esi
callq 0x1b9c
movq %rax, 0x18(%rbx)
movl $0x8, %edi
movl $0x40, %esi
callq 0x1b9c
movq %rax, 0x20(%rbx)
movl $0x0, (%rbx)
movl $0xa8, %edi
callq 0x1070
movq %rax, 0x78(%rbx)
testq %rax, %rax
je 0x131b
movq %r14, 0x70(%rbx)
movq %rbx, %rax
subq $-0x80, %rax
movq %rax, 0x80(%rbx)
movq %rax, 0x88(%rbx)
jmp 0x133e
leaq 0xdfc(%rip), %rdi       # 0x2100
leaq 0xe0b(%rip), %rsi       # 0x2116
leaq 0xe10(%rip), %rdx       # 0x2122
xorl %ebx, %ebx
movl $0xa, %ecx
jmp 0x1337
leaq 0xdde(%rip), %rdi       # 0x2100
leaq 0xded(%rip), %rsi       # 0x2116
leaq 0xdf2(%rip), %rdx       # 0x2122
xorl %ebx, %ebx
movl $0x13, %ecx
xorl %eax, %eax
callq 0x1030
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O1/xtanitfy[P]Murphy/src/muti_tree.c
// Function: MTREE_printByList
int MTREE_printByList(MTREE_s *pTree)
{
	CHECK_EXPR_RET(pTree == NULL,-1);

	MTREE_ITEM_s *pItem = NULL;
	pTree->nEnd = 0;

	printf("MTREE_printByList:\n");
	list_for_each_entry(pItem,&pTree->head,list,MTREE_ITEM_s) {
		printf("curr:%d\n",pItem->valCurr);
	}

	return 0;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
testq %rdi, %rdi
je 0x18bf
movq %rdi, %rbx
movl $0x0, 0x68(%rdi)
leaq 0x946(%rip), %rdi       # 0x21cc
callq 0x1080
movq 0x80(%rbx), %r15
subq $-0x80, %rbx
cmpq %rbx, %r15
je 0x18e7
leaq 0x762(%rip), %r14       # 0x2004
xorl %ebp, %ebp
movl -0x98(%r15), %esi
movq %r14, %rdi
xorl %eax, %eax
callq 0x1030
movq (%r15), %r15
cmpq %rbx, %r15
jne 0x18a4
jmp 0x18e9
leaq 0x83a(%rip), %rdi       # 0x2100
leaq 0x849(%rip), %rsi       # 0x2116
leaq 0x8b4(%rip), %rdx       # 0x2188
movl $0xbd, %ecx
xorl %eax, %eax
callq 0x1030
movl $0xffffffff, %ebp       # imm = 0xFFFFFFFF
jmp 0x18e9
xorl %ebp, %ebp
movl %ebp, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/xtanitfy[P]Murphy/src/muti_tree.c
// Function: MTREE_getEndIds
int MTREE_getEndIds(MTREE_s *pTree,int *endId,int *n)
{
	CHECK_EXPR_RET(pTree == NULL,-1);
	CHECK_EXPR_RET(endId == NULL,-1);
	CHECK_EXPR_RET(n == NULL,-1);

	*n = 0;
	MTREE_ITEM_s *pItem = NULL;
	list_for_each_entry(pItem,&pTree->head,list,MTREE_ITEM_s) {
		if (pItem->nNext == 0) {
			endId[(*n)++] = pItem->valCurr;
		}
	}
	
	return 0;
}

// Assembly:
pushq %rax
testq %rdi, %rdi
je 0x193e
testq %rsi, %rsi
je 0x1945
testq %rdx, %rdx
je 0x194c
movl $0x0, (%rdx)
movq 0x80(%rdi), %rcx
subq $-0x80, %rdi
xorl %eax, %eax
cmpq %rdi, %rcx
je 0x1972
cmpl $0x0, -0x50(%rcx)
jne 0x1939
movl -0x98(%rcx), %r8d
movslq (%rdx), %r9
leal 0x1(%r9), %r10d
movl %r10d, (%rdx)
movl %r8d, (%rsi,%r9,4)
movq (%rcx), %rcx
jmp 0x1919
movl $0xcc, %ecx
jmp 0x1951
movl $0xcd, %ecx
jmp 0x1951
movl $0xce, %ecx
leaq 0x7a8(%rip), %rdi       # 0x2100
leaq 0x7b7(%rip), %rsi       # 0x2116
leaq 0x834(%rip), %rdx       # 0x219a
xorl %eax, %eax
callq 0x1030
movl $0xffffffff, %eax       # imm = 0xFFFFFFFF
popq %rcx
retq
// File: /workspace/github_c_makefile_star2_O1/Enes1313[P]DataStructures/Test/main.c
// Function: main
int main(void)
{
	srand((unsigned int)time(NULL));

	testCircularBuffer();
	testDynamicArray();
	testLinkedList();
	testQueue();
	testStack();

	return EXIT_SUCCESS;
}

// Assembly:
pushq %rax
xorl %edi, %edi
callq 0x1080
movl %eax, %edi
callq 0x1060
callq 0x23d8
callq 0x2820
callq 0x2b42
callq 0x2f34
callq 0x2d25
xorl %eax, %eax
popq %rcx
retq
// File: /workspace/github_c_makefile_star2_O1/Enes1313[P]DataStructures/Test/main.c
// Function: testQueue
void testQueue()
{
	size_t i, x;
	eaDSQueue queue = NULL;

	if (NULL == (queue = eaDSQueueInit(intCreateAndCopy, free)))
	{
		puts("queue olusmadi!");
		return;
	}

	for(i = 0; i < 13; i++)
	{
		x = (unsigned int) rand() % 50;

		if(EXIT_SUCCESS == eaDSQueueEnqueue(queue, &x))
		{
			printf("Queue'e eleman eklendi : %d \n", (int)x);
		}
		else
		{
			puts("Queue'e eleman eklenemedi!");
		}
	}

	for(i = 0; !eaDSQueueIsEmpty(queue); i++)
	{
		void * data = eaDSQueueDequeue(queue);

		if(NULL != data)
		{
			printf("Queue'den %d. eleman alindi : %d\n", (int)i + 1, *(int *)data);
			free(data);
		}
		else
		{
			printf("Queue'den %d. eleman alma basarisiz\n", (int)i + 1);
		}
	}

	printf("Queue siliniyor.\n");
	eaDSQueueClear(queue);

	puts("********************************************");
	puts("Queue");
	puts("********************************************");
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
leaq -0x74d(%rip), %rdi      # 0x27f9
movq 0x406b(%rip), %rsi      # 0x6fb8
callq 0x1f00
testq %rax, %rax
je 0x304d
movq %rax, %rbx
movl $0xd, %r13d
movq %rsp, %r14
leaq 0x14fb(%rip), %r15      # 0x4469
leaq 0x1512(%rip), %r12      # 0x4487
callq 0x10b0
movl %eax, %ecx
imulq $0x51eb851f, %rcx, %rcx # imm = 0x51EB851F
shrq $0x24, %rcx
imull $0x32, %ecx, %ecx
subl %ecx, %eax
movq %rax, (%rsp)
movq %rbx, %rdi
movq %r14, %rsi
callq 0x200d
testl %eax, %eax
je 0x2fa9
movq %r12, %rdi
callq 0x1030
jmp 0x2fb6
movl (%rsp), %esi
movq %r15, %rdi
xorl %eax, %eax
callq 0x1050
decq %r13
jne 0x2f75
movq %rbx, %rdi
callq 0x1fa6
testl %eax, %eax
jne 0x301c
movl $0x1, %ebp
leaq 0x14f1(%rip), %r14      # 0x44c4
leaq 0x14c8(%rip), %r15      # 0x44a2
movq %rbx, %rdi
callq 0x1fb0
testq %rax, %rax
je 0x3002
movq %rax, %r12
movl (%rax), %edx
movq %r15, %rdi
movl %ebp, %esi
xorl %eax, %eax
callq 0x1050
movq %r12, %rdi
callq 0x10c0
jmp 0x300e
movq %r14, %rdi
movl %ebp, %esi
xorl %eax, %eax
callq 0x1050
movq %rbx, %rdi
callq 0x1fa6
incl %ebp
testl %eax, %eax
je 0x2fda
leaq 0x15b8(%rip), %rdi      # 0x45db
callq 0x1030
movq %rbx, %rdi
callq 0x1f94
leaq 0x1038(%rip), %rbx      # 0x406f
movq %rbx, %rdi
callq 0x1030
leaq 0x14a3(%rip), %rdi      # 0x44e9
callq 0x1030
jmp 0x3054
leaq 0x1405(%rip), %rbx      # 0x4459
movq %rbx, %rdi
callq 0x1030
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/attractivechaos[P]rb-eval/rb-map.cpp
// Function: test_int(int)
int test_int(int n)
{
	int i, cnt = 0;
	uint64_t x = 11;
	intmap_t *h = new intmap_t;

	for (i = 0; i < n; ++i) {
		unsigned y = x % (n>>1);
		x = kad_splitmix64(x);
		std::pair<intmap_t::iterator, bool> p = h->insert(std::pair<unsigned, int>(y, i));
		if (p.second == false) h->erase(p.first);
	}
	cnt = h->size();
	delete h;
	return cnt;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movl %edi, %ebp
movl $0x30, %edi
callq 0x1080
movq %rax, %rbx
addq $0x8, %rax
movl $0x0, 0x8(%rbx)
xorl %r12d, %r12d
movq %r12, 0x10(%rbx)
movq %rax, 0x18(%rbx)
movq %rax, 0x20(%rbx)
movq %r12, 0x28(%rbx)
testl %ebp, %ebp
jle 0x1305
movl %ebp, %r13d
shrl %r13d
movl $0xb, %r15d
movq %rsp, %r14
movq %r15, %rax
xorl %edx, %edx
divq %r13
movl %edx, (%rsp)
movl %r12d, 0x4(%rsp)
movq %rbx, %rdi
movq %r14, %rsi
callq 0x138a
testb $0x1, %dl
jne 0x12b6
movq %rbx, %rdi
movq %rax, %rsi
callq 0x14d0
movabsq $-0x61c8864680b583eb, %rax # imm = 0x9E3779B97F4A7C15
addq %rax, %r15
movq %r15, %rax
shrq $0x1e, %rax
xorq %r15, %rax
movabsq $-0x40a7b892e31b1a47, %rcx # imm = 0xBF58476D1CE4E5B9
imulq %rcx, %rax
movq %rax, %rcx
shrq $0x1b, %rcx
xorq %rax, %rcx
movabsq $-0x6b2fb644ecceee15, %rax # imm = 0x94D049BB133111EB
imulq %rax, %rcx
movq %rcx, %r15
shrq $0x1f, %r15
xorq %rcx, %r15
incl %r12d
cmpl %r12d, %ebp
jne 0x128b
movl 0x28(%rbx), %ebp
movq %rbx, %rdi
callq 0x133a
movl $0x30, %esi
movq %rbx, %rdi
callq 0x1090
movl %ebp, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/ohkimur[P]the-c-programming-language-2nd-edition-solutions/chapter_2/exercise_2_04/squeeze.c
// Function: main
int main(void)
{
  char str1[MAXSTR] = "abcdefg";
  char str2[MAXSTR] = "abcd";

  squeeze(str1, str2);

  printf("%s", str1);

  return 0;
}

// Assembly:
pushq %r14
pushq %rbx
subq $0x7d8, %rsp            # imm = 0x7D8
leaq 0xea3(%rip), %rsi       # 0x2010
leaq 0x3f0(%rsp), %rbx
movl $0x3e8, %edx            # imm = 0x3E8
movq %rbx, %rdi
callq 0x1050
movq %rsp, %r14
movl $0x3e8, %edx            # imm = 0x3E8
movq %r14, %rdi
xorl %esi, %esi
callq 0x1040
movl $0x64636261, (%r14)     # imm = 0x64636261
movq %rbx, %rdi
movq %r14, %rsi
callq 0x11c4
leaq 0x124b(%rip), %rdi      # 0x23f8
movq %rbx, %rsi
xorl %eax, %eax
callq 0x1030
xorl %eax, %eax
addq $0x7d8, %rsp            # imm = 0x7D8
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O1/ohkimur[P]the-c-programming-language-2nd-edition-solutions/chapter_2/exercise_2_04/squeeze.c
// Function: squeeze
void squeeze(char str1[], char str2[])
{
  int i, j, k;
  for (k = 0; str2[k] != '\0'; ++k)
  {
    for (i = j = 0; str1[i] != '\0'; ++i)
    {
      if (str1[i] != str2[k])
      {
        str1[j++] = str1[i];
      }
    }

    str1[j] = '\0';
  }
}

// Assembly:
cmpb $0x0, (%rsi)
je 0x120c
leaq 0x1(%rdi), %rax
xorl %ecx, %ecx
movb (%rdi), %r9b
testb %r9b, %r9b
je 0x11fb
xorl %edx, %edx
movq %rax, %r8
cmpb (%rsi,%rcx), %r9b
je 0x11eb
movslq %edx, %r10
incl %edx
movb %r9b, (%rdi,%r10)
movb (%r8), %r9b
incq %r8
testb %r9b, %r9b
jne 0x11dc
movslq %edx, %rdx
jmp 0x11fd
xorl %edx, %edx
movb $0x0, (%rdi,%rdx)
cmpb $0x0, 0x1(%rsi,%rcx)
leaq 0x1(%rcx), %rcx
jne 0x11cf
retq
// File: /workspace/github_c_makefile_star2_O1/antonblanchard[P]will-it-scale/tests/eventfd1.c
// Function: testcase
void testcase(unsigned long long *iterations, unsigned long nr)
{
	unsigned long long rbuf;
	unsigned long long wbuf;
	int fd = eventfd(0, 0);
	int ret;

	assert(fd >= 0);

	wbuf = 1;

	while (1) {
		do {
			ret = write(fd, &wbuf, sizeof(wbuf));
		} while (ret != sizeof(wbuf) && errno == EINTR);
		assert(ret == sizeof(wbuf));

		do {
			ret = read(fd, &rbuf, sizeof(rbuf));
		} while (ret != sizeof(rbuf) && errno == EINTR);
		assert(ret == sizeof(wbuf));

		(*iterations)++;
	}
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
subq $0x18, %rsp
movq %rdi, %rbx
xorl %edi, %edi
xorl %esi, %esi
callq 0x1280
testl %eax, %eax
js 0x1ce2
movl %eax, %ebp
leaq 0x8(%rsp), %r14
movq $0x1, (%r14)
leaq 0x10(%rsp), %r15
movl $0x8, %edx
movl %ebp, %edi
movq %r14, %rsi
callq 0x10d0
cmpl $0x8, %eax
jne 0x1cd1
movl $0x8, %edx
movl %ebp, %edi
movq %r15, %rsi
callq 0x1170
cmpl $0x8, %eax
je 0x1cdd
callq 0x1070
cmpl $0x4, (%rax)
je 0x1cb1
jmp 0x1d01
callq 0x1070
cmpl $0x4, (%rax)
je 0x1c9d
jmp 0x1d20
incq (%rbx)
jmp 0x1c9d
leaq 0x58d(%rip), %rdi       # 0x2276
leaq 0x58e(%rip), %rsi       # 0x227e
leaq 0x598(%rip), %rcx       # 0x228f
movl $0x11, %edx
callq 0x1130
leaq 0x5ba(%rip), %rdi       # 0x22c2
leaq 0x56f(%rip), %rsi       # 0x227e
leaq 0x579(%rip), %rcx       # 0x228f
movl $0x1e, %edx
callq 0x1130
leaq 0x59b(%rip), %rdi       # 0x22c2
leaq 0x550(%rip), %rsi       # 0x227e
leaq 0x55a(%rip), %rcx       # 0x228f
movl $0x19, %edx
callq 0x1130
// File: /workspace/github_c_makefile_star2_O1/wuxb45[P]SLB/ibperfser.c
// Function: main
int
main(int argc, char ** argv)
{
  if (argc < 6) {
    fprintf(stderr, "Usage: %s <ib-port> <host> <port> <depth> <max-unit>\n", argv[0]);
    exit(0);
  }

  struct ib_port * const port = ib_port_create(atoi(argv[1]));
  if (port == NULL) {
    fprintf(stderr, "ib_port_create() failed\n");
    exit(0);
  }

  const char * const host = argv[2];
  const int pn = atoi(argv[3]);
  const u64 depth = strtoull(argv[4], NULL, 10);
  const u64 unit = strtoull(argv[5], NULL, 10);

  struct worker_info wi;
  wi.port = port;
  wi.depth = depth;
  wi.unit = unit;
  struct server * const ser = server_create(host, pn, perf_worker, &wi);
  if (ser == NULL) {
    fprintf(stderr, "server_create() failed\n");
    exit(0);
  }

  server_wait(ser);
  return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %rsi, %rbx
cmpl $0x5, %edi
jle 0x7084
movq 0x8(%rbx), %rdi
callq 0x63e0
movslq %eax, %rdi
callq 0x14208
testq %rax, %rax
je 0x708c
movq %rax, %r14
movq 0x10(%rbx), %r15
movq 0x18(%rbx), %rdi
callq 0x63e0
movl %eax, %r12d
movq 0x20(%rbx), %rdi
xorl %esi, %esi
movl $0xa, %edx
callq 0x6580
movq %rax, %r13
movq 0x28(%rbx), %rdi
xorl %esi, %esi
movl $0xa, %edx
callq 0x6580
leaq -0x40(%rbp), %rcx
movq %r14, (%rcx)
movq %r13, 0x8(%rcx)
movq %rax, 0x10(%rcx)
leaq 0x3b(%rip), %rdx        # 0x7096
movq %r15, %rdi
movl %r12d, %esi
callq 0xb30f
testq %rax, %rax
je 0x7091
movq %rax, %rdi
callq 0xb59a
xorl %eax, %eax
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rbx, %rdi
callq 0x676e
callq 0x6747
callq 0x6720
// File: /workspace/github_c_makefile_star2_O1/rroa[P]PUCMM_2D_Asteroids/Asteroids/Game.cpp
// Function: Engine::Game::Game(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&, int, int)
Game::Game(const std::string& title, const int width, const int height)
		: m_title(title),
		m_width(width),
		m_height(height),
		m_nUpdates(0),
		m_score(0)
	{
		m_mainWindow = nullptr;
		m_state = GameState::UNINITIALIZED;
		m_player = new Asteroids::Player();
		m_entities.push_back(m_player);
		m_dimensions[0] = width;
		m_dimensions[1] = height;

		m_timer = new TimeManager;
		m_lastFrameTime = m_timer->GetElapsedTimeInSeconds();
	}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movl %ecx, %ebp
movl %edx, %r12d
movq %rsi, %r15
movq %rdi, %rbx
callq 0x5648
leaq 0x55bf(%rip), %rax      # 0x8ae0
movq %rax, (%rbx)
movl %r12d, 0x8(%rbx)
movl %ebp, 0x4(%rsp)
movl %ebp, 0xc(%rbx)
movq $0x0, 0x10(%rbx)
leaq 0x20(%rbx), %rdi
leaq 0x30(%rbx), %rax
movq %rax, 0x8(%rsp)
movq %rax, 0x20(%rbx)
movq (%r15), %rsi
movq 0x8(%r15), %rdx
addq %rsi, %rdx
movq %rdi, 0x10(%rsp)
callq 0x43ba
leaq 0x60(%rbx), %r14
movq %r14, 0x68(%rbx)
movq %r14, 0x60(%rbx)
xorl %eax, %eax
movq %rax, 0x70(%rbx)
leaq 0x78(%rbx), %rbp
movq %rbp, 0x80(%rbx)
movq %rbp, 0x78(%rbx)
movq %rax, 0x88(%rbx)
leaq 0x90(%rbx), %r15
movq %r15, 0x98(%rbx)
movq %r15, 0x90(%rbx)
movq %rax, 0xa0(%rbx)
movq %rax, 0x40(%rbx)
movl $0x0, 0x50(%rbx)
movl $0x50, %edi
callq 0x30c0
movq %rax, %r13
movq %rax, %rdi
callq 0x455c
movq %r13, 0x58(%rbx)
movl $0x18, %edi
callq 0x30c0
movq %r13, 0x10(%rax)
movq %rax, %rdi
movq %r15, %rsi
callq 0x30d0
incq 0xa0(%rbx)
movl %r12d, 0x5bfd(%rip)     # 0x91e8
movl 0x4(%rsp), %eax
movl %eax, 0x5bf7(%rip)      # 0x91ec
movl $0x38, %edi
callq 0x30c0
movq %rax, %r13
movq %rax, %rdi
callq 0x5d10
movq %r13, 0xa8(%rbx)
movq %r13, %rdi
callq 0x5db4
movsd %xmm0, 0x18(%rbx)
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %r12
movl $0x38, %esi
jmp 0x3641
jmp 0x3650
movq %rax, %r12
movl $0x50, %esi
movq %r13, %rdi
callq 0x30a0
jmp 0x3653
movq %rax, %r12
jmp 0x36ca
movq %rax, %r12
movq (%r15), %rdi
cmpq %r15, %rdi
je 0x3670
movq (%rdi), %r13
movl $0x18, %esi
callq 0x30a0
movq %r13, %rdi
cmpq %r15, %r13
jne 0x365b
movq (%rbp), %rdi
cmpq %rbp, %rdi
je 0x368e
movq (%rdi), %r15
movl $0x18, %esi
callq 0x30a0
movq %r15, %rdi
cmpq %rbp, %r15
jne 0x3679
movq (%r14), %rdi
cmpq %r14, %rdi
je 0x36ab
movq (%rdi), %r15
movl $0x18, %esi
callq 0x30a0
movq %r15, %rdi
cmpq %r14, %r15
jne 0x3696
movq 0x10(%rsp), %rax
movq (%rax), %rdi
cmpq 0x8(%rsp), %rdi
je 0x36ca
movq 0x8(%rsp), %rax
movq (%rax), %rsi
incq %rsi
callq 0x30a0
movq %rbx, %rdi
callq 0x5654
movq %r12, %rdi
callq 0x3230
// File: /workspace/github_c_makefile_star2_O1/rroa[P]PUCMM_2D_Asteroids/Asteroids/Game.cpp
// Function: Engine::Game::OnExecute()
void Game::OnExecute()
	{
		if (m_state != GameState::INIT_SUCCESSFUL)
		{
			std::cerr << "Game INIT was not successful." << std::endl;
			return;
		}

		m_state = GameState::RUNNING;
		CreateAsteroid(Asteroids::Asteroid::AsteroidSize::BIG, 1);

		SDL_Event event;
		while (m_state == GameState::RUNNING)
		{
			// Input polling
			//
			while (SDL_PollEvent(&event))
			{
				OnEvent(&event);
			}

			//
			OnUpdate();
			OnRender();
		}
	}

// Assembly:
pushq %r14
pushq %rbx
subq $0x38, %rsp
cmpl $0x2, 0x50(%rdi)
jne 0x3864
movq %rdi, %rbx
movl $0x4, 0x50(%rdi)
xorps %xmm0, %xmm0
xorps %xmm1, %xmm1
xorl %esi, %esi
movl $0x1, %edx
callq 0x38ae
cmpl $0x4, 0x50(%rbx)
jne 0x385c
movq %rsp, %r14
movq %r14, %rdi
callq 0x3340
testl %eax, %eax
je 0x3846
movq (%rbx), %rax
movq %rbx, %rdi
movq %r14, %rsi
callq *0x10(%rax)
jmp 0x382c
movq %rbx, %rdi
callq 0x3ae4
movq %rbx, %rdi
callq 0x3c02
cmpl $0x4, 0x50(%rbx)
je 0x382c
addq $0x38, %rsp
popq %rbx
popq %r14
retq
movq 0x5785(%rip), %rbx      # 0x8ff0
leaq 0x27ee(%rip), %rsi      # 0x6060
movl $0x1d, %edx
movq %rbx, %rdi
callq 0x32d0
movq (%rbx), %rax
movq -0x18(%rax), %rdi
addq %rbx, %rdi
movl $0xa, %esi
callq 0x3330
movsbl %al, %esi
movq %rbx, %rdi
callq 0x31e0
movq %rax, %rdi
addq $0x38, %rsp
popq %rbx
popq %r14
jmp 0x31a0
nop
// File: /workspace/github_c_makefile_star2_O1/rroa[P]PUCMM_2D_Asteroids/Asteroids/Game.cpp
// Function: Engine::Game::OnUpdate()
void Game::OnUpdate()
	{
		double startTime = m_timer->GetElapsedTimeInSeconds();

		// Updating the entities
		//
		std::list< Asteroids::Entity* >::iterator ait = m_entities.begin();
		while (ait != m_entities.end())
		{
			(*ait)->Update(DESIRED_FRAME_TIME, m_width, m_height);
			++ait;
		}

		if(m_player)
		{
			if (up)
				m_player->MoveUp();
			if (left)
				m_player->RotateLeft(DESIRED_FRAME_TIME);
			if (right)
				m_player->RotateRight(DESIRED_FRAME_TIME);

			m_player->Update(DESIRED_FRAME_TIME, m_width, m_height);

			// Checking collision between the entities
			//
			CheckCollision();

			// Checking for entities marked as collided or for deletion
			//
			CleanEntities();
		}

		double endTime = m_timer->GetElapsedTimeInSeconds();
		double nextTimeFrame = startTime + DESIRED_FRAME_TIME;

		while (endTime < nextTimeFrame)
		{
			// Spin lock
			endTime = m_timer->GetElapsedTimeInSeconds();
		}

		//double elapsedTime = endTime - startTime;        

		m_lastFrameTime = m_timer->GetElapsedTimeInSeconds();

		m_nUpdates++;
	}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
subq $0x10, %rsp
movq %rdi, %rbx
movq 0xa8(%rdi), %rdi
callq 0x5db4
movsd %xmm0, 0x8(%rsp)
leaq 0x90(%rbx), %r14
movq 0x90(%rbx), %r15
cmpq %r14, %r15
je 0x3b32
movq 0x10(%r15), %rdi
movl 0x8(%rbx), %esi
movl 0xc(%rbx), %edx
movq (%rdi), %rax
movss 0x250a(%rip), %xmm0     # 0x6034
callq *0x8(%rax)
movq (%r15), %r15
jmp 0x3b10
movq 0x58(%rbx), %rdi
testq %rdi, %rdi
je 0x3ba5
cmpb $0x1, 0x56a3(%rip)      # 0x91e5
jne 0x3b49
callq 0x51f8
cmpb $0x1, 0x5696(%rip)      # 0x91e6
jne 0x3b63
movq 0x58(%rbx), %rdi
movss 0x24d6(%rip), %xmm0     # 0x6034
callq 0x523e
cmpb $0x1, 0x567d(%rip)      # 0x91e7
jne 0x3b7d
movq 0x58(%rbx), %rdi
movss 0x24bc(%rip), %xmm0     # 0x6034
callq 0x522a
movq 0x58(%rbx), %rdi
movl 0x8(%rbx), %esi
movl 0xc(%rbx), %edx
movq (%rdi), %rax
movss 0x24a2(%rip), %xmm0     # 0x6034
callq *0x8(%rax)
movq %rbx, %rdi
callq 0x41ce
movq %rbx, %rdi
callq 0x3fde
movq 0xa8(%rbx), %rdi
callq 0x5db4
movsd 0x8(%rsp), %xmm1
addsd 0x2489(%rip), %xmm1     # 0x6048
ucomisd %xmm0, %xmm1
jbe 0x3be3
movsd %xmm1, 0x8(%rsp)
movq 0xa8(%rbx), %rdi
callq 0x5db4
movsd 0x8(%rsp), %xmm1
ucomisd %xmm0, %xmm1
ja 0x3bcb
movq 0xa8(%rbx), %rdi
callq 0x5db4
movsd %xmm0, 0x18(%rbx)
incl 0x10(%rbx)
addq $0x10, %rsp
popq %rbx
popq %r14
popq %r15
retq
nop
// File: /workspace/github_c_makefile_star2_O1/rroa[P]PUCMM_2D_Asteroids/Asteroids/Game.cpp
// Function: Engine::Game::OnRender()
void Game::OnRender()
	{
		glClearColor(0.1f, 0.1f, 0.15f, 1.0f);
		glClear(GL_COLOR_BUFFER_BIT);

		// Render player
		//
		if (m_player)
			m_player->Render();

		for (std::list< Asteroids::Entity* >::iterator it = m_entities.begin(); it != m_entities.end(); ++it)
		{
			if ((*it)->CouldCollide())
				(*it)->Render();
		}

		SDL_GL_SwapWindow(m_mainWindow);
	}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rdi, %rbx
movss 0x2426(%rip), %xmm0     # 0x6038
movss 0x2422(%rip), %xmm2     # 0x603c
movss 0x241e(%rip), %xmm3     # 0x6040
movaps %xmm0, %xmm1
callq 0x30b0
movl $0x4000, %edi           # imm = 0x4000
callq 0x3200
movq 0x58(%rbx), %rdi
testq %rdi, %rdi
je 0x3c43
movq (%rdi), %rax
callq *0x10(%rax)
leaq 0x90(%rbx), %r14
movq 0x90(%rbx), %r15
cmpq %r14, %r15
je 0x3c6b
movq 0x10(%r15), %rdi
cmpl $0x0, 0x1c(%rdi)
jne 0x3c66
movq (%rdi), %rax
callq *0x10(%rax)
movq (%r15), %r15
jmp 0x3c51
movq 0x40(%rbx), %rdi
popq %rbx
popq %r14
popq %r15
jmp 0x3140
nop
// File: /workspace/github_c_makefile_star2_O1/rroa[P]PUCMM_2D_Asteroids/Asteroids/Game.cpp
// Function: Engine::Game::SDLInit()
bool Game::SDLInit()
	{
		// Initialize SDL's Video subsystem
		//
		if (SDL_Init(SDL_INIT_EVERYTHING) < 0)
		{
			std::cerr << "Failed to init SDL" << std::endl;
			return false;
		}

		SDL_GL_SetAttribute(SDL_GL_DOUBLEBUFFER, 1);
		SDL_GL_SetAttribute(SDL_GL_DEPTH_SIZE, 24);

		Uint32 flags =  SDL_WINDOW_OPENGL     | 
						SDL_WINDOW_SHOWN      | 
						SDL_WINDOW_RESIZABLE;

		m_mainWindow = SDL_CreateWindow(
			m_title.c_str(),
			SDL_WINDOWPOS_CENTERED,
			SDL_WINDOWPOS_CENTERED,
			m_width,
			m_height,
			flags
		);

		if (!m_mainWindow)
		{
			std::cerr << "Failed to create window!" << std::endl;
			SDL_Quit();
			return false;
		}

		m_context = SDL_GL_CreateContext(m_mainWindow);
		SDL_GL_MakeCurrent(m_mainWindow, m_context);

		// Make double buffer interval synced with vertical scanline refresh
		SDL_GL_SetSwapInterval(0);

		return true;
	}

// Assembly:
pushq %rbx
movq %rdi, %rbx
movl $0xf231, %edi           # imm = 0xF231
callq 0x3380
testl %eax, %eax
js 0x3d37
movl $0x5, %edi
movl $0x1, %esi
callq 0x3320
movl $0x6, %edi
movl $0x18, %esi
callq 0x3320
movq 0x20(%rbx), %rdi
movl 0x8(%rbx), %ecx
movl 0xc(%rbx), %r8d
movl $0x2fff0000, %esi       # imm = 0x2FFF0000
movl $0x2fff0000, %edx       # imm = 0x2FFF0000
movl $0x26, %r9d
callq 0x3180
movq %rax, 0x40(%rbx)
testq %rax, %rax
je 0x3d7b
movq %rax, %rdi
callq 0x3260
movq %rax, 0x48(%rbx)
movq 0x40(%rbx), %rdi
movq %rax, %rsi
callq 0x3270
xorl %edi, %edi
callq 0x31d0
movb $0x1, %al
jmp 0x3dc4
movq 0x52b2(%rip), %rbx      # 0x8ff0
leaq 0x234c(%rip), %rsi      # 0x6091
movl $0x12, %edx
movq %rbx, %rdi
callq 0x32d0
movq (%rbx), %rax
movq -0x18(%rax), %rdi
addq %rbx, %rdi
movl $0xa, %esi
callq 0x3330
movsbl %al, %esi
movq %rbx, %rdi
callq 0x31e0
movq %rax, %rdi
callq 0x31a0
jmp 0x3dc2
movq 0x526e(%rip), %rbx      # 0x8ff0
leaq 0x231b(%rip), %rsi      # 0x60a4
movl $0x18, %edx
movq %rbx, %rdi
callq 0x32d0
movq (%rbx), %rax
movq -0x18(%rax), %rdi
addq %rbx, %rdi
movl $0xa, %esi
callq 0x3330
movsbl %al, %esi
movq %rbx, %rdi
callq 0x31e0
movq %rax, %rdi
callq 0x31a0
callq 0x3130
xorl %eax, %eax
popq %rbx
retq