LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O2/baskerville[P]bspwm/src/ewmh.c
// Function: ewmh_wm_state_update
void ewmh_wm_state_update(node_t *n)
{
	client_t *c = n->client;
	size_t count = 0;
	uint32_t values[12];
#define HANDLE_WM_STATE(s)  \
	if (WM_FLAG_##s & c->wm_flags) { \
		values[count++] = ewmh->_NET_WM_STATE_##s; \
	}
	HANDLE_WM_STATE(MODAL)
	HANDLE_WM_STATE(STICKY)
	HANDLE_WM_STATE(MAXIMIZED_VERT)
	HANDLE_WM_STATE(MAXIMIZED_HORZ)
	HANDLE_WM_STATE(SHADED)
	HANDLE_WM_STATE(SKIP_TASKBAR)
	HANDLE_WM_STATE(SKIP_PAGER)
	HANDLE_WM_STATE(HIDDEN)
	HANDLE_WM_STATE(FULLSCREEN)
	HANDLE_WM_STATE(ABOVE)
	HANDLE_WM_STATE(BELOW)
	HANDLE_WM_STATE(DEMANDS_ATTENTION)
#undef HANDLE_WM_STATE
	xcb_ewmh_set_wm_state(ewmh, n->id, count, values);
}

// Assembly:
subq $0x38, %rsp
movq 0x48(%rdi), %rax
movl 0x378(%rax), %ecx
movq 0xc262(%rip), %rax      # 0x28e30
testb $0x1, %cl
jne 0x1cbda
xorl %edx, %edx
movq %rsp, %rsi
jmp 0x1cbeb
leaq 0x4(%rsp), %rsi
movl 0x108(%rax), %edx
movl %edx, -0x4(%rsi)
pushq $0x1
popq %rdx
testb $0x2, %cl
je 0x1cbfd
movl 0x10c(%rax), %r8d
incq %rdx
movl %r8d, (%rsi)
testb $0x4, %cl
je 0x1cc0e
movl 0x110(%rax), %esi
movl %esi, (%rsp,%rdx,4)
incq %rdx
testb $0x8, %cl
je 0x1cc1f
movl 0x114(%rax), %esi
movl %esi, (%rsp,%rdx,4)
incq %rdx
testb $0x10, %cl
je 0x1cc30
movl 0x118(%rax), %esi
movl %esi, (%rsp,%rdx,4)
incq %rdx
testb $0x20, %cl
je 0x1cc41
movl 0x11c(%rax), %esi
movl %esi, (%rsp,%rdx,4)
incq %rdx
testb $0x40, %cl
je 0x1cc52
movl 0x120(%rax), %esi
movl %esi, (%rsp,%rdx,4)
incq %rdx
testb %cl, %cl
jns 0x1cc62
movl 0x124(%rax), %esi
movl %esi, (%rsp,%rdx,4)
incq %rdx
btl $0x8, %ecx
jae 0x1cc74
movl 0x128(%rax), %esi
movl %esi, (%rsp,%rdx,4)
incq %rdx
btl $0x9, %ecx
jae 0x1cc86
movl 0x12c(%rax), %esi
movl %esi, (%rsp,%rdx,4)
incq %rdx
btl $0xa, %ecx
jae 0x1cc98
movl 0x130(%rax), %esi
movl %esi, (%rsp,%rdx,4)
incq %rdx
btl $0xb, %ecx
jae 0x1ccaa
movl 0x134(%rax), %ecx
movl %ecx, (%rsp,%rdx,4)
incq %rdx
movl (%rdi), %esi
movq %rsp, %rcx
movq %rax, %rdi
callq 0x48a0
addq $0x38, %rsp
retq
// File: /workspace/github_c_makefile_star2_O2/baskerville[P]bspwm/src/ewmh.c
// Function: ewmh_set_supporting
void ewmh_set_supporting(xcb_window_t win)
{
	pid_t wm_pid = getpid();
	xcb_ewmh_set_supporting_wm_check(ewmh, root, win);
	xcb_ewmh_set_supporting_wm_check(ewmh, win, win);
	xcb_ewmh_set_wm_name(ewmh, win, strlen(WM_NAME), WM_NAME);
	xcb_ewmh_set_wm_pid(ewmh, win, wm_pid);
}

// Assembly:
pushq %rbp
pushq %rbx
pushq %rax
movl %edi, %ebx
callq 0x4370
movl %eax, %ebp
movq 0xc161(%rip), %rdi      # 0x28e30
leaq 0xbaa2(%rip), %rax      # 0x28778
movl (%rax), %esi
movl %ebx, %edx
callq 0x4450
movq 0xc14a(%rip), %rdi      # 0x28e30
movl %ebx, %esi
movl %ebx, %edx
callq 0x4450
movq 0xc13a(%rip), %rdi      # 0x28e30
leaq 0x1333(%rip), %rcx      # 0x1e030
pushq $0x5
popq %rdx
movl %ebx, %esi
callq 0x4720
movq 0xc122(%rip), %rdi      # 0x28e30
movl %ebx, %esi
movl %ebp, %edx
addq $0x8, %rsp
popq %rbx
popq %rbp
jmp 0x49d0
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O2/baskerville[P]bspwm/src/subscribe.c
// Function: make_subscriber
subscriber_list_t *make_subscriber(FILE *stream, char *fifo_path, int field, int count)
{
	subscriber_list_t *sb = calloc(1, sizeof(subscriber_list_t));
	sb->prev = sb->next = NULL;
	sb->stream = stream;
	sb->fifo_path = fifo_path;
	sb->field = field;
	sb->count = count;
	return sb;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movl %ecx, %ebx
movl %edx, %ebp
movq %rsi, %r14
movq %rdi, %r15
pushq $0x1
popq %rdi
pushq $0x28
popq %rsi
callq 0x48b0
movq %r15, (%rax)
movq %r14, 0x8(%rax)
movl %ebp, 0x10(%rax)
movl %ebx, 0x14(%rax)
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/baskerville[P]bspwm/src/subscribe.c
// Function: remove_subscriber
void remove_subscriber(subscriber_list_t *sb)
{
	if (sb == NULL) {
		return;
	}
	subscriber_list_t *a = sb->prev;
	subscriber_list_t *b = sb->next;
	if (a != NULL) {
		a->next = b;
	}
	if (b != NULL) {
		b->prev = a;
	}
	if (sb == subscribe_head) {
		subscribe_head = b;
	}
	if (sb == subscribe_tail) {
		subscribe_tail = a;
	}
	if (restart) {
		int cli_fd = fileno(sb->stream);
		fcntl(cli_fd, F_SETFD, ~FD_CLOEXEC & fcntl(cli_fd, F_GETFD));
	} else {
		fclose(sb->stream);
		unlink(sb->fifo_path);
	}
	free(sb->fifo_path);
	free(sb);
}

// Assembly:
testq %rdi, %rdi
je 0x1cdcc
pushq %rbp
pushq %rbx
pushq %rax
movq %rdi, %rbx
movq 0x18(%rdi), %rax
movq 0x20(%rdi), %rcx
testq %rax, %rax
je 0x1cd70
movq %rcx, 0x20(%rax)
testq %rcx, %rcx
je 0x1cd79
movq %rax, 0x18(%rcx)
leaq 0xb9d8(%rip), %rdx      # 0x28758
cmpq %rbx, (%rdx)
jne 0x1cd88
movq %rcx, (%rdx)
leaq 0xb9c1(%rip), %rcx      # 0x28750
cmpq %rbx, (%rcx)
jne 0x1cd97
movq %rax, (%rcx)
leaq 0xb942(%rip), %rax      # 0x286e0
movq (%rbx), %rdi
cmpb $0x1, (%rax)
jne 0x1cdcd
callq 0x4060
movl %eax, %ebp
pushq $0x1
popq %rsi
movl %eax, %edi
xorl %eax, %eax
callq 0x4aa0
andl $-0x2, %eax
pushq $0x2
popq %rsi
movl %ebp, %edi
movl %eax, %edx
xorl %eax, %eax
callq 0x4aa0
jmp 0x1cddb
retq
callq 0x48c0
movq 0x8(%rbx), %rdi
callq 0x42e0
movq 0x8(%rbx), %rdi
callq 0x4460
movq %rbx, %rdi
addq $0x8, %rsp
popq %rbx
popq %rbp
jmp 0x4460
// File: /workspace/github_c_makefile_star2_O2/baskerville[P]bspwm/src/subscribe.c
// Function: add_subscriber
void add_subscriber(subscriber_list_t *sb)
{
	if (subscribe_head == NULL) {
		subscribe_head = subscribe_tail = sb;
	} else {
		subscribe_tail->next = sb;
		sb->prev = subscribe_tail;
		subscribe_tail = sb;
	}
	int cli_fd = fileno(sb->stream);
	fcntl(cli_fd, F_SETFD, FD_CLOEXEC | fcntl(cli_fd, F_GETFD));
	if (sb->field & SBSC_MASK_REPORT) {
		print_report(sb->stream);
		if (sb->count-- == 1) {
			remove_subscriber(sb);
		}
	}
}

// Assembly:
pushq %rbp
pushq %rbx
pushq %rax
movq %rdi, %rbx
leaq 0xb959(%rip), %rax      # 0x28758
cmpq $0x0, (%rax)
je 0x1ce19
leaq 0xb944(%rip), %rax      # 0x28750
movq (%rax), %rax
movq %rbx, 0x20(%rax)
movq %rax, 0x18(%rbx)
jmp 0x1ce1c
movq %rbx, (%rax)
leaq 0xb92d(%rip), %rax      # 0x28750
movq %rbx, (%rax)
movq (%rbx), %rdi
callq 0x4060
movl %eax, %ebp
pushq $0x1
popq %rsi
movl %eax, %edi
xorl %eax, %eax
callq 0x4aa0
orl $0x1, %eax
pushq $0x2
popq %rsi
movl %ebp, %edi
movl %eax, %edx
xorl %eax, %eax
callq 0x4aa0
testb $0x1, 0x10(%rbx)
je 0x1ce77
movq (%rbx), %rdi
callq 0x1ce7e
movl 0x14(%rbx), %eax
leal -0x1(%rax), %ecx
movl %ecx, 0x14(%rbx)
cmpl $0x1, %eax
jne 0x1ce77
movq %rbx, %rdi
addq $0x8, %rsp
popq %rbx
popq %rbp
jmp 0x1cd54
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/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
movl %edi, %ebx
testb %al, %al
je 0x1d0cb
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)
leaq 0x20(%rsp), %r12
movq %rsi, 0x8(%r12)
movq %rdx, 0x10(%r12)
movq %rcx, 0x18(%r12)
movq %r8, 0x20(%r12)
movq %r9, 0x28(%r12)
leaq 0xb668(%rip), %rax      # 0x28758
movq (%rax), %rbp
pushq $0x8
popq %r13
movq %rsp, %r14
testq %rbp, %rbp
je 0x1d1a6
movq %rbp, %r15
movq 0x20(%rbp), %rbp
testl %ebx, 0x10(%r15)
je 0x1d0fa
movl 0x14(%r15), %eax
testl %eax, %eax
jle 0x1d11e
decl %eax
movl %eax, 0x14(%r15)
cmpl $0x1, %ebx
jne 0x1d12d
movq (%r15), %rdi
callq 0x1ce7e
jmp 0x1d188
movq %r12, 0x10(%rsp)
leaq 0x110(%rsp), %rax
movq %rax, 0x8(%rsp)
movabsq $0x3000000008, %rax     # imm = 0x3000000008
movq %rax, (%rsp)
cmpq $0x28, %r13
ja 0x1d164
movq 0x10(%rsp), %rax
addq %r13, %rax
leal 0x8(%r13), %ecx
movl %ecx, (%rsp)
jmp 0x1d172
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 0x4af0
testl %eax, %eax
je 0x1d199
movq %r15, %rdi
callq 0x1cd54
jmp 0x1d0fa
cmpl $0x0, 0x14(%r15)
jne 0x1d0fa
jmp 0x1d18c
addq $0xd8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/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 0xb595(%rip), %rax      # 0x28758
movq (%rax), %r14
testq %r14, %r14
je 0x1d1f5
movq %r14, %rbx
movq (%r14), %rdi
movq 0x20(%r14), %r14
callq 0x4060
movl %eax, %edi
xorl %esi, %esi
xorl %edx, %edx
callq 0x4a60
cmpq $-0x1, %rax
jne 0x1d1c6
movq %rbx, %rdi
callq 0x1cd54
jmp 0x1d1c6
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O2/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 %r15
pushq %r14
pushq %rbx
pushq %rax
leaq -0x20(%rbp), %rdi
callq 0x1050
callq 0x10b0
testl %eax, %eax
je 0x1282
movl %eax, %ebx
movl -0x20(%rbp), %edi
callq 0x1040
movl -0x1c(%rbp), %edi
leaq 0xe19(%rip), %rsi       # 0x2009
callq 0x1070
movq %rax, %r14
leaq 0xe0c(%rip), %rdi       # 0x200b
pushq $0x10
popq %rsi
pushq $0x1
popq %r15
movq %r15, %rdx
movq %rax, %rcx
callq 0x1090
leaq 0xe04(%rip), %rdi       # 0x201c
pushq $0xe
popq %rsi
movq %r15, %rdx
movq %r14, %rcx
callq 0x1090
leaq 0xdfe(%rip), %rdi       # 0x202b
pushq $0x12
popq %rsi
movq %r15, %rdx
movq %r14, %rcx
callq 0x1090
leaq 0xdfc(%rip), %rdi       # 0x203e
pushq $0x17
popq %rsi
movq %r15, %rdx
movq %r14, %rcx
callq 0x1090
leaq 0xdff(%rip), %rdi       # 0x2056
pushq $0x14
popq %rsi
movq %r15, %rdx
movq %r14, %rcx
callq 0x1090
movq %r14, %rdi
callq 0x1060
movl -0x1c(%rbp), %edi
callq 0x1040
movl %ebx, %edi
xorl %esi, %esi
xorl %edx, %edx
callq 0x1080
jmp 0x12a9
movl -0x1c(%rbp), %edi
callq 0x1040
movl -0x20(%rbp), %edi
xorl %esi, %esi
callq 0x1030
leaq 0xd69(%rip), %rdi       # 0x2004
movq %rdi, %rsi
xorl %edx, %edx
xorl %ecx, %ecx
xorl %eax, %eax
callq 0x10a0
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/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 0x11d8a(%rip), %r14     # 0x12ff8
movq (%r14), %rcx
leaq 0xcfa8(%rip), %rdi      # 0xe220
pushq $0xc
popq %rsi
pushq $0x1
popq %rdx
callq 0x1150
pushq $0x4
popq %r15
leaq 0x11f02(%rip), %r12     # 0x13190
leaq 0x11e2b(%rip), %r13     # 0x130c0
leaq 0xcf91(%rip), %rbx      # 0xe22d
xorl %ebp, %ebp
cmpq $0x74, %r15
je 0x12d8
movl (%r15,%r12), %ecx
testl %ecx, %ecx
jg 0x12b2
addq $0x4, %r15
jmp 0x129e
movq (%r14), %rdi
leaq (%r15,%r13), %rdx
movq %rbx, %rsi
xorl %eax, %eax
callq 0x10a0
incl %ebp
testb $0x3, %bpl
jne 0x12ac
movq (%r14), %rsi
pushq $0xa
popq %rdi
callq 0x1080
jmp 0x12ac
testb $0x3, %bpl
je 0x12f7
movq (%r14), %rsi
pushq $0xa
popq %rdi
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x1080
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/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:
andq $0x0, (%rdx)
movslq %esi, %rcx
cmpq %rcx, 0x8(%rdi)
jge 0x1322
movq 0x28(%rdi), %rax
movq %rax, (%rdx)
movq %rcx, 0x8(%rax)
movq %rcx, 0x8(%rdi)
pushq $0x1
popq %rax
movq %rdi, %rsi
movq 0x28(%rsi), %rsi
movq 0x20(%rsi), %rsi
cmpq %rdi, %rsi
je 0x134e
cmpq %rcx, 0x8(%rsi)
jge 0x134a
movq 0x28(%rsi), %r8
movq %r8, (%rdx)
movq %rcx, 0x8(%r8)
movq %rcx, 0x8(%rsi)
incl %eax
jmp 0x1328
retq
// File: /workspace/github_c_makefile_star2_O2/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:
andq $0x0, (%rdx)
movslq %esi, %rcx
cmpq %rcx, 0x8(%rdi)
jge 0x136b
movq 0x28(%rdi), %rax
movq %rax, (%rdx)
movq %rcx, 0x8(%rax)
movq %rcx, 0x8(%rdi)
pushq $0x1
popq %rax
movq %rdi, %rsi
movq 0x28(%rsi), %rsi
movq 0x18(%rsi), %rsi
cmpq %rdi, %rsi
je 0x1397
cmpq %rcx, 0x8(%rsi)
jge 0x1393
movq 0x28(%rsi), %r8
movq %r8, (%rdx)
movq %rcx, 0x8(%r8)
movq %rcx, 0x8(%rsi)
incl %eax
jmp 0x1371
retq
// File: /workspace/github_c_makefile_star2_O2/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, %r12d
movq %rdx, %rbx
movl %esi, %r14d
movq %rdi, %r15
incl %r14d
leaq 0x10(%rsp), %rdx
movl %r14d, %esi
callq 0x1306
cmpl $0x5, %eax
jne 0x1502
movb $0x1, 0x1c(%rsp)
movl $0x0, 0xc(%rsp)
pushq $0x1
popq %r13
xorl %ebp, %ebp
jmp 0x150f
pushq $-0x1
popq %rbp
pushq $0x1
popq %rax
movl %eax, 0xc(%rsp)
xorl %r13d, %r13d
leaq 0x10(%rsp), %rdx
movq %r15, %rdi
movl %r14d, %esi
callq 0x134f
cmpl $0x5, %eax
jne 0x1530
incl %ebp
movb $0x2, 0x1c(%rsp,%rbp)
incl %r13d
jmp 0x1534
incl 0xc(%rsp)
movq 0x28(%r15), %rax
movq 0x18(%rax), %rdi
movq %rdi, 0x10(%rsp)
movslq %ebp, %rax
xorl %ecx, %ecx
xorl %r15d, %r15d
cmpq %rax, %rcx
jg 0x1565
testb %r15b, %r15b
jne 0x1565
movb (%rbx,%rcx), %dl
cmpb %dl, 0x1c(%rsp,%rcx)
ja 0x15b6
setb %r15b
incq %rcx
jmp 0x1549
movl %r12d, 0x18(%rsp)
movb $0x3, %r12b
testq %rdi, %rdi
je 0x15ba
movl %r14d, %esi
leaq 0x10(%rsp), %rdx
callq 0x1306
cmpl $0x5, %eax
jne 0x159c
incl %r13d
movslq %ebp, %rbp
movb %r12b, 0x1d(%rsp,%rbp)
incq %rbp
testb %r15b, %r15b
je 0x15a2
movb $0x1, %r15b
jmp 0x15ac
incl 0xc(%rsp)
jmp 0x15ac
cmpb (%rbx,%rbp), %r12b
ja 0x15b6
setb %r15b
incb %r12b
movq 0x10(%rsp), %rdi
jmp 0x156d
xorl %eax, %eax
jmp 0x15e2
xorl %eax, %eax
cmpl $0xc, %r13d
jl 0x15e2
movl 0xc(%rsp), %ecx
cmpl 0x18(%rsp), %ecx
jl 0x15e2
xorl %eax, %eax
cmpq $0xc, %rax
je 0x15e0
movb 0x1c(%rsp,%rax), %cl
movb %cl, (%rbx,%rax)
incq %rax
jmp 0x15ce
movb $0x1, %al
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/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, 0x11c2d(%rip)     # 0x13234
jne 0x1625
leaq 0xcc29(%rip), %rdi      # 0xe239
pushq $0x19
popq %rsi
pushq $0x1
popq %rdx
movq %rbx, %rcx
callq 0x1150
movb $0x1, 0x11c0f(%rip)     # 0x13234
movzwl 0x2(%r14), %eax
cmpw $0x63, %ax
jbe 0x167a
leaq 0xf2(%r14), %r13
pushq $0x1
popq %r15
leaq 0xcc11(%rip), %r12      # 0xe253
movzwl %ax, %eax
cmpq %rax, %r15
ja 0x16c4
movzwl -0x60(%r13), %ecx
movzwl -0x30(%r13), %r8d
movzwl (%r13), %r9d
movq %rbx, %rdi
movq %r12, %rsi
movl %r15d, %edx
xorl %eax, %eax
callq 0x10a0
incq %r15
movzwl 0x2(%r14), %eax
addq $0x90, %r13
jmp 0x1642
pushq $0x1
popq %r15
leaq 0xf2(%r14), %r13
leaq 0xcbe1(%rip), %r12      # 0xe26d
movzwl %ax, %eax
cmpq %rax, %r15
ja 0x16c4
movzwl -0x60(%r13), %ecx
movzwl -0x30(%r13), %r8d
movzwl (%r13), %r9d
movq %rbx, %rdi
movq %r12, %rsi
movl %r15d, %edx
xorl %eax, %eax
callq 0x10a0
incq %r15
movzwl 0x2(%r14), %eax
addq $0x90, %r13
jmp 0x168c
leaq 0xcbbc(%rip), %rdi      # 0xe287
pushq $0x2
popq %rsi
pushq $0x1
popq %rdx
movq %rbx, %rcx
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
jmp 0x1150
// File: /workspace/github_c_makefile_star2_O2/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
cmpw $0xff, %ax
ja 0x1ae3
movb %al, (%rsi)
movl $0x1, %eax
movabsq $0x1, %rcx
movabsq $0x100000000, %rdx      # imm = 0x100000000
movzwl 0x2(%rdi), %r8d
cmpq %r8, %rcx
ja 0x1b8a
imulq $0x90, %rcx, %r9
addq %rdi, %r9
movslq %eax, %r8
leal 0x1(%r8), %eax
leaq (%rsi,%r8), %r10
shlq $0x20, %r8
movq %r9, %r11
addq %rdx, %r8
movb 0x2(%r11), %bl
movb %bl, (%r10)
movq 0x20(%r11), %r11
incl %eax
incq %r10
cmpq %r9, %r11
jne 0x1abd
sarq $0x20, %r8
movb $0x0, (%rsi,%r8)
incq %rcx
jmp 0x1a93
movabsq $0x200000000, %rcx      # imm = 0x200000000
movb $0x0, (%rsi)
movb 0x2(%rdi), %al
movb %al, 0x1(%rsi)
movb 0x3(%rdi), %al
movb %al, 0x2(%rsi)
leaq 0x3(%rsi), %rdx
movl $0x3, %eax
movabsq $0x1, %r8
xorl %r9d, %r9d
movzwl 0x2(%rdi), %r10d
cmpq %r10, %r8
ja 0x1b8a
imulq $0x90, %r8, %r10
leaq (%rdi,%r10), %r11
movb 0x2(%rdi,%r10), %bpl
movslq %eax, %rbx
movb %bpl, (%rsi,%rbx)
movb 0x3(%rdi,%r10), %al
movb %al, 0x1(%rsi,%rbx)
movq %rbx, %r10
shlq $0x20, %r10
leal 0x4(%rbx), %eax
addq %rdx, %rbx
movq %r11, %r14
movq 0x20(%r14), %r14
cmpq %r11, %r14
je 0x1b70
movb 0x2(%r14), %bpl
movb %bpl, -0x1(%rbx)
movb 0x3(%r14), %bpl
movb %bpl, (%rbx)
addq %rcx, %r10
addl $0x2, %eax
addq $0x2, %rbx
jmp 0x1b4c
leaq (%r10,%rcx), %r11
sarq $0x20, %r11
movb %r9b, (%rsi,%r11)
sarq $0x20, %r10
movb %r9b, 0x3(%rsi,%r10)
incq %r8
jmp 0x1b12
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/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), %ecx
movl %ecx, %eax
addl $-0x14, %eax
leaq 0x1(%rcx), %rdx
movq %rdi, 0x10(%rsp)
leaq 0xa4(%rdi), %rsi
pushq $0x1
popq %rdi
cmpq %rdx, %rdi
je 0x2245
xorl %r8d, %r8d
cmpq $0x90, %r8
je 0x2239
andw $0x0, (%rsi,%r8)
andq $0x0, -0xc(%rsi,%r8)
addq $0x30, %r8
jmp 0x221e
incq %rdi
addq $0x90, %rsi
jmp 0x2216
xorl %edx, %edx
cmpq $0xc, %rdx
je 0x2257
movb $-0x1, 0x24(%rsp,%rdx)
incq %rdx
jmp 0x2247
pushq $0x2
popq %rsi
cltd
idivl %esi
movl %eax, 0xc(%rsp)
movq 0x10(%rsp), %rax
addq $0x90, %rax
movq %rax, 0x18(%rsp)
movq $0x0, (%rsp)
pushq $0x1
popq %r14
pushq $0x1
popq %rdx
movl 0xc(%rsp), %r13d
movzwl %cx, %eax
cmpq %rax, %rdx
ja 0x231a
movq %rdx, 0x30(%rsp)
xorl %r15d, %r15d
cmpq $0x90, %r15
je 0x22fb
movb $-0x1, %al
movb %al, 0x24(%rsp)
movq 0x18(%rsp), %rax
leaq (%rax,%r15), %r12
movq %r12, %rdi
movl %r14d, %esi
leaq 0x24(%rsp), %rbp
movq %rbp, %rdx
movl %r13d, %ecx
callq 0x1398
movzbl %al, %eax
movq (%rsp), %rbx
addl %eax, %ebx
leal 0x1(%r14), %esi
movb $-0x1, %al
movb %al, 0x24(%rsp)
movq %r12, %rdi
movq %rbp, %rdx
movl %r13d, %ecx
callq 0x14be
movzbl %al, %eax
addl %eax, %ebx
movq %rbx, (%rsp)
addl $0x2, %r14d
addq $0x30, %r15
jmp 0x2299
movq 0x30(%rsp), %rdx
incq %rdx
movq 0x10(%rsp), %rax
movzwl 0x2(%rax), %ecx
addq $0x90, 0x18(%rsp)
jmp 0x2285
movslq (%rsp), %rax
leaq 0x112ab(%rip), %rcx     # 0x135d0
incl (%rcx,%rax,4)
addq $0x38, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/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 %r15
pushq %r14
pushq %r12
pushq %rbx
movq %rsi, %rbx
movq %rdi, %r14
pushq $0xc
popq %rbp
pushq $0x10
popq %r15
pushq $0x18
popq %r12
cmpb $0x0, (%rbx)
je 0x23b3
movq %r14, %rdi
movq %rbx, %rsi
movl %ebp, %edx
callq 0x2357
movq %r15, %rcx
testl %eax, %eax
js 0x23ad
movq %r12, %rcx
je 0x23f4
movq (%rbx,%rcx), %rbx
jmp 0x238f
xorl %eax, %eax
cmpq $0xc, %rax
je 0x23c7
movb (%r14,%rax), %cl
movb %cl, (%rbx,%rax)
incq %rax
jmp 0x23b5
pushq $0x20
popq %r14
movq %r14, %rdi
callq 0x10c0
movq %rax, 0x10(%rbx)
xorl %ebp, %ebp
movb %bpl, (%rax)
movq %r14, %rdi
callq 0x10c0
movq %rax, 0x18(%rbx)
movb %bpl, (%rax)
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
movq 0x10bfd(%rip), %rax     # 0x12ff8
movq (%rax), %rcx
leaq 0xbeab(%rip), %rdi      # 0xe2b0
pushq $0x26
popq %rsi
pushq $0x1
popq %rdx
callq 0x1150
pushq $0x2
popq %rdi
callq 0x1140
// File: /workspace/github_c_makefile_star2_O2/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
movq %rdi, %r14
movl %esi, 0x4(%rsp)
movslq %esi, %r13
cmpb $0x0, (%r14)
je 0x2492
movq 0x10(%r14), %rdi
movl 0x4(%rsp), %esi
movq %rbx, %rdx
callq 0x2418
movq (%rbx), %rcx
movb $-0x1, %al
incb %al
movzbl %al, %r15d
movb (%r14,%r15), %dl
cmpb (%rcx,%r15), %dl
je 0x244b
leaq (%r14,%r15), %r12
leaq 0x12d9a(%rip), %rbp     # 0x15200
movq (%rbp,%r13,8), %rsi
movsbl %al, %edi
callq 0x1080
pushq $0xc
popq %rdx
subq %r15, %rdx
movq (%rbp,%r13,8), %rcx
movq %r12, %rdi
pushq $0x1
popq %rsi
callq 0x1150
movq %r14, (%rbx)
movq 0x18(%r14), %r14
jmp 0x2430
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/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:
andw $0x0, 0x2(%rdi)
leaq 0x90(%rdi), %rax
pushq $0x1
popq %rcx
cmpq $0x245, %rcx            # imm = 0x245
je 0x2a0f
imulq $0x90, %rcx, %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
cmpq $0x90, %rdx
je 0x2a04
movw %cx, (%rax,%rdx)
movw $0xfffe, 0x2(%rax,%rdx) # imm = 0xFFFE
andq $0x0, 0x28(%rax,%rdx)
addq $0x30, %rdx
jmp 0x29e4
incq %rcx
addq $0x90, %rax
jmp 0x29a9
retq
// File: /workspace/github_c_makefile_star2_O2/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:
cmpl $0x2, %edi
jle 0x2b0b
pushq %rbp
pushq %r14
pushq %rbx
movq %rdx, %r14
movq %rsi, %rbx
movl %edi, %ebp
movq %rsi, %rdi
callq 0x299a
movw %bp, 0x92(%rbx)
movw $0x246, 0xc2(%rbx)      # imm = 0x246
movw $0x2, 0xf2(%rbx)
movl %ebp, %ecx
imulq $0x90, %rcx, %rax
leaq (%rbx,%rax), %rdx
addq $0x60, %rdx
movq %rdx, 0xb8(%rbx)
andq $0x0, 0xe8(%rbx)
leaq 0xc0(%rbx), %rdx
addq %rbx, %rax
leaq 0x120(%rbx), %rsi
movq %rsi, 0x118(%rbx)
movq %rdx, (%r14)
addq $-0x2, %rcx
leaq 0x1b0(%rbx), %rdx
pushq $0x2
popq %rsi
subq $0x1, %rcx
jb 0x2ac9
leal -0x1(%rsi), %edi
movw %di, -0x8e(%rdx)
movw $0x246, -0x5e(%rdx)     # imm = 0x246
incq %rsi
movw %si, -0x2e(%rdx)
leaq -0xc0(%rdx), %rdi
movq %rdi, -0x68(%rdx)
andq $0x0, -0x38(%rdx)
movq %rdx, -0x8(%rdx)
addq $0x90, %rdx
jmp 0x2a8f
movl %ebp, %ecx
decl %ecx
movw %cx, 0x2(%rax)
movw $0x246, 0x32(%rax)      # imm = 0x246
movw $0x1, 0x62(%rax)
imulq $0x90, %rcx, %rcx
addq %rbx, %rcx
addq $0x60, %rcx
movq %rcx, 0x28(%rax)
andq $0x0, 0x58(%rax)
leaq 0x90(%rbx), %rcx
movq %rcx, 0x88(%rax)
movw %bp, 0x2(%rbx)
popq %rbx
popq %r14
popq %rbp
retq
movq 0x104e6(%rip), %rax     # 0x12ff8
movq (%rax), %rcx
leaq 0xb7e9(%rip), %rdi      # 0xe305
pushq $0x1b
popq %rsi
pushq $0x1
popq %rdx
jmp 0x1150
// File: /workspace/github_c_makefile_star2_O2/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:
movl (%rdi), %ecx
movl $0x1, %r8d
leaq -0x38(%rsp), %rsi
xorl %edx, %edx
movl %ecx, %eax
cmpl $0xfffe, %eax           # imm = 0xFFFE
je 0x2db7
movl %eax, (%rsi)
xorl %r9d, %r9d
cmpl %ecx, %eax
je 0x2da7
movl %r8d, %r9d
jg 0x2e30
movl 0x4(%rdi,%rdx,4), %eax
incq %rdx
addq $0x4, %rsi
movl %r9d, %r8d
jmp 0x2d8e
movl $0x1, %eax
testl %r8d, %r8d
je 0x2dc2
retq
xorl %r8d, %r8d
cmpq %r8, %rdx
je 0x2dda
movl (%rdi,%r8,4), %r9d
movl %r9d, (%rsi)
incq %r8
addq $0x4, %rsi
jmp 0x2dc5
movabsq $0x1, %rsi
leaq -0x30(%rsp), %r8
movq %rsi, %r9
cmpq %rdx, %r9
jae 0x2dc1
cmpl %ecx, -0x38(%rsp,%r9,4)
jne 0x2e27
movq %rsi, %r10
cmpq %r10, %rdx
je 0x2e10
movl -0x4(%r8,%r10,4), %r11d
cmpl (%rdi,%r10,4), %r11d
jne 0x2e15
incq %r10
jmp 0x2dfb
movq %rdx, %r10
jmp 0x2e18
movl %r10d, %r10d
leaq (%r10,%r9), %r11
movl -0x38(%rsp,%r11,4), %r11d
cmpl (%rdi,%r10,4), %r11d
jg 0x2e30
incq %r9
addq $0x4, %r8
jmp 0x2dec
xorl %eax, %eax
retq
// File: /workspace/github_c_makefile_star2_O2/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 0x1a39a(%rip), %rax     # 0x1db10
cmpq 0x1a39b(%rip), %rax     # 0x1db18
je 0x378c
addq $0x10, %rax
movq %rax, 0x1a386(%rip)     # 0x1db10
jmp 0x37b3
movl $0x3e90, %edi           # imm = 0x3E90
callq 0x10c0
movq %rax, 0x1a373(%rip)     # 0x1db10
testq %rax, %rax
je 0x37b5
movq %rax, %rcx
addq $0x3e80, %rcx           # imm = 0x3E80
movq %rcx, 0x1a365(%rip)     # 0x1db18
popq %rcx
retq
movq 0xf83c(%rip), %rax      # 0x12ff8
movq (%rax), %rcx
leaq 0xac88(%rip), %rdi      # 0xe44e
pushq $0x23
popq %rsi
pushq $0x1
popq %rdx
callq 0x1150
pushq $0xb
popq %rdi
callq 0x1140
// File: /workspace/github_c_makefile_star2_O2/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 0x1a33f(%rip), %rax     # 0x1db20
cmpq 0x1a340(%rip), %rax     # 0x1db28
je 0x37f7
addq $0x10, %rax
movq %rax, 0x1a32b(%rip)     # 0x1db20
jmp 0x381e
movl $0x3e90, %edi           # imm = 0x3E90
callq 0x10c0
movq %rax, 0x1a318(%rip)     # 0x1db20
testq %rax, %rax
je 0x3820
movq %rax, %rcx
addq $0x3e80, %rcx           # imm = 0x3E80
movq %rcx, 0x1a30a(%rip)     # 0x1db28
popq %rcx
retq
movq 0xf7d1(%rip), %rax      # 0x12ff8
movq (%rax), %rcx
leaq 0xac41(%rip), %rdi      # 0xe472
pushq $0x21
popq %rsi
pushq $0x1
popq %rdx
callq 0x1150
pushq $0xc
popq %rdi
callq 0x1140
// File: /workspace/github_c_makefile_star2_O2/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 0x1a5a4(%rip), %rcx     # 0x1dfa0
movq 0x8(%rcx,%rax,8), %r15
movslq 0x34(%rsp), %r12
movl (%r15), %r13d
cmpl %r12d, %r13d
jg 0x3a6d
movq 0x8(%r15), %r14
leaq 0x8(,%r12,8), %rdi
callq 0x10c0
movq %rax, 0x8(%r15)
testq %rax, %rax
je 0x3ab3
movq %r12, %rax
incq %rax
xorl %ecx, %ecx
testl %r13d, %r13d
cmovlel %ecx, %r13d
cmpq %rcx, %r13
je 0x3a5d
movq (%r14,%rcx,8), %rdx
movq 0x8(%r15), %rsi
movq %rdx, (%rsi,%rcx,8)
incq %rcx
jmp 0x3a3b
movq 0x8(%r15), %rcx
andq $0x0, (%rcx,%r13,8)
incq %r13
cmpq %r12, %r13
jle 0x3a51
movl %eax, (%r15)
movq %r14, %rdi
callq 0x1030
incl 0x1a52d(%rip)           # 0x1dfa0
movzbl 0x1(%rbx), %eax
addl %eax, 0x1a527(%rip)     # 0x1dfa4
movq 0x8(%r15), %rax
movq (%rax,%r12,8), %r14
callq 0x376e
movq 0x8(%r15), %rcx
movq %rax, (%rcx,%r12,8)
movq %r14, (%rax)
xorl %ecx, %ecx
cmpq $0x8, %rcx
je 0x3aa9
movb (%rbx,%rcx), %dl
movb %dl, 0x8(%rax,%rcx)
incq %rcx
jmp 0x3a97
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
movq 0xf53e(%rip), %rax      # 0x12ff8
movq (%rax), %rcx
leaq 0xa9d0(%rip), %rdi      # 0xe494
pushq $0x17
popq %rsi
pushq $0x1
popq %rdx
callq 0x1150
pushq $0xf
popq %rdi
callq 0x1140
// File: /workspace/github_c_makefile_star2_O2/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, 0x1ac7c(%rip)     # 0x1e8bc
je 0x3d15
movl %ecx, %ebx
movl %edx, %ebp
movq %rsi, %r8
cmpb $0x0, 0xf51d(%rip)      # 0x13171
je 0x3c63
cmpb $0x0, 0xf4e7(%rip)      # 0x13144
je 0x3d15
andl $0x0, 0x68(%rsp)
movl %ebp, 0x6c(%rsp)
movq %r8, 0x88(%rsp)
movzwl 0x2(%rdi), %eax
subl %ebp, %eax
addl $-0xa, %eax
pushq $0x2
popq %rcx
cltd
idivl %ecx
movl %eax, %r14d
leal (%r14,%rbx), %eax
cmpl 0x1ac28(%rip), %eax     # 0x1e8b8
jne 0x3d27
leaq 0x60(%rsp), %rsi
pushq $0x8
popq %rcx
movq %r8, %rdx
movl %ebp, %r8d
callq 0x3439
testl %eax, %eax
je 0x3d15
cmpb $0x0, 0x60(%rsp)
jne 0x3d47
pushq $0xc
popq %rcx
leaq 0x68(%rsp), %r12
movq %rsp, %rdi
movq %r12, %rsi
rep  movsq (%rsi), %es:(%rdi)
leaq 0x60(%rsp), %r13
movl %r14d, %edi
movq %r13, %rsi
callq 0x39e6
movslq %ebp, %rax
leaq 0x1abdd(%rip), %rcx     # 0x1e8c0
movb $0x1, (%rax,%rcx)
addl %ebp, %r14d
movb $0x1, %r15b
subl %ebp, %ebx
jl 0x3d15
movb %r15b, 0x60(%rsp)
pushq $0xc
popq %rcx
movq %rsp, %rdi
movq %r12, %rsi
rep  movsq (%rsi), %es:(%rdi)
movl %r14d, %edi
movq %r13, %rsi
callq 0x39e6
incb %r15b
addl %ebp, %r14d
jmp 0x3ced
addq $0xc8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq 0xf2ca(%rip), %rax      # 0x12ff8
movq (%rax), %rcx
leaq 0xa7a1(%rip), %rdi      # 0xe4d9
pushq $0x37
popq %rsi
pushq $0x1
popq %rdx
callq 0x1150
pushq $0x12
jmp 0x3d65
movq 0xf2aa(%rip), %rax      # 0x12ff8
movq (%rax), %rcx
leaq 0xa7b9(%rip), %rdi      # 0xe511
pushq $0x21
popq %rsi
pushq $0x1
popq %rdx
callq 0x1150
pushq $0x13
popq %rdi
callq 0x1140
// File: /workspace/github_c_makefile_star2_O2/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
andl $0x0, 0x18ca2(%rip)     # 0x1db30
movslq 0x19a23(%rip), %r14     # 0x1e8b8
xorl %r15d, %r15d
pushq $0x20
popq %rbx
leaq 0x18c8e(%rip), %r12     # 0x1db30
cmpq %r14, %r15
jg 0x4ecd
movq %rbx, %rdi
callq 0x10c0
movq %rax, 0x8(%r12,%r15,8)
testq %rax, %rax
je 0x4f12
andq $0x0, (%rax)
andl $0x0, 0x8(%rax)
incq %r15
xorps %xmm0, %xmm0
movups %xmm0, 0x10(%rax)
jmp 0x4ea2
andq $0x0, 0x190cb(%rip)     # 0x1dfa0
xorl %r15d, %r15d
pushq $0x10
popq %rbx
leaq 0x190be(%rip), %r12     # 0x1dfa0
cmpq %r14, %r15
jg 0x4f06
movq %rbx, %rdi
callq 0x10c0
movq %rax, 0x8(%r12,%r15,8)
testq %rax, %rax
je 0x4f32
andq $0x0, 0x8(%rax)
andl $0x0, (%rax)
incq %r15
jmp 0x4ee2
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
movq 0xe0df(%rip), %rax      # 0x12ff8
movq (%rax), %rcx
leaq 0x9571(%rip), %rdi      # 0xe494
pushq $0x17
popq %rsi
pushq $0x1
popq %rdx
callq 0x1150
pushq $0x1b
jmp 0x4f50
movq 0xe0bf(%rip), %rax      # 0x12ff8
movq (%rax), %rcx
leaq 0x9551(%rip), %rdi      # 0xe494
pushq $0x17
popq %rsi
pushq $0x1
popq %rdx
callq 0x1150
pushq $0x1c
popq %rdi
callq 0x1140
// File: /workspace/github_c_makefile_star2_O2/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
imulq $0x90, %rax, %r12
addq %rdi, %r12
pushq $0x14
popq %r13
movabsq $0x7fffffffffffffff, %rbp # imm = 0x7FFFFFFFFFFFFFFF
cmpq $0xa4, %r13
je 0x4fce
movzwl (%r12,%r13), %eax
cmpq $0x246, %rax            # imm = 0x246
jne 0x4fa1
movq %rbp, -0xc(%r12,%r13)
jmp 0x4fc8
andq $0x0, -0xc(%r12,%r13)
cmpb $0x0, (%r14,%rax)
jne 0x4fc8
incl (%rbx)
movb $0x1, (%r14,%rax)
movzwl (%r12,%r13), %esi
movq %r15, %rdi
movq %r14, %rdx
movq %rbx, %rcx
callq 0x4f56
addq $0x30, %r13
jmp 0x4f84
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/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 %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movl %edx, %ebx
movq %rsi, %r14
movq %rdi, %r15
movslq %edx, %rax
xorl %ecx, %ecx
cmpq %rax, %rcx
jg 0x5ed2
andw $0x0, (%r14,%rcx,2)
incq %rcx
jmp 0x5ec2
pushq $0x1
popq %rbp
xorl %r12d, %r12d
movl %ebp, %r13d
cmpl %ebx, %r12d
jge 0x5f5c
movq %r15, %rdi
callq 0x5e8a
cmpl $0x5, %eax
jne 0x5efd
movslq %r12d, %rax
movw %r13w, (%r14,%rax,2)
incl %r12d
cmpl %ebx, %r12d
je 0x5f5c
incl %r13d
movq 0x28(%r15), %rax
movl %ebp, %ecx
movq 0x18(%r15), %r15
movb 0x11(%r15), %dl
cmpq %r15, %rax
je 0x5f24
testb %dl, %dl
je 0x5edb
cmpl $0x6, %ecx
ja 0x5edb
movq 0x28(%r15), %r15
incl %ecx
jmp 0x5f06
testb %dl, %dl
je 0x5edb
movslq %r12d, %r12
movw %r13w, (%r14,%r12,2)
incl %r12d
cmpl %ebx, %r12d
jge 0x5edb
movq 0xd0b9(%rip), %rax      # 0x12ff8
movq (%rax), %rcx
leaq 0x8684(%rip), %rdi      # 0xe5cd
pushq $0x37
popq %rsi
pushq $0x1
popq %rdx
callq 0x1150
pushq $0x20
popq %rdi
callq 0x1140
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/mishun[P]plantri/fullgen.c
// Function: reko_patch_sp
void reko_patch_sp(KANTE *anfang,KNOTENTYP code[],int fuenfecke)
{
int i, position, zaehler, z2;
KANTE *run, *merke;


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

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

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

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

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movl %edx, %ebx
movq %rsi, %r14
movq %rdi, %r15
movslq %edx, %rax
xorl %ecx, %ecx
cmpq %rax, %rcx
jg 0x6445
andw $0x0, (%r14,%rcx,2)
incq %rcx
jmp 0x6435
pushq $0x1
popq %rbp
xorl %r12d, %r12d
movl %ebp, %r13d
cmpl %ebx, %r12d
jge 0x64cf
movq %r15, %rdi
callq 0x63fd
cmpl $0x5, %eax
jne 0x6470
movslq %r12d, %rax
movw %r13w, (%r14,%rax,2)
incl %r12d
cmpl %ebx, %r12d
je 0x64cf
incl %r13d
movq 0x28(%r15), %rax
movl %ebp, %ecx
movq 0x20(%r15), %r15
movb 0x12(%r15), %dl
cmpq %r15, %rax
je 0x6497
testb %dl, %dl
je 0x644e
cmpl $0x6, %ecx
ja 0x644e
movq 0x28(%r15), %r15
incl %ecx
jmp 0x6479
testb %dl, %dl
je 0x644e
movslq %r12d, %r12
movw %r13w, (%r14,%r12,2)
incl %r12d
cmpl %ebx, %r12d
jge 0x644e
movq 0xcb46(%rip), %rax      # 0x12ff8
movq (%rax), %rcx
leaq 0x8149(%rip), %rdi      # 0xe605
pushq $0x3a
popq %rsi
pushq $0x1
popq %rdx
callq 0x1150
pushq $0x21
popq %rdi
callq 0x1140
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/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 0x6ccc
movzwl 0x2(%r14), %ecx
movw %cx, (%rbx,%rax,2)
movq %rbx, %rdi
movq %r15, %rsi
movq %r14, %rdx
callq 0x6c91
movq 0x18(%r15), %rsi
movzwl 0x2(%rsi), %eax
cmpw $0x0, (%rbx,%rax,2)
jne 0x6ce9
movq 0x18(%r14), %rdx
movzwl 0x2(%rdx), %ecx
movw %cx, (%rbx,%rax,2)
jmp 0x6c99
popq %rbx
popq %r14
popq %r15
retq