LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O0/LPD-EPFL[P]mctop/src/mctop_control.c
// Function: mctop_hwcid_get_nth_hwc_in_core
uint
mctop_hwcid_get_nth_hwc_in_core(mctop_t* topo, const uint hwcid)
{
  hw_context_t* hwc = &topo->hwcs[hwcid];
  if (hwc->type == CORE)
    {
      return 0;
    }
  hwc_gs_t* core = hwc->parent;
  for (int i = 0; i < core->n_hwcs; i++)
    {
      if (core->hwcs[i]->id == hwc->id)
	{
	  return i;
	}
    }
  assert(0);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movl %esi, -0x14(%rbp)
movq -0x10(%rbp), %rax
movq 0x40(%rax), %rax
movl -0x14(%rbp), %ecx
imulq $0x30, %rcx, %rcx
addq %rcx, %rax
movq %rax, -0x20(%rbp)
movq -0x20(%rbp), %rax
cmpl $0x1, 0x8(%rax)
jne 0xc388
movl $0x0, -0x4(%rbp)
jmp 0xc3f5
movq -0x20(%rbp), %rax
movq 0x18(%rax), %rax
movq %rax, -0x28(%rbp)
movl $0x0, -0x2c(%rbp)
movl -0x2c(%rbp), %eax
movq -0x28(%rbp), %rcx
cmpl 0x28(%rcx), %eax
jae 0xc3d6
movq -0x28(%rbp), %rax
movq 0x30(%rax), %rax
movslq -0x2c(%rbp), %rcx
movq (%rax,%rcx,8), %rax
movl (%rax), %eax
movq -0x20(%rbp), %rcx
cmpl (%rcx), %eax
jne 0xc3c9
movl -0x2c(%rbp), %eax
movl %eax, -0x4(%rbp)
jmp 0xc3f5
jmp 0xc3cb
movl -0x2c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x2c(%rbp)
jmp 0xc39b
leaq 0x450a(%rip), %rdi      # 0x108e7
leaq 0x4d36(%rip), %rsi      # 0x1111a
movl $0x158, %edx            # imm = 0x158
leaq 0x4d3e(%rip), %rcx      # 0x1112e
callq 0x20e0
movl -0x4(%rbp), %eax
addq $0x30, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/LPD-EPFL[P]mctop/src/mctop_control.c
// Function: mctop_hwcid_get_nth_core_in_socket
uint
mctop_hwcid_get_nth_core_in_socket(mctop_t* topo, const uint hwcid)
{
  hwc_gs_t* core = mctop_hwcid_get_core(topo, hwcid);
  hwc_gs_t* core_first = mctop_socket_get_first_gs_core(core->socket);
  uint i = 0;
  while (core_first && core->id != core_first->id)
    {
      i++;
      core_first = core_first->next;
    }

  return i;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movq -0x8(%rbp), %rdi
movl -0xc(%rbp), %esi
callq 0xc280
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rax
movq 0x10(%rax), %rdi
callq 0xbea0
movq %rax, -0x20(%rbp)
movl $0x0, -0x24(%rbp)
xorl %eax, %eax
cmpq $0x0, -0x20(%rbp)
movb %al, -0x25(%rbp)
je 0xc455
movq -0x18(%rbp), %rax
movl (%rax), %eax
movq -0x20(%rbp), %rcx
cmpl (%rcx), %eax
setne %al
movb %al, -0x25(%rbp)
movb -0x25(%rbp), %al
testb $0x1, %al
jne 0xc45e
jmp 0xc475
movl -0x24(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x24(%rbp)
movq -0x20(%rbp), %rax
movq 0x20(%rax), %rax
movq %rax, -0x20(%rbp)
jmp 0xc437
movl -0x24(%rbp), %eax
addq $0x30, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/LPD-EPFL[P]mctop/src/mctop_control.c
// Function: mctop_id_get_hwc_gs
hwc_gs_t*
mctop_id_get_hwc_gs(mctop_t* topo, const uint id)
{
  uint lvl = mctop_id_get_lvl(id);
  if (lvl > topo->n_levels)
    {
      return NULL;
    }
  hwc_gs_t* gs = NULL;
  if (lvl == 0)
    {
      gs = (hwc_gs_t*) &topo->hwcs[id];
    }
  else if (lvl == topo->socket_level)
    {
      gs = (hwc_gs_t*) &topo->sockets[mctop_id_no_lvl(id)];
    }
  else
    {
      hwc_gs_t* _gs = mctop_get_first_gs_at_lvl(topo, lvl);
      while (_gs != NULL)
	{
	  if (unlikely(_gs->id == id))
	    {
	      gs = _gs;
	      break;
	    }
	  _gs = _gs->next;
	}
    }

  return gs;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movl %esi, -0x14(%rbp)
movl -0x14(%rbp), %edi
callq 0xc610
movl %eax, -0x18(%rbp)
movl -0x18(%rbp), %eax
movq -0x10(%rbp), %rcx
cmpl (%rcx), %eax
jbe 0xc542
movq $0x0, -0x8(%rbp)
jmp 0xc5fb
movq $0x0, -0x20(%rbp)
cmpl $0x0, -0x18(%rbp)
jne 0xc56b
movq -0x10(%rbp), %rax
movq 0x40(%rax), %rax
movl -0x14(%rbp), %ecx
imulq $0x30, %rcx, %rcx
addq %rcx, %rax
movq %rax, -0x20(%rbp)
jmp 0xc5f3
movl -0x18(%rbp), %eax
movq -0x10(%rbp), %rcx
cmpl 0x14(%rcx), %eax
jne 0xc5a3
movq -0x10(%rbp), %rax
movq 0x20(%rax), %rax
movq %rax, -0x30(%rbp)
movl -0x14(%rbp), %edi
callq 0xc630
movl %eax, %ecx
movq -0x30(%rbp), %rax
movl %ecx, %ecx
imulq $0xa8, %rcx, %rcx
addq %rcx, %rax
movq %rax, -0x20(%rbp)
jmp 0xc5f1
movq -0x10(%rbp), %rdi
movl -0x18(%rbp), %esi
callq 0xbb10
movq %rax, -0x28(%rbp)
cmpq $0x0, -0x28(%rbp)
je 0xc5ef
movq -0x28(%rbp), %rax
movl (%rax), %eax
cmpl -0x14(%rbp), %eax
sete %al
xorb $-0x1, %al
xorb $-0x1, %al
andb $0x1, %al
movzbl %al, %eax
cltq
cmpq $0x0, %rax
je 0xc5e1
movq -0x28(%rbp), %rax
movq %rax, -0x20(%rbp)
jmp 0xc5ef
movq -0x28(%rbp), %rax
movq 0x20(%rax), %rax
movq %rax, -0x28(%rbp)
jmp 0xc5b3
jmp 0xc5f1
jmp 0xc5f3
movq -0x20(%rbp), %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/LPD-EPFL[P]mctop/src/mctop_control.c
// Function: mctop_ids_get_latency
uint
mctop_ids_get_latency(mctop_t* topo, const uint id0, const uint id1)
{
  hwc_gs_t* gs0 = mctop_id_get_hwc_gs(topo, id0);
  hwc_gs_t* gs1 = mctop_id_get_hwc_gs(topo, id1);
  if (gs0 == NULL || gs1 == NULL)
    {
      return 0;
    }

  while (gs0->level < gs1->level)
    {
      gs0 = gs0->parent;
    }
  while (gs1->level < gs0->level)
    {
      gs1 = gs1->parent;
    }

  if (unlikely(gs0->id == gs1->id))
    {
      if (gs0->level == 0)
	{
	  return 0;
	}
      else
	{
	  return gs0->latency;
	}
    }

  while (gs0->type != SOCKET && gs1->type != SOCKET)
    {
      gs0 = gs0->parent;
      gs1 = gs1->parent;
      if (gs0->id == gs1->id)
	{
	  return gs0->latency;
	}
    }


  sibling_t* sibling = mctop_get_sibling_with_sockets(topo, gs0, gs1);
  return sibling->latency;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x10(%rbp)
movl %esi, -0x14(%rbp)
movl %edx, -0x18(%rbp)
movq -0x10(%rbp), %rdi
movl -0x14(%rbp), %esi
callq 0xc510
movq %rax, -0x20(%rbp)
movq -0x10(%rbp), %rdi
movl -0x18(%rbp), %esi
callq 0xc510
movq %rax, -0x28(%rbp)
cmpq $0x0, -0x20(%rbp)
je 0xc690
cmpq $0x0, -0x28(%rbp)
jne 0xc69c
movl $0x0, -0x4(%rbp)
jmp 0xc799
jmp 0xc69e
movq -0x20(%rbp), %rax
movl 0x4(%rax), %eax
movq -0x28(%rbp), %rcx
cmpl 0x4(%rcx), %eax
jae 0xc6bc
movq -0x20(%rbp), %rax
movq 0x18(%rax), %rax
movq %rax, -0x20(%rbp)
jmp 0xc69e
jmp 0xc6be
movq -0x28(%rbp), %rax
movl 0x4(%rax), %eax
movq -0x20(%rbp), %rcx
cmpl 0x4(%rcx), %eax
jae 0xc6dc
movq -0x28(%rbp), %rax
movq 0x18(%rax), %rax
movq %rax, -0x28(%rbp)
jmp 0xc6be
movq -0x20(%rbp), %rax
movl (%rax), %eax
movq -0x28(%rbp), %rcx
cmpl (%rcx), %eax
sete %al
xorb $-0x1, %al
xorb $-0x1, %al
andb $0x1, %al
movzbl %al, %eax
cltq
cmpq $0x0, %rax
je 0xc71e
movq -0x20(%rbp), %rax
cmpl $0x0, 0x4(%rax)
jne 0xc712
movl $0x0, -0x4(%rbp)
jmp 0xc799
movq -0x20(%rbp), %rax
movl 0xc(%rax), %eax
movl %eax, -0x4(%rbp)
jmp 0xc799
jmp 0xc720
movq -0x20(%rbp), %rcx
xorl %eax, %eax
cmpl $0x3, 0x8(%rcx)
movb %al, -0x31(%rbp)
je 0xc73d
movq -0x28(%rbp), %rax
cmpl $0x3, 0x8(%rax)
setne %al
movb %al, -0x31(%rbp)
movb -0x31(%rbp), %al
testb $0x1, %al
jne 0xc746
jmp 0xc77a
movq -0x20(%rbp), %rax
movq 0x18(%rax), %rax
movq %rax, -0x20(%rbp)
movq -0x28(%rbp), %rax
movq 0x18(%rax), %rax
movq %rax, -0x28(%rbp)
movq -0x20(%rbp), %rax
movl (%rax), %eax
movq -0x28(%rbp), %rcx
cmpl (%rcx), %eax
jne 0xc778
movq -0x20(%rbp), %rax
movl 0xc(%rax), %eax
movl %eax, -0x4(%rbp)
jmp 0xc799
jmp 0xc720
movq -0x10(%rbp), %rdi
movq -0x20(%rbp), %rsi
movq -0x28(%rbp), %rdx
callq 0xbc90
movq %rax, -0x30(%rbp)
movq -0x30(%rbp), %rax
movl 0x8(%rax), %eax
movl %eax, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x40, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/LPD-EPFL[P]mctop/src/mctop_control.c
// Function: mctop_run_on_socket_ref
int
mctop_run_on_socket_ref(socket_t* socket, const uint fix_mem)
{
  int ret = 0;
  if (socket == NULL)
    {
      return -EINVAL;
    }

#ifdef __x86_64__
  struct bitmask* bmask = numa_bitmask_alloc(socket->topo->n_hwcs);
  for (int i = 0; i < socket->n_hwcs; i++) 
    {
      bmask = numa_bitmask_setbit(bmask, socket->hwcs[i]->id);
    }

  ret = numa_sched_setaffinity(0, bmask);
  if (fix_mem && !ret && socket->topo->has_mem)
    {
      numa_set_preferred(socket->local_node);
    }
  numa_bitmask_free(bmask);
#else
  ret = mctop_run_on_node(socket->topo, socket->local_node);
#endif
  return ret;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movl %esi, -0x14(%rbp)
movl $0x0, -0x18(%rbp)
cmpq $0x0, -0x10(%rbp)
jne 0xc7d9
movl $0xffffffea, -0x4(%rbp) # imm = 0xFFFFFFEA
jmp 0xc86d
movq -0x10(%rbp), %rax
movq 0x48(%rax), %rax
movl 0x10(%rax), %edi
callq 0x21d0
movq %rax, -0x20(%rbp)
movl $0x0, -0x24(%rbp)
movl -0x24(%rbp), %eax
movq -0x10(%rbp), %rcx
cmpl 0x28(%rcx), %eax
jae 0xc82a
movq -0x20(%rbp), %rdi
movq -0x10(%rbp), %rax
movq 0x30(%rax), %rax
movslq -0x24(%rbp), %rcx
movq (%rax,%rcx,8), %rax
movl (%rax), %esi
callq 0x2170
movq %rax, -0x20(%rbp)
movl -0x24(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x24(%rbp)
jmp 0xc7f4
movq -0x20(%rbp), %rsi
xorl %edi, %edi
callq 0x2150
movl %eax, -0x18(%rbp)
cmpl $0x0, -0x14(%rbp)
je 0xc85e
cmpl $0x0, -0x18(%rbp)
jne 0xc85e
movq -0x10(%rbp), %rax
movq 0x48(%rax), %rax
cmpl $0x0, 0x30(%rax)
je 0xc85e
movq -0x10(%rbp), %rax
movl 0x6c(%rax), %edi
callq 0x2270
movq -0x20(%rbp), %rdi
callq 0x22f0
movl -0x18(%rbp), %eax
movl %eax, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/LPD-EPFL[P]mctop/src/mctop_control.c
// Function: mctop_run_on_socket
int
mctop_run_on_socket(mctop_t* topo, const uint socket_n)
{
  if (socket_n >= topo->n_sockets)
    {
      return -EINVAL;
    }
  socket_t* socket = &topo->sockets[socket_n];
  return mctop_run_on_socket_ref(socket, 0);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movl %esi, -0x14(%rbp)
movl -0x14(%rbp), %eax
movq -0x10(%rbp), %rcx
cmpl 0x18(%rcx), %eax
jb 0xc8a4
movl $0xffffffea, -0x4(%rbp) # imm = 0xFFFFFFEA
jmp 0xc8cb
movq -0x10(%rbp), %rax
movq 0x20(%rax), %rax
movl -0x14(%rbp), %ecx
imulq $0xa8, %rcx, %rcx
addq %rcx, %rax
movq %rax, -0x20(%rbp)
movq -0x20(%rbp), %rdi
xorl %esi, %esi
callq 0xc7b0
movl %eax, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/LPD-EPFL[P]mctop/src/mctop_control.c
// Function: mctop_run_on_socket_nm
int
mctop_run_on_socket_nm(mctop_t* topo, const uint socket_n)
{
  if (socket_n >= topo->n_sockets)
    {
      return -EINVAL;
    }
  socket_t* socket = &topo->sockets[socket_n];
  return mctop_run_on_socket_ref(socket, 0);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movl %esi, -0x14(%rbp)
movl -0x14(%rbp), %eax
movq -0x10(%rbp), %rcx
cmpl 0x18(%rcx), %eax
jb 0xc904
movl $0xffffffea, -0x4(%rbp) # imm = 0xFFFFFFEA
jmp 0xc92b
movq -0x10(%rbp), %rax
movq 0x20(%rax), %rax
movl -0x14(%rbp), %ecx
imulq $0xa8, %rcx, %rcx
addq %rcx, %rax
movq %rax, -0x20(%rbp)
movq -0x20(%rbp), %rdi
xorl %esi, %esi
callq 0xc7b0
movl %eax, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/LPD-EPFL[P]mctop/src/mctop_control.c
// Function: mctop_run_on_node
int
mctop_run_on_node(mctop_t* topo, const uint node_n)
{
#if __x86_64__
  if (node_n >= topo->n_sockets)
    {
      return -EINVAL;
    }

  const uint socket_n = topo->node_to_socket[node_n];
  socket_t* socket = &topo->sockets[socket_n];
  return mctop_run_on_socket_ref(socket, 0);
#elif __sparc
  return numa_run_on_node(node_n);
#endif
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movl %esi, -0x14(%rbp)
movl -0x14(%rbp), %eax
movq -0x10(%rbp), %rcx
cmpl 0x18(%rcx), %eax
jb 0xc964
movl $0xffffffea, -0x4(%rbp) # imm = 0xFFFFFFEA
jmp 0xc99c
movq -0x10(%rbp), %rax
movq 0x38(%rax), %rax
movl -0x14(%rbp), %ecx
movl (%rax,%rcx,4), %eax
movl %eax, -0x18(%rbp)
movq -0x10(%rbp), %rax
movq 0x20(%rax), %rax
movl -0x18(%rbp), %ecx
imulq $0xa8, %rcx, %rcx
addq %rcx, %rax
movq %rax, -0x20(%rbp)
movq -0x20(%rbp), %rdi
xorl %esi, %esi
callq 0xc7b0
movl %eax, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/LPD-EPFL[P]mctop/src/mctop_control.c
// Function: mctop_set_cpu
int
mctop_set_cpu(mctop_t* topo, int cpu) 
{
  int ret = 1;
#if defined(__sparc__)
  if (processor_bind(P_LWPID, P_MYID, cpu, NULL) == -1)
    {
      /* printf("Problem with setting processor affinity: %s\n", */
      /* 	     strerror(errno)); */
      ret = 0;
    }
#elif defined(__tile__)
  if (tmc_cpus_set_my_cpu(tmc_cpus_find_nth_cpu(&cpus, cpu)) < 0)
    {
      tmc_task_die("Failure in 'tmc_cpus_set_my_cpu()'.");
    }

  if (cpu != tmc_cpus_get_my_cpu())
    {
      PRINT("******* i am not CPU %d", tmc_cpus_get_my_cpu());
    }

#else
  cpu_set_t mask;
  CPU_ZERO(&mask);
  CPU_SET(cpu, &mask);
  if (sched_setaffinity(0, sizeof(cpu_set_t), &mask) != 0)
    {
      /* printf("Problem with setting processor affinity: %s\n", */
      /* 	     strerror(errno)); */
      ret = 0;
    }

  if (likely(topo != NULL))
    {
      mctop_hwcid_fix_numa_node(topo, cpu);
    }
#endif

  return ret;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0xb0, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movl $0x1, -0x10(%rbp)
leaq -0x90(%rbp), %rdi
xorl %esi, %esi
movl $0x80, %edx
callq 0x20f0
movslq -0xc(%rbp), %rax
movq %rax, -0x98(%rbp)
movq -0x98(%rbp), %rax
shrq $0x3, %rax
cmpq $0x80, %rax
jae 0xca31
movq -0x98(%rbp), %rcx
andq $0x3f, %rcx
movl $0x1, %eax
shlq %cl, %rax
movq -0x98(%rbp), %rcx
shrq $0x6, %rcx
orq -0x90(%rbp,%rcx,8), %rax
movq %rax, -0x90(%rbp,%rcx,8)
movq %rax, -0xa8(%rbp)
jmp 0xca3c
xorl %eax, %eax
movq %rax, -0xa8(%rbp)
jmp 0xca3c
movq -0xa8(%rbp), %rax
movq %rax, -0xa0(%rbp)
xorl %edi, %edi
movl $0x80, %esi
leaq -0x90(%rbp), %rdx
callq 0x2100
cmpl $0x0, %eax
je 0xca69
movl $0x0, -0x10(%rbp)
cmpq $0x0, -0x8(%rbp)
setne %al
xorb $-0x1, %al
xorb $-0x1, %al
andb $0x1, %al
movzbl %al, %eax
cltq
cmpq $0x0, %rax
je 0xca8e
movq -0x8(%rbp), %rdi
movl -0xc(%rbp), %esi
callq 0xc190
movl -0x10(%rbp), %eax
addq $0xb0, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/LPD-EPFL[P]mctop/src/mctop_aux.c
// Function: table_malloc
void**
table_malloc(const size_t rows, const size_t cols, const size_t elem_size)
{
  void** m = malloc_assert(rows * sizeof(uint64_t*));
  for (int s = 0; s < rows; s++)
    {
      m[s] = malloc_assert(cols * elem_size);
    }

  return m;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x8(%rbp), %rdi
shlq $0x3, %rdi
callq 0xcb10
movq %rax, -0x20(%rbp)
movl $0x0, -0x24(%rbp)
movslq -0x24(%rbp), %rax
cmpq -0x8(%rbp), %rax
jae 0xcafe
movq -0x10(%rbp), %rdi
imulq -0x18(%rbp), %rdi
callq 0xcb10
movq %rax, %rdx
movq -0x20(%rbp), %rax
movslq -0x24(%rbp), %rcx
movq %rdx, (%rax,%rcx,8)
movl -0x24(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x24(%rbp)
jmp 0xcacc
movq -0x20(%rbp), %rax
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/LPD-EPFL[P]mctop/src/mctop_aux.c
// Function: table_calloc
void**
table_calloc(const size_t rows, const size_t cols, const size_t elem_size)
{
  void** m = malloc_assert(rows * sizeof(uint64_t*));
  for (int s = 0; s < rows; s++)
    {
      m[s] = calloc_assert(cols, elem_size);
    }

  return m;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x8(%rbp), %rdi
shlq $0x3, %rdi
callq 0xcb10
movq %rax, -0x20(%rbp)
movl $0x0, -0x24(%rbp)
movslq -0x24(%rbp), %rax
cmpq -0x8(%rbp), %rax
jae 0xcbbd
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rsi
callq 0xcbd0
movq %rax, %rdx
movq -0x20(%rbp), %rax
movslq -0x24(%rbp), %rcx
movq %rdx, (%rax,%rcx,8)
movl -0x24(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x24(%rbp)
jmp 0xcb8c
movq -0x20(%rbp), %rax
addq $0x30, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/LPD-EPFL[P]mctop/src/mctop_aux.c
// Function: table_free
void
table_free(void** m, const size_t cols)
{
  for (int s = 0; s < cols; s++)
    {
      free(m[s]);
    }
  free(m);
  m = NULL;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl $0x0, -0x14(%rbp)
movslq -0x14(%rbp), %rax
cmpq -0x10(%rbp), %rax
jae 0xcc6d
movq -0x8(%rbp), %rax
movslq -0x14(%rbp), %rcx
movq (%rax,%rcx,8), %rdi
callq 0x2030
movl -0x14(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x14(%rbp)
jmp 0xcc47
movq -0x8(%rbp), %rdi
callq 0x2030
movq $0x0, -0x8(%rbp)
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
nop
// File: /workspace/github_c_makefile_star2_O0/LPD-EPFL[P]mctop/src/mctop_load.c
// Function: mctop_dtype_get
static mctop_dtype_t
mctop_dtype_get(const char* in)
{
  for (int i = 0; i < MCTOP_DTYPE_N; i++)
    {
      if (strcmp(in, mctop_dtypes[i]) == 0)
	{
	  return (mctop_dtype_t) i;
	}
    }
  return UKNOWN;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movl $0x0, -0x14(%rbp)
cmpl $0x8, -0x14(%rbp)
jge 0xd68b
movq -0x10(%rbp), %rdi
movslq -0x14(%rbp), %rcx
leaq 0x7bd8(%rip), %rax      # 0x15240
movq (%rax,%rcx,8), %rsi
callq 0x2130
cmpl $0x0, %eax
jne 0xd67e
movl -0x14(%rbp), %eax
movl %eax, -0x4(%rbp)
jmp 0xd692
jmp 0xd680
movl -0x14(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x14(%rbp)
jmp 0xd653
movl $0x7, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/LPD-EPFL[P]mctop/src/mctop_load.c
// Function: mctop_load_mem_lat
static uint
mctop_load_mem_lat(FILE* ifile, const uint n_hwcs, const uint n_sockets, uint64_t** mem_lat_table)
{
  for (uint x = 0; x < (n_hwcs * n_sockets); x++)
    {
      uint xc, yc, mlat;
      if (fscanf(ifile, "%u %u %u", &xc, &yc, &mlat) != 3)
	{
	  return 0;
	}
      mem_lat_table[xc][yc] = mlat;
    }
  return 1;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movl %esi, -0x14(%rbp)
movl %edx, -0x18(%rbp)
movq %rcx, -0x20(%rbp)
movl $0x0, -0x24(%rbp)
movl -0x24(%rbp), %eax
movl -0x14(%rbp), %ecx
imull -0x18(%rbp), %ecx
cmpl %ecx, %eax
jae 0xd719
movq -0x10(%rbp), %rdi
leaq 0x3beb(%rip), %rsi      # 0x112c1
leaq -0x28(%rbp), %rdx
leaq -0x2c(%rbp), %rcx
leaq -0x30(%rbp), %r8
movb $0x0, %al
callq 0x2050
cmpl $0x3, %eax
je 0xd6f7
movl $0x0, -0x4(%rbp)
jmp 0xd720
movl -0x30(%rbp), %eax
movl %eax, %edx
movq -0x20(%rbp), %rax
movl -0x28(%rbp), %ecx
movq (%rax,%rcx,8), %rax
movl -0x2c(%rbp), %ecx
movq %rdx, (%rax,%rcx,8)
movl -0x24(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x24(%rbp)
jmp 0xd6bd
movl $0x1, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/LPD-EPFL[P]mctop/src/mctop_load.c
// Function: mctop_load_mem_bw
static uint
mctop_load_mem_bw(FILE* ifile, const uint n_sockets, double** bw_table)
{
  for (uint x = 0; x < (n_sockets * n_sockets); x++)
    {
      uint xc, yc;
      double bw;
      if (fscanf(ifile, "%u %u %lf", &xc, &yc, &bw) != 3)
	{
	  return 0;
	}
      bw_table[xc][yc] = bw;
    }
  return 1;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x10(%rbp)
movl %esi, -0x14(%rbp)
movq %rdx, -0x20(%rbp)
movl $0x0, -0x24(%rbp)
movl -0x24(%rbp), %eax
movl -0x14(%rbp), %ecx
imull -0x14(%rbp), %ecx
cmpl %ecx, %eax
jae 0xd7a7
movq -0x10(%rbp), %rdi
leaq 0x3c35(%rip), %rsi      # 0x11398
leaq -0x28(%rbp), %rdx
leaq -0x2c(%rbp), %rcx
leaq -0x38(%rbp), %r8
movb $0x0, %al
callq 0x2050
cmpl $0x3, %eax
je 0xd784
movl $0x0, -0x4(%rbp)
jmp 0xd7ae
movsd -0x38(%rbp), %xmm0
movq -0x20(%rbp), %rax
movl -0x28(%rbp), %ecx
movq (%rax,%rcx,8), %rax
movl -0x2c(%rbp), %ecx
movsd %xmm0, (%rax,%rcx,8)
movl -0x24(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x24(%rbp)
jmp 0xd74a
movl $0x1, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x40, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/LPD-EPFL[P]mctop/src/mctop_load.c
// Function: mctop_load_cache_info
static mctop_cache_info_t*
mctop_load_cache_info(mctop_cache_info_t* existing, FILE* ifile, const uint n_levels)
{
  mctop_cache_info_t* mci = mctop_cache_info_create(n_levels);
  for (int i = 0; i < n_levels; i++)
    {
      char null[4][100];
      int l;
      uint64_t lat, size_OS, size_est;
      if(fscanf(ifile, "%s %d %s %zu %s %zu %s %zu",
		null[0], &l, null[1], &lat, null[2], &size_OS, null[3], &size_est) != 8)
	{
	  mctop_cache_info_free(mci);
	  return existing;
	}
      mci->latencies[i] = lat;
      mci->sizes_OS[i] = size_OS;
      mci->sizes_estimated[i] = size_est;
    }

  if (existing != NULL)
    {
      mctop_cache_info_free(existing);
    }

  return mci;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %rbx
subq $0x208, %rsp            # imm = 0x208
movq %rdi, -0x18(%rbp)
movq %rsi, -0x20(%rbp)
movl %edx, -0x24(%rbp)
movl -0x24(%rbp), %edi
callq 0xb0b0
movq %rax, -0x30(%rbp)
movl $0x0, -0x34(%rbp)
movl -0x34(%rbp), %eax
cmpl -0x24(%rbp), %eax
jae 0xd8d0
movq -0x20(%rbp), %rdi
leaq -0x1d0(%rbp), %rdx
leaq -0x1d0(%rbp), %r8
addq $0x64, %r8
leaq -0x1d0(%rbp), %rbx
addq $0xc8, %rbx
leaq -0x1d0(%rbp), %r10
addq $0x12c, %r10            # imm = 0x12C
leaq 0x3b73(%rip), %rsi      # 0x113a2
leaq -0x1d4(%rbp), %rcx
leaq -0x1e0(%rbp), %r9
leaq -0x1e8(%rbp), %r11
leaq -0x1f0(%rbp), %rax
movq %rbx, (%rsp)
movq %r11, 0x8(%rsp)
movq %r10, 0x10(%rsp)
movq %rax, 0x18(%rsp)
movb $0x0, %al
callq 0x2050
cmpl $0x8, %eax
je 0xd87d
movq -0x30(%rbp), %rdi
callq 0xb130
movq -0x18(%rbp), %rax
movq %rax, -0x10(%rbp)
jmp 0xd8e8
movq -0x1e0(%rbp), %rdx
movq -0x30(%rbp), %rax
movq 0x8(%rax), %rax
movslq -0x34(%rbp), %rcx
movq %rdx, (%rax,%rcx,8)
movq -0x1e8(%rbp), %rdx
movq -0x30(%rbp), %rax
movq 0x10(%rax), %rax
movslq -0x34(%rbp), %rcx
movq %rdx, (%rax,%rcx,8)
movq -0x1f0(%rbp), %rdx
movq -0x30(%rbp), %rax
movq 0x18(%rax), %rax
movslq -0x34(%rbp), %rcx
movq %rdx, (%rax,%rcx,8)
movl -0x34(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x34(%rbp)
jmp 0xd7ea
cmpq $0x0, -0x18(%rbp)
je 0xd8e0
movq -0x18(%rbp), %rdi
callq 0xb130
movq -0x30(%rbp), %rax
movq %rax, -0x10(%rbp)
movq -0x10(%rbp), %rax
addq $0x208, %rsp            # imm = 0x208
popq %rbx
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/LPD-EPFL[P]mctop/src/mctop_load.c
// Function: mctop_load_pow_info
static uint
mctop_load_pow_info(FILE* ifile, const uint n_sockets, double*** pm)
{
  for (uint s = 0; s <= n_sockets; s++)
    {
      char nothing[40];
      double pow[MCTOP_POW_COMP_TYPE_NUM];
      for (uint type = 0; type < MCTOP_POW_TYPE_NUM; type++)
	{
	  if (fscanf(ifile, "%s %lf %lf %lf %lf %lf", nothing, &pow[0], &pow[1], &pow[2], &pow[3], &pow[4]) != 6)
	    {
	      return 0;
	    }
	  __copy_doubles(pm[type][s], pow, MCTOP_POW_COMP_TYPE_NUM, 1);
	}
    }
  return 1;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0xa0, %rsp
movq %rdi, -0x10(%rbp)
movl %esi, -0x14(%rbp)
movq %rdx, -0x20(%rbp)
movl $0x0, -0x24(%rbp)
movl -0x24(%rbp), %eax
cmpl -0x14(%rbp), %eax
ja 0xd9dd
movl $0x0, -0x84(%rbp)
cmpl $0x6, -0x84(%rbp)
jae 0xd9cd
movq -0x10(%rbp), %rdi
leaq -0x50(%rbp), %rdx
leaq -0x80(%rbp), %rcx
leaq -0x80(%rbp), %r8
addq $0x8, %r8
leaq -0x80(%rbp), %r9
addq $0x10, %r9
leaq -0x80(%rbp), %r10
addq $0x18, %r10
leaq -0x80(%rbp), %rax
addq $0x20, %rax
leaq 0x3a4a(%rip), %rsi      # 0x113bd
movq %r10, (%rsp)
movq %rax, 0x8(%rsp)
movb $0x0, %al
callq 0x2050
cmpl $0x6, %eax
je 0xd991
movl $0x0, -0x4(%rbp)
jmp 0xd9e4
movq -0x20(%rbp), %rax
movl -0x84(%rbp), %ecx
movq (%rax,%rcx,8), %rax
movl -0x24(%rbp), %ecx
movq (%rax,%rcx,8), %rdi
leaq -0x80(%rbp), %rsi
movl $0x5, %edx
movl $0x1, %ecx
callq 0xd9f0
movl -0x84(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x84(%rbp)
jmp 0xd933
jmp 0xd9cf
movl -0x24(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x24(%rbp)
jmp 0xd91d
movl $0x1, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0xa0, %rsp
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O0/LPD-EPFL[P]mctop/src/mctop_cache.c
// Function: mctop_cache_size_read_OS
static int
mctop_cache_size_read_OS(size_t* sizes)
{
  int ret = 1;
  char file[100];
  for (int i = 0; i < mctop_cache_n_lvls + 1; i++)
    {
      sprintf(file, "/sys/devices/system/cpu/cpu0/cache/index%d/size", i);
      FILE* fd = fopen(file, "r");
      if (fd == NULL)
	{
	  fprintf(stderr, "MCTOP Warning: Can't open %s!\n", file);
	  ret = 0;
	  continue;
	}

      uint size;
      int read = fscanf(fd, "%uK", &size);
      if (read != 1)
	{
	  ret = 0;
	  fprintf(stderr, "MCTOP Warning: Can't read %s!\n", file);
	}
      else
	{
	  sizes[i] = size;
	}

      fclose(fd);
    }

  return ret;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x90, %rsp
movq %rdi, -0x8(%rbp)
movl $0x1, -0xc(%rbp)
movl $0x0, -0x74(%rbp)
movslq -0x74(%rbp), %rax
cmpq $0x4, %rax
jae 0xdfc8
leaq -0x70(%rbp), %rdi
movl -0x74(%rbp), %edx
leaq 0x359f(%rip), %rsi      # 0x114a8
movb $0x0, %al
callq 0x2280
leaq -0x70(%rbp), %rdi
leaq 0x32ea(%rip), %rsi      # 0x11205
callq 0x2210
movq %rax, -0x80(%rbp)
cmpq $0x0, -0x80(%rbp)
jne 0xdf50
movq 0x70c6(%rip), %rax      # 0x14ff8
movq (%rax), %rdi
leaq -0x70(%rbp), %rdx
leaq 0x3598(%rip), %rsi      # 0x114d8
movb $0x0, %al
callq 0x2140
movl $0x0, -0xc(%rbp)
jmp 0xdfba
movq -0x80(%rbp), %rdi
leaq 0x359c(%rip), %rsi      # 0x114f7
leaq -0x84(%rbp), %rdx
movb $0x0, %al
callq 0x2050
movl %eax, -0x88(%rbp)
cmpl $0x1, -0x88(%rbp)
je 0xdf9d
movl $0x0, -0xc(%rbp)
movq 0x7072(%rip), %rax      # 0x14ff8
movq (%rax), %rdi
leaq -0x70(%rbp), %rdx
leaq 0x3567(%rip), %rsi      # 0x114fb
movb $0x0, %al
callq 0x2140
jmp 0xdfb1
movl -0x84(%rbp), %eax
movl %eax, %edx
movq -0x8(%rbp), %rax
movslq -0x74(%rbp), %rcx
movq %rdx, (%rax,%rcx,8)
movq -0x80(%rbp), %rdi
callq 0x20b0
movl -0x74(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x74(%rbp)
jmp 0xdeed
movl -0xc(%rbp), %eax
addq $0x90, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/LPD-EPFL[P]mctop/src/mctop_cache.c
// Function: ll_random_latency
static ticks
ll_random_latency(const size_t size_bytes)
{
  const size_t n_reps_min = 1e6;

  uint64_t* mem;
  int ret = posix_memalign((void**) &mem, CACHE_LINE_SIZE, size_bytes);
  assert(ret == 0 && mem != NULL);

  ll_random_create(mem, size_bytes);

  const size_t n_reps = size_bytes > n_reps_min ? size_bytes : n_reps_min;
  ticks lat = ll_random_traverse(mem, n_reps);

  free(mem);
  return lat;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x8(%rbp)
movq $0xf4240, -0x10(%rbp)   # imm = 0xF4240
movq -0x8(%rbp), %rdx
leaq -0x18(%rbp), %rdi
movl $0x40, %esi
callq 0x22b0
movl %eax, -0x1c(%rbp)
cmpl $0x0, -0x1c(%rbp)
jne 0xe078
cmpq $0x0, -0x18(%rbp)
je 0xe078
jmp 0xe097
leaq 0x349b(%rip), %rdi      # 0x1151a
leaq 0x34ac(%rip), %rsi      # 0x11532
movl $0x11, %edx
leaq 0x34b2(%rip), %rcx      # 0x11544
callq 0x20e0
movq -0x18(%rbp), %rdi
movq -0x8(%rbp), %rsi
callq 0x6f20
cmpq $0xf4240, -0x8(%rbp)    # imm = 0xF4240
jbe 0xe0b8
movq -0x8(%rbp), %rax
movq %rax, -0x38(%rbp)
jmp 0xe0c3
movl $0xf4240, %eax          # imm = 0xF4240
movq %rax, -0x38(%rbp)
jmp 0xe0c3
movq -0x38(%rbp), %rax
movq %rax, -0x28(%rbp)
movq -0x18(%rbp), %rdi
movq -0x28(%rbp), %rsi
callq 0x6e70
movq %rax, -0x30(%rbp)
movq -0x18(%rbp), %rdi
callq 0x2030
movq -0x30(%rbp), %rax
addq $0x40, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/LPD-EPFL[P]mctop/src/mctop_cache.c
// Function: array_get_min
ticks
array_get_min(ticks* a, const int len)
{
  ticks min = a[0];
  for (size_t i = 1; i < len; i++)
    {
      if (a[i] < min)
	{
	  min = a[i];
	}
    }

  return min;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movq -0x8(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x18(%rbp)
movq $0x1, -0x20(%rbp)
movq -0x20(%rbp), %rax
movslq -0xc(%rbp), %rcx
cmpq %rcx, %rax
jae 0xe14d
movq -0x8(%rbp), %rax
movq -0x20(%rbp), %rcx
movq (%rax,%rcx,8), %rax
cmpq -0x18(%rbp), %rax
jae 0xe13d
movq -0x8(%rbp), %rax
movq -0x20(%rbp), %rcx
movq (%rax,%rcx,8), %rax
movq %rax, -0x18(%rbp)
jmp 0xe13f
movq -0x20(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x20(%rbp)
jmp 0xe10e
movq -0x18(%rbp), %rax
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/samtools[P]htslib/test/test_faidx.c
// Function: load_index
faidx_t * load_index(const char *fn, const char *fnfai, const char *fngzi,
                     int flags, enum fai_format_options format) {
    faidx_t *fai = fai_load3_format(fn, fnfai, fngzi, flags, format);
    if (!fai) {
        fprintf(stderr, "Failed: fai_load3(%s, %s, %s, %d, %d)\n",
                fn, fnfai ? fnfai : "NULL", fngzi ? fngzi : "NULL", flags,
                (int) format);
        return NULL;
    }
    return fai;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x60, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movl %ecx, -0x24(%rbp)
movl %r8d, -0x28(%rbp)
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rsi
movq -0x20(%rbp), %rdx
movl -0x24(%rbp), %ecx
movl -0x28(%rbp), %r8d
callq 0x7b50
movq %rax, -0x30(%rbp)
cmpq $0x0, -0x30(%rbp)
jne 0x5e1e
movq 0xff23f(%rip), %rax     # 0x104fd8
movq (%rax), %rax
movq %rax, -0x40(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x38(%rbp)
cmpq $0x0, -0x18(%rbp)
je 0x5db9
movq -0x18(%rbp), %rax
movq %rax, -0x48(%rbp)
jmp 0x5dc6
leaq 0xe373e(%rip), %rax     # 0xe94fe
movq %rax, -0x48(%rbp)
jmp 0x5dc6
movq -0x48(%rbp), %rax
movq %rax, -0x50(%rbp)
cmpq $0x0, -0x20(%rbp)
je 0x5ddf
movq -0x20(%rbp), %rax
movq %rax, -0x58(%rbp)
jmp 0x5dec
leaq 0xe3718(%rip), %rax     # 0xe94fe
movq %rax, -0x58(%rbp)
jmp 0x5dec
movq -0x50(%rbp), %rcx
movq -0x38(%rbp), %rdx
movq -0x40(%rbp), %rdi
movq -0x58(%rbp), %r8
movl -0x24(%rbp), %r9d
movl -0x28(%rbp), %eax
leaq 0xe12c0(%rip), %rsi     # 0xe70ca
movl %eax, (%rsp)
movb $0x0, %al
callq 0x46e0
movq $0x0, -0x8(%rbp)
jmp 0x5e26
movq -0x30(%rbp), %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x60, %rsp
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O0/samtools[P]htslib/test/test_faidx.c
// Function: test_fai_line_length
int test_fai_line_length(const char *fn, const char *fnfai, const char *fngzi,
                         enum fai_format_options format, const char *expected,
                         const char *reg) {
    hts_pos_t found_len;
    faidx_t *fai = NULL;

    fai = load_index(fn, fnfai, fngzi, 0, format);
    if (!fai)
        return -1;

    found_len = fai_line_length(fai, reg);
    fai_destroy(fai);
    if (expected) {
        long long exp_len = strtoll(expected, NULL, 10);
        if (found_len != exp_len) {
            fprintf(stderr, "Unexpected result %"PRIhts_pos" from "
                    "fai_line_length, expected %s\n", found_len, expected);
            return -1;
        }
    } else {
        printf("%"PRIhts_pos"\n", found_len);
    }
    return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movl %ecx, -0x24(%rbp)
movq %r8, -0x30(%rbp)
movq %r9, -0x38(%rbp)
movq $0x0, -0x48(%rbp)
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rsi
movq -0x20(%rbp), %rdx
movl -0x24(%rbp), %r8d
xorl %ecx, %ecx
callq 0x5d50
movq %rax, -0x48(%rbp)
cmpq $0x0, -0x48(%rbp)
jne 0x6655
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
jmp 0x66da
movq -0x48(%rbp), %rdi
movq -0x38(%rbp), %rsi
callq 0x7bc0
movq %rax, -0x40(%rbp)
movq -0x48(%rbp), %rdi
callq 0x6fe0
cmpq $0x0, -0x30(%rbp)
je 0x66c1
movq -0x30(%rbp), %rdi
xorl %eax, %eax
movl %eax, %esi
movl $0xa, %edx
callq 0x40a0
movq %rax, -0x50(%rbp)
movq -0x40(%rbp), %rax
cmpq -0x50(%rbp), %rax
je 0x66bf
movq 0xfe93b(%rip), %rax     # 0x104fd8
movq (%rax), %rdi
movq -0x40(%rbp), %rdx
movq -0x30(%rbp), %rcx
leaq 0xe0be8(%rip), %rsi     # 0xe7297
movb $0x0, %al
callq 0x46e0
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
jmp 0x66da
jmp 0x66d3
movq -0x40(%rbp), %rsi
leaq 0xe0b69(%rip), %rdi     # 0xe7235
movb $0x0, %al
callq 0x4060
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x50, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/samtools[P]htslib/test/test_faidx.c
// Function: test_faidx_has_seq
int test_faidx_has_seq(const char *fn, const char *fnfai, const char *fngzi,
                       enum fai_format_options format, const char *expected,
                       const char *seq) {
    int res;
    faidx_t *fai = NULL;

    fai = load_index(fn, fnfai, fngzi, 0, format);
    if (!fai)
        return -1;

    res = faidx_has_seq(fai, seq);
    fai_destroy(fai);
    if (expected) {
        long exp_res = strtol(expected, NULL, 10);
        if (res != exp_res) {
            fprintf(stderr, "Unexpected result %d from faidx_has_seq(%s) "
                    "expected %s\n", res, seq, expected);
            return -1;
        }
    } else {
        printf("%d\n", res);
    }
    return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movl %ecx, -0x24(%rbp)
movq %r8, -0x30(%rbp)
movq %r9, -0x38(%rbp)
movq $0x0, -0x48(%rbp)
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rsi
movq -0x20(%rbp), %rdx
movl -0x24(%rbp), %r8d
xorl %ecx, %ecx
callq 0x5d50
movq %rax, -0x48(%rbp)
cmpq $0x0, -0x48(%rbp)
jne 0x6745
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
jmp 0x67cb
movq -0x48(%rbp), %rdi
movq -0x38(%rbp), %rsi
callq 0x8960
movl %eax, -0x3c(%rbp)
movq -0x48(%rbp), %rdi
callq 0x6fe0
cmpq $0x0, -0x30(%rbp)
je 0x67b3
movq -0x30(%rbp), %rdi
xorl %eax, %eax
movl %eax, %esi
movl $0xa, %edx
callq 0x46b0
movq %rax, -0x50(%rbp)
movslq -0x3c(%rbp), %rax
cmpq -0x50(%rbp), %rax
je 0x67b1
movq 0xfe84c(%rip), %rax     # 0x104fd8
movq (%rax), %rdi
movl -0x3c(%rbp), %edx
movq -0x38(%rbp), %rcx
movq -0x30(%rbp), %r8
leaq 0xe0b2f(%rip), %rsi     # 0xe72d0
movb $0x0, %al
callq 0x46e0
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
jmp 0x67cb
jmp 0x67c4
movl -0x3c(%rbp), %esi
leaq 0xe6a71(%rip), %rdi     # 0xed22e
movb $0x0, %al
callq 0x4060
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x50, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/samtools[P]htslib/test/test_faidx.c
// Function: test_faidx_iseq
int test_faidx_iseq(const char *fn, const char *fnfai, const char *fngzi,
                    enum fai_format_options format, const char *expected,
                    const char *index) {
    const char *found_name = NULL;
    int idx = atoi(index);
    faidx_t *fai = NULL;

    fai = load_index(fn, fnfai, fngzi, 0, format);
    if (!fai)
        return -1;

    found_name = faidx_iseq(fai, idx);

    if (expected) {
        if (!found_name || strcmp(found_name, expected) != 0) {
            fprintf(stderr, "Unexpected result %s from faidx_iseq(fai, %d), "
                    "expected %s\n", found_name ? found_name : "(null)",
                    idx, expected);
            fai_destroy(fai);
            return -1;
        }
    } else {
        printf("%s\n", found_name ? found_name : "(null)");
    }

    fai_destroy(fai);
    return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x70, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movl %ecx, -0x24(%rbp)
movq %r8, -0x30(%rbp)
movq %r9, -0x38(%rbp)
movq $0x0, -0x40(%rbp)
movq -0x38(%rbp), %rdi
callq 0x47d0
movl %eax, -0x44(%rbp)
movq $0x0, -0x50(%rbp)
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rsi
movq -0x20(%rbp), %rdx
movl -0x24(%rbp), %r8d
xorl %ecx, %ecx
callq 0x5d50
movq %rax, -0x50(%rbp)
cmpq $0x0, -0x50(%rbp)
jne 0x6849
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
jmp 0x6916
movq -0x50(%rbp), %rdi
movl -0x44(%rbp), %esi
callq 0x82c0
movq %rax, -0x40(%rbp)
cmpq $0x0, -0x30(%rbp)
je 0x68d6
cmpq $0x0, -0x40(%rbp)
je 0x6879
movq -0x40(%rbp), %rdi
movq -0x30(%rbp), %rsi
callq 0x46a0
cmpl $0x0, %eax
je 0x68d4
movq 0xfe758(%rip), %rax     # 0x104fd8
movq (%rax), %rax
movq %rax, -0x58(%rbp)
cmpq $0x0, -0x40(%rbp)
je 0x6898
movq -0x40(%rbp), %rax
movq %rax, -0x60(%rbp)
jmp 0x68a5
leaq 0xe0aa6(%rip), %rax     # 0xe7345
movq %rax, -0x60(%rbp)
jmp 0x68a5
movq -0x58(%rbp), %rdi
movq -0x60(%rbp), %rdx
movl -0x44(%rbp), %ecx
movq -0x30(%rbp), %r8
leaq 0xe0a4e(%rip), %rsi     # 0xe7309
movb $0x0, %al
callq 0x46e0
movq -0x50(%rbp), %rdi
callq 0x6fe0
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
jmp 0x6916
jmp 0x6906
cmpq $0x0, -0x40(%rbp)
je 0x68e7
movq -0x40(%rbp), %rax
movq %rax, -0x68(%rbp)
jmp 0x68f4
leaq 0xe0a57(%rip), %rax     # 0xe7345
movq %rax, -0x68(%rbp)
jmp 0x68f4
movq -0x68(%rbp), %rsi
leaq 0xe84f3(%rip), %rdi     # 0xeedf2
movb $0x0, %al
callq 0x4060
movq -0x50(%rbp), %rdi
callq 0x6fe0
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x70, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/samtools[P]htslib/test/test_faidx.c
// Function: test_faidx_seq_len
int test_faidx_seq_len(const char *fn, const char *fnfai, const char *fngzi,
                       enum fai_format_options format, const char *expected,
                       const char *seq) {
    int found_len;
    faidx_t *fai = NULL;

    fai = load_index(fn, fnfai, fngzi, 0, format);
    if (!fai)
        return -1;

    found_len = faidx_seq_len(fai, seq);
    fai_destroy(fai);

    if (expected) {
        int exp_len = atoi(expected);
        if (found_len != exp_len) {
            fprintf(stderr, "Unexpected result %d from faidx_seq_len(fai, %s) "
                    "expected %s\n", found_len, seq, expected);
            return -1;
        }
    } else {
        printf("%d\n", found_len);
    }

    return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movl %ecx, -0x24(%rbp)
movq %r8, -0x30(%rbp)
movq %r9, -0x38(%rbp)
movq $0x0, -0x48(%rbp)
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rsi
movq -0x20(%rbp), %rdx
movl -0x24(%rbp), %r8d
xorl %ecx, %ecx
callq 0x5d50
movq %rax, -0x48(%rbp)
cmpq $0x0, -0x48(%rbp)
jne 0x6972
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
jmp 0x69ec
movq -0x48(%rbp), %rdi
movq -0x38(%rbp), %rsi
callq 0x84a0
movl %eax, -0x3c(%rbp)
movq -0x48(%rbp), %rdi
callq 0x6fe0
cmpq $0x0, -0x30(%rbp)
je 0x69d4
movq -0x30(%rbp), %rdi
callq 0x47d0
movl %eax, -0x4c(%rbp)
movl -0x3c(%rbp), %eax
cmpl -0x4c(%rbp), %eax
je 0x69d2
movq 0xfe62b(%rip), %rax     # 0x104fd8
movq (%rax), %rdi
movl -0x3c(%rbp), %edx
movq -0x38(%rbp), %rcx
movq -0x30(%rbp), %r8
leaq 0xe098a(%rip), %rsi     # 0xe734c
movb $0x0, %al
callq 0x46e0
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
jmp 0x69ec
jmp 0x69e5
movl -0x3c(%rbp), %esi
leaq 0xe6850(%rip), %rdi     # 0xed22e
movb $0x0, %al
callq 0x4060
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x50, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/samtools[P]htslib/test/test_faidx.c
// Function: test_faidx_seq_len64
int test_faidx_seq_len64(const char *fn, const char *fnfai, const char *fngzi,
                         enum fai_format_options format, const char *expected,
                         const char *seq) {
    hts_pos_t found_len;
    faidx_t *fai = NULL;

    fai = load_index(fn, fnfai, fngzi, 0, format);
    if (!fai)
        return -1;

    found_len = faidx_seq_len(fai, seq);
    fai_destroy(fai);

    if (expected) {
        long long exp_len = strtoll(expected, NULL, 10);
        if (found_len != exp_len) {
            fprintf(stderr, "Unexpected result %"PRIhts_pos
                    " from fai_seq_len64(fai, %s) expected %s\n",
                    found_len, seq, expected);
            return -1;
        }
    } else {
        printf("%"PRIhts_pos"\n", found_len);
    }

    return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movl %ecx, -0x24(%rbp)
movq %r8, -0x30(%rbp)
movq %r9, -0x38(%rbp)
movq $0x0, -0x48(%rbp)
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rsi
movq -0x20(%rbp), %rdx
movl -0x24(%rbp), %r8d
xorl %ecx, %ecx
callq 0x5d50
movq %rax, -0x48(%rbp)
cmpq $0x0, -0x48(%rbp)
jne 0x6a55
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
jmp 0x6ae0
movq -0x48(%rbp), %rdi
movq -0x38(%rbp), %rsi
callq 0x84a0
cltq
movq %rax, -0x40(%rbp)
movq -0x48(%rbp), %rdi
callq 0x6fe0
cmpq $0x0, -0x30(%rbp)
je 0x6ac7
movq -0x30(%rbp), %rdi
xorl %eax, %eax
movl %eax, %esi
movl $0xa, %edx
callq 0x40a0
movq %rax, -0x50(%rbp)
movq -0x40(%rbp), %rax
cmpq -0x50(%rbp), %rax
je 0x6ac5
movq 0xfe539(%rip), %rax     # 0x104fd8
movq (%rax), %rdi
movq -0x40(%rbp), %rdx
movq -0x38(%rbp), %rcx
movq -0x30(%rbp), %r8
leaq 0xe08d5(%rip), %rsi     # 0xe738a
movb $0x0, %al
callq 0x46e0
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
jmp 0x6ae0
jmp 0x6ad9
movq -0x40(%rbp), %rsi
leaq 0xe0763(%rip), %rdi     # 0xe7235
movb $0x0, %al
callq 0x4060
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x50, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/samtools[P]htslib/test/test_faidx.c
// Function: usage
void usage(FILE *out, const char *arg0) {
    fprintf(out,
            "Usage: %s [-c] -i fasta/q [-f fai_file] [-g gzi_file] [-e expected_fai]\n"
            "       %s [-cQ] -i fasta/q [-f fai_file] [-g gzi_file] [region]\n"
            "       %s -t FUNC -i fasta/q [-f fai_file] [-g gzi_file] [-e expected] <PARAM>\n"
            "       %s -h\n",
            arg0, arg0, arg0, arg0);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rdx
movq -0x10(%rbp), %rcx
movq -0x10(%rbp), %r8
movq -0x10(%rbp), %r9
leaq 0xe08ae(%rip), %rsi     # 0xe73c9
movb $0x0, %al
callq 0x46e0
addq $0x10, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/minoki[P]icfpc2006/run_directthreaded_tailcall.c
// Function: OP_CondMove
void OP_CondMove(PARAMS)
{
    uint32_t op = arr0->data[pc];
    uint32_t a = (op >> 6) & 7;
    uint32_t b = (op >> 3) & 7;
    uint32_t c = op & 7;
    if (reg[c] != 0) {
        reg[a] = reg[b];
    }
    ++pc;
    MUSTTAIL return program[pc](ARGS);
}

// Assembly:
movq %rdi, -0x8(%rsp)
movq %rsi, -0x10(%rsp)
movq -0x10(%rsp), %rax
movq -0x8(%rsp), %rcx
movl 0x4(%rax,%rcx,4), %eax
movl %eax, -0x14(%rsp)
movl -0x14(%rsp), %eax
shrl $0x6, %eax
andl $0x7, %eax
movl %eax, -0x18(%rsp)
movl -0x14(%rsp), %eax
shrl $0x3, %eax
andl $0x7, %eax
movl %eax, -0x1c(%rsp)
movl -0x14(%rsp), %eax
andl $0x7, %eax
movl %eax, -0x20(%rsp)
movl -0x20(%rsp), %eax
movl %eax, %ecx
leaq 0x3e30(%rip), %rax      # 0x50d0
cmpl $0x0, (%rax,%rcx,4)
je 0x12c6
movl -0x1c(%rsp), %eax
movl %eax, %ecx
leaq 0x3e1d(%rip), %rax      # 0x50d0
movl (%rax,%rcx,4), %edx
movl -0x18(%rsp), %eax
movl %eax, %ecx
leaq 0x3e0d(%rip), %rax      # 0x50d0
movl %edx, (%rax,%rcx,4)
movq -0x8(%rsp), %rax
incq %rax
movq %rax, -0x8(%rsp)
movq 0x3e2e(%rip), %rax      # 0x5108
movq -0x8(%rsp), %rdi
movq (%rax,%rdi,8), %rax
movq -0x10(%rsp), %rsi
jmpq *%rax
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/minoki[P]icfpc2006/run_directthreaded_tailcall.c
// Function: OP_ArrayIndex
void OP_ArrayIndex(PARAMS)
{
    uint32_t op = arr0->data[pc];
    uint32_t a = (op >> 6) & 7;
    uint32_t b = (op >> 3) & 7;
    uint32_t c = op & 7;
    uint32_t i = reg[b];
    assert(i < arrsize);
    struct array *ai = arr[i];
    assert(ai != NULL);
    assert(reg[c] < ai->length);
    reg[a] = ai->data[reg[c]];
    ++pc;
    MUSTTAIL return program[pc](ARGS);
}

// Assembly:
subq $0x38, %rsp
movq %rdi, 0x30(%rsp)
movq %rsi, 0x28(%rsp)
movq 0x28(%rsp), %rax
movq 0x30(%rsp), %rcx
movl 0x4(%rax,%rcx,4), %eax
movl %eax, 0x24(%rsp)
movl 0x24(%rsp), %eax
shrl $0x6, %eax
andl $0x7, %eax
movl %eax, 0x20(%rsp)
movl 0x24(%rsp), %eax
shrl $0x3, %eax
andl $0x7, %eax
movl %eax, 0x1c(%rsp)
movl 0x24(%rsp), %eax
andl $0x7, %eax
movl %eax, 0x18(%rsp)
movl 0x1c(%rsp), %eax
movl %eax, %ecx
leaq 0x3d8c(%rip), %rax      # 0x50d0
movl (%rax,%rcx,4), %eax
movl %eax, 0x14(%rsp)
movl 0x14(%rsp), %eax
cmpq 0x3d62(%rip), %rax      # 0x50b8
jae 0x135a
jmp 0x1379
leaq 0x1ca3(%rip), %rdi      # 0x3004
leaq 0x1ca8(%rip), %rsi      # 0x3010
movl $0x3b, %edx
leaq 0x1cba(%rip), %rcx      # 0x302e
callq 0x1080
movq 0x3d90(%rip), %rax      # 0x5110
movl 0x14(%rsp), %ecx
movq (%rax,%rcx,8), %rax
movq %rax, 0x8(%rsp)
cmpq $0x0, 0x8(%rsp)
je 0x1397
jmp 0x13b6
leaq 0x1cbb(%rip), %rdi      # 0x3059
leaq 0x1c6b(%rip), %rsi      # 0x3010
movl $0x3d, %edx
leaq 0x1c7d(%rip), %rcx      # 0x302e
callq 0x1080
movl 0x18(%rsp), %eax
movl %eax, %ecx
leaq 0x3d0d(%rip), %rax      # 0x50d0
movl (%rax,%rcx,4), %eax
movq 0x8(%rsp), %rcx
cmpl (%rcx), %eax
jae 0x13d1
jmp 0x13f0
leaq 0x1c8c(%rip), %rdi      # 0x3064
leaq 0x1c31(%rip), %rsi      # 0x3010
movl $0x3e, %edx
leaq 0x1c43(%rip), %rcx      # 0x302e
callq 0x1080
movq 0x8(%rsp), %rcx
movl 0x18(%rsp), %eax
movl %eax, %edx
leaq 0x3cce(%rip), %rax      # 0x50d0
movl (%rax,%rdx,4), %edx
movl 0x4(%rcx,%rdx,4), %edx
movl 0x20(%rsp), %ecx
movl %edx, (%rax,%rcx,4)
movq 0x30(%rsp), %rax
incq %rax
movq %rax, 0x30(%rsp)
movq 0x3ce4(%rip), %rax      # 0x5108
movq 0x30(%rsp), %rdi
movq (%rax,%rdi,8), %rax
movq 0x28(%rsp), %rsi
addq $0x38, %rsp
jmpq *%rax
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/minoki[P]icfpc2006/run_directthreaded_tailcall.c
// Function: OP_ArrayAmendment
void OP_ArrayAmendment(PARAMS)
{
    uint32_t op = arr0->data[pc];
    uint32_t a = (op >> 6) & 7;
    uint32_t b = (op >> 3) & 7;
    uint32_t c = op & 7;
    uint32_t i = reg[a];
    assert(i < arrsize);
    struct array *ai = arr[i];
    assert(ai != NULL);
    assert(reg[b] < ai->length);
    ai->data[reg[b]] = reg[c];
    if (i == 0) {
        program[reg[b]] = operations[reg[c] >> 28];
    }
    ++pc;
    MUSTTAIL return program[pc](ARGS);
}

// Assembly:
subq $0x38, %rsp
movq %rdi, 0x30(%rsp)
movq %rsi, 0x28(%rsp)
movq 0x28(%rsp), %rax
movq 0x30(%rsp), %rcx
movl 0x4(%rax,%rcx,4), %eax
movl %eax, 0x24(%rsp)
movl 0x24(%rsp), %eax
shrl $0x6, %eax
andl $0x7, %eax
movl %eax, 0x20(%rsp)
movl 0x24(%rsp), %eax
shrl $0x3, %eax
andl $0x7, %eax
movl %eax, 0x1c(%rsp)
movl 0x24(%rsp), %eax
andl $0x7, %eax
movl %eax, 0x18(%rsp)
movl 0x20(%rsp), %eax
movl %eax, %ecx
leaq 0x3c3c(%rip), %rax      # 0x50d0
movl (%rax,%rcx,4), %eax
movl %eax, 0x14(%rsp)
movl 0x14(%rsp), %eax
cmpq 0x3c12(%rip), %rax      # 0x50b8
jae 0x14aa
jmp 0x14c9
leaq 0x1b53(%rip), %rdi      # 0x3004
leaq 0x1b58(%rip), %rsi      # 0x3010
movl $0x4a, %edx
leaq 0x1bb4(%rip), %rcx      # 0x3078
callq 0x1080
movq 0x3c40(%rip), %rax      # 0x5110
movl 0x14(%rsp), %ecx
movq (%rax,%rcx,8), %rax
movq %rax, 0x8(%rsp)
cmpq $0x0, 0x8(%rsp)
je 0x14e7
jmp 0x1506
leaq 0x1b6b(%rip), %rdi      # 0x3059
leaq 0x1b1b(%rip), %rsi      # 0x3010
movl $0x4c, %edx
leaq 0x1b77(%rip), %rcx      # 0x3078
callq 0x1080
movl 0x1c(%rsp), %eax
movl %eax, %ecx
leaq 0x3bbd(%rip), %rax      # 0x50d0
movl (%rax,%rcx,4), %eax
movq 0x8(%rsp), %rcx
cmpl (%rcx), %eax
jae 0x1521
jmp 0x1540
leaq 0x1b7f(%rip), %rdi      # 0x30a7
leaq 0x1ae1(%rip), %rsi      # 0x3010
movl $0x4d, %edx
leaq 0x1b3d(%rip), %rcx      # 0x3078
callq 0x1080
movl 0x18(%rsp), %eax
movl %eax, %ecx
leaq 0x3b83(%rip), %rax      # 0x50d0
movl (%rax,%rcx,4), %edx
movq 0x8(%rsp), %rax
movl 0x1c(%rsp), %ecx
movl %ecx, %esi
leaq 0x3b6e(%rip), %rcx      # 0x50d0
movl (%rcx,%rsi,4), %ecx
movl %edx, 0x4(%rax,%rcx,4)
cmpl $0x0, 0x14(%rsp)
jne 0x15ad
movl 0x18(%rsp), %eax
movl %eax, %ecx
leaq 0x3b53(%rip), %rax      # 0x50d0
movl (%rax,%rcx,4), %eax
shrl $0x1c, %eax
movl %eax, %eax
movl %eax, %ecx
leaq 0x37d2(%rip), %rax      # 0x4d60
movq (%rax,%rcx,8), %rdx
movq 0x3b6f(%rip), %rax      # 0x5108
movl 0x1c(%rsp), %ecx
movl %ecx, %esi
leaq 0x3b2a(%rip), %rcx      # 0x50d0
movl (%rcx,%rsi,4), %ecx
movq %rdx, (%rax,%rcx,8)
movq 0x30(%rsp), %rax
incq %rax
movq %rax, 0x30(%rsp)
movq 0x3b47(%rip), %rax      # 0x5108
movq 0x30(%rsp), %rdi
movq (%rax,%rdi,8), %rax
movq 0x28(%rsp), %rsi
addq $0x38, %rsp
jmpq *%rax
nopw %cs:(%rax,%rax)