LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_cpp_makefile_star2_O1/Danis98[P]PietGen/parse.cpp
// Function: parse_prog()
void parse_prog(){
	token t=peek();
	if(keyword_map[t]==TOK_EOS) return;
	if(keyword_map[t]==TOK_END 
		|| keyword_map[t]==TOK_INT 
		|| keyword_map[t]==TOK_CHAR) 
		parse_error("Wrong token: "+t);
	else parse_stmt_list();
	
	print_ast();
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
subq $0x40, %rsp
movslq 0x3fd8(%rip), %rax      # 0x81f0
leaq 0x3f59(%rip), %rcx      # 0x8178
movq (%rcx), %rcx
shlq $0x5, %rax
leaq -0x20(%rbp), %r14
movq %r14, -0x10(%r14)
movq (%rcx,%rax), %rsi
movq 0x8(%rcx,%rax), %rdx
addq %rsi, %rdx
leaq -0x30(%rbp), %rbx
movq %rbx, %rdi
callq 0x26ac
leaq 0x3f6b(%rip), %rdi      # 0x81b8
movq %rbx, %rsi
callq 0x43ce
cmpl $0x15, (%rax)
je 0x42a3
leaq 0x3f57(%rip), %rdi      # 0x81b8
leaq -0x30(%rbp), %rsi
callq 0x43ce
cmpl $0x2, (%rax)
je 0x42ba
leaq 0x3f42(%rip), %rdi      # 0x81b8
leaq -0x30(%rbp), %rsi
callq 0x43ce
cmpl $0x12, (%rax)
je 0x42ba
leaq 0x3f2d(%rip), %rdi      # 0x81b8
leaq -0x30(%rbp), %rsi
callq 0x43ce
cmpl $0x13, (%rax)
je 0x42ba
callq 0x40f0
callq 0x3664
movq -0x30(%rbp), %rdi
cmpq %r14, %rdi
je 0x42b1
callq 0x2190
addq $0x40, %rsp
popq %rbx
popq %r14
popq %rbp
retq
leaq 0xfbd(%rip), %rsi       # 0x527e
leaq -0x50(%rbp), %rdi
leaq -0x30(%rbp), %rdx
callq 0x444d
leaq -0x50(%rbp), %rdi
callq 0x2e00
movq %rax, %rbx
leaq -0x40(%rbp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x42f1
callq 0x2190
jmp 0x42f1
movq %rax, %rbx
movq -0x30(%rbp), %rdi
cmpq %r14, %rdi
je 0x42ff
callq 0x2190
movq %rbx, %rdi
callq 0x2270
// File: /workspace/github_cpp_makefile_star2_O1/corecodec[P]coremake/coremake.c
// Function: zalloc
void* zalloc(int size)
{
	void* p = malloc(size);
	if (!p)
	{
		printf("out of memory!\r\n");
		exit(1);
	}
	memset(p,0,size);
	return p;
}

// Assembly:
pushq %rbx
movslq %edi, %rbx
movq %rbx, %rdi
callq 0x2260
testq %rax, %rax
je 0x2529
movq %rax, %rdi
xorl %esi, %esi
movq %rbx, %rdx
popq %rbx
jmp 0x2180
leaq 0x10faf(%rip), %rdi     # 0x134df
callq 0x20d0
movl $0x1, %edi
callq 0x2330
// File: /workspace/github_cpp_makefile_star2_O1/corecodec[P]coremake/coremake.c
// Function: item_remove
void item_remove(item* i)
{
	item** child;
	item* p = i->parent;
	for (child = p->child;child != p->childend;++child)
		if (*child == i)
		{
			memmove(child,child+1,(p->childend-child-1)*sizeof(item*));
			--p->childend;
			break;
		}

	i->parent = NULL;
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
movq 0x10(%rdi), %r14
movq 0x18(%r14), %rdi
movq 0x20(%r14), %rax
cmpq %rax, %rdi
je 0x25c9
movq %rax, %rdx
subq %rdi, %rdx
addq $-0x8, %rdx
cmpq %rbx, (%rdi)
je 0x25bb
addq $0x8, %rdi
addq $-0x8, %rdx
cmpq %rax, %rdi
jne 0x25a7
jmp 0x25c9
leaq 0x8(%rdi), %rsi
callq 0x22d0
addq $-0x8, 0x20(%r14)
movq $0x0, 0x10(%rbx)
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_cpp_makefile_star2_O1/corecodec[P]coremake/coremake.c
// Function: item_add
void item_add(item* p,item* child)
{
	if (!child)
		return;

	if (child->parent)
		item_remove(child);

	if (p->childalloc == p->childend)
	{
		intptr_t count = p->childend - p->child;
		intptr_t alloc = count+16;
		p->child = (item**)realloc(p->child,sizeof(item*)*alloc);
		if (!p->child)
		{
			printf("out of memory!\r\n");
			exit(1);
		}
		p->childend = p->child+count;
		p->childalloc = p->child+alloc;
	}
	*(p->childend++) = child;
	child->parent = p;
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
testq %rsi, %rsi
je 0x268e
movq %rsi, %rbx
movq %rdi, %r14
movq 0x10(%rsi), %r15
testq %r15, %r15
je 0x263a
movq 0x18(%r15), %rdi
movq 0x20(%r15), %rax
cmpq %rax, %rdi
je 0x2632
movq %rax, %rdx
subq %rdi, %rdx
addq $-0x8, %rdx
cmpq %rbx, (%rdi)
je 0x2624
addq $0x8, %rdi
addq $-0x8, %rdx
cmpq %rax, %rdi
jne 0x2610
jmp 0x2632
leaq 0x8(%rdi), %rsi
callq 0x22d0
addq $-0x8, 0x20(%r15)
movq $0x0, 0x10(%rbx)
movq 0x20(%r14), %r15
cmpq %r15, 0x28(%r14)
jne 0x267b
movq 0x18(%r14), %rdi
subq %rdi, %r15
movq %r15, %r12
sarq $0x3, %r12
leaq 0x80(,%r12,8), %rsi
callq 0x22b0
movq %rax, 0x18(%r14)
testq %rax, %rax
je 0x269a
addq $0x10, %r12
addq %rax, %r15
movq %r15, 0x20(%r14)
leaq (%rax,%r12,8), %rax
movq %rax, 0x28(%r14)
movq 0x20(%r14), %rax
leaq 0x8(%rax), %rcx
movq %rcx, 0x20(%r14)
movq %rbx, (%rax)
movq %r14, 0x10(%rbx)
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
leaq 0x10e3e(%rip), %rdi     # 0x134df
callq 0x20d0
movl $0x1, %edi
callq 0x2330
// File: /workspace/github_cpp_makefile_star2_O1/corecodec[P]coremake/coremake.c
// Function: item_find
item* item_find(const item* parent,const char* value)
{
	if (parent)
	{
		item** child;
		for (child = parent->child;child != parent->childend;++child)
			if (stricmp((*child)->value,value)==0)
				return *child;
	}
	return NULL;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
testq %rdi, %rdi
je 0x270a
movq 0x18(%rdi), %r15
movq 0x20(%rdi), %r12
cmpq %r12, %r15
sete %bpl
je 0x2705
movq %rsi, %r14
movq (%r15), %rbx
movq (%rbx), %rdi
callq 0x2070
testl %eax, %eax
je 0x2705
addq $0x8, %r15
cmpq %r12, %r15
sete %bpl
je 0x2705
movq (%r15), %rbx
movq (%rbx), %rdi
movq %r14, %rsi
callq 0x2070
addq $0x8, %r15
testl %eax, %eax
jne 0x26e4
jmp 0x2705
testb %bpl, %bpl
je 0x270c
xorl %ebx, %ebx
movq %rbx, %rax
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O1/corecodec[P]coremake/coremake.c
// Function: item_get
item* item_get(item* parent,const char* value,int defined)
{
	item* p = item_find(parent,value);
	if (!p)
	{
		p = (item*)zalloc(sizeof(item));
		if (value)
			p->value = strdup(value);
		if (parent)
			item_add(parent,p);
	}
	if (defined)
		p->flags |= FLAG_DEFINED;
	return p;
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movl %edx, %ebx
movq %rsi, %r12
movq %rdi, %r15
callq 0x26b0
movq %rax, %r14
testq %rax, %rax
jne 0x278f
movl $0x38, %edi
callq 0x250a
movq %rax, %r14
testq %r12, %r12
je 0x277f
movq %r12, %rdi
callq 0x2350
movq %rax, (%r14)
testq %r15, %r15
je 0x278f
movq %r15, %rdi
movq %r14, %rsi
callq 0x25d9
testl %ebx, %ebx
je 0x2798
orb $0x20, 0x30(%r14)
movq %r14, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
// File: /workspace/github_cpp_makefile_star2_O1/corecodec[P]coremake/coremake.c
// Function: getvalue
item* getvalue(item* p)
{
	if (p)
	{
		item** child;
		for (child=p->child;child!=p->childend;++child)
			if (!((*child)->flags & FLAG_REMOVED))
				return *child;
	}
	return NULL;
}

// Assembly:
testq %rdi, %rdi
je 0x2801
movq 0x18(%rdi), %rdx
movq 0x20(%rdi), %rsi
cmpq %rsi, %rdx
sete %cl
je 0x27fd
movq (%rdx), %rax
testb $0x40, 0x30(%rax)
je 0x27fd
addq $0x8, %rdx
cmpq %rsi, %rdx
sete %cl
je 0x27fd
movq (%rdx), %rax
addq $0x8, %rdx
testb $0x40, 0x30(%rax)
jne 0x27e6
jmp 0x27fd
testb %cl, %cl
je 0x2803
xorl %eax, %eax
retq
// File: /workspace/github_cpp_makefile_star2_O1/corecodec[P]coremake/coremake.c
// Function: setvalue
void setvalue(item* p,const char* value)
{
    item* v = getvalue(p);
    if (v)
    {
        if (strcmp(v->value,value)==0)
            return;
        v->flags |= FLAG_REMOVED;
    }
    item_get(p,value,1);
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rsi, %rbx
movq %rdi, %r14
testq %rdi, %rdi
je 0x2840
movq 0x18(%r14), %rcx
movq 0x20(%r14), %rdx
cmpq %rdx, %rcx
sete %al
je 0x283c
movq (%rcx), %r15
testb $0x40, 0x30(%r15)
je 0x283c
addq $0x8, %rcx
cmpq %rdx, %rcx
sete %al
jne 0x2824
jmp 0x283c
testb $0x1, %al
je 0x2843
xorl %r15d, %r15d
testq %r15, %r15
je 0x285c
movq (%r15), %rdi
movq %rbx, %rsi
callq 0x21f0
testl %eax, %eax
je 0x2871
orb $0x40, 0x30(%r15)
movq %r14, %rdi
movq %rbx, %rsi
movl $0x1, %edx
popq %rbx
popq %r14
popq %r15
jmp 0x2745
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_cpp_makefile_star2_O1/corecodec[P]coremake/coremake.c
// Function: compare_use
int compare_use(const item* a, const item* b)
{
	item* refa = findref(a);
	item* refb = findref(b);
	if (refa && refb)
	{
		size_t i;
		item* use;

		use = item_get(refb,"use",0);
		for (i=0;i<item_childcount(use);++i)
			if (refa == findref(use->child[i]))
			{
				use = item_get(refa,"use",0);
				for (i=0;i<item_childcount(use);++i)
					if (refb == findref(use->child[i]))
					{
						// circular reference
						return compare_name(refa,refb);
					}

				return 1;
			}

	}
	return 0;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rsi, %r14
callq 0x2877
movq %rax, %rbx
movq %r14, %rdi
callq 0x2877
movq %rax, %r14
testq %rbx, %rbx
setne %al
testq %r14, %r14
setne %cl
andb %al, %cl
cmpb $0x1, %cl
jne 0x2bf6
leaq 0xf58f(%rip), %rsi      # 0x120dc
xorl %ebp, %ebp
movq %r14, %rdi
xorl %edx, %edx
callq 0x2745
movq %rax, %r15
movq %rbp, %r12
testq %r15, %r15
je 0x2b72
movq 0x20(%r15), %r13
subq 0x18(%r15), %r13
sarq $0x3, %r13
jmp 0x2b75
xorl %r13d, %r13d
cmpq %r13, %r12
jae 0x2bf1
movq 0x18(%r15), %rax
movq (%rax,%r12,8), %rdi
callq 0x2877
leaq 0x1(%r12), %rbp
cmpq %rax, %rbx
jne 0x2b5c
leaq 0xf544(%rip), %rsi      # 0x120dc
xorl %ebp, %ebp
movq %rbx, %rdi
xorl %edx, %edx
callq 0x2745
movq %rax, %r15
testq %r15, %r15
je 0x2bba
movq 0x20(%r15), %rax
subq 0x18(%r15), %rax
sarq $0x3, %rax
jmp 0x2bbc
xorl %eax, %eax
cmpq %rax, %rbp
jae 0x2bec
movq 0x18(%r15), %rax
movq (%rax,%rbp,8), %rdi
callq 0x2877
incq %rbp
cmpq %rax, %r14
jne 0x2ba7
movq (%rbx), %rdi
movq (%r14), %rsi
callq 0x2070
movl %eax, %ecx
xorl %eax, %eax
testl %ecx, %ecx
setg %al
jmp 0x2bf1
movl $0x1, %eax
cmpq %r13, %r12
jb 0x2bf8
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O1/corecodec[P]coremake/coremake.c
// Function: precompare_use
int precompare_use(const item* refa, const item* refb)
{
	size_t i;
	item* use;

	use = item_get((item*)refb,"use",0);
	for (i=0;i<item_childcount(use);++i)
		if (refa == findref(use->child[i]))
		{
			use = item_get((item*)refa,"use",0);
			for (i=0;i<item_childcount(use);++i)
				if (refb == findref(use->child[i]))
				{
					// circular reference
					return compare_name(refa,refb);
				}

			return 1;
		}

	return 0;
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq %rdi, %r14
leaq 0xf4c0(%rip), %rsi      # 0x120dc
xorl %r12d, %r12d
movq %rbx, %rdi
xorl %edx, %edx
callq 0x2745
movq %rax, %r15
testq %r15, %r15
je 0x2c3f
movq 0x20(%r15), %rax
subq 0x18(%r15), %rax
sarq $0x3, %rax
jmp 0x2c41
xorl %eax, %eax
cmpq %rax, %r12
jae 0x2cb7
movq 0x18(%r15), %rax
movq (%rax,%r12,8), %rdi
callq 0x2877
incq %r12
cmpq %r14, %rax
jne 0x2c2c
leaq 0xf47a(%rip), %rsi      # 0x120dc
xorl %r12d, %r12d
movq %r14, %rdi
xorl %edx, %edx
callq 0x2745
movq %rax, %r15
testq %r15, %r15
je 0x2c85
movq 0x20(%r15), %rax
subq 0x18(%r15), %rax
sarq $0x3, %rax
jmp 0x2c87
xorl %eax, %eax
cmpq %rax, %r12
jae 0x2cbb
movq 0x18(%r15), %rax
movq (%rax,%r12,8), %rdi
callq 0x2877
incq %r12
cmpq %rbx, %rax
jne 0x2c72
movq (%r14), %rdi
movq (%rbx), %rsi
callq 0x2070
movl %eax, %ecx
xorl %eax, %eax
testl %ecx, %ecx
setg %al
jmp 0x2cc0
xorl %eax, %eax
jmp 0x2cc0
movl $0x1, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
// File: /workspace/github_cpp_makefile_star2_O1/corecodec[P]coremake/coremake.c
// Function: item_sort
void item_sort(item* p,int(*compare)(const item*, const item*))
{
	if (item_childcount(p)>=2)
	{
		int changed;
		do
		{
			size_t i,j,n=item_childcount(p);
            changed=0;

			for (i=0;i<n;++i)
                for (j=i+1;j<n;++j)
                    if (compare(p->child[i],p->child[j]))
				    {
					    item* tmp = p->child[i];
					    p->child[i] = p->child[j];
					    p->child[j] = tmp;
    				    changed=1;
                    }

		} while (changed);
	}
}

// Assembly:
testq %rdi, %rdi
je 0x2d75
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rdi, %r14
movq 0x20(%rdi), %rax
subq 0x18(%rdi), %rax
cmpq $0x9, %rax
jb 0x2d67
movq %rsi, %rbx
testq %r14, %r14
je 0x2d07
movq 0x20(%r14), %r15
subq 0x18(%r14), %r15
sarq $0x3, %r15
jmp 0x2d0a
xorl %r15d, %r15d
testq %r15, %r15
je 0x2d67
xorl %r13d, %r13d
xorl %ebp, %ebp
leaq 0x1(%rbp), %r12
cmpq %r15, %r12
movq %r12, (%rsp)
jae 0x2d59
movq 0x18(%r14), %rax
movq (%rax,%rbp,8), %rdi
movq (%rax,%r12,8), %rsi
callq *%rbx
testl %eax, %eax
je 0x2d51
movq 0x18(%r14), %rax
movq (%rax,%rbp,8), %rcx
movq (%rax,%r12,8), %rdx
movq %rdx, (%rax,%rbp,8)
movq 0x18(%r14), %rax
movq %rcx, (%rax,%r12,8)
movl $0x1, %r13d
incq %r12
cmpq %r15, %r12
jb 0x2d21
movq (%rsp), %rbp
cmpq %r15, %rbp
jne 0x2d14
testl %r13d, %r13d
jne 0x2cf4
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O1/corecodec[P]coremake/coremake.c
// Function: itemcond_delete
void itemcond_delete(itemcond* p)
{
	if (p && --p->refcount==0)
	{
		itemcond_delete(p->a);
		itemcond_delete(p->b);
		free(p);
	}
}

// Assembly:
pushq %rbx
testq %rdi, %rdi
je 0x2d83
movq %rdi, %rbx
decl (%rdi)
je 0x2d85
popq %rbx
retq
movq 0x10(%rbx), %rdi
callq 0x2d76
movq 0x18(%rbx), %rdi
callq 0x2d76
movq %rbx, %rdi
popq %rbx
jmp 0x2050
// File: /workspace/github_cpp_makefile_star2_O1/corecodec[P]coremake/coremake.c
// Function: item_delete
void item_delete(item* p)
{
	item** child;
	if (!p)
		return;
	if (p->parent)
		item_remove(p);
	for (child = p->child;child != p->childend;++child)
	{
		(*child)->parent = NULL;
		item_delete(*child);
	}
	itemcond_delete(p->cond);
	free(p->value);
	free(p);
}

// Assembly:
testq %rdi, %rdi
je 0x2de0
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
movq 0x10(%rdi), %r14
testq %r14, %r14
je 0x2df7
movq 0x18(%r14), %rdi
movq 0x20(%r14), %rax
cmpq %rax, %rdi
je 0x2def
movq %rax, %rdx
subq %rdi, %rdx
addq $-0x8, %rdx
cmpq %rbx, (%rdi)
je 0x2de1
addq $0x8, %rdi
addq $-0x8, %rdx
cmpq %rax, %rdi
jne 0x2dcc
jmp 0x2def
retq
leaq 0x8(%rdi), %rsi
callq 0x22d0
addq $-0x8, 0x20(%r14)
movq $0x0, 0x10(%rbx)
movq 0x18(%rbx), %r14
cmpq 0x20(%rbx), %r14
je 0x2e1a
movq (%r14), %rax
movq $0x0, 0x10(%rax)
movq (%r14), %rdi
callq 0x2da0
addq $0x8, %r14
jmp 0x2dfb
movq 0x8(%rbx), %rdi
callq 0x2d76
movq (%rbx), %rdi
callq 0x2050
movq %rbx, %rdi
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x2050
// File: /workspace/github_cpp_makefile_star2_O1/corecodec[P]coremake/coremake.c
// Function: itemcond_new
itemcond* itemcond_new(int func, item* value)
{
	itemcond* p = (itemcond*)zalloc(sizeof(itemcond));
    p->refcount = 1;
	p->func = func;
	p->value = value;
	return p;
}

// Assembly:
pushq %rbp
pushq %rbx
pushq %rax
movq %rsi, %rbx
movl %edi, %ebp
movl $0x20, %edi
callq 0x250a
movl $0x1, (%rax)
movl %ebp, 0x4(%rax)
movq %rbx, 0x8(%rax)
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O1/corecodec[P]coremake/coremake.c
// Function: itemcond_same
int itemcond_same(itemcond* a,itemcond* b)
{
	if (!a && !b)
		return 1;
	if (!a || !b)
		return 0;
	if (a->func != b->func)
		return 0;
	switch (a->func)
	{
	case COND_GET:
		return a->value == b->value;
	case COND_AND:
	case COND_OR:
		return (itemcond_same(a->a,b->a) && itemcond_same(a->b,b->b)) ||
               (itemcond_same(a->b,b->a) && itemcond_same(a->a,b->b));
	case COND_NOT:
		return itemcond_same(a->a,b->a);
	default:
		return 1;
	}
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movq %rsi, %rbx
movq %rdi, %r14
movl $0x1, %ebp
movq %r14, %rax
orq %rbx, %rax
je 0x2eed
testq %r14, %r14
je 0x2eeb
testq %rbx, %rbx
je 0x2eeb
movl 0x4(%r14), %eax
cmpl 0x4(%rbx), %eax
jne 0x2eeb
leal -0x1(%rax), %ecx
cmpl $0x2, %ecx
jae 0x2edc
movq 0x10(%r14), %r15
movq 0x10(%rbx), %r12
movq %r15, %rdi
movq %r12, %rsi
callq 0x2e60
testl %eax, %eax
je 0x2ebe
movq 0x18(%r14), %rdi
movq 0x18(%rbx), %rsi
callq 0x2e60
testl %eax, %eax
jne 0x2eed
movq 0x18(%r14), %rdi
movq %r12, %rsi
callq 0x2e60
movl $0x0, %ebp
testl %eax, %eax
je 0x2eed
movq 0x18(%rbx), %rbx
movq %r15, %r14
jmp 0x2e6e
cmpl $0x3, %eax
jne 0x2ef8
movq 0x10(%r14), %r14
movq 0x10(%rbx), %rbx
jmp 0x2e6e
xorl %ebp, %ebp
movl %ebp, %eax
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
testl %eax, %eax
jne 0x2eed
movq 0x8(%r14), %rax
xorl %ebp, %ebp
cmpq 0x8(%rbx), %rax
sete %bpl
jmp 0x2eed
// File: /workspace/github_cpp_makefile_star2_O1/corecodec[P]coremake/coremake.c
// Function: itemcond_reduce
void itemcond_reduce(itemcond* cond)
{
    if (cond->func == COND_OR)
    {
        itemcond_reduce(cond->a);
        itemcond_reduce(cond->b);
        if (cond->a->value)
        {
            if (itemcond_same(cond->a,cond->b))
            {
                cond->func = COND_GET;
                cond->value = cond->a->value;
            }
        }
        if (cond->a->func == COND_GET && itemcond_contains(cond->b,cond->a->value))
        {
            cond->func = COND_GET;
            cond->value = cond->a->value;
        }
        if (cond->b->func == COND_GET && itemcond_contains(cond->a,cond->b->value))
        {
            cond->func = COND_GET;
            cond->value = cond->b->value;
        }
    }
    else
    if (cond->func == COND_AND)
    {
        itemcond_reduce(cond->a);
        itemcond_reduce(cond->b);
        if (cond->a->value)
        {
            if (itemcond_same(cond->a,cond->b))
            {
                cond->func = COND_GET;
                cond->value = cond->a->value;
            }
        }
    }
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rdi, %rbx
movl 0x4(%rdi), %eax
cmpl $0x2, %eax
je 0x2fbd
cmpl $0x1, %eax
jne 0x2ff4
movq 0x10(%rbx), %rdi
callq 0x2f33
movq 0x18(%rbx), %rdi
callq 0x2f33
movq 0x10(%rbx), %r14
movq 0x8(%r14), %r15
testq %r15, %r15
je 0x2f86
movq 0x18(%rbx), %rsi
movq %r14, %rdi
callq 0x2e60
testl %eax, %eax
je 0x2f86
movl $0x0, 0x4(%rbx)
movq %r15, 0x8(%rbx)
cmpl $0x0, 0x4(%r14)
je 0x2ffa
movq 0x18(%rbx), %rax
cmpl $0x0, 0x4(%rax)
jne 0x2ff4
movq 0x8(%rax), %r15
testq %r15, %r15
je 0x2ff4
cmpl $0x2, 0x4(%r14)
jne 0x2ff4
movq 0x10(%r14), %rax
cmpq %r15, 0x8(%rax)
je 0x2fe9
movq 0x18(%r14), %rax
cmpq %r15, 0x8(%rax)
jne 0x2ff4
jmp 0x2fe9
movq 0x10(%rbx), %rdi
callq 0x2f33
movq 0x18(%rbx), %rdi
callq 0x2f33
movq 0x10(%rbx), %rdi
movq 0x8(%rdi), %r15
testq %r15, %r15
je 0x2ff4
movq 0x18(%rbx), %rsi
callq 0x2e60
testl %eax, %eax
je 0x2ff4
movl $0x0, 0x4(%rbx)
movq %r15, 0x8(%rbx)
popq %rbx
popq %r14
popq %r15
retq
movq 0x8(%r14), %rax
testq %rax, %rax
je 0x2f8d
movq 0x18(%rbx), %rcx
cmpl $0x2, 0x4(%rcx)
jne 0x2f8d
movq 0x10(%rcx), %rdx
cmpq %rax, 0x8(%rdx)
je 0x3025
movq 0x18(%rcx), %rcx
cmpq %rax, 0x8(%rcx)
jne 0x2f8d
movl $0x0, 0x4(%rbx)
movq %rax, 0x8(%rbx)
jmp 0x2f8d
// File: /workspace/github_cpp_makefile_star2_O1/corecodec[P]coremake/coremake.c
// Function: itemcond_eval
int itemcond_eval(itemcond* p)
{
	switch (p->func)
	{
	case COND_GET:
		if (!(p->value->flags & FLAG_PROCESSED))
			preprocess_condeval(p->value);
		return (p->value->flags & FLAG_DEFINED)==FLAG_DEFINED;
	case COND_AND:
		return itemcond_eval(p->a) && itemcond_eval(p->b);
	case COND_OR:
		return itemcond_eval(p->a) || itemcond_eval(p->b);
	case COND_NOT:
		return !itemcond_eval(p->a);
	case COND_0:
        return 0;
	case COND_1:
        return 1;
	default:
		return 1;
	}
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %r14
xorl %ebx, %ebx
leaq 0xef5e(%rip), %r15      # 0x12004
xorl %ebp, %ebp
movl 0x4(%r14), %eax
cmpq $0x5, %rax
ja 0x30e6
movslq (%r15,%rax,4), %rax
addq %r15, %rax
jmpq *%rax
movq 0x10(%r14), %rdi
callq 0x3093
testl %eax, %eax
je 0x30d7
jmp 0x30e6
movq 0x10(%r14), %rdi
callq 0x3093
testl %eax, %eax
je 0x3109
movq 0x18(%r14), %r14
jmp 0x30a8
movq 0x10(%r14), %r14
xorl $0x1, %ebx
jmp 0x30a8
movl $0x1, %ebp
jmp 0x3109
movq 0x8(%r14), %rdi
testb $-0x80, 0x30(%rdi)
jne 0x30fc
callq 0x3118
movq 0x8(%r14), %rax
movl 0x30(%rax), %ebp
shrl $0x5, %ebp
andl $0x1, %ebp
xorl %ebp, %ebx
movl %ebx, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O1/corecodec[P]coremake/coremake.c
// Function: preprocess_condeval
void preprocess_condeval(item* p)
{
	item** child;

	p->flags |= FLAG_PROCESSED;

	if (p->cond)
	{
		if (!itemcond_eval(p->cond))
			preprocess_setremoved(p);
	}

	if (!(p->flags & FLAG_REMOVED))
		for (child=p->child;child!=p->childend;++child)
			preprocess_condeval(*child);
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
orb $-0x80, 0x30(%rdi)
movq 0x8(%rdi), %rdi
testq %rdi, %rdi
je 0x313d
callq 0x3093
testl %eax, %eax
jne 0x313d
movq %rbx, %rdi
callq 0x5e49
testb $0x40, 0x30(%rbx)
jne 0x315b
movq 0x18(%rbx), %r14
cmpq 0x20(%rbx), %r14
je 0x315b
movq (%r14), %rdi
callq 0x3118
addq $0x8, %r14
jmp 0x3147
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_cpp_makefile_star2_O1/corecodec[P]coremake/coremake.c
// Function: itemcond_and
itemcond* itemcond_and(itemcond* p,itemcond* cond)
{
	if (cond)
	{
		if (p)
		{
			itemcond* v = itemcond_new(COND_AND,NULL);
			v->a = itemcond_dup(cond);
			v->b = p;
			p = v;
		}
		else
			p = itemcond_dup(cond);
	}
	return p;
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %r14
testq %rsi, %rsi
je 0x31a5
movq %rsi, %rbx
testq %r14, %r14
je 0x31aa
movl $0x20, %edi
callq 0x250a
movabsq $0x200000001, %rcx      # imm = 0x200000001
movq %rcx, (%rax)
movq $0x0, 0x8(%rax)
incl (%rbx)
movq %rbx, 0x10(%rax)
movq %r14, 0x18(%rax)
movq %rax, %rbx
jmp 0x31ac
movq %r14, %rbx
jmp 0x31ac
incl (%rbx)
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_cpp_makefile_star2_O1/corecodec[P]coremake/coremake.c
// Function: itemcond_or
itemcond* itemcond_or(itemcond* p,itemcond* cond)
{
	if (cond && p)
	{
		itemcond* v = itemcond_new(COND_OR,NULL);
		v->a = itemcond_dup(cond);
		v->b = p;
		p = v;
	}
	else
	{
		itemcond_delete(p);
		p = NULL;
	}
	return p;
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
testq %rsi, %rsi
sete %al
testq %rdi, %rdi
sete %cl
orb %al, %cl
jne 0x31fd
movq %rsi, %r14
movl $0x20, %edi
callq 0x250a
movabsq $0x100000001, %rcx      # imm = 0x100000001
movq %rcx, (%rax)
movq $0x0, 0x8(%rax)
incl (%r14)
movq %r14, 0x10(%rax)
movq %rbx, 0x18(%rax)
jmp 0x3207
movq %rbx, %rdi
callq 0x2d76
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_cpp_makefile_star2_O1/corecodec[P]coremake/coremake.c
// Function: item_getmerge
item* item_getmerge(item* p,const item* child,int removed,int *exists)
{
    item* dup;
	*exists = item_find(p,child->value) != NULL;
	dup = item_get(p,child->value,(child->flags & FLAG_DEFINED)==FLAG_DEFINED);
    if (((child->flags & FLAG_REMOVED) || removed) && (!*exists || (dup->flags & FLAG_REMOVED)))
        dup->flags |= FLAG_REMOVED;
    else
        dup->flags &= ~FLAG_REMOVED;
    dup->flags |= (child->flags & ~FLAG_REMOVED);
    return dup;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movq %rcx, %r14
movl %edx, %ebp
movq %rsi, %rbx
movq %rdi, %r15
movq (%rsi), %r12
movq %r12, %rsi
callq 0x26b0
xorl %ecx, %ecx
testq %rax, %rax
setne %cl
movl %ecx, (%r14)
movl 0x30(%rbx), %edx
shrl $0x5, %edx
andl $0x1, %edx
movq %r15, %rdi
movq %r12, %rsi
callq 0x2745
movl 0x30(%rbx), %ecx
andl $0x40, %ecx
orl %ebp, %ecx
je 0x3262
cmpl $0x0, (%r14)
je 0x3268
testb $0x40, 0x30(%rax)
jne 0x3268
andb $-0x41, 0x30(%rax)
jmp 0x326c
orb $0x40, 0x30(%rax)
movl 0x30(%rbx), %ecx
andl $-0x41, %ecx
orl %ecx, 0x30(%rax)
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O1/corecodec[P]coremake/coremake.c
// Function: item_merge2
void item_merge2(item* p,item* group,itemcond* cond0,int removed,int exists)
{
	if (group)
	{
		item** child;
		itemcond* cond = itemcond_and(itemcond_dup(group->cond),cond0);

		for (child = group->child;child != group->childend;++child)
		{
			int child_exists;
			item* dup = item_getmerge(p,*child,removed,&child_exists);
			item_merge2(dup,*child,cond,removed,child_exists);
		}

		if (!item_childcount(group) || (p->flags & FLAG_ATTRIB))
		{
			if (exists)
				p->cond = itemcond_or(p->cond,cond);
			else
			{
				itemcond_delete(p->cond);
				p->cond = itemcond_dup(cond);
			}
		}
		itemcond_delete(cond);
	}
}

// Assembly:
testq %rsi, %rsi
je 0x331d
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movl %ecx, %r12d
movq %rsi, %r15
movq %rdi, %rbx
movl %r8d, (%rsp)
movq 0x8(%rsi), %rdi
testq %rdi, %rdi
je 0x32aa
incl (%rdi)
movq %rdx, %rsi
callq 0x3163
movq %rax, %r14
movq 0x18(%r15), %rbp
movq 0x20(%r15), %rax
cmpq %rax, %rbp
je 0x32fd
leaq 0x4(%rsp), %r13
movq (%rbp), %rsi
movq %rbx, %rdi
movl %r12d, %edx
movq %r13, %rcx
callq 0x320f
movq (%rbp), %rsi
movl 0x4(%rsp), %r8d
movq %rax, %rdi
movq %r14, %rdx
movl %r12d, %ecx
callq 0x327e
addq $0x8, %rbp
movq 0x20(%r15), %rax
cmpq %rax, %rbp
jne 0x32c7
cmpq 0x18(%r15), %rax
je 0x3309
testb $0x1, 0x31(%rbx)
je 0x3335
movq 0x8(%rbx), %rdi
cmpl $0x0, (%rsp)
je 0x331e
movq %r14, %rsi
callq 0x31b7
jmp 0x3331
retq
callq 0x2d76
movq %r14, %rax
testq %r14, %r14
je 0x3331
incl (%r14)
movq %r14, %rax
movq %rax, 0x8(%rbx)
movq %r14, %rdi
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x2d76
// File: /workspace/github_cpp_makefile_star2_O1/corecodec[P]coremake/coremake.c
// Function: item_merge
void item_merge(item* p,item* group,item* plus)
{
	if (group)
	{
		int removed=0;
		item* i;
		itemcond* cond = NULL;
		for (i=group->parent;i;i=i->parent)
			cond = itemcond_and(cond,i->cond);
		if (plus)
		{
			removed = (plus->flags & FLAG_REMOVED)==FLAG_REMOVED;
			cond = itemcond_and(cond,plus->cond);
		}
		item_merge2(p,group,cond,removed,1);
		itemcond_delete(cond);
	}
}

// Assembly:
testq %rsi, %rsi
je 0x33d9
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rdx, %r13
movq %rsi, %rbx
movq %rdi, %r14
movq 0x10(%rsi), %rbp
xorl %r15d, %r15d
xorl %r12d, %r12d
testq %rbp, %rbp
je 0x338c
movq 0x8(%rbp), %rsi
movq %r12, %rdi
callq 0x3163
movq %rax, %r12
movq 0x10(%rbp), %rbp
jmp 0x3372
testq %r13, %r13
je 0x33ac
movl 0x30(%r13), %r15d
shrl $0x6, %r15d
andl $0x1, %r15d
movq 0x8(%r13), %rsi
movq %r12, %rdi
callq 0x3163
movq %rax, %r12
movq %r14, %rdi
movq %rbx, %rsi
movq %r12, %rdx
movl %r15d, %ecx
movl $0x1, %r8d
callq 0x327e
movq %r12, %rdi
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x2d76
retq
// File: /workspace/github_cpp_makefile_star2_O1/corecodec[P]coremake/coremake.c
// Function: reader_init
void reader_init(reader *p)
{
	memset(p,0,sizeof(reader));
    p->filename = (char*)malloc(MAX_PATH);
    p->line = (char*)malloc(MAX_LINE);
    p->token = (char*)malloc(MAX_LINE);
    memset(p->filename,0,MAX_PATH);
    memset(p->line,0,MAX_LINE);
    memset(p->token,0,MAX_LINE);
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rdi, %rbx
xorps %xmm0, %xmm0
movups %xmm0, 0x30(%rdi)
movups %xmm0, 0x20(%rdi)
movups %xmm0, 0x10(%rdi)
movups %xmm0, (%rdi)
movl $0x400, %edi            # imm = 0x400
callq 0x2260
movq %rax, %r14
movq %rax, 0x38(%rbx)
movl $0x2000, %edi           # imm = 0x2000
callq 0x2260
movq %rax, %r15
movq %rax, 0x28(%rbx)
movl $0x2000, %edi           # imm = 0x2000
callq 0x2260
movq %rax, %r12
movq %rax, 0x30(%rbx)
movl $0x400, %edx            # imm = 0x400
movq %r14, %rdi
xorl %esi, %esi
callq 0x2180
movl $0x2000, %edx           # imm = 0x2000
movq %r15, %rdi
xorl %esi, %esi
callq 0x2180
movl $0x2000, %edx           # imm = 0x2000
movq %r12, %rdi
xorl %esi, %esi
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
jmp 0x2180
// File: /workspace/github_cpp_makefile_star2_O1/corecodec[P]coremake/coremake.c
// Function: reader_save
void reader_save(reader *p,reader* save)
{
	p->r.filepos = ftell(p->r.f);
	memcpy(save,p,sizeof(reader_static));
    save->filename = strdup(p->filename);
    save->line = strdup(p->line);
    save->token = strdup(p->token);
    save->pos = save->line + (p->pos - p->line);
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rsi, %rbx
movq %rdi, %r14
movq (%rdi), %rdi
callq 0x2210
movl %eax, 0x18(%r14)
movups (%r14), %xmm0
movups %xmm0, (%rbx)
movups 0x10(%r14), %xmm0
movups %xmm0, 0x10(%rbx)
movq 0x38(%r14), %rdi
callq 0x2350
movq %rax, 0x38(%rbx)
movq 0x28(%r14), %rdi
callq 0x2350
movq %rax, %r15
movq %rax, 0x28(%rbx)
movq 0x30(%r14), %rdi
callq 0x2350
movq %rax, 0x30(%rbx)
movq 0x20(%r14), %rax
subq 0x28(%r14), %rax
addq %r15, %rax
movq %rax, 0x20(%rbx)
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_cpp_makefile_star2_O1/corecodec[P]coremake/coremake.c
// Function: reader_restore
void reader_restore(reader *p,reader* save)
{
	memcpy(p,save,sizeof(reader_static));
    strcpy(p->filename,save->filename);
    strcpy(p->line,save->line);
    strcpy(p->token,save->token);
    p->pos = p->line + (save->pos - save->line);
	fseek(p->r.f,p->r.filepos,SEEK_SET);
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %r14
movq %rdi, %rbx
movups (%rsi), %xmm0
movups 0x10(%rsi), %xmm1
movups %xmm1, 0x10(%rdi)
movups %xmm0, (%rdi)
movq 0x38(%rdi), %rdi
movq 0x38(%rsi), %rsi
callq 0x20b0
movq 0x28(%rbx), %rdi
movq 0x28(%r14), %rsi
callq 0x20b0
movq 0x30(%rbx), %rdi
movq 0x30(%r14), %rsi
callq 0x20b0
movq 0x20(%r14), %rax
subq 0x28(%r14), %rax
addq 0x28(%rbx), %rax
movq %rax, 0x20(%rbx)
movq (%rbx), %rdi
movslq 0x18(%rbx), %rsi
xorl %edx, %edx
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x22a0
// File: /workspace/github_cpp_makefile_star2_O1/corecodec[P]coremake/coremake.c
// Function: reader_line
int reader_line(reader* p)
{
	size_t i;
    p->line[0] = 0;
	fgets(p->line,MAX_LINE,p->r.f);
	if (feof(p->r.f) && p->line[0]==0)
		return 0;
	i=strlen(p->line);
	while (i && isspace(p->line[--i]))
		p->line[i]=0;
	p->pos = p->line;
	++p->r.no;
	return 1;
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
movq 0x28(%rdi), %rax
movb $0x0, (%rax)
movq (%rdi), %rdx
movq 0x28(%rdi), %rdi
movl $0x2000, %esi           # imm = 0x2000
callq 0x21e0
movq (%rbx), %rdi
callq 0x2220
testl %eax, %eax
je 0x3580
movq 0x28(%rbx), %rax
cmpb $0x0, (%rax)
je 0x35c7
movq 0x28(%rbx), %rdi
callq 0x2120
testq %rax, %rax
je 0x35b5
movq %rax, %r14
callq 0x2370
movq (%rax), %rdx
movq 0x28(%rbx), %rcx
movsbq -0x1(%rcx,%r14), %rsi
testb $0x20, 0x1(%rdx,%rsi,2)
je 0x35b5
movb $0x0, -0x1(%rcx,%r14)
decq %r14
jne 0x3596
movq 0x28(%rbx), %rax
movq %rax, 0x20(%rbx)
incl 0xc(%rbx)
movl $0x1, %eax
jmp 0x35c9
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_cpp_makefile_star2_O1/corecodec[P]coremake/coremake.c
// Function: strins
char* strins(char* s,const char* begin,const char* end)
{
	size_t n = end?end-begin:strlen(begin);
	memmove(s+n,s,strlen(s)+1);
	memcpy(s,begin,n);
	return s;
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq %rdi, %r14
testq %rdx, %rdx
je 0x35ec
movq %rdx, %r15
subq %rbx, %r15
jmp 0x35f7
movq %rbx, %rdi
callq 0x2120
movq %rax, %r15
leaq (%r14,%r15), %r12
movq %r14, %rdi
callq 0x2120
leaq 0x1(%rax), %rdx
movq %r12, %rdi
movq %r14, %rsi
callq 0x22d0
movq %r14, %rdi
movq %rbx, %rsi
movq %r15, %rdx
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
jmp 0x2240
// File: /workspace/github_cpp_makefile_star2_O1/corecodec[P]coremake/coremake.c
// Function: reader_comment
void reader_comment(reader* p)
{
	char* s = p->line;
	while (*s)
	{
		if (p->r.comment)
		{
			char* s0 = s;
			for (;*s;++s)
				if (s[0]=='*' && s[1]=='/')
				{
					s = strdel(s0,s);
					p->r.comment = 0;
					break;
				}

			if (p->r.comment)
			{
				s = s0;
				*s = 0;
			}
		}
		else
		{
			for (;*s;++s)
			{
				if (s[0]=='/' && s[1]=='*')
				{
					s = strdel(s,s+2);
					p->r.comment = 1;
					break;
				}
				if (s[0]=='/' && s[1]=='/')
				{
					*s = 0;
					break;
				}
			}
		}
	}
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq 0x28(%rdi), %r15
cmpb $0x0, (%r15)
je 0x371b
movq %rdi, %rbx
movq %r15, %r14
cmpl $0x0, 0x8(%rbx)
je 0x368d
movzbl (%r14), %eax
cmpl $0x2a, %eax
je 0x3681
testl %eax, %eax
jne 0x3688
jmp 0x36d7
cmpb $0x2f, 0x1(%r14)
je 0x36b6
incq %r14
jmp 0x3672
movq %r15, %r14
movzbl (%r14), %eax
cmpl $0x2f, %eax
je 0x369f
testl %eax, %eax
jne 0x36b1
jmp 0x370e
cmpb $0x2a, 0x1(%r14)
je 0x36e6
cmpb $0x2f, %al
jne 0x36b1
cmpb $0x2f, 0x1(%r14)
je 0x370a
incq %r14
jmp 0x3690
movq %r14, %rdi
callq 0x2120
leaq 0x1(%rax), %rdx
movq %r15, %rdi
movq %r14, %rsi
callq 0x22d0
movl $0x0, 0x8(%rbx)
movq %r15, %r14
cmpl $0x0, 0x8(%rbx)
je 0x370e
movb $0x0, (%r15)
movq %r15, %r14
jmp 0x370e
leaq 0x2(%r14), %r15
movq %r15, %rdi
callq 0x2120
leaq 0x1(%rax), %rdx
movq %r14, %rdi
movq %r15, %rsi
callq 0x22d0
movl $0x1, 0x8(%rbx)
jmp 0x370e
movb $0x0, (%r14)
cmpb $0x0, (%r14)
movq %r14, %r15
jne 0x366c
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_cpp_makefile_star2_O1/corecodec[P]coremake/coremake.c
// Function: reader_istoken
int reader_istoken(reader* p,const char* token)
{
	if (!(p->r.flags & FLAG_READY) && !reader_read(p))
		return 0;

	if (stricmp(p->token,token)!=0)
		return 0;

	p->r.flags &= ~FLAG_READY;
	return 1;
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %r14
movq %rdi, %rbx
testb $0x2, 0x11(%rdi)
jne 0x39f8
movq %rbx, %rdi
callq 0x3784
testl %eax, %eax
je 0x3a08
movq 0x30(%rbx), %rdi
movq %r14, %rsi
callq 0x2070
testl %eax, %eax
je 0x3a0c
xorl %eax, %eax
jmp 0x3a15
andb $-0x3, 0x11(%rbx)
movl $0x1, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_cpp_makefile_star2_O1/corecodec[P]coremake/coremake.c
// Function: reader_tokenline
int reader_tokenline(reader* p,int onespace)
{
	char* s = p->pos;

	assert(!(p->r.flags & FLAG_READY));

    if (onespace >= 0)
    {
	    while (*s && isspace(*s))
	    {
		    ++s;
		    if (onespace) break;
	    }
    }

	strcpy(p->token,s);
	p->pos = s + strlen(s);

	return p->token[0]!=0;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
testb $0x2, 0x11(%rdi)
jne 0x3b04
movl %esi, %ebp
movq %rdi, %rbx
movq 0x20(%rdi), %r14
testl %esi, %esi
js 0x3ad2
movsbq (%r14), %r15
testq %r15, %r15
je 0x3ad2
callq 0x2370
movq (%rax), %rax
testb $0x20, 0x1(%rax,%r15,2)
je 0x3ad2
incq %r14
testl %ebp, %ebp
je 0x3ab2
movq 0x30(%rbx), %rdi
movq %r14, %rsi
callq 0x20b0
movq %r14, %rdi
callq 0x2120
addq %r14, %rax
movq %rax, 0x20(%rbx)
movq 0x30(%rbx), %rcx
xorl %eax, %eax
cmpb $0x0, (%rcx)
setne %al
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
leaq 0xe647(%rip), %rdi      # 0x12152
leaq 0xe594(%rip), %rsi      # 0x120a6
leaq 0xe654(%rip), %rcx      # 0x1216d
movl $0x3d8, %edx            # imm = 0x3D8
callq 0x2160
// File: /workspace/github_cpp_makefile_star2_O1/corecodec[P]coremake/coremake.c
// Function: truncfilefourcc
void truncfilefourcc(char* path)
{
	char* i = getfilename(path);
	memmove(path,i,strlen(i)+1);
    path[4] = 0;
    while (strlen(path)<4)
        strcat(path,"_");
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
movl $0x2f, %esi
callq 0x2150
leaq 0x1(%rax), %r14
testq %rax, %rax
cmoveq %rbx, %r14
movq %r14, %rdi
callq 0x2120
leaq 0x1(%rax), %rdx
movq %rbx, %rdi
movq %r14, %rsi
callq 0x22d0
movb $0x0, 0x4(%rbx)
movq %rbx, %rdi
callq 0x2120
cmpq $0x3, %rax
ja 0x3cd4
movq %rbx, %rdi
callq 0x2120
movw $0x5f, (%rbx,%rax)
movq %rbx, %rdi
callq 0x2120
cmpq $0x4, %rax
jb 0x3cb8
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_cpp_makefile_star2_O1/corecodec[P]coremake/coremake.c
// Function: truncfileext
void truncfileext(char* path)
{
	char* i = getfilename(path);
	char* ext = strrchr(i,'.');
	if (ext)
		memmove(path,ext+1,strlen(ext+1)+1);
	else
		path[0]=0;
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
movl $0x2f, %esi
callq 0x2150
leaq 0x1(%rax), %rdi
testq %rax, %rax
cmoveq %rbx, %rdi
movl $0x2e, %esi
callq 0x2150
testq %rax, %rax
je 0x3d2b
movq %rax, %r14
incq %r14
movq %r14, %rdi
callq 0x2120
leaq 0x1(%rax), %rdx
movq %rbx, %rdi
movq %r14, %rsi
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x22d0
movb $0x0, (%rbx)
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_cpp_makefile_star2_O1/corecodec[P]coremake/coremake.c
// Function: truncfourcc
void truncfourcc(char* s)
{
	size_t len = strlen(s);
	if (len>2 && s[0]=='\'' && s[len-1]=='\'')
	{
		strdel(s+len-1,s+len);
		strdel(s,s+1);
	}
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rdi, %rbx
callq 0x2120
cmpq $0x3, %rax
jb 0x3d97
cmpb $0x27, (%rbx)
jne 0x3d97
cmpb $0x27, -0x1(%rbx,%rax)
jne 0x3d97
leaq (%rbx,%rax), %r14
leaq (%rbx,%rax), %r15
decq %r15
movq %r14, %rdi
callq 0x2120
leaq 0x1(%rax), %rdx
movq %r15, %rdi
movq %r14, %rsi
callq 0x22d0
leaq 0x1(%rbx), %r14
movq %r14, %rdi
callq 0x2120
leaq 0x1(%rax), %rdx
movq %rbx, %rdi
movq %r14, %rsi
popq %rbx
popq %r14
popq %r15
jmp 0x22d0
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_cpp_makefile_star2_O1/corecodec[P]coremake/coremake.c
// Function: truncfilepath
void truncfilepath(char* path,int delend)
{
	char* i = getfilename(path);
	if (i) *i=0;
	if (delend)
	{
		delendpath(path);
		if (!path[0])
			strcpy(path,".");
	}
	else
		addendpath(path);
}

// Assembly:
pushq %rbp
pushq %rbx
pushq %rax
movl %esi, %ebp
movq %rdi, %rbx
movl $0x2f, %esi
callq 0x2150
leaq 0x1(%rax), %rcx
testq %rax, %rax
cmoveq %rbx, %rcx
testq %rcx, %rcx
je 0x3e57
movb $0x0, (%rcx)
testl %ebp, %ebp
je 0x3e85
cmpb $0x0, (%rbx)
je 0x3e74
movq %rbx, %rdi
callq 0x2120
cmpb $0x2f, -0x1(%rbx,%rax)
jne 0x3e74
movb $0x0, -0x1(%rbx,%rax)
cmpb $0x0, (%rbx)
jne 0x3e7e
movw $0x2e, (%rbx)
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
movq %rbx, %rdi
addq $0x8, %rsp
popq %rbx
popq %rbp
jmp 0x3df1
// File: /workspace/github_cpp_makefile_star2_O1/corecodec[P]coremake/coremake.c
// Function: truncfileupper
void truncfileupper(char* path)
{
    delendpath(path);
    truncfilepath(path,0);
    if (!path[0])
        strcpy(path,"./");
}

// Assembly:
pushq %rbx
movq %rdi, %rbx
cmpb $0x0, (%rdi)
je 0x3eb0
movq %rbx, %rdi
callq 0x2120
cmpb $0x2f, -0x1(%rbx,%rax)
jne 0x3eb0
movb $0x0, -0x1(%rbx,%rax)
movq %rbx, %rdi
xorl %esi, %esi
callq 0x3e32
cmpb $0x0, (%rbx)
jne 0x3ec8
movb $0x0, 0x2(%rbx)
movw $0x2f2e, (%rbx)         # imm = 0x2F2E
popq %rbx
retq
// File: /workspace/github_cpp_makefile_star2_O1/corecodec[P]coremake/coremake.c
// Function: reversestr
void reversestr(char *value)
{
    char tmpstr[MAX_LINE];
    size_t i,len=strlen(value);
    for (i=0;i<len;++i)
        tmpstr[i]=value[len-i-1];
    memcpy(value,tmpstr,len);
    value[len]=0;
}

// Assembly:
pushq %r14
pushq %rbx
subq $0x2008, %rsp           # imm = 0x2008
movq %rdi, %rbx
callq 0x2120
movq %rax, %r14
testq %rax, %rax
je 0x3f26
movq %rsp, %rax
movq %r14, %rcx
movb -0x1(%rbx,%rcx), %dl
movb %dl, (%rax)
incq %rax
decq %rcx
jne 0x3f18
movq %rsp, %rsi
movq %rbx, %rdi
movq %r14, %rdx
callq 0x2240
movb $0x0, (%rbx,%r14)
addq $0x2008, %rsp           # imm = 0x2008
popq %rbx
popq %r14
retq
// File: /workspace/github_cpp_makefile_star2_O1/corecodec[P]coremake/coremake.c
// Function: escapestr
void escapestr(char *value)
{
    char *s;
    s = strchr(value,'\\');
    while (s)
    {
        memmove(s+1,s,strlen(s)+1);
        value[s-value] = '\\';
        s = strchr(s+2,'\\');
    }
    s = strchr(value,'"');
    while (s)
    {
        memmove(s+1,s,strlen(s)+1);
        value[s-value] = '\\';
        s = strchr(s+2,'"');
    }
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rdi, %rbx
movl $0x5c, %esi
callq 0x2130
testq %rax, %rax
je 0x3f96
movq %rax, %r14
leaq 0x1(%r14), %r15
movq %r14, %rdi
callq 0x2120
leaq 0x1(%rax), %rdx
movq %r15, %rdi
movq %r14, %rsi
callq 0x22d0
movb $0x5c, (%r14)
addq $0x2, %r14
movq %r14, %rdi
movl $0x5c, %esi
callq 0x2130
movq %rax, %r14
testq %rax, %rax
jne 0x3f5e
movq %rbx, %rdi
movl $0x22, %esi
callq 0x2130
testq %rax, %rax
je 0x3fe2
movq %rax, %rbx
leaq 0x1(%rbx), %r14
movq %rbx, %rdi
callq 0x2120
leaq 0x1(%rax), %rdx
movq %r14, %rdi
movq %rbx, %rsi
callq 0x22d0
movb $0x5c, (%rbx)
addq $0x2, %rbx
movq %rbx, %rdi
movl $0x22, %esi
callq 0x2130
movq %rax, %rbx
testq %rax, %rax
jne 0x3fab
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_cpp_makefile_star2_O1/corecodec[P]coremake/coremake.c
// Function: simplifypath
void simplifypath(char* path, int head)
{
    char* s;
    for (s=path;*s;++s)
    {
        if (strncmp(s,"/../",4)==0 && s!=path)
        {
            char* end = s+4;
            do
            {
				if (s[-1] == '/' || s[-1] == '\\')
					break;
			} while (--s!=path);
            s = strdel(s,end);
            if (s != path)
                --s;
            --s;
        }
        if (strncmp(s,"/./",3)==0 && s!=path)
            memmove(s+1,s+3,strlen(s+3)+1);
        if (strncmp(s,"/.",3)==0 && s!=path)
            s[1]=0;
    }
    if (head)
    {
        while (path[0] == '.' && path[1] == '/')
            memmove(path,path+2,strlen(path+2));
    }
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movl %esi, 0x4(%rsp)
movq %rdi, %rbx
cmpb $0x0, (%rdi)
je 0x4485
leaq 0xee01(%rip), %r14      # 0x131a1
leaq 0xedff(%rip), %r15      # 0x131a6
leaq 0xedfc(%rip), %r12      # 0x131aa
movq %rbx, %r13
movl $0x4, %edx
movq %r13, %rdi
movq %r14, %rsi
callq 0x20a0
cmpq %rbx, %r13
je 0x440d
testl %eax, %eax
jne 0x440d
leaq 0x4(%r13), %rbp
movzbl -0x1(%r13), %eax
cmpl $0x2f, %eax
je 0x43e8
cmpl $0x5c, %eax
je 0x43e8
decq %r13
cmpq %rbx, %r13
jne 0x43ce
movq %rbx, %r13
movq %rbp, %rdi
callq 0x2120
leaq 0x1(%rax), %rdx
movq %r13, %rdi
movq %rbp, %rsi
callq 0x22d0
xorl %eax, %eax
cmpq %rbx, %r13
setne %al
notq %rax
addq %rax, %r13
movl $0x3, %edx
movq %r13, %rdi
movq %r15, %rsi
callq 0x20a0
cmpq %rbx, %r13
je 0x4458
testl %eax, %eax
jne 0x4458
leaq 0x1(%r13), %rbp
movq %r15, %r12
movq %r14, %r15
leaq 0x3(%r13), %r14
movq %r14, %rdi
callq 0x2120
leaq 0x1(%rax), %rdx
movq %rbp, %rdi
movq %r14, %rsi
movq %r15, %r14
movq %r12, %r15
leaq 0xed57(%rip), %r12      # 0x131aa
callq 0x22d0
movl $0x3, %edx
movq %r13, %rdi
movq %r12, %rsi
callq 0x20a0
cmpq %rbx, %r13
je 0x4476
testl %eax, %eax
jne 0x4476
movb $0x0, 0x1(%r13)
cmpb $0x0, 0x1(%r13)
leaq 0x1(%r13), %r13
jne 0x43b1
cmpl $0x0, 0x4(%rsp)
je 0x44b6
cmpb $0x2e, (%rbx)
jne 0x44b6
leaq 0x2(%rbx), %r14
cmpb $0x2f, 0x1(%rbx)
jne 0x44b6
movq %r14, %rdi
callq 0x2120
movq %rbx, %rdi
movq %r14, %rsi
movq %rax, %rdx
callq 0x22d0
cmpb $0x2e, (%rbx)
je 0x4495
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O1/corecodec[P]coremake/coremake.c
// Function: strip_path_abs
void strip_path_abs(char *path, int flags)
{
    assert((flags & FLAG_PATH_MASK) != FLAG_PATH_NOT_PATH);
    switch (flags & FLAG_PATH_MASK)
    {
    case FLAG_PATH_GENERATED:
        if (proj_root_len && strstr(path,proj_root)==path)
            memmove(path,path+proj_root_len,strlen(path+proj_root_len)+1);
        break;
    case FLAG_PATH_COREMAKE:
        if (coremake_root_len && strstr(path,coremake_root)==path)
           memmove(path,path+coremake_root_len,strlen(path+coremake_root_len)+1);
        break;
    case FLAG_PATH_SOURCE:
        if (src_root_len && strstr(path,src_root)==path)
            memmove(path,path+src_root_len,strlen(path+src_root_len)+1);
        break;
    case FLAG_PATH_SYSTEM: // do nothing
        break;
    default: assert(0);
    }
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
andl $0xf, %esi
cmpl $0x4, %esi
ja 0x4584
movq %rdi, %rbx
leaq 0xdb3c(%rip), %rax      # 0x1201c
movslq (%rax,%rsi,4), %rcx
addq %rax, %rcx
jmpq *%rcx
movq 0x13d10(%rip), %r14     # 0x18200
testq %r14, %r14
je 0x4540
leaq 0x13104(%rip), %r15     # 0x17600
jmp 0x4526
movq 0x13d0b(%rip), %r14     # 0x18210
testq %r14, %r14
je 0x4540
leaq 0x138ef(%rip), %r15     # 0x17e00
jmp 0x4526
movq 0x13cee(%rip), %r14     # 0x18208
testq %r14, %r14
je 0x4540
leaq 0x134da(%rip), %r15     # 0x17a00
movq %r15, %rdi
callq 0x2120
movq %rbx, %rdi
movq %r15, %rsi
movq %rax, %rdx
callq 0x20a0
testl %eax, %eax
je 0x4546
popq %rbx
popq %r14
popq %r15
retq
addq %rbx, %r14
movq %r14, %rdi
callq 0x2120
leaq 0x1(%rax), %rdx
movq %rbx, %rdi
movq %r14, %rsi
popq %rbx
popq %r14
popq %r15
jmp 0x22d0
leaq 0xdc6f(%rip), %rdi      # 0x121db
leaq 0xdb33(%rip), %rsi      # 0x120a6
leaq 0xdc90(%rip), %rcx      # 0x1220a
movl $0x4e0, %edx            # imm = 0x4E0
callq 0x2160
leaq 0xeaec(%rip), %rdi      # 0x13077
leaq 0xdb14(%rip), %rsi      # 0x120a6
leaq 0xdc71(%rip), %rcx      # 0x1220a
movl $0x4f1, %edx            # imm = 0x4F1
callq 0x2160
// File: /workspace/github_cpp_makefile_star2_O1/corecodec[P]coremake/coremake.c
// Function: load_cond2
itemcond* load_cond2(reader* file,item* config)
{
	itemcond* p;
	if (reader_istoken(file,"("))
	{
		p = load_cond0(file,config);
		if (!reader_istoken(file,")"))
			syntax(file);
	}
	else
	{
		if (reader_istoken(file,")"))
			syntax(file);
		reader_name(file);
		p = itemcond_new(COND_GET,item_get(config,file->token,0));
	}
	return p;
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %r14
movq %rdi, %rbx
leaq 0xdd8a(%rip), %rsi      # 0x12549
callq 0x39dc
testl %eax, %eax
je 0x47eb
movq %rbx, %rdi
movq %r14, %rsi
callq 0x485d
movq %rax, %r14
leaq 0xea69(%rip), %rsi      # 0x13246
movq %rbx, %rdi
callq 0x39dc
testl %eax, %eax
jne 0x482f
jmp 0x483a
leaq 0xea54(%rip), %rsi      # 0x13246
movq %rbx, %rdi
callq 0x39dc
testl %eax, %eax
jne 0x483a
movq %rbx, %rdi
callq 0x3b62
movq 0x30(%rbx), %rsi
movq %r14, %rdi
xorl %edx, %edx
callq 0x2745
movq %rax, %rbx
movl $0x20, %edi
callq 0x250a
movq %rax, %r14
movq $0x1, (%rax)
movq %rbx, 0x8(%rax)
movq %r14, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
movq 0x38(%rbx), %rsi
movl 0xc(%rbx), %edx
movq 0x28(%rbx), %rcx
leaq 0xd824(%rip), %rdi      # 0x12070
xorl %eax, %eax
callq 0x2140
movl $0x1, %edi
callq 0x2330
// File: /workspace/github_cpp_makefile_star2_O1/corecodec[P]coremake/coremake.c
// Function: load_cond0
itemcond* load_cond0(reader* file,item* config)
{
	itemcond* a = load_cond1(file,config);
	if (reader_istoken(file,"||"))
	{
		itemcond* p = itemcond_new(COND_OR,NULL);
		p->a = a;
		p->b = load_cond0(file,config);
		return p;
	}
	if (reader_istoken(file,"&&"))
	{
		itemcond* p = itemcond_new(COND_AND,NULL);
		p->a = a;
		p->b = load_cond0(file,config);
		return p;
	}
	return a;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movq %rsi, %rbx
movq %rdi, %r14
callq 0x48e4
movq %rax, %r15
leaq 0xda08(%rip), %rsi      # 0x12282
movq %r14, %rdi
callq 0x39dc
movl $0x1, %ebp
testl %eax, %eax
jne 0x48a3
leaq 0xd9f3(%rip), %rsi      # 0x12285
movq %r14, %rdi
callq 0x39dc
movl $0x2, %ebp
testl %eax, %eax
je 0x48d8
movl $0x20, %edi
callq 0x250a
movq %rax, %r12
movl $0x1, (%rax)
movl %ebp, 0x4(%rax)
movq $0x0, 0x8(%rax)
movq %r15, 0x10(%rax)
movq %r14, %rdi
movq %rbx, %rsi
callq 0x485d
movq %rax, 0x18(%r12)
movq %r12, %r15
movq %r15, %rax
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O1/corecodec[P]coremake/coremake.c
// Function: load_cond1
itemcond* load_cond1(reader* file,item* config)
{
	if (reader_istoken(file,"!"))
	{
		itemcond* p = itemcond_new(COND_NOT,NULL);
		p->a = load_cond1(file,config);
		return p;
	}
	else
		return load_cond2(file,config);
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rsi, %rbx
movq %rdi, %r14
leaq 0xeb83(%rip), %rsi      # 0x13479
callq 0x39dc
testl %eax, %eax
je 0x4939
movl $0x20, %edi
callq 0x250a
movq %rax, %r15
movabsq $0x300000001, %rax      # imm = 0x300000001
movq %rax, (%r15)
movq $0x0, 0x8(%r15)
movq %r14, %rdi
movq %rbx, %rsi
callq 0x48e4
movq %rax, 0x10(%r15)
movq %r15, %rax
popq %rbx
popq %r14
popq %r15
retq
movq %r14, %rdi
movq %rbx, %rsi
popq %rbx
popq %r14
popq %r15
jmp 0x47ae
// File: /workspace/github_cpp_makefile_star2_O1/corecodec[P]coremake/coremake.c
// Function: load_cond
itemcond* load_cond(item* item, reader* file, int force)
{
	itemcond* p = NULL;
	if (reader_istoken(file,"("))
	{
		p = load_cond0(file,getconfig(item));
		if (!reader_istoken(file,")"))
			syntax(file);
	}
	else
	if (force)
		p = load_cond0(file,getconfig(item));

	return p;
}

// Assembly:
pushq %rbp
pushq %r14
pushq %rbx
movl %edx, %ebp
movq %rsi, %rbx
movq %rdi, %r14
leaq 0xdbed(%rip), %rsi      # 0x12549
movq %rbx, %rdi
callq 0x39dc
testl %eax, %eax
je 0x49ab
movq %r14, %rdi
movq 0x10(%r14), %r14
testq %r14, %r14
jne 0x4968
leaq 0xd756(%rip), %rsi      # 0x120d1
xorl %edx, %edx
callq 0x2745
movq %rbx, %rdi
movq %rax, %rsi
callq 0x485d
movq %rax, %r14
leaq 0xe8af(%rip), %rsi      # 0x13246
movq %rbx, %rdi
callq 0x39dc
testl %eax, %eax
je 0x49dd
movq %r14, %rax
popq %rbx
popq %r14
popq %rbp
retq
testl %ebp, %ebp
je 0x49d8
movq %r14, %rdi
movq 0x10(%r14), %r14
testq %r14, %r14
jne 0x49af
leaq 0xd70f(%rip), %rsi      # 0x120d1
xorl %edx, %edx
callq 0x2745
movq %rbx, %rdi
movq %rax, %rsi
popq %rbx
popq %r14
popq %rbp
jmp 0x485d
xorl %r14d, %r14d
jmp 0x49a3
movq 0x38(%rbx), %rsi
movl 0xc(%rbx), %edx
movq 0x28(%rbx), %rcx
leaq 0xd681(%rip), %rdi      # 0x12070
xorl %eax, %eax
callq 0x2140
movl $0x1, %edi
callq 0x2330