LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O1/baskerville[P]bspwm/src/subscribe.c
// Function: put_status
void put_status(subscriber_mask_t mask, ...)
{
	subscriber_list_t *sb = subscribe_head;
	int ret;
	while (sb != NULL) {
		subscriber_list_t *next = sb->next;
		if (sb->field & mask) {
			if (sb->count > 0) {
				sb->count--;
			}
			if (mask == SBSC_MASK_REPORT) {
				ret = print_report(sb->stream);
			} else {
				char *fmt;
				va_list args;
				va_start(args, mask);
				fmt = va_arg(args, char *);
				vfprintf(sb->stream, fmt, args);
				va_end(args);
				ret = fflush(sb->stream);
			}
			if (ret != 0 || sb->count == 0) {
				remove_subscriber(sb);
			}
		}
		sb = next;
	}
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0xd8, %rsp
testb %al, %al
je 0x1eb57
movaps %xmm0, 0x50(%rsp)
movaps %xmm1, 0x60(%rsp)
movaps %xmm2, 0x70(%rsp)
movaps %xmm3, 0x80(%rsp)
movaps %xmm4, 0x90(%rsp)
movaps %xmm5, 0xa0(%rsp)
movaps %xmm6, 0xb0(%rsp)
movaps %xmm7, 0xc0(%rsp)
movq %rsi, 0x28(%rsp)
movq %rdx, 0x30(%rsp)
movq %rcx, 0x38(%rsp)
movq %r8, 0x40(%rsp)
movq %r9, 0x48(%rsp)
leaq 0xabe1(%rip), %rax      # 0x29758
movq (%rax), %r12
testq %r12, %r12
je 0x1ec39
movl %edi, %ebx
movabsq $0x3000000008, %r13     # imm = 0x3000000008
movl $0x8, %ebp
movq %rsp, %r14
movq %r12, %r15
movq 0x20(%r12), %r12
testl %ebx, 0x10(%r15)
je 0x1ec30
movl 0x14(%r15), %eax
testl %eax, %eax
jle 0x1ebb7
decl %eax
movl %eax, 0x14(%r15)
cmpl $0x1, %ebx
jne 0x1ebc6
movq (%r15), %rdi
callq 0x1e8f9
jmp 0x1ec1b
leaq 0x20(%rsp), %rax
movq %rax, 0x10(%rsp)
leaq 0x110(%rsp), %rax
movq %rax, 0x8(%rsp)
movq %r13, (%rsp)
cmpq $0x28, %rbp
ja 0x1ebf7
movq 0x10(%rsp), %rax
addq %rbp, %rax
leal 0x8(%rbp), %ecx
movl %ecx, (%rsp)
jmp 0x1ec05
movq 0x8(%rsp), %rax
leaq 0x8(%rax), %rcx
movq %rcx, 0x8(%rsp)
movq (%rax), %rsi
movq (%r15), %rdi
movq %r14, %rdx
callq 0x43d0
movq (%r15), %rdi
callq 0x4b00
testl %eax, %eax
je 0x1ec29
movq %r15, %rdi
callq 0x1e7c7
jmp 0x1ec30
cmpl $0x0, 0x14(%r15)
je 0x1ec1f
testq %r12, %r12
jne 0x1eb97
addq $0xd8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/baskerville[P]bspwm/src/subscribe.c
// Function: prune_dead_subscribers
void prune_dead_subscribers(void)
{
	subscriber_list_t *sb = subscribe_head;
	while (sb != NULL) {
		subscriber_list_t *next = sb->next;
		// Is the subscriber's stream closed?
		if (write(fileno(sb->stream), NULL, 0) == -1) {
			remove_subscriber(sb);
		}
		sb = next;
	}
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
leaq 0xab02(%rip), %rax      # 0x29758
movq (%rax), %rbx
testq %rbx, %rbx
je 0x1ec8b
movq (%rbx), %rdi
movq 0x20(%rbx), %r14
callq 0x4060
movl %eax, %edi
xorl %esi, %esi
xorl %edx, %edx
callq 0x4a60
cmpq $-0x1, %rax
jne 0x1ec83
movq %rbx, %rdi
callq 0x1e7c7
movq %r14, %rbx
testq %r14, %r14
jne 0x1ec5e
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O1/ramirezsebas[P]TP-LISTINGS/./src/capitulo_5/5.8/dup2.c
// Function: main
int main()
{
    int fds[2];
    pid_t pid;

    /* Create a pipe. File descriptors for the two ends of the pipe are
	placed in fds. */
    pipe(fds);
    /* Fork a child process. */
    pid = fork();
    if (pid == (pid_t)0)
    {
        /* This is the child process. Close our copy of the write end of
		the file descriptor. */
        close(fds[1]);
        /* Connect the read end of the pipe to standard input. */
        dup2(fds[0], STDIN_FILENO);
        /* Replace the child process with the "sort" program */
        execlp("sort", "sort", 0, NULL);
    }
    else
    {
        /*This is the parent process.*/
        FILE *stream;
        /* Close our copy of the read end of the file descriptor. */
        close(fds[0]);
        /* Convert the write file descriptor to a FILE object, and write to it. */
        stream = fdopen(fds[1], "w");
        fprintf(stream, "This is a test.\n");
        fprintf(stream, "Hello, world.\n");
        fprintf(stream, "My dog has fleas.\n");
        fprintf(stream, "This program is great.\n");
        fprintf(stream, "One fish, two fish.\n");
        fflush(stream);
        close(fds[1]);
        /* Wait for the child process to finish. */
        waitpid(pid, NULL, 0);
    }
    return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
subq $0x10, %rsp
leaq -0x18(%rbp), %rdi
callq 0x1050
callq 0x10b0
testl %eax, %eax
je 0x1293
movl %eax, %ebx
movl -0x18(%rbp), %edi
callq 0x1040
movl -0x14(%rbp), %edi
leaq 0xe18(%rip), %rsi       # 0x2009
callq 0x1070
movq %rax, %r14
leaq 0xe0b(%rip), %rdi       # 0x200b
movl $0x10, %esi
movl $0x1, %edx
movq %rax, %rcx
callq 0x1090
leaq 0xe03(%rip), %rdi       # 0x201c
movl $0xe, %esi
movl $0x1, %edx
movq %r14, %rcx
callq 0x1090
leaq 0xdf9(%rip), %rdi       # 0x202b
movl $0x12, %esi
movl $0x1, %edx
movq %r14, %rcx
callq 0x1090
leaq 0xdf3(%rip), %rdi       # 0x203e
movl $0x17, %esi
movl $0x1, %edx
movq %r14, %rcx
callq 0x1090
leaq 0xdf2(%rip), %rdi       # 0x2056
movl $0x14, %esi
movl $0x1, %edx
movq %r14, %rcx
callq 0x1090
movq %r14, %rdi
callq 0x1060
movl -0x14(%rbp), %edi
callq 0x1040
movl %ebx, %edi
xorl %esi, %esi
xorl %edx, %edx
callq 0x1080
jmp 0x12ba
movl -0x14(%rbp), %edi
callq 0x1040
movl -0x18(%rbp), %edi
xorl %esi, %esi
callq 0x1030
leaq 0xd58(%rip), %rdi       # 0x2004
movq %rdi, %rsi
xorl %edx, %edx
xorl %ecx, %ecx
xorl %eax, %eax
callq 0x10a0
xorl %eax, %eax
addq $0x10, %rsp
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/mishun[P]plantri/fullgen.c
// Function: schreibe_symmetriestatistik
void schreibe_symmetriestatistik()
{ int i, j=0;
  fprintf(stderr,"Symmetries:\n");
  for (i=1; i<=28; i++) {
    if (symm_anz[i]>0) {
      fprintf(stderr,"  %s: %10d ",symm_name[i],symm_anz[i]); 
      j++;
      if (j%4==0) {fprintf(stderr,"\n");}
    }
  }
  if (j%4) {fprintf(stderr,"\n");}
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq 0x13e46(%rip), %r14     # 0x14ff8
movq (%r14), %rcx
leaq 0xf064(%rip), %rdi      # 0x10220
pushq $0xc
popq %rsi
pushq $0x1
popq %rdx
callq 0x1180
pushq $0x4
popq %r15
leaq 0x13fde(%rip), %r12     # 0x151b0
leaq 0x13f07(%rip), %r13     # 0x150e0
leaq 0xf04d(%rip), %rbx      # 0x1022d
xorl %ebp, %ebp
movl (%r15,%r12), %ecx
testl %ecx, %ecx
jg 0x11f6
addq $0x4, %r15
cmpq $0x74, %r15
jne 0x11e2
jmp 0x121c
movq (%r14), %rdi
leaq (%r15,%r13), %rdx
movq %rbx, %rsi
xorl %eax, %eax
callq 0x10b0
incl %ebp
testb $0x3, %bpl
jne 0x11ea
movq (%r14), %rsi
pushq $0xa
popq %rdi
callq 0x1090
jmp 0x11ea
testb $0x3, %bpl
je 0x123b
movq (%r14), %rsi
pushq $0xa
popq %rdi
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x1090
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/mishun[P]plantri/fullgen.c
// Function: checksize_mark_return
int checksize_mark_return(KANTE* edge, int mark, KANTE **nextedge)

{
KANTE *run; 
int zaehler=1;

*nextedge=nil;
if (edge->dummy < mark) { *nextedge=edge->invers; edge->dummy=edge->invers->dummy=mark; }

for (run=edge->invers->next; run != edge; run=run->invers->next) 
        { if (run->dummy < mark) { *nextedge=run->invers; run->dummy=run->invers->dummy=mark; }
	  zaehler++; }
return(zaehler);
}

// Assembly:
movq $0x0, (%rdx)
movslq %esi, %rcx
cmpq %rcx, 0x8(%rdi)
jge 0x2bff
movq 0x28(%rdi), %rax
movq %rax, (%rdx)
movq 0x28(%rdi), %rax
movq %rcx, 0x8(%rax)
movq %rcx, 0x8(%rdi)
movq 0x28(%rdi), %rax
movq 0x20(%rax), %rsi
movl $0x1, %eax
cmpq %rdi, %rsi
je 0x2c36
cmpq %rcx, 0x8(%rsi)
jge 0x2c2a
movq 0x28(%rsi), %r8
movq %r8, (%rdx)
movq 0x28(%rsi), %r8
movq %rcx, 0x8(%r8)
movq %rcx, 0x8(%rsi)
incl %eax
movq 0x28(%rsi), %rsi
movq 0x20(%rsi), %rsi
jmp 0x2c0c
retq
// File: /workspace/github_c_makefile_star2_O1/mishun[P]plantri/fullgen.c
// Function: checksize_mark_return_right
int checksize_mark_return_right(KANTE* edge, int mark, KANTE **nextedge)

{
KANTE *run; 
int zaehler=1;

*nextedge=nil;
if (edge->dummy < mark) { *nextedge=edge->invers; edge->dummy=edge->invers->dummy=mark; }

for (run=edge->invers->prev; run != edge; run=run->invers->prev) 
      {if (run->dummy < mark) { *nextedge=run->invers; run->dummy=run->invers->dummy=mark; }
       zaehler++;}
return(zaehler);
}

// Assembly:
movq $0x0, (%rdx)
movslq %esi, %rcx
cmpq %rcx, 0x8(%rdi)
jge 0x2c5a
movq 0x28(%rdi), %rax
movq %rax, (%rdx)
movq 0x28(%rdi), %rax
movq %rcx, 0x8(%rax)
movq %rcx, 0x8(%rdi)
movq 0x28(%rdi), %rax
movq 0x18(%rax), %rsi
movl $0x1, %eax
cmpq %rdi, %rsi
je 0x2c91
cmpq %rcx, 0x8(%rsi)
jge 0x2c85
movq 0x28(%rsi), %r8
movq %r8, (%rdx)
movq 0x28(%rsi), %r8
movq %rcx, 0x8(%r8)
movq %rcx, 0x8(%rsi)
incl %eax
movq 0x28(%rsi), %rsi
movq 0x18(%rsi), %rsi
jmp 0x2c67
retq
// File: /workspace/github_c_makefile_star2_O1/mishun[P]plantri/fullgen.c
// Function: get_spiralcode_inv
BOOL get_spiralcode_inv ( KANTE *edge, int minmark, FLAECHENTYP cmpcode[12],
		 int sixgons)

/* entwickelt den Spiralcode, bei dem die erste Flaeche links von edge
   liegt, die zweite rechts davon und die Entwicklung im GEGEN-Uhrzeigersinn
   geht. Sonst wie oben */

{
int mark, i;
KANTE *nextedge;
BOOL kleiner=0;
FLAECHENTYP code[12], zaehler;
int fuenfecke=0, sechsecke=0; /* zaehler fuer die wirklich eingefuegten Flaechen */
int stelle;

mark=minmark+1;  

if (checksize_mark_return( edge, mark, &nextedge)==5)
                      { code[0]=1; stelle=0; fuenfecke=1; } 
else { stelle= -1; sechsecke=1; }
if (checksize_mark_return_right( edge, mark, &nextedge)==5)
    { stelle++; code[stelle]=2; fuenfecke++; } else sechsecke++;

nextedge=edge->invers->prev;

for (i=0; (i<=stelle) && (!kleiner); i++)
  { if (code[i]>cmpcode[i]) return(0);
    if (code[i]<cmpcode[i]) kleiner=1; }

zaehler=3;

while (nextedge != nil)
  { 
    if (checksize_mark_return( nextedge, mark, &nextedge)==5)
                       { fuenfecke++;
			 stelle++; code[stelle]=zaehler; 
		         if (!kleiner)
			    { if (zaehler>cmpcode[stelle]) { return(0); }
			      if (zaehler<cmpcode[stelle]) kleiner=1;
			    }
		       }
    else sechsecke++;
    zaehler++;
  }

if ((fuenfecke<12) || (sechsecke < sixgons)) return(0);

for (i=0; i<12; i++) cmpcode[i]=code[i];
return(1);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x28, %rsp
movl %ecx, 0x18(%rsp)
movq %rdx, 0x10(%rsp)
movl %esi, %r14d
movq %rdi, %r15
incl %r14d
leaq 0x8(%rsp), %rdx
movl %r14d, %esi
callq 0x2bdc
cmpl $0x5, %eax
jne 0x2e14
movb $0x1, 0x1c(%rsp)
xorl %r12d, %r12d
movl $0x1, %r13d
xorl %ebp, %ebp
jmp 0x2e22
movl $0xffffffff, %ebp       # imm = 0xFFFFFFFF
movl $0x1, %r12d
xorl %r13d, %r13d
leaq 0x8(%rsp), %rdx
movq %r15, %rdi
movl %r14d, %esi
callq 0x2c37
cmpl $0x5, %eax
jne 0x2e43
incl %ebp
movb $0x2, 0x1c(%rsp,%rbp)
incl %r13d
jmp 0x2e46
incl %r12d
movq 0x10(%rsp), %rdi
movq 0x28(%r15), %rax
movq 0x18(%rax), %rax
movq %rax, 0x8(%rsp)
testl %ebp, %ebp
js 0x2e8a
movl %ebp, %eax
xorl %ecx, %ecx
movl $0x1, %edx
xorl %ebx, %ebx
movb (%rdi,%rcx), %sil
cmpb %sil, 0x1c(%rsp,%rcx)
ja 0x2f08
movzbl %bl, %ebx
cmovbl %edx, %ebx
cmpq %rax, %rcx
jae 0x2e8c
incq %rcx
testb %bl, %bl
je 0x2e67
jmp 0x2e8c
xorl %ebx, %ebx
movq 0x8(%rsp), %rdi
testq %rdi, %rdi
je 0x2ee1
movb $0x3, %r15b
movl %r14d, %esi
leaq 0x8(%rsp), %rdx
callq 0x2bdc
cmpl $0x5, %eax
jne 0x2ec1
incl %r13d
movslq %ebp, %rbp
movb %r15b, 0x1d(%rsp,%rbp)
incq %rbp
testb %bl, %bl
je 0x2ec6
movb $0x1, %bl
jmp 0x2ed4
incl %r12d
jmp 0x2ed4
movq 0x10(%rsp), %rax
cmpb (%rax,%rbp), %r15b
ja 0x2f08
setb %bl
incb %r15b
movq 0x8(%rsp), %rdi
testq %rdi, %rdi
jne 0x2e99
xorl %eax, %eax
cmpl $0xc, %r13d
movq 0x10(%rsp), %rcx
jl 0x2f0a
cmpl 0x18(%rsp), %r12d
jl 0x2f0a
movl 0x24(%rsp), %eax
movl %eax, 0x8(%rcx)
movq 0x1c(%rsp), %rax
movq %rax, (%rcx)
movb $0x1, %al
jmp 0x2f0a
xorl %eax, %eax
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/mishun[P]plantri/fullgen.c
// Function: vegacode
void vegacode( FILE *fil, PLANMAP map )

{
static int erster_aufruf=1;
int i;

if (erster_aufruf)
  { fprintf(fil,">>writegraph3d planar <<\n");
    erster_aufruf=0; }

if (map[0][0].name >= 100)
  {
    for (i=1; i<=map[0][0].name; i++)
      fprintf(fil,"%3d  0 0 0   %3d %3d %3d\n",i,map[i][0].name,map[i][1].name,map[i][2].name);
  }
else 
  {
    for (i=1; i<=map[0][0].name; i++)
      fprintf(fil,"%2d  0 0 0   %2d %2d %2d\n",i,map[i][0].name,map[i][1].name,map[i][2].name);
  }
fprintf(fil,"0\n");

}

// Assembly:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
movq %rsi, %r14
movq %rdi, %rbx
cmpb $0x0, 0x12325(%rip)     # 0x15254
jne 0x2f51
leaq 0xd301(%rip), %rdi      # 0x10239
movl $0x19, %esi
movl $0x1, %edx
movq %rbx, %rcx
callq 0x1180
movb $0x1, 0x12303(%rip)     # 0x15254
movzwl 0x2(%r14), %eax
cmpw $0x64, %ax
jb 0x2fa2
leaq 0xf2(%r14), %r13
leaq 0xd2e9(%rip), %r15      # 0x10253
xorl %r12d, %r12d
movzwl -0x60(%r13), %ecx
movzwl -0x30(%r13), %r8d
movzwl (%r13), %r9d
incq %r12
movq %rbx, %rdi
movq %r15, %rsi
movl %r12d, %edx
xorl %eax, %eax
callq 0x10b0
movzwl 0x2(%r14), %eax
addq $0x90, %r13
cmpq %rax, %r12
jb 0x2f6d
jmp 0x2feb
testw %ax, %ax
je 0x2feb
leaq 0xf2(%r14), %r13
leaq 0xd2b8(%rip), %r15      # 0x1026d
xorl %r12d, %r12d
movzwl -0x60(%r13), %ecx
movzwl -0x30(%r13), %r8d
movzwl (%r13), %r9d
incq %r12
movq %rbx, %rdi
movq %r15, %rsi
movl %r12d, %edx
xorl %eax, %eax
callq 0x10b0
movzwl 0x2(%r14), %eax
addq $0x90, %r13
cmpq %rax, %r12
jb 0x2fb8
leaq 0xd295(%rip), %rdi      # 0x10287
movl $0x2, %esi
movl $0x1, %edx
movq %rbx, %rcx
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
jmp 0x1180
// File: /workspace/github_c_makefile_star2_O1/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:
movzwl 0x2(%rdi), %eax
cmpl $0xff, %eax
ja 0x341f
movb %al, (%rsi)
cmpw $0x0, 0x2(%rdi)
je 0x34c7
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 0x3403
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 0x33ea
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 0x33bf
retq
movb $0x0, (%rsi)
movb 0x2(%rdi), %al
movb %al, 0x1(%rsi)
movb 0x3(%rdi), %al
movb %al, 0x2(%rsi)
cmpw $0x0, 0x2(%rdi)
je 0x34cd
movl $0x3, %eax
movl $0x1, %edx
xorl %ecx, %ecx
leaq (%rdx,%rdx,8), %r9
shlq $0x4, %r9
leaq (%rdi,%r9), %r8
movb 0x2(%rdi,%r9), %r11b
movslq %eax, %r10
movb %r11b, (%rsi,%r10)
movb 0x3(%rdi,%r9), %r11b
movb %r11b, 0x1(%rsi,%r10)
movq 0x20(%rdi,%r9), %r9
addl $0x2, %r10d
cmpq %r8, %r9
je 0x34a1
movslq %r10d, %r10
addq %rsi, %r10
movb 0x2(%r9), %r11b
movb %r11b, (%r10)
movb 0x3(%r9), %r11b
cltq
movb %r11b, 0x3(%rsi,%rax)
movq 0x20(%r9), %r9
addl $0x2, %eax
addq $0x2, %r10
cmpq %r8, %r9
jne 0x347b
leal 0x2(%rax), %r10d
movslq %r10d, %r8
movb %cl, (%rsi,%r8)
cltq
movb %cl, 0x3(%rsi,%rax)
addl $0x4, %eax
leaq 0x1(%rdx), %r8
movzwl 0x2(%rdi), %r9d
cmpq %r9, %rdx
movq %r8, %rdx
jb 0x3445
jmp 0x341e
movl $0x1, %eax
retq
movl $0x3, %eax
retq
// File: /workspace/github_c_makefile_star2_O1/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 0x3b60
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 0x3b34
incq %rsi
addq $0x90, %rdx
cmpq %rcx, %rsi
jne 0x3b31
movl $0xffffffff, 0x18(%rsp) # imm = 0xFFFFFFFF
movq $-0x1, 0x10(%rsp)
xorl %r12d, %r12d
cmpw $0x0, 0x2(%rdi)
je 0x3c58
leal -0x14(%rax), %ecx
shrl $0x1f, %ecx
leal (%rax,%rcx), %ebx
addl $-0x14, %ebx
sarl %ebx
leaq 0x90(%rdi), %r15
movl $0x1, %eax
movq %rax, 0x8(%rsp)
movl $0x1, %eax
movb $-0x1, %r9b
leaq 0x10(%rsp), %rbp
movq %rdi, 0x20(%rsp)
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 %r9b, 0x10(%rsp)
movq %r15, %rdi
movq %rbp, %rdx
movl %ebx, %ecx
callq 0x2c92
movzbl %al, %r14d
addl %r12d, %r14d
movb $-0x1, %al
movb %al, 0x10(%rsp)
movq 0x8(%rsp), %rax
leal (%rax,%r13), %esi
incl %esi
movq %r15, %rdi
movq %rbp, %rdx
movl %ebx, %ecx
callq 0x2dd0
movb $-0x1, %r9b
movzbl %al, %r12d
addl %r14d, %r12d
addq $0x30, %r15
addq $0x2, %r13
cmpq $0x6, %r13
jne 0x3bc9
movq 0x28(%rsp), %r10
leaq 0x1(%r10), %rax
movq 0x20(%rsp), %rdi
movzwl 0x2(%rdi), %esi
movq 0x30(%rsp), %r15
addq $0x90, %r15
movq 0x8(%rsp), %r8
addl %r13d, %r8d
movq %r8, 0x8(%rsp)
cmpq %rsi, %r10
jb 0x3bb0
movslq %r12d, %r12
leaq 0x11991(%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_O1/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 (%rbx), %al
testb %al, %al
je 0x3d3d
movb (%rdi), %cl
cmpb %al, %cl
jne 0x3d2b
movl $0x1, %edx
movb (%rdi,%rdx), %cl
movb (%rbx,%rdx), %al
cmpb %al, %cl
jne 0x3d2b
leaq 0x1(%rdx), %rsi
cmpl $0xb, %edx
movq %rsi, %rdx
jne 0x3d15
cmpb %al, %cl
jae 0x3d35
movq 0x10(%rbx), %rbx
jmp 0x3d04
je 0x3d79
movq 0x18(%rbx), %rbx
jmp 0x3d04
xorl %eax, %eax
movb (%rdi,%rax), %cl
movb %cl, (%rbx,%rax)
incq %rax
cmpq $0xc, %rax
jne 0x3d3f
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_O1/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
movq %rdx, %rbx
movl %esi, %ebp
movq %rdi, %r14
movslq %esi, %r15
leaq 0x13485(%rip), %r12     # 0x17220
cmpb $0x0, (%r14)
je 0x3df3
movq 0x10(%r14), %rdi
movl %ebp, %esi
movq %rbx, %rdx
callq 0x3d7e
movq (%rbx), %rcx
movb $-0x1, %al
incb %al
movzbl %al, %r13d
movb (%r14,%r13), %dl
cmpb (%rcx,%r13), %dl
je 0x3db4
movq (%r12,%r15,8), %rsi
movsbl %al, %edi
callq 0x1090
leaq (%r14,%r13), %rdi
movl $0xc, %edx
subq %r13, %rdx
movq (%r12,%r15,8), %rcx
movl $0x1, %esi
callq 0x1180
movq %r14, (%rbx)
movq 0x18(%r14), %r14
jmp 0x3d9b
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/mishun[P]plantri/fullgen.c
// Function: init_map
void init_map(PLANMAP map)
{
int i,j;

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

for (i=1; i<=N; i++)
{
map[i][0].next= map[i]+1; map[i][0].prev= map[i]+2;
map[i][1].next= map[i]+2; map[i][1].prev= map[i];
map[i][2].next= map[i]; map[i][2].prev= map[i]+1;

for (j=0; j<3; j++) 
          { map[i][j].ursprung=i;
	    map[i][j].name=leer;
            map[i][j].invers=nil; }
}
}

// Assembly:
movw $0x0, 0x2(%rdi)
leaq 0x90(%rdi), %rax
movl $0x1, %ecx
leaq (%rcx,%rcx,8), %rdx
shlq $0x4, %rdx
leaq (%rdi,%rdx), %rsi
leaq (%rdi,%rdx), %r8
addq $0x30, %r8
movq %r8, -0x10(%r8)
leaq 0x60(%rdi,%rdx), %rdx
movq %rdx, -0x48(%rdx)
movq %rdx, -0x10(%rdx)
movq %rsi, -0x18(%rdx)
movq %rsi, 0x20(%rdx)
movq %r8, 0x18(%rdx)
xorl %edx, %edx
movw %cx, (%rax,%rdx)
movw $0xfffe, 0x2(%rax,%rdx) # imm = 0xFFFE
movq $0x0, 0x28(%rax,%rdx)
addq $0x30, %rdx
cmpq $0x90, %rdx
jne 0x44eb
incq %rcx
addq $0x90, %rax
cmpq $0x245, %rcx            # imm = 0x245
jne 0x44b8
retq
// File: /workspace/github_c_makefile_star2_O1/mishun[P]plantri/fullgen.c
// Function: baue_polygon
void baue_polygon(int n, PLANMAP map, KANTE **marke )
{
int j;

if (n<3) { fprintf(stderr,"Error, no 2-gons allowed !\n"); return; }

/* sicherheitshalber erstmal loeschen und initialisieren */

init_map(map);

/* Immer: erster Eintrag zurueck, 2. nach aussen, dritter vor */

map[1][0].name=n;   map[1][1].name=aussen;   map[1][2].name=2;
map[1][0].invers=map[n]+2; map[1][1].invers=nil; map[1][2].invers=map[2];

(*marke)=map[1]+1;

for (j=2; j<n; j++)
{
map[j][0].name=j-1;   map[j][1].name=aussen;   map[j][2].name=j+1;
map[j][0].invers=map[j-1]+2; map[j][1].invers=nil; map[j][2].invers=map[j+1];
}

map[n][0].name=n-1;   map[n][1].name=aussen;   map[n][2].name=1;
map[n][0].invers=map[n-1]+2; map[n][1].invers=nil; map[n][2].invers=map[1];

map[0][0].name=n;

}

// Assembly:
pushq %rbp
pushq %r14
pushq %rbx
cmpl $0x2, %edi
jle 0x4625
movq %rdx, %r14
movq %rsi, %rbx
movl %edi, %ebp
movq %rsi, %rdi
callq 0x44a6
movw %bp, 0x92(%rbx)
leaq 0xc0(%rbx), %rdx
movw $0x246, 0xc2(%rbx)      # imm = 0x246
movw $0x2, 0xf2(%rbx)
movl %ebp, %ecx
leaq (%rcx,%rcx,8), %rsi
shlq $0x4, %rsi
leaq (%rbx,%rsi), %rax
addq %rbx, %rsi
addq $0x60, %rsi
movq %rsi, 0xb8(%rbx)
movq $0x0, 0xe8(%rbx)
leaq 0x120(%rbx), %rsi
movq %rsi, 0x118(%rbx)
movq %rdx, (%r14)
leaq 0x1b0(%rbx), %rdx
addq $-0x2, %rcx
xorl %esi, %esi
leaq 0x1(%rsi), %rdi
movw %di, -0x8e(%rdx)
movw $0x246, -0x5e(%rdx)     # imm = 0x246
addl $0x3, %esi
movw %si, -0x2e(%rdx)
leaq -0xc0(%rdx), %rsi
movq %rsi, -0x68(%rdx)
movq $0x0, -0x38(%rdx)
movq %rdx, -0x8(%rdx)
addq $0x90, %rdx
movq %rdi, %rsi
cmpq %rdi, %rcx
jne 0x45a1
leaq 0x90(%rbx), %rcx
movl %ebp, %edx
decl %edx
movw %dx, 0x2(%rax)
movw $0x246, 0x32(%rax)      # imm = 0x246
movw $0x1, 0x62(%rax)
leaq (%rdx,%rdx,8), %rdx
shlq $0x4, %rdx
addq %rbx, %rdx
addq $0x60, %rdx
movq %rdx, 0x28(%rax)
movq $0x0, 0x58(%rax)
movq %rcx, 0x88(%rax)
movw %bp, 0x2(%rbx)
popq %rbx
popq %r14
popq %rbp
retq
callq 0x149c
jmp 0x4620
// File: /workspace/github_c_makefile_star2_O1/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
movq %rdi, %rbx
movl (%rdi), %r14d
xorl %ecx, %ecx
movl $0x0, %eax
cmpl $0xfffe, %r14d          # imm = 0xFFFE
je 0x48c3
movl $0x1, %ecx
xorl %eax, %eax
movl %r14d, %edx
movl %edx, (%rsp,%rax,4)
movl $0x0, %esi
cmpl %r14d, %edx
je 0x48ad
movl %ecx, %esi
jg 0x4933
movl 0x4(%rbx,%rax,4), %edx
incq %rax
movl %esi, %ecx
cmpl $0xfffe, %edx           # imm = 0xFFFE
jne 0x4898
testl %esi, %esi
sete %cl
movl $0x1, %ebp
testb %cl, %cl
je 0x4935
movl %eax, %r15d
testq %r15, %r15
je 0x48e8
leaq (,%r15,4), %rdx
leaq (%rsp,%r15,4), %rdi
movq %rbx, %rsi
callq 0x10d0
cmpl $0x2, %r15d
jb 0x4935
movl $0x1, %eax
leaq 0x8(%rsp), %rcx
cmpl %r14d, (%rsp,%rax,4)
jne 0x4925
movl $0x1, %edx
movl -0x4(%rcx,%rdx,4), %esi
cmpl (%rbx,%rdx,4), %esi
jne 0x4917
incq %rdx
cmpq %rdx, %r15
jne 0x4903
movl %r15d, %edx
movl %edx, %edx
leaq (%rax,%rdx), %rsi
movl (%rsp,%rsi,4), %esi
cmpl (%rbx,%rdx,4), %esi
jg 0x4933
incq %rax
addq $0x4, %rcx
cmpq %r15, %rax
jne 0x48f8
jmp 0x4935
xorl %ebp, %ebp
movl %ebp, %eax
addq $0x38, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/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 0x1a756(%rip), %rax     # 0x1fb30
cmpq 0x1a757(%rip), %rax     # 0x1fb38
je 0x53f0
addq $0x10, %rax
movq %rax, 0x1a742(%rip)     # 0x1fb30
jmp 0x5417
movl $0x3e90, %edi           # imm = 0x3E90
callq 0x10e0
movq %rax, 0x1a72f(%rip)     # 0x1fb30
testq %rax, %rax
je 0x5419
movq %rax, %rcx
addq $0x3e80, %rcx           # imm = 0x3E80
movq %rcx, 0x1a721(%rip)     # 0x1fb38
popq %rcx
retq
callq 0x15bb
// File: /workspace/github_c_makefile_star2_O1/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 0x1a71a(%rip), %rax     # 0x1fb40
cmpq 0x1a71b(%rip), %rax     # 0x1fb48
je 0x543c
addq $0x10, %rax
movq %rax, 0x1a706(%rip)     # 0x1fb40
jmp 0x5463
movl $0x3e90, %edi           # imm = 0x3E90
callq 0x10e0
movq %rax, 0x1a6f3(%rip)     # 0x1fb40
testq %rax, %rax
je 0x5465
movq %rax, %rcx
addq $0x3e80, %rcx           # imm = 0x3E80
movq %rcx, 0x1a6e5(%rip)     # 0x1fb48
popq %rcx
retq
callq 0x15e0
// File: /workspace/github_c_makefile_star2_O1/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 %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
movq %rsi, %rbx
movslq %edi, %rax
leaq 0x1a9c9(%rip), %rcx     # 0x1ffc0
movq 0x8(%rcx,%rax,8), %r15
movslq 0x34(%rsp), %r12
movl (%r15), %r13d
cmpl %r12d, %r13d
jg 0x5672
movq 0x8(%r15), %r14
leaq 0x8(,%r12,8), %rdi
callq 0x10e0
movq %rax, 0x8(%r15)
testq %rax, %rax
je 0x56b6
leaq 0x1(%r12), %rax
xorl %ecx, %ecx
testl %r13d, %r13d
jle 0x5647
movq (%r14,%rcx,8), %rdx
movq 0x8(%r15), %rsi
movq %rdx, (%rsi,%rcx,8)
incq %rcx
cmpq %rcx, %r13
jne 0x5633
cmpl %r12d, %ecx
jg 0x5667
movl %ecx, %ecx
leal 0x1(%r12), %edx
movq 0x8(%r15), %rsi
movq $0x0, (%rsi,%rcx,8)
incq %rcx
cmpq %rcx, %rdx
jne 0x5653
movl %eax, (%r15)
movq %r14, %rdi
callq 0x1030
incl 0x1a948(%rip)           # 0x1ffc0
movzbl 0x1(%rbx), %eax
addl %eax, 0x1a942(%rip)     # 0x1ffc4
movq 0x8(%r15), %rax
movq (%rax,%r12,8), %r14
callq 0x53d2
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 0x569c
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
callq 0x164f
// File: /workspace/github_c_makefile_star2_O1/mishun[P]plantri/fullgen.c
// Function: schreibe_auf
void schreibe_auf(PLANMAP map, SEQUENZ sq, int rest_sechsecke)
/* codiert und schreibt eine markierte Pflasterung -- wird nur fuer
   bis zu 5 Fuenfecken aufgerufen */
{
int fuenfecke, sechsecke, i, codesize, pfadlaenge, non_nuller;
FLAECHENTYP code[9];


if ( !(do_sandwich || do_brille) ) return;
if (IPR && (!is_ipr)) return;

fuenfecke=6-sq.laenge;

if (fuenfecke < 2) return; /* die werden bei der konstruktion nie gebraucht */
for (i=non_nuller=0; i< sq.laenge; i++) if (sq.sequenz[i] != 0) non_nuller++;
if (non_nuller >2) return; /* Bei jedem Patch der GEBRAUCHT wird, koennen nur
			      an 2 Stellen Probleme auftreten */


pfadlaenge=sq.laenge;
for (i=0; i< sq.laenge; i++) pfadlaenge += (2*sq.sequenz[i]);

switch (fuenfecke)
  {
  case 5: { brillenglasmark[pfadlaenge]=1;
	    break; }

  case 4: { zwei_3_4_mark[pfadlaenge]=1;
            if (sq.sequenz[1]==0) /* dann kann es auch ein brillenglas sein */
	        brillenglasmark[pfadlaenge]=1;
	    break; }
  default: { zwei_3_4_mark[pfadlaenge]=1; }
  }

sechsecke=(map[0][0].name)-10+sq.laenge-sq.sequenz[0];
for (i=1; i<sq.laenge; i++) sechsecke -= sq.sequenz[i];
sechsecke=sechsecke/2;        /* alles leicht aus Euler Formel */


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

codesize=fuenfecke; 
codiere(map, code, sq.kanten[0], fuenfecke,0);

put_in_liste(sechsecke, sq, code, codesize );

return;
	   }

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
subq $0x78, %rsp
movb 0x1ad66(%rip), %al      # 0x20431
orb 0x1ad5f(%rip), %al      # 0x20430
je 0x57e6
cmpb $0x0, 0xfab3(%rip)      # 0x15191
je 0x56ed
cmpb $0x0, 0xfa7d(%rip)      # 0x15164
je 0x57e6
leaq 0xa0(%rsp), %rbx
movslq (%rbx), %rax
cmpq $0x4, %rax
jg 0x57e6
testl %eax, %eax
jle 0x5723
xorl %ecx, %ecx
xorl %edx, %edx
cmpl $0x1, 0x4(%rbx,%rcx,4)
sbbl $-0x1, %edx
incq %rcx
cmpq %rcx, %rax
jne 0x570a
cmpl $0x2, %edx
ja 0x57e6
movl %eax, %ecx
testl %eax, %eax
jle 0x573e
xorl %edx, %edx
movl %eax, %ecx
movl 0x4(%rbx,%rdx,4), %r8d
leal (%rcx,%r8,2), %ecx
incq %rdx
cmpq %rdx, %rax
jne 0x572d
movslq %ecx, %rcx
leaq 0x1acf8(%rip), %rdx     # 0x20440
cmpl $0x1, %eax
je 0x576d
cmpl $0x2, %eax
jne 0x5766
leaq 0x1af37(%rip), %r8      # 0x20690
movb $0x1, (%rcx,%r8)
cmpl $0x0, 0x8(%rbx)
jne 0x5771
jmp 0x576d
leaq 0x1af23(%rip), %rdx     # 0x20690
movb $0x1, (%rdx,%rcx)
movzwl 0x2(%rdi), %ecx
addl %eax, %ecx
subl 0x4(%rbx), %ecx
addl $-0xa, %ecx
cmpl $0x2, %eax
jl 0x5798
movq %rax, %rdx
decq %rdx
xorl %r8d, %r8d
subl 0x8(%rbx,%r8,4), %ecx
incq %r8
cmpq %r8, %rdx
jne 0x578b
movl %ecx, %ebp
shrl $0x1f, %ebp
addl %ecx, %ebp
sarl %ebp
addl %ebp, %esi
cmpl 0x1b12f(%rip), %esi     # 0x208d8
jne 0x57f1
movl $0x6, %r14d
subl %eax, %r14d
movq 0x20(%rbx), %rdx
leaq 0x6f(%rsp), %r15
movq %r15, %rsi
movl %r14d, %ecx
xorl %r8d, %r8d
callq 0x5079
movl $0xc, %ecx
movq %rsp, %rdi
movq %rbx, %rsi
rep  movsq (%rsi), %es:(%rdi)
movl %ebp, %edi
movq %r15, %rsi
movl %r14d, %edx
callq 0x546a
addq $0x78, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
callq 0x1674
// File: /workspace/github_c_makefile_star2_O1/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, 0x1b0ce(%rip)     # 0x208dc
je 0x58fb
movl %ecx, %ebx
movl %edx, %ebp
movq %rsi, %rdx
cmpb $0x0, 0xf96f(%rip)      # 0x15191
je 0x5831
cmpb $0x0, 0xf939(%rip)      # 0x15164
je 0x58fb
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 0x1b070(%rip), %eax     # 0x208d8
jne 0x590d
leaq 0x60(%rsp), %rsi
movl $0x8, %ecx
movl %ebp, %r8d
callq 0x5079
testl %eax, %eax
je 0x58fb
cmpb $0x0, 0x60(%rsp)
jne 0x5912
leaq 0x68(%rsp), %rsi
movl $0xc, %ecx
movq %rsp, %rdi
rep  movsq (%rsi), %es:(%rdi)
leaq 0x60(%rsp), %rsi
movl %r14d, %edi
callq 0x55e1
movslq %ebp, %rax
leaq 0x1b02a(%rip), %rcx     # 0x208e0
movb $0x1, (%rax,%rcx)
cmpl %ebp, %ebx
jl 0x58fb
leaq 0x60(%rsp), %r15
movb (%r15), %r13b
addl %ebp, %r14d
incb %r13b
leaq 0x68(%rsp), %r12
subl %ebp, %ebx
movb %r13b, 0x60(%rsp)
movl $0xc, %ecx
movq %rsp, %rdi
movq %r12, %rsi
rep  movsq (%rsi), %es:(%rdi)
movl %r14d, %edi
movq %r15, %rsi
callq 0x55e1
addl %ebp, %r14d
incb %r13b
cmpl %ebp, %ebx
jge 0x58d1
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_O1/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, 0x19017(%rip)     # 0x1fb50
movl 0x19d99(%rip), %ebx     # 0x208d8
testl %ebx, %ebx
js 0x6b82
leaq 0x1(%rbx), %r14
xorl %r15d, %r15d
leaq 0x18fff(%rip), %r12     # 0x1fb50
movl $0x20, %edi
callq 0x10e0
movq %rax, 0x8(%r12,%r15,8)
testq %rax, %rax
je 0x6bd3
movq $0x0, (%rax)
movl $0x0, 0x8(%rax)
incq %r15
xorps %xmm0, %xmm0
movups %xmm0, 0x10(%rax)
cmpq %r15, %r14
jne 0x6b51
movq $0x0, 0x19433(%rip) # 0x1ffc0
testl %ebx, %ebx
js 0x6bc7
incl %ebx
xorl %r14d, %r14d
leaq 0x19423(%rip), %r15     # 0x1ffc0
movl $0x10, %edi
callq 0x10e0
movq %rax, 0x8(%r15,%r14,8)
testq %rax, %rax
je 0x6bd8
movq $0x0, 0x8(%rax)
movl $0x0, (%rax)
incq %r14
cmpq %r14, %rbx
jne 0x6b9d
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
callq 0x1708
callq 0x172d
// File: /workspace/github_c_makefile_star2_O1/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 0x6c22
movq %rbp, -0xc(%r12,%r13)
jmp 0x6c4c
movq $0x0, -0xc(%r12,%r13)
cmpb $0x0, (%r14,%rax)
jne 0x6c4c
incl (%rbx)
movb $0x1, (%r14,%rax)
movzwl (%r12,%r13), %esi
movq %r15, %rdi
movq %r14, %rdx
movq %rbx, %rcx
callq 0x6bdd
addq $0x30, %r13
cmpq $0xa4, %r13
jne 0x6c0e
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/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 %rbx
movl %edx, %ebx
movq %rsi, %r14
movq %rdi, %r15
testl %edx, %edx
js 0x7e40
movl %ebx, %eax
leaq 0x2(,%rax,2), %rdx
movq %r14, %rdi
xorl %esi, %esi
callq 0x1080
testl %ebx, %ebx
jle 0x7eea
xorl %eax, %eax
movl $0x1, %ecx
movb $0x1, 0x11(%r15)
movq 0x28(%r15), %rdx
movq 0x20(%rdx), %rsi
cmpq %r15, %rsi
je 0x7e8a
movl $0x4, %edi
movb $0x1, 0x11(%rsi)
movq 0x28(%rsi), %rsi
movq 0x20(%rsi), %rsi
decl %edi
cmpq %r15, %rsi
jne 0x7e66
testl %edi, %edi
jne 0x7e8a
cltq
movw %cx, (%r14,%rax,2)
incl %eax
cmpl %ebx, %eax
je 0x7eea
incl %ecx
movq 0x18(%r15), %r15
cmpq %r15, %rdx
sete %sil
je 0x7ece
cmpb $0x0, 0x11(%r15)
je 0x7ec9
movl $0x1, %edi
movq 0x28(%r15), %rsi
movq 0x18(%rsi), %r15
cmpq %r15, %rdx
sete %sil
je 0x7ece
cmpb $0x0, 0x11(%r15)
je 0x7ec9
leal 0x1(%rdi), %r8d
cmpl $0x5, %edi
movl %r8d, %edi
jbe 0x7ea5
testb %sil, %sil
je 0x7ee2
cmpb $0x0, 0x11(%r15)
je 0x7ee2
cltq
movw %cx, (%r14,%rax,2)
incl %eax
cmpl %ebx, %eax
jl 0x7ef0
cmpl %ebx, %eax
jl 0x7e4f
popq %rbx
popq %r14
popq %r15
retq
callq 0x17c1
// File: /workspace/github_c_makefile_star2_O1/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 %rbx
movl %edx, %ebx
movq %rsi, %r14
movq %rdi, %r15
testl %edx, %edx
js 0x8527
movl %ebx, %eax
leaq 0x2(,%rax,2), %rdx
movq %r14, %rdi
xorl %esi, %esi
callq 0x1080
testl %ebx, %ebx
jle 0x85d1
xorl %eax, %eax
movl $0x1, %ecx
movb $0x1, 0x12(%r15)
movq 0x28(%r15), %rdx
movq 0x18(%rdx), %rsi
cmpq %r15, %rsi
je 0x8571
movl $0x4, %edi
movb $0x1, 0x12(%rsi)
movq 0x28(%rsi), %rsi
movq 0x18(%rsi), %rsi
decl %edi
cmpq %r15, %rsi
jne 0x854d
testl %edi, %edi
jne 0x8571
cltq
movw %cx, (%r14,%rax,2)
incl %eax
cmpl %ebx, %eax
je 0x85d1
incl %ecx
movq 0x20(%r15), %r15
cmpq %r15, %rdx
sete %sil
je 0x85b5
cmpb $0x0, 0x12(%r15)
je 0x85b0
movl $0x1, %edi
movq 0x28(%r15), %rsi
movq 0x20(%rsi), %r15
cmpq %r15, %rdx
sete %sil
je 0x85b5
cmpb $0x0, 0x12(%r15)
je 0x85b0
leal 0x1(%rdi), %r8d
cmpl $0x5, %edi
movl %r8d, %edi
jbe 0x858c
testb %sil, %sil
je 0x85c9
cmpb $0x0, 0x12(%r15)
je 0x85c9
cltq
movw %cx, (%r14,%rax,2)
incl %eax
cmpl %ebx, %eax
jl 0x85d7
cmpl %ebx, %eax
jl 0x8536
popq %rbx
popq %r14
popq %r15
retq
callq 0x17e6
// File: /workspace/github_c_makefile_star2_O1/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 0x9008
movzwl 0x2(%r14), %ecx
movw %cx, (%rbx,%rax,2)
movq %rbx, %rdi
movq %r15, %rsi
movq %r14, %rdx
callq 0x8fcd
movq 0x18(%r15), %rsi
movzwl 0x2(%rsi), %eax
cmpw $0x0, (%rbx,%rax,2)
jne 0x9025
movq 0x18(%r14), %rdx
movzwl 0x2(%rdx), %ecx
movw %cx, (%rbx,%rax,2)
jmp 0x8fd5
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O1/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 %r15
pushq %r14
pushq %rbx
movq %rdx, %rbx
movq %rsi, %r14
movq %rdi, %r15
testl %ecx, %ecx
je 0x905d
incl %ecx
cmpw $0x3, %cx
movl $0x2, %eax
cmovael %ecx, %eax
leaq 0x2(%r15), %rdi
decl %eax
movzwl %ax, %edx
addl %edx, %edx
xorl %esi, %esi
callq 0x1080
movzwl (%rbx), %eax
movzwl (%r14), %ecx
movw %ax, (%r15,%rcx,2)
movzwl 0x2(%rbx), %eax
movzwl 0x2(%r14), %ecx
movw %ax, (%r15,%rcx,2)
movq %r15, %rdi
movq %r14, %rsi
movq %rbx, %rdx
popq %rbx
popq %r14
popq %r15
jmp 0x8fcd
// File: /workspace/github_c_makefile_star2_O1/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 0x90c5
movzwl 0x2(%r14), %ecx
movw %cx, (%rbx,%rax,2)
movq %rbx, %rdi
movq %r15, %rsi
movq %r14, %rdx
callq 0x908a
movq 0x18(%r15), %rsi
movzwl 0x2(%rsi), %eax
cmpw $0x0, (%rbx,%rax,2)
jne 0x90e2
movq 0x20(%r14), %rdx
movzwl 0x2(%rdx), %ecx
movw %cx, (%rbx,%rax,2)
jmp 0x9092
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O1/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 %r15
pushq %r14
pushq %rbx
movq %rdx, %rbx
movq %rsi, %r14
movq %rdi, %r15
testl %ecx, %ecx
je 0x911a
incl %ecx
cmpw $0x3, %cx
movl $0x2, %eax
cmovael %ecx, %eax
leaq 0x2(%r15), %rdi
decl %eax
movzwl %ax, %edx
addl %edx, %edx
xorl %esi, %esi
callq 0x1080
movzwl (%rbx), %eax
movzwl (%r14), %ecx
movw %ax, (%r15,%rcx,2)
movzwl 0x2(%rbx), %eax
movzwl 0x2(%r14), %ecx
movw %ax, (%r15,%rcx,2)
movq %r15, %rdi
movq %r14, %rsi
movq %rbx, %rdx
popq %rbx
popq %r14
popq %r15
jmp 0x908a