LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O0/inolen[P]gdb_server/./sh4.h
// Function: sh4_arg_mask
static void ARG_MASK(const char *sig, char arg, uint16_t *mask,
                     uint16_t *shift) {
  int len = (int)strlen(sig);
  if (mask) {
    *mask = 0;
  }
  if (shift) {
    *shift = 0;
  }
  for (int i = 0; i < len; i++) {
    if ((!arg && sig[i] == '1') || (arg && sig[i] == arg)) {
      if (mask) {
        *mask |= (1 << (len - i - 1));
      }
      if (shift) {
        *shift = (uint16_t)(len - i - 1);
      }
    }
  }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movb %sil, %al
movq %rdi, -0x8(%rbp)
movb %al, -0x9(%rbp)
movq %rdx, -0x18(%rbp)
movq %rcx, -0x20(%rbp)
movq -0x8(%rbp), %rdi
callq 0x30a0
movl %eax, -0x24(%rbp)
cmpq $0x0, -0x18(%rbp)
je 0x7b66
movq -0x18(%rbp), %rax
movw $0x0, (%rax)
cmpq $0x0, -0x20(%rbp)
je 0x7b76
movq -0x20(%rbp), %rax
movw $0x0, (%rax)
movl $0x0, -0x28(%rbp)
movl -0x28(%rbp), %eax
cmpl -0x24(%rbp), %eax
jge 0x7c0c
cmpb $0x0, -0x9(%rbp)
jne 0x7ba0
movq -0x8(%rbp), %rax
movslq -0x28(%rbp), %rcx
movsbl (%rax,%rcx), %eax
cmpl $0x31, %eax
je 0x7bbd
movsbl -0x9(%rbp), %eax
cmpl $0x0, %eax
je 0x7bfc
movq -0x8(%rbp), %rax
movslq -0x28(%rbp), %rcx
movsbl (%rax,%rcx), %eax
movsbl -0x9(%rbp), %ecx
cmpl %ecx, %eax
jne 0x7bfc
cmpq $0x0, -0x18(%rbp)
je 0x7be0
movl -0x24(%rbp), %ecx
subl -0x28(%rbp), %ecx
subl $0x1, %ecx
movl $0x1, %edx
shll %cl, %edx
movq -0x18(%rbp), %rax
movzwl (%rax), %ecx
orl %edx, %ecx
movw %cx, (%rax)
cmpq $0x0, -0x20(%rbp)
je 0x7bfa
movl -0x24(%rbp), %eax
subl -0x28(%rbp), %eax
subl $0x1, %eax
movw %ax, %cx
movq -0x20(%rbp), %rax
movw %cx, (%rax)
jmp 0x7bfc
jmp 0x7bfe
movl -0x28(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x28(%rbp)
jmp 0x7b7d
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/inolen[P]gdb_server/./sh4.h
// Function: sh4_decode
int DECODE(uint16_t data, INSTR_T *instr) {
  INSTR_TYPE_T *type = instr_lookup[data];

  if (!type) {
    return 0;
  }

  instr->type = type;
  instr->rm = (data & type->rm_mask) >> type->rm_shift;
  instr->rn = (data & type->rn_mask) >> type->rn_shift;
  instr->disp = (data & type->disp_mask) >> type->disp_shift;
  instr->imm = (data & type->imm_mask) >> type->imm_shift;

  return 1;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movw %di, %ax
movw %ax, -0x6(%rbp)
movq %rsi, -0x10(%rbp)
movzwl -0x6(%rbp), %eax
movl %eax, %ecx
leaq 0x9504(%rip), %rax      # 0x11140
movq (%rax,%rcx,8), %rax
movq %rax, -0x18(%rbp)
cmpq $0x0, -0x18(%rbp)
jne 0x7c57
movl $0x0, -0x4(%rbp)
jmp 0x7cf5
movq -0x18(%rbp), %rcx
movq -0x10(%rbp), %rax
movq %rcx, (%rax)
movzwl -0x6(%rbp), %eax
movq -0x18(%rbp), %rcx
movzwl 0x20(%rcx), %ecx
andl %ecx, %eax
movq -0x18(%rbp), %rcx
movzwl 0x22(%rcx), %ecx
sarl %cl, %eax
movw %ax, %cx
movq -0x10(%rbp), %rax
movw %cx, 0xa(%rax)
movzwl -0x6(%rbp), %eax
movq -0x18(%rbp), %rcx
movzwl 0x24(%rcx), %ecx
andl %ecx, %eax
movq -0x18(%rbp), %rcx
movzwl 0x26(%rcx), %ecx
sarl %cl, %eax
movw %ax, %cx
movq -0x10(%rbp), %rax
movw %cx, 0xc(%rax)
movzwl -0x6(%rbp), %eax
movq -0x18(%rbp), %rcx
movzwl 0x1c(%rcx), %ecx
andl %ecx, %eax
movq -0x18(%rbp), %rcx
movzwl 0x1e(%rcx), %ecx
sarl %cl, %eax
movw %ax, %cx
movq -0x10(%rbp), %rax
movw %cx, 0xe(%rax)
movzwl -0x6(%rbp), %eax
movq -0x18(%rbp), %rcx
movzwl 0x18(%rcx), %ecx
andl %ecx, %eax
movq -0x18(%rbp), %rcx
movzwl 0x1a(%rcx), %ecx
sarl %cl, %eax
movw %ax, %cx
movq -0x10(%rbp), %rax
movw %cx, 0x10(%rax)
movl $0x1, -0x4(%rbp)
movl -0x4(%rbp), %eax
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/inolen[P]gdb_server/./gdb_server.h
// Function: gdb_server_create
gdb_server_t *gdb_server_create(gdb_target_t *target, int port) {
  if (!target) {
    return NULL;
  }

  gdb_server_t *sv = GDB_SERVER_MALLOC(sizeof(gdb_server_t));
  memset(sv, 0, sizeof(*sv));
  sv->target = target;
  sv->listen = INVALID_SOCKET;
  sv->client = INVALID_SOCKET;

  if (gdb_server_create_listen(sv, port) == -1) {
    GDB_SERVER_FREE(sv);
    sv = NULL;
  }

  return sv;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movl %esi, -0x14(%rbp)
cmpq $0x0, -0x10(%rbp)
jne 0x7d20
movq $0x0, -0x8(%rbp)
jmp 0x7d89
movl $0x40020, %edi          # imm = 0x40020
callq 0x3160
movq %rax, -0x20(%rbp)
movq -0x20(%rbp), %rdi
xorl %esi, %esi
movl $0x40020, %edx          # imm = 0x40020
callq 0x3100
movq -0x10(%rbp), %rcx
movq -0x20(%rbp), %rax
movq %rcx, (%rax)
movq -0x20(%rbp), %rax
movl $0xffffffff, 0x8(%rax)  # imm = 0xFFFFFFFF
movq -0x20(%rbp), %rax
movl $0xffffffff, 0xc(%rax)  # imm = 0xFFFFFFFF
movq -0x20(%rbp), %rdi
movl -0x14(%rbp), %esi
callq 0x7da0
cmpl $-0x1, %eax
jne 0x7d81
movq -0x20(%rbp), %rdi
callq 0x3030
movq $0x0, -0x20(%rbp)
movq -0x20(%rbp), %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/inolen[P]gdb_server/./gdb_server.h
// Function: gdb_server_send_packet
static int gdb_server_send_packet(gdb_server_t *sv, const char *data) {
  uint8_t cs = packet_data_checksum(data);

  // make sure the data won't overflow our buffer
  int length = (int)strlen(data);
  if (length > GDB_MAX_DATA_SIZE) {
    return -1;
  }

  snprintf(sv->conn.last_sent, sizeof(sv->conn.last_sent), "%c%s%c%02x",
           GDB_PACKET_BEGIN, data, GDB_PACKET_END, cs);

  return gdb_server_send_raw(sv, sv->conn.last_sent);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x18(%rbp), %rdi
callq 0x90d0
movb %al, -0x19(%rbp)
movq -0x18(%rbp), %rdi
callq 0x30a0
movl %eax, -0x20(%rbp)
cmpl $0x1fffb, -0x20(%rbp)   # imm = 0x1FFFB
jle 0x7f9a
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
jmp 0x7fed
movq -0x10(%rbp), %rdi
addq $0x10, %rdi
addq $0x20005, %rdi          # imm = 0x20005
movq -0x18(%rbp), %r8
movzbl -0x19(%rbp), %eax
movl $0x20000, %esi          # imm = 0x20000
leaq 0x3011(%rip), %rdx      # 0xafce
movl $0x24, %ecx
movl $0x23, %r9d
movl %eax, (%rsp)
movb $0x0, %al
callq 0x30e0
movq -0x10(%rbp), %rdi
movq -0x10(%rbp), %rsi
addq $0x10, %rsi
addq $0x20005, %rsi          # imm = 0x20005
callq 0x9130
movl %eax, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/inolen[P]gdb_server/./gdb_server.h
// Function: gdb_server_pump
void gdb_server_pump(gdb_server_t *sv) {
  const char *data = NULL;

  gdb_server_accept_client(sv);

  while ((data = gdb_server_recv_packet(sv))) {
    gdb_server_handle_packet(sv, data);
  }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq $0x0, -0x10(%rbp)
movq -0x8(%rbp), %rdi
callq 0x8050
movq -0x8(%rbp), %rdi
callq 0x81d0
movq %rax, -0x10(%rbp)
cmpq $0x0, %rax
je 0x803f
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
callq 0x8550
jmp 0x801d
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/inolen[P]gdb_server/./gdb_server.h
// Function: gdb_server_accept_client
static void gdb_server_accept_client(gdb_server_t *sv) {
  if (sv->listen == INVALID_SOCKET) {
    return;
  }

  // check to see if there is a pending connection
  fd_set fd_read;
  FD_ZERO(&fd_read);
  FD_SET(sv->listen, &fd_read);

  // return immediately
  struct timeval t;
  t.tv_sec = 0;
  t.tv_usec = 0;

  if (select(sv->listen + 1, &fd_read, NULL, NULL, &t) == SOCKET_ERROR) {
    return;
  }

  // no new connections
  if (!FD_ISSET(sv->listen, &fd_read)) {
    return;
  }

  // new connection, shut down the existing one and accept it
  if (sv->client != INVALID_SOCKET) {
    gdb_server_destroy_client(sv);
  }

  sv->client = accept(sv->listen, NULL, NULL);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0xb0, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
cmpl $-0x1, 0x8(%rax)
jne 0x806e
jmp 0x81b9
jmp 0x8070
leaq -0x88(%rbp), %rax
movq %rax, -0x98(%rbp)
movl $0x0, -0x8c(%rbp)
movl -0x8c(%rbp), %eax
cmpq $0x10, %rax
jae 0x80ba
movq -0x98(%rbp), %rax
movl -0x8c(%rbp), %ecx
movq $0x0, (%rax,%rcx,8)
movl -0x8c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x8c(%rbp)
jmp 0x8088
jmp 0x80bc
movq -0x8(%rbp), %rax
movl 0x8(%rax), %eax
movl $0x40, %ecx
cltd
idivl %ecx
movl %edx, %eax
movl %eax, %ecx
movl $0x1, %eax
shlq %cl, %rax
movq %rax, %rcx
movq -0x8(%rbp), %rax
movl 0x8(%rax), %eax
movl $0x40, %esi
cltd
idivl %esi
cltq
orq -0x88(%rbp,%rax,8), %rcx
movq %rcx, -0x88(%rbp,%rax,8)
movq $0x0, -0xa8(%rbp)
movq $0x0, -0xa0(%rbp)
movq -0x8(%rbp), %rax
movl 0x8(%rax), %edi
addl $0x1, %edi
leaq -0x88(%rbp), %rsi
xorl %eax, %eax
movl %eax, %ecx
leaq -0xa8(%rbp), %r8
movq %rcx, %rdx
callq 0x3140
cmpl $-0x1, %eax
jne 0x813c
jmp 0x81b9
movq -0x8(%rbp), %rax
movl 0x8(%rax), %eax
movl $0x40, %ecx
cltd
idivl %ecx
cltq
movq -0x88(%rbp,%rax,8), %rax
movq %rax, -0xb0(%rbp)
movq -0x8(%rbp), %rax
movl 0x8(%rax), %eax
movl $0x40, %ecx
cltd
idivl %ecx
movq -0xb0(%rbp), %rax
movl %edx, %ecx
movl $0x1, %edx
shlq %cl, %rdx
movq %rdx, %rcx
andq %rcx, %rax
cmpq $0x0, %rax
jne 0x818a
jmp 0x81b9
movq -0x8(%rbp), %rax
cmpl $-0x1, 0xc(%rax)
je 0x819d
movq -0x8(%rbp), %rdi
callq 0x8ea0
movq -0x8(%rbp), %rax
movl 0x8(%rax), %edi
xorl %eax, %eax
movl %eax, %edx
movq %rdx, %rsi
callq 0x31c0
movl %eax, %ecx
movq -0x8(%rbp), %rax
movl %ecx, 0xc(%rax)
addq $0xb0, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/inolen[P]gdb_server/sh4_server.c
// Function: sh4_server_init
void sh4_server_init(gdb_target_t *target, sh4_context_t *ctx) {
  target->ctx = ctx;
  target->endian = GDB_LITTLE_ENDIAN;
  target->num_regs = 59;
  target->stop = &server_stop;
  target->resume = &server_resume;
  target->step = &server_step;
  target->add_bp = &server_add_bp;
  target->rem_bp = &server_rem_bp;
  target->read_reg = &server_read_reg;
  target->read_mem = &server_read_mem;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x10(%rbp), %rcx
movq -0x8(%rbp), %rax
movq %rcx, (%rax)
movq -0x8(%rbp), %rax
movl $0x0, 0x8(%rax)
movq -0x8(%rbp), %rax
movl $0x3b, 0xc(%rax)
movq -0x8(%rbp), %rax
leaq 0x68(%rip), %rcx        # 0x88a0
movq %rcx, 0x10(%rax)
movq -0x8(%rbp), %rax
leaq 0x79(%rip), %rcx        # 0x88c0
movq %rcx, 0x18(%rax)
movq -0x8(%rbp), %rax
leaq 0x8a(%rip), %rcx        # 0x88e0
movq %rcx, 0x20(%rax)
movq -0x8(%rbp), %rax
leaq 0xbb(%rip), %rcx        # 0x8920
movq %rcx, 0x28(%rax)
movq -0x8(%rbp), %rax
leaq 0xdc(%rip), %rcx        # 0x8950
movq %rcx, 0x30(%rax)
movq -0x8(%rbp), %rax
leaq 0x13d(%rip), %rcx       # 0x89c0
movq %rcx, 0x40(%rax)
movq -0x8(%rbp), %rax
leaq 0x39e(%rip), %rcx       # 0x8c30
movq %rcx, 0x38(%rax)
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/inolen[P]gdb_server/sh4_server.c
// Function: server_step
static void server_step(void *data) {
  sh4_context_t *ctx = (sh4_context_t *)data;
  ctx->running = 1;

  uint32_t target = server_next_pc(ctx);
  add_temp_bp(ctx, target);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x10(%rbp)
movq -0x10(%rbp), %rax
movl $0x1, 0x15c(%rax)
movq -0x10(%rbp), %rdi
callq 0x9b70
movl %eax, -0x14(%rbp)
movq -0x10(%rbp), %rdi
movl -0x14(%rbp), %esi
callq 0x9c40
addq $0x20, %rsp
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O0/inolen[P]gdb_server/sh4_server.c
// Function: server_rem_bp
static void server_rem_bp(void *data, int type, intmax_t addr) {
  sh4_context_t *ctx = (sh4_context_t *)data;
  breakpoint_t *bp = find_bp(ctx, addr);
  assert(bp);
  rem_bp(ctx, bp);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x20(%rbp)
movq -0x20(%rbp), %rdi
movq -0x18(%rbp), %rax
movl %eax, %esi
callq 0x8cf0
movq %rax, -0x28(%rbp)
cmpq $0x0, -0x28(%rbp)
je 0x8987
jmp 0x89a6
leaq 0x16cd(%rip), %rdi      # 0xa05b
leaq 0x27cb(%rip), %rsi      # 0xb160
movl $0x6a, %edx
leaq 0x27f5(%rip), %rcx      # 0xb196
callq 0x30f0
movq -0x20(%rbp), %rdi
movq -0x28(%rbp), %rsi
callq 0x8d90
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/inolen[P]gdb_server/sh4_server.c
// Function: server_read_mem
static void server_read_mem(void *data, intmax_t addr, uint8_t *buffer, int size) {
  sh4_context_t *ctx = (sh4_context_t *)data;

  addr &= ctx->physical_mask;

  int available = ctx->physical_size - addr;
  if (available < 0) {
    available = 0;
  }

  if (size > available) {
    size = available;
  }

  memcpy(buffer, &ctx->physical_base[addr], size);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movl %ecx, -0x1c(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x28(%rbp)
movq -0x28(%rbp), %rax
movq 0x168(%rax), %rax
andq -0x10(%rbp), %rax
movq %rax, -0x10(%rbp)
movq -0x28(%rbp), %rax
movq 0x170(%rax), %rax
subq -0x10(%rbp), %rax
movl %eax, -0x2c(%rbp)
cmpl $0x0, -0x2c(%rbp)
jge 0x8c81
movl $0x0, -0x2c(%rbp)
movl -0x1c(%rbp), %eax
cmpl -0x2c(%rbp), %eax
jle 0x8c8f
movl -0x2c(%rbp), %eax
movl %eax, -0x1c(%rbp)
movq -0x18(%rbp), %rdi
movq -0x28(%rbp), %rax
movq 0x160(%rax), %rsi
addq -0x10(%rbp), %rsi
movslq -0x1c(%rbp), %rdx
callq 0x3130
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/inolen[P]gdb_server/sh4_server.c
// Function: find_bp
static breakpoint_t *find_bp(sh4_context_t *ctx, uint32_t addr) {
  for (int i = 0; i < ctx->num_bp; i++) {
    breakpoint_t *bp = &ctx->bp[i];

    if (bp->addr == addr) {
      return bp;
    }
  }

  return NULL;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x10(%rbp)
movl %esi, -0x14(%rbp)
movl $0x0, -0x18(%rbp)
movl -0x18(%rbp), %eax
movq -0x10(%rbp), %rcx
cmpl 0x180(%rcx), %eax
jge 0x8d4d
movq -0x10(%rbp), %rax
movq 0x178(%rax), %rax
movslq -0x18(%rbp), %rcx
imulq $0xc, %rcx, %rcx
addq %rcx, %rax
movq %rax, -0x20(%rbp)
movq -0x20(%rbp), %rax
movl (%rax), %eax
cmpl -0x14(%rbp), %eax
jne 0x8d40
movq -0x20(%rbp), %rax
movq %rax, -0x8(%rbp)
jmp 0x8d55
jmp 0x8d42
movl -0x18(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x18(%rbp)
jmp 0x8d02
movq $0x0, -0x8(%rbp)
movq -0x8(%rbp), %rax
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/inolen[P]gdb_server/sh4_server.c
// Function: rem_bp
static void rem_bp(sh4_context_t *ctx, breakpoint_t *bp) {
  int n = bp - ctx->bp;
  uint32_t addr = bp->addr & ctx->physical_mask;
  uint16_t data = bp->data;

  // shift and resize the breakpoints array
  for (int i = n; i < ctx->num_bp - 1; i++) {
    ctx->bp[i] = ctx->bp[i + 1];
  }
  ctx->bp = realloc(ctx->bp, sizeof(breakpoint_t) * --ctx->num_bp);

  // swap the original instructon back
  *(uint16_t *)&ctx->physical_base[addr] = data;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x10(%rbp), %rax
movq -0x8(%rbp), %rcx
movq 0x178(%rcx), %rcx
subq %rcx, %rax
movl $0xc, %ecx
cqto
idivq %rcx
movl %eax, -0x14(%rbp)
movq -0x10(%rbp), %rax
movl (%rax), %eax
movq -0x8(%rbp), %rcx
andq 0x168(%rcx), %rax
movl %eax, -0x18(%rbp)
movq -0x10(%rbp), %rax
movw 0x4(%rax), %ax
movw %ax, -0x1a(%rbp)
movl -0x14(%rbp), %eax
movl %eax, -0x20(%rbp)
movl -0x20(%rbp), %eax
movq -0x8(%rbp), %rcx
movl 0x180(%rcx), %ecx
subl $0x1, %ecx
cmpl %ecx, %eax
jge 0x8e41
movq -0x8(%rbp), %rax
movq 0x178(%rax), %rax
movslq -0x20(%rbp), %rcx
imulq $0xc, %rcx, %rcx
addq %rcx, %rax
movq -0x8(%rbp), %rcx
movq 0x178(%rcx), %rcx
movl -0x20(%rbp), %edx
addl $0x1, %edx
movslq %edx, %rdx
imulq $0xc, %rdx, %rdx
addq %rdx, %rcx
movq (%rcx), %rdx
movq %rdx, (%rax)
movl 0x8(%rcx), %ecx
movl %ecx, 0x8(%rax)
movl -0x20(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x20(%rbp)
jmp 0x8de5
movq -0x8(%rbp), %rax
movq 0x178(%rax), %rdi
movq -0x8(%rbp), %rcx
movl 0x180(%rcx), %eax
addl $-0x1, %eax
movl %eax, 0x180(%rcx)
cltq
imulq $0xc, %rax, %rsi
callq 0x3190
movq %rax, %rcx
movq -0x8(%rbp), %rax
movq %rcx, 0x178(%rax)
movw -0x1a(%rbp), %dx
movq -0x8(%rbp), %rax
movq 0x160(%rax), %rax
movl -0x18(%rbp), %ecx
movw %dx, (%rax,%rcx)
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/inolen[P]gdb_server/./gdb_server.h
// Function: gdb_server_destroy_client
static void gdb_server_destroy_client(gdb_server_t *sv) {
  if (sv->client == INVALID_SOCKET) {
    return;
  }

  shutdown(sv->client, SHUT_RDWR);
  sv->client = INVALID_SOCKET;

  memset(&sv->conn, 0, sizeof(sv->conn));
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
cmpl $-0x1, 0xc(%rax)
jne 0x8eb8
jmp 0x8ee8
movq -0x8(%rbp), %rax
movl 0xc(%rax), %edi
movl $0x2, %esi
callq 0x3090
movq -0x8(%rbp), %rax
movl $0xffffffff, 0xc(%rax)  # imm = 0xFFFFFFFF
movq -0x8(%rbp), %rdi
addq $0x10, %rdi
xorl %esi, %esi
movl $0x4000c, %edx          # imm = 0x4000C
callq 0x3100
addq $0x10, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/inolen[P]gdb_server/./gdb_server.h
// Function: gdb_server_data_available
static int gdb_server_data_available(gdb_server_t *sv) {
  if (sv->client == INVALID_SOCKET) {
    return 0;
  }

  fd_set fd_read;
  FD_ZERO(&fd_read);
  FD_SET(sv->client, &fd_read);

  // return immediately
  struct timeval t;
  t.tv_sec = 0;
  t.tv_usec = 0;

  if (select(sv->client + 1, &fd_read, NULL, NULL, &t) == SOCKET_ERROR) {
    return -1;
  }

  if (!FD_ISSET(sv->client, &fd_read)) {
    return 0;
  }

  return 1;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0xc0, %rsp
movq %rdi, -0x10(%rbp)
movq -0x10(%rbp), %rax
cmpl $-0x1, 0xc(%rax)
jne 0x8f15
movl $0x0, -0x4(%rbp)
jmp 0x9046
jmp 0x8f17
leaq -0x90(%rbp), %rax
movq %rax, -0xa0(%rbp)
movl $0x0, -0x94(%rbp)
movl -0x94(%rbp), %eax
cmpq $0x10, %rax
jae 0x8f61
movq -0xa0(%rbp), %rax
movl -0x94(%rbp), %ecx
movq $0x0, (%rax,%rcx,8)
movl -0x94(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x94(%rbp)
jmp 0x8f2f
jmp 0x8f63
movq -0x10(%rbp), %rax
movl 0xc(%rax), %eax
movl $0x40, %ecx
cltd
idivl %ecx
movl %edx, %eax
movl %eax, %ecx
movl $0x1, %eax
shlq %cl, %rax
movq %rax, %rcx
movq -0x10(%rbp), %rax
movl 0xc(%rax), %eax
movl $0x40, %esi
cltd
idivl %esi
cltq
orq -0x90(%rbp,%rax,8), %rcx
movq %rcx, -0x90(%rbp,%rax,8)
movq $0x0, -0xb0(%rbp)
movq $0x0, -0xa8(%rbp)
movq -0x10(%rbp), %rax
movl 0xc(%rax), %edi
addl $0x1, %edi
leaq -0x90(%rbp), %rsi
xorl %eax, %eax
movl %eax, %ecx
leaq -0xb0(%rbp), %r8
movq %rcx, %rdx
callq 0x3140
cmpl $-0x1, %eax
jne 0x8fea
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
jmp 0x9046
movq -0x10(%rbp), %rax
movl 0xc(%rax), %eax
movl $0x40, %ecx
cltd
idivl %ecx
cltq
movq -0x90(%rbp,%rax,8), %rax
movq %rax, -0xb8(%rbp)
movq -0x10(%rbp), %rax
movl 0xc(%rax), %eax
movl $0x40, %ecx
cltd
idivl %ecx
movq -0xb8(%rbp), %rax
movl %edx, %ecx
movl $0x1, %edx
shlq %cl, %rdx
movq %rdx, %rcx
andq %rcx, %rax
cmpq $0x0, %rax
jne 0x903f
movl $0x0, -0x4(%rbp)
jmp 0x9046
movl $0x1, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0xc0, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/inolen[P]gdb_server/./gdb_server.h
// Function: xtoi
static int xtoi(char c) {
  int i = -1;
  c = tolower(c);
  if (c >= 'a' && c <= 'f') {
    i = 0xa + (c - 'a');
  } else if (c >= '0' && c <= '9') {
    i = c - '0';
  }
  return i;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movb %dil, %al
movb %al, -0x1(%rbp)
movl $0xffffffff, -0x8(%rbp) # imm = 0xFFFFFFFF
movsbl -0x1(%rbp), %edi
callq 0x3150
movb %al, -0x1(%rbp)
movsbl -0x1(%rbp), %eax
cmpl $0x61, %eax
jl 0x90a2
movsbl -0x1(%rbp), %eax
cmpl $0x66, %eax
jg 0x90a2
movsbl -0x1(%rbp), %eax
subl $0x61, %eax
addl $0xa, %eax
movl %eax, -0x8(%rbp)
jmp 0x90c0
movsbl -0x1(%rbp), %eax
cmpl $0x30, %eax
jl 0x90be
movsbl -0x1(%rbp), %eax
cmpl $0x39, %eax
jg 0x90be
movsbl -0x1(%rbp), %eax
subl $0x30, %eax
movl %eax, -0x8(%rbp)
jmp 0x90c0
movl -0x8(%rbp), %eax
addq $0x10, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/inolen[P]gdb_server/./gdb_server.h
// Function: packet_data_checksum
static uint8_t packet_data_checksum(const char *data) {
  int checksum = 0;
  int len = (int)strlen(data);
  for (int i = 0; i < len; i++) {
    checksum += data[i];
  }
  return (uint8_t)(checksum % 256);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movl $0x0, -0xc(%rbp)
movq -0x8(%rbp), %rdi
callq 0x30a0
movl %eax, -0x10(%rbp)
movl $0x0, -0x14(%rbp)
movl -0x14(%rbp), %eax
cmpl -0x10(%rbp), %eax
jge 0x911b
movq -0x8(%rbp), %rax
movslq -0x14(%rbp), %rcx
movsbl (%rax,%rcx), %eax
addl -0xc(%rbp), %eax
movl %eax, -0xc(%rbp)
movl -0x14(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x14(%rbp)
jmp 0x90f6
movl -0xc(%rbp), %eax
movl $0x100, %ecx            # imm = 0x100
cltd
idivl %ecx
movb %dl, %al
addq $0x20, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/inolen[P]gdb_server/./gdb_server.h
// Function: gdb_server_send_raw
static int gdb_server_send_raw(gdb_server_t *sv, const char *data) {
  int len = (int)strlen(data);
  int n = send(sv->client, data, len, 0);

  if (n != len) {
    GDB_SERVER_LOG("gdb server failed to send raw packet %s, %d", data, n);
    return -1;
  }

  return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x18(%rbp), %rdi
callq 0x30a0
movl %eax, -0x1c(%rbp)
movq -0x10(%rbp), %rax
movl 0xc(%rax), %edi
movq -0x18(%rbp), %rsi
movslq -0x1c(%rbp), %rdx
xorl %ecx, %ecx
callq 0x30c0
movl %eax, -0x20(%rbp)
movl -0x20(%rbp), %eax
cmpl -0x1c(%rbp), %eax
je 0x918b
movq -0x18(%rbp), %rsi
movl -0x20(%rbp), %edx
leaq 0x1e26(%rip), %rdi      # 0xafa1
movb $0x0, %al
callq 0x30d0
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
jmp 0x9192
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/inolen[P]gdb_server/./gdb_server.h
// Function: gdb_server_handle_nack
static int gdb_server_handle_nack(gdb_server_t *sv, const char *data) {
  GDB_SERVER_ASSERT(!sv->conn.ack_disabled);

  // resend last packet
  gdb_server_send_raw(sv, sv->conn.last_sent);

  return 1;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rax
cmpl $0x0, 0x40018(%rax)
jne 0x920f
jmp 0x922e
leaq 0x1ddc(%rip), %rdi      # 0xaff2
leaq 0x1d15(%rip), %rsi      # 0xaf32
movl $0x27b, %edx            # imm = 0x27B
leaq 0x1e18(%rip), %rcx      # 0xb041
callq 0x30f0
movq -0x8(%rbp), %rdi
movq -0x8(%rbp), %rsi
addq $0x10, %rsi
addq $0x20005, %rsi          # imm = 0x20005
callq 0x9130
movl $0x1, %eax
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/inolen[P]gdb_server/./gdb_server.h
// Function: gdb_server_handle_int3
static int gdb_server_handle_int3(gdb_server_t *sv, const char *data) {
  // halt the target
  sv->target->stop(sv->target->ctx);

  // let the client know we've stopped
  gdb_server_interrupt(sv, GDB_SIGNAL_TRAP);

  return 1;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq (%rax), %rax
movq 0x10(%rax), %rax
movq -0x8(%rbp), %rcx
movq (%rcx), %rcx
movq (%rcx), %rdi
callq *%rax
movq -0x8(%rbp), %rdi
movl $0x5, %esi
callq 0x7f10
movl $0x1, %eax
addq $0x10, %rsp
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O0/inolen[P]gdb_server/./gdb_server.h
// Function: gdb_server_handle_c
static int gdb_server_handle_c(gdb_server_t *sv, const char *data) {
  int addr = 0;
  data = parse_hex(&data[1], &addr);

  if (addr != 0) {
    return 0;
  }

  sv->target->resume(sv->target->ctx);

  return 1;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movl $0x0, -0x1c(%rbp)
movq -0x18(%rbp), %rdi
addq $0x1, %rdi
leaq -0x1c(%rbp), %rsi
callq 0x98f0
movq %rax, -0x18(%rbp)
cmpl $0x0, -0x1c(%rbp)
je 0x92db
movl $0x0, -0x4(%rbp)
jmp 0x92f9
movq -0x10(%rbp), %rax
movq (%rax), %rax
movq 0x18(%rax), %rax
movq -0x10(%rbp), %rcx
movq (%rcx), %rcx
movq (%rcx), %rdi
callq *%rax
movl $0x1, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/inolen[P]gdb_server/./gdb_server.h
// Function: gdb_server_handle_g
static int gdb_server_handle_g(gdb_server_t *sv, const char *data) {
  char *buffer = scratch_buffer;
  int remaining = (int)sizeof(scratch_buffer);

  // read all registers
  for (int i = 0; i < sv->target->num_regs; i++) {
    // read the register
    intmax_t value = 0;
    int size = 0;
    sv->target->read_reg(sv->target->ctx, i, &value, &size);

    // format the register
    int n = format_register(value, size, sv->target->endian, buffer, remaining);
    buffer += n;
    remaining -= n;
  }

  // send the reply
  gdb_server_send_packet(sv, scratch_buffer);

  return 1;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
leaq 0x87e19(%rip), %rax     # 0x91140
movq %rax, -0x18(%rbp)
movl $0x1fffb, -0x1c(%rbp)   # imm = 0x1FFFB
movl $0x0, -0x20(%rbp)
movl -0x20(%rbp), %eax
movq -0x8(%rbp), %rcx
movq (%rcx), %rcx
cmpl 0xc(%rcx), %eax
jge 0x93c4
movq $0x0, -0x28(%rbp)
movl $0x0, -0x2c(%rbp)
movq -0x8(%rbp), %rax
movq (%rax), %rax
movq 0x40(%rax), %rax
movq -0x8(%rbp), %rcx
movq (%rcx), %rcx
movq (%rcx), %rdi
movl -0x20(%rbp), %esi
leaq -0x28(%rbp), %rdx
leaq -0x2c(%rbp), %rcx
callq *%rax
movq -0x28(%rbp), %rdi
movl -0x2c(%rbp), %esi
movq -0x8(%rbp), %rax
movq (%rax), %rax
movl 0x8(%rax), %edx
movq -0x18(%rbp), %rcx
movl -0x1c(%rbp), %r8d
callq 0x9960
movl %eax, -0x30(%rbp)
movl -0x30(%rbp), %ecx
movq -0x18(%rbp), %rax
movslq %ecx, %rcx
addq %rcx, %rax
movq %rax, -0x18(%rbp)
movl -0x30(%rbp), %ecx
movl -0x1c(%rbp), %eax
subl %ecx, %eax
movl %eax, -0x1c(%rbp)
movl -0x20(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x20(%rbp)
jmp 0x9339
movq -0x8(%rbp), %rdi
leaq 0x87d71(%rip), %rsi     # 0x91140
callq 0x7f60
movl $0x1, %eax
addq $0x30, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/inolen[P]gdb_server/./gdb_server.h
// Function: gdb_server_handle_H
static int gdb_server_handle_H(gdb_server_t *sv, const char *data) {
  // TODO proper thread support
  int op = data[1];
  GDB_SERVER_UNUSED(op);

  int thread = 0;
  data = parse_tid(&data[2], &thread);

  if (thread != -1 && thread != 0) {
    gdb_server_send_packet(sv, "E01");
  } else {
    gdb_server_send_packet(sv, "OK");
  }

  return 1;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x10(%rbp), %rax
movsbl 0x1(%rax), %eax
movl %eax, -0x14(%rbp)
movl $0x0, -0x18(%rbp)
movq -0x10(%rbp), %rdi
addq $0x2, %rdi
leaq -0x18(%rbp), %rsi
callq 0x9a50
movq %rax, -0x10(%rbp)
cmpl $-0x1, -0x18(%rbp)
je 0x9435
cmpl $0x0, -0x18(%rbp)
je 0x9435
movq -0x8(%rbp), %rdi
leaq 0x1c8c(%rip), %rsi      # 0xb0ba
callq 0x7f60
jmp 0x9445
movq -0x8(%rbp), %rdi
leaq 0x1c7e(%rip), %rsi      # 0xb0be
callq 0x7f60
movl $0x1, %eax
addq $0x20, %rsp
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O0/inolen[P]gdb_server/./gdb_server.h
// Function: gdb_server_handle_m
static int gdb_server_handle_m(gdb_server_t *sv, const char *data) {
  int addr = 0;
  data = parse_hex(&data[1], &addr);

  int length = 0;
  data = parse_hex(&data[1], &length);

  // read bytes from the target
  uint8_t *memory = alloca(length);
  memset(memory, 0, length);
  sv->target->read_mem(sv->target->ctx, addr, memory, length);

  // format bytes into response
  char *buffer = scratch_buffer;
  int remaining = (int)sizeof(scratch_buffer);
  GDB_SERVER_ASSERT((length * 2 + 1) < remaining);

  for (int i = 0; i < length; i++) {
    int n = snprintf(buffer, remaining, "%02x", memory[i]);
    GDB_SERVER_ASSERT(n);
    buffer += n;
    remaining -= n;
  }

  gdb_server_send_packet(sv, scratch_buffer);

  return 1;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl $0x0, -0x14(%rbp)
movq -0x10(%rbp), %rdi
incq %rdi
leaq -0x14(%rbp), %rsi
callq 0x98f0
movq %rax, -0x10(%rbp)
movl $0x0, -0x18(%rbp)
movq -0x10(%rbp), %rdi
incq %rdi
leaq -0x18(%rbp), %rsi
callq 0x98f0
movq %rax, -0x10(%rbp)
movslq -0x18(%rbp), %rcx
addq $0xf, %rcx
andq $-0x10, %rcx
movq %rsp, %rax
subq %rcx, %rax
movq %rax, %rsp
movq %rax, -0x20(%rbp)
movq -0x20(%rbp), %rdi
movslq -0x18(%rbp), %rdx
xorl %esi, %esi
callq 0x3100
movq -0x8(%rbp), %rax
movq (%rax), %rax
movq 0x38(%rax), %rax
movq -0x8(%rbp), %rcx
movq (%rcx), %rcx
movq (%rcx), %rdi
movslq -0x14(%rbp), %rsi
movq -0x20(%rbp), %rdx
movl -0x18(%rbp), %ecx
callq *%rax
leaq 0x87c59(%rip), %rax     # 0x91140
movq %rax, -0x28(%rbp)
movl $0x1fffb, -0x2c(%rbp)   # imm = 0x1FFFB
movl -0x18(%rbp), %eax
shll %eax
addl $0x1, %eax
cmpl -0x2c(%rbp), %eax
jge 0x9501
jmp 0x9520
leaq 0x1bbc(%rip), %rdi      # 0xb0c4
leaq 0x1a23(%rip), %rsi      # 0xaf32
movl $0x302, %edx            # imm = 0x302
leaq 0x1bc6(%rip), %rcx      # 0xb0e1
callq 0x30f0
movl $0x0, -0x30(%rbp)
movl -0x30(%rbp), %eax
cmpl -0x18(%rbp), %eax
jge 0x95a2
movq -0x28(%rbp), %rdi
movslq -0x2c(%rbp), %rsi
movq -0x20(%rbp), %rax
movslq -0x30(%rbp), %rcx
movzbl (%rax,%rcx), %ecx
leaq 0x1917(%rip), %rdx      # 0xae61
movb $0x0, %al
callq 0x30e0
movl %eax, -0x34(%rbp)
cmpl $0x0, -0x34(%rbp)
je 0x955c
jmp 0x957b
leaq 0x1b17(%rip), %rdi      # 0xb07a
leaq 0x19c8(%rip), %rsi      # 0xaf32
movl $0x306, %edx            # imm = 0x306
leaq 0x1b6b(%rip), %rcx      # 0xb0e1
callq 0x30f0
movl -0x34(%rbp), %ecx
movq -0x28(%rbp), %rax
movslq %ecx, %rcx
addq %rcx, %rax
movq %rax, -0x28(%rbp)
movl -0x34(%rbp), %ecx
movl -0x2c(%rbp), %eax
subl %ecx, %eax
movl %eax, -0x2c(%rbp)
movl -0x30(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x30(%rbp)
jmp 0x9527
movq -0x8(%rbp), %rdi
leaq 0x87b93(%rip), %rsi     # 0x91140
callq 0x7f60
movl $0x1, %eax
movq %rbp, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/inolen[P]gdb_server/./gdb_server.h
// Function: gdb_server_handle_p
static int gdb_server_handle_p(gdb_server_t *sv, const char *data) {
  int reg = 0;
  data = parse_hex(&data[1], &reg);

  // read the register
  intmax_t value = 0;
  int size = 0;
  sv->target->read_reg(sv->target->ctx, reg, &value, &size);

  // format the register
  format_register(value, size, sv->target->endian, scratch_buffer,
                  sizeof(scratch_buffer));

  // send the reply
  gdb_server_send_packet(sv, scratch_buffer);

  return 1;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl $0x0, -0x14(%rbp)
movq -0x10(%rbp), %rdi
addq $0x1, %rdi
leaq -0x14(%rbp), %rsi
callq 0x98f0
movq %rax, -0x10(%rbp)
movq $0x0, -0x20(%rbp)
movl $0x0, -0x24(%rbp)
movq -0x8(%rbp), %rax
movq (%rax), %rax
movq 0x40(%rax), %rax
movq -0x8(%rbp), %rcx
movq (%rcx), %rcx
movq (%rcx), %rdi
movl -0x14(%rbp), %esi
leaq -0x20(%rbp), %rdx
leaq -0x24(%rbp), %rcx
callq *%rax
movq -0x20(%rbp), %rdi
movl -0x24(%rbp), %esi
movq -0x8(%rbp), %rax
movq (%rax), %rax
movl 0x8(%rax), %edx
leaq 0x87b0b(%rip), %rcx     # 0x91140
movl $0x1fffb, %r8d          # imm = 0x1FFFB
callq 0x9960
movq -0x8(%rbp), %rdi
leaq 0x87af5(%rip), %rsi     # 0x91140
callq 0x7f60
movl $0x1, %eax
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/inolen[P]gdb_server/./gdb_server.h
// Function: gdb_server_handle_q
static int gdb_server_handle_q(gdb_server_t *sv, const char *data) {
  static query_handler_t query_handlers[] = {
      {"qAttached", gdb_server_handle_qAttached},
      {"qC", gdb_server_handle_qC},
      {"qfThreadInfo", gdb_server_handle_qfThreadInfo},
      {"qsThreadInfo", gdb_server_handle_qsThreadInfo},
  };

  static int num_query_handlers =
      (int)(sizeof(query_handlers) / sizeof(query_handler_t));

  // check to see if there is a handler registered for the incoming query
  int handled = 0;

  for (int i = 0; i < num_query_handlers; i++) {
    query_handler_t *handler = &query_handlers[i];

    if (!strcmp(data, handler->name)) {
      handler->callback(sv, data);
      handled = 1;
      break;
    }
  }

  return handled;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl $0x0, -0x14(%rbp)
movl $0x0, -0x18(%rbp)
movl -0x18(%rbp), %eax
cmpl 0x7a89(%rip), %eax      # 0x11110
jge 0x96dc
movslq -0x18(%rbp), %rcx
leaq 0x7a3c(%rip), %rax      # 0x110d0
shlq $0x4, %rcx
addq %rcx, %rax
movq %rax, -0x20(%rbp)
movq -0x10(%rbp), %rdi
movq -0x20(%rbp), %rax
movq (%rax), %rsi
callq 0x3110
cmpl $0x0, %eax
jne 0x96cf
movq -0x20(%rbp), %rax
movq 0x8(%rax), %rax
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
callq *%rax
movl $0x1, -0x14(%rbp)
jmp 0x96dc
jmp 0x96d1
movl -0x18(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x18(%rbp)
jmp 0x967e
movl -0x14(%rbp), %eax
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/inolen[P]gdb_server/./gdb_server.h
// Function: gdb_server_handle_s
static int gdb_server_handle_s(gdb_server_t *sv, const char *data) {
  int addr = 0;
  data = parse_hex(&data[1], &addr);

  if (addr != 0) {
    return 0;
  }

  sv->target->step(sv->target->ctx);

  return 1;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movl $0x0, -0x1c(%rbp)
movq -0x18(%rbp), %rdi
addq $0x1, %rdi
leaq -0x1c(%rbp), %rsi
callq 0x98f0
movq %rax, -0x18(%rbp)
cmpl $0x0, -0x1c(%rbp)
je 0x973b
movl $0x0, -0x4(%rbp)
jmp 0x9759
movq -0x10(%rbp), %rax
movq (%rax), %rax
movq 0x20(%rax), %rax
movq -0x10(%rbp), %rcx
movq (%rcx), %rcx
movq (%rcx), %rdi
callq *%rax
movl $0x1, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/inolen[P]gdb_server/./gdb_server.h
// Function: gdb_server_handle_z
static int gdb_server_handle_z(gdb_server_t *sv, const char *data) {
  int type = 0;
  data = parse_hex(&data[1], &type);

  int addr = 0;
  data = parse_hex(&data[1], &addr);

  int kind = 0;
  data = parse_hex(&data[1], &kind);
  GDB_SERVER_UNUSED(kind);

  sv->target->rem_bp(sv->target->ctx, type, addr);

  gdb_server_send_packet(sv, "OK");

  return 1;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl $0x0, -0x14(%rbp)
movq -0x10(%rbp), %rdi
addq $0x1, %rdi
leaq -0x14(%rbp), %rsi
callq 0x98f0
movq %rax, -0x10(%rbp)
movl $0x0, -0x18(%rbp)
movq -0x10(%rbp), %rdi
addq $0x1, %rdi
leaq -0x18(%rbp), %rsi
callq 0x98f0
movq %rax, -0x10(%rbp)
movl $0x0, -0x1c(%rbp)
movq -0x10(%rbp), %rdi
addq $0x1, %rdi
leaq -0x1c(%rbp), %rsi
callq 0x98f0
movq %rax, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq (%rax), %rax
movq 0x30(%rax), %rax
movq -0x8(%rbp), %rcx
movq (%rcx), %rcx
movq (%rcx), %rdi
movl -0x14(%rbp), %esi
movslq -0x18(%rbp), %rdx
callq *%rax
movq -0x8(%rbp), %rdi
leaq 0x18c1(%rip), %rsi      # 0xb0be
callq 0x7f60
movl $0x1, %eax
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/inolen[P]gdb_server/./gdb_server.h
// Function: gdb_server_handle_Z
static int gdb_server_handle_Z(gdb_server_t *sv, const char *data) {
  int type = 0;
  data = parse_hex(&data[1], &type);

  int addr = 0;
  data = parse_hex(&data[1], &addr);

  int kind = 0;
  data = parse_hex(&data[1], &kind);
  GDB_SERVER_UNUSED(kind);

  sv->target->add_bp(sv->target->ctx, type, addr);

  gdb_server_send_packet(sv, "OK");

  return 1;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl $0x0, -0x14(%rbp)
movq -0x10(%rbp), %rdi
addq $0x1, %rdi
leaq -0x14(%rbp), %rsi
callq 0x98f0
movq %rax, -0x10(%rbp)
movl $0x0, -0x18(%rbp)
movq -0x10(%rbp), %rdi
addq $0x1, %rdi
leaq -0x18(%rbp), %rsi
callq 0x98f0
movq %rax, -0x10(%rbp)
movl $0x0, -0x1c(%rbp)
movq -0x10(%rbp), %rdi
addq $0x1, %rdi
leaq -0x1c(%rbp), %rsi
callq 0x98f0
movq %rax, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq (%rax), %rax
movq 0x28(%rax), %rax
movq -0x8(%rbp), %rcx
movq (%rcx), %rcx
movq (%rcx), %rdi
movl -0x14(%rbp), %esi
movslq -0x18(%rbp), %rdx
callq *%rax
movq -0x8(%rbp), %rdi
leaq 0x1821(%rip), %rsi      # 0xb0be
callq 0x7f60
movl $0x1, %eax
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/inolen[P]gdb_server/./gdb_server.h
// Function: gdb_server_handle_question
static int gdb_server_handle_question(gdb_server_t *sv, const char *data) {
  // halt the target
  sv->target->stop(sv->target->ctx);

  // send the reply, letting gdb know we're halted
  gdb_server_interrupt(sv, GDB_SIGNAL_0);

  return 1;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq (%rax), %rax
movq 0x10(%rax), %rax
movq -0x8(%rbp), %rcx
movq (%rcx), %rcx
movq (%rcx), %rdi
callq *%rax
movq -0x8(%rbp), %rdi
xorl %esi, %esi
callq 0x7f10
movl $0x1, %eax
addq $0x10, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/inolen[P]gdb_server/./gdb_server.h
// Function: parse_hex
static const char *parse_hex(const char *buffer, int *value) {
  while (isxdigit(*buffer)) {
    *value <<= 4;
    *value |= xtoi(*buffer);
    buffer++;
  }
  return buffer;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
callq 0x31d0
movq (%rax), %rax
movq -0x8(%rbp), %rcx
movsbl (%rcx), %ecx
movslq %ecx, %rcx
movzwl (%rax,%rcx,2), %eax
andl $0x1000, %eax           # imm = 0x1000
cmpl $0x0, %eax
je 0x994f
movq -0x10(%rbp), %rax
movl (%rax), %ecx
shll $0x4, %ecx
movl %ecx, (%rax)
movq -0x8(%rbp), %rax
movsbl (%rax), %edi
callq 0x9060
movl %eax, %ecx
movq -0x10(%rbp), %rax
orl (%rax), %ecx
movl %ecx, (%rax)
movq -0x8(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x8(%rbp)
jmp 0x9900
movq -0x8(%rbp), %rax
addq $0x10, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/inolen[P]gdb_server/./gdb_server.h
// Function: format_register
static int format_register(intmax_t value, int width, endianness_t endian,
                           char *buffer, int size) {
  uint8_t *ptr = (uint8_t *)&value;
  int remaining = size;

  for (int i = 0; i < width; i++) {
    uint8_t c = endian == GDB_LITTLE_ENDIAN ? ptr[i] : ptr[width - 1 - i];
    int n = snprintf(buffer, remaining, "%02x", c);
    GDB_SERVER_ASSERT(n);
    buffer += n;
    remaining -= n;
  }

  return size - remaining;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movl %edx, -0x10(%rbp)
movq %rcx, -0x18(%rbp)
movl %r8d, -0x1c(%rbp)
leaq -0x8(%rbp), %rax
movq %rax, -0x28(%rbp)
movl -0x1c(%rbp), %eax
movl %eax, -0x2c(%rbp)
movl $0x0, -0x30(%rbp)
movl -0x30(%rbp), %eax
cmpl -0xc(%rbp), %eax
jge 0x9a3d
cmpl $0x0, -0x10(%rbp)
jne 0x99b2
movq -0x28(%rbp), %rax
movslq -0x30(%rbp), %rcx
movzbl (%rax,%rcx), %eax
movl %eax, -0x3c(%rbp)
jmp 0x99c9
movq -0x28(%rbp), %rax
movl -0xc(%rbp), %ecx
subl $0x1, %ecx
subl -0x30(%rbp), %ecx
movslq %ecx, %rcx
movzbl (%rax,%rcx), %eax
movl %eax, -0x3c(%rbp)
movl -0x3c(%rbp), %eax
movb %al, -0x31(%rbp)
movq -0x18(%rbp), %rdi
movslq -0x2c(%rbp), %rsi
movzbl -0x31(%rbp), %ecx
leaq 0x147f(%rip), %rdx      # 0xae61
movb $0x0, %al
callq 0x30e0
movl %eax, -0x38(%rbp)
cmpl $0x0, -0x38(%rbp)
je 0x99f4
jmp 0x9a13
leaq 0x167f(%rip), %rdi      # 0xb07a
leaq 0x1530(%rip), %rsi      # 0xaf32
movl $0x112, %edx            # imm = 0x112
leaq 0x166e(%rip), %rcx      # 0xb07c
callq 0x30f0
movl -0x38(%rbp), %ecx
movq -0x18(%rbp), %rax
movslq %ecx, %rcx
addq %rcx, %rax
movq %rax, -0x18(%rbp)
movl -0x38(%rbp), %ecx
movl -0x2c(%rbp), %eax
subl %ecx, %eax
movl %eax, -0x2c(%rbp)
movl -0x30(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x30(%rbp)
jmp 0x998f
movl -0x1c(%rbp), %eax
subl -0x2c(%rbp), %eax
addq $0x40, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/inolen[P]gdb_server/./gdb_server.h
// Function: parse_tid
static const char *parse_tid(const char *buffer, int *value) {
  if (!strncmp(buffer, "-1", 2)) {
    *value = -1;
    return buffer + 2;
  }

  return parse_hex(buffer, value);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x10(%rbp), %rdi
leaq 0x1656(%rip), %rsi      # 0xb0c1
movl $0x2, %edx
callq 0x3050
cmpl $0x0, %eax
jne 0x9a92
movq -0x18(%rbp), %rax
movl $0xffffffff, (%rax)     # imm = 0xFFFFFFFF
movq -0x10(%rbp), %rax
addq $0x2, %rax
movq %rax, -0x8(%rbp)
jmp 0x9aa3
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rsi
callq 0x98f0
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/inolen[P]gdb_server/sh4_server.c
// Function: server_next_pc
static uint32_t server_next_pc(sh4_context_t *ctx) {
  sh4_context_t copy;
  memcpy(&copy, ctx, sizeof(copy));

  uint32_t addr = ctx->pc & ctx->physical_mask;
  uint16_t data = *(uint16_t *)&ctx->physical_base[addr];
  sh4_instr_t instr;
  assert(sh4_decode(data, &instr));

  // if the current instruction is a branch, simulate it to get the next pc.
  // this is assuming the branch instructions won't modify any other global
  // state
  if (instr.type->flags & FLAG_BRANCH) {
    instr.type->fn(&copy, &instr);
  }

  return copy.pc + 2;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x1b0, %rsp            # imm = 0x1B0
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rsi
leaq -0x190(%rbp), %rdi
movl $0x188, %edx            # imm = 0x188
callq 0x3130
movq -0x8(%rbp), %rax
movl 0x4(%rax), %eax
movq -0x8(%rbp), %rcx
andq 0x168(%rcx), %rax
movl %eax, -0x194(%rbp)
movq -0x8(%rbp), %rax
movq 0x160(%rax), %rax
movl -0x194(%rbp), %ecx
movw (%rax,%rcx), %ax
movw %ax, -0x196(%rbp)
leaq -0x1b0(%rbp), %rsi
movzwl -0x196(%rbp), %edi
callq 0x7c20
cmpl $0x0, %eax
je 0x9be2
jmp 0x9c01
leaq 0x155e(%rip), %rdi      # 0xb147
leaq 0x1570(%rip), %rsi      # 0xb160
movl $0x44, %edx
leaq 0x1571(%rip), %rcx      # 0xb16d
callq 0x30f0
movq -0x1b0(%rbp), %rax
movl 0x4(%rax), %eax
andl $0x2, %eax
cmpl $0x0, %eax
je 0x9c2b
movq -0x1b0(%rbp), %rax
leaq -0x190(%rbp), %rdi
leaq -0x1b0(%rbp), %rsi
callq *0x10(%rax)
movl -0x18c(%rbp), %eax
addl $0x2, %eax
addq $0x1b0, %rsp            # imm = 0x1B0
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/inolen[P]gdb_server/sh4_server.c
// Function: add_bp
static breakpoint_t *add_bp(sh4_context_t *ctx, uint32_t addr) {
  int n = ctx->num_bp;
  addr &= ctx->physical_mask;

  // resize the breakpoints array
  ctx->bp = realloc(ctx->bp, sizeof(breakpoint_t) * ++ctx->num_bp);

  // setup the new breakpoint
  breakpoint_t *bp = &ctx->bp[n];
  bp->addr = addr;
  bp->data = *(uint16_t *)&ctx->physical_base[addr];
  bp->temp = 0;

  // write out invalid opcode to the program
  *(uint16_t *)&ctx->physical_base[addr] = 0;

  return bp;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movq -0x8(%rbp), %rax
movl 0x180(%rax), %eax
movl %eax, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq 0x168(%rax), %rcx
movl -0xc(%rbp), %eax
andq %rcx, %rax
movl %eax, -0xc(%rbp)
movq -0x8(%rbp), %rax
movq 0x178(%rax), %rdi
movq -0x8(%rbp), %rcx
movl 0x180(%rcx), %eax
addl $0x1, %eax
movl %eax, 0x180(%rcx)
cltq
imulq $0xc, %rax, %rsi
callq 0x3190
movq %rax, %rcx
movq -0x8(%rbp), %rax
movq %rcx, 0x178(%rax)
movq -0x8(%rbp), %rax
movq 0x178(%rax), %rax
movslq -0x10(%rbp), %rcx
imulq $0xc, %rcx, %rcx
addq %rcx, %rax
movq %rax, -0x18(%rbp)
movl -0xc(%rbp), %ecx
movq -0x18(%rbp), %rax
movl %ecx, (%rax)
movq -0x8(%rbp), %rax
movq 0x160(%rax), %rax
movl -0xc(%rbp), %ecx
movw (%rax,%rcx), %cx
movq -0x18(%rbp), %rax
movw %cx, 0x4(%rax)
movq -0x18(%rbp), %rax
movl $0x0, 0x8(%rax)
movq -0x8(%rbp), %rax
movq 0x160(%rax), %rax
movl -0xc(%rbp), %ecx
movw $0x0, (%rax,%rcx)
movq -0x18(%rbp), %rax
addq $0x20, %rsp
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O0/KhuramAli[P]JAM-Benchmark/Single-Producer_Single-Consumer_RingBuffer_Lock-Synchronized_boost/code09.cpp
// Function: producer()
void producer(void)
{
	for (int i = 0; i != iterations; ++i) {
		int value = ++producer_count;
		myMutex.lock();
		cb.push_back(value);
		myMutex.unlock();
	}
}

// Assembly:
pushq %rax
movl $0x0, 0x4(%rsp)
cmpl $0x989680, 0x4(%rsp)    # imm = 0x989680
je 0x23d9
movl 0x4d6b(%rip), %eax      # 0x7104
addl $0x1, %eax
movl %eax, 0x4d62(%rip)      # 0x7104
movl %eax, (%rsp)
leaq 0x4d8c(%rip), %rdi      # 0x7138
callq 0x2700
leaq 0x4d58(%rip), %rdi      # 0x7110
movq %rsp, %rsi
callq 0x2730
leaq 0x4d71(%rip), %rdi      # 0x7138
callq 0x2760
movl 0x4(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x4(%rsp)
jmp 0x2389
popq %rax
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/KhuramAli[P]JAM-Benchmark/Single-Producer_Single-Consumer_RingBuffer_Lock-Synchronized_boost/code09.cpp
// Function: consumer()
void consumer(void)
{
	while (!done) {
		myMutex.lock();
		if(!cb.empty()){
			cb.pop_front();
			++consumer_count;
		}
		myMutex.unlock();
	}
}

// Assembly:
pushq %rax
jmp 0x23e3
movb 0x4d77(%rip), %al       # 0x7160
xorb $-0x1, %al
testb $0x1, %al
jne 0x23f1
jmp 0x2436
leaq 0x4d40(%rip), %rdi      # 0x7138
callq 0x2700
leaq 0x4d0c(%rip), %rdi      # 0x7110
callq 0x2770
testb $0x1, %al
jne 0x2428
leaq 0x4cfc(%rip), %rdi      # 0x7110
callq 0x2790
movl 0x4ce9(%rip), %eax      # 0x7108
addl $0x1, %eax
movl %eax, 0x4ce0(%rip)      # 0x7108
leaq 0x4d09(%rip), %rdi      # 0x7138
callq 0x2760
jmp 0x23e3
popq %rax
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/KhuramAli[P]JAM-Benchmark/Single-Producer_Single-Consumer_RingBuffer_Lock-Synchronized_boost/code09.cpp
// Function: main
int main(int argc, char* argv[])
{
	std::thread producer_thread(producer);
	std::thread consumer_thread(consumer);

	producer_thread.join();

	done = true;
	consumer_thread.join();

	std::cout << "produced " << producer_count << " objects." << std::endl;
	std::cout << "consumed " << consumer_count << " objects." << std::endl;
}

// Assembly:
subq $0x68, %rsp
movl %edi, 0x64(%rsp)
movq %rsi, 0x58(%rsp)
leaq -0xd4(%rip), %rsi       # 0x2380
leaq 0x50(%rsp), %rdi
callq 0x27e0
leaq -0x85(%rip), %rsi       # 0x23e0
leaq 0x48(%rsp), %rdi
callq 0x27e0
jmp 0x2471
leaq 0x50(%rsp), %rdi
callq 0x2180
jmp 0x247d
movb $0x1, 0x4cdc(%rip)      # 0x7160
leaq 0x48(%rsp), %rdi
callq 0x2180
jmp 0x2490
movq 0x4b41(%rip), %rdi      # 0x6fd8
leaq 0x1b66(%rip), %rsi      # 0x4004
callq 0x2100
movq %rax, 0x30(%rsp)
jmp 0x24aa
movq 0x30(%rsp), %rdi
movl 0x4c4f(%rip), %esi      # 0x7104
callq 0x21a0
movq %rax, 0x28(%rsp)
jmp 0x24c1
movq 0x28(%rsp), %rdi
leaq 0x1b41(%rip), %rsi      # 0x400e
callq 0x2100
movq %rax, 0x20(%rsp)
jmp 0x24d9
movq 0x20(%rsp), %rdi
movq 0x4ad3(%rip), %rsi      # 0x6fb8
callq 0x2130
jmp 0x24ec
movq 0x4ae5(%rip), %rdi      # 0x6fd8
leaq 0x1b1e(%rip), %rsi      # 0x4018
callq 0x2100
movq %rax, 0x18(%rsp)
jmp 0x2506
movq 0x18(%rsp), %rdi
movl 0x4bf7(%rip), %esi      # 0x7108
callq 0x21a0
movq %rax, 0x10(%rsp)
jmp 0x251d
movq 0x10(%rsp), %rdi
leaq 0x1ae5(%rip), %rsi      # 0x400e
callq 0x2100
movq %rax, 0x8(%rsp)
jmp 0x2535
movq 0x8(%rsp), %rdi
movq 0x4a77(%rip), %rsi      # 0x6fb8
callq 0x2130
jmp 0x2548
leaq 0x48(%rsp), %rdi
callq 0x28a0
leaq 0x50(%rsp), %rdi
callq 0x28a0
xorl %eax, %eax
addq $0x68, %rsp
retq
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x40(%rsp)
movl %eax, 0x3c(%rsp)
jmp 0x258b
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x40(%rsp)
movl %eax, 0x3c(%rsp)
leaq 0x48(%rsp), %rdi
callq 0x28a0
leaq 0x50(%rsp), %rdi
callq 0x28a0
movq 0x40(%rsp), %rdi
callq 0x21b0
nop