LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O0/chrispanag[P]operating-systems-scheduler/strace-test.c
// Function: main
int main(int argc, char *argv[])
{
	int status;
	pid_t p, waitp;

	p = fork();
	if (p < 0) {
		perror("fork");
		exit(1);
	}

	if (p == 0) {
		raise(STOP_SIGNAL);
		/* Should never reach this point */
		printf("Child: FAIL.\n");
		exit(1);
	}

	/*
	 * Father sleeps for a while and kills the child.
	 * The child should be alive when the father wakes.
	 */
	printf("Parent: sleeping for a while...\n");
	sleep(2);

	if (kill(p, SIGKILL) < 0) {
		perror("kill");
		exit(1);
	}

	waitp = wait(&status);
	assert(p == waitp);
	if (WIFEXITED(status)) {
		printf("Parent: FAIL. Child exited, status = %d\n",
			WEXITSTATUS(status));
		exit(1);
	}

	if (!WIFSIGNALED(status)) {
		printf("Parent: FAIL. Child not signaled?\n");
		exit(1);
	}

	printf("Parent: SUCCESS. Child killed, sig = %d\n",
		WTERMSIG(status));
	return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movl $0x0, -0x4(%rbp)
movl %edi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
callq 0x10b0
movl %eax, -0x18(%rbp)
cmpl $0x0, -0x18(%rbp)
jge 0x11fa
leaq 0xe19(%rip), %rdi       # 0x2004
callq 0x1070
movl $0x1, %edi
callq 0x1080
cmpl $0x0, -0x18(%rbp)
jne 0x1222
movl $0x14, %edi
callq 0x1030
leaq 0xdf8(%rip), %rdi       # 0x2009
movb $0x0, %al
callq 0x1040
movl $0x1, %edi
callq 0x1080
leaq 0xdee(%rip), %rdi       # 0x2017
movb $0x0, %al
callq 0x1040
movl $0x2, %edi
callq 0x1090
movl -0x18(%rbp), %edi
movl $0x9, %esi
callq 0x1060
cmpl $0x0, %eax
jge 0x1262
leaq 0xde5(%rip), %rdi       # 0x2038
callq 0x1070
movl $0x1, %edi
callq 0x1080
leaq -0x14(%rbp), %rdi
callq 0x10a0
movl %eax, -0x1c(%rbp)
movl -0x18(%rbp), %eax
cmpl -0x1c(%rbp), %eax
jne 0x1278
jmp 0x1297
leaq 0xdbe(%rip), %rdi       # 0x203d
leaq 0xdc2(%rip), %rsi       # 0x2048
movl $0x35, %edx
leaq 0xdc4(%rip), %rcx       # 0x2056
callq 0x1050
movl -0x14(%rbp), %eax
andl $0x7f, %eax
cmpl $0x0, %eax
jne 0x12c6
movl -0x14(%rbp), %esi
andl $0xff00, %esi           # imm = 0xFF00
sarl $0x8, %esi
leaq 0xdb8(%rip), %rdi       # 0x206d
movb $0x0, %al
callq 0x1040
movl $0x1, %edi
callq 0x1080
movl -0x14(%rbp), %eax
andl $0x7f, %eax
addl $0x1, %eax
movsbl %al, %eax
sarl %eax
cmpl $0x0, %eax
jg 0x12f1
leaq 0xdb6(%rip), %rdi       # 0x2096
movb $0x0, %al
callq 0x1040
movl $0x1, %edi
callq 0x1080
movl -0x14(%rbp), %esi
andl $0x7f, %esi
leaq 0xdbb(%rip), %rdi       # 0x20b9
movb $0x0, %al
callq 0x1040
xorl %eax, %eax
addq $0x20, %rsp
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O0/saltyJeff[P]uClibcpp/extra/config/conf.c
// Function: conf_string
int conf_string(struct menu *menu)
{
	struct symbol *sym = menu->sym;
	const char *def, *help;

	while (1) {
		printf("%*s%s ", indent - 1, "", menu->prompt->text);
		printf("(%s) ", sym->name);
		def = sym_get_string_value(sym);
		if (sym_get_string_value(sym))
			printf("[%s] ", def);
		conf_askvalue(sym, def);
		switch (line[0]) {
		case '\n':
			break;
		case '?':
			/* print help */
			if (line[1] == 0) {
				help = nohelp_text;
				if (menu->sym->help)
					help = menu->sym->help;
				printf("\n%s\n", menu->sym->help);
				def = NULL;
				break;
			}
		default:
			line[strlen(line)-1] = 0;
			def = line;
		}
		if (def && sym_set_string_value(sym, def))
			return 0;
	}
}

// Assembly:
subq $0x28, %rsp
movq %rdi, 0x20(%rsp)
movq 0x20(%rsp), %rax
movq 0x18(%rax), %rax
movq %rax, 0x18(%rsp)
movl 0x16d73(%rip), %esi     # 0x191a0
subl $0x1, %esi
movq 0x20(%rsp), %rax
movq 0x20(%rax), %rax
movq 0x18(%rax), %rcx
leaq 0xdcdc(%rip), %rdi      # 0x10120
leaq 0xdde1(%rip), %rdx      # 0x1022c
movb $0x0, %al
callq 0x20f0
movq 0x18(%rsp), %rax
movq 0x8(%rax), %rsi
leaq 0xdcc5(%rip), %rdi      # 0x10127
movb $0x0, %al
callq 0x20f0
movq 0x18(%rsp), %rdi
callq 0xb7c0
movq %rax, 0x10(%rsp)
movq 0x18(%rsp), %rdi
callq 0xb7c0
cmpq $0x0, %rax
je 0x249b
movq 0x10(%rsp), %rsi
leaq 0xdc99(%rip), %rdi      # 0x1012d
movb $0x0, %al
callq 0x20f0
movq 0x18(%rsp), %rdi
movq 0x10(%rsp), %rsi
callq 0x2590
movsbl 0x16f4f(%rip), %eax     # 0x19400
movl %eax, 0x4(%rsp)
subl $0xa, %eax
je 0x24c7
jmp 0x24bc
movl 0x4(%rsp), %eax
subl $0x3f, %eax
je 0x24cc
jmp 0x252e
jmp 0x2558
movsbl 0x16f2e(%rip), %eax     # 0x19401
cmpl $0x0, %eax
jne 0x252c
leaq 0x16cd1(%rip), %rax     # 0x191b0
movq %rax, 0x8(%rsp)
movq 0x20(%rsp), %rax
movq 0x18(%rax), %rax
cmpq $0x0, 0x10(%rax)
je 0x2506
movq 0x20(%rsp), %rax
movq 0x18(%rax), %rax
movq 0x10(%rax), %rax
movq %rax, 0x8(%rsp)
movq 0x20(%rsp), %rax
movq 0x18(%rax), %rax
movq 0x10(%rax), %rsi
leaq 0x13341(%rip), %rdi     # 0x1585b
movb $0x0, %al
callq 0x20f0
movq $0x0, 0x10(%rsp)
jmp 0x2558
jmp 0x252e
leaq 0x16ecb(%rip), %rdi     # 0x19400
callq 0x20d0
movq %rax, %rcx
subq $0x1, %rcx
leaq 0x16eb8(%rip), %rax     # 0x19400
movb $0x0, (%rax,%rcx)
leaq 0x16ead(%rip), %rax     # 0x19400
movq %rax, 0x10(%rsp)
cmpq $0x0, 0x10(%rsp)
je 0x257c
movq 0x18(%rsp), %rdi
movq 0x10(%rsp), %rsi
callq 0xf1b0
testb $0x1, %al
jne 0x2575
jmp 0x257c
xorl %eax, %eax
addq $0x28, %rsp
retq
jmp 0x2427
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/saltyJeff[P]uClibcpp/extra/config/conf.c
// Function: conf
static void conf(struct menu *menu)
{
	struct symbol *sym;
	struct property *prop;
	struct menu *child;

	if (!menu_is_visible(menu))
		return;

	sym = menu->sym;
	prop = menu->prompt;
	if (prop) {
		const char *prompt;

		switch (prop->type) {
		case P_MENU:
			if (input_mode == ask_silent && rootEntry != menu) {
				check_conf(menu);
				return;
			}
		case P_COMMENT:
			prompt = menu_get_prompt(menu);
			if (prompt)
				printf("%*c\n%*c %s\n%*c\n",
					indent, '*',
					indent, '*', prompt,
					indent, '*');
		default:
			;
		}
	}

	if (!sym)
		goto conf_childs;

	if (sym_is_choice(sym)) {
		conf_choice(menu);
		if (sym->curr.tri != mod)
			return;
		goto conf_childs;
	}

	switch (sym->type) {
	case S_INT:
	case S_HEX:
	case S_STRING:
		conf_string(menu);
		break;
	default:
		conf_sym(menu);
		break;
	}

conf_childs:
	if (sym)
		indent += 2;
	for (child = menu->list; child; child = child->next)
		conf(child);
	if (sym)
		indent -= 2;
}

// Assembly:
subq $0x48, %rsp
movq %rdi, 0x40(%rsp)
movq 0x40(%rsp), %rdi
callq 0xb650
testb $0x1, %al
jne 0x2b2c
jmp 0x2cad
movq 0x40(%rsp), %rax
movq 0x18(%rax), %rax
movq %rax, 0x38(%rsp)
movq 0x40(%rsp), %rax
movq 0x20(%rax), %rax
movq %rax, 0x30(%rsp)
cmpq $0x0, 0x30(%rsp)
je 0x2bf0
movq 0x30(%rsp), %rax
movl 0x10(%rax), %eax
movl %eax, 0x1c(%rsp)
subl $0x2, %eax
je 0x2b9a
jmp 0x2b67
movl 0x1c(%rsp), %eax
subl $0x3, %eax
jne 0x2bec
jmp 0x2b72
cmpl $0x2, 0x16877(%rip)     # 0x193f0
jne 0x2b98
movq 0x168fe(%rip), %rax     # 0x19480
cmpq 0x40(%rsp), %rax
je 0x2b98
movq 0x40(%rsp), %rdi
callq 0x2cc0
jmp 0x2cad
jmp 0x2b9a
movq 0x40(%rsp), %rdi
callq 0xb750
movq %rax, 0x20(%rsp)
cmpq $0x0, 0x20(%rsp)
je 0x2bea
movl 0x165e9(%rip), %esi     # 0x191a0
movl 0x165e3(%rip), %ecx     # 0x191a0
movq 0x20(%rsp), %r9
movl 0x165d8(%rip), %eax     # 0x191a0
leaq 0xd6b3(%rip), %rdi      # 0x10282
movl $0x2a, %r8d
movl %r8d, %edx
movl %eax, (%rsp)
movl $0x2a, 0x8(%rsp)
movb $0x0, %al
callq 0x20f0
jmp 0x2bec
jmp 0x2bee
jmp 0x2bf0
cmpq $0x0, 0x38(%rsp)
jne 0x2bfa
jmp 0x2c50
movq 0x38(%rsp), %rdi
callq 0x2e30
testb $0x1, %al
jne 0x2c0a
jmp 0x2c26
movq 0x40(%rsp), %rdi
callq 0x2e60
movq 0x38(%rsp), %rax
cmpl $0x1, 0x28(%rax)
je 0x2c24
jmp 0x2cad
jmp 0x2c50
movq 0x38(%rsp), %rax
movl 0x18(%rax), %eax
addl $-0x3, %eax
subl $0x2, %eax
ja 0x2c44
jmp 0x2c38
movq 0x40(%rsp), %rdi
callq 0x2410
jmp 0x2c4e
movq 0x40(%rsp), %rdi
callq 0x3440
jmp 0x2c50
cmpq $0x0, 0x38(%rsp)
je 0x2c67
movl 0x16542(%rip), %eax     # 0x191a0
addl $0x2, %eax
movl %eax, 0x16539(%rip)     # 0x191a0
movq 0x40(%rsp), %rax
movq 0x10(%rax), %rax
movq %rax, 0x28(%rsp)
cmpq $0x0, 0x28(%rsp)
je 0x2c96
movq 0x28(%rsp), %rdi
callq 0x2b10
movq 0x28(%rsp), %rax
movq (%rax), %rax
movq %rax, 0x28(%rsp)
jmp 0x2c75
cmpq $0x0, 0x38(%rsp)
je 0x2cad
movl 0x164fc(%rip), %eax     # 0x191a0
subl $0x2, %eax
movl %eax, 0x164f3(%rip)     # 0x191a0
addq $0x48, %rsp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/saltyJeff[P]uClibcpp/extra/config/conf.c
// Function: check_conf
static void check_conf(struct menu *menu)
{
	struct symbol *sym;
	struct menu *child;

	if (!menu_is_visible(menu))
		return;

	sym = menu->sym;
	if (sym) {
		if (sym_is_changable(sym) && !sym_has_value(sym)) {
			if (!conf_cnt++)
				printf("*\n* Restart config...\n*\n");
			rootEntry = menu_get_parent_menu(menu);
			conf(rootEntry);
		}
		if (sym_is_choice(sym) && sym_get_tristate_value(sym) != mod)
			return;
	}

	for (child = menu->list; child; child = child->next)
		check_conf(child);
}

// Assembly:
subq $0x18, %rsp
movq %rdi, 0x10(%rsp)
movq 0x10(%rsp), %rdi
callq 0xb650
testb $0x1, %al
jne 0x2cdc
jmp 0x2da2
movq 0x10(%rsp), %rax
movq 0x18(%rax), %rax
movq %rax, 0x8(%rsp)
cmpq $0x0, 0x8(%rsp)
je 0x2d78
movq 0x8(%rsp), %rdi
callq 0xf3e0
testb $0x1, %al
jne 0x2d06
jmp 0x2d55
movq 0x8(%rsp), %rdi
callq 0x2db0
testb $0x1, %al
jne 0x2d55
movl 0x1676e(%rip), %eax     # 0x19488
movl %eax, %ecx
addl $0x1, %ecx
movl %ecx, 0x16763(%rip)     # 0x19488
cmpl $0x0, %eax
jne 0x2d38
leaq 0xd5b6(%rip), %rdi      # 0x102e7
movb $0x0, %al
callq 0x20f0
movq 0x10(%rsp), %rdi
callq 0xf700
movq %rax, 0x16737(%rip)     # 0x19480
movq 0x16730(%rip), %rdi     # 0x19480
callq 0x2b10
movq 0x8(%rsp), %rdi
callq 0x2e30
testb $0x1, %al
jne 0x2d65
jmp 0x2d76
movq 0x8(%rsp), %rdi
callq 0x3730
cmpl $0x1, %eax
je 0x2d76
jmp 0x2da2
jmp 0x2d78
movq 0x10(%rsp), %rax
movq 0x10(%rax), %rax
movq %rax, (%rsp)
cmpq $0x0, (%rsp)
je 0x2da2
movq (%rsp), %rdi
callq 0x2cc0
movq (%rsp), %rax
movq (%rax), %rax
movq %rax, (%rsp)
jmp 0x2d85
addq $0x18, %rsp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/saltyJeff[P]uClibcpp/extra/config/conf.c
// Function: check_stdin
static void check_stdin(void)
{
	if (!valid_stdin && input_mode == ask_silent) {
		printf("aborted!\n\n");
		printf("Console input/output is redirected. ");
		printf("Run 'make oldconfig' to update configuration.\n\n");
		exit(1);
	}
}

// Assembly:
pushq %rax
cmpl $0x0, 0x163f8(%rip)     # 0x191e0
jne 0x2e27
cmpl $0x2, 0x165ff(%rip)     # 0x193f0
jne 0x2e27
leaq 0xd428(%rip), %rdi      # 0x10222
movb $0x0, %al
callq 0x20f0
leaq 0xd425(%rip), %rdi      # 0x1022d
movb $0x0, %al
callq 0x20f0
leaq 0xd43c(%rip), %rdi      # 0x10252
movb $0x0, %al
callq 0x20f0
movl $0x1, %edi
callq 0x22d0
popq %rax
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/saltyJeff[P]uClibcpp/extra/config/conf.c
// Function: strip
static void strip(char *str)
{
	char *p = str;
	int l;

	while ((isspace(*p)))
		p++;
	l = strlen(p);
	if (p != str)
		memmove(str, p, l + 1);
	if (!l)
		return;
	p = str + l - 1;
	while ((isspace(*p)))
		*p-- = 0;
}

// Assembly:
subq $0x18, %rsp
movq %rdi, 0x10(%rsp)
movq 0x10(%rsp), %rax
movq %rax, 0x8(%rsp)
callq 0x2300
movq (%rax), %rax
movq 0x8(%rsp), %rcx
movsbl (%rcx), %ecx
movslq %ecx, %rcx
movzwl (%rax,%rcx,2), %eax
andl $0x2000, %eax           # imm = 0x2000
cmpl $0x0, %eax
je 0x3794
movq 0x8(%rsp), %rax
addq $0x1, %rax
movq %rax, 0x8(%rsp)
jmp 0x3763
movq 0x8(%rsp), %rdi
callq 0x20d0
movl %eax, 0x4(%rsp)
movq 0x8(%rsp), %rax
cmpq 0x10(%rsp), %rax
je 0x37c7
movq 0x10(%rsp), %rdi
movq 0x8(%rsp), %rsi
movl 0x4(%rsp), %eax
addl $0x1, %eax
movslq %eax, %rdx
callq 0x2260
cmpl $0x0, 0x4(%rsp)
jne 0x37d0
jmp 0x381d
movq 0x10(%rsp), %rax
movslq 0x4(%rsp), %rcx
addq %rcx, %rax
addq $-0x1, %rax
movq %rax, 0x8(%rsp)
callq 0x2300
movq (%rax), %rax
movq 0x8(%rsp), %rcx
movsbl (%rcx), %ecx
movslq %ecx, %rcx
movzwl (%rax,%rcx,2), %eax
andl $0x2000, %eax           # imm = 0x2000
cmpl $0x0, %eax
je 0x381d
movq 0x8(%rsp), %rax
movq %rax, %rcx
addq $-0x1, %rcx
movq %rcx, 0x8(%rsp)
movb $0x0, (%rax)
jmp 0x37e6
addq $0x18, %rsp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/saltyJeff[P]uClibcpp/extra/config/zconf.tab.c
// Function: zconfprint
static void zconfprint(const char *err, ...)
{
	va_list ap;

	fprintf(stderr, "%s:%d: ", zconf_curname(), zconf_lineno() + 1);
	va_start(ap, err);
	vfprintf(stderr, err, ap);
	va_end(ap);
	fprintf(stderr, "\n");
}

// Assembly:
subq $0xf8, %rsp
testb %al, %al
je 0x5e02
movaps %xmm0, 0x50(%rsp)
movaps %xmm1, 0x60(%rsp)
movaps %xmm2, 0x70(%rsp)
movaps %xmm3, 0x80(%rsp)
movaps %xmm4, 0x90(%rsp)
movaps %xmm5, 0xa0(%rsp)
movaps %xmm6, 0xb0(%rsp)
movaps %xmm7, 0xc0(%rsp)
movq %r9, 0x48(%rsp)
movq %r8, 0x40(%rsp)
movq %rcx, 0x38(%rsp)
movq %rdx, 0x30(%rsp)
movq %rsi, 0x28(%rsp)
movq %rdi, 0xf0(%rsp)
movq 0x131ce(%rip), %rax     # 0x18ff8
movq %rax, 0x10(%rsp)
movq (%rax), %rax
movq %rax, (%rsp)
callq 0x61a0
movq %rax, 0x8(%rsp)
callq 0x61d0
movq (%rsp), %rdi
movq 0x8(%rsp), %rdx
movl %eax, %ecx
incl %ecx
leaq 0x105b2(%rip), %rsi     # 0x1640b
xorl %eax, %eax
movb %al, 0x1f(%rsp)
callq 0x21a0
movq 0x10(%rsp), %rax
leaq 0x20(%rsp), %rcx
movq %rcx, 0xe0(%rsp)
leaq 0x100(%rsp), %rcx
movq %rcx, 0xd8(%rsp)
movl $0x30, 0xd4(%rsp)
movl $0x8, 0xd0(%rsp)
movq (%rax), %rdi
movq 0xf0(%rsp), %rsi
leaq 0xd0(%rsp), %rdx
callq 0x2290
movq 0x10(%rsp), %rcx
movb 0x1f(%rsp), %al
movq (%rcx), %rdi
leaq 0xa364(%rip), %rsi      # 0x1022b
callq 0x21a0
addq $0xf8, %rsp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/saltyJeff[P]uClibcpp/extra/config/./menu.c
// Function: menu_add_entry
void menu_add_entry(struct symbol *sym)
{
	struct menu *menu;

	menu = malloc(sizeof(*menu));
	memset(menu, 0, sizeof(*menu));
	menu->sym = sym;
	menu->parent = current_menu;
	menu->file = current_file;
	menu->lineno = zconf_lineno();

	*last_entry_ptr = menu;
	last_entry_ptr = &menu->next;
	current_entry = menu;
}

// Assembly:
subq $0x18, %rsp
movq %rdi, 0x10(%rsp)
movl $0x50, %edi
callq 0x2220
movq %rax, 0x8(%rsp)
movq 0x8(%rsp), %rdi
xorl %esi, %esi
movl $0x50, %edx
callq 0x2120
movq 0x10(%rsp), %rcx
movq 0x8(%rsp), %rax
movq %rcx, 0x18(%rax)
movq 0x1336a(%rip), %rcx     # 0x194a8
movq 0x8(%rsp), %rax
movq %rcx, 0x8(%rax)
movq 0x13c3a(%rip), %rcx     # 0x19d88
movq 0x8(%rsp), %rax
movq %rcx, 0x38(%rax)
callq 0x61d0
movl %eax, %ecx
movq 0x8(%rsp), %rax
movl %ecx, 0x40(%rax)
movq 0x8(%rsp), %rcx
movq 0x14c4e(%rip), %rax     # 0x1adc0
movq %rcx, (%rax)
movq 0x8(%rsp), %rax
movq %rax, 0x14c3f(%rip)     # 0x1adc0
movq 0x8(%rsp), %rax
movq %rax, 0x13313(%rip)     # 0x194a0
addq $0x18, %rsp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/saltyJeff[P]uClibcpp/extra/config/./menu.c
// Function: menu_set_type
void menu_set_type(int type)
{
	struct symbol *sym = current_entry->sym;

	if (sym->type == type)
		return;
	if (sym->type == S_UNKNOWN) {
		sym->type = type;
		return;
	}
	fprintf(stderr, "%s:%d:warning: type of '%s' redefined from '%s' to '%s'\n",
		current_entry->file->name, current_entry->lineno,
		sym->name ? sym->name : "<choice>", sym_type_name(sym->type), sym_type_name(type));
}

// Assembly:
subq $0x48, %rsp
movl %edi, 0x44(%rsp)
movq 0x13281(%rip), %rax     # 0x194a0
movq 0x18(%rax), %rax
movq %rax, 0x38(%rsp)
movq 0x38(%rsp), %rax
movl 0x18(%rax), %eax
cmpl 0x44(%rsp), %eax
jne 0x623b
jmp 0x6301
movq 0x38(%rsp), %rax
cmpl $0x0, 0x18(%rax)
jne 0x6257
movl 0x44(%rsp), %ecx
movq 0x38(%rsp), %rax
movl %ecx, 0x18(%rax)
jmp 0x6301
movq 0x12d9a(%rip), %rax     # 0x18ff8
movq (%rax), %rax
movq %rax, 0x20(%rsp)
movq 0x13233(%rip), %rax     # 0x194a0
movq 0x38(%rax), %rax
movq 0x10(%rax), %rax
movq %rax, 0x28(%rsp)
movq 0x1321f(%rip), %rax     # 0x194a0
movl 0x40(%rax), %eax
movl %eax, 0x34(%rsp)
movq 0x38(%rsp), %rax
cmpq $0x0, 0x8(%rax)
je 0x62a4
movq 0x38(%rsp), %rax
movq 0x8(%rax), %rax
movq %rax, 0x18(%rsp)
jmp 0x62b2
leaq 0xfaf2(%rip), %rax      # 0x15d9d
movq %rax, 0x18(%rsp)
jmp 0x62b2
movq 0x18(%rsp), %rax
movq %rax, 0x8(%rsp)
movq 0x38(%rsp), %rax
movl 0x18(%rax), %edi
callq 0xea70
movq %rax, 0x10(%rsp)
movl 0x44(%rsp), %edi
callq 0xea70
movq 0x20(%rsp), %rdi
movq 0x28(%rsp), %rdx
movl 0x34(%rsp), %ecx
movq 0x8(%rsp), %r8
movq 0x10(%rsp), %r9
leaq 0xfb44(%rip), %rsi      # 0x15e3a
movq %rax, (%rsp)
movb $0x0, %al
callq 0x21a0
addq $0x48, %rsp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/saltyJeff[P]uClibcpp/extra/config/./expr.c
// Function: expr_alloc_comp
struct expr *expr_alloc_comp(enum expr_type type, struct symbol *s1, struct symbol *s2)
{
	struct expr *e = malloc(sizeof(*e));
	memset(e, 0, sizeof(*e));
	e->type = type;
	e->left.sym = s1;
	e->right.sym = s2;
	return e;
}

// Assembly:
subq $0x28, %rsp
movl %edi, 0x24(%rsp)
movq %rsi, 0x18(%rsp)
movq %rdx, 0x10(%rsp)
movl $0x18, %edi
callq 0x2220
movq %rax, 0x8(%rsp)
movq 0x8(%rsp), %rdi
xorl %esi, %esi
movl $0x18, %edx
callq 0x2120
movl 0x24(%rsp), %ecx
movq 0x8(%rsp), %rax
movl %ecx, (%rax)
movq 0x18(%rsp), %rcx
movq 0x8(%rsp), %rax
movq %rcx, 0x8(%rax)
movq 0x10(%rsp), %rcx
movq 0x8(%rsp), %rax
movq %rcx, 0x10(%rax)
movq 0x8(%rsp), %rax
addq $0x28, %rsp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/saltyJeff[P]uClibcpp/extra/config/zconf.tab.c
// Function: zconf_endtoken
static bool zconf_endtoken(int token, int starttoken, int endtoken)
{
	if (token != endtoken) {
		zconfprint("unexpected '%s' within %s block", zconf_tokenname(token), zconf_tokenname(starttoken));
		zconfnerrs++;
		return false;
	}
	if (current_menu->file != current_file) {
		zconfprint("'%s' in different file than '%s'", zconf_tokenname(token), zconf_tokenname(starttoken));
		zconfprint("location of the '%s'", zconf_tokenname(starttoken));
		zconfnerrs++;
		return false;
	}
	return true;
}

// Assembly:
subq $0x28, %rsp
movl %edi, 0x20(%rsp)
movl %esi, 0x1c(%rsp)
movl %edx, 0x18(%rsp)
movl 0x20(%rsp), %eax
cmpl 0x18(%rsp), %eax
je 0x64ad
movl 0x20(%rsp), %edi
callq 0x7950
movq %rax, 0x10(%rsp)
movl 0x1c(%rsp), %edi
callq 0x7950
movq 0x10(%rsp), %rsi
movq %rax, %rdx
leaq 0xff25(%rip), %rdi      # 0x163b5
movb $0x0, %al
callq 0x5dc0
movl 0x12ff3(%rip), %eax     # 0x19490
addl $0x1, %eax
movl %eax, 0x12fea(%rip)     # 0x19490
movb $0x0, 0x27(%rsp)
jmp 0x6523
movq 0x12ff4(%rip), %rax     # 0x194a8
movq 0x38(%rax), %rax
cmpq 0x138c9(%rip), %rax     # 0x19d88
je 0x651e
movl 0x20(%rsp), %edi
callq 0x7950
movq %rax, 0x8(%rsp)
movl 0x1c(%rsp), %edi
callq 0x7950
movq 0x8(%rsp), %rsi
movq %rax, %rdx
leaq 0xfeee(%rip), %rdi      # 0x163d5
movb $0x0, %al
callq 0x5dc0
movl 0x1c(%rsp), %edi
callq 0x7950
movq %rax, %rsi
leaq 0xfef5(%rip), %rdi      # 0x163f6
movb $0x0, %al
callq 0x5dc0
movl 0x12f82(%rip), %eax     # 0x19490
addl $0x1, %eax
movl %eax, 0x12f79(%rip)     # 0x19490
movb $0x0, 0x27(%rsp)
jmp 0x6523
movb $0x1, 0x27(%rsp)
movb 0x27(%rsp), %al
andb $0x1, %al
addq $0x28, %rsp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/saltyJeff[P]uClibcpp/extra/config/./menu.c
// Function: menu_add_prop
struct property *menu_add_prop(enum prop_type type, char *prompt, struct expr *expr, struct expr *dep)
{
	struct property *prop = prop_alloc(type, current_entry->sym);

	prop->menu = current_entry;
	prop->text = prompt;
	prop->expr = expr;
	prop->visible.expr = menu_check_dep(dep);

	if (prompt) {
		if (current_entry->prompt)
			fprintf(stderr, "%s:%d: prompt redefined\n",
				current_entry->file->name, current_entry->lineno);
		current_entry->prompt = prop;
	}

	return prop;
}

// Assembly:
subq $0x28, %rsp
movl %edi, 0x24(%rsp)
movq %rsi, 0x18(%rsp)
movq %rdx, 0x10(%rsp)
movq %rcx, 0x8(%rsp)
movl 0x24(%rsp), %edi
movq 0x12ece(%rip), %rax     # 0x194a0
movq 0x18(%rax), %rsi
callq 0xe950
movq %rax, (%rsp)
movq 0x12eba(%rip), %rcx     # 0x194a0
movq (%rsp), %rax
movq %rcx, 0x38(%rax)
movq 0x18(%rsp), %rcx
movq (%rsp), %rax
movq %rcx, 0x18(%rax)
movq 0x10(%rsp), %rcx
movq (%rsp), %rax
movq %rcx, 0x30(%rax)
movq 0x8(%rsp), %rdi
callq 0xf5c0
movq %rax, %rcx
movq (%rsp), %rax
movq %rcx, 0x20(%rax)
cmpq $0x0, 0x18(%rsp)
je 0x6673
movq 0x12e74(%rip), %rax     # 0x194a0
cmpq $0x0, 0x20(%rax)
je 0x6664
movq 0x129be(%rip), %rax     # 0x18ff8
movq (%rax), %rdi
movq 0x12e5c(%rip), %rax     # 0x194a0
movq 0x38(%rax), %rax
movq 0x10(%rax), %rdx
movq 0x12e4d(%rip), %rax     # 0x194a0
movl 0x40(%rax), %ecx
leaq 0xf816(%rip), %rsi      # 0x15e73
movb $0x0, %al
callq 0x21a0
movq (%rsp), %rcx
movq 0x12e31(%rip), %rax     # 0x194a0
movq %rcx, 0x20(%rax)
movq (%rsp), %rax
addq $0x28, %rsp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/saltyJeff[P]uClibcpp/extra/config/lex.zconf.c
// Function: zconf_nextfile
void zconf_nextfile(const char *name)
{
	struct file *file = file_lookup(name);
	struct buffer *buf = malloc(sizeof(*buf));
	memset(buf, 0, sizeof(*buf));

	current_buf->state = YY_CURRENT_BUFFER;
	zconfin = zconf_fopen(name);
	if (!zconfin) {
		printf("%s:%d: can't open file \"%s\"\n", zconf_curname(), zconf_lineno(), name);
		exit(1);
	}
	zconf_switch_to_buffer(zconf_create_buffer(zconfin,YY_BUF_SIZE));
	buf->parent = current_buf;
	current_buf = buf;

	if (file->flags & FILE_BUSY) {
		printf("recursive scan (%s)?\n", name);
		exit(1);
	}
	if (file->flags & FILE_SCANNED) {
		printf("file %s already scanned?\n", name);
		exit(1);
	}
	file->flags |= FILE_BUSY;
	file->lineno = 1;
	file->parent = current_file;
	current_file = file;
}

// Assembly:
subq $0x28, %rsp
movq %rdi, 0x20(%rsp)
movq 0x20(%rsp), %rdi
callq 0x95a0
movq %rax, 0x18(%rsp)
movl $0x10, %edi
callq 0x2220
movq %rax, 0x10(%rsp)
movq 0x10(%rsp), %rdi
xorl %esi, %esi
movl $0x10, %edx
callq 0x2120
cmpq $0x0, 0x13698(%rip)     # 0x19d58
je 0x66db
movq 0x1368f(%rip), %rax     # 0x19d58
movq 0x13690(%rip), %rcx     # 0x19d60
movq (%rax,%rcx,8), %rax
movq %rax, 0x8(%rsp)
jmp 0x66e4
xorl %eax, %eax
movq %rax, 0x8(%rsp)
jmp 0x66e4
movq 0x8(%rsp), %rcx
movq 0x136a8(%rip), %rax     # 0x19d98
movq %rcx, 0x8(%rax)
movq 0x20(%rsp), %rdi
callq 0x94f0
movq %rax, 0x1361b(%rip)     # 0x19d20
cmpq $0x0, 0x13613(%rip)     # 0x19d20
jne 0x6740
callq 0x61a0
movq %rax, (%rsp)
callq 0x61d0
movq (%rsp), %rsi
movl %eax, %edx
movq 0x20(%rsp), %rcx
leaq 0xf2a3(%rip), %rdi      # 0x159d2
movb $0x0, %al
callq 0x20f0
movl $0x1, %edi
callq 0x22d0
movq 0x135d9(%rip), %rdi     # 0x19d20
movl $0x4000, %esi           # imm = 0x4000
callq 0x8270
movq %rax, %rdi
callq 0x8cf0
movq 0x13638(%rip), %rcx     # 0x19d98
movq 0x10(%rsp), %rax
movq %rcx, (%rax)
movq 0x10(%rsp), %rax
movq %rax, 0x13624(%rip)     # 0x19d98
movq 0x18(%rsp), %rax
movl 0x1c(%rax), %eax
andl $0x1, %eax
cmpl $0x0, %eax
je 0x67a1
movq 0x20(%rsp), %rsi
leaq 0xf25f(%rip), %rdi      # 0x159ef
movb $0x0, %al
callq 0x20f0
movl $0x1, %edi
callq 0x22d0
movq 0x18(%rsp), %rax
movl 0x1c(%rax), %eax
andl $0x2, %eax
cmpl $0x0, %eax
je 0x67ce
movq 0x20(%rsp), %rsi
leaq 0xf248(%rip), %rdi      # 0x15a05
movb $0x0, %al
callq 0x20f0
movl $0x1, %edi
callq 0x22d0
movq 0x18(%rsp), %rax
movl 0x1c(%rax), %ecx
orl $0x1, %ecx
movl %ecx, 0x1c(%rax)
movq 0x18(%rsp), %rax
movl $0x1, 0x18(%rax)
movq 0x13599(%rip), %rcx     # 0x19d88
movq 0x18(%rsp), %rax
movq %rcx, 0x8(%rax)
movq 0x18(%rsp), %rax
movq %rax, 0x13584(%rip)     # 0x19d88
addq $0x28, %rsp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/saltyJeff[P]uClibcpp/extra/config/./expr.c
// Function: expr_alloc_symbol
struct expr *expr_alloc_symbol(struct symbol *sym)
{
	struct expr *e = malloc(sizeof(*e));
	memset(e, 0, sizeof(*e));
	e->type = E_SYMBOL;
	e->left.sym = sym;
	return e;
}

// Assembly:
subq $0x18, %rsp
movq %rdi, 0x10(%rsp)
movl $0x18, %edi
callq 0x2220
movq %rax, 0x8(%rsp)
movq 0x8(%rsp), %rdi
xorl %esi, %esi
movl $0x18, %edx
callq 0x2120
movq 0x8(%rsp), %rax
movl $0x7, (%rax)
movq 0x10(%rsp), %rcx
movq 0x8(%rsp), %rax
movq %rcx, 0x8(%rax)
movq 0x8(%rsp), %rax
addq $0x18, %rsp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/saltyJeff[P]uClibcpp/extra/config/./expr.c
// Function: expr_alloc_one
struct expr *expr_alloc_one(enum expr_type type, struct expr *ce)
{
	struct expr *e = malloc(sizeof(*e));
	memset(e, 0, sizeof(*e));
	e->type = type;
	e->left.expr = ce;
	return e;
}

// Assembly:
subq $0x18, %rsp
movl %edi, 0x14(%rsp)
movq %rsi, 0x8(%rsp)
movl $0x18, %edi
callq 0x2220
movq %rax, (%rsp)
movq (%rsp), %rdi
xorl %esi, %esi
movl $0x18, %edx
callq 0x2120
movl 0x14(%rsp), %ecx
movq (%rsp), %rax
movl %ecx, (%rax)
movq 0x8(%rsp), %rcx
movq (%rsp), %rax
movq %rcx, 0x8(%rax)
movq (%rsp), %rax
addq $0x18, %rsp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/saltyJeff[P]uClibcpp/extra/config/zconf.tab.c
// Function: conf_parse
void conf_parse(const char *name)
{
	struct symbol *sym;
	int i;

	zconf_initscan(name);

	sym_init();
	menu_init();
	modules_sym = sym_lookup("MODULES", 0);
	rootmenu.prompt = menu_add_prop(P_MENU, "uClibc++ Configuration", NULL, NULL);

	//zconfdebug = 1;
	zconfparse();
	if (zconfnerrs)
		exit(1);
	menu_finalize(&rootmenu);
	for_all_symbols(i, sym) {
                if (!(sym->flags & SYMBOL_CHECKED) && sym_check_deps(sym))
                        printf("\n");
		else
			sym->flags |= SYMBOL_CHECK_DONE;
        }

	sym_change_count = 1;
}

// Assembly:
subq $0x18, %rsp
movq %rdi, 0x10(%rsp)
movq 0x10(%rsp), %rdi
callq 0x6b40
callq 0x6bd0
callq 0x6c50
leaq 0xed61(%rip), %rdi      # 0x15795
xorl %esi, %esi
callq 0x5ee0
movq %rax, 0x12a6e(%rip)     # 0x194b0
movl $0x3, %edi
leaq 0xed4f(%rip), %rsi      # 0x1579d
xorl %eax, %eax
movl %eax, %ecx
movq %rcx, %rdx
callq 0x65b0
movq %rax, 0x12a77(%rip)     # 0x194d8
callq 0x3860
cmpl $0x0, 0x12a23(%rip)     # 0x19490
je 0x6a79
movl $0x1, %edi
callq 0x22d0
leaq 0x12a38(%rip), %rdi     # 0x194b8
callq 0x6c80
movl $0x0, 0x4(%rsp)
cmpl $0x101, 0x4(%rsp)       # imm = 0x101
jge 0x6b2b
movslq 0x4(%rsp), %rcx
leaq 0x12a69(%rip), %rax     # 0x19510
movq (%rax,%rcx,8), %rax
movq %rax, 0x8(%rsp)
cmpq $0x0, 0x8(%rsp)
je 0x6b19
movq 0x8(%rsp), %rax
cmpl $0x6, 0x18(%rax)
je 0x6b08
movq 0x8(%rsp), %rax
movl 0x44(%rax), %eax
andl $0x2000, %eax           # imm = 0x2000
cmpl $0x0, %eax
jne 0x6af5
movq 0x8(%rsp), %rdi
callq 0x77f0
cmpq $0x0, %rax
je 0x6af5
leaq 0x973f(%rip), %rdi      # 0x1022b
movb $0x0, %al
callq 0x20f0
jmp 0x6b06
movq 0x8(%rsp), %rax
movl 0x44(%rax), %ecx
orl $0x4000, %ecx           # imm = 0x4000
movl %ecx, 0x44(%rax)
jmp 0x6b08
jmp 0x6b0a
movq 0x8(%rsp), %rax
movq (%rax), %rax
movq %rax, 0x8(%rsp)
jmp 0x6ab0
jmp 0x6b1b
movl 0x4(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x4(%rsp)
jmp 0x6a8d
movl $0x1, 0x131e3(%rip)     # 0x19d18
addq $0x18, %rsp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/saltyJeff[P]uClibcpp/extra/config/lex.zconf.c
// Function: zconf_initscan
void zconf_initscan(const char *name)
{
	zconfin = zconf_fopen(name);
	if (!zconfin) {
		printf("can't find file %s\n", name);
		exit(1);
	}

	current_buf = malloc(sizeof(*current_buf));
	memset(current_buf, 0, sizeof(*current_buf));

	current_file = file_lookup(name);
	current_file->lineno = 1;
	current_file->flags = FILE_BUSY;
}

// Assembly:
pushq %rax
movq %rdi, (%rsp)
movq (%rsp), %rdi
callq 0x94f0
movq %rax, 0x131cb(%rip)     # 0x19d20
cmpq $0x0, 0x131c3(%rip)     # 0x19d20
jne 0x6b7b
movq (%rsp), %rsi
leaq 0xee54(%rip), %rdi      # 0x159be
movb $0x0, %al
callq 0x20f0
movl $0x1, %edi
callq 0x22d0
movl $0x10, %edi
callq 0x2220
movq %rax, 0x1320c(%rip)     # 0x19d98
movq 0x13205(%rip), %rdi     # 0x19d98
xorl %esi, %esi
movl $0x10, %edx
callq 0x2120
movq (%rsp), %rdi
callq 0x95a0
movq %rax, 0x131d9(%rip)     # 0x19d88
movq 0x131d2(%rip), %rax     # 0x19d88
movl $0x1, 0x18(%rax)
movq 0x131c4(%rip), %rax     # 0x19d88
movl $0x1, 0x1c(%rax)
popq %rax
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/saltyJeff[P]uClibcpp/extra/config/./symbol.c
// Function: sym_init
void sym_init(void)
{
	struct symbol *sym;
	char *p;
	static bool inited = false;

	if (inited)
		return;
	inited = true;

	sym = sym_lookup("VERSION", 0);
	sym->type = S_STRING;
	sym->flags |= SYMBOL_AUTO;
	p = getenv("VERSION");
	if (p)
		sym_add_default(sym, p);
}

// Assembly:
subq $0x18, %rsp
testb $0x1, 0x141dd(%rip)     # 0x1adb8
je 0x6bdf
jmp 0x6c3e
movb $0x1, 0x141d2(%rip)     # 0x1adb8
leaq 0xefe6(%rip), %rdi      # 0x15bd3
xorl %esi, %esi
callq 0x5ee0
movq %rax, 0x10(%rsp)
movq 0x10(%rsp), %rax
movl $0x5, 0x18(%rax)
movq 0x10(%rsp), %rax
movl 0x44(%rax), %ecx
orl $0x1000, %ecx           # imm = 0x1000
movl %ecx, 0x44(%rax)
leaq 0xefb6(%rip), %rdi      # 0x15bd3
callq 0x2030
movq %rax, 0x8(%rsp)
cmpq $0x0, 0x8(%rsp)
je 0x6c3e
movq 0x10(%rsp), %rdi
movq 0x8(%rsp), %rsi
callq 0xe900
addq $0x18, %rsp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/saltyJeff[P]uClibcpp/extra/config/./symbol.c
// Function: sym_check_deps
struct symbol *sym_check_deps(struct symbol *sym)
{
	struct symbol *sym2;
	struct property *prop;

	if (sym->flags & SYMBOL_CHECK_DONE)
		return NULL;
	if (sym->flags & SYMBOL_CHECK) {
		printf("Warning! Found recursive dependency: %s", sym->name);
		return sym;
	}

	sym->flags |= (SYMBOL_CHECK | SYMBOL_CHECKED);
	sym2 = sym_check_expr_deps(sym->rev_dep.expr);
	if (sym2)
		goto out;

	for (prop = sym->prop; prop; prop = prop->next) {
		if (prop->type == P_CHOICE)
			continue;
		sym2 = sym_check_expr_deps(prop->visible.expr);
		if (sym2)
			goto out;
		if (prop->type != P_DEFAULT || sym_is_choice(sym))
			continue;
		sym2 = sym_check_expr_deps(prop->expr);
		if (sym2)
			goto out;
	}
out:
	if (sym2)
		printf(" %s", sym->name);
	sym->flags &= ~SYMBOL_CHECK;
	return sym2;
}

// Assembly:
subq $0x28, %rsp
movq %rdi, 0x18(%rsp)
movq 0x18(%rsp), %rax
movl 0x44(%rax), %eax
andl $0x4000, %eax           # imm = 0x4000
cmpl $0x0, %eax
je 0x7819
movq $0x0, 0x20(%rsp)
jmp 0x7944
movq 0x18(%rsp), %rax
movl 0x44(%rax), %eax
andl $0x8, %eax
cmpl $0x0, %eax
je 0x784f
movq 0x18(%rsp), %rax
movq 0x8(%rax), %rsi
leaq 0xe5bc(%rip), %rdi      # 0x15df5
movb $0x0, %al
callq 0x20f0
movq 0x18(%rsp), %rax
movq %rax, 0x20(%rsp)
jmp 0x7944
movq 0x18(%rsp), %rax
movl 0x44(%rax), %ecx
orl $0x2008, %ecx           # imm = 0x2008
movl %ecx, 0x44(%rax)
movq 0x18(%rsp), %rax
movq 0x60(%rax), %rdi
callq 0xf400
movq %rax, 0x10(%rsp)
cmpq $0x0, 0x10(%rsp)
je 0x7880
jmp 0x790d
movq 0x18(%rsp), %rax
movq 0x48(%rax), %rax
movq %rax, 0x8(%rsp)
cmpq $0x0, 0x8(%rsp)
je 0x790b
movq 0x8(%rsp), %rax
cmpl $0x5, 0x10(%rax)
jne 0x78a3
jmp 0x78fc
movq 0x8(%rsp), %rax
movq 0x20(%rax), %rdi
callq 0xf400
movq %rax, 0x10(%rsp)
cmpq $0x0, 0x10(%rsp)
je 0x78c0
jmp 0x790d
movq 0x8(%rsp), %rax
cmpl $0x4, 0x10(%rax)
jne 0x78db
movq 0x18(%rsp), %rdi
callq 0x7da0
testb $0x1, %al
jne 0x78db
jmp 0x78dd
jmp 0x78fc
movq 0x8(%rsp), %rax
movq 0x30(%rax), %rdi
callq 0xf400
movq %rax, 0x10(%rsp)
cmpq $0x0, 0x10(%rsp)
je 0x78fa
jmp 0x790d
jmp 0x78fc
movq 0x8(%rsp), %rax
movq (%rax), %rax
movq %rax, 0x8(%rsp)
jmp 0x788e
jmp 0x790d
cmpq $0x0, 0x10(%rsp)
je 0x792c
movq 0x18(%rsp), %rax
movq 0x8(%rax), %rsi
leaq 0x8984(%rip), %rdi      # 0x102a9
movb $0x0, %al
callq 0x20f0
movq 0x18(%rsp), %rax
movl 0x44(%rax), %ecx
andl $-0x9, %ecx
movl %ecx, 0x44(%rax)
movq 0x10(%rsp), %rax
movq %rax, 0x20(%rsp)
movq 0x20(%rsp), %rax
addq $0x28, %rsp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/saltyJeff[P]uClibcpp/extra/config/zconf.tab.c
// Function: zconf_tokenname
const char *zconf_tokenname(int token)
{
	switch (token) {
	case T_MENU:		return "menu";
	case T_ENDMENU:		return "endmenu";
	case T_CHOICE:		return "choice";
	case T_ENDCHOICE:	return "endchoice";
	case T_IF:		return "if";
	case T_ENDIF:		return "endif";
	}
	return "<token>";
}

// Assembly:
movl %edi, -0xc(%rsp)
movl -0xc(%rsp), %eax
addl $0xfffffefd, %eax       # imm = 0xFFFFFEFD
movl %eax, %ecx
movq %rcx, -0x18(%rsp)
subl $0xb, %eax
ja 0x79d2
movq -0x18(%rsp), %rax
leaq 0x8c27(%rip), %rcx      # 0x1059c
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
leaq 0xde32(%rip), %rax      # 0x157b7
movq %rax, -0x8(%rsp)
jmp 0x79de
leaq 0xde21(%rip), %rax      # 0x157b4
movq %rax, -0x8(%rsp)
jmp 0x79de
leaq 0xde1e(%rip), %rax      # 0x157bf
movq %rax, -0x8(%rsp)
jmp 0x79de
leaq 0xde0d(%rip), %rax      # 0x157bc
movq %rax, -0x8(%rsp)
jmp 0x79de
leaq 0xde0c(%rip), %rax      # 0x157c9
movq %rax, -0x8(%rsp)
jmp 0x79de
leaq 0xddfb(%rip), %rax      # 0x157c6
movq %rax, -0x8(%rsp)
jmp 0x79de
leaq 0xddf3(%rip), %rax      # 0x157cc
movq %rax, -0x8(%rsp)
movq -0x8(%rsp), %rax
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/saltyJeff[P]uClibcpp/extra/config/zconf.tab.c
// Function: print_quoted_string
void print_quoted_string(FILE *out, const char *str)
{
	const char *p;
	int len;

	putc('"', out);
	while ((p = strchr(str, '"'))) {
		len = p - str;
		if (len)
			fprintf(out, "%.*s", len, str);
		fputs("\\\"", out);
		str = p + 1;
	}
	fputs(str, out);
	putc('"', out);
}

// Assembly:
subq $0x28, %rsp
movq %rdi, 0x20(%rsp)
movq %rsi, 0x18(%rsp)
movq 0x20(%rsp), %rsi
movl $0x22, %edi
callq 0x2190
movq 0x18(%rsp), %rdi
movl $0x22, %esi
callq 0x20e0
movq %rax, 0x10(%rsp)
cmpq $0x0, %rax
je 0x7a7c
movq 0x10(%rsp), %rax
movq 0x18(%rsp), %rcx
subq %rcx, %rax
movl %eax, 0xc(%rsp)
cmpl $0x0, 0xc(%rsp)
je 0x7a5b
movq 0x20(%rsp), %rdi
movl 0xc(%rsp), %edx
movq 0x18(%rsp), %rcx
leaq 0xdd80(%rip), %rsi      # 0x157d4
movb $0x0, %al
callq 0x21a0
movq 0x20(%rsp), %rsi
leaq 0xdd72(%rip), %rdi      # 0x157d9
callq 0x2110
movq 0x10(%rsp), %rax
addq $0x1, %rax
movq %rax, 0x18(%rsp)
jmp 0x7a0d
movq 0x18(%rsp), %rdi
movq 0x20(%rsp), %rsi
callq 0x2110
movq 0x20(%rsp), %rsi
movl $0x22, %edi
callq 0x2190
addq $0x28, %rsp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/saltyJeff[P]uClibcpp/extra/config/lex.zconf.c
// Function: new_string
void new_string(void)
{
	text = malloc(START_STRSIZE);
	text_asize = START_STRSIZE;
	text_ptr = text;
	text_size = 0;
	*text_ptr = 0;
}

// Assembly:
pushq %rax
movl $0x10, %edi
callq 0x2220
movq %rax, 0x11ce6(%rip)     # 0x19d38
movl $0x10, 0x11ce4(%rip)    # 0x19d40
movq 0x11cd5(%rip), %rax     # 0x19d38
movq %rax, 0x11cde(%rip)     # 0x19d48
movl $0x0, 0x11cdc(%rip)     # 0x19d50
movq 0x11ccd(%rip), %rax     # 0x19d48
movb $0x0, (%rax)
popq %rax
retq
// File: /workspace/github_c_makefile_star2_O0/saltyJeff[P]uClibcpp/extra/config/lex.zconf.c
// Function: append_string
void append_string(const char *str, int size)
{
	int new_size = text_size + size + 1;
	if (new_size > text_asize) {
		text = realloc(text, new_size);
		text_asize = new_size;
		text_ptr = text + text_size;
	}
	memcpy(text_ptr, str, size);
	text_ptr += size;
	text_size += size;
	*text_ptr = 0;
}

// Assembly:
subq $0x18, %rsp
movq %rdi, 0x10(%rsp)
movl %esi, 0xc(%rsp)
movl 0x11cbd(%rip), %eax     # 0x19d50
addl 0xc(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x8(%rsp)
movl 0x8(%rsp), %eax
cmpl 0x11c98(%rip), %eax     # 0x19d40
jle 0x80e4
movq 0x11c87(%rip), %rdi     # 0x19d38
movslq 0x8(%rsp), %rsi
callq 0x2250
movq %rax, 0x11c76(%rip)     # 0x19d38
movl 0x8(%rsp), %eax
movl %eax, 0x11c74(%rip)     # 0x19d40
movq 0x11c65(%rip), %rax     # 0x19d38
movslq 0x11c76(%rip), %rcx     # 0x19d50
addq %rcx, %rax
movq %rax, 0x11c64(%rip)     # 0x19d48
movq 0x11c5d(%rip), %rdi     # 0x19d48
movq 0x10(%rsp), %rsi
movslq 0xc(%rsp), %rdx
callq 0x21e0
movl 0xc(%rsp), %ecx
movq 0x11c43(%rip), %rax     # 0x19d48
movslq %ecx, %rcx
addq %rcx, %rax
movq %rax, 0x11c36(%rip)     # 0x19d48
movl 0xc(%rsp), %eax
addl 0x11c34(%rip), %eax     # 0x19d50
movl %eax, 0x11c2e(%rip)     # 0x19d50
movq 0x11c1f(%rip), %rax     # 0x19d48
movb $0x0, (%rax)
addq $0x18, %rsp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/saltyJeff[P]uClibcpp/extra/config/lex.zconf.c
// Function: zconfensure_buffer_stack
static void zconfensure_buffer_stack (void)
{
	int num_to_alloc;
    
	if (!(yy_buffer_stack)) {

		/* First allocation is just for 2 elements, since we don't know if this
		 * scanner will even need a stack. We use 2 instead of 1 to avoid an
		 * immediate realloc on the next call.
         */
		num_to_alloc = 1;
		(yy_buffer_stack) = (struct yy_buffer_state**)zconfalloc
								(num_to_alloc * sizeof(struct yy_buffer_state*)
								);
		
		memset((yy_buffer_stack), 0, num_to_alloc * sizeof(struct yy_buffer_state*));
				
		(yy_buffer_stack_max) = num_to_alloc;
		(yy_buffer_stack_top) = 0;
		return;
	}

	if ((yy_buffer_stack_top) >= ((yy_buffer_stack_max)) - 1){

		/* Increase the buffer to prepare for a possible push. */
		int grow_size = 8 /* arbitrary grow size */;

		num_to_alloc = (yy_buffer_stack_max) + grow_size;
		(yy_buffer_stack) = (struct yy_buffer_state**)zconfrealloc
								((yy_buffer_stack),
								num_to_alloc * sizeof(struct yy_buffer_state*)
								);

		/* zero only the new slots.*/
		memset((yy_buffer_stack) + (yy_buffer_stack_max), 0, grow_size * sizeof(struct yy_buffer_state*));
		(yy_buffer_stack_max) = num_to_alloc;
	}
}

// Assembly:
pushq %rax
cmpq $0x0, 0x11bbf(%rip)     # 0x19d58
jne 0x81ea
movl $0x1, 0x4(%rsp)
movslq 0x4(%rsp), %rax
shlq $0x3, %rax
movl %eax, %edi
callq 0x8de0
movq %rax, 0x11b9e(%rip)     # 0x19d58
movq 0x11b97(%rip), %rdi     # 0x19d58
movslq 0x4(%rsp), %rdx
shlq $0x3, %rdx
xorl %esi, %esi
callq 0x2120
movslq 0x4(%rsp), %rax
movq %rax, 0x12bf3(%rip)     # 0x1add0
movq $0x0, 0x11b78(%rip) # 0x19d60
jmp 0x8268
movq 0x11b6f(%rip), %rax     # 0x19d60
movq 0x12bd8(%rip), %rcx     # 0x1add0
subq $0x1, %rcx
cmpq %rcx, %rax
jb 0x8268
movl $0x8, (%rsp)
movq 0x12bc1(%rip), %rax     # 0x1add0
movslq (%rsp), %rcx
addq %rcx, %rax
movl %eax, 0x4(%rsp)
movq 0x11b37(%rip), %rdi     # 0x19d58
movslq 0x4(%rsp), %rax
shlq $0x3, %rax
movl %eax, %esi
callq 0x94c0
movq %rax, 0x11b20(%rip)     # 0x19d58
movq 0x11b19(%rip), %rdi     # 0x19d58
movq 0x12b8a(%rip), %rax     # 0x1add0
shlq $0x3, %rax
addq %rax, %rdi
movslq (%rsp), %rdx
shlq $0x3, %rdx
xorl %esi, %esi
callq 0x2120
movslq 0x4(%rsp), %rax
movq %rax, 0x12b68(%rip)     # 0x1add0
popq %rax
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/saltyJeff[P]uClibcpp/extra/config/lex.zconf.c
// Function: zconf_create_buffer
YY_BUFFER_STATE zconf_create_buffer  (FILE * file, int  size )
{
	YY_BUFFER_STATE b;
    
	b = (YY_BUFFER_STATE) zconfalloc(sizeof( struct yy_buffer_state )  );
	if ( ! b )
		YY_FATAL_ERROR( "out of dynamic memory in zconf_create_buffer()" );

	b->yy_buf_size = size;

	/* yy_ch_buf has to be 2 characters longer than the size given because
	 * we need to put in 2 end-of-buffer characters.
	 */
	b->yy_ch_buf = (char *) zconfalloc(b->yy_buf_size + 2  );
	if ( ! b->yy_ch_buf )
		YY_FATAL_ERROR( "out of dynamic memory in zconf_create_buffer()" );

	b->yy_is_our_buffer = 1;

	zconf_init_buffer(b,file );

	return b;
}

// Assembly:
subq $0x18, %rsp
movq %rdi, 0x10(%rsp)
movl %esi, 0xc(%rsp)
movl $0x40, %edi
callq 0x8de0
movq %rax, (%rsp)
cmpq $0x0, (%rsp)
jne 0x829e
leaq 0xd66e(%rip), %rdi      # 0x15907
callq 0x8640
movl 0xc(%rsp), %ecx
movq (%rsp), %rax
movl %ecx, 0x18(%rax)
movq (%rsp), %rax
movl 0x18(%rax), %edi
addl $0x2, %edi
callq 0x8de0
movq %rax, %rcx
movq (%rsp), %rax
movq %rcx, 0x8(%rax)
movq (%rsp), %rax
cmpq $0x0, 0x8(%rax)
jne 0x82da
leaq 0xd632(%rip), %rdi      # 0x15907
callq 0x8640
movq (%rsp), %rax
movl $0x1, 0x20(%rax)
movq (%rsp), %rdi
movq 0x10(%rsp), %rsi
callq 0x8c30
movq (%rsp), %rax
addq $0x18, %rsp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/saltyJeff[P]uClibcpp/extra/config/lex.zconf.c
// Function: zconf_load_buffer_state
static void zconf_load_buffer_state  (void)
{
    	(yy_n_chars) = YY_CURRENT_BUFFER_LVALUE->yy_n_chars;
	(yytext_ptr) = (yy_c_buf_p) = YY_CURRENT_BUFFER_LVALUE->yy_buf_pos;
	zconfin = YY_CURRENT_BUFFER_LVALUE->yy_input_file;
	(yy_hold_char) = *(yy_c_buf_p);
}

// Assembly:
movq 0x11a51(%rip), %rax     # 0x19d58
movq 0x11a52(%rip), %rcx     # 0x19d60
movq (%rax,%rcx,8), %rax
movl 0x1c(%rax), %eax
movl %eax, 0x11a85(%rip)     # 0x19da0
movq 0x11a36(%rip), %rax     # 0x19d58
movq 0x11a37(%rip), %rcx     # 0x19d60
movq (%rax,%rcx,8), %rax
movq 0x10(%rax), %rax
movq %rax, 0x11a30(%rip)     # 0x19d68
movq %rax, 0x11a39(%rip)     # 0x19d78
movq 0x11a12(%rip), %rax     # 0x19d58
movq 0x11a13(%rip), %rcx     # 0x19d60
movq (%rax,%rcx,8), %rax
movq (%rax), %rax
movq %rax, 0x119c5(%rip)     # 0x19d20
movq 0x11a06(%rip), %rax     # 0x19d68
movb (%rax), %al
movb %al, 0x11a06(%rip)      # 0x19d70
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/saltyJeff[P]uClibcpp/extra/config/lex.zconf.c
// Function: zconf_endfile
static struct buffer *zconf_endfile(void)
{
	struct buffer *parent;

	current_file->flags |= FILE_SCANNED;
	current_file->flags &= ~FILE_BUSY;
	current_file = current_file->parent;

	parent = current_buf->parent;
	if (parent) {
		fclose(zconfin);
		zconf_delete_buffer(YY_CURRENT_BUFFER);
		zconf_switch_to_buffer(parent->state);
	}
	free(current_buf);
	current_buf = parent;

	return parent;
}

// Assembly:
subq $0x18, %rsp
movq 0x117fd(%rip), %rax     # 0x19d88
movl 0x1c(%rax), %ecx
orl $0x2, %ecx
movl %ecx, 0x1c(%rax)
movq 0x117ed(%rip), %rax     # 0x19d88
movl 0x1c(%rax), %ecx
andl $-0x2, %ecx
movl %ecx, 0x1c(%rax)
movq 0x117dd(%rip), %rax     # 0x19d88
movq 0x8(%rax), %rax
movq %rax, 0x117d2(%rip)     # 0x19d88
movq 0x117db(%rip), %rax     # 0x19d98
movq (%rax), %rax
movq %rax, 0x10(%rsp)
cmpq $0x0, 0x10(%rsp)
je 0x861d
movq 0x1174c(%rip), %rdi     # 0x19d20
callq 0x20c0
cmpq $0x0, 0x11777(%rip)     # 0x19d58
je 0x85fc
movq 0x1176e(%rip), %rax     # 0x19d58
movq 0x1176f(%rip), %rcx     # 0x19d60
movq (%rax,%rcx,8), %rax
movq %rax, 0x8(%rsp)
jmp 0x8605
xorl %eax, %eax
movq %rax, 0x8(%rsp)
jmp 0x8605
movq 0x8(%rsp), %rdi
callq 0x8e00
movq 0x10(%rsp), %rax
movq 0x8(%rax), %rdi
callq 0x8cf0
movq 0x11774(%rip), %rdi     # 0x19d98
callq 0x2040
movq 0x10(%rsp), %rax
movq %rax, 0x11763(%rip)     # 0x19d98
movq 0x10(%rsp), %rax
addq $0x18, %rsp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/saltyJeff[P]uClibcpp/extra/config/lex.zconf.c
// Function: yy_get_previous_state
static yy_state_type yy_get_previous_state (void)
{
	register yy_state_type yy_current_state;
	register char *yy_cp;
    
	yy_current_state = (yy_start);

	for ( yy_cp = (yytext_ptr) + YY_MORE_ADJ; yy_cp < (yy_c_buf_p); ++yy_cp )
		{
		yy_current_state = yy_nxt[yy_current_state][(*yy_cp ? yy_ec[YY_SC_TO_UI(*yy_cp)] : 1)];
		}

	return yy_current_state;
}

// Assembly:
movl 0x116de(%rip), %eax     # 0x19d54
movl %eax, -0x4(%rsp)
movq 0x116f7(%rip), %rax     # 0x19d78
movq %rax, -0x10(%rsp)
movq -0x10(%rsp), %rax
cmpq 0x116d6(%rip), %rax     # 0x19d68
jae 0x8704
movslq -0x4(%rsp), %rcx
leaq 0x8940(%rip), %rax      # 0x10fe0
imulq $0x4c, %rcx, %rcx
addq %rcx, %rax
movq %rax, -0x18(%rsp)
movq -0x10(%rsp), %rax
movsbl (%rax), %eax
cmpl $0x0, %eax
je 0x86d5
movq -0x10(%rsp), %rax
movzbl (%rax), %eax
movl %eax, %eax
movl %eax, %ecx
leaq 0xc7c4(%rip), %rax      # 0x14e90
movl (%rax,%rcx,4), %eax
movl %eax, -0x1c(%rsp)
jmp 0x86e0
movl $0x1, %eax
movl %eax, -0x1c(%rsp)
jmp 0x86e0
movq -0x18(%rsp), %rax
movl -0x1c(%rsp), %ecx
movslq %ecx, %rcx
movswl (%rax,%rcx,2), %eax
movl %eax, -0x4(%rsp)
movq -0x10(%rsp), %rax
addq $0x1, %rax
movq %rax, -0x10(%rsp)
jmp 0x8686
movl -0x4(%rsp), %eax
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/saltyJeff[P]uClibcpp/extra/config/lex.zconf.c
// Function: yy_try_NUL_trans
static yy_state_type yy_try_NUL_trans  (yy_state_type yy_current_state )
{
	register int yy_is_jam;
    
	yy_current_state = yy_nxt[yy_current_state][1];
	yy_is_jam = (yy_current_state <= 0);

	return yy_is_jam ? 0 : yy_current_state;
}

// Assembly:
movl %edi, -0x4(%rsp)
movslq -0x4(%rsp), %rcx
leaq 0x88c0(%rip), %rax      # 0x10fe0
imulq $0x4c, %rcx, %rcx
addq %rcx, %rax
movswl 0x2(%rax), %eax
movl %eax, -0x4(%rsp)
cmpl $0x0, -0x4(%rsp)
setle %al
andb $0x1, %al
movzbl %al, %eax
movl %eax, -0x8(%rsp)
cmpl $0x0, -0x8(%rsp)
je 0x874f
xorl %eax, %eax
movl %eax, -0xc(%rsp)
jmp 0x8757
movl -0x4(%rsp), %eax
movl %eax, -0xc(%rsp)
movl -0xc(%rsp), %eax
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/saltyJeff[P]uClibcpp/extra/config/lex.zconf.c
// Function: zconfrestart
void zconfrestart  (FILE * input_file )
{
    
	if ( ! YY_CURRENT_BUFFER ){
        zconfensure_buffer_stack ();
		YY_CURRENT_BUFFER_LVALUE =
            zconf_create_buffer(zconfin,YY_BUF_SIZE );
	}

	zconf_init_buffer(YY_CURRENT_BUFFER,input_file );
	zconf_load_buffer_state( );
}

// Assembly:
subq $0x18, %rsp
movq %rdi, 0x10(%rsp)
cmpq $0x0, 0x111c7(%rip)     # 0x19d58
je 0x8baa
movq 0x111be(%rip), %rax     # 0x19d58
movq 0x111bf(%rip), %rcx     # 0x19d60
cmpq $0x0, (%rax,%rcx,8)
jne 0x8bdd
jmp 0x8bb2
xorl %eax, %eax
testb $0x1, %al
jne 0x8bdd
jmp 0x8bb2
callq 0x8190
movq 0x11162(%rip), %rdi     # 0x19d20
movl $0x4000, %esi           # imm = 0x4000
callq 0x8270
movq %rax, %rdx
movq 0x11186(%rip), %rax     # 0x19d58
movq 0x11187(%rip), %rcx     # 0x19d60
movq %rdx, (%rax,%rcx,8)
cmpq $0x0, 0x11173(%rip)     # 0x19d58
je 0x8c00
movq 0x1116a(%rip), %rax     # 0x19d58
movq 0x1116b(%rip), %rcx     # 0x19d60
movq (%rax,%rcx,8), %rax
movq %rax, 0x8(%rsp)
jmp 0x8c09
xorl %eax, %eax
movq %rax, 0x8(%rsp)
jmp 0x8c09
movq 0x8(%rsp), %rdi
movq 0x10(%rsp), %rsi
callq 0x8c30
callq 0x8300
addq $0x18, %rsp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/saltyJeff[P]uClibcpp/extra/config/lex.zconf.c
// Function: zconf_init_buffer
static void zconf_init_buffer  (YY_BUFFER_STATE  b, FILE * file )

{
	int oerrno = errno;
    
	zconf_flush_buffer(b );

	b->yy_input_file = file;
	b->yy_fill_buffer = 1;

    /* If b is the current buffer, then zconf_init_buffer was _probably_
     * called from zconfrestart() or through yy_get_next_buffer.
     * In that case, we don't want to reset the lineno or column.
     */
    if (b != YY_CURRENT_BUFFER){
        b->yy_bs_lineno = 1;
        b->yy_bs_column = 0;
    }

        b->yy_is_interactive = 0;
    
	errno = oerrno;
}

// Assembly:
subq $0x38, %rsp
movq %rdi, 0x30(%rsp)
movq %rsi, 0x28(%rsp)
callq 0x2060
movl (%rax), %eax
movl %eax, 0x24(%rsp)
movq 0x30(%rsp), %rdi
callq 0x8eb0
movq 0x28(%rsp), %rcx
movq 0x30(%rsp), %rax
movq %rcx, (%rax)
movq 0x30(%rsp), %rax
movl $0x1, 0x34(%rax)
movq 0x30(%rsp), %rax
movq %rax, 0x18(%rsp)
cmpq $0x0, 0x110da(%rip)     # 0x19d58
je 0x8c99
movq 0x110d1(%rip), %rax     # 0x19d58
movq 0x110d2(%rip), %rcx     # 0x19d60
movq (%rax,%rcx,8), %rax
movq %rax, 0x10(%rsp)
jmp 0x8ca2
xorl %eax, %eax
movq %rax, 0x10(%rsp)
jmp 0x8ca2
movq 0x18(%rsp), %rax
movq 0x10(%rsp), %rcx
cmpq %rcx, %rax
je 0x8cc9
movq 0x30(%rsp), %rax
movl $0x1, 0x2c(%rax)
movq 0x30(%rsp), %rax
movl $0x0, 0x30(%rax)
movq 0x30(%rsp), %rax
movl $0x0, 0x24(%rax)
movl 0x24(%rsp), %eax
movl %eax, 0xc(%rsp)
callq 0x2060
movl 0xc(%rsp), %ecx
movl %ecx, (%rax)
addq $0x38, %rsp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/saltyJeff[P]uClibcpp/extra/config/lex.zconf.c
// Function: zconf_switch_to_buffer
void zconf_switch_to_buffer  (YY_BUFFER_STATE  new_buffer )
{
    
	/* TODO. We should be able to replace this entire function body
	 * with
	 *		zconfpop_buffer_state();
	 *		zconfpush_buffer_state(new_buffer);
     */
	zconfensure_buffer_stack ();
	if ( YY_CURRENT_BUFFER == new_buffer )
		return;

	if ( YY_CURRENT_BUFFER )
		{
		/* Flush out information for old buffer. */
		*(yy_c_buf_p) = (yy_hold_char);
		YY_CURRENT_BUFFER_LVALUE->yy_buf_pos = (yy_c_buf_p);
		YY_CURRENT_BUFFER_LVALUE->yy_n_chars = (yy_n_chars);
		}

	YY_CURRENT_BUFFER_LVALUE = new_buffer;
	zconf_load_buffer_state( );

	/* We don't actually know whether we did this switch during
	 * EOF (zconfwrap()) processing, but the only time this flag
	 * is looked at is after zconfwrap() is called, so it's safe
	 * to go ahead and always set it.
	 */
	(yy_did_buffer_switch_on_eof) = 1;
}

// Assembly:
subq $0x18, %rsp
movq %rdi, 0x10(%rsp)
callq 0x8190
cmpq $0x0, 0x11052(%rip)     # 0x19d58
je 0x8d21
movq 0x11049(%rip), %rax     # 0x19d58
movq 0x1104a(%rip), %rcx     # 0x19d60
movq (%rax,%rcx,8), %rax
movq %rax, 0x8(%rsp)
jmp 0x8d2a
xorl %eax, %eax
movq %rax, 0x8(%rsp)
jmp 0x8d2a
movq 0x8(%rsp), %rax
cmpq 0x10(%rsp), %rax
jne 0x8d3b
jmp 0x8dd1
cmpq $0x0, 0x11015(%rip)     # 0x19d58
je 0x8d5c
movq 0x1100c(%rip), %rax     # 0x19d58
movq 0x1100d(%rip), %rcx     # 0x19d60
cmpq $0x0, (%rax,%rcx,8)
jne 0x8d64
jmp 0x8dab
xorl %eax, %eax
testb $0x1, %al
jne 0x8d64
jmp 0x8dab
movb 0x11006(%rip), %cl      # 0x19d70
movq 0x10ff7(%rip), %rax     # 0x19d68
movb %cl, (%rax)
movq 0x10fee(%rip), %rcx     # 0x19d68
movq 0x10fd7(%rip), %rax     # 0x19d58
movq 0x10fd8(%rip), %rdx     # 0x19d60
movq (%rax,%rdx,8), %rax
movq %rcx, 0x10(%rax)
movl 0x1100a(%rip), %ecx     # 0x19da0
movq 0x10fbb(%rip), %rax     # 0x19d58
movq 0x10fbc(%rip), %rdx     # 0x19d60
movq (%rax,%rdx,8), %rax
movl %ecx, 0x1c(%rax)
movq 0x10(%rsp), %rdx
movq 0x10fa1(%rip), %rax     # 0x19d58
movq 0x10fa2(%rip), %rcx     # 0x19d60
movq %rdx, (%rax,%rcx,8)
callq 0x8300
movl $0x1, 0x10fd3(%rip)     # 0x19da4
addq $0x18, %rsp
retq
nopw %cs:(%rax,%rax)