LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: corecodec[P]coremake/coremake.c
// Function: simplifypath
void simplifypath(char* path, int head)
{
    char* s;
    for (s=path;*s;++s)
    {
        if (strncmp(s,"/../",4)==0 && s!=path)
        {
            char* end = s+4;
            do
            {
				if (s[-1] == '/' || s[-1] == '\\')
					break;
			} while (--s!=path);
            s = strdel(s,end);
            if (s != path)
                --s;
            --s;
        }
        if (strncmp(s,"/./",3)==0 && s!=path)
            memmove(s+1,s+3,strlen(s+3)+1);
        if (strncmp(s,"/.",3)==0 && s!=path)
            s[1]=0;
    }
    if (head)
    {
        while (path[0] == '.' && path[1] == '/')
            memmove(path,path+2,strlen(path+2));
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rax
cmpb $0x0, (%rax)
je 0x55e3
movq -0x18(%rbp), %rdi
leaq 0x11df8(%rip), %rsi     # 0x172b7
movl $0x4, %edx
callq 0x2080
cmpl $0x0, %eax
jne 0x5547
movq -0x18(%rbp), %rax
cmpq -0x8(%rbp), %rax
je 0x5547
movq -0x18(%rbp), %rax
addq $0x4, %rax
movq %rax, -0x20(%rbp)
movq -0x18(%rbp), %rax
movsbl -0x1(%rax), %eax
cmpl $0x2f, %eax
je 0x54fe
movq -0x18(%rbp), %rax
movsbl -0x1(%rax), %eax
cmpl $0x5c, %eax
jne 0x5500
jmp 0x5514
jmp 0x5502
movq -0x18(%rbp), %rax
addq $-0x1, %rax
movq %rax, -0x18(%rbp)
cmpq -0x8(%rbp), %rax
jne 0x54e4
movq -0x18(%rbp), %rdi
movq -0x20(%rbp), %rsi
callq 0x3fe0
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rax
cmpq -0x8(%rbp), %rax
je 0x553b
movq -0x18(%rbp), %rax
addq $-0x1, %rax
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rax
addq $-0x1, %rax
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rdi
leaq 0x11d6a(%rip), %rsi     # 0x172bc
movl $0x3, %edx
callq 0x2080
cmpl $0x0, %eax
jne 0x55a4
movq -0x18(%rbp), %rax
cmpq -0x8(%rbp), %rax
je 0x55a4
movq -0x18(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x30(%rbp)
movq -0x18(%rbp), %rax
addq $0x3, %rax
movq %rax, -0x28(%rbp)
movq -0x18(%rbp), %rdi
addq $0x3, %rdi
callq 0x2100
movq -0x30(%rbp), %rdi
movq -0x28(%rbp), %rsi
movq %rax, %rdx
addq $0x1, %rdx
callq 0x22b0
movq -0x18(%rbp), %rdi
leaq 0x11d11(%rip), %rsi     # 0x172c0
movl $0x3, %edx
callq 0x2080
cmpl $0x0, %eax
jne 0x55d0
movq -0x18(%rbp), %rax
cmpq -0x8(%rbp), %rax
je 0x55d0
movq -0x18(%rbp), %rax
movb $0x0, 0x1(%rax)
jmp 0x55d2
movq -0x18(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x18(%rbp)
jmp 0x54a7
cmpl $0x0, -0xc(%rbp)
je 0x564b
jmp 0x55eb
movq -0x8(%rbp), %rax
movsbl (%rax), %ecx
xorl %eax, %eax
cmpl $0x2e, %ecx
movb %al, -0x31(%rbp)
jne 0x560d
movq -0x8(%rbp), %rax
movsbl 0x1(%rax), %eax
cmpl $0x2f, %eax
sete %al
movb %al, -0x31(%rbp)
movb -0x31(%rbp), %al
testb $0x1, %al
jne 0x5616
jmp 0x5649
movq -0x8(%rbp), %rax
movq %rax, -0x48(%rbp)
movq -0x8(%rbp), %rax
addq $0x2, %rax
movq %rax, -0x40(%rbp)
movq -0x8(%rbp), %rdi
addq $0x2, %rdi
callq 0x2100
movq -0x48(%rbp), %rdi
movq -0x40(%rbp), %rsi
movq %rax, %rdx
callq 0x22b0
jmp 0x55eb
jmp 0x564b
addq $0x50, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: corecodec[P]coremake/coremake.c
// Function: strip_path_abs
void strip_path_abs(char *path, int flags)
{
    assert((flags & FLAG_PATH_MASK) != FLAG_PATH_NOT_PATH);
    switch (flags & FLAG_PATH_MASK)
    {
    case FLAG_PATH_GENERATED:
        if (proj_root_len && strstr(path,proj_root)==path)
            memmove(path,path+proj_root_len,strlen(path+proj_root_len)+1);
        break;
    case FLAG_PATH_COREMAKE:
        if (coremake_root_len && strstr(path,coremake_root)==path)
           memmove(path,path+coremake_root_len,strlen(path+coremake_root_len)+1);
        break;
    case FLAG_PATH_SOURCE:
        if (src_root_len && strstr(path,src_root)==path)
            memmove(path,path+src_root_len,strlen(path+src_root_len)+1);
        break;
    case FLAG_PATH_SYSTEM: // do nothing
        break;
    default: assert(0);
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movl -0xc(%rbp), %eax
andl $0xf, %eax
cmpl $0x0, %eax
je 0x567c
jmp 0x569b
leaq 0x10b89(%rip), %rdi     # 0x1620c
leaq 0x10a4d(%rip), %rsi     # 0x160d7
movl $0x4e0, %edx            # imm = 0x4E0
leaq 0x10ba5(%rip), %rcx     # 0x1623b
callq 0x2140
movl -0xc(%rbp), %eax
andl $0xf, %eax
decl %eax
movl %eax, %ecx
movq %rcx, -0x18(%rbp)
subl $0x3, %eax
ja 0x57e2
movq -0x18(%rbp), %rax
leaq 0x1095f(%rip), %rcx     # 0x1601c
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
cmpq $0x0, 0x15b2a(%rip)     # 0x1b1f8
je 0x5721
movq -0x8(%rbp), %rdi
leaq 0x15315(%rip), %rsi     # 0x1a9f0
callq 0x2340
cmpq -0x8(%rbp), %rax
jne 0x5721
movq -0x8(%rbp), %rax
movq %rax, -0x28(%rbp)
movq -0x8(%rbp), %rax
addq 0x15aff(%rip), %rax     # 0x1b1f8
movq %rax, -0x20(%rbp)
movq -0x8(%rbp), %rdi
addq 0x15af0(%rip), %rdi     # 0x1b1f8
callq 0x2100
movq -0x28(%rbp), %rdi
movq -0x20(%rbp), %rsi
movq %rax, %rdx
addq $0x1, %rdx
callq 0x22b0
jmp 0x5801
cmpq $0x0, 0x15ad2(%rip)     # 0x1b200
je 0x5781
movq -0x8(%rbp), %rdi
leaq 0x156b5(%rip), %rsi     # 0x1adf0
callq 0x2340
cmpq -0x8(%rbp), %rax
jne 0x5781
movq -0x8(%rbp), %rax
movq %rax, -0x38(%rbp)
movq -0x8(%rbp), %rax
addq 0x15aa7(%rip), %rax     # 0x1b200
movq %rax, -0x30(%rbp)
movq -0x8(%rbp), %rdi
addq 0x15a98(%rip), %rdi     # 0x1b200
callq 0x2100
movq -0x38(%rbp), %rdi
movq -0x30(%rbp), %rsi
movq %rax, %rdx
addq $0x1, %rdx
callq 0x22b0
jmp 0x5801
cmpq $0x0, 0x15a65(%rip)     # 0x1b1f0
je 0x57de
movq -0x8(%rbp), %rdi
leaq 0x14e58(%rip), %rsi     # 0x1a5f0
callq 0x2340
cmpq -0x8(%rbp), %rax
jne 0x57de
movq -0x8(%rbp), %rax
movq %rax, -0x48(%rbp)
movq -0x8(%rbp), %rax
addq 0x15a3a(%rip), %rax     # 0x1b1f0
movq %rax, -0x40(%rbp)
movq -0x8(%rbp), %rdi
addq 0x15a2b(%rip), %rdi     # 0x1b1f0
callq 0x2100
movq -0x48(%rbp), %rdi
movq -0x40(%rbp), %rsi
movq %rax, %rdx
addq $0x1, %rdx
callq 0x22b0
jmp 0x5801
jmp 0x5801
leaq 0x119a4(%rip), %rdi     # 0x1718d
leaq 0x108e7(%rip), %rsi     # 0x160d7
movl $0x4f1, %edx            # imm = 0x4F1
leaq 0x10a3f(%rip), %rcx     # 0x1623b
callq 0x2140
addq $0x50, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: corecodec[P]coremake/coremake.c
// Function: load_cond2
itemcond* load_cond2(reader* file,item* config)
{
	itemcond* p;
	if (reader_istoken(file,"("))
	{
		p = load_cond0(file,config);
		if (!reader_istoken(file,")"))
			syntax(file);
	}
	else
	{
		if (reader_istoken(file,")"))
			syntax(file);
		reader_name(file);
		p = itemcond_new(COND_GET,item_get(config,file->token,0));
	}
	return p;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rdi
leaq 0x10a7f(%rip), %rsi     # 0x1657a
callq 0x4630
cmpl $0x0, %eax
je 0x5b36
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
callq 0x5b90
movq %rax, -0x18(%rbp)
movq -0x8(%rbp), %rdi
leaq 0x11861(%rip), %rsi     # 0x17382
callq 0x4630
cmpl $0x0, %eax
jne 0x5b34
movq -0x8(%rbp), %rdi
callq 0x24e0
jmp 0x5b7e
movq -0x8(%rbp), %rdi
leaq 0x11841(%rip), %rsi     # 0x17382
callq 0x4630
cmpl $0x0, %eax
je 0x5b54
movq -0x8(%rbp), %rdi
callq 0x24e0
movq -0x8(%rbp), %rdi
callq 0x48c0
movq -0x10(%rbp), %rdi
movq -0x8(%rbp), %rax
movq 0x30(%rax), %rsi
xorl %edx, %edx
callq 0x28d0
movq %rax, %rsi
xorl %edi, %edi
callq 0x31f0
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rax
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: corecodec[P]coremake/coremake.c
// Function: load_cond0
itemcond* load_cond0(reader* file,item* config)
{
	itemcond* a = load_cond1(file,config);
	if (reader_istoken(file,"||"))
	{
		itemcond* p = itemcond_new(COND_OR,NULL);
		p->a = a;
		p->b = load_cond0(file,config);
		return p;
	}
	if (reader_istoken(file,"&&"))
	{
		itemcond* p = itemcond_new(COND_AND,NULL);
		p->a = a;
		p->b = load_cond0(file,config);
		return p;
	}
	return a;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rsi
callq 0x5c70
movq %rax, -0x20(%rbp)
movq -0x10(%rbp), %rdi
leaq 0x106f7(%rip), %rsi     # 0x162b3
callq 0x4630
cmpl $0x0, %eax
je 0x5c06
movl $0x1, %edi
xorl %eax, %eax
movl %eax, %esi
callq 0x31f0
movq %rax, -0x28(%rbp)
movq -0x20(%rbp), %rcx
movq -0x28(%rbp), %rax
movq %rcx, 0x10(%rax)
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rsi
callq 0x5b90
movq %rax, %rcx
movq -0x28(%rbp), %rax
movq %rcx, 0x18(%rax)
movq -0x28(%rbp), %rax
movq %rax, -0x8(%rbp)
jmp 0x5c63
movq -0x10(%rbp), %rdi
leaq 0x106a5(%rip), %rsi     # 0x162b6
callq 0x4630
cmpl $0x0, %eax
je 0x5c5b
movl $0x2, %edi
xorl %eax, %eax
movl %eax, %esi
callq 0x31f0
movq %rax, -0x30(%rbp)
movq -0x20(%rbp), %rcx
movq -0x30(%rbp), %rax
movq %rcx, 0x10(%rax)
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rsi
callq 0x5b90
movq %rax, %rcx
movq -0x30(%rbp), %rax
movq %rcx, 0x18(%rax)
movq -0x30(%rbp), %rax
movq %rax, -0x8(%rbp)
jmp 0x5c63
movq -0x20(%rbp), %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax)
// File: corecodec[P]coremake/coremake.c
// Function: load_cond1
itemcond* load_cond1(reader* file,item* config)
{
	if (reader_istoken(file,"!"))
	{
		itemcond* p = itemcond_new(COND_NOT,NULL);
		p->a = load_cond1(file,config);
		return p;
	}
	else
		return load_cond2(file,config);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x10(%rbp), %rdi
leaq 0x1194f(%rip), %rsi     # 0x175da
callq 0x4630
cmpl $0x0, %eax
je 0x5cc9
movl $0x3, %edi
xorl %eax, %eax
movl %eax, %esi
callq 0x31f0
movq %rax, -0x20(%rbp)
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rsi
callq 0x5c70
movq %rax, %rcx
movq -0x20(%rbp), %rax
movq %rcx, 0x10(%rax)
movq -0x20(%rbp), %rax
movq %rax, -0x8(%rbp)
jmp 0x5cda
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rsi
callq 0x5ae0
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: corecodec[P]coremake/coremake.c
// Function: load_cond
itemcond* load_cond(item* item, reader* file, int force)
{
	itemcond* p = NULL;
	if (reader_istoken(file,"("))
	{
		p = load_cond0(file,getconfig(item));
		if (!reader_istoken(file,")"))
			syntax(file);
	}
	else
	if (force)
		p = load_cond0(file,getconfig(item));

	return p;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl %edx, -0x14(%rbp)
movq $0x0, -0x20(%rbp)
movq -0x10(%rbp), %rdi
leaq 0x10864(%rip), %rsi     # 0x1657a
callq 0x4630
cmpl $0x0, %eax
je 0x5d61
movq -0x10(%rbp), %rax
movq %rax, -0x28(%rbp)
movq -0x8(%rbp), %rdi
callq 0x2960
movq -0x28(%rbp), %rdi
movq %rax, %rsi
callq 0x5b90
movq %rax, -0x20(%rbp)
movq -0x10(%rbp), %rdi
leaq 0x11636(%rip), %rsi     # 0x17382
callq 0x4630
cmpl $0x0, %eax
jne 0x5d5f
movq -0x10(%rbp), %rdi
callq 0x24e0
jmp 0x5d8a
cmpl $0x0, -0x14(%rbp)
je 0x5d88
movq -0x10(%rbp), %rax
movq %rax, -0x30(%rbp)
movq -0x8(%rbp), %rdi
callq 0x2960
movq -0x30(%rbp), %rdi
movq %rax, %rsi
callq 0x5b90
movq %rax, -0x20(%rbp)
jmp 0x5d8a
movq -0x20(%rbp), %rax
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: 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
movq %rsp, %rbp
subq $0x70, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movl %edx, -0x1c(%rbp)
movq %rcx, -0x28(%rbp)
leaq -0x68(%rbp), %rdi
callq 0x3bf0
movq -0x30(%rbp), %rdi
movq -0x18(%rbp), %rsi
callq 0x2090
movq -0x30(%rbp), %rdi
callq 0x4e10
movq -0x18(%rbp), %rdi
leaq 0xee4f(%rip), %rsi      # 0x163a0
callq 0x22c0
movq %rax, -0x68(%rbp)
movq -0x40(%rbp), %rax
movq %rax, -0x48(%rbp)
cmpq $0x0, -0x68(%rbp)
je 0x759d
movl -0x1c(%rbp), %eax
movl %eax, -0x54(%rbp)
movq -0x10(%rbp), %rdi
movq -0x28(%rbp), %rcx
leaq -0x68(%rbp), %rsi
xorl %edx, %edx
callq 0x5da0
movq -0x68(%rbp), %rdi
callq 0x20d0
leaq -0x68(%rbp), %rdi
callq 0x3c90
movl $0x1, -0x4(%rbp)
jmp 0x75ad
leaq -0x68(%rbp), %rdi
callq 0x3c90
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x70, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: 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 %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movl -0xc(%rbp), %esi
shll %esi
movq -0x8(%rbp), %rax
movq (%rax), %rcx
leaq 0xed11(%rip), %rdi      # 0x16573
movl $0x20, %edx
movb $0x0, %al
callq 0x2120
movq -0x8(%rbp), %rax
cmpq $0x0, 0x8(%rax)
je 0x78bc
leaq 0xecf9(%rip), %rdi      # 0x16579
movb $0x0, %al
callq 0x2120
movq 0x12752(%rip), %rax     # 0x19fe0
movq (%rax), %rdi
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rsi
movl $0x1, %edx
xorl %r9d, %r9d
xorl %eax, %eax
movl %eax, %r8d
movl %r9d, %ecx
callq 0x75c0
leaq 0xfacd(%rip), %rdi      # 0x17382
movb $0x0, %al
callq 0x2120
leaq 0xece1(%rip), %rdi      # 0x165a4
movb $0x0, %al
callq 0x2120
movq -0x8(%rbp), %rax
movq 0x18(%rax), %rax
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rax
movq -0x8(%rbp), %rcx
cmpq 0x20(%rcx), %rax
je 0x7904
movq -0x18(%rbp), %rax
movq (%rax), %rdi
movl -0xc(%rbp), %esi
addl $0x1, %esi
callq 0x7840
movq -0x18(%rbp), %rax
addq $0x8, %rax
movq %rax, -0x18(%rbp)
jmp 0x78d6
addq $0x20, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: 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 %rbp
movq %rsp, %rbp
leaq 0xec61(%rip), %rdi      # 0x1657c
movb $0x0, %al
callq 0x2120
leaq 0xec7e(%rip), %rdi      # 0x165a7
movb $0x0, %al
callq 0x2120
leaq 0xec7d(%rip), %rdi      # 0x165b4
movb $0x0, %al
callq 0x2120
leaq 0xec7f(%rip), %rdi      # 0x165c4
movb $0x0, %al
callq 0x2120
leaq 0xec9e(%rip), %rdi      # 0x165f1
movb $0x0, %al
callq 0x2120
leaq 0xeccb(%rip), %rdi      # 0x1662c
movb $0x0, %al
callq 0x2120
leaq 0xecd2(%rip), %rdi      # 0x16641
movb $0x0, %al
callq 0x2120
popq %rbp
retq
nopl (%rax,%rax)
// File: 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 %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movl 0x30(%rax), %ecx
orl $0x40, %ecx
movl %ecx, 0x30(%rax)
movq -0x8(%rbp), %rax
movl 0x30(%rax), %ecx
andl $-0x21, %ecx
movl %ecx, 0x30(%rax)
movq -0x8(%rbp), %rax
movq 0x18(%rax), %rax
movq %rax, -0x10(%rbp)
movq -0x10(%rbp), %rax
movq -0x8(%rbp), %rcx
cmpq 0x20(%rcx), %rax
je 0x79da
movq -0x10(%rbp), %rax
movq (%rax), %rdi
callq 0x7980
movq -0x10(%rbp), %rax
addq $0x8, %rax
movq %rax, -0x10(%rbp)
jmp 0x79b2
addq $0x10, %rsp
popq %rbp
retq
// File: 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 %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movl 0x30(%rax), %ecx
andl $0xffffff7f, %ecx       # imm = 0xFFFFFF7F
movl %ecx, 0x30(%rax)
movq -0x8(%rbp), %rax
movl 0x30(%rax), %ecx
andl $-0x41, %ecx
movl %ecx, 0x30(%rax)
movq -0x8(%rbp), %rax
movq 0x18(%rax), %rax
movq %rax, -0x10(%rbp)
movq -0x10(%rbp), %rax
movq -0x8(%rbp), %rcx
cmpq 0x20(%rcx), %rax
je 0x7a3d
movq -0x10(%rbp), %rax
movq (%rax), %rdi
callq 0x79e0
movq -0x10(%rbp), %rax
addq $0x8, %rax
movq %rax, -0x10(%rbp)
jmp 0x7a15
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: 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:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq 0x18(%rax), %rax
movq %rax, -0x10(%rbp)
movq -0x10(%rbp), %rax
movq -0x8(%rbp), %rcx
cmpq 0x20(%rcx), %rax
je 0x7aa4
movq -0x10(%rbp), %rax
movq (%rax), %rax
movl 0x30(%rax), %eax
andl $0x20, %eax
cmpl $0x0, %eax
jne 0x7a94
movq -0x10(%rbp), %rax
movq (%rax), %rax
movl 0x30(%rax), %ecx
orl $0x40, %ecx
movl %ecx, 0x30(%rax)
jmp 0x7a96
movq -0x10(%rbp), %rax
addq $0x8, %rax
movq %rax, -0x10(%rbp)
jmp 0x7a64
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: 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 %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
cmpq $0x0, 0x8(%rax)
je 0x7ae0
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rdi
callq 0x3100
movq -0x8(%rbp), %rax
movq $0x0, 0x8(%rax)
movq -0x8(%rbp), %rax
movq 0x18(%rax), %rax
movq %rax, -0x10(%rbp)
movq -0x10(%rbp), %rax
movq -0x8(%rbp), %rcx
cmpq 0x20(%rcx), %rax
je 0x7b42
movq -0x10(%rbp), %rax
movq (%rax), %rax
movl 0x30(%rax), %eax
andl $0x40, %eax
cmpl $0x0, %eax
je 0x7b26
movq -0x10(%rbp), %rax
movq (%rax), %rdi
callq 0x3150
movq -0x10(%rbp), %rax
addq $-0x8, %rax
movq %rax, -0x10(%rbp)
jmp 0x7b32
movq -0x10(%rbp), %rax
movq (%rax), %rdi
callq 0x7ab0
jmp 0x7b34
movq -0x10(%rbp), %rax
addq $0x8, %rax
movq %rax, -0x10(%rbp)
jmp 0x7aec
addq $0x10, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: 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:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
cmpq $0x0, -0x8(%rbp)
jne 0x7e55
jmp 0x7e89
movq -0x8(%rbp), %rax
movq 0x18(%rax), %rax
movq %rax, -0x10(%rbp)
movq -0x10(%rbp), %rax
movq -0x8(%rbp), %rcx
cmpq 0x20(%rcx), %rax
je 0x7e89
movq -0x10(%rbp), %rax
movq (%rax), %rdi
callq 0x7bb0
movq -0x10(%rbp), %rax
addq $0x8, %rax
movq %rax, -0x10(%rbp)
jmp 0x7e61
addq $0x10, %rsp
popq %rbp
retq
nop
// File: 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
movq %rsp, %rbp
subq $0xc40, %rsp            # imm = 0xC40
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
movl $0x2e, %esi
callq 0x2130
movq %rax, -0x418(%rbp)
cmpq $0x0, -0x418(%rbp)
je 0x8078
movq -0x418(%rbp), %rdi
leaq 0xe7c9(%rip), %rsi      # 0x16699
callq 0x2050
cmpl $0x0, %eax
jne 0x8078
movl $0x0, -0x42c(%rbp)
leaq -0x410(%rbp), %rdi
movq -0x8(%rbp), %rsi
callq 0x2090
movq -0x418(%rbp), %rax
movb $0x0, (%rax)
leaq -0x410(%rbp), %rdi
leaq 0xe78e(%rip), %rsi      # 0x1669e
callq 0x22c0
movq %rax, -0x420(%rbp)
movq -0x8(%rbp), %rdi
leaq 0xe777(%rip), %rsi      # 0x1669e
callq 0x22c0
movq %rax, -0x428(%rbp)
cmpq $0x0, -0x420(%rbp)
je 0x7fff
cmpq $0x0, -0x428(%rbp)
je 0x7fff
jmp 0x7f51
leaq -0x830(%rbp), %rdi
movq -0x420(%rbp), %rcx
movl $0x1, %esi
movl $0x400, %edx            # imm = 0x400
callq 0x20c0
movq %rax, -0xc38(%rbp)
leaq -0xc30(%rbp), %rdi
movq -0x428(%rbp), %rcx
movl $0x1, %esi
movl $0x400, %edx            # imm = 0x400
callq 0x20c0
movq %rax, -0xc40(%rbp)
movq -0xc38(%rbp), %rax
cmpq -0xc40(%rbp), %rax
jne 0x7fc8
leaq -0x830(%rbp), %rdi
leaq -0xc30(%rbp), %rsi
movq -0xc38(%rbp), %rdx
callq 0x21b0
cmpl $0x0, %eax
je 0x7fca
jmp 0x7ffd
movq -0x420(%rbp), %rdi
callq 0x2200
cmpl $0x0, %eax
jne 0x7fec
movq -0x428(%rbp), %rdi
callq 0x2200
cmpl $0x0, %eax
je 0x7ff8
movl $0x1, -0x42c(%rbp)
jmp 0x7ffd
jmp 0x7f51
jmp 0x7fff
cmpq $0x0, -0x420(%rbp)
je 0x8015
movq -0x420(%rbp), %rdi
callq 0x20d0
cmpq $0x0, -0x428(%rbp)
je 0x802b
movq -0x428(%rbp), %rdi
callq 0x20d0
cmpl $0x0, -0x42c(%rbp)
jne 0x806a
cmpl $0x0, 0x125a5(%rip)     # 0x1a5e0
je 0x804f
movq -0x8(%rbp), %rsi
leaq 0xe659(%rip), %rdi      # 0x166a1
movb $0x0, %al
callq 0x2120
movq -0x8(%rbp), %rdi
callq 0x2070
leaq -0x410(%rbp), %rdi
movq -0x8(%rbp), %rsi
callq 0x22d0
jmp 0x8076
leaq -0x410(%rbp), %rdi
callq 0x2070
jmp 0x8078
addq $0xc40, %rsp            # imm = 0xC40
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: 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 %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rsi
callq 0x3240
cmpl $0x0, %eax
jne 0x813e
cmpq $0x0, -0x10(%rbp)
je 0x80dc
movq -0x10(%rbp), %rdi
callq 0x3100
movq -0x8(%rbp), %rdi
leaq 0xe5da(%rip), %rsi      # 0x166af
movb $0x0, %al
callq 0x21e0
movq -0x18(%rbp), %rdi
callq 0x3640
movq %rax, -0x10(%rbp)
cmpq $0x0, -0x10(%rbp)
je 0x813c
movq -0x8(%rbp), %rdi
callq 0x21f0
movl %eax, -0x1c(%rbp)
movq -0x8(%rbp), %rdi
leaq 0xe5b0(%rip), %rsi      # 0x166b7
movb $0x0, %al
callq 0x21e0
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
movl $0x1, %edx
xorl %r9d, %r9d
leaq -0x1c(%rbp), %r8
movl %r9d, %ecx
callq 0x75c0
movq -0x8(%rbp), %rdi
leaq 0xe842(%rip), %rsi      # 0x16977
movb $0x0, %al
callq 0x21e0
jmp 0x813e
movq -0x10(%rbp), %rax
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: 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 %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movq -0x10(%rbp), %rdi
leaq 0xe346(%rip), %rsi      # 0x1654d
callq 0x27d0
movq %rax, -0x20(%rbp)
cmpq $0x0, -0x20(%rbp)
je 0x8253
movq -0x20(%rbp), %rdi
callq 0x25d0
cmpq $0x0, %rax
je 0x8253
movq -0x20(%rbp), %rax
movq 0x18(%rax), %rax
movq (%rax), %rax
movq (%rax), %rdi
leaq 0xe63e(%rip), %rsi      # 0x16879
leaq -0x14(%rbp), %rdx
movb $0x0, %al
callq 0x2270
cmpl $0x1, %eax
jne 0x8253
movl -0x14(%rbp), %eax
movl %eax, -0x4(%rbp)
jmp 0x825a
movl $0x100000, -0x4(%rbp)   # imm = 0x100000
movl -0x4(%rbp), %eax
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: 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:
pushq %rbp
movq %rsp, %rbp
subq $0xc40, %rsp            # imm = 0xC40
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movq %rdx, -0x18(%rbp)
movl %ecx, -0x1c(%rbp)
movl -0xc(%rbp), %eax
andl $0x10, %eax
cmpl $0x0, %eax
jne 0x8991
movq -0x18(%rbp), %rax
cmpb $0x0, (%rax)
je 0x88e2
movb $0x0, -0xc20(%rbp)
leaq -0xc20(%rbp), %rax
movq %rax, -0xc30(%rbp)
movq -0x18(%rbp), %rax
movq %rax, -0xc28(%rbp)
movq -0x18(%rbp), %rdi
callq 0x4940
movq -0xc30(%rbp), %rdi
movq -0xc28(%rbp), %rsi
movq %rax, %rdx
callq 0x3f50
jmp 0x8957
movl -0x1c(%rbp), %eax
andl $0xf, %eax
movl %eax, -0xc34(%rbp)
subl $0x1, %eax
je 0x890f
jmp 0x88f5
movl -0xc34(%rbp), %eax
subl $0x2, %eax
je 0x8924
jmp 0x8902
movl -0xc34(%rbp), %eax
subl $0x3, %eax
je 0x8939
jmp 0x894e
leaq -0xc20(%rbp), %rdi
leaq 0x11cd3(%rip), %rsi     # 0x1a5f0
callq 0x2090
jmp 0x8955
leaq -0xc20(%rbp), %rdi
leaq 0x120be(%rip), %rsi     # 0x1a9f0
callq 0x2090
jmp 0x8955
leaq -0xc20(%rbp), %rdi
leaq 0x124a9(%rip), %rsi     # 0x1adf0
callq 0x2090
jmp 0x8955
movb $0x0, -0xc20(%rbp)
jmp 0x8957
leaq -0xc20(%rbp), %rdi
callq 0x4c90
leaq -0xc20(%rbp), %rdi
movq -0x8(%rbp), %rsi
callq 0x22f0
leaq -0xc20(%rbp), %rdi
xorl %esi, %esi
callq 0x5490
movq -0x8(%rbp), %rdi
leaq -0xc20(%rbp), %rsi
callq 0x2090
addq $0xc40, %rsp            # imm = 0xC40
popq %rbp
retq
nopw (%rax,%rax)
// File: 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
movq %rsp, %rbp
subq $0x8c0, %rsp            # imm = 0x8C0
movq %rdi, -0x8(%rbp)
movq $0x0, -0x10(%rbp)
movq -0x8(%rbp), %rdi
callq 0x50d0
cmpl $0x0, %eax
je 0xb1b7
jmp 0xb1d6
leaq 0xc18f(%rip), %rdi      # 0x1734d
leaq 0xaf12(%rip), %rsi      # 0x160d7
movl $0x1210, %edx           # imm = 0x1210
leaq 0xc18c(%rip), %rcx      # 0x1735d
callq 0x2140
leaq -0x820(%rbp), %rdi
movq -0x8(%rbp), %rsi
callq 0x2090
leaq -0x820(%rbp), %rdi
callq 0x4e10
leaq -0x820(%rbp), %rdi
movl $0x1, %esi
callq 0x5490
leaq -0x820(%rbp), %rdi
addq -0x10(%rbp), %rdi
leaq 0xc0a5(%rip), %rsi      # 0x172ba
callq 0x21a0
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rax
movq %rax, -0x8c0(%rbp)
leaq -0x820(%rbp), %rdi
addq -0x10(%rbp), %rdi
callq 0x2100
movq %rax, %rcx
movq -0x8c0(%rbp), %rax
cmpq %rcx, %rax
jne 0xb24d
jmp 0xb340
movq -0x18(%rbp), %rax
addq $0x1, %rax
addq -0x10(%rbp), %rax
movq %rax, -0x10(%rbp)
leaq -0x420(%rbp), %rdi
leaq -0x820(%rbp), %rsi
movq -0x10(%rbp), %rdx
subq $0x1, %rdx
callq 0x2060
movq -0x10(%rbp), %rax
subq $0x1, %rax
movb $0x0, -0x420(%rbp,%rax)
leaq -0x420(%rbp), %rdi
leaq -0x8b8(%rbp), %rsi
callq 0x2210
cmpl $0x0, %eax
jne 0xb2d3
movl -0x8a0(%rbp), %eax
andl $0x4000, %eax           # imm = 0x4000
cmpl $0x4000, %eax           # imm = 0x4000
je 0xb2d1
leaq -0x420(%rbp), %rsi
leaq 0xc0c4(%rip), %rdi      # 0x17384
movb $0x0, %al
callq 0x2120
movl $0x1, %edi
callq 0x2310
jmp 0xb33b
cmpq $0x1, -0x10(%rbp)
jbe 0xb339
movq -0x10(%rbp), %rax
subq $0x2, %rax
movsbl -0x420(%rbp,%rax), %eax
cmpl $0x3a, %eax
je 0xb339
leaq -0x420(%rbp), %rdi
movl $0x1c0, %esi            # imm = 0x1C0
callq 0x20a0
movl %eax, -0x824(%rbp)
cmpl $0x0, -0x824(%rbp)
je 0xb337
cmpl $0x11, -0x824(%rbp)
je 0xb337
leaq -0x420(%rbp), %rsi
leaq 0xc076(%rip), %rdi      # 0x1739c
movb $0x0, %al
callq 0x2120
movl $0x1, %edi
callq 0x2310
jmp 0xb339
jmp 0xb33b
jmp 0xb203
addq $0x8c0, %rsp            # imm = 0x8C0
popq %rbp
retq
nopl (%rax)
// File: 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 %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x10(%rbp), %rdi
callq 0x2a60
movq %rax, -0x18(%rbp)
movq -0x10(%rbp), %rax
movl 0x30(%rax), %ecx
orl $0x80, %ecx
movl %ecx, 0x30(%rax)
cmpq $0x0, -0x18(%rbp)
je 0xd839
movq -0x18(%rbp), %rax
movl 0x30(%rax), %eax
andl $0x40, %eax
cmpl $0x0, %eax
jne 0xd839
movq -0x18(%rbp), %rdi
leaq 0x8a27(%rip), %rsi      # 0x1610d
xorl %edx, %edx
callq 0x28d0
movq %rax, -0x28(%rbp)
movq $0x0, -0x20(%rbp)
movq -0x20(%rbp), %rax
movq %rax, -0x40(%rbp)
movq -0x28(%rbp), %rdi
callq 0x25d0
movq %rax, %rcx
movq -0x40(%rbp), %rax
cmpq %rcx, %rax
jae 0xd789
movq -0x28(%rbp), %rax
movq 0x18(%rax), %rax
movq -0x20(%rbp), %rcx
movq (%rax,%rcx,8), %rax
movl 0x30(%rax), %eax
andl $0x40, %eax
cmpl $0x0, %eax
jne 0xd776
movq -0x8(%rbp), %rdi
movq -0x28(%rbp), %rax
movq 0x18(%rax), %rax
movq -0x20(%rbp), %rcx
movq (%rax,%rcx,8), %rax
movq (%rax), %rsi
movl $0x1, %edx
callq 0x28d0
movq %rax, -0x30(%rbp)
movq -0x30(%rbp), %rax
movl 0x30(%rax), %eax
andl $0x80, %eax
cmpl $0x0, %eax
jne 0xd774
movq -0x8(%rbp), %rdi
movq -0x30(%rbp), %rsi
callq 0xd690
jmp 0xd776
jmp 0xd778
movq -0x20(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x20(%rbp)
jmp 0xd6f9
movq -0x18(%rbp), %rdi
leaq 0x8975(%rip), %rsi      # 0x16109
xorl %edx, %edx
callq 0x28d0
movq %rax, -0x28(%rbp)
movq $0x0, -0x20(%rbp)
movq -0x20(%rbp), %rax
movq %rax, -0x48(%rbp)
movq -0x28(%rbp), %rdi
callq 0x25d0
movq %rax, %rcx
movq -0x48(%rbp), %rax
cmpq %rcx, %rax
jae 0xd837
movq -0x28(%rbp), %rax
movq 0x18(%rax), %rax
movq -0x20(%rbp), %rcx
movq (%rax,%rcx,8), %rax
movl 0x30(%rax), %eax
andl $0x40, %eax
cmpl $0x0, %eax
jne 0xd824
movq -0x8(%rbp), %rdi
movq -0x28(%rbp), %rax
movq 0x18(%rax), %rax
movq -0x20(%rbp), %rcx
movq (%rax,%rcx,8), %rax
movq (%rax), %rsi
movl $0x1, %edx
callq 0x28d0
movq %rax, -0x38(%rbp)
movq -0x38(%rbp), %rax
movl 0x30(%rax), %eax
andl $0x80, %eax
cmpl $0x0, %eax
jne 0xd822
movq -0x8(%rbp), %rdi
movq -0x38(%rbp), %rsi
callq 0xd690
jmp 0xd824
jmp 0xd826
movq -0x20(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x20(%rbp)
jmp 0xd7a7
jmp 0xd839
addq $0x50, %rsp
popq %rbp
retq
nop
// File: 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:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
cmpq $0x0, -0x8(%rbp)
jne 0xd851
jmp 0xd88c
movq -0x8(%rbp), %rax
movq 0x18(%rax), %rax
movq %rax, -0x10(%rbp)
movq -0x10(%rbp), %rax
movq -0x8(%rbp), %rcx
cmpq 0x20(%rcx), %rax
je 0xd88c
movq -0x10(%rbp), %rax
movq (%rax), %rax
movl 0x30(%rax), %ecx
andl $0xffffff7f, %ecx       # imm = 0xFFFFFF7F
movl %ecx, 0x30(%rax)
movq -0x10(%rbp), %rax
addq $0x8, %rax
movq %rax, -0x10(%rbp)
jmp 0xd85d
popq %rbp
retq
nop
// File: 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 %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
xorl %eax, %eax
movl %eax, %edi
leaq 0x8c1b(%rip), %rsi      # 0x1669a
xorl %edx, %edx
callq 0x28d0
movq %rax, -0x28(%rbp)
movq -0x28(%rbp), %rax
movq %rax, -0x30(%rbp)
movq -0x10(%rbp), %rdi
leaq 0x96e7(%rip), %rsi      # 0x17184
callq 0x27d0
movq -0x30(%rbp), %rdi
movq %rax, %rsi
callq 0x26b0
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
movq -0x18(%rbp), %rdx
callq 0x3b20
movq $0x0, -0x20(%rbp)
movq -0x20(%rbp), %rax
movq %rax, -0x38(%rbp)
movq -0x28(%rbp), %rdi
callq 0x25d0
movq %rax, %rcx
movq -0x38(%rbp), %rax
cmpq %rcx, %rax
jae 0xdb0b
movq -0x10(%rbp), %rdi
movq -0x28(%rbp), %rax
movq 0x18(%rax), %rax
movq -0x20(%rbp), %rcx
movq (%rax,%rcx,8), %rsi
callq 0x26b0
movq -0x20(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x20(%rbp)
jmp 0xdac7
movq -0x28(%rbp), %rdi
callq 0x3150
addq $0x40, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: 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
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
cmpq $0x0, -0x8(%rbp)
jne 0xdb40
jmp 0xdc86
movq -0x8(%rbp), %rax
movq 0x18(%rax), %rax
movq %rax, -0x20(%rbp)
movq -0x20(%rbp), %rax
movq -0x8(%rbp), %rcx
cmpq 0x20(%rcx), %rax
je 0xdc86
movq -0x20(%rbp), %rax
movq (%rax), %rdi
leaq 0x85a1(%rip), %rsi      # 0x1610d
xorl %edx, %edx
callq 0x28d0
movq %rax, -0x28(%rbp)
movq -0x28(%rbp), %rdi
movq -0x10(%rbp), %rsi
callq 0x27d0
movq %rax, -0x30(%rbp)
cmpq $0x0, -0x30(%rbp)
je 0xdc73
movq -0x30(%rbp), %rax
movl 0x30(%rax), %eax
andl $0x40, %eax
cmpl $0x0, %eax
jne 0xdc73
movq -0x30(%rbp), %rdi
callq 0x3150
movq -0x20(%rbp), %rax
movq (%rax), %rax
movq (%rax), %rdi
movq -0x18(%rbp), %rax
movq (%rax), %rsi
callq 0x2050
cmpl $0x0, %eax
je 0xdc71
movq -0x18(%rbp), %rdi
leaq 0x8534(%rip), %rsi      # 0x1610d
callq 0x27d0
movq %rax, %rdi
movq -0x20(%rbp), %rax
movq (%rax), %rax
movq (%rax), %rsi
callq 0x27d0
movq %rax, -0x38(%rbp)
cmpq $0x0, -0x38(%rbp)
je 0xdc5c
movq -0x20(%rbp), %rax
movq (%rax), %rax
cmpq $0x0, 0x10(%rax)
je 0xdc2a
movq -0x20(%rbp), %rax
movq (%rax), %rax
movq 0x10(%rax), %rax
movq (%rax), %rdi
leaq 0x9695(%rip), %rsi      # 0x172b3
callq 0x2050
cmpl $0x0, %eax
jne 0xdc2a
jmp 0xdc75
movq -0x18(%rbp), %rdi
leaq 0x84d4(%rip), %rsi      # 0x16109
xorl %edx, %edx
callq 0x28d0
movq %rax, %rdi
movq -0x20(%rbp), %rax
movq (%rax), %rax
movq (%rax), %rsi
movl $0x1, %edx
callq 0x28d0
movq -0x38(%rbp), %rdi
callq 0x3150
movq -0x28(%rbp), %rdi
movq -0x18(%rbp), %rax
movq (%rax), %rsi
movl $0x1, %edx
callq 0x28d0
jmp 0xdc73
jmp 0xdc75
movq -0x20(%rbp), %rax
addq $0x8, %rax
movq %rax, -0x20(%rbp)
jmp 0xdb4c
addq $0x40, %rsp
popq %rbp
retq
nopl (%rax)
// File: 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:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
cmpq $0x0, -0x8(%rbp)
jne 0xe17c
jmp 0xe228
movq -0x8(%rbp), %rdi
callq 0x2960
movq %rax, %rdi
movq -0x10(%rbp), %rsi
callq 0x27d0
movq %rax, %rdi
callq 0x2990
movq %rax, -0x18(%rbp)
movq -0x8(%rbp), %rax
movq 0x18(%rax), %rax
movq %rax, -0x20(%rbp)
movq -0x20(%rbp), %rax
movq -0x8(%rbp), %rcx
cmpq 0x20(%rcx), %rax
je 0xe228
cmpq $0x0, -0x18(%rbp)
jne 0xe1cc
movq -0x20(%rbp), %rax
movq (%rax), %rdi
callq 0x7980
jmp 0xe218
movq -0x20(%rbp), %rax
movq (%rax), %rdi
leaq 0x85c2(%rip), %rsi      # 0x1679c
callq 0x27d0
movq %rax, %rdi
callq 0x2990
cmpq $0x0, %rax
jne 0xe216
movq -0x20(%rbp), %rax
movq (%rax), %rdi
leaq 0x85a1(%rip), %rsi      # 0x1679c
xorl %edx, %edx
callq 0x28d0
movq %rax, %rdi
movq -0x18(%rbp), %rax
movq (%rax), %rsi
movl $0x1, %edx
callq 0x28d0
jmp 0xe218
jmp 0xe21a
movq -0x20(%rbp), %rax
addq $0x8, %rax
movq %rax, -0x20(%rbp)
jmp 0xe1a9
addq $0x20, %rsp
popq %rbp
retq
nop
// File: 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:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
cmpq $0x0, -0x8(%rbp)
jne 0xe248
jmp 0xe2ea
movq $0x0, -0x10(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x20(%rbp)
movq -0x8(%rbp), %rdi
callq 0x25d0
movq %rax, %rcx
movq -0x20(%rbp), %rax
cmpq %rcx, %rax
jae 0xe2ea
movq -0x8(%rbp), %rax
movq 0x18(%rax), %rax
movq -0x10(%rbp), %rcx
movq (%rax,%rcx,8), %rdi
callq 0x2a60
movq %rax, -0x18(%rbp)
cmpq $0x0, -0x18(%rbp)
je 0xe2d7
movq -0x18(%rbp), %rdi
movq -0x8(%rbp), %rax
movq 0x18(%rax), %rax
movq -0x10(%rbp), %rcx
movq (%rax,%rcx,8), %rsi
movq -0x8(%rbp), %rax
movq 0x18(%rax), %rax
movq -0x10(%rbp), %rcx
movq (%rax,%rcx,8), %rdx
callq 0xda60
movq -0x8(%rbp), %rax
movq 0x18(%rax), %rax
movq -0x10(%rbp), %rcx
movq (%rax,%rcx,8), %rdi
callq 0x3150
movq -0x10(%rbp), %rax
addq $-0x1, %rax
movq %rax, -0x10(%rbp)
jmp 0xe2d9
movq -0x10(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x10(%rbp)
jmp 0xe250
addq $0x20, %rsp
popq %rbp
retq
// File: 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:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
cmpq $0x0, -0x8(%rbp)
jne 0xe308
jmp 0xe405
movq -0x8(%rbp), %rax
movq 0x18(%rax), %rax
movq %rax, -0x10(%rbp)
movq -0x10(%rbp), %rax
movq -0x8(%rbp), %rcx
cmpq 0x20(%rcx), %rax
je 0xe405
movq -0x10(%rbp), %rax
movq (%rax), %rdi
leaq 0x7dd9(%rip), %rsi      # 0x1610d
xorl %edx, %edx
callq 0x28d0
movq %rax, -0x20(%rbp)
movq $0x0, -0x18(%rbp)
movq -0x18(%rbp), %rax
movq %rax, -0x30(%rbp)
movq -0x20(%rbp), %rdi
callq 0x25d0
movq %rax, %rcx
movq -0x30(%rbp), %rax
cmpq %rcx, %rax
jae 0xe3f2
movq -0x8(%rbp), %rdi
leaq 0x7dbb(%rip), %rsi      # 0x1612e
callq 0x2890
movq %rax, %rdi
movq -0x20(%rbp), %rax
movq 0x18(%rax), %rax
movq -0x18(%rbp), %rcx
movq (%rax,%rcx,8), %rax
movq (%rax), %rsi
callq 0x27d0
movq %rax, -0x28(%rbp)
cmpq $0x0, -0x28(%rbp)
je 0xe3df
movq -0x10(%rbp), %rax
movq (%rax), %rdi
movq -0x28(%rbp), %rsi
movq -0x20(%rbp), %rax
movq 0x18(%rax), %rax
movq -0x18(%rbp), %rcx
movq (%rax,%rcx,8), %rdx
callq 0xda60
movq -0x20(%rbp), %rax
movq 0x18(%rax), %rax
movq -0x18(%rbp), %rcx
movq (%rax,%rcx,8), %rdi
callq 0x3150
movq -0x18(%rbp), %rax
addq $-0x1, %rax
movq %rax, -0x18(%rbp)
jmp 0xe3e1
movq -0x18(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x18(%rbp)
jmp 0xe347
jmp 0xe3f4
movq -0x10(%rbp), %rax
addq $0x8, %rax
movq %rax, -0x10(%rbp)
jmp 0xe314
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: 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
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x68, %rsp
movq %rdi, -0x30(%rbp)
movq %rsi, -0x38(%rbp)
movl $0x0, -0x3c(%rbp)
cmpl $0x3, -0x3c(%rbp)
jge 0xedfd
movslq -0x3c(%rbp), %rax
movl $0x1, -0x48(%rbp,%rax,4)
movl -0x3c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x3c(%rbp)
jmp 0xede0
movl $0x0, -0x3c(%rbp)
movq -0x38(%rbp), %rax
movslq -0x3c(%rbp), %rcx
cmpb $0x0, (%rax,%rcx)
je 0xee79
movq -0x38(%rbp), %rax
movslq -0x3c(%rbp), %rcx
movb (%rax,%rcx), %al
movb %al, -0x49(%rbp)
movl -0x48(%rbp), %eax
addl $0x33299112, %eax       # imm = 0x33299112
movl -0x48(%rbp), %ecx
movzbl -0x49(%rbp), %edx
imull %edx, %ecx
addl %ecx, %eax
xorl -0x40(%rbp), %eax
movl %eax, -0x48(%rbp)
movl -0x44(%rbp), %eax
addl $0x1345af22, %eax       # imm = 0x1345AF22
movl -0x40(%rbp), %ecx
movzbl -0x49(%rbp), %edx
imull %edx, %ecx
addl %ecx, %eax
xorl -0x44(%rbp), %eax
movl %eax, -0x44(%rbp)
movl -0x40(%rbp), %eax
addl $0x73a92332, %eax       # imm = 0x73A92332
movl -0x44(%rbp), %ecx
movzbl -0x49(%rbp), %edx
imull %edx, %ecx
addl %ecx, %eax
xorl -0x48(%rbp), %eax
movl %eax, -0x40(%rbp)
movl -0x3c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x3c(%rbp)
jmp 0xee04
movq -0x30(%rbp), %rdi
movzbl -0x48(%rbp), %edx
movzbl -0x47(%rbp), %ecx
movzbl -0x46(%rbp), %r8d
movzbl -0x45(%rbp), %r9d
movzbl -0x44(%rbp), %r13d
movzbl -0x43(%rbp), %r12d
movzbl -0x42(%rbp), %r15d
movzbl -0x41(%rbp), %r14d
movzbl -0x40(%rbp), %ebx
movzbl -0x3f(%rbp), %r11d
movzbl -0x3e(%rbp), %r10d
movzbl -0x3d(%rbp), %eax
leaq 0x8137(%rip), %rsi      # 0x16ff3
movl %r13d, (%rsp)
movl %r12d, 0x8(%rsp)
movl %r15d, 0x10(%rsp)
movl %r14d, 0x18(%rsp)
movl %ebx, 0x20(%rsp)
movl %r11d, 0x28(%rsp)
movl %r10d, 0x30(%rsp)
movl %eax, 0x38(%rsp)
movb $0x0, %al
callq 0x2300
addq $0x68, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
nopw (%rax,%rax)
// File: 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:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
cmpq $0x0, -0x8(%rbp)
jne 0xf255
jmp 0xf2a1
movq -0x8(%rbp), %rax
movq 0x18(%rax), %rax
movq %rax, -0x10(%rbp)
movq -0x10(%rbp), %rax
movq -0x8(%rbp), %rcx
cmpq 0x20(%rcx), %rax
je 0xf2a1
movq -0x10(%rbp), %rax
movq (%rax), %rdi
leaq 0x6e90(%rip), %rsi      # 0x1610d
xorl %edx, %edx
callq 0x28d0
movq %rax, %rdi
leaq -0xc53e(%rip), %rsi     # 0x2d50
callq 0x2fe0
movq -0x10(%rbp), %rax
addq $0x8, %rax
movq %rax, -0x10(%rbp)
jmp 0xf261
addq $0x10, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: 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
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rax
movsbl (%rax), %ecx
xorl %eax, %eax
cmpl $0x0, %ecx
movb %al, -0x11(%rbp)
je 0x11b55
callq 0x2350
movq (%rax), %rax
movq -0x8(%rbp), %rcx
movsbl (%rcx), %ecx
movslq %ecx, %rcx
movzwl (%rax,%rcx,2), %eax
andl $0x2000, %eax           # imm = 0x2000
cmpl $0x0, %eax
setne %al
movb %al, -0x11(%rbp)
movb -0x11(%rbp), %al
testb $0x1, %al
jne 0x11b5e
jmp 0x11b6e
jmp 0x11b60
movq -0x8(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x8(%rbp)
jmp 0x11b20
jmp 0x11b70
movq -0x8(%rbp), %rax
movsbl (%rax), %ecx
xorl %eax, %eax
cmpl $0x0, %ecx
movb %al, -0x12(%rbp)
je 0x11b96
movq -0x8(%rbp), %rax
movsbl (%rax), %edi
callq 0x4190
cmpl $0x0, %eax
setne %al
movb %al, -0x12(%rbp)
movb -0x12(%rbp), %al
testb $0x1, %al
jne 0x11b9f
jmp 0x11bc4
movq -0x8(%rbp), %rax
movb (%rax), %cl
movq -0x10(%rbp), %rax
movq %rax, %rdx
addq $0x1, %rdx
movq %rdx, -0x10(%rbp)
movb %cl, (%rax)
movq -0x8(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x8(%rbp)
jmp 0x11b70
movq -0x10(%rbp), %rax
movb $0x0, (%rax)
movq -0x8(%rbp), %rax
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: 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 %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movq -0x8(%rbp), %rdi
movl $0x22, %esi
callq 0x2130
movq %rax, -0x18(%rbp)
cmpq $0x0, -0x18(%rbp)
je 0x11c5b
movq -0x18(%rbp), %rdi
movq -0x18(%rbp), %rsi
addq $0x1, %rsi
callq 0x3fe0
movq -0x18(%rbp), %rdi
leaq 0x569f(%rip), %rsi      # 0x172c3
xorl %eax, %eax
movl %eax, %edx
callq 0x3f50
cmpl $0x0, -0xc(%rbp)
jne 0x11c47
movq -0x18(%rbp), %rdi
leaq 0x568c(%rip), %rsi      # 0x172ca
xorl %eax, %eax
movl %eax, %edx
callq 0x3f50
movq -0x8(%rbp), %rdi
movl $0x22, %esi
callq 0x2130
movq %rax, -0x18(%rbp)
jmp 0x11c01
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)