LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O1/LenShustek[P]miditones/miditones.c
// Function: outfile_items
void outfile_items(int n) {
   outfile_bytecount += n;
   outfile_itemcount += n;
   if (!binaryoutput) {
      if (outfile_itemcount >= outfile_maxitems) {
         if (asm_output) fprintf(outfile, "\n%s", byteop);
         else fprintf(outfile, ",\n");
         outfile_itemcount = 0; }
      else fprintf(outfile, ", "); } }

// Assembly:
movslq %edi, %rax
addq %rax, 0x73d7(%rip)      # 0x9188
addl 0x737d(%rip), %eax      # 0x9134
movl %eax, 0x7377(%rip)      # 0x9134
cmpb $0x0, 0x73fc(%rip)      # 0x91c0
jne 0x1e3a
cmpl 0x731c(%rip), %eax      # 0x90e8
jge 0x1deb
movq 0x741b(%rip), %rcx      # 0x91f0
leaq 0x4a84(%rip), %rdi      # 0x6860
movl $0x2, %esi
movl $0x1, %edx
jmp 0x1150
pushq %rax
movq 0x73fd(%rip), %rcx      # 0x91f0
cmpb $0x1, 0x73d0(%rip)      # 0x91ca
jne 0x1e16
movq 0x72dd(%rip), %rdx      # 0x90e0
leaq 0x4a78(%rip), %rsi      # 0x6882
movq %rcx, %rdi
xorl %eax, %eax
callq 0x10b0
jmp 0x1e2c
leaq 0x3c36(%rip), %rdi      # 0x5a53
movl $0x2, %esi
movl $0x1, %edx
callq 0x1150
movl $0x0, 0x72fe(%rip)      # 0x9134
addq $0x8, %rsp
retq
// File: /workspace/github_c_makefile_star2_O1/LenShustek[P]miditones/miditones.c
// Function: describe
char *describe(struct noteinfo *np) { // create a description of a note
   // WARNING: returns a pointer to a static string, so only call once per line, in a printf!
   static char notedescription[100];
   int secs = np->time_usec / 1000000;
   sprintf(notedescription, "at %3lu.%06lu sec (%d:%02d), note %d (0x%02X) track %d channel %d volume %d instrument %d",
           secs, np->time_usec % 1000000,
           secs/60, secs % 60,
           np->note, np->note,
           np->track, np->channel, np->volume, np->instrument);
   return notedescription; }

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movl (%rdi), %eax
movl 0x4(%rdi), %r10d
imulq $0x431bde83, %rax, %rdx # imm = 0x431BDE83
shrq $0x32, %rdx
imull $0xf4240, %edx, %esi    # imm = 0xF4240
movl %eax, %ecx
subl %esi, %ecx
shrl $0x8, %eax
imulq $0x11e54c7, %rax, %r8   # imm = 0x11E54C7
shrq $0x2a, %r8
imulq $0x4444445, %rdx, %rax  # imm = 0x4444445
shrq $0x20, %rax
imull $0x3c, %eax, %eax
movl %edx, %r9d
subl %eax, %r9d
movl 0xc(%rdi), %r11d
movl 0x8(%rdi), %r14d
movl 0x14(%rdi), %r15d
movl 0x10(%rdi), %r12d
leaq 0x92e9(%rip), %rbx      # 0xb180
leaq 0x3bb8(%rip), %rsi      # 0x5a56
movq %rbx, %rdi
xorl %eax, %eax
pushq %r12
pushq %r15
pushq %r14
pushq %r10
pushq %r11
pushq %r11
callq 0x1130
addq $0x30, %rsp
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O1/LenShustek[P]miditones/miditones.c
// Function: show_queue
void show_queue(void) { // for debugging: dump the whole event queue
   FILE *fid = logfile;
   if (!logfile) fid = stdout;
   fprintf(fid, "***at output time %lu.%03lu  queue has %d items; oldest at %d, newest at %d\n",
           output_usec / 1000, output_usec % 1000, queue_numitems, queue_oldest_ndx, queue_newest_ndx);
   int ndx = queue_oldest_ndx;
   if (queue_numitems > 0) while (1) {
         struct queue_entry *q = &queue[ndx];
         fprintf(fid, "%2d: %s %s %s\n", ndx, q->cmd == CMD_PLAYNOTE ? "PLAY" : "STOP", q->delete ? "deleted" : "", describe(&q->note));
         if (ndx == queue_newest_ndx) break;
         if (++ndx >= QUEUE_SIZE) ndx = 0; } }

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq 0x72ff(%rip), %rbx      # 0x91d8
testq %rbx, %rbx
jne 0x1ee8
movq 0x70f3(%rip), %rax      # 0x8fd8
movq (%rax), %rbx
movl 0x72ba(%rip), %ecx      # 0x91a8
imulq $0x10624dd3, %rcx, %rdx # imm = 0x10624DD3
shrq $0x26, %rdx
imull $0x3e8, %edx, %eax      # imm = 0x3E8
subl %eax, %ecx
movl 0x92dc(%rip), %r8d      # 0xb1e4
movl 0x92d9(%rip), %r9d      # 0xb1e8
movl 0x92d7(%rip), %eax      # 0xb1ec
movl %eax, (%rsp)
leaq 0x3b91(%rip), %rsi      # 0x5ab0
movq %rbx, %rdi
xorl %eax, %eax
callq 0x10b0
cmpl $0x0, 0x92b4(%rip)      # 0xb1e4
jle 0x1fd0
movl 0x92ac(%rip), %eax      # 0xb1e8
leaq 0x3bba(%rip), %r14      # 0x5afd
leaq 0x9236(%rip), %r15      # 0xb180
movslq %eax, %r12
leaq (%r12,%r12,8), %rax
leaq (%rax,%rax,2), %rax
addq %r12, %rax
leaq 0x92a1(%rip), %rcx      # 0xb200
leaq (%rcx,%rax), %rdi
addq $0x4, %rdi
cmpb $-0x70, -0x4(%rdi)
leaq 0x3b9f(%rip), %r13      # 0x5b11
leaq 0x3b93(%rip), %rax      # 0x5b0c
cmoveq %rax, %r13
cmpb $0x0, -0x3(%rdi)
leaq 0x3b8e(%rip), %rbp      # 0x5b16
leaq 0x46fb(%rip), %rax      # 0x668a
cmoveq %rax, %rbp
callq 0x1e3b
movq %rbx, %rdi
movq %r14, %rsi
movl %r12d, %edx
movq %r13, %rcx
movq %rbp, %r8
xorl %ebp, %ebp
movq %r15, %r9
xorl %eax, %eax
callq 0x10b0
leal 0x1(%r12), %eax
cmpl $0x63, %r12d
cmovgel %ebp, %eax
cmpl 0x9226(%rip), %r12d     # 0xb1ec
cmovel %r12d, %eax
jne 0x1f4a
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/LenShustek[P]miditones/miditones.c
// Function: show_tonegens
void show_tonegens(void) { // for debugging: dump tone generator status
   FILE *fid = logfile;
   if (!logfile) fid = stdout;
   fprintf(fid, "*** tone generator status at output time %lu.%03lu\n", output_usec / 1000, output_usec % 1000);
   for (int tgnum = 0; tgnum < num_tonegens; ++tgnum) {
      struct tonegen_status *tg = &tonegen[tgnum];
      if (tg->playing)
         fprintf(fid, "#%d: playing note %d (%02X), instrument %d, track %d channel %d%s\n",
                 tgnum, tg->note.note, tg->note.note, tg->note.instrument, tg->note.track, tg->note.channel,
                 tg->stopnote_pending ? ", stopnote pending\n" : "");
      else fprintf(fid, "#%d: idle\n", tgnum); } }

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq 0x71e7(%rip), %rbx      # 0x91d8
testq %rbx, %rbx
jne 0x2000
movq 0x6fdb(%rip), %rax      # 0x8fd8
movq (%rax), %rbx
movl 0x71a2(%rip), %ecx      # 0x91a8
imulq $0x10624dd3, %rcx, %rdx # imm = 0x10624DD3
shrq $0x26, %rdx
imull $0x3e8, %edx, %eax      # imm = 0x3E8
subl %eax, %ecx
leaq 0x3afe(%rip), %rsi      # 0x5b1e
movq %rbx, %rdi
xorl %eax, %eax
callq 0x10b0
cmpl $0x0, 0x70bb(%rip)      # 0x90ec
jle 0x20c2
leaq 0x71c2(%rip), %r13      # 0x9200
leaq 0x3b0d(%rip), %r14      # 0x5b52
leaq 0x3b5d(%rip), %r15      # 0x5ba9
xorl %r12d, %r12d
cmpb $0x1, (%r13)
jne 0x209f
movl 0x10(%r13), %ecx
movl 0x14(%r13), %r9d
movl 0x8(%r13), %r10d
cmpb $0x0, 0x1(%r13)
movl 0xc(%r13), %r11d
leaq 0x4618(%rip), %rbp      # 0x668a
leaq 0x3b1c(%rip), %rax      # 0x5b95
cmovneq %rax, %rbp
subq $0x8, %rsp
movq %rbx, %rdi
movq %r14, %rsi
movl %r12d, %edx
movl %ecx, %r8d
xorl %eax, %eax
pushq %rbp
pushq %r11
pushq %r10
callq 0x10b0
addq $0x20, %rsp
jmp 0x20af
movq %rbx, %rdi
movq %r15, %rsi
movl %r12d, %edx
xorl %eax, %eax
callq 0x10b0
incq %r12
movslq 0x7033(%rip), %rax      # 0x90ec
addq $0x1c, %r13
cmpq %rax, %r12
jl 0x204f
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/LenShustek[P]miditones/miditones.c
// Function: generate_delay
void generate_delay(unsigned long delta_msec) { // output a delay command
   if (delta_msec > 0) {
      assert(delta_msec <= 0x7fff, "time delta too big");
      if (last_output_was_delay) {
         ++consecutive_delays;
         if (loggen) fprintf(logfile, "      *** this is a consecutive delay, of %d msec\n", delta_msec); }
      last_output_was_delay = true;
      if (binaryoutput) { // output a 15-bit delay in big-endian format
         putc((byte)(delta_msec >> 8), outfile);
         putc((byte)(delta_msec & 0xff), outfile);
         outfile_bytecount += 2; }
      else if (asm_output) {
         fprintf(outfile, "%s%02X", hex, (byte)(delta_msec >> 8));
         outfile_items(1);
         fprintf(outfile, "%s%02X", hex, (byte)(delta_msec & 0xff));
         outfile_items(1); }
      else {
         fprintf(outfile, "%ld,%ld", delta_msec >> 8, delta_msec & 0xff);
         outfile_items(2); } } }

// Assembly:
pushq %rbp
pushq %r14
pushq %rbx
testq %rdi, %rdi
je 0x27de
movq %rdi, %rbx
xorl %edi, %edi
cmpq $0x8000, %rbx           # imm = 0x8000
setb %dil
leaq 0x35d6(%rip), %rsi      # 0x5d3f
callq 0x1b7b
cmpb $0x1, 0x69eb(%rip)      # 0x9160
jne 0x279e
incl 0x69df(%rip)            # 0x915c
cmpb $0x1, 0x6a3f(%rip)      # 0x91c3
jne 0x279e
movq 0x6a4b(%rip), %rdi      # 0x91d8
leaq 0x35be(%rip), %rsi      # 0x5d52
movq %rbx, %rdx
xorl %eax, %eax
callq 0x10b0
movb $0x1, 0x69bb(%rip)      # 0x9160
cmpb $0x1, 0x6a14(%rip)      # 0x91c0
jne 0x27e3
movl %ebx, %edi
shrl $0x8, %edi
movl $0xff, %ebp
andl %ebp, %edi
movq 0x6a2f(%rip), %rsi      # 0x91f0
callq 0x10a0
andl %ebp, %ebx
movq 0x6a21(%rip), %rsi      # 0x91f0
movl %ebx, %edi
callq 0x10a0
addq $0x2, 0x69aa(%rip)      # 0x9188
popq %rbx
popq %r14
popq %rbp
retq
movq 0x6a06(%rip), %rdi      # 0x91f0
cmpb $0x1, 0x69d9(%rip)      # 0x91ca
jne 0x2844
movq 0x68de(%rip), %rdx      # 0x90d8
movl %ebx, %ecx
shrl $0x8, %ecx
movl $0xff, %ebp
andl %ebp, %ecx
leaq 0x34a5(%rip), %r14      # 0x5cb2
movq %r14, %rsi
xorl %eax, %eax
callq 0x10b0
movl $0x1, %edi
callq 0x1da7
movq 0x69c8(%rip), %rdi      # 0x91f0
movq 0x68a9(%rip), %rdx      # 0x90d8
andl %ebp, %ebx
movq %r14, %rsi
movl %ebx, %ecx
xorl %eax, %eax
callq 0x10b0
movl $0x1, %edi
jmp 0x2861
movq %rbx, %rdx
shrq $0x8, %rdx
movzbl %bl, %ecx
leaq 0x3530(%rip), %rsi      # 0x5d85
xorl %eax, %eax
callq 0x10b0
movl $0x2, %edi
popq %rbx
popq %r14
popq %rbp
jmp 0x1da7
// File: /workspace/github_c_makefile_star2_O1/LenShustek[P]miditones/miditones.c
// Function: queue_find_playnote
int queue_find_playnote(int search_ndx) {
   if (loggen) fprintf(logfile, "      queue_find_playnote(%d), %s: ", search_ndx, describe(&queue[search_ndx].note));
   for (int ndx = queue_newest_ndx;;) {
      if (ndx != search_ndx // don't look at the entry we're trying to match
            && !queue[ndx].delete // don't re-find queue entries already deleted
            && queue[ndx].cmd == CMD_PLAYNOTE // must match playnote
            && queue[ndx].note.channel == queue[search_ndx].note.channel //also channel, track, note, and instrument
            && queue[ndx].note.track == queue[search_ndx].note.track
            && queue[ndx].note.note == queue[search_ndx].note.note
            && queue[ndx].note.instrument == queue[search_ndx].note.instrument ) {
         if (loggen) fprintf(logfile, "found ndx %d\n", ndx);
         return ndx; }
      if (ndx == queue_oldest_ndx) break;
      if (--ndx < 0) ndx = QUEUE_SIZE - 1; }
   if (loggen) fprintf(logfile, "not found\n");
   return -1; }

// Assembly:
pushq %rbp
pushq %r14
pushq %rbx
movl %edi, %ebp
cmpb $0x1, 0x666d(%rip)      # 0x91c3
movslq %edi, %r14
jne 0x2b9c
movq 0x6676(%rip), %rbx      # 0x91d8
leaq (%r14,%r14,8), %rax
leaq (%rax,%rax,2), %rax
addq %r14, %rax
leaq 0x868c(%rip), %rcx      # 0xb200
leaq (%rcx,%rax), %rdi
addq $0x4, %rdi
callq 0x1e3b
leaq 0x3328(%rip), %rsi      # 0x5eb0
leaq 0x85f1(%rip), %rcx      # 0xb180
movq %rbx, %rdi
movl %r14d, %edx
xorl %eax, %eax
callq 0x10b0
movl 0x864a(%rip), %ebx      # 0xb1ec
leaq (%r14,%r14,8), %rax
leaq (%rax,%rax,2), %rcx
addq %r14, %rcx
leaq 0x864c(%rip), %rax      # 0xb200
addq %rax, %rcx
addq $0x4, %rcx
movl 0x8627(%rip), %edx      # 0xb1e8
movl $0x63, %esi
cmpl %ebp, %ebx
je 0x2c0d
movslq %ebx, %r8
leaq (%r8,%r8,8), %rdi
leaq (%rdi,%rdi,2), %rdi
addq %r8, %rdi
cmpb $0x0, 0x1(%rax,%rdi)
jne 0x2c0d
addq %rax, %rdi
cmpb $-0x70, (%rdi)
jne 0x2c0d
movl 0xc(%rdi), %r8d
cmpl 0x8(%rcx), %r8d
jne 0x2c0d
movl 0x8(%rdi), %r8d
cmpl 0x4(%rcx), %r8d
jne 0x2c0d
movl 0x10(%rdi), %r8d
cmpl 0xc(%rcx), %r8d
jne 0x2c0d
movl 0x14(%rdi), %edi
cmpl 0x10(%rcx), %edi
je 0x2c4f
cmpl %edx, %ebx
je 0x2c1d
testl %ebx, %ebx
leal -0x1(%rbx), %edi
cmovlel %esi, %edi
movl %edi, %ebx
jmp 0x2bc6
movl $0xffffffff, %ebx       # imm = 0xFFFFFFFF
cmpb $0x1, 0x659a(%rip)      # 0x91c3
jne 0x2c48
movq 0x65a6(%rip), %rcx      # 0x91d8
leaq 0x32a9(%rip), %rdi      # 0x5ee2
movl $0xa, %esi
movl $0x1, %edx
callq 0x1150
movl %ebx, %eax
popq %rbx
popq %r14
popq %rbp
retq
cmpb $0x1, 0x656d(%rip)      # 0x91c3
jne 0x2c48
movq 0x6579(%rip), %rdi      # 0x91d8
leaq 0x326e(%rip), %rsi      # 0x5ed4
movl %ebx, %edx
xorl %eax, %eax
callq 0x10b0
jmp 0x2c48
// File: /workspace/github_c_makefile_star2_O1/LenShustek[P]miditones/miditones.c
// Function: queue_find_stopnote
int queue_find_stopnote(int search_ndx) {
   if (loggen) fprintf(logfile, "      queue_find_stopnote(%d), %s: ", search_ndx, describe(&queue[search_ndx].note));
   for (int ndx = queue_newest_ndx;;) {
      if (ndx != search_ndx // don't look at the entry we're trying to match
            && !queue[ndx].delete // don't re-find queue entries already deleted
            && queue[ndx].cmd == CMD_STOPNOTE // must match stopnote
            && queue[ndx].note.time_usec == queue[search_ndx].note.time_usec // also time, note, and instrument
            && queue[ndx].note.note == queue[search_ndx].note.note
            && queue[ndx].note.instrument == queue[search_ndx].note.instrument) {
         if (loggen) fprintf(logfile, "found ndx %d\n", ndx);
         return ndx; }
      if (ndx == queue_oldest_ndx) break;
      if (--ndx < 0) ndx = QUEUE_SIZE - 1; }
   if (loggen) fprintf(logfile, "not found\n");
   return -1; }

// Assembly:
pushq %rbp
pushq %r14
pushq %rbx
movl %edi, %ebp
cmpb $0x1, 0x6545(%rip)      # 0x91c3
movslq %edi, %r14
jne 0x2cc4
movq 0x654e(%rip), %rbx      # 0x91d8
leaq (%r14,%r14,8), %rax
leaq (%rax,%rax,2), %rax
addq %r14, %rax
leaq 0x8564(%rip), %rcx      # 0xb200
leaq (%rcx,%rax), %rdi
addq $0x4, %rdi
callq 0x1e3b
leaq 0x323d(%rip), %rsi      # 0x5eed
leaq 0x84c9(%rip), %rcx      # 0xb180
movq %rbx, %rdi
movl %r14d, %edx
xorl %eax, %eax
callq 0x10b0
movl 0x8522(%rip), %ebx      # 0xb1ec
leaq (%r14,%r14,8), %rax
leaq (%rax,%rax,2), %rcx
addq %r14, %rcx
leaq 0x8524(%rip), %rax      # 0xb200
addq %rax, %rcx
addq $0x4, %rcx
movl 0x84ff(%rip), %edx      # 0xb1e8
movl $0x63, %esi
xorl %edi, %edi
cmpl %ebp, %ebx
je 0x2d2f
movslq %ebx, %r9
leaq (%r9,%r9,8), %r8
leaq (%r8,%r8,2), %r8
addq %r9, %r8
cmpb $0x0, 0x1(%rax,%r8)
jne 0x2d2f
addq %rax, %r8
cmpb (%r8), %dil
jno 0x2d2f
movl 0x4(%r8), %r9d
cmpl (%rcx), %r9d
jne 0x2d2f
movl 0x10(%r8), %r9d
cmpl 0xc(%rcx), %r9d
jne 0x2d2f
movl 0x14(%r8), %r8d
cmpl 0x10(%rcx), %r8d
je 0x2d74
cmpl %edx, %ebx
je 0x2d42
testl %ebx, %ebx
leal -0x1(%rbx), %r8d
cmovlel %esi, %r8d
movl %r8d, %ebx
jmp 0x2cf0
movl $0xffffffff, %ebx       # imm = 0xFFFFFFFF
cmpb $0x1, 0x6475(%rip)      # 0x91c3
jne 0x2d6d
movq 0x6481(%rip), %rcx      # 0x91d8
leaq 0x3184(%rip), %rdi      # 0x5ee2
movl $0xa, %esi
movl $0x1, %edx
callq 0x1150
movl %ebx, %eax
popq %rbx
popq %r14
popq %rbp
retq
cmpb $0x1, 0x6448(%rip)      # 0x91c3
jne 0x2d6d
movq 0x6454(%rip), %rdi      # 0x91d8
leaq 0x3149(%rip), %rsi      # 0x5ed4
movl %ebx, %edx
xorl %eax, %eax
callq 0x10b0
jmp 0x2d6d
// File: /workspace/github_c_makefile_star2_O1/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:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movl %edi, %ebx
callq 0x2b49
testl %eax, %eax
js 0x2e56
movl %eax, %r14d
movl %ebx, %edi
callq 0x2c71
testl %eax, %eax
js 0x2e56
movl %eax, %ebx
movl %eax, %edi
callq 0x2b49
testl %eax, %eax
js 0x2e56
movl %eax, %ebp
movl %eax, %ecx
leaq (%rcx,%rcx,8), %rax
leaq (%rax,%rax,2), %rax
addq %rcx, %rax
leaq 0x841a(%rip), %r15      # 0xb200
movl 0x4(%r15,%rax), %ecx
movl %r14d, %edx
leaq (%rdx,%rdx,8), %rsi
leaq (%rsi,%rsi,2), %rsi
addq %rdx, %rsi
cmpl 0x4(%r15,%rsi), %ecx
jne 0x2e56
leaq (%r15,%rax), %r12
cmpb $0x1, 0x63b8(%rip)      # 0x91c3
jne 0x2e3d
leaq (%r15,%rax), %rdi
addq $0x4, %rdi
movq 0x63bc(%rip), %r14      # 0x91d8
callq 0x1e3b
leaq 0x30e9(%rip), %rsi      # 0x5f11
leaq 0x8351(%rip), %r8       # 0xb180
movq %r14, %rdi
movl %ebp, %edx
movl %ebx, %ecx
xorl %eax, %eax
callq 0x10b0
movl %ebx, %eax
leaq (%rax,%rax,8), %rcx
leaq (%rcx,%rcx,2), %rcx
addq %rax, %rcx
movb $0x1, %al
movb %al, 0x1(%r15,%rcx)
movb %al, 0x1(%r12)
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/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:
pushq %rbp
pushq %r14
pushq %rbx
subq $0x20, %rsp
movl %edx, %ebx
movl %esi, %ebp
movl %edi, %r14d
cmpl $0x90, %esi
leaq 0x2a79(%rip), %rax      # 0x5b0c
leaq 0x2a77(%rip), %rsi      # 0x5b11
cmoveq %rax, %rsi
leaq 0x2ef0(%rip), %rdi      # 0x5f95
movl %r14d, %ecx
xorl %eax, %eax
callq 0x1080
leaq 0x8(%rsp), %rsi
movl %r14d, (%rsi)
movq $0x0, 0x4(%rsi)
movl %ebx, 0xc(%rsi)
movabsq $0x6400000001, %rax     # imm = 0x6400000001
movq %rax, 0x10(%rsi)
movl %ebp, %edi
callq 0x2e5f
addq $0x20, %rsp
popq %rbx
popq %r14
popq %rbp
jmp 0x1ec7
// File: /workspace/github_c_makefile_star2_O1/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:
pushq %rbp
pushq %rbx
pushq %rax
movq 0x8c02(%rip), %rbx      # 0xbcf0
movl 0x60ec(%rip), %eax      # 0x91e0
movl %ebx, %ecx
subl %eax, %ecx
addl $0x10, %ecx
cmpq 0x60e6(%rip), %rcx      # 0x91e8
ja 0x3216
xorl %eax, %eax
leaq 0x2ea6(%rip), %rcx      # 0x5fb7
movb (%rbx,%rax), %dl
cmpb (%rax,%rcx), %dl
jne 0x3207
incq %rax
cmpq $0x4, %rax
jne 0x3111
movzwl 0xa(%rbx), %eax
rolw $0x8, %ax
movzwl %ax, %eax
movl %eax, 0x8bc1(%rip)      # 0xbcf8
movzwl 0xc(%rbx), %eax
rolw $0x8, %ax
movzwl %ax, %ebp
movl %ebp, %eax
shrl $0x8, %eax
andl $0x7f, %eax
movzbl %bpl, %ecx
imull %eax, %ecx
testw %bp, %bp
cmovnsl %ebp, %ecx
movl %ecx, 0x5faf(%rip)      # 0x910c
cmpb $0x1, 0x6061(%rip)      # 0x91c5
jne 0x31f1
movq 0x6067(%rip), %rdi      # 0x91d8
movl 0x4(%rbx), %edx
bswapl %edx
leaq 0x2e4e(%rip), %rsi      # 0x5fcb
xorl %eax, %eax
callq 0x10b0
movq 0x604d(%rip), %rdi      # 0x91d8
movzwl 0x8(%rbx), %eax
rolw $0x8, %ax
movzwl %ax, %edx
leaq 0x2e3e(%rip), %rsi      # 0x5fdb
xorl %eax, %eax
callq 0x10b0
movq 0x602d(%rip), %rdi      # 0x91d8
movl 0x8b47(%rip), %edx      # 0xbcf8
leaq 0x2e33(%rip), %rsi      # 0x5feb
xorl %eax, %eax
callq 0x10b0
movq 0x6012(%rip), %rdi      # 0x91d8
leaq 0x2e33(%rip), %rsi      # 0x6000
movl %ebp, %edx
xorl %eax, %eax
callq 0x10b0
movq 0x5ffb(%rip), %rdi      # 0x91d8
movl 0x5f29(%rip), %edx      # 0x910c
leaq 0x2e2a(%rip), %rsi      # 0x6014
xorl %eax, %eax
callq 0x10b0
movl 0x4(%rbx), %eax
bswapl %eax
addl $0x8, %eax
addq %rax, 0x8af0(%rip)      # 0xbcf0
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
leaq 0x2dae(%rip), %rdi      # 0x5fbc
movq %rbx, %rsi
callq 0x1b89
leaq 0x2829(%rip), %rdi      # 0x5a46
jmp 0x320e
// File: /workspace/github_c_makefile_star2_O1/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:
pushq %r14
pushq %rbx
pushq %rax
movq 0x8ac6(%rip), %rsi      # 0xbcf0
movl 0x5fb0(%rip), %eax      # 0x91e0
movl %esi, %ecx
subl %eax, %ecx
addl $0x8, %ecx
cmpq 0x5faa(%rip), %rcx      # 0x91e8
ja 0x32f0
movl %edi, %ebx
xorl %eax, %eax
leaq 0x2dd6(%rip), %rcx      # 0x6025
movb (%rsi,%rax), %dl
cmpb (%rax,%rcx), %dl
jne 0x32e4
incq %rax
cmpq $0x4, %rax
jne 0x324f
movl 0x4(%rsi), %r14d
bswapl %r14d
cmpb $0x1, 0x5f53(%rip)      # 0x91c5
jne 0x328e
movq 0x5f5d(%rip), %rdi      # 0x91d8
leaq 0x2db7(%rip), %rsi      # 0x6039
movl %ebx, %edx
movq %r14, %rcx
xorl %eax, %eax
callq 0x10b0
movq 0x8a5b(%rip), %rax      # 0xbcf0
leaq 0x8(%rax), %rsi
movq %rsi, 0x8a50(%rip)      # 0xbcf0
addq %r14, %rax
addq $0x8, %rax
movl 0x5f33(%rip), %ecx      # 0x91e0
movl %eax, %edx
subl %ecx, %edx
cmpq 0x5f30(%rip), %rdx      # 0x91e8
ja 0x32f0
movslq %ebx, %rcx
leaq (%rcx,%rcx,2), %rcx
shlq $0x4, %rcx
leaq 0x60f4(%rip), %rdx      # 0x93c0
movq %rsi, (%rcx,%rdx)
movq %rax, 0x8a19(%rip)      # 0xbcf0
movq %rax, 0x8(%rcx,%rdx)
addq $0x8, %rsp
popq %rbx
popq %r14
retq
leaq 0x2d3f(%rip), %rdi      # 0x602a
callq 0x1b89
leaq 0x274f(%rip), %rdi      # 0x5a46
callq 0x1b89
// File: /workspace/github_c_makefile_star2_O1/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), %rcx
incq %rcx
movl $0x4, %edx
xorl %eax, %eax
movq %rcx, (%rdi)
movzbl -0x1(%rcx), %r8d
movq %rax, %r9
shlq $0x7, %r9
movl %r8d, %eax
andl $0x7f, %eax
orq %r9, %rax
testb %r8b, %r8b
cmovnsq %rax, %rsi
jns 0x3332
incq %rcx
decl %edx
jne 0x3309
retq
movq %rsi, %rax
retq
// File: /workspace/github_c_makefile_star2_O1/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:
cmpb $0x1, 0x55d5(%rip)      # 0x91c3
jne 0x3c86
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movslq %edi, %rdx
imulq $0x194, %rdx, %rbx      # imm = 0x194
leaq 0x5c30(%rip), %r14      # 0x9840
leaq (%r14,%rbx), %rbp
movq 0x55bd(%rip), %rdi      # 0x91d8
leaq 0x2737(%rip), %rsi      # 0x6359
xorl %eax, %eax
callq 0x10b0
addq %r14, %rbx
addq $0x14, %rbx
leaq 0x2741(%rip), %r14      # 0x6378
leaq 0x7542(%rip), %r15      # 0xb180
xorl %r12d, %r12d
cmpb $0x1, 0x4(%rbp,%r12)
jne 0x3c6b
movq 0x5588(%rip), %r13      # 0x91d8
movq %rbx, %rdi
callq 0x1e3b
movq %r13, %rdi
movq %r14, %rsi
movl %r12d, %edx
movq %r15, %rcx
xorl %eax, %eax
callq 0x10b0
incq %r12
addq $0x18, %rbx
cmpq $0x10, %r12
jne 0x3c41
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/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 %r14
pushq %rbx
pushq %rax
leaq 0x4(%rsp), %rbx
movl $0x0, (%rbx)
leaq 0xe3f(%rip), %r14       # 0x2021
movq %r14, %rdi
callq 0x1060
leaq 0xe13(%rip), %rdi       # 0x2004
callq 0x1060
movq %r14, %rdi
callq 0x1060
movq %rbx, %rdi
callq 0x128c
xorl %r14d, %r14d
testl %eax, %eax
setne %r14b
movq %rbx, %rdi
callq 0x1340
leal 0x1(%r14), %ecx
testl %eax, %eax
cmovel %r14d, %ecx
movl %ecx, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
nop
// File: /workspace/github_c_makefile_star2_O1/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
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movq %rdx, %rbx
movl %esi, %r14d
movl %edi, %ebp
xorl %r15d, %r15d
xorl %edi, %edi
callq 0x1090
movl %eax, %edi
callq 0x1050
testl %r14d, %r14d
jle 0x1280
movl %r14d, %r14d
xorl %r12d, %r12d
callq 0x10a0
cqto
idivq %r14
movl %ebp, %eax
subl %r12d, %eax
cltq
cmpq %rax, %rdx
jge 0x1278
movslq %r12d, %rax
incl %r12d
movl %r15d, (%rbx,%rax,4)
incl %r15d
decq %r14
jne 0x1258
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O1/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 %rax
movl $0x10, %edi
callq 0x1070
movl $0x0, 0x8(%rax)
movq $0x0, (%rax)
popq %rcx
retq
// File: /workspace/github_c_makefile_star2_O1/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 %rbx
movq %rdi, %rbx
movq %rbx, %rdi
callq 0x1357
testq %rax, %rax
jne 0x1333
movq $0x0, (%rbx)
movl $0x0, 0x8(%rbx)
movq %rbx, %rdi
popq %rbx
jmp 0x1030
// File: /workspace/github_c_makefile_star2_O1/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 %rbx
movq %rdi, %rax
movq (%rdi), %rdi
testq %rdi, %rdi
je 0x137d
movq 0x8(%rdi), %rcx
movq %rcx, (%rax)
decl 0x8(%rax)
movq (%rdi), %rbx
xorps %xmm0, %xmm0
movups %xmm0, (%rdi)
callq 0x1030
jmp 0x137f
xorl %ebx, %ebx
movq %rbx, %rax
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O1/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 %r14
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq %rdi, %r14
movl $0x10, %edi
callq 0x1070
movq %rbx, (%rax)
movq (%r14), %rcx
movq %rcx, 0x8(%rax)
movq %rax, (%r14)
incl 0x8(%r14)
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O1/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
pushq %r14
pushq %rbx
callq 0x1050
movl %eax, %ebx
leaq 0xe83(%rip), %rdi       # 0x2004
callq 0x1030
leaq 0xe7c(%rip), %rdi       # 0x2009
movq %rax, %rsi
movl %ebx, %edx
xorl %eax, %eax
callq 0x1060
xorl %r14d, %r14d
testl %ebx, %ebx
setne %r14b
leaq 0xe92(%rip), %rax       # 0x203b
leaq 0xe71(%rip), %rdi       # 0x2021
cmovneq %rax, %rdi
callq 0x1040
movl %r14d, %eax
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/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
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
leaq 0x3e90(%rip), %rbx      # 0x54a0
leaq -0x22(%rip), %rcx       # 0x15f5
movl $0xfa0, %esi            # imm = 0xFA0
movl $0x18, %edx
movq %rbx, %rdi
callq 0x1050
movq 0x3e60(%rip), %rcx      # 0x5490
leaq 0x1a17(%rip), %rdi      # 0x304e
movl $0x12, %esi
movl $0x1, %edx
callq 0x1160
leaq 0x1a14(%rip), %r14      # 0x3061
xorl %r15d, %r15d
movl 0x8(%r15,%rbx), %eax
andl $0x7, %eax
cmpl $0x1, %eax
jne 0x167f
cmpl $0x0, 0xc(%r15,%rbx)
jne 0x167f
leaq (%rbx,%r15), %rdx
movq 0x3e20(%rip), %rdi      # 0x5490
movl 0x10(%r15,%rbx), %ecx
movq %r14, %rsi
xorl %eax, %eax
callq 0x10d0
leaq 0x18(%r15), %rax
cmpq $0x176e8, %r15          # imm = 0x176E8
movq %rax, %r15
jb 0x1650
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/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
pushq %r14
pushq %rbx
movl %edi, %ebx
cmpl $0x0, 0x1afc7(%rip)     # 0x1cba4
movq 0x1afe4(%rip), %rax     # 0x1cbc8
movl 0x10(%rax), %edx
je 0x1c34
leaq 0x1afe0(%rip), %r14     # 0x1cbd0
leaq 0x151c(%rip), %rsi      # 0x3113
movq %r14, %rdi
movl %ebx, %ecx
xorl %eax, %eax
callq 0x1140
movq %r14, %rdi
callq 0x159f
movq 0x1affe(%rip), %rdi     # 0x1cc10
movq 0x1afaf(%rip), %rax     # 0x1cbc8
movl 0x10(%rax), %edx
leal 0x1(%rdx), %ecx
movl %ecx, 0x10(%rax)
leaq 0x14f6(%rip), %rsi      # 0x311f
movl %ebx, %ecx
xorl %eax, %eax
callq 0x10d0
jmp 0x1c44
leal 0x1(%rdx), %ecx
movl %ecx, 0x10(%rax)
leaq 0x1afdf(%rip), %rax     # 0x1cc20
movl %ebx, (%rax,%rdx,4)
movq 0x1af7d(%rip), %rax     # 0x1cbc8
andl $0x3ffff, 0x10(%rax)    # imm = 0x3FFFF
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/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
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq 0x3824(%rip), %rcx      # 0x5490
leaq 0x14b4(%rip), %rdi      # 0x3127
movl $0xe, %esi
movl $0x1, %edx
callq 0x1160
movl 0x5afd8(%rip), %ebx     # 0x5cc60
cmpl 0x5afd6(%rip), %ebx     # 0x5cc64
jae 0x1cf4
leaq 0x1af89(%rip), %rax     # 0x1cc20
leaq (%rax,%rbx,4), %r13
leaq 0x5af7e(%rip), %r14     # 0x5cc20
leaq 0x146a(%rip), %r15      # 0x3113
leaq 0x146f(%rip), %r12      # 0x311f
movl (%r13), %ecx
movq %r14, %rdi
movq %r15, %rsi
movl %ebx, %edx
xorl %eax, %eax
callq 0x1140
movq %r14, %rdi
callq 0x159f
movq 0x1af3e(%rip), %rdi     # 0x1cc10
movl (%r13), %ecx
movq %r12, %rsi
movl %ebx, %edx
xorl %eax, %eax
callq 0x10d0
incq %rbx
movl 0x5af79(%rip), %eax     # 0x5cc64
addq $0x4, %r13
cmpq %rax, %rbx
jb 0x1cb0
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/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
pushq %r14
pushq %rbx
incl 0x5af58(%rip)           # 0x5cc68
movl %edi, %ebx
movl 0x5af48(%rip), %ecx     # 0x5cc60
leaq 0x1af01(%rip), %r14     # 0x1cc20
cmpq $0xffff, %rcx           # imm = 0xFFFF
ja 0x1d41
leaq (%r14,%rcx,4), %rdx
movq %rcx, %rax
cmpl %ebx, (%rdx)
je 0x1d58
incq %rax
addq $0x4, %rdx
cmpl $0x10000, %eax          # imm = 0x10000
jne 0x1d2f
testq %rcx, %rcx
je 0x1d5d
movl 0x5af14(%rip), %eax     # 0x5cc60
decl %eax
movl %eax, 0x5af0c(%rip)     # 0x5cc60
movl %ebx, (%r14,%rax,4)
popq %rbx
popq %r14
popq %rbp
retq
callq 0x1301
jmp 0x1d46
// File: /workspace/github_c_makefile_star2_O1/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:
movl %edi, %eax
cmpl $0x25, %edi
jg 0x1d77
leal -0x20(%rax), %ecx
cmpl $0x2, %ecx
jae 0x1d91
orl %esi, %edx
jmp 0x1dc1
cmpl $0x26, %eax
je 0x1dbf
cmpl $0x2d, %eax
je 0x1da9
cmpl $0x2b, %eax
jne 0x1d95
leal (%rdx,%rsi), %eax
btl $0x12, %eax
adcl %esi, %edx
jmp 0x1dc1
testl %eax, %eax
je 0x1dc7
pushq %rbp
movq %rsp, %rbp
leaq 0x13af(%rip), %rdi      # 0x314f
movl %eax, %esi
xorl %eax, %eax
callq 0x14bc
notl %edx
movl $0x3ffff, %eax          # imm = 0x3FFFF
andl %eax, %edx
leal (%rdx,%rsi), %ecx
btl $0x12, %ecx
adcl %esi, %edx
andl %eax, %edx
jmp 0x1dc7
andl %esi, %edx
andl $0x3ffff, %edx          # imm = 0x3FFFF
movl %edx, %eax
retq
// File: /workspace/github_c_makefile_star2_O1/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
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq 0x2dc8(%rip), %rax      # 0x4fd8
movq (%rax), %rax
movq %rax, 0x1a98e(%rip)     # 0x1cba8
leaq 0x10e9(%rip), %rax      # 0x330a
movq %rax, 0x3208(%rip)      # 0x5430
leaq 0x10e3(%rip), %r14      # 0x3312
leaq 0x10e3(%rip), %rbx      # 0x3319
movq %r14, %rdi
movq %rbx, %rsi
callq 0x1556
movq %rax, 0x1a968(%rip)     # 0x1cbb0
callq 0x215a
movl $0x10000, 0x5aa09(%rip) # imm = 0x10000
movq 0x1a96a(%rip), %rax     # 0x1cbc8
movl $0x20, %r15d
movl %r15d, 0x10(%rax)
xorl %r12d, %r12d
movl %r12d, 0x1a932(%rip)    # 0x1cba4
callq 0x20b1
callq 0x20f2
movl $0x1, %r13d
movl %r13d, 0x1a91b(%rip)    # 0x1cba4
movq 0x1a920(%rip), %rdi     # 0x1cbb0
callq 0x1060
movq $0x0, 0x1a910(%rip) # 0x1cbb0
leaq 0x1075(%rip), %rsi      # 0x331c
movq %r14, %rdi
callq 0x1556
movq %rax, 0x1a8f2(%rip)     # 0x1cba8
leaq 0x1062(%rip), %rdi      # 0x331f
movq %rbx, %rsi
callq 0x1556
movq %rax, 0x1a944(%rip)     # 0x1cc10
leaq 0x1054(%rip), %rdi      # 0x3327
leaq 0x1055(%rip), %rsi      # 0x332f
callq 0x1556
movq %rax, 0x31aa(%rip)      # 0x5490
movq 0x1a8db(%rip), %rax     # 0x1cbc8
movl 0x5a975(%rip), %ecx     # 0x5cc68
addl 0x10(%rax), %ecx
movl %ecx, 0x5a968(%rip)     # 0x5cc64
movl %ecx, 0x5a95e(%rip)     # 0x5cc60
movl %r15d, 0x10(%rax)
movl %r13d, 0x2dd7(%rip)     # 0x50e4
movl %r12d, 0x1a88c(%rip)    # 0x1cba0
leaq 0x1a905(%rip), %rdi     # 0x1cc20
movl $0x40000, %edx          # imm = 0x40000
xorl %esi, %esi
callq 0x1080
callq 0x20b1
callq 0x1c57
movq 0x1a870(%rip), %rdi     # 0x1cba8
callq 0x1060
movq 0x1a8cc(%rip), %rdi     # 0x1cc10
callq 0x1060
callq 0x15ff
movl 0x5a918(%rip), %esi     # 0x5cc6c
leaq 0xfd6(%rip), %rdi       # 0x3331
xorl %eax, %eax
callq 0x1070
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/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:
leaq 0xe7d(%rip), %rax       # 0x2000
movq %rax, 0x2ede(%rip)      # 0x4068
leaq 0x2ed7(%rip), %rax      # 0x4068
leaq 0x40(%rip), %rcx        # 0x11d8
movq %rcx, 0x2ed1(%rip)      # 0x4070
leaq 0x81(%rip), %rcx        # 0x1227
movq %rcx, 0x2ecb(%rip)      # 0x4078
leaq 0x2b5(%rip), %rcx       # 0x1469
movq %rcx, 0x2ec5(%rip)      # 0x4080
leaq 0x3e1(%rip), %rcx       # 0x15a3
movq %rcx, 0x2ebf(%rip)      # 0x4088
leaq 0x3ed(%rip), %rcx       # 0x15bd
movq %rcx, 0x2eb9(%rip)      # 0x4090
retq
// File: /workspace/github_c_makefile_star2_O1/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 %r14
pushq %rbx
pushq %rax
leaq 0xe21(%rip), %rsi       # 0x2004
callq 0x1070
testq %rax, %rax
je 0x121d
movq %rax, %rbx
leaq 0x6(%rsp), %r14
movl $0x2, %esi
movl $0x1, %edx
movq %r14, %rdi
movq %rax, %rcx
callq 0x1050
movq %rbx, %rdi
callq 0x1060
cmpw $0x4d42, (%r14)         # imm = 0x4D42
sete %al
jmp 0x121f
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O1/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
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x28, %rsp
movq %rdi, %r15
callq 0x1040
movq %rax, %rbx
movl $0x0, (%rax)
movq 0x60(%rsp), %rdi
leaq 0xb73(%rip), %rsi       # 0x2007
callq 0x1070
testq %rax, %rax
je 0x1592
movq %rax, %r14
movq %rbx, 0x18(%rsp)
leaq 0x60(%rsp), %r12
movq 0x48(%r12), %rbx
movq 0x8(%rbx), %rdi
movl (%rbx), %esi
movl $0x1, %edx
movq %rax, %rcx
callq 0x10a0
movq 0x30(%r12), %rax
movq %rax, 0x8(%rsp)
movq %rbx, 0x10(%rsp)
movl (%rbx), %esi
movq %r14, %rdi
xorl %edx, %edx
callq 0x1090
movq 0x28(%r12), %rbp
testq %rbp, %rbp
je 0x1561
leaq 0x60(%rsp), %rax
movq 0x40(%rax), %rbx
movzwl 0x38(%rax), %eax
movq %rax, 0x20(%rsp)
movq 0x8(%rsp), %r13
andl $0x3, %r13d
xorl %r12d, %r12d
movq (%rbx,%r12,8), %rdi
movq 0x8(%rsp), %rsi
movq 0x20(%rsp), %rdx
movq %r14, %rcx
callq 0x10a0
movq (%rbx,%r12,8), %rdi
callq 0x1030
movl $0x0, 0x4(%rsp)
testq %r13, %r13
je 0x154b
movl $0x1, %edx
leaq 0x4(%rsp), %rdi
movq %r13, %rsi
movq %r14, %rcx
callq 0x10a0
testq %r15, %r15
je 0x1559
movq %r12, %rdi
movq %rbp, %rsi
callq *%r15
incq %r12
cmpq %r12, %rbp
jne 0x150a
leaq 0x60(%rsp), %rax
movq 0x40(%rax), %rdi
callq 0x1030
movq 0x10(%rsp), %rbx
movq 0x8(%rbx), %rdi
callq 0x1030
movq %rbx, %rdi
callq 0x1030
movq %r14, %rdi
callq 0x1060
movq 0x18(%rsp), %rbx
movl (%rbx), %eax
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/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 %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
leaq 0x30(%rsp), %rbx
movq 0x28(%rbx), %r14
testq %r14, %r14
je 0x15eb
movq 0x40(%rbx), %r15
xorl %r12d, %r12d
movq (%r15,%r12,8), %rdi
callq 0x1030
incq %r12
cmpq %r12, %r14
jne 0x15da
movq 0x40(%rbx), %rdi
callq 0x1030
movq 0x48(%rbx), %rbx
movq 0x8(%rbx), %rdi
callq 0x1030
movq %rbx, %rdi
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
jmp 0x1030
// File: /workspace/github_c_makefile_star2_O1/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
pushq %r15
pushq %r14
pushq %rbx
subq $0x8b8, %rsp            # imm = 0x8B8
leaq 0x42d9(%rip), %rsi      # 0x548c
leaq -0x4c8(%rbp), %rdi
movl $0x1, %edx
callq 0x1434
movl %eax, %ebx
movl %eax, %edi
callq 0x12a9
leaq 0x3e30(%rip), %rdi      # 0x5004
leaq 0x3e3c(%rip), %rsi      # 0x5017
movl %ebx, %edx
movq %rax, %rcx
xorl %eax, %eax
callq 0x1050
leaq 0x3e3d(%rip), %rsi      # 0x502b
leaq -0x270(%rbp), %rdi
movl $0x1, %edx
callq 0x182e
testl %eax, %eax
je 0x1240
leaq 0x41e7(%rip), %rdi      # 0x53f1
callq 0x1030
leaq -0x270(%rbp), %rdi
callq 0x2a6f
movl %eax, %ebx
movl %eax, %edi
callq 0x12a9
leaq 0x3dd9(%rip), %rdi      # 0x5004
leaq 0x3e2c(%rip), %rsi      # 0x505e
movl %ebx, %edx
movq %rax, %rcx
xorl %eax, %eax
callq 0x1050
jmp 0x129b
leaq -0x270(%rbp), %rdi
leaq -0x8d0(%rbp), %rbx
leaq -0x1c(%rbp), %r14
movq %rbx, %rsi
movl $0x9, %edx
movq %r14, %rcx
callq 0x216c
movl %eax, %r15d
movl %eax, %edi
callq 0x12a9
leaq 0x3d91(%rip), %rdi      # 0x5004
leaq 0x3db9(%rip), %rsi      # 0x5033
movl %r15d, %edx
movq %rax, %rcx
xorl %eax, %eax
callq 0x1050
movl (%r14), %esi
leaq 0x3db9(%rip), %rdi      # 0x504a
movq %rbx, %rdx
xorl %eax, %eax
callq 0x1050
addq $0x8b8, %rsp            # imm = 0x8B8
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/snej[P]zdelta/zdc.c
// Function: main_single
int main_single(int argc, char *argv[]){
  FILE *fp_ref;
  zd_mem_buffer tar_buf;
  zd_mem_buffer ref_buf;
  Bytef *delta = NULL;
  uLong d_size = 0;

  /* open and check the input files */
  if( !(fp_ref = fopen(argv[1],"rb")) )
  {
    perror(argv[1]);
    exit(0);
  }

  if(argc>2 && (!freopen(argv[2],"rb",stdin)))
  {
    perror(argv[2]); 
    exit(0);
  }

  /* copy input data to memory */
  if(dread_file(fp_ref,&ref_buf) < 0) perror(argv[1]);
  if(dread_file(stdin,&tar_buf) < 0) perror(argv[2]);

  /* compress the data */
  if(zd_compress1((const Bytef*) ref_buf.buffer, ref_buf.pos - ref_buf.buffer,
		  (const Bytef*) tar_buf.buffer, tar_buf.pos - tar_buf.buffer,
		  &delta, &d_size) == ZD_OK){

    /* successfull compression write the delta to a file */
    if(argc>3 && (!freopen(argv[3],"wb",stdout))){
      perror(argv[3]);
      exit(0);
    }
    if(d_size != fwrite(delta, sizeof(char), d_size, stdout)) perror("ouput");
  }
  
  /* release memory */
  free(delta);
  zd_free(&tar_buf);
  zd_free(&ref_buf);

  /* close files */
  fclose(fp_ref);

  return 0;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
subq $0x48, %rsp
movq %rsi, %r14
movl %edi, %ebp
xorl %eax, %eax
movq %rax, 0x8(%rsp)
movq %rax, 0x10(%rsp)
leaq 0x8(%rsi), %r15
movq 0x8(%rsi), %rdi
leaq 0x7d1e(%rip), %rsi      # 0x9004
callq 0x1120
testq %rax, %rax
je 0x1427
movq %rax, %rbx
cmpl $0x3, %ebp
jl 0x131f
movq 0x10(%r14), %rdi
movq 0xccc9(%rip), %rax      # 0xdfd0
movq (%rax), %rdx
leaq 0x7cf3(%rip), %rsi      # 0x9004
callq 0x10a0
testq %rax, %rax
je 0x142f
leaq 0x18(%rsp), %rsi
movq %rbx, %rdi
callq 0x1589
testl %eax, %eax
js 0x13fe
movq 0xcc95(%rip), %rax      # 0xdfd0
movq (%rax), %rdi
leaq 0x30(%rsp), %rsi
callq 0x1589
testl %eax, %eax
js 0x140b
movq 0x18(%rsp), %rdi
movq 0x20(%rsp), %rsi
subq %rdi, %rsi
movq 0x30(%rsp), %rdx
movq 0x38(%rsp), %rcx
subq %rdx, %rcx
leaq 0x8(%rsp), %r8
leaq 0x10(%rsp), %r9
callq 0x173d
testl %eax, %eax
jne 0x13cb
cmpl $0x4, %ebp
jl 0x13a5
movq 0x18(%r14), %rdi
movq 0xcc3b(%rip), %rax      # 0xdfc8
movq (%rax), %rdx
leaq 0x7c70(%rip), %rsi      # 0x9007
callq 0x10a0
testq %rax, %rax
je 0x143b
movq 0x10(%rsp), %r14
movq 0x8(%rsp), %rdi
movq 0xcc12(%rip), %rax      # 0xdfc8
movq (%rax), %rcx
movl $0x1, %esi
movq %r14, %rdx
callq 0x1150
cmpq %rax, %r14
jne 0x1419
movq 0x8(%rsp), %rdi
callq 0x1030
leaq 0x30(%rsp), %rdi
callq 0x1512
leaq 0x18(%rsp), %rdi
callq 0x1512
movq %rbx, %rdi
callq 0x1060
xorl %eax, %eax
addq $0x48, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
movq (%r15), %rdi
callq 0x1130
jmp 0x1334
movq 0x10(%r14), %rdi
callq 0x1130
jmp 0x1350
leaq 0x7bea(%rip), %rdi      # 0x900a
callq 0x1130
jmp 0x13cb
movq %r15, %rdi
callq 0x1190
addq $0x10, %r14
movq %r14, %rdi
callq 0x1180
addq $0x18, %r14
movq %r14, %rdi
callq 0x1170