LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O0/saltyJeff[P]uClibcpp/extra/config/lex.zconf.c
// Function: zconf_delete_buffer
void zconf_delete_buffer (YY_BUFFER_STATE  b )
{
    
	if ( ! b )
		return;

	if ( b == YY_CURRENT_BUFFER ) /* Not sure if we should pop here. */
		YY_CURRENT_BUFFER_LVALUE = (YY_BUFFER_STATE) 0;

	if ( b->yy_is_our_buffer )
		zconffree((void *) b->yy_ch_buf  );

	zconffree((void *) b  );
}

// Assembly:
subq $0x18, %rsp
movq %rdi, 0x10(%rsp)
cmpq $0x0, 0x10(%rsp)
jne 0x8e13
jmp 0x8e8e
movq 0x10(%rsp), %rax
movq %rax, 0x8(%rsp)
cmpq $0x0, 0x10f33(%rip)     # 0x19d58
je 0x8e3f
movq 0x10f2a(%rip), %rax     # 0x19d58
movq 0x10f2b(%rip), %rcx     # 0x19d60
movq (%rax,%rcx,8), %rax
movq %rax, (%rsp)
jmp 0x8e47
xorl %eax, %eax
movq %rax, (%rsp)
jmp 0x8e47
movq 0x8(%rsp), %rax
movq (%rsp), %rcx
cmpq %rcx, %rax
jne 0x8e6b
movq 0x10efc(%rip), %rax     # 0x19d58
movq 0x10efd(%rip), %rcx     # 0x19d60
movq $0x0, (%rax,%rcx,8)
movq 0x10(%rsp), %rax
cmpl $0x0, 0x20(%rax)
je 0x8e84
movq 0x10(%rsp), %rax
movq 0x8(%rax), %rdi
callq 0x8ea0
movq 0x10(%rsp), %rdi
callq 0x8ea0
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_flush_buffer
void zconf_flush_buffer (YY_BUFFER_STATE  b )
{
    	if ( ! b )
		return;

	b->yy_n_chars = 0;

	/* We always need two end-of-buffer characters.  The first causes
	 * a transition to the end-of-buffer state.  The second causes
	 * a jam in that state.
	 */
	b->yy_ch_buf[0] = YY_END_OF_BUFFER_CHAR;
	b->yy_ch_buf[1] = YY_END_OF_BUFFER_CHAR;

	b->yy_buf_pos = &b->yy_ch_buf[0];

	b->yy_at_bol = 1;
	b->yy_buffer_status = YY_BUFFER_NEW;

	if ( b == YY_CURRENT_BUFFER )
		zconf_load_buffer_state( );
}

// Assembly:
subq $0x18, %rsp
movq %rdi, 0x10(%rsp)
cmpq $0x0, 0x10(%rsp)
jne 0x8ec6
jmp 0x8f5c
movq 0x10(%rsp), %rax
movl $0x0, 0x1c(%rax)
movq 0x10(%rsp), %rax
movq 0x8(%rax), %rax
movb $0x0, (%rax)
movq 0x10(%rsp), %rax
movq 0x8(%rax), %rax
movb $0x0, 0x1(%rax)
movq 0x10(%rsp), %rax
movq 0x8(%rax), %rcx
movq 0x10(%rsp), %rax
movq %rcx, 0x10(%rax)
movq 0x10(%rsp), %rax
movl $0x1, 0x28(%rax)
movq 0x10(%rsp), %rax
movl $0x0, 0x38(%rax)
movq 0x10(%rsp), %rax
movq %rax, 0x8(%rsp)
cmpq $0x0, 0x10e31(%rip)     # 0x19d58
je 0x8f41
movq 0x10e28(%rip), %rax     # 0x19d58
movq 0x10e29(%rip), %rcx     # 0x19d60
movq (%rax,%rcx,8), %rax
movq %rax, (%rsp)
jmp 0x8f49
xorl %eax, %eax
movq %rax, (%rsp)
jmp 0x8f49
movq 0x8(%rsp), %rax
movq (%rsp), %rcx
cmpq %rcx, %rax
jne 0x8f5c
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: zconfpush_buffer_state
void zconfpush_buffer_state (YY_BUFFER_STATE new_buffer )
{
    	if (new_buffer == NULL)
		return;

	zconfensure_buffer_stack();

	/* This block is copied from zconf_switch_to_buffer. */
	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);
		}

	/* Only push if top exists. Otherwise, replace top. */
	if (YY_CURRENT_BUFFER)
		(yy_buffer_stack_top)++;
	YY_CURRENT_BUFFER_LVALUE = new_buffer;

	/* copied from zconf_switch_to_buffer. */
	zconf_load_buffer_state( );
	(yy_did_buffer_switch_on_eof) = 1;
}

// Assembly:
pushq %rax
movq %rdi, (%rsp)
cmpq $0x0, (%rsp)
jne 0x8f81
jmp 0x9056
callq 0x8190
cmpq $0x0, 0x10dca(%rip)     # 0x19d58
je 0x8fa7
movq 0x10dc1(%rip), %rax     # 0x19d58
movq 0x10dc2(%rip), %rcx     # 0x19d60
cmpq $0x0, (%rax,%rcx,8)
jne 0x8faf
jmp 0x8ff6
xorl %eax, %eax
testb $0x1, %al
jne 0x8faf
jmp 0x8ff6
movb 0x10dbb(%rip), %cl      # 0x19d70
movq 0x10dac(%rip), %rax     # 0x19d68
movb %cl, (%rax)
movq 0x10da3(%rip), %rcx     # 0x19d68
movq 0x10d8c(%rip), %rax     # 0x19d58
movq 0x10d8d(%rip), %rdx     # 0x19d60
movq (%rax,%rdx,8), %rax
movq %rcx, 0x10(%rax)
movl 0x10dbf(%rip), %ecx     # 0x19da0
movq 0x10d70(%rip), %rax     # 0x19d58
movq 0x10d71(%rip), %rdx     # 0x19d60
movq (%rax,%rdx,8), %rax
movl %ecx, 0x1c(%rax)
cmpq $0x0, 0x10d5a(%rip)     # 0x19d58
je 0x9017
movq 0x10d51(%rip), %rax     # 0x19d58
movq 0x10d52(%rip), %rcx     # 0x19d60
cmpq $0x0, (%rax,%rcx,8)
jne 0x901f
jmp 0x9031
xorl %eax, %eax
testb $0x1, %al
jne 0x901f
jmp 0x9031
movq 0x10d3a(%rip), %rax     # 0x19d60
addq $0x1, %rax
movq %rax, 0x10d2f(%rip)     # 0x19d60
movq (%rsp), %rdx
movq 0x10d1c(%rip), %rax     # 0x19d58
movq 0x10d1d(%rip), %rcx     # 0x19d60
movq %rdx, (%rax,%rcx,8)
callq 0x8300
movl $0x1, 0x10d4e(%rip)     # 0x19da4
popq %rax
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/saltyJeff[P]uClibcpp/extra/config/lex.zconf.c
// Function: zconfpop_buffer_state
void zconfpop_buffer_state (void)
{
    	if (!YY_CURRENT_BUFFER)
		return;

	zconf_delete_buffer(YY_CURRENT_BUFFER );
	YY_CURRENT_BUFFER_LVALUE = NULL;
	if ((yy_buffer_stack_top) > 0)
		--(yy_buffer_stack_top);

	if (YY_CURRENT_BUFFER) {
		zconf_load_buffer_state( );
		(yy_did_buffer_switch_on_eof) = 1;
	}
}

// Assembly:
pushq %rax
cmpq $0x0, 0x10cef(%rip)     # 0x19d58
je 0x9082
movq 0x10ce6(%rip), %rax     # 0x19d58
movq 0x10ce7(%rip), %rcx     # 0x19d60
cmpq $0x0, (%rax,%rcx,8)
jne 0x908f
jmp 0x908a
xorl %eax, %eax
testb $0x1, %al
jne 0x908f
jmp 0x908a
jmp 0x912c
cmpq $0x0, 0x10cc1(%rip)     # 0x19d58
je 0x90b1
movq 0x10cb8(%rip), %rax     # 0x19d58
movq 0x10cb9(%rip), %rcx     # 0x19d60
movq (%rax,%rcx,8), %rax
movq %rax, (%rsp)
jmp 0x90b9
xorl %eax, %eax
movq %rax, (%rsp)
jmp 0x90b9
movq (%rsp), %rdi
callq 0x8e00
movq 0x10c8f(%rip), %rax     # 0x19d58
movq 0x10c90(%rip), %rcx     # 0x19d60
movq $0x0, (%rax,%rcx,8)
cmpq $0x0, 0x10c80(%rip)     # 0x19d60
jbe 0x90f4
movq 0x10c77(%rip), %rax     # 0x19d60
addq $-0x1, %rax
movq %rax, 0x10c6c(%rip)     # 0x19d60
cmpq $0x0, 0x10c5c(%rip)     # 0x19d58
je 0x9115
movq 0x10c53(%rip), %rax     # 0x19d58
movq 0x10c54(%rip), %rcx     # 0x19d60
cmpq $0x0, (%rax,%rcx,8)
jne 0x911d
jmp 0x912c
xorl %eax, %eax
testb $0x1, %al
jne 0x911d
jmp 0x912c
callq 0x8300
movl $0x1, 0x10c78(%rip)     # 0x19da4
popq %rax
retq
nop
// File: /workspace/github_c_makefile_star2_O0/saltyJeff[P]uClibcpp/extra/config/lex.zconf.c
// Function: zconf_scan_bytes
YY_BUFFER_STATE zconf_scan_bytes  (yyconst char * bytes, int  len )
{
	YY_BUFFER_STATE b;
	char *buf;
	yy_size_t n;
	int i;
    
	/* Get memory for full buffer, including space for trailing EOB's. */
	n = len + 2;
	buf = (char *) zconfalloc(n  );
	if ( ! buf )
		YY_FATAL_ERROR( "out of dynamic memory in zconf_scan_bytes()" );

	for ( i = 0; i < len; ++i )
		buf[i] = bytes[i];

	buf[len] = buf[len+1] = YY_END_OF_BUFFER_CHAR;

	b = zconf_scan_buffer(buf,n );
	if ( ! b )
		YY_FATAL_ERROR( "bad buffer in zconf_scan_bytes()" );

	/* It's okay to grow etc. this buffer, and we should throw it
	 * away when we're done.
	 */
	b->yy_is_our_buffer = 1;

	return b;
}

// Assembly:
subq $0x28, %rsp
movq %rdi, 0x20(%rsp)
movl %esi, 0x1c(%rsp)
movl 0x1c(%rsp), %eax
addl $0x2, %eax
movl %eax, 0x4(%rsp)
movl 0x4(%rsp), %edi
callq 0x8de0
movq %rax, 0x8(%rsp)
cmpq $0x0, 0x8(%rsp)
jne 0x92aa
leaq 0xc6be(%rip), %rdi      # 0x15963
callq 0x8640
movl $0x0, (%rsp)
movl (%rsp), %eax
cmpl 0x1c(%rsp), %eax
jge 0x92dd
movq 0x20(%rsp), %rax
movslq (%rsp), %rcx
movb (%rax,%rcx), %dl
movq 0x8(%rsp), %rax
movslq (%rsp), %rcx
movb %dl, (%rax,%rcx)
movl (%rsp), %eax
addl $0x1, %eax
movl %eax, (%rsp)
jmp 0x92b1
movq 0x8(%rsp), %rax
movl 0x1c(%rsp), %ecx
addl $0x1, %ecx
movslq %ecx, %rcx
movb $0x0, (%rax,%rcx)
movq 0x8(%rsp), %rax
movslq 0x1c(%rsp), %rcx
movb $0x0, (%rax,%rcx)
movq 0x8(%rsp), %rdi
movl 0x4(%rsp), %esi
callq 0x9130
movq %rax, 0x10(%rsp)
cmpq $0x0, 0x10(%rsp)
jne 0x9325
leaq 0xc66f(%rip), %rdi      # 0x1598f
callq 0x8640
movq 0x10(%rsp), %rax
movl $0x1, 0x20(%rax)
movq 0x10(%rsp), %rax
addq $0x28, %rsp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/saltyJeff[P]uClibcpp/extra/config/lex.zconf.c
// Function: zconflex_destroy
int zconflex_destroy  (void)
{
    
    /* Pop the buffer stack, destroying each element. */
	while(YY_CURRENT_BUFFER){
		zconf_delete_buffer(YY_CURRENT_BUFFER  );
		YY_CURRENT_BUFFER_LVALUE = NULL;
		zconfpop_buffer_state();
	}

	/* Destroy the stack itself. */
	zconffree((yy_buffer_stack) );
	(yy_buffer_stack) = NULL;

    return 0;
}

// Assembly:
subq $0x18, %rsp
jmp 0x9406
cmpq $0x0, 0x1094a(%rip)     # 0x19d58
je 0x9429
movq 0x10941(%rip), %rax     # 0x19d58
movq 0x10942(%rip), %rcx     # 0x19d60
movq (%rax,%rcx,8), %rax
movq %rax, 0x10(%rsp)
jmp 0x9432
xorl %eax, %eax
movq %rax, 0x10(%rsp)
jmp 0x9432
movq 0x10(%rsp), %rax
cmpq $0x0, %rax
je 0x9493
cmpq $0x0, 0x10913(%rip)     # 0x19d58
je 0x9460
movq 0x1090a(%rip), %rax     # 0x19d58
movq 0x1090b(%rip), %rcx     # 0x19d60
movq (%rax,%rcx,8), %rax
movq %rax, 0x8(%rsp)
jmp 0x9469
xorl %eax, %eax
movq %rax, 0x8(%rsp)
jmp 0x9469
movq 0x8(%rsp), %rdi
callq 0x8e00
movq 0x108de(%rip), %rax     # 0x19d58
movq 0x108df(%rip), %rcx     # 0x19d60
movq $0x0, (%rax,%rcx,8)
callq 0x9060
jmp 0x9406
movq 0x108be(%rip), %rdi     # 0x19d58
callq 0x8ea0
movq $0x0, 0x108ae(%rip) # 0x19d58
xorl %eax, %eax
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_fopen
FILE *zconf_fopen(const char *name)
{
	char *env, fullname[PATH_MAX+1];
	FILE *f;

	f = fopen(name, "r");
	if (!f && name[0] != '/') {
		env = getenv(SRCTREE);
		if (env) {
			sprintf(fullname, "%s/%s", env, name);
			f = fopen(fullname, "r");
		}
	}
	return f;
}

// Assembly:
subq $0x1028, %rsp           # imm = 0x1028
movq %rdi, 0x1020(%rsp)
movq 0x1020(%rsp), %rdi
leaq 0xc8ce(%rip), %rsi      # 0x15ddc
callq 0x2270
movq %rax, 0x8(%rsp)
cmpq $0x0, 0x8(%rsp)
jne 0x958a
movq 0x1020(%rsp), %rax
movsbl (%rax), %eax
cmpl $0x2f, %eax
je 0x958a
leaq 0xc479(%rip), %rdi      # 0x159b0
callq 0x2030
movq %rax, 0x1018(%rsp)
cmpq $0x0, 0x1018(%rsp)
je 0x9588
leaq 0x10(%rsp), %rdi
movq 0x1018(%rsp), %rdx
movq 0x1020(%rsp), %rcx
leaq 0xc44d(%rip), %rsi      # 0x159b8
movb $0x0, %al
callq 0x22c0
leaq 0x10(%rsp), %rdi
leaq 0xc85e(%rip), %rsi      # 0x15ddc
callq 0x2270
movq %rax, 0x8(%rsp)
jmp 0x958a
movq 0x8(%rsp), %rax
addq $0x1028, %rsp           # imm = 0x1028
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/saltyJeff[P]uClibcpp/extra/config/./menu.c
// Function: file_lookup
struct file *file_lookup(const char *name)
{
	struct file *file;

	for (file = file_list; file; file = file->next) {
		if (!strcmp(name, file->name))
			return file;
	}

	file = malloc(sizeof(*file));
	memset(file, 0, sizeof(*file));
	file->name = strdup(name);
	file->next = file_list;
	file_list = file;
	return file;
}

// Assembly:
subq $0x18, %rsp
movq %rdi, 0x8(%rsp)
movq 0x11818(%rip), %rax     # 0x1adc8
movq %rax, (%rsp)
cmpq $0x0, (%rsp)
je 0x95ec
movq 0x8(%rsp), %rdi
movq (%rsp), %rax
movq 0x10(%rax), %rsi
callq 0x2180
cmpl $0x0, %eax
jne 0x95dd
movq (%rsp), %rax
movq %rax, 0x10(%rsp)
jmp 0x9641
jmp 0x95df
movq (%rsp), %rax
movq (%rax), %rax
movq %rax, (%rsp)
jmp 0x95b4
movl $0x20, %edi
callq 0x2220
movq %rax, (%rsp)
movq (%rsp), %rdi
xorl %esi, %esi
movl $0x20, %edx
callq 0x2120
movq 0x8(%rsp), %rdi
callq 0x22f0
movq %rax, %rcx
movq (%rsp), %rax
movq %rcx, 0x10(%rax)
movq 0x117a2(%rip), %rcx     # 0x1adc8
movq (%rsp), %rax
movq %rcx, (%rax)
movq (%rsp), %rax
movq %rax, 0x11790(%rip)     # 0x1adc8
movq (%rsp), %rax
movq %rax, 0x10(%rsp)
movq 0x10(%rsp), %rax
addq $0x18, %rsp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/saltyJeff[P]uClibcpp/extra/config/./confdata.c
// Function: conf_get_default_confname
char *conf_get_default_confname(void)
{
	struct stat buf;
	static char fullname[4096+1];
	char *env, *name;

	name = conf_expand_value(conf_defname);
	env = getenv(SRCTREE);
	if (env) {
		sprintf(fullname, "%s/%s", env, name);
		if (!stat(fullname, &buf))
			return fullname;
	}
	return name;
}

// Assembly:
subq $0xa8, %rsp
leaq 0xbde2(%rip), %rdi      # 0x15440
callq 0x96f0
movq %rax, (%rsp)
leaq 0xc342(%rip), %rdi      # 0x159b0
callq 0x2030
movq %rax, 0x8(%rsp)
cmpq $0x0, 0x8(%rsp)
je 0x96c7
movq 0x8(%rsp), %rdx
movq (%rsp), %rcx
leaq 0x10720(%rip), %rdi     # 0x19db0
leaq 0xc321(%rip), %rsi      # 0x159b8
movb $0x0, %al
callq 0x22c0
leaq 0x1070b(%rip), %rdi     # 0x19db0
leaq 0x10(%rsp), %rsi
callq 0x21b0
cmpl $0x0, %eax
jne 0x96c5
leaq 0x106f5(%rip), %rax     # 0x19db0
movq %rax, 0xa0(%rsp)
jmp 0x96d3
jmp 0x96c7
movq (%rsp), %rax
movq %rax, 0xa0(%rsp)
movq 0xa0(%rsp), %rax
addq $0xa8, %rsp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/saltyJeff[P]uClibcpp/extra/config/./confdata.c
// Function: conf_expand_value
static char *conf_expand_value(const char *in)
{
	struct symbol *sym;
	const char *src;
	static char res_value[SYMBOL_MAXLENGTH];
	char *dst, name[SYMBOL_MAXLENGTH];

	res_value[0] = 0;
	dst = name;
	while ((src = strchr(in, '$'))) {
		strncat(res_value, in, src - in);
		src++;
		dst = name;
		while (isalnum(*src) || *src == '_')
			*dst++ = *src++;
		*dst = 0;
		sym = sym_lookup(name, 0);
		sym_calc_value(sym);
		strcat(res_value, sym_get_string_value(sym));
		in = src;
	}
	strcat(res_value, in);

	return res_value;
}

// Assembly:
subq $0x138, %rsp            # imm = 0x138
movq %rdi, 0x130(%rsp)
movb $0x0, 0x116da(%rip)     # 0x1ade0
leaq 0x10(%rsp), %rax
movq %rax, 0x118(%rsp)
movq 0x130(%rsp), %rdi
movl $0x24, %esi
callq 0x20e0
movq %rax, 0x120(%rsp)
cmpq $0x0, %rax
je 0x9857
movq 0x130(%rsp), %rsi
movq 0x120(%rsp), %rdx
movq 0x130(%rsp), %rax
subq %rax, %rdx
leaq 0x11687(%rip), %rdi     # 0x1ade0
callq 0x2130
movq 0x120(%rsp), %rax
addq $0x1, %rax
movq %rax, 0x120(%rsp)
leaq 0x10(%rsp), %rax
movq %rax, 0x118(%rsp)
callq 0x2300
movq (%rax), %rax
movq 0x120(%rsp), %rcx
movsbl (%rcx), %ecx
movslq %ecx, %rcx
movzwl (%rax,%rcx,2), %ecx
andl $0x8, %ecx
movb $0x1, %al
cmpl $0x0, %ecx
movb %al, 0xf(%rsp)
jne 0x97bc
movq 0x120(%rsp), %rax
movsbl (%rax), %eax
cmpl $0x5f, %eax
sete %al
movb %al, 0xf(%rsp)
movb 0xf(%rsp), %al
testb $0x1, %al
jne 0x97c6
jmp 0x97fa
movq 0x120(%rsp), %rax
movq %rax, %rcx
addq $0x1, %rcx
movq %rcx, 0x120(%rsp)
movb (%rax), %cl
movq 0x118(%rsp), %rax
movq %rax, %rdx
addq $0x1, %rdx
movq %rdx, 0x118(%rsp)
movb %cl, (%rax)
jmp 0x977f
movq 0x118(%rsp), %rax
movb $0x0, (%rax)
leaq 0x10(%rsp), %rdi
xorl %esi, %esi
callq 0x5ee0
movq %rax, 0x128(%rsp)
movq 0x128(%rsp), %rdi
callq 0xa4f0
movq 0x128(%rsp), %rdi
callq 0xb7c0
movq %rax, %rsi
leaq 0x115a3(%rip), %rdi     # 0x1ade0
callq 0x22b0
movq 0x120(%rsp), %rax
movq %rax, 0x130(%rsp)
jmp 0x9713
movq 0x130(%rsp), %rsi
leaq 0x1157a(%rip), %rdi     # 0x1ade0
callq 0x22b0
leaq 0x1156e(%rip), %rax     # 0x1ade0
addq $0x138, %rsp            # imm = 0x138
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/saltyJeff[P]uClibcpp/extra/config/./symbol.c
// Function: sym_find
struct symbol *sym_find(const char *name)
{
	struct symbol *symbol = NULL;
	const char *ptr;
	int hash = 0;

	if (!name)
		return NULL;

	if (name[0] && !name[1]) {
		switch (name[0]) {
		case 'y': return &symbol_yes;
		case 'm': return &symbol_mod;
		case 'n': return &symbol_no;
		}
	}
	for (ptr = name; *ptr; ptr++)
		hash += *ptr;
	hash &= 0xff;

	for (symbol = symbol_hash[hash]; symbol; symbol = symbol->next) {
		if (!strcmp(symbol->name, name) &&
		    !(symbol->flags & SYMBOL_CONST))
				break;
	}

	return symbol;
}

// Assembly:
subq $0x28, %rsp
movq %rdi, 0x18(%rsp)
movq $0x0, 0x10(%rsp)
movl $0x0, 0x4(%rsp)
cmpq $0x0, 0x18(%rsp)
jne 0xa0e0
movq $0x0, 0x20(%rsp)
jmp 0xa1f6
movq 0x18(%rsp), %rax
movsbl (%rax), %eax
cmpl $0x0, %eax
je 0xa153
movq 0x18(%rsp), %rax
cmpb $0x0, 0x1(%rax)
jne 0xa153
movq 0x18(%rsp), %rax
movsbl (%rax), %eax
movl %eax, (%rsp)
subl $0x6d, %eax
je 0xa12f
jmp 0xa10a
movl (%rsp), %eax
subl $0x6e, %eax
je 0xa140
jmp 0xa114
movl (%rsp), %eax
subl $0x79, %eax
jne 0xa151
jmp 0xa11e
leaq 0xf163(%rip), %rax      # 0x19288
movq %rax, 0x20(%rsp)
jmp 0xa1f6
leaq 0xf1c2(%rip), %rax      # 0x192f8
movq %rax, 0x20(%rsp)
jmp 0xa1f6
leaq 0xf0d1(%rip), %rax      # 0x19218
movq %rax, 0x20(%rsp)
jmp 0xa1f6
jmp 0xa153
movq 0x18(%rsp), %rax
movq %rax, 0x8(%rsp)
movq 0x8(%rsp), %rax
cmpb $0x0, (%rax)
je 0xa187
movq 0x8(%rsp), %rax
movsbl (%rax), %eax
addl 0x4(%rsp), %eax
movl %eax, 0x4(%rsp)
movq 0x8(%rsp), %rax
addq $0x1, %rax
movq %rax, 0x8(%rsp)
jmp 0xa15d
movl 0x4(%rsp), %eax
andl $0xff, %eax
movl %eax, 0x4(%rsp)
movslq 0x4(%rsp), %rcx
leaq 0xf370(%rip), %rax      # 0x19510
movq (%rax,%rcx,8), %rax
movq %rax, 0x10(%rsp)
cmpq $0x0, 0x10(%rsp)
je 0xa1ec
movq 0x10(%rsp), %rax
movq 0x8(%rax), %rdi
movq 0x18(%rsp), %rsi
callq 0x2180
cmpl $0x0, %eax
jne 0xa1db
movq 0x10(%rsp), %rax
movl 0x44(%rax), %eax
andl $0x7, %eax
cmpl $0x0, %eax
jne 0xa1db
jmp 0xa1ec
jmp 0xa1dd
movq 0x10(%rsp), %rax
movq (%rax), %rax
movq %rax, 0x10(%rsp)
jmp 0xa1a9
movq 0x10(%rsp), %rax
movq %rax, 0x20(%rsp)
movq 0x20(%rsp), %rax
addq $0x28, %rsp
retq
// File: /workspace/github_c_makefile_star2_O0/saltyJeff[P]uClibcpp/extra/config/./symbol.c
// Function: prop_get_symbol
struct symbol *prop_get_symbol(struct property *prop)
{
	if (prop->expr && (prop->expr->type == E_SYMBOL ||
			   prop->expr->type == E_CHOICE))
		return prop->expr->left.sym;
	return NULL;
}

// Assembly:
movq %rdi, -0x10(%rsp)
movq -0x10(%rsp), %rax
cmpq $0x0, 0x30(%rax)
je 0xa481
movq -0x10(%rsp), %rax
movq 0x30(%rax), %rax
cmpl $0x7, (%rax)
je 0xa46d
movq -0x10(%rsp), %rax
movq 0x30(%rax), %rax
cmpl $0x6, (%rax)
jne 0xa481
movq -0x10(%rsp), %rax
movq 0x30(%rax), %rax
movq 0x8(%rax), %rax
movq %rax, -0x8(%rsp)
jmp 0xa48a
movq $0x0, -0x8(%rsp)
movq -0x8(%rsp), %rax
retq
// File: /workspace/github_c_makefile_star2_O0/saltyJeff[P]uClibcpp/extra/config/./symbol.c
// Function: sym_get_choice_prop
struct property *sym_get_choice_prop(struct symbol *sym)
{
	struct property *prop;

	for_all_choices(sym, prop)
		return prop;
	return NULL;
}

// Assembly:
movq %rdi, -0x10(%rsp)
movq -0x10(%rsp), %rax
movq 0x48(%rax), %rax
movq %rax, -0x18(%rsp)
cmpq $0x0, -0x18(%rsp)
je 0xa4d3
movq -0x18(%rsp), %rax
cmpl $0x5, 0x10(%rax)
jne 0xa4c2
movq -0x18(%rsp), %rax
movq %rax, -0x8(%rsp)
jmp 0xa4dc
jmp 0xa4c4
movq -0x18(%rsp), %rax
movq (%rax), %rax
movq %rax, -0x18(%rsp)
jmp 0xa4a3
movq $0x0, -0x8(%rsp)
movq -0x8(%rsp), %rax
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/saltyJeff[P]uClibcpp/extra/config/./symbol.c
// Function: sym_clear_all_valid
void sym_clear_all_valid(void)
{
	struct symbol *sym;
	int i;

	for_all_symbols(i, sym)
		sym->flags &= ~SYMBOL_VALID;
	sym_change_count++;
}

// Assembly:
movl $0x0, -0xc(%rsp)
cmpl $0x101, -0xc(%rsp)      # imm = 0x101
jge 0xb63b
movslq -0xc(%rsp), %rcx
leaq 0xdf22(%rip), %rax      # 0x19510
movq (%rax,%rcx,8), %rax
movq %rax, -0x8(%rsp)
cmpq $0x0, -0x8(%rsp)
je 0xb62c
movq -0x8(%rsp), %rax
cmpl $0x6, 0x18(%rax)
je 0xb61b
movq -0x8(%rsp), %rax
movl 0x44(%rax), %ecx
andl $0xffffff7f, %ecx       # imm = 0xFFFFFF7F
movl %ecx, 0x44(%rax)
jmp 0xb61d
movq -0x8(%rsp), %rax
movq (%rax), %rax
movq %rax, -0x8(%rsp)
jmp 0xb5f7
jmp 0xb62e
movl -0xc(%rsp), %eax
addl $0x1, %eax
movl %eax, -0xc(%rsp)
jmp 0xb5d8
movl 0xe6d7(%rip), %eax      # 0x19d18
addl $0x1, %eax
movl %eax, 0xe6ce(%rip)      # 0x19d18
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/saltyJeff[P]uClibcpp/extra/config/./menu.c
// Function: menu_is_visible
bool menu_is_visible(struct menu *menu)
{
	struct menu *child;
	struct symbol *sym;
	tristate visible;

	if (!menu->prompt)
		return false;
	sym = menu->sym;
	if (sym) {
		sym_calc_value(sym);
		visible = menu->prompt->visible.tri;
	} else
		visible = menu->prompt->visible.tri = expr_calc_value(menu->prompt->visible.expr);

	if (visible != no)
		return true;
	if (!sym || sym_get_tristate_value(menu->sym) == no)
		return false;

	for (child = menu->list; child; child = child->next)
		if (menu_is_visible(child))
			return true;
	return false;
}

// Assembly:
subq $0x28, %rsp
movq %rdi, 0x18(%rsp)
movq 0x18(%rsp), %rax
cmpq $0x0, 0x20(%rax)
jne 0xb66f
movb $0x0, 0x27(%rsp)
jmp 0xb736
movq 0x18(%rsp), %rax
movq 0x18(%rax), %rax
movq %rax, 0x8(%rsp)
cmpq $0x0, 0x8(%rsp)
je 0xb6a1
movq 0x8(%rsp), %rdi
callq 0xa4f0
movq 0x18(%rsp), %rax
movq 0x20(%rax), %rax
movl 0x28(%rax), %eax
movl %eax, 0x4(%rsp)
jmp 0xb6c3
movq 0x18(%rsp), %rax
movq 0x20(%rax), %rax
movq 0x20(%rax), %rdi
callq 0xe270
movq 0x18(%rsp), %rcx
movq 0x20(%rcx), %rcx
movl %eax, 0x28(%rcx)
movl %eax, 0x4(%rsp)
cmpl $0x0, 0x4(%rsp)
je 0xb6d1
movb $0x1, 0x27(%rsp)
jmp 0xb736
cmpq $0x0, 0x8(%rsp)
je 0xb6ec
movq 0x18(%rsp), %rax
movq 0x18(%rax), %rdi
callq 0xb7b0
cmpl $0x0, %eax
jne 0xb6f3
movb $0x0, 0x27(%rsp)
jmp 0xb736
movq 0x18(%rsp), %rax
movq 0x10(%rax), %rax
movq %rax, 0x10(%rsp)
cmpq $0x0, 0x10(%rsp)
je 0xb731
movq 0x10(%rsp), %rdi
callq 0xb650
testb $0x1, %al
jne 0xb719
jmp 0xb720
movb $0x1, 0x27(%rsp)
jmp 0xb736
jmp 0xb722
movq 0x10(%rsp), %rax
movq (%rax), %rax
movq %rax, 0x10(%rsp)
jmp 0xb701
movb $0x0, 0x27(%rsp)
movb 0x27(%rsp), %al
andb $0x1, %al
addq $0x28, %rsp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/saltyJeff[P]uClibcpp/extra/config/./menu.c
// Function: menu_get_prompt
const char *menu_get_prompt(struct menu *menu)
{
	if (menu->prompt)
		return menu->prompt->text;
	else if (menu->sym)
		return menu->sym->name;
	return NULL;
}

// Assembly:
movq %rdi, -0x10(%rsp)
movq -0x10(%rsp), %rax
cmpq $0x0, 0x20(%rax)
je 0xb775
movq -0x10(%rsp), %rax
movq 0x20(%rax), %rax
movq 0x18(%rax), %rax
movq %rax, -0x8(%rsp)
jmp 0xb7a0
movq -0x10(%rsp), %rax
cmpq $0x0, 0x18(%rax)
je 0xb795
movq -0x10(%rsp), %rax
movq 0x18(%rax), %rax
movq 0x8(%rax), %rax
movq %rax, -0x8(%rsp)
jmp 0xb7a0
jmp 0xb797
movq $0x0, -0x8(%rsp)
movq -0x8(%rsp), %rax
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/saltyJeff[P]uClibcpp/extra/config/./symbol.c
// Function: sym_get_string_value
const char *sym_get_string_value(struct symbol *sym)
{
	tristate val;

	switch (sym->type) {
	case S_BOOLEAN:
	case S_TRISTATE:
		val = sym_get_tristate_value(sym);
		switch (val) {
		case no:
			return "n";
		case mod:
			return "m";
		case yes:
			return "y";
		}
		break;
	default:
		;
	}
	return (const char *)sym->curr.val;
}

// Assembly:
subq $0x18, %rsp
movq %rdi, 0x8(%rsp)
movq 0x8(%rsp), %rax
movl 0x18(%rax), %eax
decl %eax
subl $0x1, %eax
ja 0xb835
jmp 0xb7da
movq 0x8(%rsp), %rdi
callq 0xb7b0
movl %eax, 0x4(%rsp)
movl 0x4(%rsp), %eax
movl %eax, (%rsp)
testl %eax, %eax
je 0xb809
jmp 0xb7f5
movl (%rsp), %eax
subl $0x1, %eax
je 0xb817
jmp 0xb7ff
movl (%rsp), %eax
subl $0x2, %eax
je 0xb825
jmp 0xb833
leaq 0x4ac7(%rip), %rax      # 0x102d7
movq %rax, 0x10(%rsp)
jmp 0xb845
leaq 0x4abc(%rip), %rax      # 0x102da
movq %rax, 0x10(%rsp)
jmp 0xb845
leaq 0x4ab1(%rip), %rax      # 0x102dd
movq %rax, 0x10(%rsp)
jmp 0xb845
jmp 0xb837
jmp 0xb837
movq 0x8(%rsp), %rax
movq 0x20(%rax), %rax
movq %rax, 0x10(%rsp)
movq 0x10(%rsp), %rax
addq $0x18, %rsp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/saltyJeff[P]uClibcpp/extra/config/./menu.c
// Function: file_write_dep
int file_write_dep(const char *name)
{
	struct file *file;
	FILE *out;

	if (!name)
		name = ".config.cmd";
	out = fopen(".config.tmp", "w");
	if (!out)
		return 1;
	fprintf(out, "deps_config := \\\n");
	for (file = file_list; file; file = file->next) {
		if (file->next)
			fprintf(out, "\t%s \\\n", file->name);
		else
			fprintf(out, "\t%s\n", file->name);
	}
	fprintf(out, "\n.config include/system_configuration.h: $(deps_config)\n\n$(deps_config):\n");
	fclose(out);
	rename(".config.tmp", name);
	return 0;
}

// Assembly:
subq $0x28, %rsp
movq %rdi, 0x18(%rsp)
cmpq $0x0, 0x18(%rsp)
jne 0xb86d
leaq 0xa7f2(%rip), %rax      # 0x1605a
movq %rax, 0x18(%rsp)
leaq 0xa7f2(%rip), %rdi      # 0x16066
leaq 0xac42(%rip), %rsi      # 0x164bd
callq 0x2270
movq %rax, 0x8(%rsp)
cmpq $0x0, 0x8(%rsp)
jne 0xb89a
movl $0x1, 0x24(%rsp)
jmp 0xb94d
movq 0x8(%rsp), %rdi
leaq 0xa7cc(%rip), %rsi      # 0x16072
movb $0x0, %al
callq 0x21a0
movq 0xf514(%rip), %rax      # 0x1adc8
movq %rax, 0x10(%rsp)
cmpq $0x0, 0x10(%rsp)
je 0xb917
movq 0x10(%rsp), %rax
cmpq $0x0, (%rax)
je 0xb8ea
movq 0x8(%rsp), %rdi
movq 0x10(%rsp), %rax
movq 0x10(%rax), %rdx
leaq 0xa7a3(%rip), %rsi      # 0x16084
movb $0x0, %al
callq 0x21a0
jmp 0xb906
movq 0x8(%rsp), %rdi
movq 0x10(%rsp), %rax
movq 0x10(%rax), %rdx
leaq 0xa78c(%rip), %rsi      # 0x1608b
movb $0x0, %al
callq 0x21a0
jmp 0xb908
movq 0x10(%rsp), %rax
movq (%rax), %rax
movq %rax, 0x10(%rsp)
jmp 0xb8b9
movq 0x8(%rsp), %rdi
leaq 0xa76d(%rip), %rsi      # 0x16090
movb $0x0, %al
callq 0x21a0
movq 0x8(%rsp), %rdi
callq 0x20c0
movq 0x18(%rsp), %rsi
leaq 0xa726(%rip), %rdi      # 0x16066
callq 0x2280
movl $0x0, 0x24(%rsp)
movl 0x24(%rsp), %eax
addq $0x28, %rsp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/saltyJeff[P]uClibcpp/extra/config/./expr.c
// Function: expr_copy
struct expr *expr_copy(struct expr *org)
{
	struct expr *e;

	if (!org)
		return NULL;

	e = malloc(sizeof(*org));
	memcpy(e, org, sizeof(*org));
	switch (org->type) {
	case E_SYMBOL:
		e->left = org->left;
		break;
	case E_NOT:
		e->left.expr = expr_copy(org->left.expr);
		break;
	case E_EQUAL:
	case E_UNEQUAL:
		e->left.sym = org->left.sym;
		e->right.sym = org->right.sym;
		break;
	case E_AND:
	case E_OR:
	case E_CHOICE:
		e->left.expr = expr_copy(org->left.expr);
		e->right.expr = expr_copy(org->right.expr);
		break;
	default:
		printf("can't copy type %d\n", e->type);
		free(e);
		e = NULL;
		break;
	}

	return e;
}

// Assembly:
subq $0x28, %rsp
movq %rdi, 0x18(%rsp)
cmpq $0x0, 0x18(%rsp)
jne 0xba5f
movq $0x0, 0x20(%rsp)
jmp 0xbb78
movl $0x18, %edi
callq 0x2220
movq %rax, 0x10(%rsp)
movq 0x10(%rsp), %rax
movq 0x18(%rsp), %rcx
movq 0x10(%rcx), %rdx
movq %rdx, 0x10(%rax)
movups (%rcx), %xmm0
movups %xmm0, (%rax)
movq 0x18(%rsp), %rax
movl (%rax), %eax
decl %eax
movl %eax, %ecx
movq %rcx, 0x8(%rsp)
subl $0x6, %eax
ja 0xbb46
movq 0x8(%rsp), %rax
leaq 0x4b85(%rip), %rcx      # 0x10630
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
movq 0x10(%rsp), %rax
movq 0x18(%rsp), %rcx
movq 0x8(%rcx), %rcx
movq %rcx, 0x8(%rax)
jmp 0xbb6e
movq 0x18(%rsp), %rax
movq 0x8(%rax), %rdi
callq 0xba40
movq %rax, %rcx
movq 0x10(%rsp), %rax
movq %rcx, 0x8(%rax)
jmp 0xbb6e
movq 0x18(%rsp), %rax
movq 0x8(%rax), %rcx
movq 0x10(%rsp), %rax
movq %rcx, 0x8(%rax)
movq 0x18(%rsp), %rax
movq 0x10(%rax), %rcx
movq 0x10(%rsp), %rax
movq %rcx, 0x10(%rax)
jmp 0xbb6e
movq 0x18(%rsp), %rax
movq 0x8(%rax), %rdi
callq 0xba40
movq %rax, %rcx
movq 0x10(%rsp), %rax
movq %rcx, 0x8(%rax)
movq 0x18(%rsp), %rax
movq 0x10(%rax), %rdi
callq 0xba40
movq %rax, %rcx
movq 0x10(%rsp), %rax
movq %rcx, 0x10(%rax)
jmp 0xbb6e
movq 0x10(%rsp), %rax
movl (%rax), %esi
leaq 0xa17f(%rip), %rdi      # 0x15cd3
movb $0x0, %al
callq 0x20f0
movq 0x10(%rsp), %rdi
callq 0x2040
movq $0x0, 0x10(%rsp)
movq 0x10(%rsp), %rax
movq %rax, 0x20(%rsp)
movq 0x20(%rsp), %rax
addq $0x28, %rsp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/saltyJeff[P]uClibcpp/extra/config/./expr.c
// Function: expr_free
void expr_free(struct expr *e)
{
	if (!e)
		return;

	switch (e->type) {
	case E_SYMBOL:
		break;
	case E_NOT:
		expr_free(e->left.expr);
		return;
	case E_EQUAL:
	case E_UNEQUAL:
		break;
	case E_OR:
	case E_AND:
		expr_free(e->left.expr);
		expr_free(e->right.expr);
		break;
	default:
		printf("how to free type %d?\n", e->type);
		break;
	}
	free(e);
}

// Assembly:
subq $0x18, %rsp
movq %rdi, 0x10(%rsp)
cmpq $0x0, 0x10(%rsp)
jne 0xbba3
jmp 0xbc1e
movq 0x10(%rsp), %rax
movl (%rax), %eax
decl %eax
movl %eax, %ecx
movq %rcx, 0x8(%rsp)
subl $0x6, %eax
ja 0xbbff
movq 0x8(%rsp), %rax
leaq 0x4a88(%rip), %rcx      # 0x1064c
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
jmp 0xbc14
movq 0x10(%rsp), %rax
movq 0x8(%rax), %rdi
callq 0xbb90
jmp 0xbc1e
jmp 0xbc14
movq 0x10(%rsp), %rax
movq 0x8(%rax), %rdi
callq 0xbb90
movq 0x10(%rsp), %rax
movq 0x10(%rax), %rdi
callq 0xbb90
jmp 0xbc14
movq 0x10(%rsp), %rax
movl (%rax), %esi
leaq 0xa0da(%rip), %rdi      # 0x15ce7
movb $0x0, %al
callq 0x20f0
movq 0x10(%rsp), %rdi
callq 0x2040
addq $0x18, %rsp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/saltyJeff[P]uClibcpp/extra/config/./expr.c
// Function: expr_eliminate_eq
void expr_eliminate_eq(struct expr **ep1, struct expr **ep2)
{
	if (!e1 || !e2)
		return;
	switch (e1->type) {
	case E_OR:
	case E_AND:
		__expr_eliminate_eq(e1->type, ep1, ep2);
	default:
		;
	}
	if (e1->type != e2->type) switch (e2->type) {
	case E_OR:
	case E_AND:
		__expr_eliminate_eq(e2->type, ep1, ep2);
	default:
		;
	}
	e1 = expr_eliminate_yn(e1);
	e2 = expr_eliminate_yn(e2);
}

// Assembly:
subq $0x18, %rsp
movq %rdi, 0x10(%rsp)
movq %rsi, 0x8(%rsp)
movq 0x10(%rsp), %rax
cmpq $0x0, (%rax)
je 0xbc54
movq 0x8(%rsp), %rax
cmpq $0x0, (%rax)
jne 0xbc59
jmp 0xbcfd
movq 0x10(%rsp), %rax
movq (%rax), %rax
movl (%rax), %eax
decl %eax
subl $0x1, %eax
ja 0xbc85
jmp 0xbc6c
movq 0x10(%rsp), %rax
movq (%rax), %rax
movl (%rax), %edi
movq 0x10(%rsp), %rsi
movq 0x8(%rsp), %rdx
callq 0xbd10
jmp 0xbc87
movq 0x10(%rsp), %rax
movq (%rax), %rax
movl (%rax), %eax
movq 0x8(%rsp), %rcx
movq (%rcx), %rcx
cmpl (%rcx), %eax
je 0xbccd
movq 0x8(%rsp), %rax
movq (%rax), %rax
movl (%rax), %eax
decl %eax
subl $0x1, %eax
ja 0xbcc9
jmp 0xbcb0
movq 0x8(%rsp), %rax
movq (%rax), %rax
movl (%rax), %edi
movq 0x10(%rsp), %rsi
movq 0x8(%rsp), %rdx
callq 0xbd10
jmp 0xbccb
jmp 0xbccd
movq 0x10(%rsp), %rax
movq (%rax), %rdi
callq 0xbed0
movq %rax, %rcx
movq 0x10(%rsp), %rax
movq %rcx, (%rax)
movq 0x8(%rsp), %rax
movq (%rax), %rdi
callq 0xbed0
movq %rax, %rcx
movq 0x8(%rsp), %rax
movq %rcx, (%rax)
addq $0x18, %rsp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/saltyJeff[P]uClibcpp/extra/config/./expr.c
// Function: _expr_eliminate_eq
static void __expr_eliminate_eq(enum expr_type type, struct expr **ep1, struct expr **ep2)
{
	if (e1->type == type) {
		__expr_eliminate_eq(type, &e1->left.expr, &e2);
		__expr_eliminate_eq(type, &e1->right.expr, &e2);
		return;
	}
	if (e2->type == type) {
		__expr_eliminate_eq(type, &e1, &e2->left.expr);
		__expr_eliminate_eq(type, &e1, &e2->right.expr);
		return;
	}
	if (e1->type == E_SYMBOL && e2->type == E_SYMBOL &&
	    e1->left.sym == e2->left.sym && (e1->left.sym->flags & (SYMBOL_YES|SYMBOL_NO)))
		return;
	if (!expr_eq(e1, e2))
		return;
	trans_count++;
	expr_free(e1); expr_free(e2);
	switch (type) {
	case E_OR:
		e1 = expr_alloc_symbol(&symbol_no);
		e2 = expr_alloc_symbol(&symbol_no);
		break;
	case E_AND:
		e1 = expr_alloc_symbol(&symbol_yes);
		e2 = expr_alloc_symbol(&symbol_yes);
		break;
	default:
		;
	}
}

// Assembly:
subq $0x28, %rsp
movl %edi, 0x24(%rsp)
movq %rsi, 0x18(%rsp)
movq %rdx, 0x10(%rsp)
movq 0x18(%rsp), %rax
movq (%rax), %rax
movl (%rax), %eax
cmpl 0x24(%rsp), %eax
jne 0xbd6b
movl 0x24(%rsp), %edi
movq 0x18(%rsp), %rax
movq (%rax), %rsi
addq $0x8, %rsi
movq 0x10(%rsp), %rdx
callq 0xbd10
movl 0x24(%rsp), %edi
movq 0x18(%rsp), %rax
movq (%rax), %rsi
addq $0x10, %rsi
movq 0x10(%rsp), %rdx
callq 0xbd10
jmp 0xbec7
movq 0x10(%rsp), %rax
movq (%rax), %rax
movl (%rax), %eax
cmpl 0x24(%rsp), %eax
jne 0xbdb4
movl 0x24(%rsp), %edi
movq 0x18(%rsp), %rsi
movq 0x10(%rsp), %rax
movq (%rax), %rdx
addq $0x8, %rdx
callq 0xbd10
movl 0x24(%rsp), %edi
movq 0x18(%rsp), %rsi
movq 0x10(%rsp), %rax
movq (%rax), %rdx
addq $0x10, %rdx
callq 0xbd10
jmp 0xbec7
movq 0x18(%rsp), %rax
movq (%rax), %rax
cmpl $0x7, (%rax)
jne 0xbe04
movq 0x10(%rsp), %rax
movq (%rax), %rax
cmpl $0x7, (%rax)
jne 0xbe04
movq 0x18(%rsp), %rax
movq (%rax), %rax
movq 0x8(%rax), %rax
movq 0x10(%rsp), %rcx
movq (%rcx), %rcx
cmpq 0x8(%rcx), %rax
jne 0xbe04
movq 0x18(%rsp), %rax
movq (%rax), %rax
movq 0x8(%rax), %rax
movl 0x44(%rax), %eax
andl $0x5, %eax
cmpl $0x0, %eax
je 0xbe04
jmp 0xbec7
movq 0x18(%rsp), %rax
movq (%rax), %rdi
movq 0x10(%rsp), %rax
movq (%rax), %rsi
callq 0xc350
cmpl $0x0, %eax
jne 0xbe23
jmp 0xbec7
movl 0xef8b(%rip), %eax      # 0x1adb4
incl %eax
movl %eax, 0xef83(%rip)      # 0x1adb4
movq 0x18(%rsp), %rax
movq (%rax), %rdi
callq 0xbb90
movq 0x10(%rsp), %rax
movq (%rax), %rdi
callq 0xbb90
movl 0x24(%rsp), %eax
movl %eax, 0xc(%rsp)
subl $0x1, %eax
je 0xbe65
jmp 0xbe5a
movl 0xc(%rsp), %eax
subl $0x2, %eax
je 0xbe95
jmp 0xbec5
leaq 0xd3ac(%rip), %rdi      # 0x19218
callq 0x6840
movq %rax, %rcx
movq 0x18(%rsp), %rax
movq %rcx, (%rax)
leaq 0xd395(%rip), %rdi      # 0x19218
callq 0x6840
movq %rax, %rcx
movq 0x10(%rsp), %rax
movq %rcx, (%rax)
jmp 0xbec7
leaq 0xd3ec(%rip), %rdi      # 0x19288
callq 0x6840
movq %rax, %rcx
movq 0x18(%rsp), %rax
movq %rcx, (%rax)
leaq 0xd3d5(%rip), %rdi      # 0x19288
callq 0x6840
movq %rax, %rcx
movq 0x10(%rsp), %rax
movq %rcx, (%rax)
jmp 0xbec7
jmp 0xbec7
addq $0x28, %rsp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/saltyJeff[P]uClibcpp/extra/config/./expr.c
// Function: expr_eq
int expr_eq(struct expr *e1, struct expr *e2)
{
	int res, old_count;

	if (e1->type != e2->type)
		return 0;
	switch (e1->type) {
	case E_EQUAL:
	case E_UNEQUAL:
		return e1->left.sym == e2->left.sym && e1->right.sym == e2->right.sym;
	case E_SYMBOL:
		return e1->left.sym == e2->left.sym;
	case E_NOT:
		return expr_eq(e1->left.expr, e2->left.expr);
	case E_AND:
	case E_OR:
		e1 = expr_copy(e1);
		e2 = expr_copy(e2);
		old_count = trans_count;
		expr_eliminate_eq(&e1, &e2);
		res = (e1->type == E_SYMBOL && e2->type == E_SYMBOL &&
		       e1->left.sym == e2->left.sym);
		expr_free(e1);
		expr_free(e2);
		trans_count = old_count;
		return res;
	case E_CHOICE:
	case E_RANGE:
	case E_NONE:
		/* panic */;
	}

	print_expr(0, e1, 0);
	printf(" = ");
	print_expr(0, e2, 0);
	printf(" ?\n");

	return 0;
}

// Assembly:
subq $0x38, %rsp
movq %rdi, 0x28(%rsp)
movq %rsi, 0x20(%rsp)
movq 0x28(%rsp), %rax
movl (%rax), %eax
movq 0x20(%rsp), %rcx
cmpl (%rcx), %eax
je 0xc37b
movl $0x0, 0x34(%rsp)
jmp 0xc515
movq 0x28(%rsp), %rax
movl (%rax), %eax
movq %rax, 0x10(%rsp)
subq $0x8, %rax
ja 0xc4d5
movq 0x10(%rsp), %rax
leaq 0x42cb(%rip), %rcx      # 0x10668
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
movq 0x28(%rsp), %rax
movq 0x8(%rax), %rcx
movq 0x20(%rsp), %rdx
xorl %eax, %eax
cmpq 0x8(%rdx), %rcx
movb %al, 0xf(%rsp)
jne 0xc3d9
movq 0x28(%rsp), %rax
movq 0x10(%rax), %rax
movq 0x20(%rsp), %rcx
cmpq 0x10(%rcx), %rax
sete %al
movb %al, 0xf(%rsp)
movb 0xf(%rsp), %al
andb $0x1, %al
movzbl %al, %eax
movl %eax, 0x34(%rsp)
jmp 0xc515
movq 0x28(%rsp), %rax
movq 0x8(%rax), %rax
movq 0x20(%rsp), %rcx
cmpq 0x8(%rcx), %rax
sete %al
andb $0x1, %al
movzbl %al, %eax
movl %eax, 0x34(%rsp)
jmp 0xc515
movq 0x28(%rsp), %rax
movq 0x8(%rax), %rdi
movq 0x20(%rsp), %rax
movq 0x8(%rax), %rsi
callq 0xc350
movl %eax, 0x34(%rsp)
jmp 0xc515
movq 0x28(%rsp), %rdi
callq 0xba40
movq %rax, 0x28(%rsp)
movq 0x20(%rsp), %rdi
callq 0xba40
movq %rax, 0x20(%rsp)
movl 0xe962(%rip), %eax      # 0x1adb4
movl %eax, 0x18(%rsp)
leaq 0x28(%rsp), %rdi
leaq 0x20(%rsp), %rsi
callq 0xbc30
movq 0x28(%rsp), %rcx
xorl %eax, %eax
cmpl $0x7, (%rcx)
movb %al, 0xe(%rsp)
jne 0xc49e
movq 0x20(%rsp), %rcx
xorl %eax, %eax
cmpl $0x7, (%rcx)
movb %al, 0xe(%rsp)
jne 0xc49e
movq 0x28(%rsp), %rax
movq 0x8(%rax), %rax
movq 0x20(%rsp), %rcx
cmpq 0x8(%rcx), %rax
sete %al
movb %al, 0xe(%rsp)
movb 0xe(%rsp), %al
andb $0x1, %al
movzbl %al, %eax
movl %eax, 0x1c(%rsp)
movq 0x28(%rsp), %rdi
callq 0xbb90
movq 0x20(%rsp), %rdi
callq 0xbb90
movl 0x18(%rsp), %eax
movl %eax, 0xe8eb(%rip)      # 0x1adb4
movl 0x1c(%rsp), %eax
movl %eax, 0x34(%rsp)
jmp 0xc515
jmp 0xc4d5
movq 0x28(%rsp), %rsi
xorl %edx, %edx
movl %edx, %edi
callq 0xc520
leaq 0x9813(%rip), %rdi      # 0x15cfd
movb $0x0, %al
callq 0x20f0
movq 0x20(%rsp), %rsi
xorl %edx, %edx
movl %edx, %edi
callq 0xc520
leaq 0x97fb(%rip), %rdi      # 0x15d01
movb $0x0, %al
callq 0x20f0
movl $0x0, 0x34(%rsp)
movl 0x34(%rsp), %eax
addq $0x38, %rsp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/saltyJeff[P]uClibcpp/extra/config/./expr.c
// Function: expr_trans_bool
struct expr *expr_trans_bool(struct expr *e)
{
	if (!e)
		return NULL;
	switch (e->type) {
	case E_AND:
	case E_OR:
	case E_NOT:
		e->left.expr = expr_trans_bool(e->left.expr);
		e->right.expr = expr_trans_bool(e->right.expr);
		break;
	case E_UNEQUAL:
		// FOO!=n -> FOO
		if (e->left.sym->type == S_TRISTATE) {
			if (e->right.sym == &symbol_no) {
				e->type = E_SYMBOL;
				e->right.sym = NULL;
			}
		}
		break;
	default:
		;
	}
	return e;
}

// Assembly:
subq $0x18, %rsp
movq %rdi, 0x8(%rsp)
cmpq $0x0, 0x8(%rsp)
jne 0xc57f
movq $0x0, 0x10(%rsp)
jmp 0xc61d
movq 0x8(%rsp), %rax
movl (%rax), %eax
movl %eax, 0x4(%rsp)
decl %eax
subl $0x3, %eax
jb 0xc59e
jmp 0xc593
movl 0x4(%rsp), %eax
subl $0x5, %eax
je 0xc5d4
jmp 0xc611
movq 0x8(%rsp), %rax
movq 0x8(%rax), %rdi
callq 0xc560
movq %rax, %rcx
movq 0x8(%rsp), %rax
movq %rcx, 0x8(%rax)
movq 0x8(%rsp), %rax
movq 0x10(%rax), %rdi
callq 0xc560
movq %rax, %rcx
movq 0x8(%rsp), %rax
movq %rcx, 0x10(%rax)
jmp 0xc613
movq 0x8(%rsp), %rax
movq 0x8(%rax), %rax
cmpl $0x2, 0x18(%rax)
jne 0xc60f
movq 0x8(%rsp), %rax
leaq 0xcc29(%rip), %rcx      # 0x19218
cmpq %rcx, 0x10(%rax)
jne 0xc60d
movq 0x8(%rsp), %rax
movl $0x7, (%rax)
movq 0x8(%rsp), %rax
movq $0x0, 0x10(%rax)
jmp 0xc60f
jmp 0xc613
jmp 0xc613
movq 0x8(%rsp), %rax
movq %rax, 0x10(%rsp)
movq 0x10(%rsp), %rax
addq $0x18, %rsp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/saltyJeff[P]uClibcpp/extra/config/./expr.c
// Function: expr_eliminate_dups
struct expr *expr_eliminate_dups(struct expr *e)
{
	int oldcount;
	if (!e)
		return e;

	oldcount = trans_count;
	while (1) {
		trans_count = 0;
		switch (e->type) {
		case E_OR: case E_AND:
			expr_eliminate_dups1(e->type, &e, &e);
			expr_eliminate_dups2(e->type, &e, &e);
		default:
			;
		}
		if (!trans_count)
			break;
		e = expr_eliminate_yn(e);
	}
	trans_count = oldcount;
	return e;
}

// Assembly:
subq $0x18, %rsp
movq %rdi, 0x8(%rsp)
cmpq $0x0, 0x8(%rsp)
jne 0xd03d
movq 0x8(%rsp), %rax
movq %rax, 0x10(%rsp)
jmp 0xd0bb
movl 0xdd71(%rip), %eax      # 0x1adb4
movl %eax, 0x4(%rsp)
movl $0x0, 0xdd63(%rip)      # 0x1adb4
movq 0x8(%rsp), %rax
movl (%rax), %eax
decl %eax
subl $0x1, %eax
ja 0xd089
jmp 0xd061
movq 0x8(%rsp), %rax
movl (%rax), %edi
leaq 0x8(%rsp), %rdx
movq %rdx, %rsi
callq 0xd0d0
movq 0x8(%rsp), %rax
movl (%rax), %edi
leaq 0x8(%rsp), %rdx
movq %rdx, %rsi
callq 0xd2c0
jmp 0xd08b
cmpl $0x0, 0xdd22(%rip)      # 0x1adb4
jne 0xd096
jmp 0xd0a7
movq 0x8(%rsp), %rdi
callq 0xbed0
movq %rax, 0x8(%rsp)
jmp 0xd047
movl 0x4(%rsp), %eax
movl %eax, 0xdd03(%rip)      # 0x1adb4
movq 0x8(%rsp), %rax
movq %rax, 0x10(%rsp)
movq 0x10(%rsp), %rax
addq $0x18, %rsp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/saltyJeff[P]uClibcpp/extra/config/./expr.c
// Function: expr_contains_symbol
int expr_contains_symbol(struct expr *dep, struct symbol *sym)
{
	if (!dep)
		return 0;

	switch (dep->type) {
	case E_AND:
	case E_OR:
		return expr_contains_symbol(dep->left.expr, sym) ||
		       expr_contains_symbol(dep->right.expr, sym);
	case E_SYMBOL:
		return dep->left.sym == sym;
	case E_EQUAL:
	case E_UNEQUAL:
		return dep->left.sym == sym ||
		       dep->right.sym == sym;
	case E_NOT:
		return expr_contains_symbol(dep->left.expr, sym);
	default:
		;
	}
	return 0;
}

// Assembly:
subq $0x28, %rsp
movq %rdi, 0x18(%rsp)
movq %rsi, 0x10(%rsp)
cmpq $0x0, 0x18(%rsp)
jne 0xda83
movl $0x0, 0x24(%rsp)
jmp 0xdb76
movq 0x18(%rsp), %rax
movl (%rax), %eax
decl %eax
movl %eax, %ecx
movq %rcx, 0x8(%rsp)
subl $0x6, %eax
ja 0xdb6c
movq 0x8(%rsp), %rax
leaq 0x2c00(%rip), %rcx      # 0x106a8
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
movq 0x18(%rsp), %rax
movq 0x8(%rax), %rdi
movq 0x10(%rsp), %rsi
callq 0xda60
movl %eax, %ecx
movb $0x1, %al
cmpl $0x0, %ecx
movb %al, 0x7(%rsp)
jne 0xdaee
movq 0x18(%rsp), %rax
movq 0x10(%rax), %rdi
movq 0x10(%rsp), %rsi
callq 0xda60
cmpl $0x0, %eax
setne %al
movb %al, 0x7(%rsp)
movb 0x7(%rsp), %al
andb $0x1, %al
movzbl %al, %eax
movl %eax, 0x24(%rsp)
jmp 0xdb76
movq 0x18(%rsp), %rax
movq 0x8(%rax), %rax
cmpq 0x10(%rsp), %rax
sete %al
andb $0x1, %al
movzbl %al, %eax
movl %eax, 0x24(%rsp)
jmp 0xdb76
movq 0x18(%rsp), %rax
movq 0x8(%rax), %rcx
movb $0x1, %al
cmpq 0x10(%rsp), %rcx
movb %al, 0x6(%rsp)
je 0xdb44
movq 0x18(%rsp), %rax
movq 0x10(%rax), %rax
cmpq 0x10(%rsp), %rax
sete %al
movb %al, 0x6(%rsp)
movb 0x6(%rsp), %al
andb $0x1, %al
movzbl %al, %eax
movl %eax, 0x24(%rsp)
jmp 0xdb76
movq 0x18(%rsp), %rax
movq 0x8(%rax), %rdi
movq 0x10(%rsp), %rsi
callq 0xda60
movl %eax, 0x24(%rsp)
jmp 0xdb76
jmp 0xdb6e
movl $0x0, 0x24(%rsp)
movl 0x24(%rsp), %eax
addq $0x28, %rsp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/saltyJeff[P]uClibcpp/extra/config/./expr.c
// Function: expr_depends_symbol
bool expr_depends_symbol(struct expr *dep, struct symbol *sym)
{
	if (!dep)
		return false;

	switch (dep->type) {
	case E_AND:
		return expr_depends_symbol(dep->left.expr, sym) ||
		       expr_depends_symbol(dep->right.expr, sym);
	case E_SYMBOL:
		return dep->left.sym == sym;
	case E_EQUAL:
		if (dep->left.sym == sym) {
			if (dep->right.sym == &symbol_yes || dep->right.sym == &symbol_mod)
				return true;
		}
		break;
	case E_UNEQUAL:
		if (dep->left.sym == sym) {
			if (dep->right.sym == &symbol_no)
				return true;
		}
		break;
	default:
		;
	}
 	return false;
}

// Assembly:
subq $0x28, %rsp
movq %rdi, 0x18(%rsp)
movq %rsi, 0x10(%rsp)
cmpq $0x0, 0x18(%rsp)
jne 0xdba0
movb $0x0, 0x27(%rsp)
jmp 0xdca1
movq 0x18(%rsp), %rax
movl (%rax), %eax
addl $-0x2, %eax
movl %eax, %ecx
movq %rcx, 0x8(%rsp)
subl $0x5, %eax
ja 0xdc9a
movq 0x8(%rsp), %rax
leaq 0x2afe(%rip), %rcx      # 0x106c4
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
movq 0x18(%rsp), %rax
movq 0x8(%rax), %rdi
movq 0x10(%rsp), %rsi
callq 0xdb80
movb %al, %cl
movb $0x1, %al
testb $0x1, %cl
movb %al, 0x7(%rsp)
jne 0xdc06
movq 0x18(%rsp), %rax
movq 0x10(%rax), %rdi
movq 0x10(%rsp), %rsi
callq 0xdb80
movb %al, 0x7(%rsp)
movb 0x7(%rsp), %al
andb $0x1, %al
movb %al, 0x27(%rsp)
jmp 0xdca1
movq 0x18(%rsp), %rax
movq 0x8(%rax), %rax
cmpq 0x10(%rsp), %rax
sete %al
andb $0x1, %al
movb %al, 0x27(%rsp)
jmp 0xdca1
movq 0x18(%rsp), %rax
movq 0x8(%rax), %rax
cmpq 0x10(%rsp), %rax
jne 0xdc6b
movq 0x18(%rsp), %rax
leaq 0xb63e(%rip), %rcx      # 0x19288
cmpq %rcx, 0x10(%rax)
je 0xdc62
movq 0x18(%rsp), %rax
leaq 0xb69c(%rip), %rcx      # 0x192f8
cmpq %rcx, 0x10(%rax)
jne 0xdc69
movb $0x1, 0x27(%rsp)
jmp 0xdca1
jmp 0xdc6b
jmp 0xdc9c
movq 0x18(%rsp), %rax
movq 0x8(%rax), %rax
cmpq 0x10(%rsp), %rax
jne 0xdc98
movq 0x18(%rsp), %rax
leaq 0xb58f(%rip), %rcx      # 0x19218
cmpq %rcx, 0x10(%rax)
jne 0xdc96
movb $0x1, 0x27(%rsp)
jmp 0xdca1
jmp 0xdc98
jmp 0xdc9c
jmp 0xdc9c
movb $0x0, 0x27(%rsp)
movb 0x27(%rsp), %al
andb $0x1, %al
addq $0x28, %rsp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/saltyJeff[P]uClibcpp/extra/config/./expr.c
// Function: expr_extract_eq_and
struct expr *expr_extract_eq_and(struct expr **ep1, struct expr **ep2)
{
	struct expr *tmp = NULL;
	expr_extract_eq(E_AND, &tmp, ep1, ep2);
	if (tmp) {
		*ep1 = expr_eliminate_yn(*ep1);
		*ep2 = expr_eliminate_yn(*ep2);
	}
	return tmp;
}

// Assembly:
subq $0x18, %rsp
movq %rdi, 0x10(%rsp)
movq %rsi, 0x8(%rsp)
movq $0x0, (%rsp)
movq 0x10(%rsp), %rdx
movq 0x8(%rsp), %rcx
movl $0x2, %edi
movq %rsp, %rsi
callq 0xdd20
cmpq $0x0, (%rsp)
je 0xdd14
movq 0x10(%rsp), %rax
movq (%rax), %rdi
callq 0xbed0
movq %rax, %rcx
movq 0x10(%rsp), %rax
movq %rcx, (%rax)
movq 0x8(%rsp), %rax
movq (%rax), %rdi
callq 0xbed0
movq %rax, %rcx
movq 0x8(%rsp), %rax
movq %rcx, (%rax)
movq (%rsp), %rax
addq $0x18, %rsp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/saltyJeff[P]uClibcpp/extra/config/./expr.c
// Function: expr_extract_eq
void expr_extract_eq(enum expr_type type, struct expr **ep, struct expr **ep1, struct expr **ep2)
{
#define e1 (*ep1)
#define e2 (*ep2)
	if (e1->type == type) {
		expr_extract_eq(type, ep, &e1->left.expr, &e2);
		expr_extract_eq(type, ep, &e1->right.expr, &e2);
		return;
	}
	if (e2->type == type) {
		expr_extract_eq(type, ep, ep1, &e2->left.expr);
		expr_extract_eq(type, ep, ep1, &e2->right.expr);
		return;
	}
	if (expr_eq(e1, e2)) {
		*ep = *ep ? expr_alloc_two(type, *ep, e1) : e1;
		expr_free(e2);
		if (type == E_AND) {
			e1 = expr_alloc_symbol(&symbol_yes);
			e2 = expr_alloc_symbol(&symbol_yes);
		} else if (type == E_OR) {
			e1 = expr_alloc_symbol(&symbol_no);
			e2 = expr_alloc_symbol(&symbol_no);
		}
	}
#undef e1
#undef e2
}

// Assembly:
subq $0x28, %rsp
movl %edi, 0x24(%rsp)
movq %rsi, 0x18(%rsp)
movq %rdx, 0x10(%rsp)
movq %rcx, 0x8(%rsp)
movq 0x10(%rsp), %rax
movq (%rax), %rax
movl (%rax), %eax
cmpl 0x24(%rsp), %eax
jne 0xdd8a
movl 0x24(%rsp), %edi
movq 0x18(%rsp), %rsi
movq 0x10(%rsp), %rax
movq (%rax), %rdx
addq $0x8, %rdx
movq 0x8(%rsp), %rcx
callq 0xdd20
movl 0x24(%rsp), %edi
movq 0x18(%rsp), %rsi
movq 0x10(%rsp), %rax
movq (%rax), %rdx
addq $0x10, %rdx
movq 0x8(%rsp), %rcx
callq 0xdd20
jmp 0xdeba
movq 0x8(%rsp), %rax
movq (%rax), %rax
movl (%rax), %eax
cmpl 0x24(%rsp), %eax
jne 0xdddd
movl 0x24(%rsp), %edi
movq 0x18(%rsp), %rsi
movq 0x10(%rsp), %rdx
movq 0x8(%rsp), %rax
movq (%rax), %rcx
addq $0x8, %rcx
callq 0xdd20
movl 0x24(%rsp), %edi
movq 0x18(%rsp), %rsi
movq 0x10(%rsp), %rdx
movq 0x8(%rsp), %rax
movq (%rax), %rcx
addq $0x10, %rcx
callq 0xdd20
jmp 0xdeba
movq 0x10(%rsp), %rax
movq (%rax), %rdi
movq 0x8(%rsp), %rax
movq (%rax), %rsi
callq 0xc350
cmpl $0x0, %eax
je 0xdeba
movq 0x18(%rsp), %rax
cmpq $0x0, (%rax)
je 0xde25
movl 0x24(%rsp), %edi
movq 0x18(%rsp), %rax
movq (%rax), %rsi
movq 0x10(%rsp), %rax
movq (%rax), %rdx
callq 0x68e0
movq %rax, (%rsp)
jmp 0xde31
movq 0x10(%rsp), %rax
movq (%rax), %rax
movq %rax, (%rsp)
movq (%rsp), %rcx
movq 0x18(%rsp), %rax
movq %rcx, (%rax)
movq 0x8(%rsp), %rax
movq (%rax), %rdi
callq 0xbb90
cmpl $0x2, 0x24(%rsp)
jne 0xde81
leaq 0xb430(%rip), %rdi      # 0x19288
callq 0x6840
movq %rax, %rcx
movq 0x10(%rsp), %rax
movq %rcx, (%rax)
leaq 0xb419(%rip), %rdi      # 0x19288
callq 0x6840
movq %rax, %rcx
movq 0x8(%rsp), %rax
movq %rcx, (%rax)
jmp 0xdeb8
cmpl $0x1, 0x24(%rsp)
jne 0xdeb6
leaq 0xb389(%rip), %rdi      # 0x19218
callq 0x6840
movq %rax, %rcx
movq 0x10(%rsp), %rax
movq %rcx, (%rax)
leaq 0xb372(%rip), %rdi      # 0x19218
callq 0x6840
movq %rax, %rcx
movq 0x8(%rsp), %rax
movq %rcx, (%rax)
jmp 0xdeb8
jmp 0xdeba
addq $0x28, %rsp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/saltyJeff[P]uClibcpp/extra/config/./expr.c
// Function: expr_extract_eq_or
struct expr *expr_extract_eq_or(struct expr **ep1, struct expr **ep2)
{
	struct expr *tmp = NULL;
	expr_extract_eq(E_OR, &tmp, ep1, ep2);
	if (tmp) {
		*ep1 = expr_eliminate_yn(*ep1);
		*ep2 = expr_eliminate_yn(*ep2);
	}
	return tmp;
}

// Assembly:
subq $0x18, %rsp
movq %rdi, 0x10(%rsp)
movq %rsi, 0x8(%rsp)
movq $0x0, (%rsp)
movq 0x10(%rsp), %rdx
movq 0x8(%rsp), %rcx
movl $0x1, %edi
movq %rsp, %rsi
callq 0xdd20
cmpq $0x0, (%rsp)
je 0xdf24
movq 0x10(%rsp), %rax
movq (%rax), %rdi
callq 0xbed0
movq %rax, %rcx
movq 0x10(%rsp), %rax
movq %rcx, (%rax)
movq 0x8(%rsp), %rax
movq (%rax), %rdi
callq 0xbed0
movq %rax, %rcx
movq 0x8(%rsp), %rax
movq %rcx, (%rax)
movq (%rsp), %rax
addq $0x18, %rsp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/saltyJeff[P]uClibcpp/extra/config/./expr.c
// Function: expr_compare_type
int expr_compare_type(enum expr_type t1, enum expr_type t2)
{
#if 0
	return 1;
#else
	if (t1 == t2)
		return 0;
	switch (t1) {
	case E_EQUAL:
	case E_UNEQUAL:
		if (t2 == E_NOT)
			return 1;
	case E_NOT:
		if (t2 == E_AND)
			return 1;
	case E_AND:
		if (t2 == E_OR)
			return 1;
	case E_OR:
		if (t2 == E_CHOICE)
			return 1;
	case E_CHOICE:
		if (t2 == 0)
			return 1;
	default:
		return -1;
	}
	printf("[%dgt%d?]", t1, t2);
	return 0;
#endif
}

// Assembly:
movl %edi, -0x8(%rsp)
movl %esi, -0xc(%rsp)
movl -0x8(%rsp), %eax
cmpl -0xc(%rsp), %eax
jne 0xe4bf
movl $0x0, -0x4(%rsp)
jmp 0xe54d
movl -0x8(%rsp), %eax
decl %eax
movl %eax, %ecx
movq %rcx, -0x18(%rsp)
subl $0x5, %eax
ja 0xe545
movq -0x18(%rsp), %rax
leaq 0x223f(%rip), %rcx      # 0x1071c
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
cmpl $0x3, -0xc(%rsp)
jne 0xe4f7
movl $0x1, -0x4(%rsp)
jmp 0xe54d
jmp 0xe4f9
cmpl $0x2, -0xc(%rsp)
jne 0xe50a
movl $0x1, -0x4(%rsp)
jmp 0xe54d
jmp 0xe50c
cmpl $0x1, -0xc(%rsp)
jne 0xe51d
movl $0x1, -0x4(%rsp)
jmp 0xe54d
jmp 0xe51f
cmpl $0x6, -0xc(%rsp)
jne 0xe530
movl $0x1, -0x4(%rsp)
jmp 0xe54d
jmp 0xe532
cmpl $0x0, -0xc(%rsp)
jne 0xe543
movl $0x1, -0x4(%rsp)
jmp 0xe54d
jmp 0xe545
movl $0xffffffff, -0x4(%rsp) # imm = 0xFFFFFFFF
movl -0x4(%rsp), %eax
retq
nopw %cs:(%rax,%rax)