LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_cpp_makefile_star2_O1/corecodec[P]coremake/coremake.c
// Function: load_file
int load_file(item* p,const char* filename, int file_kind, itemcond* cond)
{
	reader r;
    reader_init(&r);
	strcpy(r.filename,filename);
	pathunix(r.filename);
	r.r.f = fopen(filename,"r");
	r.pos = r.line;
	if (r.r.f)
	{
        r.r.filename_kind = file_kind;
		load_item(p,&r,0,cond);
		fclose(r.r.f);
        reader_free(&r);
		return 1;
	}
    reader_free(&r);
	return 0;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x40, %rsp
movq %rcx, %rbx
movl %edx, %ebp
movq %rsi, %r15
movq %rdi, %r14
movq %rsp, %r12
movq %r12, %rdi
callq 0x33da
movq 0x38(%r12), %rdi
movq %r15, %rsi
callq 0x20b0
movq 0x38(%r12), %rax
movzbl (%rax), %ecx
cmpl $0x5c, %ecx
je 0x5b04
testl %ecx, %ecx
jne 0x5b07
jmp 0x5b0c
movb $0x2f, (%rax)
incq %rax
jmp 0x5af6
leaq 0xc85c(%rip), %rsi      # 0x1236f
movq %r15, %rdi
callq 0x22e0
movq %rax, (%rsp)
movq 0x28(%rsp), %rcx
movq %rcx, 0x20(%rsp)
testq %rax, %rax
je 0x5b54
movq %rsp, %r15
movl %ebp, 0x14(%r15)
movq %r14, %rdi
movq %r15, %rsi
xorl %edx, %edx
movq %rbx, %rcx
callq 0x4a00
movq (%r15), %rdi
callq 0x20f0
movl $0x1, %ebx
jmp 0x5b56
xorl %ebx, %ebx
movq 0x38(%rsp), %rdi
callq 0x2050
movq 0x28(%rsp), %rdi
callq 0x2050
movq 0x30(%rsp), %rdi
callq 0x2050
movl %ebx, %eax
addq $0x40, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O1/corecodec[P]coremake/coremake.c
// Function: dumpitem
void dumpitem(item* p,int deep)
{
	item** child;
	printf("%*c%s",deep*2,' ',p->value);
	if (p->cond)
	{
		printf(" (");
		dumpcond(stdout,p->cond,1,COND_GET,NULL,0);
		printf(")");
	}
	printf("\r\n");
	for (child=p->child;child!=p->childend;++child)
		dumpitem(*child,deep+1);
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movl %esi, %ebx
movq %rdi, %r14
leal (%rbx,%rbx), %esi
movq (%rdi), %rcx
leaq 0xc7cc(%rip), %rdi      # 0x12542
movl $0x20, %edx
xorl %eax, %eax
callq 0x2140
cmpq $0x0, 0x8(%r14)
je 0x5dc1
leaq 0xc7b8(%rip), %rdi      # 0x12548
xorl %eax, %eax
callq 0x2140
movq 0x11242(%rip), %rax     # 0x16fe0
movq (%rax), %rdi
movq 0x8(%r14), %rsi
movl $0x1, %edx
xorl %ecx, %ecx
xorl %r8d, %r8d
xorl %r9d, %r9d
callq 0x5b83
movl $0x29, %edi
callq 0x2060
leaq 0xd74f(%rip), %rdi      # 0x13517
callq 0x20d0
movq 0x18(%r14), %r15
cmpq 0x20(%r14), %r15
je 0x5ded
incl %ebx
movq (%r15), %rdi
movl %ebx, %esi
callq 0x5d5f
addq $0x8, %r15
cmpq 0x20(%r14), %r15
jne 0x5dd9
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_cpp_makefile_star2_O1/corecodec[P]coremake/coremake.c
// Function: usage
void usage()
{
	printf("usage: coremake [<options>] <platform>\r\n\r\n");
	printf(" -h : help\r\n");
	printf(" -v : verbose\r\n");
	printf(" -r : root folder (default is current dir)\r\n");
	printf(" -f <file> : specify project file (default is root.proj)\r\n");
	printf(" -d : dump project\r\n");
	printf(" -p : dump project at the end\r\n");
    // TODO: add support for using another config file than config.h
}

// Assembly:
pushq %rax
leaq 0xd6f4(%rip), %rdi      # 0x134ef
callq 0x20d0
leaq 0xd712(%rip), %rdi      # 0x13519
callq 0x20d0
leaq 0xd712(%rip), %rdi      # 0x13525
callq 0x20d0
leaq 0xd715(%rip), %rdi      # 0x13534
callq 0x20d0
leaq 0xd735(%rip), %rdi      # 0x13560
callq 0x20d0
leaq 0xd763(%rip), %rdi      # 0x1359a
callq 0x20d0
leaq 0xd76b(%rip), %rdi      # 0x135ae
popq %rax
jmp 0x20d0
// File: /workspace/github_cpp_makefile_star2_O1/corecodec[P]coremake/coremake.c
// Function: preprocess_setremoved
void preprocess_setremoved(item* p)
{
	item** child;
	p->flags |= FLAG_REMOVED;
	p->flags &= ~FLAG_DEFINED;
	for (child=p->child;child!=p->childend;++child)
		preprocess_setremoved(*child);
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movl 0x30(%rdi), %eax
andl $-0x61, %eax
orl $0x40, %eax
movl %eax, 0x30(%rdi)
movq 0x18(%rdi), %r14
cmpq 0x20(%rdi), %r14
je 0x5e78
movq %rdi, %rbx
movq (%r14), %rdi
callq 0x5e49
addq $0x8, %r14
cmpq 0x20(%rbx), %r14
jne 0x5e66
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_cpp_makefile_star2_O1/corecodec[P]coremake/coremake.c
// Function: preprocess_condstart
void preprocess_condstart(item* p)
{
	item** child;
	p->flags &= ~FLAG_PROCESSED;
	p->flags &= ~FLAG_REMOVED;
	for (child=p->child;child!=p->childend;++child)
		preprocess_condstart(*child);
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
andb $0x3f, 0x30(%rdi)
movq 0x18(%rdi), %r14
cmpq 0x20(%rdi), %r14
je 0x5ea7
movq %rdi, %rbx
movq (%r14), %rdi
callq 0x5e80
addq $0x8, %r14
cmpq 0x20(%rbx), %r14
jne 0x5e95
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_cpp_makefile_star2_O1/corecodec[P]coremake/coremake.c
// Function: preprocess_config
void preprocess_config(item* p)
{
	item** child;
	for (child=p->child;child!=p->childend;++child)
		if (!((*child)->flags & FLAG_DEFINED))
			(*child)->flags |= FLAG_REMOVED;
}

// Assembly:
movq 0x18(%rdi), %rax
movq 0x20(%rdi), %rcx
cmpq %rcx, %rax
je 0x5ed4
movq (%rax), %rdx
movl 0x30(%rdx), %esi
testb $0x20, %sil
jne 0x5ece
orl $0x40, %esi
movl %esi, 0x30(%rdx)
addq $0x8, %rax
jmp 0x5eb7
retq
// File: /workspace/github_cpp_makefile_star2_O1/corecodec[P]coremake/coremake.c
// Function: preprocess_condend
void preprocess_condend(item* p)
{
	item** child;

	if (p->cond)
	{
		itemcond_delete(p->cond);
		p->cond = NULL;
	}

	for (child=p->child;child!=p->childend;++child)
	{
		if ((*child)->flags & FLAG_REMOVED)
		{
			item_delete(*child);
			--child;
		}
		else
			preprocess_condend(*child);
	}
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
movq 0x8(%rdi), %rdi
testq %rdi, %rdi
je 0x5ef2
callq 0x2d76
movq $0x0, 0x8(%rbx)
movq 0x18(%rbx), %r14
cmpq 0x20(%rbx), %r14
je 0x5f1b
movq (%r14), %rdi
testb $0x40, 0x30(%rdi)
jne 0x5f0c
callq 0x5ed5
jmp 0x5f15
callq 0x2da0
addq $-0x8, %r14
addq $0x8, %r14
jmp 0x5ef6
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_cpp_makefile_star2_O1/corecodec[P]coremake/coremake.c
// Function: preprocess_dependency
void preprocess_dependency(item* p)
{
	item** child;
	if (!p) return;
	for (child=p->child;child!=p->childend;++child)
		preprocess_dependency_project(*child);
}

// Assembly:
testq %rdi, %rdi
je 0x616d
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
movq 0x18(%rdi), %r14
cmpq 0x20(%rbx), %r14
je 0x6166
movq (%r14), %rdi
callq 0x5f6f
addq $0x8, %r14
jmp 0x6152
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_cpp_makefile_star2_O1/corecodec[P]coremake/coremake.c
// Function: file_finalize
void file_finalize(char* name)
{
	char tmp[MAX_PATH];
	char* i = strrchr(name,'.');
	if (i && stricmp(i,".tmp")==0)
	{
		FILE* a;
		FILE* b;
		int same=0;

		strcpy(tmp,name);
		*i = 0;

		a = fopen(tmp,"rb");
		b = fopen(name,"rb");
		if (a && b)
		{
			char bufa[1024];
			char bufb[1024];
			for (;;)
			{
				size_t na = fread(bufa,1,sizeof(bufa),a);
				size_t nb = fread(bufb,1,sizeof(bufb),b);
				if (na != nb || memcmp(bufa,bufb,na)!=0)
					break;
				if (feof(a) || feof(b))
				{
					same=1;
					break;
				}
			}
		}
		if (a) fclose(a);
		if (b) fclose(b);
		if (!same)
		{
			if (verbose)
				printf("updating %s\r\n",name);
			remove(name);
			rename(tmp,name);
		}
		else
			remove(tmp);
	}
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0xc18, %rsp            # imm = 0xC18
movq %rdi, %rbx
movl $0x2e, %esi
callq 0x2150
testq %rax, %rax
je 0x62f7
movq %rax, %r14
leaq 0xc3e4(%rip), %rsi      # 0x12583
movq %rax, %rdi
callq 0x2070
testl %eax, %eax
jne 0x62f7
leaq 0x10(%rsp), %r15
movq %r15, %rdi
movq %rbx, %rsi
callq 0x20b0
movb $0x0, (%r14)
leaq 0xc3be(%rip), %r14      # 0x12588
movq %r15, %rdi
movq %r14, %rsi
callq 0x22e0
movq %rax, %r15
movq %rbx, %rdi
movq %r14, %rsi
callq 0x22e0
movq %rax, %r14
testq %r15, %r15
sete %al
testq %r14, %r14
sete %cl
movb $0x1, %bpl
orb %al, %cl
jne 0x629d
movl $0x0, 0xc(%rsp)
leaq 0x810(%rsp), %r12
leaq 0x410(%rsp), %r13
movl $0x1, %esi
movl $0x400, %edx            # imm = 0x400
movq %r12, %rdi
movq %r15, %rcx
callq 0x20e0
movq %rax, %rbp
movl $0x1, %esi
movl $0x400, %edx            # imm = 0x400
movq %r13, %rdi
movq %r14, %rcx
callq 0x20e0
cmpq %rax, %rbp
jne 0x626d
movq %r12, %rdi
movq %r13, %rsi
movq %rbp, %rdx
callq 0x2290
testl %eax, %eax
jne 0x626d
movq %r15, %rdi
callq 0x2220
testl %eax, %eax
je 0x6275
movl $0x1, 0xc(%rsp)
xorl %eax, %eax
testb %al, %al
jne 0x6215
jmp 0x6294
movq %r14, %rdi
callq 0x2220
testl %eax, %eax
sete %al
movl 0xc(%rsp), %ecx
movl $0x1, %edx
cmovnel %edx, %ecx
movl %ecx, 0xc(%rsp)
jmp 0x626f
cmpl $0x0, 0xc(%rsp)
sete %bpl
testq %r15, %r15
je 0x62aa
movq %r15, %rdi
callq 0x20f0
testq %r14, %r14
je 0x62b7
movq %r14, %rdi
callq 0x20f0
testb %bpl, %bpl
je 0x62ed
cmpl $0x0, 0x1132d(%rip)     # 0x175f0
je 0x62d6
leaq 0xc2bf(%rip), %rdi      # 0x1258b
movq %rbx, %rsi
xorl %eax, %eax
callq 0x2140
movq %rbx, %rdi
callq 0x2090
leaq 0x10(%rsp), %rdi
movq %rbx, %rsi
callq 0x22f0
jmp 0x62f7
leaq 0x10(%rsp), %rdi
callq 0x2090
addq $0xc18, %rsp            # imm = 0xC18
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_print
itemcond* itemcond_print(FILE* f,itemcond* p,itemcond* cond)
{
	if (!itemcond_same(p,cond))
	{
		if (p)
		{
			itemcond_delete(p);
			fprintf(f,"#endif\n");
		}

		p = itemcond_dup(cond);
		if (p)
		{
            int pos = ftell(f);
			fprintf(f,"#if ");
			dumpcond(f,p,1,COND_GET,&pos,0);
			fprintf(f,"\n");
		}
	}
	return p;
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
subq $0x10, %rsp
movq %rdx, %rbx
movq %rsi, %r15
movq %rdi, %r14
movq %rsi, %rdi
movq %rdx, %rsi
callq 0x2e60
testl %eax, %eax
je 0x632f
movq %r15, %rbx
jmp 0x63ae
testq %r15, %r15
je 0x6355
movq %r15, %rdi
callq 0x2d76
leaq 0xc256(%rip), %rdi      # 0x12599
movl $0x7, %esi
movl $0x1, %edx
movq %r14, %rcx
callq 0x2340
testq %rbx, %rbx
je 0x63ac
incl (%rbx)
movq %r14, %rdi
callq 0x2210
leaq 0xc(%rsp), %r15
movl %eax, (%r15)
leaq 0xc22e(%rip), %rdi      # 0x125a1
movl $0x4, %esi
movl $0x1, %edx
movq %r14, %rcx
callq 0x2340
movq %r14, %rdi
movq %rbx, %rsi
movl $0x1, %edx
xorl %ecx, %ecx
movq %r15, %r8
xorl %r9d, %r9d
callq 0x5b83
movl $0xa, %edi
movq %r14, %rsi
callq 0x21b0
jmp 0x63ae
xorl %ebx, %ebx
movq %rbx, %rax
addq $0x10, %rsp
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_cpp_makefile_star2_O1/corecodec[P]coremake/coremake.c
// Function: getpri
int getpri(item* p)
{
    int i;
    item* v = item_find(p,"priority");
    if (v && item_childcount(v) && sscanf(v->child[0]->value,"%d",&i)==1)
        return i;
    return MAX_PRI;
}

// Assembly:
pushq %rax
leaq 0xc0e3(%rip), %rsi      # 0x1251c
callq 0x26b0
movq %rax, %rcx
movl $0x100000, %eax         # imm = 0x100000
testq %rcx, %rcx
je 0x6482
movq 0x20(%rcx), %rdx
cmpq 0x18(%rcx), %rdx
je 0x6482
movq 0x18(%rcx), %rax
movq (%rax), %rax
movq (%rax), %rdi
leaq 0xc2fd(%rip), %rsi      # 0x12763
leaq 0x4(%rsp), %rdx
xorl %eax, %eax
callq 0x2280
movl %eax, %ecx
movl $0x100000, %eax         # imm = 0x100000
cmpl $0x1, %ecx
jne 0x6482
movl 0x4(%rsp), %eax
popq %rcx
retq
// File: /workspace/github_cpp_makefile_star2_O1/corecodec[P]coremake/coremake.c
// Function: getabspath
void getabspath(char* path, int path_flags, const char *rel_path, int rel_flags)
{
    //assert((path_flags & FLAG_PATH_MASK) != FLAG_PATH_NOT_PATH);
    if (!(path_flags & FLAG_PATH_SET_ABSOLUTE))
    {
        char base[3*MAX_PATH];
        if (rel_path[0])
        {
            base[0] = '\0';
            strins(base,rel_path,getfilename(rel_path));
        }
        else
            switch (rel_flags & FLAG_PATH_MASK)
            {
            case FLAG_PATH_SOURCE:    strcpy(base,src_root); break;
            case FLAG_PATH_GENERATED: strcpy(base,proj_root); break;
            case FLAG_PATH_COREMAKE:  strcpy(base,coremake_root); break;
            default: base[0] = '\0'; // safety
            }
        addendpath(base);
        strcat(base,path);
        simplifypath(base,0);
        strcpy(path,base);
    }
}

// Assembly:
testb $0x10, %sil
jne 0x6aa9
pushq %r15
pushq %r14
pushq %rbx
subq $0xc00, %rsp            # imm = 0xC00
movq %rdx, %r14
movq %rdi, %rbx
cmpb $0x0, (%rdx)
je 0x6a39
movq %rsp, %r15
movb $0x0, (%r15)
movq %r14, %rdi
movl $0x2f, %esi
callq 0x2150
leaq 0x1(%rax), %rdx
testq %rax, %rax
cmoveq %r14, %rdx
movq %r15, %rdi
movq %r14, %rsi
callq 0x35d1
jmp 0x6a72
andl $0xf, %ecx
cmpl $0x3, %ecx
je 0x6a5d
cmpl $0x2, %ecx
je 0x6a54
cmpl $0x1, %ecx
jne 0x6a6e
leaq 0x10bae(%rip), %rsi     # 0x17600
jmp 0x6a64
leaq 0x10fa5(%rip), %rsi     # 0x17a00
jmp 0x6a64
leaq 0x1139c(%rip), %rsi     # 0x17e00
movq %rsp, %rdi
callq 0x20b0
jmp 0x6a72
movb $0x0, (%rsp)
movq %rsp, %r14
movq %r14, %rdi
callq 0x3df1
movq %r14, %rdi
movq %rbx, %rsi
callq 0x2310
movq %r14, %rdi
xorl %esi, %esi
callq 0x437e
movq %rbx, %rdi
movq %r14, %rsi
callq 0x20b0
addq $0xc00, %rsp            # imm = 0xC00
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_cpp_makefile_star2_O1/corecodec[P]coremake/coremake.c
// Function: create_missing_dirs
void create_missing_dirs(const char *path)
{
	size_t strpos = 0, strpos_i;
	char new_dir[MAX_PATH];
	char new_path[MAX_PATH];
	int ret;
	struct stat dir_stats;

    assert(ispathabs(path)); // internally all pathes should be absolute

    strcpy(new_path,path);
    pathunix(new_path);
    simplifypath(new_path,1);

	for (;;)
	{
		strpos_i = strcspn(&new_path[strpos], "/");
		if (strpos_i == strlen(&new_path[strpos]))
			break;
		strpos += strpos_i+1;

		strncpy(new_dir, new_path, strpos-1);
        new_dir[strpos-1] = '\0';

		if (stat(new_dir, &dir_stats) == 0)
		{
			if ((dir_stats.st_mode & S_IFDIR) != S_IFDIR)
			{
				printf("%s is not a directory\r\n",new_dir);
				exit(1);
			}
		}
        else if (strpos>1 && new_dir[strpos-2] != ':')
		{
			ret = make_dir(new_dir);

			if (ret != 0 && ret != EEXIST)
			{
				printf("can't create directory %s\r\n",new_dir);
				exit(1);
			}
		}
	}
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x898, %rsp            # imm = 0x898
movq %rdi, %r14
callq 0x4016
testl %eax, %eax
je 0x8cc6
leaq 0x90(%rsp), %rbx
movq %rbx, %rdi
movq %r14, %rsi
callq 0x20b0
movzbl (%rbx), %eax
cmpl $0x5c, %eax
je 0x8bac
testl %eax, %eax
jne 0x8baf
jmp 0x8bb4
movb $0x2f, (%rbx)
incq %rbx
jmp 0x8b9e
leaq 0x90(%rsp), %rbx
movq %rbx, %rdi
movl $0x1, %esi
callq 0x437e
leaq 0xa5d4(%rip), %rsi      # 0x131a4
movq %rbx, %rdi
callq 0x21c0
movq %rax, %r13
movq %rbx, %rdi
callq 0x2120
cmpq %rax, %r13
je 0x8c8b
xorl %r14d, %r14d
leaq 0x490(%rsp), %rbx
movq %rsp, %r15
leaq 0xa5a3(%rip), %r12      # 0x131a4
leaq (%r14,%r13), %rbp
addq %r13, %r14
incq %r14
movq %rbx, %rdi
leaq 0x90(%rsp), %rsi
movq %rbp, %rdx
callq 0x2080
movb $0x0, 0x490(%rsp,%rbp)
movq %rbx, %rdi
movq %r15, %rsi
callq 0x2230
testl %eax, %eax
je 0x8c5a
cmpq $0x2, %r14
jb 0x8c61
cmpb $0x3a, -0x1(%rbp,%rbx)
je 0x8c61
movq %rbx, %rdi
movl $0x1c0, %esi            # imm = 0x1C0
callq 0x20c0
testl %eax, %eax
je 0x8c61
cmpl $0x11, %eax
je 0x8c61
jmp 0x8cbd
testb $0x40, 0x19(%rsp)
je 0x8c9d
leaq (%rsp,%r14), %rbp
addq $0x90, %rbp
movq %rbp, %rdi
movq %r12, %rsi
callq 0x21c0
movq %rax, %r13
movq %rbp, %rdi
callq 0x2120
cmpq %rax, %r13
jne 0x8c01
addq $0x898, %rsp            # imm = 0x898
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
leaq 0xa5a4(%rip), %rdi      # 0x13248
leaq 0x490(%rsp), %rsi
xorl %eax, %eax
callq 0x2140
movl $0x1, %edi
callq 0x2330
leaq 0xa59c(%rip), %rdi      # 0x13260
jmp 0x8ca4
leaq 0xa544(%rip), %rdi      # 0x13211
leaq 0x93d2(%rip), %rsi      # 0x120a6
leaq 0xa546(%rip), %rcx      # 0x13221
movl $0x1210, %edx           # imm = 0x1210
callq 0x2160
// File: /workspace/github_cpp_makefile_star2_O1/corecodec[P]coremake/coremake.c
// Function: preprocess_workspace_adddep
void preprocess_workspace_adddep(item* workspace_use,item* p)
{
	item* ref = findref(p);
	p->flags |= FLAG_PROCESSED;
	if (ref && !(ref->flags & FLAG_REMOVED))
	{
		size_t i;
		item* use = item_get(ref,"use",0);
		for (i=0;i<item_childcount(use);++i)
			if (!(use->child[i]->flags & FLAG_REMOVED))
			{
				item* dep = item_get(workspace_use,use->child[i]->value,1);
				if (!(dep->flags & FLAG_PROCESSED))
					preprocess_workspace_adddep(workspace_use,dep);
			}

		use = item_get(ref,"dep",0);
		for (i=0;i<item_childcount(use);++i)
			if (!(use->child[i]->flags & FLAG_REMOVED))
			{
				item* dep = item_get(workspace_use,use->child[i]->value,1);
				if (!(dep->flags & FLAG_PROCESSED))
					preprocess_workspace_adddep(workspace_use,dep);
			}
	}
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rsi, %r15
movq %rdi, %rbx
movq %rsi, %rdi
callq 0x2877
orb $-0x80, 0x30(%r15)
testq %rax, %rax
je 0xa72e
movq %rax, %r14
testb $0x40, 0x30(%rax)
jne 0xa72e
leaq 0x7a71(%rip), %rsi      # 0x120dc
xorl %r12d, %r12d
movq %r14, %rdi
xorl %edx, %edx
callq 0x2745
movq %rax, %r15
testq %r15, %r15
je 0xa68e
movq 0x20(%r15), %rax
subq 0x18(%r15), %rax
sarq $0x3, %rax
jmp 0xa690
xorl %eax, %eax
cmpq %rax, %r12
jae 0xa6c9
movq 0x18(%r15), %rax
movq (%rax,%r12,8), %rax
testb $0x40, 0x30(%rax)
jne 0xa6c4
movq (%rax), %rsi
movq %rbx, %rdi
movl $0x1, %edx
callq 0x2745
testb $-0x80, 0x30(%rax)
jne 0xa6c4
movq %rbx, %rdi
movq %rax, %rsi
callq 0xa633
incq %r12
jmp 0xa67b
leaq 0x7a08(%rip), %rsi      # 0x120d8
xorl %r15d, %r15d
movq %r14, %rdi
xorl %edx, %edx
callq 0x2745
movq %rax, %r14
testq %r14, %r14
je 0xa6f3
movq 0x20(%r14), %rax
subq 0x18(%r14), %rax
sarq $0x3, %rax
jmp 0xa6f5
xorl %eax, %eax
cmpq %rax, %r15
jae 0xa72e
movq 0x18(%r14), %rax
movq (%rax,%r15,8), %rax
testb $0x40, 0x30(%rax)
jne 0xa729
movq (%rax), %rsi
movq %rbx, %rdi
movl $0x1, %edx
callq 0x2745
testb $-0x80, 0x30(%rax)
jne 0xa729
movq %rbx, %rdi
movq %rax, %rsi
callq 0xa633
incq %r15
jmp 0xa6e0
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: preprocess_workspace_init
void preprocess_workspace_init(item* p)
{
	item** child;
	if (!p) return;
	for (child=p->child;child!=p->childend;++child)
		(*child)->flags &= ~FLAG_PROCESSED;
}

// Assembly:
testq %rdi, %rdi
je 0xa75c
movq 0x18(%rdi), %rax
movq 0x20(%rdi), %rcx
cmpq %rcx, %rax
je 0xa75c
movq (%rax), %rdx
andl $0xffffff7f, 0x30(%rdx) # imm = 0xFFFFFF7F
addq $0x8, %rax
jmp 0xa747
retq
// File: /workspace/github_cpp_makefile_star2_O1/corecodec[P]coremake/coremake.c
// Function: preprocess_workspace
void preprocess_workspace(item* p)
{
	item** child;
	for (child=p->child;child!=p->childend;++child)
	{
		item* use = item_get(*child,"use",0);
		size_t i;
		for (i=0;i<item_childcount(use);++i)
			use->child[i]->flags &= ~FLAG_PROCESSED;

		for (i=0;i<item_childcount(use);++i)
			if (!(use->child[i]->flags & FLAG_PROCESSED))
				preprocess_workspace_adddep(use,use->child[i]);

		for (i=0;i<item_childcount(use);++i)
		{
			item* ref = findref(use->child[i]);
			if (!ref || (ref->flags & FLAG_REMOVED))
			{
				item_delete(use->child[i]);
				--i;
			}
		}

		if (!item_childcount(use))
		{
			item_delete(*child);
			--child;
		}
#if 0
		else
		{
			// copy all the FRAMEWORK of each (use) into the WORKSPACE (*child)
			item *frameworks = item_get(*child,"framework",0);
			for (i=0;i<item_childcount(use);++i)
			{
				item* ref = findref(use->child[i]);
				if (ref)
				{
					item_merge(frameworks,item_find(ref,"framework"),NULL);
				}
			}
		}
#endif
	}
}

// Assembly:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
movq 0x18(%rdi), %r12
cmpq 0x20(%rdi), %r12
je 0xa86b
movq %rdi, %rbx
leaq 0x795e(%rip), %r14      # 0x120dc
movq (%r12), %rdi
movq %r14, %rsi
xorl %edx, %edx
callq 0x2745
movq %rax, %r15
xorl %eax, %eax
testq %r15, %r15
je 0xa7a4
movq 0x20(%r15), %rcx
subq 0x18(%r15), %rcx
sarq $0x3, %rcx
jmp 0xa7a6
xorl %ecx, %ecx
cmpq %rcx, %rax
jae 0xa7bf
movq 0x18(%r15), %rcx
movq (%rcx,%rax,8), %rcx
andl $0xffffff7f, 0x30(%rcx) # imm = 0xFFFFFF7F
incq %rax
jmp 0xa791
xorl %r13d, %r13d
testq %r15, %r15
je 0xa7d5
movq 0x20(%r15), %rax
subq 0x18(%r15), %rax
sarq $0x3, %rax
jmp 0xa7d7
xorl %eax, %eax
cmpq %rax, %r13
jae 0xa7f7
movq 0x18(%r15), %rax
movq (%rax,%r13,8), %rsi
testb $-0x80, 0x30(%rsi)
jne 0xa7f2
movq %r15, %rdi
callq 0xa633
incq %r13
jmp 0xa7c2
xorl %r13d, %r13d
testq %r15, %r15
je 0xa80d
movq 0x20(%r15), %rax
subq 0x18(%r15), %rax
sarq $0x3, %rax
jmp 0xa80f
xorl %eax, %eax
cmpq %rax, %r13
jae 0xa841
movq 0x18(%r15), %rax
movq (%rax,%r13,8), %rdi
callq 0x2877
testq %rax, %rax
je 0xa82c
testb $0x40, 0x30(%rax)
je 0xa83c
movq 0x18(%r15), %rax
movq (%rax,%r13,8), %rdi
callq 0x2da0
decq %r13
incq %r13
jmp 0xa7fa
testq %r15, %r15
je 0xa850
movq 0x20(%r15), %rax
cmpq 0x18(%r15), %rax
jne 0xa85d
movq (%r12), %rdi
callq 0x2da0
addq $-0x8, %r12
addq $0x8, %r12
cmpq 0x20(%rbx), %r12
jne 0xa77e
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
// File: /workspace/github_cpp_makefile_star2_O1/corecodec[P]coremake/coremake.c
// Function: merge_project
void merge_project(item* target,item* source,item* filter)
{
	size_t j;

    item* tmp = item_get(NULL,"tmp",0);

	item_add(tmp,item_find(source,"path"));

	item_merge(target,source,filter);

	for (j=0;j<item_childcount(tmp);++j)
		item_add(source,tmp->child[j]);

	item_delete(tmp);

}

// Assembly:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
movq %rdx, %r15
movq %rsi, %rbx
movq %rdi, %r12
leaq 0x7cf6(%rip), %rsi      # 0x12584
xorl %r13d, %r13d
xorl %edi, %edi
xorl %edx, %edx
callq 0x2745
movq %rax, %r14
leaq 0x87ca(%rip), %rsi      # 0x1306e
movq %rbx, %rdi
callq 0x26b0
movq %r14, %rdi
movq %rax, %rsi
callq 0x25d9
movq %r12, %rdi
movq %rbx, %rsi
movq %r15, %rdx
callq 0x334b
testq %r14, %r14
je 0xa8d8
movq 0x20(%r14), %rax
subq 0x18(%r14), %rax
sarq $0x3, %rax
jmp 0xa8da
xorl %eax, %eax
cmpq %rax, %r13
jae 0xa8f4
movq 0x18(%r14), %rax
movq (%rax,%r13,8), %rsi
movq %rbx, %rdi
callq 0x25d9
incq %r13
jmp 0xa8c5
movq %r14, %rdi
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
jmp 0x2da0
// File: /workspace/github_cpp_makefile_star2_O1/corecodec[P]coremake/coremake.c
// Function: replace_use
void replace_use(item* p,const char* remove,item* set)
{
	item** child;
	if (!p) return;
	for (child=p->child;child!=p->childend;++child)
	{
		item* use = item_get(*child,"use",0);
		item* a = item_find(use,remove);
		if (a && !(a->flags & FLAG_REMOVED))
		{
            // remove old use
			item_delete(a);

			if (stricmp((*child)->value,set->value)!=0)
			{
				item* setuse = item_find(item_find(set,"use"),(*child)->value);
				if (setuse)
				{
                    if ((*child)->parent && stricmp((*child)->parent->value,"lib")==0)
                        continue;

					item_get(item_get(set,"dep",0),(*child)->value,1);
					item_delete(setuse);
				}

                // replace use
				item_get(use,set->value,1);
			}
		}
	}
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %rdx, 0x8(%rsp)
testq %rdi, %rdi
je 0xaa31
movq %rdi, %r15
movq 0x18(%rdi), %r12
cmpq 0x20(%rdi), %r12
je 0xaa31
movq %rsi, %r14
movq %rsi, 0x10(%rsp)
movq (%r12), %rdi
leaq 0x7797(%rip), %rsi      # 0x120dc
xorl %edx, %edx
callq 0x2745
movq %rax, %rbp
movq %rax, %rdi
movq %r14, %rsi
callq 0x26b0
testq %rax, %rax
je 0xaa23
testb $0x40, 0x30(%rax)
jne 0xaa23
movq %rax, %rdi
callq 0x2da0
movq (%r12), %rbx
movq (%rbx), %r13
movq 0x8(%rsp), %rax
movq (%rax), %rsi
movq %r13, %rdi
callq 0x2070
testl %eax, %eax
je 0xaa23
movq 0x8(%rsp), %r14
movq %r14, %rdi
leaq 0x7739(%rip), %rsi      # 0x120dc
callq 0x26b0
movq %rax, %rdi
movq %r13, %rsi
callq 0x26b0
testq %rax, %rax
je 0xaa0e
movq %rax, %r13
movq 0x10(%rbx), %rax
testq %rax, %rax
movq 0x10(%rsp), %r14
je 0xa9dc
movq (%rax), %rdi
leaq 0x87ca(%rip), %rsi      # 0x1319d
callq 0x2070
testl %eax, %eax
je 0xaa23
movq 0x8(%rsp), %r14
movq %r14, %rdi
leaq 0x76ed(%rip), %rsi      # 0x120d8
xorl %edx, %edx
callq 0x2745
movq (%r12), %rcx
movq (%rcx), %rsi
movq %rax, %rdi
movl $0x1, %edx
callq 0x2745
movq %r13, %rdi
callq 0x2da0
movq (%r14), %rsi
movq %rbp, %rdi
movl $0x1, %edx
callq 0x2745
movq 0x10(%rsp), %r14
addq $0x8, %r12
cmpq 0x20(%r15), %r12
jne 0xa93a
addq $0x18, %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: preprocess_outputname
void preprocess_outputname(item* p,const char* outputname)
{
	item* output;
	item** child;
	if (!p) return;
	output = getvalue(item_find(getconfig(p),outputname));
	for (child=p->child;child!=p->childend;++child)
	{
		if (!output)
			preprocess_setremoved(*child);
		else
		if (!getvalue(item_find(*child,"output")))
			item_get(item_get(*child,"output",0),output->value,1);
	}
}

// Assembly:
testq %rdi, %rdi
je 0xaf5b
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
movq %rsi, %r14
movq %rdi, %rbx
movq %rdi, %rax
movq %rax, %rdi
movq 0x10(%rax), %rax
testq %rax, %rax
jne 0xae65
leaq 0x7259(%rip), %rsi      # 0x120d1
xorl %edx, %edx
callq 0x2745
movq %rax, %rdi
movq %r14, %rsi
callq 0x26b0
testq %rax, %rax
je 0xaebc
movq 0x18(%rax), %rcx
movq 0x20(%rax), %rdx
cmpq %rdx, %rcx
sete %al
je 0xaeb8
movq (%rcx), %r12
testb $0x40, 0x30(%r12)
je 0xaeb8
addq $0x8, %rcx
cmpq %rdx, %rcx
sete %al
jne 0xae9f
jmp 0xaeb8
testb $0x1, %al
je 0xaebf
xorl %r12d, %r12d
movq 0x18(%rbx), %r13
cmpq 0x20(%rbx), %r13
je 0xaf52
leaq 0x77b2(%rip), %r14      # 0x12686
movq (%r13), %r15
testq %r12, %r12
je 0xaf14
movq %r15, %rdi
movq %r14, %rsi
callq 0x26b0
testq %rax, %rax
je 0xaf23
movq 0x18(%rax), %rdx
movq 0x20(%rax), %rsi
cmpq %rsi, %rdx
sete %cl
je 0xaf1e
movq (%rdx), %rax
testb $0x40, 0x30(%rax)
je 0xaf1e
addq $0x8, %rdx
cmpq %rsi, %rdx
sete %cl
jne 0xaefd
jmp 0xaf1e
movq %r15, %rdi
callq 0x5e49
jmp 0xaf48
testb $0x1, %cl
je 0xaf25
xorl %eax, %eax
testq %rax, %rax
jne 0xaf48
movq %r15, %rdi
movq %r14, %rsi
xorl %edx, %edx
callq 0x2745
movq (%r12), %rsi
movq %rax, %rdi
movl $0x1, %edx
callq 0x2745
addq $0x8, %r13
cmpq 0x20(%rbx), %r13
jne 0xaed4
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
// File: /workspace/github_cpp_makefile_star2_O1/corecodec[P]coremake/coremake.c
// Function: preprocess_project
void preprocess_project(item* p)
{
	size_t i;
	if (!p) return;
    for (i=0;i<item_childcount(p);++i)
	{
        item* ref = findref(p->child[i]);
        if (ref)
        {
			merge_project(ref,p->child[i],p->child[i]);
			item_delete(p->child[i]);
			--i;
        }
	}
}

// Assembly:
testq %rdi, %rdi
je 0xafc5
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
movq 0x20(%rdi), %rax
cmpq 0x18(%rdi), %rax
je 0xafbe
xorl %r14d, %r14d
movq 0x18(%rbx), %rax
movq (%rax,%r14,8), %rdi
callq 0x2877
testq %rax, %rax
je 0xafaa
movq 0x18(%rbx), %rcx
movq (%rcx,%r14,8), %rdx
movq %rax, %rdi
movq %rdx, %rsi
callq 0xa875
movq 0x18(%rbx), %rax
movq (%rax,%r14,8), %rdi
callq 0x2da0
decq %r14
incq %r14
movq 0x20(%rbx), %rax
subq 0x18(%rbx), %rax
sarq $0x3, %rax
cmpq %rax, %r14
jb 0xaf75
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_cpp_makefile_star2_O1/corecodec[P]coremake/coremake.c
// Function: preprocess_group
void preprocess_group(item* p)
{
	item** child;
	if (!p) return;
	for (child=p->child;child!=p->childend;++child)
	{
		size_t i;
		item* use = item_get(*child,"use",0);
		for (i=0;i<item_childcount(use);++i)
		{
			item* group = item_find(getroot(p,"group"),use->child[i]->value);
			if (group)
			{
				merge_project(*child,group,use->child[i]);
				item_delete(use->child[i]);
				--i; // process the same item again until there is no more 'group'
			}
		}
	}
}

// Assembly:
testq %rdi, %rdi
je 0xb09a
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rdi, %rbx
movq 0x18(%rdi), %rbp
cmpq 0x20(%rdi), %rbp
je 0xb08c
leaq 0x710b(%rip), %r15      # 0x120fd
movq (%rbp), %rdi
leaq 0x70df(%rip), %rsi      # 0x120dc
xorl %edx, %edx
callq 0x2745
movq %rax, %r12
xorl %r14d, %r14d
testq %r12, %r12
je 0xb01f
movq 0x20(%r12), %rax
subq 0x18(%r12), %rax
sarq $0x3, %rax
jmp 0xb021
xorl %eax, %eax
cmpq %rax, %r14
jae 0xb07e
movq %rbx, %rax
movq %rax, %rdi
movq 0x10(%rax), %rax
testq %rax, %rax
jne 0xb029
movq %r15, %rsi
xorl %edx, %edx
callq 0x2745
movq 0x18(%r12), %rcx
movq (%rcx,%r14,8), %r13
movq (%r13), %rsi
movq %rax, %rdi
callq 0x26b0
testq %rax, %rax
je 0xb079
movq (%rbp), %rdi
movq %rax, %rsi
movq %r13, %rdx
callq 0xa875
movq 0x18(%r12), %rax
movq (%rax,%r14,8), %rdi
callq 0x2da0
decq %r14
incq %r14
jmp 0xb00a
addq $0x8, %rbp
cmpq 0x20(%rbx), %rbp
jne 0xaff2
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: generate_xcodeuid
void generate_xcodeuid(char *xcodeuid,const char *srcstr)
{
	int i;
	union
	{
		unsigned int d[3];
		unsigned char b[12];
	} code;

    for (i=0;i<3;++i)
        code.d[i] = 1;

	for (i=0;srcstr[i];++i)
	{
		unsigned char ch = (unsigned char)srcstr[i];
		code.d[0] = (code.d[0] + 0x33299112 + code.d[0] * ch) ^ code.d[2];
		code.d[1] = (code.d[1] + 0x1345AF22 + code.d[2] * ch) ^ code.d[1];
		code.d[2] = (code.d[2] + 0x73A92332 + code.d[1] * ch) ^ code.d[0];
	}

	sprintf(xcodeuid,"%02X%02X%02X%02X%02X%02X%02X%02X%02X%02X%02X%02X",
		code.b[0],code.b[1],code.b[2],code.b[3],
		code.b[4],code.b[5],code.b[6],code.b[7],
		code.b[8],code.b[9],code.b[10],code.b[11]);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
xorl %eax, %eax
movl $0x1, 0xc(%rsp,%rax,4)
incq %rax
cmpq $0x3, %rax
jne 0xb8c9
movl 0xc(%rsp), %eax
movb (%rsi), %r8b
testb %r8b, %r8b
je 0xb93b
movl 0x10(%rsp), %edx
movl 0x14(%rsp), %ecx
incq %rsi
movl %edx, %r9d
movzbl %r8b, %r8d
movl %eax, %edx
imull %r8d, %edx
addl %edx, %eax
addl $0x33299112, %eax       # imm = 0x33299112
xorl %ecx, %eax
movl %ecx, %edx
imull %r8d, %edx
addl %r9d, %edx
addl $0x1345af22, %edx       # imm = 0x1345AF22
xorl %r9d, %edx
imull %edx, %r8d
addl %r8d, %ecx
addl $0x73a92332, %ecx       # imm = 0x73A92332
xorl %eax, %ecx
movb (%rsi), %r8b
incq %rsi
testb %r8b, %r8b
jne 0xb8f1
movl %ecx, 0x14(%rsp)
movl %edx, 0x10(%rsp)
movl %eax, 0xc(%rsp)
movzbl %al, %edx
movzbl 0xd(%rsp), %ecx
movzbl 0xe(%rsp), %r8d
movzbl 0xf(%rsp), %r9d
movzbl 0x10(%rsp), %r10d
movzbl 0x11(%rsp), %r11d
movzbl 0x12(%rsp), %ebx
movzbl 0x13(%rsp), %r14d
movzbl 0x14(%rsp), %r15d
movzbl 0x15(%rsp), %r12d
movzbl 0x16(%rsp), %r13d
movzbl 0x17(%rsp), %ebp
leaq 0x7555(%rip), %rsi      # 0x12edd
xorl %eax, %eax
pushq %rbp
pushq %r13
pushq %r12
pushq %r15
pushq %r14
pushq %rbx
pushq %r11
pushq %r10
callq 0x2320
addq $0x58, %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: generate_msmuid
void generate_msmuid(char *msmuid,const char *srcstr)
{
	int i;
    union
    {
        unsigned int d[4];
        unsigned char b[16];
    } code;

    for (i=0;i<4;++i)
        code.d[i] = 1;

    for (i=0;srcstr[i];++i)
    {
        unsigned char ch = (unsigned char)srcstr[i];
        code.d[0] = (code.d[0] + 0x33299112 + code.d[2] * ch) ^ code.d[3];
        code.d[1] = (code.d[1] + 0x1345AF22 + code.d[3] * ch) ^ code.d[2];
        code.d[2] = (code.d[2] + 0x73A92332 + code.d[0] * ch) ^ code.d[1];
        code.d[3] = (code.d[3] + 0x5123ABC1 + code.d[1] * ch) ^ code.d[0];
    }

	sprintf(msmuid,"%02X%02X%02X%02X%02X%02X%02X%02X%02X%02X%02X%02X%02X%02X%02X%02X",
		code.b[0],code.b[1],code.b[2],code.b[3],
		code.b[4],code.b[5],code.b[6],code.b[7],
		code.b[8],code.b[9],code.b[10],code.b[11],
        code.b[12],code.b[13],code.b[14],code.b[15]);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x38, %rsp
xorl %eax, %eax
movl $0x1, 0x8(%rsp,%rax,4)
incq %rax
cmpq $0x4, %rax
jne 0xb9bc
movl 0x8(%rsp), %eax
movb (%rsi), %r9b
testb %r9b, %r9b
je 0xba4c
movl 0xc(%rsp), %ecx
movl 0x10(%rsp), %edx
movl 0x14(%rsp), %r8d
incq %rsi
movzbl %r9b, %r9d
movl %edx, %r10d
imull %r9d, %r10d
addl %r10d, %eax
addl $0x33299112, %eax       # imm = 0x33299112
xorl %r8d, %eax
movl %r8d, %r10d
imull %r9d, %r10d
addl %r10d, %ecx
addl $0x1345af22, %ecx       # imm = 0x1345AF22
xorl %edx, %ecx
movl %eax, %r10d
imull %r9d, %r10d
addl %r10d, %edx
addl $0x73a92332, %edx       # imm = 0x73A92332
xorl %ecx, %edx
imull %ecx, %r9d
addl %r9d, %r8d
addl $0x5123abc1, %r8d       # imm = 0x5123ABC1
xorl %eax, %r8d
movb (%rsi), %r9b
incq %rsi
testb %r9b, %r9b
jne 0xb9e9
movl %edx, 0x10(%rsp)
movl %r8d, 0x14(%rsp)
movl %ecx, 0xc(%rsp)
movl %eax, 0x8(%rsp)
movzbl %al, %edx
movzbl 0x9(%rsp), %ecx
movzbl 0xa(%rsp), %r8d
movzbl 0xb(%rsp), %r9d
movzbl 0xc(%rsp), %eax
movq %rax, 0x30(%rsp)
movzbl 0xd(%rsp), %eax
movq %rax, 0x28(%rsp)
movzbl 0xe(%rsp), %eax
movq %rax, 0x20(%rsp)
movzbl 0xf(%rsp), %eax
movq %rax, 0x18(%rsp)
movzbl 0x10(%rsp), %r15d
movzbl 0x11(%rsp), %r12d
movzbl 0x12(%rsp), %r13d
movzbl 0x13(%rsp), %ebp
movzbl 0x14(%rsp), %r10d
movzbl 0x15(%rsp), %r11d
movzbl 0x16(%rsp), %ebx
movzbl 0x17(%rsp), %r14d
leaq 0x740c(%rip), %rsi      # 0x12ecd
xorl %eax, %eax
pushq %r14
pushq %rbx
pushq %r11
pushq %r10
pushq %rbp
pushq %r13
pushq %r12
pushq %r15
pushq 0x58(%rsp)
pushq 0x68(%rsp)
pushq 0x78(%rsp)
pushq 0x88(%rsp)
callq 0x2320
addq $0x98, %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: preprocess_sort_workspace
void preprocess_sort_workspace(item* p)
{
	item** child;
	if (!p) return;
	for (child=p->child;child!=p->childend;++child)
	{
#if 0
		size_t i;
		item *frameworks = item_find(*child,"framework");
		for (i=0;i<item_childcount(frameworks);++i)
		{
	        char xcodeuid[25];
			generate_xcodeuid(xcodeuid,frameworks->child[i]->value);
			item_get(item_get(frameworks->child[i],"xcodegrpuid",0),xcodeuid,1);

			generate_xcodeuid(xcodeuid, xcodeuid);
			item_get(item_get(frameworks->child[i],"xcodegrpuid2",0),xcodeuid,1);
		}
#endif
        item_sort(item_get(*child,"use",0),compare_use); // for automake "subdirs"
    }
}

// Assembly:
testq %rdi, %rdi
je 0xbca0
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rdi, %rbx
movq 0x18(%rdi), %r12
cmpq 0x20(%rdi), %r12
je 0xbc95
leaq 0x6471(%rip), %r14      # 0x120dc
leaq -0x9164(%rip), %r15     # 0x2b0e
movq (%r12), %rdi
movq %r14, %rsi
xorl %edx, %edx
callq 0x2745
movq %rax, %rdi
movq %r15, %rsi
callq 0x2ccc
addq $0x8, %r12
cmpq 0x20(%rbx), %r12
jne 0xbc72
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: getname
char* getname(char* s,char* name)
{
	for (;*s && isspace(*s);++s);
	for (;*s && isname(*s);++s)
		*(name++) = *s;
	*name = 0;
	return s;
}

// Assembly:
pushq %rbp
pushq %r14
pushq %rbx
movq %rsi, %r14
movq %rdi, %rbx
movb (%rdi), %bpl
testb %bpl, %bpl
je 0xe139
callq 0x2370
movq (%rax), %rax
movsbq %bpl, %rcx
testb $0x20, 0x1(%rax,%rcx,2)
je 0xe139
movb 0x1(%rbx), %bpl
incq %rbx
testb %bpl, %bpl
jne 0xe122
movb (%rbx), %bpl
testb %bpl, %bpl
je 0xe15d
movsbl %bpl, %edi
callq 0x3741
testl %eax, %eax
je 0xe15d
movb %bpl, (%r14)
incq %r14
movb 0x1(%rbx), %bpl
incq %rbx
jmp 0xe13c
movb $0x0, (%r14)
movq %rbx, %rax
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O1/corecodec[P]coremake/coremake.c
// Function: urlquote
void urlquote(char *name,int no_backslash)
{
    char *q = strrchr(name,'\"');
    while (q)
    {
        strdel(q,q+1);
        strins(q,"&quot;",NULL);
        if (!no_backslash)
            strins(q,"\\",NULL);
        q = strrchr(name,'\"');
    }
}

// Assembly:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
movl %esi, %ebx
movq %rdi, %r14
movl $0x22, %esi
callq 0x2150
testq %rax, %rax
je 0xe201
movq %rax, %r15
leaq 0x1(%r15), %r12
movq %r12, %rdi
callq 0x2120
leaq 0x1(%rax), %rdx
movq %r15, %rdi
movq %r12, %rsi
callq 0x22d0
leaq 0x6(%r15), %r13
movq %r15, %rdi
callq 0x2120
leaq 0x1(%rax), %rdx
movq %r13, %rdi
movq %r15, %rsi
callq 0x22d0
movl $0x6f757126, (%r15)     # imm = 0x6F757126
movw $0x3b74, 0x4(%r15)      # imm = 0x3B74
testl %ebx, %ebx
jne 0xe1ec
movq %r15, %rdi
callq 0x2120
leaq 0x1(%rax), %rdx
movq %r12, %rdi
movq %r15, %rsi
callq 0x22d0
movb $0x5c, (%r15)
movq %r14, %rdi
movl $0x22, %esi
callq 0x2150
movq %rax, %r15
testq %rax, %rax
jne 0xe189
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
// File: /workspace/github_cpp_makefile_star2_O1/corecodec[P]coremake/coremake.c
// Function: eval0
char* eval0(const char** s,item* config,reader* file)
{
	int value;
	char* b;
	char* a = eval1(s,config,file);

	evalspace(s);
	if ((*s)[0] == '&' && (*s)[1] == '&')
	{
		*s += 2;
		b = eval0(s,config,file);
		value = str2bool(a) && str2bool(b);
		free(a);
		free(b);
		a = bool2str(value);
	}
	else
	if ((*s)[0] == '|' && (*s)[1] == '|')
	{
		*s += 2;
		b = eval0(s,config,file);
		value = str2bool(a) || str2bool(b);
		free(a);
		free(b);
		a = bool2str(value);
	}
	return a;
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rdx, %r14
movq %rsi, %r15
movq %rdi, %r12
callq 0xe686
movq %rax, %rbx
movq %r12, %rdi
callq 0xe27e
movq (%r12), %rax
movzbl (%rax), %ecx
cmpl $0x7c, %ecx
je 0xe559
cmpl $0x26, %ecx
jne 0xe599
cmpb $0x26, 0x1(%rax)
jne 0xe554
addq $0x2, %rax
movq %rax, (%r12)
movq %r12, %rdi
movq %r15, %rsi
movq %r14, %rdx
callq 0xe4d1
movq %rax, %r14
cmpb $0x0, (%rbx)
je 0xe5cf
leaq 0x4b41(%rip), %r15      # 0x13077
movq %rbx, %rdi
movq %r15, %rsi
callq 0x21f0
testl %eax, %eax
je 0xe5d6
cmpb $0x0, (%r14)
jne 0xe5ae
jmp 0xe5d6
cmpb $0x7c, %cl
jne 0xe599
cmpb $0x7c, 0x1(%rax)
jne 0xe599
addq $0x2, %rax
movq %rax, (%r12)
movq %r12, %rdi
movq %r15, %rsi
movq %r14, %rdx
callq 0xe4d1
movq %rax, %r14
cmpb $0x0, (%rbx)
je 0xe5a8
leaq 0x4af3(%rip), %rsi      # 0x13077
movq %rbx, %rdi
callq 0x21f0
testl %eax, %eax
je 0xe5a8
leaq 0x3ed0(%rip), %r15      # 0x12467
jmp 0xe5d6
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
cmpb $0x0, (%r14)
je 0xe5cf
leaq 0x4ac2(%rip), %r12      # 0x13077
movq %r14, %rdi
movq %r12, %rsi
callq 0x21f0
testl %eax, %eax
leaq 0x3e9e(%rip), %r15      # 0x12467
cmoveq %r12, %r15
jmp 0xe5d6
leaq 0x4aa1(%rip), %r15      # 0x13077
movq %rbx, %rdi
callq 0x2050
movq %r14, %rdi
callq 0x2050
movq %r15, %rdi
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
jmp 0x2350
// File: /workspace/github_cpp_makefile_star2_O1/corecodec[P]coremake/coremake.c
// Function: eval2
char* eval2(const char** s,item* config,reader* file)
{
	evalspace(s);
	if ((*s)[0] == '!' && (*s)[1] != '=')
	{
		int value;
		char* a;
		*s += 1;
		a = eval2(s,config,file);
		value = !str2bool(a);
		free(a);
		return bool2str(value);
	}
	else
		return eval3(s,config,file);
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rdx, %rbx
movq %rsi, %r14
movq %rdi, %r15
callq 0xe27e
movq (%r15), %rax
cmpb $0x21, (%rax)
jne 0xe61a
cmpb $0x3d, 0x1(%rax)
jne 0xe62d
movq %r15, %rdi
movq %r14, %rsi
movq %rbx, %rdx
popq %rbx
popq %r14
popq %r15
jmp 0xe2b9
incq %rax
movq %rax, (%r15)
movq %r15, %rdi
movq %r14, %rsi
movq %rbx, %rdx
callq 0xe5f9
movq %rax, %rbx
cmpb $0x0, (%rax)
je 0xe66a
leaq 0x4a27(%rip), %r15      # 0x13077
movq %rbx, %rdi
movq %r15, %rsi
callq 0x21f0
testl %eax, %eax
leaq 0x3e03(%rip), %r14      # 0x12467
cmovneq %r15, %r14
jmp 0xe671
leaq 0x3df6(%rip), %r14      # 0x12467
movq %rbx, %rdi
callq 0x2050
movq %r14, %rdi
popq %rbx
popq %r14
popq %r15
jmp 0x2350
// File: /workspace/github_cpp_makefile_star2_O1/corecodec[P]coremake/coremake.c
// Function: eval1
char* eval1(const char** s,item* config,reader* file)
{
	int value;
	char* b;
	char* a = eval2(s,config,file);

	evalspace(s);
	if ((*s)[0] == '=' && (*s)[1] == '=')
	{
		*s += 2;
		b = eval1(s,config,file);
		value = stricmp(a,b)==0;
		free(a);
		free(b);
		a = bool2str(value);
	}
	else
	if ((*s)[0] == '!' && (*s)[1] == '=')
	{
		*s += 2;
		b = eval1(s,config,file);
		value = stricmp(a,b)!=0;
		free(a);
		free(b);
		a = bool2str(value);
	}
	return a;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movq %rdx, %r14
movq %rsi, %r15
movq %rdi, %r12
callq 0xe5f9
movq %rax, %rbx
movq %r12, %rdi
callq 0xe27e
movq (%r12), %rax
movzbl (%rax), %ecx
cmpl $0x21, %ecx
je 0xe70f
cmpl $0x3d, %ecx
jne 0xe76c
cmpb $0x3d, 0x1(%rax)
jne 0xe70a
addq $0x2, %rax
movq %rax, (%r12)
movq %r12, %rdi
movq %r15, %rsi
movq %r14, %rdx
callq 0xe686
movq %rax, %r14
movq %rbx, %rdi
movq %rax, %rsi
callq 0x2070
movl %eax, %ebp
movq %rbx, %rdi
callq 0x2050
movq %r14, %rdi
callq 0x2050
testl %ebp, %ebp
leaq 0x3d66(%rip), %rax      # 0x12467
leaq 0x496f(%rip), %rdi      # 0x13077
jmp 0xe75b
cmpb $0x21, %cl
jne 0xe76c
cmpb $0x3d, 0x1(%rax)
jne 0xe76c
addq $0x2, %rax
movq %rax, (%r12)
movq %r12, %rdi
movq %r15, %rsi
movq %r14, %rdx
callq 0xe686
movq %rax, %r14
movq %rbx, %rdi
movq %rax, %rsi
callq 0x2070
movl %eax, %ebp
movq %rbx, %rdi
callq 0x2050
movq %r14, %rdi
callq 0x2050
testl %ebp, %ebp
leaq 0x4923(%rip), %rax      # 0x13077
leaq 0x3d0c(%rip), %rdi      # 0x12467
cmoveq %rax, %rdi
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
jmp 0x2350
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: eval
int eval(const char* s,item* config,reader* file)
{
	int result;
	char* a = eval0(&s,config,file);
	result = str2bool(a);
	free(a);
	return result;
}

// Assembly:
pushq %rbp
pushq %rbx
pushq %rax
movq %rsp, %rax
movq %rdi, (%rax)
movq %rax, %rdi
callq 0xe4d1
movq %rax, %rbx
cmpb $0x0, (%rax)
je 0xe7aa
leaq 0x48df(%rip), %rsi      # 0x13077
movq %rbx, %rdi
callq 0x21f0
xorl %ebp, %ebp
testl %eax, %eax
setne %bpl
jmp 0xe7ac
xorl %ebp, %ebp
movq %rbx, %rdi
callq 0x2050
movl %ebp, %eax
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O1/corecodec[P]coremake/coremake.c
// Function: match
int match(const char* name, const char* mask)
{
    if (*mask=='*')
    {
        ++mask;
        for (;!match(name,mask);++name)
        {
            if (*name==0)
                return 0;
        }
        return 1;
    }
    else
    {
        if (*mask==0)
            return *name==0;

        if (*name==0)
            return 0;

        return (mask[0]=='?' || same_ch(name[0],mask[0])) && match(name+1,mask+1);
    }
}

// Assembly:
pushq %rbp
pushq %r14
pushq %rbx
movq %rsi, %r14
movq %rdi, %rbx
incq %r14
xorl %ebp, %ebp
movzbl -0x1(%r14), %eax
testl %eax, %eax
je 0xe82f
cmpl $0x2a, %eax
je 0xe7fe
movb (%rbx), %cl
testb %cl, %cl
je 0xe838
cmpb $0x3f, %al
setne %dl
cmpb %al, %cl
setne %al
testb %al, %dl
jne 0xe838
incq %rbx
incq %r14
jmp 0xe7d4
movq %rbx, %rdi
movq %r14, %rsi
callq 0xe7c5
movl $0x1, %ebp
testl %eax, %eax
jne 0xe838
incq %rbx
cmpb $0x0, -0x1(%rbx)
je 0xe83f
movq %rbx, %rdi
movq %r14, %rsi
callq 0xe7c5
incq %rbx
testl %eax, %eax
je 0xe815
jmp 0xe838
xorl %ebp, %ebp
cmpb $0x0, (%rbx)
sete %bpl
movl %ebp, %eax
popq %rbx
popq %r14
popq %rbp
retq
xorl %ebp, %ebp
jmp 0xe838
// File: /workspace/github_cpp_makefile_star2_O1/corecodec[P]coremake/coremake.c
// Function: remove_file
void remove_file(const char* name)
{
	if (strchr(name,'*') == NULL && strchr(name,'?') == NULL)
		remove(name);
	else
	{
		DIR* dir;
        const char* mask = getfilename(name);
        char path[MAX_PATH];
		strncpy(path,name,MAX_PATH);
		truncfilepath(path,1);
		dir = opendir(path[0]?path:".");
		if (dir)
		{
			struct dirent* entry;
			addendpath(path);
			while ((entry = readdir(dir)) != NULL)
			{
				if (entry->d_name[0]!='.' && match(entry->d_name,mask))
				{
                    char filepath[MAX_PATH];
                    strcpy(filepath,path);
                    strcat(filepath,entry->d_name);
					remove(filepath);
				}
			}
			closedir(dir);
		}
	}
}

// Assembly:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x800, %rsp            # imm = 0x800
movq %rdi, %r14
movl $0x2a, %esi
callq 0x2130
testq %rax, %rax
jne 0xe87b
movq %r14, %rdi
movl $0x3f, %esi
callq 0x2130
testq %rax, %rax
je 0xe953
movq %r14, %rdi
movl $0x2f, %esi
callq 0x2150
leaq 0x1(%rax), %rbx
testq %rax, %rax
cmoveq %r14, %rbx
movq %rsp, %r15
movl $0x400, %edx            # imm = 0x400
movq %r15, %rdi
movq %r14, %rsi
callq 0x2080
movq %r15, %rdi
movl $0x1, %esi
callq 0x3e32
cmpb $0x0, (%r15)
leaq 0x48ed(%rip), %rdi      # 0x131ab
cmovneq %r15, %rdi
callq 0x2100
testq %rax, %rax
je 0xe942
movq %rax, %r14
movq %rsp, %rdi
callq 0x3df1
movq %r14, %rdi
callq 0x2250
testq %rax, %rax
je 0xe93a
movq %rax, %r13
leaq 0x400(%rsp), %r15
movq %rsp, %r12
cmpb $0x2e, 0x13(%r13)
je 0xe92a
addq $0x13, %r13
movq %r13, %rdi
movq %rbx, %rsi
callq 0xe7c5
testl %eax, %eax
je 0xe92a
movq %r15, %rdi
movq %r12, %rsi
callq 0x20b0
movq %r15, %rdi
movq %r13, %rsi
callq 0x2310
movq %r15, %rdi
callq 0x2090
movq %r14, %rdi
callq 0x2250
movq %rax, %r13
testq %rax, %rax
jne 0xe8f2
movq %r14, %rdi
callq 0x21a0
addq $0x800, %rsp            # imm = 0x800
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
movq %r14, %rdi
addq $0x800, %rsp            # imm = 0x800
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
jmp 0x2090
// File: /workspace/github_cpp_makefile_star2_O1/corecodec[P]coremake/coremake.c
// Function: remove_dir
void remove_dir(const char* name)
{
	DIR* dir = opendir(name);
	if (dir)
	{
		struct dirent* entry;
		while ((entry = readdir(dir)) != NULL)
		{
			if (entry->d_name[0]!='.')
			{
				char item[MAX_PATH];
				sprintf(item,"%s/%s",name,entry->d_name);
				remove_dir(item);
			}
		}
		closedir(dir);
        remove_dir(".DS_Store");
        remove_dir(".Trashes");
		rmdir(name);
	}
	else
		remove(name);
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x408, %rsp            # imm = 0x408
movq %rdi, %rbx
callq 0x2100
testq %rax, %rax
je 0xea0d
movq %rax, %r14
movq %rax, %rdi
callq 0x2250
testq %rax, %rax
je 0xe9d6
leaq 0x4857(%rip), %r15      # 0x131f8
movq %rsp, %r12
cmpb $0x2e, 0x13(%rax)
je 0xe9c9
addq $0x13, %rax
movq %r12, %rdi
movq %r15, %rsi
movq %rbx, %rdx
movq %rax, %rcx
xorl %eax, %eax
callq 0x2320
movq %r12, %rdi
callq 0xe96b
movq %r14, %rdi
callq 0x2250
testq %rax, %rax
jne 0xe9a4
movq %r14, %rdi
callq 0x21a0
leaq 0x4819(%rip), %rdi      # 0x131fe
callq 0xe96b
leaq 0x4817(%rip), %rdi      # 0x13208
callq 0xe96b
movq %rbx, %rdi
callq 0x2110
addq $0x408, %rsp            # imm = 0x408
popq %rbx
popq %r12
popq %r14
popq %r15
retq
movq %rbx, %rdi
addq $0x408, %rsp            # imm = 0x408
popq %rbx
popq %r12
popq %r14
popq %r15
jmp 0x2090
// File: /workspace/github_cpp_makefile_star2_O1/corecodec[P]coremake/coremake.c
// Function: reader_item
item* reader_item(reader* file, int skip, build_pos* pos)
{
    item* i = NULL;

	reader_name(file);
    if (!skip)
    {
        const char* token = file->token;
        build_pos* parent = pos;
        while (token[0]=='.' && token[1]=='.' && token[2]=='/')
        {
            if (parent)
                parent = parent->prev;
            token += 3;
        }
        if (parent)
    		i = item_get(parent->p,token,1);
    }

    return i;
}

// Assembly:
pushq %rbp
pushq %r14
pushq %rbx
movq %rdx, %rbx
movl %esi, %ebp
movq %rdi, %r14
callq 0x3b62
testl %ebp, %ebp
je 0xea3f
xorl %eax, %eax
popq %rbx
popq %r14
popq %rbp
retq
movq 0x30(%r14), %rax
cmpb $0x2e, (%rax)
jne 0xea6f
cmpb $0x2e, 0x1(%rax)
jne 0xea6f
cmpb $0x2f, 0x2(%rax)
jne 0xea6f
testq %rbx, %rbx
je 0xea5e
movq (%rbx), %rbx
jmp 0xea60
xorl %ebx, %ebx
leaq 0x3(%rax), %rsi
cmpb $0x2e, 0x3(%rax)
movq %rsi, %rax
je 0xea48
jmp 0xea72
movq %rax, %rsi
testq %rbx, %rbx
je 0xea38
movq 0x8(%rbx), %rdi
movl $0x1, %edx
popq %rbx
popq %r14
popq %rbp
jmp 0x2745