LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O2/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 %rsi, (%rdi)
movabsq $0x3b00000000, %rax     # imm = 0x3B00000000
movq %rax, 0x8(%rdi)
leaq 0x48(%rip), %rax        # 0x5ada
movq %rax, 0x10(%rdi)
leaq 0x4a(%rip), %rax        # 0x5ae7
movq %rax, 0x18(%rdi)
leaq 0x4f(%rip), %rax        # 0x5af7
movq %rax, 0x20(%rdi)
leaq 0xe9(%rip), %rax        # 0x5b9c
movq %rax, 0x28(%rdi)
leaq 0xea(%rip), %rax        # 0x5ba8
movq %rax, 0x30(%rdi)
leaq 0x122(%rip), %rax       # 0x5beb
movq %rax, 0x40(%rdi)
leaq 0x21b(%rip), %rax       # 0x5cef
movq %rax, 0x38(%rdi)
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/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
pushq %rbx
subq $0x1a8, %rsp            # imm = 0x1A8
movq %rdi, %rbx
movl $0x1, 0x15c(%rdi)
leaq -0x1a8(%rbp), %rdi
movl $0x188, %edx            # imm = 0x188
movq %rbx, %rsi
callq 0x3130
movl 0x4(%rbx), %eax
andl 0x168(%rbx), %eax
movq 0x160(%rbx), %rcx
movzwl (%rcx,%rax), %edi
leaq -0x20(%rbp), %rsi
callq 0x5097
testl %eax, %eax
je 0x5b7f
movq -0x20(%rbp), %rax
testb $0x2, 0x4(%rax)
je 0x5b5d
leaq -0x1a8(%rbp), %rdi
leaq -0x20(%rbp), %rsi
callq *0x10(%rax)
movl -0x1a4(%rbp), %esi
addl $0x2, %esi
movq %rbx, %rdi
callq 0x6175
movl $0x1, 0x8(%rax)
addq $0x1a8, %rsp            # imm = 0x1A8
popq %rbx
popq %rbp
retq
leaq 0x2589(%rip), %rdi      # 0x810f
leaq 0x259b(%rip), %rsi      # 0x8128
leaq 0x25a1(%rip), %rcx      # 0x8135
pushq $0x44
popq %rdx
callq 0x30e0
// File: /workspace/github_c_makefile_star2_O2/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
pushq %rbx
pushq %rax
movq %rdi, %rbx
movl %edx, %esi
callq 0x5d2f
testq %rax, %rax
je 0x5bce
movq %rbx, %rdi
movq %rax, %rsi
addq $0x8, %rsp
popq %rbx
popq %rbp
jmp 0x5d77
leaq 0x144b(%rip), %rdi      # 0x7020
leaq 0x254c(%rip), %rsi      # 0x8128
leaq 0x257b(%rip), %rcx      # 0x815e
pushq $0x6a
popq %rdx
callq 0x30e0
// File: /workspace/github_c_makefile_star2_O2/inolen[P]gdb_server/sh4_server.c
// Function: server_read_reg
static void server_read_reg(void *data, int n, intmax_t *value, int *size) {
  sh4_context_t *ctx = (sh4_context_t *)data;

  if (n < 16) {
    *value = ctx->r[n];
  } else if (n == 16) {
    *value = ctx->pc;
  } else if (n == 17) {
    *value = ctx->pr;
  } else if (n == 18) {
    *value = ctx->gbr;
  } else if (n == 19) {
    *value = ctx->vbr;
  } else if (n == 20) {
    *value = ctx->mach;
  } else if (n == 21) {
    *value = ctx->macl;
  } else if (n == 22) {
    *value = ctx->sr;
  } else if (n == 23) {
    *value = ctx->fpul;
  } else if (n == 24) {
    *value = ctx->fpscr;
  } else if (n < 41) {
    *value = ctx->fr[n - 25];
  } else if (n == 41) {
    *value = ctx->ssr;
  } else if (n == 42) {
    *value = ctx->spc;
  } else if (n < 51) {
    uint32_t *b0 = (ctx->sr & RB) ? ctx->ralt : ctx->r;
    *value = b0[n - 43];
  } else if (n < 59) {
    uint32_t *b1 = (ctx->sr & RB) ? ctx->r : ctx->ralt;
    *value = b1[n - 51];
  }

  *size = 4;
}

// Assembly:
cmpl $0xf, %esi
jg 0x5c0c
movslq %esi, %rax
leaq (%rdi,%rax,4), %rdi
addq $0x20, %rdi
pushq %rbp
movq %rsp, %rbp
movl (%rdi), %eax
movq %rax, (%rdx)
popq %rbp
movl $0x4, (%rcx)
retq
leal -0x10(%rsi), %eax
cmpl $0x8, %eax
ja 0x5c63
leaq 0x2275(%rip), %rsi      # 0x7e90
movslq (%rsi,%rax,4), %rax
addq %rsi, %rax
jmpq *%rax
addq $0x4, %rdi
jmp 0x5bfb
addq $0x18, %rdi
jmp 0x5bfb
addq $0x10, %rdi
jmp 0x5bfb
addq $0x14, %rdi
jmp 0x5bfb
addq $0x104, %rdi            # imm = 0x104
jmp 0x5bfb
addq $0xc, %rdi
jmp 0x5bfb
addq $0x1c, %rdi
jmp 0x5bfb
addq $0x14c, %rdi            # imm = 0x14C
jmp 0x5bfb
addq $0x158, %rdi            # imm = 0x158
jmp 0x5bfb
cmpl $0x28, %esi
ja 0x5c78
addl $-0x19, %esi
leaq (%rdi,%rsi,4), %rdi
addq $0x84, %rdi
jmp 0x5bfb
cmpl $0x2a, %esi
je 0x5c8e
cmpl $0x29, %esi
jne 0x5c97
addq $0x150, %rdi            # imm = 0x150
jmp 0x5bfb
addq $0x8, %rdi
jmp 0x5bfb
cmpl $0x32, %esi
ja 0x5cc2
movb 0x14f(%rdi), %al
andb $0x20, %al
shrb $0x5, %al
movzbl %al, %eax
shll $0x6, %eax
addq %rdi, %rax
movl %esi, %esi
leaq (%rax,%rsi,4), %rdi
addq $-0x8c, %rdi
jmp 0x5bfb
cmpl $0x3a, %esi
ja 0x5c05
xorl %eax, %eax
testb $0x20, 0x14f(%rdi)
sete %al
shll $0x6, %eax
addq %rdi, %rax
movl %esi, %esi
leaq (%rax,%rsi,4), %rdi
addq $-0xac, %rdi
jmp 0x5bfb
// File: /workspace/github_c_makefile_star2_O2/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
movl 0x180(%rdi), %ecx
xorl %eax, %eax
testl %ecx, %ecx
cmovlel %eax, %ecx
imulq $0xc, %rcx, %rcx
movabsq $-0xc, %rdx
leaq 0xc(%rdx), %r8
cmpq %r8, %rcx
je 0x5d6e
movq 0x178(%rdi), %r9
cmpl %esi, 0xc(%r9,%rdx)
movq %r8, %rdx
jne 0x5d4e
addq %r8, %r9
movq %r9, %rax
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/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
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
movq %rsi, %rax
subq 0x178(%rdi), %rax
pushq $0xc
popq %rcx
cqto
idivq %rcx
movl (%rsi), %r14d
movq 0x168(%rdi), %rcx
movzwl 0x4(%rsi), %r15d
cltq
imulq $0xc, %rax, %rdx
movslq 0x180(%rbx), %rsi
decq %rsi
cmpq %rsi, %rax
jge 0x5ddb
movq 0x178(%rbx), %rsi
incq %rax
movl 0x14(%rsi,%rdx), %edi
movl %edi, 0x8(%rsi,%rdx)
movq 0xc(%rsi,%rdx), %rdi
movq %rdi, (%rsi,%rdx)
addq $0xc, %rdx
jmp 0x5dab
andl %ecx, %r14d
movq 0x178(%rbx), %rdi
movl %esi, 0x180(%rbx)
imulq $0xc, %rsi, %rsi
callq 0x3180
movq %rax, 0x178(%rbx)
movq 0x160(%rbx), %rax
movw %r15w, (%rax,%r14)
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/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
pushq %rbx
pushq %rax
movq %rdi, %rbx
movl 0xc(%rdi), %edi
cmpl $-0x1, %edi
je 0x5e48
pushq $0x2
popq %rsi
callq 0x3090
orl $-0x1, 0xc(%rbx)
addq $0x10, %rbx
movl $0x4000c, %edx          # imm = 0x4000C
movq %rbx, %rdi
xorl %esi, %esi
addq $0x8, %rsp
popq %rbx
popq %rbp
jmp 0x30f0
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/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
pushq %rbx
pushq %rax
movl %edi, %ebx
callq 0x31c0
movq (%rax), %rax
movslq %ebx, %rcx
movsbl (%rax,%rcx,4), %ecx
leal -0x61(%rcx), %edx
leal -0x57(%rcx), %esi
addl $-0x30, %ecx
cmpl $0xa, %ecx
pushq $-0x1
popq %rax
cmovbl %ecx, %eax
cmpl $0x6, %edx
cmovbl %esi, %eax
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/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
pushq %rbx
pushq %rax
movq %rdi, %rbx
callq 0x30a0
xorl %edx, %edx
testl %eax, %eax
cmovlel %edx, %eax
xorl %ecx, %ecx
cmpq %rdx, %rax
je 0x5ea9
addb (%rbx,%rdx), %cl
incq %rdx
jmp 0x5e9c
movl %ecx, %eax
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/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
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq %rdi, %r14
movq %rsi, %rdi
callq 0x30a0
movl 0xc(%r14), %edi
movslq %eax, %r15
xorl %r14d, %r14d
movq %rbx, %rsi
movq %r15, %rdx
xorl %ecx, %ecx
callq 0x30b0
cmpl %r15d, %eax
je 0x5efd
leaq 0x2083(%rip), %rdi      # 0x7f70
movq %rbx, %rsi
movl %eax, %edx
xorl %eax, %eax
callq 0x30c0
pushq $-0x1
popq %r14
movl %r14d, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/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
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %rdi, %rbx
leaq -0x38(%rbp), %r15
andl $0x0, (%r15)
leaq 0x1(%rsi), %rdi
movq %r15, %rsi
callq 0x603c
leaq -0x34(%rbp), %r14
andl $0x0, (%r14)
leaq 0x1(%rax), %rdi
movq %r14, %rsi
callq 0x603c
movl (%r14), %r13d
movslq %r13d, %r12
movq %rsp, %r14
leaq 0xf(%r12), %rax
andq $-0x10, %rax
subq %rax, %r14
movq %r14, %rsp
movq %r14, %rdi
xorl %esi, %esi
movq %r12, %rdx
callq 0x30f0
movq %rbx, -0x30(%rbp)
movq (%rbx), %rax
movq (%rax), %rdi
movslq (%r15), %rsi
movq %r14, %rdx
movl %r12d, %ecx
callq *0x38(%rax)
leal 0x1(,%r12,2), %eax
cmpl $0x1fffa, %eax          # imm = 0x1FFFA
jg 0x601d
testl %r13d, %r13d
movl $0x0, %eax
cmovlel %eax, %r13d
leaq 0x88138(%rip), %r15     # 0x8e0e0
movl $0x1fffb, %ebx          # imm = 0x1FFFB
xorl %r12d, %r12d
cmpq %r12, %r13
je 0x5fdf
movslq %ebx, %rsi
movzbl (%r14,%r12), %ecx
movq %r15, %rdi
leaq 0x1eee(%rip), %rdx      # 0x7eb5
xorl %eax, %eax
callq 0x30d0
testl %eax, %eax
je 0x5ffe
movslq %eax, %rcx
addq %rcx, %r15
subl %eax, %ebx
incq %r12
jmp 0x5fb0
leaq 0x880fa(%rip), %rsi     # 0x8e0e0
movq -0x30(%rbp), %rdi
callq 0x523f
leaq -0x28(%rbp), %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
leaq 0x1090(%rip), %rdi      # 0x7095
leaq 0x1ef5(%rip), %rsi      # 0x7f01
leaq 0x2096(%rip), %rcx      # 0x80a9
movl $0x306, %edx            # imm = 0x306
callq 0x30e0
leaq 0x2068(%rip), %rdi      # 0x808c
leaq 0x1ed6(%rip), %rsi      # 0x7f01
leaq 0x2077(%rip), %rcx      # 0x80a9
movl $0x302, %edx            # imm = 0x302
callq 0x30e0
// File: /workspace/github_c_makefile_star2_O2/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
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movq %rsi, %r14
movq %rdi, %rbx
callq 0x31d0
movq (%rax), %r15
movsbq (%rbx), %rax
testb $0x10, 0x1(%r15,%rax,2)
je 0x607e
movl (%r14), %r12d
shll $0x4, %r12d
movl %r12d, (%r14)
movsbl (%rbx), %edi
callq 0x5e4f
orl %r12d, %eax
movl %eax, (%r14)
incq %rbx
jmp 0x6055
movq %rbx, %rax
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/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
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movl %r8d, %r13d
movq %rcx, %r14
movl %edx, -0x30(%rbp)
movl %esi, %r12d
movq %rdi, -0x38(%rbp)
testl %esi, %esi
movl $0x0, %ebx
cmovgl %esi, %ebx
decl %r12d
xorl %r15d, %r15d
movl %r8d, -0x2c(%rbp)
cmpq %r15, %rbx
je 0x60fd
cmpl $0x0, -0x30(%rbp)
movslq %r12d, %rax
cmoveq %r15, %rax
movzbl -0x38(%rbp,%rax), %ecx
movslq %r13d, %rsi
movq %r14, %rdi
leaq 0x1dd4(%rip), %rdx      # 0x7eb5
xorl %eax, %eax
callq 0x30d0
testl %eax, %eax
je 0x6112
movslq %eax, %rcx
addq %rcx, %r14
subl %eax, %r13d
incq %r15
decl %r12d
jmp 0x60bf
movl -0x2c(%rbp), %eax
subl %r13d, %eax
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
leaq 0xf7c(%rip), %rdi       # 0x7095
leaq 0x1de1(%rip), %rsi      # 0x7f01
leaq 0x1f20(%rip), %rcx      # 0x8047
movl $0x112, %edx            # imm = 0x112
callq 0x30e0
// File: /workspace/github_c_makefile_star2_O2/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
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movl %esi, %ebx
movq %rdi, %r14
movslq 0x180(%rdi), %rax
andl 0x168(%rdi), %ebx
movq 0x178(%rdi), %rdi
leal 0x1(%rax), %ecx
movl %ecx, 0x180(%r14)
imulq $0xc, %rax, %r15
leaq 0xc(%r15), %rsi
callq 0x3180
movq %rax, 0x178(%r14)
leaq (%rax,%r15), %rcx
movl %ebx, (%rax,%r15)
movq 0x160(%r14), %rdx
movzwl (%rdx,%rbx), %esi
movw %si, 0x4(%rax,%r15)
andl $0x0, 0x8(%rax,%r15)
andw $0x0, (%rdx,%rbx)
movq %rcx, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/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 %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movl $0x989680, %ebp         # imm = 0x989680
leaq 0x2e09(%rip), %rbx      # 0x5138
leaq 0x2dda(%rip), %r14      # 0x5110
leaq 0x4(%rsp), %r15
subl $0x1, %ebp
jb 0x236f
movl 0x2dbe(%rip), %eax      # 0x5104
incl %eax
movl %eax, 0x2db6(%rip)      # 0x5104
movl %eax, 0x4(%rsp)
movq %rbx, %rdi
callq 0x24d4
movq %r14, %rdi
movq %r15, %rsi
callq 0x29e6
movq %rbx, %rdi
callq 0x20b0
jmp 0x233b
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/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 %r14
pushq %rbx
pushq %rax
leaq 0x2db3(%rip), %rbx      # 0x5138
leaq 0x2d84(%rip), %r14      # 0x5110
cmpb $0x0, 0x2dcd(%rip)      # 0x5160
jne 0x23bf
movq %rbx, %rdi
callq 0x24d4
cmpq $0x0, 0x2d8b(%rip)      # 0x5130
je 0x23b5
movq %r14, %rdi
callq 0x24e8
incl 0x2d53(%rip)            # 0x5108
movq %rbx, %rdi
callq 0x20b0
jmp 0x238c
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O2/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:
pushq %rbx
subq $0x10, %rsp
leaq -0xb7(%rip), %rsi       # 0x231c
leaq 0x8(%rsp), %rdi
callq 0x2506
leaq -0x6a(%rip), %rsi       # 0x237a
movq %rsp, %rdi
callq 0x2506
leaq 0x8(%rsp), %rdi
callq 0x2180
movb $0x1, 0x2d63(%rip)      # 0x5160
movq %rsp, %rdi
callq 0x2180
movq 0x2bcc(%rip), %rdi      # 0x4fd8
leaq 0xbf1(%rip), %rsi       # 0x3004
callq 0x2110
movl 0x2ce6(%rip), %esi      # 0x5104
movq %rax, %rdi
callq 0x21a0
leaq 0xbe1(%rip), %rsi       # 0x300e
movq %rax, %rdi
callq 0x2110
movq %rax, %rdi
callq 0x2070
movq 0x2b94(%rip), %rdi      # 0x4fd8
leaq 0xbcd(%rip), %rsi       # 0x3018
callq 0x2110
movl 0x2cb2(%rip), %esi      # 0x5108
movq %rax, %rdi
callq 0x21a0
leaq 0xba9(%rip), %rsi       # 0x300e
movq %rax, %rdi
callq 0x2110
movq %rax, %rdi
callq 0x2070
movq %rsp, %rdi
callq 0x256c
leaq 0x8(%rsp), %rdi
callq 0x256c
xorl %eax, %eax
addq $0x10, %rsp
popq %rbx
retq
movq %rax, %rbx
jmp 0x249f
movq %rax, %rbx
movq %rsp, %rdi
callq 0x256c
leaq 0x8(%rsp), %rdi
callq 0x256c
movq %rbx, %rdi
callq 0x21b0
nop
// File: /workspace/github_c_makefile_star2_O2/chrispanag[P]operating-systems-scheduler/strace-test.c
// Function: main
int main(int argc, char *argv[])
{
	int status;
	pid_t p, waitp;

	p = fork();
	if (p < 0) {
		perror("fork");
		exit(1);
	}

	if (p == 0) {
		raise(STOP_SIGNAL);
		/* Should never reach this point */
		printf("Child: FAIL.\n");
		exit(1);
	}

	/*
	 * Father sleeps for a while and kills the child.
	 * The child should be alive when the father wakes.
	 */
	printf("Parent: sleeping for a while...\n");
	sleep(2);

	if (kill(p, SIGKILL) < 0) {
		perror("kill");
		exit(1);
	}

	waitp = wait(&status);
	assert(p == waitp);
	if (WIFEXITED(status)) {
		printf("Parent: FAIL. Child exited, status = %d\n",
			WEXITSTATUS(status));
		exit(1);
	}

	if (!WIFSIGNALED(status)) {
		printf("Parent: FAIL. Child not signaled?\n");
		exit(1);
	}

	printf("Parent: SUCCESS. Child killed, sig = %d\n",
		WTERMSIG(status));
	return 0;
}

// Assembly:
pushq %rbx
subq $0x10, %rsp
callq 0x10c0
testl %eax, %eax
js 0x1244
je 0x124d
movl %eax, %ebx
leaq 0xeab(%rip), %rdi       # 0x2090
callq 0x1040
pushq $0x2
popq %rdi
callq 0x10a0
pushq $0x9
popq %rsi
movl %ebx, %edi
callq 0x1070
testl %eax, %eax
js 0x125e
leaq 0xc(%rsp), %rdi
callq 0x10b0
cmpl %eax, %ebx
jne 0x126c
movl 0xc(%rsp), %ecx
movl %ecx, %eax
andl $0x7f, %eax
je 0x1289
movl %eax, %ecx
shll $0x18, %ecx
addl $0x1000000, %ecx        # imm = 0x1000000
cmpl $0x1ffffff, %ecx        # imm = 0x1FFFFFF
jle 0x129c
leaq 0xe34(%rip), %rdi       # 0x2067
movl %eax, %esi
xorl %eax, %eax
callq 0x1050
xorl %eax, %eax
addq $0x10, %rsp
popq %rbx
retq
leaq 0xdb9(%rip), %rdi       # 0x2004
jmp 0x1265
pushq $0x14
popq %rdi
callq 0x1030
leaq 0xe76(%rip), %rdi       # 0x20d2
jmp 0x12a3
leaq 0xda4(%rip), %rdi       # 0x2009
callq 0x1080
jmp 0x12a8
leaq 0xd9b(%rip), %rdi       # 0x200e
leaq 0xd9f(%rip), %rsi       # 0x2019
leaq 0xda6(%rip), %rcx       # 0x2027
pushq $0x35
popq %rdx
callq 0x1060
movzbl %ch, %esi
leaq 0xdab(%rip), %rdi       # 0x203e
xorl %eax, %eax
callq 0x1050
jmp 0x12a8
leaq 0xe0d(%rip), %rdi       # 0x20b0
callq 0x1040
pushq $0x1
popq %rdi
callq 0x1090
// File: /workspace/github_c_makefile_star2_O2/saltyJeff[P]uClibcpp/extra/config/conf.c
// Function: conf_string
int conf_string(struct menu *menu)
{
	struct symbol *sym = menu->sym;
	const char *def, *help;

	while (1) {
		printf("%*s%s ", indent - 1, "", menu->prompt->text);
		printf("(%s) ", sym->name);
		def = sym_get_string_value(sym);
		if (sym_get_string_value(sym))
			printf("[%s] ", def);
		conf_askvalue(sym, def);
		switch (line[0]) {
		case '\n':
			break;
		case '?':
			/* print help */
			if (line[1] == 0) {
				help = nohelp_text;
				if (menu->sym->help)
					help = menu->sym->help;
				printf("\n%s\n", menu->sym->help);
				def = NULL;
				break;
			}
		default:
			line[strlen(line)-1] = 0;
			def = line;
		}
		if (def && sym_set_string_value(sym, def))
			return 0;
	}
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rdi, %rbx
movq 0x18(%rdi), %r14
leaq 0xd292(%rip), %r12      # 0xf6d7
leaq 0x7c2f(%rip), %r13      # 0xa07b
leaq 0x11fbd(%rip), %r15     # 0x14410
movl 0x11d57(%rip), %esi     # 0x141b0
decl %esi
movq 0x20(%rbx), %rax
movq 0x18(%rax), %rcx
leaq 0x7c0a(%rip), %rdi      # 0xa074
movq %r12, %rdx
xorl %eax, %eax
callq 0x2100
movq 0x8(%r14), %rsi
movq %r13, %rdi
xorl %eax, %eax
callq 0x2100
movq %r14, %rdi
callq 0x7c9f
movq %rax, %rbp
movq %r14, %rdi
callq 0x7c9f
testq %rax, %rax
je 0x24ab
leaq 0x7be0(%rip), %rdi      # 0xa081
movq %rbp, %rsi
xorl %eax, %eax
callq 0x2100
movq %r14, %rdi
movq %rbp, %rsi
callq 0x252d
movzbl 0x11f53(%rip), %eax     # 0x14410
cmpl $0xa, %eax
je 0x24e3
cmpl $0x3f, %eax
jne 0x24d0
cmpb $0x0, 0x11f43(%rip)     # 0x14411
je 0x2501
movq %r15, %rdi
callq 0x20e0
movb $0x0, -0x1(%rax,%r15)
movq %r15, %rbp
jmp 0x24ec
testq %rbp, %rbp
je 0x2453
movq %r14, %rdi
movq %rbp, %rsi
callq 0x9872
testb %al, %al
je 0x2453
jmp 0x251c
movq 0x18(%rbx), %rax
movq 0x10(%rax), %rsi
leaq 0xd1ce(%rip), %rdi      # 0xf6de
xorl %eax, %eax
callq 0x2100
jmp 0x2453
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/saltyJeff[P]uClibcpp/extra/config/conf.c
// Function: check_conf
static void check_conf(struct menu *menu)
{
	struct symbol *sym;
	struct menu *child;

	if (!menu_is_visible(menu))
		return;

	sym = menu->sym;
	if (sym) {
		if (sym_is_changable(sym) && !sym_has_value(sym)) {
			if (!conf_cnt++)
				printf("*\n* Restart config...\n*\n");
			rootEntry = menu_get_parent_menu(menu);
			conf(rootEntry);
		}
		if (sym_is_choice(sym) && sym_get_tristate_value(sym) != mod)
			return;
	}

	for (child = menu->list; child; child = child->next)
		check_conf(child);
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
callq 0x7c07
testb %al, %al
je 0x2dc2
movq 0x18(%rbx), %r14
testq %r14, %r14
je 0x2dac
movq %r14, %rdi
callq 0x99b4
testb %al, %al
je 0x2d9e
testb $0x8, 0x45(%r14)
je 0x2d9e
movl 0x1172a(%rip), %eax     # 0x14498
leal 0x1(%rax), %ecx
movl %ecx, 0x11721(%rip)     # 0x14498
testl %eax, %eax
jne 0x2d87
leaq 0x7475(%rip), %rdi      # 0xa1f7
callq 0x20a0
movq %rbx, %rdi
callq 0x9af2
movq %rax, 0x116fa(%rip)     # 0x14490
movq %rax, %rdi
callq 0x2893
testb $0x10, 0x44(%r14)
je 0x2dac
cmpl $0x1, 0x28(%r14)
jne 0x2dc2
addq $0x10, %rbx
movq (%rbx), %rbx
testq %rbx, %rbx
je 0x2dc2
movq %rbx, %rdi
callq 0x2d3c
jmp 0x2db0
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O2/saltyJeff[P]uClibcpp/extra/config/conf.c
// Function: check_stdin
static void check_stdin(void)
{
	if (!valid_stdin && input_mode == ask_silent) {
		printf("aborted!\n\n");
		printf("Console input/output is redirected. ");
		printf("Run 'make oldconfig' to update configuration.\n\n");
		exit(1);
	}
}

// Assembly:
cmpl $0x0, 0x1141f(%rip)     # 0x141f0
jne 0x2ddc
cmpl $0x2, 0x11626(%rip)     # 0x14400
je 0x2ddd
retq
pushq %rax
leaq 0x742a(%rip), %rdi      # 0xa20f
callq 0x20a0
leaq 0x72ec(%rip), %rdi      # 0xa0dd
xorl %eax, %eax
callq 0x2100
leaq 0x741a(%rip), %rdi      # 0xa219
callq 0x20a0
pushq $0x1
popq %rdi
callq 0x22f0
// File: /workspace/github_c_makefile_star2_O2/saltyJeff[P]uClibcpp/extra/config/conf.c
// Function: strip
static void strip(char *str)
{
	char *p = str;
	int l;

	while ((isspace(*p)))
		p++;
	l = strlen(p);
	if (p != str)
		memmove(str, p, l + 1);
	if (!l)
		return;
	p = str + l - 1;
	while ((isspace(*p)))
		*p-- = 0;
}

// Assembly:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
callq 0x2320
movq %rax, %rbx
movq (%rax), %rax
pushq $-0x1
popq %r13
leaq 0x113ca(%rip), %r12     # 0x14410
movsbq 0x1(%r13,%r12), %rcx
incq %r13
testb $0x20, 0x1(%rax,%rcx,2)
jne 0x3046
leaq (%r12,%r13), %r15
movq %r15, %rdi
callq 0x20e0
movq %rax, %r14
testq %r13, %r13
je 0x3080
leal 0x1(%r14), %eax
movslq %eax, %rdx
leaq 0x11398(%rip), %rdi     # 0x14410
movq %r15, %rsi
callq 0x2280
testl %r14d, %r14d
je 0x30a4
movslq %r14d, %rax
addq %r12, %rax
decq %rax
movq (%rbx), %rcx
movsbq (%rax), %rdx
testb $0x20, 0x1(%rcx,%rdx,2)
je 0x30a4
movb $0x0, (%rax)
decq %rax
jmp 0x308e
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
nop
// File: /workspace/github_c_makefile_star2_O2/saltyJeff[P]uClibcpp/extra/config/zconf.tab.c
// Function: zconfprint
static void zconfprint(const char *err, ...)
{
	va_list ap;

	fprintf(stderr, "%s:%d: ", zconf_curname(), zconf_lineno() + 1);
	va_start(ap, err);
	vfprintf(stderr, err, ap);
	va_end(ap);
	fprintf(stderr, "\n");
}

// Assembly:
pushq %r14
pushq %rbx
subq $0xd8, %rsp
movq %rdi, %rbx
movq %rsi, 0x28(%rsp)
movq %rdx, 0x30(%rsp)
movq %rcx, 0x38(%rsp)
movq %r8, 0x40(%rsp)
movq %r9, 0x48(%rsp)
testb %al, %al
je 0x4fb8
movaps %xmm0, 0x50(%rsp)
movaps %xmm1, 0x60(%rsp)
movaps %xmm2, 0x70(%rsp)
movaps %xmm3, 0x80(%rsp)
movaps %xmm4, 0x90(%rsp)
movaps %xmm5, 0xa0(%rsp)
movaps %xmm6, 0xb0(%rsp)
movaps %xmm7, 0xc0(%rsp)
movq 0xf039(%rip), %r14      # 0x13ff8
movq (%r14), %rdi
cmpq $0x0, 0xfde6(%rip)      # 0x14db0
jne 0x4fd8
pushq $0x1
popq %rcx
leaq 0xa8cc(%rip), %rdx      # 0xf8a2
jmp 0x4fe6
movq 0xfdc1(%rip), %rax      # 0x14da0
movq 0x10(%rax), %rdx
movl 0x18(%rax), %ecx
leaq 0xb29d(%rip), %rsi      # 0x1028a
xorl %eax, %eax
callq 0x21b0
movabsq $0x3000000008, %rax     # imm = 0x3000000008
movq %rsp, %rdx
movq %rax, (%rdx)
leaq 0xf0(%rsp), %rax
movq %rax, 0x8(%rdx)
leaq 0x20(%rsp), %rax
movq %rax, 0x10(%rdx)
movq (%r14), %rdi
movq %rbx, %rsi
callq 0x22b0
movq (%r14), %rsi
pushq $0xa
popq %rdi
callq 0x2140
addq $0xd8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O2/saltyJeff[P]uClibcpp/extra/config/./symbol.c
// Function: sym_lookup
struct symbol *sym_lookup(const char *name, int isconst)
{
	struct symbol *symbol;
	const char *ptr;
	char *new_name;
	int hash = 0;

	if (name) {
		if (name[0] && !name[1]) {
			switch (name[0]) {
			case 'y': return &symbol_yes;
			case 'm': return &symbol_mod;
			case 'n': return &symbol_no;
			}
		}
		for (ptr = name; *ptr; ptr++)
			hash += *ptr;
		hash &= 0xff;

		for (symbol = symbol_hash[hash]; symbol; symbol = symbol->next) {
			if (!strcmp(symbol->name, name)) {
				if ((isconst && symbol->flags & SYMBOL_CONST) ||
				    (!isconst && !(symbol->flags & SYMBOL_CONST)))
					return symbol;
			}
		}
		new_name = strdup(name);
	} else {
		new_name = NULL;
		hash = 256;
	}

	symbol = malloc(sizeof(*symbol));
	memset(symbol, 0, sizeof(*symbol));
	symbol->name = new_name;
	symbol->type = S_UNKNOWN;
	symbol->flags = SYMBOL_NEW;
	if (isconst)
		symbol->flags |= SYMBOL_CONST;

	symbol->next = symbol_hash[hash];
	symbol_hash[hash] = symbol;

	return symbol;
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movl %esi, %ebx
testq %rdi, %rdi
je 0x50bb
movq %rdi, %r14
movzbl (%rdi), %eax
testl %eax, %eax
je 0x505e
cmpb $0x0, 0x1(%r14)
je 0x510a
leaq 0x1(%r14), %rdx
xorl %ecx, %ecx
testb %al, %al
je 0x5074
movzbl %al, %eax
addl %eax, %ecx
movb (%rdx), %al
incq %rdx
jmp 0x5064
movzbl %cl, %r12d
leaq 0xf4a1(%rip), %rax      # 0x14520
leaq (%rax,%r12,8), %r15
movq (%r15), %r15
testq %r15, %r15
je 0x50ae
movq 0x8(%r15), %rdi
movq %r14, %rsi
callq 0x2190
testl %eax, %eax
jne 0x5083
testl %ebx, %ebx
sete %al
testb $0x7, 0x44(%r15)
sete %cl
xorb %al, %cl
jne 0x5083
jmp 0x50fb
movq %r14, %rdi
callq 0x2310
movq %rax, %r14
jmp 0x50c4
movl $0x100, %r12d           # imm = 0x100
xorl %r14d, %r14d
pushq $0x1
popq %rdi
pushq $0x70
popq %rsi
callq 0x2180
movq %rax, %r15
movq %r14, 0x8(%rax)
testl %ebx, %ebx
movl $0x800, %eax            # imm = 0x800
movl $0x807, %ecx            # imm = 0x807
cmovel %eax, %ecx
movl %ecx, 0x44(%r15)
leaq 0xf430(%rip), %rax      # 0x14520
movq (%rax,%r12,8), %rcx
movq %rcx, (%r15)
movq %r15, (%rax,%r12,8)
movq %r15, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
cmpl $0x79, %eax
je 0x512f
cmpl $0x6e, %eax
je 0x5126
cmpl $0x6d, %eax
jne 0x505e
leaq 0xf1e4(%rip), %r15      # 0x14308
jmp 0x50fb
leaq 0xf0fb(%rip), %r15      # 0x14228
jmp 0x50fb
leaq 0xf162(%rip), %r15      # 0x14298
jmp 0x50fb
// File: /workspace/github_c_makefile_star2_O2/saltyJeff[P]uClibcpp/extra/config/./menu.c
// Function: menu_add_entry
void menu_add_entry(struct symbol *sym)
{
	struct menu *menu;

	menu = malloc(sizeof(*menu));
	memset(menu, 0, sizeof(*menu));
	menu->sym = sym;
	menu->parent = current_menu;
	menu->file = current_file;
	menu->lineno = zconf_lineno();

	*last_entry_ptr = menu;
	last_entry_ptr = &menu->next;
	current_entry = menu;
}

// Assembly:
pushq %rbx
movq %rdi, %rbx
pushq $0x1
popq %rdi
pushq $0x50
popq %rsi
callq 0x2180
movq %rbx, 0x18(%rax)
movq 0xf366(%rip), %rcx      # 0x144b8
movq %rcx, 0x8(%rax)
movq 0xfc43(%rip), %rcx      # 0x14da0
movq %rcx, 0x38(%rax)
cmpq $0x0, 0xfc47(%rip)      # 0x14db0
je 0x5172
movl 0x18(%rcx), %ecx
decl %ecx
jmp 0x5174
xorl %ecx, %ecx
movl %ecx, 0x40(%rax)
movq 0x10c52(%rip), %rcx     # 0x15dd0
movq %rax, (%rcx)
movq %rax, 0x10c48(%rip)     # 0x15dd0
movq %rax, 0xf321(%rip)      # 0x144b0
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O2/saltyJeff[P]uClibcpp/extra/config/./menu.c
// Function: menu_set_type
void menu_set_type(int type)
{
	struct symbol *sym = current_entry->sym;

	if (sym->type == type)
		return;
	if (sym->type == S_UNKNOWN) {
		sym->type = type;
		return;
	}
	fprintf(stderr, "%s:%d:warning: type of '%s' redefined from '%s' to '%s'\n",
		current_entry->file->name, current_entry->lineno,
		sym->name ? sym->name : "<choice>", sym_type_name(sym->type), sym_type_name(type));
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movl %edi, %ebx
movq 0xf2d2(%rip), %rcx      # 0x144b0
movq 0x18(%rcx), %rax
movl 0x18(%rax), %edi
cmpl %ebx, %edi
je 0x51f0
testl %edi, %edi
jne 0x51ff
movl %ebx, 0x18(%rax)
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq 0xedf2(%rip), %rdx      # 0x13ff8
movq (%rdx), %r14
movq 0x38(%rcx), %rdx
movq 0x10(%rdx), %r15
movl 0x40(%rcx), %ebp
movq 0x8(%rax), %rax
testq %rax, %rax
leaq 0xa9fa(%rip), %r12      # 0xfc1c
cmovneq %rax, %r12
callq 0x95f1
movq %rax, %r13
movl %ebx, %edi
callq 0x95f1
movq %rax, (%rsp)
leaq 0xaa79(%rip), %rsi      # 0xfcb9
movq %r14, %rdi
movq %r15, %rdx
movl %ebp, %ecx
movq %r12, %r8
movq %r13, %r9
xorl %eax, %eax
callq 0x21b0
jmp 0x51f0
// File: /workspace/github_c_makefile_star2_O2/saltyJeff[P]uClibcpp/extra/config/./expr.c
// Function: expr_alloc_comp
struct expr *expr_alloc_comp(enum expr_type type, struct symbol *s1, struct symbol *s2)
{
	struct expr *e = malloc(sizeof(*e));
	memset(e, 0, sizeof(*e));
	e->type = type;
	e->left.sym = s1;
	e->right.sym = s2;
	return e;
}

// Assembly:
pushq %rbp
pushq %r14
pushq %rbx
movq %rdx, %rbx
movq %rsi, %r14
movl %edi, %ebp
pushq $0x1
popq %rdi
pushq $0x18
popq %rsi
callq 0x2180
movl %ebp, (%rax)
movq %r14, 0x8(%rax)
movq %rbx, 0x10(%rax)
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/saltyJeff[P]uClibcpp/extra/config/zconf.tab.c
// Function: zconf_endtoken
static bool zconf_endtoken(int token, int starttoken, int endtoken)
{
	if (token != endtoken) {
		zconfprint("unexpected '%s' within %s block", zconf_tokenname(token), zconf_tokenname(starttoken));
		zconfnerrs++;
		return false;
	}
	if (current_menu->file != current_file) {
		zconfprint("'%s' in different file than '%s'", zconf_tokenname(token), zconf_tokenname(starttoken));
		zconfprint("location of the '%s'", zconf_tokenname(starttoken));
		zconfnerrs++;
		return false;
	}
	return true;
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movl %esi, %ebx
cmpl %edx, %edi
jne 0x532a
movq 0xf1d4(%rip), %rax      # 0x144b8
movq 0x38(%rax), %rax
cmpq 0xfab1(%rip), %rax      # 0x14da0
je 0x535d
callq 0x5f0b
movq %rax, %r14
movl %ebx, %edi
callq 0x5f0b
movq %rax, %rbx
leaq 0xaf4a(%rip), %rdi      # 0x10254
movq %r14, %rsi
movq %rax, %rdx
xorl %eax, %eax
callq 0x4f57
leaq 0xaf57(%rip), %rdi      # 0x10275
movq %rbx, %rsi
xorl %eax, %eax
callq 0x4f57
jmp 0x534d
callq 0x5f0b
movq %rax, %r14
movl %ebx, %edi
callq 0x5f0b
leaq 0xaef4(%rip), %rdi      # 0x10234
movq %r14, %rsi
movq %rax, %rdx
xorl %eax, %eax
callq 0x4f57
incl 0xf14d(%rip)            # 0x144a0
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
movb $0x1, %al
jmp 0x5355
// File: /workspace/github_c_makefile_star2_O2/saltyJeff[P]uClibcpp/extra/config/./menu.c
// Function: menu_add_prop
struct property *menu_add_prop(enum prop_type type, char *prompt, struct expr *expr, struct expr *dep)
{
	struct property *prop = prop_alloc(type, current_entry->sym);

	prop->menu = current_entry;
	prop->text = prompt;
	prop->expr = expr;
	prop->visible.expr = menu_check_dep(dep);

	if (prompt) {
		if (current_entry->prompt)
			fprintf(stderr, "%s:%d: prompt redefined\n",
				current_entry->file->name, current_entry->lineno);
		current_entry->prompt = prop;
	}

	return prop;
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rcx, %r14
movq %rdx, %r15
movq %rsi, %r12
movq 0xf0f4(%rip), %rax      # 0x144b0
movq 0x18(%rax), %rsi
callq 0x955d
movq %rax, %rbx
movq 0xf0e1(%rip), %rax      # 0x144b0
movq %rax, 0x38(%rbx)
movq %r12, 0x18(%rbx)
movq %r15, 0x30(%rbx)
movq %r14, %rdi
callq 0x9a76
movq %rax, 0x20(%rbx)
testq %r12, %r12
je 0x53fe
movq 0xf0bd(%rip), %rax      # 0x144b0
cmpq $0x0, 0x20(%rax)
jne 0x540d
movq %rbx, 0x20(%rax)
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
movq 0xebe4(%rip), %rcx      # 0x13ff8
movq (%rcx), %rdi
movq 0x38(%rax), %rcx
movq 0x10(%rcx), %rdx
movl 0x40(%rax), %ecx
leaq 0xa8c9(%rip), %rsi      # 0xfcf2
xorl %eax, %eax
callq 0x21b0
movq 0xf079(%rip), %rax      # 0x144b0
jmp 0x53fa
// File: /workspace/github_c_makefile_star2_O2/saltyJeff[P]uClibcpp/extra/config/lex.zconf.c
// Function: zconf_nextfile
void zconf_nextfile(const char *name)
{
	struct file *file = file_lookup(name);
	struct buffer *buf = malloc(sizeof(*buf));
	memset(buf, 0, sizeof(*buf));

	current_buf->state = YY_CURRENT_BUFFER;
	zconfin = zconf_fopen(name);
	if (!zconfin) {
		printf("%s:%d: can't open file \"%s\"\n", zconf_curname(), zconf_lineno(), name);
		exit(1);
	}
	zconf_switch_to_buffer(zconf_create_buffer(zconfin,YY_BUF_SIZE));
	buf->parent = current_buf;
	current_buf = buf;

	if (file->flags & FILE_BUSY) {
		printf("recursive scan (%s)?\n", name);
		exit(1);
	}
	if (file->flags & FILE_SCANNED) {
		printf("file %s already scanned?\n", name);
		exit(1);
	}
	file->flags |= FILE_BUSY;
	file->lineno = 1;
	file->parent = current_file;
	current_file = file;
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rdi, %rbx
callq 0x69d7
movq %rax, %r14
pushq $0x1
popq %rdi
pushq $0x10
popq %rsi
callq 0x2180
movq %rax, %r15
movq 0xf912(%rip), %rax      # 0x14d70
testq %rax, %rax
je 0x5470
movq 0xf90e(%rip), %rcx      # 0x14d78
movq (%rax,%rcx,8), %rax
jmp 0x5472
xorl %eax, %eax
movq 0xf937(%rip), %rcx      # 0x14db0
movq %rax, 0x8(%rcx)
movq %rbx, %rdi
callq 0x696b
movq %rax, 0xf8a4(%rip)      # 0x14d30
testq %rax, %rax
je 0x54ea
movq %rax, %rdi
movl $0x4000, %esi           # imm = 0x4000
callq 0x642e
movq %rax, %rdi
callq 0x65fc
movq 0xf903(%rip), %rax      # 0x14db0
movq %rax, (%r15)
movq %r15, 0xf8f9(%rip)      # 0x14db0
movl 0x1c(%r14), %eax
testb $0x1, %al
jne 0x54fd
testb $0x2, %al
jne 0x5506
orl $0x1, %eax
movl %eax, 0x1c(%r14)
movl $0x1, 0x18(%r14)
movq 0xf8c7(%rip), %rax      # 0x14da0
movq %rax, 0x8(%r14)
movq %r14, 0xf8bc(%rip)      # 0x14da0
popq %rbx
popq %r14
popq %r15
retq
cmpq $0x0, 0xf8be(%rip)      # 0x14db0
jne 0x5519
leaq 0xa3a7(%rip), %r14      # 0xf8a2
jmp 0x5524
leaq 0xa36e(%rip), %rdi      # 0xf872
jmp 0x550d
leaq 0xa37b(%rip), %rdi      # 0xf888
movq %rbx, %rsi
xorl %eax, %eax
callq 0x2100
jmp 0x553f
movq 0xf880(%rip), %rax      # 0x14da0
movq 0x10(%rax), %r14
callq 0x51af
leaq 0xa325(%rip), %rdi      # 0xf855
movq %r14, %rsi
movl %eax, %edx
movq %rbx, %rcx
xorl %eax, %eax
callq 0x2100
pushq $0x1
popq %rdi
callq 0x22f0
// File: /workspace/github_c_makefile_star2_O2/saltyJeff[P]uClibcpp/extra/config/./expr.c
// Function: expr_alloc_symbol
struct expr *expr_alloc_symbol(struct symbol *sym)
{
	struct expr *e = malloc(sizeof(*e));
	memset(e, 0, sizeof(*e));
	e->type = E_SYMBOL;
	e->left.sym = sym;
	return e;
}

// Assembly:
pushq %rbx
movq %rdi, %rbx
pushq $0x1
popq %rdi
pushq $0x18
popq %rsi
callq 0x2180
movl $0x7, (%rax)
movq %rbx, 0x8(%rax)
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O2/saltyJeff[P]uClibcpp/extra/config/./expr.c
// Function: expr_alloc_one
struct expr *expr_alloc_one(enum expr_type type, struct expr *ce)
{
	struct expr *e = malloc(sizeof(*e));
	memset(e, 0, sizeof(*e));
	e->type = type;
	e->left.expr = ce;
	return e;
}

// Assembly:
pushq %rbp
pushq %rbx
pushq %rax
movq %rsi, %rbx
movl %edi, %ebp
pushq $0x1
popq %rdi
pushq $0x18
popq %rsi
callq 0x2180
movl %ebp, (%rax)
movq %rbx, 0x8(%rax)
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/saltyJeff[P]uClibcpp/extra/config/zconf.tab.c
// Function: conf_parse
void conf_parse(const char *name)
{
	struct symbol *sym;
	int i;

	zconf_initscan(name);

	sym_init();
	menu_init();
	modules_sym = sym_lookup("MODULES", 0);
	rootmenu.prompt = menu_add_prop(P_MENU, "uClibc++ Configuration", NULL, NULL);

	//zconfdebug = 1;
	zconfparse();
	if (zconfnerrs)
		exit(1);
	menu_finalize(&rootmenu);
	for_all_symbols(i, sym) {
                if (!(sym->flags & SYMBOL_CHECKED) && sym_check_deps(sym))
                        printf("\n");
		else
			sym->flags |= SYMBOL_CHECK_DONE;
        }

	sym_change_count = 1;
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
callq 0x5716
callq 0x5775
leaq 0xee92(%rip), %rax      # 0x144c8
movq %rax, 0xee7b(%rip)      # 0x144b8
movq %rax, 0xee6c(%rip)      # 0x144b0
leaq 0xee8d(%rip), %rax      # 0x144d8
movq %rax, 0x1077e(%rip)     # 0x15dd0
leaq 0x9fbf(%rip), %rdi      # 0xf618
xorl %esi, %esi
callq 0x503a
movq %rax, 0xee59(%rip)      # 0x144c0
leaq 0x9fb2(%rip), %rsi      # 0xf620
pushq $0x3
popq %rdi
xorl %edx, %edx
xorl %ecx, %ecx
callq 0x53a4
movq %rax, 0xee67(%rip)      # 0x144e8
callq 0x30b0
cmpl $0x0, 0xee13(%rip)      # 0x144a0
jne 0x570e
leaq 0xee32(%rip), %rdi      # 0x144c8
callq 0x57f3
xorl %r15d, %r15d
leaq 0xee7b(%rip), %r12      # 0x14520
pushq $0xa
popq %rbx
cmpq $0x101, %r15            # imm = 0x101
je 0x56f8
leaq (%r12,%r15,8), %r14
movq (%r14), %r14
testq %r14, %r14
je 0x56f3
cmpl $0x6, 0x18(%r14)
je 0x56b5
movl 0x44(%r14), %eax
btl $0xd, %eax
jb 0x56e8
movq %r14, %rdi
callq 0x5e62
testq %rax, %rax
je 0x56e4
movl %ebx, %edi
callq 0x2050
jmp 0x56b5
movl 0x44(%r14), %eax
orl $0x4000, %eax           # imm = 0x4000
movl %eax, 0x44(%r14)
jmp 0x56b5
incq %r15
jmp 0x56a8
movl $0x1, 0xf626(%rip)      # 0x14d28
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
pushq $0x1
popq %rdi
callq 0x22f0
// File: /workspace/github_c_makefile_star2_O2/saltyJeff[P]uClibcpp/extra/config/lex.zconf.c
// Function: zconf_initscan
void zconf_initscan(const char *name)
{
	zconfin = zconf_fopen(name);
	if (!zconfin) {
		printf("can't find file %s\n", name);
		exit(1);
	}

	current_buf = malloc(sizeof(*current_buf));
	memset(current_buf, 0, sizeof(*current_buf));

	current_file = file_lookup(name);
	current_file->lineno = 1;
	current_file->flags = FILE_BUSY;
}

// Assembly:
pushq %rbx
movq %rdi, %rbx
callq 0x696b
movq %rax, 0xf60a(%rip)      # 0x14d30
testq %rax, %rax
je 0x575c
pushq $0x1
popq %rdi
pushq $0x10
popq %rsi
callq 0x2180
movq %rax, 0xf673(%rip)      # 0x14db0
movq %rbx, %rdi
callq 0x69d7
movq %rax, 0xf654(%rip)      # 0x14da0
movabsq $0x100000001, %rcx      # imm = 0x100000001
movq %rcx, 0x18(%rax)
popq %rbx
retq
leaq 0xa0de(%rip), %rdi      # 0xf841
movq %rbx, %rsi
xorl %eax, %eax
callq 0x2100
pushq $0x1
popq %rdi
callq 0x22f0
// File: /workspace/github_c_makefile_star2_O2/saltyJeff[P]uClibcpp/extra/config/./symbol.c
// Function: sym_init
void sym_init(void)
{
	struct symbol *sym;
	char *p;
	static bool inited = false;

	if (inited)
		return;
	inited = true;

	sym = sym_lookup("VERSION", 0);
	sym->type = S_STRING;
	sym->flags |= SYMBOL_AUTO;
	p = getenv("VERSION");
	if (p)
		sym_add_default(sym, p);
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
cmpb $0x0, 0x10648(%rip)     # 0x15dc8
jne 0x57c7
movb $0x1, 0x1063f(%rip)     # 0x15dc8
leaq 0xa2c6(%rip), %r14      # 0xfa56
movq %r14, %rdi
xorl %esi, %esi
callq 0x503a
movq %rax, %rbx
movl $0x5, 0x18(%rax)
orb $0x10, 0x45(%rax)
movq %r14, %rdi
callq 0x2030
testq %rax, %rax
je 0x57c7
movq %rbx, %rdi
movq %rax, %rsi
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x9529
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O2/saltyJeff[P]uClibcpp/extra/config/./symbol.c
// Function: sym_check_deps
struct symbol *sym_check_deps(struct symbol *sym)
{
	struct symbol *sym2;
	struct property *prop;

	if (sym->flags & SYMBOL_CHECK_DONE)
		return NULL;
	if (sym->flags & SYMBOL_CHECK) {
		printf("Warning! Found recursive dependency: %s", sym->name);
		return sym;
	}

	sym->flags |= (SYMBOL_CHECK | SYMBOL_CHECKED);
	sym2 = sym_check_expr_deps(sym->rev_dep.expr);
	if (sym2)
		goto out;

	for (prop = sym->prop; prop; prop = prop->next) {
		if (prop->type == P_CHOICE)
			continue;
		sym2 = sym_check_expr_deps(prop->visible.expr);
		if (sym2)
			goto out;
		if (prop->type != P_DEFAULT || sym_is_choice(sym))
			continue;
		sym2 = sym_check_expr_deps(prop->expr);
		if (sym2)
			goto out;
	}
out:
	if (sym2)
		printf(" %s", sym->name);
	sym->flags &= ~SYMBOL_CHECK;
	return sym2;
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movl 0x44(%rdi), %eax
btl $0xe, %eax
jb 0x5eab
movq %rdi, %rbx
testb $0x8, %al
jne 0x5eaf
orl $0x2008, %eax           # imm = 0x2008
movl %eax, 0x44(%rbx)
movq 0x60(%rbx), %rdi
callq 0x99be
testq %rax, %rax
je 0x5eca
movq %rax, %r14
movq 0x8(%rbx), %rsi
leaq 0x428e(%rip), %rdi      # 0xa129
xorl %eax, %eax
callq 0x2100
andb $-0x9, 0x44(%rbx)
movq %r14, %rbx
jmp 0x5ec1
xorl %ebx, %ebx
jmp 0x5ec1
movq 0x8(%rbx), %rsi
leaq 0x9dba(%rip), %rdi      # 0xfc74
xorl %eax, %eax
callq 0x2100
movq %rbx, %rax
popq %rbx
popq %r14
popq %r15
retq
leaq 0x48(%rbx), %r15
xorl %r14d, %r14d
movq (%r15), %r15
testq %r15, %r15
je 0x5ea2
cmpl $0x5, 0x10(%r15)
je 0x5ed1
movq 0x20(%r15), %rdi
callq 0x99be
testq %rax, %rax
jne 0x5e8d
cmpl $0x4, 0x10(%r15)
jne 0x5ed1
testb $0x10, 0x44(%rbx)
jne 0x5ed1
movq 0x30(%r15), %rdi
callq 0x99be
testq %rax, %rax
je 0x5ed1
jmp 0x5e8d
// File: /workspace/github_c_makefile_star2_O2/saltyJeff[P]uClibcpp/extra/config/zconf.tab.c
// Function: print_quoted_string
void print_quoted_string(FILE *out, const char *str)
{
	const char *p;
	int len;

	putc('"', out);
	while ((p = strchr(str, '"'))) {
		len = p - str;
		if (len)
			fprintf(out, "%.*s", len, str);
		fputs("\\\"", out);
		str = p + 1;
	}
	fputs(str, out);
	putc('"', out);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rsi, %r12
movq %rdi, %rbx
pushq $0x22
popq %rbp
movl %ebp, %edi
movq %rbx, %rsi
callq 0x21a0
leaq 0x9708(%rip), %r14      # 0xf65c
leaq 0x96fc(%rip), %r15      # 0xf657
movq %r12, %rdi
movl %ebp, %esi
callq 0x20f0
testq %rax, %rax
je 0x5f98
movq %rax, %r13
movl %r13d, %edx
subl %r12d, %edx
je 0x5f85
movq %rbx, %rdi
movq %r15, %rsi
movq %r12, %rcx
xorl %eax, %eax
callq 0x21b0
movq %r14, %rdi
movq %rbx, %rsi
callq 0x2120
incq %r13
movq %r13, %r12
jmp 0x5f5b
movq %r12, %rdi
movq %rbx, %rsi
callq 0x2120
pushq $0x22
popq %rdi
movq %rbx, %rsi
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x21a0
// File: /workspace/github_c_makefile_star2_O2/saltyJeff[P]uClibcpp/extra/config/zconf.tab.c
// Function: zconfdump
void zconfdump(FILE *out)
{
	struct property *prop;
	struct symbol *sym;
	struct menu *menu;

	menu = rootmenu.list;
	while (menu) {
		if ((sym = menu->sym))
			print_symbol(out, menu);
		else if ((prop = menu->prompt)) {
			switch (prop->type) {
			case P_COMMENT:
				fputs("\ncomment ", out);
				print_quoted_string(out, prop->text);
				fputs("\n", out);
				break;
			case P_MENU:
				fputs("\nmenu ", out);
				print_quoted_string(out, prop->text);
				fputs("\n", out);
				break;
			default:
				;
			}
			if (!expr_is_yes(prop->visible.expr)) {
				fputs("  depends ", out);
				expr_fprint(prop->visible.expr, out);
				fputc('\n', out);
			}
			fputs("\n", out);
		}

		if (menu->list)
			menu = menu->list;
		else if (menu->next)
			menu = menu->next;
		else while ((menu = menu->parent)) {
			if (menu->prompt && menu->prompt->type == P_MENU)
				fputs("\nendmenu\n", out);
			if (menu->next) {
				menu = menu->next;
				break;
			}
		}
	}
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rdi, %rbx
movq 0xe339(%rip), %rax      # 0x144d8
leaq 0x953d(%rip), %r15      # 0xf6e3
leaq 0x9529(%rip), %r14      # 0xf6d6
leaq 0x954b(%rip), %r12      # 0xf6ff
testq %rax, %rax
je 0x6297
movq %rax, %r13
cmpq $0x0, 0x18(%rax)
je 0x61d4
movq %rbx, %rdi
movq %r13, %rsi
callq 0x5fbc
jmp 0x6251
movq 0x20(%r13), %rbp
testq %rbp, %rbp
je 0x6251
movl 0x10(%rbp), %eax
movq %r15, %rdi
cmpl $0x2, %eax
je 0x61f4
cmpl $0x3, %eax
jne 0x6213
leaq 0x94f9(%rip), %rdi      # 0xf6ed
movq %rbx, %rsi
callq 0x2120
movq 0x18(%rbp), %rsi
movq %rbx, %rdi
callq 0x5f2f
movq %r14, %rdi
movq %rbx, %rsi
callq 0x2120
movq 0x20(%rbp), %rdi
callq 0x6158
testl %eax, %eax
jne 0x6246
leaq 0x94cd(%rip), %rdi      # 0xf6f4
movq %rbx, %rsi
callq 0x2120
movq 0x20(%rbp), %rdi
movq %rbx, %rsi
callq 0x6179
pushq $0xa
popq %rdi
movq %rbx, %rsi
callq 0x2140
movq %r14, %rdi
movq %rbx, %rsi
callq 0x2120
movq 0x10(%r13), %rax
testq %rax, %rax
jne 0x61b4
jmp 0x627a
movq 0x20(%r13), %rax
testq %rax, %rax
je 0x627a
cmpl $0x3, 0x10(%rax)
jne 0x627a
movq %r12, %rdi
movq %rbx, %rsi
callq 0x2120
movq (%r13), %rax
testq %rax, %rax
jne 0x61b4
movq 0x8(%r13), %r13
testq %r13, %r13
jne 0x6260
xorl %eax, %eax
jmp 0x61b4
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/saltyJeff[P]uClibcpp/extra/config/lex.zconf.c
// Function: new_string
void new_string(void)
{
	text = malloc(START_STRSIZE);
	text_asize = START_STRSIZE;
	text_ptr = text;
	text_size = 0;
	*text_ptr = 0;
}

// Assembly:
pushq %rax
pushq $0x10
popq %rdi
callq 0x2230
movq %rax, 0xea92(%rip)      # 0x14d48
movl $0x10, 0xea90(%rip)     # 0x14d50
movq %rax, 0xea91(%rip)      # 0x14d58
andl $0x0, 0xea92(%rip)      # 0x14d60
movb $0x0, (%rax)
popq %rax
retq