LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: corecodec[P]coremake/coremake.c
// Function: getvalue
item* getvalue(item* p)
{
	if (p)
	{
		item** child;
		for (child=p->child;child!=p->childend;++child)
			if (!((*child)->flags & FLAG_REMOVED))
				return *child;
	}
	return NULL;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x10(%rbp)
cmpq $0x0, -0x10(%rbp)
je 0x29ea
movq -0x10(%rbp), %rax
movq 0x18(%rax), %rax
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rax
movq -0x10(%rbp), %rcx
cmpq 0x20(%rcx), %rax
je 0x29e8
movq -0x18(%rbp), %rax
movq (%rax), %rax
movl 0x30(%rax), %eax
andl $0x40, %eax
cmpl $0x0, %eax
jne 0x29d8
movq -0x18(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x8(%rbp)
jmp 0x29f2
jmp 0x29da
movq -0x18(%rbp), %rax
addq $0x8, %rax
movq %rax, -0x18(%rbp)
jmp 0x29ab
jmp 0x29ea
movq $0x0, -0x8(%rbp)
movq -0x8(%rbp), %rax
popq %rbp
retq
nopl (%rax,%rax)
// File: corecodec[P]coremake/coremake.c
// Function: setvalue
void setvalue(item* p,const char* value)
{
    item* v = getvalue(p);
    if (v)
    {
        if (strcmp(v->value,value)==0)
            return;
        v->flags |= FLAG_REMOVED;
    }
    item_get(p,value,1);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rdi
callq 0x2990
movq %rax, -0x18(%rbp)
cmpq $0x0, -0x18(%rbp)
je 0x2a48
movq -0x18(%rbp), %rax
movq (%rax), %rdi
movq -0x10(%rbp), %rsi
callq 0x21d0
cmpl $0x0, %eax
jne 0x2a3b
jmp 0x2a5a
movq -0x18(%rbp), %rax
movl 0x30(%rax), %ecx
orl $0x40, %ecx
movl %ecx, 0x30(%rax)
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
movl $0x1, %edx
callq 0x28d0
addq $0x20, %rsp
popq %rbp
retq
// File: corecodec[P]coremake/coremake.c
// Function: compare_use
int compare_use(const item* a, const item* b)
{
	item* refa = findref(a);
	item* refb = findref(b);
	if (refa && refb)
	{
		size_t i;
		item* use;

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

				return 1;
			}

	}
	return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x60, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x10(%rbp), %rdi
callq 0x2a60
movq %rax, -0x20(%rbp)
movq -0x18(%rbp), %rdi
callq 0x2a60
movq %rax, -0x28(%rbp)
cmpq $0x0, -0x20(%rbp)
je 0x2ea0
cmpq $0x0, -0x28(%rbp)
je 0x2ea0
movq -0x28(%rbp), %rdi
leaq 0x13372(%rip), %rsi     # 0x1610d
xorl %edx, %edx
callq 0x28d0
movq %rax, -0x38(%rbp)
movq $0x0, -0x30(%rbp)
movq -0x30(%rbp), %rax
movq %rax, -0x40(%rbp)
movq -0x38(%rbp), %rdi
callq 0x25d0
movq %rax, %rcx
movq -0x40(%rbp), %rax
cmpq %rcx, %rax
jae 0x2e9e
movq -0x20(%rbp), %rax
movq %rax, -0x48(%rbp)
movq -0x38(%rbp), %rax
movq 0x18(%rax), %rax
movq -0x30(%rbp), %rcx
movq (%rax,%rcx,8), %rdi
callq 0x2a60
movq %rax, %rcx
movq -0x48(%rbp), %rax
cmpq %rcx, %rax
jne 0x2e8b
movq -0x20(%rbp), %rdi
leaq 0x13306(%rip), %rsi     # 0x1610d
xorl %edx, %edx
callq 0x28d0
movq %rax, -0x38(%rbp)
movq $0x0, -0x30(%rbp)
movq -0x30(%rbp), %rax
movq %rax, -0x50(%rbp)
movq -0x38(%rbp), %rdi
callq 0x25d0
movq %rax, %rcx
movq -0x50(%rbp), %rax
cmpq %rcx, %rax
jae 0x2e82
movq -0x28(%rbp), %rax
movq %rax, -0x58(%rbp)
movq -0x38(%rbp), %rax
movq 0x18(%rax), %rax
movq -0x30(%rbp), %rcx
movq (%rax,%rcx,8), %rdi
callq 0x2a60
movq %rax, %rcx
movq -0x58(%rbp), %rax
cmpq %rcx, %rax
jne 0x2e72
movq -0x20(%rbp), %rdi
movq -0x28(%rbp), %rsi
callq 0x2850
movl %eax, -0x4(%rbp)
jmp 0x2ea7
jmp 0x2e74
movq -0x30(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x30(%rbp)
jmp 0x2e1a
movl $0x1, -0x4(%rbp)
jmp 0x2ea7
jmp 0x2e8d
movq -0x30(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x30(%rbp)
jmp 0x2dae
jmp 0x2ea0
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x60, %rsp
popq %rbp
retq
// File: corecodec[P]coremake/coremake.c
// Function: precompare_use
int precompare_use(const item* refa, const item* refb)
{
	size_t i;
	item* use;

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

			return 1;
		}

	return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x18(%rbp), %rdi
leaq 0x13242(%rip), %rsi     # 0x1610d
xorl %edx, %edx
callq 0x28d0
movq %rax, -0x28(%rbp)
movq $0x0, -0x20(%rbp)
movq -0x20(%rbp), %rax
movq %rax, -0x30(%rbp)
movq -0x28(%rbp), %rdi
callq 0x25d0
movq %rax, %rcx
movq -0x30(%rbp), %rax
cmpq %rcx, %rax
jae 0x2fce
movq -0x10(%rbp), %rax
movq %rax, -0x38(%rbp)
movq -0x28(%rbp), %rax
movq 0x18(%rax), %rax
movq -0x20(%rbp), %rcx
movq (%rax,%rcx,8), %rdi
callq 0x2a60
movq %rax, %rcx
movq -0x38(%rbp), %rax
cmpq %rcx, %rax
jne 0x2fbb
movq -0x10(%rbp), %rdi
leaq 0x131d6(%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 0x2fb2
movq -0x18(%rbp), %rax
movq %rax, -0x48(%rbp)
movq -0x28(%rbp), %rax
movq 0x18(%rax), %rax
movq -0x20(%rbp), %rcx
movq (%rax,%rcx,8), %rdi
callq 0x2a60
movq %rax, %rcx
movq -0x48(%rbp), %rax
cmpq %rcx, %rax
jne 0x2fa2
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rsi
callq 0x2850
movl %eax, -0x4(%rbp)
jmp 0x2fd5
jmp 0x2fa4
movq -0x20(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x20(%rbp)
jmp 0x2f4a
movl $0x1, -0x4(%rbp)
jmp 0x2fd5
jmp 0x2fbd
movq -0x20(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x20(%rbp)
jmp 0x2ede
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x50, %rsp
popq %rbp
retq
nop
// File: corecodec[P]coremake/coremake.c
// Function: item_sort
void item_sort(item* p,int(*compare)(const item*, const item*))
{
	if (item_childcount(p)>=2)
	{
		int changed;
		do
		{
			size_t i,j,n=item_childcount(p);
            changed=0;

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

		} while (changed);
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rdi
callq 0x25d0
cmpq $0x2, %rax
jb 0x30f7
jmp 0x3005
movq -0x8(%rbp), %rdi
callq 0x25d0
movq %rax, -0x30(%rbp)
movl $0x0, -0x14(%rbp)
movq $0x0, -0x20(%rbp)
movq -0x20(%rbp), %rax
cmpq -0x30(%rbp), %rax
jae 0x30e9
movq -0x20(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x28(%rbp)
movq -0x28(%rbp), %rax
cmpq -0x30(%rbp), %rax
jae 0x30d6
movq -0x10(%rbp), %rax
movq -0x8(%rbp), %rcx
movq 0x18(%rcx), %rcx
movq -0x20(%rbp), %rdx
movq (%rcx,%rdx,8), %rdi
movq -0x8(%rbp), %rcx
movq 0x18(%rcx), %rcx
movq -0x28(%rbp), %rdx
movq (%rcx,%rdx,8), %rsi
callq *%rax
cmpl $0x0, %eax
je 0x30c3
movq -0x8(%rbp), %rax
movq 0x18(%rax), %rax
movq -0x20(%rbp), %rcx
movq (%rax,%rcx,8), %rax
movq %rax, -0x38(%rbp)
movq -0x8(%rbp), %rax
movq 0x18(%rax), %rax
movq -0x28(%rbp), %rcx
movq (%rax,%rcx,8), %rdx
movq -0x8(%rbp), %rax
movq 0x18(%rax), %rax
movq -0x20(%rbp), %rcx
movq %rdx, (%rax,%rcx,8)
movq -0x38(%rbp), %rdx
movq -0x8(%rbp), %rax
movq 0x18(%rax), %rax
movq -0x28(%rbp), %rcx
movq %rdx, (%rax,%rcx,8)
movl $0x1, -0x14(%rbp)
jmp 0x30c5
movq -0x28(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x28(%rbp)
jmp 0x303b
jmp 0x30d8
movq -0x20(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x20(%rbp)
jmp 0x3021
jmp 0x30eb
cmpl $0x0, -0x14(%rbp)
jne 0x3005
jmp 0x30f7
addq $0x40, %rsp
popq %rbp
retq
nopl (%rax)
// File: corecodec[P]coremake/coremake.c
// Function: itemcond_delete
void itemcond_delete(itemcond* p)
{
	if (p && --p->refcount==0)
	{
		itemcond_delete(p->a);
		itemcond_delete(p->b);
		free(p);
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
cmpq $0x0, -0x8(%rbp)
je 0x3146
movq -0x8(%rbp), %rcx
movl (%rcx), %eax
addl $-0x1, %eax
movl %eax, (%rcx)
cmpl $0x0, %eax
jne 0x3146
movq -0x8(%rbp), %rax
movq 0x10(%rax), %rdi
callq 0x3100
movq -0x8(%rbp), %rax
movq 0x18(%rax), %rdi
callq 0x3100
movq -0x8(%rbp), %rdi
callq 0x2040
addq $0x10, %rsp
popq %rbp
retq
nopl (%rax)
// File: corecodec[P]coremake/coremake.c
// Function: item_delete
void item_delete(item* p)
{
	item** child;
	if (!p)
		return;
	if (p->parent)
		item_remove(p);
	for (child = p->child;child != p->childend;++child)
	{
		(*child)->parent = NULL;
		item_delete(*child);
	}
	itemcond_delete(p->cond);
	free(p->value);
	free(p);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
cmpq $0x0, -0x8(%rbp)
jne 0x3165
jmp 0x31de
movq -0x8(%rbp), %rax
cmpq $0x0, 0x10(%rax)
je 0x3179
movq -0x8(%rbp), %rdi
callq 0x2610
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 0x31bc
movq -0x10(%rbp), %rax
movq (%rax), %rax
movq $0x0, 0x10(%rax)
movq -0x10(%rbp), %rax
movq (%rax), %rdi
callq 0x3150
movq -0x10(%rbp), %rax
addq $0x8, %rax
movq %rax, -0x10(%rbp)
jmp 0x3185
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rdi
callq 0x3100
movq -0x8(%rbp), %rax
movq (%rax), %rdi
callq 0x2040
movq -0x8(%rbp), %rdi
callq 0x2040
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: corecodec[P]coremake/coremake.c
// Function: itemcond_new
itemcond* itemcond_new(int func, item* value)
{
	itemcond* p = (itemcond*)zalloc(sizeof(itemcond));
    p->refcount = 1;
	p->func = func;
	p->value = value;
	return p;
}

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

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
cmpq $0x0, -0x10(%rbp)
jne 0x326a
cmpq $0x0, -0x18(%rbp)
jne 0x326a
movl $0x1, -0x4(%rbp)
jmp 0x339b
cmpq $0x0, -0x10(%rbp)
je 0x3278
cmpq $0x0, -0x18(%rbp)
jne 0x3284
movl $0x0, -0x4(%rbp)
jmp 0x339b
movq -0x10(%rbp), %rax
movl 0x4(%rax), %eax
movq -0x18(%rbp), %rcx
cmpl 0x4(%rcx), %eax
je 0x32a0
movl $0x0, -0x4(%rbp)
jmp 0x339b
movq -0x10(%rbp), %rax
movl 0x4(%rax), %eax
movl %eax, -0x1c(%rbp)
testl %eax, %eax
je 0x32cd
jmp 0x32b0
movl -0x1c(%rbp), %eax
decl %eax
subl $0x2, %eax
jb 0x32ed
jmp 0x32bc
movl -0x1c(%rbp), %eax
subl $0x3, %eax
je 0x337a
jmp 0x3394
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rax
movq -0x18(%rbp), %rcx
cmpq 0x8(%rcx), %rax
sete %al
andb $0x1, %al
movzbl %al, %eax
movl %eax, -0x4(%rbp)
jmp 0x339b
movq -0x10(%rbp), %rax
movq 0x10(%rax), %rdi
movq -0x18(%rbp), %rax
movq 0x10(%rax), %rsi
callq 0x3240
cmpl $0x0, %eax
je 0x3328
movq -0x10(%rbp), %rax
movq 0x18(%rax), %rdi
movq -0x18(%rbp), %rax
movq 0x18(%rax), %rsi
callq 0x3240
movl %eax, %ecx
movb $0x1, %al
cmpl $0x0, %ecx
movb %al, -0x1d(%rbp)
jne 0x336d
movq -0x10(%rbp), %rax
movq 0x18(%rax), %rdi
movq -0x18(%rbp), %rax
movq 0x10(%rax), %rsi
callq 0x3240
movl %eax, %ecx
xorl %eax, %eax
cmpl $0x0, %ecx
movb %al, -0x1e(%rbp)
je 0x3367
movq -0x10(%rbp), %rax
movq 0x10(%rax), %rdi
movq -0x18(%rbp), %rax
movq 0x18(%rax), %rsi
callq 0x3240
cmpl $0x0, %eax
setne %al
movb %al, -0x1e(%rbp)
movb -0x1e(%rbp), %al
movb %al, -0x1d(%rbp)
movb -0x1d(%rbp), %al
andb $0x1, %al
movzbl %al, %eax
movl %eax, -0x4(%rbp)
jmp 0x339b
movq -0x10(%rbp), %rax
movq 0x10(%rax), %rdi
movq -0x18(%rbp), %rax
movq 0x10(%rax), %rsi
callq 0x3240
movl %eax, -0x4(%rbp)
jmp 0x339b
movl $0x1, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: corecodec[P]coremake/coremake.c
// Function: itemcond_contains
int itemcond_contains(itemcond* cond,item* has)
{
    if (cond->func == COND_AND && has)
    {
        if (cond->a->value == has)
            return 1;
        if (cond->b->value == has)
            return 1;
    }
    return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x10(%rbp), %rax
cmpl $0x2, 0x4(%rax)
jne 0x3405
cmpq $0x0, -0x18(%rbp)
je 0x3405
movq -0x10(%rbp), %rax
movq 0x10(%rax), %rax
movq 0x8(%rax), %rax
cmpq -0x18(%rbp), %rax
jne 0x33e8
movl $0x1, -0x4(%rbp)
jmp 0x340c
movq -0x10(%rbp), %rax
movq 0x18(%rax), %rax
movq 0x8(%rax), %rax
cmpq -0x18(%rbp), %rax
jne 0x3403
movl $0x1, -0x4(%rbp)
jmp 0x340c
jmp 0x3405
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: corecodec[P]coremake/coremake.c
// Function: itemcond_reduce
void itemcond_reduce(itemcond* cond)
{
    if (cond->func == COND_OR)
    {
        itemcond_reduce(cond->a);
        itemcond_reduce(cond->b);
        if (cond->a->value)
        {
            if (itemcond_same(cond->a,cond->b))
            {
                cond->func = COND_GET;
                cond->value = cond->a->value;
            }
        }
        if (cond->a->func == COND_GET && itemcond_contains(cond->b,cond->a->value))
        {
            cond->func = COND_GET;
            cond->value = cond->a->value;
        }
        if (cond->b->func == COND_GET && itemcond_contains(cond->a,cond->b->value))
        {
            cond->func = COND_GET;
            cond->value = cond->b->value;
        }
    }
    else
    if (cond->func == COND_AND)
    {
        itemcond_reduce(cond->a);
        itemcond_reduce(cond->b);
        if (cond->a->value)
        {
            if (itemcond_same(cond->a,cond->b))
            {
                cond->func = COND_GET;
                cond->value = cond->a->value;
            }
        }
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
cmpl $0x1, 0x4(%rax)
jne 0x3536
movq -0x8(%rbp), %rax
movq 0x10(%rax), %rdi
callq 0x3420
movq -0x8(%rbp), %rax
movq 0x18(%rax), %rdi
callq 0x3420
movq -0x8(%rbp), %rax
movq 0x10(%rax), %rax
cmpq $0x0, 0x8(%rax)
je 0x349e
movq -0x8(%rbp), %rax
movq 0x10(%rax), %rdi
movq -0x8(%rbp), %rax
movq 0x18(%rax), %rsi
callq 0x3240
cmpl $0x0, %eax
je 0x349c
movq -0x8(%rbp), %rax
movl $0x0, 0x4(%rax)
movq -0x8(%rbp), %rax
movq 0x10(%rax), %rax
movq 0x8(%rax), %rcx
movq -0x8(%rbp), %rax
movq %rcx, 0x8(%rax)
jmp 0x349e
movq -0x8(%rbp), %rax
movq 0x10(%rax), %rax
cmpl $0x0, 0x4(%rax)
jne 0x34e9
movq -0x8(%rbp), %rax
movq 0x18(%rax), %rdi
movq -0x8(%rbp), %rax
movq 0x10(%rax), %rax
movq 0x8(%rax), %rsi
callq 0x33b0
cmpl $0x0, %eax
je 0x34e9
movq -0x8(%rbp), %rax
movl $0x0, 0x4(%rax)
movq -0x8(%rbp), %rax
movq 0x10(%rax), %rax
movq 0x8(%rax), %rcx
movq -0x8(%rbp), %rax
movq %rcx, 0x8(%rax)
movq -0x8(%rbp), %rax
movq 0x18(%rax), %rax
cmpl $0x0, 0x4(%rax)
jne 0x3534
movq -0x8(%rbp), %rax
movq 0x10(%rax), %rdi
movq -0x8(%rbp), %rax
movq 0x18(%rax), %rax
movq 0x8(%rax), %rsi
callq 0x33b0
cmpl $0x0, %eax
je 0x3534
movq -0x8(%rbp), %rax
movl $0x0, 0x4(%rax)
movq -0x8(%rbp), %rax
movq 0x18(%rax), %rax
movq 0x8(%rax), %rcx
movq -0x8(%rbp), %rax
movq %rcx, 0x8(%rax)
jmp 0x35a8
movq -0x8(%rbp), %rax
cmpl $0x2, 0x4(%rax)
jne 0x35a6
movq -0x8(%rbp), %rax
movq 0x10(%rax), %rdi
callq 0x3420
movq -0x8(%rbp), %rax
movq 0x18(%rax), %rdi
callq 0x3420
movq -0x8(%rbp), %rax
movq 0x10(%rax), %rax
cmpq $0x0, 0x8(%rax)
je 0x35a4
movq -0x8(%rbp), %rax
movq 0x10(%rax), %rdi
movq -0x8(%rbp), %rax
movq 0x18(%rax), %rsi
callq 0x3240
cmpl $0x0, %eax
je 0x35a2
movq -0x8(%rbp), %rax
movl $0x0, 0x4(%rax)
movq -0x8(%rbp), %rax
movq 0x10(%rax), %rax
movq 0x8(%rax), %rcx
movq -0x8(%rbp), %rax
movq %rcx, 0x8(%rax)
jmp 0x35a4
jmp 0x35a6
jmp 0x35a8
addq $0x10, %rsp
popq %rbp
retq
nop
// File: corecodec[P]coremake/coremake.c
// Function: itemcond_partof
int itemcond_partof(itemcond* a,itemcond* b)
{
    if (itemcond_same(a,b))
        return 1;

    if (a && a->func == COND_OR)
        return itemcond_partof(a->a,b) || itemcond_partof(a->b,b);

    return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rsi
callq 0x3240
cmpl $0x0, %eax
je 0x35db
movl $0x1, -0x4(%rbp)
jmp 0x3637
cmpq $0x0, -0x10(%rbp)
je 0x3630
movq -0x10(%rbp), %rax
cmpl $0x1, 0x4(%rax)
jne 0x3630
movq -0x10(%rbp), %rax
movq 0x10(%rax), %rdi
movq -0x18(%rbp), %rsi
callq 0x35b0
movl %eax, %ecx
movb $0x1, %al
cmpl $0x0, %ecx
movb %al, -0x19(%rbp)
jne 0x3623
movq -0x10(%rbp), %rax
movq 0x18(%rax), %rdi
movq -0x18(%rbp), %rsi
callq 0x35b0
cmpl $0x0, %eax
setne %al
movb %al, -0x19(%rbp)
movb -0x19(%rbp), %al
andb $0x1, %al
movzbl %al, %eax
movl %eax, -0x4(%rbp)
jmp 0x3637
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x20, %rsp
popq %rbp
retq
// File: corecodec[P]coremake/coremake.c
// Function: itemcond_eval
int itemcond_eval(itemcond* p)
{
	switch (p->func)
	{
	case COND_GET:
		if (!(p->value->flags & FLAG_PROCESSED))
			preprocess_condeval(p->value);
		return (p->value->flags & FLAG_DEFINED)==FLAG_DEFINED;
	case COND_AND:
		return itemcond_eval(p->a) && itemcond_eval(p->b);
	case COND_OR:
		return itemcond_eval(p->a) || itemcond_eval(p->b);
	case COND_NOT:
		return !itemcond_eval(p->a);
	case COND_0:
        return 0;
	case COND_1:
        return 1;
	default:
		return 1;
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movq -0x10(%rbp), %rax
movl 0x4(%rax), %eax
movq %rax, -0x18(%rbp)
subq $0x5, %rax
ja 0x3781
movq -0x18(%rbp), %rax
leaq 0x12978(%rip), %rcx     # 0x16004
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rax
movl 0x30(%rax), %eax
andl $0x80, %eax
cmpl $0x0, %eax
jne 0x36b7
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rdi
callq 0x37a0
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rax
movl 0x30(%rax), %eax
andl $0x20, %eax
cmpl $0x20, %eax
sete %al
andb $0x1, %al
movzbl %al, %eax
movl %eax, -0x4(%rbp)
jmp 0x3788
movq -0x10(%rbp), %rax
movq 0x10(%rax), %rdi
callq 0x3660
movl %eax, %ecx
xorl %eax, %eax
cmpl $0x0, %ecx
movb %al, -0x19(%rbp)
je 0x3707
movq -0x10(%rbp), %rax
movq 0x18(%rax), %rdi
callq 0x3660
cmpl $0x0, %eax
setne %al
movb %al, -0x19(%rbp)
movb -0x19(%rbp), %al
andb $0x1, %al
movzbl %al, %eax
movl %eax, -0x4(%rbp)
jmp 0x3788
movq -0x10(%rbp), %rax
movq 0x10(%rax), %rdi
callq 0x3660
movl %eax, %ecx
movb $0x1, %al
cmpl $0x0, %ecx
movb %al, -0x1a(%rbp)
jne 0x3743
movq -0x10(%rbp), %rax
movq 0x18(%rax), %rdi
callq 0x3660
cmpl $0x0, %eax
setne %al
movb %al, -0x1a(%rbp)
movb -0x1a(%rbp), %al
andb $0x1, %al
movzbl %al, %eax
movl %eax, -0x4(%rbp)
jmp 0x3788
movq -0x10(%rbp), %rax
movq 0x10(%rax), %rdi
callq 0x3660
cmpl $0x0, %eax
setne %al
xorb $-0x1, %al
andb $0x1, %al
movzbl %al, %eax
movl %eax, -0x4(%rbp)
jmp 0x3788
movl $0x0, -0x4(%rbp)
jmp 0x3788
movl $0x1, -0x4(%rbp)
jmp 0x3788
movl $0x1, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: corecodec[P]coremake/coremake.c
// Function: preprocess_condeval
void preprocess_condeval(item* p)
{
	item** child;

	p->flags |= FLAG_PROCESSED;

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

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

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movl 0x30(%rax), %ecx
orl $0x80, %ecx
movl %ecx, 0x30(%rax)
movq -0x8(%rbp), %rax
cmpq $0x0, 0x8(%rax)
je 0x37e4
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rdi
callq 0x3660
cmpl $0x0, %eax
jne 0x37e2
movq -0x8(%rbp), %rdi
callq 0x7980
jmp 0x37e4
movq -0x8(%rbp), %rax
movl 0x30(%rax), %eax
andl $0x40, %eax
cmpl $0x0, %eax
jne 0x3829
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 0x3827
movq -0x10(%rbp), %rax
movq (%rax), %rdi
callq 0x37a0
movq -0x10(%rbp), %rax
addq $0x8, %rax
movq %rax, -0x10(%rbp)
jmp 0x37ff
jmp 0x3829
addq $0x10, %rsp
popq %rbp
retq
nop
// File: corecodec[P]coremake/coremake.c
// Function: itemcond_and
itemcond* itemcond_and(itemcond* p,itemcond* cond)
{
	if (cond)
	{
		if (p)
		{
			itemcond* v = itemcond_new(COND_AND,NULL);
			v->a = itemcond_dup(cond);
			v->b = p;
			p = v;
		}
		else
			p = itemcond_dup(cond);
	}
	return p;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
cmpq $0x0, -0x10(%rbp)
je 0x3899
cmpq $0x0, -0x8(%rbp)
je 0x388a
movl $0x2, %edi
xorl %eax, %eax
movl %eax, %esi
callq 0x31f0
movq %rax, -0x18(%rbp)
movq -0x10(%rbp), %rdi
callq 0x3640
movq %rax, %rcx
movq -0x18(%rbp), %rax
movq %rcx, 0x10(%rax)
movq -0x8(%rbp), %rcx
movq -0x18(%rbp), %rax
movq %rcx, 0x18(%rax)
movq -0x18(%rbp), %rax
movq %rax, -0x8(%rbp)
jmp 0x3897
movq -0x10(%rbp), %rdi
callq 0x3640
movq %rax, -0x8(%rbp)
jmp 0x3899
movq -0x8(%rbp), %rax
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: corecodec[P]coremake/coremake.c
// Function: itemcond_or
itemcond* itemcond_or(itemcond* p,itemcond* cond)
{
	if (cond && p)
	{
		itemcond* v = itemcond_new(COND_OR,NULL);
		v->a = itemcond_dup(cond);
		v->b = p;
		p = v;
	}
	else
	{
		itemcond_delete(p);
		p = NULL;
	}
	return p;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
cmpq $0x0, -0x10(%rbp)
je 0x390a
cmpq $0x0, -0x8(%rbp)
je 0x390a
movl $0x1, %edi
xorl %eax, %eax
movl %eax, %esi
callq 0x31f0
movq %rax, -0x18(%rbp)
movq -0x10(%rbp), %rdi
callq 0x3640
movq %rax, %rcx
movq -0x18(%rbp), %rax
movq %rcx, 0x10(%rax)
movq -0x8(%rbp), %rcx
movq -0x18(%rbp), %rax
movq %rcx, 0x18(%rax)
movq -0x18(%rbp), %rax
movq %rax, -0x8(%rbp)
jmp 0x391b
movq -0x8(%rbp), %rdi
callq 0x3100
movq $0x0, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: corecodec[P]coremake/coremake.c
// Function: item_getmerge
item* item_getmerge(item* p,const item* child,int removed,int *exists)
{
    item* dup;
	*exists = item_find(p,child->value) != NULL;
	dup = item_get(p,child->value,(child->flags & FLAG_DEFINED)==FLAG_DEFINED);
    if (((child->flags & FLAG_REMOVED) || removed) && (!*exists || (dup->flags & FLAG_REMOVED)))
        dup->flags |= FLAG_REMOVED;
    else
        dup->flags &= ~FLAG_REMOVED;
    dup->flags |= (child->flags & ~FLAG_REMOVED);
    return dup;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl %edx, -0x14(%rbp)
movq %rcx, -0x20(%rbp)
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rax
movq (%rax), %rsi
callq 0x27d0
cmpq $0x0, %rax
setne %al
andb $0x1, %al
movzbl %al, %ecx
movq -0x20(%rbp), %rax
movl %ecx, (%rax)
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rax
movq (%rax), %rsi
movq -0x10(%rbp), %rax
movl 0x30(%rax), %eax
andl $0x20, %eax
cmpl $0x20, %eax
sete %al
andb $0x1, %al
movzbl %al, %edx
callq 0x28d0
movq %rax, -0x28(%rbp)
movq -0x10(%rbp), %rax
movl 0x30(%rax), %eax
andl $0x40, %eax
cmpl $0x0, %eax
jne 0x39a7
cmpl $0x0, -0x14(%rbp)
je 0x39ce
movq -0x20(%rbp), %rax
cmpl $0x0, (%rax)
je 0x39bf
movq -0x28(%rbp), %rax
movl 0x30(%rax), %eax
andl $0x40, %eax
cmpl $0x0, %eax
je 0x39ce
movq -0x28(%rbp), %rax
movl 0x30(%rax), %ecx
orl $0x40, %ecx
movl %ecx, 0x30(%rax)
jmp 0x39db
movq -0x28(%rbp), %rax
movl 0x30(%rax), %ecx
andl $-0x41, %ecx
movl %ecx, 0x30(%rax)
movq -0x10(%rbp), %rax
movl 0x30(%rax), %ecx
andl $-0x41, %ecx
movq -0x28(%rbp), %rax
orl 0x30(%rax), %ecx
movl %ecx, 0x30(%rax)
movq -0x28(%rbp), %rax
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax)
// File: corecodec[P]coremake/coremake.c
// Function: item_merge2
void item_merge2(item* p,item* group,itemcond* cond0,int removed,int exists)
{
	if (group)
	{
		item** child;
		itemcond* cond = itemcond_and(itemcond_dup(group->cond),cond0);

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

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

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movl %ecx, -0x1c(%rbp)
movl %r8d, -0x20(%rbp)
cmpq $0x0, -0x10(%rbp)
je 0x3b11
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rdi
callq 0x3640
movq %rax, %rdi
movq -0x18(%rbp), %rsi
callq 0x3830
movq %rax, -0x30(%rbp)
movq -0x10(%rbp), %rax
movq 0x18(%rax), %rax
movq %rax, -0x28(%rbp)
movq -0x28(%rbp), %rax
movq -0x10(%rbp), %rcx
cmpq 0x20(%rcx), %rax
je 0x3aa1
movq -0x8(%rbp), %rdi
movq -0x28(%rbp), %rax
movq (%rax), %rsi
movl -0x1c(%rbp), %edx
leaq -0x34(%rbp), %rcx
callq 0x3930
movq %rax, -0x40(%rbp)
movq -0x40(%rbp), %rdi
movq -0x28(%rbp), %rax
movq (%rax), %rsi
movq -0x30(%rbp), %rdx
movl -0x1c(%rbp), %ecx
movl -0x34(%rbp), %r8d
callq 0x3a00
movq -0x28(%rbp), %rax
addq $0x8, %rax
movq %rax, -0x28(%rbp)
jmp 0x3a4f
movq -0x10(%rbp), %rdi
callq 0x25d0
cmpq $0x0, %rax
je 0x3ac1
movq -0x8(%rbp), %rax
movl 0x30(%rax), %eax
andl $0x100, %eax            # imm = 0x100
cmpl $0x0, %eax
je 0x3b08
cmpl $0x0, -0x20(%rbp)
je 0x3ae5
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rdi
movq -0x30(%rbp), %rsi
callq 0x38b0
movq %rax, %rcx
movq -0x8(%rbp), %rax
movq %rcx, 0x8(%rax)
jmp 0x3b06
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rdi
callq 0x3100
movq -0x30(%rbp), %rdi
callq 0x3640
movq %rax, %rcx
movq -0x8(%rbp), %rax
movq %rcx, 0x8(%rax)
jmp 0x3b08
movq -0x30(%rbp), %rdi
callq 0x3100
addq $0x40, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: corecodec[P]coremake/coremake.c
// Function: item_merge
void item_merge(item* p,item* group,item* plus)
{
	if (group)
	{
		int removed=0;
		item* i;
		itemcond* cond = NULL;
		for (i=group->parent;i;i=i->parent)
			cond = itemcond_and(cond,i->cond);
		if (plus)
		{
			removed = (plus->flags & FLAG_REMOVED)==FLAG_REMOVED;
			cond = itemcond_and(cond,plus->cond);
		}
		item_merge2(p,group,cond,removed,1);
		itemcond_delete(cond);
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
cmpq $0x0, -0x10(%rbp)
je 0x3bdb
movl $0x0, -0x1c(%rbp)
movq $0x0, -0x30(%rbp)
movq -0x10(%rbp), %rax
movq 0x10(%rax), %rax
movq %rax, -0x28(%rbp)
cmpq $0x0, -0x28(%rbp)
je 0x3b84
movq -0x30(%rbp), %rdi
movq -0x28(%rbp), %rax
movq 0x8(%rax), %rsi
callq 0x3830
movq %rax, -0x30(%rbp)
movq -0x28(%rbp), %rax
movq 0x10(%rax), %rax
movq %rax, -0x28(%rbp)
jmp 0x3b5a
cmpq $0x0, -0x18(%rbp)
je 0x3bb8
movq -0x18(%rbp), %rax
movl 0x30(%rax), %eax
andl $0x40, %eax
cmpl $0x40, %eax
sete %al
andb $0x1, %al
movzbl %al, %eax
movl %eax, -0x1c(%rbp)
movq -0x30(%rbp), %rdi
movq -0x18(%rbp), %rax
movq 0x8(%rax), %rsi
callq 0x3830
movq %rax, -0x30(%rbp)
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
movq -0x30(%rbp), %rdx
movl -0x1c(%rbp), %ecx
movl $0x1, %r8d
callq 0x3a00
movq -0x30(%rbp), %rdi
callq 0x3100
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: corecodec[P]coremake/coremake.c
// Function: reader_init
void reader_init(reader *p)
{
	memset(p,0,sizeof(reader));
    p->filename = (char*)malloc(MAX_PATH);
    p->line = (char*)malloc(MAX_LINE);
    p->token = (char*)malloc(MAX_LINE);
    memset(p->filename,0,MAX_PATH);
    memset(p->line,0,MAX_LINE);
    memset(p->token,0,MAX_LINE);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
xorl %esi, %esi
movl $0x40, %edx
callq 0x2160
movl $0x400, %edi            # imm = 0x400
callq 0x2250
movq %rax, %rcx
movq -0x8(%rbp), %rax
movq %rcx, 0x38(%rax)
movl $0x2000, %edi           # imm = 0x2000
callq 0x2250
movq %rax, %rcx
movq -0x8(%rbp), %rax
movq %rcx, 0x28(%rax)
movl $0x2000, %edi           # imm = 0x2000
callq 0x2250
movq %rax, %rcx
movq -0x8(%rbp), %rax
movq %rcx, 0x30(%rax)
movq -0x8(%rbp), %rax
movq 0x38(%rax), %rdi
xorl %esi, %esi
movl $0x400, %edx            # imm = 0x400
callq 0x2160
movq -0x8(%rbp), %rax
movq 0x28(%rax), %rdi
xorl %esi, %esi
movl $0x2000, %edx           # imm = 0x2000
callq 0x2160
movq -0x8(%rbp), %rax
movq 0x30(%rax), %rdi
xorl %esi, %esi
movl $0x2000, %edx           # imm = 0x2000
callq 0x2160
addq $0x10, %rsp
popq %rbp
retq
nopl (%rax)
// File: corecodec[P]coremake/coremake.c
// Function: reader_save
void reader_save(reader *p,reader* save)
{
	p->r.filepos = ftell(p->r.f);
	memcpy(save,p,sizeof(reader_static));
    save->filename = strdup(p->filename);
    save->line = strdup(p->line);
    save->token = strdup(p->token);
    save->pos = save->line + (p->pos - p->line);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq (%rax), %rdi
callq 0x21f0
movl %eax, %ecx
movq -0x8(%rbp), %rax
movl %ecx, 0x18(%rax)
movq -0x10(%rbp), %rax
movq -0x8(%rbp), %rcx
movq (%rcx), %rdx
movq %rdx, (%rax)
movq 0x8(%rcx), %rdx
movq %rdx, 0x8(%rax)
movq 0x10(%rcx), %rdx
movq %rdx, 0x10(%rax)
movq 0x18(%rcx), %rcx
movq %rcx, 0x18(%rax)
movq -0x8(%rbp), %rax
movq 0x38(%rax), %rdi
callq 0x2330
movq %rax, %rcx
movq -0x10(%rbp), %rax
movq %rcx, 0x38(%rax)
movq -0x8(%rbp), %rax
movq 0x28(%rax), %rdi
callq 0x2330
movq %rax, %rcx
movq -0x10(%rbp), %rax
movq %rcx, 0x28(%rax)
movq -0x8(%rbp), %rax
movq 0x30(%rax), %rdi
callq 0x2330
movq %rax, %rcx
movq -0x10(%rbp), %rax
movq %rcx, 0x30(%rax)
movq -0x10(%rbp), %rax
movq 0x28(%rax), %rcx
movq -0x8(%rbp), %rax
movq 0x20(%rax), %rax
movq -0x8(%rbp), %rdx
movq 0x28(%rdx), %rdx
subq %rdx, %rax
addq %rax, %rcx
movq -0x10(%rbp), %rax
movq %rcx, 0x20(%rax)
addq $0x10, %rsp
popq %rbp
retq
nop
// File: corecodec[P]coremake/coremake.c
// Function: reader_restore
void reader_restore(reader *p,reader* save)
{
	memcpy(p,save,sizeof(reader_static));
    strcpy(p->filename,save->filename);
    strcpy(p->line,save->line);
    strcpy(p->token,save->token);
    p->pos = p->line + (save->pos - save->line);
	fseek(p->r.f,p->r.filepos,SEEK_SET);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq -0x10(%rbp), %rcx
movq (%rcx), %rdx
movq %rdx, (%rax)
movq 0x8(%rcx), %rdx
movq %rdx, 0x8(%rax)
movq 0x10(%rcx), %rdx
movq %rdx, 0x10(%rax)
movq 0x18(%rcx), %rcx
movq %rcx, 0x18(%rax)
movq -0x8(%rbp), %rax
movq 0x38(%rax), %rdi
movq -0x10(%rbp), %rax
movq 0x38(%rax), %rsi
callq 0x2090
movq -0x8(%rbp), %rax
movq 0x28(%rax), %rdi
movq -0x10(%rbp), %rax
movq 0x28(%rax), %rsi
callq 0x2090
movq -0x8(%rbp), %rax
movq 0x30(%rax), %rdi
movq -0x10(%rbp), %rax
movq 0x30(%rax), %rsi
callq 0x2090
movq -0x8(%rbp), %rax
movq 0x28(%rax), %rcx
movq -0x10(%rbp), %rax
movq 0x20(%rax), %rax
movq -0x10(%rbp), %rdx
movq 0x28(%rdx), %rdx
subq %rdx, %rax
addq %rax, %rcx
movq -0x8(%rbp), %rax
movq %rcx, 0x20(%rax)
movq -0x8(%rbp), %rax
movq (%rax), %rdi
movq -0x8(%rbp), %rax
movslq 0x18(%rax), %rsi
xorl %edx, %edx
callq 0x2280
addq $0x10, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: corecodec[P]coremake/coremake.c
// Function: reader_line
int reader_line(reader* p)
{
	size_t i;
    p->line[0] = 0;
	fgets(p->line,MAX_LINE,p->r.f);
	if (feof(p->r.f) && p->line[0]==0)
		return 0;
	i=strlen(p->line);
	while (i && isspace(p->line[--i]))
		p->line[i]=0;
	p->pos = p->line;
	++p->r.no;
	return 1;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movq -0x10(%rbp), %rax
movq 0x28(%rax), %rax
movb $0x0, (%rax)
movq -0x10(%rbp), %rax
movq 0x28(%rax), %rdi
movq -0x10(%rbp), %rax
movq (%rax), %rdx
movl $0x2000, %esi           # imm = 0x2000
callq 0x21c0
movq -0x10(%rbp), %rax
movq (%rax), %rdi
callq 0x2200
cmpl $0x0, %eax
je 0x3ead
movq -0x10(%rbp), %rax
movq 0x28(%rax), %rax
movsbl (%rax), %eax
cmpl $0x0, %eax
jne 0x3ead
movl $0x0, -0x4(%rbp)
jmp 0x3f42
movq -0x10(%rbp), %rax
movq 0x28(%rax), %rdi
callq 0x2100
movq %rax, -0x18(%rbp)
xorl %eax, %eax
cmpq $0x0, -0x18(%rbp)
movb %al, -0x19(%rbp)
je 0x3f03
callq 0x2350
movq (%rax), %rax
movq -0x10(%rbp), %rcx
movq 0x28(%rcx), %rcx
movq -0x18(%rbp), %rdx
movq %rdx, %rsi
addq $-0x1, %rsi
movq %rsi, -0x18(%rbp)
movsbl -0x1(%rcx,%rdx), %ecx
movslq %ecx, %rcx
movzwl (%rax,%rcx,2), %eax
andl $0x2000, %eax           # imm = 0x2000
cmpl $0x0, %eax
setne %al
movb %al, -0x19(%rbp)
movb -0x19(%rbp), %al
testb $0x1, %al
jne 0x3f0c
jmp 0x3f1e
movq -0x10(%rbp), %rax
movq 0x28(%rax), %rax
movq -0x18(%rbp), %rcx
movb $0x0, (%rax,%rcx)
jmp 0x3ebe
movq -0x10(%rbp), %rax
movq 0x28(%rax), %rcx
movq -0x10(%rbp), %rax
movq %rcx, 0x20(%rax)
movq -0x10(%rbp), %rax
movl 0xc(%rax), %ecx
addl $0x1, %ecx
movl %ecx, 0xc(%rax)
movl $0x1, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: corecodec[P]coremake/coremake.c
// Function: strins
char* strins(char* s,const char* begin,const char* end)
{
	size_t n = end?end-begin:strlen(begin);
	memmove(s+n,s,strlen(s)+1);
	memcpy(s,begin,n);
	return s;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
cmpq $0x0, -0x18(%rbp)
je 0x3f7c
movq -0x18(%rbp), %rax
movq -0x10(%rbp), %rcx
subq %rcx, %rax
movq %rax, -0x28(%rbp)
jmp 0x3f89
movq -0x10(%rbp), %rdi
callq 0x2100
movq %rax, -0x28(%rbp)
movq -0x28(%rbp), %rax
movq %rax, -0x20(%rbp)
movq -0x8(%rbp), %rax
addq -0x20(%rbp), %rax
movq %rax, -0x38(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x30(%rbp)
movq -0x8(%rbp), %rdi
callq 0x2100
movq -0x38(%rbp), %rdi
movq -0x30(%rbp), %rsi
movq %rax, %rdx
addq $0x1, %rdx
callq 0x22b0
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
movq -0x20(%rbp), %rdx
callq 0x2220
movq -0x8(%rbp), %rax
addq $0x40, %rsp
popq %rbp
retq
nopl (%rax)
// File: corecodec[P]coremake/coremake.c
// Function: reader_comment
void reader_comment(reader* p)
{
	char* s = p->line;
	while (*s)
	{
		if (p->r.comment)
		{
			char* s0 = s;
			for (;*s;++s)
				if (s[0]=='*' && s[1]=='/')
				{
					s = strdel(s0,s);
					p->r.comment = 0;
					break;
				}

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

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq 0x28(%rax), %rax
movq %rax, -0x10(%rbp)
movq -0x10(%rbp), %rax
cmpb $0x0, (%rax)
je 0x4151
movq -0x8(%rbp), %rax
cmpl $0x0, 0x8(%rax)
je 0x40d2
movq -0x10(%rbp), %rax
movq %rax, -0x18(%rbp)
movq -0x10(%rbp), %rax
cmpb $0x0, (%rax)
je 0x40b7
movq -0x10(%rbp), %rax
movsbl (%rax), %eax
cmpl $0x2a, %eax
jne 0x40a7
movq -0x10(%rbp), %rax
movsbl 0x1(%rax), %eax
cmpl $0x2f, %eax
jne 0x40a7
movq -0x18(%rbp), %rdi
movq -0x10(%rbp), %rsi
callq 0x3fe0
movq %rax, -0x10(%rbp)
movq -0x8(%rbp), %rax
movl $0x0, 0x8(%rax)
jmp 0x40b7
jmp 0x40a9
movq -0x10(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x10(%rbp)
jmp 0x4067
movq -0x8(%rbp), %rax
cmpl $0x0, 0x8(%rax)
je 0x40d0
movq -0x18(%rbp), %rax
movq %rax, -0x10(%rbp)
movq -0x10(%rbp), %rax
movb $0x0, (%rax)
jmp 0x414c
jmp 0x40d4
movq -0x10(%rbp), %rax
cmpb $0x0, (%rax)
je 0x414a
movq -0x10(%rbp), %rax
movsbl (%rax), %eax
cmpl $0x2f, %eax
jne 0x4118
movq -0x10(%rbp), %rax
movsbl 0x1(%rax), %eax
cmpl $0x2a, %eax
jne 0x4118
movq -0x10(%rbp), %rdi
movq -0x10(%rbp), %rsi
addq $0x2, %rsi
callq 0x3fe0
movq %rax, -0x10(%rbp)
movq -0x8(%rbp), %rax
movl $0x1, 0x8(%rax)
jmp 0x414a
movq -0x10(%rbp), %rax
movsbl (%rax), %eax
cmpl $0x2f, %eax
jne 0x413a
movq -0x10(%rbp), %rax
movsbl 0x1(%rax), %eax
cmpl $0x2f, %eax
jne 0x413a
movq -0x10(%rbp), %rax
movb $0x0, (%rax)
jmp 0x414a
jmp 0x413c
movq -0x10(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x10(%rbp)
jmp 0x40d4
jmp 0x414c
jmp 0x4048
addq $0x20, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: corecodec[P]coremake/coremake.c
// Function: reader_istoken
int reader_istoken(reader* p,const char* token)
{
	if (!(p->r.flags & FLAG_READY) && !reader_read(p))
		return 0;

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

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

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x10(%rbp), %rax
movl 0x10(%rax), %eax
andl $0x200, %eax            # imm = 0x200
cmpl $0x0, %eax
jne 0x4668
movq -0x10(%rbp), %rdi
callq 0x4240
cmpl $0x0, %eax
jne 0x4668
movl $0x0, -0x4(%rbp)
jmp 0x469e
movq -0x10(%rbp), %rax
movq 0x30(%rax), %rdi
movq -0x18(%rbp), %rsi
callq 0x2050
cmpl $0x0, %eax
je 0x4687
movl $0x0, -0x4(%rbp)
jmp 0x469e
movq -0x10(%rbp), %rax
movl 0x10(%rax), %ecx
andl $0xfffffdff, %ecx       # imm = 0xFFFFFDFF
movl %ecx, 0x10(%rax)
movl $0x1, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x20, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: corecodec[P]coremake/coremake.c
// Function: reader_istoken_n
int reader_istoken_n(reader* p,const char* token, int n)
{
	if (!(p->r.flags & FLAG_READY) && !reader_read(p))
		return 0;

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

	return 1;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movl %edx, -0x1c(%rbp)
movq -0x10(%rbp), %rax
movl 0x10(%rax), %eax
andl $0x200, %eax            # imm = 0x200
cmpl $0x0, %eax
jne 0x46eb
movq -0x10(%rbp), %rdi
callq 0x4240
cmpl $0x0, %eax
jne 0x46eb
movl $0x0, -0x4(%rbp)
jmp 0x4715
movq -0x10(%rbp), %rax
movq 0x30(%rax), %rdi
movq -0x18(%rbp), %rsi
movslq -0x1c(%rbp), %rdx
callq 0x2260
cmpl $0x0, %eax
je 0x470e
movl $0x0, -0x4(%rbp)
jmp 0x4715
movl $0x1, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x20, %rsp
popq %rbp
retq
nop
// File: corecodec[P]coremake/coremake.c
// Function: reader_tokenline
int reader_tokenline(reader* p,int onespace)
{
	char* s = p->pos;

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

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

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

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

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movq -0x8(%rbp), %rax
movq 0x20(%rax), %rax
movq %rax, -0x18(%rbp)
movq -0x8(%rbp), %rax
movl 0x10(%rax), %eax
andl $0x200, %eax            # imm = 0x200
cmpl $0x0, %eax
jne 0x479e
jmp 0x47bd
leaq 0x119de(%rip), %rdi     # 0x16183
leaq 0x1192b(%rip), %rsi     # 0x160d7
movl $0x3d8, %edx            # imm = 0x3D8
leaq 0x119e6(%rip), %rcx     # 0x1619e
callq 0x2140
cmpl $0x0, -0xc(%rbp)
jl 0x481b
jmp 0x47c5
movq -0x18(%rbp), %rax
movsbl (%rax), %ecx
xorl %eax, %eax
cmpl $0x0, %ecx
movb %al, -0x19(%rbp)
je 0x47fa
callq 0x2350
movq (%rax), %rax
movq -0x18(%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, -0x19(%rbp)
movb -0x19(%rbp), %al
testb $0x1, %al
jne 0x4803
jmp 0x4819
movq -0x18(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x18(%rbp)
cmpl $0x0, -0xc(%rbp)
je 0x4817
jmp 0x4819
jmp 0x47c5
jmp 0x481b
movq -0x8(%rbp), %rax
movq 0x30(%rax), %rdi
movq -0x18(%rbp), %rsi
callq 0x2090
movq -0x18(%rbp), %rax
movq %rax, -0x28(%rbp)
movq -0x18(%rbp), %rdi
callq 0x2100
movq -0x28(%rbp), %rcx
addq %rax, %rcx
movq -0x8(%rbp), %rax
movq %rcx, 0x20(%rax)
movq -0x8(%rbp), %rax
movq 0x30(%rax), %rax
movsbl (%rax), %eax
cmpl $0x0, %eax
setne %al
andb $0x1, %al
movzbl %al, %eax
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: corecodec[P]coremake/coremake.c
// Function: truncfilefourcc
void truncfilefourcc(char* path)
{
	char* i = getfilename(path);
	memmove(path,i,strlen(i)+1);
    path[4] = 0;
    while (strlen(path)<4)
        strcat(path,"_");
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
callq 0x4940
movq %rax, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x20(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x18(%rbp)
movq -0x10(%rbp), %rdi
callq 0x2100
movq -0x20(%rbp), %rdi
movq -0x18(%rbp), %rsi
movq %rax, %rdx
addq $0x1, %rdx
callq 0x22b0
movq -0x8(%rbp), %rax
movb $0x0, 0x4(%rax)
movq -0x8(%rbp), %rdi
callq 0x2100
cmpq $0x4, %rax
jae 0x4aef
movq -0x8(%rbp), %rdi
leaq 0x128e7(%rip), %rsi     # 0x173cf
callq 0x22f0
jmp 0x4ace
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: corecodec[P]coremake/coremake.c
// Function: truncfileext
void truncfileext(char* path)
{
	char* i = getfilename(path);
	char* ext = strrchr(i,'.');
	if (ext)
		memmove(path,ext+1,strlen(ext+1)+1);
	else
		path[0]=0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
callq 0x4940
movq %rax, -0x10(%rbp)
movq -0x10(%rbp), %rdi
movl $0x2e, %esi
callq 0x2130
movq %rax, -0x18(%rbp)
cmpq $0x0, -0x18(%rbp)
je 0x4b69
movq -0x8(%rbp), %rax
movq %rax, -0x28(%rbp)
movq -0x18(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x20(%rbp)
movq -0x18(%rbp), %rdi
addq $0x1, %rdi
callq 0x2100
movq -0x28(%rbp), %rdi
movq -0x20(%rbp), %rsi
movq %rax, %rdx
addq $0x1, %rdx
callq 0x22b0
jmp 0x4b70
movq -0x8(%rbp), %rax
movb $0x0, (%rax)
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: corecodec[P]coremake/coremake.c
// Function: truncfourcc
void truncfourcc(char* s)
{
	size_t len = strlen(s);
	if (len>2 && s[0]=='\'' && s[len-1]=='\'')
	{
		strdel(s+len-1,s+len);
		strdel(s,s+1);
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
callq 0x2100
movq %rax, -0x10(%rbp)
cmpq $0x2, -0x10(%rbp)
jbe 0x4beb
movq -0x8(%rbp), %rax
movsbl (%rax), %eax
cmpl $0x27, %eax
jne 0x4beb
movq -0x8(%rbp), %rax
movq -0x10(%rbp), %rcx
subq $0x1, %rcx
movsbl (%rax,%rcx), %eax
cmpl $0x27, %eax
jne 0x4beb
movq -0x8(%rbp), %rdi
addq -0x10(%rbp), %rdi
addq $-0x1, %rdi
movq -0x8(%rbp), %rsi
addq -0x10(%rbp), %rsi
callq 0x3fe0
movq -0x8(%rbp), %rdi
movq -0x8(%rbp), %rsi
addq $0x1, %rsi
callq 0x3fe0
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: corecodec[P]coremake/coremake.c
// Function: truncfilepath
void truncfilepath(char* path,int delend)
{
	char* i = getfilename(path);
	if (i) *i=0;
	if (delend)
	{
		delendpath(path);
		if (!path[0])
			strcpy(path,".");
	}
	else
		addendpath(path);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movq -0x8(%rbp), %rdi
callq 0x4940
movq %rax, -0x18(%rbp)
cmpq $0x0, -0x18(%rbp)
je 0x4d8a
movq -0x18(%rbp), %rax
movb $0x0, (%rax)
cmpl $0x0, -0xc(%rbp)
je 0x4db4
movq -0x8(%rbp), %rdi
callq 0x4cf0
movq -0x8(%rbp), %rax
cmpb $0x0, (%rax)
jne 0x4db2
movq -0x8(%rbp), %rdi
leaq 0x12514(%rip), %rsi     # 0x172c1
callq 0x2090
jmp 0x4dbd
movq -0x8(%rbp), %rdi
callq 0x4c90
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: corecodec[P]coremake/coremake.c
// Function: truncfileupper
void truncfileupper(char* path)
{
    delendpath(path);
    truncfilepath(path,0);
    if (!path[0])
        strcpy(path,"./");
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
callq 0x4cf0
movq -0x8(%rbp), %rdi
xorl %esi, %esi
callq 0x4d60
movq -0x8(%rbp), %rax
cmpb $0x0, (%rax)
jne 0x4e09
movq -0x8(%rbp), %rdi
leaq 0x124b5(%rip), %rsi     # 0x172b9
callq 0x2090
addq $0x10, %rsp
popq %rbp
retq
nop
// File: corecodec[P]coremake/coremake.c
// Function: pathdos
void pathdos(char* path)
{
	int i;
	for (i=0;path[i];++i)
		if (path[i]=='/')
			path[i]='\\';
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movl $0x0, -0xc(%rbp)
movq -0x8(%rbp), %rax
movslq -0xc(%rbp), %rcx
cmpb $0x0, (%rax,%rcx)
je 0x4ea7
movq -0x8(%rbp), %rax
movslq -0xc(%rbp), %rcx
movsbl (%rax,%rcx), %eax
cmpl $0x2f, %eax
jne 0x4e9a
movq -0x8(%rbp), %rax
movslq -0xc(%rbp), %rcx
movb $0x5c, (%rax,%rcx)
jmp 0x4e9c
movl -0xc(%rbp), %eax
addl $0x1, %eax
movl %eax, -0xc(%rbp)
jmp 0x4e6f
popq %rbp
retq
nopl (%rax)
// File: corecodec[P]coremake/coremake.c
// Function: reversestr
void reversestr(char *value)
{
    char tmpstr[MAX_LINE];
    size_t i,len=strlen(value);
    for (i=0;i<len;++i)
        tmpstr[i]=value[len-i-1];
    memcpy(value,tmpstr,len);
    value[len]=0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x2020, %rsp           # imm = 0x2020
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
callq 0x2100
movq %rax, -0x2020(%rbp)
movq $0x0, -0x2018(%rbp)
movq -0x2018(%rbp), %rax
cmpq -0x2020(%rbp), %rax
jae 0x4f25
movq -0x8(%rbp), %rax
movq -0x2020(%rbp), %rcx
subq -0x2018(%rbp), %rcx
subq $0x1, %rcx
movb (%rax,%rcx), %cl
movq -0x2018(%rbp), %rax
movb %cl, -0x2010(%rbp,%rax)
movq -0x2018(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x2018(%rbp)
jmp 0x4eda
movq -0x8(%rbp), %rdi
leaq -0x2010(%rbp), %rsi
movq -0x2020(%rbp), %rdx
callq 0x2220
movq -0x8(%rbp), %rax
movq -0x2020(%rbp), %rcx
movb $0x0, (%rax,%rcx)
addq $0x2020, %rsp           # imm = 0x2020
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: corecodec[P]coremake/coremake.c
// Function: escapestr
void escapestr(char *value)
{
    char *s;
    s = strchr(value,'\\');
    while (s)
    {
        memmove(s+1,s,strlen(s)+1);
        value[s-value] = '\\';
        s = strchr(s+2,'\\');
    }
    s = strchr(value,'"');
    while (s)
    {
        memmove(s+1,s,strlen(s)+1);
        value[s-value] = '\\';
        s = strchr(s+2,'"');
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
movl $0x5c, %esi
callq 0x2110
movq %rax, -0x10(%rbp)
cmpq $0x0, -0x10(%rbp)
je 0x4fe1
movq -0x10(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x20(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x18(%rbp)
movq -0x10(%rbp), %rdi
callq 0x2100
movq -0x20(%rbp), %rdi
movq -0x18(%rbp), %rsi
movq %rax, %rdx
addq $0x1, %rdx
callq 0x22b0
movq -0x8(%rbp), %rax
movq -0x10(%rbp), %rcx
movq -0x8(%rbp), %rdx
subq %rdx, %rcx
movb $0x5c, (%rax,%rcx)
movq -0x10(%rbp), %rdi
addq $0x2, %rdi
movl $0x5c, %esi
callq 0x2110
movq %rax, -0x10(%rbp)
jmp 0x4f7e
movq -0x8(%rbp), %rdi
movl $0x22, %esi
callq 0x2110
movq %rax, -0x10(%rbp)
cmpq $0x0, -0x10(%rbp)
je 0x5056
movq -0x10(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x30(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x28(%rbp)
movq -0x10(%rbp), %rdi
callq 0x2100
movq -0x30(%rbp), %rdi
movq -0x28(%rbp), %rsi
movq %rax, %rdx
addq $0x1, %rdx
callq 0x22b0
movq -0x8(%rbp), %rax
movq -0x10(%rbp), %rcx
movq -0x8(%rbp), %rdx
subq %rdx, %rcx
movb $0x5c, (%rax,%rcx)
movq -0x10(%rbp), %rdi
addq $0x2, %rdi
movl $0x22, %esi
callq 0x2110
movq %rax, -0x10(%rbp)
jmp 0x4ff3
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax)
// File: corecodec[P]coremake/coremake.c
// Function: escapepath
void escapepath(char *value, int mode)
{
    char *s;
    s = strchr(value,'/');
    while (s)
    {
        if (mode==2)
            *s = '_';
        else if (mode==3)
            *s = '.';
        s = strchr(s+1,'/');
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movq -0x8(%rbp), %rdi
movl $0x2f, %esi
callq 0x2110
movq %rax, -0x18(%rbp)
cmpq $0x0, -0x18(%rbp)
je 0x50be
cmpl $0x2, -0xc(%rbp)
jne 0x5097
movq -0x18(%rbp), %rax
movb $0x5f, (%rax)
jmp 0x50a6
cmpl $0x3, -0xc(%rbp)
jne 0x50a4
movq -0x18(%rbp), %rax
movb $0x2e, (%rax)
jmp 0x50a6
movq -0x18(%rbp), %rdi
addq $0x1, %rdi
movl $0x2f, %esi
callq 0x2110
movq %rax, -0x18(%rbp)
jmp 0x5081
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)