LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O0/mabdi[P]bunney/bunny-flow.c
// Function: main
int main(int argc,char** argv) {

  if (argc - 3)
    fatal("usage: %s input_dir/ output_dir/",argv[0]);
    
  indir  = argv[1];
  outdir = argv[2];

  signal(SIGPIPE,SIG_IGN);    
  signal(SIGTERM,exit_nicely);
  
  validate_dirs();
      
  debug("bunny-flow " VERSION " (" __DATE__ " " __TIME__ ") by <lcamtuf@google.com>\n");
  
  reload_config();
  process_commands();
  
  debug("Done - exiting gracefully.\n");

  return 0;
  
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movl $0x0, -0x4(%rbp)
movl %edi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl -0x8(%rbp), %eax
subl $0x3, %eax
cmpl $0x0, %eax
je 0x1428
jmp 0x13d3
movq 0x5c06(%rip), %rax      # 0x6fe0
movq (%rax), %rdi
movq -0x10(%rbp), %rax
movq (%rax), %rdx
leaq 0x3c19(%rip), %rsi      # 0x5004
movb $0x0, %al
callq 0x11b0
movq 0x5be7(%rip), %rax      # 0x6fe0
movq (%rax), %rdi
leaq 0x3c39(%rip), %rsi      # 0x503c
leaq 0x3c42(%rip), %rdx      # 0x504c
leaq 0x3c40(%rip), %rcx      # 0x5051
movl $0x337, %r8d            # imm = 0x337
movb $0x0, %al
callq 0x11b0
movl $0x1, %edi
callq 0x1180
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rax
movq %rax, 0x5d49(%rip)      # 0x7180
movq -0x10(%rbp), %rax
movq 0x10(%rax), %rax
movq %rax, 0x5d42(%rip)      # 0x7188
movl $0xd, %edi
movl $0x1, %esi
callq 0x1160
movl $0xf, %edi
leaq 0x4f(%rip), %rsi        # 0x14b0
callq 0x1160
callq 0x14e0
movq 0x5b6e(%rip), %rax      # 0x6fe0
movq (%rax), %rdi
leaq 0x3be2(%rip), %rsi      # 0x505e
movb $0x0, %al
callq 0x11b0
callq 0x1770
callq 0x1d50
movq 0x5b4c(%rip), %rax      # 0x6fe0
movq (%rax), %rdi
leaq 0x3c05(%rip), %rsi      # 0x50a3
movb $0x0, %al
callq 0x11b0
xorl %eax, %eax
addq $0x10, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/mabdi[P]bunney/bunny-flow.c
// Function: reset_state
static void reset_state(void) {
  _u32 i;
  for (i=0;i<infcount;i++) {
    /* Do not dealloc as-is files workbuffers, it's pointless unless a 
       reload is requested; clean buffers may stay, too. */
    if (infile[i].asis) continue;
    if (infile[i].dirty && infile[i].data) {
      free(infile[i].data);
      infile[i].data    = 0;
      infile[i].dirty   = 0;
      infile[i].cur_len = infile[i].orig_len;
    }
  }
  cur_fuzzable = orig_fuzzable;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
cmpl 0x56f8(%rip), %eax      # 0x8190
jae 0x2b70
movq 0x56f3(%rip), %rax      # 0x8198
movl -0x4(%rbp), %ecx
shlq $0x5, %rcx
addq %rcx, %rax
cmpb $0x0, 0x10(%rax)
je 0x2aba
jmp 0x2b62
movq 0x56d7(%rip), %rax      # 0x8198
movl -0x4(%rbp), %ecx
shlq $0x5, %rcx
addq %rcx, %rax
movzbl 0x1c(%rax), %eax
cmpl $0x0, %eax
je 0x2b60
movq 0x56b9(%rip), %rax      # 0x8198
movl -0x4(%rbp), %ecx
shlq $0x5, %rcx
addq %rcx, %rax
cmpq $0x0, 0x8(%rax)
je 0x2b60
movq 0x56a1(%rip), %rax      # 0x8198
movl -0x4(%rbp), %ecx
shlq $0x5, %rcx
addq %rcx, %rax
movq 0x8(%rax), %rdi
callq 0x1170
movq 0x5687(%rip), %rax      # 0x8198
movl -0x4(%rbp), %ecx
shlq $0x5, %rcx
addq %rcx, %rax
movq $0x0, 0x8(%rax)
movq 0x566e(%rip), %rax      # 0x8198
movl -0x4(%rbp), %ecx
shlq $0x5, %rcx
addq %rcx, %rax
movb $0x0, 0x1c(%rax)
movq 0x5659(%rip), %rax      # 0x8198
movl -0x4(%rbp), %ecx
shlq $0x5, %rcx
addq %rcx, %rax
movl 0x14(%rax), %ecx
movq 0x5645(%rip), %rax      # 0x8198
movl -0x4(%rbp), %edx
shlq $0x5, %rdx
addq %rdx, %rax
movl %ecx, 0x18(%rax)
jmp 0x2b62
movl -0x4(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x4(%rbp)
jmp 0x2a8f
movl 0x562a(%rip), %eax      # 0x81a0
movl %eax, 0x5628(%rip)      # 0x81a4
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/mabdi[P]bunney/bunny-flow.c
// Function: flip_bits
static void flip_bits(_u32 bitpos, _u32 bitlen) {
  _u32 f, roff;
  
  if (!cur_fuzzable || !bitlen) return;
  bitpos %= cur_fuzzable * 8;

  f = lookup_file(bitpos / 8, 1, &roff);
  load_data(f);

  infile[f].dirty = 1;  
  
  while (bitlen--) {

    /* Assume LE - we're IA32 specific anyway */
    infile[f].data[roff] ^= 1 << (7 - (bitpos % 8));
    
    if (!(++bitpos % 8)) roff++;

    if (roff >= infile[f].cur_len) {
      f = lookup_file(bitpos / 8, 1, &roff);
      load_data(f);
      infile[f].dirty = 1;  
    }

  }  
  
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movl %edi, -0x4(%rbp)
movl %esi, -0x8(%rbp)
cmpl $0x0, 0x55ff(%rip)      # 0x81a4
je 0x2bad
cmpl $0x0, -0x8(%rbp)
jne 0x2bb2
jmp 0x2cae
movl 0x55ec(%rip), %ecx      # 0x81a4
shll $0x3, %ecx
movl -0x4(%rbp), %eax
xorl %edx, %edx
divl %ecx
movl %edx, -0x4(%rbp)
movl -0x4(%rbp), %edi
shrl $0x3, %edi
movl $0x1, %esi
leaq -0x10(%rbp), %rdx
callq 0x39b0
movl %eax, -0xc(%rbp)
movl -0xc(%rbp), %edi
callq 0x3b00
movq 0x55ad(%rip), %rax      # 0x8198
movl -0xc(%rbp), %ecx
shlq $0x5, %rcx
addq %rcx, %rax
movb $0x1, 0x1c(%rax)
movl -0x8(%rbp), %eax
movl %eax, %ecx
addl $-0x1, %ecx
movl %ecx, -0x8(%rbp)
cmpl $0x0, %eax
je 0x2cae
movl -0x4(%rbp), %eax
andl $0x7, %eax
movl $0x7, %ecx
subl %eax, %ecx
movl $0x1, %esi
shll %cl, %esi
movq 0x5570(%rip), %rax      # 0x8198
movl -0xc(%rbp), %ecx
shlq $0x5, %rcx
addq %rcx, %rax
movq 0x8(%rax), %rax
movl -0x10(%rbp), %ecx
movzbl (%rax,%rcx), %edx
xorl %esi, %edx
movb %dl, (%rax,%rcx)
movl -0x4(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x4(%rbp)
andl $0x7, %eax
cmpl $0x0, %eax
jne 0x2c5c
movl -0x10(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x10(%rbp)
movl -0x10(%rbp), %eax
movq 0x5532(%rip), %rcx      # 0x8198
movl -0xc(%rbp), %edx
shlq $0x5, %rdx
addq %rdx, %rcx
cmpl 0x18(%rcx), %eax
jb 0x2ca9
movl -0x4(%rbp), %edi
shrl $0x3, %edi
movl $0x1, %esi
leaq -0x10(%rbp), %rdx
callq 0x39b0
movl %eax, -0xc(%rbp)
movl -0xc(%rbp), %edi
callq 0x3b00
movq 0x54fd(%rip), %rax      # 0x8198
movl -0xc(%rbp), %ecx
shlq $0x5, %rcx
addq %rcx, %rax
movb $0x1, 0x1c(%rax)
jmp 0x2bf9
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/mabdi[P]bunney/bunny-flow.c
// Function: set_byte
static void set_byte(_u32 position, _u32 val) {
  _u32 f, roff;
  
  if (!cur_fuzzable) return;
  position %= cur_fuzzable;

  f = lookup_file(position, 1, &roff);
  load_data(f);

  infile[f].dirty = 1;  
  infile[f].data[roff] = val;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movl %edi, -0x4(%rbp)
movl %esi, -0x8(%rbp)
cmpl $0x0, 0x54cf(%rip)      # 0x81a4
jne 0x2cd9
jmp 0x2d3a
movl 0x54c5(%rip), %ecx      # 0x81a4
movl -0x4(%rbp), %eax
xorl %edx, %edx
divl %ecx
movl %edx, -0x4(%rbp)
movl -0x4(%rbp), %edi
movl $0x1, %esi
leaq -0x10(%rbp), %rdx
callq 0x39b0
movl %eax, -0xc(%rbp)
movl -0xc(%rbp), %edi
callq 0x3b00
movq 0x548c(%rip), %rax      # 0x8198
movl -0xc(%rbp), %ecx
shlq $0x5, %rcx
addq %rcx, %rax
movb $0x1, 0x1c(%rax)
movl -0x8(%rbp), %eax
movb %al, %dl
movq 0x5472(%rip), %rax      # 0x8198
movl -0xc(%rbp), %ecx
shlq $0x5, %rcx
addq %rcx, %rax
movq 0x8(%rax), %rax
movl -0x10(%rbp), %ecx
movb %dl, (%rax,%rcx)
addq $0x10, %rsp
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O0/mabdi[P]bunney/bunny-flow.c
// Function: set_word
static void set_word(_u32 position, _u32 val) {
  _u32 f, roff;
  
  if (!cur_fuzzable) return;
  position %= cur_fuzzable;

  f = lookup_file(position, 1, &roff);
  load_data(f);

  infile[f].dirty = 1;  
  
  if (roff + 1 < infile[f].cur_len) 
    *(_u16*)(infile[f].data + roff) = val;
  else {
    /* Assume LE - we're IA32 specific anyway */
    infile[f].data[roff] = val;
    set_byte(position + 1, val >> 8);
  }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movl %edi, -0x4(%rbp)
movl %esi, -0x8(%rbp)
cmpl $0x0, 0x544f(%rip)      # 0x81a4
jne 0x2d5c
jmp 0x2e0e
movl 0x5442(%rip), %ecx      # 0x81a4
movl -0x4(%rbp), %eax
xorl %edx, %edx
divl %ecx
movl %edx, -0x4(%rbp)
movl -0x4(%rbp), %edi
movl $0x1, %esi
leaq -0x10(%rbp), %rdx
callq 0x39b0
movl %eax, -0xc(%rbp)
movl -0xc(%rbp), %edi
callq 0x3b00
movq 0x5409(%rip), %rax      # 0x8198
movl -0xc(%rbp), %ecx
shlq $0x5, %rcx
addq %rcx, %rax
movb $0x1, 0x1c(%rax)
movl -0x10(%rbp), %eax
addl $0x1, %eax
movq 0x53ee(%rip), %rcx      # 0x8198
movl -0xc(%rbp), %edx
shlq $0x5, %rdx
addq %rdx, %rcx
cmpl 0x18(%rcx), %eax
jae 0x2ddd
movl -0x8(%rbp), %eax
movw %ax, %dx
movq 0x53d2(%rip), %rax      # 0x8198
movl -0xc(%rbp), %ecx
shlq $0x5, %rcx
addq %rcx, %rax
movq 0x8(%rax), %rax
movl -0x10(%rbp), %ecx
movw %dx, (%rax,%rcx)
jmp 0x2e0e
movl -0x8(%rbp), %eax
movb %al, %dl
movq 0x53af(%rip), %rax      # 0x8198
movl -0xc(%rbp), %ecx
shlq $0x5, %rcx
addq %rcx, %rax
movq 0x8(%rax), %rax
movl -0x10(%rbp), %ecx
movb %dl, (%rax,%rcx)
movl -0x4(%rbp), %edi
addl $0x1, %edi
movl -0x8(%rbp), %esi
shrl $0x8, %esi
callq 0x2cc0
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/mabdi[P]bunney/bunny-flow.c
// Function: set_dword
static void set_dword(_u32 position, _u32 val) {
  _u32 f, roff;
  
  if (!cur_fuzzable) return;
  position %= cur_fuzzable;

  f = lookup_file(position, 1, &roff);
  load_data(f);

  infile[f].dirty = 1;  
  
  if (roff + 3 < infile[f].cur_len)
    *(_u32*)(infile[f].data + roff) = val;
  else {
    /* Assume LE - we're IA32 specific anyway */
    infile[f].data[roff] = val;
    set_byte(position + 1, val >> 8);
    set_word(position + 2, val >> 16);
  }
  
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movl %edi, -0x4(%rbp)
movl %esi, -0x8(%rbp)
cmpl $0x0, 0x536f(%rip)      # 0x81a4
jne 0x2e3c
jmp 0x2efb
movl 0x5362(%rip), %ecx      # 0x81a4
movl -0x4(%rbp), %eax
xorl %edx, %edx
divl %ecx
movl %edx, -0x4(%rbp)
movl -0x4(%rbp), %edi
movl $0x1, %esi
leaq -0x10(%rbp), %rdx
callq 0x39b0
movl %eax, -0xc(%rbp)
movl -0xc(%rbp), %edi
callq 0x3b00
movq 0x5329(%rip), %rax      # 0x8198
movl -0xc(%rbp), %ecx
shlq $0x5, %rcx
addq %rcx, %rax
movb $0x1, 0x1c(%rax)
movl -0x10(%rbp), %eax
addl $0x3, %eax
movq 0x530e(%rip), %rcx      # 0x8198
movl -0xc(%rbp), %edx
shlq $0x5, %rdx
addq %rdx, %rcx
cmpl 0x18(%rcx), %eax
jae 0x2eb9
movl -0x8(%rbp), %edx
movq 0x52f5(%rip), %rax      # 0x8198
movl -0xc(%rbp), %ecx
shlq $0x5, %rcx
addq %rcx, %rax
movq 0x8(%rax), %rax
movl -0x10(%rbp), %ecx
movl %edx, (%rax,%rcx)
jmp 0x2efb
movl -0x8(%rbp), %eax
movb %al, %dl
movq 0x52d3(%rip), %rax      # 0x8198
movl -0xc(%rbp), %ecx
shlq $0x5, %rcx
addq %rcx, %rax
movq 0x8(%rax), %rax
movl -0x10(%rbp), %ecx
movb %dl, (%rax,%rcx)
movl -0x4(%rbp), %edi
addl $0x1, %edi
movl -0x8(%rbp), %esi
shrl $0x8, %esi
callq 0x2cc0
movl -0x4(%rbp), %edi
addl $0x2, %edi
movl -0x8(%rbp), %esi
shrl $0x10, %esi
callq 0x2d40
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/mabdi[P]bunney/bunny-flow.c
// Function: swap_data_ext
static void swap_data_ext(_u32 pos1, _u32 len, _u32 pos2) {
  _u8 *o1 = get_data(pos1,len,0),
      *o2 = get_data(pos2,len,0);
  set_data(pos1,len,o2);
  set_data(pos2,len,o1);
  free(o1);
  free(o2);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movl %edi, -0x4(%rbp)
movl %esi, -0x8(%rbp)
movl %edx, -0xc(%rbp)
movl -0x4(%rbp), %edi
movl -0x8(%rbp), %esi
xorl %eax, %eax
movl %eax, %edx
callq 0x3ed0
movq %rax, -0x18(%rbp)
movl -0xc(%rbp), %edi
movl -0x8(%rbp), %esi
xorl %eax, %eax
movl %eax, %edx
callq 0x3ed0
movq %rax, -0x20(%rbp)
movl -0x4(%rbp), %edi
movl -0x8(%rbp), %esi
movq -0x20(%rbp), %rdx
callq 0x4080
movl -0xc(%rbp), %edi
movl -0x8(%rbp), %esi
movq -0x18(%rbp), %rdx
callq 0x4080
movq -0x18(%rbp), %rdi
callq 0x1170
movq -0x20(%rbp), %rdi
callq 0x1170
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/mabdi[P]bunney/bunny-flow.c
// Function: commit_file
static void commit_file(_u8* fn) {
  _s32 of;

  if (lport) { close(lsock); lport = 0; }
  
  /* The user might want to output to special devices, FIFOs and the like,
     and keep the file readable to other UIDs, so we skip unlink + O_EXCL
     and trust the environment is set up wisely. Keep-alive functionality of
     bunny-exec explicitly depends on this. */

  of = open(fn,O_WRONLY|O_CREAT|O_TRUNC,0644);
  if (of < 0) pfatal("unable to open '%s' for writing",fn);
  
  commit_data_fd(of);
  
  close(of);
  
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
cmpw $0x0, 0x4e94(%rip)      # 0x81a8
je 0x332a
movl 0x4e90(%rip), %edi      # 0x81ac
callq 0x12a0
movw $0x0, 0x4e7e(%rip)      # 0x81a8
movq -0x8(%rbp), %rdi
movl $0x241, %esi            # imm = 0x241
movl $0x1a4, %edx            # imm = 0x1A4
movb $0x0, %al
callq 0x10d0
movl %eax, -0xc(%rbp)
cmpl $0x0, -0xc(%rbp)
jge 0x33a8
jmp 0x334a
movq 0x3c8f(%rip), %rax      # 0x6fe0
movq (%rax), %rdi
movq -0x8(%rbp), %rdx
leaq 0x2224(%rip), %rsi      # 0x5583
movb $0x0, %al
callq 0x11b0
movq 0x3c73(%rip), %rax      # 0x6fe0
movq (%rax), %rdi
leaq 0x1cc5(%rip), %rsi      # 0x503c
leaq 0x223b(%rip), %rdx      # 0x55b9
leaq 0x1ccc(%rip), %rcx      # 0x5051
movl $0x233, %r8d            # imm = 0x233
movb $0x0, %al
callq 0x11b0
leaq 0x1d83(%rip), %rdi      # 0x511c
callq 0x1100
movl $0x1, %edi
callq 0x1180
movl -0xc(%rbp), %edi
callq 0x4370
movl -0xc(%rbp), %edi
callq 0x12a0
addq $0x10, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/mabdi[P]bunney/bunny-flow.c
// Function: lookup_file
static _u32 lookup_file(_u32 position, _u8 skip_blank, _u32* offset) {
  _u32 i;
  _u32 cpos = 0;
  _s32 last0 = -1;
  
  for (i=0;i < infcount - 1;i++) {
    if (infile[i].asis) continue;
    if (position < cpos + infile[i].cur_len) break;
    if (!infile[i].cur_len && last0 < 0) last0 = i;
      else if (infile[i].cur_len) last0 = -1;
    cpos += infile[i].cur_len;
  }
  
  *offset = position - cpos;
  
  if (!*offset) {
    if (!skip_blank) return last0 > 0 ? last0 : i;
  } else {
    if (position >= cur_fuzzable) *offset = infile[i].cur_len; /* EOF */
  }
  
  return i;

}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movb %sil, %al
movl %edi, -0x8(%rbp)
movb %al, -0x9(%rbp)
movq %rdx, -0x18(%rbp)
movl $0x0, -0x20(%rbp)
movl $0xffffffff, -0x24(%rbp) # imm = 0xFFFFFFFF
movl $0x0, -0x1c(%rbp)
movl -0x1c(%rbp), %eax
movl 0x47b1(%rip), %ecx      # 0x8190
subl $0x1, %ecx
cmpl %ecx, %eax
jae 0x3a90
movq 0x47a7(%rip), %rax      # 0x8198
movl -0x1c(%rbp), %ecx
shlq $0x5, %rcx
addq %rcx, %rax
cmpb $0x0, 0x10(%rax)
je 0x3a03
jmp 0x3a82
movl -0x8(%rbp), %eax
movl -0x20(%rbp), %ecx
movq 0x4788(%rip), %rdx      # 0x8198
movl -0x1c(%rbp), %esi
shlq $0x5, %rsi
addq %rsi, %rdx
addl 0x18(%rdx), %ecx
cmpl %ecx, %eax
jae 0x3a23
jmp 0x3a90
movq 0x476e(%rip), %rax      # 0x8198
movl -0x1c(%rbp), %ecx
shlq $0x5, %rcx
addq %rcx, %rax
cmpl $0x0, 0x18(%rax)
jne 0x3a48
cmpl $0x0, -0x24(%rbp)
jge 0x3a48
movl -0x1c(%rbp), %eax
movl %eax, -0x24(%rbp)
jmp 0x3a68
movq 0x4749(%rip), %rax      # 0x8198
movl -0x1c(%rbp), %ecx
shlq $0x5, %rcx
addq %rcx, %rax
cmpl $0x0, 0x18(%rax)
je 0x3a66
movl $0xffffffff, -0x24(%rbp) # imm = 0xFFFFFFFF
jmp 0x3a68
movq 0x4729(%rip), %rax      # 0x8198
movl -0x1c(%rbp), %ecx
shlq $0x5, %rcx
addq %rcx, %rax
movl 0x18(%rax), %eax
addl -0x20(%rbp), %eax
movl %eax, -0x20(%rbp)
movl -0x1c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x1c(%rbp)
jmp 0x39d6
movl -0x8(%rbp), %ecx
subl -0x20(%rbp), %ecx
movq -0x18(%rbp), %rax
movl %ecx, (%rax)
movq -0x18(%rbp), %rax
cmpl $0x0, (%rax)
jne 0x3ac9
cmpb $0x0, -0x9(%rbp)
jne 0x3ac7
cmpl $0x0, -0x24(%rbp)
jle 0x3ab9
movl -0x24(%rbp), %eax
movl %eax, -0x28(%rbp)
jmp 0x3abf
movl -0x1c(%rbp), %eax
movl %eax, -0x28(%rbp)
movl -0x28(%rbp), %eax
movl %eax, -0x4(%rbp)
jmp 0x3af6
jmp 0x3af0
movl -0x8(%rbp), %eax
cmpl 0x46d2(%rip), %eax      # 0x81a4
jb 0x3aee
movq 0x46bd(%rip), %rax      # 0x8198
movl -0x1c(%rbp), %ecx
shlq $0x5, %rcx
addq %rcx, %rax
movl 0x18(%rax), %ecx
movq -0x18(%rbp), %rax
movl %ecx, (%rax)
jmp 0x3af0
movl -0x1c(%rbp), %eax
movl %eax, -0x4(%rbp)
movl -0x4(%rbp), %eax
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/mabdi[P]bunney/bunny-flow.c
// Function: set_data
static void set_data(_u32 position, _u32 len,_u8* src) {
  _u32 f, roff;

  if (!cur_fuzzable || !len) return;
  position %= cur_fuzzable;
  
  f = lookup_file(position, 1, &roff);
  load_data(f);

  infile[f].dirty = 1;

  if (roff + len <= infile[f].cur_len) {
    memcpy(infile[f].data + roff, src, len);
  } else {
    _u32 cancopy = infile[f].cur_len - roff;
    memcpy(infile[f].data + roff, src, cancopy);
    position += cancopy;
    len -= cancopy;
    set_data(position, len, src + cancopy);
  }
  
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movl %edi, -0x4(%rbp)
movl %esi, -0x8(%rbp)
movq %rdx, -0x10(%rbp)
cmpl $0x0, 0x410b(%rip)      # 0x81a4
je 0x40a1
cmpl $0x0, -0x8(%rbp)
jne 0x40a6
jmp 0x419a
movl 0x40f8(%rip), %ecx      # 0x81a4
movl -0x4(%rbp), %eax
xorl %edx, %edx
divl %ecx
movl %edx, -0x4(%rbp)
movl -0x4(%rbp), %edi
movl $0x1, %esi
leaq -0x18(%rbp), %rdx
callq 0x39b0
movl %eax, -0x14(%rbp)
movl -0x14(%rbp), %edi
callq 0x3b00
movq 0x40bf(%rip), %rax      # 0x8198
movl -0x14(%rbp), %ecx
shlq $0x5, %rcx
addq %rcx, %rax
movb $0x1, 0x1c(%rax)
movl -0x18(%rbp), %eax
addl -0x8(%rbp), %eax
movq 0x40a4(%rip), %rcx      # 0x8198
movl -0x14(%rbp), %edx
shlq $0x5, %rdx
addq %rdx, %rcx
cmpl 0x18(%rcx), %eax
ja 0x412e
movq 0x408e(%rip), %rax      # 0x8198
movl -0x14(%rbp), %ecx
shlq $0x5, %rcx
addq %rcx, %rax
movq 0x8(%rax), %rdi
movl -0x18(%rbp), %eax
addq %rax, %rdi
movq -0x10(%rbp), %rsi
movl -0x8(%rbp), %eax
movl %eax, %edx
callq 0x10e0
jmp 0x419a
movq 0x4063(%rip), %rax      # 0x8198
movl -0x14(%rbp), %ecx
shlq $0x5, %rcx
addq %rcx, %rax
movl 0x18(%rax), %eax
subl -0x18(%rbp), %eax
movl %eax, -0x1c(%rbp)
movq 0x4049(%rip), %rax      # 0x8198
movl -0x14(%rbp), %ecx
shlq $0x5, %rcx
addq %rcx, %rax
movq 0x8(%rax), %rdi
movl -0x18(%rbp), %eax
addq %rax, %rdi
movq -0x10(%rbp), %rsi
movl -0x1c(%rbp), %eax
movl %eax, %edx
callq 0x10e0
movl -0x1c(%rbp), %eax
addl -0x4(%rbp), %eax
movl %eax, -0x4(%rbp)
movl -0x1c(%rbp), %ecx
movl -0x8(%rbp), %eax
subl %ecx, %eax
movl %eax, -0x8(%rbp)
movl -0x4(%rbp), %edi
movl -0x8(%rbp), %esi
movq -0x10(%rbp), %rdx
movl -0x1c(%rbp), %eax
addq %rax, %rdx
callq 0x4080
addq $0x20, %rsp
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O0/ohkimur[P]the-c-programming-language-2nd-edition-solutions/chapter_5/exercise_5_06/getline.c
// Function: main
int main(void)
{
  char string[150] = "";

  get_line(string);
  puts(string);

  return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0xa0, %rsp
movl $0x0, -0x4(%rbp)
leaq -0xa0(%rbp), %rdi
xorl %esi, %esi
movl $0x96, %edx
callq 0x1040
leaq -0xa0(%rbp), %rdi
callq 0x11b0
leaq -0xa0(%rbp), %rdi
callq 0x1030
xorl %eax, %eax
addq $0xa0, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/KhuramAli[P]JAM-Benchmark/Single-Producer_Single-Consumer_RingBuffer_Lock-free_boost/code10.cpp
// Function: consumer()
void consumer(void)
{
	int value;
	while (!done) {
		while (spsc_queue.pop(value))
			++consumer_count;
	}

	while (spsc_queue.pop(value))
		++consumer_count;
}

// Assembly:
pushq %rax
leaq 0x4e58(%rip), %rdi      # 0x6100
callq 0x1530
xorb $-0x1, %al
testb $0x1, %al
jne 0x12b5
jmp 0x12de
jmp 0x12b7
leaq 0x3df2(%rip), %rdi      # 0x50b0
leaq 0x4(%rsp), %rsi
callq 0x15d0
testb $0x1, %al
jne 0x12ce
jmp 0x12dc
leaq 0x3dd3(%rip), %rdi      # 0x50a8
callq 0x1610
jmp 0x12b7
jmp 0x12a1
jmp 0x12e0
leaq 0x3dc9(%rip), %rdi      # 0x50b0
leaq 0x4(%rsp), %rsi
callq 0x15d0
testb $0x1, %al
jne 0x12f7
jmp 0x1305
leaq 0x3daa(%rip), %rdi      # 0x50a8
callq 0x1610
jmp 0x12e0
popq %rax
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/KhuramAli[P]JAM-Benchmark/Single-Producer_Single-Consumer_RingBuffer_Lock-free_boost/code10.cpp
// Function: main
int main(int argc, char* argv[])
{
	using namespace std;
	cout << "boost::lockfree::queue is ";
	if (!spsc_queue.is_lock_free())
		cout << "not ";
	cout << "lockfree" << endl;

	std::thread producer_thread(producer);
	std::thread consumer_thread(consumer);

	producer_thread.join();
	done = true;
	consumer_thread.join();

	cout << "produced " << producer_count << " objects." << endl;
	cout << "consumed " << consumer_count << " objects." << endl;
}

// Assembly:
subq $0x68, %rsp
movl $0x0, 0x64(%rsp)
movl %edi, 0x60(%rsp)
movq %rsi, 0x58(%rsp)
movq 0x3cac(%rip), %rdi      # 0x4fd8
leaq 0x1cd1(%rip), %rsi      # 0x3004
callq 0x1090
leaq 0x3d71(%rip), %rdi      # 0x50b0
callq 0x1640
testb $0x1, %al
jne 0x135b
movq 0x3c89(%rip), %rdi      # 0x4fd8
leaq 0x1cc9(%rip), %rsi      # 0x301f
callq 0x1090
movq 0x3c76(%rip), %rdi      # 0x4fd8
leaq 0x1cbb(%rip), %rsi      # 0x3024
callq 0x1090
movq %rax, %rdi
movq 0x3c48(%rip), %rsi      # 0x4fc0
callq 0x10b0
leaq -0x134(%rip), %rsi      # 0x1250
leaq 0x50(%rsp), %rdi
callq 0x1690
leaq -0xf5(%rip), %rsi       # 0x12a0
leaq 0x48(%rsp), %rdi
callq 0x1690
jmp 0x13a1
leaq 0x50(%rsp), %rdi
callq 0x10d0
jmp 0x13ad
leaq 0x4d4c(%rip), %rdi      # 0x6100
movl $0x1, %esi
callq 0x1750
leaq 0x48(%rsp), %rdi
callq 0x10d0
jmp 0x13ca
movq 0x3c07(%rip), %rdi      # 0x4fd8
leaq 0x1c55(%rip), %rsi      # 0x302d
callq 0x1090
movq %rax, 0x30(%rsp)
jmp 0x13e4
movq 0x30(%rsp), %rdi
movl 0x3cb5(%rip), %esi      # 0x50a4
callq 0x10e0
movq %rax, 0x28(%rsp)
jmp 0x13fb
movq 0x28(%rsp), %rdi
leaq 0x1c30(%rip), %rsi      # 0x3037
callq 0x1090
movq %rax, 0x20(%rsp)
jmp 0x1413
movq 0x20(%rsp), %rdi
movq 0x3ba1(%rip), %rsi      # 0x4fc0
callq 0x10b0
jmp 0x1426
movq 0x3bab(%rip), %rdi      # 0x4fd8
leaq 0x1c0d(%rip), %rsi      # 0x3041
callq 0x1090
movq %rax, 0x18(%rsp)
jmp 0x1440
leaq 0x3c61(%rip), %rdi      # 0x50a8
callq 0x1780
movq 0x18(%rsp), %rdi
movl %eax, %esi
callq 0x10e0
movq %rax, 0x10(%rsp)
jmp 0x145f
movq 0x10(%rsp), %rdi
leaq 0x1bcc(%rip), %rsi      # 0x3037
callq 0x1090
movq %rax, 0x8(%rsp)
jmp 0x1477
movq 0x8(%rsp), %rdi
movq 0x3b3d(%rip), %rsi      # 0x4fc0
callq 0x10b0
jmp 0x148a
leaq 0x48(%rsp), %rdi
callq 0x1810
leaq 0x50(%rsp), %rdi
callq 0x1810
movl 0x64(%rsp), %eax
addq $0x68, %rsp
retq
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x40(%rsp)
movl %eax, 0x3c(%rsp)
jmp 0x14cf
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x40(%rsp)
movl %eax, 0x3c(%rsp)
leaq 0x48(%rsp), %rdi
callq 0x1810
leaq 0x50(%rsp), %rdi
callq 0x1810
movq 0x40(%rsp), %rdi
callq 0x10f0
nopw %cs:(%rax,%rax)
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/kevinp89[P]Operating-System-EXT2-file-system-with-commands/./ext2_utils.c
// Function: get_dir_type
unsigned char get_dir_type(unsigned char file_type) {
	if (file_type == EXT2_FT_REG_FILE) {
		return 'f';
	} else if (file_type == EXT2_FT_DIR) {
		return 'd';
	} else if (file_type == EXT2_FT_SYMLINK) {
		return 'l';
	} else {
		return '?';
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movb %dil, %al
movb %al, -0x2(%rbp)
movzbl -0x2(%rbp), %eax
cmpl $0x1, %eax
jne 0x1319
movb $0x66, -0x1(%rbp)
jmp 0x133b
movzbl -0x2(%rbp), %eax
cmpl $0x2, %eax
jne 0x1328
movb $0x64, -0x1(%rbp)
jmp 0x133b
movzbl -0x2(%rbp), %eax
cmpl $0x7, %eax
jne 0x1337
movb $0x6c, -0x1(%rbp)
jmp 0x133b
movb $0x3f, -0x1(%rbp)
movb -0x1(%rbp), %al
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O0/kevinp89[P]Operating-System-EXT2-file-system-with-commands/./ext2_utils.c
// Function: get_inode_type
unsigned char get_inode_type(struct ext2_inode *ip) {
	if (S_ISREG(ip->i_mode)) {
		return 'f';
	} else if (S_ISDIR(ip->i_mode)) {
		return 'd';
	} else if (S_ISLNK(ip->i_mode)) {
		return 'l';
	} else {
		return '?';
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x10(%rbp)
movq -0x10(%rbp), %rax
movzwl (%rax), %eax
andl $0xf000, %eax           # imm = 0xF000
cmpl $0x8000, %eax           # imm = 0x8000
jne 0x1361
movb $0x66, -0x1(%rbp)
jmp 0x1397
movq -0x10(%rbp), %rax
movzwl (%rax), %eax
andl $0xf000, %eax           # imm = 0xF000
cmpl $0x4000, %eax           # imm = 0x4000
jne 0x137a
movb $0x64, -0x1(%rbp)
jmp 0x1397
movq -0x10(%rbp), %rax
movzwl (%rax), %eax
andl $0xf000, %eax           # imm = 0xF000
cmpl $0xa000, %eax           # imm = 0xA000
jne 0x1393
movb $0x6c, -0x1(%rbp)
jmp 0x1397
movb $0x3f, -0x1(%rbp)
movb -0x1(%rbp), %al
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/kevinp89[P]Operating-System-EXT2-file-system-with-commands/./ext2_utils.c
// Function: set_dir_type
void set_dir_type(struct ext2_dir_entry *dir_entry, unsigned char type) {
	switch(type) {
		case 'f':
			dir_entry->file_type = EXT2_FT_REG_FILE;
			break;
		case 'd':
			dir_entry->file_type = EXT2_FT_DIR;
			break;
		case 'l':
			dir_entry->file_type = EXT2_FT_SYMLINK;
			break;
		case '?':
		default:
			dir_entry->file_type = EXT2_FT_UNKNOWN;
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movb %sil, %al
movq %rdi, -0x8(%rbp)
movb %al, -0x9(%rbp)
movzbl -0x9(%rbp), %eax
movl %eax, -0x10(%rbp)
subl $0x3f, %eax
je 0x13f8
jmp 0x13bc
movl -0x10(%rbp), %eax
subl $0x64, %eax
je 0x13e4
jmp 0x13c6
movl -0x10(%rbp), %eax
subl $0x66, %eax
je 0x13da
jmp 0x13d0
movl -0x10(%rbp), %eax
subl $0x6c, %eax
je 0x13ee
jmp 0x13fa
movq -0x8(%rbp), %rax
movb $0x1, 0x7(%rax)
jmp 0x1402
movq -0x8(%rbp), %rax
movb $0x2, 0x7(%rax)
jmp 0x1402
movq -0x8(%rbp), %rax
movb $0x7, 0x7(%rax)
jmp 0x1402
jmp 0x13fa
movq -0x8(%rbp), %rax
movb $0x0, 0x7(%rax)
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/kevinp89[P]Operating-System-EXT2-file-system-with-commands/./ext2_utils.c
// Function: search_directories
unsigned int search_directories(unsigned char *disk, struct ext2_inode *node, char *target, int dir_only) {
	// Dir related
	unsigned int cur_rec_len;
	char filename[256];
	struct ext2_dir_entry *cur_dir;

	int i;
	for (i = 0; node->i_block[i] != 0; i++) {
		for (cur_rec_len = 0; cur_rec_len < 1024; ) {
			cur_dir = (struct ext2_dir_entry *)(disk + (1024 * node->i_block[i]) + cur_rec_len);
			cur_rec_len += cur_dir->rec_len;
			memset(filename, '\0', sizeof(filename));
			strncpy(filename, cur_dir->name, cur_dir->name_len);
			if (strcmp(filename, target) == 0) { // Found matching dir
				if (dir_only) { // If we're only checking for directories
					if (get_dir_type(cur_dir->file_type) == 'd') {
						return cur_dir->inode-1; // Return index, not the node itself.
					}
				} else { // Check all types of files
					return cur_dir->inode-1;
				}
			}
		}
	}
	return -1;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x140, %rsp            # imm = 0x140
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movl %ecx, -0x24(%rbp)
movl $0x0, -0x13c(%rbp)
movq -0x18(%rbp), %rax
movslq -0x13c(%rbp), %rcx
cmpl $0x0, 0x28(%rax,%rcx,4)
je 0x1542
movl $0x0, -0x28(%rbp)
cmpl $0x400, -0x28(%rbp)     # imm = 0x400
jae 0x152c
movq -0x10(%rbp), %rax
movq -0x18(%rbp), %rcx
movslq -0x13c(%rbp), %rdx
movl 0x28(%rcx,%rdx,4), %ecx
shll $0xa, %ecx
movl %ecx, %ecx
addq %rcx, %rax
movl -0x28(%rbp), %ecx
addq %rcx, %rax
movq %rax, -0x138(%rbp)
movq -0x138(%rbp), %rax
movzwl 0x4(%rax), %eax
addl -0x28(%rbp), %eax
movl %eax, -0x28(%rbp)
leaq -0x130(%rbp), %rdi
xorl %esi, %esi
movl $0x100, %edx            # imm = 0x100
callq 0x1090
leaq -0x130(%rbp), %rdi
movq -0x138(%rbp), %rsi
addq $0x8, %rsi
movq -0x138(%rbp), %rax
movzbl 0x6(%rax), %eax
movl %eax, %edx
callq 0x1040
leaq -0x130(%rbp), %rdi
movq -0x20(%rbp), %rsi
callq 0x10b0
cmpl $0x0, %eax
jne 0x1527
cmpl $0x0, -0x24(%rbp)
je 0x1514
movq -0x138(%rbp), %rax
movzbl 0x7(%rax), %edi
callq 0x1300
movzbl %al, %eax
cmpl $0x64, %eax
jne 0x1512
movq -0x138(%rbp), %rax
movl (%rax), %eax
subl $0x1, %eax
movl %eax, -0x4(%rbp)
jmp 0x1549
jmp 0x1525
movq -0x138(%rbp), %rax
movl (%rax), %eax
subl $0x1, %eax
movl %eax, -0x4(%rbp)
jmp 0x1549
jmp 0x1527
jmp 0x1451
jmp 0x152e
movl -0x13c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x13c(%rbp)
jmp 0x1434
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
movl -0x4(%rbp), %eax
addq $0x140, %rsp            # imm = 0x140
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/kevinp89[P]Operating-System-EXT2-file-system-with-commands/ext2_cp.c
// Function: check_path
int check_path(char *path){
	if(path[0] != '/'){
		return 1;	
	} else {
		return 0;
	}

}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x10(%rbp)
movq -0x10(%rbp), %rax
movsbl (%rax), %eax
cmpl $0x2f, %eax
je 0x17bd
movl $0x1, -0x4(%rbp)
jmp 0x17c4
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/kevinp89[P]Operating-System-EXT2-file-system-with-commands/ext2_cp.c
// Function: get_free_blocks
int *get_free_blocks(int blocks_need, unsigned char *block_bit_map){

	int i,j=22;
	
	int* free_blocks = malloc(sizeof(int)*blocks_need);
	
	for(i=0; i<blocks_need; i++){
		while(check_node(j, block_bit_map) == 0){
			j++;
			//if j reaches max block count, return null
			if(j==sb->s_blocks_count){
				return NULL;
			}
		}
		free_blocks[i] = j;	
		set_node(j, block_bit_map);
	}
	return free_blocks;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movl %edi, -0xc(%rbp)
movq %rsi, -0x18(%rbp)
movl $0x16, -0x20(%rbp)
movslq -0xc(%rbp), %rdi
shlq $0x2, %rdi
callq 0x10f0
movq %rax, -0x28(%rbp)
movl $0x0, -0x1c(%rbp)
movl -0x1c(%rbp), %eax
cmpl -0xc(%rbp), %eax
jge 0x1862
jmp 0x1808
movl -0x20(%rbp), %edi
movq -0x18(%rbp), %rsi
callq 0x1260
cmpl $0x0, %eax
jne 0x183d
movl -0x20(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x20(%rbp)
movl -0x20(%rbp), %eax
movq 0x389c(%rip), %rcx      # 0x50c8
cmpl 0x4(%rcx), %eax
jne 0x183b
movq $0x0, -0x8(%rbp)
jmp 0x186a
jmp 0x1808
movl -0x20(%rbp), %edx
movq -0x28(%rbp), %rax
movslq -0x1c(%rbp), %rcx
movl %edx, (%rax,%rcx,4)
movl -0x20(%rbp), %edi
movq -0x18(%rbp), %rsi
callq 0x12b0
movl -0x1c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x1c(%rbp)
jmp 0x17fe
movq -0x28(%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/kevinp89[P]Operating-System-EXT2-file-system-with-commands/ext2_cp.c
// Function: find_free_block
int find_free_block(unsigned char *bmap){
	int bnode;
	for (bnode = 22; bnode < sb->s_blocks_count; bnode++) {
		if (check_node(bnode, bmap) == 0) {
			break;
		}
	}
	if(bnode == sb->s_blocks_count){
		return -1;	
	}
	set_node(bnode, bmap);
	return bnode;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movl $0x16, -0x14(%rbp)
movl -0x14(%rbp), %eax
movq 0x382b(%rip), %rcx      # 0x50c8
cmpl 0x4(%rcx), %eax
jae 0x18c2
movl -0x14(%rbp), %edi
movq -0x10(%rbp), %rsi
callq 0x1260
cmpl $0x0, %eax
jne 0x18b5
jmp 0x18c2
jmp 0x18b7
movl -0x14(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x14(%rbp)
jmp 0x1893
movl -0x14(%rbp), %eax
movq 0x37fc(%rip), %rcx      # 0x50c8
cmpl 0x4(%rcx), %eax
jne 0x18da
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
jmp 0x18ec
movl -0x14(%rbp), %edi
movq -0x10(%rbp), %rsi
callq 0x12b0
movl -0x14(%rbp), %eax
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/chatziko-k08[P]lecture-code/programs/fibonacci/ADTIntVector_test.c
// Function: test_insert
void test_insert(void) {
	IntVector vec = int_vector_create(0);

	// insert 1000 στοιχεία ώστε να συμβούν πολλαπλά resizes
	for (int i = 0; i < 1000; i++) {
		int_vector_insert_last(vec, i);
		TEST_ASSERT(int_vector_size(vec) == i+1);	// Το size ενημερώθηκε;
		TEST_ASSERT(int_vector_get_at(vec, i) == i);	// Μπορούμε να κάνουμε at το στοιχείο που μόλις βάλαμε;
	}

	// Δοκιμή ότι μετά τα resizes τα στοιχεία είναι ακόμα προσπελάσιμα
	for (int i = 0; i < 1000; i++)
		TEST_ASSERT(int_vector_get_at(vec, i) == i);

	int_vector_destroy(vec);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
xorl %edi, %edi
callq 0x53c0
movq %rax, -0x8(%rbp)
movl $0x0, -0xc(%rbp)
cmpl $0x3e8, -0xc(%rbp)      # imm = 0x3E8
jge 0x44df
movq -0x8(%rbp), %rdi
movl -0xc(%rbp), %esi
callq 0x54c0
movq -0x8(%rbp), %rdi
callq 0x5430
movl -0xc(%rbp), %ecx
addl $0x1, %ecx
cmpl %ecx, %eax
sete %al
andb $0x1, %al
movzbl %al, %edi
leaq 0x1e7e(%rip), %rsi      # 0x62e1
movl $0x1b, %edx
leaq 0x1fde(%rip), %rcx      # 0x644d
leaq 0x1e99(%rip), %r8       # 0x630f
movb $0x0, %al
callq 0x2370
cmpl $0x0, %eax
jne 0x4487
callq 0x2e50
jmp 0x4489
jmp 0x448b
movq -0x8(%rbp), %rdi
movl -0xc(%rbp), %esi
callq 0x5490
cmpl -0xc(%rbp), %eax
sete %al
andb $0x1, %al
movzbl %al, %edi
leaq 0x1e38(%rip), %rsi      # 0x62e1
movl $0x1c, %edx
leaq 0x1f98(%rip), %rcx      # 0x644d
leaq 0x1e6f(%rip), %r8       # 0x632b
movb $0x0, %al
callq 0x2370
cmpl $0x0, %eax
jne 0x44cd
callq 0x2e50
jmp 0x44cf
jmp 0x44d1
movl -0xc(%rbp), %eax
addl $0x1, %eax
movl %eax, -0xc(%rbp)
jmp 0x442a
movl $0x0, -0x10(%rbp)
cmpl $0x3e8, -0x10(%rbp)     # imm = 0x3E8
jge 0x4542
jmp 0x44f1
movq -0x8(%rbp), %rdi
movl -0x10(%rbp), %esi
callq 0x5490
cmpl -0x10(%rbp), %eax
sete %al
andb $0x1, %al
movzbl %al, %edi
leaq 0x1dd2(%rip), %rsi      # 0x62e1
movl $0x21, %edx
leaq 0x1f32(%rip), %rcx      # 0x644d
leaq 0x1e09(%rip), %r8       # 0x632b
movb $0x0, %al
callq 0x2370
cmpl $0x0, %eax
jne 0x4533
callq 0x2e50
jmp 0x4535
jmp 0x4537
movl -0x10(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x10(%rbp)
jmp 0x44e6
movq -0x8(%rbp), %rdi
callq 0x5590
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/chatziko-k08[P]lecture-code/programs/fibonacci/ADTIntVector_test.c
// Function: test_remove
void test_remove(void) {
	IntVector vec = int_vector_create(1000);

	// replace για προσθήκη δεδομένων, χωρίς ελέγχους (έχουμε ξεχωριστό test για το replace)
	for (int i = 0; i < 1000; i++)
		int_vector_set_at(vec, i, i);

	// Διαδοχικά remove ώστε να συμβούν και resizes
	for (int i = 999; i >= 0; i--) {
		TEST_ASSERT(int_vector_get_at(vec, i) == i);
		int_vector_remove_last(vec);
		TEST_ASSERT(int_vector_size(vec) == i);
	}

	int_vector_destroy(vec);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movl $0x3e8, %edi            # imm = 0x3E8
callq 0x53c0
movq %rax, -0x8(%rbp)
movl $0x0, -0xc(%rbp)
cmpl $0x3e8, -0xc(%rbp)      # imm = 0x3E8
jge 0x45a0
movq -0x8(%rbp), %rdi
movl -0xc(%rbp), %esi
movl -0xc(%rbp), %edx
callq 0x5450
movl -0xc(%rbp), %eax
addl $0x1, %eax
movl %eax, -0xc(%rbp)
jmp 0x457d
movl $0x3e7, -0x10(%rbp)     # imm = 0x3E7
cmpl $0x0, -0x10(%rbp)
jl 0x4651
jmp 0x45b3
movq -0x8(%rbp), %rdi
movl -0x10(%rbp), %esi
callq 0x5490
cmpl -0x10(%rbp), %eax
sete %al
andb $0x1, %al
movzbl %al, %edi
leaq 0x1d10(%rip), %rsi      # 0x62e1
movl $0x2f, %edx
leaq 0x1e70(%rip), %rcx      # 0x644d
leaq 0x1d47(%rip), %r8       # 0x632b
movb $0x0, %al
callq 0x2370
cmpl $0x0, %eax
jne 0x45f5
callq 0x2e50
jmp 0x45f7
movq -0x8(%rbp), %rdi
callq 0x5500
movq -0x8(%rbp), %rdi
callq 0x5430
cmpl -0x10(%rbp), %eax
sete %al
andb $0x1, %al
movzbl %al, %edi
leaq 0x1cc6(%rip), %rsi      # 0x62e1
movl $0x31, %edx
leaq 0x1e26(%rip), %rcx      # 0x644d
leaq 0x1d1c(%rip), %r8       # 0x634a
movb $0x0, %al
callq 0x2370
cmpl $0x0, %eax
jne 0x463f
callq 0x2e50
jmp 0x4641
jmp 0x4643
movl -0x10(%rbp), %eax
addl $-0x1, %eax
movl %eax, -0x10(%rbp)
jmp 0x45a7
movq -0x8(%rbp), %rdi
callq 0x5590
addq $0x10, %rsp
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O0/chatziko-k08[P]lecture-code/programs/fibonacci/ADTIntVector_test.c
// Function: test_get_set_at
void test_get_set_at(void) {
	IntVector vec = int_vector_create(0);

	// insert πολλαπλά 0, θα τα αλλάξουμε μετά με replace
	for (int i = 0; i < 1000; i++)
		int_vector_insert_last(vec, 0);

	for (int i = 0; i < 1000; i++) {
		TEST_ASSERT(int_vector_get_at(vec, i) == 0);
		int_vector_set_at(vec, i, i);
		TEST_ASSERT(int_vector_get_at(vec, i) == i);
	}

	int_vector_destroy(vec);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
xorl %edi, %edi
callq 0x53c0
movq %rax, -0x8(%rbp)
movl $0x0, -0xc(%rbp)
cmpl $0x3e8, -0xc(%rbp)      # imm = 0x3E8
jge 0x4699
movq -0x8(%rbp), %rdi
xorl %esi, %esi
callq 0x54c0
movl -0xc(%rbp), %eax
addl $0x1, %eax
movl %eax, -0xc(%rbp)
jmp 0x467a
movl $0x0, -0x10(%rbp)
cmpl $0x3e8, -0x10(%rbp)     # imm = 0x3E8
jge 0x4756
jmp 0x46af
movq -0x8(%rbp), %rdi
movl -0x10(%rbp), %esi
callq 0x5490
cmpl $0x0, %eax
sete %al
andb $0x1, %al
movzbl %al, %edi
leaq 0x1c14(%rip), %rsi      # 0x62e1
movl $0x3f, %edx
leaq 0x1d74(%rip), %rcx      # 0x644d
leaq 0x1c84(%rip), %r8       # 0x6364
movb $0x0, %al
callq 0x2370
cmpl $0x0, %eax
jne 0x46f1
callq 0x2e50
jmp 0x46f3
movq -0x8(%rbp), %rdi
movl -0x10(%rbp), %esi
movl -0x10(%rbp), %edx
callq 0x5450
movq -0x8(%rbp), %rdi
movl -0x10(%rbp), %esi
callq 0x5490
cmpl -0x10(%rbp), %eax
sete %al
andb $0x1, %al
movzbl %al, %edi
leaq 0x1bc1(%rip), %rsi      # 0x62e1
movl $0x41, %edx
leaq 0x1d21(%rip), %rcx      # 0x644d
leaq 0x1bf8(%rip), %r8       # 0x632b
movb $0x0, %al
callq 0x2370
cmpl $0x0, %eax
jne 0x4744
callq 0x2e50
jmp 0x4746
jmp 0x4748
movl -0x10(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x10(%rbp)
jmp 0x46a0
movq -0x8(%rbp), %rdi
callq 0x5590
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/chatziko-k08[P]lecture-code/programs/fibonacci/ADTIntVector_test.c
// Function: test_find
void test_find(void) {
	IntVector vec = int_vector_create(1000);

	// replace για προσθήκη δεδομένων
	for (int i = 0; i < 1000; i++)
		int_vector_set_at(vec, i, i);

	for (int i = 0; i < 1000; i++) {
		int p = int_vector_find(vec, i);
		TEST_ASSERT(p == i);
	}

	TEST_ASSERT(int_vector_find(vec, -12) == INT_MIN);

	int_vector_destroy(vec);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movl $0x3e8, %edi            # imm = 0x3E8
callq 0x53c0
movq %rax, -0x8(%rbp)
movl $0x0, -0xc(%rbp)
cmpl $0x3e8, -0xc(%rbp)      # imm = 0x3E8
jge 0x47b0
movq -0x8(%rbp), %rdi
movl -0xc(%rbp), %esi
movl -0xc(%rbp), %edx
callq 0x5450
movl -0xc(%rbp), %eax
addl $0x1, %eax
movl %eax, -0xc(%rbp)
jmp 0x478d
movl $0x0, -0x10(%rbp)
cmpl $0x3e8, -0x10(%rbp)     # imm = 0x3E8
jge 0x4817
movq -0x8(%rbp), %rdi
movl -0x10(%rbp), %esi
callq 0x5540
movl %eax, -0x14(%rbp)
movl -0x14(%rbp), %eax
cmpl -0x10(%rbp), %eax
sete %al
andb $0x1, %al
movzbl %al, %edi
leaq 0x1afd(%rip), %rsi      # 0x62e1
movl $0x50, %edx
leaq 0x1c5d(%rip), %rcx      # 0x644d
leaq 0x1b8c(%rip), %r8       # 0x6383
movb $0x0, %al
callq 0x2370
cmpl $0x0, %eax
jne 0x4808
callq 0x2e50
jmp 0x480a
jmp 0x480c
movl -0x10(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x10(%rbp)
jmp 0x47b7
jmp 0x4819
movq -0x8(%rbp), %rdi
movl $0xfffffff4, %esi       # imm = 0xFFFFFFF4
callq 0x5540
cmpl $0x80000000, %eax       # imm = 0x80000000
sete %al
andb $0x1, %al
movzbl %al, %edi
leaq 0x1aa6(%rip), %rsi      # 0x62e1
movl $0x53, %edx
leaq 0x1c06(%rip), %rcx      # 0x644d
leaq 0x1b3c(%rip), %r8       # 0x638a
movb $0x0, %al
callq 0x2370
cmpl $0x0, %eax
jne 0x485f
callq 0x2e50
jmp 0x4861
movq -0x8(%rbp), %rdi
callq 0x5590
addq $0x20, %rsp
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O0/chatziko-k08[P]lecture-code/programs/fibonacci/ADTIntVector_test.c
// Function: test_destroy
void test_destroy(void) {
	// Απλά εκτελούμε την destroy, για να ελέγξουμε αν όντως δουλεύει
	// σωστά τρέχουμε το test με valgrind.

	IntVector vec = int_vector_create(1);

	int_vector_set_at(vec, 0, 1);
	int_vector_insert_last(vec, 1);
	int_vector_remove_last(vec);

	int_vector_destroy(vec);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movl $0x1, %edi
callq 0x53c0
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rdi
xorl %esi, %esi
movl $0x1, %edx
callq 0x5450
movq -0x8(%rbp), %rdi
movl $0x1, %esi
callq 0x54c0
movq -0x8(%rbp), %rdi
callq 0x5500
movq -0x8(%rbp), %rdi
callq 0x5590
addq $0x10, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/chatziko-k08[P]lecture-code/programs/fibonacci/ADTIntVector.c
// Function: int_vector_create
IntVector int_vector_create(int size) {
	// Περνάμε τη free στην vector_create, ώστε κάθε στοιχείο που αφαιρείται να γίνεται free αυτόματα
	Vector vec = vector_create(size, free);

	// Ο πίνακας περιέχει size μη-αρχικοποιημένους ακεραίους, δεσμεύουμε μνήμη για αυτούς
	for (int i = 0; i < size; i ++)
		vector_set_at(vec, i, malloc(sizeof(int)));

	return (IntVector)vec;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movl %edi, -0x4(%rbp)
movl -0x4(%rbp), %edi
movq 0x3beb(%rip), %rsi      # 0x8fc0
callq 0x55b0
movq %rax, -0x10(%rbp)
movl $0x0, -0x14(%rbp)
movl -0x14(%rbp), %eax
cmpl -0x4(%rbp), %eax
jge 0x541f
movq -0x10(%rbp), %rax
movq %rax, -0x20(%rbp)
movl -0x14(%rbp), %eax
movl %eax, -0x18(%rbp)
movl $0x4, %edi
callq 0x2180
movq -0x20(%rbp), %rdi
movl -0x18(%rbp), %esi
movq %rax, %rdx
callq 0x56b0
movl -0x14(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x14(%rbp)
jmp 0x53e5
movq -0x10(%rbp), %rax
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/chatziko-k08[P]lecture-code/programs/fibonacci/ADTIntVector.c
// Function: int_vector_insert_last
void int_vector_insert_last(IntVector vec, int value) {
	// Νέο στοιχείο, χρειαζόμαστε μνήμη!
	int *p = malloc(sizeof(int));
	*p = value;
	vector_insert_last((Vector)vec, p);		// προσθήκη του int pointer στο vector
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movl $0x4, %edi
callq 0x2180
movq %rax, -0x18(%rbp)
movl -0xc(%rbp), %ecx
movq -0x18(%rbp), %rax
movl %ecx, (%rax)
movq -0x8(%rbp), %rdi
movq -0x18(%rbp), %rsi
callq 0x5750
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/chatziko-k08[P]lecture-code/programs/cat/../../modules/UsingDynamicArray/ADTVector.c
// Function: vector_create
Vector vector_create(int size, DestroyFunc destroy_value) {
	// Δημιουργία του struct
	Vector vec = malloc(sizeof(*vec));

	vec->size = size;
	vec->destroy_value = destroy_value;

	// Δέσμευση μνήμης για τον πίνακα. Αρχικά το vector περιέχει size
	// μη-αρχικοποιημένα στοιχεία, αλλά εμείς δεσμεύουμε xώρο για τουλάχιστον
	// VECTOR_MIN_CAPACITY για να αποφύγουμε τα πολλαπλά resizes.
	//
	vec->capacity = size < VECTOR_MIN_CAPACITY ? VECTOR_MIN_CAPACITY : size;
	vec->array = calloc(vec->capacity, sizeof(*vec->array));		// αρχικοποίηση σε 0 (NULL)

	return vec;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movl %edi, -0x4(%rbp)
movq %rsi, -0x10(%rbp)
movl $0x18, %edi
callq 0x2180
movq %rax, -0x18(%rbp)
movl -0x4(%rbp), %ecx
movq -0x18(%rbp), %rax
movl %ecx, 0x8(%rax)
movq -0x10(%rbp), %rcx
movq -0x18(%rbp), %rax
movq %rcx, 0x10(%rax)
cmpl $0xa, -0x4(%rbp)
jge 0x55f3
movl $0xa, %eax
movl %eax, -0x1c(%rbp)
jmp 0x55f9
movl -0x4(%rbp), %eax
movl %eax, -0x1c(%rbp)
movl -0x1c(%rbp), %ecx
movq -0x18(%rbp), %rax
movl %ecx, 0xc(%rax)
movq -0x18(%rbp), %rax
movslq 0xc(%rax), %rdi
movl $0x8, %esi
callq 0x2140
movq %rax, %rcx
movq -0x18(%rbp), %rax
movq %rcx, (%rax)
movq -0x18(%rbp), %rax
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/chatziko-k08[P]lecture-code/programs/cat/../../modules/UsingDynamicArray/ADTVector.c
// Function: vector_set_at
void vector_set_at(Vector vec, int pos, Pointer value) {
	assert(pos >= 0 && pos < vec->size);	// LCOV_EXCL_LINE

	// Αν υπάρχει συνάρτηση destroy_value, την καλούμε για το στοιχείο που αντικαθίσταται
	if (value != vec->array[pos].value && vec->destroy_value != NULL)
		vec->destroy_value(vec->array[pos].value);

	vec->array[pos].value = value;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movq %rdx, -0x18(%rbp)
cmpl $0x0, -0xc(%rbp)
jl 0x56d7
movl -0xc(%rbp), %eax
movq -0x8(%rbp), %rcx
cmpl 0x8(%rcx), %eax
jge 0x56d7
jmp 0x56f6
leaq 0x1713(%rip), %rdi      # 0x6df1
leaq 0x1728(%rip), %rsi      # 0x6e0d
movl $0x3a, %edx
leaq 0x176b(%rip), %rcx      # 0x6e5c
callq 0x20f0
movq -0x18(%rbp), %rax
movq -0x8(%rbp), %rcx
movq (%rcx), %rcx
movslq -0xc(%rbp), %rdx
cmpq (%rcx,%rdx,8), %rax
je 0x572f
movq -0x8(%rbp), %rax
cmpq $0x0, 0x10(%rax)
je 0x572f
movq -0x8(%rbp), %rax
movq 0x10(%rax), %rax
movq -0x8(%rbp), %rcx
movq (%rcx), %rcx
movslq -0xc(%rbp), %rdx
movq (%rcx,%rdx,8), %rdi
callq *%rax
movq -0x18(%rbp), %rdx
movq -0x8(%rbp), %rax
movq (%rax), %rax
movslq -0xc(%rbp), %rcx
movq %rdx, (%rax,%rcx,8)
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/chatziko-k08[P]lecture-code/programs/cat/../../modules/UsingDynamicArray/ADTVector.c
// Function: vector_insert_last
void vector_insert_last(Vector vec, Pointer value) {
	// Μεγαλώνουμε τον πίνακα (αν χρειαστεί), ώστε να χωράει τουλάχιστον size στοιχεία
	// Διπλασιάζουμε κάθε φορά το capacity (σημαντικό για την πολυπλοκότητα!)
	if (vec->capacity == vec->size) {
		// Προσοχή: δεν πρέπει να κάνουμε free τον παλιό pointer, το κάνει η realloc
		vec->capacity *= 2;
		vec->array = realloc(vec->array, vec->capacity * sizeof(*vec->array));
	}

	// Μεγαλώνουμε τον πίνακα και προσθέτουμε το στοιχείο
	vec->array[vec->size].value = value;
	vec->size++;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rax
movl 0xc(%rax), %eax
movq -0x8(%rbp), %rcx
cmpl 0x8(%rcx), %eax
jne 0x579e
movq -0x8(%rbp), %rax
movl 0xc(%rax), %ecx
shll %ecx
movl %ecx, 0xc(%rax)
movq -0x8(%rbp), %rax
movq (%rax), %rdi
movq -0x8(%rbp), %rax
movslq 0xc(%rax), %rsi
shlq $0x3, %rsi
callq 0x21b0
movq %rax, %rcx
movq -0x8(%rbp), %rax
movq %rcx, (%rax)
movq -0x10(%rbp), %rdx
movq -0x8(%rbp), %rax
movq (%rax), %rax
movq -0x8(%rbp), %rcx
movslq 0x8(%rcx), %rcx
movq %rdx, (%rax,%rcx,8)
movq -0x8(%rbp), %rax
movl 0x8(%rax), %ecx
addl $0x1, %ecx
movl %ecx, 0x8(%rax)
addq $0x10, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/chatziko-k08[P]lecture-code/programs/cat/../../modules/UsingDynamicArray/ADTVector.c
// Function: vector_remove_last
void vector_remove_last(Vector vec) {
	assert(vec->size != 0);		// LCOV_EXCL_LINE

	// Αν υπάρχει συνάρτηση destroy_value, την καλούμε για το στοιχείο που αφαιρείται
	if (vec->destroy_value != NULL)
		vec->destroy_value(vec->array[vec->size - 1].value);

	// Αφαιρούμε στοιχείο οπότε ο πίνακας μικραίνει
	vec->size--;

	// Μικραίνουμε τον πίνακα αν χρειαστεί, ώστε να μην υπάρχει υπερβολική σπατάλη χώρου.
	// Για την πολυπλοκότητα είναι σημαντικό να μειώνουμε το μέγεθος στο μισό, και μόνο
	// αν το capacity είναι τετραπλάσιο του size (δηλαδή το 75% του πίνακα είναι άδειος).
	//
	if (vec->capacity > vec->size * 4 && vec->capacity > 2*VECTOR_MIN_CAPACITY) {
		vec->capacity /= 2;
		vec->array = realloc(vec->array, vec->capacity * sizeof(*vec->array));
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
cmpl $0x0, 0x8(%rax)
je 0x57e8
jmp 0x5807
leaq 0x1696(%rip), %rdi      # 0x6e85
leaq 0x1617(%rip), %rsi      # 0x6e0d
movl $0x52, %edx
leaq 0x1692(%rip), %rcx      # 0x6e94
callq 0x20f0
movq -0x8(%rbp), %rax
cmpq $0x0, 0x10(%rax)
je 0x5834
movq -0x8(%rbp), %rax
movq 0x10(%rax), %rax
movq -0x8(%rbp), %rcx
movq (%rcx), %rcx
movq -0x8(%rbp), %rdx
movl 0x8(%rdx), %edx
subl $0x1, %edx
movslq %edx, %rdx
movq (%rcx,%rdx,8), %rdi
callq *%rax
movq -0x8(%rbp), %rax
movl 0x8(%rax), %ecx
addl $-0x1, %ecx
movl %ecx, 0x8(%rax)
movq -0x8(%rbp), %rax
movl 0xc(%rax), %eax
movq -0x8(%rbp), %rcx
movl 0x8(%rcx), %ecx
shll $0x2, %ecx
cmpl %ecx, %eax
jle 0x589e
movq -0x8(%rbp), %rax
cmpl $0x14, 0xc(%rax)
jle 0x589e
movq -0x8(%rbp), %rax
movq %rax, -0x10(%rbp)
movl 0xc(%rax), %eax
movl $0x2, %ecx
cltd
idivl %ecx
movl %eax, %ecx
movq -0x10(%rbp), %rax
movl %ecx, 0xc(%rax)
movq -0x8(%rbp), %rax
movq (%rax), %rdi
movq -0x8(%rbp), %rax
movslq 0xc(%rax), %rsi
shlq $0x3, %rsi
callq 0x21b0
movq %rax, %rcx
movq -0x8(%rbp), %rax
movq %rcx, (%rax)
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/chatziko-k08[P]lecture-code/programs/cat/../../modules/UsingDynamicArray/ADTVector.c
// Function: vector_find
Pointer vector_find(Vector vec, Pointer value, CompareFunc compare) {
	// Διάσχιση του vector
	for (int i = 0; i < vec->size; i++)
		if (compare(vec->array[i].value, value) == 0)
			return vec->array[i].value;		// βρέθηκε

	return NULL;				// δεν υπάρχει
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movl $0x0, -0x24(%rbp)
movl -0x24(%rbp), %eax
movq -0x10(%rbp), %rcx
cmpl 0x8(%rcx), %eax
jge 0x5917
movq -0x20(%rbp), %rax
movq -0x10(%rbp), %rcx
movq (%rcx), %rcx
movslq -0x24(%rbp), %rdx
movq (%rcx,%rdx,8), %rdi
movq -0x18(%rbp), %rsi
callq *%rax
cmpl $0x0, %eax
jne 0x590a
movq -0x10(%rbp), %rax
movq (%rax), %rax
movslq -0x24(%rbp), %rcx
movq (%rax,%rcx,8), %rax
movq %rax, -0x8(%rbp)
jmp 0x591f
jmp 0x590c
movl -0x24(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x24(%rbp)
jmp 0x58cb
movq $0x0, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax)