LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O0/crcx[P]retroforth/vm/nga-c/./dev-float.c
// Function: float_eq
void float_eq(NgaState *vm) {
  double a = float_pop(vm);
  double b = float_pop(vm);
  if (a == b)
    stack_push(vm, -1);
  else
    stack_push(vm, 0);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
callq 0x5460
movsd %xmm0, -0x10(%rbp)
movq -0x8(%rbp), %rdi
callq 0x5460
movsd %xmm0, -0x18(%rbp)
movsd -0x10(%rbp), %xmm0
ucomisd -0x18(%rbp), %xmm0
jne 0x5aa6
jp 0x5aa6
movq -0x8(%rbp), %rdi
movl $0xffffffff, %esi       # imm = 0xFFFFFFFF
callq 0x3980
jmp 0x5ab1
movq -0x8(%rbp), %rdi
xorl %esi, %esi
callq 0x3980
addq $0x20, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/crcx[P]retroforth/vm/nga-c/./dev-float.c
// Function: float_lt
void float_lt(NgaState *vm) {
  double a = float_pop(vm);
  double b = float_pop(vm);
  if (b < a)
    stack_push(vm, -1);
  else
    stack_push(vm, 0);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
callq 0x5460
movsd %xmm0, -0x10(%rbp)
movq -0x8(%rbp), %rdi
callq 0x5460
movsd %xmm0, -0x18(%rbp)
movsd -0x18(%rbp), %xmm1
movsd -0x10(%rbp), %xmm0
ucomisd %xmm1, %xmm0
jbe 0x5b68
movq -0x8(%rbp), %rdi
movl $0xffffffff, %esi       # imm = 0xFFFFFFFF
callq 0x3980
jmp 0x5b73
movq -0x8(%rbp), %rdi
xorl %esi, %esi
callq 0x3980
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/crcx[P]retroforth/vm/nga-c/./dev-float.c
// Function: float_gt
void float_gt(NgaState *vm) {
  double a = float_pop(vm);
  double b = float_pop(vm);
  if (b > a)
    stack_push(vm, -1);
  else
    stack_push(vm, 0);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
callq 0x5460
movsd %xmm0, -0x10(%rbp)
movq -0x8(%rbp), %rdi
callq 0x5460
movsd %xmm0, -0x18(%rbp)
movsd -0x18(%rbp), %xmm0
ucomisd -0x10(%rbp), %xmm0
jbe 0x5bc4
movq -0x8(%rbp), %rdi
movl $0xffffffff, %esi       # imm = 0xFFFFFFFF
callq 0x3980
jmp 0x5bcf
movq -0x8(%rbp), %rdi
xorl %esi, %esi
callq 0x3980
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/crcx[P]retroforth/vm/nga-c/./dev-float.c
// Function: float_swap
void float_swap(NgaState *vm) {
  double a = float_pop(vm);
  double b = float_pop(vm);
  float_push(vm, a);
  float_push(vm, b);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
callq 0x5460
movsd %xmm0, -0x10(%rbp)
movq -0x8(%rbp), %rdi
callq 0x5460
movsd %xmm0, -0x18(%rbp)
movq -0x8(%rbp), %rdi
movsd -0x10(%rbp), %xmm0
callq 0x5410
movq -0x8(%rbp), %rdi
movsd -0x18(%rbp), %xmm0
callq 0x5410
addq $0x20, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/crcx[P]retroforth/vm/nga-c/./dev-rng.c
// Function: io_rng
V io_rng(NgaState *vm) {
  int64_t r = 0;
  char buffer[8];
  int i;
  ssize_t ignore;
  int fd = open("/dev/urandom", O_RDONLY);
  ignore = read(fd, buffer, 8);
  close(fd);
  for(i = 0; i < 8; ++i) {
    r = r << 8;
    r += ((int64_t)buffer[i] & 0xFF);
  }
#ifndef BIT64
  stack_push(vm, (CELL)abs((CELL)r));
#else
  stack_push(vm, (CELL)llabs((CELL)r));
#endif
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq $0x0, -0x10(%rbp)
leaq 0x6ee9(%rip), %rdi      # 0xd274
xorl %esi, %esi
movb $0x0, %al
callq 0x3310
movl %eax, -0x2c(%rbp)
movl -0x2c(%rbp), %edi
leaq -0x18(%rbp), %rsi
movl $0x8, %edx
callq 0x3200
movq %rax, -0x28(%rbp)
movl -0x2c(%rbp), %edi
callq 0x31b0
movl $0x0, -0x1c(%rbp)
cmpl $0x8, -0x1c(%rbp)
jge 0x63f0
movq -0x10(%rbp), %rax
shlq $0x8, %rax
movq %rax, -0x10(%rbp)
movslq -0x1c(%rbp), %rax
movsbq -0x18(%rbp,%rax), %rax
andq $0xff, %rax
addq -0x10(%rbp), %rax
movq %rax, -0x10(%rbp)
movl -0x1c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x1c(%rbp)
jmp 0x63bb
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rax
movl %eax, %esi
movl %esi, %eax
negl %eax
cmovnsl %eax, %esi
callq 0x3980
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/crcx[P]retroforth/vm/nga-c/./dev-unix.c
// Function: unix_open_pipe
V unix_open_pipe(NgaState *vm) {
  CELL slot, mode, name;
  char *request;
  const char *modes[] = {"r", "w", "", "r+"};
  slot = files_get_handle(vm);
  mode = stack_pop(vm);
  name = stack_pop(vm);
  request = string_extract(vm, name);
  if (slot > 0) {
    vm->OpenFileHandles[slot] = popen(request, modes[mode]);
  }
  if (vm->OpenFileHandles[slot] == NULL) {
    vm->OpenFileHandles[slot] = 0;
    slot = 0;
  }
  stack_push(vm, slot);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x8(%rbp)
movq 0xa95d(%rip), %rax      # 0x10db0
movq %rax, -0x40(%rbp)
movq 0xa95a(%rip), %rax      # 0x10db8
movq %rax, -0x38(%rbp)
movq 0xa957(%rip), %rax      # 0x10dc0
movq %rax, -0x30(%rbp)
movq 0xa954(%rip), %rax      # 0x10dc8
movq %rax, -0x28(%rbp)
movq -0x8(%rbp), %rdi
callq 0x41e0
movl %eax, -0xc(%rbp)
movq -0x8(%rbp), %rdi
callq 0x3b30
movl %eax, -0x10(%rbp)
movq -0x8(%rbp), %rdi
callq 0x3b30
movl %eax, -0x14(%rbp)
movq -0x8(%rbp), %rdi
movl -0x14(%rbp), %esi
callq 0x40c0
movq %rax, -0x20(%rbp)
cmpl $0x0, -0xc(%rbp)
jle 0x64d7
movq -0x20(%rbp), %rdi
movslq -0x10(%rbp), %rax
movq -0x40(%rbp,%rax,8), %rsi
callq 0x3320
movq %rax, %rdx
movq -0x8(%rbp), %rax
movslq -0xc(%rbp), %rcx
movq %rdx, 0x288ef0(%rax,%rcx,8)
movq -0x8(%rbp), %rax
movslq -0xc(%rbp), %rcx
cmpq $0x0, 0x288ef0(%rax,%rcx,8)
jne 0x6505
movq -0x8(%rbp), %rax
movslq -0xc(%rbp), %rcx
movq $0x0, 0x288ef0(%rax,%rcx,8)
movl $0x0, -0xc(%rbp)
movq -0x8(%rbp), %rdi
movl -0xc(%rbp), %esi
callq 0x3980
addq $0x40, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/crcx[P]retroforth/vm/nga-c/./dev-unix.c
// Function: unix_exec0
V unix_exec0(NgaState *vm) {
  char path[1025];
  strlcpy(path, string_extract(vm, stack_pop(vm)), 1024);
  execl(path, path, (char *)0);
  stack_push(vm, errno);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x430, %rsp            # imm = 0x430
movq %rdi, -0x8(%rbp)
leaq -0x410(%rbp), %rax
movq %rax, -0x420(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x428(%rbp)
movq -0x8(%rbp), %rdi
callq 0x3b30
movq -0x428(%rbp), %rdi
movl %eax, %esi
callq 0x40c0
movq -0x420(%rbp), %rdi
movq %rax, %rsi
movl $0x400, %edx            # imm = 0x400
callq 0x4010
leaq -0x410(%rbp), %rdi
leaq -0x410(%rbp), %rsi
xorl %eax, %eax
movl %eax, %edx
movb $0x0, %al
callq 0x33d0
movq -0x8(%rbp), %rax
movq %rax, -0x418(%rbp)
callq 0x3060
movq -0x418(%rbp), %rdi
movl (%rax), %esi
callq 0x3980
addq $0x430, %rsp            # imm = 0x430
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/crcx[P]retroforth/vm/nga-c/./dev-unix.c
// Function: unix_exec1
V unix_exec1(NgaState *vm) {
  char path[1025];
  char arg0[1025];
  strlcpy(arg0, string_extract(vm, stack_pop(vm)), 1024);
  strlcpy(path, string_extract(vm, stack_pop(vm)), 1024);
  execl(path, path, arg0, (char *)0);
  stack_push(vm, errno);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x850, %rsp            # imm = 0x850
movq %rdi, -0x8(%rbp)
leaq -0x820(%rbp), %rax
movq %rax, -0x840(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x848(%rbp)
movq -0x8(%rbp), %rdi
callq 0x3b30
movq -0x848(%rbp), %rdi
movl %eax, %esi
callq 0x40c0
movq -0x840(%rbp), %rdi
movq %rax, %rsi
movl $0x400, %edx            # imm = 0x400
callq 0x4010
leaq -0x410(%rbp), %rax
movq %rax, -0x830(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x838(%rbp)
movq -0x8(%rbp), %rdi
callq 0x3b30
movq -0x838(%rbp), %rdi
movl %eax, %esi
callq 0x40c0
movq -0x830(%rbp), %rdi
movq %rax, %rsi
movl $0x400, %edx            # imm = 0x400
callq 0x4010
leaq -0x410(%rbp), %rdi
leaq -0x410(%rbp), %rsi
leaq -0x820(%rbp), %rdx
xorl %eax, %eax
movl %eax, %ecx
movb $0x0, %al
callq 0x33d0
movq -0x8(%rbp), %rax
movq %rax, -0x828(%rbp)
callq 0x3060
movq -0x828(%rbp), %rdi
movl (%rax), %esi
callq 0x3980
addq $0x850, %rsp            # imm = 0x850
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/crcx[P]retroforth/vm/nga-c/./dev-unix.c
// Function: unix_exec2
V unix_exec2(NgaState *vm) {
  char path[1025];
  char arg0[1025], arg1[1025];
  strlcpy(arg1, string_extract(vm, stack_pop(vm)), 1024);
  strlcpy(arg0, string_extract(vm, stack_pop(vm)), 1024);
  strlcpy(path, string_extract(vm, stack_pop(vm)), 1024);
  execl(path, path, arg0, arg1, (char *)0);
  stack_push(vm, errno);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0xc70, %rsp            # imm = 0xC70
movq %rdi, -0x8(%rbp)
leaq -0xc30(%rbp), %rax
movq %rax, -0xc60(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0xc68(%rbp)
movq -0x8(%rbp), %rdi
callq 0x3b30
movq -0xc68(%rbp), %rdi
movl %eax, %esi
callq 0x40c0
movq -0xc60(%rbp), %rdi
movq %rax, %rsi
movl $0x400, %edx            # imm = 0x400
callq 0x4010
leaq -0x820(%rbp), %rax
movq %rax, -0xc50(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0xc58(%rbp)
movq -0x8(%rbp), %rdi
callq 0x3b30
movq -0xc58(%rbp), %rdi
movl %eax, %esi
callq 0x40c0
movq -0xc50(%rbp), %rdi
movq %rax, %rsi
movl $0x400, %edx            # imm = 0x400
callq 0x4010
leaq -0x410(%rbp), %rax
movq %rax, -0xc40(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0xc48(%rbp)
movq -0x8(%rbp), %rdi
callq 0x3b30
movq -0xc48(%rbp), %rdi
movl %eax, %esi
callq 0x40c0
movq -0xc40(%rbp), %rdi
movq %rax, %rsi
movl $0x400, %edx            # imm = 0x400
callq 0x4010
leaq -0x410(%rbp), %rdi
leaq -0x410(%rbp), %rsi
leaq -0x820(%rbp), %rdx
leaq -0xc30(%rbp), %rcx
xorl %eax, %eax
movl %eax, %r8d
movb $0x0, %al
callq 0x33d0
movq -0x8(%rbp), %rax
movq %rax, -0xc38(%rbp)
callq 0x3060
movq -0xc38(%rbp), %rdi
movl (%rax), %esi
callq 0x3980
addq $0xc70, %rsp            # imm = 0xC70
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/crcx[P]retroforth/vm/nga-c/./dev-unix.c
// Function: unix_exec3
V unix_exec3(NgaState *vm) {
  char path[1025];
  char arg0[1025], arg1[1025], arg2[1025];
  strlcpy(arg2, string_extract(vm, stack_pop(vm)), 1024);
  strlcpy(arg1, string_extract(vm, stack_pop(vm)), 1024);
  strlcpy(arg0, string_extract(vm, stack_pop(vm)), 1024);
  strlcpy(path, string_extract(vm, stack_pop(vm)), 1024);
  execl(path, path, arg0, arg1, arg2, (char *)0);
  stack_push(vm, errno);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x1090, %rsp           # imm = 0x1090
movq %rdi, -0x8(%rbp)
leaq -0x1040(%rbp), %rax
movq %rax, -0x1080(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x1088(%rbp)
movq -0x8(%rbp), %rdi
callq 0x3b30
movq -0x1088(%rbp), %rdi
movl %eax, %esi
callq 0x40c0
movq -0x1080(%rbp), %rdi
movq %rax, %rsi
movl $0x400, %edx            # imm = 0x400
callq 0x4010
leaq -0xc30(%rbp), %rax
movq %rax, -0x1070(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x1078(%rbp)
movq -0x8(%rbp), %rdi
callq 0x3b30
movq -0x1078(%rbp), %rdi
movl %eax, %esi
callq 0x40c0
movq -0x1070(%rbp), %rdi
movq %rax, %rsi
movl $0x400, %edx            # imm = 0x400
callq 0x4010
leaq -0x820(%rbp), %rax
movq %rax, -0x1060(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x1068(%rbp)
movq -0x8(%rbp), %rdi
callq 0x3b30
movq -0x1068(%rbp), %rdi
movl %eax, %esi
callq 0x40c0
movq -0x1060(%rbp), %rdi
movq %rax, %rsi
movl $0x400, %edx            # imm = 0x400
callq 0x4010
leaq -0x410(%rbp), %rax
movq %rax, -0x1050(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x1058(%rbp)
movq -0x8(%rbp), %rdi
callq 0x3b30
movq -0x1058(%rbp), %rdi
movl %eax, %esi
callq 0x40c0
movq -0x1050(%rbp), %rdi
movq %rax, %rsi
movl $0x400, %edx            # imm = 0x400
callq 0x4010
leaq -0x410(%rbp), %rdi
leaq -0x410(%rbp), %rsi
leaq -0x820(%rbp), %rdx
leaq -0xc30(%rbp), %rcx
leaq -0x1040(%rbp), %r8
xorl %eax, %eax
movl %eax, %r9d
movb $0x0, %al
callq 0x33d0
movq -0x8(%rbp), %rax
movq %rax, -0x1048(%rbp)
callq 0x3060
movq -0x1048(%rbp), %rdi
movl (%rax), %esi
callq 0x3980
addq $0x1090, %rsp           # imm = 0x1090
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/crcx[P]retroforth/vm/nga-c/./dev-unix.c
// Function: unix_write
V unix_write(NgaState *vm) {
  ssize_t ignore;
  CELL c = stack_pop(vm);
  CELL b = stack_pop(vm);
  CELL a = stack_pop(vm);
  ignore = write(fileno(vm->OpenFileHandles[c]), string_extract(vm, a), b);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
callq 0x3b30
movl %eax, -0x14(%rbp)
movq -0x8(%rbp), %rdi
callq 0x3b30
movl %eax, -0x18(%rbp)
movq -0x8(%rbp), %rdi
callq 0x3b30
movl %eax, -0x1c(%rbp)
movq -0x8(%rbp), %rax
movslq -0x14(%rbp), %rcx
movq 0x288ef0(%rax,%rcx,8), %rdi
callq 0x32a0
movl %eax, -0x20(%rbp)
movq -0x8(%rbp), %rdi
movl -0x1c(%rbp), %esi
callq 0x40c0
movl -0x20(%rbp), %edi
movq %rax, %rsi
movslq -0x18(%rbp), %rdx
callq 0x30b0
movq %rax, -0x10(%rbp)
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/crcx[P]retroforth/vm/nga-c/retro.c
// Function: validate_opcode_bundle
V validate_opcode_bundle(NgaState *vm, CELL opcode) {
  CELL remainingOpcode = opcode;
  for (int i = 0; i < 4; i++) {
    CELL current = remainingOpcode & 0xFF;
    if (current < 0 || current > 29) {
      invalid_opcode(vm, opcode);
    }
    remainingOpcode >>= 8;
  }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movl -0xc(%rbp), %eax
movl %eax, -0x10(%rbp)
movl $0x0, -0x14(%rbp)
cmpl $0x4, -0x14(%rbp)
jge 0x85e9
movl -0x10(%rbp), %eax
andl $0xff, %eax
movl %eax, -0x18(%rbp)
cmpl $0x0, -0x18(%rbp)
jl 0x85c9
cmpl $0x1d, -0x18(%rbp)
jle 0x85d5
movq -0x8(%rbp), %rdi
movl -0xc(%rbp), %esi
callq 0x84d0
movl -0x10(%rbp), %eax
sarl $0x8, %eax
movl %eax, -0x10(%rbp)
movl -0x14(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x14(%rbp)
jmp 0x85ac
addq $0x20, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/crcx[P]retroforth/vm/nga-c/retro.c
// Function: process_opcode_bundle
V process_opcode_bundle(NgaState *vm, CELL opcode) {
#ifndef BRANCH_PREDICTION
  if (INST(0))  instructions[opcode & 0xFF](vm);
  if (INST(8))  instructions[(opcode >> 8) & 0xFF](vm);
  if (INST(16)) instructions[(opcode >> 16) & 0xFF](vm);
  if (INST(24)) instructions[(opcode >> 24) & 0xFF](vm);
#else
  for (size_t i = 0; i < 4; ++i) {
    uint8_t current = ((uint8_t*)&opcode)[i];
    if (unlikely(current > 29)) {
      invalid_opcode(vm, opcode);
    }
    instructions[current](vm);
  }
#endif
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movl -0xc(%rbp), %eax
sarl $0x0, %eax
andl $0xff, %eax
cmpl $0x0, %eax
je 0x862b
movl -0xc(%rbp), %eax
andl $0xff, %eax
movslq %eax, %rcx
leaq 0x4f43f(%rip), %rax     # 0x57a60
movq (%rax,%rcx,8), %rax
movq -0x8(%rbp), %rdi
callq *%rax
movl -0xc(%rbp), %eax
sarl $0x8, %eax
andl $0xff, %eax
cmpl $0x0, %eax
je 0x865a
movl -0xc(%rbp), %eax
sarl $0x8, %eax
andl $0xff, %eax
movslq %eax, %rcx
leaq 0x4f410(%rip), %rax     # 0x57a60
movq (%rax,%rcx,8), %rax
movq -0x8(%rbp), %rdi
callq *%rax
movl -0xc(%rbp), %eax
sarl $0x10, %eax
andl $0xff, %eax
cmpl $0x0, %eax
je 0x8689
movl -0xc(%rbp), %eax
sarl $0x10, %eax
andl $0xff, %eax
movslq %eax, %rcx
leaq 0x4f3e1(%rip), %rax     # 0x57a60
movq (%rax,%rcx,8), %rax
movq -0x8(%rbp), %rdi
callq *%rax
movl -0xc(%rbp), %eax
sarl $0x18, %eax
andl $0xff, %eax
cmpl $0x0, %eax
je 0x86b8
movl -0xc(%rbp), %eax
sarl $0x18, %eax
andl $0xff, %eax
movslq %eax, %rcx
leaq 0x4f3b2(%rip), %rax     # 0x57a60
movq (%rax,%rcx,8), %rax
movq -0x8(%rbp), %rdi
callq *%rax
addq $0x10, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/crcx[P]retroforth/vm/nga-c/retro.c
// Function: register_devices
V register_devices(NgaState *vm) {
  register_device(vm, io_output, query_output);
  register_device(vm, io_keyboard, query_keyboard);
#ifdef ENABLE_FILES
  register_device(vm, io_filesystem, query_filesystem);
#endif
  register_device(vm, io_image, query_image);
#ifdef ENABLE_FLOATS
  register_device(vm, io_floatingpoint, query_floatingpoint);
#endif
#ifdef ENABLE_UNIX
  register_device(vm, io_unix, query_unix);
#endif
#ifdef ENABLE_MALLOC
#ifdef BIT64
  register_device(vm, io_malloc, query_malloc);
#endif
#endif
#ifdef ENABLE_BLOCKS
  register_device(vm, io_blocks, query_blocks);
#endif
#ifdef ENABLE_CLOCK
  register_device(vm, io_clock, query_clock);
#endif
  register_device(vm, io_scripting, query_scripting);
#ifdef ENABLE_RNG
  register_device(vm, io_rng, query_rng);
#endif
#ifdef ENABLE_SOCKETS
  register_device(vm, io_socket, query_socket);
#endif
#ifdef ENABLE_MULTICORE
  register_device(vm, io_multicore, query_multicore);
#endif
#ifdef ENABLE_FFI
  register_device(vm, io_ffi, query_ffi);
  nlibs = 0;
  nffi = 0;
#endif
#ifdef ENABLE_UNSIGNED
  register_device(vm, io_unsigned, query_unsigned);
#endif
#ifdef ENABLE_ERROR
  register_device(vm, io_error, query_error);
#endif
#ifdef ENABLE_IOCTL
  register_device(vm, io_ioctl, query_ioctl);
#endif
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
leaq -0x23c7(%rip), %rsi     # 0x6f80
leaq -0x237e(%rip), %rdx     # 0x6fd0
callq 0x9490
movq -0x8(%rbp), %rdi
leaq -0x21ae(%rip), %rsi     # 0x71b0
leaq -0x20f5(%rip), %rdx     # 0x7270
callq 0x9490
movq -0x8(%rbp), %rdi
leaq -0x44e5(%rip), %rsi     # 0x4e90
leaq -0x451c(%rip), %rdx     # 0x4e60
callq 0x9490
movq -0x8(%rbp), %rdi
leaq -0x1f6c(%rip), %rsi     # 0x7420
leaq -0x1ee3(%rip), %rdx     # 0x74b0
callq 0x9490
movq -0x8(%rbp), %rdi
leaq -0x3403(%rip), %rsi     # 0x5fa0
leaq -0x343a(%rip), %rdx     # 0x5f70
callq 0x9490
movq -0x8(%rbp), %rdi
leaq -0x24aa(%rip), %rsi     # 0x6f10
leaq -0x24e1(%rip), %rdx     # 0x6ee0
callq 0x9490
movq -0x8(%rbp), %rdi
leaq -0x5281(%rip), %rsi     # 0x4150
leaq -0x5228(%rip), %rdx     # 0x41b0
callq 0x9490
movq -0x8(%rbp), %rdi
leaq -0x30b8(%rip), %rsi     # 0x6330
leaq -0x30ef(%rip), %rdx     # 0x6300
callq 0x9490
movq -0x8(%rbp), %rdi
leaq -0xf5f(%rip), %rsi      # 0x84a0
leaq -0xf96(%rip), %rdx      # 0x8470
callq 0x9490
movq -0x8(%rbp), %rdi
leaq -0x30a6(%rip), %rsi     # 0x6370
leaq -0x300d(%rip), %rdx     # 0x6410
callq 0x9490
movq -0x8(%rbp), %rdi
leaq -0x42bd(%rip), %rsi     # 0x5170
leaq -0x4154(%rip), %rdx     # 0x52e0
callq 0x9490
movq -0x8(%rbp), %rdi
leaq -0x21a4(%rip), %rsi     # 0x72a0
leaq -0x205b(%rip), %rdx     # 0x73f0
callq 0x9490
movq -0x8(%rbp), %rdi
leaq -0x56ab(%rip), %rsi     # 0x3db0
leaq -0x5682(%rip), %rdx     # 0x3de0
callq 0x9490
movq -0x8(%rbp), %rdi
leaq -0x5972(%rip), %rsi     # 0x3b00
leaq -0x59a9(%rip), %rdx     # 0x3ad0
callq 0x9490
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/crcx[P]retroforth/vm/nga-c/retro.c
// Function: register_signal_handlers
V register_signal_handlers() {
#ifdef ENABLE_SIGNALS
  signal(SIGHUP, sig_handler);
  signal(SIGINT, sig_handler);
  signal(SIGILL, sig_handler);
  signal(SIGBUS, sig_handler);
  signal(SIGFPE, sig_handler);
#endif
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movl $0x1, %edi
leaq 0x50(%rip), %rsi        # 0x9550
callq 0x3240
movl $0x2, %edi
leaq 0x3f(%rip), %rsi        # 0x9550
callq 0x3240
movl $0x4, %edi
leaq 0x2e(%rip), %rsi        # 0x9550
callq 0x3240
movl $0x7, %edi
leaq 0x1d(%rip), %rsi        # 0x9550
callq 0x3240
movl $0x8, %edi
leaq 0xc(%rip), %rsi         # 0x9550
callq 0x3240
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/crcx[P]retroforth/vm/nga-c/retro.c
// Function: load_image
CELL load_image(NgaState *vm, char *imageFile) {
  FILE *fp;
  CELL imageSize = 0;
  long fileLen;
  if ((fp = fopen(imageFile, "rb")) != NULL) {
    /* Determine length (in cells) */
    fseek(fp, 0, SEEK_END);
    fileLen = ftell(fp) / sizeof(CELL);
    if (fileLen > IMAGE_SIZE) {
      fclose(fp);
      printf("\nERROR (nga/ngaLoadImage): Image is larger than alloted space!\n");
      exit(1);
    }
    rewind(fp);

    /* Erase old image in memory: 0 = nop instruction */
    for (int i = 0; i < IMAGE_SIZE; i++) { vm->memory[i] = 0; }

    /* Read the file into memory */
    imageSize = fread(vm->memory, sizeof(CELL), fileLen, fp);
    fclose(fp);
  }
  return imageSize;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl $0x0, -0x1c(%rbp)
movq -0x10(%rbp), %rdi
leaq 0x352d(%rip), %rsi      # 0xd06f
callq 0x3330
movq %rax, -0x18(%rbp)
cmpq $0x0, %rax
je 0x9bf8
movq -0x18(%rbp), %rdi
xorl %eax, %eax
movl %eax, %esi
movl $0x2, %edx
callq 0x32e0
movq -0x18(%rbp), %rdi
callq 0x3260
shrq $0x2, %rax
movq %rax, -0x28(%rbp)
cmpq $0x80000, -0x28(%rbp)   # imm = 0x80000
jle 0x9ba3
movq -0x18(%rbp), %rdi
callq 0x30f0
leaq 0x3be1(%rip), %rdi      # 0xd773
movb $0x0, %al
callq 0x3130
movl $0x1, %edi
callq 0x33a0
movq -0x18(%rbp), %rdi
callq 0x3140
movl $0x0, -0x2c(%rbp)
cmpl $0x80000, -0x2c(%rbp)   # imm = 0x80000
jge 0x9bd6
movq -0x8(%rbp), %rax
movslq -0x2c(%rbp), %rcx
movl $0x0, (%rax,%rcx,4)
movl -0x2c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x2c(%rbp)
jmp 0x9bb3
movq -0x8(%rbp), %rdi
movq -0x28(%rbp), %rdx
movq -0x18(%rbp), %rcx
movl $0x4, %esi
callq 0x3090
movl %eax, -0x1c(%rbp)
movq -0x18(%rbp), %rdi
callq 0x30f0
movl -0x1c(%rbp), %eax
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/crcx[P]retroforth/vm/nga-c/retro.c
// Function: i_li
V i_li(NgaState *vm) {
  guard(vm, 0, 1, 0);
  ACTIVE.sp++;
  ACTIVE.ip++;
  TOS = vm->memory[ACTIVE.ip];
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
xorl %ecx, %ecx
movl $0x1, %edx
movl %ecx, %esi
callq 0x3740
movq -0x8(%rbp), %rax
addq $0x200004, %rax         # imm = 0x200004
movq -0x8(%rbp), %rcx
movslq 0x2043a4(%rcx), %rcx
imulq $0x874, %rcx, %rcx      # imm = 0x874
addq %rcx, %rax
movl (%rax), %ecx
addl $0x1, %ecx
movl %ecx, (%rax)
movq -0x8(%rbp), %rax
addq $0x200004, %rax         # imm = 0x200004
movq -0x8(%rbp), %rcx
movslq 0x2043a4(%rcx), %rcx
imulq $0x874, %rcx, %rcx      # imm = 0x874
addq %rcx, %rax
movl 0x8(%rax), %ecx
addl $0x1, %ecx
movl %ecx, 0x8(%rax)
movq -0x8(%rbp), %rax
movq -0x8(%rbp), %rcx
addq $0x200004, %rcx         # imm = 0x200004
movq -0x8(%rbp), %rdx
movslq 0x2043a4(%rdx), %rdx
imulq $0x874, %rdx, %rdx      # imm = 0x874
addq %rdx, %rcx
movslq 0x8(%rcx), %rcx
movl (%rax,%rcx,4), %edx
movq -0x8(%rbp), %rax
addq $0x200004, %rax         # imm = 0x200004
movq -0x8(%rbp), %rcx
movslq 0x2043a4(%rcx), %rcx
imulq $0x874, %rcx, %rcx      # imm = 0x874
addq %rcx, %rax
movq -0x8(%rbp), %rcx
addq $0x200004, %rcx         # imm = 0x200004
movq -0x8(%rbp), %rsi
movslq 0x2043a4(%rsi), %rsi
imulq $0x874, %rsi, %rsi      # imm = 0x874
addq %rsi, %rcx
movslq (%rcx), %rcx
movl %edx, 0x14(%rax,%rcx,4)
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/crcx[P]retroforth/vm/nga-c/retro.c
// Function: i_sw
V i_sw(NgaState *vm) {
  guard(vm, 2, 2, 0);
  CELL a;
  a = TOS;
  TOS = NOS;
  NOS = a;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
movl $0x2, %edx
xorl %ecx, %ecx
movl %edx, %esi
callq 0x3740
movq -0x8(%rbp), %rax
addq $0x200004, %rax         # imm = 0x200004
movq -0x8(%rbp), %rcx
movslq 0x2043a4(%rcx), %rcx
imulq $0x874, %rcx, %rcx      # imm = 0x874
addq %rcx, %rax
movq -0x8(%rbp), %rcx
addq $0x200004, %rcx         # imm = 0x200004
movq -0x8(%rbp), %rdx
movslq 0x2043a4(%rdx), %rdx
imulq $0x874, %rdx, %rdx      # imm = 0x874
addq %rdx, %rcx
movslq (%rcx), %rcx
movl 0x14(%rax,%rcx,4), %eax
movl %eax, -0xc(%rbp)
movq -0x8(%rbp), %rax
addq $0x200004, %rax         # imm = 0x200004
movq -0x8(%rbp), %rcx
movslq 0x2043a4(%rcx), %rcx
imulq $0x874, %rcx, %rcx      # imm = 0x874
addq %rcx, %rax
movq -0x8(%rbp), %rcx
addq $0x200004, %rcx         # imm = 0x200004
movq -0x8(%rbp), %rdx
movslq 0x2043a4(%rdx), %rdx
imulq $0x874, %rdx, %rdx      # imm = 0x874
addq %rdx, %rcx
movl (%rcx), %ecx
subl $0x1, %ecx
movslq %ecx, %rcx
movl 0x14(%rax,%rcx,4), %edx
movq -0x8(%rbp), %rax
addq $0x200004, %rax         # imm = 0x200004
movq -0x8(%rbp), %rcx
movslq 0x2043a4(%rcx), %rcx
imulq $0x874, %rcx, %rcx      # imm = 0x874
addq %rcx, %rax
movq -0x8(%rbp), %rcx
addq $0x200004, %rcx         # imm = 0x200004
movq -0x8(%rbp), %rsi
movslq 0x2043a4(%rsi), %rsi
imulq $0x874, %rsi, %rsi      # imm = 0x874
addq %rsi, %rcx
movslq (%rcx), %rcx
movl %edx, 0x14(%rax,%rcx,4)
movl -0xc(%rbp), %edx
movq -0x8(%rbp), %rax
addq $0x200004, %rax         # imm = 0x200004
movq -0x8(%rbp), %rcx
movslq 0x2043a4(%rcx), %rcx
imulq $0x874, %rcx, %rcx      # imm = 0x874
addq %rcx, %rax
movq -0x8(%rbp), %rcx
addq $0x200004, %rcx         # imm = 0x200004
movq -0x8(%rbp), %rsi
movslq 0x2043a4(%rsi), %rsi
imulq $0x874, %rsi, %rsi      # imm = 0x874
addq %rsi, %rcx
movl (%rcx), %ecx
subl $0x1, %ecx
movslq %ecx, %rcx
movl %edx, 0x14(%rax,%rcx,4)
addq $0x10, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/crcx[P]retroforth/vm/nga-c/retro.c
// Function: i_pu
V i_pu(NgaState *vm) {
  guard(vm, 1, 0, 1);
  ACTIVE.rp++;
  TORS = TOS;
  i_dr(vm);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
movl $0x1, %ecx
xorl %edx, %edx
movl %ecx, %esi
callq 0x3740
movq -0x8(%rbp), %rax
addq $0x200004, %rax         # imm = 0x200004
movq -0x8(%rbp), %rcx
movslq 0x2043a4(%rcx), %rcx
imulq $0x874, %rcx, %rcx      # imm = 0x874
addq %rcx, %rax
movl 0x4(%rax), %ecx
addl $0x1, %ecx
movl %ecx, 0x4(%rax)
movq -0x8(%rbp), %rax
addq $0x200004, %rax         # imm = 0x200004
movq -0x8(%rbp), %rcx
movslq 0x2043a4(%rcx), %rcx
imulq $0x874, %rcx, %rcx      # imm = 0x874
addq %rcx, %rax
movq -0x8(%rbp), %rcx
addq $0x200004, %rcx         # imm = 0x200004
movq -0x8(%rbp), %rdx
movslq 0x2043a4(%rdx), %rdx
imulq $0x874, %rdx, %rdx      # imm = 0x874
addq %rdx, %rcx
movslq (%rcx), %rcx
movl 0x14(%rax,%rcx,4), %edx
movq -0x8(%rbp), %rax
addq $0x200004, %rax         # imm = 0x200004
movq -0x8(%rbp), %rcx
movslq 0x2043a4(%rcx), %rcx
imulq $0x874, %rcx, %rcx      # imm = 0x874
addq %rcx, %rax
movq -0x8(%rbp), %rcx
addq $0x200004, %rcx         # imm = 0x200004
movq -0x8(%rbp), %rsi
movslq 0x2043a4(%rsi), %rsi
imulq $0x874, %rsi, %rsi      # imm = 0x874
addq %rsi, %rcx
movslq 0x4(%rcx), %rcx
movl %edx, 0x414(%rax,%rcx,4)
movq -0x8(%rbp), %rdi
callq 0x9e10
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/crcx[P]retroforth/vm/nga-c/retro.c
// Function: i_po
V i_po(NgaState *vm) {
  guard(vm, 0, 1, -1);
  ACTIVE.sp++;
  TOS = TORS;
  ACTIVE.rp--;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
xorl %esi, %esi
movl $0x1, %edx
movl $0xffffffff, %ecx       # imm = 0xFFFFFFFF
callq 0x3740
movq -0x8(%rbp), %rax
addq $0x200004, %rax         # imm = 0x200004
movq -0x8(%rbp), %rcx
movslq 0x2043a4(%rcx), %rcx
imulq $0x874, %rcx, %rcx      # imm = 0x874
addq %rcx, %rax
movl (%rax), %ecx
addl $0x1, %ecx
movl %ecx, (%rax)
movq -0x8(%rbp), %rax
addq $0x200004, %rax         # imm = 0x200004
movq -0x8(%rbp), %rcx
movslq 0x2043a4(%rcx), %rcx
imulq $0x874, %rcx, %rcx      # imm = 0x874
addq %rcx, %rax
movq -0x8(%rbp), %rcx
addq $0x200004, %rcx         # imm = 0x200004
movq -0x8(%rbp), %rdx
movslq 0x2043a4(%rdx), %rdx
imulq $0x874, %rdx, %rdx      # imm = 0x874
addq %rdx, %rcx
movslq 0x4(%rcx), %rcx
movl 0x414(%rax,%rcx,4), %edx
movq -0x8(%rbp), %rax
addq $0x200004, %rax         # imm = 0x200004
movq -0x8(%rbp), %rcx
movslq 0x2043a4(%rcx), %rcx
imulq $0x874, %rcx, %rcx      # imm = 0x874
addq %rcx, %rax
movq -0x8(%rbp), %rcx
addq $0x200004, %rcx         # imm = 0x200004
movq -0x8(%rbp), %rsi
movslq 0x2043a4(%rsi), %rsi
imulq $0x874, %rsi, %rsi      # imm = 0x874
addq %rsi, %rcx
movslq (%rcx), %rcx
movl %edx, 0x14(%rax,%rcx,4)
movq -0x8(%rbp), %rax
addq $0x200004, %rax         # imm = 0x200004
movq -0x8(%rbp), %rcx
movslq 0x2043a4(%rcx), %rcx
imulq $0x874, %rcx, %rcx      # imm = 0x874
addq %rcx, %rax
movl 0x4(%rax), %ecx
addl $-0x1, %ecx
movl %ecx, 0x4(%rax)
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/crcx[P]retroforth/vm/nga-c/retro.c
// Function: i_ca
V i_ca(NgaState *vm) {
  guard(vm, 1, 0, 1);
  ACTIVE.rp++;
  TORS = ACTIVE.ip;
  ACTIVE.ip = TOS - 1;
  i_dr(vm);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
movl $0x1, %ecx
xorl %edx, %edx
movl %ecx, %esi
callq 0x3740
movq -0x8(%rbp), %rax
addq $0x200004, %rax         # imm = 0x200004
movq -0x8(%rbp), %rcx
movslq 0x2043a4(%rcx), %rcx
imulq $0x874, %rcx, %rcx      # imm = 0x874
addq %rcx, %rax
movl 0x4(%rax), %ecx
addl $0x1, %ecx
movl %ecx, 0x4(%rax)
movq -0x8(%rbp), %rax
addq $0x200004, %rax         # imm = 0x200004
movq -0x8(%rbp), %rcx
movslq 0x2043a4(%rcx), %rcx
imulq $0x874, %rcx, %rcx      # imm = 0x874
addq %rcx, %rax
movl 0x8(%rax), %edx
movq -0x8(%rbp), %rax
addq $0x200004, %rax         # imm = 0x200004
movq -0x8(%rbp), %rcx
movslq 0x2043a4(%rcx), %rcx
imulq $0x874, %rcx, %rcx      # imm = 0x874
addq %rcx, %rax
movq -0x8(%rbp), %rcx
addq $0x200004, %rcx         # imm = 0x200004
movq -0x8(%rbp), %rsi
movslq 0x2043a4(%rsi), %rsi
imulq $0x874, %rsi, %rsi      # imm = 0x874
addq %rsi, %rcx
movslq 0x4(%rcx), %rcx
movl %edx, 0x414(%rax,%rcx,4)
movq -0x8(%rbp), %rax
addq $0x200004, %rax         # imm = 0x200004
movq -0x8(%rbp), %rcx
movslq 0x2043a4(%rcx), %rcx
imulq $0x874, %rcx, %rcx      # imm = 0x874
addq %rcx, %rax
movq -0x8(%rbp), %rcx
addq $0x200004, %rcx         # imm = 0x200004
movq -0x8(%rbp), %rdx
movslq 0x2043a4(%rdx), %rdx
imulq $0x874, %rdx, %rdx      # imm = 0x874
addq %rdx, %rcx
movslq (%rcx), %rcx
movl 0x14(%rax,%rcx,4), %ecx
subl $0x1, %ecx
movq -0x8(%rbp), %rax
addq $0x200004, %rax         # imm = 0x200004
movq -0x8(%rbp), %rdx
movslq 0x2043a4(%rdx), %rdx
imulq $0x874, %rdx, %rdx      # imm = 0x874
addq %rdx, %rax
movl %ecx, 0x8(%rax)
movq -0x8(%rbp), %rdi
callq 0x9e10
addq $0x10, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/crcx[P]retroforth/vm/nga-c/retro.c
// Function: i_cc
V i_cc(NgaState *vm) {
  guard(vm, 2, 0, 1);
  CELL a, b;
  a = TOS; i_dr(vm);  /* Target */
  b = TOS; i_dr(vm);  /* Flag   */
  if (b != 0) {
    ACTIVE.rp++;
    TORS = ACTIVE.ip;
    ACTIVE.ip = a - 1;
  }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
movl $0x2, %esi
xorl %edx, %edx
movl $0x1, %ecx
callq 0x3740
movq -0x8(%rbp), %rax
addq $0x200004, %rax         # imm = 0x200004
movq -0x8(%rbp), %rcx
movslq 0x2043a4(%rcx), %rcx
imulq $0x874, %rcx, %rcx      # imm = 0x874
addq %rcx, %rax
movq -0x8(%rbp), %rcx
addq $0x200004, %rcx         # imm = 0x200004
movq -0x8(%rbp), %rdx
movslq 0x2043a4(%rdx), %rdx
imulq $0x874, %rdx, %rdx      # imm = 0x874
addq %rdx, %rcx
movslq (%rcx), %rcx
movl 0x14(%rax,%rcx,4), %eax
movl %eax, -0xc(%rbp)
movq -0x8(%rbp), %rdi
callq 0x9e10
movq -0x8(%rbp), %rax
addq $0x200004, %rax         # imm = 0x200004
movq -0x8(%rbp), %rcx
movslq 0x2043a4(%rcx), %rcx
imulq $0x874, %rcx, %rcx      # imm = 0x874
addq %rcx, %rax
movq -0x8(%rbp), %rcx
addq $0x200004, %rcx         # imm = 0x200004
movq -0x8(%rbp), %rdx
movslq 0x2043a4(%rdx), %rdx
imulq $0x874, %rdx, %rdx      # imm = 0x874
addq %rdx, %rcx
movslq (%rcx), %rcx
movl 0x14(%rax,%rcx,4), %eax
movl %eax, -0x10(%rbp)
movq -0x8(%rbp), %rdi
callq 0x9e10
cmpl $0x0, -0x10(%rbp)
je 0xa55b
movq -0x8(%rbp), %rax
addq $0x200004, %rax         # imm = 0x200004
movq -0x8(%rbp), %rcx
movslq 0x2043a4(%rcx), %rcx
imulq $0x874, %rcx, %rcx      # imm = 0x874
addq %rcx, %rax
movl 0x4(%rax), %ecx
addl $0x1, %ecx
movl %ecx, 0x4(%rax)
movq -0x8(%rbp), %rax
addq $0x200004, %rax         # imm = 0x200004
movq -0x8(%rbp), %rcx
movslq 0x2043a4(%rcx), %rcx
imulq $0x874, %rcx, %rcx      # imm = 0x874
addq %rcx, %rax
movl 0x8(%rax), %edx
movq -0x8(%rbp), %rax
addq $0x200004, %rax         # imm = 0x200004
movq -0x8(%rbp), %rcx
movslq 0x2043a4(%rcx), %rcx
imulq $0x874, %rcx, %rcx      # imm = 0x874
addq %rcx, %rax
movq -0x8(%rbp), %rcx
addq $0x200004, %rcx         # imm = 0x200004
movq -0x8(%rbp), %rsi
movslq 0x2043a4(%rsi), %rsi
imulq $0x874, %rsi, %rsi      # imm = 0x874
addq %rsi, %rcx
movslq 0x4(%rcx), %rcx
movl %edx, 0x414(%rax,%rcx,4)
movl -0xc(%rbp), %ecx
subl $0x1, %ecx
movq -0x8(%rbp), %rax
addq $0x200004, %rax         # imm = 0x200004
movq -0x8(%rbp), %rdx
movslq 0x2043a4(%rdx), %rdx
imulq $0x874, %rdx, %rdx      # imm = 0x874
addq %rdx, %rax
movl %ecx, 0x8(%rax)
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/crcx[P]retroforth/vm/nga-c/retro.c
// Function: i_st
V i_st(NgaState *vm) {
  guard(vm, 2, 0, 0);
  vm->memory[TOS] = NOS;
  i_dr(vm);
  i_dr(vm);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
movl $0x2, %esi
xorl %ecx, %ecx
movl %ecx, %edx
callq 0x3740
movq -0x8(%rbp), %rax
addq $0x200004, %rax         # imm = 0x200004
movq -0x8(%rbp), %rcx
movslq 0x2043a4(%rcx), %rcx
imulq $0x874, %rcx, %rcx      # imm = 0x874
addq %rcx, %rax
movq -0x8(%rbp), %rcx
addq $0x200004, %rcx         # imm = 0x200004
movq -0x8(%rbp), %rdx
movslq 0x2043a4(%rdx), %rdx
imulq $0x874, %rdx, %rdx      # imm = 0x874
addq %rdx, %rcx
movl (%rcx), %ecx
subl $0x1, %ecx
movslq %ecx, %rcx
movl 0x14(%rax,%rcx,4), %edx
movq -0x8(%rbp), %rax
movq -0x8(%rbp), %rcx
addq $0x200004, %rcx         # imm = 0x200004
movq -0x8(%rbp), %rsi
movslq 0x2043a4(%rsi), %rsi
imulq $0x874, %rsi, %rsi      # imm = 0x874
addq %rsi, %rcx
movq -0x8(%rbp), %rsi
addq $0x200004, %rsi         # imm = 0x200004
movq -0x8(%rbp), %rdi
movslq 0x2043a4(%rdi), %rdi
imulq $0x874, %rdi, %rdi      # imm = 0x874
addq %rdi, %rsi
movslq (%rsi), %rsi
movslq 0x14(%rcx,%rsi,4), %rcx
movl %edx, (%rax,%rcx,4)
movq -0x8(%rbp), %rdi
callq 0x9e10
movq -0x8(%rbp), %rdi
callq 0x9e10
addq $0x10, %rsp
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O0/crcx[P]retroforth/vm/nga-c/retro.c
// Function: i_ad
V i_ad(NgaState *vm) {
  guard(vm, 2, 1, 0);
  if (ACTIVE.u != 0) {
    NOS = (unsigned)NOS + (unsigned)TOS;
    ACTIVE.u = 0;
  } else {
    NOS += TOS;
  }
  i_dr(vm);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
movl $0x2, %esi
movl $0x1, %edx
xorl %ecx, %ecx
callq 0x3740
movq -0x8(%rbp), %rax
addq $0x200004, %rax         # imm = 0x200004
movq -0x8(%rbp), %rcx
movslq 0x2043a4(%rcx), %rcx
imulq $0x874, %rcx, %rcx      # imm = 0x874
addq %rcx, %rax
cmpl $0x0, 0x10(%rax)
je 0xb4a1
movq -0x8(%rbp), %rax
addq $0x200004, %rax         # imm = 0x200004
movq -0x8(%rbp), %rcx
movslq 0x2043a4(%rcx), %rcx
imulq $0x874, %rcx, %rcx      # imm = 0x874
addq %rcx, %rax
movq -0x8(%rbp), %rcx
addq $0x200004, %rcx         # imm = 0x200004
movq -0x8(%rbp), %rdx
movslq 0x2043a4(%rdx), %rdx
imulq $0x874, %rdx, %rdx      # imm = 0x874
addq %rdx, %rcx
movl (%rcx), %ecx
subl $0x1, %ecx
movslq %ecx, %rcx
movl 0x14(%rax,%rcx,4), %edx
movq -0x8(%rbp), %rax
addq $0x200004, %rax         # imm = 0x200004
movq -0x8(%rbp), %rcx
movslq 0x2043a4(%rcx), %rcx
imulq $0x874, %rcx, %rcx      # imm = 0x874
addq %rcx, %rax
movq -0x8(%rbp), %rcx
addq $0x200004, %rcx         # imm = 0x200004
movq -0x8(%rbp), %rsi
movslq 0x2043a4(%rsi), %rsi
imulq $0x874, %rsi, %rsi      # imm = 0x874
addq %rsi, %rcx
movslq (%rcx), %rcx
addl 0x14(%rax,%rcx,4), %edx
movq -0x8(%rbp), %rax
addq $0x200004, %rax         # imm = 0x200004
movq -0x8(%rbp), %rcx
movslq 0x2043a4(%rcx), %rcx
imulq $0x874, %rcx, %rcx      # imm = 0x874
addq %rcx, %rax
movq -0x8(%rbp), %rcx
addq $0x200004, %rcx         # imm = 0x200004
movq -0x8(%rbp), %rsi
movslq 0x2043a4(%rsi), %rsi
imulq $0x874, %rsi, %rsi      # imm = 0x874
addq %rsi, %rcx
movl (%rcx), %ecx
subl $0x1, %ecx
movslq %ecx, %rcx
movl %edx, 0x14(%rax,%rcx,4)
movq -0x8(%rbp), %rax
addq $0x200004, %rax         # imm = 0x200004
movq -0x8(%rbp), %rcx
movslq 0x2043a4(%rcx), %rcx
imulq $0x874, %rcx, %rcx      # imm = 0x874
addq %rcx, %rax
movl $0x0, 0x10(%rax)
jmp 0xb536
movq -0x8(%rbp), %rax
addq $0x200004, %rax         # imm = 0x200004
movq -0x8(%rbp), %rcx
movslq 0x2043a4(%rcx), %rcx
imulq $0x874, %rcx, %rcx      # imm = 0x874
addq %rcx, %rax
movq -0x8(%rbp), %rcx
addq $0x200004, %rcx         # imm = 0x200004
movq -0x8(%rbp), %rdx
movslq 0x2043a4(%rdx), %rdx
imulq $0x874, %rdx, %rdx      # imm = 0x874
addq %rdx, %rcx
movslq (%rcx), %rcx
movl 0x14(%rax,%rcx,4), %edx
movq -0x8(%rbp), %rax
addq $0x200004, %rax         # imm = 0x200004
movq -0x8(%rbp), %rcx
movslq 0x2043a4(%rcx), %rcx
imulq $0x874, %rcx, %rcx      # imm = 0x874
addq %rcx, %rax
movq -0x8(%rbp), %rcx
addq $0x200004, %rcx         # imm = 0x200004
movq -0x8(%rbp), %rsi
movslq 0x2043a4(%rsi), %rsi
imulq $0x874, %rsi, %rsi      # imm = 0x874
addq %rsi, %rcx
movl (%rcx), %ecx
subl $0x1, %ecx
movslq %ecx, %rcx
addl 0x14(%rax,%rcx,4), %edx
movl %edx, 0x14(%rax,%rcx,4)
movq -0x8(%rbp), %rdi
callq 0x9e10
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/crcx[P]retroforth/vm/nga-c/retro.c
// Function: i_zr
V i_zr(NgaState *vm) {
  guard(vm, 1, 0, 0);
  if (TOS == 0) {
    i_dr(vm);
    ACTIVE.ip = TORS;
    ACTIVE.rp--;
  }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
movl $0x1, %esi
xorl %ecx, %ecx
movl %ecx, %edx
callq 0x3740
movq -0x8(%rbp), %rax
addq $0x200004, %rax         # imm = 0x200004
movq -0x8(%rbp), %rcx
movslq 0x2043a4(%rcx), %rcx
imulq $0x874, %rcx, %rcx      # imm = 0x874
addq %rcx, %rax
movq -0x8(%rbp), %rcx
addq $0x200004, %rcx         # imm = 0x200004
movq -0x8(%rbp), %rdx
movslq 0x2043a4(%rdx), %rdx
imulq $0x874, %rdx, %rdx      # imm = 0x874
addq %rdx, %rcx
movslq (%rcx), %rcx
cmpl $0x0, 0x14(%rax,%rcx,4)
jne 0xc368
movq -0x8(%rbp), %rdi
callq 0x9e10
movq -0x8(%rbp), %rax
addq $0x200004, %rax         # imm = 0x200004
movq -0x8(%rbp), %rcx
movslq 0x2043a4(%rcx), %rcx
imulq $0x874, %rcx, %rcx      # imm = 0x874
addq %rcx, %rax
movq -0x8(%rbp), %rcx
addq $0x200004, %rcx         # imm = 0x200004
movq -0x8(%rbp), %rdx
movslq 0x2043a4(%rdx), %rdx
imulq $0x874, %rdx, %rdx      # imm = 0x874
addq %rdx, %rcx
movslq 0x4(%rcx), %rcx
movl 0x414(%rax,%rcx,4), %ecx
movq -0x8(%rbp), %rax
addq $0x200004, %rax         # imm = 0x200004
movq -0x8(%rbp), %rdx
movslq 0x2043a4(%rdx), %rdx
imulq $0x874, %rdx, %rdx      # imm = 0x874
addq %rdx, %rax
movl %ecx, 0x8(%rax)
movq -0x8(%rbp), %rax
addq $0x200004, %rax         # imm = 0x200004
movq -0x8(%rbp), %rcx
movslq 0x2043a4(%rcx), %rcx
imulq $0x874, %rcx, %rcx      # imm = 0x874
addq %rcx, %rax
movl 0x4(%rax), %ecx
addl $-0x1, %ecx
movl %ecx, 0x4(%rax)
addq $0x10, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/crcx[P]retroforth/vm/nga-c/retro.c
// Function: i_ha
V i_ha(NgaState *vm) {
  guard(vm, 0, 0, 0);
  ACTIVE.ip = IMAGE_SIZE;
  ACTIVE.rp = 0;
  exit(0);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
xorl %ecx, %ecx
movl %ecx, %esi
movl %ecx, %edx
callq 0x3740
movq -0x8(%rbp), %rax
addq $0x200004, %rax         # imm = 0x200004
movq -0x8(%rbp), %rcx
movslq 0x2043a4(%rcx), %rcx
imulq $0x874, %rcx, %rcx      # imm = 0x874
addq %rcx, %rax
movl $0x80000, 0x8(%rax)     # imm = 0x80000
movq -0x8(%rbp), %rax
addq $0x200004, %rax         # imm = 0x200004
movq -0x8(%rbp), %rcx
movslq 0x2043a4(%rcx), %rcx
imulq $0x874, %rcx, %rcx      # imm = 0x874
addq %rcx, %rax
movl $0x0, 0x4(%rax)
xorl %edi, %edi
callq 0x33a0
nop
// File: /workspace/github_c_makefile_star2_O0/crcx[P]retroforth/vm/nga-c/retro.c
// Function: verbose_details
V verbose_details(NgaState *vm, CELL opcode) {
  fprintf(stderr, "ip: %lld ", (long long)ACTIVE.ip);
  fprintf(stderr, "sp: %lld ", (long long)ACTIVE.sp);
  fprintf(stderr, "rp: %lld ", (long long)ACTIVE.rp);
  fprintf(stderr, "core: %lld ", (long long)vm->active);
  fprintf(stderr, "opcode: %lld\n", (long long)opcode);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movq 0x4aea(%rip), %rax      # 0x10ff0
movq (%rax), %rdi
movq -0x8(%rbp), %rax
addq $0x200004, %rax         # imm = 0x200004
movq -0x8(%rbp), %rcx
movslq 0x2043a4(%rcx), %rcx
imulq $0x874, %rcx, %rcx      # imm = 0x874
addq %rcx, %rax
movslq 0x8(%rax), %rdx
leaq 0x1280(%rip), %rsi      # 0xd7b3
movb $0x0, %al
callq 0x3250
movq 0x4aaf(%rip), %rax      # 0x10ff0
movq (%rax), %rdi
movq -0x8(%rbp), %rax
addq $0x200004, %rax         # imm = 0x200004
movq -0x8(%rbp), %rcx
movslq 0x2043a4(%rcx), %rcx
imulq $0x874, %rcx, %rcx      # imm = 0x874
addq %rcx, %rax
movslq (%rax), %rdx
leaq 0x1250(%rip), %rsi      # 0xd7bd
movb $0x0, %al
callq 0x3250
movq 0x4a75(%rip), %rax      # 0x10ff0
movq (%rax), %rdi
movq -0x8(%rbp), %rax
addq $0x200004, %rax         # imm = 0x200004
movq -0x8(%rbp), %rcx
movslq 0x2043a4(%rcx), %rcx
imulq $0x874, %rcx, %rcx      # imm = 0x874
addq %rcx, %rax
movslq 0x4(%rax), %rdx
leaq 0x121f(%rip), %rsi      # 0xd7c7
movb $0x0, %al
callq 0x3250
movq 0x4a3a(%rip), %rax      # 0x10ff0
movq (%rax), %rdi
movq -0x8(%rbp), %rax
movslq 0x2043a4(%rax), %rdx
leaq 0x1206(%rip), %rsi      # 0xd7d1
movb $0x0, %al
callq 0x3250
movq 0x4a17(%rip), %rax      # 0x10ff0
movq (%rax), %rdi
movslq -0xc(%rbp), %rdx
leaq 0x11f6(%rip), %rsi      # 0xd7dd
movb $0x0, %al
callq 0x3250
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/crcx[P]retroforth/vm/nga-c/retro.c
// Function: strlcat
size_t strlcat(char *dst, const char *src, size_t dsize) {
  const char *odst = dst;
  const char *osrc = src;
  size_t n = dsize;
  size_t dlen;

  /* Find the end of dst and adjust bytes left but don't go past end. */
  while (n-- != 0 && *dst != '\0')
    dst++;
  dlen = dst - odst;
  n = dsize - dlen;

  if (n-- == 0)
    return(dlen + strlen(src));
  while (*src != '\0') {
    if (n != 0) {
      *dst++ = *src;
      n--;
    }
    src++;
  }
  *dst = '\0';
  return(dlen + (src - osrc));  /* count does not include NUL */
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x28(%rbp)
movq -0x18(%rbp), %rax
movq %rax, -0x30(%rbp)
movq -0x20(%rbp), %rax
movq %rax, -0x38(%rbp)
movq -0x38(%rbp), %rcx
movq %rcx, %rax
addq $-0x1, %rax
movq %rax, -0x38(%rbp)
xorl %eax, %eax
cmpq $0x0, %rcx
movb %al, -0x41(%rbp)
je 0xc656
movq -0x10(%rbp), %rax
movsbl (%rax), %eax
cmpl $0x0, %eax
setne %al
movb %al, -0x41(%rbp)
movb -0x41(%rbp), %al
testb $0x1, %al
jne 0xc65f
jmp 0xc66d
movq -0x10(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x10(%rbp)
jmp 0xc62c
movq -0x10(%rbp), %rax
movq -0x28(%rbp), %rcx
subq %rcx, %rax
movq %rax, -0x40(%rbp)
movq -0x20(%rbp), %rax
subq -0x40(%rbp), %rax
movq %rax, -0x38(%rbp)
movq -0x38(%rbp), %rax
movq %rax, %rcx
addq $-0x1, %rcx
movq %rcx, -0x38(%rbp)
cmpq $0x0, %rax
jne 0xc6be
movq -0x40(%rbp), %rax
movq %rax, -0x50(%rbp)
movq -0x18(%rbp), %rdi
callq 0x3100
movq %rax, %rcx
movq -0x50(%rbp), %rax
addq %rcx, %rax
movq %rax, -0x8(%rbp)
jmp 0xc721
jmp 0xc6c0
movq -0x18(%rbp), %rax
movsbl (%rax), %eax
cmpl $0x0, %eax
je 0xc704
cmpq $0x0, -0x38(%rbp)
je 0xc6f6
movq -0x18(%rbp), %rax
movb (%rax), %cl
movq -0x10(%rbp), %rax
movq %rax, %rdx
addq $0x1, %rdx
movq %rdx, -0x10(%rbp)
movb %cl, (%rax)
movq -0x38(%rbp), %rax
addq $-0x1, %rax
movq %rax, -0x38(%rbp)
movq -0x18(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x18(%rbp)
jmp 0xc6c0
movq -0x10(%rbp), %rax
movb $0x0, (%rax)
movq -0x40(%rbp), %rax
movq -0x18(%rbp), %rcx
movq -0x30(%rbp), %rdx
subq %rdx, %rcx
addq %rcx, %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x50, %rsp
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O0/chatziko-k08[P]lecture-code/tests/ADTPriorityQueue_test.c
// Function: shuffle
void shuffle(int* array[], int size) {
	for (int i = 0; i < size; i++) {
		int new_pos = i + rand() / (RAND_MAX / (size - i) + 1);
		int* temp = array[new_pos];
		array[new_pos] = array[i];
		array[i] = temp;
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movl $0x0, -0x10(%rbp)
movl -0x10(%rbp), %eax
cmpl -0xc(%rbp), %eax
jge 0x4442
movl -0x10(%rbp), %eax
movl %eax, -0x24(%rbp)
callq 0x2260
movl %eax, -0x28(%rbp)
movl -0xc(%rbp), %ecx
subl -0x10(%rbp), %ecx
movl $0x7fffffff, %eax       # imm = 0x7FFFFFFF
cltd
idivl %ecx
movl %eax, %ecx
movl -0x28(%rbp), %eax
addl $0x1, %ecx
cltd
idivl %ecx
movl %eax, %ecx
movl -0x24(%rbp), %eax
addl %ecx, %eax
movl %eax, -0x14(%rbp)
movq -0x8(%rbp), %rax
movslq -0x14(%rbp), %rcx
movq (%rax,%rcx,8), %rax
movq %rax, -0x20(%rbp)
movq -0x8(%rbp), %rax
movslq -0x10(%rbp), %rcx
movq (%rax,%rcx,8), %rdx
movq -0x8(%rbp), %rax
movslq -0x14(%rbp), %rcx
movq %rdx, (%rax,%rcx,8)
movq -0x20(%rbp), %rdx
movq -0x8(%rbp), %rax
movslq -0x10(%rbp), %rcx
movq %rdx, (%rax,%rcx,8)
movl -0x10(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x10(%rbp)
jmp 0x43c6
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/chatziko-k08[P]lecture-code/tests/ADTPriorityQueue_test.c
// Function: test_insert
void test_insert(void) {
	PriorityQueue pqueue = pqueue_create(compare_ints, NULL, NULL);
	int N = 1000;
	int* array = malloc(N * sizeof(*array));					// Στο pqueue θα προσθέσουμε pointers προς τα στοιχεία αυτού του πίνακα

	// insert N στοιχεία
	for (int i = 0; i < N; i++) {
		array[i] = i;
		pqueue_insert(pqueue, &array[i]);
		TEST_ASSERT(pqueue_size(pqueue) == i+1);			// Το size ενημερώθηκε;
		TEST_ASSERT(pqueue_max(pqueue) == &array[i]);	// Εισαγωγή σε αύξουσα σειρά, το στοιχείο που μόλις βάλαμε πρέπει να είναι στην κορυφή
	}

	pqueue_destroy(pqueue);
	free(array);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
leaq -0x2af(%rip), %rdi      # 0x4480
xorl %eax, %eax
movl %eax, %edx
movq %rdx, %rsi
callq 0x5550
movq %rax, -0x8(%rbp)
movl $0x3e8, -0xc(%rbp)      # imm = 0x3E8
movslq -0xc(%rbp), %rdi
shlq $0x2, %rdi
callq 0x2180
movq %rax, -0x18(%rbp)
movl $0x0, -0x1c(%rbp)
movl -0x1c(%rbp), %eax
cmpl -0xc(%rbp), %eax
jge 0x4838
movl -0x1c(%rbp), %edx
movq -0x18(%rbp), %rax
movslq -0x1c(%rbp), %rcx
movl %edx, (%rax,%rcx,4)
movq -0x8(%rbp), %rdi
movq -0x18(%rbp), %rsi
movslq -0x1c(%rbp), %rax
shlq $0x2, %rax
addq %rax, %rsi
callq 0x56c0
movq -0x8(%rbp), %rdi
callq 0x5650
movl -0x1c(%rbp), %ecx
addl $0x1, %ecx
cmpl %ecx, %eax
sete %al
andb $0x1, %al
movzbl %al, %edi
leaq 0x1b31(%rip), %rsi      # 0x62e1
movl $0x46, %edx
leaq 0x1cd4(%rip), %rcx      # 0x6490
leaq 0x1bb5(%rip), %r8       # 0x6378
movb $0x0, %al
callq 0x2380
cmpl $0x0, %eax
jne 0x47d4
callq 0x2e60
jmp 0x47d6
jmp 0x47d8
movq -0x8(%rbp), %rdi
callq 0x5670
movq -0x18(%rbp), %rcx
movslq -0x1c(%rbp), %rdx
shlq $0x2, %rdx
addq %rdx, %rcx
cmpq %rcx, %rax
sete %al
andb $0x1, %al
movzbl %al, %edi
leaq 0x1adf(%rip), %rsi      # 0x62e1
movl $0x47, %edx
leaq 0x1c82(%rip), %rcx      # 0x6490
leaq 0x1b7e(%rip), %r8       # 0x6393
movb $0x0, %al
callq 0x2380
cmpl $0x0, %eax
jne 0x4826
callq 0x2e60
jmp 0x4828
jmp 0x482a
movl -0x1c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x1c(%rbp)
jmp 0x475e
movq -0x8(%rbp), %rdi
callq 0x59c0
movq -0x18(%rbp), %rdi
callq 0x2280
addq $0x20, %rsp
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O0/chatziko-k08[P]lecture-code/lib/../modules/UsingHeap/ADTPriorityQueue.c
// Function: pqueue_create
PriorityQueue pqueue_create(CompareFunc compare, DestroyFunc destroy_value, Vector values) {
	assert(compare != NULL);	// LCOV_EXCL_LINE

	PriorityQueue pqueue = malloc(sizeof(*pqueue));
	pqueue->compare = compare;
	pqueue->destroy_value = destroy_value;

	// Δημιουργία του vector που αποθηκεύει τα στοιχεία.
	// ΠΡΟΣΟΧΗ: ΔΕΝ περνάμε την destroy_value στο vector!
	// Αν την περάσουμε θα καλείται όταν κάνουμε swap 2 στοιχεία, το οποίο δεν το επιθυμούμε.
	pqueue->values = vector_create(0, NULL);

	// Αν values != NULL, αρχικοποιούμε το σωρό.
	if (values != NULL)
		naive_heapify(pqueue, values);

	return pqueue;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
cmpq $0x0, -0x8(%rbp)
je 0x556d
jmp 0x558c
leaq 0x18c0(%rip), %rdi      # 0x6e34
leaq 0x18c9(%rip), %rsi      # 0x6e44
movl $0x6a, %edx
leaq 0x18e5(%rip), %rcx      # 0x6e6c
callq 0x20f0
movl $0x18, %edi
callq 0x2180
movq %rax, -0x20(%rbp)
movq -0x8(%rbp), %rcx
movq -0x20(%rbp), %rax
movq %rcx, 0x8(%rax)
movq -0x10(%rbp), %rcx
movq -0x20(%rbp), %rax
movq %rcx, 0x10(%rax)
xorl %edi, %edi
xorl %eax, %eax
movl %eax, %esi
callq 0x5a00
movq %rax, %rcx
movq -0x20(%rbp), %rax
movq %rcx, (%rax)
cmpq $0x0, -0x18(%rbp)
je 0x55db
movq -0x20(%rbp), %rdi
movq -0x18(%rbp), %rsi
callq 0x55f0
movq -0x20(%rbp), %rax
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)