LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O0/mmayer[P]pcal/src/writefil.c
// Function: select_color
int select_color (void)
{
   int i, min, index = BLACK;
   char count[NUM_COLORS];
   
   for (i = 0; i < NUM_COLORS; i++) {   /* clear counts */
      count[i] = 0;
   }
   
   for (i = SUN; i <= SAT; i++) {   /* count colors */
      count[(int)day_color[i]]++;
   }
   
   /* find smallest non-zero count; set its index and value */
   for (i = 0, min = 99; i < NUM_COLORS; i++) {
      if (count[i] && count[i] < min) min = count[index = i];
   }
   
   /* return least-used color (or pick one if only one color used) */
   return min == 7 ? index == BLACK ? GRAY : BLACK : index;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movl $0x0, -0xc(%rbp)
movl $0x0, -0x4(%rbp)
cmpl $0x4, -0x4(%rbp)
jge 0x187bc
movslq -0x4(%rbp), %rax
movb $0x0, -0x10(%rbp,%rax)
movl -0x4(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x4(%rbp)
jmp 0x187a2
movl $0x0, -0x4(%rbp)
cmpl $0x6, -0x4(%rbp)
jg 0x187f0
movslq -0x4(%rbp), %rcx
leaq 0x19fd8(%rip), %rax     # 0x327ac
movsbl (%rax,%rcx), %eax
cltq
movb -0x10(%rbp,%rax), %cl
addb $0x1, %cl
movb %cl, -0x10(%rbp,%rax)
movl -0x4(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x4(%rbp)
jmp 0x187c3
movl $0x0, -0x4(%rbp)
movl $0x63, -0x8(%rbp)
cmpl $0x4, -0x4(%rbp)
jge 0x1883d
movslq -0x4(%rbp), %rax
movsbl -0x10(%rbp,%rax), %eax
cmpl $0x0, %eax
je 0x18830
movslq -0x4(%rbp), %rax
movsbl -0x10(%rbp,%rax), %eax
cmpl -0x8(%rbp), %eax
jge 0x18830
movl -0x4(%rbp), %eax
movl %eax, -0xc(%rbp)
cltq
movsbl -0x10(%rbp,%rax), %eax
movl %eax, -0x8(%rbp)
jmp 0x18832
movl -0x4(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x4(%rbp)
jmp 0x187fe
cmpl $0x7, -0x8(%rbp)
jne 0x18858
movl -0xc(%rbp), %edx
xorl %eax, %eax
movl $0x1, %ecx
cmpl $0x0, %edx
cmovel %ecx, %eax
movl %eax, -0x14(%rbp)
jmp 0x1885e
movl -0xc(%rbp), %eax
movl %eax, -0x14(%rbp)
movl -0x14(%rbp), %eax
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/mmayer[P]pcal/src/writefil.c
// Function: ordinal_suffix
char *ordinal_suffix (int num)
{
   static char buf[10];
   int tens, units;
   
   /* Select suffix according to rules for target language.  In English,
      the rules are as follows:
      
       tens digit      units digit     suffix
         (any)           0, 4..9        "th"
           1              (any)         "th"
         != 1               1           "st"
         != 1               2           "nd"
         != 1               3           "rd"
   */
   tens = (num / 10) % 10;
   units = num % 10;
   strcpy(buf, ord_suffix[(units > 3 || tens == 1) ? 0 : units]);
   
   return buf;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movl %edi, -0x4(%rbp)
movl -0x4(%rbp), %eax
movl $0xa, %ecx
cltd
idivl %ecx
movl $0xa, %ecx
cltd
idivl %ecx
movl %edx, -0x8(%rbp)
movl -0x4(%rbp), %eax
movl $0xa, %ecx
cltd
idivl %ecx
movl %edx, -0xc(%rbp)
cmpl $0x3, -0xc(%rbp)
jg 0x188ab
cmpl $0x1, -0x8(%rbp)
jne 0x188b2
xorl %eax, %eax
movl %eax, -0x10(%rbp)
jmp 0x188b8
movl -0xc(%rbp), %eax
movl %eax, -0x10(%rbp)
movl -0x10(%rbp), %eax
movslq %eax, %rcx
leaq 0x1614b(%rip), %rax     # 0x2ea10
movq (%rax,%rcx,8), %rsi
leaq 0x1c878(%rip), %rdi     # 0x35148
callq 0x5080
leaq 0x1c86c(%rip), %rax     # 0x35148
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/mmayer[P]pcal/src/writefil.c
// Function: print_pstext
void print_pstext (char *p)
{
   char *s = p;   /* save for possible second pass */
   
   while ((p = print_word(p)) != NULL) printf(" ");

   /* repeat to generate debugging info if requested */
   if (debug_text) {
      while ((s = print_db_word(s)) != NULL) fprintf(stderr, " ");
   }

   return;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x10(%rbp)
movq -0x8(%rbp), %rdi
callq 0x16270
movq %rax, -0x8(%rbp)
cmpq $0x0, %rax
je 0x195a7
leaq 0x1124a(%rip), %rdi     # 0x2a7e8
movb $0x0, %al
callq 0x5110
jmp 0x19584
cmpl $0x0, 0x1ba92(%rip)     # 0x35040
je 0x195e1
jmp 0x195b2
movq -0x10(%rbp), %rdi
callq 0x19320
movq %rax, -0x10(%rbp)
cmpq $0x0, %rax
je 0x195df
movq 0x14a2c(%rip), %rax     # 0x2dff8
movq (%rax), %rdi
leaq 0x11212(%rip), %rsi     # 0x2a7e8
movb $0x0, %al
callq 0x51b0
jmp 0x195b2
jmp 0x195e1
addq $0x10, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/mmayer[P]pcal/src/writefil.c
// Function: print_text
void print_text (char *p)
{
   char c, buf[STRSIZ];
   
   while ((c = *p) != '\0') {
      if (c == '%' && p[1] != '\0') {
         p = expand_fmt(buf, p + 1);
         /* AH: non-ascii for -c mode should pass clean! */
         PUTSTR_CLEAN(isprint, buf, stdout);
      } 
      else {
         PUTCHAR_CLEAN(isprint, c, stdout);
         p++;
      }
   }

   return;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0xf0, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movb (%rax), %al
movb %al, -0x9(%rbp)
movsbl %al, %eax
cmpl $0x0, %eax
je 0x196cf
movsbl -0x9(%rbp), %eax
cmpl $0x25, %eax
jne 0x1969c
movq -0x8(%rbp), %rax
movsbl 0x1(%rax), %eax
cmpl $0x0, %eax
je 0x1969c
leaq -0xe0(%rbp), %rdi
movq -0x8(%rbp), %rsi
addq $0x1, %rsi
callq 0x188f0
movq %rax, -0x8(%rbp)
leaq -0xe0(%rbp), %rax
movq %rax, -0xe8(%rbp)
movq -0xe8(%rbp), %rax
cmpb $0x0, (%rax)
je 0x19698
movq 0x14975(%rip), %rax     # 0x2dfd8
movq (%rax), %rdi
movq -0xe8(%rbp), %rax
movsbl (%rax), %edx
andl $0xff, %edx
leaq 0x10f99(%rip), %rsi     # 0x2a616
movb $0x0, %al
callq 0x51b0
movq -0xe8(%rbp), %rax
addq $0x1, %rax
movq %rax, -0xe8(%rbp)
jmp 0x19650
jmp 0x1969a
jmp 0x196ca
movq 0x14935(%rip), %rax     # 0x2dfd8
movq (%rax), %rdi
movsbl -0x9(%rbp), %edx
andl $0xff, %edx
leaq 0x10f5f(%rip), %rsi     # 0x2a616
movb $0x0, %al
callq 0x51b0
movq -0x8(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x8(%rbp)
jmp 0x195ff
addq $0xf0, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/mmayer[P]pcal/src/writefil.c
// Function: def_footstring
void def_footstring (char *p, char *str)
{
   char c, buf[STRSIZ];
   
   this_day = 1;   /* set default day in foot string */
   RESET_DATE();   /* reset working date */
   
   printf("/%s (", str);
   while ((c = *p) != '\0') {
      if (c == '%' && p[1] != '\0') {
         p = expand_fmt(buf, p + 1);
         PUTSTR(isalnum, buf, stdout);
      } 
      else {
         PUTCHAR(isalnum, c, stdout);
         p++;
      }
   }
   printf(") def\n");

   return;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x110, %rsp            # imm = 0x110
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl $0x1, 0x1b96b(%rip)     # 0x35068
movl 0x1b941(%rip), %eax     # 0x35044
movl %eax, 0x1b963(%rip)     # 0x3506c
movl 0x1b959(%rip), %eax     # 0x35068
movl %eax, 0x1b95b(%rip)     # 0x35070
movl 0x1b92d(%rip), %eax     # 0x35048
movl %eax, 0x1b953(%rip)     # 0x35074
movq -0x10(%rbp), %rsi
leaq 0x1107f(%rip), %rdi     # 0x2a7ab
movb $0x0, %al
callq 0x5110
movq -0x8(%rbp), %rax
movb (%rax), %al
movb %al, -0x11(%rbp)
movsbl %al, %eax
cmpl $0x0, %eax
je 0x198d7
movsbl -0x11(%rbp), %eax
cmpl $0x25, %eax
jne 0x19849
movq -0x8(%rbp), %rax
movsbl 0x1(%rax), %eax
cmpl $0x0, %eax
je 0x19849
leaq -0xe0(%rbp), %rdi
movq -0x8(%rbp), %rsi
addq $0x1, %rsi
callq 0x188f0
movq %rax, -0x8(%rbp)
leaq -0xe0(%rbp), %rax
movq %rax, -0xe8(%rbp)
movq -0xe8(%rbp), %rax
cmpb $0x0, (%rax)
je 0x19842
movq 0x14835(%rip), %rax     # 0x2dfd8
movq (%rax), %rax
movq %rax, -0xf8(%rbp)
movq -0xe8(%rbp), %rax
movsbl (%rax), %ecx
movb $0x1, %al
cmpl $0x20, %ecx
movb %al, -0xe9(%rbp)
je 0x197f2
callq 0x52e0
movq (%rax), %rax
movq -0xe8(%rbp), %rcx
movsbl (%rcx), %ecx
andl $0xff, %ecx
movslq %ecx, %rcx
movzwl (%rax,%rcx,2), %eax
andl $0x8, %eax
cmpl $0x0, %eax
setne %al
movb %al, -0xe9(%rbp)
movq -0xf8(%rbp), %rdi
movb -0xe9(%rbp), %cl
leaq 0xb7c6(%rip), %rsi      # 0x24fcc
leaq 0x10e09(%rip), %rax     # 0x2a616
testb $0x1, %cl
cmovneq %rax, %rsi
movq -0xe8(%rbp), %rax
movsbl (%rax), %edx
andl $0xff, %edx
movb $0x0, %al
callq 0x51b0
movq -0xe8(%rbp), %rax
addq $0x1, %rax
movq %rax, -0xe8(%rbp)
jmp 0x1978c
jmp 0x19844
jmp 0x198d2
movq 0x14788(%rip), %rax     # 0x2dfd8
movq (%rax), %rax
movq %rax, -0x108(%rbp)
movsbl -0x11(%rbp), %ecx
movb $0x1, %al
cmpl $0x20, %ecx
movb %al, -0xf9(%rbp)
je 0x19893
callq 0x52e0
movq (%rax), %rax
movsbl -0x11(%rbp), %ecx
andl $0xff, %ecx
movslq %ecx, %rcx
movzwl (%rax,%rcx,2), %eax
andl $0x8, %eax
cmpl $0x0, %eax
setne %al
movb %al, -0xf9(%rbp)
movq -0x108(%rbp), %rdi
movb -0xf9(%rbp), %cl
leaq 0xb725(%rip), %rsi      # 0x24fcc
leaq 0x10d68(%rip), %rax     # 0x2a616
testb $0x1, %cl
cmovneq %rax, %rsi
movsbl -0x11(%rbp), %edx
andl $0xff, %edx
movb $0x0, %al
callq 0x51b0
movq -0x8(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x8(%rbp)
jmp 0x19733
leaq 0x10ed3(%rip), %rdi     # 0x2a7b1
movb $0x0, %al
callq 0x5110
addq $0x110, %rsp            # imm = 0x110
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/mmayer[P]pcal/src/writefil.c
// Function: find_noteboxes
void find_noteboxes (int month, int year)
{
   register int day;
   year_info *py;
   month_info *pm;
   
   /* if no text for this year and month, print empty list and return */
   
   if ((py = find_year(year, FALSE)) == NULL ||
       (pm = py->month[month-1]) == NULL) {
      printf("/noteboxes [ ] def\n");
      return;
   }
   
   printf("/noteboxes [");   /* start definition of list */
   
   /* walk array of note text pointers, converting days to box numbers */
   
   for (day = FIRST_NOTE_DAY; day <= LAST_NOTE_DAY; day++) {
      if (pm->day[day-1]) {
         printf(" %d", note_box(month, day, year));
      }
   }

   printf(" ] def\n");

   return;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movl %edi, -0x4(%rbp)
movl %esi, -0x8(%rbp)
movl -0x8(%rbp), %edi
xorl %esi, %esi
callq 0xefe0
movq %rax, -0x18(%rbp)
cmpq $0x0, %rax
je 0x19f5e
movq -0x18(%rbp), %rax
movl -0x4(%rbp), %ecx
subl $0x1, %ecx
movslq %ecx, %rcx
movq 0x8(%rax,%rcx,8), %rax
movq %rax, -0x20(%rbp)
cmpq $0x0, %rax
jne 0x19f6e
leaq 0x108c9(%rip), %rdi     # 0x2a82e
movb $0x0, %al
callq 0x5110
jmp 0x19fd7
leaq 0x108cd(%rip), %rdi     # 0x2a842
movb $0x0, %al
callq 0x5110
movl $0x20, -0xc(%rbp)
cmpl $0x2d, -0xc(%rbp)
jg 0x19fc9
movq -0x20(%rbp), %rax
movl -0xc(%rbp), %ecx
subl $0x1, %ecx
movslq %ecx, %rcx
cmpq $0x0, 0x8(%rax,%rcx,8)
je 0x19fbc
movl -0x4(%rbp), %edi
movl -0xc(%rbp), %esi
movl -0x8(%rbp), %edx
callq 0xc4c0
movl %eax, %esi
leaq 0xb5aa(%rip), %rdi      # 0x2555f
movb $0x0, %al
callq 0x5110
jmp 0x19fbe
movl -0xc(%rbp), %eax
addl $0x1, %eax
movl %eax, -0xc(%rbp)
jmp 0x19f83
leaq 0x1086a(%rip), %rdi     # 0x2a83a
movb $0x0, %al
callq 0x5110
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/mmayer[P]pcal/src/writefil.c
// Function: print_julian_info
void print_julian_info (int month, int year)
{
   if (julian_dates != NO_JULIANS) {
      printf("/jdstart %d def\n", DAY_OF_YEAR(month, 1, year));
   }
   if (julian_dates == ALL_JULIANS) {
      printf("/yearlen %d def\n", YEAR_LEN(year));
   }
   return;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movl %edi, -0x4(%rbp)
movl %esi, -0x8(%rbp)
leaq 0x1844b(%rip), %rax     # 0x32740
cmpl $0x0, (%rax)
je 0x1a388
movl -0x4(%rbp), %eax
subl $0x1, %eax
movslq %eax, %rcx
leaq 0x13e92(%rip), %rax     # 0x2e1a0
movswl (%rax,%rcx,2), %eax
movl %eax, -0x10(%rbp)
xorl %eax, %eax
cmpl $0x2, -0x4(%rbp)
movb %al, -0x9(%rbp)
jle 0x1a36a
movl -0x8(%rbp), %eax
movl $0x4, %ecx
cltd
idivl %ecx
xorl %eax, %eax
cmpl $0x0, %edx
movb %al, -0x11(%rbp)
jne 0x1a364
movl -0x8(%rbp), %eax
movl $0x64, %ecx
cltd
idivl %ecx
movb $0x1, %al
cmpl $0x0, %edx
movb %al, -0x12(%rbp)
jne 0x1a35e
movl -0x8(%rbp), %eax
movl $0x190, %ecx            # imm = 0x190
cltd
idivl %ecx
cmpl $0x0, %edx
sete %al
movb %al, -0x12(%rbp)
movb -0x12(%rbp), %al
movb %al, -0x11(%rbp)
movb -0x11(%rbp), %al
movb %al, -0x9(%rbp)
movl -0x10(%rbp), %esi
movb -0x9(%rbp), %al
andb $0x1, %al
movzbl %al, %eax
addl %eax, %esi
addl $0x1, %esi
leaq 0x1055c(%rip), %rdi     # 0x2a8dd
movb $0x0, %al
callq 0x5110
leaq 0x183b1(%rip), %rax     # 0x32740
cmpl $0x1, (%rax)
jne 0x1a3f9
movl -0x8(%rbp), %eax
movl $0x4, %ecx
cltd
idivl %ecx
xorl %eax, %eax
cmpl $0x0, %edx
movb %al, -0x13(%rbp)
jne 0x1a3d8
movl -0x8(%rbp), %eax
movl $0x64, %ecx
cltd
idivl %ecx
movb $0x1, %al
cmpl $0x0, %edx
movb %al, -0x14(%rbp)
jne 0x1a3d2
movl -0x8(%rbp), %eax
movl $0x190, %ecx            # imm = 0x190
cltd
idivl %ecx
cmpl $0x0, %edx
sete %al
movb %al, -0x14(%rbp)
movb -0x14(%rbp), %al
movb %al, -0x13(%rbp)
movb -0x13(%rbp), %cl
movl $0x16d, %esi            # imm = 0x16D
movl $0x16e, %eax            # imm = 0x16E
testb $0x1, %cl
cmovnel %eax, %esi
leaq 0x104fc(%rip), %rdi     # 0x2a8ee
movb $0x0, %al
callq 0x5110
addq $0x20, %rsp
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O0/antonblanchard[P]will-it-scale/tests/open2.c
// Function: testcase
void testcase(unsigned long long *iterations, unsigned long nr)
{
	int fd;
	char tmpfile[PATH_MAX];
	sprintf(tmpfile, "%s/willitscale", tmpdirs[nr]);

	while (1) {
		fd = open(tmpfile, O_RDWR);
		assert(fd >= 0);
		close(fd);

		(*iterations)++;
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x1020, %rsp           # imm = 0x1020
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
leaq -0x1020(%rbp), %rdi
movq 0xf03f(%rip), %rdx      # 0x121c0
imulq $0x18, -0x10(%rbp), %rax
addq %rax, %rdx
leaq 0x1175(%rip), %rsi      # 0x4305
movb $0x0, %al
callq 0x22b0
leaq -0x1020(%rbp), %rdi
movl $0x2, %esi
movb $0x0, %al
callq 0x2230
movl %eax, -0x14(%rbp)
cmpl $0x0, -0x14(%rbp)
jl 0x31b5
jmp 0x31d4
leaq 0x1158(%rip), %rdi      # 0x4314
leaq 0x10df(%rip), %rsi      # 0x42a2
movl $0x30, %edx
leaq 0x114d(%rip), %rcx      # 0x431c
callq 0x2130
movl -0x14(%rbp), %edi
callq 0x2150
movq -0x8(%rbp), %rax
movq (%rax), %rcx
addq $0x1, %rcx
movq %rcx, (%rax)
jmp 0x3197
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/ohkimur[P]the-c-programming-language-2nd-edition-solutions/chapter_1/exercise_1_05/celsius_fahrenheit.c
// Function: main
int main(void)
{
  float celsius, fahr;
  int lower, upper, step;

  lower = 0;
  upper = 300;
  step = 20;

  printf("Celsius\tFahr\n");
  printf("---------------\n");

  for (celsius = upper; celsius >= lower; celsius = celsius - step)
  {
    fahr = (9.0 / 5.0) * celsius + 32.0f;
    printf("%3.0f\t\t%6.1f\n", celsius, fahr);
  }

  return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movl $0x0, -0x4(%rbp)
movl $0x0, -0x10(%rbp)
movl $0x12c, -0x14(%rbp)     # imm = 0x12C
movl $0x14, -0x18(%rbp)
leaq 0xead(%rip), %rdi       # 0x2018
movb $0x0, %al
callq 0x1030
leaq 0xead(%rip), %rdi       # 0x2026
movb $0x0, %al
callq 0x1030
cvtsi2ssl -0x14(%rbp), %xmm0
movss %xmm0, -0x8(%rbp)
movss -0x8(%rbp), %xmm0
cvtsi2ssl -0x10(%rbp), %xmm1
ucomiss %xmm1, %xmm0
jb 0x11f8
movss -0x8(%rbp), %xmm0
cvtss2sd %xmm0, %xmm0
movsd 0xe5e(%rip), %xmm1      # 0x2008
mulsd %xmm1, %xmm0
movsd 0xe5a(%rip), %xmm1      # 0x2010
addsd %xmm1, %xmm0
cvtsd2ss %xmm0, %xmm0
movss %xmm0, -0xc(%rbp)
movss -0x8(%rbp), %xmm0
cvtss2sd %xmm0, %xmm0
movss -0xc(%rbp), %xmm1
cvtss2sd %xmm1, %xmm1
leaq 0xe5b(%rip), %rdi       # 0x2037
movb $0x2, %al
callq 0x1030
movss -0x8(%rbp), %xmm0
cvtsi2ssl -0x18(%rbp), %xmm1
subss %xmm1, %xmm0
movss %xmm0, -0x8(%rbp)
jmp 0x118a
xorl %eax, %eax
addq $0x20, %rsp
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O0/Matthias-Wandel[P]imgcomp/src/main.c
// Function: ScaleRegion
static void ScaleRegion (Region_t * Reg, int Denom)
{
    Reg->x1 /= Denom;
    Reg->x2 /= Denom;
    Reg->y1 /= Denom;
    Reg->y2 /= Denom;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movl -0xc(%rbp), %ecx
movq -0x8(%rbp), %rax
movq %rax, -0x30(%rbp)
movl (%rax), %eax
cltd
idivl %ecx
movl %eax, %ecx
movq -0x30(%rbp), %rax
movl %ecx, (%rax)
movl -0xc(%rbp), %ecx
movq -0x8(%rbp), %rax
movq %rax, -0x28(%rbp)
movl 0x4(%rax), %eax
cltd
idivl %ecx
movl %eax, %ecx
movq -0x28(%rbp), %rax
movl %ecx, 0x4(%rax)
movl -0xc(%rbp), %ecx
movq -0x8(%rbp), %rax
movq %rax, -0x20(%rbp)
movl 0x8(%rax), %eax
cltd
idivl %ecx
movl %eax, %ecx
movq -0x20(%rbp), %rax
movl %ecx, 0x8(%rax)
movl -0xc(%rbp), %ecx
movq -0x8(%rbp), %rax
movq %rax, -0x18(%rbp)
movl 0xc(%rax), %eax
cltd
idivl %ecx
movl %eax, %ecx
movq -0x18(%rbp), %rax
movl %ecx, 0xc(%rax)
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/Matthias-Wandel[P]imgcomp/src/main.c
// Function: GeometryConvert
static void GeometryConvert(TriggerInfo_t  * Trig)
{
    double x,y;

    x = ((float)Trig->x/(LastPics[0].Image->width*ScaleDenom));
    y = ((float)Trig->y/(LastPics[0].Image->height*ScaleDenom));

    Trig->x = (int)((x-0.5)*1000);
    Trig->y = (int)((0.5-y)*1000);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
cvtsi2ssl 0x4(%rax), %xmm0
movq 0xf4f8(%rip), %rax      # 0x14380
movl (%rax), %eax
leaq 0xfeb7(%rip), %rcx      # 0x14d48
imull (%rcx), %eax
cvtsi2ss %eax, %xmm1
divss %xmm1, %xmm0
cvtss2sd %xmm0, %xmm0
movsd %xmm0, -0x10(%rbp)
movq -0x8(%rbp), %rax
cvtsi2ssl 0x8(%rax), %xmm0
movq 0xf4cb(%rip), %rax      # 0x14380
movl 0x4(%rax), %eax
leaq 0xfe89(%rip), %rcx      # 0x14d48
imull (%rcx), %eax
cvtsi2ss %eax, %xmm1
divss %xmm1, %xmm0
cvtss2sd %xmm0, %xmm0
movsd %xmm0, -0x18(%rbp)
movsd -0x10(%rbp), %xmm0
movsd 0x9130(%rip), %xmm1     # 0xe010
subsd %xmm1, %xmm0
movsd 0x911c(%rip), %xmm1     # 0xe008
mulsd %xmm1, %xmm0
cvttsd2si %xmm0, %ecx
movq -0x8(%rbp), %rax
movl %ecx, 0x4(%rax)
movsd 0x910d(%rip), %xmm0     # 0xe010
subsd -0x18(%rbp), %xmm0
movsd 0x90f8(%rip), %xmm1     # 0xe008
mulsd %xmm1, %xmm0
cvttsd2si %xmm0, %ecx
movq -0x8(%rbp), %rax
movl %ecx, 0x8(%rax)
popq %rbp
retq
nopw %cs:(%rax,%rax)
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/Matthias-Wandel[P]imgcomp/src/config.c
// Function: parse_switches
int parse_switches (int argc, char **argv, int last_file_arg_seen)
{
    int argn,a;
    char * arg;
    char * value;

    // Scan command line options, adjust parameters
    for (argn = 1; argn < argc;) {
        //printf("argn = %d\n",argn);
        arg = argv[argn];
        if (*arg != '-') {
            return argn;
        }
        value = NULL;
        if (argn+1 < argc) value = argv[argn+1];

        a = parse_parameter(arg+1, value);
        if (a < 0) usage();
        argn += a;
    }
    return argc;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movl %edi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl %edx, -0x14(%rbp)
movl $0x1, -0x18(%rbp)
movl -0x18(%rbp), %eax
cmpl -0x8(%rbp), %eax
jge 0x5027
movq -0x10(%rbp), %rax
movslq -0x18(%rbp), %rcx
movq (%rax,%rcx,8), %rax
movq %rax, -0x28(%rbp)
movq -0x28(%rbp), %rax
movsbl (%rax), %eax
cmpl $0x2d, %eax
je 0x4fd5
movl -0x18(%rbp), %eax
movl %eax, -0x4(%rbp)
jmp 0x502d
movq $0x0, -0x30(%rbp)
movl -0x18(%rbp), %eax
addl $0x1, %eax
cmpl -0x8(%rbp), %eax
jge 0x4ffd
movq -0x10(%rbp), %rax
movl -0x18(%rbp), %ecx
addl $0x1, %ecx
movslq %ecx, %rcx
movq (%rax,%rcx,8), %rax
movq %rax, -0x30(%rbp)
movq -0x28(%rbp), %rdi
addq $0x1, %rdi
movq -0x30(%rbp), %rsi
callq 0x5040
movl %eax, -0x1c(%rbp)
cmpl $0x0, -0x1c(%rbp)
jge 0x501c
callq 0x4f30
movl -0x1c(%rbp), %eax
addl -0x18(%rbp), %eax
movl %eax, -0x18(%rbp)
jmp 0x4fa9
movl -0x8(%rbp), %eax
movl %eax, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/Matthias-Wandel[P]imgcomp/src/config.c
// Function: keymatch
static int keymatch (const char * arg, const char * keyword, int minchars)
{
    int ca, ck, nmatched = 0;

    while ((ca = *arg++) != '\0') {
        if ((ck = *keyword++) == '\0') return 0;// arg longer than keyword, no good
        if (isupper(ca))  ca = tolower(ca);     // force arg to lcase (assume ck is already)
        if (ca != ck) return 0;                 // no good
        nmatched++;                             // count matched characters
    }
    // reached end of argument; fail if it's too short for unique abbrev 
    if (nmatched < minchars) return 0;
    return 1;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movl %edx, -0x1c(%rbp)
movl $0x0, -0x28(%rbp)
movq -0x10(%rbp), %rax
movq %rax, %rcx
addq $0x1, %rcx
movq %rcx, -0x10(%rbp)
movsbl (%rax), %eax
movl %eax, -0x20(%rbp)
cmpl $0x0, %eax
je 0x61d8
movq -0x18(%rbp), %rax
movq %rax, %rcx
addq $0x1, %rcx
movq %rcx, -0x18(%rbp)
movsbl (%rax), %eax
movl %eax, -0x24(%rbp)
cmpl $0x0, %eax
jne 0x6197
movl $0x0, -0x4(%rbp)
jmp 0x61f0
callq 0x3500
movq (%rax), %rax
movslq -0x20(%rbp), %rcx
movzwl (%rax,%rcx,2), %eax
andl $0x100, %eax            # imm = 0x100
cmpl $0x0, %eax
je 0x61bc
movl -0x20(%rbp), %edi
callq 0x3320
movl %eax, -0x20(%rbp)
movl -0x20(%rbp), %eax
cmpl -0x24(%rbp), %eax
je 0x61cd
movl $0x0, -0x4(%rbp)
jmp 0x61f0
movl -0x28(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x28(%rbp)
jmp 0x615a
movl -0x28(%rbp), %eax
cmpl -0x1c(%rbp), %eax
jge 0x61e9
movl $0x0, -0x4(%rbp)
jmp 0x61f0
movl $0x1, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/Matthias-Wandel[P]imgcomp/src/config.c
// Function: ParseRegion
static int ParseRegion(Region_t * reg, const char * value)
{
    char * t;
    t = strstr(value, ",");
    if (t == NULL || t != value){
        // No comma, or comma not in first position.  Parse X parameters.
        if (sscanf(value, "%d-%d", &reg->x1, &reg->x2) != 2){
            if (sscanf(value, "%d+%d", &reg->x1, &reg->x2) != 2) return 0;
            reg->x2 += reg->x1;
        }
    }
    if (t != NULL){
        // Y parameters come after the comma.
        if (sscanf(t+1, "%d-%d", &reg->y1, &reg->y2) != 2){
            if (sscanf(t+1, "%d+%d", &reg->y1, &reg->y2) != 2) return 0;
            reg->y2 += reg->y1;
        }
    }
    if (reg->y2-reg->y1 < 16 || reg->x2-reg->x1 < 16){
        fprintf(stderr,"Detect region is too small\n");
        exit(-1);
    }
    printf("    Region is x:%d-%d, y:%d-%d\n",reg->x1, reg->x2, reg->y1, reg->y2);
    return 1;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x18(%rbp), %rdi
leaq 0x9477(%rip), %rsi      # 0xf692
callq 0x34f0
movq %rax, -0x20(%rbp)
cmpq $0x0, -0x20(%rbp)
je 0x6235
movq -0x20(%rbp), %rax
cmpq -0x18(%rbp), %rax
je 0x6299
movq -0x18(%rbp), %rdi
movq -0x10(%rbp), %rdx
movq -0x10(%rbp), %rcx
addq $0x4, %rcx
leaq 0x91ec(%rip), %rsi      # 0xf438
movb $0x0, %al
callq 0x3370
cmpl $0x2, %eax
je 0x6297
movq -0x18(%rbp), %rdi
movq -0x10(%rbp), %rdx
movq -0x10(%rbp), %rcx
addq $0x4, %rcx
leaq 0x9425(%rip), %rsi      # 0xf694
movb $0x0, %al
callq 0x3370
cmpl $0x2, %eax
je 0x6287
movl $0x0, -0x4(%rbp)
jmp 0x638d
movq -0x10(%rbp), %rax
movl (%rax), %ecx
movq -0x10(%rbp), %rax
addl 0x4(%rax), %ecx
movl %ecx, 0x4(%rax)
jmp 0x6299
cmpq $0x0, -0x20(%rbp)
je 0x6315
movq -0x20(%rbp), %rdi
addq $0x1, %rdi
movq -0x10(%rbp), %rdx
addq $0x8, %rdx
movq -0x10(%rbp), %rcx
addq $0xc, %rcx
leaq 0x9179(%rip), %rsi      # 0xf438
movb $0x0, %al
callq 0x3370
cmpl $0x2, %eax
je 0x6313
movq -0x20(%rbp), %rdi
addq $0x1, %rdi
movq -0x10(%rbp), %rdx
addq $0x8, %rdx
movq -0x10(%rbp), %rcx
addq $0xc, %rcx
leaq 0x93aa(%rip), %rsi      # 0xf694
movb $0x0, %al
callq 0x3370
cmpl $0x2, %eax
je 0x6302
movl $0x0, -0x4(%rbp)
jmp 0x638d
movq -0x10(%rbp), %rax
movl 0x8(%rax), %ecx
movq -0x10(%rbp), %rax
addl 0xc(%rax), %ecx
movl %ecx, 0xc(%rax)
jmp 0x6315
movq -0x10(%rbp), %rax
movl 0xc(%rax), %eax
movq -0x10(%rbp), %rcx
subl 0x8(%rcx), %eax
cmpl $0x10, %eax
jl 0x633a
movq -0x10(%rbp), %rax
movl 0x4(%rax), %eax
movq -0x10(%rbp), %rcx
subl (%rcx), %eax
cmpl $0x10, %eax
jge 0x635c
movq 0xdcaf(%rip), %rax      # 0x13ff0
movq (%rax), %rdi
leaq 0x934f(%rip), %rsi      # 0xf69a
movb $0x0, %al
callq 0x3290
movl $0xffffffff, %edi       # imm = 0xFFFFFFFF
callq 0x3480
movq -0x10(%rbp), %rax
movl (%rax), %esi
movq -0x10(%rbp), %rax
movl 0x4(%rax), %edx
movq -0x10(%rbp), %rax
movl 0x8(%rax), %ecx
movq -0x10(%rbp), %rax
movl 0xc(%rax), %r8d
leaq 0x9337(%rip), %rdi      # 0xf6b6
movb $0x0, %al
callq 0x3170
movl $0x1, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/Matthias-Wandel[P]imgcomp/src/compare_util.c
// Function: ShowWeightMap
static void ShowWeightMap(ImgMap_t * WeightMap)
{
    int row, width, height;
    width = WeightMap->w;
    height = WeightMap->h;
    printf("Weight map (%dx%d):  '-' = ignore, '1' = normal, '#' = 2x weight\n",width, height);
	int skip = width/100;
	if (skip < 4) skip = 4;
    for (row=skip/2;row<height;row+=skip){
        int r;
        printf("  ");
        for (r=skip/2;r<width;r+=skip){
            switch (WeightMap->values[row*width+r]){
                case 0: putchar('-');break;
                case 1: putchar('1');break;
                case 2: putchar('#');break;
                default: 
				printf(" %d",WeightMap->values[row*width+r]);
				putchar('?'); break;
            }
        }
        printf("\n");
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movl (%rax), %eax
movl %eax, -0x10(%rbp)
movq -0x8(%rbp), %rax
movl 0x4(%rax), %eax
movl %eax, -0x14(%rbp)
movl -0x10(%rbp), %esi
movl -0x14(%rbp), %edx
leaq 0x7e5a(%rip), %rdi      # 0xf9f6
movb $0x0, %al
callq 0x3170
movl -0x10(%rbp), %eax
movl $0x64, %ecx
cltd
idivl %ecx
movl %eax, -0x18(%rbp)
cmpl $0x4, -0x18(%rbp)
jge 0x7bbe
movl $0x4, -0x18(%rbp)
movl -0x18(%rbp), %eax
movl $0x2, %ecx
cltd
idivl %ecx
movl %eax, -0xc(%rbp)
movl -0xc(%rbp), %eax
cmpl -0x14(%rbp), %eax
jge 0x7cb3
leaq 0x7e59(%rip), %rdi      # 0xfa38
movb $0x0, %al
callq 0x3170
movl -0x18(%rbp), %eax
movl $0x2, %ecx
cltd
idivl %ecx
movl %eax, -0x1c(%rbp)
movl -0x1c(%rbp), %eax
cmpl -0x10(%rbp), %eax
jge 0x7c97
movq -0x8(%rbp), %rax
movl -0xc(%rbp), %ecx
movl -0x10(%rbp), %edx
imull %edx, %ecx
movl -0x1c(%rbp), %edx
addl %edx, %ecx
movslq %ecx, %rcx
movl 0x8(%rax,%rcx,4), %eax
movl %eax, -0x20(%rbp)
testl %eax, %eax
je 0x7c36
jmp 0x7c22
movl -0x20(%rbp), %eax
subl $0x1, %eax
je 0x7c42
jmp 0x7c2c
movl -0x20(%rbp), %eax
subl $0x2, %eax
je 0x7c4e
jmp 0x7c5a
movl $0x2d, %edi
callq 0x3050
jmp 0x7c87
movl $0x31, %edi
callq 0x3050
jmp 0x7c87
movl $0x23, %edi
callq 0x3050
jmp 0x7c87
movq -0x8(%rbp), %rax
movl -0xc(%rbp), %ecx
imull -0x10(%rbp), %ecx
addl -0x1c(%rbp), %ecx
movslq %ecx, %rcx
movl 0x8(%rax,%rcx,4), %esi
leaq 0x9a59(%rip), %rdi      # 0x116cf
movb $0x0, %al
callq 0x3170
movl $0x3f, %edi
callq 0x3050
jmp 0x7c89
movl -0x18(%rbp), %eax
addl -0x1c(%rbp), %eax
movl %eax, -0x1c(%rbp)
jmp 0x7bf4
leaq 0x651d(%rip), %rdi      # 0xe1bb
movb $0x0, %al
callq 0x3170
movl -0x18(%rbp), %eax
addl -0xc(%rbp), %eax
movl %eax, -0xc(%rbp)
jmp 0x7bcc
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/Matthias-Wandel[P]imgcomp/src/compare_util.c
// Function: AverageBright
double AverageBright(MemImage_t * pic, Region_t Region, ImgMap_t* WeightMap)
{
    double baverage;//
    int DetectionPixels;
    int row;
    int rowbytes = pic->width*3;
    DetectionPixels = 0;
 
    // Compute average brightnesses.
    baverage = 0;//rzaverage = 0;
    for (row=Region.y1;row<Region.y2;row++){
        unsigned char *p1;
		int *px;
        int col, brow = 0;//, redrow = 0;
        p1 = pic->pixels+rowbytes*row;
        px = &WeightMap->values[pic->width*row];
        for (col=Region.x1;col<Region.x2;col++){
            if (px[col]){
                int bv;
                bv = p1[0]+p1[1]*2+p1[2];  // Multiplies by 4.
                brow += bv;
                DetectionPixels += 1;
            }
            p1 += 3;
        }
        baverage += brow;
    }

    if (DetectionPixels < 1000){
        fprintf(stderr, "Detection region too small");
        exit(-1);
    }
   
    return baverage * 0.25 / DetectionPixels; // Multiply by 4 again.
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x60, %rsp
movq %rsi, -0x10(%rbp)
movq %rdx, -0x8(%rbp)
movq %rdi, -0x18(%rbp)
movq %rcx, -0x20(%rbp)
movq -0x18(%rbp), %rax
imull $0x3, (%rax), %eax
movl %eax, -0x34(%rbp)
movl $0x0, -0x2c(%rbp)
xorps %xmm0, %xmm0
movsd %xmm0, -0x28(%rbp)
movl -0x8(%rbp), %eax
movl %eax, -0x30(%rbp)
movl -0x30(%rbp), %eax
cmpl -0x4(%rbp), %eax
jge 0x7fa5
movl $0x0, -0x50(%rbp)
movq -0x18(%rbp), %rax
addq $0xc, %rax
movl -0x34(%rbp), %ecx
imull -0x30(%rbp), %ecx
movslq %ecx, %rcx
addq %rcx, %rax
movq %rax, -0x40(%rbp)
movq -0x20(%rbp), %rax
addq $0x8, %rax
movq -0x18(%rbp), %rcx
movl (%rcx), %ecx
imull -0x30(%rbp), %ecx
movslq %ecx, %rcx
shlq $0x2, %rcx
addq %rcx, %rax
movq %rax, -0x48(%rbp)
movl -0x10(%rbp), %eax
movl %eax, -0x4c(%rbp)
movl -0x4c(%rbp), %eax
cmpl -0xc(%rbp), %eax
jge 0x7f88
movq -0x48(%rbp), %rax
movslq -0x4c(%rbp), %rcx
cmpl $0x0, (%rax,%rcx,4)
je 0x7f71
movq -0x40(%rbp), %rax
movzbl (%rax), %eax
movq -0x40(%rbp), %rcx
movzbl 0x1(%rcx), %ecx
shll %ecx
addl %ecx, %eax
movq -0x40(%rbp), %rcx
movzbl 0x2(%rcx), %ecx
addl %ecx, %eax
movl %eax, -0x54(%rbp)
movl -0x54(%rbp), %eax
addl -0x50(%rbp), %eax
movl %eax, -0x50(%rbp)
movl -0x2c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x2c(%rbp)
movq -0x40(%rbp), %rax
addq $0x3, %rax
movq %rax, -0x40(%rbp)
movl -0x4c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x4c(%rbp)
jmp 0x7f29
cvtsi2sdl -0x50(%rbp), %xmm0
addsd -0x28(%rbp), %xmm0
movsd %xmm0, -0x28(%rbp)
movl -0x30(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x30(%rbp)
jmp 0x7ed7
cmpl $0x3e8, -0x2c(%rbp)     # imm = 0x3E8
jge 0x7fd0
movq 0xc03b(%rip), %rax      # 0x13ff0
movq (%rax), %rdi
leaq 0x79ff(%rip), %rsi      # 0xf9be
movb $0x0, %al
callq 0x3290
movl $0xffffffff, %edi       # imm = 0xFFFFFFFF
callq 0x3480
movsd 0x63d8(%rip), %xmm0     # 0xe3b0
mulsd -0x28(%rbp), %xmm0
cvtsi2sdl -0x2c(%rbp), %xmm1
divsd %xmm1, %xmm0
addq $0x60, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/Matthias-Wandel[P]imgcomp/src/compare_util.c
// Function: MakeImgMap
ImgMap_t * MakeImgMap(int w,int h)
{
	ImgMap_t * ImgMap = malloc(sizeof(int)*w*h+sizeof(ImgMap_t));
	memset(ImgMap, 0, sizeof(int)*w*h+sizeof(ImgMap_t));
	ImgMap->w = w;
	ImgMap->h = h;
	return ImgMap;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movl %edi, -0x4(%rbp)
movl %esi, -0x8(%rbp)
movslq -0x4(%rbp), %rdi
shlq $0x2, %rdi
movslq -0x8(%rbp), %rax
imulq %rax, %rdi
addq $0x8, %rdi
callq 0x3330
movq %rax, -0x10(%rbp)
movq -0x10(%rbp), %rdi
movslq -0x4(%rbp), %rdx
shlq $0x2, %rdx
movslq -0x8(%rbp), %rax
imulq %rax, %rdx
addq $0x8, %rdx
xorl %esi, %esi
callq 0x31b0
movl -0x4(%rbp), %ecx
movq -0x10(%rbp), %rax
movl %ecx, (%rax)
movl -0x8(%rbp), %ecx
movq -0x10(%rbp), %rax
movl %ecx, 0x4(%rax)
movq -0x10(%rbp), %rax
addq $0x10, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/Matthias-Wandel[P]imgcomp/src/jpeg2mem.c
// Function: WritePpmFile
void WritePpmFile(char * FileName, MemImage_t *MemImage)
{
    FILE * outfile;
    outfile = fopen(FileName,"wb");
    if (outfile == NULL){
        fprintf(Log,"could not open outfile\n");
        return;
    }
    fprintf(outfile, "P%c\n%d %d\n%d\n", MemImage->components == 3 ? '6' : '5',  
            MemImage->width, MemImage->height, 255);
    fwrite(MemImage->pixels, 1, MemImage->width * MemImage->height*MemImage->components, outfile);
    fclose(outfile);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rdi
leaq 0x6e9c(%rip), %rsi      # 0xfaa7
callq 0x3420
movq %rax, -0x18(%rbp)
cmpq $0x0, -0x18(%rbp)
jne 0x8c35
leaq 0xc3f6(%rip), %rax      # 0x15018
movq (%rax), %rdi
leaq 0x6e7e(%rip), %rsi      # 0xfaaa
movb $0x0, %al
callq 0x3290
jmp 0x8caa
movq -0x18(%rbp), %rdi
movq -0x10(%rbp), %rax
movl 0x8(%rax), %ecx
movl $0x35, %edx
movl $0x36, %eax
cmpl $0x3, %ecx
cmovel %eax, %edx
movq -0x10(%rbp), %rax
movl (%rax), %ecx
movq -0x10(%rbp), %rax
movl 0x4(%rax), %r8d
leaq 0x6e5d(%rip), %rsi      # 0xfac2
movl $0xff, %r9d
movb $0x0, %al
callq 0x3290
movq -0x10(%rbp), %rdi
addq $0xc, %rdi
movq -0x10(%rbp), %rax
movl (%rax), %eax
movq -0x10(%rbp), %rcx
imull 0x4(%rcx), %eax
movq -0x10(%rbp), %rcx
imull 0x8(%rcx), %eax
movslq %eax, %rdx
movq -0x18(%rbp), %rcx
movl $0x1, %esi
callq 0x3490
movq -0x18(%rbp), %rdi
callq 0x3110
addq $0x20, %rsp
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O0/Matthias-Wandel[P]imgcomp/src/jpgfile.c
// Function: ErrNonfatal
void ErrNonfatal(const char * msg, int a1, int a2)
{
    if (SupressNonFatalErrors) return;

    fprintf(Log,"\nNonfatal Error : ");
    fprintf(Log, msg, a1, a2);
    fprintf(Log, "\n");
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movl %edx, -0x10(%rbp)
cmpl $0x0, 0xc7eb(%rip)      # 0x154b4
je 0x8ccd
jmp 0x8d18
leaq 0xc344(%rip), %rax      # 0x15018
movq (%rax), %rdi
leaq 0x6df2(%rip), %rsi      # 0xfad0
movb $0x0, %al
callq 0x3290
leaq 0xc32c(%rip), %rax      # 0x15018
movq (%rax), %rdi
movq -0x8(%rbp), %rsi
movl -0xc(%rbp), %edx
movl -0x10(%rbp), %ecx
movb $0x0, %al
callq 0x3290
leaq 0xc311(%rip), %rax      # 0x15018
movq (%rax), %rdi
leaq 0x54aa(%rip), %rsi      # 0xe1bb
movb $0x0, %al
callq 0x3290
addq $0x10, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/Matthias-Wandel[P]imgcomp/src/jpgfile.c
// Function: process_SOFn
static void process_SOFn (const uchar * Data, int marker)
{
    int data_precision, num_components;

    data_precision = Data[2];
    ImageInfo.Height = Get16m(Data+3);
    ImageInfo.Width = Get16m(Data+5);
    num_components = Data[7];

    if (num_components == 3){
        ImageInfo.IsColor = 1;
    }else{
        ImageInfo.IsColor = 0;
    }

    ImageInfo.Process = marker;

    if (ShowTags){
        printf("JPEG image is %uw * %uh, %d color components, %d bits per sample\n",
                   ImageInfo.Width, ImageInfo.Height, num_components, data_precision);
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movq -0x8(%rbp), %rax
movzbl 0x2(%rax), %eax
movl %eax, -0x10(%rbp)
movq -0x8(%rbp), %rdi
addq $0x3, %rdi
callq 0x9100
movl %eax, 0xd48f(%rip)      # 0x1651c
movq -0x8(%rbp), %rdi
addq $0x5, %rdi
callq 0x9100
movl %eax, 0xd480(%rip)      # 0x16520
movq -0x8(%rbp), %rax
movzbl 0x7(%rax), %eax
movl %eax, -0x14(%rbp)
cmpl $0x3, -0x14(%rbp)
jne 0x90bd
movl $0x1, 0xd46d(%rip)      # 0x16528
jmp 0x90c7
movl $0x0, 0xd461(%rip)      # 0x16528
movl -0xc(%rbp), %eax
movl %eax, 0xd45c(%rip)      # 0x1652c
cmpl $0x0, 0xc3d9(%rip)      # 0x154b0
je 0x90fa
movl 0xd441(%rip), %esi      # 0x16520
movl 0xd437(%rip), %edx      # 0x1651c
movl -0x14(%rbp), %ecx
movl -0x10(%rbp), %r8d
leaq 0x6a99(%rip), %rdi      # 0xfb8c
movb $0x0, %al
callq 0x3170
addq $0x20, %rsp
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O0/Matthias-Wandel[P]imgcomp/src/exif.c
// Function: Get32s
int Get32s(void * Long)
{
    if (MotorolaOrder){
        return  ((( char *)Long)[0] << 24) | (((uchar *)Long)[1] << 16)
              | (((uchar *)Long)[2] << 8 ) | (((uchar *)Long)[3] << 0 );
    }else{
        return  ((( char *)Long)[3] << 24) | (((uchar *)Long)[2] << 16)
              | (((uchar *)Long)[1] << 8 ) | (((uchar *)Long)[0] << 0 );
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x10(%rbp)
cmpl $0x0, 0xd401(%rip)      # 0x16580
je 0x91b7
movq -0x10(%rbp), %rax
movsbl (%rax), %eax
shll $0x18, %eax
movq -0x10(%rbp), %rcx
movzbl 0x1(%rcx), %ecx
shll $0x10, %ecx
orl %ecx, %eax
movq -0x10(%rbp), %rcx
movzbl 0x2(%rcx), %ecx
shll $0x8, %ecx
orl %ecx, %eax
movq -0x10(%rbp), %rcx
movzbl 0x3(%rcx), %ecx
shll $0x0, %ecx
orl %ecx, %eax
movl %eax, -0x4(%rbp)
jmp 0x91eb
movq -0x10(%rbp), %rax
movsbl 0x3(%rax), %eax
shll $0x18, %eax
movq -0x10(%rbp), %rcx
movzbl 0x2(%rcx), %ecx
shll $0x10, %ecx
orl %ecx, %eax
movq -0x10(%rbp), %rcx
movzbl 0x1(%rcx), %ecx
shll $0x8, %ecx
orl %ecx, %eax
movq -0x10(%rbp), %rcx
movzbl (%rcx), %ecx
shll $0x0, %ecx
orl %ecx, %eax
movl %eax, -0x4(%rbp)
movl -0x4(%rbp), %eax
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O0/Matthias-Wandel[P]imgcomp/src/exif.c
// Function: Put32u
void Put32u(void * Value, unsigned PutValue)
{
    if (MotorolaOrder){
        ((uchar *)Value)[0] = (uchar)(PutValue>>24);
        ((uchar *)Value)[1] = (uchar)(PutValue>>16);
        ((uchar *)Value)[2] = (uchar)(PutValue>>8);
        ((uchar *)Value)[3] = (uchar)PutValue;
    }else{
        ((uchar *)Value)[0] = (uchar)PutValue;
        ((uchar *)Value)[1] = (uchar)(PutValue>>8);
        ((uchar *)Value)[2] = (uchar)(PutValue>>16);
        ((uchar *)Value)[3] = (uchar)(PutValue>>24);
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
cmpl $0x0, 0xd37e(%rip)      # 0x16580
je 0x923e
movl -0xc(%rbp), %eax
shrl $0x18, %eax
movb %al, %cl
movq -0x8(%rbp), %rax
movb %cl, (%rax)
movl -0xc(%rbp), %eax
shrl $0x10, %eax
movb %al, %cl
movq -0x8(%rbp), %rax
movb %cl, 0x1(%rax)
movl -0xc(%rbp), %eax
shrl $0x8, %eax
movb %al, %cl
movq -0x8(%rbp), %rax
movb %cl, 0x2(%rax)
movl -0xc(%rbp), %eax
movb %al, %cl
movq -0x8(%rbp), %rax
movb %cl, 0x3(%rax)
jmp 0x9276
movl -0xc(%rbp), %eax
movb %al, %cl
movq -0x8(%rbp), %rax
movb %cl, (%rax)
movl -0xc(%rbp), %eax
shrl $0x8, %eax
movb %al, %cl
movq -0x8(%rbp), %rax
movb %cl, 0x1(%rax)
movl -0xc(%rbp), %eax
shrl $0x10, %eax
movb %al, %cl
movq -0x8(%rbp), %rax
movb %cl, 0x2(%rax)
movl -0xc(%rbp), %eax
shrl $0x18, %eax
movb %al, %cl
movq -0x8(%rbp), %rax
movb %cl, 0x3(%rax)
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/Matthias-Wandel[P]imgcomp/src/exif.c
// Function: Exif2tm
int Exif2tm(struct tm * timeptr, char * ExifTime)
{
    int a;

    timeptr->tm_wday = -1;

    // Check for format: YYYY:MM:DD HH:MM:SS format.
    // Date and time normally separated by a space, but also seen a ':' there, so
    // skip the middle space with '%*c' so it can be any character.
    timeptr->tm_sec = 0;
    a = sscanf(ExifTime, "%d%*c%d%*c%d%*c%d:%d:%d",
            &timeptr->tm_year, &timeptr->tm_mon, &timeptr->tm_mday,
            &timeptr->tm_hour, &timeptr->tm_min, &timeptr->tm_sec);

    if (a >= 5){
        if (timeptr->tm_year <= 12 && timeptr->tm_mday > 2000 && ExifTime[2] == '.'){
            // LG Electronics VX-9700 seems to encode the date as 'MM.DD.YYYY HH:MM'
            // can't these people read the standard?  At least they left enough room
            // in the header to put an Exif format date in there.
            int tmp;
            tmp = timeptr->tm_year;
            timeptr->tm_year = timeptr->tm_mday;
            timeptr->tm_mday = timeptr->tm_mon;
            timeptr->tm_mon = tmp;
        }

        // Accept five or six parameters.  Some cameras do not store seconds.
        timeptr->tm_isdst = -1;  
        timeptr->tm_mon -= 1;      // Adjust for unix zero-based months 
        timeptr->tm_year -= 1900;  // Adjust for year starting at 1900 
        return TRUE; // worked. 
    }

    return FALSE; // Wasn't in Exif date format.
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x10(%rbp), %rax
movl $0xffffffff, 0x18(%rax) # imm = 0xFFFFFFFF
movq -0x10(%rbp), %rax
movl $0x0, (%rax)
movq -0x18(%rbp), %rdi
movq -0x10(%rbp), %rdx
addq $0x14, %rdx
movq -0x10(%rbp), %rcx
addq $0x10, %rcx
movq -0x10(%rbp), %r8
addq $0xc, %r8
movq -0x10(%rbp), %r9
addq $0x8, %r9
movq -0x10(%rbp), %r10
addq $0x4, %r10
movq -0x10(%rbp), %rax
leaq 0x5a61(%rip), %rsi      # 0xffad
movq %r10, (%rsp)
movq %rax, 0x8(%rsp)
movb $0x0, %al
callq 0x3370
movl %eax, -0x1c(%rbp)
cmpl $0x5, -0x1c(%rbp)
jl 0xa5ee
movq -0x10(%rbp), %rax
cmpl $0xc, 0x14(%rax)
jg 0xa5bd
movq -0x10(%rbp), %rax
cmpl $0x7d0, 0xc(%rax)       # imm = 0x7D0
jle 0xa5bd
movq -0x18(%rbp), %rax
movsbl 0x2(%rax), %eax
cmpl $0x2e, %eax
jne 0xa5bd
movq -0x10(%rbp), %rax
movl 0x14(%rax), %eax
movl %eax, -0x20(%rbp)
movq -0x10(%rbp), %rax
movl 0xc(%rax), %ecx
movq -0x10(%rbp), %rax
movl %ecx, 0x14(%rax)
movq -0x10(%rbp), %rax
movl 0x10(%rax), %ecx
movq -0x10(%rbp), %rax
movl %ecx, 0xc(%rax)
movl -0x20(%rbp), %ecx
movq -0x10(%rbp), %rax
movl %ecx, 0x10(%rax)
movq -0x10(%rbp), %rax
movl $0xffffffff, 0x20(%rax) # imm = 0xFFFFFFFF
movq -0x10(%rbp), %rax
movl 0x10(%rax), %ecx
subl $0x1, %ecx
movl %ecx, 0x10(%rax)
movq -0x10(%rbp), %rax
movl 0x14(%rax), %ecx
subl $0x76c, %ecx            # imm = 0x76C
movl %ecx, 0x14(%rax)
movl $0x1, -0x4(%rbp)
jmp 0xa5f5
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x30, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/Matthias-Wandel[P]imgcomp/src/exif.c
// Function: ShowConciseImageInfo
void ShowConciseImageInfo(void)
{
    printf("\"%s\"",ImageInfo.FileName);

    printf(" %dx%d",ImageInfo.Width, ImageInfo.Height);

    if (ImageInfo.ExposureTime){
        if (ImageInfo.ExposureTime <= 0.5){
            printf(" (1/%d)",(int)(0.5 + 1/ImageInfo.ExposureTime));
        }else{
            printf(" (%1.1f)",ImageInfo.ExposureTime);
        }
    }

    if (ImageInfo.ApertureFNumber){
        printf(" f/%3.1f",(double)ImageInfo.ApertureFNumber);
    }

    if (ImageInfo.FocalLength35mmEquiv){
        printf(" f(35)=%dmm",ImageInfo.FocalLength35mmEquiv);
    }

    if (ImageInfo.FlashUsed >= 0 && ImageInfo.FlashUsed & 1){
        printf(" (flash)");
    }

    printf("\n");
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
leaq 0x3268(%rip), %rdi      # 0xe183
leaq 0xa596(%rip), %rsi      # 0x154b8
movb $0x0, %al
callq 0x3170
leaq 0xa588(%rip), %rax      # 0x154b8
movl 0x1068(%rax), %esi
leaq 0xa57b(%rip), %rax      # 0x154b8
movl 0x1064(%rax), %edx
leaq 0x5762(%rip), %rdi      # 0x106ac
movb $0x0, %al
callq 0x3170
leaq 0xa560(%rip), %rax      # 0x154b8
movss 0x1080(%rax), %xmm0
xorps %xmm1, %xmm1
ucomiss %xmm1, %xmm0
jne 0xaf6c
jp 0xaf6c
jmp 0xafeb
leaq 0xa545(%rip), %rax      # 0x154b8
movss 0x1080(%rax), %xmm0
cvtss2sd %xmm0, %xmm1
movsd 0x3089(%rip), %xmm0     # 0xe010
ucomisd %xmm1, %xmm0
jb 0xafc8
movss 0x4ec3(%rip), %xmm0     # 0xfe58
leaq 0xa51c(%rip), %rax      # 0x154b8
divss 0x1080(%rax), %xmm0
cvtss2sd %xmm0, %xmm1
movsd 0x3060(%rip), %xmm0     # 0xe010
addsd %xmm1, %xmm0
cvttsd2si %xmm0, %esi
leaq 0x53a6(%rip), %rdi      # 0x10365
movb $0x0, %al
callq 0x3170
jmp 0xafe9
leaq 0xa4e9(%rip), %rax      # 0x154b8
movss 0x1080(%rax), %xmm0
cvtss2sd %xmm0, %xmm0
leaq 0x56d1(%rip), %rdi      # 0x106b3
movb $0x1, %al
callq 0x3170
jmp 0xafeb
leaq 0xa4c6(%rip), %rax      # 0x154b8
movss 0x1084(%rax), %xmm0
xorps %xmm1, %xmm1
ucomiss %xmm1, %xmm0
jne 0xb006
jp 0xb006
jmp 0xb027
leaq 0xa4ab(%rip), %rax      # 0x154b8
movss 0x1084(%rax), %xmm0
cvtss2sd %xmm0, %xmm0
leaq 0x569c(%rip), %rdi      # 0x106bc
movb $0x1, %al
callq 0x3170
leaq 0xa48a(%rip), %rax      # 0x154b8
cmpl $0x0, 0x1094(%rax)
je 0xb052
leaq 0xa47a(%rip), %rax      # 0x154b8
movl 0x1094(%rax), %esi
leaq 0x567a(%rip), %rdi      # 0x106c5
movb $0x0, %al
callq 0x3170
leaq 0xa45f(%rip), %rax      # 0x154b8
cmpl $0x0, 0x1078(%rax)
jl 0xb085
leaq 0xa44f(%rip), %rax      # 0x154b8
movl 0x1078(%rax), %eax
andl $0x1, %eax
cmpl $0x0, %eax
je 0xb085
leaq 0x5653(%rip), %rdi      # 0x106d1
movb $0x0, %al
callq 0x3170
leaq 0x312f(%rip), %rdi      # 0xe1bb
movb $0x0, %al
callq 0x3170
popq %rbp
retq
nopw %cs:(%rax,%rax)
nop
// File: /workspace/github_c_makefile_star2_O0/Matthias-Wandel[P]imgcomp/src/start_camera_prog.c
// Function: do_launch_program
static pid_t do_launch_program(char * cmd_string)
{
    char * Arguments[51];
    int narg;
    int a;
    int wasblank = 1;

    // Note: NOT handling quoted strings or anything for arguments with spaces in them.
    narg=0;
    for (a=0;cmd_string[a];a++){
        if (cmd_string[a] != ' '){
            if (wasblank){
                if (narg >= 50){
                    fprintf(stderr, "too many command line arguments\n");
                    exit(0);
                }
                Arguments[narg++] = &cmd_string[a];
            }
            wasblank = 0;
        }else{
            cmd_string[a] = '\0';
            wasblank = 1;
        }
    }
    Arguments[narg] = NULL;

    //printf("%d arguments\n",narg);
    //for (a=0;a<narg;a++){
    //    printf("'%s'\n",Arguments[a]);
    //}
    
    int pid = fork();
    if (pid == -1){
        // Failed to fork.
        fprintf(Log,"Failed to fork off child process\n");
        return -1;
    }

    if(pid == 0){
        // Child takes this branch.
        execvp(Arguments[0], Arguments);
        fprintf(Log,"Failed to execute: %s\n",Arguments[0]);
        perror("Reason");
        exit(errno);
        return -1;
    }
    return pid;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x1c0, %rsp            # imm = 0x1C0
movq %rdi, -0x10(%rbp)
movl $0x1, -0x1bc(%rbp)
movl $0x0, -0x1b4(%rbp)
movl $0x0, -0x1b8(%rbp)
movq -0x10(%rbp), %rax
movslq -0x1b8(%rbp), %rcx
cmpb $0x0, (%rax,%rcx)
je 0xb43b
movq -0x10(%rbp), %rax
movslq -0x1b8(%rbp), %rcx
movsbl (%rax,%rcx), %eax
cmpl $0x20, %eax
je 0xb40c
cmpl $0x0, -0x1bc(%rbp)
je 0xb400
cmpl $0x32, -0x1b4(%rbp)
jl 0xb3d7
movq 0x8c31(%rip), %rax      # 0x13ff0
movq (%rax), %rdi
leaq 0x5e45(%rip), %rsi      # 0x1120e
movb $0x0, %al
callq 0x3290
xorl %edi, %edi
callq 0x3480
movq -0x10(%rbp), %rcx
movslq -0x1b8(%rbp), %rax
addq %rax, %rcx
movl -0x1b4(%rbp), %eax
movl %eax, %edx
addl $0x1, %edx
movl %edx, -0x1b4(%rbp)
cltq
movq %rcx, -0x1b0(%rbp,%rax,8)
movl $0x0, -0x1bc(%rbp)
jmp 0xb425
movq -0x10(%rbp), %rax
movslq -0x1b8(%rbp), %rcx
movb $0x0, (%rax,%rcx)
movl $0x1, -0x1bc(%rbp)
jmp 0xb427
movl -0x1b8(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x1b8(%rbp)
jmp 0xb37d
movslq -0x1b4(%rbp), %rax
movq $0x0, -0x1b0(%rbp,%rax,8)
callq 0x34e0
movl %eax, -0x1c0(%rbp)
cmpl $-0x1, -0x1c0(%rbp)
jne 0xb483
leaq 0x9baf(%rip), %rax      # 0x15018
movq (%rax), %rdi
leaq 0x5dbc(%rip), %rsi      # 0x1122f
movb $0x0, %al
callq 0x3290
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
jmp 0xb4df
cmpl $0x0, -0x1c0(%rbp)
jne 0xb4d6
movq -0x1b0(%rbp), %rdi
leaq -0x1b0(%rbp), %rsi
callq 0x3440
leaq 0x9b72(%rip), %rax      # 0x15018
movq (%rax), %rdi
movq -0x1b0(%rbp), %rdx
leaq 0x5d9a(%rip), %rsi      # 0x11251
movb $0x0, %al
callq 0x3290
leaq 0x5da3(%rip), %rdi      # 0x11268
callq 0x3430
callq 0x3070
movl (%rax), %edi
callq 0x3480
movl -0x1c0(%rbp), %eax
movl %eax, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x1c0, %rsp            # imm = 0x1C0
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/Matthias-Wandel[P]imgcomp/src/util.c
// Function: CatPath
char * CatPath(char *Dir, char * FileName)
{
    static char catpath[502];
    int pathlen;

    pathlen = strlen(Dir);
    if (pathlen > 300){
        fprintf(Log, "path too long!");
        exit(-1);
    }
    memcpy(catpath, Dir, pathlen+1);
    if (catpath[pathlen-1] != '/' && catpath[pathlen-1] != '\\'){
        catpath[pathlen] = '/';
        pathlen += 1;
    }
    strncpy(catpath+pathlen, FileName,256);
    return catpath;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rdi
callq 0x3130
movl %eax, -0x14(%rbp)
cmpl $0x12c, -0x14(%rbp)     # imm = 0x12C
jle 0xbae7
leaq 0x954c(%rip), %rax      # 0x15018
movq (%rax), %rdi
leaq 0x5799(%rip), %rsi      # 0x1126f
movb $0x0, %al
callq 0x3290
movl $0xffffffff, %edi       # imm = 0xFFFFFFFF
callq 0x3480
movq -0x8(%rbp), %rsi
movl -0x14(%rbp), %eax
addl $0x1, %eax
movslq %eax, %rdx
leaq 0xac25(%rip), %rdi      # 0x16720
callq 0x32c0
movl -0x14(%rbp), %eax
subl $0x1, %eax
movslq %eax, %rcx
leaq 0xac10(%rip), %rax      # 0x16720
movsbl (%rax,%rcx), %eax
cmpl $0x2f, %eax
je 0xbb4a
movl -0x14(%rbp), %eax
subl $0x1, %eax
movslq %eax, %rcx
leaq 0xabf7(%rip), %rax      # 0x16720
movsbl (%rax,%rcx), %eax
cmpl $0x5c, %eax
je 0xbb4a
movslq -0x14(%rbp), %rcx
leaq 0xabe3(%rip), %rax      # 0x16720
movb $0x2f, (%rax,%rcx)
movl -0x14(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x14(%rbp)
movslq -0x14(%rbp), %rax
leaq 0xabcb(%rip), %rdi      # 0x16720
addq %rax, %rdi
movq -0x10(%rbp), %rsi
movl $0x100, %edx            # imm = 0x100
callq 0x3090
leaq 0xabb3(%rip), %rax      # 0x16720
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)