LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O0/pavel-demin[P]ft8d-c/pffft.c
// Function: unreversed_copy
static void unreversed_copy(int N, const v4sf *in, v4sf *out, int out_stride) {
  v4sf g0, g1, h0, h1;
  int k;
  g0 = g1 = in[0]; ++in;
  for (k=1; k < N; ++k) {
    h0 = *in++; h1 = *in++;
    g1 = VSWAPHL(g1, h0);
    h0 = VSWAPHL(h0, h1);
    UNINTERLEAVE2(h0, g1, out[0], out[1]); out += out_stride;
    g1 = h1;
  }
  h0 = *in++; h1 = g0;
  g1 = VSWAPHL(g1, h0);
  h0 = VSWAPHL(h0, h1);
  UNINTERLEAVE2(h0, g1, out[0], out[1]);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movl %edi, -0x4(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movl %ecx, -0x1c(%rbp)
movq -0x10(%rbp), %rax
movaps (%rax), %xmm0
movaps %xmm0, -0x40(%rbp)
movaps %xmm0, -0x30(%rbp)
movq -0x10(%rbp), %rax
addq $0x10, %rax
movq %rax, -0x10(%rbp)
movl $0x1, -0x64(%rbp)
movl -0x64(%rbp), %eax
cmpl -0x4(%rbp), %eax
jge 0x7140
movq -0x10(%rbp), %rax
movq %rax, %rcx
addq $0x10, %rcx
movq %rcx, -0x10(%rbp)
movaps (%rax), %xmm0
movaps %xmm0, -0x50(%rbp)
movq -0x10(%rbp), %rax
movq %rax, %rcx
addq $0x10, %rcx
movq %rcx, -0x10(%rbp)
movaps (%rax), %xmm0
movaps %xmm0, -0x60(%rbp)
movapd -0x50(%rbp), %xmm1
movapd -0x40(%rbp), %xmm0
movsd %xmm1, %xmm0            # xmm0 = xmm1[0],xmm0[1]
movapd %xmm0, -0x40(%rbp)
movapd -0x60(%rbp), %xmm1
movapd -0x50(%rbp), %xmm0
movsd %xmm1, %xmm0            # xmm0 = xmm1[0],xmm0[1]
movapd %xmm0, -0x50(%rbp)
movaps -0x50(%rbp), %xmm0
movaps -0x40(%rbp), %xmm1
shufps $0x88, %xmm1, %xmm0     # xmm0 = xmm0[0,2],xmm1[0,2]
movaps %xmm0, -0x80(%rbp)
movaps -0x50(%rbp), %xmm0
movaps -0x40(%rbp), %xmm1
shufps $0xdd, %xmm1, %xmm0     # xmm0 = xmm0[1,3],xmm1[1,3]
movq -0x18(%rbp), %rax
movaps %xmm0, 0x10(%rax)
movaps -0x80(%rbp), %xmm0
movq -0x18(%rbp), %rax
movaps %xmm0, (%rax)
movl -0x1c(%rbp), %ecx
movq -0x18(%rbp), %rax
movslq %ecx, %rcx
shlq $0x4, %rcx
addq %rcx, %rax
movq %rax, -0x18(%rbp)
movaps -0x60(%rbp), %xmm0
movaps %xmm0, -0x40(%rbp)
movl -0x64(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x64(%rbp)
jmp 0x7088
movq -0x10(%rbp), %rax
movq %rax, %rcx
addq $0x10, %rcx
movq %rcx, -0x10(%rbp)
movaps (%rax), %xmm0
movaps %xmm0, -0x50(%rbp)
movaps -0x30(%rbp), %xmm0
movaps %xmm0, -0x60(%rbp)
movapd -0x50(%rbp), %xmm1
movapd -0x40(%rbp), %xmm0
movsd %xmm1, %xmm0            # xmm0 = xmm1[0],xmm0[1]
movapd %xmm0, -0x40(%rbp)
movapd -0x60(%rbp), %xmm1
movapd -0x50(%rbp), %xmm0
movsd %xmm1, %xmm0            # xmm0 = xmm1[0],xmm0[1]
movapd %xmm0, -0x50(%rbp)
movaps -0x50(%rbp), %xmm0
movaps -0x40(%rbp), %xmm1
shufps $0x88, %xmm1, %xmm0     # xmm0 = xmm0[0,2],xmm1[0,2]
movaps %xmm0, -0x90(%rbp)
movaps -0x50(%rbp), %xmm0
movaps -0x40(%rbp), %xmm1
shufps $0xdd, %xmm1, %xmm0     # xmm0 = xmm0[1,3],xmm1[1,3]
movq -0x18(%rbp), %rax
movaps %xmm0, 0x10(%rax)
movaps -0x90(%rbp), %xmm0
movq -0x18(%rbp), %rax
movaps %xmm0, (%rax)
addq $0x10, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/pavel-demin[P]ft8d-c/ft8d.c
// Function: max
real_t max(real_t a, real_t b, real_t c, real_t d)
{
  real_t x, y;
  x = a > b ? a : b;
  y = c > d ? c : d;
  return x > y ? x : y;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movss %xmm0, -0x4(%rbp)
movss %xmm1, -0x8(%rbp)
movss %xmm2, -0xc(%rbp)
movss %xmm3, -0x10(%rbp)
movss -0x4(%rbp), %xmm0
ucomiss -0x8(%rbp), %xmm0
jbe 0x1663f
movss -0x4(%rbp), %xmm0
movss %xmm0, -0x1c(%rbp)
jmp 0x16649
movss -0x8(%rbp), %xmm0
movss %xmm0, -0x1c(%rbp)
movss -0x1c(%rbp), %xmm0
movss %xmm0, -0x14(%rbp)
movss -0xc(%rbp), %xmm0
ucomiss -0x10(%rbp), %xmm0
jbe 0x1666a
movss -0xc(%rbp), %xmm0
movss %xmm0, -0x20(%rbp)
jmp 0x16674
movss -0x10(%rbp), %xmm0
movss %xmm0, -0x20(%rbp)
movss -0x20(%rbp), %xmm0
movss %xmm0, -0x18(%rbp)
movss -0x14(%rbp), %xmm0
ucomiss -0x18(%rbp), %xmm0
jbe 0x16695
movss -0x14(%rbp), %xmm0
movss %xmm0, -0x24(%rbp)
jmp 0x1669f
movss -0x18(%rbp), %xmm0
movss %xmm0, -0x24(%rbp)
movss -0x24(%rbp), %xmm0
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/pavel-demin[P]ft8d-c/ft8d.c
// Function: check
int check()
{
  int i, j;
  uint8_t poly[15] = {1, 1, 0, 0, 1, 1, 1, 0, 1, 0, 1, 0, 1, 1, 1 };
  uint8_t data[96] = {0};

  memcpy(data, message, 77);

  for(i = 0; i < 82; ++i)
  {
    if(data[i])
    {
      for(j = 0; j < 15; ++j)
      {
        data[i + j] ^= poly[j];
      }
    }
  }

  for(i = 0; i < 14; ++i)
  {
    if(data[82 + i] != message[77 + i]) return 0;
  }

  return 1;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x80, %rsp
movq 0x2236(%rip), %rax      # 0x18c58
movq %rax, -0x1b(%rbp)
movl 0x2234(%rip), %eax      # 0x18c60
movl %eax, -0x13(%rbp)
movw 0x222e(%rip), %ax       # 0x18c64
movw %ax, -0xf(%rbp)
movb 0x2226(%rip), %al       # 0x18c66
movb %al, -0xd(%rbp)
leaq -0x80(%rbp), %rdi
xorl %esi, %esi
movl $0x60, %edx
callq 0x10a0
leaq -0x80(%rbp), %rdi
leaq 0x6a62(%rip), %rsi      # 0x1d4c0
movl $0x4d, %edx
callq 0x10e0
movl $0x0, -0x8(%rbp)
cmpl $0x52, -0x8(%rbp)
jge 0x16ac3
movslq -0x8(%rbp), %rax
cmpb $0x0, -0x80(%rbp,%rax)
je 0x16ab6
movl $0x0, -0xc(%rbp)
cmpl $0xf, -0xc(%rbp)
jge 0x16ab4
movslq -0xc(%rbp), %rax
movzbl -0x1b(%rbp,%rax), %edx
movl -0x8(%rbp), %eax
addl -0xc(%rbp), %eax
cltq
movzbl -0x80(%rbp,%rax), %ecx
xorl %edx, %ecx
movb %cl, -0x80(%rbp,%rax)
movl -0xc(%rbp), %eax
addl $0x1, %eax
movl %eax, -0xc(%rbp)
jmp 0x16a87
jmp 0x16ab6
jmp 0x16ab8
movl -0x8(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x8(%rbp)
jmp 0x16a6f
movl $0x0, -0x8(%rbp)
cmpl $0xe, -0x8(%rbp)
jge 0x16b0b
movl -0x8(%rbp), %eax
addl $0x52, %eax
cltq
movzbl -0x80(%rbp,%rax), %eax
movl -0x8(%rbp), %ecx
addl $0x4d, %ecx
movslq %ecx, %rdx
leaq 0x69d3(%rip), %rcx      # 0x1d4c0
movzbl (%rcx,%rdx), %ecx
cmpl %ecx, %eax
je 0x16afe
movl $0x0, -0x4(%rbp)
jmp 0x16b12
jmp 0x16b00
movl -0x8(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x8(%rbp)
jmp 0x16aca
movl $0x1, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x80, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/pavel-demin[P]ft8d-c/ft8d.c
// Function: trim
void trim(char *s)
{
  char *p = s;
  int l = strlen(p);

  while(isspace(p[l - 1])) p[--l] = 0;
  while(*p && isspace(*p)) ++p, --l;

  memmove(s, p, l + 1);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x10(%rbp)
movq -0x10(%rbp), %rdi
callq 0x1060
movl %eax, -0x14(%rbp)
callq 0x1160
movq (%rax), %rax
movq -0x10(%rbp), %rcx
movl -0x14(%rbp), %edx
subl $0x1, %edx
movslq %edx, %rdx
movsbl (%rcx,%rdx), %ecx
movslq %ecx, %rcx
movzwl (%rax,%rcx,2), %eax
andl $0x2000, %eax           # imm = 0x2000
cmpl $0x0, %eax
je 0x171d0
movq -0x10(%rbp), %rax
movl -0x14(%rbp), %ecx
addl $-0x1, %ecx
movl %ecx, -0x14(%rbp)
movslq %ecx, %rcx
movb $0x0, (%rax,%rcx)
jmp 0x17190
jmp 0x171d2
movq -0x10(%rbp), %rax
movsbl (%rax), %ecx
xorl %eax, %eax
cmpl $0x0, %ecx
movb %al, -0x15(%rbp)
je 0x17207
callq 0x1160
movq (%rax), %rax
movq -0x10(%rbp), %rcx
movsbl (%rcx), %ecx
movslq %ecx, %rcx
movzwl (%rax,%rcx,2), %eax
andl $0x2000, %eax           # imm = 0x2000
cmpl $0x0, %eax
setne %al
movb %al, -0x15(%rbp)
movb -0x15(%rbp), %al
testb $0x1, %al
jne 0x17210
jmp 0x17227
movq -0x10(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x10(%rbp)
movl -0x14(%rbp), %eax
addl $-0x1, %eax
movl %eax, -0x14(%rbp)
jmp 0x171d2
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
movl -0x14(%rbp), %eax
addl $0x1, %eax
movslq %eax, %rdx
callq 0x1110
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/ohkimur[P]the-c-programming-language-2nd-edition-solutions/chapter_5/exercise_5_11/detab.c
// Function: main
int main(int argc, char *argv[])
{
  if (!is_tab_stop_arg_list_valid(argc, argv))
  {
    puts("Error: invalid tab stop list.\n");
    return EXIT_FAILURE;
  }

  int c;
  size_t arg_pos = 1;
  size_t line_pos = 0;
  size_t tab_stop = DEFAULT_TAB_LENGTH;
  size_t nr_of_spaces;
  size_t nr_of_custom_tab_stops = argc - 1;

  while ((c = getchar()) != EOF)
  {
    if (c == '\t')
    {
      if (nr_of_custom_tab_stops)
      {
        tab_stop = atoi(argv[arg_pos++]);
        --nr_of_custom_tab_stops;
      }
      else if (argc > 1)
      {
        tab_stop = 1;
      }

      nr_of_spaces = tab_stop - line_pos % tab_stop;

      while (nr_of_spaces)
      {
        putchar(' ');
        ++line_pos;
        --nr_of_spaces;
      }
    }
    else
    {
      putchar(c);
      ++line_pos;

      if (c == '\n')
      {
        arg_pos = 1;
        line_pos = 0;
        nr_of_custom_tab_stops = argc - 1;
      }
    }
  }

  return EXIT_SUCCESS;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movl $0x0, -0x4(%rbp)
movl %edi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl -0x8(%rbp), %edi
movq -0x10(%rbp), %rsi
callq 0x12f0
cmpl $0x0, %eax
jne 0x11cf
leaq 0xe46(%rip), %rdi       # 0x2004
callq 0x1040
movl $0x1, -0x4(%rbp)
jmp 0x12e5
movq $0x1, -0x20(%rbp)
movq $0x0, -0x28(%rbp)
movq $0x8, -0x30(%rbp)
movl -0x8(%rbp), %eax
subl $0x1, %eax
cltq
movq %rax, -0x40(%rbp)
callq 0x1060
movl %eax, -0x14(%rbp)
cmpl $-0x1, %eax
je 0x12de
cmpl $0x9, -0x14(%rbp)
jne 0x12a1
cmpq $0x0, -0x40(%rbp)
je 0x1245
movq -0x10(%rbp), %rax
movq -0x20(%rbp), %rcx
movq %rcx, %rdx
addq $0x1, %rdx
movq %rdx, -0x20(%rbp)
movq (%rax,%rcx,8), %rdi
callq 0x1070
cltq
movq %rax, -0x30(%rbp)
movq -0x40(%rbp), %rax
addq $-0x1, %rax
movq %rax, -0x40(%rbp)
jmp 0x1255
cmpl $0x1, -0x8(%rbp)
jle 0x1253
movq $0x1, -0x30(%rbp)
jmp 0x1255
movq -0x30(%rbp), %rax
movq %rax, -0x48(%rbp)
movq -0x28(%rbp), %rax
xorl %ecx, %ecx
movl %ecx, %edx
divq -0x30(%rbp)
movq -0x48(%rbp), %rax
subq %rdx, %rax
movq %rax, -0x38(%rbp)
cmpq $0x0, -0x38(%rbp)
je 0x129f
movl $0x20, %edi
callq 0x1030
movq -0x28(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x28(%rbp)
movq -0x38(%rbp), %rax
addq $-0x1, %rax
movq %rax, -0x38(%rbp)
jmp 0x1274
jmp 0x12d9
movl -0x14(%rbp), %edi
callq 0x1030
movq -0x28(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x28(%rbp)
cmpl $0xa, -0x14(%rbp)
jne 0x12d7
movq $0x1, -0x20(%rbp)
movq $0x0, -0x28(%rbp)
movl -0x8(%rbp), %eax
subl $0x1, %eax
cltq
movq %rax, -0x40(%rbp)
jmp 0x12d9
jmp 0x11f3
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x50, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/rsa9000[P]regfanalysistools/regfdump.c
// Function: regf_parse_hbin
static int regf_parse_hbin(unsigned off)
{
	const struct regf_hbin *hbin = st.data + off;
	int res;

	if (strncmp(hbin->sign, "hbin", 4) != 0) {
		fprintf(stderr, "%s: unexpected 0x%08X hbin signature '%.4s'\n",
			__func__, off, hbin->sign);
		return -1;
	}

	printf("hbin.{off,sz,timestamp} = 0x%08X, 0x%08X, 0x%016"PRIX64"\n",
	       hbin->off, hbin->sz, hbin->timestamp);

	res = regf_parse_cells(off, hbin->sz);
	if (res) {
		fprintf(stderr, "%s: could not parse cells of 0x%08X hbin\n",
			__func__, off);
		return -1;
	}

	return hbin->sz;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movl %edi, -0x8(%rbp)
movq 0x673e(%rip), %rax      # 0x80f0
movl -0x8(%rbp), %ecx
addq %rcx, %rax
movq %rax, -0x10(%rbp)
movq -0x10(%rbp), %rdi
leaq 0x396b(%rip), %rsi      # 0x5332
movl $0x4, %edx
callq 0x1040
cmpl $0x0, %eax
je 0x1a05
movq 0x661b(%rip), %rax      # 0x7ff8
movq (%rax), %rdi
movl -0x8(%rbp), %ecx
movq -0x10(%rbp), %r8
leaq 0x390c(%rip), %rsi      # 0x52fa
leaq 0x3932(%rip), %rdx      # 0x5327
movb $0x0, %al
callq 0x10d0
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
jmp 0x1a76
movq -0x10(%rbp), %rax
movl 0x4(%rax), %esi
movq -0x10(%rbp), %rax
movl 0x8(%rax), %edx
movq -0x10(%rbp), %rax
movq 0x18(%rax), %rcx
leaq 0x3915(%rip), %rdi      # 0x5337
movb $0x0, %al
callq 0x1090
movl -0x8(%rbp), %edi
movq -0x10(%rbp), %rax
movl 0x8(%rax), %esi
callq 0x1c90
movl %eax, -0x14(%rbp)
cmpl $0x0, -0x14(%rbp)
je 0x1a6c
movq 0x65b0(%rip), %rax      # 0x7ff8
movq (%rax), %rdi
movl -0x8(%rbp), %ecx
leaq 0x3916(%rip), %rsi      # 0x536b
leaq 0x38cb(%rip), %rdx      # 0x5327
movb $0x0, %al
callq 0x10d0
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
jmp 0x1a76
movq -0x10(%rbp), %rax
movl 0x8(%rax), %eax
movl %eax, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x20, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/rsa9000[P]regfanalysistools/regfdump.c
// Function: regf_parse_sk
static int regf_parse_sk(const char *pref, unsigned off)
{
	const struct regf_cell *rc = st.data + off;
	const struct regf_sk *sk = (void *)rc->data;

	printf("%ssk.{prev,next} = 0x%08X, 0x%08X\n", pref, sk->prev, sk->next);
	printf("%ssk.refcnt = 0x%08X\n", pref, sk->refcnt);

	return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movq 0x5d1a(%rip), %rax      # 0x80f0
movl -0xc(%rbp), %ecx
addq %rcx, %rax
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rax
addq $0x4, %rax
movq %rax, -0x20(%rbp)
movq -0x8(%rbp), %rsi
movq -0x20(%rbp), %rax
movl 0x4(%rax), %edx
movq -0x20(%rbp), %rax
movl 0x8(%rax), %ecx
leaq 0x34eb(%rip), %rdi      # 0x58f0
movb $0x0, %al
callq 0x1090
movq -0x8(%rbp), %rsi
movq -0x20(%rbp), %rax
movl 0xc(%rax), %edx
leaq 0x34f5(%rip), %rdi      # 0x5913
movb $0x0, %al
callq 0x1090
xorl %eax, %eax
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/rsa9000[P]regfanalysistools/regfdump.c
// Function: regf_parse_lst_lf
static int regf_parse_lst_lf(const char *pref, unsigned off)
{
#define LF_PR_ERR(__fmt, ...)	PR_ERR(off, "lf", __fmt, ##__VA_ARGS__)
#define LF_PR_WARN(__fmt, ...)	PR_WARN(off, "lf", __fmt, ##__VA_ARGS__)
	const struct regf_cell *rc = st.data + off;
	const struct regf_lst *lst = (void *)rc->data;
	const struct regf_lf_elem *elems = (void *)lst->data;
	struct cell *cell;
	int i, ret = 0;

	if (sizeof(*rc) + sizeof(*lst) + lst->nelem * sizeof(elems[0]) > -rc->sz) {
		LF_PR_ERR("cell size too small for %u elements\n", lst->nelem);
		return -1;
	}

	printf("%slf.nelem = %u\n", pref, lst->nelem);
	for (i = 0; i < lst->nelem; ++i) {
		printf("%slf.elem[%u]{off,hint} = 0x%08X, %.4s\n",
		       pref, i, elems[i].off, elems[i].hint);
		cell = cache_cell_find(elems[i].off);
		if (!cell) {
			LF_PR_WARN("could not find key cell 0x%08X\n",
				   elems[i].off);
			ret = -1;
			continue;
		}
		cache_cell_updref(cell, CT_NK);
	}

	return ret;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x10(%rbp)
movl %esi, -0x14(%rbp)
movq 0x5caa(%rip), %rax      # 0x80f0
movl -0x14(%rbp), %ecx
addq %rcx, %rax
movq %rax, -0x20(%rbp)
movq -0x20(%rbp), %rax
addq $0x4, %rax
movq %rax, -0x28(%rbp)
movq -0x28(%rbp), %rax
addq $0x4, %rax
movq %rax, -0x30(%rbp)
movl $0x0, -0x40(%rbp)
movq -0x28(%rbp), %rax
movzwl 0x2(%rax), %eax
shlq $0x3, %rax
addq $0x8, %rax
movq -0x20(%rbp), %rdx
xorl %ecx, %ecx
subl (%rdx), %ecx
movslq %ecx, %rcx
cmpq %rcx, %rax
jbe 0x24bb
movl -0x14(%rbp), %esi
movq -0x28(%rbp), %rax
movzwl 0x2(%rax), %ecx
leaq 0x3488(%rip), %rdi      # 0x5929
leaq 0x2f5a(%rip), %rdx      # 0x5402
movb $0x0, %al
callq 0x45e0
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
jmp 0x258b
movq -0x10(%rbp), %rsi
movq -0x28(%rbp), %rax
movzwl 0x2(%rax), %edx
leaq 0x348f(%rip), %rdi      # 0x595d
movb $0x0, %al
callq 0x1090
movl $0x0, -0x3c(%rbp)
movl -0x3c(%rbp), %eax
movq -0x28(%rbp), %rcx
movzwl 0x2(%rcx), %ecx
cmpl %ecx, %eax
jge 0x2585
movq -0x10(%rbp), %rsi
movl -0x3c(%rbp), %edx
movq -0x30(%rbp), %rax
movslq -0x3c(%rbp), %rcx
movl (%rax,%rcx,8), %ecx
movq -0x30(%rbp), %r8
movslq -0x3c(%rbp), %rax
shlq $0x3, %rax
addq %rax, %r8
addq $0x4, %r8
leaq 0x3453(%rip), %rdi      # 0x596e
movb $0x0, %al
callq 0x1090
movq -0x30(%rbp), %rax
movslq -0x3c(%rbp), %rcx
movl (%rax,%rcx,8), %edi
callq 0x3060
movq %rax, -0x38(%rbp)
cmpq $0x0, -0x38(%rbp)
jne 0x2569
movl -0x14(%rbp), %esi
movq -0x30(%rbp), %rax
movslq -0x3c(%rbp), %rcx
movl (%rax,%rcx,8), %ecx
leaq 0x3444(%rip), %rdi      # 0x5996
leaq 0x2ea9(%rip), %rdx      # 0x5402
movb $0x0, %al
callq 0x45e0
movl $0xffffffff, -0x40(%rbp) # imm = 0xFFFFFFFF
jmp 0x2577
movq -0x38(%rbp), %rdi
movl $0x2, %esi
callq 0x30c0
movl -0x3c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x3c(%rbp)
jmp 0x24dc
movl -0x40(%rbp), %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/rsa9000[P]regfanalysistools/regfdump.c
// Function: regf_parse_lst_lh
static int regf_parse_lst_lh(const char *pref, unsigned off)
{
#define LH_PR_ERR(__fmt, ...)	PR_ERR(off, "lh", __fmt, ##__VA_ARGS__)
#define LH_PR_WARN(__fmt, ...)	PR_WARN(off, "lh", __fmt, ##__VA_ARGS__)
	const struct regf_cell *rc = st.data + off;
	const struct regf_lst *lst = (void *)rc->data;
	const struct regf_lh_elem *elems = (void *)lst->data;
	struct cell *cell;
	int i, ret = 0;

	if (sizeof(*rc) + sizeof(*lst) + lst->nelem * sizeof(elems[0]) > -rc->sz) {
		LH_PR_ERR("cell size too small for %u elements\n", lst->nelem);
		return -1;
	}

	printf("%slh.nelem = %u\n", pref, lst->nelem);
	for (i = 0; i < lst->nelem; ++i) {
		printf("%slh.elem[%u]{off,hash} = 0x%08X, 0x%08X\n",
		       pref, i, elems[i].off, elems[i].hash);
		cell = cache_cell_find(elems[i].off);
		if (!cell) {
			LH_PR_WARN("could not find key cell 0x%08X\n",
				   elems[i].off);
			ret = -1;
			continue;
		}
		cache_cell_updref(cell, CT_NK);
	}

	return ret;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x10(%rbp)
movl %esi, -0x14(%rbp)
movq 0x5b3a(%rip), %rax      # 0x80f0
movl -0x14(%rbp), %ecx
addq %rcx, %rax
movq %rax, -0x20(%rbp)
movq -0x20(%rbp), %rax
addq $0x4, %rax
movq %rax, -0x28(%rbp)
movq -0x28(%rbp), %rax
addq $0x4, %rax
movq %rax, -0x30(%rbp)
movl $0x0, -0x40(%rbp)
movq -0x28(%rbp), %rax
movzwl 0x2(%rax), %eax
shlq $0x3, %rax
addq $0x8, %rax
movq -0x20(%rbp), %rdx
xorl %ecx, %ecx
subl (%rdx), %ecx
movslq %ecx, %rcx
cmpq %rcx, %rax
jbe 0x262b
movl -0x14(%rbp), %esi
movq -0x28(%rbp), %rax
movzwl 0x2(%rax), %ecx
leaq 0x3318(%rip), %rdi      # 0x5929
leaq 0x2e11(%rip), %rdx      # 0x5429
movb $0x0, %al
callq 0x45e0
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
jmp 0x26f5
movq -0x10(%rbp), %rsi
movq -0x28(%rbp), %rax
movzwl 0x2(%rax), %edx
leaq 0x3388(%rip), %rdi      # 0x59c6
movb $0x0, %al
callq 0x1090
movl $0x0, -0x3c(%rbp)
movl -0x3c(%rbp), %eax
movq -0x28(%rbp), %rcx
movzwl 0x2(%rcx), %ecx
cmpl %ecx, %eax
jge 0x26ef
movq -0x10(%rbp), %rsi
movl -0x3c(%rbp), %edx
movq -0x30(%rbp), %rax
movslq -0x3c(%rbp), %rcx
movl (%rax,%rcx,8), %ecx
movq -0x30(%rbp), %rax
movslq -0x3c(%rbp), %rdi
movl 0x4(%rax,%rdi,8), %r8d
leaq 0x3352(%rip), %rdi      # 0x59d7
movb $0x0, %al
callq 0x1090
movq -0x30(%rbp), %rax
movslq -0x3c(%rbp), %rcx
movl (%rax,%rcx,8), %edi
callq 0x3060
movq %rax, -0x38(%rbp)
cmpq $0x0, -0x38(%rbp)
jne 0x26d3
movl -0x14(%rbp), %esi
movq -0x30(%rbp), %rax
movslq -0x3c(%rbp), %rcx
movl (%rax,%rcx,8), %ecx
leaq 0x32da(%rip), %rdi      # 0x5996
leaq 0x2d66(%rip), %rdx      # 0x5429
movb $0x0, %al
callq 0x45e0
movl $0xffffffff, -0x40(%rbp) # imm = 0xFFFFFFFF
jmp 0x26e1
movq -0x38(%rbp), %rdi
movl $0x2, %esi
callq 0x30c0
movl -0x3c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x3c(%rbp)
jmp 0x264c
movl -0x40(%rbp), %eax
movl %eax, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x40, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/rsa9000[P]regfanalysistools/regfdump.c
// Function: regf_parse_lst_li
static int regf_parse_lst_li(const char *pref, unsigned off)
{
#define LI_PR_ERR(__fmt, ...)	PR_ERR(off, "li", __fmt, ##__VA_ARGS__)
#define LI_PR_WARN(__fmt, ...)	PR_WARN(off, "li", __fmt, ##__VA_ARGS__)
	const struct regf_cell *rc = st.data + off;
	const struct regf_lst *lst = (void *)rc->data;
	const struct regf_li_elem *elems = (void *)lst->data;
	struct cell *cell;
	int i, ret = 0;

	if (sizeof(*rc) + sizeof(*lst) + lst->nelem * sizeof(elems[0]) > -rc->sz) {
		LI_PR_ERR("cell size too small for %u elements\n", lst->nelem);
		return -1;
	}

	printf("%sli.nelem = %u\n", pref, lst->nelem);
	for (i = 0; i < lst->nelem; ++i) {
		printf("%sli.elem[%u].off = 0x%08X\n",
		       pref, i, elems[i].off);
		cell = cache_cell_find(elems[i].off);
		if (!cell) {
			LI_PR_WARN("could not find key cell 0x%08X\n",
				   elems[i].off);
			ret = -1;
			continue;
		}
		cache_cell_updref(cell, CT_NK);
	}

	return ret;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x10(%rbp)
movl %esi, -0x14(%rbp)
movq 0x59da(%rip), %rax      # 0x80f0
movl -0x14(%rbp), %ecx
addq %rcx, %rax
movq %rax, -0x20(%rbp)
movq -0x20(%rbp), %rax
addq $0x4, %rax
movq %rax, -0x28(%rbp)
movq -0x28(%rbp), %rax
addq $0x4, %rax
movq %rax, -0x30(%rbp)
movl $0x0, -0x40(%rbp)
movq -0x28(%rbp), %rax
movzwl 0x2(%rax), %eax
shlq $0x2, %rax
addq $0x8, %rax
movq -0x20(%rbp), %rdx
xorl %ecx, %ecx
subl (%rdx), %ecx
movslq %ecx, %rcx
cmpq %rcx, %rax
jbe 0x278b
movl -0x14(%rbp), %esi
movq -0x28(%rbp), %rax
movzwl 0x2(%rax), %ecx
leaq 0x31b8(%rip), %rdi      # 0x5929
leaq 0x2cd8(%rip), %rdx      # 0x5450
movb $0x0, %al
callq 0x45e0
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
jmp 0x2848
movq -0x10(%rbp), %rsi
movq -0x28(%rbp), %rax
movzwl 0x2(%rax), %edx
leaq 0x3263(%rip), %rdi      # 0x5a01
movb $0x0, %al
callq 0x1090
movl $0x0, -0x3c(%rbp)
movl -0x3c(%rbp), %eax
movq -0x28(%rbp), %rcx
movzwl 0x2(%rcx), %ecx
cmpl %ecx, %eax
jge 0x2842
movq -0x10(%rbp), %rsi
movl -0x3c(%rbp), %edx
movq -0x30(%rbp), %rax
movslq -0x3c(%rbp), %rcx
movl (%rax,%rcx,4), %ecx
leaq 0x323a(%rip), %rdi      # 0x5a12
movb $0x0, %al
callq 0x1090
movq -0x30(%rbp), %rax
movslq -0x3c(%rbp), %rcx
movl (%rax,%rcx,4), %edi
callq 0x3060
movq %rax, -0x38(%rbp)
cmpq $0x0, -0x38(%rbp)
jne 0x2826
movl -0x14(%rbp), %esi
movq -0x30(%rbp), %rax
movslq -0x3c(%rbp), %rcx
movl (%rax,%rcx,4), %ecx
leaq 0x3187(%rip), %rdi      # 0x5996
leaq 0x2c3a(%rip), %rdx      # 0x5450
movb $0x0, %al
callq 0x45e0
movl $0xffffffff, -0x40(%rbp) # imm = 0xFFFFFFFF
jmp 0x2834
movq -0x38(%rbp), %rdi
movl $0x2, %esi
callq 0x30c0
movl -0x3c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x3c(%rbp)
jmp 0x27ac
movl -0x40(%rbp), %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/rsa9000[P]regfanalysistools/regfdump.c
// Function: regf_parse_lst_ri
static int regf_parse_lst_ri(const char *pref, unsigned off)
{
#define RI_PR_ERR(__fmt, ...)	PR_ERR(off, "ri", __fmt, ##__VA_ARGS__)
#define RI_PR_WARN(__fmt, ...)	PR_WARN(off, "ri", __fmt, ##__VA_ARGS__)
	const struct regf_cell *rc = st.data + off;
	const struct regf_lst *lst = (void *)rc->data;
	const struct regf_ri_elem *elems = (void *)lst->data;
	struct cell *cell;
	int i, ret = 0;

	if (sizeof(*rc) + sizeof(*lst) + lst->nelem * sizeof(elems[0]) > -rc->sz) {
		RI_PR_ERR("cell size too small for %u elements\n", lst->nelem);
		return -1;
	}

	printf("%sri.nelem = %u\n", pref, lst->nelem);
	for (i = 0; i < lst->nelem; ++i) {
		printf("%sri.elem[%u].off = 0x%08X\n",
		       pref, i, elems[i].off);
		cell = cache_cell_find(elems[i].off);
		if (!cell) {
			RI_PR_WARN("could not find keys list cell 0x%08X\n",
				   elems[i].off);
			ret = -1;
			continue;
		}
		cache_cell_updref(cell, CT_LST);
	}

	return ret;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x10(%rbp)
movl %esi, -0x14(%rbp)
movq 0x587a(%rip), %rax      # 0x80f0
movl -0x14(%rbp), %ecx
addq %rcx, %rax
movq %rax, -0x20(%rbp)
movq -0x20(%rbp), %rax
addq $0x4, %rax
movq %rax, -0x28(%rbp)
movq -0x28(%rbp), %rax
addq $0x4, %rax
movq %rax, -0x30(%rbp)
movl $0x0, -0x40(%rbp)
movq -0x28(%rbp), %rax
movzwl 0x2(%rax), %eax
shlq $0x2, %rax
addq $0x8, %rax
movq -0x20(%rbp), %rdx
xorl %ecx, %ecx
subl (%rdx), %ecx
movslq %ecx, %rcx
cmpq %rcx, %rax
jbe 0x28eb
movl -0x14(%rbp), %esi
movq -0x28(%rbp), %rax
movzwl 0x2(%rax), %ecx
leaq 0x3058(%rip), %rdi      # 0x5929
leaq 0x2ba0(%rip), %rdx      # 0x5478
movb $0x0, %al
callq 0x45e0
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
jmp 0x29a8
movq -0x10(%rbp), %rsi
movq -0x28(%rbp), %rax
movzwl 0x2(%rax), %edx
leaq 0x3130(%rip), %rdi      # 0x5a2e
movb $0x0, %al
callq 0x1090
movl $0x0, -0x3c(%rbp)
movl -0x3c(%rbp), %eax
movq -0x28(%rbp), %rcx
movzwl 0x2(%rcx), %ecx
cmpl %ecx, %eax
jge 0x29a2
movq -0x10(%rbp), %rsi
movl -0x3c(%rbp), %edx
movq -0x30(%rbp), %rax
movslq -0x3c(%rbp), %rcx
movl (%rax,%rcx,4), %ecx
leaq 0x3107(%rip), %rdi      # 0x5a3f
movb $0x0, %al
callq 0x1090
movq -0x30(%rbp), %rax
movslq -0x3c(%rbp), %rcx
movl (%rax,%rcx,4), %edi
callq 0x3060
movq %rax, -0x38(%rbp)
cmpq $0x0, -0x38(%rbp)
jne 0x2986
movl -0x14(%rbp), %esi
movq -0x30(%rbp), %rax
movslq -0x3c(%rbp), %rcx
movl (%rax,%rcx,4), %ecx
leaq 0x30ec(%rip), %rdi      # 0x5a5b
leaq 0x2b02(%rip), %rdx      # 0x5478
movb $0x0, %al
callq 0x45e0
movl $0xffffffff, -0x40(%rbp) # imm = 0xFFFFFFFF
jmp 0x2994
movq -0x38(%rbp), %rdi
movl $0x10, %esi
callq 0x30c0
movl -0x3c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x3c(%rbp)
jmp 0x290c
movl -0x40(%rbp), %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/rsa9000[P]regfanalysistools/regfdump.c
// Function: regf_parse_db
static int regf_parse_db(const char *pref, unsigned off)
{
#define DB_PR_WARN(__fmt, ...)	PR_WARN(off, "db", __fmt, ##__VA_ARGS__)
	const struct regf_cell *rc = st.data + off;
	const struct regf_db *db = (void *)rc->data;
	char __pref[0x10];
	struct cell *cell;
	int res;

	printf("%sdb.nsegm = %u\n", pref, db->nsegm);

	if (db->nsegm) {
		cell = cache_cell_find(db->segm_off);
		if (!cell) {
			DB_PR_WARN("could not find segments list cell 0x%08X\n",
				   db->segm_off);
			return -1;
		}
		cache_cell_updref(cell, CT_SLST);
		snprintf(__pref, sizeof(__pref), "%s  ", pref);
		res = regf_parse_slst(__pref, db->segm_off, db->nsegm);
		if (res) {
			DB_PR_WARN("could not parse segments list cell 0x%08X\n",
				   db->segm_off);
			return -1;
		}
	}

	return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movq %rdi, -0x10(%rbp)
movl %esi, -0x14(%rbp)
movq 0x552a(%rip), %rax      # 0x80f0
movl -0x14(%rbp), %ecx
addq %rcx, %rax
movq %rax, -0x20(%rbp)
movq -0x20(%rbp), %rax
addq $0x4, %rax
movq %rax, -0x28(%rbp)
movq -0x10(%rbp), %rsi
movq -0x28(%rbp), %rax
movzwl 0x2(%rax), %edx
leaq 0x3045(%rip), %rdi      # 0x5c34
movb $0x0, %al
callq 0x1090
movq -0x28(%rbp), %rax
cmpw $0x0, 0x2(%rax)
je 0x2cb8
movq -0x28(%rbp), %rax
movl 0x4(%rax), %edi
callq 0x3060
movq %rax, -0x48(%rbp)
cmpq $0x0, -0x48(%rbp)
jne 0x2c44
movl -0x14(%rbp), %esi
movq -0x28(%rbp), %rax
movl 0x4(%rax), %ecx
leaq 0x3018(%rip), %rdi      # 0x5c45
leaq 0x2893(%rip), %rdx      # 0x54c7
movb $0x0, %al
callq 0x45e0
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
jmp 0x2cbf
movq -0x48(%rbp), %rdi
movl $0x200, %esi            # imm = 0x200
callq 0x30c0
leaq -0x40(%rbp), %rdi
movq -0x10(%rbp), %rcx
movl $0x10, %esi
leaq 0x2b54(%rip), %rdx      # 0x57ba
movb $0x0, %al
callq 0x10a0
leaq -0x40(%rbp), %rdi
movq -0x28(%rbp), %rax
movl 0x4(%rax), %esi
movq -0x28(%rbp), %rax
movzwl 0x2(%rax), %edx
callq 0x3360
movl %eax, -0x4c(%rbp)
cmpl $0x0, -0x4c(%rbp)
je 0x2cb6
movl -0x14(%rbp), %esi
movq -0x28(%rbp), %rax
movl 0x4(%rax), %ecx
leaq 0x2fe0(%rip), %rdi      # 0x5c7f
leaq 0x2821(%rip), %rdx      # 0x54c7
movb $0x0, %al
callq 0x45e0
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
jmp 0x2cbf
jmp 0x2cb8
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x50, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/rsa9000[P]regfanalysistools/regfdump.c
// Function: regf_parse_vlst
static int regf_parse_vlst(const char *pref, unsigned off, unsigned num)
{
#define VLST_PR_ERR(__fmt, ...)	PR_ERR(off, "vlst", __fmt, ##__VA_ARGS__)
#define VLST_PR_WARN(__fmt, ...)	PR_WARN(off, "vlst", __fmt, ##__VA_ARGS__)
	const struct regf_cell *rc = st.data + off;
	const uint32_t *vals = (void *)rc->data;
	struct cell *cell;
	unsigned i;
	int ret = 0;

	if (rc->sz > 0) {
		VLST_PR_ERR("values list cell marked as free\n");
		return -1;
	}

	if (num * sizeof(vals[0]) > -rc->sz - sizeof(*rc)) {
		VLST_PR_ERR("values list cell too small for %d items\n", num);
		return -1;
	}

	for (i = 0; i < num; ++i) {
		printf("%svals[%u] = 0x%08X\n", pref, i, vals[i]);
		cell = cache_cell_find(vals[i]);
		if (!cell) {
			VLST_PR_WARN("could not find value cell 0x%08X\n",
				     vals[i]);
			ret = -1;
			continue;
		}
		cache_cell_updref(cell, CT_VK);
	}

	return ret;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x10(%rbp)
movl %esi, -0x14(%rbp)
movl %edx, -0x18(%rbp)
movq 0x4fe7(%rip), %rax      # 0x80f0
movl -0x14(%rbp), %ecx
addq %rcx, %rax
movq %rax, -0x20(%rbp)
movq -0x20(%rbp), %rax
addq $0x4, %rax
movq %rax, -0x28(%rbp)
movl $0x0, -0x38(%rbp)
movq -0x20(%rbp), %rax
cmpl $0x0, (%rax)
jle 0x3153
movl -0x14(%rbp), %esi
leaq 0x2703(%rip), %rdi      # 0x583c
leaq 0x272c(%rip), %rdx      # 0x586c
movb $0x0, %al
callq 0x45e0
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
jmp 0x322e
movl -0x18(%rbp), %eax
shlq $0x2, %rax
movq -0x20(%rbp), %rdx
xorl %ecx, %ecx
subl (%rdx), %ecx
movslq %ecx, %rcx
subq $0x4, %rcx
cmpq %rcx, %rax
jbe 0x3195
movl -0x14(%rbp), %esi
movl -0x18(%rbp), %ecx
leaq 0x26f6(%rip), %rdi      # 0x5871
leaq 0x26ea(%rip), %rdx      # 0x586c
movb $0x0, %al
callq 0x45e0
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
jmp 0x322e
movl $0x0, -0x34(%rbp)
movl -0x34(%rbp), %eax
cmpl -0x18(%rbp), %eax
jae 0x3228
movq -0x10(%rbp), %rsi
movl -0x34(%rbp), %edx
movq -0x28(%rbp), %rax
movl -0x34(%rbp), %ecx
movl (%rax,%rcx,4), %ecx
leaq 0x26e9(%rip), %rdi      # 0x58a9
movb $0x0, %al
callq 0x1090
movq -0x28(%rbp), %rax
movl -0x34(%rbp), %ecx
movl (%rax,%rcx,4), %edi
callq 0x3060
movq %rax, -0x30(%rbp)
cmpq $0x0, -0x30(%rbp)
jne 0x320c
movl -0x14(%rbp), %esi
movq -0x28(%rbp), %rax
movl -0x34(%rbp), %ecx
movl (%rax,%rcx,4), %ecx
leaq 0x26c9(%rip), %rdi      # 0x58be
leaq 0x2670(%rip), %rdx      # 0x586c
movb $0x0, %al
callq 0x45e0
movl $0xffffffff, -0x38(%rbp) # imm = 0xFFFFFFFF
jmp 0x321a
movq -0x30(%rbp), %rdi
movl $0x40, %esi
callq 0x30c0
movl -0x34(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x34(%rbp)
jmp 0x319c
movl -0x38(%rbp), %eax
movl %eax, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x40, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/rsa9000[P]regfanalysistools/regfdump.c
// Function: regf_parse_slst
static int regf_parse_slst(const char *pref, unsigned off, unsigned num)
{
#define SLST_PR_ERR(__fmt, ...)	PR_ERR(off, "slst", __fmt, ##__VA_ARGS__)
#define SLST_PR_WARN(__fmt, ...)PR_WARN(off, "slst", __fmt, ##__VA_ARGS__)
	const struct regf_cell *rc = st.data + off;
	const uint32_t *segs = (void *)rc->data;
	struct cell *cell;
	int i, ret = 0;

	if (rc->sz > 0) {
		SLST_PR_ERR("segments list cell marked as free\n");
		return -1;
	}

	if (num * sizeof(segs[0]) > -rc->sz - sizeof(*rc)) {
		SLST_PR_ERR("segments list cell too small for %d items\n", num);
		return -1;
	}

	for (i = 0; i < num; ++i) {
		printf("%ssegm[%u] = 0x%08X\n", pref, i, segs[i]);
		cell = cache_cell_find(segs[i]);
		if (!cell) {
			SLST_PR_WARN("could not find data segment cell 0x%08X\n",
				     segs[i]);
			ret = -1;
			continue;
		}
		cache_cell_updref(cell, CT_DATAS);
	}

	return ret;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x10(%rbp)
movl %esi, -0x14(%rbp)
movl %edx, -0x18(%rbp)
movq 0x4d77(%rip), %rax      # 0x80f0
movl -0x14(%rbp), %ecx
addq %rcx, %rax
movq %rax, -0x20(%rbp)
movq -0x20(%rbp), %rax
addq $0x4, %rax
movq %rax, -0x28(%rbp)
movl $0x0, -0x38(%rbp)
movq -0x20(%rbp), %rax
cmpl $0x0, (%rax)
jle 0x33c3
movl -0x14(%rbp), %esi
leaq 0x2911(%rip), %rdi      # 0x5cba
leaq 0x293c(%rip), %rdx      # 0x5cec
movb $0x0, %al
callq 0x45e0
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
jmp 0x34a1
movl -0x18(%rbp), %eax
shlq $0x2, %rax
movq -0x20(%rbp), %rdx
xorl %ecx, %ecx
subl (%rdx), %ecx
movslq %ecx, %rcx
subq $0x4, %rcx
cmpq %rcx, %rax
jbe 0x3405
movl -0x14(%rbp), %esi
movl -0x18(%rbp), %ecx
leaq 0x2906(%rip), %rdi      # 0x5cf1
leaq 0x28fa(%rip), %rdx      # 0x5cec
movb $0x0, %al
callq 0x45e0
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
jmp 0x34a1
movl $0x0, -0x34(%rbp)
movl -0x34(%rbp), %eax
cmpl -0x18(%rbp), %eax
jae 0x349b
movq -0x10(%rbp), %rsi
movl -0x34(%rbp), %edx
movq -0x28(%rbp), %rax
movslq -0x34(%rbp), %rcx
movl (%rax,%rcx,4), %ecx
leaq 0x28fa(%rip), %rdi      # 0x5d2b
movb $0x0, %al
callq 0x1090
movq -0x28(%rbp), %rax
movslq -0x34(%rbp), %rcx
movl (%rax,%rcx,4), %edi
callq 0x3060
movq %rax, -0x30(%rbp)
cmpq $0x0, -0x30(%rbp)
jne 0x347f
movl -0x14(%rbp), %esi
movq -0x28(%rbp), %rax
movslq -0x34(%rbp), %rcx
movl (%rax,%rcx,4), %ecx
leaq 0x28d8(%rip), %rdi      # 0x5d40
leaq 0x287d(%rip), %rdx      # 0x5cec
movb $0x0, %al
callq 0x45e0
movl $0xffffffff, -0x38(%rbp) # imm = 0xFFFFFFFF
jmp 0x348d
movq -0x30(%rbp), %rdi
movl $0x400, %esi            # imm = 0x400
callq 0x30c0
movl -0x34(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x34(%rbp)
jmp 0x340c
movl -0x38(%rbp), %eax
movl %eax, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x40, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/chatziko-k08[P]lecture-code/programs/fibonacci/fibonacci_test.c
// Function: syllables_no
int syllables_no(char* s) {
	int num = 1;
	for (; *s != '\0'; s++)
		if (*s == ' ' || *s == '-')
			num++;

	return num;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movl $0x1, -0xc(%rbp)
movq -0x8(%rbp), %rax
movsbl (%rax), %eax
cmpl $0x0, %eax
je 0x43ec
movq -0x8(%rbp), %rax
movsbl (%rax), %eax
cmpl $0x20, %eax
je 0x43d3
movq -0x8(%rbp), %rax
movsbl (%rax), %eax
cmpl $0x2d, %eax
jne 0x43dc
movl -0xc(%rbp), %eax
addl $0x1, %eax
movl %eax, -0xc(%rbp)
jmp 0x43de
movq -0x8(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x8(%rbp)
jmp 0x43af
movl -0xc(%rbp), %eax
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/chatziko-k08[P]lecture-code/programs/fibonacci/fibonacci.c
// Function: fibonacci
int fibonacci(int n) {
	if (memory == NULL) {
		// Αρχικοποίηση της μνήμης με τα πρώτα 2 στοιχεία της ακολουθίας
		memory = int_vector_create(0);
		int_vector_insert_last(memory, 0);
		int_vector_insert_last(memory, 1);
	}

	// Αν δεν έχουμε ήδη το αποτέλεσμα το υπολογίζουμε και το αποθηκεύουμε
	if (n >= int_vector_size(memory)) {
		int res = fibonacci(n-2) + fibonacci(n-1);
		int_vector_insert_last(memory, res);
	}

	return int_vector_get_at(memory, n);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movl %edi, -0x4(%rbp)
cmpq $0x0, 0x5995(%rip)      # 0xb428
jne 0x5ac2
xorl %edi, %edi
callq 0x5b50
movq %rax, 0x5985(%rip)      # 0xb428
movq 0x597e(%rip), %rdi      # 0xb428
xorl %esi, %esi
callq 0x5c50
movq 0x5970(%rip), %rdi      # 0xb428
movl $0x1, %esi
callq 0x5c50
movl -0x4(%rbp), %eax
movl %eax, -0xc(%rbp)
movq 0x5959(%rip), %rdi      # 0xb428
callq 0x5bc0
movl %eax, %ecx
movl -0xc(%rbp), %eax
cmpl %ecx, %eax
jl 0x5b0f
movl -0x4(%rbp), %edi
subl $0x2, %edi
callq 0x5a80
movl %eax, -0x10(%rbp)
movl -0x4(%rbp), %edi
subl $0x1, %edi
callq 0x5a80
movl %eax, %ecx
movl -0x10(%rbp), %eax
addl %ecx, %eax
movl %eax, -0x8(%rbp)
movq 0x5921(%rip), %rdi      # 0xb428
movl -0x8(%rbp), %esi
callq 0x5c50
movq 0x5912(%rip), %rdi      # 0xb428
movl -0x4(%rbp), %esi
callq 0x5c20
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/felipelouza[P]egap/tools/mergelcp.c
// Function: file_open
FILE* file_open(char *c_file, const char * c_mode){
  
  FILE* f_in;
  f_in = fopen(c_file, c_mode);
  if (!f_in) {perror (__func__); exit(EXIT_FAILURE);}
  fseek(f_in, 0, SEEK_SET);
  
return f_in;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
callq 0x1160
movq %rax, -0x18(%rbp)
cmpq $0x0, -0x18(%rbp)
jne 0x133e
leaq 0x3e91(%rip), %rdi      # 0x51c0
callq 0x1170
movl $0x1, %edi
callq 0x11d0
movq -0x18(%rbp), %rdi
xorl %eax, %eax
movl %eax, %esi
xorl %edx, %edx
callq 0x1140
movq -0x18(%rbp), %rax
addq $0x20, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/felipelouza[P]egap/tools/mergelcp.c
// Function: usage
void usage(char *name){
  printf("\n\tUsage: %s [options] FILE POS_SIZE LCP_SIZE \n\n",name);
  puts("Multiway k-merge sort for the lists of pairs <pos, lcp>.");
  puts("Input:\tFILE.pair.lcp with the lists and FILE.size.lcp");
  puts("with their start positions in FILE.pair.lcp");
  puts("Output:\tFILE.lcp contains <lcp> sorted by <pos>.\n");
  puts("Available options:");
  puts("\t-h\tthis help message");
  puts("\t-s\tHEAP_SIZE");
  puts("\t-t\ttime");
  puts("\t-k\tk-truncated LCP merging");
  puts("\t-v\tverbose\n");
  exit(EXIT_FAILURE);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rsi
leaq 0x3b11(%rip), %rdi      # 0x51e8
movb $0x0, %al
callq 0x10d0
leaq 0x3b33(%rip), %rdi      # 0x5218
callq 0x1070
leaq 0x3b60(%rip), %rdi      # 0x5251
callq 0x1070
leaq 0x3b8a(%rip), %rdi      # 0x5287
callq 0x1070
leaq 0x3baa(%rip), %rdi      # 0x52b3
callq 0x1070
leaq 0x3bd0(%rip), %rdi      # 0x52e5
callq 0x1070
leaq 0x3bd7(%rip), %rdi      # 0x52f8
callq 0x1070
leaq 0x3be1(%rip), %rdi      # 0x530e
callq 0x1070
leaq 0x3be3(%rip), %rdi      # 0x531c
callq 0x1070
leaq 0x3be0(%rip), %rdi      # 0x5325
callq 0x1070
leaq 0x3bf0(%rip), %rdi      # 0x5341
callq 0x1070
movl $0x1, %edi
callq 0x11d0
// File: /workspace/github_c_makefile_star2_O0/felipelouza[P]egap/tools/heap.c
// Function: write_buffer
void write_buffer(heap *h, FILE *f_out, int level) {

  int i;
  if(level){
    for(i=0; i<h->out_idx; i++){
      fwrite(&h->out_buffer[i], h->pos_size+h->lcp_size, 1, f_out);
    }
  }
  else{
    for(i=0; i<h->out_idx; i++){
      uint64_t lcp = lcp(h->out_buffer[i]);
      fwrite(&lcp, h->lcp_size, 1, f_out);
    }
  }
  h->out_idx = 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl %edx, -0x14(%rbp)
cmpl $0x0, -0x14(%rbp)
je 0x3397
movl $0x0, -0x18(%rbp)
movl -0x18(%rbp), %eax
movq -0x8(%rbp), %rcx
cmpl 0x210(%rcx), %eax
jge 0x3395
movq -0x8(%rbp), %rax
movq 0x208(%rax), %rdi
movslq -0x18(%rbp), %rax
shlq $0x4, %rax
addq %rax, %rdi
movq -0x8(%rbp), %rax
movl 0x214(%rax), %eax
movq -0x8(%rbp), %rcx
addl 0x218(%rcx), %eax
movslq %eax, %rsi
movq -0x10(%rbp), %rcx
movl $0x1, %edx
callq 0x11e0
movl -0x18(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x18(%rbp)
jmp 0x3340
jmp 0x340b
movl $0x0, -0x18(%rbp)
movl -0x18(%rbp), %eax
movq -0x8(%rbp), %rcx
cmpl 0x210(%rcx), %eax
jge 0x3409
movq -0x8(%rbp), %rcx
movq 0x208(%rcx), %rax
movslq -0x18(%rbp), %rdx
shlq $0x4, %rdx
movq (%rax,%rdx), %rax
movslq 0x218(%rcx), %rcx
shlq $0x4, %rcx
leaq 0x232a(%rip), %rdx      # 0x5700
movq (%rcx,%rdx), %rcx
andq %rcx, %rax
movq %rax, -0x20(%rbp)
movq -0x8(%rbp), %rax
movslq 0x218(%rax), %rsi
movq -0x10(%rbp), %rcx
leaq -0x20(%rbp), %rdi
movl $0x1, %edx
callq 0x11e0
movl -0x18(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x18(%rbp)
jmp 0x339e
jmp 0x340b
movq -0x8(%rbp), %rax
movl $0x0, 0x210(%rax)
addq $0x20, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/felipelouza[P]egap/tools/heap.c
// Function: heap_free
void heap_free(heap *h, FILE *f_out, int level) {

  int i;
  for (i=0; i<h->size; i++){
    //fclose(h->heap[i]->f_in);
    free(h->heap[i]->buffer);
    free(h->heap[i]);
  }

  #if OUTPUT_BUFFER 
    if(h->out_idx) write_buffer(h, f_out, level);
    free(h->out_buffer);
  #endif
  
  fclose(h->f_in);
      
  free(h->heap);
  free(h);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl %edx, -0x14(%rbp)
movl $0x0, -0x18(%rbp)
movl -0x18(%rbp), %eax
movq -0x8(%rbp), %rcx
cmpl 0x8(%rcx), %eax
jge 0x347c
movq -0x8(%rbp), %rax
movq (%rax), %rax
movslq -0x18(%rbp), %rcx
movq (%rax,%rcx,8), %rax
movq (%rax), %rdi
callq 0x3ed0
movq -0x8(%rbp), %rax
movq (%rax), %rax
movslq -0x18(%rbp), %rcx
movq (%rax,%rcx,8), %rdi
callq 0x3ed0
movl -0x18(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x18(%rbp)
jmp 0x343a
movq -0x8(%rbp), %rax
cmpl $0x0, 0x210(%rax)
je 0x3499
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
movl -0x14(%rbp), %edx
callq 0x3320
movq -0x8(%rbp), %rax
movq 0x208(%rax), %rdi
callq 0x3ed0
movq -0x8(%rbp), %rax
movq 0x200(%rax), %rdi
callq 0x10b0
movq -0x8(%rbp), %rax
movq (%rax), %rdi
callq 0x3ed0
movq -0x8(%rbp), %rdi
callq 0x3ed0
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/felipelouza[P]egap/tools/heap.c
// Function: heapfy_up
void heapfy_up(heap *h, int i) {

  int p = (int) floor((i-1)/2);

  while (i>0 && key(i) < key(p)) {  
      
    heap_node *auxn = h->heap[i];
    h->heap[i] = h->heap[p];
    h->heap[p] = auxn;

    i = p;
    p = (int) floor((i-1)/2);
  }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movl -0xc(%rbp), %eax
subl $0x1, %eax
movl $0x2, %ecx
cltd
idivl %ecx
cvtsi2sd %eax, %xmm0
callq 0x11a0
cvttsd2si %xmm0, %eax
movl %eax, -0x10(%rbp)
xorl %eax, %eax
cmpl $0x0, -0xc(%rbp)
movb %al, -0x19(%rbp)
jle 0x3563
movq -0x8(%rbp), %rax
movq (%rax), %rcx
movslq -0xc(%rbp), %rax
movq (%rcx,%rax,8), %rdx
movq (%rdx), %rax
movslq 0x8(%rdx), %rsi
shlq $0x4, %rsi
movq (%rax,%rsi), %rdx
movq 0x8(%rax,%rsi), %rax
movslq -0x10(%rbp), %rsi
movq (%rcx,%rsi,8), %rsi
movq (%rsi), %rcx
movslq 0x8(%rsi), %rdi
shlq $0x4, %rdi
movq (%rcx,%rdi), %rsi
movq 0x8(%rcx,%rdi), %rcx
subq %rsi, %rdx
sbbq %rcx, %rax
setb %al
movb %al, -0x19(%rbp)
movb -0x19(%rbp), %al
testb $0x1, %al
jne 0x356c
jmp 0x35d9
movq -0x8(%rbp), %rax
movq (%rax), %rax
movslq -0xc(%rbp), %rcx
movq (%rax,%rcx,8), %rax
movq %rax, -0x18(%rbp)
movq -0x8(%rbp), %rax
movq (%rax), %rax
movslq -0x10(%rbp), %rcx
movq (%rax,%rcx,8), %rdx
movq -0x8(%rbp), %rax
movq (%rax), %rax
movslq -0xc(%rbp), %rcx
movq %rdx, (%rax,%rcx,8)
movq -0x18(%rbp), %rdx
movq -0x8(%rbp), %rax
movq (%rax), %rax
movslq -0x10(%rbp), %rcx
movq %rdx, (%rax,%rcx,8)
movl -0x10(%rbp), %eax
movl %eax, -0xc(%rbp)
movl -0xc(%rbp), %eax
subl $0x1, %eax
movl $0x2, %ecx
cltd
idivl %ecx
cvtsi2sd %eax, %xmm0
callq 0x11a0
cvttsd2si %xmm0, %eax
movl %eax, -0x10(%rbp)
jmp 0x350d
addq $0x20, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/felipelouza[P]egap/tools/heap.c
// Function: read_buffer
void  read_buffer(heap *h, heap_node *node){

//  fseek(h->f_in, node->seek*sizeof(pair), SEEK_SET);
    fseek(h->f_in, node->seek*(h->pos_size+h->lcp_size), SEEK_SET);

    int i;
    for(i=0; i<h->input_size; i++){
      node->buffer[i]=0;
      int e = fread(&node->buffer[i], h->pos_size+h->lcp_size, 1, h->f_in);
      if(e!=1) {perror(__func__); exit(1);}
      if(node->buffer[i]==MAX_KEY) break; 
    }

    node->seek += h->input_size;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq 0x200(%rax), %rdi
movq -0x10(%rbp), %rax
movq 0x10(%rax), %rsi
movq -0x8(%rbp), %rax
movl 0x214(%rax), %eax
movq -0x8(%rbp), %rcx
addl 0x218(%rcx), %eax
cltq
imulq %rax, %rsi
xorl %edx, %edx
callq 0x1140
movl $0x0, -0x14(%rbp)
movslq -0x14(%rbp), %rax
movq -0x8(%rbp), %rcx
cmpq 0x220(%rcx), %rax
jae 0x3921
movq -0x10(%rbp), %rax
movq (%rax), %rax
movslq -0x14(%rbp), %rcx
shlq $0x4, %rcx
movq $0x0, 0x8(%rax,%rcx)
movq $0x0, (%rax,%rcx)
movq -0x10(%rbp), %rax
movq (%rax), %rdi
movslq -0x14(%rbp), %rax
shlq $0x4, %rax
addq %rax, %rdi
movq -0x8(%rbp), %rax
movl 0x214(%rax), %eax
movq -0x8(%rbp), %rcx
addl 0x218(%rcx), %eax
movslq %eax, %rsi
movq -0x8(%rbp), %rax
movq 0x200(%rax), %rcx
movl $0x1, %edx
callq 0x1080
movl %eax, -0x18(%rbp)
cmpl $0x1, -0x18(%rbp)
je 0x389d
leaq 0x1e4f(%rip), %rdi      # 0x56dd
callq 0x1170
movl $0x1, %edi
callq 0x11d0
movq -0x10(%rbp), %rax
movq (%rax), %rcx
movslq -0x14(%rbp), %rdx
shlq $0x4, %rdx
movq (%rcx,%rdx), %rax
movq 0x8(%rcx,%rdx), %rcx
movq %rcx, -0x20(%rbp)
movq 0x1ec0(%rip), %rdx      # 0x5780
movq -0x8(%rbp), %rsi
movl 0x214(%rsi), %ecx
movl 0x218(%rsi), %esi
addl %esi, %ecx
movb $0x10, %r8b
subb %cl, %r8b
shlb $0x3, %r8b
movq $-0x1, %rsi
movb %r8b, %cl
shrdq %cl, %rdx, %rsi
movb %r8b, %cl
shrq %cl, %rdx
movq -0x20(%rbp), %rcx
xorl %edi, %edi
testb $0x40, %r8b
cmovneq %rdx, %rsi
cmovneq %rdi, %rdx
xorq %rsi, %rax
xorq %rdx, %rcx
orq %rcx, %rax
jne 0x3911
jmp 0x390f
jmp 0x3921
jmp 0x3913
movl -0x14(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x14(%rbp)
jmp 0x380b
movq -0x8(%rbp), %rax
movq 0x220(%rax), %rcx
movq -0x10(%rbp), %rax
addq 0x10(%rax), %rcx
movq %rcx, 0x10(%rax)
addq $0x20, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/felipelouza[P]egap/tools/heap.c
// Function: heap_insert
int heap_insert(heap *h, size_t pos) {

  if (!h->heap[h->size])
    h->heap[h->size] = malloc(sizeof(heap_node));

  if (!h->heap[h->size]) 
    return errno = ENOMEM;

  heap_node *node = h->heap[h->size];

  //alloc buffer <pos, lcp>
  node->buffer = (pair*) malloc(h->input_size*sizeof(pair));
  if (!node->buffer) 
    return errno = ENOMEM;
  node->idx = 0;
  
  //load buffer
  node->seek = pos;
  read_buffer(h, node);

  #if DEBUG
    int i;
    for(i=0; i<h->input_size; i++) 
      printf("<%lu, %lu (%lu)> ", lcp(node->buffer[i]), pos(node->buffer[i]), node->buffer[i]);
    printf("**\n");
  #endif
  
  heapfy_up(h,h->size++);

  return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x10(%rbp), %rax
movq (%rax), %rax
movq -0x10(%rbp), %rcx
movslq 0x8(%rcx), %rcx
cmpq $0x0, (%rax,%rcx,8)
jne 0x3986
movl $0x18, %edi
callq 0x3d60
movq %rax, %rdx
movq -0x10(%rbp), %rax
movq (%rax), %rax
movq -0x10(%rbp), %rcx
movslq 0x8(%rcx), %rcx
movq %rdx, (%rax,%rcx,8)
movq -0x10(%rbp), %rax
movq (%rax), %rax
movq -0x10(%rbp), %rcx
movslq 0x8(%rcx), %rcx
cmpq $0x0, (%rax,%rcx,8)
jne 0x39b3
callq 0x1040
movl $0xc, (%rax)
movl $0xc, -0x4(%rbp)
jmp 0x3b07
movq -0x10(%rbp), %rax
movq (%rax), %rax
movq -0x10(%rbp), %rcx
movslq 0x8(%rcx), %rcx
movq (%rax,%rcx,8), %rax
movq %rax, -0x20(%rbp)
movq -0x10(%rbp), %rax
movq 0x220(%rax), %rdi
shlq $0x4, %rdi
callq 0x3d60
movq %rax, %rcx
movq -0x20(%rbp), %rax
movq %rcx, (%rax)
movq -0x20(%rbp), %rax
cmpq $0x0, (%rax)
jne 0x3a09
callq 0x1040
movl $0xc, (%rax)
movl $0xc, -0x4(%rbp)
jmp 0x3b07
movq -0x20(%rbp), %rax
movl $0x0, 0x8(%rax)
movq -0x18(%rbp), %rcx
movq -0x20(%rbp), %rax
movq %rcx, 0x10(%rax)
movq -0x10(%rbp), %rdi
movq -0x20(%rbp), %rsi
callq 0x37c0
movl $0x0, -0x24(%rbp)
movslq -0x24(%rbp), %rax
movq -0x10(%rbp), %rcx
cmpq 0x220(%rcx), %rax
jae 0x3ada
movq -0x20(%rbp), %rax
movq (%rax), %rcx
movslq -0x24(%rbp), %rdx
shlq $0x4, %rdx
movq (%rcx,%rdx), %rax
movq 0x8(%rcx,%rdx), %r9
movq %r9, -0x48(%rbp)
movq -0x10(%rbp), %rcx
movslq 0x218(%rcx), %rcx
movq %rcx, %rdx
shlq $0x4, %rdx
leaq 0x1c82(%rip), %rsi      # 0x5700
movq (%rdx,%rsi), %rdx
movq %rax, %rsi
andq %rdx, %rsi
movb %cl, %r8b
shlb $0x3, %r8b
movb %r8b, %cl
movq %r9, %rdi
shrq %cl, %rdi
movb %r8b, %cl
movq %rax, %rdx
shrdq %cl, %r9, %rdx
movq -0x48(%rbp), %rcx
testb $0x40, %r8b
cmovneq %rdi, %rdx
movq %rcx, -0x38(%rbp)
movq %rax, -0x40(%rbp)
movq -0x40(%rbp), %rcx
movq -0x38(%rbp), %r8
leaq 0x1c24(%rip), %rdi      # 0x56e9
movb $0x0, %al
callq 0x10d0
movl -0x24(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x24(%rbp)
jmp 0x3a34
leaq 0x1703(%rip), %rdi      # 0x51e4
movb $0x0, %al
callq 0x10d0
movq -0x10(%rbp), %rdi
movq -0x10(%rbp), %rax
movl 0x8(%rax), %esi
movl %esi, %ecx
addl $0x1, %ecx
movl %ecx, 0x8(%rax)
callq 0x34e0
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x50, %rsp
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O0/felipelouza[P]egap/tools/heap.c
// Function: heap_delete_min
pair heap_delete_min(heap *h) {

  heap_node *node = h->heap[0];

  pair tmp=0;
  tmp= node->buffer[node->idx];

  if(++node->idx == h->input_size){ //load from disk
    node->idx = 0; 
    read_buffer(h, node);
  }

  heapfy_down(h,0);
  
  return tmp;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x18(%rbp)
movq -0x18(%rbp), %rax
movq (%rax), %rax
movq (%rax), %rax
movq %rax, -0x20(%rbp)
movq $0x0, -0x28(%rbp)
movq $0x0, -0x30(%rbp)
movq -0x20(%rbp), %rax
movq (%rax), %rcx
movslq 0x8(%rax), %rdx
shlq $0x4, %rdx
movq (%rcx,%rdx), %rax
movq 0x8(%rcx,%rdx), %rcx
movq %rcx, -0x28(%rbp)
movq %rax, -0x30(%rbp)
movq -0x20(%rbp), %rcx
movl 0x8(%rcx), %eax
addl $0x1, %eax
movl %eax, 0x8(%rcx)
cltq
movq -0x18(%rbp), %rcx
cmpq 0x220(%rcx), %rax
jne 0x3b8e
movq -0x20(%rbp), %rax
movl $0x0, 0x8(%rax)
movq -0x18(%rbp), %rdi
movq -0x20(%rbp), %rsi
callq 0x37c0
movq -0x18(%rbp), %rdi
xorl %esi, %esi
callq 0x35e0
movq -0x30(%rbp), %rax
movq -0x28(%rbp), %rcx
movq %rcx, -0x8(%rbp)
movq %rax, -0x10(%rbp)
movq -0x10(%rbp), %rax
movq -0x8(%rbp), %rdx
addq $0x30, %rsp
popq %rbp
retq
nopw (%rax,%rax)