LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O3/mishun[P]plantri/fullgen.c
// Function: longcode
int longcode( PLANMAP map, FLAECHENTYP *codeF )
{
/* Codiert die Einbettung in codeF und gibt die laenge des codes zurueck */
int i,zaehler;
KANTE *merke, *lauf;

if (map[0][0].name <= FL_MAX)
{
zaehler=1;
codeF[0]=map[0][0].name;
for(i=1;i<=map[0][0].name;i++)
    { merke=map[i]; codeF[zaehler]=merke->name; zaehler++;
      for(lauf=merke->next; lauf!=merke; lauf=lauf->next) 
	           { codeF[zaehler]=lauf->name; zaehler++; }
      codeF[zaehler]=0; zaehler++; }
}
else /* zu viele knoten fuer FLAECHENTYP */
{
zaehler=1;
codeF[0]=0;
TWOBYTES(map[0][0].name);
for(i=1;i<=map[0][0].name;i++)
    { merke=map[i]; TWOBYTES(merke->name)
      for(lauf=merke->next; lauf!=merke; lauf=lauf->next) TWOBYTES(lauf->name);
      TWOBYTES(0);}
}
return(zaehler);
}

// Assembly:
pushq %rbp
pushq %r14
pushq %rbx
movzwl 0x2(%rdi), %eax
cmpl $0xff, %eax
ja 0x3446
movb %al, (%rsi)
cmpw $0x0, 0x2(%rdi)
je 0x3510
movl $0x1, %eax
movl $0x1, %ecx
leaq (%rcx,%rcx,8), %r8
shlq $0x4, %r8
leaq (%rdi,%r8), %rdx
movb 0x2(%rdi,%r8), %r10b
movslq %eax, %r9
movb %r10b, (%rsi,%r9)
movq 0x20(%rdi,%r8), %r8
incl %r9d
cmpq %rdx, %r8
je 0x3426
movslq %r9d, %r9
addq %rsi, %r9
movb 0x2(%r8), %r10b
movb %r10b, (%r9)
movq 0x20(%r8), %r8
incl %eax
incq %r9
cmpq %rdx, %r8
jne 0x340d
leal 0x1(%rax), %r9d
movslq %r9d, %rdx
movb $0x0, (%rsi,%rdx)
addl $0x2, %eax
leaq 0x1(%rcx), %rdx
movzwl 0x2(%rdi), %r8d
cmpq %r8, %rcx
movq %rdx, %rcx
jb 0x33e2
jmp 0x351c
movb $0x0, (%rsi)
movb 0x2(%rdi), %al
movb %al, 0x1(%rsi)
movb 0x3(%rdi), %al
movb %al, 0x2(%rsi)
cmpw $0x0, 0x2(%rdi)
je 0x3517
movl $0x3, %eax
movl $0x1, %edx
xorl %ecx, %ecx
movabsq $-0x200000000, %r8      # imm = 0xFFFFFFFE00000000
movabsq $0x200000000, %r9       # imm = 0x200000000
leaq (%rdx,%rdx,8), %rbx
shlq $0x4, %rbx
leaq (%rdi,%rbx), %r11
movb 0x2(%rdi,%rbx), %bpl
movslq %eax, %r10
movb %bpl, (%rsi,%r10)
movb 0x3(%rdi,%rbx), %bpl
movb %bpl, 0x1(%rsi,%r10)
movq 0x20(%rdi,%rbx), %rbx
leal 0x2(%r10), %ebp
cmpq %r11, %rbx
je 0x34ea
movslq %ebp, %r10
leaq (%rsi,%r10), %r14
shlq $0x20, %r10
addq %r8, %r10
addq %r9, %r10
movb 0x2(%rbx), %bpl
movb %bpl, (%r14)
movb 0x3(%rbx), %bpl
cltq
movb %bpl, 0x3(%rsi,%rax)
movq 0x20(%rbx), %rbx
addl $0x2, %eax
addq $0x2, %r14
cmpq %r11, %rbx
jne 0x34be
leal 0x2(%rax), %ebp
sarq $0x20, %r10
movslq %ebp, %r11
movb %cl, (%rsi,%r11)
movb %cl, 0x3(%rsi,%r10)
addl $0x4, %eax
leaq 0x1(%rdx), %r10
movzwl 0x2(%rdi), %r11d
cmpq %r11, %rdx
movq %r10, %rdx
jb 0x3480
jmp 0x351c
movl $0x1, %eax
jmp 0x351c
movl $0x3, %eax
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/mishun[P]plantri/fullgen.c
// Function: spiralstatistic
void spiralstatistic(PLANMAP map)

/* berechnet die Statistik, wieviele Spiralen es gibt */

{ int zaehler=0, i,j, mark, sixgons;
  FLAECHENTYP code[12];


/*schreibemap(map);*/

sixgons= (map[0][0].name - 20)/2;

for (i=1; i<=map[0][0].name; i++)
  for (j=0; j<3; j++) { map[i][j].dummy=map[i][j].mininame=0; }
for (i=0; i<12; i++) code[i]=FL_MAX;

mark=1;

for (i=1; (i<=map[0][0].name); i++) 
  for (j=0; j<3; j++)
      { code[0]=FL_MAX; 
	if (get_spiralcode ( map[i]+j, mark, code, sixgons)) zaehler++; 
	/*else fprintf(stderr,"no %d %d \n",i,map[i][j].name);*/
	mark++;
	code[0]=FL_MAX;
	if (get_spiralcode_inv ( map[i]+j, mark, code, sixgons)) zaehler++; 
	/*else fprintf(stderr,"no inv %d %d \n",i,map[i][j].name); */
        mark++;}

spiralnumbers[zaehler]++;

}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x38, %rsp
movzwl 0x2(%rdi), %eax
testl %eax, %eax
je 0x3c89
leal -0x14(%rax), %ecx
shrl $0x1f, %ecx
leal (%rax,%rcx), %r9d
addl $-0x14, %r9d
sarl %r9d
leaq 0x1(%rax), %rcx
leaq 0xa4(%rdi), %rdx
movl $0x1, %esi
xorl %r8d, %r8d
movw $0x0, (%rdx,%r8)
movq $0x0, -0xc(%rdx,%r8)
addq $0x30, %r8
cmpq $0x90, %r8
jne 0x3b6a
incq %rsi
addq $0x90, %rdx
cmpq %rcx, %rsi
jne 0x3b67
xorl %r12d, %r12d
movl $0xffffffff, 0x1c(%rsp) # imm = 0xFFFFFFFF
movq $-0x1, 0x15(%rsp)
testq %rax, %rax
je 0x3c8c
movl %r9d, 0x10(%rsp)
leaq 0x90(%rdi), %r15
movl $0x1, %eax
movq %rax, 0x8(%rsp)
movl $0x1, %eax
movb $-0x1, %r8b
leaq 0x14(%rsp), %rbp
movq %rdi, 0x20(%rsp)
movl 0x10(%rsp), %ebx
movq %rax, 0x28(%rsp)
movq 0x8(%rsp), %rax
movl %eax, %eax
movq %rax, 0x8(%rsp)
xorl %r13d, %r13d
movq %r15, 0x30(%rsp)
movq 0x8(%rsp), %rax
leal (%rax,%r13), %esi
movb %r8b, 0x14(%rsp)
movq %r15, %rdi
movq %rbp, %rdx
movl %ebx, %ecx
callq 0x2c42
movzbl %al, %r14d
addl %r12d, %r14d
movb $-0x1, %al
movb %al, 0x14(%rsp)
movq 0x8(%rsp), %rax
leal (%rax,%r13), %esi
incl %esi
movq %r15, %rdi
movq %rbp, %rdx
movl %ebx, %ecx
callq 0x2d87
movb $-0x1, %r8b
movzbl %al, %r12d
addl %r14d, %r12d
addq $0x30, %r15
addq $0x2, %r13
cmpq $0x6, %r13
jne 0x3bf8
movq 0x28(%rsp), %r9
leaq 0x1(%r9), %rax
movq 0x20(%rsp), %rdi
movzwl 0x2(%rdi), %ecx
movq 0x30(%rsp), %r15
addq $0x90, %r15
movq 0x8(%rsp), %rsi
addl %r13d, %esi
movq %rsi, 0x8(%rsp)
cmpq %rcx, %r9
jb 0x3bdf
movslq %r12d, %r12
jmp 0x3c8c
xorl %r12d, %r12d
leaq 0x1195d(%rip), %rax     # 0x155f0
incl (%rax,%r12,4)
addq $0x38, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/mishun[P]plantri/fullgen.c
// Function: in_liste
void in_liste(FLAECHENTYP *code, LISTENTRY *el)
/* schreibt code in die liste */
{ int compare;
  int n;


if (el->code[0]==0)
    { 
      for (n=0; n<12; n++) (el->code)[n]= code[n];
      el->smaller=(LISTENTRY *)malloc(sizeof(LISTENTRY));
         (el->smaller->code)[0]=0;
      el->larger=(LISTENTRY *)malloc(sizeof(LISTENTRY));
         (el->larger->code)[0]=0;
      if ((el->smaller==nil) || (el->larger==nil)) 
	{ fprintf(stderr,"Cannot allocate memory in \"in_liste\" \n");
						     exit(1); }
    }

else { 
       compare=codecmp(code,el->code,12);
        if (compare<0) in_liste(code,el->smaller);
                else if (compare>0) in_liste(code,el->larger);
                   else { fprintf(stderr,"Dangerous error -- Two equal codes ! \n"); exit(2); }
     }
}

// Assembly:
pushq %rbp
pushq %rbx
pushq %rax
movq %rsi, %rbx
movb (%rsi), %cl
testb %cl, %cl
je 0x3d7b
movb (%rdi), %al
movl %eax, %edx
cmpb %cl, %al
jne 0x3d61
movl $0x1, %esi
movb (%rdi,%rsi), %dl
movb (%rbx,%rsi), %cl
cmpb %cl, %dl
jne 0x3d61
leaq 0x1(%rsi), %r8
cmpl $0xb, %esi
movq %r8, %rsi
jne 0x3d4b
movl $0x10, %esi
cmpb %cl, %dl
jb 0x3d71
movl $0x18, %esi
je 0x3db7
movq (%rbx,%rsi), %rbx
movb (%rbx), %cl
testb %cl, %cl
jne 0x3d40
xorl %eax, %eax
movb (%rdi,%rax), %cl
movb %cl, (%rbx,%rax)
incq %rax
cmpq $0xc, %rax
jne 0x3d7d
movl $0x20, %edi
callq 0x10e0
movq %rax, 0x10(%rbx)
xorl %ebp, %ebp
movb %bpl, (%rax)
movl $0x20, %edi
callq 0x10e0
movq %rax, 0x18(%rbx)
movb %bpl, (%rax)
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
callq 0x12ea
// File: /workspace/github_c_makefile_star2_O3/mishun[P]plantri/fullgen.c
// Function: ausgabe
void ausgabe(LISTENTRY *liste,int knotenzahl,FLAECHENTYP **lastcode)

{ 
FLAECHENTYP i;

if ((liste->code)[0]==0) return;
ausgabe(liste->smaller,knotenzahl,lastcode);

for (i=0; (liste->code)[i]==(*lastcode)[i]; i++);
fwrite(&i,sizeof(FLAECHENTYP),1,fil[knotenzahl]);
fwrite((liste->code)+i,sizeof(FLAECHENTYP),12-i,fil[knotenzahl]);
*lastcode=liste->code;

ausgabe(liste->larger,knotenzahl,lastcode);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movl %esi, 0x4(%rsp)
cmpb $0x0, (%rdi)
je 0x3e3d
movq %rdx, %rbx
movq %rdi, %r14
movslq 0x4(%rsp), %r12
leaq 0x1343e(%rip), %r13     # 0x17220
movq 0x10(%r14), %rdi
movl 0x4(%rsp), %esi
movq %rbx, %rdx
callq 0x3dbc
movq (%rbx), %rcx
movb $-0x1, %al
incb %al
movzbl %al, %ebp
movb (%r14,%rbp), %dl
cmpb (%rcx,%rbp), %dl
je 0x3df7
leaq (%r14,%rbp), %r15
movq (%r13,%r12,8), %rsi
movsbl %al, %edi
callq 0x1090
movl $0xc, %edx
subq %rbp, %rdx
movq (%r13,%r12,8), %rcx
movl $0x1, %esi
movq %r15, %rdi
callq 0x1180
movq %r14, (%rbx)
movq 0x18(%r14), %r14
cmpb $0x0, (%r14)
jne 0x3de2
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/mishun[P]plantri/fullgen.c
// Function: sequenz_kanonisch
int sequenz_kanonisch( int sequenz[] )
/* checkt, ob eine sequenz kanonisch ist, gibt 1 zurueck wenn ja, 0 sonst */

{ int i,j, laenge, max;
  int longseq[14];


  max=sequenz[0]; j=1; /* j hier nur als merker */
  for (i=0; sequenz[i] != leer; i++) { longseq[i]=sequenz[i];
				       if (longseq[i]==max) j=0;
				         else if (longseq[i]>max) { return(0); }
				     }
  if (j) return(1); /* der erste ist eindeutig, also die ganze sequenz */

  laenge=i;
  for (j=0; j<laenge; i++, j++) longseq[i]=sequenz[j];

for (j=1; j<laenge; i++, j++)
    if (longseq[j]==max)
	{ for (i=1; (i<laenge) && (longseq[j+i]==sequenz[i]) ; i++);
	  if (longseq[j+i]>sequenz[i]) 
                        { return(0); }
        }
return(1);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
subq $0x38, %rsp
movl (%rdi), %ebp
movl $0x1, %ebx
cmpl $0xfffe, %ebp           # imm = 0xFFFE
je 0x497b
movq %rdi, %r14
xorl %r15d, %r15d
movl %ebp, %ecx
xorl %eax, %eax
incq %r15
movl %ecx, -0x4(%rsp,%r15,4)
cmpl %ebp, %ecx
je 0x48fd
jg 0x4979
movl (%r14,%r15,4), %ecx
incq %r15
cmpl $0xfffe, %ecx           # imm = 0xFFFE
jne 0x48dd
jmp 0x490d
movl (%r14,%r15,4), %ecx
movb $0x1, %al
cmpl $0xfffe, %ecx           # imm = 0xFFFE
jne 0x48da
jmp 0x4914
testb $0x1, %al
je 0x497b
decq %r15
movl %r15d, %edx
shlq $0x2, %rdx
leaq (%rsp,%rdx), %rdi
movq %r14, %rsi
callq 0x10d0
testl $0xfffffffe, %r15d      # imm = 0xFFFFFFFE
je 0x497b
movl %r15d, %eax
movl $0x1, %ecx
leaq 0x8(%rsp), %rdx
cmpl %ebp, (%rsp,%rcx,4)
jne 0x496b
movl $0x1, %esi
movl -0x4(%rdx,%rsi,4), %edi
cmpl (%r14,%rsi,4), %edi
jne 0x495c
incq %rsi
cmpq %rsi, %rax
jne 0x4947
movq %r15, %rsi
movl %esi, %esi
leaq (%rcx,%rsi), %rdi
movl (%rsp,%rdi,4), %edi
cmpl (%r14,%rsi,4), %edi
jg 0x4979
incq %rcx
addq $0x4, %rdx
cmpq %rax, %rcx
jne 0x493d
jmp 0x497b
xorl %ebx, %ebx
movl %ebx, %eax
addq $0x38, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/mishun[P]plantri/fullgen.c
// Function: bbitemalloc
BBITEMLISTE *bbitemalloc()
/* gibt immer die Adresse eines neuen bbitems zurueck */
{
static BBITEMLISTE *back=nil; /* back enthaelt immer den letzten, der zurueckgegeben 
			       wurde -- erst hochsetzen -- wichtig */
static BBITEMLISTE *last=nil;

if (back==last) { back=(BBITEMLISTE *)malloc(sizeof(BBITEMLISTE)*1001);
		  if (back==NULL) { fprintf(stderr,"Can not get more memory for bbitems"); exit(11); }
		  last=back+1000;
		  return(back); }

/* else */
back++;
return(back);
}

// Assembly:
pushq %rax
movq 0x1a66d(%rip), %rax     # 0x1fb30
cmpq 0x1a66e(%rip), %rax     # 0x1fb38
je 0x54d9
addq $0x10, %rax
movq %rax, 0x1a659(%rip)     # 0x1fb30
jmp 0x5500
movl $0x3e90, %edi           # imm = 0x3E90
callq 0x10e0
movq %rax, 0x1a646(%rip)     # 0x1fb30
testq %rax, %rax
je 0x5502
movq %rax, %rcx
addq $0x3e80, %rcx           # imm = 0x3E80
movq %rcx, 0x1a638(%rip)     # 0x1fb38
popq %rcx
retq
callq 0x15bb
// File: /workspace/github_c_makefile_star2_O3/mishun[P]plantri/fullgen.c
// Function: itemalloc
ITEMLISTE *itemalloc()
/* gibt immer die Adresse eines neuen items zurueck */
{
static ITEMLISTE *back=nil; /* back enthaelt immer den letzten, der zurueckgegeben 
			       wurde -- erst hochsetzen -- wichtig */
static ITEMLISTE *last=nil;

if (back==last) { back=(ITEMLISTE *)malloc(sizeof(ITEMLISTE)*1001);
		  if (back==NULL) { fprintf(stderr,"Can not get more memory for items"); exit(12); }
		  last=back+1000;
		  return(back); }

/* else */
back++;
return(back);
}

// Assembly:
pushq %rax
movq 0x1a631(%rip), %rax     # 0x1fb40
cmpq 0x1a632(%rip), %rax     # 0x1fb48
je 0x5525
addq $0x10, %rax
movq %rax, 0x1a61d(%rip)     # 0x1fb40
jmp 0x554c
movl $0x3e90, %edi           # imm = 0x3E90
callq 0x10e0
movq %rax, 0x1a60a(%rip)     # 0x1fb40
testq %rax, %rax
je 0x554e
movq %rax, %rcx
addq $0x3e80, %rcx           # imm = 0x3E80
movq %rcx, 0x1a5fc(%rip)     # 0x1fb48
popq %rcx
retq
callq 0x15e0
// File: /workspace/github_c_makefile_star2_O3/mishun[P]plantri/fullgen.c
// Function: put_in_bb_liste
void put_in_bb_liste(int sechsecke, SEQUENZ sq, FLAECHENTYP *code)
{

BBITEMLISTE *item, **puffer, *merke;
BBSEQUENZLISTE *anfang;
int j, s_eintrag;

/*schreibesequenz(sq);*/
/*schreibelistitems();*/



anfang=bbliste.sechser[sechsecke];
s_eintrag=sq.sequenz[0];
if (anfang->number_next <= s_eintrag)
  { puffer=anfang->items;
    anfang->items=(BBITEMLISTE **)malloc((s_eintrag+1)*sizeof(BBITEMLISTE *));
    if (anfang->items==NULL) { fprintf(stderr,"Can not get more memory"); exit(15); }
    for (j=0; j< anfang->number_next; j++) { anfang->items[j]=puffer[j]; }
    for (   ; j <= s_eintrag; j++) { anfang->items[j]=nil; }
    anfang->number_next=s_eintrag+1;
    free(puffer);
  }

bbliste.total_items++;
bbliste.total_maps += code[1];

if (anfang->items[s_eintrag]==nil) { item=anfang->items[s_eintrag]=bbitemalloc(); 
			              item->next_item=nil; }
   else { merke=anfang->items[s_eintrag];
	  item=anfang->items[s_eintrag]=bbitemalloc();
	  item->next_item=merke; }
if (item==NULL) { fprintf(stderr,"Can not get more memory"); exit(16); }
for (j=0; j<8; j++) item->code[j]=code[j];

}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rsi, %rbx
movslq %edi, %rax
leaq 0x1a8d5(%rip), %rcx     # 0x1ffc0
movq 0x8(%rcx,%rax,8), %r15
movslq 0x44(%rsp), %r12
movl (%r15), %r13d
cmpl %r12d, %r13d
jg 0x5768
movq 0x8(%r15), %r14
leal 0x1(%r12), %ebp
movslq %ebp, %rdi
shlq $0x3, %rdi
callq 0x10e0
movq %rax, 0x8(%r15)
testq %rax, %rax
je 0x57b1
testl %r13d, %r13d
jle 0x573c
xorl %eax, %eax
movq (%r14,%rax,8), %rcx
movq 0x8(%r15), %rdx
movq %rcx, (%rdx,%rax,8)
incq %rax
cmpq %rax, %r13
jne 0x5726
jmp 0x573f
xorl %r13d, %r13d
cmpl %r12d, %r13d
jg 0x575d
movl %r13d, %eax
movl %ebp, %ecx
movq 0x8(%r15), %rdx
movq $0x0, (%rdx,%rax,8)
incq %rax
cmpq %rax, %rcx
jne 0x5749
movl %ebp, (%r15)
movq %r14, %rdi
callq 0x1030
incl 0x1a852(%rip)           # 0x1ffc0
movzbl 0x1(%rbx), %eax
addl %eax, 0x1a84c(%rip)     # 0x1ffc4
movq 0x8(%r15), %rax
movq (%rax,%r12,8), %r14
callq 0x54bb
movq 0x8(%r15), %rcx
movq %rax, (%rcx,%r12,8)
movq %r14, (%rax)
xorl %ecx, %ecx
movb (%rbx,%rcx), %dl
movb %dl, 0x8(%rax,%rcx)
incq %rcx
cmpq $0x8, %rcx
jne 0x5792
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
callq 0x164f
// File: /workspace/github_c_makefile_star2_O3/mishun[P]plantri/fullgen.c
// Function: check_mark_und_schreibe
void check_mark_und_schreibe(PLANMAP map, KANTE *first, int laenge, int rest_sechsecke)
{


SEQUENZ localsq;
int sechsecke;
FLAECHENTYP code[8];

if (!do_bauchbinde) return;
if (IPR && (!is_ipr))  return; 

localsq.laenge=0; localsq.sequenz[0]=laenge;
localsq.kanten[0]=first;

sechsecke=((map[0][0].name)-10-laenge)/2;
               /* leicht aus Euler Formel */

if (sechsecke+rest_sechsecke != max_sechsecke) 
  { fprintf(stderr,"Error in 6-gon calculation (check_mark_und_schreibe) !\n");
						 exit(18); }

if (!codiere(map, code, first, 8, laenge)) return; /* nicht kanonisch */
if (code[0] !=0) { fprintf(stderr," there was a hexagon ring.......\n"); exit(19); }
put_in_bb_liste(sechsecke, localsq, code);

bblmark[laenge]=1;

/* neue ringe hinzufuegen */
while (rest_sechsecke >= laenge)
  { 
    rest_sechsecke -= laenge;
    sechsecke+= laenge;
    (code[0])++;
    put_in_bb_liste(sechsecke, localsq, code);
  }

return;

}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0xc8, %rsp
cmpb $0x0, 0x1afa9(%rip)     # 0x208dc
je 0x5a1d
movl %ecx, %ebx
movl %edx, %ebp
movq %rsi, %rdx
cmpb $0x0, 0xf84a(%rip)      # 0x15191
je 0x5956
cmpb $0x0, 0xf814(%rip)      # 0x15164
je 0x5a1d
movl $0x0, 0x68(%rsp)
movl %ebp, 0x6c(%rsp)
movq %rdx, 0x88(%rsp)
movzwl 0x2(%rdi), %eax
subl %ebp, %eax
movl %eax, %ecx
addl $-0xa, %ecx
shrl $0x1f, %ecx
leal (%rax,%rcx), %r14d
addl $-0xa, %r14d
sarl %r14d
leal (%r14,%rbx), %eax
cmpl 0x1af4b(%rip), %eax     # 0x208d8
jne 0x5a2f
leaq 0x60(%rsp), %rsi
movl $0x8, %ecx
movl %ebp, %r8d
callq 0x5177
testl %eax, %eax
je 0x5a1d
cmpb $0x0, 0x60(%rsp)
jne 0x5a34
leaq 0x68(%rsp), %rsi
movl $0xc, %ecx
movq %rsp, %rdi
rep  movsq (%rsi), %es:(%rdi)
leaq 0x60(%rsp), %rsi
movl %r14d, %edi
callq 0x56d3
movslq %ebp, %rax
leaq 0x1af05(%rip), %rcx     # 0x208e0
movb $0x1, (%rax,%rcx)
cmpl %ebp, %ebx
jl 0x5a1d
addl %ebp, %r14d
movb $0x1, %r13b
leaq 0x68(%rsp), %r15
leaq 0x60(%rsp), %r12
subl %ebp, %ebx
movb %r13b, 0x60(%rsp)
movl $0xc, %ecx
movq %rsp, %rdi
movq %r15, %rsi
rep  movsq (%rsi), %es:(%rdi)
movl %r14d, %edi
movq %r12, %rsi
callq 0x56d3
addl %ebp, %r14d
incb %r13b
cmpl %ebp, %ebx
jge 0x59f3
addq $0xc8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
callq 0x1699
callq 0x16be
// File: /workspace/github_c_makefile_star2_O3/mishun[P]plantri/fullgen.c
// Function: initialize_list
void initialize_list()
{
int j;
SEQUENZLISTE *qq;
BBSEQUENZLISTE *bbqq;

mapliste.total_maps=0;

for (j=0; j<=max_sechsecke; j++)
  {
    qq=(mapliste.sechser)[j]=(SEQUENZLISTE *)malloc(sizeof(SEQUENZLISTE));
    if (qq==NULL) { fprintf(stderr,"Can not get more memory"); exit(27); }
    qq->next_level=nil;
    qq->number_next=0;
    qq->items=qq->last_item=nil;
  }


bbliste.total_items=bbliste.total_maps=0;
for (j=0; j<=max_sechsecke; j++)
  {
    bbqq=(bbliste.sechser)[j]=(BBSEQUENZLISTE *)malloc(sizeof(BBSEQUENZLISTE));
    if (bbqq==NULL) { fprintf(stderr,"Can not get more memory"); exit(28); }
    bbqq->items=nil;
    bbqq->number_next=0;
  }




}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movl $0x0, 0x18eab(%rip)     # 0x1fb50
movl 0x19c2c(%rip), %r14d    # 0x208d8
testl %r14d, %r14d
js 0x6d3c
movq %r14, %rbx
incq %rbx
xorl %r15d, %r15d
leaq 0x18e8b(%rip), %r12     # 0x1fb50
movl $0x20, %edi
callq 0x10e0
movq %rax, 0x8(%r12,%r15,8)
testq %rax, %rax
je 0x6d53
movq $0x0, (%rax)
movl $0x0, 0x8(%rax)
incq %r15
xorps %xmm0, %xmm0
movups %xmm0, 0x10(%rax)
cmpq %r15, %rbx
jne 0x6cc5
movq $0x0, 0x192bf(%rip) # 0x1ffc0
testl %r14d, %r14d
js 0x6d47
xorl %r14d, %r14d
leaq 0x192b0(%rip), %r15     # 0x1ffc0
movl $0x10, %edi
callq 0x10e0
movq %rax, 0x8(%r15,%r14,8)
testq %rax, %rax
je 0x6d58
movq $0x0, 0x8(%rax)
movl $0x0, (%rax)
incq %r14
cmpq %r14, %rbx
jne 0x6d10
jmp 0x6d47
movq $0x0, 0x19279(%rip) # 0x1ffc0
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
callq 0x172d
callq 0x1708
// File: /workspace/github_c_makefile_star2_O3/mishun[P]plantri/fullgen.c
// Function: zaehle_knoten
void zaehle_knoten(PLANMAP map, KNOTENTYP knoten, BOOL mark[], int *patchknz)

/* zaehlt die knoten, belegt aber auch dummy */

{
int j;

for (j=0; j<3; j++) 
  if (map[knoten][j].mininame == aussen) map[knoten][j].dummy=infty;
   else { map[knoten][j].dummy=0;
	  if (!mark[map[knoten][j].mininame])
	    { (*patchknz)++;
	      mark[map[knoten][j].mininame]=1;
	      zaehle_knoten(map,map[knoten][j].mininame,mark,patchknz);
	    }
	}
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rcx, %rbx
movq %rdx, %r14
movq %rdi, %r15
movl %esi, %eax
leaq (%rax,%rax,8), %r12
shll $0x4, %r12d
addq %rdi, %r12
movl $0x14, %r13d
movabsq $0x7fffffffffffffff, %rbp # imm = 0x7FFFFFFFFFFFFFFF
movzwl (%r12,%r13), %eax
cmpq $0x246, %rax            # imm = 0x246
jne 0x6da2
movq %rbp, -0xc(%r12,%r13)
jmp 0x6dcc
movq $0x0, -0xc(%r12,%r13)
cmpb $0x0, (%r14,%rax)
jne 0x6dcc
incl (%rbx)
movb $0x1, (%r14,%rax)
movzwl (%r12,%r13), %esi
movq %r15, %rdi
movq %r14, %rdx
movq %rbx, %rcx
callq 0x6d5d
addq $0x30, %r13
cmpq $0xa4, %r13
jne 0x6d8e
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/mishun[P]plantri/fullgen.c
// Function: reko_patch
void reko_patch(KANTE *anfang,KNOTENTYP code[],int fuenfecke)
{
int i, position, zaehler, z2;
KANTE *run, *merke;


/* wenn bei einer kante hier noleft gesetzt ist, so heisst das, dass
   links 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(run)==5) { code[position]=zaehler; position++; 
					  if (position==fuenfecke) return; }
    zaehler++;
    merke=run->invers; run=run->prev; z2=1;
    while ((merke != run) && (run->noleft) && (z2 <=6))
      { run=run->invers->prev; z2++; }
    if ((merke==run) && (run->noleft)) /* dann muss die letzte flaeche das letzte 5-eck sein */
      { code[position]=zaehler; position++; 
	if (position<fuenfecke)  
		{ fprintf(stderr," ERROR in reko_patch ! Patch empty and missing 5-gon !\n"); exit(32); }
      }
  }
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
testl %edx, %edx
js 0x808e
movl %edx, %ebx
movq %rsi, %r14
movq %rdi, %r15
movl %edx, %eax
leaq 0x2(,%rax,2), %rdx
xorl %r12d, %r12d
movq %rsi, %rdi
xorl %esi, %esi
callq 0x1080
testl %ebx, %ebx
je 0x808e
movl $0x1, %eax
movb $0x1, 0x11(%r15)
movq 0x28(%r15), %rcx
movq 0x20(%rcx), %rdx
cmpq %r15, %rdx
je 0x8043
movl $0x4, %esi
movb $0x1, 0x11(%rdx)
movq 0x28(%rdx), %rdx
movq 0x20(%rdx), %rdx
decl %esi
cmpq %r15, %rdx
jne 0x801c
testl %esi, %esi
jne 0x8043
movslq %r12d, %r12
movw %ax, (%r14,%r12,2)
incl %r12d
cmpl %ebx, %r12d
je 0x808e
incl %eax
movq 0x18(%r15), %r15
cmpq %r15, %rcx
je 0x806e
movl $0x1, %edx
cmpb $0x0, 0x11(%r15)
je 0x8085
cmpl $0x6, %edx
ja 0x8085
movq 0x28(%r15), %rsi
incl %edx
movq 0x18(%rsi), %r15
cmpq %r15, %rcx
jne 0x8053
cmpb $0x0, 0x11(%r15)
je 0x8085
movslq %r12d, %r12
movw %ax, (%r14,%r12,2)
incl %r12d
cmpl %ebx, %r12d
jl 0x809a
cmpl %ebx, %r12d
jl 0x8005
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
callq 0x17c1
// File: /workspace/github_c_makefile_star2_O3/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 %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
testl %edx, %edx
js 0x8772
movl %edx, %ebx
movq %rsi, %r14
movq %rdi, %r15
movl %edx, %eax
leaq 0x2(,%rax,2), %rdx
xorl %r12d, %r12d
movq %rsi, %rdi
xorl %esi, %esi
callq 0x1080
testl %ebx, %ebx
je 0x8772
movl $0x1, %eax
movb $0x1, 0x12(%r15)
movq 0x28(%r15), %rcx
movq 0x18(%rcx), %rdx
cmpq %r15, %rdx
je 0x8727
movl $0x4, %esi
movb $0x1, 0x12(%rdx)
movq 0x28(%rdx), %rdx
movq 0x18(%rdx), %rdx
decl %esi
cmpq %r15, %rdx
jne 0x8700
testl %esi, %esi
jne 0x8727
movslq %r12d, %r12
movw %ax, (%r14,%r12,2)
incl %r12d
cmpl %ebx, %r12d
je 0x8772
incl %eax
movq 0x20(%r15), %r15
cmpq %r15, %rcx
je 0x8752
movl $0x1, %edx
cmpb $0x0, 0x12(%r15)
je 0x8769
cmpl $0x6, %edx
ja 0x8769
movq 0x28(%r15), %rsi
incl %edx
movq 0x20(%rsi), %r15
cmpq %r15, %rcx
jne 0x8737
cmpb $0x0, 0x12(%r15)
je 0x8769
movslq %r12d, %r12
movw %ax, (%r14,%r12,2)
incl %r12d
cmpl %ebx, %r12d
jl 0x877e
cmpl %ebx, %r12d
jl 0x86e9
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
callq 0x17e6
// File: /workspace/github_c_makefile_star2_O3/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 %r15
pushq %r14
pushq %rbx
movq %rdi, %rbx
movq 0x28(%rsi), %rax
movq 0x18(%rax), %r15
movq 0x28(%rdx), %rax
movq 0x18(%rax), %r14
movzwl 0x2(%r15), %eax
cmpw $0x0, (%rbx,%rax,2)
jne 0x91af
movzwl 0x2(%r14), %ecx
movw %cx, (%rbx,%rax,2)
movq %rbx, %rdi
movq %r15, %rsi
movq %r14, %rdx
callq 0x9174
movq 0x18(%r15), %rsi
movzwl 0x2(%rsi), %eax
cmpw $0x0, (%rbx,%rax,2)
jne 0x91cc
movq 0x18(%r14), %rdx
movzwl 0x2(%rdx), %ecx
movw %cx, (%rbx,%rax,2)
jmp 0x917c
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O3/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 %r15
pushq %r14
pushq %rbx
movq %rdi, %rbx
movq 0x28(%rsi), %rax
movq 0x18(%rax), %r15
movq 0x28(%rdx), %rax
movq 0x20(%rax), %r14
movzwl 0x2(%r15), %eax
cmpw $0x0, (%rbx,%rax,2)
jne 0x926c
movzwl 0x2(%r14), %ecx
movw %cx, (%rbx,%rax,2)
movq %rbx, %rdi
movq %r15, %rsi
movq %r14, %rdx
callq 0x9231
movq 0x18(%r15), %rsi
movzwl 0x2(%rsi), %eax
cmpw $0x0, (%rbx,%rax,2)
jne 0x9289
movq 0x20(%r14), %rdx
movzwl 0x2(%rdx), %ecx
movw %cx, (%rbx,%rax,2)
jmp 0x9239
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O3/mishun[P]plantri/fullgen.c
// Function: bilde_f_und_g_sp_rek
BOOL bilde_f_und_g_sp_rek(KNOTENTYP *f, KNOTENTYP *g, KANTE *k1, KANTE *k2) {
  KNOTENTYP u,v;
  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 */
  v = k2->name;
  if (!(f[u])) {          /* Funktionswert noch nicht bekannt */
    f[u] = v;
    if (g[v]) {return(0);}    /* Widerspruch gefunden */
    g[v] = u;
    if (!bilde_f_und_g_sp_rek(f,g,k1,k2))  {return(0);}  /* weitere Funktionswerte: Widerspruch? */
  }
  else { 
    if (!(g[v])) {return(0);}     /* Widerspruch gefunden. Diese Abfrage koennte aber auch
                                      entfallen, denn wenn ein Wert von g noch nicht festgelegt
        ist, obwohl der zugehoerige Wert von f bereits feststeht, so wird an anderer Stelle ein
        Wert von g zuviel festgelegt sein, obwohl der zugehoerige Wert von f noch nicht feststeht */
  }
  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;
  v = k2->name;
  if (!(f[u])) {
    f[u] = v;
    if (g[v]) {return(0);}
    g[v] = u;
    if (!bilde_f_und_g_sp_rek(f,g,k1,k2))  {return(0);}
  }
  else {
    if (!(g[v])) {return(0);}
  }
  return(1);       /* keinen Widerspruch festgestellt */
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq %rdi, %r14
movq 0x28(%rdx), %rax
movq 0x18(%rax), %r15
movq 0x28(%rcx), %rax
movq 0x20(%rax), %r12
movzwl 0x2(%r15), %ecx
movzwl 0x2(%r12), %edx
movzwl %dx, %eax
cmpw $0x0, (%rdi,%rcx,2)
je 0x934f
cmpw $0x0, (%rbx,%rax,2)
je 0x9382
movq 0x18(%r15), %rdx
movq 0x20(%r12), %rcx
movzwl 0x2(%rdx), %esi
movzwl 0x2(%rcx), %edi
movzwl %di, %eax
cmpw $0x0, (%r14,%rsi,2)
je 0x9376
cmpw $0x0, (%rbx,%rax,2)
je 0x9382
movb $0x1, %al
jmp 0x9384
movw %dx, (%r14,%rcx,2)
cmpw $0x0, (%rbx,%rax,2)
jne 0x9382
movw %cx, (%rbx,%rax,2)
movq %r14, %rdi
movq %rbx, %rsi
movq %r15, %rdx
movq %r12, %rcx
callq 0x92ee
testb %al, %al
jne 0x9328
jmp 0x9382
movw %di, (%r14,%rsi,2)
cmpw $0x0, (%rbx,%rax,2)
je 0x9390
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
movw %si, (%rbx,%rax,2)
movq %r14, %rdi
movq %rbx, %rsi
callq 0x92ee
testb %al, %al
jne 0x934b
jmp 0x9382
// File: /workspace/github_c_makefile_star2_O3/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:
testl %r8d, %r8d
je 0x93d9
incl %r8d
cmpw $0x3, %r8w
movl $0x2, %eax
cmovael %r8d, %eax
movzwl %ax, %eax
movl $0x1, %r8d
xorl %r9d, %r9d
movw %r9w, (%rdi,%r8,2)
movw %r9w, (%rsi,%r8,2)
incq %r8
cmpq %r8, %rax
jne 0x93c7
movzwl (%rcx), %eax
movzwl (%rdx), %r8d
movw %ax, (%rdi,%r8,2)
movzwl 0x2(%rcx), %eax
movzwl 0x2(%rdx), %r8d
movw %ax, (%rdi,%r8,2)
movzwl (%rdx), %eax
movzwl (%rcx), %r8d
movw %ax, (%rsi,%r8,2)
movzwl 0x2(%rdx), %eax
movzwl 0x2(%rcx), %r8d
movw %ax, (%rsi,%r8,2)
jmp 0x92ee
// File: /workspace/github_c_makefile_star2_O3/mishun[P]plantri/fullgen.c
// Function: bilde_f_und_g_rek
BOOL bilde_f_und_g_rek(KNOTENTYP *f, KNOTENTYP *g, KANTE *k1, KANTE *k2) {
  KNOTENTYP u,v;
  k1 = k1->invers->prev;
  k2 = k2->invers->prev;   /* k1 und k2 im Gleichschritt nach rechts und links */
  u = k1->name;            /* von u wird der Funktionswert f[u] berechnet */
  v = k2->name;
  if (!(f[u])) {          /* Funktionswert noch nicht bekannt */
    f[u] = v;
    if (g[v]) {return(0);}    /* Widerspruch gefunden */
    g[v] = u;
    if (!bilde_f_und_g_rek(f,g,k1,k2))  {return(0);}  /* weitere Funktionswerte: Widerspruch? */
  }
  else { 
    if (!(g[v])) {return(0);}     /* Widerspruch gefunden. Diese Abfrage koennte aber auch
                                      entfallen, denn wenn ein Wert von g noch nicht festgelegt
        ist, obwohl der zugehoerige Wert von f bereits feststeht, so wird an anderer Stelle ein
        Wert von g zuviel festgelegt sein, obwohl der zugehoerige Wert von f noch nicht feststeht */
  }
  k1 = k1->prev;           /* k1 und k2 spiegelverkehrt nach links und rechts */
  k2 = k2->prev;           /* denn: (k->invers->prev)->prev = k->invers->next */
  u = k1->name;
  v = k2->name;
  if (!(f[u])) {
    f[u] = v;
    if (g[v]) {return(0);}
    g[v] = u;
    if (!bilde_f_und_g_rek(f,g,k1,k2))  {return(0);}
  }
  else {
    if (!(g[v])) {return(0);}
  }
  return(1);       /* keinen Widerspruch festgestellt */
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq %rdi, %r14
movq 0x28(%rdx), %rax
movq 0x18(%rax), %r15
movq 0x28(%rcx), %rax
movq 0x18(%rax), %r12
movzwl 0x2(%r15), %ecx
movzwl 0x2(%r12), %edx
movzwl %dx, %eax
cmpw $0x0, (%rdi,%rcx,2)
je 0x9473
cmpw $0x0, (%rbx,%rax,2)
je 0x94a6
movq 0x18(%r15), %rdx
movq 0x18(%r12), %rcx
movzwl 0x2(%rdx), %esi
movzwl 0x2(%rcx), %edi
movzwl %di, %eax
cmpw $0x0, (%r14,%rsi,2)
je 0x949a
cmpw $0x0, (%rbx,%rax,2)
je 0x94a6
movb $0x1, %al
jmp 0x94a8
movw %dx, (%r14,%rcx,2)
cmpw $0x0, (%rbx,%rax,2)
jne 0x94a6
movw %cx, (%rbx,%rax,2)
movq %r14, %rdi
movq %rbx, %rsi
movq %r15, %rdx
movq %r12, %rcx
callq 0x9412
testb %al, %al
jne 0x944c
jmp 0x94a6
movw %di, (%r14,%rsi,2)
cmpw $0x0, (%rbx,%rax,2)
je 0x94b4
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
movw %si, (%rbx,%rax,2)
movq %r14, %rdi
movq %rbx, %rsi
callq 0x9412
testb %al, %al
jne 0x946f
jmp 0x94a6
// File: /workspace/github_c_makefile_star2_O3/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:
testl %r8d, %r8d
je 0x94fd
incl %r8d
cmpw $0x3, %r8w
movl $0x2, %eax
cmovael %r8d, %eax
movzwl %ax, %eax
movl $0x1, %r8d
xorl %r9d, %r9d
movw %r9w, (%rdi,%r8,2)
movw %r9w, (%rsi,%r8,2)
incq %r8
cmpq %r8, %rax
jne 0x94eb
movzwl (%rcx), %eax
movzwl (%rdx), %r8d
movw %ax, (%rdi,%r8,2)
movzwl 0x2(%rcx), %eax
movzwl 0x2(%rdx), %r8d
movw %ax, (%rdi,%r8,2)
movzwl (%rdx), %eax
movzwl (%rcx), %r8d
movw %ax, (%rsi,%r8,2)
movzwl 0x2(%rdx), %eax
movzwl 0x2(%rcx), %r8d
movw %ax, (%rsi,%r8,2)
jmp 0x9412
// File: /workspace/github_c_makefile_star2_O3/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:
movq 0x28(%rdi), %rax
movq 0x20(%rax), %rcx
movl $0x1, %eax
cmpq %rdi, %rcx
je 0xc463
cmpw $0x246, 0x2(%rcx)       # imm = 0x246
je 0xc45e
incl %eax
movq 0x28(%rcx), %rcx
movq 0x20(%rcx), %rcx
jmp 0xc445
movl $0x6, %eax
retq
// File: /workspace/github_c_makefile_star2_O3/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:
movslq 0x8de5(%rip), %rax      # 0x15250
testq %rax, %rax
jle 0xc487
xorl %ecx, %ecx
leaq 0x8db7(%rip), %rdx      # 0x15230
cmpb %dil, (%rcx,%rdx)
je 0xc48a
incq %rcx
cmpq %rcx, %rax
jne 0xc479
xorl %eax, %eax
retq
movb $0x1, %al
retq
// File: /workspace/github_c_makefile_star2_O3/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
pushq %rbx
pushq %rax
movq %rdi, %rbx
movzwl 0x2(%rdi), %eax
leaq 0x14692(%rip), %rcx     # 0x20b30
incq (%rcx,%rax,8)
callq 0x9536
testl %eax, %eax
je 0xc4f8
movl %eax, %ebp
movzwl 0x2(%rbx), %eax
leaq 0x11228(%rip), %rcx     # 0x1d6e0
incq (%rcx,%rax,8)
movl 0x8d8e(%rip), %eax      # 0x15250
testq %rax, %rax
je 0xc4e4
testl %eax, %eax
jle 0xc4ec
xorl %ecx, %ecx
leaq 0x8d5c(%rip), %rdx      # 0x15230
cmpb %bpl, (%rcx,%rdx)
je 0xc4e4
incq %rcx
cmpq %rcx, %rax
jne 0xc4d4
jmp 0xc4ec
movq %rbx, %rdi
callq 0x3e7b
movl %ebp, %eax
leaq 0x8cbb(%rip), %rcx      # 0x151b0
incl (%rcx,%rax,4)
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/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:
movzwl (%rdi), %eax
movzwl 0x2(%rdi), %ecx
leaq 0x13643(%rip), %rdx     # 0x1fb50
movq 0x8(%rdx,%rcx,8), %rcx
cmpw $0x5, %ax
ja 0xc548
movl $0x8, %edx
subl %eax, %edx
movzwl %dx, %edx
movl $0x2, %esi
xorl %eax, %eax
movzwl (%rdi,%rsi,2), %r8d
cmpl %r8d, 0x8(%rcx)
jle 0xc54c
movq (%rcx), %rcx
movq (%rcx,%r8,8), %rcx
testq %rcx, %rcx
je 0xc54c
incq %rsi
cmpq %rsi, %rdx
jne 0xc529
movq 0x10(%rcx), %rax
retq
// File: /workspace/github_c_makefile_star2_O3/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
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movl %ecx, 0xc(%rsp)
movq %rsi, 0x10(%rsp)
testq %rsi, %rsi
je 0xd60f
movl %r8d, %r14d
movq %rdx, %r15
movq %rsi, %rdx
movq %rdi, %r12
movl $0x1, %ebp
xorl %ebx, %ebx
leaq 0x10(%rsp), %r13
cmpl %r14d, %ebx
jge 0xd5f1
movslq %ebx, %rax
movzbl 0x8(%r15,%rax), %eax
cmpl %eax, %ebp
jne 0xd5f1
movl $0x5, %edi
movq %r12, %rsi
movq %r13, %rcx
callq 0xc571
incl %ebx
jmp 0xd601
movl $0x6, %edi
movq %r12, %rsi
movq %r13, %rcx
callq 0xc571
incl %ebp
movq 0x10(%rsp), %rdx
testq %rdx, %rdx
jne 0xd5cb
jmp 0xd614
movl $0x1, %ebp
movl 0xc(%rsp), %esi
cmpl %esi, %ebp
jne 0xd62b
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movl %ebp, %edi
callq 0x2116
// File: /workspace/github_c_makefile_star2_O3/mishun[P]plantri/fullgen.c
// Function: delete_patch
void delete_patch(PLANMAP map, KANTE *anfang, KNOTENTYP *adresse)
{
int sqlaenge, randlaenge, i, j, knotenverlust;
KANTE *run;

sqlaenge=6-adresse[0];
for (i=2, randlaenge=sqlaenge; i<= 1+sqlaenge; i++) randlaenge+=(2*adresse[i]);

knotenverlust=(3*adresse[0])+randlaenge;
knotenverlust= knotenverlust/2;  /* diese konstruktion nur Sicherheitshalber, damit kein
				    Compiler die Ordnung "erst 3a[0]+r" aufloest */
knotenverlust= knotenverlust+(2*adresse[1])+1-randlaenge;
/*alles nur Euler-Formel*/

map[0][0].name = map[0][0].name - knotenverlust;

for (i=1+sqlaenge; adresse[i]==0; i--);
for ( run=anfang ; i>1 ; i--)
  { if (adresse[i])
      { for (j=0; j < adresse[i]; j++)
	  { 
	    run->name=aussen; run->invers=nil; run = run->next->invers->next->invers->next; }
	run=run->invers->next;
      }
    else { run=run->invers->next; }
  }
}

// Assembly:
movzwl (%rdx), %eax
movl $0x6, %ecx
subl %eax, %ecx
cmpl $0x5, %eax
ja 0xd661
movl $0x8, %r8d
subq %rax, %r8
movl $0x2, %r9d
movzwl (%rdx,%r9,2), %r10d
leal (%rcx,%r10,2), %ecx
incq %r9
cmpq %r9, %r8
jne 0xd650
leal (%rax,%rax,2), %r8d
addl %ecx, %r8d
movl %r8d, %r9d
shrl $0x1f, %r9d
addl %r8d, %r9d
shrl %r9d
movzwl 0x2(%rdx), %r8d
leal (%r9,%r8,2), %r8d
notl %r8d
addl %ecx, %r8d
addw %r8w, 0x2(%rdi)
movl %eax, %ecx
movl $0x8, %eax
subq %rcx, %rax
cmpw $0x0, -0x2(%rdx,%rax,2)
leaq -0x1(%rax), %rax
je 0xd693
cmpq $0x2, %rax
jl 0xd6f0
movl %eax, %eax
cmpw $0x0, (%rdx,%rax,2)
je 0xd6dc
xorl %ecx, %ecx
movw $0x246, 0x2(%rsi)       # imm = 0x246
movq $0x0, 0x28(%rsi)
movq 0x20(%rsi), %rsi
movq 0x28(%rsi), %rsi
movq 0x20(%rsi), %rsi
movq 0x28(%rsi), %rsi
movq 0x20(%rsi), %rsi
incl %ecx
movzwl (%rdx,%rax,2), %edi
cmpl %edi, %ecx
jb 0xd6b0
movq 0x28(%rsi), %rcx
movq 0x20(%rcx), %rsi
leaq -0x1(%rax), %rcx
cmpl $0x2, %eax
movq %rcx, %rax
jg 0xd6a7
retq
// File: /workspace/github_c_makefile_star2_O3/mishun[P]plantri/fullgen.c
// Function: berechne_adresse3
void berechne_adresse3(int l1, int l3, KNOTENTYP adresse[]) 
{
int sl1, sl3;

if (l1%2) { sl1=(l1-1)/2; 
	    if (l3%2) { sl3=(l3-1)/2; adresse[0]=4;
			if (sl3>sl1) { adresse[2]=sl3; adresse[3]=sl1; } 
			else { adresse[2]=sl1; adresse[3]=sl3; }
		      } else /* d.h. l3 gerade */
			{ sl3=(l3-2)/2;
			  adresse[0]=3;
			  if (sl3>sl1) { adresse[2]=sl3; adresse[3]=0; adresse[4]=sl1; }
			  else { adresse[2]=sl1;
				 adresse[3]=sl3; adresse[4]=0; }
			}
	  }

else { sl1=(l1-2)/2; 
       if (l3%2) { sl3=(l3-1)/2;
		   adresse[0]=3;
		   if (sl3>sl1) { adresse[2]=sl3; adresse[3]=0; adresse[4]=sl1; } 
		   else { adresse[2]=sl1; adresse[3]=sl3; adresse[4]=0; }
		 } else /*d.h. l3 gerade */ 
		   { sl3=(l3-2)/2;
		     adresse[0]=2; 
		     if (sl3>sl1) { adresse[2]=sl3; adresse[3]=0; adresse[4]=sl1; adresse[5]=0; } 
		     else { adresse[2]=sl1; adresse[3]=0; adresse[4]=sl3; adresse[5]=0; }
		   }
     }
 }

// Assembly:
testb $0x1, %dil
jne 0xdd0a
addl $-0x2, %edi
sarl %edi
testb $0x1, %sil
jne 0xdd19
addl $-0x2, %esi
sarl %esi
movw $0x2, (%rdx)
cmpl %edi, %esi
jle 0xdd5a
movw %si, 0x4(%rdx)
xorl %eax, %eax
movw %ax, 0x6(%rdx)
movw %di, 0x8(%rdx)
jmp 0xdd68
decl %edi
sarl %edi
testb $0x1, %sil
jne 0xdd35
addl $-0x2, %esi
jmp 0xdd1b
decl %esi
sarl %esi
movw $0x3, (%rdx)
cmpl %edi, %esi
jle 0xdd4b
movw %si, 0x4(%rdx)
movw $0x0, 0x6(%rdx)
movw %di, 0x8(%rdx)
retq
decl %esi
sarl %esi
movw $0x4, (%rdx)
cmpl %edi, %esi
jle 0xdd6d
movw %si, 0x4(%rdx)
movw %di, 0x6(%rdx)
retq
movw %di, 0x4(%rdx)
movw %si, 0x6(%rdx)
movw $0x0, 0x8(%rdx)
retq
movw %di, 0x4(%rdx)
xorl %eax, %eax
movw %ax, 0x6(%rdx)
movw %si, 0x8(%rdx)
movw %ax, 0xa(%rdx)
retq
movw %di, 0x4(%rdx)
movw %si, 0x6(%rdx)
retq
// File: /workspace/github_c_makefile_star2_O3/cath-mawr[P]rscmapgen/mapdump.c
// Function: load_chunk
int
load_chunk(struct chunk *c, unsigned x, unsigned y, unsigned z)
{
	FILE *f;
	char name[128];

	snprintf(name, sizeof(name), "./Map/%u-%u-%u.dat", x, y, z);
	f = fopen(name, "rb");
	if (f == NULL) {
		if (errno == ENOENT) {
			memset(c->overlays[z], 2, sizeof(c->overlays[z]));
			return 0;
		}
		return 1;
	}
	puts(name);
	fread(c->colour[z], 1, CHUNKAREA, f);
	fread(c->elevation[z], 1, CHUNKAREA, f);
	fread(c->h_boundaries[z], 1, CHUNKAREA, f);
	fread(c->v_boundaries[z], 1, CHUNKAREA, f);
	fread(c->d_boundaries[z], 2, CHUNKAREA, f);
	fread(c->roofing[z], 1, CHUNKAREA, f);
	fread(c->overlays[z], 1, CHUNKAREA, f);
	fread(c->rotation[z], 1, CHUNKAREA, f);
	fclose(f);
	return 0;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x88, %rsp
movl %ecx, %ebp
movl %edx, %r8d
movl %esi, %ecx
movq %rdi, %r14
leaq 0x30f32(%rip), %rdx     # 0x32140
xorl %ebx, %ebx
movq %rsp, %r15
movl $0x80, %esi
movq %r15, %rdi
movl %ebp, %r9d
xorl %eax, %eax
callq 0x1090
leaq 0x30f27(%rip), %rsi     # 0x32153
movq %r15, %rdi
callq 0x10d0
testq %rax, %rax
je 0x1344
movq %rax, %r15
movq %rsp, %rdi
callq 0x1050
movl %ebp, %eax
leaq (%rax,%rax,8), %r13
movq %r13, %r12
shlq $0x8, %r12
leaq (%r14,%r12), %rdi
addq $0x2400, %rdi           # imm = 0x2400
movl $0x1, %esi
movl $0x900, %edx            # imm = 0x900
movq %r15, %rcx
callq 0x1060
leaq (%r14,%r12), %rdi
movl $0x1, %esi
movl $0x900, %edx            # imm = 0x900
movq %r15, %rcx
callq 0x1060
leaq (%r14,%r12), %rdi
addq $0x6c00, %rdi           # imm = 0x6C00
movl $0x1, %esi
movl $0x900, %edx            # imm = 0x900
movq %r15, %rcx
callq 0x1060
leaq (%r14,%r12), %rdi
addq $0x4800, %rdi           # imm = 0x4800
movl $0x1, %esi
movl $0x900, %edx            # imm = 0x900
movq %r15, %rcx
callq 0x1060
shlq $0x9, %r13
leaq (%r14,%r13), %rdi
addq $0x9000, %rdi           # imm = 0x9000
movl $0x2, %esi
movl $0x900, %edx            # imm = 0x900
movq %r15, %rcx
callq 0x1060
leaq (%r14,%r12), %rdi
addq $0xd800, %rdi           # imm = 0xD800
movl $0x1, %esi
movl $0x900, %edx            # imm = 0x900
movq %r15, %rcx
callq 0x1060
leaq (%r14,%r12), %rdi
addq $0xfc00, %rdi           # imm = 0xFC00
movl $0x1, %esi
movl $0x900, %edx            # imm = 0x900
movq %r15, %rcx
callq 0x1060
leaq (%r14,%r12), %rdi
addq $0x12000, %rdi          # imm = 0x12000
movl $0x1, %esi
movl $0x900, %edx            # imm = 0x900
movq %r15, %rcx
callq 0x1060
movq %r15, %rdi
callq 0x1070
jmp 0x1379
callq 0x1040
movl $0x1, %ebx
cmpl $0x2, (%rax)
jne 0x1379
movl %ebp, %eax
leaq (%rax,%rax,8), %rax
shlq $0x8, %rax
leaq (%r14,%rax), %rdi
addq $0xfc00, %rdi           # imm = 0xFC00
movl $0x900, %edx            # imm = 0x900
movl $0x2, %esi
callq 0x10a0
xorl %ebx, %ebx
movl %ebx, %eax
addq $0x88, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/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 %r15
pushq %r14
pushq %rbx
movq %rsi, %rbx
leaq 0x309ea(%rip), %rsi     # 0x32176
callq 0x10d0
testq %rax, %rax
je 0x18aa
movq %rax, %r14
xorl %r15d, %r15d
xorl %edi, %edi
movq %rax, %rsi
callq 0x10b0
xorl %edi, %edi
movq %r14, %rsi
callq 0x10b0
movl $0x2, %edi
movq %r14, %rsi
callq 0x10b0
xorl %edi, %edi
movq %r14, %rsi
callq 0x10b0
xorl %edi, %edi
movq %r14, %rsi
callq 0x10b0
xorl %edi, %edi
movq %r14, %rsi
callq 0x10b0
xorl %edi, %edi
movq %r14, %rsi
callq 0x10b0
xorl %edi, %edi
movq %r14, %rsi
callq 0x10b0
xorl %edi, %edi
movq %r14, %rsi
callq 0x10b0
xorl %edi, %edi
movq %r14, %rsi
callq 0x10b0
xorl %edi, %edi
movq %r14, %rsi
callq 0x10b0
xorl %edi, %edi
movq %r14, %rsi
callq 0x10b0
movl $0x90, %edi
movq %r14, %rsi
callq 0x10b0
movl $0x9, %edi
movq %r14, %rsi
callq 0x10b0
movl $0x90, %edi
movq %r14, %rsi
callq 0x10b0
movl $0x9, %edi
movq %r14, %rsi
callq 0x10b0
movl $0x18, %edi
movq %r14, %rsi
callq 0x10b0
movl $0x20, %edi
movq %r14, %rsi
callq 0x10b0
movzbl (%rbx,%r15,4), %edi
movq %r14, %rsi
callq 0x10b0
movzbl 0x1(%rbx,%r15,4), %edi
movq %r14, %rsi
callq 0x10b0
movzbl 0x2(%rbx,%r15,4), %edi
movq %r14, %rsi
callq 0x10b0
incq %r15
cmpq $0x5b7100, %r15         # imm = 0x5B7100
jne 0x1869
movq %r14, %rdi
callq 0x1070
xorl %eax, %eax
jmp 0x18af
movl $0x1, %eax
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O3/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
pushq %r14
pushq %rbx
movq %rsi, %rbx
movl %edi, %r14d
movl $0x1, %edi
movl $0x50, %esi
callq 0x10d0
testq %rax, %rax
je 0x139b
movw %r14w, (%rax)
movq $0x4, 0x28(%rax)
decl %r14d
cmpw $0x2, %r14w
ja 0x1396
movzwl %r14w, %ecx
leaq 0x3d22(%rip), %rdx      # 0x50b0
movq (%rdx,%rcx,8), %rcx
movq %rbx, (%rax,%rcx)
popq %rbx
popq %r14
popq %rbp
retq
leaq 0x3c62(%rip), %rdi      # 0x5004
leaq 0x3c67(%rip), %rsi      # 0x5010
leaq 0x3c6a(%rip), %rcx      # 0x501a
movl $0xc, %edx
callq 0x10b0