LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: corecodec[P]coremake/coremake.c
// Function: eval0
char* eval0(const char** s,item* config,reader* file)
{
	int value;
	char* b;
	char* a = eval1(s,config,file);

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

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
movq -0x18(%rbp), %rdx
callq 0x12320
movq %rax, -0x30(%rbp)
movq -0x8(%rbp), %rdi
callq 0x11d40
movq -0x8(%rbp), %rax
movq (%rax), %rax
movsbl (%rax), %eax
cmpl $0x26, %eax
jne 0x121cd
movq -0x8(%rbp), %rax
movq (%rax), %rax
movsbl 0x1(%rax), %eax
cmpl $0x26, %eax
jne 0x121cd
movq -0x8(%rbp), %rax
movq (%rax), %rcx
addq $0x2, %rcx
movq %rcx, (%rax)
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
movq -0x18(%rbp), %rdx
callq 0x12100
movq %rax, -0x28(%rbp)
movq -0x30(%rbp), %rdi
callq 0x11cc0
movl %eax, %ecx
xorl %eax, %eax
cmpl $0x0, %ecx
movb %al, -0x31(%rbp)
je 0x1219f
movq -0x28(%rbp), %rdi
callq 0x11cc0
cmpl $0x0, %eax
setne %al
movb %al, -0x31(%rbp)
movb -0x31(%rbp), %al
andb $0x1, %al
movzbl %al, %eax
movl %eax, -0x1c(%rbp)
movq -0x30(%rbp), %rdi
callq 0x2040
movq -0x28(%rbp), %rdi
callq 0x2040
movl -0x1c(%rbp), %edi
callq 0x11d10
movq %rax, -0x30(%rbp)
jmp 0x12265
movq -0x8(%rbp), %rax
movq (%rax), %rax
movsbl (%rax), %eax
cmpl $0x7c, %eax
jne 0x12263
movq -0x8(%rbp), %rax
movq (%rax), %rax
movsbl 0x1(%rax), %eax
cmpl $0x7c, %eax
jne 0x12263
movq -0x8(%rbp), %rax
movq (%rax), %rcx
addq $0x2, %rcx
movq %rcx, (%rax)
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
movq -0x18(%rbp), %rdx
callq 0x12100
movq %rax, -0x28(%rbp)
movq -0x30(%rbp), %rdi
callq 0x11cc0
movl %eax, %ecx
movb $0x1, %al
cmpl $0x0, %ecx
movb %al, -0x32(%rbp)
jne 0x1223a
movq -0x28(%rbp), %rdi
callq 0x11cc0
cmpl $0x0, %eax
setne %al
movb %al, -0x32(%rbp)
movb -0x32(%rbp), %al
andb $0x1, %al
movzbl %al, %eax
movl %eax, -0x1c(%rbp)
movq -0x30(%rbp), %rdi
callq 0x2040
movq -0x28(%rbp), %rdi
callq 0x2040
movl -0x1c(%rbp), %edi
callq 0x11d10
movq %rax, -0x30(%rbp)
jmp 0x12265
movq -0x30(%rbp), %rax
addq $0x40, %rsp
popq %rbp
retq
nop
// File: corecodec[P]coremake/coremake.c
// Function: eval2
char* eval2(const char** s,item* config,reader* file)
{
	evalspace(s);
	if ((*s)[0] == '!' && (*s)[1] != '=')
	{
		int value;
		char* a;
		*s += 1;
		a = eval2(s,config,file);
		value = !str2bool(a);
		free(a);
		return bool2str(value);
	}
	else
		return eval3(s,config,file);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movq -0x10(%rbp), %rdi
callq 0x11d40
movq -0x10(%rbp), %rax
movq (%rax), %rax
movsbl (%rax), %eax
cmpl $0x21, %eax
jne 0x122ff
movq -0x10(%rbp), %rax
movq (%rax), %rax
movsbl 0x1(%rax), %eax
cmpl $0x3d, %eax
je 0x122ff
movq -0x10(%rbp), %rax
movq (%rax), %rcx
addq $0x1, %rcx
movq %rcx, (%rax)
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rsi
movq -0x20(%rbp), %rdx
callq 0x12270
movq %rax, -0x30(%rbp)
movq -0x30(%rbp), %rdi
callq 0x11cc0
cmpl $0x0, %eax
setne %al
xorb $-0x1, %al
andb $0x1, %al
movzbl %al, %eax
movl %eax, -0x24(%rbp)
movq -0x30(%rbp), %rdi
callq 0x2040
movl -0x24(%rbp), %edi
callq 0x11d10
movq %rax, -0x8(%rbp)
jmp 0x12314
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rsi
movq -0x20(%rbp), %rdx
callq 0x11db0
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x30, %rsp
popq %rbp
retq
nop
// File: corecodec[P]coremake/coremake.c
// Function: eval1
char* eval1(const char** s,item* config,reader* file)
{
	int value;
	char* b;
	char* a = eval2(s,config,file);

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

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
movq -0x18(%rbp), %rdx
callq 0x12270
movq %rax, -0x30(%rbp)
movq -0x8(%rbp), %rdi
callq 0x11d40
movq -0x8(%rbp), %rax
movq (%rax), %rax
movsbl (%rax), %eax
cmpl $0x3d, %eax
jne 0x123cf
movq -0x8(%rbp), %rax
movq (%rax), %rax
movsbl 0x1(%rax), %eax
cmpl $0x3d, %eax
jne 0x123cf
movq -0x8(%rbp), %rax
movq (%rax), %rcx
addq $0x2, %rcx
movq %rcx, (%rax)
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
movq -0x18(%rbp), %rdx
callq 0x12320
movq %rax, -0x28(%rbp)
movq -0x30(%rbp), %rdi
movq -0x28(%rbp), %rsi
callq 0x2050
cmpl $0x0, %eax
sete %al
andb $0x1, %al
movzbl %al, %eax
movl %eax, -0x1c(%rbp)
movq -0x30(%rbp), %rdi
callq 0x2040
movq -0x28(%rbp), %rdi
callq 0x2040
movl -0x1c(%rbp), %edi
callq 0x11d10
movq %rax, -0x30(%rbp)
jmp 0x1244c
movq -0x8(%rbp), %rax
movq (%rax), %rax
movsbl (%rax), %eax
cmpl $0x21, %eax
jne 0x1244a
movq -0x8(%rbp), %rax
movq (%rax), %rax
movsbl 0x1(%rax), %eax
cmpl $0x3d, %eax
jne 0x1244a
movq -0x8(%rbp), %rax
movq (%rax), %rcx
addq $0x2, %rcx
movq %rcx, (%rax)
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
movq -0x18(%rbp), %rdx
callq 0x12320
movq %rax, -0x28(%rbp)
movq -0x30(%rbp), %rdi
movq -0x28(%rbp), %rsi
callq 0x2050
cmpl $0x0, %eax
setne %al
andb $0x1, %al
movzbl %al, %eax
movl %eax, -0x1c(%rbp)
movq -0x30(%rbp), %rdi
callq 0x2040
movq -0x28(%rbp), %rdi
callq 0x2040
movl -0x1c(%rbp), %edi
callq 0x11d10
movq %rax, -0x30(%rbp)
jmp 0x1244c
movq -0x30(%rbp), %rax
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: corecodec[P]coremake/coremake.c
// Function: eval
int eval(const char* s,item* config,reader* file)
{
	int result;
	char* a = eval0(&s,config,file);
	result = str2bool(a);
	free(a);
	return result;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x10(%rbp), %rsi
movq -0x18(%rbp), %rdx
leaq -0x8(%rbp), %rdi
callq 0x12100
movq %rax, -0x28(%rbp)
movq -0x28(%rbp), %rdi
callq 0x11cc0
movl %eax, -0x1c(%rbp)
movq -0x28(%rbp), %rdi
callq 0x2040
movl -0x1c(%rbp), %eax
addq $0x30, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: corecodec[P]coremake/coremake.c
// Function: match
int match(const char* name, const char* mask)
{
    if (*mask=='*')
    {
        ++mask;
        for (;!match(name,mask);++name)
        {
            if (*name==0)
                return 0;
        }
        return 1;
    }
    else
    {
        if (*mask==0)
            return *name==0;

        if (*name==0)
            return 0;

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

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x18(%rbp), %rax
movsbl (%rax), %eax
cmpl $0x2a, %eax
jne 0x12547
movq -0x18(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x18(%rbp)
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rsi
callq 0x124d0
cmpl $0x0, %eax
setne %al
xorb $-0x1, %al
testb $0x1, %al
jne 0x12513
jmp 0x1253b
movq -0x10(%rbp), %rax
movsbl (%rax), %eax
cmpl $0x0, %eax
jne 0x1252b
movl $0x0, -0x4(%rbp)
jmp 0x125d3
jmp 0x1252d
movq -0x10(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x10(%rbp)
jmp 0x124f8
movl $0x1, -0x4(%rbp)
jmp 0x125d3
movq -0x18(%rbp), %rax
movsbl (%rax), %eax
cmpl $0x0, %eax
jne 0x1256a
movq -0x10(%rbp), %rax
movsbl (%rax), %eax
cmpl $0x0, %eax
sete %al
andb $0x1, %al
movzbl %al, %eax
movl %eax, -0x4(%rbp)
jmp 0x125d3
movq -0x10(%rbp), %rax
movsbl (%rax), %eax
cmpl $0x0, %eax
jne 0x1257f
movl $0x0, -0x4(%rbp)
jmp 0x125d3
movq -0x18(%rbp), %rax
movsbl (%rax), %eax
cmpl $0x3f, %eax
je 0x125aa
movq -0x10(%rbp), %rax
movsbl (%rax), %edi
movq -0x18(%rbp), %rax
movsbl (%rax), %esi
callq 0x124b0
movl %eax, %ecx
xorl %eax, %eax
cmpl $0x0, %ecx
movb %al, -0x19(%rbp)
je 0x125c8
movq -0x10(%rbp), %rdi
addq $0x1, %rdi
movq -0x18(%rbp), %rsi
addq $0x1, %rsi
callq 0x124d0
cmpl $0x0, %eax
setne %al
movb %al, -0x19(%rbp)
movb -0x19(%rbp), %al
andb $0x1, %al
movzbl %al, %eax
movl %eax, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax)
// File: corecodec[P]coremake/coremake.c
// Function: remove_file
void remove_file(const char* name)
{
	if (strchr(name,'*') == NULL && strchr(name,'?') == NULL)
		remove(name);
	else
	{
		DIR* dir;
        const char* mask = getfilename(name);
        char path[MAX_PATH];
		strncpy(path,name,MAX_PATH);
		truncfilepath(path,1);
		dir = opendir(path[0]?path:".");
		if (dir)
		{
			struct dirent* entry;
			addendpath(path);
			while ((entry = readdir(dir)) != NULL)
			{
				if (entry->d_name[0]!='.' && match(entry->d_name,mask))
				{
                    char filepath[MAX_PATH];
                    strcpy(filepath,path);
                    strcat(filepath,entry->d_name);
					remove(filepath);
				}
			}
			closedir(dir);
		}
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x840, %rsp            # imm = 0x840
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
movl $0x2a, %esi
callq 0x2110
cmpq $0x0, %rax
jne 0x12625
movq -0x8(%rbp), %rdi
movl $0x3f, %esi
callq 0x2110
cmpq $0x0, %rax
jne 0x12625
movq -0x8(%rbp), %rdi
callq 0x2070
jmp 0x1272d
movq -0x8(%rbp), %rdi
callq 0x4940
movq %rax, -0x18(%rbp)
leaq -0x420(%rbp), %rdi
movq -0x8(%rbp), %rsi
movl $0x400, %edx            # imm = 0x400
callq 0x2060
leaq -0x420(%rbp), %rdi
movl $0x1, %esi
callq 0x4d60
movsbl -0x420(%rbp), %eax
cmpl $0x0, %eax
je 0x12674
leaq -0x420(%rbp), %rax
movq %rax, -0x838(%rbp)
jmp 0x12684
leaq 0x4c46(%rip), %rax      # 0x172c1
movq %rax, -0x838(%rbp)
jmp 0x12684
movq -0x838(%rbp), %rdi
callq 0x20e0
movq %rax, -0x10(%rbp)
cmpq $0x0, -0x10(%rbp)
je 0x1272b
leaq -0x420(%rbp), %rdi
callq 0x4c90
movq -0x10(%rbp), %rdi
callq 0x2230
movq %rax, -0x428(%rbp)
cmpq $0x0, %rax
je 0x12722
movq -0x428(%rbp), %rax
movsbl 0x13(%rax), %eax
cmpl $0x2e, %eax
je 0x12720
movq -0x428(%rbp), %rdi
addq $0x13, %rdi
movq -0x18(%rbp), %rsi
callq 0x124d0
cmpl $0x0, %eax
je 0x12720
leaq -0x830(%rbp), %rdi
leaq -0x420(%rbp), %rsi
callq 0x2090
leaq -0x830(%rbp), %rdi
movq -0x428(%rbp), %rsi
addq $0x13, %rsi
callq 0x22f0
leaq -0x830(%rbp), %rdi
callq 0x2070
jmp 0x126ab
movq -0x10(%rbp), %rdi
callq 0x2180
jmp 0x1272d
addq $0x840, %rsp            # imm = 0x840
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: corecodec[P]coremake/coremake.c
// Function: remove_dir
void remove_dir(const char* name)
{
	DIR* dir = opendir(name);
	if (dir)
	{
		struct dirent* entry;
		while ((entry = readdir(dir)) != NULL)
		{
			if (entry->d_name[0]!='.')
			{
				char item[MAX_PATH];
				sprintf(item,"%s/%s",name,entry->d_name);
				remove_dir(item);
			}
		}
		closedir(dir);
        remove_dir(".DS_Store");
        remove_dir(".Trashes");
		rmdir(name);
	}
	else
		remove(name);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x420, %rsp            # imm = 0x420
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
callq 0x20e0
movq %rax, -0x10(%rbp)
cmpq $0x0, -0x10(%rbp)
je 0x127e0
jmp 0x12765
movq -0x10(%rbp), %rdi
callq 0x2230
movq %rax, -0x18(%rbp)
cmpq $0x0, %rax
je 0x127b4
movq -0x18(%rbp), %rax
movsbl 0x13(%rax), %eax
cmpl $0x2e, %eax
je 0x127b2
leaq -0x420(%rbp), %rdi
movq -0x8(%rbp), %rdx
movq -0x18(%rbp), %rcx
addq $0x13, %rcx
leaq 0x4b95(%rip), %rsi      # 0x17334
movb $0x0, %al
callq 0x2300
leaq -0x420(%rbp), %rdi
callq 0x12740
jmp 0x12765
movq -0x10(%rbp), %rdi
callq 0x2180
leaq 0x4b76(%rip), %rdi      # 0x1733a
callq 0x12740
leaq 0x4b74(%rip), %rdi      # 0x17344
callq 0x12740
movq -0x8(%rbp), %rdi
callq 0x20f0
jmp 0x127e9
movq -0x8(%rbp), %rdi
callq 0x2070
addq $0x420, %rsp            # imm = 0x420
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: corecodec[P]coremake/coremake.c
// Function: reader_item
item* reader_item(reader* file, int skip, build_pos* pos)
{
    item* i = NULL;

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

    return i;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movq %rdx, -0x18(%rbp)
movq $0x0, -0x20(%rbp)
movq -0x8(%rbp), %rdi
callq 0x48c0
cmpl $0x0, -0xc(%rbp)
jne 0x128c2
movq -0x8(%rbp), %rax
movq 0x30(%rax), %rax
movq %rax, -0x28(%rbp)
movq -0x18(%rbp), %rax
movq %rax, -0x30(%rbp)
movq -0x28(%rbp), %rax
movsbl (%rax), %ecx
xorl %eax, %eax
cmpl $0x2e, %ecx
movb %al, -0x31(%rbp)
jne 0x12876
movq -0x28(%rbp), %rax
movsbl 0x1(%rax), %ecx
xorl %eax, %eax
cmpl $0x2e, %ecx
movb %al, -0x31(%rbp)
jne 0x12876
movq -0x28(%rbp), %rax
movsbl 0x2(%rax), %eax
cmpl $0x2f, %eax
sete %al
movb %al, -0x31(%rbp)
movb -0x31(%rbp), %al
testb $0x1, %al
jne 0x1287f
jmp 0x1289f
cmpq $0x0, -0x30(%rbp)
je 0x12891
movq -0x30(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x30(%rbp)
movq -0x28(%rbp), %rax
addq $0x3, %rax
movq %rax, -0x28(%rbp)
jmp 0x12842
cmpq $0x0, -0x30(%rbp)
je 0x128c0
movq -0x30(%rbp), %rax
movq 0x8(%rax), %rdi
movq -0x28(%rbp), %rsi
movl $0x1, %edx
callq 0x28d0
movq %rax, -0x20(%rbp)
jmp 0x128c2
movq -0x20(%rbp), %rax
addq $0x40, %rsp
popq %rbp
retq
nopl (%rax)
// File: corecodec[P]coremake/coremake.c
// Function: getarg
void getarg(char* s, const char** in)
{
    int quote = 0;

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

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

    *s = 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl $0x0, -0x14(%rbp)
movq -0x10(%rbp), %rax
movq (%rax), %rax
movsbl (%rax), %ecx
xorl %eax, %eax
cmpl $0x0, %ecx
movb %al, -0x15(%rbp)
je 0x12922
callq 0x2350
movq (%rax), %rax
movq -0x10(%rbp), %rcx
movq (%rcx), %rcx
movsbl (%rcx), %ecx
movslq %ecx, %rcx
movzwl (%rax,%rcx,2), %eax
andl $0x2000, %eax           # imm = 0x2000
cmpl $0x0, %eax
setne %al
movb %al, -0x15(%rbp)
movb -0x15(%rbp), %al
testb $0x1, %al
jne 0x1292b
jmp 0x1293b
movq -0x10(%rbp), %rax
movq (%rax), %rcx
addq $0x1, %rcx
movq %rcx, (%rax)
jmp 0x128e7
jmp 0x1293d
movq -0x10(%rbp), %rax
movq (%rax), %rax
movsbl (%rax), %ecx
xorl %eax, %eax
cmpl $0x0, %ecx
movb %al, -0x16(%rbp)
je 0x1298b
movb $0x1, %al
cmpl $0x0, -0x14(%rbp)
movb %al, -0x17(%rbp)
jne 0x12985
callq 0x2350
movq (%rax), %rax
movq -0x10(%rbp), %rcx
movq (%rcx), %rcx
movsbl (%rcx), %ecx
movslq %ecx, %rcx
movzwl (%rax,%rcx,2), %eax
andl $0x2000, %eax           # imm = 0x2000
cmpl $0x0, %eax
setne %al
xorb $-0x1, %al
movb %al, -0x17(%rbp)
movb -0x17(%rbp), %al
movb %al, -0x16(%rbp)
movb -0x16(%rbp), %al
testb $0x1, %al
jne 0x12994
jmp 0x129e3
movq -0x10(%rbp), %rax
movq (%rax), %rax
movsbl (%rax), %eax
cmpl $0x22, %eax
jne 0x129b6
cmpl $0x0, -0x14(%rbp)
setne %al
xorb $-0x1, %al
andb $0x1, %al
movzbl %al, %eax
movl %eax, -0x14(%rbp)
jmp 0x129d0
movq -0x10(%rbp), %rax
movq (%rax), %rax
movb (%rax), %cl
movq -0x8(%rbp), %rax
movq %rax, %rdx
addq $0x1, %rdx
movq %rdx, -0x8(%rbp)
movb %cl, (%rax)
movq -0x10(%rbp), %rax
movq (%rax), %rcx
addq $0x1, %rcx
movq %rcx, (%rax)
jmp 0x1293d
movq -0x8(%rbp), %rax
movb $0x0, (%rax)
addq $0x20, %rsp
popq %rbp
retq
// File: corecodec[P]coremake/coremake.c
// Function: build_file
void build_file(item* p,const char* filename, int reader_flags)
{
	reader r;
    reader_init(&r);
	strcpy(r.filename,filename);
	pathunix(r.filename);
	r.r.f = fopen(filename,"r");
	r.pos = r.line;
	if (!r.r.f)
	{
		printf("'%s' build file not found!\r\n",filename);
		exit(1);
	}
    r.r.flags = reader_flags;
    r.r.filename_kind = reader_flags;
	build_parse(p,&r,0,0,NULL);
	fclose(r.r.f);
    reader_free(&r);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x60, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl %edx, -0x14(%rbp)
leaq -0x58(%rbp), %rdi
callq 0x3bf0
movq -0x20(%rbp), %rdi
movq -0x10(%rbp), %rsi
callq 0x2090
movq -0x20(%rbp), %rdi
callq 0x4e10
movq -0x10(%rbp), %rdi
leaq 0x1683(%rip), %rsi      # 0x163a0
callq 0x22c0
movq %rax, -0x58(%rbp)
movq -0x30(%rbp), %rax
movq %rax, -0x38(%rbp)
cmpq $0x0, -0x58(%rbp)
jne 0x14d51
movq -0x10(%rbp), %rsi
leaq 0x285f(%rip), %rdi      # 0x1759f
movb $0x0, %al
callq 0x2120
movl $0x1, %edi
callq 0x2310
movl -0x14(%rbp), %eax
movl %eax, -0x48(%rbp)
movl -0x14(%rbp), %eax
movl %eax, -0x44(%rbp)
movq -0x8(%rbp), %rdi
leaq -0x58(%rbp), %rsi
xorl %ecx, %ecx
xorl %eax, %eax
movl %eax, %r8d
movl %ecx, %edx
callq 0x129f0
movq -0x58(%rbp), %rdi
callq 0x20d0
leaq -0x58(%rbp), %rdi
callq 0x3c90
addq $0x60, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: corecodec[P]coremake/coremake.c
// Function: default_workspace
item* default_workspace(item* workspace,item* i,item* p)
{
	item** child;
	if (!p) return i;
	for (child=p->child;child!=p->childend;++child)
    {
        if (!i)
        {
            truncfilename(proj);
            i = item_get(workspace,proj,1);
        }
        item_get(item_get(i,"use",1),(*child)->value,1);
    }
    return i;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
cmpq $0x0, -0x20(%rbp)
jne 0x14db8
movq -0x18(%rbp), %rax
movq %rax, -0x8(%rbp)
jmp 0x14e40
movq -0x20(%rbp), %rax
movq 0x18(%rax), %rax
movq %rax, -0x28(%rbp)
movq -0x28(%rbp), %rax
movq -0x20(%rbp), %rcx
cmpq 0x20(%rcx), %rax
je 0x14e38
cmpq $0x0, -0x18(%rbp)
jne 0x14dfe
leaq 0x53e0(%rip), %rdi      # 0x1a1c0
callq 0x4a10
movq -0x10(%rbp), %rdi
leaq 0x53d0(%rip), %rsi      # 0x1a1c0
movl $0x1, %edx
callq 0x28d0
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rdi
leaq 0x1304(%rip), %rsi      # 0x1610d
movl $0x1, %edx
callq 0x28d0
movq %rax, %rdi
movq -0x28(%rbp), %rax
movq (%rax), %rax
movq (%rax), %rsi
movl $0x1, %edx
callq 0x28d0
movq -0x28(%rbp), %rax
addq $0x8, %rax
movq %rax, -0x28(%rbp)
jmp 0x14dc4
movq -0x18(%rbp), %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x30, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: ArashPartow[P]exprtk-extras/./exprtk.hpp
// Function: exprtk::function_compositor<double>::function::vars(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&)
inline function& vars(const std::string& v0,
                               const std::string& v1,
                               const std::string& v2,
                               const std::string& v3)
         {
            v_.push_back(v0);
            v_.push_back(v1);
            v_.push_back(v2);
            v_.push_back(v3);
            return (*this);
         }

// Assembly:
subq $0x38, %rsp
movq %rdi, 0x30(%rsp)
movq %rsi, 0x28(%rsp)
movq %rdx, 0x20(%rsp)
movq %rcx, 0x18(%rsp)
movq %r8, 0x10(%rsp)
movq 0x30(%rsp), %rdi
movq %rdi, 0x8(%rsp)
addq $0x40, %rdi
movq 0x28(%rsp), %rsi
callq 0x146af0
movq 0x8(%rsp), %rdi
addq $0x40, %rdi
movq 0x20(%rsp), %rsi
callq 0x146af0
movq 0x8(%rsp), %rdi
addq $0x40, %rdi
movq 0x18(%rsp), %rsi
callq 0x146af0
movq 0x8(%rsp), %rdi
addq $0x40, %rdi
movq 0x10(%rsp), %rsi
callq 0x146af0
movq 0x8(%rsp), %rax
addq $0x38, %rsp
retq
nopl (%rax,%rax)
// File: iZhangHui[P]CppPrimer/CH16_TemplatesAndGenericProgramming/exercises/ex16_41.cc
// Function: main
int main(int argc, char const *argv[])
{
	using namespace std;
	auto a = numeric_limits<int>::min();
	cout << a << " + " << a << " = " << my_sum(a, a) << endl;

	auto b = numeric_limits<unsigned int>::max();
	cout << b << " + " << b << " = " << my_sum(b, b) << endl;
	return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movl $0x0, -0x4(%rbp)
movl %edi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
callq 0x12f0
movl %eax, -0x14(%rbp)
movl -0x14(%rbp), %esi
movq 0x2dc0(%rip), %rdi      # 0x3fd8
callq 0x1090
movq %rax, %rdi
leaq 0xddd(%rip), %rsi       # 0x2004
callq 0x1050
movq %rax, %rdi
movl -0x14(%rbp), %esi
callq 0x1090
movq %rax, %rdi
leaq 0xdc7(%rip), %rsi       # 0x2008
callq 0x1050
movq %rax, -0x28(%rbp)
movl -0x14(%rbp), %edi
movl -0x14(%rbp), %esi
callq 0x1300
movq -0x28(%rbp), %rdi
movq %rax, %rsi
callq 0x10a0
movq %rax, %rdi
movq 0x2d5d(%rip), %rsi      # 0x3fc8
callq 0x1060
callq 0x1320
movl %eax, -0x18(%rbp)
movl -0x18(%rbp), %esi
movq 0x2d56(%rip), %rdi      # 0x3fd8
callq 0x1070
movq %rax, %rdi
leaq 0xd73(%rip), %rsi       # 0x2004
callq 0x1050
movq %rax, %rdi
movl -0x18(%rbp), %esi
callq 0x1070
movq %rax, %rdi
leaq 0xd5d(%rip), %rsi       # 0x2008
callq 0x1050
movq %rax, -0x20(%rbp)
movl -0x18(%rbp), %edi
movl -0x18(%rbp), %esi
callq 0x1330
movq -0x20(%rbp), %rdi
movq %rax, %rsi
callq 0x1030
movq %rax, %rdi
movq 0x2cf3(%rip), %rsi      # 0x3fc8
callq 0x1060
xorl %eax, %eax
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
nopl (%rax)
// File: jaldhar[P]Lets-Build-a-Simple-Interpreter/calc5.cc
// Function: Interpreter::factor()
long Interpreter::factor() {
    Token token = _current_token;
    if (token.type == TOKENTYPE::LPAREN) {
        eat(TOKENTYPE::LPAREN);
        long result = expression();
        eat(TOKENTYPE::RPAREN);
        return result;
    } else {
        eat(TOKENTYPE::INTEGER);
        return token.value;
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x30(%rbp)
movq 0x8(%rax), %rcx
movq %rcx, -0x20(%rbp)
movq 0x10(%rax), %rax
movq %rax, -0x18(%rbp)
cmpl $0x6, -0x20(%rbp)
jne 0x2ffd
movq -0x30(%rbp), %rdi
movl $0x6, %esi
callq 0x2e20
movq -0x30(%rbp), %rdi
callq 0x2c60
movq -0x30(%rbp), %rdi
movq %rax, -0x28(%rbp)
movl $0x7, %esi
callq 0x2e20
movq -0x28(%rbp), %rax
movq %rax, -0x8(%rbp)
jmp 0x3013
movq -0x30(%rbp), %rdi
movl $0x1, %esi
callq 0x2e20
movq -0x18(%rbp), %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax)
// File: maydali28[P]cpp-socket/matrix_hal/server.cpp
// Function: matrix_hal::server::bind()
int server::bind(){
  matrix_hal::socketAddr* sockaddr = new socketAddr(address,this->port);
  addr = sockaddr->to_sockaddr_in();

  socketfd = ::socket(AF_INET,SOCK_DGRAM,0);

  if(socketfd == -1){
    return errno;
  }
  int yes =1;
  if(::setsockopt(socketfd,SOL_SOCKET,SO_REUSEADDR,&yes,sizeof(int)) != 0){
    close();
    return errno;
  }
  int n;
  unsigned int m = sizeof(n);
getsockopt(socketfd,SOL_SOCKET,SO_RCVBUF,(void *)&n, &m);
  printf("%d %d\n",n,m);

  if(::bind(socketfd,(struct sockaddr *)&addr,sizeof(struct sockaddr))!= 0){
    close();
    return errno;
  }

  return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x80, %rsp
movq %rdi, -0x10(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x78(%rbp)
movl $0x28, %edi
callq 0x21b0
movq -0x78(%rbp), %rsi
movq %rax, -0x70(%rbp)
movb $0x1, -0x45(%rbp)
leaq -0x38(%rbp), %rdi
callq 0x20f0
jmp 0x25e8
movq -0x70(%rbp), %rdi
movq -0x78(%rbp), %rax
movl 0x20(%rax), %edx
leaq -0x38(%rbp), %rsi
callq 0x28a0
jmp 0x25fe
movb $0x0, -0x45(%rbp)
leaq -0x38(%rbp), %rdi
callq 0x2110
movq -0x70(%rbp), %rax
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rdi
callq 0x2910
movq %rax, %rcx
movq -0x78(%rbp), %rax
movq %rcx, -0x58(%rbp)
movq %rdx, -0x50(%rbp)
movq -0x58(%rbp), %rcx
movq %rcx, 0x28(%rax)
movq -0x50(%rbp), %rcx
movq %rcx, 0x30(%rax)
movl $0x2, %esi
xorl %edx, %edx
movl %esi, %edi
callq 0x20a0
movl %eax, %ecx
movq -0x78(%rbp), %rax
movl %ecx, 0x24(%rax)
cmpl $-0x1, 0x24(%rax)
jne 0x26a0
callq 0x2040
movl (%rax), %eax
movl %eax, -0x4(%rbp)
jmp 0x2750
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x40(%rbp)
movl %eax, -0x44(%rbp)
jmp 0x268a
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x40(%rbp)
movl %eax, -0x44(%rbp)
leaq -0x38(%rbp), %rdi
callq 0x2110
testb $0x1, -0x45(%rbp)
jne 0x2692
jmp 0x269b
movq -0x70(%rbp), %rdi
callq 0x2190
jmp 0x275c
movq -0x78(%rbp), %rax
movl $0x1, -0x5c(%rbp)
movl 0x24(%rax), %edi
movl $0x1, %esi
movl $0x2, %edx
leaq -0x5c(%rbp), %rcx
movl $0x4, %r8d
callq 0x22a0
cmpl $0x0, %eax
je 0x26e1
movq -0x78(%rbp), %rdi
callq 0x2580
callq 0x2040
movl (%rax), %eax
movl %eax, -0x4(%rbp)
jmp 0x2750
movq -0x78(%rbp), %rax
movl $0x4, -0x64(%rbp)
movl 0x24(%rax), %edi
movl $0x1, %esi
movl $0x8, %edx
leaq -0x60(%rbp), %rcx
leaq -0x64(%rbp), %r8
callq 0x2130
movl -0x60(%rbp), %esi
movl -0x64(%rbp), %edx
leaq 0x18f9(%rip), %rdi      # 0x400c
movb $0x0, %al
callq 0x2050
movq -0x78(%rbp), %rsi
movl 0x24(%rsi), %edi
addq $0x28, %rsi
movl $0x10, %edx
callq 0x2080
cmpl $0x0, %eax
je 0x2749
movq -0x78(%rbp), %rdi
callq 0x2580
callq 0x2040
movl (%rax), %eax
movl %eax, -0x4(%rbp)
jmp 0x2750
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x80, %rsp
popq %rbp
retq
movq -0x40(%rbp), %rdi
callq 0x2280
nopw %cs:(%rax,%rax)
// File: maydali28[P]cpp-socket/matrix_hal/socketAddr.cpp
// Function: matrix_hal::socketAddr::to_sockaddr_in()
struct sockaddr_in socketAddr::to_sockaddr_in(){
    struct sockaddr_in addr;
    //addr = (struct sockaddr_in *) malloc(sizeof(struct sockaddr_in));
    memset(&addr,0,sizeof(addr));

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

    return addr;
  }

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x18(%rbp)
movq -0x18(%rbp), %rax
movq %rax, -0x20(%rbp)
xorps %xmm0, %xmm0
movaps %xmm0, -0x10(%rbp)
movw $0x2, -0x10(%rbp)
movzwl 0x20(%rax), %edi
callq 0x2060
movq -0x20(%rbp), %rdi
movw %ax, -0xe(%rbp)
callq 0x20e0
movq %rax, %rdi
leaq -0xc(%rbp), %rsi
callq 0x2120
movq -0x10(%rbp), %rax
movq -0x8(%rbp), %rdx
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: maydali28[P]cpp-socket/matrix_hal/socketUDP.cpp
// Function: matrix_hal::socketUDP::receive()
Datagram socketUDP::receive(){
    socklen_t size = sizeof(struct sockaddr_in);
    char * Buffer = (char*) malloc(MAX_BUFFER*sizeof(char));
    struct sockaddr_in addressClt;
    Datagram ret;
    if(::recvfrom(socketfd,Buffer,sizeof(Buffer),0,(struct sockaddr *) &addressClt,&size)){
      ret.data = Buffer;
      ret.address = addressClt;
      free(Buffer);
    }
    return ret;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x70, %rsp
movq %rdi, -0x60(%rbp)
movq %rdi, %rax
movq %rax, -0x68(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x58(%rbp)
movl $0x10, -0x14(%rbp)
movl $0x400, %edi            # imm = 0x400
callq 0x2210
movq -0x60(%rbp), %rdi
movq %rax, -0x20(%rbp)
movb $0x0, -0x31(%rbp)
callq 0x3120
movq -0x58(%rbp), %rax
movl (%rax), %edi
movq -0x20(%rbp), %rsi
movl $0x8, %edx
xorl %ecx, %ecx
leaq -0x30(%rbp), %r8
leaq -0x14(%rbp), %r9
callq 0x2140
movq %rax, -0x50(%rbp)
jmp 0x2b89
movq -0x50(%rbp), %rax
cmpq $0x0, %rax
je 0x2bdb
movq -0x60(%rbp), %rdi
movq -0x20(%rbp), %rsi
addq $0x10, %rdi
callq 0x2230
jmp 0x2ba6
movq -0x60(%rbp), %rax
movq -0x30(%rbp), %rcx
movq %rcx, (%rax)
movq -0x28(%rbp), %rcx
movq %rcx, 0x8(%rax)
movq -0x20(%rbp), %rdi
callq 0x21f0
jmp 0x2bdb
movq -0x60(%rbp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x40(%rbp)
movl %eax, -0x44(%rbp)
callq 0x3140
jmp 0x2bf8
movb $0x1, -0x31(%rbp)
testb $0x1, -0x31(%rbp)
jne 0x2bee
movq -0x60(%rbp), %rdi
callq 0x3140
movq -0x68(%rbp), %rax
addq $0x70, %rsp
popq %rbp
retq
movq -0x40(%rbp), %rdi
callq 0x2280
nopw %cs:(%rax,%rax)
// File: maydali28[P]cpp-socket/matrix_hal/socketUDP.cpp
// Function: matrix_hal::socketUDP::send(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>)
int socketUDP::send(std::string data){
    struct sockaddr_in address;
    address.sin_family = AF_INET;
    address.sin_port = (this->address).sin_port;
    address.sin_addr = (this->address).sin_addr;
    if (sendto(this->socketfd, (void*)data.c_str(), data.length() + 1, 0, (struct sockaddr*)&address, sizeof(struct sockaddr_in)) == -1)
    {
        return 0;
    }
    return 1;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movq %rsi, -0x48(%rbp)
movq %rdi, %rax
movq -0x48(%rbp), %rdi
movq %rdi, -0x40(%rbp)
movq %rax, -0x10(%rbp)
movq %rdi, -0x18(%rbp)
movq -0x10(%rbp), %rax
movw $0x2, -0x28(%rbp)
movw 0x6(%rax), %cx
movw %cx, -0x26(%rbp)
movl 0x8(%rax), %ecx
movl %ecx, -0x24(%rbp)
movl (%rax), %eax
movl %eax, -0x34(%rbp)
callq 0x20e0
movq -0x40(%rbp), %rdi
movq %rax, -0x30(%rbp)
callq 0x2260
movl -0x34(%rbp), %edi
movq -0x30(%rbp), %rsi
movq %rax, %rdx
addq $0x1, %rdx
xorl %ecx, %ecx
leaq -0x28(%rbp), %r8
movl $0x10, %r9d
callq 0x2070
cmpq $-0x1, %rax
jne 0x2c8c
movl $0x0, -0x4(%rbp)
jmp 0x2c93
movl $0x1, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x50, %rsp
popq %rbp
retq
nopl (%rax)
// File: maydali28[P]cpp-socket/matrix_hal/socketUDP.cpp
// Function: matrix_hal::socketUDP::send(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>)
int socketUDP::send(std::string ip,std::string data){
    struct sockaddr_in address;
    address.sin_family = AF_INET;
    address.sin_port = (this->address).sin_port;
    inet_aton(ip.c_str(), &address.sin_addr);
    if (sendto(this->socketfd, (void*)data.c_str(), data.length() + 1, 0, (struct sockaddr*)&address, sizeof(struct sockaddr_in)) == -1)
    {
        return 0;
    }
    return 1;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x60, %rsp
movq %rsi, -0x58(%rbp)
movq %rdi, %rax
movq -0x58(%rbp), %rdi
movq %rdx, -0x48(%rbp)
movq %rax, -0x10(%rbp)
movq %rdi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x50(%rbp)
movw $0x2, -0x30(%rbp)
movw 0x6(%rax), %ax
movw %ax, -0x2e(%rbp)
callq 0x20e0
movq %rax, %rdi
leaq -0x30(%rbp), %rsi
addq $0x4, %rsi
callq 0x2120
movq -0x48(%rbp), %rdi
movq -0x50(%rbp), %rax
movl (%rax), %eax
movl %eax, -0x3c(%rbp)
callq 0x20e0
movq -0x48(%rbp), %rdi
movq %rax, -0x38(%rbp)
callq 0x2260
movl -0x3c(%rbp), %edi
movq -0x38(%rbp), %rsi
movq %rax, %rdx
addq $0x1, %rdx
xorl %ecx, %ecx
leaq -0x30(%rbp), %r8
movl $0x10, %r9d
callq 0x2070
cmpq $-0x1, %rax
jne 0x2d3b
movl $0x0, -0x4(%rbp)
jmp 0x2d42
movl $0x1, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x60, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: maydali28[P]cpp-socket/matrix_hal/socketUDP.cpp
// Function: matrix_hal::socketUDP::send(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, int, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>)
int socketUDP::send(std::string ip, int port, std::string data){
    struct sockaddr_in address;
    address.sin_family = AF_INET;
    address.sin_port = htons(port);
    inet_aton(ip.c_str(), &address.sin_addr);
    if (sendto(this->socketfd, (void*)data.c_str(), data.length() + 1, 0, (struct sockaddr*)&address, sizeof(struct sockaddr_in)) == -1)
    {
        return 0;
    }
    return 1;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x60, %rsp
movq %rsi, -0x60(%rbp)
movq %rcx, -0x50(%rbp)
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movl %edx, -0x1c(%rbp)
movq %rcx, -0x28(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x58(%rbp)
movw $0x2, -0x38(%rbp)
movl -0x1c(%rbp), %eax
movzwl %ax, %edi
callq 0x2060
movq -0x60(%rbp), %rdi
movw %ax, -0x36(%rbp)
callq 0x20e0
movq %rax, %rdi
leaq -0x38(%rbp), %rsi
addq $0x4, %rsi
callq 0x2120
movq -0x50(%rbp), %rdi
movq -0x58(%rbp), %rax
movl (%rax), %eax
movl %eax, -0x44(%rbp)
callq 0x20e0
movq -0x50(%rbp), %rdi
movq %rax, -0x40(%rbp)
callq 0x2260
movl -0x44(%rbp), %edi
movq -0x40(%rbp), %rsi
movq %rax, %rdx
addq $0x1, %rdx
xorl %ecx, %ecx
leaq -0x38(%rbp), %r8
movl $0x10, %r9d
callq 0x2070
cmpq $-0x1, %rax
jne 0x2df2
movl $0x0, -0x4(%rbp)
jmp 0x2df9
movl $0x1, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x60, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: GradCristi[P]Threaded-Sort/src/main.cpp
// Function: consumer(void*)
void* consumer(void* ptr) {
	while (true) {
		if (g_prod_done && g_buffer.empty()) return NULL;

		 //if the buffer is empty, wait for the producer to add some more data to it
		while (g_buffer.empty())
			sleep(g_sleep);
		
		// Acquire lock to read from the shared buffer
		pthread_mutex_lock(&g_mutex);
		int data = g_buffer.front(); // read the first element from the queue
		g_buffer.pop();	// and remove it
		g_log_file << "Consumed: " << data << std::endl;
		pthread_mutex_unlock(&g_mutex); // the lock is no longer needed as we're not accessing shared resources anymore

		g_output_data.sortedInsert(data);
	}
}

// Assembly:
subq $0x18, %rsp
movq %rdi, 0x10(%rsp)
testb $0x1, 0x5cf8(%rip)      # 0x71a8
je 0x14cb
leaq 0x5c7f(%rip), %rdi      # 0x7138
callq 0x1990
testb $0x1, %al
jne 0x14c4
jmp 0x14cb
xorl %eax, %eax
addq $0x18, %rsp
retq
jmp 0x14cd
leaq 0x5c64(%rip), %rdi      # 0x7138
callq 0x1990
testb $0x1, %al
jne 0x14df
jmp 0x14ec
movl 0x5c0b(%rip), %edi      # 0x70f0
callq 0x1090
jmp 0x14cd
leaq 0x5c1d(%rip), %rdi      # 0x7110
callq 0x1130
leaq 0x5c39(%rip), %rdi      # 0x7138
callq 0x19b0
movl (%rax), %eax
movl %eax, 0xc(%rsp)
leaq 0x5c27(%rip), %rdi      # 0x7138
callq 0x19c0
leaq 0x5c93(%rip), %rdi      # 0x71b0
leaq 0x2b1c(%rip), %rsi      # 0x4040
callq 0x10e0
movq %rax, %rdi
movl 0xc(%rsp), %esi
callq 0x1180
movq %rax, %rdi
movq 0x5a81(%rip), %rsi      # 0x6fc0
callq 0x1110
leaq 0x5bc5(%rip), %rdi      # 0x7110
callq 0x10a0
movl 0xc(%rsp), %esi
leaq 0x5c45(%rip), %rdi      # 0x71a0
callq 0x3c80
jmp 0x14a9
nopw %cs:(%rax,%rax)
// File: GradCristi[P]Threaded-Sort/src/main.cpp
// Function: producer(void*)
void* producer(void* ptr) {
	while (true) {
		if (g_input_data.size() == 0) { 
			g_prod_done = true;
			return NULL;
		}

		pthread_mutex_lock(&g_mutex);
		int data = g_input_data.front();
		g_buffer.push(data); // read the first element from the input vector
		g_input_data.erase( g_input_data.begin() );	// and remove it
		g_log_file << "Produced: " << data << std::endl;
		pthread_mutex_unlock(&g_mutex);


		// if the buffer is full, wait for the consumer to take some data out of it
		while (g_buffer.size() >= g_buffer_limit)
			sleep(g_sleep);
	}
}

// Assembly:
subq $0x28, %rsp
movq %rdi, 0x20(%rsp)
leaq 0x5c08(%rip), %rdi      # 0x7188
callq 0x19d0
cmpq $0x0, %rax
jne 0x1599
movb $0x1, 0x5c16(%rip)      # 0x71a8
xorl %eax, %eax
addq $0x28, %rsp
retq
leaq 0x5b70(%rip), %rdi      # 0x7110
callq 0x1130
leaq 0x5bdc(%rip), %rdi      # 0x7188
callq 0x19f0
movl (%rax), %eax
movl %eax, 0x1c(%rsp)
leaq 0x5b7a(%rip), %rdi      # 0x7138
leaq 0x1c(%rsp), %rsi
callq 0x1a20
leaq 0x5bb9(%rip), %rdi      # 0x7188
callq 0x1ac0
movq %rax, 0x8(%rsp)
leaq 0x10(%rsp), %rdi
leaq 0x8(%rsp), %rsi
callq 0x1af0
movq 0x10(%rsp), %rsi
leaq 0x5b94(%rip), %rdi      # 0x7188
callq 0x1a50
movq %rax, (%rsp)
leaq 0x5bac(%rip), %rdi      # 0x71b0
leaq 0x2a40(%rip), %rsi      # 0x404b
callq 0x10e0
movq %rax, %rdi
movl 0x1c(%rsp), %esi
callq 0x1180
movq %rax, %rdi
movq 0x599a(%rip), %rsi      # 0x6fc0
callq 0x1110
leaq 0x5ade(%rip), %rdi      # 0x7110
callq 0x10a0
leaq 0x5afa(%rip), %rdi      # 0x7138
callq 0x1b30
cmpq $0xa, %rax
jb 0x1656
movl 0x5aa1(%rip), %edi      # 0x70f0
callq 0x1090
jmp 0x1637
jmp 0x1579
nopl (%rax,%rax)
// File: GradCristi[P]Threaded-Sort/src/main.cpp
// Function: main
int main() {
	g_log_file.open("threads.log");

	pthread_t thread1, thread2;

	std::cout << "Input data: " << std::endl;
	for (auto it = g_input_data.begin(); it != g_input_data.end(); it++) std::cout << *it << " ";
	std::cout << std::endl << std::endl;

	pthread_create(&thread1, NULL, producer, NULL);
	std::cout << "S-a creat firul producer " << std::endl;
	pthread_create(&thread2, NULL, consumer, NULL);
	std::cout << "S-a creat firul consumer " << std::endl;
	
	pthread_join(thread1, NULL);
	
	pthread_join(thread2, NULL);
	
	
	std::cout << "Output data: " << std::endl;
	g_output_data.print();
	std::cout << std::endl;

	pthread_exit(NULL);
	g_log_file.close();
	return 0;
}

// Assembly:
subq $0x38, %rsp
movl $0x0, 0x34(%rsp)
leaq 0x5b3d(%rip), %rdi      # 0x71b0
leaq 0x29dc(%rip), %rsi      # 0x4056
movl $0x10, %edx
callq 0x1030
movq 0x5945(%rip), %rdi      # 0x6fd0
leaq 0x29d0(%rip), %rsi      # 0x4062
callq 0x10e0
movq %rax, %rdi
movq 0x591f(%rip), %rsi      # 0x6fc0
callq 0x1110
leaq 0x5adb(%rip), %rdi      # 0x7188
callq 0x1ac0
movq %rax, 0x18(%rsp)
leaq 0x5aca(%rip), %rdi      # 0x7188
callq 0x1b80
movq %rax, 0x10(%rsp)
leaq 0x18(%rsp), %rdi
leaq 0x10(%rsp), %rsi
callq 0x1b40
testb $0x1, %al
jne 0x16dd
jmp 0x1717
leaq 0x18(%rsp), %rdi
callq 0x1bb0
movl (%rax), %esi
movq 0x58e0(%rip), %rdi      # 0x6fd0
callq 0x1180
movq %rax, %rdi
leaq 0x296e(%rip), %rsi      # 0x406d
callq 0x10e0
leaq 0x18(%rsp), %rdi
xorl %esi, %esi
callq 0x1bc0
movq %rax, 0x8(%rsp)
jmp 0x16b7
movq 0x58b2(%rip), %rdi      # 0x6fd0
movq 0x589b(%rip), %rsi      # 0x6fc0
callq 0x1110
movq %rax, %rdi
movq 0x588c(%rip), %rsi      # 0x6fc0
callq 0x1110
leaq 0x28(%rsp), %rdi
xorl %eax, %eax
movl %eax, %ecx
leaq -0x1d9(%rip), %rdx      # 0x1570
movq %rcx, %rsi
callq 0x11b0
movq 0x5878(%rip), %rdi      # 0x6fd0
leaq 0x2910(%rip), %rsi      # 0x406f
callq 0x10e0
movq %rax, %rdi
movq 0x5852(%rip), %rsi      # 0x6fc0
callq 0x1110
leaq 0x20(%rsp), %rdi
xorl %eax, %eax
movl %eax, %ecx
leaq -0x2e3(%rip), %rdx      # 0x14a0
movq %rcx, %rsi
callq 0x11b0
movq 0x583e(%rip), %rdi      # 0x6fd0
leaq 0x28f0(%rip), %rsi      # 0x4089
callq 0x10e0
movq %rax, %rdi
movq 0x5818(%rip), %rsi      # 0x6fc0
callq 0x1110
movq 0x28(%rsp), %rdi
xorl %eax, %eax
movl %eax, %esi
callq 0x10d0
movq 0x20(%rsp), %rdi
xorl %eax, %eax
movl %eax, %esi
callq 0x10d0
movq 0x5800(%rip), %rdi      # 0x6fd0
leaq 0x28cc(%rip), %rsi      # 0x40a3
callq 0x10e0
movq %rax, %rdi
movq 0x57da(%rip), %rsi      # 0x6fc0
callq 0x1110
leaq 0x59ae(%rip), %rdi      # 0x71a0
callq 0x3d70
movq 0x57d2(%rip), %rdi      # 0x6fd0
movq 0x57bb(%rip), %rsi      # 0x6fc0
callq 0x1110
xorl %eax, %eax
movl %eax, %edi
callq 0x11a0
nopw %cs:(%rax,%rax)
nopl (%rax)
// File: GradCristi[P]Threaded-Sort/src/LinkedList/linked_list.cpp
// Function: LinkedList::~LinkedList()
LinkedList::~LinkedList() {
	if (head == nullptr) return;

	Node *p, *q;
	for (p = head; p != nullptr; p = q) {
		q = p->next;
		delete p;
	}
}

// Assembly:
subq $0x28, %rsp
movq %rdi, 0x20(%rsp)
movq 0x20(%rsp), %rax
movq %rax, 0x8(%rsp)
cmpq $0x0, (%rax)
jne 0x3c2b
jmp 0x3c79
movq 0x8(%rsp), %rax
movq (%rax), %rax
movq %rax, 0x18(%rsp)
cmpq $0x0, 0x18(%rsp)
je 0x3c79
movq 0x18(%rsp), %rax
movq 0x8(%rax), %rax
movq %rax, 0x10(%rsp)
movq 0x18(%rsp), %rax
movq %rax, (%rsp)
cmpq $0x0, %rax
je 0x3c6b
movq (%rsp), %rdi
movl $0x10, %esi
callq 0x1100
jmp 0x3c6d
movq 0x10(%rsp), %rax
movq %rax, 0x18(%rsp)
jmp 0x3c38
addq $0x28, %rsp
retq
nop
// File: GradCristi[P]Threaded-Sort/src/LinkedList/linked_list.cpp
// Function: LinkedList::sortedInsert(int)
void LinkedList::sortedInsert(int _value) {
	Node *newNode = new Node(_value);  //we declare a new node with the value
	Node * aux = head; // and the auxiliaries, both one that points to the list head
	Node **aux2 = &head;  // and another that can modify the list head, if suitable
	
	//while we have not reached the place of insertion( the data is bigger)
	while (aux != nullptr && aux->data < newNode->data) {
		aux2 = &aux->next;// cycle through
		aux = aux->next;
	}
	*aux2 = newNode; //otherwise insert at the place in which we were
	newNode->next = aux;
}

// Assembly:
subq $0x58, %rsp
movq %rdi, 0x50(%rsp)
movl %esi, 0x4c(%rsp)
movq 0x50(%rsp), %rax
movq %rax, 0x10(%rsp)
movl $0x10, %edi
callq 0x10f0
movq %rax, %rdi
movq %rdi, %rax
movq %rax, 0x18(%rsp)
movl 0x4c(%rsp), %esi
callq 0x3de0
jmp 0x3cb7
movq 0x10(%rsp), %rax
movq 0x18(%rsp), %rcx
movq %rcx, 0x40(%rsp)
movq (%rax), %rcx
movq %rcx, 0x28(%rsp)
movq %rax, 0x20(%rsp)
xorl %eax, %eax
cmpq $0x0, 0x28(%rsp)
movb %al, 0xf(%rsp)
je 0x3cf6
movq 0x28(%rsp), %rax
movl (%rax), %eax
movq 0x40(%rsp), %rcx
cmpl (%rcx), %eax
setl %al
movb %al, 0xf(%rsp)
movb 0xf(%rsp), %al
testb $0x1, %al
jne 0x3d00
jmp 0x3d3d
movq 0x28(%rsp), %rax
addq $0x8, %rax
movq %rax, 0x20(%rsp)
movq 0x28(%rsp), %rax
movq 0x8(%rax), %rax
movq %rax, 0x28(%rsp)
jmp 0x3cd3
movq 0x18(%rsp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x38(%rsp)
movl %eax, 0x34(%rsp)
movl $0x10, %esi
callq 0x1100
jmp 0x3d5d
movq 0x40(%rsp), %rcx
movq 0x20(%rsp), %rax
movq %rcx, (%rax)
movq 0x28(%rsp), %rcx
movq 0x40(%rsp), %rax
movq %rcx, 0x8(%rax)
addq $0x58, %rsp
retq
movq 0x38(%rsp), %rdi
callq 0x1190
nopw (%rax,%rax)
// File: GradCristi[P]Threaded-Sort/src/LinkedList/linked_list.cpp
// Function: LinkedList::print()
void LinkedList::print() {
	if (head == nullptr) return;

	Node *p;
	for (p = head; p != nullptr; p = p->next) {
		std::cout << p->data << " ";
	}
}

// Assembly:
subq $0x18, %rsp
movq %rdi, 0x10(%rsp)
movq 0x10(%rsp), %rax
movq %rax, (%rsp)
cmpq $0x0, (%rax)
jne 0x3d8a
jmp 0x3dd0
movq (%rsp), %rax
movq (%rax), %rax
movq %rax, 0x8(%rsp)
cmpq $0x0, 0x8(%rsp)
je 0x3dd0
movq 0x8(%rsp), %rax
movl (%rax), %esi
movq 0x3224(%rip), %rdi      # 0x6fd0
callq 0x1180
movq %rax, %rdi
leaq 0x2b2(%rip), %rsi       # 0x406d
callq 0x10e0
movq 0x8(%rsp), %rax
movq 0x8(%rax), %rax
movq %rax, 0x8(%rsp)
jmp 0x3d96
addq $0x18, %rsp
retq
nopw %cs:(%rax,%rax)
nop
// File: dannycalegari[P]circle_pack/./Trigonometry_routine.cc
// Function: midpoint(Point, Point)
Point midpoint(Point P, Point Q){
	Point R;
	R.x=(P.x+Q.x)/2.0;
	R.y=(P.y+Q.y)/2.0;
	R.z=(P.z+Q.z)/2.0;
	return(R);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, %rax
leaq 0x28(%rbp), %rcx
leaq 0x10(%rbp), %rdx
movsd (%rdx), %xmm0
addsd (%rcx), %xmm0
movsd 0xea09(%rip), %xmm1     # 0x11008
divsd %xmm1, %xmm0
movsd %xmm0, (%rdi)
movsd 0x8(%rdx), %xmm0
addsd 0x8(%rcx), %xmm0
movsd 0xe9ef(%rip), %xmm1     # 0x11008
divsd %xmm1, %xmm0
movsd %xmm0, 0x8(%rdi)
movsd 0x10(%rdx), %xmm0
addsd 0x10(%rcx), %xmm0
movsd 0xe9d4(%rip), %xmm1     # 0x11008
divsd %xmm1, %xmm0
movsd %xmm0, 0x10(%rdi)
popq %rbp
retq
nop
// File: dannycalegari[P]circle_pack/./Trigonometry_routine.cc
// Function: operator*(Point, double)
Point operator*(Point P, double d){
	Point Q;
	Q.x=P.x*d;
	Q.y=P.y*d;
	Q.z=P.z*d;
	return(Q);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, %rax
leaq 0x10(%rbp), %rcx
movsd %xmm0, -0x8(%rbp)
movsd (%rcx), %xmm0
mulsd -0x8(%rbp), %xmm0
movsd %xmm0, (%rdi)
movsd 0x8(%rcx), %xmm0
mulsd -0x8(%rbp), %xmm0
movsd %xmm0, 0x8(%rdi)
movsd 0x10(%rcx), %xmm0
mulsd -0x8(%rbp), %xmm0
movsd %xmm0, 0x10(%rdi)
popq %rbp
retq
nopl (%rax)
// File: dannycalegari[P]circle_pack/./Trigonometry_routine.cc
// Function: operator+(Point, Point)
Point operator+(Point P, Point Q){
	Point R;
	R.x=P.x+Q.x;
	R.y=P.y+Q.y;
	R.z=P.z+Q.z;
	return(R);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, %rax
leaq 0x28(%rbp), %rcx
leaq 0x10(%rbp), %rdx
movsd (%rdx), %xmm0
addsd (%rcx), %xmm0
movsd %xmm0, (%rdi)
movsd 0x8(%rdx), %xmm0
addsd 0x8(%rcx), %xmm0
movsd %xmm0, 0x8(%rdi)
movsd 0x10(%rdx), %xmm0
addsd 0x10(%rcx), %xmm0
movsd %xmm0, 0x10(%rdi)
popq %rbp
retq
nopl (%rax,%rax)
// File: dannycalegari[P]circle_pack/./Trigonometry_routine.cc
// Function: cross(Point, Point)
Point cross(Point P, Point Q){
	Point R;
	R.z=P.x*Q.y-P.y*Q.x;
	R.y=P.z*Q.x-P.x*Q.z;
	R.x=P.y*Q.z-P.z*Q.y;
	return(R);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, %rax
leaq 0x28(%rbp), %rcx
leaq 0x10(%rbp), %rdx
movsd (%rdx), %xmm0
movsd 0x8(%rcx), %xmm2
movsd 0x8(%rdx), %xmm1
mulsd (%rcx), %xmm1
movq %xmm1, %rsi
movabsq $-0x8000000000000000, %r8 # imm = 0x8000000000000000
xorq %r8, %rsi
movq %rsi, %xmm1
mulsd %xmm2, %xmm0
addsd %xmm1, %xmm0
movsd %xmm0, 0x10(%rdi)
movsd 0x10(%rdx), %xmm0
movsd (%rcx), %xmm2
movsd (%rdx), %xmm1
mulsd 0x10(%rcx), %xmm1
movq %xmm1, %rsi
movabsq $-0x8000000000000000, %r8 # imm = 0x8000000000000000
xorq %r8, %rsi
movq %rsi, %xmm1
mulsd %xmm2, %xmm0
addsd %xmm1, %xmm0
movsd %xmm0, 0x8(%rdi)
movsd 0x8(%rdx), %xmm0
movsd 0x10(%rcx), %xmm2
movsd 0x10(%rdx), %xmm1
mulsd 0x8(%rcx), %xmm1
movq %xmm1, %rcx
movabsq $-0x8000000000000000, %rdx # imm = 0x8000000000000000
xorq %rdx, %rcx
movq %rcx, %xmm1
mulsd %xmm2, %xmm0
addsd %xmm1, %xmm0
movsd %xmm0, (%rdi)
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: dannycalegari[P]circle_pack/./Trigonometry_routine.cc
// Function: write_Matrix(Matrix)
void write_Matrix(Matrix M){
	int i,j;
	for(i=0;i<3;i++){
		for(j=0;j<3;j++){
			cout << M.e[i][j] << " ";
		};
		cout << "\n";
	};
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x18(%rbp)
movq %rdi, -0x8(%rbp)
movl $0x0, -0xc(%rbp)
cmpl $0x3, -0xc(%rbp)
jge 0x296b
movl $0x0, -0x10(%rbp)
cmpl $0x3, -0x10(%rbp)
jge 0x294d
movq -0x18(%rbp), %rdi
movslq -0xc(%rbp), %rsi
callq 0xa250
movq %rax, %rdi
movslq -0x10(%rbp), %rsi
callq 0xa270
movsd (%rax), %xmm0
movq 0x156a2(%rip), %rdi     # 0x17fd0
callq 0x2400
movq %rax, %rdi
leaq 0xed53(%rip), %rsi      # 0x11690
callq 0x21f0
movl -0x10(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x10(%rbp)
jmp 0x2904
movq 0x1567c(%rip), %rdi     # 0x17fd0
leaq 0xed9e(%rip), %rsi      # 0x116f9
callq 0x21f0
movl -0xc(%rbp), %eax
addl $0x1, %eax
movl %eax, -0xc(%rbp)
jmp 0x28f7
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: dannycalegari[P]circle_pack/./Trigonometry_routine.cc
// Function: ROT(double)
Matrix ROT(double angle){	// rotation in xy-plane about origin
	// returns matrix C=cos(angle), S=sin(angle)
	// (C -S  0)
	// (S  C  0)
	// (0  0  1)
	Matrix M;
	M.e.clear();
	vector<double> row;
	row.clear();
	row.push_back(cos(angle));
	row.push_back(-sin(angle));
	row.push_back(0.0);
	M.e.push_back(row);
	row.clear();
	row.push_back(sin(angle));
	row.push_back(cos(angle));
	row.push_back(0.0);
	M.e.push_back(row);
	row.clear();
	row.push_back(0.0);
	row.push_back(0.0);
	row.push_back(1.0);
	M.e.push_back(row);
	return(M);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0xb0, %rsp
movq %rdi, -0x98(%rbp)
movq %rdi, %rax
movq %rax, -0xa0(%rbp)
movq %rdi, -0x8(%rbp)
movsd %xmm0, -0x10(%rbp)
movb $0x0, -0x11(%rbp)
callq 0xa290
movq -0x98(%rbp), %rdi
callq 0xa2b0
leaq -0x30(%rbp), %rdi
movq %rdi, -0x90(%rbp)
callq 0xa2d0
movq -0x90(%rbp), %rdi
callq 0xa2f0
movsd -0x10(%rbp), %xmm0
callq 0x23f0
movq -0x90(%rbp), %rdi
movsd %xmm0, -0x38(%rbp)
leaq -0x38(%rbp), %rsi
callq 0xa310
jmp 0x29f7
movsd -0x10(%rbp), %xmm0
callq 0x2060
movaps 0xe6b8(%rip), %xmm1     # 0x110c0
pxor %xmm1, %xmm0
movlpd %xmm0, -0x50(%rbp)
leaq -0x30(%rbp), %rdi
leaq -0x50(%rbp), %rsi
callq 0xa310
jmp 0x2a20
movq $0x0, -0x58(%rbp)
leaq -0x30(%rbp), %rdi
leaq -0x58(%rbp), %rsi
callq 0xa310
jmp 0x2a37
movq -0x98(%rbp), %rdi
leaq -0x30(%rbp), %rsi
callq 0xa340
jmp 0x2a49
leaq -0x30(%rbp), %rdi
movq %rdi, -0xa8(%rbp)
callq 0xa2f0
movsd -0x10(%rbp), %xmm0
callq 0x2060
movq -0xa8(%rbp), %rdi
movsd %xmm0, -0x60(%rbp)
leaq -0x60(%rbp), %rsi
callq 0xa310
jmp 0x2a7a
movsd -0x10(%rbp), %xmm0
callq 0x23f0
movsd %xmm0, -0x68(%rbp)
leaq -0x30(%rbp), %rdi
leaq -0x68(%rbp), %rsi
callq 0xa310
jmp 0x2a98
movq $0x0, -0x70(%rbp)
leaq -0x30(%rbp), %rdi
leaq -0x70(%rbp), %rsi
callq 0xa310
jmp 0x2aaf
movq -0x98(%rbp), %rdi
leaq -0x30(%rbp), %rsi
callq 0xa340
jmp 0x2ac1
leaq -0x30(%rbp), %rdi
movq %rdi, -0xb0(%rbp)
callq 0xa2f0
movq -0xb0(%rbp), %rdi
movq $0x0, -0x78(%rbp)
leaq -0x78(%rbp), %rsi
callq 0xa310
jmp 0x2aeb
movq $0x0, -0x80(%rbp)
leaq -0x30(%rbp), %rdi
leaq -0x80(%rbp), %rsi
callq 0xa310
jmp 0x2b02
movabsq $0x3ff0000000000000, %rax # imm = 0x3FF0000000000000
movq %rax, -0x88(%rbp)
leaq -0x30(%rbp), %rdi
leaq -0x88(%rbp), %rsi
callq 0xa310
jmp 0x2b25
movq -0x98(%rbp), %rdi
leaq -0x30(%rbp), %rsi
callq 0xa340
jmp 0x2b37
movb $0x1, -0x11(%rbp)
leaq -0x30(%rbp), %rdi
callq 0xa3b0
testb $0x1, -0x11(%rbp)
jne 0x2b7b
jmp 0x2b6f
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x40(%rbp)
movl %eax, -0x44(%rbp)
leaq -0x30(%rbp), %rdi
callq 0xa3b0
movq -0x98(%rbp), %rdi
callq 0xa410
jmp 0x2b8b
movq -0x98(%rbp), %rdi
callq 0xa410
movq -0xa0(%rbp), %rax
addq $0xb0, %rsp
popq %rbp
retq
movq -0x40(%rbp), %rdi
callq 0x23c0
nopw %cs:(%rax,%rax)