LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O0/LenShustek[P]miditones/miditones.c
// Function: remove_queue_duplicates
void remove_queue_duplicates(int stop_ndx) {
   int play_ndx, dup_play_ndx, dup_stop_ndx;
   if ((play_ndx = queue_find_playnote(stop_ndx)) >= 0 // find its matching playnote
         && (dup_stop_ndx = queue_find_stopnote(stop_ndx)) >= 0  // find another stopnote for the same note at the same time
         && (dup_play_ndx = queue_find_playnote(dup_stop_ndx)) >= 0 // find its matching playnote
         && queue[dup_play_ndx].note.time_usec == queue[play_ndx].note.time_usec) {  // if it starts at the same time, delete it
      if (loggen) fprintf(logfile, "    remove duplicate, ndxs %d, %d: %s\n", dup_play_ndx, dup_stop_ndx, describe(&queue[dup_play_ndx].note));
      queue[dup_play_ndx].delete = queue[dup_stop_ndx].delete = true; } }

// Assembly:
subq $0x28, %rsp
movl %edi, 0x24(%rsp)
movl 0x24(%rsp), %edi
callq 0x33f0
movl %eax, 0x20(%rsp)
cmpl $0x0, %eax
jl 0x38c9
movl 0x24(%rsp), %edi
callq 0x35f0
movl %eax, 0x18(%rsp)
cmpl $0x0, %eax
jl 0x38c9
movl 0x18(%rsp), %edi
callq 0x33f0
movl %eax, 0x1c(%rsp)
cmpl $0x0, %eax
jl 0x38c9
movslq 0x1c(%rsp), %rcx
leaq 0x9b2a(%rip), %rax      # 0xd340
imulq $0x1c, %rcx, %rcx
addq %rcx, %rax
movl 0x4(%rax), %eax
movslq 0x20(%rsp), %rdx
leaq 0x9b14(%rip), %rcx      # 0xd340
imulq $0x1c, %rdx, %rdx
addq %rdx, %rcx
cmpl 0x4(%rcx), %eax
jne 0x38c9
testb $0x1, 0x7ac0(%rip)      # 0xb303
je 0x389b
movq 0x7acc(%rip), %rax      # 0xb318
movq %rax, 0x8(%rsp)
movl 0x1c(%rsp), %eax
movl %eax, 0x10(%rsp)
movl 0x18(%rsp), %eax
movl %eax, 0x14(%rsp)
movslq 0x1c(%rsp), %rax
leaq 0x9ad3(%rip), %rdi      # 0xd340
imulq $0x1c, %rax, %rax
addq %rax, %rdi
addq $0x4, %rdi
callq 0x2260
movq 0x8(%rsp), %rdi
movl 0x10(%rsp), %edx
movl 0x14(%rsp), %ecx
movq %rax, %r8
leaq 0x4831(%rip), %rsi      # 0x80c5
movb $0x0, %al
callq 0x10a0
movslq 0x18(%rsp), %rcx
leaq 0x9a99(%rip), %rax      # 0xd340
imulq $0x1c, %rcx, %rcx
addq %rcx, %rax
movb $0x1, 0x1(%rax)
movslq 0x1c(%rsp), %rcx
leaq 0x9a82(%rip), %rax      # 0xd340
imulq $0x1c, %rcx, %rcx
addq %rcx, %rax
movb $0x1, 0x1(%rax)
addq $0x28, %rsp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/LenShustek[P]miditones/miditones.c
// Function: show_queue_cmd
void show_queue_cmd(timestamp time_usec, byte cmd, int note) {
   printf("debug queue %s note %02X at %6ld\n", cmd == CMD_PLAYNOTE ? "PLAY" : "STOP", note, time_usec);
   struct noteinfo notedata;
   notedata.time_usec = time_usec;
   notedata.track = 0;
   notedata.channel = 0;
   notedata.note = note;
   notedata.instrument = 1;
   notedata.volume = 100;
   queue_cmd(cmd, &notedata);
   show_queue(); }

// Assembly:
subq $0x28, %rsp
movb %sil, %al
movl %edi, 0x24(%rsp)
movb %al, 0x23(%rsp)
movl %edx, 0x1c(%rsp)
movzbl 0x23(%rsp), %ecx
leaq 0x40c6(%rip), %rsi      # 0x7cc5
leaq 0x40ba(%rip), %rax      # 0x7cc0
cmpl $0x90, %ecx
cmoveq %rax, %rsi
movl 0x1c(%rsp), %edx
movl 0x24(%rsp), %ecx
leaq 0x452a(%rip), %rdi      # 0x8149
movb $0x0, %al
callq 0x1070
movl 0x24(%rsp), %eax
movl %eax, 0x4(%rsp)
movl $0x0, 0x8(%rsp)
movl $0x0, 0xc(%rsp)
movl 0x1c(%rsp), %eax
movl %eax, 0x10(%rsp)
movl $0x1, 0x14(%rsp)
movl $0x64, 0x18(%rsp)
leaq 0x4(%rsp), %rsi
movzbl 0x23(%rsp), %edi
callq 0x38d0
callq 0x2330
addq $0x28, %rsp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/LenShustek[P]miditones/miditones.c
// Function: process_file_header
void process_file_header (void) {
   struct midi_header *hdr;
   unsigned int time_division;

   chk_bufdata (hdrptr, sizeof (struct midi_header));
   hdr = (struct midi_header *) hdrptr;
   if (!charcmp ((char *) hdr->MThd, "MThd"))
      midi_error ("Missing 'MThd'", hdrptr);
   num_tracks = rev_short (hdr->number_of_tracks);
   time_division = rev_short (hdr->time_division);
   if (time_division < 0x8000)
      ticks_per_beat = time_division;
   else
      ticks_per_beat = ((time_division >> 8) & 0x7f) /* SMTE frames/sec */ *(time_division & 0xff);     /* ticks/SMTE frame */
   if (logparse) {
      fprintf (logfile, "Header size %" PRId32 "\n", rev_long (hdr->header_size));
      fprintf (logfile, "Format type %d\n", rev_short (hdr->format_type));
      fprintf (logfile, "Number of tracks %d\n", num_tracks);
      fprintf (logfile, "Time division %04X\n", time_division);
      fprintf (logfile, "Ticks/beat = %d\n", ticks_per_beat); }
   hdrptr += rev_long (hdr->header_size) + 8;   /* point past header to track header, presumably. */
   return; }

// Assembly:
subq $0x28, %rsp
movq 0xa1b5(%rip), %rdi      # 0xde30
movl $0x10, %esi
callq 0x20f0
movq 0xa1a4(%rip), %rax      # 0xde30
movq %rax, 0x20(%rsp)
movq 0x20(%rsp), %rdi
leaq 0x44ce(%rip), %rsi      # 0x816b
callq 0x2070
cmpl $0x0, %eax
jne 0x3cba
movq 0xa182(%rip), %rsi      # 0xde30
leaq 0x44bb(%rip), %rdi      # 0x8170
callq 0x1ce0
movq 0x20(%rsp), %rax
movzwl 0xa(%rax), %edi
callq 0x2140
movzwl %ax, %eax
movl %eax, 0xa167(%rip)      # 0xde38
movq 0x20(%rsp), %rax
movzwl 0xc(%rax), %edi
callq 0x2140
movzwl %ax, %eax
movl %eax, 0x1c(%rsp)
cmpl $0x8000, 0x1c(%rsp)     # imm = 0x8000
jae 0x3cfc
movl 0x1c(%rsp), %eax
movl %eax, 0x7402(%rip)      # 0xb0fc
jmp 0x3d19
movl 0x1c(%rsp), %eax
shrl $0x8, %eax
andl $0x7f, %eax
movl 0x1c(%rsp), %ecx
andl $0xff, %ecx
imull %ecx, %eax
movl %eax, 0x73e3(%rip)      # 0xb0fc
testb $0x1, 0x75e5(%rip)      # 0xb305
je 0x3dd3
movq 0x75eb(%rip), %rax      # 0xb318
movq %rax, 0x8(%rsp)
movq 0x20(%rsp), %rax
movl 0x4(%rax), %edi
callq 0x2170
movq 0x8(%rsp), %rdi
movl %eax, %edx
leaq 0x4432(%rip), %rsi      # 0x817f
movb $0x0, %al
callq 0x10a0
movq 0x75bd(%rip), %rax      # 0xb318
movq %rax, 0x10(%rsp)
movq 0x20(%rsp), %rax
movzwl 0x8(%rax), %edi
callq 0x2140
movq 0x10(%rsp), %rdi
movzwl %ax, %edx
leaq 0x4412(%rip), %rsi      # 0x818f
movb $0x0, %al
callq 0x10a0
movq 0x758d(%rip), %rdi      # 0xb318
movl 0xa0a7(%rip), %edx      # 0xde38
leaq 0x4407(%rip), %rsi      # 0x819f
movb $0x0, %al
callq 0x10a0
movq 0x7572(%rip), %rdi      # 0xb318
movl 0x1c(%rsp), %edx
leaq 0x4403(%rip), %rsi      # 0x81b4
movb $0x0, %al
callq 0x10a0
movq 0x7559(%rip), %rdi      # 0xb318
movl 0x7337(%rip), %edx      # 0xb0fc
leaq 0x43fc(%rip), %rsi      # 0x81c8
movb $0x0, %al
callq 0x10a0
movq 0x20(%rsp), %rax
movl 0x4(%rax), %edi
callq 0x2170
movl %eax, %ecx
addl $0x8, %ecx
movq 0xa044(%rip), %rax      # 0xde30
movl %ecx, %ecx
addq %rcx, %rax
movq %rax, 0xa038(%rip)      # 0xde30
addq $0x28, %rsp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/LenShustek[P]miditones/miditones.c
// Function: process_track_header
void process_track_header (int tracknum) {
   struct track_header *hdr;
   unsigned long tracklen;

   chk_bufdata (hdrptr, sizeof (struct track_header));
   hdr = (struct track_header *) hdrptr;
   if (!charcmp ((char *) (hdr->MTrk), "MTrk"))
      midi_error ("Missing 'MTrk'", hdrptr);
   tracklen = rev_long (hdr->track_size);
   if (logparse) fprintf (logfile, "\nTrack %d length %ld\n", tracknum, tracklen);
   hdrptr += sizeof (struct track_header);      /* point past header */
   chk_bufdata (hdrptr, tracklen);
   track[tracknum].trkptr = hdrptr;
   hdrptr += tracklen;          /* point to the start of the next track */
   track[tracknum].trkend = hdrptr;     /* the point past the end of the track */
}

// Assembly:
subq $0x18, %rsp
movl %edi, 0x14(%rsp)
movq 0xa021(%rip), %rdi      # 0xde30
movl $0x8, %esi
callq 0x20f0
movq 0xa010(%rip), %rax      # 0xde30
movq %rax, 0x8(%rsp)
movq 0x8(%rsp), %rdi
leaq 0x43a8(%rip), %rsi      # 0x81d9
callq 0x2070
cmpl $0x0, %eax
jne 0x3e4e
movq 0x9fee(%rip), %rsi      # 0xde30
leaq 0x4395(%rip), %rdi      # 0x81de
callq 0x1ce0
movq 0x8(%rsp), %rax
movl 0x4(%rax), %edi
callq 0x2170
movl %eax, %eax
movq %rax, (%rsp)
testb $0x1, 0x749d(%rip)      # 0xb305
je 0x3e87
movq 0x74a7(%rip), %rdi      # 0xb318
movl 0x14(%rsp), %edx
movq (%rsp), %rcx
leaq 0x436d(%rip), %rsi      # 0x81ed
movb $0x0, %al
callq 0x10a0
movq 0x9fa2(%rip), %rax      # 0xde30
addq $0x8, %rax
movq %rax, 0x9f97(%rip)      # 0xde30
movq 0x9f90(%rip), %rdi      # 0xde30
movq (%rsp), %rsi
callq 0x20f0
movq 0x9f80(%rip), %rcx      # 0xde30
movslq 0x14(%rsp), %rdx
leaq 0x7644(%rip), %rax      # 0xb500
imulq $0x30, %rdx, %rdx
addq %rdx, %rax
movq %rcx, (%rax)
movq (%rsp), %rax
addq 0x9f5f(%rip), %rax      # 0xde30
movq %rax, 0x9f58(%rip)      # 0xde30
movq 0x9f51(%rip), %rcx      # 0xde30
movslq 0x14(%rsp), %rdx
leaq 0x7615(%rip), %rax      # 0xb500
imulq $0x30, %rdx, %rdx
addq %rdx, %rax
movq %rcx, 0x8(%rax)
addq $0x18, %rsp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/LenShustek[P]miditones/miditones.c
// Function: get_varlen
unsigned long get_varlen (uint8_t ** ptr) { // get a MIDI-style integer
   /* Get a 1-4 byte variable-length value and adjust the pointer past it.
   These are a succession of 7-bit values with a MSB bit of zero marking the end */
   unsigned long val = 0;
   for (int i = 0; i < 4; ++i) {
      byte b = *(*ptr)++;
      val = (val << 7) | (b & 0x7f);
      if (!(b & 0x80))
         return val; }
   return val; }

// Assembly:
movq %rdi, -0x10(%rsp)
movq $0x0, -0x18(%rsp)
movl $0x0, -0x1c(%rsp)
cmpl $0x4, -0x1c(%rsp)
jge 0x3f7b
movq -0x10(%rsp), %rcx
movq (%rcx), %rax
movq %rax, %rdx
addq $0x1, %rdx
movq %rdx, (%rcx)
movb (%rax), %al
movb %al, -0x1d(%rsp)
movq -0x18(%rsp), %rax
shlq $0x7, %rax
movzbl -0x1d(%rsp), %ecx
andl $0x7f, %ecx
movslq %ecx, %rcx
orq %rcx, %rax
movq %rax, -0x18(%rsp)
movzbl -0x1d(%rsp), %eax
andl $0x80, %eax
cmpl $0x0, %eax
jne 0x3f6c
movq -0x18(%rsp), %rax
movq %rax, -0x8(%rsp)
jmp 0x3f85
jmp 0x3f6e
movl -0x1c(%rsp), %eax
addl $0x1, %eax
movl %eax, -0x1c(%rsp)
jmp 0x3f16
movq -0x18(%rsp), %rax
movq %rax, -0x8(%rsp)
movq -0x8(%rsp), %rax
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/LenShustek[P]miditones/miditones.c
// Function: show_noteinfo_slots
void show_noteinfo_slots(int channum) {
   struct channel_status *cp = &channel[channum];
   if (loggen) {
      fprintf(logfile, "notes playing for channel %d:\n", channum);
      for (int ndx = 0; ndx < MAX_CHANNELNOTES; ++ndx)
         if (cp->note_playing[ndx]) {
            struct noteinfo *np = &cp->notes_playing[ndx];
            fprintf(logfile, "  %2d: %s\n", ndx, describe(np)); } } }

// Assembly:
subq $0x38, %rsp
movl %edi, 0x34(%rsp)
movslq 0x34(%rsp), %rcx
leaq 0x6e5c(%rip), %rax      # 0xb980
imulq $0x194, %rcx, %rcx      # imm = 0x194
addq %rcx, %rax
movq %rax, 0x28(%rsp)
testb $0x1, 0x67c9(%rip)      # 0xb303
je 0x4bdc
movq 0x67d1(%rip), %rdi      # 0xb318
movl 0x34(%rsp), %edx
leaq 0x39d3(%rip), %rsi      # 0x8525
movb $0x0, %al
callq 0x10a0
movl $0x0, 0x24(%rsp)
cmpl $0x10, 0x24(%rsp)
jge 0x4bda
movq 0x28(%rsp), %rax
movslq 0x24(%rsp), %rcx
testb $0x1, 0x4(%rax,%rcx)
je 0x4bcb
movq 0x28(%rsp), %rax
addq $0x14, %rax
movslq 0x24(%rsp), %rcx
imulq $0x18, %rcx, %rcx
addq %rcx, %rax
movq %rax, 0x18(%rsp)
movq 0x677e(%rip), %rax      # 0xb318
movq %rax, 0x8(%rsp)
movl 0x24(%rsp), %eax
movl %eax, 0x14(%rsp)
movq 0x18(%rsp), %rdi
callq 0x2260
movq 0x8(%rsp), %rdi
movl 0x14(%rsp), %edx
movq %rax, %rcx
leaq 0x3980(%rip), %rsi      # 0x8544
movb $0x0, %al
callq 0x10a0
jmp 0x4bcd
movl 0x24(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x24(%rsp)
jmp 0x4b61
jmp 0x4bdc
addq $0x38, %rsp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/keithnoguchi[P]pearls-in-action/0xc/main_test.c
// Function: main
int main(void)
{
	int fail = 0;
	int i = 0;

	printf("============================\n");
	printf("Column 0xc: A Sample Problem\n");
	printf("============================\n");

	if (test_genknuth(&i))
		fail++;
	if (bench_genknuth(&i))
		fail++;

	return fail;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movl $0x0, -0x4(%rbp)
movl $0x0, -0x8(%rbp)
movl $0x0, -0xc(%rbp)
leaq 0xe00(%rip), %rdi       # 0x2004
movb $0x0, %al
callq 0x1080
leaq 0xe10(%rip), %rdi       # 0x2022
movb $0x0, %al
callq 0x1080
leaq 0xde4(%rip), %rdi       # 0x2004
movb $0x0, %al
callq 0x1080
leaq -0xc(%rbp), %rdi
callq 0x12f0
cmpl $0x0, %eax
je 0x123e
movl -0x8(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x8(%rbp)
leaq -0xc(%rbp), %rdi
callq 0x1460
cmpl $0x0, %eax
je 0x1255
movl -0x8(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x8(%rbp)
movl -0x8(%rbp), %eax
addq $0x10, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/keithnoguchi[P]pearls-in-action/0xc/genknuth.c
// Function: genknuth
void genknuth(int m, int n, int x[])
{
	int i, j;

	srandom(time(0));

	j = 0;
	for (i = 0; i < n; i++)
		if (random()%(n-i) < (m-j))
			x[j++] = i;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movl %edi, -0x4(%rbp)
movl %esi, -0x8(%rbp)
movq %rdx, -0x10(%rbp)
xorl %eax, %eax
movl %eax, %edi
callq 0x10a0
movl %eax, %edi
callq 0x1050
movl $0x0, -0x18(%rbp)
movl $0x0, -0x14(%rbp)
movl -0x14(%rbp), %eax
cmpl -0x8(%rbp), %eax
jge 0x12dd
callq 0x10b0
movl -0x8(%rbp), %ecx
subl -0x14(%rbp), %ecx
movslq %ecx, %rcx
cqto
idivq %rcx
movl -0x4(%rbp), %eax
subl -0x18(%rbp), %eax
cltq
cmpq %rax, %rdx
jge 0x12d0
movl -0x14(%rbp), %edx
movq -0x10(%rbp), %rax
movl -0x18(%rbp), %ecx
movl %ecx, %esi
addl $0x1, %esi
movl %esi, -0x18(%rbp)
movslq %ecx, %rcx
movl %edx, (%rax,%rcx,4)
jmp 0x12d2
movl -0x14(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x14(%rbp)
jmp 0x1290
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/keithnoguchi[P]pearls-in-action/0xc/genknuth_bench.c
// Function: is_sorted
static bool is_sorted(int n, const int x[])
{
	int i;

	for (i = 1; i < n; i++)
		if (x[i-1] >= x[i])
			return false;
	return true;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movl %edi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl $0x1, -0x14(%rbp)
movl -0x14(%rbp), %eax
cmpl -0x8(%rbp), %eax
jge 0x173a
movq -0x10(%rbp), %rax
movl -0x14(%rbp), %ecx
subl $0x1, %ecx
movslq %ecx, %rcx
movl (%rax,%rcx,4), %eax
movq -0x10(%rbp), %rcx
movslq -0x14(%rbp), %rdx
cmpl (%rcx,%rdx,4), %eax
jl 0x172d
movb $0x0, -0x1(%rbp)
jmp 0x173e
jmp 0x172f
movl -0x14(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x14(%rbp)
jmp 0x1702
movb $0x1, -0x1(%rbp)
movb -0x1(%rbp), %al
andb $0x1, %al
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/keithnoguchi[P]pearls-in-action/0xc/genknuth_bench.c
// Function: dump
static void dump(int n, const int x[])
{
	int i;

	if (!debug)
		return;

	for (i = 0; i < n; i++) {
		printf("%8d", x[i]);
		if ((i&0x7)==0x7 && i+1 != n)
			puts("");
	}
	puts("");
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movl %edi, -0x4(%rbp)
movq %rsi, -0x10(%rbp)
testb $0x1, 0x291b(%rip)      # 0x4081
jne 0x176a
jmp 0x17cd
movl $0x0, -0x14(%rbp)
movl -0x14(%rbp), %eax
cmpl -0x4(%rbp), %eax
jge 0x17c1
movq -0x10(%rbp), %rax
movslq -0x14(%rbp), %rcx
movl (%rax,%rcx,4), %esi
leaq 0xb9c(%rip), %rdi       # 0x2327
movb $0x0, %al
callq 0x1080
movl -0x14(%rbp), %eax
andl $0x7, %eax
cmpl $0x7, %eax
jne 0x17b4
movl -0x14(%rbp), %eax
addl $0x1, %eax
cmpl -0x4(%rbp), %eax
je 0x17b4
leaq 0x872(%rip), %rdi       # 0x2021
callq 0x1060
jmp 0x17b6
movl -0x14(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x14(%rbp)
jmp 0x1771
leaq 0x859(%rip), %rdi       # 0x2021
callq 0x1060
addq $0x20, %rsp
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O0/niho[P]elmc/src/test.c
// Function: stack_push_pop_test
static void stack_push_pop_test() {
    elmS_stack_t *S = elmS_stack_new();
    assert(S != NULL);

    const char *hello = "hello";
    const char *world = "world";
    elmS_stack_push(S, &world);
    elmS_stack_push(S, &hello);

    assert(S->size == 2);

    assert(strcmp(elmS_stack_pop(S), "hello"));
    assert(strcmp(elmS_stack_pop(S), "world"));
    assert(elmS_stack_pop(S) == NULL);

    assert(S->size == 0);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movb $0x0, %al
callq 0x1350
movq %rax, -0x8(%rbp)
cmpq $0x0, -0x8(%rbp)
je 0x11ec
jmp 0x120b
leaq 0xe3c(%rip), %rdi       # 0x202f
leaq 0xe3f(%rip), %rsi       # 0x2039
movl $0xf, %edx
leaq 0xe3a(%rip), %rcx       # 0x2040
callq 0x1060
leaq 0xe49(%rip), %rax       # 0x205b
movq %rax, -0x10(%rbp)
leaq 0xe44(%rip), %rax       # 0x2061
movq %rax, -0x18(%rbp)
movq -0x8(%rbp), %rdi
leaq -0x18(%rbp), %rsi
callq 0x1470
movq -0x8(%rbp), %rdi
leaq -0x10(%rbp), %rsi
callq 0x1470
movq -0x8(%rbp), %rax
cmpl $0x2, 0x8(%rax)
jne 0x1247
jmp 0x1266
leaq 0xe19(%rip), %rdi       # 0x2067
leaq 0xde4(%rip), %rsi       # 0x2039
movl $0x16, %edx
leaq 0xddf(%rip), %rcx       # 0x2040
callq 0x1060
movq -0x8(%rbp), %rdi
callq 0x13e0
movq %rax, %rdi
leaq 0xde2(%rip), %rsi       # 0x205b
callq 0x1070
cmpl $0x0, %eax
je 0x1285
jmp 0x12a4
leaq 0xde8(%rip), %rdi       # 0x2074
leaq 0xda6(%rip), %rsi       # 0x2039
movl $0x18, %edx
leaq 0xda1(%rip), %rcx       # 0x2040
callq 0x1060
movq -0x8(%rbp), %rdi
callq 0x13e0
movq %rax, %rdi
leaq 0xdaa(%rip), %rsi       # 0x2061
callq 0x1070
cmpl $0x0, %eax
je 0x12c3
jmp 0x12e2
leaq 0xdcd(%rip), %rdi       # 0x2097
leaq 0xd68(%rip), %rsi       # 0x2039
movl $0x19, %edx
leaq 0xd63(%rip), %rcx       # 0x2040
callq 0x1060
movq -0x8(%rbp), %rdi
callq 0x13e0
cmpq $0x0, %rax
jne 0x12f3
jmp 0x1312
leaq 0xdc0(%rip), %rdi       # 0x20ba
leaq 0xd38(%rip), %rsi       # 0x2039
movl $0x1a, %edx
leaq 0xd33(%rip), %rcx       # 0x2040
callq 0x1060
movq -0x8(%rbp), %rax
cmpl $0x0, 0x8(%rax)
jne 0x131e
jmp 0x133d
leaq 0xdaf(%rip), %rdi       # 0x20d4
leaq 0xd0d(%rip), %rsi       # 0x2039
movl $0x1c, %edx
leaq 0xd08(%rip), %rcx       # 0x2040
callq 0x1060
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/niho[P]elmc/src/estack.c
// Function: elmS_stack_new
elmS_stack_t *elmS_stack_new() {
    elmS_stack_t *stack = malloc(sizeof(elmS_stack_t));
    stack->size = 0;
    stack->head = NULL;
    return stack;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movl $0x10, %edi
callq 0x1080
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
movl $0x0, 0x8(%rax)
movq -0x8(%rbp), %rax
movq $0x0, (%rax)
movq -0x8(%rbp), %rax
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/niho[P]elmc/src/estack.c
// Function: elmS_stack_delete
void elmS_stack_delete(elmS_stack_t *stack) {
    while(1) {
        if(elmS_stack_pop(stack) == NULL)
            break;
    }
    stack->head = NULL;
    stack->size = 0;
    free(stack);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
callq 0x13e0
cmpq $0x0, %rax
jne 0x13ad
jmp 0x13af
jmp 0x139c
movq -0x8(%rbp), %rax
movq $0x0, (%rax)
movq -0x8(%rbp), %rax
movl $0x0, 0x8(%rax)
movq -0x8(%rbp), %rdi
callq 0x1030
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/niho[P]elmc/src/estack.c
// Function: elmS_stack_pop
void *elmS_stack_pop(elmS_stack_t *stack) {
    if(stack->head == NULL)
        return NULL;

    elmS_stack_frame_t *frame = stack->head;
    /* Start of critical section */
    stack->head = frame->next;
    stack->size--;
    /* End of critical section */

    void *item = frame->item;
    frame->item = NULL;
    frame->next = NULL;
    free(frame);

    return item;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movq -0x10(%rbp), %rax
cmpq $0x0, (%rax)
jne 0x1400
movq $0x0, -0x8(%rbp)
jmp 0x145a
movq -0x10(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rax
movq 0x8(%rax), %rcx
movq -0x10(%rbp), %rax
movq %rcx, (%rax)
movq -0x10(%rbp), %rax
movl 0x8(%rax), %ecx
addl $-0x1, %ecx
movl %ecx, 0x8(%rax)
movq -0x18(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x20(%rbp)
movq -0x18(%rbp), %rax
movq $0x0, (%rax)
movq -0x18(%rbp), %rax
movq $0x0, 0x8(%rax)
movq -0x18(%rbp), %rdi
callq 0x1030
movq -0x20(%rbp), %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/niho[P]elmc/src/estack.c
// Function: elmS_stack_push
void elmS_stack_push(elmS_stack_t *stack, void *item) {
    elmS_stack_frame_t *frame = malloc(sizeof(elmS_stack_frame_t));
    frame->item = item;
    /* Start of critical section */
    frame->next = stack->head;
    stack->head = frame;
    stack->size++;
    /* End of critical section */
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl $0x10, %edi
callq 0x1080
movq %rax, -0x18(%rbp)
movq -0x10(%rbp), %rcx
movq -0x18(%rbp), %rax
movq %rcx, (%rax)
movq -0x8(%rbp), %rax
movq (%rax), %rcx
movq -0x18(%rbp), %rax
movq %rcx, 0x8(%rax)
movq -0x18(%rbp), %rcx
movq -0x8(%rbp), %rax
movq %rcx, (%rax)
movq -0x8(%rbp), %rax
movl 0x8(%rax), %ecx
addl $0x1, %ecx
movl %ecx, 0x8(%rax)
addq $0x20, %rsp
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O0/lacework-dev[P]strace_lab_PUBLIC/./src/example_5.c
// Function: main
int main(int argc, char *argv[])
{

	int pid = getuid();
	char *usr = getenv("USER");
	printf("User is %s, UID is: %d\n", usr, pid);

	if (pid != 0) {
		printf("[!] Cannot run! Must be root...\n");
		return 1;
	} else {
		printf("[+] Woo, running as root!\n");
	}

	return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movl $0x0, -0x4(%rbp)
movl %edi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
callq 0x1040
movl %eax, -0x14(%rbp)
leaq 0xe7f(%rip), %rdi       # 0x2004
callq 0x1030
movq %rax, -0x20(%rbp)
movq -0x20(%rbp), %rsi
movl -0x14(%rbp), %edx
leaq 0xe6d(%rip), %rdi       # 0x2009
movb $0x0, %al
callq 0x1050
cmpl $0x0, -0x14(%rbp)
je 0x11c0
leaq 0xe71(%rip), %rdi       # 0x2021
movb $0x0, %al
callq 0x1050
movl $0x1, -0x4(%rbp)
jmp 0x11d5
leaq 0xe7b(%rip), %rdi       # 0x2042
movb $0x0, %al
callq 0x1050
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x20, %rsp
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O0/aap[P]rx-0/misc/texas.c
// Function: listsyms
void
listsyms(void)
{
	Sym *s;

	qsort(symtab, MAXSYM, sizeof(Sym), cmpsym);
	fprintf(lstfp, "\n    SYMBOL TABLE\n");
	for(s = symtab; s < &symtab[MAXSYM]; s++){
		if((s->type&7) != SymValue)
			continue;
		if(s->supress)
			continue;
		fprintf(lstfp, "%-07s %06o\n", s->name, s->val);
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
leaq 0x3f31(%rip), %rdi      # 0x54a0
movl $0xfa0, %esi            # imm = 0xFA0
movl $0x18, %edx
leaq -0x50(%rip), %rcx       # 0x1530
callq 0x1050
movq 0x3f04(%rip), %rdi      # 0x5490
leaq 0x1b73(%rip), %rsi      # 0x3106
movb $0x0, %al
callq 0x10c0
leaq 0x3eff(%rip), %rax      # 0x54a0
movq %rax, -0x8(%rbp)
leaq 0x3ef4(%rip), %rax      # 0x54a0
addq $0x17700, %rax          # imm = 0x17700
cmpq %rax, -0x8(%rbp)
jae 0x1603
movq -0x8(%rbp), %rax
movl 0x8(%rax), %eax
andl $0x7, %eax
cmpl $0x1, %eax
je 0x15c9
jmp 0x15f5
movq -0x8(%rbp), %rax
cmpl $0x0, 0xc(%rax)
je 0x15d5
jmp 0x15f5
movq 0x3eb4(%rip), %rdi      # 0x5490
movq -0x8(%rbp), %rdx
movq -0x8(%rbp), %rax
movl 0x10(%rax), %ecx
leaq 0x1b2b(%rip), %rsi      # 0x3119
movb $0x0, %al
callq 0x10c0
movq -0x8(%rbp), %rax
addq $0x18, %rax
movq %rax, -0x8(%rbp)
jmp 0x15a5
addq $0x10, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/aap[P]rx-0/misc/texas.c
// Function: putword
void
putword(word w)
{
	static char left[64];

	if(pass2){
		/* listing */
		sprintf(left, "%06o  %06o\t", dot->val, w);
		list(left);

		fprintf(outfp, "%o: %o\n", dot->val++, w);
	}else{
		// this is probably useless...
		memory[dot->val++] = w;
	}
	dot->val &= W;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movl %edi, -0x4(%rbp)
cmpl $0x0, 0x1ae22(%rip)     # 0x1cba4
je 0x1dde
movq 0x1ae3d(%rip), %rax     # 0x1cbc8
movl 0x10(%rax), %edx
movl -0x4(%rbp), %ecx
leaq 0x1ae38(%rip), %rdi     # 0x1cbd0
leaq 0x142c(%rip), %rsi      # 0x31cb
movb $0x0, %al
callq 0x1130
leaq 0x1ae23(%rip), %rdi     # 0x1cbd0
callq 0x14b0
movq 0x1ae57(%rip), %rdi     # 0x1cc10
movq 0x1ae08(%rip), %rax     # 0x1cbc8
movl 0x10(%rax), %edx
movl %edx, %ecx
addl $0x1, %ecx
movl %ecx, 0x10(%rax)
movl -0x4(%rbp), %ecx
leaq 0x1402(%rip), %rsi      # 0x31d7
movb $0x0, %al
callq 0x10c0
jmp 0x1e01
movl -0x4(%rbp), %edx
movq 0x1ade0(%rip), %rcx     # 0x1cbc8
movl 0x10(%rcx), %eax
movl %eax, %esi
addl $0x1, %esi
movl %esi, 0x10(%rcx)
movl %eax, %eax
movl %eax, %ecx
leaq 0x1ae22(%rip), %rax     # 0x1cc20
movl %edx, (%rax,%rcx,4)
movq 0x1adc0(%rip), %rax     # 0x1cbc8
movl 0x10(%rax), %ecx
andl $0x3ffff, %ecx          # imm = 0x3FFFF
movl %ecx, 0x10(%rax)
addq $0x10, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/aap[P]rx-0/misc/texas.c
// Function: writelits
void
writelits(void)
{
	word a;
	static char left[64];

	fprintf(lstfp, "\n    LITERALS\n");
	for(a = litdot; a < litend; a++){
		/* listing */
		sprintf(left, "%06o  %06o\t", a, memory[a]);
		list(left);

		fprintf(outfp, "%o: %o\n", a, memory[a]);
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq 0x3661(%rip), %rdi      # 0x5490
leaq 0x13a9(%rip), %rsi      # 0x31df
movb $0x0, %al
callq 0x10c0
movl 0x5ae1d(%rip), %eax     # 0x5cc60
movl %eax, -0x4(%rbp)
movl -0x4(%rbp), %eax
cmpl 0x5ae15(%rip), %eax     # 0x5cc64
jae 0x1eb6
movl -0x4(%rbp), %edx
movl -0x4(%rbp), %eax
movl %eax, %ecx
leaq 0x1adc0(%rip), %rax     # 0x1cc20
movl (%rax,%rcx,4), %ecx
leaq 0x5adb6(%rip), %rdi     # 0x5cc20
leaq 0x135a(%rip), %rsi      # 0x31cb
movb $0x0, %al
callq 0x1130
leaq 0x5ada1(%rip), %rdi     # 0x5cc20
callq 0x14b0
movq 0x1ad85(%rip), %rdi     # 0x1cc10
movl -0x4(%rbp), %edx
movl -0x4(%rbp), %eax
movl %eax, %ecx
leaq 0x1ad86(%rip), %rax     # 0x1cc20
movl (%rax,%rcx,4), %ecx
leaq 0x1333(%rip), %rsi      # 0x31d7
movb $0x0, %al
callq 0x10c0
movl -0x4(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x4(%rbp)
jmp 0x1e46
addq $0x10, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/aap[P]rx-0/misc/texas.c
// Function: putlit
word
putlit(word w)
{
	word a;

	maxlits++;
	for(a = litdot; a < MAXMEM; a++)
		if(memory[a] == w)
			return a;
	if(litdot == 0)
		err(1, "error: too many literals");
	a = --litdot;
	memory[a] = w;
	return a;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movl %edi, -0x8(%rbp)
movl 0x5ad97(%rip), %eax     # 0x5cc68
addl $0x1, %eax
movl %eax, 0x5ad8e(%rip)     # 0x5cc68
movl 0x5ad80(%rip), %eax     # 0x5cc60
movl %eax, -0xc(%rbp)
cmpl $0x10000, -0xc(%rbp)    # imm = 0x10000
jae 0x1f15
movl -0xc(%rbp), %eax
movl %eax, %ecx
leaq 0x1ad28(%rip), %rax     # 0x1cc20
movl (%rax,%rcx,4), %eax
cmpl -0x8(%rbp), %eax
jne 0x1f08
movl -0xc(%rbp), %eax
movl %eax, -0x4(%rbp)
jmp 0x1f5b
jmp 0x1f0a
movl -0xc(%rbp), %eax
addl $0x1, %eax
movl %eax, -0xc(%rbp)
jmp 0x1ee3
cmpl $0x0, 0x5ad44(%rip)     # 0x5cc60
jne 0x1f31
movl $0x1, %edi
leaq 0x12c4(%rip), %rsi      # 0x31ee
movb $0x0, %al
callq 0x1270
movl 0x5ad29(%rip), %eax     # 0x5cc60
addl $-0x1, %eax
movl %eax, 0x5ad20(%rip)     # 0x5cc60
movl %eax, -0xc(%rbp)
movl -0x8(%rbp), %edx
movl -0xc(%rbp), %eax
movl %eax, %ecx
leaq 0x1acce(%rip), %rax     # 0x1cc20
movl %edx, (%rax,%rcx,4)
movl -0xc(%rbp), %eax
movl %eax, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/aap[P]rx-0/misc/texas.c
// Function: combine
word
combine(int op, word w1, word w2)
{
	switch(op){
	case 0:
		return w2;
	case '+':
		w1 += w2;
		if(w1 & 01000000)
			w1 += 1;
		return w1 & W;
	case '-':
		w1 += ~w2 & W;
		if(w1 & 01000000)
			w1 += 1;
		return w1 & W;
	case ' ':
	case '!':
		return (w1 | w2) & W;
	case '&':
		return (w1 & w2) & W;
	default:
		panic("unknown operator %c", op);
	}
	return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movl %edi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movl %edx, -0x10(%rbp)
movl -0x8(%rbp), %eax
movq %rax, -0x18(%rbp)
subq $0x2d, %rax
ja 0x2031
movq -0x18(%rbp), %rax
leaq 0x1067(%rip), %rcx      # 0x3004
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
movl -0x10(%rbp), %eax
movl %eax, -0x4(%rbp)
jmp 0x2049
movl -0x10(%rbp), %eax
addl -0xc(%rbp), %eax
movl %eax, -0xc(%rbp)
movl -0xc(%rbp), %eax
andl $0x40000, %eax          # imm = 0x40000
cmpl $0x0, %eax
je 0x1fd0
movl -0xc(%rbp), %eax
addl $0x1, %eax
movl %eax, -0xc(%rbp)
movl -0xc(%rbp), %eax
andl $0x3ffff, %eax          # imm = 0x3FFFF
movl %eax, -0x4(%rbp)
jmp 0x2049
movl -0x10(%rbp), %eax
xorl $-0x1, %eax
andl $0x3ffff, %eax          # imm = 0x3FFFF
addl -0xc(%rbp), %eax
movl %eax, -0xc(%rbp)
movl -0xc(%rbp), %eax
andl $0x40000, %eax          # imm = 0x40000
cmpl $0x0, %eax
je 0x2004
movl -0xc(%rbp), %eax
addl $0x1, %eax
movl %eax, -0xc(%rbp)
movl -0xc(%rbp), %eax
andl $0x3ffff, %eax          # imm = 0x3FFFF
movl %eax, -0x4(%rbp)
jmp 0x2049
movl -0xc(%rbp), %eax
orl -0x10(%rbp), %eax
andl $0x3ffff, %eax          # imm = 0x3FFFF
movl %eax, -0x4(%rbp)
jmp 0x2049
movl -0xc(%rbp), %eax
andl -0x10(%rbp), %eax
andl $0x3ffff, %eax          # imm = 0x3FFFF
movl %eax, -0x4(%rbp)
jmp 0x2049
movl -0x8(%rbp), %esi
leaq 0x11cc(%rip), %rdi      # 0x3207
movb $0x0, %al
callq 0x1360
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/aap[P]rx-0/misc/texas.c
// Function: main
int
main(int argc, char *argv[])
{
	int i;

	infp = stdin;
	filename = "<stdin>";
	tmpfp = mustopen("tmptmp", "wb");

	initsymtab();

	litdot = MAXMEM;
	dot->val = 040;
	pass2 = 0;
	assemble();

	checkundef();

	pass2 = 1;
	fclose(tmpfp);
	tmpfp = nil;
	infp = mustopen("tmptmp", "rb");
	outfp = mustopen("out.mem", "wb");

	lstfp = mustopen("out.lst", "w");
	litend = dot->val + maxlits;	// dot->val + (MAXMEM-litdot);
	litdot = litend;
	dot->val = 040;
	lineno = 1;
	peekc = 0;
	memset(memory, 0, sizeof(memory));
	assemble();

	writelits();

	fclose(infp);
	fclose(outfp);

	listsyms();

	printf("start: %o\n", startaddr);

	return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movl $0x0, -0x4(%rbp)
movl %edi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq 0x291b(%rip), %rax      # 0x4fd8
movq (%rax), %rax
movq %rax, 0x1a4e1(%rip)     # 0x1cba8
leaq 0xcf4(%rip), %rax       # 0x33c2
movq %rax, 0x2d5b(%rip)      # 0x5430
leaq 0xcee(%rip), %rdi       # 0x33ca
leaq 0xcee(%rip), %rsi       # 0x33d1
callq 0x1420
movq %rax, 0x1a4c1(%rip)     # 0x1cbb0
callq 0x25e0
movl $0x10000, 0x5a562(%rip) # imm = 0x10000
movq 0x1a4c3(%rip), %rax     # 0x1cbc8
movl $0x20, 0x10(%rax)
movl $0x0, 0x1a48e(%rip)     # 0x1cba4
callq 0x24f0
callq 0x2530
movl $0x1, 0x1a47a(%rip)     # 0x1cba4
movq 0x1a47f(%rip), %rdi     # 0x1cbb0
callq 0x1060
movq $0x0, 0x1a46f(%rip) # 0x1cbb0
leaq 0xc82(%rip), %rdi       # 0x33ca
leaq 0xc85(%rip), %rsi       # 0x33d4
callq 0x1420
movq %rax, 0x1a44d(%rip)     # 0x1cba8
leaq 0xc75(%rip), %rdi       # 0x33d7
leaq 0xc68(%rip), %rsi       # 0x33d1
callq 0x1420
movq %rax, 0x1a49b(%rip)     # 0x1cc10
leaq 0xc63(%rip), %rdi       # 0x33df
leaq 0xc64(%rip), %rsi       # 0x33e7
callq 0x1420
movq %rax, 0x2d01(%rip)      # 0x5490
movq 0x1a432(%rip), %rax     # 0x1cbc8
movl 0x10(%rax), %eax
addl 0x5a4c9(%rip), %eax     # 0x5cc68
movl %eax, 0x5a4bf(%rip)     # 0x5cc64
movl 0x5a4b9(%rip), %eax     # 0x5cc64
movl %eax, 0x5a4af(%rip)     # 0x5cc60
movq 0x1a410(%rip), %rax     # 0x1cbc8
movl $0x20, 0x10(%rax)
movl $0x1, 0x290b(%rip)      # 0x50d4
movl $0x0, 0x1a3cd(%rip)     # 0x1cba0
leaq 0x1a446(%rip), %rdi     # 0x1cc20
xorl %esi, %esi
movl $0x40000, %edx          # imm = 0x40000
callq 0x1090
callq 0x24f0
callq 0x1e20
movq 0x1a3b1(%rip), %rdi     # 0x1cba8
callq 0x1060
movq 0x1a40d(%rip), %rdi     # 0x1cc10
callq 0x1060
callq 0x1560
movl 0x5a459(%rip), %esi     # 0x5cc6c
leaq 0xbcf(%rip), %rdi       # 0x33e9
movb $0x0, %al
callq 0x1080
xorl %eax, %eax
addq $0x20, %rsp
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O0/albinoloverats[P]hide/src/bmp.c
// Function: init
extern image_type_t *init(void)
{
	static image_type_t bmp;
	bmp.type = "BMP";
	bmp.is_type = is_bmp;
	bmp.read = read_bmp;
	bmp.write = write_bmp;
	bmp.info = info_bmp;
	bmp.free = free_bmp;
	return &bmp;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
leaq 0xe55(%rip), %rax       # 0x2000
movq %rax, 0x2ec6(%rip)      # 0x4078
leaq 0x57(%rip), %rax        # 0x1210
movq %rax, 0x2ec0(%rip)      # 0x4080
leaq 0xc9(%rip), %rax        # 0x1290
movq %rax, 0x2eba(%rip)      # 0x4088
leaq 0x3fb(%rip), %rax       # 0x15d0
movq %rax, 0x2eb4(%rip)      # 0x4090
leaq 0x57d(%rip), %rax       # 0x1760
movq %rax, 0x2eae(%rip)      # 0x4098
leaq 0x5af(%rip), %rax       # 0x17a0
movq %rax, 0x2ea8(%rip)      # 0x40a0
leaq 0x2e79(%rip), %rax      # 0x4078
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/albinoloverats[P]hide/src/bmp.c
// Function: is_bmp
static bool is_bmp(char *file_name)
{
	FILE *bmp = fopen(file_name, "rb");
	if (!bmp)
		return false;
	uint8_t header[2];
	fread(header, sizeof header, 1, bmp);
	fclose(bmp);
	return !memcmp(HEADER, header, sizeof header);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movq -0x10(%rbp), %rdi
leaq 0xddd(%rip), %rsi       # 0x2004
callq 0x1070
movq %rax, -0x18(%rbp)
cmpq $0x0, -0x18(%rbp)
jne 0x123d
movb $0x0, -0x1(%rbp)
jmp 0x127b
leaq -0x1a(%rbp), %rdi
movq -0x18(%rbp), %rcx
movl $0x2, %esi
movl $0x1, %edx
callq 0x1050
movq -0x18(%rbp), %rdi
callq 0x1060
leaq -0x1a(%rbp), %rax
movw (%rax), %ax
subw $0x4d42, %ax            # imm = 0x4D42
setne %al
movzbl %al, %eax
cmpl $0x0, %eax
setne %al
xorb $-0x1, %al
andb $0x1, %al
movb %al, -0x1(%rbp)
movb -0x1(%rbp), %al
andb $0x1, %al
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/albinoloverats[P]hide/src/bmp.c
// Function: write_bmp
static int write_bmp(image_info_t image_info, void (*progress_update)(uint64_t, uint64_t))
{
	errno = EXIT_SUCCESS;

	FILE *bmp = fopen(image_info.file, "wb");
	if (!bmp)
		return errno;

	bmp_extra_t *extra = image_info.extra;
	fwrite(extra->data, extra->size, 1, bmp);

	uint32_t padding = image_info.width % 4;
	if (padding == 4)
		padding = 0;

	fseek(bmp, extra->size, SEEK_SET);
	for (uint64_t y = 0; y < image_info.height; y++)
	{
		fwrite(image_info.buffer[y], image_info.width, image_info.bpp, bmp);
		free(image_info.buffer[y]);
		uint32_t ignored = 0;
		if (padding)
			fwrite(&ignored, padding, 1, bmp);
		if (progress_update)
			progress_update(y, image_info.height);
	}
	free(image_info.buffer);

	free(extra->data);
	free(extra);

	fclose(bmp);

	return errno;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
leaq 0x10(%rbp), %rax
movq %rax, -0x40(%rbp)
movq %rdi, -0x10(%rbp)
callq 0x1040
movq %rax, %rcx
movq -0x40(%rbp), %rax
movl $0x0, (%rcx)
movq (%rax), %rdi
leaq 0xa07(%rip), %rsi       # 0x2007
callq 0x1070
movq %rax, -0x18(%rbp)
cmpq $0x0, -0x18(%rbp)
jne 0x161f
callq 0x1040
movl (%rax), %eax
movl %eax, -0x4(%rbp)
jmp 0x1750
movq -0x40(%rbp), %rax
movq 0x48(%rax), %rax
movq %rax, -0x20(%rbp)
movq -0x20(%rbp), %rax
movq 0x8(%rax), %rdi
movq -0x20(%rbp), %rax
movl (%rax), %eax
movl %eax, %esi
movq -0x18(%rbp), %rcx
movl $0x1, %edx
callq 0x10b0
movq -0x40(%rbp), %rax
movq 0x30(%rax), %rax
andq $0x3, %rax
movl %eax, -0x24(%rbp)
cmpl $0x4, -0x24(%rbp)
jne 0x1665
movl $0x0, -0x24(%rbp)
movq -0x18(%rbp), %rdi
movq -0x20(%rbp), %rax
movl (%rax), %eax
movl %eax, %esi
xorl %edx, %edx
callq 0x1090
movq $0x0, -0x30(%rbp)
movq -0x40(%rbp), %rcx
movq -0x30(%rbp), %rax
cmpq 0x28(%rcx), %rax
jae 0x171a
movq -0x40(%rbp), %rax
movq 0x40(%rax), %rcx
movq -0x30(%rbp), %rdx
movq (%rcx,%rdx,8), %rdi
movq 0x30(%rax), %rsi
movzwl 0x38(%rax), %eax
movl %eax, %edx
movq -0x18(%rbp), %rcx
callq 0x10b0
movq -0x40(%rbp), %rax
movq 0x40(%rax), %rax
movq -0x30(%rbp), %rcx
movq (%rax,%rcx,8), %rdi
callq 0x1030
movl $0x0, -0x34(%rbp)
cmpl $0x0, -0x24(%rbp)
je 0x16ee
movl -0x24(%rbp), %eax
movl %eax, %esi
movq -0x18(%rbp), %rcx
leaq -0x34(%rbp), %rdi
movl $0x1, %edx
callq 0x10b0
cmpq $0x0, -0x10(%rbp)
je 0x1707
movq -0x40(%rbp), %rcx
movq -0x10(%rbp), %rax
movq -0x30(%rbp), %rdi
movq 0x28(%rcx), %rsi
callq *%rax
jmp 0x1709
movq -0x30(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x30(%rbp)
jmp 0x1680
movq -0x40(%rbp), %rax
movq 0x40(%rax), %rdi
callq 0x1030
movq -0x20(%rbp), %rax
movq 0x8(%rax), %rdi
callq 0x1030
movq -0x20(%rbp), %rdi
callq 0x1030
movq -0x18(%rbp), %rdi
callq 0x1060
callq 0x1040
movl (%rax), %eax
movl %eax, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x40, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/albinoloverats[P]hide/src/bmp.c
// Function: free_bmp
static void free_bmp(image_info_t image_info)
{
	for (uint64_t y = 0; y < image_info.height; y++)
		free(image_info.buffer[y]);
	free(image_info.buffer);
	bmp_extra_t *extra = image_info.extra;
	free(extra->data);
	free(extra);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
leaq 0x10(%rbp), %rax
movq %rax, -0x18(%rbp)
movq $0x0, -0x8(%rbp)
movq -0x18(%rbp), %rcx
movq -0x8(%rbp), %rax
cmpq 0x28(%rcx), %rax
jae 0x17e9
movq -0x18(%rbp), %rax
movq 0x40(%rax), %rax
movq -0x8(%rbp), %rcx
movq (%rax,%rcx,8), %rdi
callq 0x1030
movq -0x8(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x8(%rbp)
jmp 0x17b8
movq -0x18(%rbp), %rax
movq 0x40(%rax), %rdi
callq 0x1030
movq -0x18(%rbp), %rax
movq 0x48(%rax), %rax
movq %rax, -0x10(%rbp)
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rdi
callq 0x1030
movq -0x10(%rbp), %rdi
callq 0x1030
addq $0x20, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/gadget114514[P]fatfs-example/rf2.c
// Function: main
void main()
{
  FIL f;
  int w;
  FATFS fs;
  char buf[1024];
  FCHK(f_mount(&fs, "", 1)); 
  if (f_open(&f, "0:a.txt", FA_OPEN_EXISTING|FA_READ) == FR_OK) {
    FCHK(f_read(&f, buf, 9, &w));
    printf("open & write %d %s\n", w, buf);
  } else {
    printf("open error\n");
    FCHK(f_close(&f));    
  }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x8d0, %rsp            # imm = 0x8D0
leaq -0x4b0(%rbp), %rdi
leaq 0x6309(%rip), %rsi      # 0x74a2
movl $0x1, %edx
callq 0x1630
movl %eax, -0x8b4(%rbp)
movl -0x8b4(%rbp), %eax
movl %eax, -0x8c0(%rbp)
movl -0x8b4(%rbp), %edi
callq 0x12d0
movl -0x8c0(%rbp), %edx
movq %rax, %rcx
leaq 0x5e84(%rip), %rdi      # 0x7054
leaq 0x5e90(%rip), %rsi      # 0x7067
movb $0x0, %al
callq 0x1040
leaq -0x250(%rbp), %rdi
leaq 0x5e8f(%rip), %rsi      # 0x707b
movl $0x1, %edx
callq 0x2000
cmpl $0x0, %eax
jne 0x1272
leaq -0x8b0(%rbp), %rsi
leaq -0x250(%rbp), %rdi
movl $0x9, %edx
leaq -0x254(%rbp), %rcx
callq 0x2c80
movl %eax, -0x8b8(%rbp)
movl -0x8b8(%rbp), %eax
movl %eax, -0x8c4(%rbp)
movl -0x8b8(%rbp), %edi
callq 0x12d0
movl -0x8c4(%rbp), %edx
movq %rax, %rcx
leaq 0x5e0d(%rip), %rdi      # 0x7054
leaq 0x5e35(%rip), %rsi      # 0x7083
movb $0x0, %al
callq 0x1040
movl -0x254(%rbp), %esi
leaq -0x8b0(%rbp), %rdx
leaq 0x5e31(%rip), %rdi      # 0x709a
movb $0x0, %al
callq 0x1040
jmp 0x12c7
leaq 0x5e35(%rip), %rdi      # 0x70ae
movb $0x0, %al
callq 0x1040
leaq -0x250(%rbp), %rdi
callq 0x3b40
movl %eax, -0x8bc(%rbp)
movl -0x8bc(%rbp), %eax
movl %eax, -0x8c8(%rbp)
movl -0x8bc(%rbp), %edi
callq 0x12d0
movl -0x8c8(%rbp), %edx
movq %rax, %rcx
leaq 0x5d9b(%rip), %rdi      # 0x7054
leaq 0x5dfa(%rip), %rsi      # 0x70ba
movb $0x0, %al
callq 0x1040
addq $0x8d0, %rsp            # imm = 0x8D0
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O0/motet-a[P]libforks/tests/file_descriptor_leaks.c
// Function: main
int main() {
  struct rlimit l;
  l.rlim_cur = l.rlim_max = 9;
  check(setrlimit(RLIMIT_NOFILE, &l) == 0);

  for (size_t i = 0; i < LOOPS; i++) {
    libforks_ServerConn conn;
    check(libforks_start(&conn) == libforks_OK);
    check(libforks_stop(conn) == libforks_OK);
  }

  libforks_ServerConn conn;
  check(libforks_start(&conn) == libforks_OK);

  for (size_t i = 0; i < LOOPS; i++) {
    int exit_fd;

    libforks_Result r = libforks_fork(
      conn,
      NULL, // pid_ptr
      NULL, // socket_fd_ptr
      &exit_fd, // exit_fd_ptr
      child_main
    );
    check(r == libforks_OK);

    libforks_ExitEvent event;
    check(read(exit_fd, &event, sizeof event) == sizeof event);

    check(close(exit_fd) == 0);
  }

  check(libforks_stop(conn) == libforks_OK);

  return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movl $0x0, -0x4(%rbp)
movq $0x9, -0x10(%rbp)
movq $0x9, -0x18(%rbp)
movl $0x7, %edi
leaq -0x18(%rbp), %rsi
callq 0x1180
cmpl $0x0, %eax
jne 0x1344
jmp 0x135c
leaq 0x2cb9(%rip), %rdi      # 0x4004
leaq 0x2cd4(%rip), %rsi      # 0x4026
movl $0x15, %edx
callq 0x14e0
movq $0x0, -0x20(%rbp)
cmpq $0x13, -0x20(%rbp)
jae 0x13cb
leaq -0x28(%rbp), %rdi
callq 0x1b40
cmpl $0x0, %eax
jne 0x137b
jmp 0x1393
leaq 0x2cc2(%rip), %rdi      # 0x4044
leaq 0x2c9d(%rip), %rsi      # 0x4026
movl $0x19, %edx
callq 0x14e0
movq -0x28(%rbp), %rdi
callq 0x25a0
cmpl $0x0, %eax
jne 0x13a3
jmp 0x13bb
leaq 0x2cbf(%rip), %rdi      # 0x4069
leaq 0x2c75(%rip), %rsi      # 0x4026
movl $0x1a, %edx
callq 0x14e0
jmp 0x13bd
movq -0x20(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x20(%rbp)
jmp 0x1364
leaq -0x30(%rbp), %rdi
callq 0x1b40
cmpl $0x0, %eax
jne 0x13db
jmp 0x13f3
leaq 0x2c62(%rip), %rdi      # 0x4044
leaq 0x2c3d(%rip), %rsi      # 0x4026
movl $0x1e, %edx
callq 0x14e0
movq $0x0, -0x38(%rbp)
cmpq $0x13, -0x38(%rbp)
jae 0x14af
movq -0x30(%rbp), %rdi
xorl %eax, %eax
movl %eax, %edx
leaq -0x3c(%rbp), %rcx
leaq 0x107(%rip), %r8        # 0x1520
movq %rdx, %rsi
callq 0x2310
movl %eax, -0x40(%rbp)
cmpl $0x0, -0x40(%rbp)
jne 0x142c
jmp 0x1444
leaq 0x2c59(%rip), %rdi      # 0x408c
leaq 0x2bec(%rip), %rsi      # 0x4026
movl $0x2a, %edx
callq 0x14e0
movl -0x3c(%rbp), %edi
leaq -0x48(%rbp), %rsi
movl $0x8, %edx
callq 0x1100
cmpq $0x8, %rax
jne 0x145d
jmp 0x1475
leaq 0x2c39(%rip), %rdi      # 0x409d
leaq 0x2bbb(%rip), %rsi      # 0x4026
movl $0x2d, %edx
callq 0x14e0
movl -0x3c(%rbp), %edi
callq 0x10d0
cmpl $0x0, %eax
jne 0x1484
jmp 0x149c
leaq 0x2c46(%rip), %rdi      # 0x40d1
leaq 0x2b94(%rip), %rsi      # 0x4026
movl $0x2f, %edx
callq 0x14e0
jmp 0x149e
movq -0x38(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x38(%rbp)
jmp 0x13fb
movq -0x30(%rbp), %rdi
callq 0x25a0
cmpl $0x0, %eax
jne 0x14bf
jmp 0x14d7
leaq 0x2ba3(%rip), %rdi      # 0x4069
leaq 0x2b59(%rip), %rsi      # 0x4026
movl $0x32, %edx
callq 0x14e0
xorl %eax, %eax
addq $0x50, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/Tarsnap[P]kivaloo/lbs-s3/dispatch.c
// Function: dispatch_accept
struct dispatch_state *
dispatch_accept(struct s3state * S, int s)
{
	struct dispatch_state * D;

	/* Allocate space for dispatcher state. */
	if ((D = malloc(sizeof(struct dispatch_state))) == NULL)
		goto err0;

	/* Initialize dispatcher. */
	D->S = S;

	/* Accept a connection. */
	D->accepting = 1;
	if (network_accept(s, callback_accept, D) == NULL)
		goto err1;

	/* Success! */
	return (D);

err1:
	free(D);
err0:
	/* Failure! */
	return (NULL);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movl %esi, -0x14(%rbp)
movl $0x38, %edi
callq 0x2290
movq %rax, -0x20(%rbp)
cmpq $0x0, %rax
jne 0x3535
jmp 0x3579
movq -0x10(%rbp), %rcx
movq -0x20(%rbp), %rax
movq %rcx, (%rax)
movq -0x20(%rbp), %rax
movl $0x1, 0x8(%rax)
movl -0x14(%rbp), %edi
movq -0x20(%rbp), %rdx
leaq 0x37(%rip), %rsi        # 0x3590
callq 0x9850
cmpq $0x0, %rax
jne 0x3566
jmp 0x3570
movq -0x20(%rbp), %rax
movq %rax, -0x8(%rbp)
jmp 0x3581
movq -0x20(%rbp), %rdi
callq 0x2040
movq $0x0, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/Tarsnap[P]kivaloo/lbs-s3/s3state.c
// Function: s3state_get
int
s3state_get(struct s3state * S, struct proto_lbs_request * R,
    int (* callback)(void *, struct proto_lbs_request *,
        const uint8_t *, size_t), void * cookie)
{
	struct get_cookie * C;

	/* Bake a cookie. */
	if ((C = malloc(sizeof(struct get_cookie))) == NULL)
		goto err0;
	C->S = S;
	C->R = R;
	C->callback = callback;
	C->cookie = cookie;

	/* Send the S3 request. */
	if (proto_s3_request_range(S->Q_S3, S->bucket,
	    objmap(BLK2OBJECT(R->r.get.blkno)),
	    BLKOFFSET(R->r.get.blkno, S->blklen), S->blklen,
	    callback_get, C))
		goto err1;

	/* We will be performing a callback later. */
	S->npending += 1;

	/* Success! */
	return (0);

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

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movq %rcx, -0x28(%rbp)
movl $0x20, %edi
callq 0x2290
movq %rax, -0x30(%rbp)
cmpq $0x0, %rax
jne 0x4091
jmp 0x4156
movq -0x10(%rbp), %rcx
movq -0x30(%rbp), %rax
movq %rcx, (%rax)
movq -0x18(%rbp), %rcx
movq -0x30(%rbp), %rax
movq %rcx, 0x8(%rax)
movq -0x20(%rbp), %rcx
movq -0x30(%rbp), %rax
movq %rcx, 0x10(%rax)
movq -0x28(%rbp), %rcx
movq -0x30(%rbp), %rax
movq %rcx, 0x18(%rax)
movq -0x10(%rbp), %rax
movq 0x18(%rax), %rax
movq %rax, -0x40(%rbp)
movq -0x10(%rbp), %rax
movq 0x28(%rax), %rax
movq %rax, -0x38(%rbp)
movq -0x18(%rbp), %rax
movq 0x10(%rax), %rdi
shrq $0x18, %rdi
addq $0x1, %rdi
callq 0x5060
movq -0x40(%rbp), %rdi
movq -0x38(%rbp), %rsi
movq %rax, %rdx
movq -0x18(%rbp), %rax
movq 0x10(%rax), %rax
andq $0xffffff, %rax         # imm = 0xFFFFFF
movq -0x10(%rbp), %rcx
movl (%rcx), %ecx
imulq %rcx, %rax
movl %eax, %ecx
movq -0x10(%rbp), %rax
movl (%rax), %r8d
movq -0x30(%rbp), %rax
leaq 0x4c(%rip), %r9         # 0x4170
movq %rax, (%rsp)
callq 0xf220
cmpl $0x0, %eax
je 0x4134
jmp 0x414d
movq -0x10(%rbp), %rax
movq 0x30(%rax), %rcx
addq $0x1, %rcx
movq %rcx, 0x30(%rax)
movl $0x0, -0x4(%rbp)
jmp 0x415d
movq -0x30(%rbp), %rdi
callq 0x2040
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
movl -0x4(%rbp), %eax
addq $0x50, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/Tarsnap[P]kivaloo/lbs-s3/s3state.c
// Function: callback_get
static int
callback_get(void * cookie, int failed, size_t buflen, const uint8_t * buf)
{
	struct get_cookie * C = cookie;
	struct s3state * S = C->S;
	int rc;

	/* If we failed or have the wrong size of buffer, we have no block. */
	if ((failed != 0) || (buflen != S->blklen))
		buf = NULL;

	/* Tell the dispatcher to send its response back. */
	rc = (C->callback)(C->cookie, C->R, buf, buflen);

	/* We've done a callback. */
	S->npending -= 1;

	/* Free our cookie. */
	free(C);

	/* Return status from callback. */
	return (rc);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movq %rdx, -0x18(%rbp)
movq %rcx, -0x20(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x28(%rbp)
movq -0x28(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x30(%rbp)
cmpl $0x0, -0xc(%rbp)
jne 0x41af
movq -0x18(%rbp), %rax
movq -0x30(%rbp), %rcx
movl (%rcx), %ecx
cmpq %rcx, %rax
je 0x41b7
movq $0x0, -0x20(%rbp)
movq -0x28(%rbp), %rax
movq 0x10(%rax), %rax
movq -0x28(%rbp), %rcx
movq 0x18(%rcx), %rdi
movq -0x28(%rbp), %rcx
movq 0x8(%rcx), %rsi
movq -0x20(%rbp), %rdx
movq -0x18(%rbp), %rcx
callq *%rax
movl %eax, -0x34(%rbp)
movq -0x30(%rbp), %rax
movq 0x30(%rax), %rcx
subq $0x1, %rcx
movq %rcx, 0x30(%rax)
movq -0x28(%rbp), %rdi
callq 0x2040
movl -0x34(%rbp), %eax
addq $0x40, %rsp
popq %rbp
retq
nop