LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O0/mishun[P]plantri/fullgen.c
// Function: reko_patch_sp
void reko_patch_sp(KANTE *anfang,KNOTENTYP code[],int fuenfecke)
{
int i, position, zaehler, z2;
KANTE *run, *merke;


/* wenn bei einer kante hier noright gesetzt ist, so heisst das, dass
   rechts davon keine Flaeche mehr ist. Bei den zur Brille gehoerenden Kanten
   ist das teilweise falsch --macht aber nichts */

for (i=0; i<=fuenfecke; i++) code[i]=0;

position=0; run=anfang;
zaehler=1;

while (position<fuenfecke)
  { if (checksize_and_mark_sp(run)==5) { code[position]=zaehler; position++;
					     if (position==fuenfecke) return; }
    zaehler++;
    merke=run->invers; run=run->next; z2=1;
    while ((merke != run) && (run->noright) && (z2 <=6))
      { run=run->invers->next; z2++; }
    if ((merke==run) && (run->noright)) /* dann muss die letzte flaeche das letzte 5-eck sein */
      { code[position]=zaehler; position++; 
	if (position<fuenfecke)  
		{ fprintf(stderr," ERROR in reko_patch_sp ! Patch empty and missing 5-gon !\n"); exit(33); }
      }
  }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl %edx, -0x14(%rbp)
movl $0x0, -0x18(%rbp)
movl -0x18(%rbp), %eax
cmpl -0x14(%rbp), %eax
jg 0xaf5b
movq -0x10(%rbp), %rax
movslq -0x18(%rbp), %rcx
movw $0x0, (%rax,%rcx,2)
movl -0x18(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x18(%rbp)
jmp 0xaf3a
movl $0x0, -0x1c(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x30(%rbp)
movl $0x1, -0x20(%rbp)
movl -0x1c(%rbp), %eax
cmpl -0x14(%rbp), %eax
jge 0xb08f
movq -0x30(%rbp), %rdi
callq 0xaec0
cmpl $0x5, %eax
jne 0xafb5
movl -0x20(%rbp), %eax
movw %ax, %dx
movq -0x10(%rbp), %rax
movslq -0x1c(%rbp), %rcx
movw %dx, (%rax,%rcx,2)
movl -0x1c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x1c(%rbp)
movl -0x1c(%rbp), %eax
cmpl -0x14(%rbp), %eax
jne 0xafb3
jmp 0xb08f
jmp 0xafb5
movl -0x20(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x20(%rbp)
movq -0x30(%rbp), %rax
movq 0x28(%rax), %rax
movq %rax, -0x38(%rbp)
movq -0x30(%rbp), %rax
movq 0x20(%rax), %rax
movq %rax, -0x30(%rbp)
movl $0x1, -0x24(%rbp)
movq -0x38(%rbp), %rcx
xorl %eax, %eax
cmpq -0x30(%rbp), %rcx
movb %al, -0x39(%rbp)
je 0xb008
movq -0x30(%rbp), %rax
movsbl 0x12(%rax), %ecx
xorl %eax, %eax
cmpl $0x0, %ecx
movb %al, -0x39(%rbp)
je 0xb008
cmpl $0x6, -0x24(%rbp)
setle %al
movb %al, -0x39(%rbp)
movb -0x39(%rbp), %al
testb $0x1, %al
jne 0xb011
jmp 0xb02c
movq -0x30(%rbp), %rax
movq 0x28(%rax), %rax
movq 0x20(%rax), %rax
movq %rax, -0x30(%rbp)
movl -0x24(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x24(%rbp)
jmp 0xafdd
movq -0x38(%rbp), %rax
cmpq -0x30(%rbp), %rax
jne 0xb08a
movq -0x30(%rbp), %rax
movsbl 0x12(%rax), %eax
cmpl $0x0, %eax
je 0xb08a
movl -0x20(%rbp), %eax
movw %ax, %dx
movq -0x10(%rbp), %rax
movslq -0x1c(%rbp), %rcx
movw %dx, (%rax,%rcx,2)
movl -0x1c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x1c(%rbp)
movl -0x1c(%rbp), %eax
cmpl -0x14(%rbp), %eax
jge 0xb088
movq 0x10f8b(%rip), %rax     # 0x1bff8
movq (%rax), %rdi
leaq 0xd7e5(%rip), %rsi      # 0x1885c
movb $0x0, %al
callq 0x1080
movl $0x21, %edi
callq 0x1120
jmp 0xb08a
jmp 0xaf71
addq $0x40, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/mishun[P]plantri/fullgen.c
// Function: bilde_f_rek
void bilde_f_rek(KNOTENTYP *f, KANTE *k1, KANTE *k2) {
  KNOTENTYP u;
  k1 = k1->invers->prev;
  k2 = k2->invers->prev;   /* k1 und k2 im Gleichschritt nach rechts */
  u = k1->name;            /* von u wird der Funktionswert f[u] berechnet */
  if (!(f[u])) {          /* Funktionswert noch nicht bekannt */
    f[u] = k2->name;
    bilde_f_rek(f,k1,k2);  /* von u ausgehend weitere Funktionswerte ermitteln */
  }
  k1 = k1->prev;           /* k1 und k2 im Gleichschritt nach links */
  k2 = k2->prev;           /* denn: (k->invers->prev)->prev = k->invers->next */
  u = k1->name;
  if (!(f[u])) {
    f[u] = k2->name;
    bilde_f_rek(f,k1,k2);
  }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x10(%rbp), %rax
movq 0x28(%rax), %rax
movq 0x18(%rax), %rax
movq %rax, -0x10(%rbp)
movq -0x18(%rbp), %rax
movq 0x28(%rax), %rax
movq 0x18(%rax), %rax
movq %rax, -0x18(%rbp)
movq -0x10(%rbp), %rax
movw 0x2(%rax), %ax
movw %ax, -0x1a(%rbp)
movq -0x8(%rbp), %rax
movzwl -0x1a(%rbp), %ecx
cmpw $0x0, (%rax,%rcx,2)
jne 0xbe94
movq -0x18(%rbp), %rax
movw 0x2(%rax), %dx
movq -0x8(%rbp), %rax
movzwl -0x1a(%rbp), %ecx
movw %dx, (%rax,%rcx,2)
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
movq -0x18(%rbp), %rdx
callq 0xbe20
movq -0x10(%rbp), %rax
movq 0x18(%rax), %rax
movq %rax, -0x10(%rbp)
movq -0x18(%rbp), %rax
movq 0x18(%rax), %rax
movq %rax, -0x18(%rbp)
movq -0x10(%rbp), %rax
movw 0x2(%rax), %ax
movw %ax, -0x1a(%rbp)
movq -0x8(%rbp), %rax
movzwl -0x1a(%rbp), %ecx
cmpw $0x0, (%rax,%rcx,2)
jne 0xbeec
movq -0x18(%rbp), %rax
movw 0x2(%rax), %dx
movq -0x8(%rbp), %rax
movzwl -0x1a(%rbp), %ecx
movw %dx, (%rax,%rcx,2)
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
movq -0x18(%rbp), %rdx
callq 0xbe20
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/mishun[P]plantri/fullgen.c
// Function: bilde_f
void bilde_f(KNOTENTYP *f, KANTE *k1, KANTE *k2, KNOTENTYP anz) {
  KNOTENTYP i;
  for (i=1; i<=anz; i++) {f[i] = 0;}   /* Funktionstabelle loeschen */
  f[k1->ursprung] = k2->ursprung;
  f[k1->name]     = k2->name;           /* k1 wird auf k2 abgebildet */  
  bilde_f_rek(f,k1,k2);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movw %cx, %ax
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movw %ax, -0x1a(%rbp)
movw $0x1, -0x1c(%rbp)
movzwl -0x1c(%rbp), %eax
movzwl -0x1a(%rbp), %ecx
cmpl %ecx, %eax
jg 0xbf49
movq -0x8(%rbp), %rax
movzwl -0x1c(%rbp), %ecx
movw $0x0, (%rax,%rcx,2)
movw -0x1c(%rbp), %ax
addw $0x1, %ax
movw %ax, -0x1c(%rbp)
jmp 0xbf21
movq -0x18(%rbp), %rax
movw (%rax), %dx
movq -0x8(%rbp), %rax
movq -0x10(%rbp), %rcx
movzwl (%rcx), %ecx
movw %dx, (%rax,%rcx,2)
movq -0x18(%rbp), %rax
movw 0x2(%rax), %dx
movq -0x8(%rbp), %rax
movq -0x10(%rbp), %rcx
movzwl 0x2(%rcx), %ecx
movw %dx, (%rax,%rcx,2)
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
movq -0x18(%rbp), %rdx
callq 0xbe20
addq $0x20, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/mishun[P]plantri/fullgen.c
// Function: bilde_f_sp_rek
void bilde_f_sp_rek(KNOTENTYP *f, KANTE *k1, KANTE *k2) {
  KNOTENTYP u;
  k1 = k1->invers->prev;
  k2 = k2->invers->next;   /* k1 und k2 spiegelverkehrt nach rechts und links */
  u = k1->name;            /* von u wird der Funktionswert f[u] berechnet */
  if (!(f[u])) {           /* Funktionswert noch nicht bekannt */
    f[u] = k2->name;
    bilde_f_sp_rek(f,k1,k2);  /* von u ausgehend weitere Funktionswerte ermitteln */
  }
  k1 = k1->prev;           /* k1 und k2 spiegelverkehrt nach links und rechts */
  k2 = k2->next;           /* denn: (k->invers->next)->next = k->invers->prev */
  u = k1->name;
  if (!(f[u])) {
    f[u] = k2->name;
    bilde_f_sp_rek(f,k1,k2);
  }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x10(%rbp), %rax
movq 0x28(%rax), %rax
movq 0x18(%rax), %rax
movq %rax, -0x10(%rbp)
movq -0x18(%rbp), %rax
movq 0x28(%rax), %rax
movq 0x20(%rax), %rax
movq %rax, -0x18(%rbp)
movq -0x10(%rbp), %rax
movw 0x2(%rax), %ax
movw %ax, -0x1a(%rbp)
movq -0x8(%rbp), %rax
movzwl -0x1a(%rbp), %ecx
cmpw $0x0, (%rax,%rcx,2)
jne 0xc004
movq -0x18(%rbp), %rax
movw 0x2(%rax), %dx
movq -0x8(%rbp), %rax
movzwl -0x1a(%rbp), %ecx
movw %dx, (%rax,%rcx,2)
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
movq -0x18(%rbp), %rdx
callq 0xbf90
movq -0x10(%rbp), %rax
movq 0x18(%rax), %rax
movq %rax, -0x10(%rbp)
movq -0x18(%rbp), %rax
movq 0x20(%rax), %rax
movq %rax, -0x18(%rbp)
movq -0x10(%rbp), %rax
movw 0x2(%rax), %ax
movw %ax, -0x1a(%rbp)
movq -0x8(%rbp), %rax
movzwl -0x1a(%rbp), %ecx
cmpw $0x0, (%rax,%rcx,2)
jne 0xc05c
movq -0x18(%rbp), %rax
movw 0x2(%rax), %dx
movq -0x8(%rbp), %rax
movzwl -0x1a(%rbp), %ecx
movw %dx, (%rax,%rcx,2)
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
movq -0x18(%rbp), %rdx
callq 0xbf90
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/mishun[P]plantri/fullgen.c
// Function: bilde_f_sp
void bilde_f_sp(KNOTENTYP *f, KANTE *k1, KANTE *k2, KNOTENTYP anz) {
  KNOTENTYP i;
  for (i=1; i<=anz; i++) {f[i] = 0;}   /* Funktionstabelle loeschen */
  f[k1->ursprung] = k2->ursprung;
  f[k1->name]     = k2->name;           /* k1 wird auf k2 abgebildet */  
  bilde_f_sp_rek(f,k1,k2);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movw %cx, %ax
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movw %ax, -0x1a(%rbp)
movw $0x1, -0x1c(%rbp)
movzwl -0x1c(%rbp), %eax
movzwl -0x1a(%rbp), %ecx
cmpl %ecx, %eax
jg 0xc0b9
movq -0x8(%rbp), %rax
movzwl -0x1c(%rbp), %ecx
movw $0x0, (%rax,%rcx,2)
movw -0x1c(%rbp), %ax
addw $0x1, %ax
movw %ax, -0x1c(%rbp)
jmp 0xc091
movq -0x18(%rbp), %rax
movw (%rax), %dx
movq -0x8(%rbp), %rax
movq -0x10(%rbp), %rcx
movzwl (%rcx), %ecx
movw %dx, (%rax,%rcx,2)
movq -0x18(%rbp), %rax
movw 0x2(%rax), %dx
movq -0x8(%rbp), %rax
movq -0x10(%rbp), %rcx
movzwl 0x2(%rcx), %ecx
movw %dx, (%rax,%rcx,2)
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
movq -0x18(%rbp), %rdx
callq 0xbf90
addq $0x20, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/mishun[P]plantri/fullgen.c
// Function: bilde_f_und_g_sp
BOOL bilde_f_und_g_sp(KNOTENTYP *f, KNOTENTYP *g, KANTE *k1, KANTE *k2, KNOTENTYP anz) {
  KNOTENTYP i;
  for (i=1; i<=anz; i++) {f[i]=0; g[i]=0;}   /* Funktionstabellen loeschen */
  f[k1->ursprung] = k2->ursprung;
  f[k1->name]     = k2->name;           /* f: k1 wird auf k2 abgebildet */  
  g[k2->ursprung] = k1->ursprung;
  g[k2->name]     = k1->name;           /* g: k2 wird auf k1 abgebildet */
  return(bilde_f_und_g_sp_rek(f,g,k1,k2));
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movw %r8w, %ax
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq %rcx, -0x20(%rbp)
movw %ax, -0x22(%rbp)
movw $0x1, -0x24(%rbp)
movzwl -0x24(%rbp), %eax
movzwl -0x22(%rbp), %ecx
cmpl %ecx, %eax
jg 0xc2ec
movq -0x8(%rbp), %rax
movzwl -0x24(%rbp), %ecx
movw $0x0, (%rax,%rcx,2)
movq -0x10(%rbp), %rax
movzwl -0x24(%rbp), %ecx
movw $0x0, (%rax,%rcx,2)
movw -0x24(%rbp), %ax
addw $0x1, %ax
movw %ax, -0x24(%rbp)
jmp 0xc2b6
movq -0x20(%rbp), %rax
movw (%rax), %dx
movq -0x8(%rbp), %rax
movq -0x18(%rbp), %rcx
movzwl (%rcx), %ecx
movw %dx, (%rax,%rcx,2)
movq -0x20(%rbp), %rax
movw 0x2(%rax), %dx
movq -0x8(%rbp), %rax
movq -0x18(%rbp), %rcx
movzwl 0x2(%rcx), %ecx
movw %dx, (%rax,%rcx,2)
movq -0x18(%rbp), %rax
movw (%rax), %dx
movq -0x10(%rbp), %rax
movq -0x20(%rbp), %rcx
movzwl (%rcx), %ecx
movw %dx, (%rax,%rcx,2)
movq -0x18(%rbp), %rax
movw 0x2(%rax), %dx
movq -0x10(%rbp), %rax
movq -0x20(%rbp), %rcx
movzwl 0x2(%rcx), %ecx
movw %dx, (%rax,%rcx,2)
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
movq -0x18(%rbp), %rdx
movq -0x20(%rbp), %rcx
callq 0xc100
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/mishun[P]plantri/fullgen.c
// Function: bilde_f_und_g
BOOL bilde_f_und_g(KNOTENTYP *f, KNOTENTYP *g, KANTE *k1, KANTE *k2, KNOTENTYP anz) {
  KNOTENTYP i;
  for (i=1; i<=anz; i++) {f[i]=0; g[i]=0;}   /* Funktionstabellen loeschen */
  f[k1->ursprung] = k2->ursprung;
  f[k1->name]     = k2->name;           /* f: k1 wird auf k2 abgebildet */  
  g[k2->ursprung] = k1->ursprung;
  g[k2->name]     = k1->name;           /* g: k2 wird auf k1 abgebildet */
  return(bilde_f_und_g_rek(f,g,k1,k2));
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movw %r8w, %ax
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq %rcx, -0x20(%rbp)
movw %ax, -0x22(%rbp)
movw $0x1, -0x24(%rbp)
movzwl -0x24(%rbp), %eax
movzwl -0x22(%rbp), %ecx
cmpl %ecx, %eax
jg 0xc55c
movq -0x8(%rbp), %rax
movzwl -0x24(%rbp), %ecx
movw $0x0, (%rax,%rcx,2)
movq -0x10(%rbp), %rax
movzwl -0x24(%rbp), %ecx
movw $0x0, (%rax,%rcx,2)
movw -0x24(%rbp), %ax
addw $0x1, %ax
movw %ax, -0x24(%rbp)
jmp 0xc526
movq -0x20(%rbp), %rax
movw (%rax), %dx
movq -0x8(%rbp), %rax
movq -0x18(%rbp), %rcx
movzwl (%rcx), %ecx
movw %dx, (%rax,%rcx,2)
movq -0x20(%rbp), %rax
movw 0x2(%rax), %dx
movq -0x8(%rbp), %rax
movq -0x18(%rbp), %rcx
movzwl 0x2(%rcx), %ecx
movw %dx, (%rax,%rcx,2)
movq -0x18(%rbp), %rax
movw (%rax), %dx
movq -0x10(%rbp), %rax
movq -0x20(%rbp), %rcx
movzwl (%rcx), %ecx
movw %dx, (%rax,%rcx,2)
movq -0x18(%rbp), %rax
movw 0x2(%rax), %dx
movq -0x10(%rbp), %rax
movq -0x20(%rbp), %rcx
movzwl 0x2(%rcx), %ecx
movw %dx, (%rax,%rcx,2)
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
movq -0x18(%rbp), %rdx
movq -0x20(%rbp), %rcx
callq 0xc370
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/mishun[P]plantri/fullgen.c
// Function: checksize_right_2
int checksize_right_2( KANTE* edge)
{
KANTE *run; 
int zaehler=1;

for (run=edge->invers->prev; run != edge; run=run->invers->prev) 
  { if (run->name==aussen) return(6); zaehler++; }
return(zaehler);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x10(%rbp)
movl $0x1, -0x1c(%rbp)
movq -0x10(%rbp), %rax
movq 0x28(%rax), %rax
movq 0x18(%rax), %rax
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rax
cmpq -0x10(%rbp), %rax
je 0x122dc
movq -0x18(%rbp), %rax
movzwl 0x2(%rax), %eax
cmpl $0x246, %eax            # imm = 0x246
jne 0x122c1
movl $0x6, -0x4(%rbp)
jmp 0x122e2
movl -0x1c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x1c(%rbp)
movq -0x18(%rbp), %rax
movq 0x28(%rax), %rax
movq 0x18(%rax), %rax
movq %rax, -0x18(%rbp)
jmp 0x1229f
movl -0x1c(%rbp), %eax
movl %eax, -0x4(%rbp)
movl -0x4(%rbp), %eax
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/mishun[P]plantri/fullgen.c
// Function: checksize_2
int checksize_2( KANTE* edge)
{
KANTE *run; 
int zaehler=1;

for (run=edge->invers->next; run != edge; run=run->invers->next) 
  { if (run->name==aussen) return(6); 
    zaehler++;  }
return(zaehler);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x10(%rbp)
movl $0x1, -0x1c(%rbp)
movq -0x10(%rbp), %rax
movq 0x28(%rax), %rax
movq 0x20(%rax), %rax
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rax
cmpq -0x10(%rbp), %rax
je 0x1234c
movq -0x18(%rbp), %rax
movzwl 0x2(%rax), %eax
cmpl $0x246, %eax            # imm = 0x246
jne 0x12331
movl $0x6, -0x4(%rbp)
jmp 0x12352
movl -0x1c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x1c(%rbp)
movq -0x18(%rbp), %rax
movq 0x28(%rax), %rax
movq 0x20(%rax), %rax
movq %rax, -0x18(%rbp)
jmp 0x1230f
movl -0x1c(%rbp), %eax
movl %eax, -0x4(%rbp)
movl -0x4(%rbp), %eax
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/mishun[P]plantri/fullgen.c
// Function: vergleiche_symm
BOOL vergleiche_symm(char nr) {
  int i;
  for (i=0; i<symm_len; i++) {
    if (symm[i]==nr) {return(True);}
  }
  return(False);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movb %dil, %al
movb %al, -0x2(%rbp)
movl $0x0, -0x8(%rbp)
movl -0x8(%rbp), %eax
cmpl 0x9ec6(%rip), %eax      # 0x1c240
jge 0x123a6
movslq -0x8(%rbp), %rcx
leaq 0x9e99(%rip), %rax      # 0x1c220
movsbl (%rax,%rcx), %eax
movsbl -0x2(%rbp), %ecx
cmpl %ecx, %eax
jne 0x12399
movb $0x1, -0x1(%rbp)
jmp 0x123aa
jmp 0x1239b
movl -0x8(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x8(%rbp)
jmp 0x12371
movb $0x0, -0x1(%rbp)
movb -0x1(%rbp), %al
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/mishun[P]plantri/fullgen.c
// Function: teste_und_schreibe
void teste_und_schreibe(PLANMAP map, KNOTENTYP *code)
{ int erg;

(non_iso_graphenzahl[map[0][0].name])++;
if ((erg=minitest(map,code))) { 
  (graphenzahl[map[0][0].name])++;
  if (symm_len==0 || vergleiche_symm(erg)) codiereplanar(map);
  (symm_anz[erg])++;                  /* fuer die Symmetriestatistik */  
}

}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rax
movzwl 0x2(%rax), %eax
movl %eax, %ecx
leaq 0x1573f(%rip), %rax     # 0x27b10
movq (%rax,%rcx,8), %rdx
addq $0x1, %rdx
leaq 0x15730(%rip), %rax     # 0x27b10
movq %rdx, (%rax,%rcx,8)
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
callq 0xc5e0
movl %eax, -0x14(%rbp)
cmpl $0x0, %eax
je 0x1245d
movq -0x8(%rbp), %rax
movzwl 0x2(%rax), %eax
movl %eax, %ecx
leaq 0x122b6(%rip), %rax     # 0x246c0
movq (%rax,%rcx,8), %rdx
addq $0x1, %rdx
leaq 0x122a7(%rip), %rax     # 0x246c0
movq %rdx, (%rax,%rcx,8)
cmpl $0x0, 0x9e1c(%rip)      # 0x1c240
je 0x12439
movl -0x14(%rbp), %eax
movsbl %al, %edi
callq 0x12360
movsbl %al, %eax
cmpl $0x0, %eax
je 0x12442
movq -0x8(%rbp), %rdi
callq 0x32b0
movslq -0x14(%rbp), %rcx
leaq 0x9d53(%rip), %rax      # 0x1c1a0
movl (%rax,%rcx,4), %edx
addl $0x1, %edx
leaq 0x9d46(%rip), %rax      # 0x1c1a0
movl %edx, (%rax,%rcx,4)
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/mishun[P]plantri/fullgen.c
// Function: suche_item
ITEMLISTE *suche_item(KNOTENTYP *adresse)
{
int i, laenge;
SEQUENZLISTE *sq;

laenge=8-adresse[0];

sq=mapliste.sechser[adresse[1]];

for (i=2; i<laenge; i++)
  { if (sq->number_next <= adresse[i]) return(nil);
    if (sq->next_level[adresse[i]]==nil) return(nil);
    sq=sq->next_level[adresse[i]]; }
return(sq->items);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x10(%rbp)
movq -0x10(%rbp), %rax
movzwl (%rax), %ecx
movl $0x8, %eax
subl %ecx, %eax
movl %eax, -0x18(%rbp)
movq -0x10(%rbp), %rax
movzwl 0x2(%rax), %eax
movl %eax, %ecx
leaq 0x14696(%rip), %rax     # 0x26b30
movq 0x8(%rax,%rcx,8), %rax
movq %rax, -0x20(%rbp)
movl $0x2, -0x14(%rbp)
movl -0x14(%rbp), %eax
cmpl -0x18(%rbp), %eax
jge 0x1251d
movq -0x20(%rbp), %rax
movl 0x8(%rax), %eax
movq -0x10(%rbp), %rcx
movslq -0x14(%rbp), %rdx
movzwl (%rcx,%rdx,2), %ecx
cmpl %ecx, %eax
jg 0x124d3
movq $0x0, -0x8(%rbp)
jmp 0x12529
movq -0x20(%rbp), %rax
movq (%rax), %rax
movq -0x10(%rbp), %rcx
movslq -0x14(%rbp), %rdx
movzwl (%rcx,%rdx,2), %ecx
cmpq $0x0, (%rax,%rcx,8)
jne 0x124f7
movq $0x0, -0x8(%rbp)
jmp 0x12529
movq -0x20(%rbp), %rax
movq (%rax), %rax
movq -0x10(%rbp), %rcx
movslq -0x14(%rbp), %rdx
movzwl (%rcx,%rdx,2), %ecx
movq (%rax,%rcx,8), %rax
movq %rax, -0x20(%rbp)
movl -0x14(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x14(%rbp)
jmp 0x124aa
movq -0x20(%rbp), %rax
movq 0x10(%rax), %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/mishun[P]plantri/fullgen.c
// Function: insert_patch
void insert_patch(PLANMAP map, KANTE *anfang, ITEMLISTE *item, int flaechenzahl, int fuenfecke)
{

FLAECHENTYP *code;
KANTE *run;
int zaehler, codestelle;

code=item->code;
    for (codestelle=0, zaehler=1, run=anfang; run != nil; zaehler++ )
      { 
	if ((codestelle<fuenfecke) && (code[codestelle]==zaehler))
          { add_polygon_invers(5, map, run, &run); codestelle++; }
        else add_polygon_invers(6, map, run, &run);
      }
        if (zaehler != flaechenzahl) 
	  { fprintf(stderr,"Insert_patch: Could not insert enough faces: ");
	    fprintf(stderr,"%d instead of %d\n (insert_patch)\n",zaehler,flaechenzahl);
	    exit(92); }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movl %ecx, -0x1c(%rbp)
movl %r8d, -0x20(%rbp)
movq -0x18(%rbp), %rax
addq $0x8, %rax
movq %rax, -0x28(%rbp)
movl $0x0, -0x38(%rbp)
movl $0x1, -0x34(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x30(%rbp)
cmpq $0x0, -0x30(%rbp)
je 0x144f1
movl -0x38(%rbp), %eax
cmpl -0x20(%rbp), %eax
jge 0x144ce
movq -0x28(%rbp), %rax
movslq -0x38(%rbp), %rcx
movzbl (%rax,%rcx), %eax
cmpl -0x34(%rbp), %eax
jne 0x144ce
movq -0x8(%rbp), %rsi
movq -0x30(%rbp), %rdx
movl $0x5, %edi
leaq -0x30(%rbp), %rcx
callq 0x12590
movl -0x38(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x38(%rbp)
jmp 0x144e4
movq -0x8(%rbp), %rsi
movq -0x30(%rbp), %rdx
movl $0x6, %edi
leaq -0x30(%rbp), %rcx
callq 0x12590
jmp 0x144e6
movl -0x34(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x34(%rbp)
jmp 0x1448d
movl -0x34(%rbp), %eax
cmpl -0x1c(%rbp), %eax
je 0x14539
movq 0x7af8(%rip), %rax      # 0x1bff8
movq (%rax), %rdi
leaq 0x484d(%rip), %rsi      # 0x18d57
movb $0x0, %al
callq 0x1080
movq 0x7ae0(%rip), %rax      # 0x1bff8
movq (%rax), %rdi
movl -0x34(%rbp), %edx
movl -0x1c(%rbp), %ecx
leaq 0x485d(%rip), %rsi      # 0x18d85
movb $0x0, %al
callq 0x1080
movl $0x5c, %edi
callq 0x1120
addq $0x40, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/cath-mawr[P]rscmapgen/mapdump.c
// Function: get_tile_colour
uint32_t
get_tile_colour(const struct chunk *c, unsigned x, unsigned y)
{
	const unsigned pos = x + y * CHUNKSIZE;

	switch (c->overlays[0][pos]) {
	case 0: return colour_tab[c->colour[0][pos]];
	case 1: return 0x40403f;
	case 2: return 0x1f3f7d;
	case 3: return 0x603001;
	case 4: return 0x603001;
	case 5: return 0x40403f;
	case 6: return 0x6b030f;
	case 7: return 0x0e2c38;
	case 8: return 0x000000;
	case 9: return 0x606260;
	case 10: return 0x000000;
	case 11: return 0x9f5000;
	case 12: return 0x613000;
	case 13: return 0x1f3f7d;
	case 14: return 0x40403f;
	case 15: return 0x241609;
	case 16: return 0x241609;
	case 17: return 0x797b7a;
	case 23: return 0x483000;
	case 21: return 0x000000;
	case 24: return 0x3f2200;
	default:
		printf("Missing overlay definition: %u\n", c->overlays[0][pos]);
		return 0x0;
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movl %esi, -0x14(%rbp)
movl %edx, -0x18(%rbp)
movl -0x14(%rbp), %eax
movl -0x18(%rbp), %edx
movl %edx, %ecx
leal (%rcx,%rcx,2), %ecx
shll $0x4, %ecx
addl %ecx, %eax
movl %eax, -0x1c(%rbp)
movq -0x10(%rbp), %rax
movl -0x1c(%rbp), %ecx
movzbl 0xfc00(%rax,%rcx), %eax
movq %rax, -0x28(%rbp)
subq $0x18, %rax
ja 0x1558
movq -0x28(%rbp), %rax
leaq 0xbb3(%rip), %rcx       # 0x2010
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
movq -0x10(%rbp), %rax
movl -0x1c(%rbp), %ecx
movzbl 0x2400(%rax,%rcx), %eax
movl %eax, %ecx
leaq 0x32c22(%rip), %rax     # 0x340a0
movl (%rax,%rcx,4), %eax
movl %eax, -0x4(%rbp)
jmp 0x157c
movl $0x40403f, -0x4(%rbp)   # imm = 0x40403F
jmp 0x157c
movl $0x1f3f7d, -0x4(%rbp)   # imm = 0x1F3F7D
jmp 0x157c
movl $0x603001, -0x4(%rbp)   # imm = 0x603001
jmp 0x157c
movl $0x603001, -0x4(%rbp)   # imm = 0x603001
jmp 0x157c
movl $0x40403f, -0x4(%rbp)   # imm = 0x40403F
jmp 0x157c
movl $0x6b030f, -0x4(%rbp)   # imm = 0x6B030F
jmp 0x157c
movl $0xe2c38, -0x4(%rbp)    # imm = 0xE2C38
jmp 0x157c
movl $0x0, -0x4(%rbp)
jmp 0x157c
movl $0x606260, -0x4(%rbp)   # imm = 0x606260
jmp 0x157c
movl $0x0, -0x4(%rbp)
jmp 0x157c
movl $0x9f5000, -0x4(%rbp)   # imm = 0x9F5000
jmp 0x157c
movl $0x613000, -0x4(%rbp)   # imm = 0x613000
jmp 0x157c
movl $0x1f3f7d, -0x4(%rbp)   # imm = 0x1F3F7D
jmp 0x157c
movl $0x40403f, -0x4(%rbp)   # imm = 0x40403F
jmp 0x157c
movl $0x241609, -0x4(%rbp)   # imm = 0x241609
jmp 0x157c
movl $0x241609, -0x4(%rbp)   # imm = 0x241609
jmp 0x157c
movl $0x797b7a, -0x4(%rbp)   # imm = 0x797B7A
jmp 0x157c
movl $0x483000, -0x4(%rbp)   # imm = 0x483000
jmp 0x157c
movl $0x0, -0x4(%rbp)
jmp 0x157c
movl $0x3f2200, -0x4(%rbp)   # imm = 0x3F2200
jmp 0x157c
movq -0x10(%rbp), %rax
movl -0x1c(%rbp), %ecx
movzbl 0xfc00(%rax,%rcx), %esi
leaq 0x30ae8(%rip), %rdi     # 0x32056
movb $0x0, %al
callq 0x1080
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/cath-mawr[P]rscmapgen/mapdump.c
// Function: write_tga
int write_tga(const char *outname, const uint32_t *pixels)
{
	unsigned i;
	FILE *f;

	if ((f = fopen(outname, "w")) == NULL) {
		return 1;
	}
	fputc(0, f); /* id len */
	fputc(0, f); /* maptype */
	fputc(2, f); /* uncompressed trucolour */
	fputc(0, f); /* map entry index */
	fputc(0, f); /* map entry index */
	fputc(0, f); /* map len */
	fputc(0, f); /* map len */
	fputc(0, f); /* map bpp */
	fputc(0, f); /* x-origin */
	fputc(0, f); /* x-origin */
	fputc(0, f); /* y-origin */
	fputc(0, f); /* y-origin */
	fputc((uint8_t)(XSIZE >> 0), f); /* width */
	fputc((uint8_t)(XSIZE >> 8), f); /* width */
	fputc((uint8_t)(YSIZE >> 0), f); /* height */
	fputc((uint8_t)(YSIZE >> 8), f); /* height */
	fputc(24, f); /* bpp */
	fputc(0x20, f); /* desc */
	for (i = 0; i < IMGSIZE; ++i) {
		fputc((uint8_t)(pixels[i] >> 0), f);
		fputc((uint8_t)(pixels[i] >> 8), f);
		fputc((uint8_t)(pixels[i] >> 16), f);
	}
	fclose(f);
	return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x10(%rbp), %rdi
leaq 0x305fb(%rip), %rsi     # 0x32076
callq 0x10d0
movq %rax, -0x28(%rbp)
cmpq $0x0, %rax
jne 0x1a96
movl $0x1, -0x4(%rbp)
jmp 0x1be7
movq -0x28(%rbp), %rsi
xorl %edi, %edi
callq 0x10b0
movq -0x28(%rbp), %rsi
xorl %edi, %edi
callq 0x10b0
movq -0x28(%rbp), %rsi
movl $0x2, %edi
callq 0x10b0
movq -0x28(%rbp), %rsi
xorl %edi, %edi
callq 0x10b0
movq -0x28(%rbp), %rsi
xorl %edi, %edi
callq 0x10b0
movq -0x28(%rbp), %rsi
xorl %edi, %edi
callq 0x10b0
movq -0x28(%rbp), %rsi
xorl %edi, %edi
callq 0x10b0
movq -0x28(%rbp), %rsi
xorl %edi, %edi
callq 0x10b0
movq -0x28(%rbp), %rsi
xorl %edi, %edi
callq 0x10b0
movq -0x28(%rbp), %rsi
xorl %edi, %edi
callq 0x10b0
movq -0x28(%rbp), %rsi
xorl %edi, %edi
callq 0x10b0
movq -0x28(%rbp), %rsi
xorl %edi, %edi
callq 0x10b0
movq -0x28(%rbp), %rsi
movl $0x90, %edi
callq 0x10b0
movq -0x28(%rbp), %rsi
movl $0x9, %edi
callq 0x10b0
movq -0x28(%rbp), %rsi
movl $0x90, %edi
callq 0x10b0
movq -0x28(%rbp), %rsi
movl $0x9, %edi
callq 0x10b0
movq -0x28(%rbp), %rsi
movl $0x18, %edi
callq 0x10b0
movq -0x28(%rbp), %rsi
movl $0x20, %edi
callq 0x10b0
movl $0x0, -0x1c(%rbp)
cmpl $0x5b7100, -0x1c(%rbp)  # imm = 0x5B7100
jae 0x1bd7
movq -0x18(%rbp), %rax
movl -0x1c(%rbp), %ecx
movl (%rax,%rcx,4), %eax
shrl $0x0, %eax
movzbl %al, %edi
movq -0x28(%rbp), %rsi
callq 0x10b0
movq -0x18(%rbp), %rax
movl -0x1c(%rbp), %ecx
movl (%rax,%rcx,4), %eax
shrl $0x8, %eax
movzbl %al, %edi
movq -0x28(%rbp), %rsi
callq 0x10b0
movq -0x18(%rbp), %rax
movl -0x1c(%rbp), %ecx
movl (%rax,%rcx,4), %eax
shrl $0x10, %eax
movzbl %al, %edi
movq -0x28(%rbp), %rsi
callq 0x10b0
movl -0x1c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x1c(%rbp)
jmp 0x1b78
movq -0x28(%rbp), %rdi
callq 0x1070
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x30, %rsp
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O0/plvhx[P]dummy-vm/src/ast.c
// Function: vm_ast_create
vm_ast_t *vm_ast_create(unsigned short kind_type, const void *ast_value) {
  vm_ast_t *ret = vm_ast_alloc(vm_ast_calculate_child(4));

  ret->kind_type = kind_type;
  ret->num_childs = 0;
  ret->num_childs_alloc_size = 4;

  switch (ret->kind_type) {
  case VM_AST_REGISTER:
    ret->regs.name = (unsigned char *)ast_value;
    break;
  case VM_AST_MNEMONIC:
    ret->mnemonic.name = (unsigned char *)ast_value;
    break;
  case VM_AST_INTEGER_VALUE:
    ret->number.val = (unsigned char *)ast_value;
    break;
  }

  return ret;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movw %di, %ax
movw %ax, -0x2(%rbp)
movq %rsi, -0x10(%rbp)
movl $0x4, %edi
callq 0x13d0
movq %rax, %rdi
callq 0x1370
movq %rax, -0x18(%rbp)
movw -0x2(%rbp), %cx
movq -0x18(%rbp), %rax
movw %cx, (%rax)
movq -0x18(%rbp), %rax
movq $0x0, 0x20(%rax)
movq -0x18(%rbp), %rax
movq $0x4, 0x28(%rax)
movq -0x18(%rbp), %rax
movzwl (%rax), %eax
movl %eax, -0x1c(%rbp)
subl $0x1, %eax
je 0x133f
jmp 0x131d
movl -0x1c(%rbp), %eax
subl $0x2, %eax
je 0x1331
jmp 0x1327
movl -0x1c(%rbp), %eax
subl $0x3, %eax
je 0x134d
jmp 0x1359
movq -0x10(%rbp), %rcx
movq -0x18(%rbp), %rax
movq %rcx, 0x8(%rax)
jmp 0x1359
movq -0x10(%rbp), %rcx
movq -0x18(%rbp), %rax
movq %rcx, 0x10(%rax)
jmp 0x1359
movq -0x10(%rbp), %rcx
movq -0x18(%rbp), %rax
movq %rcx, 0x18(%rax)
movq -0x18(%rbp), %rax
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/plvhx[P]dummy-vm/src/ast.c
// Function: vm_ast_alloc
static vm_ast_t *vm_ast_alloc(size_t size) {
  vm_ast_t *ret = malloc(size);
  assert(ret != NULL);
  memset(ret, 0, size);
  return ret;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
callq 0x1130
movq %rax, -0x10(%rbp)
cmpq $0x0, -0x10(%rbp)
je 0x1392
jmp 0x13b1
leaq 0x5c6b(%rip), %rdi      # 0x7004
leaq 0x5c70(%rip), %rsi      # 0x7010
movl $0xc, %edx
leaq 0x5c6e(%rip), %rcx      # 0x701a
callq 0x10b0
movq -0x10(%rbp), %rdi
movq -0x8(%rbp), %rdx
xorl %esi, %esi
callq 0x10c0
movq -0x10(%rbp), %rax
addq $0x10, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/plvhx[P]dummy-vm/src/ast.c
// Function: vm_ast_create_multi_ex
vm_ast_t *vm_ast_create_multi_ex(unsigned short kind_type,
                                 const void *ast_value, ...) {
  va_list ap;
  vm_ast_t *ret;

  va_start(ap, ast_value);
  ret = vm_ast_create_from_va_list(kind_type, ast_value, ap);
  va_end(ap);

  return ret;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0xf0, %rsp
testb %al, %al
je 0x142b
movaps %xmm0, -0xc0(%rbp)
movaps %xmm1, -0xb0(%rbp)
movaps %xmm2, -0xa0(%rbp)
movaps %xmm3, -0x90(%rbp)
movaps %xmm4, -0x80(%rbp)
movaps %xmm5, -0x70(%rbp)
movaps %xmm6, -0x60(%rbp)
movaps %xmm7, -0x50(%rbp)
movq %r9, -0xc8(%rbp)
movq %r8, -0xd0(%rbp)
movq %rcx, -0xd8(%rbp)
movq %rdx, -0xe0(%rbp)
movw %di, %ax
movw %ax, -0x2(%rbp)
movq %rsi, -0x10(%rbp)
leaq -0xf0(%rbp), %rax
movq %rax, -0x20(%rbp)
leaq 0x10(%rbp), %rax
movq %rax, -0x28(%rbp)
movl $0x30, -0x2c(%rbp)
movl $0x10, -0x30(%rbp)
movzwl -0x2(%rbp), %edi
movq -0x10(%rbp), %rsi
leaq -0x30(%rbp), %rdx
callq 0x14a0
movq %rax, -0x38(%rbp)
movq -0x38(%rbp), %rax
addq $0xf0, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/plvhx[P]dummy-vm/src/ast.c
// Function: vm_ast_create_from_va_list
static vm_ast_t *vm_ast_create_from_va_list(unsigned short kind_type,
                                            const void *ast_value,
                                            va_list args) {
  vm_ast_t *node = vm_ast_create(kind_type, ast_value);
  vm_ast_t *child;

  while ((child = (vm_ast_t *)va_arg(args, vm_ast_t *)) != NULL) {
    node = vm_ast_add_child(node, child);
  }

  return node;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movw %di, %ax
movw %ax, -0x2(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movw -0x2(%rbp), %ax
movq -0x10(%rbp), %rsi
movzwl %ax, %edi
callq 0x12c0
movq %rax, -0x20(%rbp)
movq -0x18(%rbp), %rax
movq %rax, -0x38(%rbp)
movl (%rax), %eax
movl %eax, -0x2c(%rbp)
cmpl $0x28, %eax
ja 0x14f6
movq -0x38(%rbp), %rcx
movl -0x2c(%rbp), %edx
movslq %edx, %rax
addq 0x10(%rcx), %rax
addl $0x8, %edx
movl %edx, (%rcx)
movq %rax, -0x40(%rbp)
jmp 0x150d
movq -0x38(%rbp), %rcx
movq 0x8(%rcx), %rax
movq %rax, %rdx
addq $0x8, %rdx
movq %rdx, 0x8(%rcx)
movq %rax, -0x40(%rbp)
movq -0x40(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x28(%rbp)
cmpq $0x0, %rax
je 0x1531
movq -0x20(%rbp), %rdi
movq -0x28(%rbp), %rsi
callq 0x1540
movq %rax, -0x20(%rbp)
jmp 0x14cb
movq -0x20(%rbp), %rax
addq $0x40, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/plvhx[P]dummy-vm/src/ast.c
// Function: vm_ast_add_child
vm_ast_t *vm_ast_add_child(vm_ast_t *ast, vm_ast_t *child) {
  if (ast->num_childs >= ast->num_childs_alloc_size) {
    ast =
        vm_ast_realloc(ast, vm_ast_calculate_child(ast->num_childs_alloc_size),
                       vm_ast_calculate_child(ast->num_childs_alloc_size + 4));

    ast->num_childs_alloc_size += 4;
  }

  ast->childs[ast->num_childs++] = child;
  return ast;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq 0x20(%rax), %rax
movq -0x8(%rbp), %rcx
cmpq 0x28(%rcx), %rax
jb 0x15b0
movq -0x8(%rbp), %rax
movq %rax, -0x20(%rbp)
movq -0x8(%rbp), %rax
movq 0x28(%rax), %rdi
callq 0x13d0
movq %rax, -0x18(%rbp)
movq -0x8(%rbp), %rax
movq 0x28(%rax), %rdi
addq $0x4, %rdi
callq 0x13d0
movq -0x20(%rbp), %rdi
movq -0x18(%rbp), %rsi
movq %rax, %rdx
callq 0x15e0
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq 0x28(%rax), %rcx
addq $0x4, %rcx
movq %rcx, 0x28(%rax)
movq -0x10(%rbp), %rdx
movq -0x8(%rbp), %rax
movq -0x8(%rbp), %rsi
movq 0x20(%rsi), %rcx
movq %rcx, %rdi
addq $0x1, %rdi
movq %rdi, 0x20(%rsi)
movq %rdx, 0x30(%rax,%rcx,8)
movq -0x8(%rbp), %rax
addq $0x20, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/plvhx[P]dummy-vm/src/ast.c
// Function: vm_ast_realloc
static vm_ast_t *vm_ast_realloc(vm_ast_t *ast, size_t old_size,
                                size_t new_size) {
  assert(new_size > old_size);
  vm_ast_t *ret = realloc(ast, new_size);
  assert(ret != NULL);
  memset(ret + old_size, 0, new_size - old_size);
  return ret;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x18(%rbp), %rax
cmpq -0x10(%rbp), %rax
jbe 0x1600
jmp 0x161f
leaq 0x5a32(%rip), %rdi      # 0x7039
leaq 0x5a02(%rip), %rsi      # 0x7010
movl $0x13, %edx
leaq 0x5a33(%rip), %rcx      # 0x704d
callq 0x10b0
movq -0x8(%rbp), %rdi
movq -0x18(%rbp), %rsi
callq 0x1140
movq %rax, -0x20(%rbp)
cmpq $0x0, -0x20(%rbp)
je 0x1639
jmp 0x1658
leaq 0x59c4(%rip), %rdi      # 0x7004
leaq 0x59c9(%rip), %rsi      # 0x7010
movl $0x15, %edx
leaq 0x59fa(%rip), %rcx      # 0x704d
callq 0x10b0
movq -0x20(%rbp), %rdi
imulq $0x38, -0x10(%rbp), %rax
addq %rax, %rdi
movq -0x18(%rbp), %rdx
subq -0x10(%rbp), %rdx
xorl %esi, %esi
callq 0x10c0
movq -0x20(%rbp), %rax
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/plvhx[P]dummy-vm/src/ast.c
// Function: vm_ast_traverse
void vm_ast_traverse(vm_ast_t *ast, FILE *file,
                     void (*visitor)(FILE *file, int opcode)) {
  if (ast == NULL) {
    return;
  }

  if (ast->kind_type == VM_AST_INSTRUCTION_LINE) {
    vm_ast_process_instruction_line(ast, file, visitor);
  }

  for (int i = 0; i < ast->num_childs; i++) {
    vm_ast_traverse(ast->childs[i], file, visitor);
  }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
cmpq $0x0, -0x8(%rbp)
jne 0x169d
jmp 0x16f4
movq -0x8(%rbp), %rax
movzwl (%rax), %eax
cmpl $0x4, %eax
jne 0x16ba
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
movq -0x18(%rbp), %rdx
callq 0x1700
movl $0x0, -0x1c(%rbp)
movslq -0x1c(%rbp), %rax
movq -0x8(%rbp), %rcx
cmpq 0x20(%rcx), %rax
jae 0x16f4
movq -0x8(%rbp), %rax
movslq -0x1c(%rbp), %rcx
movq 0x30(%rax,%rcx,8), %rdi
movq -0x10(%rbp), %rsi
movq -0x18(%rbp), %rdx
callq 0x1680
movl -0x1c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x1c(%rbp)
jmp 0x16c1
addq $0x20, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/plvhx[P]dummy-vm/src/ast.c
// Function: vm_ast_dtor
void vm_ast_dtor(vm_ast_t *ast) {
  if (ast == NULL) {
    return;
  }

  for (int i = 0; i < ast->num_childs; i++) {
    vm_ast_dtor(ast->childs[i]);
  }

  free(ast);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
cmpq $0x0, -0x8(%rbp)
jne 0x1ca5
jmp 0x1ce0
movl $0x0, -0xc(%rbp)
movslq -0xc(%rbp), %rax
movq -0x8(%rbp), %rcx
cmpq 0x20(%rcx), %rax
jae 0x1cd7
movq -0x8(%rbp), %rax
movslq -0xc(%rbp), %rcx
movq 0x30(%rax,%rcx,8), %rdi
callq 0x1c90
movl -0xc(%rbp), %eax
addl $0x1, %eax
movl %eax, -0xc(%rbp)
jmp 0x1cac
movq -0x8(%rbp), %rdi
callq 0x1030
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/plvhx[P]dummy-vm/src/ast.c
// Function: vm_ast_process_binary_movb_imm8_to_regs_instruction
static void vm_ast_process_binary_movb_imm8_to_regs_instruction(
    vm_ast_t *ast, FILE *file, void (*visitor)(FILE *file, int opcode)) {
  if (VM_AST_GET_NUM_CHILDS(ast) != 3) {
    return;
  }

  if (!strcasecmp((const char *)VM_AST_GET_REGS_NAME(ast->childs[1]), "r0")) {
    visitor(file, VM_INSN_MOVB_IMM8_TO_R0);
  } else if (!strcasecmp((const char *)VM_AST_GET_REGS_NAME(ast->childs[1]),
                         "r1")) {
    visitor(file, VM_INSN_MOVB_IMM8_TO_R1);
  } else if (!strcasecmp((const char *)VM_AST_GET_REGS_NAME(ast->childs[1]),
                         "r2")) {
    visitor(file, VM_INSN_MOVB_IMM8_TO_R2);
  } else if (!strcasecmp((const char *)VM_AST_GET_REGS_NAME(ast->childs[1]),
                         "r3")) {
    visitor(file, VM_INSN_MOVB_IMM8_TO_R3);
  }

  unsigned int is_negated =
      VM_AST_GET_NUMBER_VAL(ast->childs[2])[0] == '-' ? 0xff : 0xfa;

  visitor(file, is_negated);
  visitor(file, is_negated == 0xfa
                    ? atoi((char *)VM_AST_GET_NUMBER_VAL(ast->childs[2]))
                    : atoi((char *)VM_AST_GET_NUMBER_VAL(ast->childs[2]) + 1));
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x8(%rbp), %rax
cmpq $0x3, 0x20(%rax)
je 0x3754
jmp 0x3896
movq -0x8(%rbp), %rax
movq 0x38(%rax), %rax
movq 0x8(%rax), %rdi
leaq 0x3934(%rip), %rsi      # 0x709b
callq 0x1040
cmpl $0x0, %eax
jne 0x3785
movq -0x18(%rbp), %rax
movq -0x10(%rbp), %rdi
movl $0x90, %esi
callq *%rax
jmp 0x3813
movq -0x8(%rbp), %rax
movq 0x38(%rax), %rax
movq 0x8(%rax), %rdi
leaq 0x3906(%rip), %rsi      # 0x709e
callq 0x1040
cmpl $0x0, %eax
jne 0x37b3
movq -0x18(%rbp), %rax
movq -0x10(%rbp), %rdi
movl $0x91, %esi
callq *%rax
jmp 0x3811
movq -0x8(%rbp), %rax
movq 0x38(%rax), %rax
movq 0x8(%rax), %rdi
leaq 0x38db(%rip), %rsi      # 0x70a1
callq 0x1040
cmpl $0x0, %eax
jne 0x37e1
movq -0x18(%rbp), %rax
movq -0x10(%rbp), %rdi
movl $0x92, %esi
callq *%rax
jmp 0x380f
movq -0x8(%rbp), %rax
movq 0x38(%rax), %rax
movq 0x8(%rax), %rdi
leaq 0x38b0(%rip), %rsi      # 0x70a4
callq 0x1040
cmpl $0x0, %eax
jne 0x380d
movq -0x18(%rbp), %rax
movq -0x10(%rbp), %rdi
movl $0x93, %esi
callq *%rax
jmp 0x380f
jmp 0x3811
jmp 0x3813
movq -0x8(%rbp), %rax
movq 0x40(%rax), %rax
movq 0x18(%rax), %rax
movzbl (%rax), %edx
movl $0xfa, %eax
movl $0xff, %ecx
cmpl $0x2d, %edx
cmovel %ecx, %eax
movl %eax, -0x1c(%rbp)
movq -0x18(%rbp), %rax
movq -0x10(%rbp), %rdi
movl -0x1c(%rbp), %esi
callq *%rax
movq -0x18(%rbp), %rax
movq %rax, -0x30(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x28(%rbp)
cmpl $0xfa, -0x1c(%rbp)
jne 0x3871
movq -0x8(%rbp), %rax
movq 0x40(%rax), %rax
movq 0x18(%rax), %rdi
callq 0x1170
movl %eax, -0x34(%rbp)
jmp 0x3889
movq -0x8(%rbp), %rax
movq 0x40(%rax), %rax
movq 0x18(%rax), %rdi
addq $0x1, %rdi
callq 0x1170
movl %eax, -0x34(%rbp)
movq -0x30(%rbp), %rax
movq -0x28(%rbp), %rdi
movl -0x34(%rbp), %esi
callq *%rax
addq $0x40, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/plvhx[P]dummy-vm/src/ast.c
// Function: vm_ast_process_binary_movb_regs_to_r0_instruction
static void vm_ast_process_binary_movb_regs_to_r0_instruction(
    vm_ast_t *ast, FILE *file, void (*visitor)(FILE *file, int opcode)) {
  if (VM_AST_GET_NUM_CHILDS(ast) != 3) {
    return;
  }

  if (!strcasecmp((const char *)VM_AST_GET_REGS_NAME(ast->childs[2]), "r0")) {
    visitor(file, VM_INSN_MOVB_R0_TO_R0);
  } else if (!strcasecmp((const char *)VM_AST_GET_REGS_NAME(ast->childs[2]),
                         "r1")) {
    visitor(file, VM_INSN_MOVB_R1_TO_R0);
  } else if (!strcasecmp((const char *)VM_AST_GET_REGS_NAME(ast->childs[2]),
                         "r2")) {
    visitor(file, VM_INSN_MOVB_R2_TO_R0);
  } else if (!strcasecmp((const char *)VM_AST_GET_REGS_NAME(ast->childs[2]),
                         "r3")) {
    visitor(file, VM_INSN_MOVB_R3_TO_R0);
  }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x8(%rbp), %rax
cmpq $0x3, 0x20(%rax)
je 0x38c4
jmp 0x3983
movq -0x8(%rbp), %rax
movq 0x40(%rax), %rax
movq 0x8(%rax), %rdi
leaq 0x37c4(%rip), %rsi      # 0x709b
callq 0x1040
cmpl $0x0, %eax
jne 0x38f5
movq -0x18(%rbp), %rax
movq -0x10(%rbp), %rdi
movl $0xa0, %esi
callq *%rax
jmp 0x3983
movq -0x8(%rbp), %rax
movq 0x40(%rax), %rax
movq 0x8(%rax), %rdi
leaq 0x3796(%rip), %rsi      # 0x709e
callq 0x1040
cmpl $0x0, %eax
jne 0x3923
movq -0x18(%rbp), %rax
movq -0x10(%rbp), %rdi
movl $0xa1, %esi
callq *%rax
jmp 0x3981
movq -0x8(%rbp), %rax
movq 0x40(%rax), %rax
movq 0x8(%rax), %rdi
leaq 0x376b(%rip), %rsi      # 0x70a1
callq 0x1040
cmpl $0x0, %eax
jne 0x3951
movq -0x18(%rbp), %rax
movq -0x10(%rbp), %rdi
movl $0xa2, %esi
callq *%rax
jmp 0x397f
movq -0x8(%rbp), %rax
movq 0x40(%rax), %rax
movq 0x8(%rax), %rdi
leaq 0x3740(%rip), %rsi      # 0x70a4
callq 0x1040
cmpl $0x0, %eax
jne 0x397d
movq -0x18(%rbp), %rax
movq -0x10(%rbp), %rdi
movl $0xa3, %esi
callq *%rax
jmp 0x397f
jmp 0x3981
jmp 0x3983
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/plvhx[P]dummy-vm/src/ast.c
// Function: vm_ast_process_binary_movb_regs_to_r1_instruction
static void vm_ast_process_binary_movb_regs_to_r1_instruction(
    vm_ast_t *ast, FILE *file, void (*visitor)(FILE *file, int opcode)) {
  if (VM_AST_GET_NUM_CHILDS(ast) != 3) {
    return;
  }

  if (!strcasecmp((const char *)VM_AST_GET_REGS_NAME(ast->childs[2]), "r0")) {
    visitor(file, VM_INSN_MOVB_R0_TO_R1);
  } else if (!strcasecmp((const char *)VM_AST_GET_REGS_NAME(ast->childs[2]),
                         "r1")) {
    visitor(file, VM_INSN_MOVB_R1_TO_R1);
  } else if (!strcasecmp((const char *)VM_AST_GET_REGS_NAME(ast->childs[2]),
                         "r2")) {
    visitor(file, VM_INSN_MOVB_R2_TO_R1);
  } else if (!strcasecmp((const char *)VM_AST_GET_REGS_NAME(ast->childs[2]),
                         "r3")) {
    visitor(file, VM_INSN_MOVB_R3_TO_R1);
  }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x8(%rbp), %rax
cmpq $0x3, 0x20(%rax)
je 0x39b4
jmp 0x3a73
movq -0x8(%rbp), %rax
movq 0x40(%rax), %rax
movq 0x8(%rax), %rdi
leaq 0x36d4(%rip), %rsi      # 0x709b
callq 0x1040
cmpl $0x0, %eax
jne 0x39e5
movq -0x18(%rbp), %rax
movq -0x10(%rbp), %rdi
movl $0xb0, %esi
callq *%rax
jmp 0x3a73
movq -0x8(%rbp), %rax
movq 0x40(%rax), %rax
movq 0x8(%rax), %rdi
leaq 0x36a6(%rip), %rsi      # 0x709e
callq 0x1040
cmpl $0x0, %eax
jne 0x3a13
movq -0x18(%rbp), %rax
movq -0x10(%rbp), %rdi
movl $0xb1, %esi
callq *%rax
jmp 0x3a71
movq -0x8(%rbp), %rax
movq 0x40(%rax), %rax
movq 0x8(%rax), %rdi
leaq 0x367b(%rip), %rsi      # 0x70a1
callq 0x1040
cmpl $0x0, %eax
jne 0x3a41
movq -0x18(%rbp), %rax
movq -0x10(%rbp), %rdi
movl $0xb2, %esi
callq *%rax
jmp 0x3a6f
movq -0x8(%rbp), %rax
movq 0x40(%rax), %rax
movq 0x8(%rax), %rdi
leaq 0x3650(%rip), %rsi      # 0x70a4
callq 0x1040
cmpl $0x0, %eax
jne 0x3a6d
movq -0x18(%rbp), %rax
movq -0x10(%rbp), %rdi
movl $0xb3, %esi
callq *%rax
jmp 0x3a6f
jmp 0x3a71
jmp 0x3a73
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/plvhx[P]dummy-vm/src/ast.c
// Function: vm_ast_process_binary_movb_regs_to_r2_instruction
static void vm_ast_process_binary_movb_regs_to_r2_instruction(
    vm_ast_t *ast, FILE *file, void (*visitor)(FILE *file, int opcode)) {
  if (VM_AST_GET_NUM_CHILDS(ast) != 3) {
    return;
  }

  if (!strcasecmp((const char *)VM_AST_GET_REGS_NAME(ast->childs[2]), "r0")) {
    visitor(file, VM_INSN_MOVB_R0_TO_R2);
  } else if (!strcasecmp((const char *)VM_AST_GET_REGS_NAME(ast->childs[2]),
                         "r1")) {
    visitor(file, VM_INSN_MOVB_R1_TO_R2);
  } else if (!strcasecmp((const char *)VM_AST_GET_REGS_NAME(ast->childs[2]),
                         "r2")) {
    visitor(file, VM_INSN_MOVB_R2_TO_R2);
  } else if (!strcasecmp((const char *)VM_AST_GET_REGS_NAME(ast->childs[2]),
                         "r3")) {
    visitor(file, VM_INSN_MOVB_R3_TO_R2);
  }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x8(%rbp), %rax
cmpq $0x3, 0x20(%rax)
je 0x3aa4
jmp 0x3b63
movq -0x8(%rbp), %rax
movq 0x40(%rax), %rax
movq 0x8(%rax), %rdi
leaq 0x35e4(%rip), %rsi      # 0x709b
callq 0x1040
cmpl $0x0, %eax
jne 0x3ad5
movq -0x18(%rbp), %rax
movq -0x10(%rbp), %rdi
movl $0xc0, %esi
callq *%rax
jmp 0x3b63
movq -0x8(%rbp), %rax
movq 0x40(%rax), %rax
movq 0x8(%rax), %rdi
leaq 0x35b6(%rip), %rsi      # 0x709e
callq 0x1040
cmpl $0x0, %eax
jne 0x3b03
movq -0x18(%rbp), %rax
movq -0x10(%rbp), %rdi
movl $0xc1, %esi
callq *%rax
jmp 0x3b61
movq -0x8(%rbp), %rax
movq 0x40(%rax), %rax
movq 0x8(%rax), %rdi
leaq 0x358b(%rip), %rsi      # 0x70a1
callq 0x1040
cmpl $0x0, %eax
jne 0x3b31
movq -0x18(%rbp), %rax
movq -0x10(%rbp), %rdi
movl $0xc2, %esi
callq *%rax
jmp 0x3b5f
movq -0x8(%rbp), %rax
movq 0x40(%rax), %rax
movq 0x8(%rax), %rdi
leaq 0x3560(%rip), %rsi      # 0x70a4
callq 0x1040
cmpl $0x0, %eax
jne 0x3b5d
movq -0x18(%rbp), %rax
movq -0x10(%rbp), %rdi
movl $0xc3, %esi
callq *%rax
jmp 0x3b5f
jmp 0x3b61
jmp 0x3b63
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/plvhx[P]dummy-vm/src/ast.c
// Function: vm_ast_process_binary_movb_regs_to_r3_instruction
static void vm_ast_process_binary_movb_regs_to_r3_instruction(
    vm_ast_t *ast, FILE *file, void (*visitor)(FILE *file, int opcode)) {
  if (VM_AST_GET_NUM_CHILDS(ast) != 3) {
    return;
  }

  if (!strcasecmp((const char *)VM_AST_GET_REGS_NAME(ast->childs[2]), "r0")) {
    visitor(file, VM_INSN_MOVB_R0_TO_R3);
  } else if (!strcasecmp((const char *)VM_AST_GET_REGS_NAME(ast->childs[2]),
                         "r1")) {
    visitor(file, VM_INSN_MOVB_R1_TO_R3);
  } else if (!strcasecmp((const char *)VM_AST_GET_REGS_NAME(ast->childs[2]),
                         "r2")) {
    visitor(file, VM_INSN_MOVB_R2_TO_R3);
  } else if (!strcasecmp((const char *)VM_AST_GET_REGS_NAME(ast->childs[2]),
                         "r3")) {
    visitor(file, VM_INSN_MOVB_R3_TO_R3);
  }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x8(%rbp), %rax
cmpq $0x3, 0x20(%rax)
je 0x3b94
jmp 0x3c53
movq -0x8(%rbp), %rax
movq 0x40(%rax), %rax
movq 0x8(%rax), %rdi
leaq 0x34f4(%rip), %rsi      # 0x709b
callq 0x1040
cmpl $0x0, %eax
jne 0x3bc5
movq -0x18(%rbp), %rax
movq -0x10(%rbp), %rdi
movl $0xd0, %esi
callq *%rax
jmp 0x3c53
movq -0x8(%rbp), %rax
movq 0x40(%rax), %rax
movq 0x8(%rax), %rdi
leaq 0x34c6(%rip), %rsi      # 0x709e
callq 0x1040
cmpl $0x0, %eax
jne 0x3bf3
movq -0x18(%rbp), %rax
movq -0x10(%rbp), %rdi
movl $0xd1, %esi
callq *%rax
jmp 0x3c51
movq -0x8(%rbp), %rax
movq 0x40(%rax), %rax
movq 0x8(%rax), %rdi
leaq 0x349b(%rip), %rsi      # 0x70a1
callq 0x1040
cmpl $0x0, %eax
jne 0x3c21
movq -0x18(%rbp), %rax
movq -0x10(%rbp), %rdi
movl $0xd2, %esi
callq *%rax
jmp 0x3c4f
movq -0x8(%rbp), %rax
movq 0x40(%rax), %rax
movq 0x8(%rax), %rdi
leaq 0x3470(%rip), %rsi      # 0x70a4
callq 0x1040
cmpl $0x0, %eax
jne 0x3c4d
movq -0x18(%rbp), %rax
movq -0x10(%rbp), %rdi
movl $0xd3, %esi
callq *%rax
jmp 0x3c4f
jmp 0x3c51
jmp 0x3c53
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/plvhx[P]dummy-vm/src/ast.c
// Function: vm_ast_process_unary_print_imm8_instruction
static void vm_ast_process_unary_print_imm8_instruction(
    vm_ast_t *ast, FILE *file, void (*visitor)(FILE *file, int opcode)) {
  if (VM_AST_GET_NUM_CHILDS(ast) != 2) {
    return;
  }

  visitor(file, VM_INSN_PRINT_IMM8);

  unsigned int is_negated =
      VM_AST_GET_NUMBER_VAL(ast->childs[1])[0] == '-' ? 0xff : 0xfa;

  visitor(file, is_negated);
  visitor(file, is_negated == 0xfa
                    ? atoi((char *)VM_AST_GET_NUMBER_VAL(ast->childs[1]))
                    : atoi((char *)VM_AST_GET_NUMBER_VAL(ast->childs[1]) + 1));
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x8(%rbp), %rax
cmpq $0x2, 0x20(%rax)
je 0x3c84
jmp 0x3d16
movq -0x18(%rbp), %rax
movq -0x10(%rbp), %rdi
movl $0x20, %esi
callq *%rax
movq -0x8(%rbp), %rax
movq 0x38(%rax), %rax
movq 0x18(%rax), %rax
movzbl (%rax), %edx
movl $0xfa, %eax
movl $0xff, %ecx
cmpl $0x2d, %edx
cmovel %ecx, %eax
movl %eax, -0x1c(%rbp)
movq -0x18(%rbp), %rax
movq -0x10(%rbp), %rdi
movl -0x1c(%rbp), %esi
callq *%rax
movq -0x18(%rbp), %rax
movq %rax, -0x30(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x28(%rbp)
cmpl $0xfa, -0x1c(%rbp)
jne 0x3cf1
movq -0x8(%rbp), %rax
movq 0x38(%rax), %rax
movq 0x18(%rax), %rdi
callq 0x1170
movl %eax, -0x34(%rbp)
jmp 0x3d09
movq -0x8(%rbp), %rax
movq 0x38(%rax), %rax
movq 0x18(%rax), %rdi
addq $0x1, %rdi
callq 0x1170
movl %eax, -0x34(%rbp)
movq -0x30(%rbp), %rax
movq -0x28(%rbp), %rdi
movl -0x34(%rbp), %esi
callq *%rax
addq $0x40, %rsp
popq %rbp
retq
nopl (%rax)