LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O0/ramirezsebas[P]TP-LISTINGS/./src/capitulo_5/5.5/mmap-write.c
// Function: main
int main (int argc, char* const argv[])
{
  int fd;
  void* file_memory;

  /* Seed the random number generator.*/
  srand (time (NULL));

  /* Prepare a file large enough to hold an unsigned integer. */
  fd = open (argv[1], O_RDWR | O_CREAT, S_IRUSR | S_IWUSR);
  lseek (fd, FILE_LENGTH+1, SEEK_SET);
  write (fd, "", 1);
  lseek (fd, 0, SEEK_SET);

  /* Create the memory mapping. */
  file_memory = mmap (0, FILE_LENGTH, PROT_WRITE, MAP_SHARED, fd, 0);
  close (fd);
  /* Write a random integer to memory-mapped area. */
  sprintf((char*) file_memory, "%d\n", random_range (-100, 100));

  /* Release the memory (unnecessary because the program exits). */
  munmap (file_memory, FILE_LENGTH);

  return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movl $0x0, -0x4(%rbp)
movl %edi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
xorl %eax, %eax
movl %eax, %edi
callq 0x1080
movl %eax, %edi
callq 0x1070
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rdi
movl $0x42, %esi
movl $0x180, %edx            # imm = 0x180
movb $0x0, %al
callq 0x10a0
movl %eax, -0x14(%rbp)
movl -0x14(%rbp), %edi
movl $0x101, %esi            # imm = 0x101
xorl %edx, %edx
callq 0x1050
movl -0x14(%rbp), %edi
leaq 0xd88(%rip), %rsi       # 0x2013
movl $0x1, %edx
callq 0x1030
movl -0x14(%rbp), %edi
xorl %eax, %eax
movl %eax, %esi
xorl %edx, %edx
callq 0x1050
movl -0x14(%rbp), %r8d
xorl %eax, %eax
movl %eax, %r9d
movl $0x100, %esi            # imm = 0x100
movl $0x2, %edx
movl $0x1, %ecx
movq %r9, %rdi
callq 0x1040
movq %rax, -0x20(%rbp)
movl -0x14(%rbp), %edi
callq 0x1060
movq -0x20(%rbp), %rax
movq %rax, -0x28(%rbp)
movl $0xffffff9c, %edi       # imm = 0xFFFFFF9C
movl $0x64, %esi
callq 0x11d0
movq -0x28(%rbp), %rdi
movl %eax, %edx
leaq 0xd1d(%rip), %rsi       # 0x2010
movb $0x0, %al
callq 0x10b0
movq -0x20(%rbp), %rdi
movl $0x100, %esi            # imm = 0x100
callq 0x1090
xorl %eax, %eax
addq $0x30, %rsp
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O0/vanhauser-thc[P]vulntest/tricky.c
// Function: main
int main(int argc, char *argv[]) {
  char buf[128];
  int user_len = atoi(argv[2]);
  int buf_size = sizeof(buf);

  if (user_len > buf_size) {
    printf("Attempted Overflow Detected\n");
    return -1;
  }

  memcpy(buf, argv[1], user_len);
  if (buf[0] != 0)
    return 0;
  else
    return -1;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0xa0, %rsp
movl $0x0, -0x4(%rbp)
movl %edi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x10(%rbp), %rax
movq 0x10(%rax), %rdi
callq 0x1050
movl %eax, -0x94(%rbp)
movl $0x80, -0x98(%rbp)
movl -0x94(%rbp), %eax
cmpl -0x98(%rbp), %eax
jle 0x11bb
leaq 0xe59(%rip), %rdi       # 0x2004
movb $0x0, %al
callq 0x1030
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
jmp 0x11f2
leaq -0x90(%rbp), %rdi
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rsi
movslq -0x94(%rbp), %rdx
callq 0x1040
movsbl -0x90(%rbp), %eax
cmpl $0x0, %eax
je 0x11eb
movl $0x0, -0x4(%rbp)
jmp 0x11f2
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
movl -0x4(%rbp), %eax
addq $0xa0, %rsp
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O0/simh[P]simtools/crossassemblers/macro8x/macro8x.c
// Function: lexemeToName
char *lexemeToName( char *name, WORD32 from, WORD32 term )
{
  WORD32  to;

  to = 0;

  while( from < term && to < ( SYMLEN - 1 ))
  {
    name[to++] = toupper( line[from++] );
  }

  while( to < SYMLEN )
  {
    name[to++] = '\0';
  }
  return( name );
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movl %edx, -0x10(%rbp)
movl $0x0, -0x14(%rbp)
movl -0xc(%rbp), %ecx
xorl %eax, %eax
cmpl -0x10(%rbp), %ecx
movb %al, -0x15(%rbp)
jge 0x4cc0
cmpl $0x6, -0x14(%rbp)
setl %al
movb %al, -0x15(%rbp)
movb -0x15(%rbp), %al
testb $0x1, %al
jne 0x4cc9
jmp 0x4d00
movl -0xc(%rbp), %eax
movl %eax, %ecx
addl $0x1, %ecx
movl %ecx, -0xc(%rbp)
movslq %eax, %rcx
leaq 0xb4c2(%rip), %rax      # 0x101a0
movsbl (%rax,%rcx), %edi
callq 0x2080
movb %al, %dl
movq -0x8(%rbp), %rax
movl -0x14(%rbp), %ecx
movl %ecx, %esi
addl $0x1, %esi
movl %esi, -0x14(%rbp)
movslq %ecx, %rcx
movb %dl, (%rax,%rcx)
jmp 0x4ca9
jmp 0x4d02
cmpl $0x7, -0x14(%rbp)
jge 0x4d20
movq -0x8(%rbp), %rax
movl -0x14(%rbp), %ecx
movl %ecx, %edx
addl $0x1, %edx
movl %edx, -0x14(%rbp)
movslq %ecx, %rcx
movb $0x0, (%rax,%rcx)
jmp 0x4d02
movq -0x8(%rbp), %rax
addq $0x20, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/simh[P]simtools/crossassemblers/macro8x/macro8x.c
// Function: errorMessage
void errorMessage( EMSG_T *mesg, WORD32 col )
{
  char   linecol[12];

  if( pass == 2 )
  {
    errors++;
    sprintf( linecol, "(%d:%d)", lineno, col + 1 );
    fprintf( errorfile, "%s%-9s : error:  %s at Loc = %5.5o\n",
                                         filename, linecol, mesg->file, clc );
    saveError( mesg->list, col );
  }
  error_in_line = TRUE;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
cmpl $0x2, 0x85ba(%rip)      # 0xf2e0
jne 0x6d93
movl 0x85aa(%rip), %eax      # 0xf2d8
addl $0x1, %eax
movl %eax, 0x85a1(%rip)      # 0xf2d8
leaq -0x18(%rbp), %rdi
movl 0x943f(%rip), %edx      # 0x10180
movl -0xc(%rbp), %ecx
addl $0x1, %ecx
leaq 0x2bea(%rip), %rsi      # 0x9938
movb $0x0, %al
callq 0x2160
movq 0x8574(%rip), %rdi      # 0xf2d0
leaq -0x18(%rbp), %rcx
movq -0x8(%rbp), %rax
movq 0x8(%rax), %r8
movl 0x87e1(%rip), %r9d      # 0xf550
leaq 0x2bf3(%rip), %rsi      # 0x9969
leaq 0x8753(%rip), %rdx      # 0xf4d0
movb $0x0, %al
callq 0x2110
movq -0x8(%rbp), %rax
movq (%rax), %rdi
movl -0xc(%rbp), %esi
callq 0x8590
movb $0x1, 0x958a(%rip)      # 0x10324
addq $0x20, %rsp
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O0/simh[P]simtools/crossassemblers/macro8x/macro8x.c
// Function: punchObject
void punchObject( WORD32 val )
{
  val &= 0377;
  if( objectfile != NULL )
  {
    fputc( val, objectfile );
    checksum += val;
  }
  binary_data_output = TRUE;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movl %edi, -0x4(%rbp)
movl -0x4(%rbp), %eax
andl $0xff, %eax
movl %eax, -0x4(%rbp)
cmpq $0x0, 0x7352(%rip)      # 0xf390
je 0x805e
movl -0x4(%rbp), %edi
movq 0x7346(%rip), %rsi      # 0xf390
callq 0x20d0
movl -0x4(%rbp), %eax
addl 0x72a8(%rip), %eax      # 0xf300
movl %eax, 0x72a2(%rip)      # 0xf300
movb $0x1, 0x51db(%rip)      # 0xd240
addq $0x10, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/antonblanchard[P]will-it-scale/tests/readseek3.c
// Function: testcase
void testcase(unsigned long long *iterations, unsigned long nr)
{
	char buf[BUFLEN];
	int fd = open(tmpfile, O_RDONLY);
	unsigned long offset = getpagesize() * nr;

	assert(fd >= 0);

	while (1) {
		lseek(fd, offset, SEEK_SET);
		assert(read(fd, buf, BUFLEN) == BUFLEN);

		(*iterations)++;
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x1020, %rsp           # imm = 0x1020
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
leaq 0x30a6(%rip), %rdi      # 0x61a0
xorl %esi, %esi
movb $0x0, %al
callq 0x2220
movl %eax, -0x1014(%rbp)
callq 0x2290
cltq
imulq -0x10(%rbp), %rax
movq %rax, -0x1020(%rbp)
cmpl $0x0, -0x1014(%rbp)
jl 0x3127
jmp 0x3146
leaq 0x1163(%rip), %rdi      # 0x4291
leaq 0x1164(%rip), %rsi      # 0x4299
movl $0x24, %edx
leaq 0x1195(%rip), %rcx      # 0x42d6
callq 0x2120
jmp 0x3148
movl -0x1014(%rbp), %edi
movq -0x1020(%rbp), %rsi
xorl %edx, %edx
callq 0x2110
movl -0x1014(%rbp), %edi
leaq -0x1010(%rbp), %rsi
movl $0x1000, %edx           # imm = 0x1000
callq 0x2160
cmpq $0x1000, %rax           # imm = 0x1000
jne 0x317d
jmp 0x319c
leaq 0x1185(%rip), %rdi      # 0x4309
leaq 0x110e(%rip), %rsi      # 0x4299
movl $0x28, %edx
leaq 0x113f(%rip), %rcx      # 0x42d6
callq 0x2120
movq -0x8(%rbp), %rax
movq (%rax), %rcx
addq $0x1, %rcx
movq %rcx, (%rax)
jmp 0x3148
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/wuxb45[P]SLB/map_test.c
// Function: test_kvmap
static int
test_kvmap(const int argc, char ** const argv)
{
  struct oalloc * const oa = oalloc_create();
  debug_assert(oa);
  struct kvmap_mm mm = { .af = (kv_alloc_func)oalloc_alloc, .ap = oa, };
  //struct kvmap_mm mm = { .af = kv_alloc_malloc, .rf = kv_retire_free, };
  struct kvmap_api * api = NULL;
  const int n1 = kvmap_api_helper(argc, argv, &api, &mm, false);
  if (n1 < 0) {
    kvmap_help_message();
    oalloc_destroy(oa);
    return n1;
  }

  char *pref[64] = {};
  for (int i = 0; i < n1; i++) {
    pref[i] = argv[i];
  }
  pref[n1] = NULL;

  struct pass_info pi = {};
  pi.api = api;
  pi.vctr_size = 8;
  pi.wf = kvmap_worker;
  pi.af = kvmap_analyze;
  const int n2 = maptest_passes(argc - n1, argv + n1, pref, &pi);

  kvmap_api_destroy(api);
  oalloc_destroy(oa);
  if (n2 < 0) {
    kvmap_help_message();
    return n2;
  } else {
    return n1 + n2;
  }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x2c0, %rsp            # imm = 0x2C0
movl %edi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
callq 0x8d70
movq %rax, -0x18(%rbp)
cmpq $0x0, -0x18(%rbp)
setne %al
movzbl %al, %edi
andl $0x1, %edi
callq 0x7560
leaq -0x68(%rbp), %rdi
xorl %esi, %esi
movl $0x50, %edx
callq 0x61f0
leaq 0x265b(%rip), %rax      # 0x8de0
movq %rax, -0x68(%rbp)
movq -0x18(%rbp), %rax
movq %rax, -0x60(%rbp)
movq $0x0, -0x70(%rbp)
movl -0x8(%rbp), %edi
movq -0x10(%rbp), %rsi
leaq -0x70(%rbp), %rdx
leaq -0x68(%rbp), %rcx
xorl %r8d, %r8d
callq 0xe460
movl %eax, -0x74(%rbp)
cmpl $0x0, -0x74(%rbp)
jge 0x67d2
callq 0x68f0
movq -0x18(%rbp), %rdi
callq 0x9040
movl -0x74(%rbp), %eax
movl %eax, -0x4(%rbp)
jmp 0x68e3
leaq -0x280(%rbp), %rdi
xorl %esi, %esi
movl $0x200, %edx            # imm = 0x200
callq 0x61f0
movl $0x0, -0x284(%rbp)
movl -0x284(%rbp), %eax
cmpl -0x74(%rbp), %eax
jge 0x6829
movq -0x10(%rbp), %rax
movslq -0x284(%rbp), %rcx
movq (%rax,%rcx,8), %rcx
movslq -0x284(%rbp), %rax
movq %rcx, -0x280(%rbp,%rax,8)
movl -0x284(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x284(%rbp)
jmp 0x67ef
movslq -0x74(%rbp), %rax
movq $0x0, -0x280(%rbp,%rax,8)
leaq -0x2b0(%rbp), %rdi
xorl %esi, %esi
movl $0x28, %edx
callq 0x61f0
movq -0x70(%rbp), %rax
movq %rax, -0x2a8(%rbp)
movq $0x8, -0x2a0(%rbp)
leaq 0xd7(%rip), %rax        # 0x6940
movq %rax, -0x298(%rbp)
leaq 0x1b9(%rip), %rax       # 0x6a30
movq %rax, -0x290(%rbp)
movl -0x8(%rbp), %edi
subl -0x74(%rbp), %edi
movq -0x10(%rbp), %rsi
movslq -0x74(%rbp), %rax
shlq $0x3, %rax
addq %rax, %rsi
leaq -0x280(%rbp), %rdx
leaq -0x2b0(%rbp), %rcx
callq 0x17190
movl %eax, -0x2b4(%rbp)
movq -0x70(%rbp), %rdi
callq 0xe340
movq -0x18(%rbp), %rdi
callq 0x9040
cmpl $0x0, -0x2b4(%rbp)
jge 0x68d7
callq 0x68f0
movl -0x2b4(%rbp), %eax
movl %eax, -0x4(%rbp)
jmp 0x68e3
movl -0x74(%rbp), %eax
addl -0x2b4(%rbp), %eax
movl %eax, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x2c0, %rsp            # imm = 0x2C0
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/wuxb45[P]SLB/map_test.c
// Function: kvmap_help_message
static void
kvmap_help_message(void)
{
  fprintf(stderr, "%s Usage: <stdout> <stderr> {api ... {rgen ... {pass ...}}}\n", __func__);
  kvmap_api_helper_message();
  maptest_passes_message();
  fprintf(stderr, "set MAP_TEST_PERF=y to enable perf recording\n");
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq 0x1a6fd(%rip), %rax     # 0x20ff8
movq (%rax), %rdi
leaq 0x13753(%rip), %rsi     # 0x1a058
leaq 0x13789(%rip), %rdx     # 0x1a095
movb $0x0, %al
callq 0x62d0
callq 0xe380
callq 0x173e0
movq 0x1a6d4(%rip), %rax     # 0x20ff8
movq (%rax), %rdi
leaq 0x1377a(%rip), %rsi     # 0x1a0a8
movb $0x0, %al
callq 0x62d0
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/wuxb45[P]SLB/map_test.c
// Function: kvmap_worker
static void *
kvmap_worker(void * const ptr)
{
  struct maptest_worker_info * const info = (typeof(info))ptr;
  const u64 end_magic = info->end_magic;
  info->priv = malloc(2048);
  srandom_u64(info->seed);
  if (info->end_type == MAPTEST_END_TIME) {
    do {
      kvmap_mix_batch(info, 4096);
    } while (time_nsec() < end_magic);
  } else if (info->end_type == MAPTEST_END_COUNT) {
    u64 count = 0;
    do {
      const u64 nr = (end_magic - count) > 4096 ? 4096 : (end_magic - count);
      kvmap_mix_batch(info, nr);
      count += nr;
    } while (count < end_magic);
  }
  free(info->priv);
  return NULL;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x10(%rbp)
movq -0x10(%rbp), %rax
movq 0x50(%rax), %rax
movq %rax, -0x18(%rbp)
movl $0x800, %edi            # imm = 0x800
callq 0x6370
movq %rax, %rcx
movq -0x10(%rbp), %rax
movq %rcx, 0x58(%rax)
movq -0x10(%rbp), %rax
movq 0x20(%rax), %rdi
callq 0xb140
movq -0x10(%rbp), %rax
cmpq $0x0, 0x48(%rax)
jne 0x69aa
jmp 0x698f
movq -0x10(%rbp), %rdi
movl $0x1000, %esi           # imm = 0x1000
callq 0x6b60
callq 0x71c0
cmpq -0x18(%rbp), %rax
jb 0x698f
jmp 0x6a13
movq -0x10(%rbp), %rax
cmpq $0x1, 0x48(%rax)
jne 0x6a11
movq $0x0, -0x20(%rbp)
movq -0x18(%rbp), %rax
subq -0x20(%rbp), %rax
cmpq $0x1000, %rax           # imm = 0x1000
jbe 0x69d8
movl $0x1000, %eax           # imm = 0x1000
movq %rax, -0x30(%rbp)
jmp 0x69e4
movq -0x18(%rbp), %rax
subq -0x20(%rbp), %rax
movq %rax, -0x30(%rbp)
movq -0x30(%rbp), %rax
movq %rax, -0x28(%rbp)
movq -0x10(%rbp), %rdi
movq -0x28(%rbp), %rsi
callq 0x6b60
movq -0x28(%rbp), %rax
addq -0x20(%rbp), %rax
movq %rax, -0x20(%rbp)
movq -0x20(%rbp), %rax
cmpq -0x18(%rbp), %rax
jb 0x69bd
jmp 0x6a11
jmp 0x6a13
movq -0x10(%rbp), %rax
movq 0x58(%rax), %rdi
callq 0x6060
xorl %eax, %eax
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/wuxb45[P]SLB/map_test.c
// Function: kvmap_analyze
static bool
kvmap_analyze(struct vctr * const va, const double dt, struct damp * const damp, char * const out)
{
  u64 v[8];
  for (u64 i = 0; i < 8; i++) {
    v[i] = vctr_get(va, i);
  }

  const u64 nrop = v[XSA] + v[XDA] + v[XGA] + v[XPA];
  const double mops = ((double)nrop) / (dt * 1.0e6);
  const bool done = damp_add_test(damp, mops);
  const double havg = damp_average(damp);
  const char * const pat = " set %"PRIu64" %"PRIu64" del %"PRIu64" %"PRIu64
      " get %"PRIu64" %"PRIu64" pro %"PRIu64" %"PRIu64" mops %.4lf havg %.4lf\n";
  sprintf(out, pat, v[XSA], v[XSS], v[XDA], v[XDS], v[XGA], v[XGS], v[XPA], v[XPS], mops, havg);
  return done;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %rbx
subq $0xb8, %rsp
movq %rdi, -0x10(%rbp)
vmovsd %xmm0, -0x18(%rbp)
movq %rsi, -0x20(%rbp)
movq %rdx, -0x28(%rbp)
movq $0x0, -0x78(%rbp)
cmpq $0x8, -0x78(%rbp)
jae 0x6a83
movq -0x10(%rbp), %rdi
movq -0x78(%rbp), %rsi
callq 0xafa0
movq %rax, %rcx
movq -0x78(%rbp), %rax
movq %rcx, -0x70(%rbp,%rax,8)
movq -0x78(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x78(%rbp)
jmp 0x6a55
movq -0x70(%rbp), %rax
addq -0x60(%rbp), %rax
addq -0x50(%rbp), %rax
addq -0x40(%rbp), %rax
movq %rax, -0x80(%rbp)
vcvtusi2sdq -0x80(%rbp), %xmm0, %xmm0
vmovsd 0x13562(%rip), %xmm1    # 0x1a008
vmulsd -0x18(%rbp), %xmm1, %xmm1
vdivsd %xmm1, %xmm0, %xmm0
vmovsd %xmm0, -0x88(%rbp)
movq -0x20(%rbp), %rdi
vmovsd -0x88(%rbp), %xmm0
callq 0xab00
andb $0x1, %al
movb %al, -0x89(%rbp)
movq -0x20(%rbp), %rdi
callq 0xa890
vmovsd %xmm0, -0x98(%rbp)
leaq 0x13528(%rip), %rax     # 0x1a010
movq %rax, -0xa0(%rbp)
movq -0x28(%rbp), %rdi
movq -0x70(%rbp), %rdx
movq -0x68(%rbp), %rcx
movq -0x60(%rbp), %r8
movq -0x58(%rbp), %r9
movq -0x50(%rbp), %rbx
movq -0x48(%rbp), %r11
movq -0x40(%rbp), %r10
movq -0x38(%rbp), %rax
vmovsd -0x88(%rbp), %xmm0
vmovsd -0x98(%rbp), %xmm1
leaq 0x134e6(%rip), %rsi     # 0x1a010
movq %rbx, (%rsp)
movq %r11, 0x8(%rsp)
movq %r10, 0x10(%rsp)
movq %rax, 0x18(%rsp)
movb $0x2, %al
callq 0x64e0
movb -0x89(%rbp), %al
andb $0x1, %al
addq $0xb8, %rsp
popq %rbx
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/openshmem-org[P]openshmem-examples/c/cswap.c
// Function: main
int
main()
{
    static int race_winner = -1;
    int oldval;
    int me;

    shmem_init();
    me = shmem_my_pe();

    oldval = shmem_int_atomic_compare_swap(&race_winner, -1, me, 0);

    if (oldval == -1) {
        printf("pe %d was first\n", me);
    }

    shmem_finalize();

    return 0;
}

// Assembly:
subq $0x18, %rsp
movl $0x0, 0x14(%rsp)
callq 0x1060
callq 0x1050
movl %eax, 0xc(%rsp)
movl 0xc(%rsp), %edx
leaq 0x2eab(%rip), %rdi      # 0x4050
movl $0xffffffff, %esi       # imm = 0xFFFFFFFF
xorl %ecx, %ecx
callq 0x1070
movl %eax, 0x10(%rsp)
cmpl $-0x1, 0x10(%rsp)
jne 0x11ce
movl 0xc(%rsp), %esi
leaq 0xe3d(%rip), %rdi       # 0x2004
movb $0x0, %al
callq 0x1030
callq 0x1040
xorl %eax, %eax
addq $0x18, %rsp
retq
// File: /workspace/github_c_makefile_star2_O0/cktan[P]tomlc99/toml_sample.c
// Function: main
int main() {
  FILE *fp;
  char errbuf[200];

  // 1. Read and parse toml file
  fp = fopen("sample.toml", "r");
  if (!fp) {
    fatal("cannot open sample.toml - ", strerror(errno));
  }

  toml_table_t *conf = toml_parse_file(fp, errbuf, sizeof(errbuf));
  fclose(fp);

  if (!conf) {
    fatal("cannot parse - ", errbuf);
  }

  // 2. Traverse to a table.
  toml_table_t *server = toml_table_in(conf, "server");
  if (!server) {
    fatal("missing [server]", "");
  }

  // 3. Extract values
  toml_datum_t host = toml_string_in(server, "host");
  if (!host.ok) {
    fatal("cannot read server.host", "");
  }

  toml_array_t *portarray = toml_array_in(server, "port");
  if (!portarray) {
    fatal("cannot read server.port", "");
  }

  printf("host: %s\n", host.u.s);
  printf("port: ");
  for (int i = 0;; i++) {
    toml_datum_t port = toml_int_at(portarray, i);
    if (!port.ok)
      break;
    printf("%d ", (int)port.u.i);
  }
  printf("\n");

  // 4. Free memory
  free(host.u.s);
  toml_free(conf);
  return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x120, %rsp            # imm = 0x120
movl $0x0, -0x4(%rbp)
leaq 0x6d2b(%rip), %rdi      # 0x8004
leaq 0x7357(%rip), %rsi      # 0x8637
callq 0x1170
movq %rax, -0x10(%rbp)
cmpq $0x0, -0x10(%rbp)
jne 0x130b
callq 0x1040
movl (%rax), %edi
callq 0x1190
movq %rax, %rsi
leaq 0x6d0a(%rip), %rdi      # 0x8010
callq 0x14b0
movq -0x10(%rbp), %rdi
leaq -0xe0(%rbp), %rsi
movl $0xc8, %edx
callq 0x2be0
movq %rax, -0xe8(%rbp)
movq -0x10(%rbp), %rdi
callq 0x1090
cmpq $0x0, -0xe8(%rbp)
jne 0x134d
leaq -0xe0(%rbp), %rsi
leaq 0x6ce3(%rip), %rdi      # 0x802b
callq 0x14b0
movq -0xe8(%rbp), %rdi
leaq 0x6ce0(%rip), %rsi      # 0x803b
callq 0x3210
movq %rax, -0xf0(%rbp)
cmpq $0x0, -0xf0(%rbp)
jne 0x1384
leaq 0x6cca(%rip), %rdi      # 0x8042
leaq 0x73a6(%rip), %rsi      # 0x8725
callq 0x14b0
movq -0xf0(%rbp), %rdi
leaq 0x6cd4(%rip), %rsi      # 0x8066
callq 0x4d10
movl %eax, -0x100(%rbp)
movq %rdx, -0xf8(%rbp)
cmpl $0x0, -0x100(%rbp)
jne 0x13c0
leaq 0x6c9f(%rip), %rdi      # 0x8053
leaq 0x736a(%rip), %rsi      # 0x8725
callq 0x14b0
movq -0xf0(%rbp), %rdi
leaq 0x6cb0(%rip), %rsi      # 0x807e
callq 0x3190
movq %rax, -0x108(%rbp)
cmpq $0x0, -0x108(%rbp)
jne 0x13f7
leaq 0x6c80(%rip), %rdi      # 0x806b
leaq 0x7333(%rip), %rsi      # 0x8725
callq 0x14b0
movq -0xf8(%rbp), %rsi
leaq 0x6c7e(%rip), %rdi      # 0x8083
movb $0x0, %al
callq 0x10c0
leaq 0x6c7a(%rip), %rdi      # 0x808d
movb $0x0, %al
callq 0x10c0
movl $0x0, -0x10c(%rbp)
movq -0x108(%rbp), %rdi
movl -0x10c(%rbp), %esi
callq 0x4ae0
movl %eax, -0x120(%rbp)
movq %rdx, -0x118(%rbp)
cmpl $0x0, -0x120(%rbp)
jne 0x144e
jmp 0x1476
movq -0x118(%rbp), %rax
movl %eax, %esi
leaq 0x6c36(%rip), %rdi      # 0x8094
movb $0x0, %al
callq 0x10c0
movl -0x10c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x10c(%rbp)
jmp 0x1424
leaq 0x72a7(%rip), %rdi      # 0x8724
movb $0x0, %al
callq 0x10c0
movq -0xf8(%rbp), %rdi
callq 0x1030
movq -0xe8(%rbp), %rdi
callq 0x2bc0
xorl %eax, %eax
addq $0x120, %rsp            # imm = 0x120
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/aparrish[P]rwet-examples-c/forfinder.c
// Function: main
int main(int argc, char** argv) {
	char* target_pos;
	char* line = NULL;
	int len;

	if (argc != 2) {
		fprintf(stderr, "please supply target string\n");
		exit(-1);
	}

	while (!feof(stdin)) {
		len = ap_getline(&line, stdin);
		target_pos = strstr(line, argv[1]);
		if (target_pos) printf("%s", target_pos);
		free(line);
	}

	return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movl $0x0, -0x4(%rbp)
movl %edi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq $0x0, -0x20(%rbp)
cmpl $0x2, -0x8(%rbp)
je 0x1206
movq 0x2e0d(%rip), %rax      # 0x3ff8
movq (%rax), %rdi
leaq 0xe0f(%rip), %rsi       # 0x2004
movb $0x0, %al
callq 0x1050
movl $0xffffffff, %edi       # imm = 0xFFFFFFFF
callq 0x1090
jmp 0x1208
movq 0x2dc9(%rip), %rax      # 0x3fd8
movq (%rax), %rdi
callq 0x1060
cmpl $0x0, %eax
setne %al
xorb $-0x1, %al
testb $0x1, %al
jne 0x1225
jmp 0x1274
movq 0x2dac(%rip), %rax      # 0x3fd8
movq (%rax), %rsi
leaq -0x20(%rbp), %rdi
callq 0x1280
movl %eax, -0x24(%rbp)
movq -0x20(%rbp), %rdi
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rsi
callq 0x10b0
movq %rax, -0x18(%rbp)
cmpq $0x0, -0x18(%rbp)
je 0x1269
movq -0x18(%rbp), %rsi
leaq 0xdbf(%rip), %rdi       # 0x2021
movb $0x0, %al
callq 0x1040
movq -0x20(%rbp), %rdi
callq 0x1030
jmp 0x1208
xorl %eax, %eax
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/hansvanstaveren[P]BigDeal/rmd160.c
// Function: MDinit
void MDinit(dword *MDbuf)
{
   MDbuf[0] = 0x67452301UL;
   MDbuf[1] = 0xefcdab89UL;
   MDbuf[2] = 0x98badcfeUL;
   MDbuf[3] = 0x10325476UL;
   MDbuf[4] = 0xc3d2e1f0UL;

   return;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movl $0x67452301, (%rax)     # imm = 0x67452301
movq -0x8(%rbp), %rax
movl $0xefcdab89, 0x4(%rax)  # imm = 0xEFCDAB89
movq -0x8(%rbp), %rax
movl $0x98badcfe, 0x8(%rax)  # imm = 0x98BADCFE
movq -0x8(%rbp), %rax
movl $0x10325476, 0xc(%rax)  # imm = 0x10325476
movq -0x8(%rbp), %rax
movl $0xc3d2e1f0, 0x10(%rax) # imm = 0xC3D2E1F0
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O0/hansvanstaveren[P]BigDeal/rmd160.c
// Function: MDfinish
void MDfinish(dword *MDbuf, byte *strptr, dword lswlen, dword mswlen)
{
   unsigned int i;                                 /* counter       */
   dword        X[16];                             /* message words */

   memset(X, 0, 16*sizeof(dword));

   /* put bytes from strptr into X */
   for (i=0; i<(lswlen&63); i++) {
      /* byte i goes into word X[i div 4] at pos.  8*(i mod 4)  */
      X[i>>2] ^= (dword) *strptr++ << (8 * (i&3));
   }

   /* append the bit m_n == 1 */
   X[(lswlen>>2)&15] ^= (dword)1 << (8*(lswlen&3) + 7);

   if ((lswlen & 63) > 55) {
      /* length goes to next block */
      compress(MDbuf, X);
      memset(X, 0, 16*sizeof(dword));
   }

   /* append length in bits*/
   X[14] = lswlen << 3;
   X[15] = (lswlen >> 29) | (mswlen << 3);
   compress(MDbuf, X);

   return;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x60, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl %edx, -0x14(%rbp)
movl %ecx, -0x18(%rbp)
leaq -0x60(%rbp), %rdi
xorl %esi, %esi
movl $0x40, %edx
callq 0x20d0
movl $0x0, -0x1c(%rbp)
movl -0x1c(%rbp), %eax
movl -0x14(%rbp), %ecx
andl $0x3f, %ecx
cmpl %ecx, %eax
jae 0x54b4
movq -0x10(%rbp), %rax
movq %rax, %rcx
addq $0x1, %rcx
movq %rcx, -0x10(%rbp)
movzbl (%rax), %eax
movl -0x1c(%rbp), %ecx
andl $0x3, %ecx
shll $0x3, %ecx
shll %cl, %eax
movl %eax, %ecx
movl -0x1c(%rbp), %eax
shrl $0x2, %eax
movl %eax, %eax
xorl -0x60(%rbp,%rax,4), %ecx
movl %ecx, -0x60(%rbp,%rax,4)
movl -0x1c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x1c(%rbp)
jmp 0x546d
movl -0x14(%rbp), %ecx
andl $0x3, %ecx
shll $0x3, %ecx
addl $0x7, %ecx
movl $0x1, %eax
shll %cl, %eax
movl %eax, %ecx
movl -0x14(%rbp), %eax
shrl $0x2, %eax
andl $0xf, %eax
movl %eax, %eax
xorl -0x60(%rbp,%rax,4), %ecx
movl %ecx, -0x60(%rbp,%rax,4)
movl -0x14(%rbp), %eax
andl $0x3f, %eax
cmpl $0x37, %eax
jbe 0x5504
movq -0x8(%rbp), %rdi
leaq -0x60(%rbp), %rsi
callq 0x2310
leaq -0x60(%rbp), %rdi
xorl %esi, %esi
movl $0x40, %edx
callq 0x20d0
movl -0x14(%rbp), %eax
shll $0x3, %eax
movl %eax, -0x28(%rbp)
movl -0x14(%rbp), %eax
shrl $0x1d, %eax
movl -0x18(%rbp), %ecx
shll $0x3, %ecx
orl %ecx, %eax
movl %eax, -0x24(%rbp)
movq -0x8(%rbp), %rdi
leaq -0x60(%rbp), %rsi
callq 0x2310
addq $0x60, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/hansvanstaveren[P]BigDeal/mp.c
// Function: mp96_add
int
mp96_add(byte *b,byte *b1,byte *b2)
/*
 * Computes b=b1+b2
 * returns carry bit signifying overflow
 */
{
	int i;
	unsigned int h,carry;

	carry = 0;
	for (i=L-1; i>=0; i--) {
		h = b1[i]+b2[i]+carry;
		carry = h>=256 ? 1 : 0;
		b[i] = h;		/* Truncates to 8 bits automatically */
	}
	return carry;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movl $0x0, -0x24(%rbp)
movl $0xb, -0x1c(%rbp)
cmpl $0x0, -0x1c(%rbp)
jl 0x5645
movq -0x10(%rbp), %rax
movslq -0x1c(%rbp), %rcx
movzbl (%rax,%rcx), %eax
movq -0x18(%rbp), %rcx
movslq -0x1c(%rbp), %rdx
movzbl (%rcx,%rdx), %ecx
addl %ecx, %eax
addl -0x24(%rbp), %eax
movl %eax, -0x20(%rbp)
movl -0x20(%rbp), %edx
xorl %eax, %eax
movl $0x1, %ecx
cmpl $0x100, %edx            # imm = 0x100
cmovael %ecx, %eax
movl %eax, -0x24(%rbp)
movl -0x20(%rbp), %eax
movb %al, %dl
movq -0x8(%rbp), %rax
movslq -0x1c(%rbp), %rcx
movb %dl, (%rax,%rcx)
movl -0x1c(%rbp), %eax
addl $-0x1, %eax
movl %eax, -0x1c(%rbp)
jmp 0x55ee
movl -0x24(%rbp), %eax
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/hansvanstaveren[P]BigDeal/mp.c
// Function: mp96_sub
int
mp96_sub(byte *b,byte *b1,byte *b2)
/*
 * Computes b=b1-b2
 * returns borrow bit signifying overflow
 */
{
	int i,h;
	unsigned int borrow;

	borrow = 0;
	for (i=L-1; i>=0; i--) {
		h = b1[i]-b2[i]-borrow;
		borrow = h<0 ? 1 : 0;
		b[i] = h;
	}
	return borrow;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movl $0x0, -0x24(%rbp)
movl $0xb, -0x1c(%rbp)
cmpl $0x0, -0x1c(%rbp)
jl 0x56c2
movq -0x10(%rbp), %rax
movslq -0x1c(%rbp), %rcx
movzbl (%rax,%rcx), %eax
movq -0x18(%rbp), %rcx
movslq -0x1c(%rbp), %rdx
movzbl (%rcx,%rdx), %ecx
subl %ecx, %eax
subl -0x24(%rbp), %eax
movl %eax, -0x20(%rbp)
movl -0x20(%rbp), %edx
xorl %eax, %eax
movl $0x1, %ecx
cmpl $0x0, %edx
cmovll %ecx, %eax
movl %eax, -0x24(%rbp)
movl -0x20(%rbp), %eax
movb %al, %dl
movq -0x8(%rbp), %rax
movslq -0x1c(%rbp), %rcx
movb %dl, (%rax,%rcx)
movl -0x1c(%rbp), %eax
addl $-0x1, %eax
movl %eax, -0x1c(%rbp)
jmp 0x566e
movl -0x24(%rbp), %eax
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/hansvanstaveren[P]BigDeal/mp.c
// Function: mp96_cmp
int
mp96_cmp(byte *b1, byte *b2)
/*
 * Compares b1 with b2
 * returns >0 when b1>b2, <0 when b1<b2, 0 when b1==b2
 */
 {
	int i;
	int diff;

	for (i=0; i<L; i++) {
		diff = b1[i] - b2[i];
		if (diff)
			return diff;
	}
	return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movl $0x0, -0x1c(%rbp)
cmpl $0xc, -0x1c(%rbp)
jge 0x5721
movq -0x10(%rbp), %rax
movslq -0x1c(%rbp), %rcx
movzbl (%rax,%rcx), %eax
movq -0x18(%rbp), %rcx
movslq -0x1c(%rbp), %rdx
movzbl (%rcx,%rdx), %ecx
subl %ecx, %eax
movl %eax, -0x20(%rbp)
cmpl $0x0, -0x20(%rbp)
je 0x5714
movl -0x20(%rbp), %eax
movl %eax, -0x4(%rbp)
jmp 0x5728
jmp 0x5716
movl -0x1c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x1c(%rbp)
jmp 0x56e3
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/hansvanstaveren[P]BigDeal/mp.c
// Function: mp96_mul
void
mp96_mul(byte *b,byte *b1,byte *b2)
/*
 * Computes b=b1*b2
 * overflow goes undetected
 */
{
	int i,j;
	unsigned int h,carry;
	byte b1copy[L],b2copy[L],bpart[L];

	/*
	 * Make copies of input in case one of the inputs is also output
	 */
	mp96_assign(b1copy, b1);
	mp96_assign(b2copy, b2);

	/*
	 * Here if an input is also output the input gets overwritten
	 */
	mp96_zero(b);

	for (i=L-1; i>=0; i--) {
		for (j=L-1; j>i; j--)
			bpart[j] = 0;
		carry=0;
		for (j=i; j>=0; j--) {
			h = b1copy[i]*b2copy[L-1+j-i]+carry;
			carry = h/256;
			bpart[j] = h;
		}
		(void) mp96_add(b,b,bpart);
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
leaq -0x34(%rbp), %rdi
movq -0x10(%rbp), %rsi
callq 0x55a0
leaq -0x40(%rbp), %rdi
movq -0x18(%rbp), %rsi
callq 0x55a0
movq -0x8(%rbp), %rdi
callq 0x5540
movl $0xb, -0x1c(%rbp)
cmpl $0x0, -0x1c(%rbp)
jl 0x5811
movl $0xb, -0x20(%rbp)
movl -0x20(%rbp), %eax
cmpl -0x1c(%rbp), %eax
jle 0x579b
movslq -0x20(%rbp), %rax
movb $0x0, -0x4c(%rbp,%rax)
movl -0x20(%rbp), %eax
addl $-0x1, %eax
movl %eax, -0x20(%rbp)
jmp 0x577f
movl $0x0, -0x28(%rbp)
movl -0x1c(%rbp), %eax
movl %eax, -0x20(%rbp)
cmpl $0x0, -0x20(%rbp)
jl 0x57f2
movslq -0x1c(%rbp), %rax
movzbl -0x34(%rbp,%rax), %eax
movl -0x20(%rbp), %ecx
addl $0xb, %ecx
subl -0x1c(%rbp), %ecx
movslq %ecx, %rcx
movzbl -0x40(%rbp,%rcx), %ecx
imull %ecx, %eax
addl -0x28(%rbp), %eax
movl %eax, -0x24(%rbp)
movl -0x24(%rbp), %eax
shrl $0x8, %eax
movl %eax, -0x28(%rbp)
movl -0x24(%rbp), %eax
movb %al, %cl
movslq -0x20(%rbp), %rax
movb %cl, -0x4c(%rbp,%rax)
movl -0x20(%rbp), %eax
addl $-0x1, %eax
movl %eax, -0x20(%rbp)
jmp 0x57a8
movq -0x8(%rbp), %rdi
movq -0x8(%rbp), %rsi
leaq -0x4c(%rbp), %rdx
callq 0x55d0
movl -0x1c(%rbp), %eax
addl $-0x1, %eax
movl %eax, -0x1c(%rbp)
jmp 0x576e
addq $0x50, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/hansvanstaveren[P]BigDeal/binomial.c
// Function: binomial_start
void
binomial_start(void)
/*
 * Precomputes all numbers (n over k) with k<=NCARDSPERHAND and
 * n<=NCARDSPERDECK.
 * Numbers are stored in pascal_triangle[][] with L bytes precision (96 bits)
 *
 * Calculation method is the addition from the top of the triangle
 * with the equation:
 * 	n_over_k(n,k) = n_over_k(n-1, k-1) + n_over_k(n-1, k)
 * except for some boundary condition situations
 */
{
	int i,j,min;

	for (i=0; i<=NCARDSPERDECK; i++) {
		if (i<NCARDSPERHAND)
			min = i;
		else
			min = NCARDSPERHAND;
		for (j=0; j<=min; j++) {
			if (i==j || j==0)
				mp96_one(pascal_triangle[i][j]);
			else
				mp96_add(pascal_triangle[i][j],
					   pascal_triangle[i-1][j],
					   pascal_triangle[i-1][j-1]);
		}
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movl $0x0, -0x4(%rbp)
cmpl $0x34, -0x4(%rbp)
jg 0x5927
cmpl $0xd, -0x4(%rbp)
jge 0x5847
movl -0x4(%rbp), %eax
movl %eax, -0xc(%rbp)
jmp 0x584e
movl $0xd, -0xc(%rbp)
movl $0x0, -0x8(%rbp)
movl -0x8(%rbp), %eax
cmpl -0xc(%rbp), %eax
jg 0x5917
movl -0x4(%rbp), %eax
cmpl -0x8(%rbp), %eax
je 0x586f
cmpl $0x0, -0x8(%rbp)
jne 0x5896
movslq -0x4(%rbp), %rax
leaq 0x7136(%rip), %rdi      # 0xc9b0
imulq $0xa8, %rax, %rax
addq %rax, %rdi
movslq -0x8(%rbp), %rax
imulq $0xc, %rax, %rax
addq %rax, %rdi
callq 0x5570
jmp 0x5907
movslq -0x4(%rbp), %rax
leaq 0x710f(%rip), %rdi      # 0xc9b0
imulq $0xa8, %rax, %rax
addq %rax, %rdi
movslq -0x8(%rbp), %rax
imulq $0xc, %rax, %rax
addq %rax, %rdi
movl -0x4(%rbp), %eax
subl $0x1, %eax
cltq
leaq 0x70eb(%rip), %rsi      # 0xc9b0
imulq $0xa8, %rax, %rax
addq %rax, %rsi
movslq -0x8(%rbp), %rax
imulq $0xc, %rax, %rax
addq %rax, %rsi
movl -0x4(%rbp), %eax
subl $0x1, %eax
cltq
leaq 0x70c7(%rip), %rdx      # 0xc9b0
imulq $0xa8, %rax, %rax
addq %rax, %rdx
movl -0x8(%rbp), %eax
subl $0x1, %eax
cltq
imulq $0xc, %rax, %rax
addq %rax, %rdx
callq 0x55d0
jmp 0x5909
movl -0x8(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x8(%rbp)
jmp 0x5855
jmp 0x5919
movl -0x4(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x4(%rbp)
jmp 0x582f
addq $0x10, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/hansvanstaveren[P]BigDeal/main.c
// Function: readline
static int
readline(FILE *ifile, char *buf, int len)
/*
 * Read line into buf
 * Check for length, discard trailing \n
 */
{
	char *eol;

	if(fgets(buf, len, ifile) == NULL)
		return 0;
	eol = strchr(buf, '\n');
	if (eol)
		*eol = 0;
	return 1;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movl %edx, -0x1c(%rbp)
movq -0x18(%rbp), %rdi
movl -0x1c(%rbp), %esi
movq -0x10(%rbp), %rdx
callq 0x2110
cmpq $0x0, %rax
jne 0x5dc2
movl $0x0, -0x4(%rbp)
jmp 0x5de9
movq -0x18(%rbp), %rdi
movl $0xa, %esi
callq 0x2090
movq %rax, -0x28(%rbp)
cmpq $0x0, -0x28(%rbp)
je 0x5de2
movq -0x28(%rbp), %rax
movb $0x0, (%rax)
movl $0x1, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/hansvanstaveren[P]BigDeal/main.c
// Function: read_init_file
void
read_init_file(char *ifname, int write_when_absent)
/*
 * Read init file
 */
{
	FILE *ifile;
	char buf[MESSLEN+LONGESTKEYWORD];
	char *eqptr;
	struct ifrecord *ifrp;

	ifile = fopen(ifname, "r");
	if (ifile == NULL) {
		if (write_when_absent)
			write_init_file(ifname);
		return;
	}
	while (readline(ifile, buf, MESSLEN+LONGESTKEYWORD)) {
		if (buf[0] == 0)
			continue;		/* empty line */
		if (strcmp(buf, init_header)==0)
			continue;		/* header for Windows routines */
		if (buf[0] == '[')
			break;			/* end of our stuff */
		eqptr = strchr(buf, '=');
		if (eqptr == 0) {
			fprintf(stderr, "Line '%s' does not contain =\n", buf);
			fprintf(stderr, "Suggest rerun program with -R flag\n");
			continue;
		}
		*eqptr++ = 0;
		for (ifrp=init_file; ifrp->if_keyword; ifrp++) {
			if (strcmp(ifrp->if_keyword, buf)==0) {
				strcpy(ifrp->if_value, eqptr);
				break;
			}
		}
		if (!ifrp->if_keyword) {
			fprintf(stderr, "Keyword %s in init_file unknown\n", buf);
			fprintf(stderr, "Suggest rerun program with -R flag\n");
		}
	}
	fclose(ifile);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0xa0, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movq -0x8(%rbp), %rdi
leaq 0x3801(%rip), %rsi      # 0x961e
callq 0x2180
movq %rax, -0x18(%rbp)
cmpq $0x0, -0x18(%rbp)
jne 0x5e41
cmpl $0x0, -0xc(%rbp)
je 0x5e3c
movq -0x8(%rbp), %rdi
callq 0x5b70
jmp 0x5fc7
jmp 0x5e43
movq -0x18(%rbp), %rdi
leaq -0x90(%rbp), %rsi
movl $0x78, %edx
callq 0x5d90
cmpl $0x0, %eax
je 0x5fbe
movsbl -0x90(%rbp), %eax
cmpl $0x0, %eax
jne 0x5e6f
jmp 0x5e43
leaq -0x90(%rbp), %rdi
leaq 0x6413(%rip), %rsi      # 0xc290
callq 0x2120
cmpl $0x0, %eax
jne 0x5e89
jmp 0x5e43
movsbl -0x90(%rbp), %eax
cmpl $0x5b, %eax
jne 0x5e9a
jmp 0x5fbe
leaq -0x90(%rbp), %rdi
movl $0x3d, %esi
callq 0x2090
movq %rax, -0x98(%rbp)
cmpq $0x0, -0x98(%rbp)
jne 0x5ef8
movq 0x6135(%rip), %rax      # 0xbff8
movq (%rax), %rdi
leaq -0x90(%rbp), %rdx
leaq 0x33fc(%rip), %rsi      # 0x92d0
movb $0x0, %al
callq 0x2150
movq 0x6116(%rip), %rax      # 0xbff8
movq (%rax), %rdi
leaq 0x3402(%rip), %rsi      # 0x92ee
movb $0x0, %al
callq 0x2150
jmp 0x5e43
movq -0x98(%rbp), %rax
movq %rax, %rcx
addq $0x1, %rcx
movq %rcx, -0x98(%rbp)
movb $0x0, (%rax)
leaq 0x6339(%rip), %rax      # 0xc250
movq %rax, -0xa0(%rbp)
movq -0xa0(%rbp), %rax
cmpq $0x0, (%rax)
je 0x5f75
movq -0xa0(%rbp), %rax
movq (%rax), %rdi
leaq -0x90(%rbp), %rsi
callq 0x2120
cmpl $0x0, %eax
jne 0x5f5f
movq -0xa0(%rbp), %rax
movq 0x8(%rax), %rdi
movq -0x98(%rbp), %rsi
callq 0x2040
jmp 0x5f75
jmp 0x5f61
movq -0xa0(%rbp), %rax
addq $0x10, %rax
movq %rax, -0xa0(%rbp)
jmp 0x5f1e
movq -0xa0(%rbp), %rax
cmpq $0x0, (%rax)
jne 0x5fb9
movq 0x606f(%rip), %rax      # 0xbff8
movq (%rax), %rdi
leaq -0x90(%rbp), %rdx
leaq 0x3378(%rip), %rsi      # 0x9312
movb $0x0, %al
callq 0x2150
movq 0x6050(%rip), %rax      # 0xbff8
movq (%rax), %rdi
leaq 0x333c(%rip), %rsi      # 0x92ee
movb $0x0, %al
callq 0x2150
jmp 0x5e43
movq -0x18(%rbp), %rdi
callq 0x2060
addq $0xa0, %rsp
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O0/hansvanstaveren[P]BigDeal/main.c
// Function: setboards
void
setboards(char *a) {
	char *chptr;

	chptr =strchr(a,'-');
	if (chptr) {
		*chptr++ = 0;
		parameters.pp_lowboard = atoi(a);
		parameters.pp_highboard = atoi(chptr);
	} else {
		parameters.pp_lowboard = 1;
		parameters.pp_highboard = atoi(a);
	}
	parameters.pp_nboards =
	    parameters.pp_highboard - parameters.pp_lowboard + 1;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
movl $0x2d, %esi
callq 0x2090
movq %rax, -0x10(%rbp)
cmpq $0x0, -0x10(%rbp)
je 0x6027
movq -0x10(%rbp), %rax
movq %rax, %rcx
addq $0x1, %rcx
movq %rcx, -0x10(%rbp)
movb $0x0, (%rax)
movq -0x8(%rbp), %rdi
callq 0x21a0
movl %eax, 0x8c6a(%rip)      # 0xec80
movq -0x10(%rbp), %rdi
callq 0x21a0
movl %eax, 0x8c5f(%rip)      # 0xec84
jmp 0x6040
movl $0x1, 0x8c4f(%rip)      # 0xec80
movq -0x8(%rbp), %rdi
callq 0x21a0
movl %eax, 0x8c44(%rip)      # 0xec84
movl 0x8c3e(%rip), %eax      # 0xec84
subl 0x8c34(%rip), %eax      # 0xec80
addl $0x1, %eax
movl %eax, 0x8c33(%rip)      # 0xec88
addq $0x10, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/hansvanstaveren[P]BigDeal/main.c
// Function: get_entropy_from_keyboard
static void
get_entropy_from_keyboard(void) {
	int c, oldc;
	int nbits;

	cbreak();
	printf("Type random characters until you are told to stop ");
	oldc = 0;
	do {
		c = getchtm(&nbits);
		if (c != oldc) {
			/*
			 * Collect the character, assume 2 bits entropy
			 * plus what the timing supplied.
			 */
			collect_more( (byte*)&c, sizeof(c), 2+nbits);
			oldc = c;
		}
	} while (nrandombits < ENTROPY_TO_COLLECT);
	printf("\nThat is enough\007\n");
	cooked();
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
callq 0x8620
leaq 0x2ee8(%rip), %rdi      # 0x944c
movb $0x0, %al
callq 0x20a0
movl $0x0, -0x8(%rbp)
leaq -0xc(%rbp), %rdi
callq 0x83f0
movl %eax, -0x4(%rbp)
movl -0x4(%rbp), %eax
cmpl -0x8(%rbp), %eax
je 0x65a0
movl -0xc(%rbp), %edx
addl $0x2, %edx
leaq -0x4(%rbp), %rdi
movl $0x4, %esi
callq 0x67e0
movl -0x4(%rbp), %eax
movl %eax, -0x8(%rbp)
jmp 0x65a2
leaq 0x8763(%rip), %rax      # 0xed0c
cmpl $0xd5, (%rax)
jl 0x6572
leaq 0x2ec7(%rip), %rdi      # 0x947f
movb $0x0, %al
callq 0x20a0
callq 0x8670
addq $0x10, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/hansvanstaveren[P]BigDeal/collect.c
// Function: collect_more
void
collect_more(byte *bp, int nbytes, int entropybits)
/*
 * Throw a bunch of information into the machine.
 * The user supplies a hopefully pessimistic estimate of the entropy
 */
{

	nrandombits += entropybits;
#ifdef BIGDEALX
	if (flog) {
		int i;

		fprintf(flog, "collect_more(");
		for (i=0; i < nbytes; i++)
			fprintf(flog, "%02x", bp[i]);
		fprintf(flog, ", %d, %d) -> %d\n", nbytes, entropybits, nrandombits);
	}
#endif
	while(nbytes > 0) {
		collect_byte(*bp);
		nbytes--;
		bp++;
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movl %edx, -0x10(%rbp)
movl -0x10(%rbp), %eax
addl 0x8511(%rip), %eax      # 0xed0c
movl %eax, 0x850b(%rip)      # 0xed0c
cmpl $0x0, -0xc(%rbp)
jle 0x682a
movq -0x8(%rbp), %rax
movzbl (%rax), %edi
callq 0x6830
movl -0xc(%rbp), %eax
addl $-0x1, %eax
movl %eax, -0xc(%rbp)
movq -0x8(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x8(%rbp)
jmp 0x6801
addq $0x10, %rsp
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O0/hansvanstaveren[P]BigDeal/collect.c
// Function: collect_byte
static void
collect_byte(byte b)
/*
 * Throw another byte into the machine. If it fills up the buffer run the 
 * buffer through the hashing engine
 */
{
	dword X[16];
	int i;
	byte *bp;

	nhashbytes++;
	variousbytes[vbytesindex++] = b;
	if (vbytesindex == 64) {
		bp = variousbytes;
		for (i=0; i<16; i++) {
			X[i] = BYTES_TO_DWORD(bp);
			bp += 4;
		}
		compress(MDbuf, X);
		vbytesindex = 0;
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x60, %rsp
movb %dil, %al
movb %al, -0x1(%rbp)
movl 0x84c4(%rip), %eax      # 0xed08
addl $0x1, %eax
movl %eax, 0x84bb(%rip)      # 0xed08
movb -0x1(%rbp), %dl
movl 0x84ae(%rip), %eax      # 0xed04
movl %eax, %ecx
addl $0x1, %ecx
movl %ecx, 0x84a3(%rip)      # 0xed04
movslq %eax, %rcx
leaq 0x84a5(%rip), %rax      # 0xed10
movb %dl, (%rax,%rcx)
cmpl $0x40, 0x848f(%rip)     # 0xed04
jne 0x68f6
leaq 0x8492(%rip), %rax      # 0xed10
movq %rax, -0x60(%rbp)
movl $0x0, -0x54(%rbp)
cmpl $0x10, -0x54(%rbp)
jge 0x68dc
movq -0x60(%rbp), %rax
movzbl 0x3(%rax), %ecx
shll $0x18, %ecx
movq -0x60(%rbp), %rax
movzbl 0x2(%rax), %eax
shll $0x10, %eax
orl %eax, %ecx
movq -0x60(%rbp), %rax
movzbl 0x1(%rax), %eax
shll $0x8, %eax
orl %eax, %ecx
movq -0x60(%rbp), %rax
movzbl (%rax), %eax
orl %eax, %ecx
movslq -0x54(%rbp), %rax
movl %ecx, -0x50(%rbp,%rax,4)
movq -0x60(%rbp), %rax
addq $0x4, %rax
movq %rax, -0x60(%rbp)
movl -0x54(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x54(%rbp)
jmp 0x6889
leaq -0x50(%rbp), %rsi
leaq 0x8409(%rip), %rdi      # 0xecf0
callq 0x2310
movl $0x0, 0x840e(%rip)      # 0xed04
addq $0x60, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/hansvanstaveren[P]BigDeal/collect.c
// Function: collect_finish
void
collect_finish(byte *hash)
/*
 * Halt the hashing engine
 * Extract the result into hash[]
 */
{
	int i;

	MDfinish(MDbuf, variousbytes, nhashbytes, 0);
#ifdef BIGDEALX
	if (flog)
		fprintf(flog, "collected %d random bits, from %d bytes of data\n",
			nrandombits, nhashbytes);

#endif
	for (i=0; i<RMDbytes; i+=4) {
		hash[i]   =  MDbuf[i>>2];         /* implicit cast to byte  */
		hash[i+1] = (MDbuf[i>>2] >>  8);  /*  extracts the 8 least  */
		hash[i+2] = (MDbuf[i>>2] >> 16);  /*  significant bits.     */
		hash[i+3] = (MDbuf[i>>2] >> 24);
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movl 0x83f6(%rip), %edx      # 0xed08
leaq 0x83d7(%rip), %rdi      # 0xecf0
leaq 0x83f0(%rip), %rsi      # 0xed10
xorl %ecx, %ecx
callq 0x5440
movl $0x0, -0xc(%rbp)
cmpl $0x14, -0xc(%rbp)
jge 0x69de
movl -0xc(%rbp), %eax
sarl $0x2, %eax
movslq %eax, %rcx
leaq 0x83a8(%rip), %rax      # 0xecf0
movl (%rax,%rcx,4), %eax
movb %al, %dl
movq -0x8(%rbp), %rax
movslq -0xc(%rbp), %rcx
movb %dl, (%rax,%rcx)
movl -0xc(%rbp), %eax
sarl $0x2, %eax
movslq %eax, %rcx
leaq 0x8388(%rip), %rax      # 0xecf0
movl (%rax,%rcx,4), %eax
shrl $0x8, %eax
movb %al, %dl
movq -0x8(%rbp), %rax
movl -0xc(%rbp), %ecx
addl $0x1, %ecx
movslq %ecx, %rcx
movb %dl, (%rax,%rcx)
movl -0xc(%rbp), %eax
sarl $0x2, %eax
movslq %eax, %rcx
leaq 0x8360(%rip), %rax      # 0xecf0
movl (%rax,%rcx,4), %eax
shrl $0x10, %eax
movb %al, %dl
movq -0x8(%rbp), %rax
movl -0xc(%rbp), %ecx
addl $0x2, %ecx
movslq %ecx, %rcx
movb %dl, (%rax,%rcx)
movl -0xc(%rbp), %eax
sarl $0x2, %eax
movslq %eax, %rcx
leaq 0x8338(%rip), %rax      # 0xecf0
movl (%rax,%rcx,4), %eax
shrl $0x18, %eax
movb %al, %dl
movq -0x8(%rbp), %rax
movl -0xc(%rbp), %ecx
addl $0x3, %ecx
movslq %ecx, %rcx
movb %dl, (%rax,%rcx)
movl -0xc(%rbp), %eax
addl $0x4, %eax
movl %eax, -0xc(%rbp)
jmp 0x692e
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
nop
// File: /workspace/github_c_makefile_star2_O0/hansvanstaveren[P]BigDeal/output.c
// Function: init_kops
void
init_kops(FILE *out) {
    int nb = prparp->pp_nboards;

    putc(nb&0xff, out);
    putc((nb>>8)&0xff, out);
    out_fill(out, ' ', 11);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq 0x834d(%rip), %rax      # 0xed50
movl 0x8(%rax), %eax
movl %eax, -0xc(%rbp)
movl -0xc(%rbp), %edi
andl $0xff, %edi
movq -0x8(%rbp), %rsi
callq 0x2130
movl -0xc(%rbp), %edi
sarl $0x8, %edi
andl $0xff, %edi
movq -0x8(%rbp), %rsi
callq 0x2130
movq -0x8(%rbp), %rdi
movl $0x20, %esi
movl $0xb, %edx
callq 0x6a50
addq $0x10, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/hansvanstaveren[P]BigDeal/output.c
// Function: output_help
void
output_help(void) {
	of_p ofp;

	printf("%-8s%8s    Explanation\n\n", "Name", "Suffix");
	/* For all formats: */
	for (ofp=output_formats; ofp->of_name; ofp++) {
		printf("%-8s%8s    %s\n",
			ofp->of_name,
			ofp->of_suffix? ofp->of_suffix : "",
			ofp->of_help);
	}
	printf("\n");
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
leaq 0x29f5(%rip), %rdi      # 0x94a4
leaq 0x2a07(%rip), %rsi      # 0x94bd
leaq 0x2a05(%rip), %rdx      # 0x94c2
movb $0x0, %al
callq 0x20a0
leaq 0x57d5(%rip), %rax      # 0xc2a0
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
cmpq $0x0, (%rax)
je 0x6b36
movq -0x8(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x10(%rbp)
movq -0x8(%rbp), %rax
cmpq $0x0, 0x18(%rax)
je 0x6afd
movq -0x8(%rbp), %rax
movq 0x18(%rax), %rax
movq %rax, -0x18(%rbp)
jmp 0x6b0a
leaq 0x298c(%rip), %rax      # 0x9490
movq %rax, -0x18(%rbp)
jmp 0x6b0a
movq -0x10(%rbp), %rsi
movq -0x18(%rbp), %rdx
movq -0x8(%rbp), %rax
movq 0x28(%rax), %rcx
leaq 0x29a8(%rip), %rdi      # 0x94c9
movb $0x0, %al
callq 0x20a0
movq -0x8(%rbp), %rax
addq $0x48, %rax
movq %rax, -0x8(%rbp)
jmp 0x6acf
leaq 0x2952(%rip), %rdi      # 0x948f
movb $0x0, %al
callq 0x20a0
addq $0x20, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/hansvanstaveren[P]BigDeal/output.c
// Function: output_specify_formats
int
output_specify_formats(char *format_string, int for_real)
/*
 * Comma separated list of output formats to use
 *
 * Return value is used to check validity of string
 */
{
	char **ofvector;
	of_p ofp;
	int found;
	int retval;

	retval = 1;	/* While all OK */
	for(ofvector = tokenize(format_string, ','); *ofvector; ofvector++) {
		found = 0;
		for (ofp=output_formats; ofp->of_name; ofp++) {
			if (strcmp(ofp->of_name, *ofvector) == 0) {
				if (suf_in_use(ofp->of_name, ofp->of_suffix)) {
					retval = 0;
				} else {
					ofp->of_flags |= OFF_USEIT;
				}
				found++;
				break;
			}
		}
		if (!found) {
			fprintf(stderr, "Format %s unknown\n", *ofvector);
			retval = 0;
		}
	}

	if (!for_real) {
		/*
		 * This was just a test, clean up
		 */
		for (ofp=output_formats; ofp->of_name; ofp++) {
			ofp->of_flags &= ~OFF_USEIT;
		}
	}

	return retval;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movl $0x1, -0x28(%rbp)
movq -0x8(%rbp), %rdi
movl $0x2c, %esi
callq 0x6c90
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rax
cmpq $0x0, (%rax)
je 0x6c43
movl $0x0, -0x24(%rbp)
leaq 0x570c(%rip), %rax      # 0xc2a0
movq %rax, -0x20(%rbp)
movq -0x20(%rbp), %rax
cmpq $0x0, (%rax)
je 0x6c04
movq -0x20(%rbp), %rax
movq (%rax), %rdi
movq -0x18(%rbp), %rax
movq (%rax), %rsi
callq 0x2120
cmpl $0x0, %eax
jne 0x6bf4
movq -0x20(%rbp), %rax
movq (%rax), %rdi
movq -0x20(%rbp), %rax
movq 0x18(%rax), %rsi
callq 0x6d70
cmpl $0x0, %eax
je 0x6bdc
movl $0x0, -0x28(%rbp)
jmp 0x6be9
movq -0x20(%rbp), %rax
movl 0x8(%rax), %ecx
orl $0x1, %ecx
movl %ecx, 0x8(%rax)
movl -0x24(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x24(%rbp)
jmp 0x6c04
jmp 0x6bf6
movq -0x20(%rbp), %rax
addq $0x48, %rax
movq %rax, -0x20(%rbp)
jmp 0x6b98
cmpl $0x0, -0x24(%rbp)
jne 0x6c30
movq 0x53e7(%rip), %rax      # 0xbff8
movq (%rax), %rdi
movq -0x18(%rbp), %rax
movq (%rax), %rdx
leaq 0x28b6(%rip), %rsi      # 0x94d8
movb $0x0, %al
callq 0x2150
movl $0x0, -0x28(%rbp)
jmp 0x6c32
movq -0x18(%rbp), %rax
addq $0x8, %rax
movq %rax, -0x18(%rbp)
jmp 0x6b78
cmpl $0x0, -0xc(%rbp)
jne 0x6c7b
leaq 0x5650(%rip), %rax      # 0xc2a0
movq %rax, -0x20(%rbp)
movq -0x20(%rbp), %rax
cmpq $0x0, (%rax)
je 0x6c79
movq -0x20(%rbp), %rax
movl 0x8(%rax), %ecx
andl $-0x2, %ecx
movl %ecx, 0x8(%rax)
movq -0x20(%rbp), %rax
addq $0x48, %rax
movq %rax, -0x20(%rbp)
jmp 0x6c54
jmp 0x6c7b
movl -0x28(%rbp), %eax
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)