LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O0/baskerville[P]bspwm/src/ewmh.c
// Function: ewmh_update_desktop_names
void ewmh_update_desktop_names(void)
{
	char names[MAXLEN];
	unsigned int i, j;
	uint32_t names_len;
	i = 0;

	for (monitor_t *m = mon_head; m != NULL; m = m->next) {
		for (desktop_t *d = m->desk_head; d != NULL; d = d->next) {
			for (j = 0; d->name[j] != '\0' && (i + j) < sizeof(names); j++) {
				names[i + j] = d->name[j];
			}
			i += j;
			if (i < sizeof(names)) {
				names[i++] = '\0';
			}
		}
	}

	if (i < 1) {
		xcb_ewmh_set_desktop_names(ewmh, default_screen, 0, NULL);
		return;
	}

	names_len = i - 1;
	xcb_ewmh_set_desktop_names(ewmh, default_screen, names_len, names);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x130, %rsp            # imm = 0x130
movl $0x0, -0x104(%rbp)
leaq 0xa6fc(%rip), %rax      # 0x356f8
movq (%rax), %rax
movq %rax, -0x118(%rbp)
cmpq $0x0, -0x118(%rbp)
je 0x2b128
movq -0x118(%rbp), %rax
movq 0x60(%rax), %rax
movq %rax, -0x120(%rbp)
cmpq $0x0, -0x120(%rbp)
je 0x2b10f
movl $0x0, -0x108(%rbp)
movq -0x120(%rbp), %rax
movl -0x108(%rbp), %ecx
movsbl (%rax,%rcx), %ecx
xorl %eax, %eax
cmpl $0x0, %ecx
movb %al, -0x129(%rbp)
je 0x2b079
movl -0x104(%rbp), %eax
addl -0x108(%rbp), %eax
movl %eax, %eax
cmpq $0x100, %rax            # imm = 0x100
setb %al
movb %al, -0x129(%rbp)
movb -0x129(%rbp), %al
testb $0x1, %al
jne 0x2b085
jmp 0x2b0bb
movq -0x120(%rbp), %rax
movl -0x108(%rbp), %ecx
movb (%rax,%rcx), %cl
movl -0x104(%rbp), %eax
addl -0x108(%rbp), %eax
movl %eax, %eax
movb %cl, -0x100(%rbp,%rax)
movl -0x108(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x108(%rbp)
jmp 0x2b03e
movl -0x108(%rbp), %eax
addl -0x104(%rbp), %eax
movl %eax, -0x104(%rbp)
movl -0x104(%rbp), %eax
cmpq $0x100, %rax            # imm = 0x100
jae 0x2b0f6
movl -0x104(%rbp), %eax
movl %eax, %ecx
addl $0x1, %ecx
movl %ecx, -0x104(%rbp)
movl %eax, %eax
movb $0x0, -0x100(%rbp,%rax)
jmp 0x2b0f8
movq -0x120(%rbp), %rax
movq 0x48(%rax), %rax
movq %rax, -0x120(%rbp)
jmp 0x2b026
jmp 0x2b111
movq -0x118(%rbp), %rax
movq 0x78(%rax), %rax
movq %rax, -0x118(%rbp)
jmp 0x2b006
cmpl $0x1, -0x104(%rbp)
jae 0x2b154
movq 0xace8(%rip), %rdi      # 0x35e20
leaq 0xa571(%rip), %rax      # 0x356b0
movl (%rax), %esi
xorl %edx, %edx
xorl %eax, %eax
movl %eax, %ecx
callq 0x4850
movl %eax, -0x124(%rbp)
jmp 0x2b18b
movl -0x104(%rbp), %eax
subl $0x1, %eax
movl %eax, -0x10c(%rbp)
movq 0xacb6(%rip), %rdi      # 0x35e20
leaq 0xa53f(%rip), %rax      # 0x356b0
movl (%rax), %esi
movl -0x10c(%rbp), %edx
leaq -0x100(%rbp), %rcx
callq 0x4850
movl %eax, -0x128(%rbp)
addq $0x130, %rsp            # imm = 0x130
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/baskerville[P]bspwm/src/ewmh.c
// Function: ewmh_update_desktop_viewport
void ewmh_update_desktop_viewport(void)
{
	uint32_t desktops_count = 0;
	for (monitor_t *m = mon_head; m != NULL; m = m->next) {
		for (desktop_t *d = m->desk_head; d != NULL; d = d->next) {
			desktops_count++;
		}
	}
	if (desktops_count == 0) {
		xcb_ewmh_set_desktop_viewport(ewmh, default_screen, 0, NULL);
		return;
	}
	xcb_ewmh_coordinates_t coords[desktops_count];
	uint16_t desktop = 0;
	for (monitor_t *m = mon_head; m != NULL; m = m->next) {
		for (desktop_t *d = m->desk_head; d != NULL; d = d->next) {
			coords[desktop++] = (xcb_ewmh_coordinates_t){m->rectangle.x, m->rectangle.y};
		}
	}
	xcb_ewmh_set_desktop_viewport(ewmh, default_screen, desktop, coords);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x60, %rsp
movl $0x0, -0x4(%rbp)
leaq 0xa542(%rip), %rax      # 0x356f8
movq (%rax), %rax
movq %rax, -0x10(%rbp)
cmpq $0x0, -0x10(%rbp)
je 0x2b1fe
movq -0x10(%rbp), %rax
movq 0x60(%rax), %rax
movq %rax, -0x18(%rbp)
cmpq $0x0, -0x18(%rbp)
je 0x2b1ee
movl -0x4(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x4(%rbp)
movq -0x18(%rbp), %rax
movq 0x48(%rax), %rax
movq %rax, -0x18(%rbp)
jmp 0x2b1d0
jmp 0x2b1f0
movq -0x10(%rbp), %rax
movq 0x78(%rax), %rax
movq %rax, -0x10(%rbp)
jmp 0x2b1bd
cmpl $0x0, -0x4(%rbp)
jne 0x2b227
movq 0xac15(%rip), %rdi      # 0x35e20
leaq 0xa49e(%rip), %rax      # 0x356b0
movl (%rax), %esi
xorl %edx, %edx
xorl %eax, %eax
movl %eax, %ecx
callq 0x40a0
movl %eax, -0x1c(%rbp)
jmp 0x2b2f5
movl -0x4(%rbp), %eax
movq %rsp, %rcx
movq %rcx, -0x28(%rbp)
leaq 0xf(,%rax,8), %rdx
andq $-0x10, %rdx
movq %rsp, %rcx
subq %rdx, %rcx
movq %rcx, -0x60(%rbp)
movq %rcx, %rsp
movq %rax, -0x30(%rbp)
movw $0x0, -0x32(%rbp)
leaq 0xa49d(%rip), %rax      # 0x356f8
movq (%rax), %rax
movq %rax, -0x40(%rbp)
cmpq $0x0, -0x40(%rbp)
je 0x2b2ce
movq -0x40(%rbp), %rax
movq 0x60(%rax), %rax
movq %rax, -0x48(%rbp)
cmpq $0x0, -0x48(%rbp)
je 0x2b2be
movq -0x60(%rbp), %rax
movw -0x32(%rbp), %cx
movw %cx, %dx
addw $0x1, %dx
movw %dx, -0x32(%rbp)
movzwl %cx, %ecx
movq -0x40(%rbp), %rdx
movswl 0x4c(%rdx), %edx
movl %edx, -0x50(%rbp)
movq -0x40(%rbp), %rdx
movswl 0x4e(%rdx), %edx
movl %edx, -0x4c(%rbp)
movq -0x50(%rbp), %rdx
movq %rdx, (%rax,%rcx,8)
movq -0x48(%rbp), %rax
movq 0x48(%rax), %rax
movq %rax, -0x48(%rbp)
jmp 0x2b275
jmp 0x2b2c0
movq -0x40(%rbp), %rax
movq 0x78(%rax), %rax
movq %rax, -0x40(%rbp)
jmp 0x2b262
movq -0x60(%rbp), %rcx
movq 0xab47(%rip), %rdi      # 0x35e20
leaq 0xa3d0(%rip), %rax      # 0x356b0
movl (%rax), %esi
movzwl -0x32(%rbp), %edx
callq 0x40a0
movl %eax, -0x54(%rbp)
movq -0x28(%rbp), %rax
movq %rax, %rsp
movq %rbp, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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
movq %rsp, %rbp
subq $0x20, %rsp
movl %edi, -0x4(%rbp)
callq 0x4380
movl %eax, -0x8(%rbp)
movq 0xa346(%rip), %rdi      # 0x35e20
leaq 0x9c87(%rip), %rax      # 0x35768
movl (%rax), %esi
movl -0x4(%rbp), %edx
callq 0x4440
movl %eax, -0xc(%rbp)
movq 0xa32b(%rip), %rdi      # 0x35e20
movl -0x4(%rbp), %esi
movl -0x4(%rbp), %edx
callq 0x4440
movl %eax, -0x10(%rbp)
movq 0xa316(%rip), %rdi      # 0x35e20
movl -0x4(%rbp), %esi
movl $0x5, %edx
leaq 0x15c0(%rip), %rcx      # 0x2d0d9
callq 0x4700
movl %eax, -0x14(%rbp)
movq 0xa2f8(%rip), %rdi      # 0x35e20
movl -0x4(%rbp), %esi
movl -0x8(%rbp), %edx
callq 0x49b0
movl %eax, -0x18(%rbp)
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/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
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl %edx, -0x14(%rbp)
movl %ecx, -0x18(%rbp)
movl $0x1, %edi
movl $0x28, %esi
callq 0x4890
movq %rax, -0x20(%rbp)
movq -0x20(%rbp), %rax
movq $0x0, 0x20(%rax)
movq -0x20(%rbp), %rax
movq $0x0, 0x18(%rax)
movq -0x8(%rbp), %rcx
movq -0x20(%rbp), %rax
movq %rcx, (%rax)
movq -0x10(%rbp), %rcx
movq -0x20(%rbp), %rax
movq %rcx, 0x8(%rax)
movl -0x14(%rbp), %ecx
movq -0x20(%rbp), %rax
movl %ecx, 0x10(%rax)
movl -0x18(%rbp), %ecx
movq -0x20(%rbp), %rax
movl %ecx, 0x14(%rax)
movq -0x20(%rbp), %rax
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
cmpq $0x0, -0x8(%rbp)
jne 0x2bbd8
jmp 0x2bcca
movq -0x8(%rbp), %rax
movq 0x18(%rax), %rax
movq %rax, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq 0x20(%rax), %rax
movq %rax, -0x18(%rbp)
cmpq $0x0, -0x10(%rbp)
je 0x2bc03
movq -0x18(%rbp), %rcx
movq -0x10(%rbp), %rax
movq %rcx, 0x20(%rax)
cmpq $0x0, -0x18(%rbp)
je 0x2bc16
movq -0x10(%rbp), %rcx
movq -0x18(%rbp), %rax
movq %rcx, 0x18(%rax)
movq -0x8(%rbp), %rax
leaq 0x9b27(%rip), %rcx      # 0x35748
cmpq (%rcx), %rax
jne 0x2bc34
movq -0x18(%rbp), %rcx
leaq 0x9b17(%rip), %rax      # 0x35748
movq %rcx, (%rax)
movq -0x8(%rbp), %rax
leaq 0x9b01(%rip), %rcx      # 0x35740
cmpq (%rcx), %rax
jne 0x2bc52
movq -0x10(%rbp), %rcx
leaq 0x9af1(%rip), %rax      # 0x35740
movq %rcx, (%rax)
leaq 0x9a77(%rip), %rax      # 0x356d0
testb $0x1, (%rax)
je 0x2bc9b
movq -0x8(%rbp), %rax
movq (%rax), %rdi
callq 0x4060
movl %eax, -0x1c(%rbp)
movl -0x1c(%rbp), %eax
movl %eax, -0x20(%rbp)
movl -0x1c(%rbp), %edi
movl $0x1, %esi
movb $0x0, %al
callq 0x4a80
movl -0x20(%rbp), %edi
movl %eax, %edx
andl $0xfffffffe, %edx       # imm = 0xFFFFFFFE
movl $0x2, %esi
movb $0x0, %al
callq 0x4a80
jmp 0x2bcb4
movq -0x8(%rbp), %rax
movq (%rax), %rdi
callq 0x48a0
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rdi
callq 0x42f0
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rdi
callq 0x4450
movq -0x8(%rbp), %rdi
callq 0x4450
addq $0x20, %rsp
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O0/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
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
leaq 0x9a65(%rip), %rax      # 0x35748
cmpq $0x0, (%rax)
jne 0x2bd03
movq -0x8(%rbp), %rcx
leaq 0x9a4c(%rip), %rax      # 0x35740
movq %rcx, (%rax)
leaq 0x9a4a(%rip), %rax      # 0x35748
movq %rcx, (%rax)
jmp 0x2bd35
movq -0x8(%rbp), %rcx
leaq 0x9a32(%rip), %rax      # 0x35740
movq (%rax), %rax
movq %rcx, 0x20(%rax)
leaq 0x9a24(%rip), %rax      # 0x35740
movq (%rax), %rcx
movq -0x8(%rbp), %rax
movq %rcx, 0x18(%rax)
movq -0x8(%rbp), %rcx
leaq 0x9a0e(%rip), %rax      # 0x35740
movq %rcx, (%rax)
movq -0x8(%rbp), %rax
movq (%rax), %rdi
callq 0x4060
movl %eax, -0xc(%rbp)
movl -0xc(%rbp), %eax
movl %eax, -0x10(%rbp)
movl -0xc(%rbp), %edi
movl $0x1, %esi
movb $0x0, %al
callq 0x4a80
movl -0x10(%rbp), %edi
movl %eax, %edx
orl $0x1, %edx
movl $0x2, %esi
movb $0x0, %al
callq 0x4a80
movq -0x8(%rbp), %rax
movl 0x10(%rax), %eax
andl $0x1, %eax
cmpl $0x0, %eax
je 0x2bda7
movq -0x8(%rbp), %rax
movq (%rax), %rdi
callq 0x2bdb0
movq -0x8(%rbp), %rcx
movl 0x14(%rcx), %eax
movl %eax, %edx
addl $-0x1, %edx
movl %edx, 0x14(%rcx)
cmpl $0x1, %eax
jne 0x2bda5
movq -0x8(%rbp), %rdi
callq 0x2bbc0
jmp 0x2bda7
addq $0x10, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/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
movq %rsp, %rbp
subq $0x110, %rsp            # imm = 0x110
testb %al, %al
je 0x2c0eb
movaps %xmm0, -0xc0(%rbp)
movaps %xmm1, -0xb0(%rbp)
movaps %xmm2, -0xa0(%rbp)
movaps %xmm3, -0x90(%rbp)
movaps %xmm4, -0x80(%rbp)
movaps %xmm5, -0x70(%rbp)
movaps %xmm6, -0x60(%rbp)
movaps %xmm7, -0x50(%rbp)
movq %r9, -0xc8(%rbp)
movq %r8, -0xd0(%rbp)
movq %rcx, -0xd8(%rbp)
movq %rdx, -0xe0(%rbp)
movq %rsi, -0xe8(%rbp)
movl %edi, -0x4(%rbp)
leaq 0x9630(%rip), %rax      # 0x35748
movq (%rax), %rax
movq %rax, -0x10(%rbp)
cmpq $0x0, -0x10(%rbp)
je 0x2c253
movq -0x10(%rbp), %rax
movq 0x20(%rax), %rax
movq %rax, -0x20(%rbp)
movq -0x10(%rbp), %rax
movl 0x10(%rax), %eax
andl -0x4(%rbp), %eax
cmpl $0x0, %eax
je 0x2c246
movq -0x10(%rbp), %rax
cmpl $0x0, 0x14(%rax)
jle 0x2c160
movq -0x10(%rbp), %rax
movl 0x14(%rax), %ecx
addl $-0x1, %ecx
movl %ecx, 0x14(%rax)
cmpl $0x1, -0x4(%rbp)
jne 0x2c17a
movq -0x10(%rbp), %rax
movq (%rax), %rdi
callq 0x2bdb0
movl %eax, -0x14(%rbp)
jmp 0x2c22b
leaq -0x40(%rbp), %rax
leaq -0xf0(%rbp), %rcx
movq %rcx, 0x10(%rax)
leaq 0x10(%rbp), %rcx
movq %rcx, 0x8(%rax)
movl $0x30, 0x4(%rax)
movl $0x8, (%rax)
leaq -0x40(%rbp), %rax
movq %rax, -0x100(%rbp)
movl -0x40(%rbp), %eax
movl %eax, -0xf4(%rbp)
cmpl $0x28, %eax
ja 0x2c1d9
movq -0x100(%rbp), %rcx
movl -0xf4(%rbp), %edx
movslq %edx, %rax
addq 0x10(%rcx), %rax
addl $0x8, %edx
movl %edx, (%rcx)
movq %rax, -0x108(%rbp)
jmp 0x2c1f6
movq -0x100(%rbp), %rcx
movq 0x8(%rcx), %rax
movq %rax, %rdx
addq $0x8, %rdx
movq %rdx, 0x8(%rcx)
movq %rax, -0x108(%rbp)
movq -0x108(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x28(%rbp)
movq -0x10(%rbp), %rax
movq (%rax), %rdi
movq -0x28(%rbp), %rsi
leaq -0x40(%rbp), %rdx
callq 0x43e0
leaq -0x40(%rbp), %rax
movq -0x10(%rbp), %rax
movq (%rax), %rdi
callq 0x4ad0
movl %eax, -0x14(%rbp)
cmpl $0x0, -0x14(%rbp)
jne 0x2c23b
movq -0x10(%rbp), %rax
cmpl $0x0, 0x14(%rax)
jne 0x2c244
movq -0x10(%rbp), %rdi
callq 0x2bbc0
jmp 0x2c246
movq -0x20(%rbp), %rax
movq %rax, -0x10(%rbp)
jmp 0x2c11f
addq $0x110, %rsp            # imm = 0x110
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/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 %rbp
movq %rsp, %rbp
subq $0x10, %rsp
leaq 0x94d9(%rip), %rax      # 0x35748
movq (%rax), %rax
movq %rax, -0x8(%rbp)
cmpq $0x0, -0x8(%rbp)
je 0x2c2bc
movq -0x8(%rbp), %rax
movq 0x20(%rax), %rax
movq %rax, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq (%rax), %rdi
callq 0x4060
movl %eax, %edi
xorl %eax, %eax
movl %eax, %edx
movq %rdx, %rsi
callq 0x4a30
cmpq $-0x1, %rax
jne 0x2c2b2
movq -0x8(%rbp), %rdi
callq 0x2bbc0
movq -0x10(%rbp), %rax
movq %rax, -0x8(%rbp)
jmp 0x2c276
addq $0x10, %rsp
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O0/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
subq $0x20, %rsp
movl $0x0, -0x4(%rbp)
leaq -0xc(%rbp), %rdi
callq 0x1050
callq 0x10b0
movl %eax, -0x10(%rbp)
cmpl $0x0, -0x10(%rbp)
jne 0x1214
movl -0x8(%rbp), %edi
callq 0x1040
movl -0xc(%rbp), %edi
xorl %esi, %esi
callq 0x1030
leaq 0xe05(%rip), %rsi       # 0x2004
xorl %edx, %edx
xorl %eax, %eax
movl %eax, %ecx
movq %rsi, %rdi
movb $0x0, %al
callq 0x10a0
jmp 0x12a8
movl -0xc(%rbp), %edi
callq 0x1040
movl -0x8(%rbp), %edi
leaq 0xde3(%rip), %rsi       # 0x2009
callq 0x1080
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rdi
leaq 0xdd1(%rip), %rsi       # 0x200b
movb $0x0, %al
callq 0x1060
movq -0x18(%rbp), %rdi
leaq 0xdd0(%rip), %rsi       # 0x201c
movb $0x0, %al
callq 0x1060
movq -0x18(%rbp), %rdi
leaq 0xdcd(%rip), %rsi       # 0x202b
movb $0x0, %al
callq 0x1060
movq -0x18(%rbp), %rdi
leaq 0xdce(%rip), %rsi       # 0x203e
movb $0x0, %al
callq 0x1060
movq -0x18(%rbp), %rdi
leaq 0xdd4(%rip), %rsi       # 0x2056
movb $0x0, %al
callq 0x1060
movq -0x18(%rbp), %rdi
callq 0x1070
movl -0x8(%rbp), %edi
callq 0x1040
movl -0x10(%rbp), %edi
xorl %eax, %eax
movl %eax, %esi
xorl %edx, %edx
callq 0x1090
xorl %eax, %eax
addq $0x20, %rsp
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O0/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
movq %rsp, %rbp
subq $0x10, %rsp
movl $0x0, -0x8(%rbp)
movq 0x1ada2(%rip), %rax     # 0x1bff8
movq (%rax), %rdi
leaq 0x171f0(%rip), %rsi     # 0x18450
movb $0x0, %al
callq 0x1080
movl $0x1, -0x4(%rbp)
cmpl $0x1c, -0x4(%rbp)
jg 0x1304
movslq -0x4(%rbp), %rcx
leaq 0x1af1d(%rip), %rax     # 0x1c1a0
cmpl $0x0, (%rax,%rcx,4)
jle 0x12f4
movq 0x1ad68(%rip), %rax     # 0x1bff8
movq (%rax), %rdi
movslq -0x4(%rbp), %rax
leaq 0x1ae12(%rip), %rdx     # 0x1c0b0
shlq $0x2, %rax
addq %rax, %rdx
movslq -0x4(%rbp), %rcx
leaq 0x1aef0(%rip), %rax     # 0x1c1a0
movl (%rax,%rcx,4), %ecx
leaq 0x171a3(%rip), %rsi     # 0x1845d
movb $0x0, %al
callq 0x1080
movl -0x8(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x8(%rbp)
movl -0x8(%rbp), %eax
movl $0x4, %ecx
cltd
idivl %ecx
cmpl $0x0, %edx
jne 0x12f2
movq 0x1ad17(%rip), %rax     # 0x1bff8
movq (%rax), %rdi
leaq 0x17f13(%rip), %rsi     # 0x191fe
movb $0x0, %al
callq 0x1080
jmp 0x12f4
jmp 0x12f6
movl -0x4(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x4(%rbp)
jmp 0x126e
movl -0x8(%rbp), %eax
movl $0x4, %ecx
cltd
idivl %ecx
cmpl $0x0, %edx
je 0x132c
movq 0x1acdd(%rip), %rax     # 0x1bff8
movq (%rax), %rdi
leaq 0x17ed9(%rip), %rsi     # 0x191fe
movb $0x0, %al
callq 0x1080
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movq %rdx, -0x18(%rbp)
movl $0x1, -0x24(%rbp)
movq -0x18(%rbp), %rax
movq $0x0, (%rax)
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rax
movslq -0xc(%rbp), %rcx
cmpq %rcx, %rax
jge 0x1399
movq -0x8(%rbp), %rax
movq 0x28(%rax), %rcx
movq -0x18(%rbp), %rax
movq %rcx, (%rax)
movslq -0xc(%rbp), %rcx
movq -0x8(%rbp), %rax
movq 0x28(%rax), %rax
movq %rcx, 0x8(%rax)
movq -0x8(%rbp), %rax
movq %rcx, 0x8(%rax)
movq -0x8(%rbp), %rax
movq 0x28(%rax), %rax
movq 0x20(%rax), %rax
movq %rax, -0x20(%rbp)
movq -0x20(%rbp), %rax
cmpq -0x8(%rbp), %rax
je 0x1406
movq -0x20(%rbp), %rax
movq 0x8(%rax), %rax
movslq -0xc(%rbp), %rcx
cmpq %rcx, %rax
jge 0x13eb
movq -0x20(%rbp), %rax
movq 0x28(%rax), %rcx
movq -0x18(%rbp), %rax
movq %rcx, (%rax)
movslq -0xc(%rbp), %rcx
movq -0x20(%rbp), %rax
movq 0x28(%rax), %rax
movq %rcx, 0x8(%rax)
movq -0x20(%rbp), %rax
movq %rcx, 0x8(%rax)
movl -0x24(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x24(%rbp)
movq -0x20(%rbp), %rax
movq 0x28(%rax), %rax
movq 0x20(%rax), %rax
movq %rax, -0x20(%rbp)
jmp 0x13a9
movl -0x24(%rbp), %eax
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movq %rdx, -0x18(%rbp)
movl $0x1, -0x24(%rbp)
movq -0x18(%rbp), %rax
movq $0x0, (%rax)
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rax
movslq -0xc(%rbp), %rcx
cmpq %rcx, %rax
jge 0x1469
movq -0x8(%rbp), %rax
movq 0x28(%rax), %rcx
movq -0x18(%rbp), %rax
movq %rcx, (%rax)
movslq -0xc(%rbp), %rcx
movq -0x8(%rbp), %rax
movq 0x28(%rax), %rax
movq %rcx, 0x8(%rax)
movq -0x8(%rbp), %rax
movq %rcx, 0x8(%rax)
movq -0x8(%rbp), %rax
movq 0x28(%rax), %rax
movq 0x18(%rax), %rax
movq %rax, -0x20(%rbp)
movq -0x20(%rbp), %rax
cmpq -0x8(%rbp), %rax
je 0x14d6
movq -0x20(%rbp), %rax
movq 0x8(%rax), %rax
movslq -0xc(%rbp), %rcx
cmpq %rcx, %rax
jge 0x14bb
movq -0x20(%rbp), %rax
movq 0x28(%rax), %rcx
movq -0x18(%rbp), %rax
movq %rcx, (%rax)
movslq -0xc(%rbp), %rcx
movq -0x20(%rbp), %rax
movq 0x28(%rax), %rax
movq %rcx, 0x8(%rax)
movq -0x20(%rbp), %rax
movq %rcx, 0x8(%rax)
movl -0x24(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x24(%rbp)
movq -0x20(%rbp), %rax
movq 0x28(%rax), %rax
movq 0x18(%rax), %rax
movq %rax, -0x20(%rbp)
jmp 0x1479
movl -0x24(%rbp), %eax
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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 %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
cmpl $0x0, 0x1a831(%rip)     # 0x1c138
je 0x1925
movq -0x8(%rbp), %rdi
leaq 0x16b55(%rip), %rsi     # 0x18469
movb $0x0, %al
callq 0x1080
movl $0x0, 0x1a813(%rip)     # 0x1c138
movq -0x10(%rbp), %rax
movzwl 0x2(%rax), %eax
cmpl $0x64, %eax
jl 0x19ae
movl $0x1, -0x14(%rbp)
movl -0x14(%rbp), %eax
movq -0x10(%rbp), %rcx
movzwl 0x2(%rcx), %ecx
cmpl %ecx, %eax
jg 0x19ac
movq -0x8(%rbp), %rdi
movl -0x14(%rbp), %edx
movq -0x10(%rbp), %rax
movslq -0x14(%rbp), %rcx
imulq $0x90, %rcx, %rcx
addq %rcx, %rax
movzwl 0x2(%rax), %ecx
movq -0x10(%rbp), %rax
movslq -0x14(%rbp), %rsi
imulq $0x90, %rsi, %rsi
addq %rsi, %rax
movzwl 0x32(%rax), %r8d
movq -0x10(%rbp), %rax
movslq -0x14(%rbp), %rsi
imulq $0x90, %rsi, %rsi
addq %rsi, %rax
movzwl 0x62(%rax), %r9d
leaq 0x16ae9(%rip), %rsi     # 0x18483
movb $0x0, %al
callq 0x1080
movl -0x14(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x14(%rbp)
jmp 0x1939
jmp 0x1a2a
movl $0x1, -0x14(%rbp)
movl -0x14(%rbp), %eax
movq -0x10(%rbp), %rcx
movzwl 0x2(%rcx), %ecx
cmpl %ecx, %eax
jg 0x1a28
movq -0x8(%rbp), %rdi
movl -0x14(%rbp), %edx
movq -0x10(%rbp), %rax
movslq -0x14(%rbp), %rcx
imulq $0x90, %rcx, %rcx
addq %rcx, %rax
movzwl 0x2(%rax), %ecx
movq -0x10(%rbp), %rax
movslq -0x14(%rbp), %rsi
imulq $0x90, %rsi, %rsi
addq %rsi, %rax
movzwl 0x32(%rax), %r8d
movq -0x10(%rbp), %rax
movslq -0x14(%rbp), %rsi
imulq $0x90, %rsi, %rsi
addq %rsi, %rax
movzwl 0x62(%rax), %r9d
leaq 0x16a87(%rip), %rsi     # 0x1849d
movb $0x0, %al
callq 0x1080
movl -0x14(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x14(%rbp)
jmp 0x19b5
jmp 0x1a2a
movq -0x8(%rbp), %rdi
leaq 0x16a82(%rip), %rsi     # 0x184b7
movb $0x0, %al
callq 0x1080
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/mishun[P]plantri/fullgen.c
// Function: belegedummies
void belegedummies(KANTE *edge, int nummer)
/* belegt edge->dummy, edge->invers->pre->dummy, ... mit Nummer
   -- einmal rund um die Flaeche */

{
KANTE *merke;

merke=edge; edge->dummy=nummer;
edge=edge->invers->prev;

while (edge != merke) { edge->dummy=nummer;
			edge=edge->invers->prev; }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x18(%rbp)
movslq -0xc(%rbp), %rcx
movq -0x8(%rbp), %rax
movq %rcx, 0x8(%rax)
movq -0x8(%rbp), %rax
movq 0x28(%rax), %rax
movq 0x18(%rax), %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
cmpq -0x18(%rbp), %rax
je 0x1aa7
movslq -0xc(%rbp), %rcx
movq -0x8(%rbp), %rax
movq %rcx, 0x8(%rax)
movq -0x8(%rbp), %rax
movq 0x28(%rax), %rax
movq 0x18(%rax), %rax
movq %rax, -0x8(%rbp)
jmp 0x1a7f
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/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
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x10(%rbp), %rax
movzbl (%rax), %eax
cmpl $0x0, %eax
jne 0x30f8
movl $0x0, -0x18(%rbp)
cmpl $0xc, -0x18(%rbp)
jge 0x307e
movq -0x8(%rbp), %rax
movslq -0x18(%rbp), %rcx
movb (%rax,%rcx), %dl
movq -0x10(%rbp), %rax
movslq -0x18(%rbp), %rcx
movb %dl, (%rax,%rcx)
movl -0x18(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x18(%rbp)
jmp 0x3057
movl $0x20, %edi
callq 0x10a0
movq %rax, %rcx
movq -0x10(%rbp), %rax
movq %rcx, 0x10(%rax)
movq -0x10(%rbp), %rax
movq 0x10(%rax), %rax
movb $0x0, (%rax)
movl $0x20, %edi
callq 0x10a0
movq %rax, %rcx
movq -0x10(%rbp), %rax
movq %rcx, 0x18(%rax)
movq -0x10(%rbp), %rax
movq 0x18(%rax), %rax
movb $0x0, (%rax)
movq -0x10(%rbp), %rax
cmpq $0x0, 0x10(%rax)
je 0x30d4
movq -0x10(%rbp), %rax
cmpq $0x0, 0x18(%rax)
jne 0x30f6
movq 0x18f1d(%rip), %rax     # 0x1bff8
movq (%rax), %rdi
leaq 0x153fb(%rip), %rsi     # 0x184e0
movb $0x0, %al
callq 0x1080
movl $0x1, %edi
callq 0x1120
jmp 0x3165
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
movl $0xc, %edx
callq 0x2fb0
movl %eax, -0x14(%rbp)
cmpl $0x0, -0x14(%rbp)
jge 0x3126
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rax
movq 0x10(%rax), %rsi
callq 0x3030
jmp 0x3163
cmpl $0x0, -0x14(%rbp)
jle 0x313f
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rax
movq 0x18(%rax), %rsi
callq 0x3030
jmp 0x3161
movq 0x18eb2(%rip), %rax     # 0x1bff8
movq (%rax), %rdi
leaq 0x153b7(%rip), %rsi     # 0x18507
movb $0x0, %al
callq 0x1080
movl $0x2, %edi
callq 0x1120
jmp 0x3163
jmp 0x3165
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x8(%rbp), %rax
movzbl (%rax), %eax
cmpl $0x0, %eax
jne 0x3194
jmp 0x324a
movq -0x8(%rbp), %rax
movq 0x10(%rax), %rdi
movl -0xc(%rbp), %esi
movq -0x18(%rbp), %rdx
callq 0x3170
movb $0x0, -0x19(%rbp)
movq -0x8(%rbp), %rax
movzbl -0x19(%rbp), %ecx
movzbl (%rax,%rcx), %eax
movq -0x18(%rbp), %rcx
movq (%rcx), %rcx
movzbl -0x19(%rbp), %edx
movzbl (%rcx,%rdx), %ecx
cmpl %ecx, %eax
jne 0x31d7
jmp 0x31cd
movb -0x19(%rbp), %al
addb $0x1, %al
movb %al, -0x19(%rbp)
jmp 0x31ac
movslq -0xc(%rbp), %rcx
leaq 0x1b01e(%rip), %rax     # 0x1e200
movq (%rax,%rcx,8), %rcx
leaq -0x19(%rbp), %rdi
movl $0x1, %edx
movq %rdx, %rsi
callq 0x1130
movq -0x8(%rbp), %rdi
movzbl -0x19(%rbp), %eax
cltq
addq %rax, %rdi
movzbl -0x19(%rbp), %ecx
movl $0xc, %eax
subl %ecx, %eax
movslq %eax, %rdx
movslq -0xc(%rbp), %rcx
leaq 0x1afe3(%rip), %rax     # 0x1e200
movq (%rax,%rcx,8), %rcx
movl $0x1, %esi
callq 0x1130
movq -0x8(%rbp), %rcx
movq -0x18(%rbp), %rax
movq %rcx, (%rax)
movq -0x8(%rbp), %rax
movq 0x18(%rax), %rdi
movl -0xc(%rbp), %esi
movq -0x18(%rbp), %rdx
callq 0x3170
addq $0x20, %rsp
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O0/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:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movw $0x0, 0x2(%rax)
movl $0x1, -0xc(%rbp)
cmpl $0x244, -0xc(%rbp)      # imm = 0x244
jg 0x40ff
movq -0x8(%rbp), %rcx
movslq -0xc(%rbp), %rax
imulq $0x90, %rax, %rax
addq %rax, %rcx
addq $0x30, %rcx
movq -0x8(%rbp), %rax
movslq -0xc(%rbp), %rdx
imulq $0x90, %rdx, %rdx
addq %rdx, %rax
movq %rcx, 0x20(%rax)
movq -0x8(%rbp), %rcx
movslq -0xc(%rbp), %rax
imulq $0x90, %rax, %rax
addq %rax, %rcx
addq $0x60, %rcx
movq -0x8(%rbp), %rax
movslq -0xc(%rbp), %rdx
imulq $0x90, %rdx, %rdx
addq %rdx, %rax
movq %rcx, 0x18(%rax)
movq -0x8(%rbp), %rcx
movslq -0xc(%rbp), %rax
imulq $0x90, %rax, %rax
addq %rax, %rcx
addq $0x60, %rcx
movq -0x8(%rbp), %rax
movslq -0xc(%rbp), %rdx
imulq $0x90, %rdx, %rdx
addq %rdx, %rax
movq %rcx, 0x50(%rax)
movq -0x8(%rbp), %rcx
movslq -0xc(%rbp), %rax
imulq $0x90, %rax, %rax
addq %rax, %rcx
movq -0x8(%rbp), %rax
movslq -0xc(%rbp), %rdx
imulq $0x90, %rdx, %rdx
addq %rdx, %rax
movq %rcx, 0x48(%rax)
movq -0x8(%rbp), %rcx
movslq -0xc(%rbp), %rax
imulq $0x90, %rax, %rax
addq %rax, %rcx
movq -0x8(%rbp), %rax
movslq -0xc(%rbp), %rdx
imulq $0x90, %rdx, %rdx
addq %rdx, %rax
movq %rcx, 0x80(%rax)
movq -0x8(%rbp), %rcx
movslq -0xc(%rbp), %rax
imulq $0x90, %rax, %rax
addq %rax, %rcx
addq $0x30, %rcx
movq -0x8(%rbp), %rax
movslq -0xc(%rbp), %rdx
imulq $0x90, %rdx, %rdx
addq %rdx, %rax
movq %rcx, 0x78(%rax)
movl $0x0, -0x10(%rbp)
cmpl $0x3, -0x10(%rbp)
jge 0x40ef
movl -0xc(%rbp), %eax
movw %ax, %cx
movq -0x8(%rbp), %rax
movslq -0xc(%rbp), %rdx
imulq $0x90, %rdx, %rdx
addq %rdx, %rax
movslq -0x10(%rbp), %rdx
imulq $0x30, %rdx, %rdx
addq %rdx, %rax
movw %cx, (%rax)
movq -0x8(%rbp), %rax
movslq -0xc(%rbp), %rcx
imulq $0x90, %rcx, %rcx
addq %rcx, %rax
movslq -0x10(%rbp), %rcx
imulq $0x30, %rcx, %rcx
addq %rcx, %rax
movw $0xfffe, 0x2(%rax)      # imm = 0xFFFE
movq -0x8(%rbp), %rax
movslq -0xc(%rbp), %rcx
imulq $0x90, %rcx, %rcx
addq %rcx, %rax
movslq -0x10(%rbp), %rcx
imulq $0x30, %rcx, %rcx
addq %rcx, %rax
movq $0x0, 0x28(%rax)
movl -0x10(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x10(%rbp)
jmp 0x4070
jmp 0x40f1
movl -0xc(%rbp), %eax
addl $0x1, %eax
movl %eax, -0xc(%rbp)
jmp 0x3f59
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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
movq %rsp, %rbp
movq %rdi, -0x10(%rbp)
movq -0x10(%rbp), %rax
movl (%rax), %eax
movl %eax, -0x20(%rbp)
movl $0x1, -0x18(%rbp)
movl $0x0, -0x14(%rbp)
movq -0x10(%rbp), %rax
movslq -0x14(%rbp), %rcx
cmpl $0xfffe, (%rax,%rcx,4)  # imm = 0xFFFE
je 0x4a21
movq -0x10(%rbp), %rax
movslq -0x14(%rbp), %rcx
movl (%rax,%rcx,4), %ecx
movslq -0x14(%rbp), %rax
movl %ecx, -0x60(%rbp,%rax,4)
movslq -0x14(%rbp), %rax
movl -0x60(%rbp,%rax,4), %eax
cmpl -0x20(%rbp), %eax
jne 0x49f9
movl $0x0, -0x18(%rbp)
jmp 0x4a14
movslq -0x14(%rbp), %rax
movl -0x60(%rbp,%rax,4), %eax
cmpl -0x20(%rbp), %eax
jle 0x4a12
movl $0x0, -0x4(%rbp)
jmp 0x4b1a
jmp 0x4a14
jmp 0x4a16
movl -0x14(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x14(%rbp)
jmp 0x49bf
cmpl $0x0, -0x18(%rbp)
je 0x4a33
movl $0x1, -0x4(%rbp)
jmp 0x4b1a
movl -0x14(%rbp), %eax
movl %eax, -0x1c(%rbp)
movl $0x0, -0x18(%rbp)
movl -0x18(%rbp), %eax
cmpl -0x1c(%rbp), %eax
jge 0x4a6f
movq -0x10(%rbp), %rax
movslq -0x18(%rbp), %rcx
movl (%rax,%rcx,4), %ecx
movslq -0x14(%rbp), %rax
movl %ecx, -0x60(%rbp,%rax,4)
movl -0x14(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x14(%rbp)
movl -0x18(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x18(%rbp)
jmp 0x4a40
movl $0x1, -0x18(%rbp)
movl -0x18(%rbp), %eax
cmpl -0x1c(%rbp), %eax
jge 0x4b13
movslq -0x18(%rbp), %rax
movl -0x60(%rbp,%rax,4), %eax
cmpl -0x20(%rbp), %eax
jne 0x4afa
movl $0x1, -0x14(%rbp)
movl -0x14(%rbp), %ecx
xorl %eax, %eax
cmpl -0x1c(%rbp), %ecx
movb %al, -0x61(%rbp)
jge 0x4ac0
movl -0x18(%rbp), %eax
addl -0x14(%rbp), %eax
cltq
movl -0x60(%rbp,%rax,4), %eax
movq -0x10(%rbp), %rcx
movslq -0x14(%rbp), %rdx
cmpl (%rcx,%rdx,4), %eax
sete %al
movb %al, -0x61(%rbp)
movb -0x61(%rbp), %al
testb $0x1, %al
jne 0x4ac9
jmp 0x4ad6
jmp 0x4acb
movl -0x14(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x14(%rbp)
jmp 0x4a96
movl -0x18(%rbp), %eax
addl -0x14(%rbp), %eax
cltq
movl -0x60(%rbp,%rax,4), %eax
movq -0x10(%rbp), %rcx
movslq -0x14(%rbp), %rdx
cmpl (%rcx,%rdx,4), %eax
jle 0x4af8
movl $0x0, -0x4(%rbp)
jmp 0x4b1a
jmp 0x4afa
jmp 0x4afc
movl -0x14(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x14(%rbp)
movl -0x18(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x18(%rbp)
jmp 0x4a76
movl $0x1, -0x4(%rbp)
movl -0x4(%rbp), %eax
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/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 %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq 0x20e51(%rip), %rax     # 0x26b10
cmpq 0x20e52(%rip), %rax     # 0x26b18
jne 0x5d26
movl $0x3e90, %edi           # imm = 0x3E90
callq 0x10a0
movq %rax, 0x20e37(%rip)     # 0x26b10
cmpq $0x0, 0x20e2f(%rip)     # 0x26b10
jne 0x5d05
movq 0x1630e(%rip), %rax     # 0x1bff8
movq (%rax), %rdi
leaq 0x129b1(%rip), %rsi     # 0x186a5
movb $0x0, %al
callq 0x1080
movl $0xb, %edi
callq 0x1120
movq 0x20e04(%rip), %rax     # 0x26b10
addq $0x3e80, %rax           # imm = 0x3E80
movq %rax, 0x20dff(%rip)     # 0x26b18
movq 0x20df0(%rip), %rax     # 0x26b10
movq %rax, -0x8(%rbp)
jmp 0x5d43
movq 0x20de3(%rip), %rax     # 0x26b10
addq $0x10, %rax
movq %rax, 0x20dd8(%rip)     # 0x26b10
movq 0x20dd1(%rip), %rax     # 0x26b10
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x10, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/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 %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq 0x20dc1(%rip), %rax     # 0x26b20
cmpq 0x20dc2(%rip), %rax     # 0x26b28
jne 0x5dc6
movl $0x3e90, %edi           # imm = 0x3E90
callq 0x10a0
movq %rax, 0x20da7(%rip)     # 0x26b20
cmpq $0x0, 0x20d9f(%rip)     # 0x26b20
jne 0x5da5
movq 0x1626e(%rip), %rax     # 0x1bff8
movq (%rax), %rdi
leaq 0x12935(%rip), %rsi     # 0x186c9
movb $0x0, %al
callq 0x1080
movl $0xc, %edi
callq 0x1120
movq 0x20d74(%rip), %rax     # 0x26b20
addq $0x3e80, %rax           # imm = 0x3E80
movq %rax, 0x20d6f(%rip)     # 0x26b28
movq 0x20d60(%rip), %rax     # 0x26b20
movq %rax, -0x8(%rbp)
jmp 0x5de3
movq 0x20d53(%rip), %rax     # 0x26b20
addq $0x10, %rax
movq %rax, 0x20d48(%rip)     # 0x26b20
movq 0x20d41(%rip), %rax     # 0x26b20
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x10, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/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 %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movl $0x0, 0x1e60e(%rip)     # 0x26b30
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
cmpl 0x1f386(%rip), %eax     # 0x278b8
jg 0x85bb
movl $0x20, %edi
callq 0x10a0
movslq -0x4(%rbp), %rdx
leaq 0x1e5e3(%rip), %rcx     # 0x26b30
movq %rax, 0x8(%rcx,%rdx,8)
movq %rax, -0x10(%rbp)
cmpq $0x0, -0x10(%rbp)
jne 0x857f
movq 0x13a94(%rip), %rax     # 0x1bff8
movq (%rax), %rdi
leaq 0x1017d(%rip), %rsi     # 0x186eb
movb $0x0, %al
callq 0x1080
movl $0x1b, %edi
callq 0x1120
movq -0x10(%rbp), %rax
movq $0x0, (%rax)
movq -0x10(%rbp), %rax
movl $0x0, 0x8(%rax)
movq -0x10(%rbp), %rax
movq $0x0, 0x18(%rax)
movq -0x10(%rbp), %rax
movq $0x0, 0x10(%rax)
movl -0x4(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x4(%rbp)
jmp 0x8529
movl $0x0, 0x1e9df(%rip)     # 0x26fa4
movl $0x0, 0x1e9d1(%rip)     # 0x26fa0
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
cmpl 0x1f2d9(%rip), %eax     # 0x278b8
jg 0x8649
movl $0x10, %edi
callq 0x10a0
movslq -0x4(%rbp), %rdx
leaq 0x1e9aa(%rip), %rcx     # 0x26fa0
movq %rax, 0x8(%rcx,%rdx,8)
movq %rax, -0x18(%rbp)
cmpq $0x0, -0x18(%rbp)
jne 0x8628
movq 0x139eb(%rip), %rax     # 0x1bff8
movq (%rax), %rdi
leaq 0x100d4(%rip), %rsi     # 0x186eb
movb $0x0, %al
callq 0x1080
movl $0x1c, %edi
callq 0x1120
movq -0x18(%rbp), %rax
movq $0x0, 0x8(%rax)
movq -0x18(%rbp), %rax
movl $0x0, (%rax)
movl -0x4(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x4(%rbp)
jmp 0x85d6
addq $0x20, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/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
movq %rsp, %rbp
subq $0x30, %rsp
movw %si, %ax
movq %rdi, -0x8(%rbp)
movw %ax, -0xa(%rbp)
movq %rdx, -0x18(%rbp)
movq %rcx, -0x20(%rbp)
movl $0x0, -0x24(%rbp)
cmpl $0x3, -0x24(%rbp)
jge 0x879f
movq -0x8(%rbp), %rax
movzwl -0xa(%rbp), %ecx
imulq $0x90, %rcx, %rcx
addq %rcx, %rax
movslq -0x24(%rbp), %rcx
imulq $0x30, %rcx, %rcx
addq %rcx, %rax
movzwl 0x14(%rax), %eax
cmpl $0x246, %eax            # imm = 0x246
jne 0x86d4
movq -0x8(%rbp), %rax
movzwl -0xa(%rbp), %ecx
imulq $0x90, %rcx, %rcx
addq %rcx, %rax
movslq -0x24(%rbp), %rcx
imulq $0x30, %rcx, %rcx
addq %rcx, %rax
movabsq $0x7fffffffffffffff, %rcx # imm = 0x7FFFFFFFFFFFFFFF
movq %rcx, 0x8(%rax)
jmp 0x878f
movq -0x8(%rbp), %rax
movzwl -0xa(%rbp), %ecx
imulq $0x90, %rcx, %rcx
addq %rcx, %rax
movslq -0x24(%rbp), %rcx
imulq $0x30, %rcx, %rcx
addq %rcx, %rax
movq $0x0, 0x8(%rax)
movq -0x18(%rbp), %rax
movq -0x8(%rbp), %rcx
movzwl -0xa(%rbp), %edx
imulq $0x90, %rdx, %rdx
addq %rdx, %rcx
movslq -0x24(%rbp), %rdx
imulq $0x30, %rdx, %rdx
addq %rdx, %rcx
movzwl 0x14(%rcx), %ecx
cmpb $0x0, (%rax,%rcx)
jne 0x878d
movq -0x20(%rbp), %rax
movl (%rax), %ecx
addl $0x1, %ecx
movl %ecx, (%rax)
movq -0x18(%rbp), %rax
movq -0x8(%rbp), %rcx
movzwl -0xa(%rbp), %edx
imulq $0x90, %rdx, %rdx
addq %rdx, %rcx
movslq -0x24(%rbp), %rdx
imulq $0x30, %rdx, %rdx
addq %rdx, %rcx
movzwl 0x14(%rcx), %ecx
movb $0x1, (%rax,%rcx)
movq -0x8(%rbp), %rdi
movq -0x8(%rbp), %rax
movzwl -0xa(%rbp), %ecx
imulq $0x90, %rcx, %rcx
addq %rcx, %rax
movslq -0x24(%rbp), %rcx
imulq $0x30, %rcx, %rcx
addq %rcx, %rax
movw 0x14(%rax), %ax
movq -0x18(%rbp), %rdx
movq -0x20(%rbp), %rcx
movzwl %ax, %esi
callq 0x8650
jmp 0x878f
jmp 0x8791
movl -0x24(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x24(%rbp)
jmp 0x8672
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/mishun[P]plantri/fullgen.c
// Function: checksize_and_mark
int checksize_and_mark( KANTE* edge)
{
KANTE *run; 
int zaehler=1;

edge->noleft=1;
for (run=edge->invers->next; run != edge; run=run->invers->next) {run->noleft=1; zaehler++;}
return(zaehler);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movl $0x1, -0x14(%rbp)
movq -0x8(%rbp), %rax
movb $0x1, 0x11(%rax)
movq -0x8(%rbp), %rax
movq 0x28(%rax), %rax
movq 0x20(%rax), %rax
movq %rax, -0x10(%rbp)
movq -0x10(%rbp), %rax
cmpq -0x8(%rbp), %rax
je 0xa444
movq -0x10(%rbp), %rax
movb $0x1, 0x11(%rax)
movl -0x14(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x14(%rbp)
movq -0x10(%rbp), %rax
movq 0x28(%rax), %rax
movq 0x20(%rax), %rax
movq %rax, -0x10(%rbp)
jmp 0xa417
movl -0x14(%rbp), %eax
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/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
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl %edx, -0x14(%rbp)
movl $0x0, -0x18(%rbp)
movl -0x18(%rbp), %eax
cmpl -0x14(%rbp), %eax
jg 0xa48b
movq -0x10(%rbp), %rax
movslq -0x18(%rbp), %rcx
movw $0x0, (%rax,%rcx,2)
movl -0x18(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x18(%rbp)
jmp 0xa46a
movl $0x0, -0x1c(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x30(%rbp)
movl $0x1, -0x20(%rbp)
movl -0x1c(%rbp), %eax
cmpl -0x14(%rbp), %eax
jge 0xa5bf
movq -0x30(%rbp), %rdi
callq 0xa3f0
cmpl $0x5, %eax
jne 0xa4e5
movl -0x20(%rbp), %eax
movw %ax, %dx
movq -0x10(%rbp), %rax
movslq -0x1c(%rbp), %rcx
movw %dx, (%rax,%rcx,2)
movl -0x1c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x1c(%rbp)
movl -0x1c(%rbp), %eax
cmpl -0x14(%rbp), %eax
jne 0xa4e3
jmp 0xa5bf
jmp 0xa4e5
movl -0x20(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x20(%rbp)
movq -0x30(%rbp), %rax
movq 0x28(%rax), %rax
movq %rax, -0x38(%rbp)
movq -0x30(%rbp), %rax
movq 0x18(%rax), %rax
movq %rax, -0x30(%rbp)
movl $0x1, -0x24(%rbp)
movq -0x38(%rbp), %rcx
xorl %eax, %eax
cmpq -0x30(%rbp), %rcx
movb %al, -0x39(%rbp)
je 0xa538
movq -0x30(%rbp), %rax
movsbl 0x11(%rax), %ecx
xorl %eax, %eax
cmpl $0x0, %ecx
movb %al, -0x39(%rbp)
je 0xa538
cmpl $0x6, -0x24(%rbp)
setle %al
movb %al, -0x39(%rbp)
movb -0x39(%rbp), %al
testb $0x1, %al
jne 0xa541
jmp 0xa55c
movq -0x30(%rbp), %rax
movq 0x28(%rax), %rax
movq 0x18(%rax), %rax
movq %rax, -0x30(%rbp)
movl -0x24(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x24(%rbp)
jmp 0xa50d
movq -0x38(%rbp), %rax
cmpq -0x30(%rbp), %rax
jne 0xa5ba
movq -0x30(%rbp), %rax
movsbl 0x11(%rax), %eax
cmpl $0x0, %eax
je 0xa5ba
movl -0x20(%rbp), %eax
movw %ax, %dx
movq -0x10(%rbp), %rax
movslq -0x1c(%rbp), %rcx
movw %dx, (%rax,%rcx,2)
movl -0x1c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x1c(%rbp)
movl -0x1c(%rbp), %eax
cmpl -0x14(%rbp), %eax
jge 0xa5b8
movq 0x11a5b(%rip), %rax     # 0x1bff8
movq (%rax), %rdi
leaq 0xe27d(%rip), %rsi      # 0x18824
movb $0x0, %al
callq 0x1080
movl $0x20, %edi
callq 0x1120
jmp 0xa5ba
jmp 0xa4a1
addq $0x40, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/mishun[P]plantri/fullgen.c
// Function: checksize_and_mark_sp
int checksize_and_mark_sp( KANTE* edge)
{
KANTE *run; 
int zaehler=1;

edge->noright=1;
for (run=edge->invers->prev; run != edge; run=run->invers->prev) {run->noright=1; zaehler++;}
return(zaehler);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movl $0x1, -0x14(%rbp)
movq -0x8(%rbp), %rax
movb $0x1, 0x12(%rax)
movq -0x8(%rbp), %rax
movq 0x28(%rax), %rax
movq 0x18(%rax), %rax
movq %rax, -0x10(%rbp)
movq -0x10(%rbp), %rax
cmpq -0x8(%rbp), %rax
je 0xaf14
movq -0x10(%rbp), %rax
movb $0x1, 0x12(%rax)
movl -0x14(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x14(%rbp)
movq -0x10(%rbp), %rax
movq 0x28(%rax), %rax
movq 0x18(%rax), %rax
movq %rax, -0x10(%rbp)
jmp 0xaee7
movl -0x14(%rbp), %eax
popq %rbp
retq
nopl (%rax)