LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O0/plvhx[P]dummy-vm/src/vm.c
// Function: vm_mulb_imm8_imm8_to_regs
static void vm_mulb_imm8_imm8_to_regs(vm_t *vm) {
  switch (vm->buf[vm->ip]) {
  case VM_INSN_MULB_IMM8_IMM8_TO_R0:
    vm_insn_mulb_imm8_imm8_to_r0(vm);
    break;
  case VM_INSN_MULB_IMM8_IMM8_TO_R1:
    vm_insn_mulb_imm8_imm8_to_r1(vm);
    break;
  case VM_INSN_MULB_IMM8_IMM8_TO_R2:
    vm_insn_mulb_imm8_imm8_to_r2(vm);
    break;
  case VM_INSN_MULB_IMM8_IMM8_TO_R3:
    vm_insn_mulb_imm8_imm8_to_r3(vm);
    break;
  }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rcx
movq (%rcx), %rax
movslq 0x8(%rcx), %rcx
movzbl (%rax,%rcx), %eax
addl $-0x48, %eax
movl %eax, %ecx
movq %rcx, -0x10(%rbp)
subl $0x3, %eax
ja 0x88e7
movq -0x10(%rbp), %rax
leaq 0x1b60(%rip), %rcx      # 0xa414
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
movq -0x8(%rbp), %rdi
callq 0x2580
jmp 0x88e7
movq -0x8(%rbp), %rdi
callq 0x26d0
jmp 0x88e7
movq -0x8(%rbp), %rdi
callq 0x2820
jmp 0x88e7
movq -0x8(%rbp), %rdi
callq 0x2970
addq $0x10, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/plvhx[P]dummy-vm/src/vm.c
// Function: vm_divb_imm8_imm8_to_regs
static void vm_divb_imm8_imm8_to_regs(vm_t *vm) {
  switch (vm->buf[vm->ip]) {
  case VM_INSN_DIVB_IMM8_IMM8_TO_R0:
    vm_insn_divb_imm8_imm8_to_r0(vm);
    break;
  case VM_INSN_DIVB_IMM8_IMM8_TO_R1:
    vm_insn_divb_imm8_imm8_to_r1(vm);
    break;
  case VM_INSN_DIVB_IMM8_IMM8_TO_R2:
    vm_insn_divb_imm8_imm8_to_r2(vm);
    break;
  case VM_INSN_DIVB_IMM8_IMM8_TO_R3:
    vm_insn_divb_imm8_imm8_to_r3(vm);
    break;
  }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rcx
movq (%rcx), %rax
movslq 0x8(%rcx), %rcx
movzbl (%rax,%rcx), %eax
addl $-0x4c, %eax
movl %eax, %ecx
movq %rcx, -0x10(%rbp)
subl $0x3, %eax
ja 0x8957
movq -0x10(%rbp), %rax
leaq 0x1b00(%rip), %rcx      # 0xa424
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
movq -0x8(%rbp), %rdi
callq 0x2ac0
jmp 0x8957
movq -0x8(%rbp), %rdi
callq 0x2c30
jmp 0x8957
movq -0x8(%rbp), %rdi
callq 0x2da0
jmp 0x8957
movq -0x8(%rbp), %rdi
callq 0x2f10
addq $0x10, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/plvhx[P]dummy-vm/src/vm.c
// Function: vm_addb_imm8_r0_to_regs
static void vm_addb_imm8_r0_to_regs(vm_t *vm) {
  switch (vm->buf[vm->ip]) {
  case VM_INSN_ADDB_IMM8_R0_TO_R0:
    vm_insn_addb_imm8_r0_to_r0(vm);
    break;
  case VM_INSN_ADDB_IMM8_R0_TO_R1:
    vm_insn_addb_imm8_r0_to_r1(vm);
    break;
  case VM_INSN_ADDB_IMM8_R0_TO_R2:
    vm_insn_addb_imm8_r0_to_r2(vm);
    break;
  case VM_INSN_ADDB_IMM8_R0_TO_R3:
    vm_insn_addb_imm8_r0_to_r3(vm);
    break;
  }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rcx
movq (%rcx), %rax
movslq 0x8(%rcx), %rcx
movzbl (%rax,%rcx), %eax
addl $-0x50, %eax
movl %eax, %ecx
movq %rcx, -0x10(%rbp)
subl $0x3, %eax
ja 0x89c7
movq -0x10(%rbp), %rax
leaq 0x1aa0(%rip), %rcx      # 0xa434
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
movq -0x8(%rbp), %rdi
callq 0x3080
jmp 0x89c7
movq -0x8(%rbp), %rdi
callq 0x31e0
jmp 0x89c7
movq -0x8(%rbp), %rdi
callq 0x3340
jmp 0x89c7
movq -0x8(%rbp), %rdi
callq 0x34a0
addq $0x10, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/plvhx[P]dummy-vm/src/vm.c
// Function: vm_subb_imm8_r0_to_regs
static void vm_subb_imm8_r0_to_regs(vm_t *vm) {
  switch (vm->buf[vm->ip]) {
  case VM_INSN_SUBB_IMM8_R0_TO_R0:
    vm_insn_subb_imm8_r0_to_r0(vm);
    break;
  case VM_INSN_SUBB_IMM8_R0_TO_R1:
    vm_insn_subb_imm8_r0_to_r1(vm);
    break;
  case VM_INSN_SUBB_IMM8_R0_TO_R2:
    vm_insn_subb_imm8_r0_to_r2(vm);
    break;
  case VM_INSN_SUBB_IMM8_R0_TO_R3:
    vm_insn_subb_imm8_r0_to_r3(vm);
    break;
  }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rcx
movq (%rcx), %rax
movslq 0x8(%rcx), %rcx
movzbl (%rax,%rcx), %eax
addl $-0x54, %eax
movl %eax, %ecx
movq %rcx, -0x10(%rbp)
subl $0x3, %eax
ja 0x8a37
movq -0x10(%rbp), %rax
leaq 0x1a40(%rip), %rcx      # 0xa444
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
movq -0x8(%rbp), %rdi
callq 0x3600
jmp 0x8a37
movq -0x8(%rbp), %rdi
callq 0x3760
jmp 0x8a37
movq -0x8(%rbp), %rdi
callq 0x38c0
jmp 0x8a37
movq -0x8(%rbp), %rdi
callq 0x3a20
addq $0x10, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/plvhx[P]dummy-vm/src/vm.c
// Function: vm_mulb_imm8_r0_to_regs
static void vm_mulb_imm8_r0_to_regs(vm_t *vm) {
  switch (vm->buf[vm->ip]) {
  case VM_INSN_MULB_IMM8_R0_TO_R0:
    vm_insn_mulb_imm8_r0_to_r0(vm);
    break;
  case VM_INSN_MULB_IMM8_R0_TO_R1:
    vm_insn_mulb_imm8_r0_to_r1(vm);
    break;
  case VM_INSN_MULB_IMM8_R0_TO_R2:
    vm_insn_mulb_imm8_r0_to_r2(vm);
    break;
  case VM_INSN_MULB_IMM8_R0_TO_R3:
    vm_insn_mulb_imm8_r0_to_r3(vm);
    break;
  }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rcx
movq (%rcx), %rax
movslq 0x8(%rcx), %rcx
movzbl (%rax,%rcx), %eax
addl $-0x58, %eax
movl %eax, %ecx
movq %rcx, -0x10(%rbp)
subl $0x3, %eax
ja 0x8aa7
movq -0x10(%rbp), %rax
leaq 0x19e0(%rip), %rcx      # 0xa454
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
movq -0x8(%rbp), %rdi
callq 0x3b80
jmp 0x8aa7
movq -0x8(%rbp), %rdi
callq 0x3ce0
jmp 0x8aa7
movq -0x8(%rbp), %rdi
callq 0x3e40
jmp 0x8aa7
movq -0x8(%rbp), %rdi
callq 0x3fa0
addq $0x10, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/plvhx[P]dummy-vm/src/vm.c
// Function: vm_divb_imm8_r0_to_regs
static void vm_divb_imm8_r0_to_regs(vm_t *vm) {
  switch (vm->buf[vm->ip]) {
  case VM_INSN_DIVB_IMM8_R0_TO_R0:
    vm_insn_divb_imm8_r0_to_r0(vm);
    break;
  case VM_INSN_DIVB_IMM8_R0_TO_R1:
    vm_insn_divb_imm8_r0_to_r1(vm);
    break;
  case VM_INSN_DIVB_IMM8_R0_TO_R2:
    vm_insn_divb_imm8_r0_to_r2(vm);
    break;
  case VM_INSN_DIVB_IMM8_R0_TO_R3:
    vm_insn_divb_imm8_r0_to_r3(vm);
    break;
  }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rcx
movq (%rcx), %rax
movslq 0x8(%rcx), %rcx
movzbl (%rax,%rcx), %eax
addl $-0x5c, %eax
movl %eax, %ecx
movq %rcx, -0x10(%rbp)
subl $0x3, %eax
ja 0x8b17
movq -0x10(%rbp), %rax
leaq 0x1980(%rip), %rcx      # 0xa464
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
movq -0x8(%rbp), %rdi
callq 0x4100
jmp 0x8b17
movq -0x8(%rbp), %rdi
callq 0x4280
jmp 0x8b17
movq -0x8(%rbp), %rdi
callq 0x4400
jmp 0x8b17
movq -0x8(%rbp), %rdi
callq 0x4580
addq $0x10, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/plvhx[P]dummy-vm/src/vm.c
// Function: vm_addb_imm8_r1_to_regs
static void vm_addb_imm8_r1_to_regs(vm_t *vm) {
  switch (vm->buf[vm->ip]) {
  case VM_INSN_ADDB_IMM8_R1_TO_R0:
    vm_insn_addb_imm8_r1_to_r0(vm);
    break;
  case VM_INSN_ADDB_IMM8_R1_TO_R1:
    vm_insn_addb_imm8_r1_to_r1(vm);
    break;
  case VM_INSN_ADDB_IMM8_R1_TO_R2:
    vm_insn_addb_imm8_r1_to_r2(vm);
    break;
  case VM_INSN_ADDB_IMM8_R1_TO_R3:
    vm_insn_addb_imm8_r1_to_r3(vm);
    break;
  }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rcx
movq (%rcx), %rax
movslq 0x8(%rcx), %rcx
movzbl (%rax,%rcx), %eax
addl $-0x60, %eax
movl %eax, %ecx
movq %rcx, -0x10(%rbp)
subl $0x3, %eax
ja 0x8b87
movq -0x10(%rbp), %rax
leaq 0x1920(%rip), %rcx      # 0xa474
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
movq -0x8(%rbp), %rdi
callq 0x4700
jmp 0x8b87
movq -0x8(%rbp), %rdi
callq 0x4860
jmp 0x8b87
movq -0x8(%rbp), %rdi
callq 0x49c0
jmp 0x8b87
movq -0x8(%rbp), %rdi
callq 0x4b20
addq $0x10, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/plvhx[P]dummy-vm/src/vm.c
// Function: vm_subb_imm8_r1_to_regs
static void vm_subb_imm8_r1_to_regs(vm_t *vm) {
  switch (vm->buf[vm->ip]) {
  case VM_INSN_SUBB_IMM8_R1_TO_R0:
    vm_insn_subb_imm8_r1_to_r0(vm);
    break;
  case VM_INSN_SUBB_IMM8_R1_TO_R1:
    vm_insn_subb_imm8_r1_to_r1(vm);
    break;
  case VM_INSN_SUBB_IMM8_R1_TO_R2:
    vm_insn_subb_imm8_r1_to_r2(vm);
    break;
  case VM_INSN_SUBB_IMM8_R1_TO_R3:
    vm_insn_subb_imm8_r1_to_r3(vm);
    break;
  }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rcx
movq (%rcx), %rax
movslq 0x8(%rcx), %rcx
movzbl (%rax,%rcx), %eax
addl $-0x64, %eax
movl %eax, %ecx
movq %rcx, -0x10(%rbp)
subl $0x3, %eax
ja 0x8bf7
movq -0x10(%rbp), %rax
leaq 0x18c0(%rip), %rcx      # 0xa484
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
movq -0x8(%rbp), %rdi
callq 0x4c80
jmp 0x8bf7
movq -0x8(%rbp), %rdi
callq 0x4de0
jmp 0x8bf7
movq -0x8(%rbp), %rdi
callq 0x4f40
jmp 0x8bf7
movq -0x8(%rbp), %rdi
callq 0x50a0
addq $0x10, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/plvhx[P]dummy-vm/src/vm.c
// Function: vm_mulb_imm8_r1_to_regs
static void vm_mulb_imm8_r1_to_regs(vm_t *vm) {
  switch (vm->buf[vm->ip]) {
  case VM_INSN_MULB_IMM8_R1_TO_R0:
    vm_insn_mulb_imm8_r1_to_r0(vm);
    break;
  case VM_INSN_MULB_IMM8_R1_TO_R1:
    vm_insn_mulb_imm8_r1_to_r1(vm);
    break;
  case VM_INSN_MULB_IMM8_R1_TO_R2:
    vm_insn_mulb_imm8_r1_to_r2(vm);
    break;
  case VM_INSN_MULB_IMM8_R1_TO_R3:
    vm_insn_mulb_imm8_r1_to_r3(vm);
    break;
  }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rcx
movq (%rcx), %rax
movslq 0x8(%rcx), %rcx
movzbl (%rax,%rcx), %eax
addl $-0x68, %eax
movl %eax, %ecx
movq %rcx, -0x10(%rbp)
subl $0x3, %eax
ja 0x8c67
movq -0x10(%rbp), %rax
leaq 0x1860(%rip), %rcx      # 0xa494
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
movq -0x8(%rbp), %rdi
callq 0x5200
jmp 0x8c67
movq -0x8(%rbp), %rdi
callq 0x5360
jmp 0x8c67
movq -0x8(%rbp), %rdi
callq 0x54c0
jmp 0x8c67
movq -0x8(%rbp), %rdi
callq 0x5620
addq $0x10, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/plvhx[P]dummy-vm/src/vm.c
// Function: vm_divb_imm8_r1_to_regs
static void vm_divb_imm8_r1_to_regs(vm_t *vm) {
  switch (vm->buf[vm->ip]) {
  case VM_INSN_DIVB_IMM8_R1_TO_R0:
    vm_insn_divb_imm8_r1_to_r0(vm);
    break;
  case VM_INSN_DIVB_IMM8_R1_TO_R1:
    vm_insn_divb_imm8_r1_to_r1(vm);
    break;
  case VM_INSN_DIVB_IMM8_R1_TO_R2:
    vm_insn_divb_imm8_r1_to_r2(vm);
    break;
  case VM_INSN_DIVB_IMM8_R1_TO_R3:
    vm_insn_divb_imm8_r1_to_r3(vm);
    break;
  }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rcx
movq (%rcx), %rax
movslq 0x8(%rcx), %rcx
movzbl (%rax,%rcx), %eax
addl $-0x6c, %eax
movl %eax, %ecx
movq %rcx, -0x10(%rbp)
subl $0x3, %eax
ja 0x8cd7
movq -0x10(%rbp), %rax
leaq 0x1800(%rip), %rcx      # 0xa4a4
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
movq -0x8(%rbp), %rdi
callq 0x5780
jmp 0x8cd7
movq -0x8(%rbp), %rdi
callq 0x5900
jmp 0x8cd7
movq -0x8(%rbp), %rdi
callq 0x5a80
jmp 0x8cd7
movq -0x8(%rbp), %rdi
callq 0x5c00
addq $0x10, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/plvhx[P]dummy-vm/src/vm.c
// Function: vm_addb_imm8_r2_to_regs
static void vm_addb_imm8_r2_to_regs(vm_t *vm) {
  switch (vm->buf[vm->ip]) {
  case VM_INSN_ADDB_IMM8_R2_TO_R0:
    vm_insn_addb_imm8_r2_to_r0(vm);
    break;
  case VM_INSN_ADDB_IMM8_R2_TO_R1:
    vm_insn_addb_imm8_r2_to_r1(vm);
    break;
  case VM_INSN_ADDB_IMM8_R2_TO_R2:
    vm_insn_addb_imm8_r2_to_r2(vm);
    break;
  case VM_INSN_ADDB_IMM8_R2_TO_R3:
    vm_insn_addb_imm8_r2_to_r3(vm);
    break;
  }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rcx
movq (%rcx), %rax
movslq 0x8(%rcx), %rcx
movzbl (%rax,%rcx), %eax
addl $-0x70, %eax
movl %eax, %ecx
movq %rcx, -0x10(%rbp)
subl $0x3, %eax
ja 0x8d47
movq -0x10(%rbp), %rax
leaq 0x17a0(%rip), %rcx      # 0xa4b4
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
movq -0x8(%rbp), %rdi
callq 0x5d80
jmp 0x8d47
movq -0x8(%rbp), %rdi
callq 0x5ee0
jmp 0x8d47
movq -0x8(%rbp), %rdi
callq 0x6040
jmp 0x8d47
movq -0x8(%rbp), %rdi
callq 0x61a0
addq $0x10, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/plvhx[P]dummy-vm/src/vm.c
// Function: vm_subb_imm8_r2_to_regs
static void vm_subb_imm8_r2_to_regs(vm_t *vm) {
  switch (vm->buf[vm->ip]) {
  case VM_INSN_SUBB_IMM8_R2_TO_R0:
    vm_insn_subb_imm8_r2_to_r0(vm);
    break;
  case VM_INSN_SUBB_IMM8_R2_TO_R1:
    vm_insn_subb_imm8_r2_to_r1(vm);
    break;
  case VM_INSN_SUBB_IMM8_R2_TO_R2:
    vm_insn_subb_imm8_r2_to_r2(vm);
    break;
  case VM_INSN_SUBB_IMM8_R2_TO_R3:
    vm_insn_subb_imm8_r2_to_r3(vm);
    break;
  }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rcx
movq (%rcx), %rax
movslq 0x8(%rcx), %rcx
movzbl (%rax,%rcx), %eax
addl $-0x74, %eax
movl %eax, %ecx
movq %rcx, -0x10(%rbp)
subl $0x3, %eax
ja 0x8db7
movq -0x10(%rbp), %rax
leaq 0x1740(%rip), %rcx      # 0xa4c4
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
movq -0x8(%rbp), %rdi
callq 0x6300
jmp 0x8db7
movq -0x8(%rbp), %rdi
callq 0x6460
jmp 0x8db7
movq -0x8(%rbp), %rdi
callq 0x65c0
jmp 0x8db7
movq -0x8(%rbp), %rdi
callq 0x6720
addq $0x10, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/plvhx[P]dummy-vm/src/vm.c
// Function: vm_mulb_imm8_r2_to_regs
static void vm_mulb_imm8_r2_to_regs(vm_t *vm) {
  switch (vm->buf[vm->ip]) {
  case VM_INSN_MULB_IMM8_R2_TO_R0:
    vm_insn_mulb_imm8_r2_to_r0(vm);
    break;
  case VM_INSN_MULB_IMM8_R2_TO_R1:
    vm_insn_mulb_imm8_r2_to_r1(vm);
    break;
  case VM_INSN_MULB_IMM8_R2_TO_R2:
    vm_insn_mulb_imm8_r2_to_r2(vm);
    break;
  case VM_INSN_MULB_IMM8_R2_TO_R3:
    vm_insn_mulb_imm8_r2_to_r3(vm);
    break;
  }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rcx
movq (%rcx), %rax
movslq 0x8(%rcx), %rcx
movzbl (%rax,%rcx), %eax
addl $-0x78, %eax
movl %eax, %ecx
movq %rcx, -0x10(%rbp)
subl $0x3, %eax
ja 0x8e27
movq -0x10(%rbp), %rax
leaq 0x16e0(%rip), %rcx      # 0xa4d4
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
movq -0x8(%rbp), %rdi
callq 0x6880
jmp 0x8e27
movq -0x8(%rbp), %rdi
callq 0x69e0
jmp 0x8e27
movq -0x8(%rbp), %rdi
callq 0x6b40
jmp 0x8e27
movq -0x8(%rbp), %rdi
callq 0x6ca0
addq $0x10, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/plvhx[P]dummy-vm/src/vm.c
// Function: vm_divb_imm8_r2_to_regs
static void vm_divb_imm8_r2_to_regs(vm_t *vm) {
  switch (vm->buf[vm->ip]) {
  case VM_INSN_DIVB_IMM8_R2_TO_R0:
    vm_insn_divb_imm8_r2_to_r0(vm);
    break;
  case VM_INSN_DIVB_IMM8_R2_TO_R1:
    vm_insn_divb_imm8_r2_to_r1(vm);
    break;
  case VM_INSN_DIVB_IMM8_R2_TO_R2:
    vm_insn_divb_imm8_r2_to_r2(vm);
    break;
  case VM_INSN_DIVB_IMM8_R2_TO_R3:
    vm_insn_divb_imm8_r2_to_r3(vm);
    break;
  }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rcx
movq (%rcx), %rax
movslq 0x8(%rcx), %rcx
movzbl (%rax,%rcx), %eax
addl $-0x7c, %eax
movl %eax, %ecx
movq %rcx, -0x10(%rbp)
subl $0x3, %eax
ja 0x8e97
movq -0x10(%rbp), %rax
leaq 0x1680(%rip), %rcx      # 0xa4e4
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
movq -0x8(%rbp), %rdi
callq 0x6e00
jmp 0x8e97
movq -0x8(%rbp), %rdi
callq 0x6f80
jmp 0x8e97
movq -0x8(%rbp), %rdi
callq 0x7100
jmp 0x8e97
movq -0x8(%rbp), %rdi
callq 0x7280
addq $0x10, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/plvhx[P]dummy-vm/src/vm.c
// Function: vm_addb_imm8_r3_to_regs
static void vm_addb_imm8_r3_to_regs(vm_t *vm) {
  switch (vm->buf[vm->ip]) {
  case VM_INSN_ADDB_IMM8_R3_TO_R0:
    vm_insn_addb_imm8_r3_to_r0(vm);
    break;
  case VM_INSN_ADDB_IMM8_R3_TO_R1:
    vm_insn_addb_imm8_r3_to_r1(vm);
    break;
  case VM_INSN_ADDB_IMM8_R3_TO_R2:
    vm_insn_addb_imm8_r3_to_r2(vm);
    break;
  case VM_INSN_ADDB_IMM8_R3_TO_R3:
    vm_insn_addb_imm8_r3_to_r3(vm);
    break;
  }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rcx
movq (%rcx), %rax
movslq 0x8(%rcx), %rcx
movzbl (%rax,%rcx), %eax
addl $-0x80, %eax
movl %eax, %ecx
movq %rcx, -0x10(%rbp)
subl $0x3, %eax
ja 0x8f07
movq -0x10(%rbp), %rax
leaq 0x1620(%rip), %rcx      # 0xa4f4
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
movq -0x8(%rbp), %rdi
callq 0x7400
jmp 0x8f07
movq -0x8(%rbp), %rdi
callq 0x7560
jmp 0x8f07
movq -0x8(%rbp), %rdi
callq 0x76c0
jmp 0x8f07
movq -0x8(%rbp), %rdi
callq 0x7820
addq $0x10, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/plvhx[P]dummy-vm/src/vm.c
// Function: vm_print_regs
static void vm_print_regs(vm_t *vm) {
  switch (vm->buf[vm->ip]) {
  case VM_INSN_PRINT_R0:
    vm_insn_print_r0(vm);
    break;
  case VM_INSN_PRINT_R1:
    vm_insn_print_r1(vm);
    break;
  case VM_INSN_PRINT_R2:
    vm_insn_print_r2(vm);
    break;
  case VM_INSN_PRINT_R3:
    vm_insn_print_r3(vm);
    break;
  }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rcx
movq (%rcx), %rax
movslq 0x8(%rcx), %rcx
movzbl (%rax,%rcx), %eax
addl $-0x21, %eax
movl %eax, %ecx
movq %rcx, -0x10(%rbp)
subl $0x3, %eax
ja 0x8f77
movq -0x10(%rbp), %rax
leaq 0x15c0(%rip), %rcx      # 0xa504
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
movq -0x8(%rbp), %rdi
callq 0x7a50
jmp 0x8f77
movq -0x8(%rbp), %rdi
callq 0x7b30
jmp 0x8f77
movq -0x8(%rbp), %rdi
callq 0x7c10
jmp 0x8f77
movq -0x8(%rbp), %rdi
callq 0x7cf0
addq $0x10, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/plvhx[P]dummy-vm/src/vm.c
// Function: vm_destroy
void vm_destroy(vm_t *vm) {
  vm_stack_destroy(vm->stack);
  vm_state_destroy(vm->state);
  vm_regs_destroy(vm->regs);

  vm->ip = -1;

  free(vm->buf);
  free(vm);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq 0x28(%rax), %rdi
callq 0x82c0
movq -0x8(%rbp), %rax
movq 0x20(%rax), %rdi
callq 0x8110
movq -0x8(%rbp), %rax
movq 0x18(%rax), %rdi
callq 0x7f10
movq -0x8(%rbp), %rax
movl $0xffffffff, 0x8(%rax)  # imm = 0xFFFFFFFF
movq -0x8(%rbp), %rax
movq (%rax), %rdi
callq 0x1030
movq -0x8(%rbp), %rdi
callq 0x1030
addq $0x10, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/plvhx[P]dummy-vm/dispatcher.c
// Function: main
int main(int argc, char **argv) {
  int opt;

  if (argc == 1) {
    fprintf(stderr, "Usage: %s -f <filename>.cplx\n", argv[0]);
    return 1;
  }

  while ((opt = getopt(argc, argv, "f:")) != -1) {
    switch (opt) {
    case 'f':
      vm_runner_run_file(optarg);
      break;
    default:
      fprintf(stderr, "Usage: %s -f <filename>.cplx\n", argv[0]);
      return 1;
    }
  }

  return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movl $0x0, -0x4(%rbp)
movl %edi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
cmpl $0x1, -0x8(%rbp)
jne 0x9024
movq 0x3ff5(%rip), %rax      # 0xcff8
movq (%rax), %rdi
movq -0x10(%rbp), %rax
movq (%rax), %rdx
leaq 0x1576(%rip), %rsi      # 0xa58a
movb $0x0, %al
callq 0x10b0
movl $0x1, -0x4(%rbp)
jmp 0x908d
jmp 0x9026
movl -0x8(%rbp), %edi
movq -0x10(%rbp), %rsi
leaq 0x1574(%rip), %rdx      # 0xa5a8
callq 0x10e0
movl %eax, -0x14(%rbp)
cmpl $-0x1, %eax
je 0x9086
movl -0x14(%rbp), %eax
subl $0x66, %eax
jne 0x905c
jmp 0x904b
movq 0x3f86(%rip), %rax      # 0xcfd8
movq (%rax), %rdi
callq 0x90a0
jmp 0x9084
movq 0x3f95(%rip), %rax      # 0xcff8
movq (%rax), %rdi
movq -0x10(%rbp), %rax
movq (%rax), %rdx
leaq 0x1516(%rip), %rsi      # 0xa58a
movb $0x0, %al
callq 0x10b0
movl $0x1, -0x4(%rbp)
jmp 0x908d
jmp 0x9026
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/plvhx[P]dummy-vm/dispatcher.c
// Function: vm_runner_run_file
static void vm_runner_run_file(const char *file) {
  int fd = open(file, O_RDONLY);
  struct stat st;

  if (fd < 0) {
    perror("open() fail.\n");
    return;
  }

  memset(&st, 0, sizeof(struct stat));

  if (fstat(fd, &st) < 0) {
    perror("fstat() fail.\n");
    return;
  }

  char *obuf = calloc(st.st_size, sizeof(char));

  if (obuf == NULL) {
    perror("calloc() fail.\n");
    return;
  }

  if (read(fd, obuf, st.st_size) < 0) {
    perror("read() fail.\n");
    return;
  }

  vm_t *vm = vm_init(obuf, strlen(obuf));
  vm_run(vm);
  vm_destroy(vm);

  free(obuf);
  close(fd);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0xc0, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
xorl %esi, %esi
movb $0x0, %al
callq 0x10c0
movl %eax, -0xc(%rbp)
cmpl $0x0, -0xc(%rbp)
jge 0x90d6
leaq 0x14df(%rip), %rdi      # 0xa5ab
callq 0x10d0
jmp 0x91c1
leaq -0xa0(%rbp), %rdi
xorl %esi, %esi
movl $0x90, %edx
callq 0x1070
movl -0xc(%rbp), %edi
leaq -0xa0(%rbp), %rsi
callq 0x1100
cmpl $0x0, %eax
jge 0x910e
leaq 0x14b5(%rip), %rdi      # 0xa5b9
callq 0x10d0
jmp 0x91c1
movq -0x70(%rbp), %rdi
movl $0x1, %esi
callq 0x10a0
movq %rax, -0xa8(%rbp)
cmpq $0x0, -0xa8(%rbp)
jne 0x913e
leaq 0x1494(%rip), %rdi      # 0xa5c8
callq 0x10d0
jmp 0x91c1
movl -0xc(%rbp), %edi
movq -0xa8(%rbp), %rsi
movq -0x70(%rbp), %rdx
callq 0x1090
cmpq $0x0, %rax
jge 0x9165
leaq 0x147a(%rip), %rdi      # 0xa5d8
callq 0x10d0
jmp 0x91c1
movq -0xa8(%rbp), %rax
movq %rax, -0xb8(%rbp)
movq -0xa8(%rbp), %rdi
callq 0x1040
movq -0xb8(%rbp), %rdi
movq %rax, %rsi
callq 0x82e0
movq %rax, -0xb0(%rbp)
movq -0xb0(%rbp), %rdi
callq 0x83a0
movq -0xb0(%rbp), %rdi
callq 0x8f80
movq -0xa8(%rbp), %rdi
callq 0x1030
movl -0xc(%rbp), %edi
callq 0x1080
addq $0xc0, %rsp
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O0/nilyang[P]redis-tdd-annotation/src/redis-benchmark.c
// Function: showThroughput
int showThroughput(struct aeEventLoop *eventLoop, long long id, void *clientData) {
    REDIS_NOTUSED(eventLoop);
    REDIS_NOTUSED(id);
    REDIS_NOTUSED(clientData);

    if (config.csv) return 250;
    float dt = (float)(mstime()-config.start)/1000.0;
    float rps = (float)config.requests_finished/dt;
    printf("%s: %.2f\r", config.title, rps);
    fflush(stdout);
    return 250; /* every 250ms */
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
cmpl $0x0, 0x44e39(%rip)     # 0x51434
je 0xc606
movl $0xfa, -0x4(%rbp)
jmp 0xc676
callq 0xc680
subq 0x44df6(%rip), %rax     # 0x51408
cvtsi2ss %rax, %xmm0
cvtss2sd %xmm0, %xmm0
movsd 0x34b45(%rip), %xmm1    # 0x41168
divsd %xmm1, %xmm0
cvtsd2ss %xmm0, %xmm0
movss %xmm0, -0x24(%rbp)
cvtsi2ssl 0x44db0(%rip), %xmm0 # 0x513e8
divss -0x24(%rbp), %xmm0
movss %xmm0, -0x28(%rbp)
movq 0x44dd7(%rip), %rsi     # 0x51420
movss -0x28(%rbp), %xmm0
cvtss2sd %xmm0, %xmm0
leaq 0x35433(%rip), %rdi     # 0x41a8c
movb $0x1, %al
callq 0x91a0
movq 0x44949(%rip), %rax     # 0x50fb0
movq (%rax), %rdi
callq 0x9390
movl $0xfa, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x30, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/nilyang[P]redis-tdd-annotation/src/redis-benchmark.c
// Function: createMissingClients
static void createMissingClients(client c) {
    int n = 0;
    char *buf = c->obuf;
    size_t buflen = sdslen(c->obuf);

    /* If we are cloning from a client with a SELECT prefix, skip it since the
     * client will be created with the prefixed SELECT if needed. */
    if (c->selectlen) {
        buf += c->selectlen;
        buflen -= c->selectlen;
    }

    while(config.liveclients < config.numclients) {
        createClient(NULL,0,c);

        /* Listen backlog is quite limited on most systems */
        if (++n > 64) {
            usleep(50000);
            n = 0;
        }
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movl $0x0, -0xc(%rbp)
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rax
movq %rax, -0x18(%rbp)
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rdi
callq 0xc010
movq %rax, -0x20(%rbp)
movq -0x8(%rbp), %rax
cmpl $0x0, 0x44(%rax)
je 0xd482
movq -0x8(%rbp), %rax
movl 0x44(%rax), %ecx
movq -0x18(%rbp), %rax
movslq %ecx, %rcx
addq %rcx, %rax
movq %rax, -0x18(%rbp)
movq -0x8(%rbp), %rax
movslq 0x44(%rax), %rcx
movq -0x20(%rbp), %rax
subq %rcx, %rax
movq %rax, -0x20(%rbp)
jmp 0xd484
movl 0x43f52(%rip), %eax     # 0x513dc
cmpl 0x43f48(%rip), %eax     # 0x513d8
jge 0xd4c3
movq -0x8(%rbp), %rdx
xorl %eax, %eax
movl %eax, %esi
movq %rsi, %rdi
callq 0xcf90
movl -0xc(%rbp), %eax
addl $0x1, %eax
movl %eax, -0xc(%rbp)
cmpl $0x40, %eax
jle 0xd4c1
movl $0xc350, %edi           # imm = 0xC350
callq 0x95c0
movl $0x0, -0xc(%rbp)
jmp 0xd484
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/giometti[P]mastering_UNIX_programming/chapter_09/setjmp1.c
// Function: main
int main(int argc, char *argv[])
{
	jmp_buf env;
	int i, j, k, l;
	int ret;

	if (argc < 5) {
		fprintf(stderr, "usage: %s <i> <j> <k> <l>\n", argv[0]);
		return -1;
	}

	/* Here we check if nested functions detect an error */
	ret = setjmp(env);
	if (ret != 0) {
		fprintf(stderr, "bad values!\n");
		return -1;
	}

	/* Convert the input values and then call func1() */
	i = atoi(argv[1]);
	j = atoi(argv[2]);
	k = atoi(argv[3]);
	l = atoi(argv[4]);
	printf("func1() returned %d\n", func1(env, i, j, k, l));

	return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x100, %rsp            # imm = 0x100
movl $0x0, -0x4(%rbp)
movl %edi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
cmpl $0x5, -0x8(%rbp)
jge 0x12da
movq 0x2d42(%rip), %rax      # 0x3ff8
movq (%rax), %rdi
movq -0x10(%rbp), %rax
movq (%rax), %rdx
leaq 0xd3d(%rip), %rsi       # 0x2004
movb $0x0, %al
callq 0x1050
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
jmp 0x13a1
leaq -0xe0(%rbp), %rdi
callq 0x1040
movl %eax, -0xf4(%rbp)
cmpl $0x0, -0xf4(%rbp)
je 0x1319
movq 0x2cfc(%rip), %rax      # 0x3ff8
movq (%rax), %rdi
leaq 0xd19(%rip), %rsi       # 0x201f
movb $0x0, %al
callq 0x1050
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
jmp 0x13a1
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rdi
callq 0x1070
movl %eax, -0xe4(%rbp)
movq -0x10(%rbp), %rax
movq 0x10(%rax), %rdi
callq 0x1070
movl %eax, -0xe8(%rbp)
movq -0x10(%rbp), %rax
movq 0x18(%rax), %rdi
callq 0x1070
movl %eax, -0xec(%rbp)
movq -0x10(%rbp), %rax
movq 0x20(%rax), %rdi
callq 0x1070
movl %eax, -0xf0(%rbp)
leaq -0xe0(%rbp), %rdi
movl -0xe4(%rbp), %esi
movl -0xe8(%rbp), %edx
movl -0xec(%rbp), %ecx
movl -0xf0(%rbp), %r8d
callq 0x1250
movl %eax, %esi
leaq 0xc99(%rip), %rdi       # 0x202c
movb $0x0, %al
callq 0x1030
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x100, %rsp            # imm = 0x100
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O0/PARKINHYO[P]BlackjackGame/fifo/fifo_client.c
// Function: main
int main(void)
{
	int id;
	char msg[BUFF_SIZE];

	//클라이언트 시작 시 파이프 open
	if ((fd = open(TO_SERVER_FILE, O_WRONLY)) == -1) {
		printf("[SYSTEM] in main() open error!!\n");
		return 0;
	}

	pid = getpid();
	printf("[CLIENT] client(%d) enter\n", pid);

	//서버로 cmd==3, pid 값 전달
	sprintf(msg, "3 %d", pid);
	write(fd, msg, strlen(msg));

	//쓰레드 생성, 게임시작
	pthread_create(&threads[0], NULL, play_game, (void*)(intptr_t)id);
	pthread_join(threads[0], NULL);

	printf("\n\n============Game End============\n\n");
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movl $0x0, -0x4(%rbp)
leaq 0xbb3(%rip), %rdi       # 0x2069
movl $0x1, %esi
movb $0x0, %al
callq 0x10d0
movl %eax, 0x2c94(%rip)      # 0x415c
cmpl $-0x1, %eax
jne 0x14e7
leaq 0xba3(%rip), %rdi       # 0x2077
movb $0x0, %al
callq 0x1070
movl $0x0, -0x4(%rbp)
jmp 0x1580
callq 0x1050
movl %eax, 0x2c6e(%rip)      # 0x4160
movl 0x2c68(%rip), %esi      # 0x4160
leaq 0xb99(%rip), %rdi       # 0x2098
movb $0x0, %al
callq 0x1070
leaq -0x30(%rbp), %rdi
movl 0x2c50(%rip), %edx      # 0x4160
leaq 0xb9c(%rip), %rsi       # 0x20b3
movb $0x0, %al
callq 0x10f0
movl 0x2c38(%rip), %eax      # 0x415c
movl %eax, -0x3c(%rbp)
leaq -0x30(%rbp), %rax
movq %rax, -0x38(%rbp)
leaq -0x30(%rbp), %rdi
callq 0x1060
movl -0x3c(%rbp), %edi
movq -0x38(%rbp), %rsi
movq %rax, %rdx
callq 0x1040
movslq -0x8(%rbp), %rcx
leaq 0x2c1e(%rip), %rdi      # 0x4170
xorl %eax, %eax
movl %eax, %esi
leaq 0x33(%rip), %rdx        # 0x1590
callq 0x10c0
movq 0x2c07(%rip), %rdi      # 0x4170
xorl %eax, %eax
movl %eax, %esi
callq 0x1110
leaq 0xb3f(%rip), %rdi       # 0x20b8
movb $0x0, %al
callq 0x1070
movl -0x4(%rbp), %eax
addq $0x40, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/PARKINHYO[P]BlackjackGame/fifo/fifo_client.c
// Function: play_game
void* play_game(void* id)
{
	//recv_msg, send_msg 쓰레드 생성
	pthread_create(&threads[1], NULL, recv_msg, NULL);
	pthread_create(&threads[2], NULL, send_msg, NULL);
	int tid;
	for (tid = 1; tid < 2; ++tid)
		pthread_join(threads[tid], NULL);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
leaq 0x2bcd(%rip), %rdi      # 0x4170
addq $0x8, %rdi
xorl %eax, %eax
movl %eax, %ecx
leaq 0x24e(%rip), %rdx       # 0x1800
movq %rcx, %rsi
callq 0x10c0
leaq 0x2baf(%rip), %rdi      # 0x4170
addq $0x10, %rdi
xorl %eax, %eax
movl %eax, %ecx
leaq 0x50(%rip), %rdx        # 0x1620
movq %rcx, %rsi
callq 0x10c0
movl $0x1, -0x14(%rbp)
cmpl $0x2, -0x14(%rbp)
jge 0x1608
movslq -0x14(%rbp), %rcx
leaq 0x2b80(%rip), %rax      # 0x4170
movq (%rax,%rcx,8), %rdi
xorl %eax, %eax
movl %eax, %esi
callq 0x1110
movl -0x14(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x14(%rbp)
jmp 0x15df
movq -0x8(%rbp), %rax
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/eric-lo[P]3150/6-Memory/access_code.c
// Function: main
int main(void) {
	void *ptr = main;
	unsigned char c = *((unsigned char *) ptr);
	printf("Read  : 0x%x\n", c);
    printf("Read  : %p\n", ptr);
	printf("Write : \n");
	*((unsigned char *) ptr) = 0xff;
	printf("done\n");
	return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movl $0x0, -0x4(%rbp)
leaq -0x16(%rip), %rax       # 0x1140
movq %rax, -0x10(%rbp)
movq -0x10(%rbp), %rax
movb (%rax), %al
movb %al, -0x11(%rbp)
movzbl -0x11(%rbp), %esi
leaq 0xe96(%rip), %rdi       # 0x2004
movb $0x0, %al
callq 0x1030
movq -0x10(%rbp), %rsi
leaq 0xe92(%rip), %rdi       # 0x2012
movb $0x0, %al
callq 0x1030
leaq 0xe90(%rip), %rdi       # 0x201e
movb $0x0, %al
callq 0x1030
movq -0x10(%rbp), %rax
movb $-0x1, (%rax)
leaq 0xe85(%rip), %rdi       # 0x2028
movb $0x0, %al
callq 0x1030
xorl %eax, %eax
addq $0x20, %rsp
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O0/Tarsnap[P]libcperciva/tests/ipc_sync/main.c
// Function: main
int
main(int argc, char * argv[])
{
	int num;

	WARNP_INIT;

	/* Parse command-line argument. */
	if (argc != 2) {
		fprintf(stderr, "usage: test_ipc_sync NUM\n");
		exit(1);
	}
	if (PARSENUM(&num, argv[1], 0, sizeof(tests) / sizeof(tests[0]) - 1)) {
		warnp("parsenum");
		goto err0;
	}

	/* Run the specified test. */
	if (check(&tests[num]))
		goto err0;

	/* Success! */
	exit(0);

err0:
	/* Failure! */
	exit(1);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movl $0x0, -0x4(%rbp)
movl %edi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x10(%rbp), %rax
cmpq $0x0, (%rax)
je 0x131c
movq -0x10(%rbp), %rax
movq (%rax), %rdi
callq 0x20f0
jmp 0x131e
cmpl $0x2, -0x8(%rbp)
je 0x1346
movq 0x3ccd(%rip), %rax      # 0x4ff8
movq (%rax), %rdi
leaq 0x1cdb(%rip), %rsi      # 0x3010
movb $0x0, %al
callq 0x1130
movl $0x1, %edi
callq 0x11b0
callq 0x1070
movl $0x0, (%rax)
movl $0x1, -0x14(%rbp)
movl -0x14(%rbp), %eax
movl $0x2, %ecx
cltd
idivl %ecx
movl %eax, -0x14(%rbp)
cmpl $0x0, %eax
jle 0x138e
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rdi
xorps %xmm0, %xmm0
movsd 0x1c8a(%rip), %xmm1     # 0x3008
xorl %esi, %esi
callq 0x1480
cvttsd2si %xmm0, %eax
movl %eax, -0x14(%rbp)
jmp 0x1404
movl $0xffffffff, -0x14(%rbp) # imm = 0xFFFFFFFF
movb $0x1, %al
testb $0x1, %al
jne 0x139d
jmp 0x13d9
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rdi
movl -0x14(%rbp), %ecx
xorl %eax, %eax
cmpl $0x0, %ecx
cmovlel %eax, %eax
movslq %eax, %rsi
movl -0x14(%rbp), %ecx
xorl %eax, %eax
movl %eax, %edx
movl $0x7, %eax
cmpl $0x0, %ecx
cmovleq %rax, %rdx
xorl %r8d, %r8d
movl %r8d, %ecx
callq 0x1530
movl %eax, -0x14(%rbp)
movl %eax, -0x18(%rbp)
jmp 0x1401
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rdi
movslq -0x14(%rbp), %rcx
xorl %eax, %eax
movl %eax, %esi
movl $0x7, %edx
xorl %r9d, %r9d
movl %r9d, %r8d
callq 0x15f0
movl %eax, -0x14(%rbp)
xorl %eax, %eax
movl %eax, -0x18(%rbp)
movl -0x18(%rbp), %eax
callq 0x1070
cmpl $0x0, (%rax)
je 0x1447
jmp 0x1410
callq 0x1070
cmpl $0x0, (%rax)
je 0x1435
leaq 0x1c09(%rip), %rdi      # 0x302a
movb $0x0, %al
callq 0x21b0
callq 0x1070
movl $0x0, (%rax)
jmp 0x1443
leaq 0x1bee(%rip), %rdi      # 0x302a
movb $0x0, %al
callq 0x2400
jmp 0x1445
jmp 0x146c
movslq -0x14(%rbp), %rax
leaq 0x3cbe(%rip), %rdi      # 0x5110
imulq $0xc, %rax, %rax
addq %rax, %rdi
callq 0x16b0
cmpl $0x0, %eax
je 0x1465
jmp 0x146c
xorl %edi, %edi
callq 0x11b0
movl $0x1, %edi
callq 0x11b0
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/Tarsnap[P]libcperciva/tests/ipc_sync/main.c
// Function: check
static int
check(struct testcase * test)
{
	struct child_info CI_actual;
	struct child_info * CI = &CI_actual;
	struct ipc_sync * IS;
	pid_t pid;

	/* Initialize the synchronization. */
	if ((IS = ipc_sync_init()) == NULL)
		goto err0;

	/* Populate the child cookie. */
	CI->IS = IS;
	CI->wait = test->wait_in_child;
	CI->prep = test->prep_in_child;

	/* Fork. */
	if ((pid = fork_func(child, CI)) == -1)
		goto err0;
	PRINT_PID("post-fork parent");

	/* Wait or signal, optionally with a prep. */
	if (wait_or_signal(IS, !test->wait_in_child, test->prep_in_main))
		goto err0;

	/* Wait for the child to finish. */
	if (fork_func_wait(pid))
		goto err0;

	/* Clean up. */
	if (ipc_sync_done(IS))
		goto err0;

	/* Success! */
	return (0);

err0:
	/* Failure! */
	return (-1);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x10(%rbp)
leaq -0x20(%rbp), %rax
movq %rax, -0x28(%rbp)
callq 0x1b60
movq %rax, -0x30(%rbp)
cmpq $0x0, %rax
jne 0x16d8
jmp 0x1785
movq -0x30(%rbp), %rcx
movq -0x28(%rbp), %rax
movq %rcx, 0x8(%rax)
movq -0x10(%rbp), %rax
movl (%rax), %ecx
movq -0x28(%rbp), %rax
movl %ecx, (%rax)
movq -0x10(%rbp), %rax
movl 0x8(%rax), %ecx
movq -0x28(%rbp), %rax
movl %ecx, 0x4(%rax)
movq -0x28(%rbp), %rsi
leaq 0x97(%rip), %rdi        # 0x17a0
callq 0x19d0
movl %eax, -0x34(%rbp)
cmpl $-0x1, %eax
jne 0x1718
jmp 0x1785
callq 0x10c0
movslq %eax, %rsi
leaq 0x19ff(%rip), %rdi      # 0x3126
leaq 0x1a00(%rip), %rdx      # 0x312e
movb $0x0, %al
callq 0x10d0
movq -0x30(%rbp), %rdi
movq -0x10(%rbp), %rax
cmpl $0x0, (%rax)
setne %al
xorb $-0x1, %al
andb $0x1, %al
movzbl %al, %esi
movq -0x10(%rbp), %rax
movl 0x4(%rax), %edx
callq 0x1890
cmpl $0x0, %eax
je 0x175d
jmp 0x1785
movl -0x34(%rbp), %edi
callq 0x1a70
cmpl $0x0, %eax
je 0x176c
jmp 0x1785
movq -0x30(%rbp), %rdi
callq 0x1ec0
cmpl $0x0, %eax
je 0x177c
jmp 0x1785
movl $0x0, -0x4(%rbp)
jmp 0x178c
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
movl -0x4(%rbp), %eax
addq $0x40, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/Tarsnap[P]libcperciva/tests/ipc_sync/main.c
// Function: child
static int
child(void * cookie)
{
	struct child_info * ci = cookie;

	PRINT_PID("post-fork child");

	/* Wait or signal, optionally with a prep. */
	if (wait_or_signal(ci->IS, ci->wait, ci->prep))
		goto err1;

	/* Clean up. */
	if (ipc_sync_done(ci->IS))
		goto err0;

	/* Ensure that we've finished writing to stdout. */
	if (fflush(stdout)) {
		warnp("fflush");
		goto err0;
	}

	/* Success! */
	return (0);

err1:
	if (ipc_sync_done(ci->IS))
		goto err0;
err0:
	/* Failure! */
	return (-1);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x18(%rbp)
callq 0x10c0
movslq %eax, %rsi
leaq 0x1963(%rip), %rdi      # 0x3126
leaq 0x1975(%rip), %rdx      # 0x313f
movb $0x0, %al
callq 0x10d0
movq -0x18(%rbp), %rax
movq 0x8(%rax), %rdi
movq -0x18(%rbp), %rax
movl (%rax), %esi
movq -0x18(%rbp), %rax
movl 0x4(%rax), %edx
callq 0x1890
cmpl $0x0, %eax
je 0x17f2
jmp 0x185c
movq -0x18(%rbp), %rax
movq 0x8(%rax), %rdi
callq 0x1ec0
cmpl $0x0, %eax
je 0x1806
jmp 0x1872
movq 0x37cb(%rip), %rax      # 0x4fd8
movq (%rax), %rdi
callq 0x1150
cmpl $0x0, %eax
je 0x1853
jmp 0x181c
callq 0x1070
cmpl $0x0, (%rax)
je 0x1841
leaq 0x1922(%rip), %rdi      # 0x314f
movb $0x0, %al
callq 0x21b0
callq 0x1070
movl $0x0, (%rax)
jmp 0x184f
leaq 0x1907(%rip), %rdi      # 0x314f
movb $0x0, %al
callq 0x2400
jmp 0x1851
jmp 0x1872
movl $0x0, -0x4(%rbp)
jmp 0x1879
movq -0x18(%rbp), %rax
movq 0x8(%rax), %rdi
callq 0x1ec0
cmpl $0x0, %eax
je 0x1870
jmp 0x1872
jmp 0x1872
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
movl -0x4(%rbp), %eax
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/Tarsnap[P]libcperciva/tests/ipc_sync/main.c
// Function: wait_or_signal
static int
wait_or_signal(struct ipc_sync * ip, int which, int prep)
{

	/* Are we going to wait, or signal? */
	if (which) {
		/* If desired, prep for a wait. */
		if (prep) {
			PRINT_PID("_wait_prep");
			if (ipc_sync_wait_prep(ip))
				goto err0;
		}

		/* Wait. */
		PRINT_PID("_wait");
		if (ipc_sync_wait(ip))
			goto err0;
		PRINT_PID("finished _wait");
	} else {
		/* If desired, prep for a signal. */
		if (prep) {
			PRINT_PID("_signal_prep");
			if (ipc_sync_signal_prep(ip))
				goto err0;
		}

		/* Signal. */
		PRINT_PID("_signal");
		if (ipc_sync_signal(ip))
			goto err0;
		PRINT_PID("finished _signal");
	}

	/* Success! */
	return (0);

err0:
	/* Failure! */
	return (-1);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movl %esi, -0x14(%rbp)
movl %edx, -0x18(%rbp)
cmpl $0x0, -0x14(%rbp)
je 0x1933
cmpl $0x0, -0x18(%rbp)
je 0x18e4
callq 0x10c0
movslq %eax, %rsi
leaq 0x1865(%rip), %rdi      # 0x3126
leaq 0x188e(%rip), %rdx      # 0x3156
movb $0x0, %al
callq 0x10d0
movq -0x10(%rbp), %rdi
callq 0x1e80
cmpl $0x0, %eax
je 0x18e2
jmp 0x19bb
jmp 0x18e4
callq 0x10c0
movslq %eax, %rsi
leaq 0x1833(%rip), %rdi      # 0x3126
leaq 0x1870(%rip), %rdx      # 0x316a
movb $0x0, %al
callq 0x10d0
movq -0x10(%rbp), %rdi
callq 0x1c30
cmpl $0x0, %eax
je 0x1914
jmp 0x19bb
callq 0x10c0
movslq %eax, %rsi
leaq 0x1803(%rip), %rdi      # 0x3126
leaq 0x1837(%rip), %rdx      # 0x3161
movb $0x0, %al
callq 0x10d0
jmp 0x19b2
cmpl $0x0, -0x18(%rbp)
je 0x1968
callq 0x10c0
movslq %eax, %rsi
leaq 0x17de(%rip), %rdi      # 0x3126
leaq 0x1821(%rip), %rdx      # 0x3170
movb $0x0, %al
callq 0x10d0
movq -0x10(%rbp), %rdi
callq 0x1ea0
cmpl $0x0, %eax
je 0x1966
jmp 0x19bb
jmp 0x1968
callq 0x10c0
movslq %eax, %rsi
leaq 0x17af(%rip), %rdi      # 0x3126
leaq 0x1808(%rip), %rdx      # 0x3186
movb $0x0, %al
callq 0x10d0
movq -0x10(%rbp), %rdi
callq 0x1dc0
cmpl $0x0, %eax
je 0x1995
jmp 0x19bb
callq 0x10c0
movslq %eax, %rsi
leaq 0x1782(%rip), %rdi      # 0x3126
leaq 0x17d2(%rip), %rdx      # 0x317d
movb $0x0, %al
callq 0x10d0
movl $0x0, -0x4(%rbp)
jmp 0x19c2
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
movl -0x4(%rbp), %eax
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/umbrant[P]Non-blocking-Buffers/nbb.c
// Function: nbb_nameserver_connect
int nbb_nameserver_connect(const char* request, char** ret, int* ret_len)
{
  int nameserver_pid = 0;
  FILE* pFile;
  int retval;
  char* recv;
  size_t recv_len;

  // Sanity check to isolate errors faster
  assert(request != NULL && ret != NULL && ret_len != NULL);
  *ret = NULL;
  *ret_len = 0;

  // Should be reversed since what's written by service is read by nameserver
  if(nbb_open_channel(NULL, NAMESERVER_WRITE, NAMESERVER_READ, !IPC_CREAT)) {
    return -1;
  }

  pFile = fopen(NAMESERVER_PID_FILE, "r+"); 
  fscanf(pFile,"%d",&nameserver_pid); 
  fclose(pFile); 

  nbb_insert_item(0, request, strlen(request));
  kill(nameserver_pid, SIGUSR1);

  // Poll until we get something
  do{ 
    retval = nbb_read_item(0, (void**)&recv, &recv_len);
  } while (retval == BUFFER_EMPTY || retval == BUFFER_EMPTY_PRODUCER_INSERTING);

  // Set return values
  *ret = recv;
  *ret_len = recv_len;

  // No errors, we're happy
  return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x60, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movl $0x0, -0x24(%rbp)
cmpq $0x0, -0x10(%rbp)
je 0x1672
cmpq $0x0, -0x18(%rbp)
je 0x1672
cmpq $0x0, -0x20(%rbp)
je 0x1672
jmp 0x1691
leaq 0x2afe(%rip), %rdi      # 0x4177
leaq 0x2b29(%rip), %rsi      # 0x41a9
movl $0x1c, %edx
leaq 0x2b23(%rip), %rcx      # 0x41af
callq 0x10c0
movq -0x18(%rbp), %rax
movq $0x0, (%rax)
movq -0x20(%rbp), %rax
movl $0x0, (%rax)
xorl %eax, %eax
movl %eax, %edi
movl $0xfa0, %esi            # imm = 0xFA0
movl $0xfa1, %edx            # imm = 0xFA1
xorl %ecx, %ecx
callq 0x1790
cmpl $0x0, %eax
je 0x16cc
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
jmp 0x177a
leaq 0x342d(%rip), %rdi      # 0x4b00
leaq 0x2b0e(%rip), %rsi      # 0x41e8
callq 0x11a0
movq %rax, -0x30(%rbp)
movq -0x30(%rbp), %rdi
leaq 0x297c(%rip), %rsi      # 0x406a
leaq -0x24(%rbp), %rdx
movb $0x0, %al
callq 0x1050
movq -0x30(%rbp), %rdi
callq 0x1090
movq -0x10(%rbp), %rax
movq %rax, -0x50(%rbp)
movq -0x10(%rbp), %rdi
callq 0x10a0
movq -0x50(%rbp), %rsi
movq %rax, %rdx
xorl %edi, %edi
callq 0x1ae0
movl -0x24(%rbp), %edi
movl $0xa, %esi
callq 0x1150
xorl %edi, %edi
leaq -0x40(%rbp), %rsi
leaq -0x48(%rbp), %rdx
callq 0x1e60
movl %eax, -0x34(%rbp)
movb $0x1, %al
cmpl $0x3, -0x34(%rbp)
movb %al, -0x51(%rbp)
je 0x1755
cmpl $0x4, -0x34(%rbp)
sete %al
movb %al, -0x51(%rbp)
movb -0x51(%rbp), %al
testb $0x1, %al
jne 0x172e
movq -0x40(%rbp), %rcx
movq -0x18(%rbp), %rax
movq %rcx, (%rax)
movq -0x48(%rbp), %rax
movl %eax, %ecx
movq -0x20(%rbp), %rax
movl %ecx, (%rax)
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x60, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/umbrant[P]Non-blocking-Buffers/nbb.c
// Function: init_nameserver
int init_nameserver()
{
  FILE* pFile;

  // XXX: Initial semaphore value? Use 1 for now...
  sem_id = sem_open(SEM_KEY, O_CREAT, 0666, 1);
  if(sem_id == SEM_FAILED) {
    perror("! Unable to obtain semaphore\n");
    return -1;
  }

  if(nbb_open_channel(NULL, NAMESERVER_READ, NAMESERVER_WRITE, IPC_CREAT)) {
    printf("! Unable to open channel\n");
    return -1;
  }

  pFile = fopen(NAMESERVER_PID_FILE,"w+");
  fprintf(pFile,"%d",(int)getpid());
  fclose(pFile);

  return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
leaq 0x215c(%rip), %rdi      # 0x41eb
movl $0x40, %esi
movl $0x1b6, %edx            # imm = 0x1B6
movl $0x1, %ecx
movb $0x0, %al
callq 0x1110
movq %rax, 0x56b4(%rip)      # 0x7760
cmpq $0x0, 0x56ac(%rip)      # 0x7760
jne 0x20cb
leaq 0x2134(%rip), %rdi      # 0x41f1
callq 0x11b0
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
jmp 0x2147
xorl %eax, %eax
movl %eax, %edi
movl $0xfa1, %esi            # imm = 0xFA1
movl $0xfa0, %edx            # imm = 0xFA0
movl $0x200, %ecx            # imm = 0x200
callq 0x1790
cmpl $0x0, %eax
je 0x20ff
leaq 0x2120(%rip), %rdi      # 0x420f
movb $0x0, %al
callq 0x10b0
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
jmp 0x2147
leaq 0x29fa(%rip), %rdi      # 0x4b00
leaq 0x211c(%rip), %rsi      # 0x4229
callq 0x11a0
movq %rax, -0x10(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x18(%rbp)
callq 0x1080
movq -0x18(%rbp), %rdi
movl %eax, %edx
leaq 0x1f3a(%rip), %rsi      # 0x406a
movb $0x0, %al
callq 0x1120
movq -0x10(%rbp), %rdi
callq 0x1090
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x20, %rsp
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O0/umbrant[P]Non-blocking-Buffers/nbb.c
// Function: nbb_send
int nbb_send(const char* destination, const char* msg, size_t msg_len)
{
  int i;
  // int retval;

  printf("** dest: %s, msg: %s, msg_len: %d\n", destination, msg, (int) msg_len);
  assert(destination != NULL && msg != NULL);

  if (msg_len == 0) {
    printf("! nbb_send(): nothing to send (0 length passed in)\n");
    return 0;
  }

  // Since i = 0 is already reserved for nameserver
  for(i = 1; i < SERVICE_MAX_CHANNELS;i++) {
    if(channel_list[i].in_use && connected_nodes[i].name &&
       !strcmp(destination, connected_nodes[i].name)) {
      break;
    }
  }

  if(i == SERVICE_MAX_CHANNELS) {
    printf("! nbb_send(): Process not found\n");
    return -1;
  }

  nbb_insert_item(i, msg, msg_len); 
  kill(connected_nodes[i].pid, SIGUSR1);

  printf("** Send '%.*s' to %s\n", (int) msg_len, msg, destination);

  /* Not needed
  do { 
    retval = nbb_read_item(i, (void**)&recv, &recv_len);
  } while (retval == BUFFER_EMPTY || retval == BUFFER_EMPTY_PRODUCER_INSERTING); 

  if(strcmp(recv, NEW_CONN_NOTIFY_MSG)) {
    nbb_flush_shm(i, recv, recv_len);
  }

  printf("** Received '%.*s' from the service\n", (int) recv_len, recv);
*/

  return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movq -0x10(%rbp), %rsi
movq -0x18(%rbp), %rdx
movq -0x20(%rbp), %rax
movl %eax, %ecx
leaq 0x1af7(%rip), %rdi      # 0x4620
movb $0x0, %al
callq 0x10b0
cmpq $0x0, -0x10(%rbp)
je 0x2b40
cmpq $0x0, -0x18(%rbp)
je 0x2b40
jmp 0x2b5f
leaq 0x1afc(%rip), %rdi      # 0x4643
leaq 0x165b(%rip), %rsi      # 0x41a9
movl $0x11c, %edx            # imm = 0x11C
leaq 0x1b0c(%rip), %rcx      # 0x4666
callq 0x10c0
cmpq $0x0, -0x20(%rbp)
jne 0x2b80
leaq 0x1b2a(%rip), %rdi      # 0x4697
movb $0x0, %al
callq 0x10b0
movl $0x0, -0x4(%rbp)
jmp 0x2c5e
movl $0x1, -0x24(%rbp)
cmpl $0xf, -0x24(%rbp)
jge 0x2bef
movslq -0x24(%rbp), %rcx
leaq 0x45a8(%rip), %rax      # 0x7140
imulq $0x58, %rcx, %rcx
addq %rcx, %rax
cmpl $0x0, 0x50(%rax)
je 0x2be2
movslq -0x24(%rbp), %rcx
leaq 0x4ac0(%rip), %rax      # 0x7670
shlq $0x4, %rcx
addq %rcx, %rax
cmpq $0x0, (%rax)
je 0x2be2
movq -0x10(%rbp), %rdi
movslq -0x24(%rbp), %rcx
leaq 0x4aa4(%rip), %rax      # 0x7670
shlq $0x4, %rcx
addq %rcx, %rax
movq (%rax), %rsi
callq 0x1100
cmpl $0x0, %eax
jne 0x2be2
jmp 0x2bef
jmp 0x2be4
movl -0x24(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x24(%rbp)
jmp 0x2b87
cmpl $0xf, -0x24(%rbp)
jne 0x2c0c
leaq 0x1acf(%rip), %rdi      # 0x46cb
movb $0x0, %al
callq 0x10b0
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
jmp 0x2c5e
movl -0x24(%rbp), %edi
movq -0x18(%rbp), %rsi
movq -0x20(%rbp), %rdx
callq 0x1ae0
movslq -0x24(%rbp), %rcx
leaq 0x4a49(%rip), %rax      # 0x7670
shlq $0x4, %rcx
addq %rcx, %rax
movl 0x8(%rax), %edi
movl $0xa, %esi
callq 0x1150
movq -0x20(%rbp), %rax
movl %eax, %esi
movq -0x18(%rbp), %rdx
movq -0x10(%rbp), %rcx
leaq 0x1a9c(%rip), %rdi      # 0x46ec
movb $0x0, %al
callq 0x10b0
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x30, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/umbrant[P]Non-blocking-Buffers/nbb.c
// Function: nbb_set_cb_new_connection
void nbb_set_cb_new_connection(const char* owner, cb_new_conn_func func, void* arg)
{
  int i;

  // |arg| can be NULL
  assert(owner != NULL && func != NULL);

  for(i = 1;i < SERVICE_MAX_CHANNELS;i++) {
    if(!channel_list[i].in_use) {
      continue;
    }

    if(channel_list[i].owner && !strcmp(owner, channel_list[i].owner)) {
      channel_list[i].new_conn = func;
      channel_list[i].arg = arg;
      printf("***NBB***: Set new_conn callback for '%s'\n", owner);
    }
  }
}

// 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 0x2c94
cmpq $0x0, -0x10(%rbp)
je 0x2c94
jmp 0x2cb3
leaq 0x18bc(%rip), %rdi      # 0x4557
leaq 0x1507(%rip), %rsi      # 0x41a9
movl $0xf6, %edx
leaq 0x18c7(%rip), %rcx      # 0x4575
callq 0x10c0
movl $0x1, -0x1c(%rbp)
cmpl $0xf, -0x1c(%rbp)
jge 0x2d74
movslq -0x1c(%rbp), %rcx
leaq 0x4471(%rip), %rax      # 0x7140
imulq $0x58, %rcx, %rcx
addq %rcx, %rax
cmpl $0x0, 0x50(%rax)
jne 0x2ce1
jmp 0x2d66
movslq -0x1c(%rbp), %rcx
leaq 0x4454(%rip), %rax      # 0x7140
imulq $0x58, %rcx, %rcx
addq %rcx, %rax
cmpq $0x0, 0x30(%rax)
je 0x2d64
movq -0x8(%rbp), %rdi
movslq -0x1c(%rbp), %rcx
leaq 0x4437(%rip), %rax      # 0x7140
imulq $0x58, %rcx, %rcx
addq %rcx, %rax
movq 0x30(%rax), %rsi
callq 0x1100
cmpl $0x0, %eax
jne 0x2d64
movq -0x10(%rbp), %rcx
movslq -0x1c(%rbp), %rdx
leaq 0x4413(%rip), %rax      # 0x7140
imulq $0x58, %rdx, %rdx
addq %rdx, %rax
movq %rcx, 0x38(%rax)
movq -0x18(%rbp), %rcx
movslq -0x1c(%rbp), %rdx
leaq 0x43f9(%rip), %rax      # 0x7140
imulq $0x58, %rdx, %rdx
addq %rdx, %rax
movq %rcx, 0x48(%rax)
movq -0x8(%rbp), %rsi
leaq 0x185f(%rip), %rdi      # 0x45bc
movb $0x0, %al
callq 0x10b0
jmp 0x2d66
movl -0x1c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x1c(%rbp)
jmp 0x2cba
addq $0x20, %rsp
popq %rbp
retq
nopw (%rax,%rax)