LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_cpp_makefile_star2_O3/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 0x3ff4
testl %eax, %eax
je 0x8cdb
leaq 0x90(%rsp), %rbx
movq %rbx, %rdi
movq %r14, %rsi
callq 0x20b0
movzbl (%rbx), %eax
cmpl $0x5c, %eax
je 0x8bc1
testl %eax, %eax
jne 0x8bc4
jmp 0x8bc9
movb $0x2f, (%rbx)
incq %rbx
jmp 0x8bb3
leaq 0x90(%rsp), %rbx
movq %rbx, %rdi
movl $0x1, %esi
callq 0x43fb
leaq 0x95c1(%rip), %rsi      # 0x121a6
movq %rbx, %rdi
callq 0x21b0
movq %rax, %r13
movq %rbx, %rdi
callq 0x2120
cmpq %rax, %r13
je 0x8ca0
xorl %r14d, %r14d
leaq 0x490(%rsp), %rbx
movq %rsp, %r15
leaq 0x9590(%rip), %r12      # 0x121a6
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 0x8c6f
cmpq $0x2, %r14
jb 0x8c76
cmpb $0x3a, -0x1(%rbp,%rbx)
je 0x8c76
movq %rbx, %rdi
movl $0x1c0, %esi            # imm = 0x1C0
callq 0x20c0
testl %eax, %eax
je 0x8c76
cmpl $0x11, %eax
je 0x8c76
jmp 0x8cd2
testb $0x40, 0x19(%rsp)
je 0x8cb2
leaq (%rsp,%r14), %rbp
addq $0x90, %rbp
movq %rbp, %rdi
movq %r12, %rsi
callq 0x21b0
movq %rax, %r13
movq %rbp, %rdi
callq 0x2120
cmpq %rax, %r13
jne 0x8c16
addq $0x898, %rsp            # imm = 0x898
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
leaq 0x958a(%rip), %rdi      # 0x12243
leaq 0x490(%rsp), %rsi
xorl %eax, %eax
callq 0x2140
movl $0x1, %edi
callq 0x2320
leaq 0x9582(%rip), %rdi      # 0x1225b
jmp 0x8cb9
leaq 0x952a(%rip), %rdi      # 0x1220c
leaq 0x83bd(%rip), %rsi      # 0x110a6
leaq 0x952c(%rip), %rcx      # 0x1221c
movl $0x1210, %edx           # imm = 0x1210
callq 0x2160
// File: /workspace/github_cpp_makefile_star2_O3/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 0x281b
orb $-0x80, 0x30(%r15)
testq %rax, %rax
je 0xa71c
movq %rax, %r14
testb $0x40, 0x30(%rax)
jne 0xa71c
leaq 0x6a83(%rip), %rsi      # 0x110dc
xorl %r12d, %r12d
movq %r14, %rdi
xorl %edx, %edx
callq 0x270b
movq %rax, %r15
testq %r15, %r15
je 0xa67c
movq 0x20(%r15), %rax
subq 0x18(%r15), %rax
sarq $0x3, %rax
jmp 0xa67e
xorl %eax, %eax
cmpq %rax, %r12
jae 0xa6b7
movq 0x18(%r15), %rax
movq (%rax,%r12,8), %rax
testb $0x40, 0x30(%rax)
jne 0xa6b2
movq (%rax), %rsi
movq %rbx, %rdi
movl $0x1, %edx
callq 0x270b
testb $-0x80, 0x30(%rax)
jne 0xa6b2
movq %rbx, %rdi
movq %rax, %rsi
callq 0xa621
incq %r12
jmp 0xa669
leaq 0x6a1a(%rip), %rsi      # 0x110d8
xorl %r15d, %r15d
movq %r14, %rdi
xorl %edx, %edx
callq 0x270b
movq %rax, %r14
testq %r14, %r14
je 0xa6e1
movq 0x20(%r14), %rax
subq 0x18(%r14), %rax
sarq $0x3, %rax
jmp 0xa6e3
xorl %eax, %eax
cmpq %rax, %r15
jae 0xa71c
movq 0x18(%r14), %rax
movq (%rax,%r15,8), %rax
testb $0x40, 0x30(%rax)
jne 0xa717
movq (%rax), %rsi
movq %rbx, %rdi
movl $0x1, %edx
callq 0x270b
testb $-0x80, 0x30(%rax)
jne 0xa717
movq %rbx, %rdi
movq %rax, %rsi
callq 0xa621
incq %r15
jmp 0xa6ce
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
// File: /workspace/github_cpp_makefile_star2_O3/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 0xa74a
movq 0x18(%rdi), %rax
movq 0x20(%rdi), %rcx
cmpq %rcx, %rax
je 0xa74a
movq (%rax), %rdx
andl $0xffffff7f, 0x30(%rdx) # imm = 0xFFFFFF7F
addq $0x8, %rax
jmp 0xa735
retq
// File: /workspace/github_cpp_makefile_star2_O3/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 0xa858
movq %rdi, %rbx
leaq 0x6970(%rip), %r14      # 0x110dc
movq (%r12), %rdi
movq %r14, %rsi
xorl %edx, %edx
callq 0x270b
movq %rax, %r15
xorl %eax, %eax
testq %r15, %r15
je 0xa792
movq 0x20(%r15), %rcx
subq 0x18(%r15), %rcx
sarq $0x3, %rcx
jmp 0xa794
xorl %ecx, %ecx
cmpq %rcx, %rax
jae 0xa7ad
movq 0x18(%r15), %rcx
movq (%rcx,%rax,8), %rcx
andl $0xffffff7f, 0x30(%rcx) # imm = 0xFFFFFF7F
incq %rax
jmp 0xa77f
testq %r15, %r15
je 0xa83d
xorl %r13d, %r13d
movq 0x20(%r15), %rax
subq 0x18(%r15), %rax
sarq $0x3, %rax
cmpq %rax, %r13
jae 0xa7ea
movq 0x18(%r15), %rax
movq (%rax,%r13,8), %rsi
testb $-0x80, 0x30(%rsi)
jne 0xa7e0
movq %r15, %rdi
callq 0xa621
incq %r13
testq %r15, %r15
jne 0xa7b9
jmp 0xa83d
movq 0x18(%r15), %rax
movq 0x20(%r15), %rcx
cmpq %rax, %rcx
je 0xa838
xorl %r13d, %r13d
movq (%rax,%r13,8), %rdi
callq 0x281b
testq %rax, %rax
je 0xa80e
testb $0x40, 0x30(%rax)
je 0xa81e
movq 0x18(%r15), %rax
movq (%rax,%r13,8), %rdi
callq 0x2d5b
decq %r13
incq %r13
movq 0x18(%r15), %rax
movq 0x20(%r15), %rcx
movq %rcx, %rdx
subq %rax, %rdx
sarq $0x3, %rdx
cmpq %rdx, %r13
jb 0xa7fa
cmpq %rax, %rcx
jne 0xa84a
movq (%r12), %rdi
callq 0x2d5b
addq $-0x8, %r12
addq $0x8, %r12
cmpq 0x20(%rbx), %r12
jne 0xa76c
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
// File: /workspace/github_cpp_makefile_star2_O3/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 0x6d0b(%rip), %rsi      # 0x11586
xorl %r13d, %r13d
xorl %edi, %edi
xorl %edx, %edx
callq 0x270b
movq %rax, %r14
leaq 0x77df(%rip), %rsi      # 0x12070
movq %rbx, %rdi
callq 0x2694
movq %r14, %rdi
movq %rax, %rsi
callq 0x25bf
movq %r12, %rdi
movq %rbx, %rsi
movq %r15, %rdx
callq 0x334a
testq %r14, %r14
je 0xa8c5
movq 0x20(%r14), %rax
subq 0x18(%r14), %rax
sarq $0x3, %rax
jmp 0xa8c7
xorl %eax, %eax
cmpq %rax, %r13
jae 0xa8e1
movq 0x18(%r14), %rax
movq (%rax,%r13,8), %rsi
movq %rbx, %rdi
callq 0x25bf
incq %r13
jmp 0xa8b2
movq %r14, %rdi
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
jmp 0x2d5b
// File: /workspace/github_cpp_makefile_star2_O3/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)
movq %rsi, 0x10(%rsp)
testq %rdi, %rdi
je 0xaa0e
movq %rdi, %r15
movq 0x18(%rdi), %rbx
cmpq 0x20(%r15), %rbx
je 0xaa0e
movq (%rbx), %rdi
leaq 0x67ae(%rip), %rsi      # 0x110dc
xorl %edx, %edx
callq 0x270b
movq %rax, %rbp
movq %rax, %rdi
movq 0x10(%rsp), %rsi
callq 0x2694
testq %rax, %rax
je 0xaa05
testb $0x40, 0x30(%rax)
jne 0xaa05
movq %rax, %rdi
callq 0x2d5b
movq (%rbx), %r14
movq (%r14), %r13
movq 0x8(%rsp), %rax
movq (%rax), %r12
movq %r13, %rdi
movq %r12, %rsi
callq 0x2070
testl %eax, %eax
je 0xaa05
movq 0x8(%rsp), %rdi
leaq 0x674f(%rip), %rsi      # 0x110dc
callq 0x2694
movq %rax, %rdi
movq %r13, %rsi
callq 0x2694
testq %rax, %rax
je 0xa9f5
movq %rax, %r13
movq 0x10(%r14), %rax
testq %rax, %rax
je 0xa9c1
movq (%rax), %rdi
leaq 0x77e7(%rip), %rsi      # 0x1219f
callq 0x2070
testl %eax, %eax
je 0xaa05
movq 0x8(%rsp), %r14
movq %r14, %rdi
leaq 0x6708(%rip), %rsi      # 0x110d8
xorl %edx, %edx
callq 0x270b
movq (%rbx), %rcx
movq (%rcx), %rsi
movq %rax, %rdi
movl $0x1, %edx
callq 0x270b
movq %r13, %rdi
callq 0x2d5b
movq (%r14), %r12
movq %rbp, %rdi
movq %r12, %rsi
movl $0x1, %edx
callq 0x270b
addq $0x8, %rbx
jmp 0xa91a
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O3/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 0xaf11
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 0xae42
leaq 0x627c(%rip), %rsi      # 0x110d1
xorl %r12d, %r12d
xorl %edx, %edx
callq 0x270b
movq %rax, %rdi
movq %r14, %rsi
callq 0x2694
testq %rax, %rax
je 0xae90
movq 0x18(%rax), %rcx
movq 0x20(%rax), %rax
cmpq %rax, %rcx
je 0xae8d
movq (%rcx), %r12
testb $0x40, 0x30(%r12)
je 0xae90
addq $0x8, %rcx
jmp 0xae77
xorl %r12d, %r12d
movq 0x18(%rbx), %r13
cmpq 0x20(%rbx), %r13
je 0xaf08
leaq 0x67e7(%rip), %r14      # 0x11688
movq (%r13), %r15
testq %r12, %r12
je 0xaef6
movq %r15, %rdi
movq %r14, %rsi
callq 0x2694
testq %rax, %rax
je 0xaed6
movq 0x18(%rax), %rcx
movq 0x20(%rax), %rax
cmpq %rax, %rcx
je 0xaed6
movq (%rcx), %rdx
testb $0x40, 0x30(%rdx)
je 0xaefe
addq $0x8, %rcx
jmp 0xaec2
movq %r15, %rdi
movq %r14, %rsi
xorl %edx, %edx
callq 0x270b
movq (%r12), %rsi
movq %rax, %rdi
movl $0x1, %edx
callq 0x270b
jmp 0xaefe
movq %r15, %rdi
callq 0x5e99
addq $0x8, %r13
cmpq 0x20(%rbx), %r13
jne 0xaea1
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
// File: /workspace/github_cpp_makefile_star2_O3/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 0xaf7a
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
movq 0x18(%rdi), %rax
cmpq %rax, 0x20(%rdi)
je 0xaf73
xorl %r14d, %r14d
movq (%rax,%r14,8), %rdi
callq 0x281b
testq %rax, %rax
je 0xaf5c
movq 0x18(%rbx), %rcx
movq (%rcx,%r14,8), %rdx
movq %rax, %rdi
movq %rdx, %rsi
callq 0xa862
movq 0x18(%rbx), %rax
movq (%rax,%r14,8), %rdi
callq 0x2d5b
decq %r14
incq %r14
movq 0x18(%rbx), %rax
movq 0x20(%rbx), %rcx
subq %rax, %rcx
sarq $0x3, %rcx
cmpq %rcx, %r14
jb 0xaf2b
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_cpp_makefile_star2_O3/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 0xb04f
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 0xb041
leaq 0x6156(%rip), %r15      # 0x110fd
movq (%rbp), %rdi
leaq 0x612a(%rip), %rsi      # 0x110dc
xorl %edx, %edx
callq 0x270b
movq %rax, %r12
xorl %r14d, %r14d
testq %r12, %r12
je 0xafd4
movq 0x20(%r12), %rax
subq 0x18(%r12), %rax
sarq $0x3, %rax
jmp 0xafd6
xorl %eax, %eax
cmpq %rax, %r14
jae 0xb033
movq %rbx, %rax
movq %rax, %rdi
movq 0x10(%rax), %rax
testq %rax, %rax
jne 0xafde
movq %r15, %rsi
xorl %edx, %edx
callq 0x270b
movq 0x18(%r12), %rcx
movq (%rcx,%r14,8), %r13
movq (%r13), %rsi
movq %rax, %rdi
callq 0x2694
testq %rax, %rax
je 0xb02e
movq (%rbp), %rdi
movq %rax, %rsi
movq %r13, %rdx
callq 0xa862
movq 0x18(%r12), %rax
movq (%rax,%r14,8), %rdi
callq 0x2d5b
decq %r14
incq %r14
jmp 0xafbf
addq $0x8, %rbp
cmpq 0x20(%rbx), %rbp
jne 0xafa7
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O3/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
pushq %rax
movb (%rsi), %al
testb %al, %al
je 0xb911
incq %rsi
movl $0x1, %r11d
movl $0x1, %r10d
movl $0x1, %r9d
movl %r11d, %ecx
movzbl %al, %eax
movl %r9d, %edx
imull %eax, %edx
addl %edx, %r9d
addl $0x33299112, %r9d       # imm = 0x33299112
xorl %r10d, %r9d
movl %r10d, %edx
imull %eax, %edx
leal (%rdx,%rcx), %r11d
addl $0x1345af22, %r11d      # imm = 0x1345AF22
xorl %ecx, %r11d
imull %r11d, %eax
addl %eax, %r10d
addl $0x73a92332, %r10d      # imm = 0x73A92332
xorl %r9d, %r10d
movb (%rsi), %al
incq %rsi
testb %al, %al
jne 0xb88a
movl %r11d, %ebx
shrl $0x8, %ebx
movl %r11d, %r14d
shrl $0x10, %r14d
movl %r11d, %r15d
shrl $0x18, %r15d
movl %r10d, %r12d
shrl $0x8, %r12d
movl %r10d, %r13d
shrl $0x10, %r13d
movl %r10d, %ebp
shrl $0x18, %ebp
movl $0xff, %eax
andl %eax, %r11d
andl %eax, %ebx
andl %eax, %r14d
andl %eax, %r10d
andl %eax, %r12d
andl %eax, %r13d
jmp 0xb933
movl $0x1, %r10d
xorl %ebp, %ebp
xorl %r13d, %r13d
xorl %r12d, %r12d
xorl %r15d, %r15d
xorl %r14d, %r14d
xorl %ebx, %ebx
movl $0x1, %r11d
movl $0x1, %r9d
movl $0xff, %eax
movl %r9d, %edx
andl %eax, %edx
movl %r9d, %ecx
shrl $0x8, %ecx
andl %eax, %ecx
movl %r9d, %r8d
shrl $0x10, %r8d
andl %eax, %r8d
shrl $0x18, %r9d
leaq 0x6585(%rip), %rsi      # 0x11edf
xorl %eax, %eax
pushq %rbp
pushq %r13
pushq %r12
pushq %r10
pushq %r15
pushq %r14
pushq %rbx
pushq %r11
callq 0x2310
addq $0x48, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O3/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 $0x28, %rsp
movb (%rsi), %al
testb %al, %al
je 0xba6f
incq %rsi
movl $0x1, %r10d
movl $0x1, %ebx
movl $0x1, %r11d
movl $0x1, %r9d
movzbl %al, %eax
movl %r11d, %ecx
imull %eax, %ecx
addl %ecx, %r9d
addl $0x33299112, %r9d       # imm = 0x33299112
xorl %ebx, %r9d
movl %ebx, %ecx
imull %eax, %ecx
addl %ecx, %r10d
addl $0x1345af22, %r10d      # imm = 0x1345AF22
xorl %r11d, %r10d
movl %r9d, %ecx
imull %eax, %ecx
addl %ecx, %r11d
addl $0x73a92332, %r11d      # imm = 0x73A92332
xorl %r10d, %r11d
imull %r10d, %eax
addl %eax, %ebx
addl $0x5123abc1, %ebx       # imm = 0x5123ABC1
xorl %r9d, %ebx
movb (%rsi), %al
incq %rsi
testb %al, %al
jne 0xb9b0
movl %r10d, %ecx
shrl $0x8, %ecx
movl %r10d, %r15d
shrl $0x10, %r15d
movl %r10d, %eax
shrl $0x18, %eax
movq %rax, 0x18(%rsp)
movl %r11d, %r13d
shrl $0x8, %r13d
movl %r11d, %ebp
shrl $0x10, %ebp
movl %r11d, %eax
shrl $0x18, %eax
movq %rax, 0x10(%rsp)
movl %ebx, %r12d
shrl $0x8, %r12d
movl %ebx, %r14d
shrl $0x10, %r14d
movl %ebx, %eax
shrl $0x18, %eax
movq %rax, 0x8(%rsp)
movl $0xff, %eax
andl %eax, %r10d
andl %eax, %ecx
movq %rcx, 0x20(%rsp)
andl %eax, %r15d
andl %eax, %r11d
andl %eax, %r13d
andl %eax, %ebp
andl %eax, %ebx
andl %eax, %r12d
andl %eax, %r14d
jmp 0xbab8
movl $0x1, %ebx
movq $0x0, 0x8(%rsp)
xorl %r14d, %r14d
xorl %r12d, %r12d
movq $0x0, 0x10(%rsp)
xorl %ebp, %ebp
xorl %r13d, %r13d
movl $0x1, %r11d
movq $0x0, 0x18(%rsp)
xorl %r15d, %r15d
movq $0x0, 0x20(%rsp)
movl $0x1, %r10d
movl $0x1, %r9d
movl $0xff, %eax
movl %r9d, %edx
andl %eax, %edx
movl %r9d, %ecx
shrl $0x8, %ecx
andl %eax, %ecx
movl %r9d, %r8d
shrl $0x10, %r8d
andl %eax, %r8d
shrl $0x18, %r9d
leaq 0x63f0(%rip), %rsi      # 0x11ecf
xorl %eax, %eax
pushq 0x8(%rsp)
pushq %r14
pushq %r12
pushq %rbx
pushq 0x30(%rsp)
pushq %rbp
pushq %r13
pushq %r11
pushq 0x58(%rsp)
pushq %r15
pushq 0x70(%rsp)
pushq %r10
callq 0x2310
addq $0x88, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O3/corecodec[P]coremake/coremake.c
// Function: generate_msuid
void generate_msuid(char *msuid,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(msuid,"{%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 $0x28, %rsp
movb (%rsi), %al
testb %al, %al
je 0xbc07
incq %rsi
movl $0x1, %r10d
movl $0x1, %ebx
movl $0x1, %r11d
movl $0x1, %r9d
movzbl %al, %eax
movl %r11d, %ecx
imull %eax, %ecx
addl %ecx, %r9d
addl $0x33299112, %r9d       # imm = 0x33299112
xorl %ebx, %r9d
movl %ebx, %ecx
imull %eax, %ecx
addl %ecx, %r10d
addl $0x1345af22, %r10d      # imm = 0x1345AF22
xorl %r11d, %r10d
movl %r9d, %ecx
imull %eax, %ecx
addl %ecx, %r11d
addl $0x73a92332, %r11d      # imm = 0x73A92332
xorl %r10d, %r11d
imull %r10d, %eax
addl %eax, %ebx
addl $0x5123abc1, %ebx       # imm = 0x5123ABC1
xorl %r9d, %ebx
movb (%rsi), %al
incq %rsi
testb %al, %al
jne 0xbb48
movl %r10d, %ecx
shrl $0x8, %ecx
movl %r10d, %r15d
shrl $0x10, %r15d
movl %r10d, %eax
shrl $0x18, %eax
movq %rax, 0x18(%rsp)
movl %r11d, %r13d
shrl $0x8, %r13d
movl %r11d, %ebp
shrl $0x10, %ebp
movl %r11d, %eax
shrl $0x18, %eax
movq %rax, 0x10(%rsp)
movl %ebx, %r12d
shrl $0x8, %r12d
movl %ebx, %r14d
shrl $0x10, %r14d
movl %ebx, %eax
shrl $0x18, %eax
movq %rax, 0x8(%rsp)
movl $0xff, %eax
andl %eax, %r10d
andl %eax, %ecx
movq %rcx, 0x20(%rsp)
andl %eax, %r15d
andl %eax, %r11d
andl %eax, %r13d
andl %eax, %ebp
andl %eax, %ebx
andl %eax, %r12d
andl %eax, %r14d
jmp 0xbc50
movl $0x1, %ebx
movq $0x0, 0x8(%rsp)
xorl %r14d, %r14d
xorl %r12d, %r12d
movq $0x0, 0x10(%rsp)
xorl %ebp, %ebp
xorl %r13d, %r13d
movl $0x1, %r11d
movq $0x0, 0x18(%rsp)
xorl %r15d, %r15d
movq $0x0, 0x20(%rsp)
movl $0x1, %r10d
movl $0x1, %r9d
movl $0xff, %eax
movl %r9d, %edx
andl %eax, %edx
movl %r9d, %ecx
shrl $0x8, %ecx
andl %eax, %ecx
movl %r9d, %r8d
shrl $0x10, %r8d
andl %eax, %r8d
shrl $0x18, %r9d
leaq 0x6299(%rip), %rsi      # 0x11f10
xorl %eax, %eax
pushq 0x8(%rsp)
pushq %r14
pushq %r12
pushq %rbx
pushq 0x30(%rsp)
pushq %rbp
pushq %r13
pushq %r11
pushq 0x58(%rsp)
pushq %r15
pushq 0x70(%rsp)
pushq %r10
callq 0x2310
addq $0x88, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O3/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 0xbd04
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rdi, %rbx
movq 0x18(%rdi), %r12
cmpq 0x20(%rdi), %r12
je 0xbcf9
leaq 0x540d(%rip), %r14      # 0x110dc
leaq -0x9208(%rip), %r15     # 0x2ace
movq (%r12), %rdi
movq %r14, %rsi
xorl %edx, %edx
callq 0x270b
movq %rax, %rdi
movq %r15, %rsi
callq 0x2c7c
addq $0x8, %r12
cmpq 0x20(%rbx), %r12
jne 0xbcd6
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
// File: /workspace/github_cpp_makefile_star2_O3/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 0xe102
callq 0x2360
movq (%rax), %rax
movsbq %bpl, %rcx
testb $0x20, 0x1(%rax,%rcx,2)
je 0xe0f5
movb 0x1(%rbx), %bpl
incq %rbx
testb %bpl, %bpl
jne 0xe0ca
jmp 0xe102
movb %bpl, (%r14)
incq %r14
movb 0x1(%rbx), %bpl
incq %rbx
testb %bpl, %bpl
je 0xe102
movsbl %bpl, %edi
callq 0x3704
testl %eax, %eax
jne 0xe0e3
movb $0x0, (%r14)
movq %rbx, %rax
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O3/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 0xe1a6
movq %rax, %r15
leaq 0x1(%r15), %r12
movq %r12, %rdi
callq 0x2120
leaq 0x1(%rax), %rdx
movq %r15, %rdi
movq %r12, %rsi
callq 0x22c0
leaq 0x6(%r15), %r13
movq %r15, %rdi
callq 0x2120
leaq 0x1(%rax), %rdx
movq %r13, %rdi
movq %r15, %rsi
callq 0x22c0
movl $0x6f757126, (%r15)     # imm = 0x6F757126
movw $0x3b74, 0x4(%r15)      # imm = 0x3B74
testl %ebx, %ebx
jne 0xe191
movq %r15, %rdi
callq 0x2120
leaq 0x1(%rax), %rdx
movq %r12, %rdi
movq %r15, %rsi
callq 0x22c0
movb $0x5c, (%r15)
movq %r14, %rdi
movl $0x22, %esi
callq 0x2150
movq %rax, %r15
testq %rax, %rax
jne 0xe12e
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
// File: /workspace/github_cpp_makefile_star2_O3/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 0xe629
movq %rax, %rbx
movq %r12, %rdi
callq 0xe21c
movq (%r12), %rax
movzbl (%rax), %ecx
cmpl $0x7c, %ecx
je 0xe501
cmpl $0x26, %ecx
jne 0xe55f
cmpb $0x26, 0x1(%rax)
jne 0xe55f
addq $0x2, %rax
movq %rax, (%r12)
movq %r12, %rdi
movq %r15, %rsi
movq %r14, %rdx
callq 0xe46d
movq %rax, %r14
movzbl (%rbx), %eax
leaq 0x3ba9(%rip), %r15      # 0x12079
testl %eax, %eax
je 0xe575
cmpl $0x30, %eax
jne 0xe4e7
cmpb $0x0, 0x1(%rbx)
je 0xe575
movzbl (%r14), %eax
testl %eax, %eax
je 0xe575
cmpl $0x30, %eax
je 0xe546
leaq 0x2f6a(%rip), %r15      # 0x11469
jmp 0xe575
cmpb $0x7c, 0x1(%rax)
jne 0xe55f
addq $0x2, %rax
movq %rax, (%r12)
movq %r12, %rdi
movq %r15, %rsi
movq %r14, %rdx
callq 0xe46d
movq %rax, %r14
movzbl (%rbx), %eax
leaq 0x2f3f(%rip), %r15      # 0x11469
testl %eax, %eax
je 0xe539
cmpl $0x30, %eax
jne 0xe575
cmpb $0x0, 0x1(%rbx)
jne 0xe575
movzbl (%r14), %eax
testl %eax, %eax
je 0xe56e
cmpl $0x30, %eax
jne 0xe575
cmpb $0x0, 0x1(%r14)
leaq 0x3b27(%rip), %rax      # 0x12079
leaq 0x2f10(%rip), %r15      # 0x11469
cmoveq %rax, %r15
jmp 0xe575
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
leaq 0x3b04(%rip), %r15      # 0x12079
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 0x2340
// File: /workspace/github_cpp_makefile_star2_O3/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 0xe21c
movq (%r15), %rax
cmpb $0x21, (%rax)
jne 0xe5b9
cmpb $0x3d, 0x1(%rax)
jne 0xe5cc
movq %r15, %rdi
movq %r14, %rsi
movq %rbx, %rdx
popq %rbx
popq %r14
popq %r15
jmp 0xe257
incq %rax
movq %rax, (%r15)
movq %r15, %rdi
movq %r14, %rsi
movq %rbx, %rdx
callq 0xe598
movzbl (%rax), %ecx
testl %ecx, %ecx
je 0xe604
cmpl $0x30, %ecx
jne 0xe60d
cmpb $0x0, 0x1(%rax)
leaq 0x2e72(%rip), %rcx      # 0x11469
leaq 0x3a7b(%rip), %rbx      # 0x12079
cmoveq %rcx, %rbx
jmp 0xe614
leaq 0x2e5e(%rip), %rbx      # 0x11469
jmp 0xe614
leaq 0x3a65(%rip), %rbx      # 0x12079
movq %rax, %rdi
callq 0x2050
movq %rbx, %rdi
popq %rbx
popq %r14
popq %r15
jmp 0x2340
// File: /workspace/github_cpp_makefile_star2_O3/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 0xe598
movq %rax, %rbx
movq %r12, %rdi
callq 0xe21c
movq (%r12), %rax
movzbl (%rax), %ecx
cmpl $0x21, %ecx
je 0xe6b1
cmpl $0x3d, %ecx
jne 0xe70e
cmpb $0x3d, 0x1(%rax)
jne 0xe70e
addq $0x2, %rax
movq %rax, (%r12)
movq %r12, %rdi
movq %r15, %rsi
movq %r14, %rdx
callq 0xe629
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 0x2dc1(%rip), %rax      # 0x11469
leaq 0x39ca(%rip), %rdi      # 0x12079
jmp 0xe6fd
cmpb $0x3d, 0x1(%rax)
jne 0xe70e
addq $0x2, %rax
movq %rax, (%r12)
movq %r12, %rdi
movq %r15, %rsi
movq %r14, %rdx
callq 0xe629
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 0x3983(%rip), %rax      # 0x12079
leaq 0x2d6c(%rip), %rdi      # 0x11469
cmoveq %rax, %rdi
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
jmp 0x2340
movq %rbx, %rax
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O3/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 %rbx
subq $0x10, %rsp
leaq 0x8(%rsp), %rax
movq %rdi, (%rax)
movq %rax, %rdi
callq 0xe46d
movzbl (%rax), %ebx
testl %ebx, %ebx
je 0xe74b
cmpl $0x30, %ebx
jne 0xe746
xorl %ebx, %ebx
cmpb $0x0, 0x1(%rax)
setne %bl
jmp 0xe74b
movl $0x1, %ebx
movq %rax, %rdi
callq 0x2050
movl %ebx, %eax
addq $0x10, %rsp
popq %rbx
retq
// File: /workspace/github_cpp_makefile_star2_O3/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 0xe7cd
cmpl $0x2a, %eax
je 0xe79c
movb (%rbx), %cl
testb %cl, %cl
je 0xe7d6
cmpb $0x3f, %al
setne %dl
cmpb %al, %cl
setne %al
testb %al, %dl
jne 0xe7d6
incq %rbx
incq %r14
jmp 0xe772
movq %rbx, %rdi
movq %r14, %rsi
callq 0xe763
movl $0x1, %ebp
testl %eax, %eax
jne 0xe7d6
incq %rbx
cmpb $0x0, -0x1(%rbx)
je 0xe7dd
movq %rbx, %rdi
movq %r14, %rsi
callq 0xe763
incq %rbx
testl %eax, %eax
je 0xe7b3
jmp 0xe7d6
xorl %ebp, %ebp
cmpb $0x0, (%rbx)
sete %bpl
movl %ebp, %eax
popq %rbx
popq %r14
popq %rbp
retq
xorl %ebp, %ebp
jmp 0xe7d6
// File: /workspace/github_cpp_makefile_star2_O3/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 0xe819
movq %r14, %rdi
movl $0x3f, %esi
callq 0x2130
testq %rax, %rax
je 0xe8f1
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 0x3e10
cmpb $0x0, (%r15)
leaq 0x2935(%rip), %rdi      # 0x11191
cmovneq %r15, %rdi
callq 0x2100
testq %rax, %rax
je 0xe8e0
movq %rax, %r14
movq %rsp, %rdi
callq 0x3dcf
movq %r14, %rdi
callq 0x2250
testq %rax, %rax
je 0xe8d8
movq %rax, %r13
leaq 0x400(%rsp), %r15
movq %rsp, %r12
cmpb $0x2e, 0x13(%r13)
je 0xe8c8
addq $0x13, %r13
movq %r13, %rdi
movq %rbx, %rsi
callq 0xe763
testl %eax, %eax
je 0xe8c8
movq %r15, %rdi
movq %r12, %rsi
callq 0x20b0
movq %r15, %rdi
movq %r13, %rsi
callq 0x2300
movq %r15, %rdi
callq 0x2090
movq %r14, %rdi
callq 0x2250
movq %rax, %r13
testq %rax, %rax
jne 0xe890
movq %r14, %rdi
callq 0x2190
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_O3/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 0xe9ab
movq %rax, %r14
movq %rax, %rdi
callq 0x2250
testq %rax, %rax
je 0xe974
leaq 0x38b4(%rip), %r15      # 0x121f3
movq %rsp, %r12
cmpb $0x2e, 0x13(%rax)
je 0xe967
addq $0x13, %rax
movq %r12, %rdi
movq %r15, %rsi
movq %rbx, %rdx
movq %rax, %rcx
xorl %eax, %eax
callq 0x2310
movq %r12, %rdi
callq 0xe909
movq %r14, %rdi
callq 0x2250
testq %rax, %rax
jne 0xe942
movq %r14, %rdi
callq 0x2190
leaq 0x3876(%rip), %rdi      # 0x121f9
callq 0xe909
leaq 0x3874(%rip), %rdi      # 0x12203
callq 0xe909
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_O3/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 0x3b40
testl %ebp, %ebp
je 0xe9dd
xorl %eax, %eax
popq %rbx
popq %r14
popq %rbp
retq
movq 0x30(%r14), %rax
cmpb $0x2e, (%rax)
jne 0xea0d
cmpb $0x2e, 0x1(%rax)
jne 0xea0d
cmpb $0x2f, 0x2(%rax)
jne 0xea0d
testq %rbx, %rbx
je 0xe9fc
movq (%rbx), %rbx
jmp 0xe9fe
xorl %ebx, %ebx
leaq 0x3(%rax), %rsi
cmpb $0x2e, 0x3(%rax)
movq %rsi, %rax
je 0xe9e6
jmp 0xea10
movq %rax, %rsi
testq %rbx, %rbx
je 0xe9d6
movq 0x8(%rbx), %rdi
movl $0x1, %edx
popq %rbx
popq %r14
popq %rbp
jmp 0x270b
// File: /workspace/github_cpp_makefile_star2_O3/corecodec[P]coremake/coremake.c
// Function: getarg
void getarg(char* s, const char** in)
{
    int quote = 0;

	while (**in && isspace(**in))
        ++(*in);

	for (;**in && (quote || !isspace(**in));++(*in))
    {
        if (**in == '"')
        {
            quote = !quote;
            continue;
        }
        *(s++) = **in;
    }

    *s = 0;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movq %rdi, %rbx
movq (%rsi), %r15
movb (%r15), %bpl
testb %bpl, %bpl
je 0xeab3
movq %rsi, %r14
callq 0x2360
incq %r15
movq (%rax), %rcx
movsbq %bpl, %rdx
testb $0x20, 0x1(%rcx,%rdx,2)
je 0xea66
movq %r15, (%r14)
movb (%r15), %bpl
incq %r15
testb %bpl, %bpl
jne 0xea48
jmp 0xeab3
decq %r15
xorl %r12d, %r12d
testl %r12d, %r12d
jne 0xea84
callq 0x2360
movq (%rax), %rax
movsbq %bpl, %rcx
testb $0x20, 0x1(%rax,%rcx,2)
jne 0xeab3
cmpb $0x22, %bpl
jne 0xea97
xorl %eax, %eax
testl %r12d, %r12d
sete %al
movl %eax, %r12d
jmp 0xeaa0
movb %bpl, (%rbx)
incq %rbx
movq (%r14), %r15
leaq 0x1(%r15), %rax
movq %rax, (%r14)
movb 0x1(%r15), %bpl
movq %rax, %r15
testb %bpl, %bpl
jne 0xea6c
movb $0x0, (%rbx)
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O3/corecodec[P]coremake/coremake.c
// Function: build_file
void build_file(item* p,const char* filename, int reader_flags)
{
	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)
	{
		printf("'%s' build file not found!\r\n",filename);
		exit(1);
	}
    r.r.flags = reader_flags;
    r.r.filename_kind = reader_flags;
	build_parse(p,&r,0,0,NULL);
	fclose(r.r.f);
    reader_free(&r);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
subq $0x48, %rsp
movl %edx, %ebp
movq %rsi, %r14
movq %rdi, %rbx
leaq 0x8(%rsp), %r15
movq %r15, %rdi
callq 0x33d9
movq 0x38(%r15), %r15
movq %r15, %rdi
movq %r14, %rsi
callq 0x20b0
movzbl (%r15), %eax
cmpl $0x5c, %eax
je 0x105c6
testl %eax, %eax
jne 0x105ca
jmp 0x105cf
movb $0x2f, (%r15)
incq %r15
jmp 0x105b7
leaq 0xd9b(%rip), %rsi       # 0x11371
movq %r14, %rdi
callq 0x22d0
movq %rax, 0x8(%rsp)
movq 0x30(%rsp), %rcx
movq %rcx, 0x28(%rsp)
testq %rax, %rax
je 0x1063f
leaq 0x8(%rsp), %r14
movl %ebp, 0x10(%r14)
movl %ebp, 0x14(%r14)
movq %rbx, %rdi
movq %r14, %rsi
xorl %edx, %edx
xorl %ecx, %ecx
xorl %r8d, %r8d
callq 0xeabf
movq (%r14), %rdi
callq 0x20f0
movq 0x38(%r14), %rdi
callq 0x2050
movq 0x28(%r14), %rdi
callq 0x2050
movq 0x30(%r14), %rdi
callq 0x2050
addq $0x48, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
leaq 0x1df3(%rip), %rdi      # 0x12439
movq %r14, %rsi
xorl %eax, %eax
callq 0x2140
movl $0x1, %edi
callq 0x2320
// File: /workspace/github_cpp_makefile_star2_O3/corecodec[P]coremake/coremake.c
// Function: default_workspace
item* default_workspace(item* workspace,item* i,item* p)
{
	item** child;
	if (!p) return i;
	for (child=p->child;child!=p->childend;++child)
    {
        if (!i)
        {
            truncfilename(proj);
            i = item_get(workspace,proj,1);
        }
        item_get(item_get(i,"use",1),(*child)->value,1);
    }
    return i;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rsi, %r15
testq %rdx, %rdx
je 0x106d9
movq %rdx, %rbx
movq 0x18(%rdx), %rbp
cmpq 0x20(%rdx), %rbp
je 0x106d9
movq %rdi, %r14
leaq 0x5b4c(%rip), %r12      # 0x161d0
leaq 0xa51(%rip), %r13       # 0x110dc
testq %r15, %r15
jne 0x106ab
movq %r12, %rdi
callq 0x3c01
movq %r14, %rdi
movq %r12, %rsi
movl $0x1, %edx
callq 0x270b
movq %rax, %r15
movq %r15, %rdi
movq %r13, %rsi
movl $0x1, %edx
callq 0x270b
movq (%rbp), %rcx
movq (%rcx), %rsi
movq %rax, %rdi
movl $0x1, %edx
callq 0x270b
addq $0x8, %rbp
cmpq 0x20(%rbx), %rbp
jne 0x1068b
movq %r15, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O3/jaldhar[P]Lets-Build-a-Simple-Interpreter/calc5.cc
// Function: Interpreter::factor()
long Interpreter::factor() {
    Token token = _current_token;
    if (token.type == TOKENTYPE::LPAREN) {
        eat(TOKENTYPE::LPAREN);
        long result = expression();
        eat(TOKENTYPE::RPAREN);
        return result;
    } else {
        eat(TOKENTYPE::INTEGER);
        return token.value;
    }
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
cmpl $0x6, 0x8(%rdi)
jne 0x2b60
movq %rbx, %rdi
movl $0x6, %esi
callq 0x2a48
movq %rbx, %rdi
callq 0x295a
movq %rax, %r14
movl $0x7, %esi
jmp 0x2b69
movq 0x10(%rbx), %r14
movl $0x1, %esi
movq %rbx, %rdi
callq 0x2a48
movq %r14, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_cpp_makefile_star2_O3/maydali28[P]cpp-socket/matrix_hal/socketAddr.cpp
// Function: matrix_hal::socketAddr::to_sockaddr_in()
struct sockaddr_in socketAddr::to_sockaddr_in(){
    struct sockaddr_in addr;
    //addr = (struct sockaddr_in *) malloc(sizeof(struct sockaddr_in));
    memset(&addr,0,sizeof(addr));

    addr.sin_family = AF_INET;
    addr.sin_port = htons(port);
    inet_aton(address.c_str(),&(addr.sin_addr));

    return addr;
  }

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %rbx
subq $0x18, %rsp
leaq -0x14(%rbp), %rbx
movl $0x0, 0x8(%rbx)
movq $0x0, (%rbx)
movw $0x2, -0x4(%rbx)
movzwl 0x20(%rdi), %eax
rolw $0x8, %ax
movw %ax, -0x2(%rbx)
movq (%rdi), %rdi
movq %rbx, %rsi
callq 0x2140
movq -0x4(%rbx), %rax
movq 0x4(%rbx), %rdx
addq $0x18, %rsp
popq %rbx
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O3/maydali28[P]cpp-socket/prog.cpp
// Function: main
int main(void){
  matrix_hal::server *srv = new matrix_hal::server(8080);
  int err = srv->bind();
  if(err != 0){
    std::cout<<strerror(err)<<std::endl;
    exit(err);
  }
  matrix_hal::socketUDP* socket = srv->getConnexion();
  if(!socket->valid()){
    delete socket;
    exit(0);
  }

std::valarray<int16_t> raw_data_ = {1, 2, 3, 4, 5, 6, 7, 8, 9, 10};
// matrix_hal::Datagram msg;
//    while (true) {
int tab[1024];
for(int i = 0;i<1024;i++){
tab[i] = 11111;
printf("%d\n",tab[i] );
}
  		socket->send("127.0.0.1",2012,raw_data_,raw_data_.size()) == 1 ? std::cout<<"ok"<<std::endl : std::cout<<"not ok"<<std::endl;
  		// std::cout<<msg.data<<std::endl;
//  }


}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x30, %rsp
movl $0x38, %edi
callq 0x21d0
movq %rax, %rbx
movq %rax, %rdi
movl $0x1f90, %esi           # imm = 0x1F90
callq 0x243c
movq %rbx, %rdi
callq 0x2532
testl %eax, %eax
jne 0x2f61
movq %rbx, %rdi
callq 0x267e
movq %rax, %r14
movq %rax, %rdi
callq 0x2984
testb %al, %al
je 0x2f8a
movl $0x14, %edi
callq 0x21d0
movq %rax, %rbx
movups 0x11f0(%rip), %xmm0     # 0x4040
movups %xmm0, (%rax)
movl $0xa0009, 0x10(%rax)    # imm = 0xA0009
movl $0x400, %r12d           # imm = 0x400
leaq 0x11a8(%rip), %r15      # 0x400f
movq %r15, %rdi
movl $0x2b67, %esi           # imm = 0x2B67
xorl %eax, %eax
callq 0x2050
decl %r12d
jne 0x2e67
leaq -0x40(%rbp), %r15
movq %r15, -0x10(%r15)
leaq 0x11ca(%rip), %rsi      # 0x4054
leaq 0x11cc(%rip), %rdx      # 0x405d
leaq -0x50(%rbp), %rdi
callq 0x2fd8
movq $0xa, -0x30(%rbp)
movl $0x14, %edi
callq 0x21d0
leaq -0x30(%rbp), %rcx
movq %rax, 0x8(%rcx)
movl 0x10(%rbx), %edx
movl %edx, 0x10(%rax)
movups (%rbx), %xmm0
movups %xmm0, (%rax)
leaq -0x50(%rbp), %rsi
movq %r14, %rdi
movl $0x7dc, %edx            # imm = 0x7DC
movl $0xa, %r8d
callq 0x2b7a
xorl %ecx, %ecx
cmpl $0x1, %eax
setne %cl
leaq 0x117c(%rip), %rax      # 0x4062
leaq 0x1171(%rip), %rsi      # 0x405e
cmoveq %rax, %rsi
leaq 0x2(,%rcx,4), %rdx
movq 0x30d8(%rip), %r14      # 0x5fd8
movq %r14, %rdi
callq 0x21e0
movq (%r14), %rax
addq -0x18(%rax), %r14
movq %r14, %rdi
movl $0xa, %esi
callq 0x21b0
movsbl %al, %esi
movq 0x30b2(%rip), %rdi      # 0x5fd8
callq 0x2030
movq %rax, %rdi
callq 0x2120
movq -0x28(%rbp), %rdi
callq 0x21a0
movq -0x50(%rbp), %rdi
cmpq %r15, %rdi
je 0x2f4a
callq 0x21a0
movq %rbx, %rdi
callq 0x21a0
xorl %eax, %eax
addq $0x30, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
movl %eax, %r14d
movl %eax, %edi
callq 0x20b0
movq 0x3066(%rip), %rdi      # 0x5fd8
movq %rax, %rsi
callq 0x21c0
movq %rax, %rdi
callq 0x20f0
movl %r14d, %edi
callq 0x2200
movq %r14, %rdi
callq 0x292a
movq %r14, %rdi
callq 0x21a0
xorl %edi, %edi
callq 0x2200
movq %rax, %r14
jmp 0x2fb9
jmp 0x2fa8
movq %rax, %r14
jmp 0x2fc7
movq %rax, %r14
movq -0x28(%rbp), %rdi
callq 0x21a0
movq -0x50(%rbp), %rdi
cmpq %r15, %rdi
je 0x2fc7
callq 0x21a0
movq %rbx, %rdi
callq 0x21a0
movq %r14, %rdi
callq 0x2260
nop
// File: /workspace/github_cpp_makefile_star2_O3/dannycalegari[P]circle_pack/./Trigonometry_routine.cc
// Function: midpoint(Point, Point)
Point midpoint(Point P, Point Q){
	Point R;
	R.x=(P.x+Q.x)/2.0;
	R.y=(P.y+Q.y)/2.0;
	R.z=(P.z+Q.z)/2.0;
	return(R);
}

// Assembly:
movq %rdi, %rax
movupd 0x20(%rsp), %xmm0
addpd 0x8(%rsp), %xmm0
mulpd 0x79c3(%rip), %xmm0     # 0xa010
movupd %xmm0, (%rdi)
movsd 0x18(%rsp), %xmm0
addsd 0x30(%rsp), %xmm0
mulsd 0x7a1b(%rip), %xmm0     # 0xa080
movsd %xmm0, 0x10(%rdi)
retq
// File: /workspace/github_cpp_makefile_star2_O3/dannycalegari[P]circle_pack/./Trigonometry_routine.cc
// Function: write_Matrix(Matrix)
void write_Matrix(Matrix M){
	int i,j;
	for(i=0;i<3;i++){
		for(j=0;j<3;j++){
			cout << M.e[i][j] << " ";
		};
		cout << "\n";
	};
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rdi, %rbx
xorl %r13d, %r13d
movq 0xb7e6(%rip), %r14      # 0xdfd0
leaq 0x7ec7(%rip), %r15      # 0xa6b8
leaq (,%r13,2), %rbp
addq %r13, %rbp
xorl %r12d, %r12d
movq (%rbx), %rax
movq (%rax,%rbp,8), %rax
movsd (%rax,%r12,8), %xmm0
movq %r14, %rdi
callq 0x2330
movl $0x1, %edx
movq %rax, %rdi
movq %r15, %rsi
callq 0x2220
incq %r12
cmpq $0x3, %r12
jne 0x27ff
movl $0x1, %edx
movq %r14, %rdi
leaq 0x7ee5(%rip), %rsi      # 0xa721
callq 0x2220
incq %r13
cmpq $0x3, %r13
jne 0x27f1
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O3/dannycalegari[P]circle_pack/./Trigonometry_routine.cc
// Function: hyp_ang(Point)
double hyp_ang(Point P){	// hyperbolic angle from origin; also works as Euclidean angle
	double d;
	d=hyp_dist(P);
	if(d==0.0){
		return(0.0);
	};
	return(atan2(P.y,P.x));
}

// Assembly:
pushq %rax
movsd 0x20(%rsp), %xmm0
movsd 0x67be(%rip), %xmm1     # 0xa088
ucomisd %xmm0, %xmm1
ja 0x38e1
callq 0x23a0
xorpd %xmm1, %xmm1
ucomisd %xmm1, %xmm0
jne 0x38e7
jp 0x38e7
xorpd %xmm0, %xmm0
popq %rax
retq
leaq 0x10(%rsp), %rax
movsd (%rax), %xmm1
movsd 0x8(%rax), %xmm0
popq %rax
jmp 0x2040