LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_cpp_makefile_star2_O2/corecodec[P]coremake/coremake.c
// Function: generate_msmuid
void generate_msmuid(char *msmuid,const char *srcstr)
{
	int i;
    union
    {
        unsigned int d[4];
        unsigned char b[16];
    } code;

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

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

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

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x38, %rsp
xorl %eax, %eax
cmpq $0x4, %rax
je 0xa5e3
movl $0x1, 0x8(%rsp,%rax,4)
incq %rax
jmp 0xa5d0
movl 0x8(%rsp), %r9d
movl 0xc(%rsp), %r10d
movl 0x10(%rsp), %r11d
movl 0x14(%rsp), %ebx
movzbl (%rsi), %eax
testl %eax, %eax
je 0xa649
movl %r11d, %ecx
imull %eax, %ecx
addl %ecx, %r9d
addl $0x33299112, %r9d       # imm = 0x33299112
xorl %ebx, %r9d
movl %ebx, %ecx
imull %eax, %ecx
addl %ecx, %r10d
addl $0x1345af22, %r10d      # imm = 0x1345AF22
xorl %r11d, %r10d
movl %r9d, %ecx
imull %eax, %ecx
addl %ecx, %r11d
addl $0x73a92332, %r11d      # imm = 0x73A92332
xorl %r10d, %r11d
imull %r10d, %eax
addl %eax, %ebx
addl $0x5123abc1, %ebx       # imm = 0x5123ABC1
xorl %r9d, %ebx
incq %rsi
jmp 0xa5f6
movl $0xff, %eax
movl %r9d, %edx
andl %eax, %edx
movl %r9d, %ecx
shrl $0x8, %ecx
andl %eax, %ecx
movl %r9d, %r8d
shrl $0x10, %r8d
andl %eax, %r8d
movl %r10d, %esi
andl %eax, %esi
movq %rsi, 0x30(%rsp)
movl %r10d, %esi
shrl $0x8, %esi
andl %eax, %esi
movq %rsi, 0x28(%rsp)
movl %r10d, %esi
shrl $0x10, %esi
andl %eax, %esi
movq %rsi, 0x20(%rsp)
movl %r11d, %esi
andl %eax, %esi
movq %rsi, 0x18(%rsp)
movl %r11d, %ebp
shrl $0x8, %ebp
andl %eax, %ebp
movl %r11d, %r12d
shrl $0x10, %r12d
andl %eax, %r12d
movl %ebx, %r13d
andl %eax, %r13d
movl %ebx, %r15d
shrl $0x8, %r15d
andl %eax, %r15d
movl %ebx, %r14d
shrl $0x10, %r14d
andl %eax, %r14d
shrl $0x18, %r9d
shrl $0x18, %r10d
shrl $0x18, %r11d
shrl $0x18, %ebx
leaq 0x67fa(%rip), %rsi      # 0x10ecf
xorl %eax, %eax
pushq %rbx
pushq %r14
pushq %r15
pushq %r13
pushq %r11
pushq %r12
pushq %rbp
pushq 0x50(%rsp)
pushq %r10
pushq 0x68(%rsp)
pushq 0x78(%rsp)
pushq 0x88(%rsp)
callq 0x2310
addq $0x98, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/corecodec[P]coremake/coremake.c
// Function: generate_msuid
void generate_msuid(char *msuid,const char *srcstr)
{
	int i;
    union
    {
        unsigned int d[4];
        unsigned char b[16];
    } code;

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

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

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

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x38, %rsp
xorl %eax, %eax
cmpq $0x4, %rax
je 0xa732
movl $0x1, 0x8(%rsp,%rax,4)
incq %rax
jmp 0xa71f
movl 0x8(%rsp), %r9d
movl 0xc(%rsp), %r10d
movl 0x10(%rsp), %r11d
movl 0x14(%rsp), %ebx
movzbl (%rsi), %eax
testl %eax, %eax
je 0xa798
movl %r11d, %ecx
imull %eax, %ecx
addl %ecx, %r9d
addl $0x33299112, %r9d       # imm = 0x33299112
xorl %ebx, %r9d
movl %ebx, %ecx
imull %eax, %ecx
addl %ecx, %r10d
addl $0x1345af22, %r10d      # imm = 0x1345AF22
xorl %r11d, %r10d
movl %r9d, %ecx
imull %eax, %ecx
addl %ecx, %r11d
addl $0x73a92332, %r11d      # imm = 0x73A92332
xorl %r10d, %r11d
imull %r10d, %eax
addl %eax, %ebx
addl $0x5123abc1, %ebx       # imm = 0x5123ABC1
xorl %r9d, %ebx
incq %rsi
jmp 0xa745
movl $0xff, %eax
movl %r9d, %edx
andl %eax, %edx
movl %r9d, %ecx
shrl $0x8, %ecx
andl %eax, %ecx
movl %r9d, %r8d
shrl $0x10, %r8d
andl %eax, %r8d
movl %r10d, %esi
andl %eax, %esi
movq %rsi, 0x30(%rsp)
movl %r10d, %esi
shrl $0x8, %esi
andl %eax, %esi
movq %rsi, 0x28(%rsp)
movl %r10d, %esi
shrl $0x10, %esi
andl %eax, %esi
movq %rsi, 0x20(%rsp)
movl %r11d, %esi
andl %eax, %esi
movq %rsi, 0x18(%rsp)
movl %r11d, %ebp
shrl $0x8, %ebp
andl %eax, %ebp
movl %r11d, %r12d
shrl $0x10, %r12d
andl %eax, %r12d
movl %ebx, %r13d
andl %eax, %r13d
movl %ebx, %r15d
shrl $0x8, %r15d
andl %eax, %r15d
movl %ebx, %r14d
shrl $0x10, %r14d
andl %eax, %r14d
shrl $0x18, %r9d
shrl $0x18, %r10d
shrl $0x18, %r11d
shrl $0x18, %ebx
leaq 0x66ec(%rip), %rsi      # 0x10f10
xorl %eax, %eax
pushq %rbx
pushq %r14
pushq %r15
pushq %r13
pushq %r11
pushq %r12
pushq %rbp
pushq 0x50(%rsp)
pushq %r10
pushq 0x68(%rsp)
pushq 0x78(%rsp)
pushq 0x88(%rsp)
callq 0x2310
addq $0x98, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/corecodec[P]coremake/coremake.c
// Function: preprocess_sort_workspace
void preprocess_sort_workspace(item* p)
{
	item** child;
	if (!p) return;
	for (child=p->child;child!=p->childend;++child)
	{
#if 0
		size_t i;
		item *frameworks = item_find(*child,"framework");
		for (i=0;i<item_childcount(frameworks);++i)
		{
	        char xcodeuid[25];
			generate_xcodeuid(xcodeuid,frameworks->child[i]->value);
			item_get(item_get(frameworks->child[i],"xcodegrpuid",0),xcodeuid,1);

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

// Assembly:
testq %rdi, %rdi
je 0xa8b0
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rdi, %rbx
movq 0x18(%rdi), %r12
leaq 0x5863(%rip), %r14      # 0x100dc
leaq -0x7ef9(%rip), %r15     # 0x2987
cmpq 0x20(%rbx), %r12
je 0xa8a5
movq (%r12), %rdi
movq %r14, %rsi
xorl %edx, %edx
callq 0x26a2
movq %rax, %rdi
movq %r15, %rsi
callq 0x2b25
addq $0x8, %r12
jmp 0xa880
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
// File: /workspace/github_cpp_makefile_star2_O2/corecodec[P]coremake/coremake.c
// Function: getname
char* getname(char* s,char* name)
{
	for (;*s && isspace(*s);++s);
	for (;*s && isname(*s);++s)
		*(name++) = *s;
	*name = 0;
	return s;
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rsi, %r14
movq %rdi, %rbx
movsbq (%rbx), %r15
testq %r15, %r15
je 0xc8a8
callq 0x2360
movq (%rax), %rax
testb $0x20, 0x1(%rax,%r15,2)
je 0xc8a8
incq %rbx
jmp 0xc88a
xorl %r12d, %r12d
testb %r15b, %r15b
je 0xc8cb
movsbl %r15b, %edi
callq 0x3476
testl %eax, %eax
je 0xc8cb
movb %r15b, (%r14,%r12)
movb 0x1(%rbx,%r12), %r15b
incq %r12
jmp 0xc8ab
movb $0x0, (%r14,%r12)
addq %r12, %rbx
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
// File: /workspace/github_cpp_makefile_star2_O2/corecodec[P]coremake/coremake.c
// Function: urlquote
void urlquote(char *name,int no_backslash)
{
    char *q = strrchr(name,'\"');
    while (q)
    {
        strdel(q,q+1);
        strins(q,"&quot;",NULL);
        if (!no_backslash)
            strins(q,"\\",NULL);
        q = strrchr(name,'\"');
    }
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movl %esi, %ebx
movq %rdi, %r14
pushq $0x22
popq %rbp
movl %ebp, %esi
callq 0x2150
movq %rax, %r13
leaq 0x48a2(%rip), %r15      # 0x111a8
leaq 0x48a2(%rip), %r12      # 0x111af
testq %r13, %r13
je 0xc94b
leaq 0x1(%r13), %rsi
movq %r13, %rdi
callq 0x33a5
movq %r13, %rdi
movq %r15, %rsi
xorl %edx, %edx
callq 0x334b
testl %ebx, %ebx
jne 0xc93c
movq %r13, %rdi
movq %r12, %rsi
xorl %edx, %edx
callq 0x334b
movq %r14, %rdi
movl %ebp, %esi
callq 0x2150
movq %rax, %r13
jmp 0xc90d
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/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
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movq %rdx, %r14
movq %rsi, %r15
movq %rdi, %r12
callq 0xcd20
movq %rax, %rbx
movq %r12, %rdi
callq 0xc9c4
movq (%r12), %rax
movzbl (%rax), %ecx
cmpl $0x7c, %ecx
je 0xcc43
cmpl $0x26, %ecx
jne 0xcc73
cmpb $0x26, 0x1(%rax)
jne 0xcc73
addq $0x2, %rax
movq %rax, (%r12)
movq %r12, %rdi
movq %r15, %rsi
movq %r14, %rdx
callq 0xcbe2
movq %rax, %r14
movq %rbx, %rdi
callq 0xc991
testl %eax, %eax
jne 0xcc7f
xorl %ebp, %ebp
jmp 0xcc89
cmpb $0x7c, 0x1(%rax)
jne 0xcc73
addq $0x2, %rax
movq %rax, (%r12)
movq %r12, %rdi
movq %r15, %rsi
movq %r14, %rdx
callq 0xcbe2
movq %rax, %r14
movq %rbx, %rdi
callq 0xc991
testl %eax, %eax
je 0xcc7f
pushq $0x1
popq %rbp
jmp 0xcc89
movq %rbx, %rax
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
movq %r14, %rdi
callq 0xc991
movl %eax, %ebp
movq %rbx, %rdi
callq 0x2050
movq %r14, %rdi
callq 0x2050
movl %ebp, %edi
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
jmp 0xc9ab
// File: /workspace/github_cpp_makefile_star2_O2/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
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rdx, %rbx
movq %rsi, %r14
movq %rdi, %r15
callq 0xc9c4
movq (%r15), %rax
cmpb $0x21, (%rax)
jne 0xcccb
cmpb $0x3d, 0x1(%rax)
jne 0xcce3
movq %r15, %rdi
movq %r14, %rsi
movq %rbx, %rdx
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
jmp 0xc9f7
incq %rax
movq %rax, (%r15)
movq %r15, %rdi
movq %r14, %rsi
movq %rbx, %rdx
callq 0xcca8
movq %rax, %rbx
movq %rax, %rdi
callq 0xc991
movl %eax, %ebp
xorl $0x1, %ebp
movq %rbx, %rdi
callq 0x2050
movl %ebp, %edi
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
jmp 0xc9ab
// File: /workspace/github_cpp_makefile_star2_O2/corecodec[P]coremake/coremake.c
// Function: eval1
char* eval1(const char** s,item* config,reader* file)
{
	int value;
	char* b;
	char* a = eval2(s,config,file);

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

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movq %rdx, %r14
movq %rsi, %r15
movq %rdi, %r12
callq 0xcca8
movq %rax, %rbx
movq %r12, %rdi
callq 0xc9c4
movq (%r12), %rax
movzbl (%rax), %ecx
cmpl $0x21, %ecx
je 0xcd87
cmpl $0x3d, %ecx
jne 0xcdd8
cmpb $0x3d, 0x1(%rax)
jne 0xcdd8
addq $0x2, %rax
movq %rax, (%r12)
movq %r12, %rdi
movq %r15, %rsi
movq %r14, %rdx
callq 0xcd20
movq %rax, %r14
movq %rbx, %rdi
movq %rax, %rsi
callq 0x2070
testl %eax, %eax
sete %al
jmp 0xcdb6
cmpb $0x3d, 0x1(%rax)
jne 0xcdd8
addq $0x2, %rax
movq %rax, (%r12)
movq %r12, %rdi
movq %r15, %rsi
movq %r14, %rdx
callq 0xcd20
movq %rax, %r14
movq %rbx, %rdi
movq %rax, %rsi
callq 0x2070
testl %eax, %eax
setne %al
movzbl %al, %ebp
movq %rbx, %rdi
callq 0x2050
movq %r14, %rdi
callq 0x2050
movl %ebp, %edi
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
jmp 0xc9ab
movq %rbx, %rax
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/corecodec[P]coremake/coremake.c
// Function: eval
int eval(const char* s,item* config,reader* file)
{
	int result;
	char* a = eval0(&s,config,file);
	result = str2bool(a);
	free(a);
	return result;
}

// Assembly:
pushq %rbp
pushq %rbx
pushq %rax
movq %rsp, %rax
movq %rdi, (%rax)
movq %rax, %rdi
callq 0xcbe2
movq %rax, %rbx
movq %rax, %rdi
callq 0xc991
movl %eax, %ebp
movq %rbx, %rdi
callq 0x2050
movl %ebp, %eax
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/corecodec[P]coremake/coremake.c
// Function: match
int match(const char* name, const char* mask)
{
    if (*mask=='*')
    {
        ++mask;
        for (;!match(name,mask);++name)
        {
            if (*name==0)
                return 0;
        }
        return 1;
    }
    else
    {
        if (*mask==0)
            return *name==0;

        if (*name==0)
            return 0;

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

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

// Assembly:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x800, %rsp            # imm = 0x800
movq %rdi, %r14
pushq $0x2a
popq %rsi
callq 0x2130
testq %rax, %rax
jne 0xceb7
pushq $0x3f
popq %rsi
movq %r14, %rdi
callq 0x2130
testq %rax, %rax
je 0xcf71
movq %r14, %rdi
callq 0x3853
movq %rax, %rbx
movq %rsp, %r15
movl $0x400, %edx            # imm = 0x400
movq %r15, %rdi
movq %r14, %rsi
callq 0x2080
pushq $0x1
popq %rsi
movq %r15, %rdi
callq 0x3a31
cmpb $0x0, (%r15)
leaq 0x32a6(%rip), %rdi      # 0x10191
cmovneq %r15, %rdi
callq 0x2100
testq %rax, %rax
je 0xcf60
movq %rax, %r14
movq %rsp, %r15
movq %r15, %rdi
callq 0x39f0
leaq 0x400(%rsp), %r12
movq %r14, %rdi
callq 0x2250
testq %rax, %rax
je 0xcf58
movq %rax, %r13
cmpb $0x2e, 0x13(%rax)
je 0xcf0f
addq $0x13, %r13
movq %r13, %rdi
movq %rbx, %rsi
callq 0xce1b
testl %eax, %eax
je 0xcf0f
movq %r12, %rdi
movq %r15, %rsi
callq 0x20b0
movq %r12, %rdi
movq %r13, %rsi
callq 0x2300
movq %r12, %rdi
callq 0x2090
jmp 0xcf0f
movq %r14, %rdi
callq 0x2190
addq $0x800, %rsp            # imm = 0x800
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
movq %r14, %rdi
addq $0x800, %rsp            # imm = 0x800
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
jmp 0x2090
// File: /workspace/github_cpp_makefile_star2_O2/corecodec[P]coremake/coremake.c
// Function: remove_dir
void remove_dir(const char* name)
{
	DIR* dir = opendir(name);
	if (dir)
	{
		struct dirent* entry;
		while ((entry = readdir(dir)) != NULL)
		{
			if (entry->d_name[0]!='.')
			{
				char item[MAX_PATH];
				sprintf(item,"%s/%s",name,entry->d_name);
				remove_dir(item);
			}
		}
		closedir(dir);
        remove_dir(".DS_Store");
        remove_dir(".Trashes");
		rmdir(name);
	}
	else
		remove(name);
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x408, %rsp            # imm = 0x408
movq %rdi, %rbx
callq 0x2100
testq %rax, %rax
je 0xd01c
movq %rax, %r14
leaq 0x4247(%rip), %r15      # 0x111f5
movq %rsp, %r12
movq %r14, %rdi
callq 0x2250
testq %rax, %rax
je 0xcfe5
cmpb $0x2e, 0x13(%rax)
je 0xcfb1
addq $0x13, %rax
movq %r12, %rdi
movq %r15, %rsi
movq %rbx, %rdx
movq %rax, %rcx
xorl %eax, %eax
callq 0x2310
movq %r12, %rdi
callq 0xcf89
jmp 0xcfb1
movq %r14, %rdi
callq 0x2190
leaq 0x4207(%rip), %rdi      # 0x111fb
callq 0xcf89
leaq 0x4205(%rip), %rdi      # 0x11205
callq 0xcf89
movq %rbx, %rdi
callq 0x2110
addq $0x408, %rsp            # imm = 0x408
popq %rbx
popq %r12
popq %r14
popq %r15
retq
movq %rbx, %rdi
addq $0x408, %rsp            # imm = 0x408
popq %rbx
popq %r12
popq %r14
popq %r15
jmp 0x2090
// File: /workspace/github_cpp_makefile_star2_O2/corecodec[P]coremake/coremake.c
// Function: reader_item
item* reader_item(reader* file, int skip, build_pos* pos)
{
    item* i = NULL;

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

    return i;
}

// Assembly:
pushq %rbp
pushq %r14
pushq %rbx
movq %rdx, %rbx
movl %esi, %ebp
movq %rdi, %r14
callq 0x380b
testl %ebp, %ebp
je 0xd04e
xorl %eax, %eax
popq %rbx
popq %r14
popq %rbp
retq
movq 0x30(%r14), %rsi
cmpb $0x2e, (%rsi)
jne 0xd075
cmpb $0x2e, 0x1(%rsi)
jne 0xd075
cmpb $0x2f, 0x2(%rsi)
jne 0xd075
testq %rbx, %rbx
je 0xd06d
movq (%rbx), %rbx
jmp 0xd06f
xorl %ebx, %ebx
addq $0x3, %rsi
jmp 0xd052
testq %rbx, %rbx
je 0xd047
movq 0x8(%rbx), %rdi
pushq $0x1
popq %rdx
popq %rbx
popq %r14
popq %rbp
jmp 0x26a2
// File: /workspace/github_cpp_makefile_star2_O2/corecodec[P]coremake/coremake.c
// Function: getarg
void getarg(char* s, const char** in)
{
    int quote = 0;

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

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

    *s = 0;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movq %rsi, %r14
movq %rdi, %rbx
movq (%rsi), %r15
movsbq (%r15), %r12
testq %r12, %r12
je 0xd0bc
callq 0x2360
movq (%rax), %rax
testb $0x20, 0x1(%rax,%r12,2)
je 0xd0bc
incq %r15
movq %r15, (%r14)
jmp 0xd09b
xorl %ebp, %ebp
testb %r12b, %r12b
je 0xd104
testl %ebp, %ebp
jne 0xd0da
callq 0x2360
movq (%rax), %rax
movsbq %r12b, %rcx
testb $0x20, 0x1(%rax,%rcx,2)
jne 0xd104
cmpb $0x22, %r12b
jne 0xd0eb
xorl %eax, %eax
testl %ebp, %ebp
sete %al
movl %eax, %ebp
jmp 0xd0f4
movb %r12b, (%rbx)
incq %rbx
movq (%r14), %r15
leaq 0x1(%r15), %rax
movq %rax, (%r14)
movb 0x1(%r15), %r12b
movq %rax, %r15
jmp 0xd0be
movb $0x0, (%rbx)
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/corecodec[P]coremake/coremake.c
// Function: build_file
void build_file(item* p,const char* filename, int reader_flags)
{
	reader r;
    reader_init(&r);
	strcpy(r.filename,filename);
	pathunix(r.filename);
	r.r.f = fopen(filename,"r");
	r.pos = r.line;
	if (!r.r.f)
	{
		printf("'%s' build file not found!\r\n",filename);
		exit(1);
	}
    r.r.flags = reader_flags;
    r.r.filename_kind = reader_flags;
	build_parse(p,&r,0,0,NULL);
	fclose(r.r.f);
    reader_free(&r);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x40, %rsp
movl %edx, %ebp
movq %rsi, %r14
movq %rdi, %rbx
movq %rsp, %r15
movq %r15, %rdi
callq 0x3181
movq 0x38(%r15), %r12
movq %r12, %rdi
movq %r14, %rsi
callq 0x20b0
movq %r12, %rdi
callq 0x3a94
leaq 0x1b60(%rip), %rsi      # 0x10371
movq %r14, %rdi
callq 0x22d0
movq %rax, (%r15)
movq 0x28(%r15), %rcx
movq %rcx, 0x20(%r15)
testq %rax, %rax
je 0xe863
movq %rsp, %r14
movl %ebp, 0x10(%r14)
movl %ebp, 0x14(%r14)
movq %rbx, %rdi
movq %r14, %rsi
xorl %edx, %edx
xorl %ecx, %ecx
xorl %r8d, %r8d
callq 0xd110
movq (%r14), %rdi
callq 0x20f0
movq %r14, %rdi
callq 0x31d6
addq $0x40, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
leaq 0x2bd1(%rip), %rdi      # 0x1143b
movq %r14, %rsi
xorl %eax, %eax
callq 0x2140
pushq $0x1
popq %rdi
callq 0x2320
// File: /workspace/github_cpp_makefile_star2_O2/corecodec[P]coremake/coremake.c
// Function: default_workspace
item* default_workspace(item* workspace,item* i,item* p)
{
	item** child;
	if (!p) return i;
	for (child=p->child;child!=p->childend;++child)
    {
        if (!i)
        {
            truncfilename(proj);
            i = item_get(workspace,proj,1);
        }
        item_get(item_get(i,"use",1),(*child)->value,1);
    }
    return i;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rsi, %r15
testq %rdx, %rdx
je 0xe8f1
movq %rdx, %rbx
movq %rdi, %r14
movq 0x18(%rdx), %r12
pushq $0x1
popq %rbp
leaq 0x1839(%rip), %r13      # 0x100dc
cmpq 0x20(%rbx), %r12
je 0xe8f1
testq %r15, %r15
jne 0xe8cd
leaq 0x791b(%rip), %r15      # 0x161d0
movq %r15, %rdi
callq 0x38af
movq %r14, %rdi
movq %r15, %rsi
movl %ebp, %edx
callq 0x26a2
movq %rax, %r15
movq %r15, %rdi
movq %r13, %rsi
movl %ebp, %edx
callq 0x26a2
movq (%r12), %rcx
movq (%rcx), %rsi
movq %rax, %rdi
movl %ebp, %edx
callq 0x26a2
addq $0x8, %r12
jmp 0xe8a3
movq %r15, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/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:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
movq %r8, %rbx
movq %rcx, %r14
movq %rdx, %r15
movq %rdi, %r12
leaq 0x40(%rdi), %r13
movq %r13, %rdi
callq 0x11ed02
movq %r13, %rdi
movq %r15, %rsi
callq 0x11ed02
movq %r13, %rdi
movq %r14, %rsi
callq 0x11ed02
movq %r13, %rdi
movq %rbx, %rsi
callq 0x11ed02
movq %r12, %rax
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
nop
// File: /workspace/github_cpp_makefile_star2_O2/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
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq 0x2deb(%rip), %rbx      # 0x3fd8
movq %rbx, %rdi
movl $0x80000000, %esi       # imm = 0x80000000
callq 0x1090
leaq 0xe03(%rip), %r14       # 0x2004
movq %rax, %rdi
movq %r14, %rsi
callq 0x1070
movq %rax, %rdi
movl $0x80000000, %esi       # imm = 0x80000000
callq 0x1090
leaq 0xde8(%rip), %r15       # 0x2008
movq %rax, %rdi
movq %r15, %rsi
callq 0x1070
movabsq $-0x100000000, %rsi     # imm = 0xFFFFFFFF00000000
movq %rax, %rdi
callq 0x1060
movq %rax, %rdi
callq 0x1030
movl $0xffffffff, %esi       # imm = 0xFFFFFFFF
movq %rbx, %rdi
callq 0x1040
movq %rax, %rdi
movq %r14, %rsi
callq 0x1070
movl $0xffffffff, %esi       # imm = 0xFFFFFFFF
movq %rax, %rdi
callq 0x1040
movq %rax, %rdi
movq %r15, %rsi
callq 0x1070
movabsq $0x1fffffffe, %rsi      # imm = 0x1FFFFFFFE
movq %rax, %rdi
callq 0x1040
movq %rax, %rdi
callq 0x1030
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/jaldhar[P]Lets-Build-a-Simple-Interpreter/calc5.cc
// Function: Interpreter::factor()
long Interpreter::factor() {
    Token token = _current_token;
    if (token.type == TOKENTYPE::LPAREN) {
        eat(TOKENTYPE::LPAREN);
        long result = expression();
        eat(TOKENTYPE::RPAREN);
        return result;
    } else {
        eat(TOKENTYPE::INTEGER);
        return token.value;
    }
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
cmpl $0x6, 0x8(%rdi)
jne 0x287b
pushq $0x6
popq %rsi
movq %rbx, %rdi
callq 0x2796
movq %rbx, %rdi
callq 0x2696
movq %rax, %r14
pushq $0x7
jmp 0x2881
movq 0x10(%rbx), %r14
pushq $0x1
popq %rsi
movq %rbx, %rdi
callq 0x2796
movq %r14, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_cpp_makefile_star2_O2/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
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x30, %rsp
movq %rdi, %rbx
pushq $0x28
popq %rdi
callq 0x21a0
movq %rax, %r14
leaq -0x50(%rbp), %rdi
movq %rbx, %rsi
callq 0x21f0
movl 0x20(%rbx), %edx
leaq -0x50(%rbp), %rsi
movq %r14, %rdi
callq 0x2684
leaq -0x50(%rbp), %rdi
callq 0x20e0
movq %r14, %rdi
callq 0x26c2
movq %rax, 0x28(%rbx)
movq %rdx, 0x30(%rbx)
pushq $0x2
popq %rdi
movl %edi, %esi
xorl %edx, %edx
callq 0x2080
movl %eax, 0x24(%rbx)
cmpl $-0x1, %eax
je 0x2591
leaq -0x2c(%rbp), %rcx
movl $0x1, (%rcx)
pushq $0x1
popq %rsi
pushq $0x2
popq %rdx
pushq $0x4
popq %r8
movl %eax, %edi
callq 0x2230
testl %eax, %eax
jne 0x2589
leaq 0x28(%rbx), %r15
leaq -0x24(%rbp), %r14
movl $0x4, (%r14)
movl 0x24(%rbx), %edi
pushq $0x1
popq %rsi
pushq $0x8
popq %rdx
leaq -0x28(%rbp), %r12
movq %r12, %rcx
movq %r14, %r8
callq 0x2120
movl (%r12), %esi
movl (%r14), %edx
leaq 0xa9f(%rip), %rdi       # 0x300c
xorl %r14d, %r14d
xorl %eax, %eax
callq 0x2040
movl 0x24(%rbx), %edi
pushq $0x10
popq %rdx
movq %r15, %rsi
callq 0x2060
testl %eax, %eax
je 0x2599
movq %rbx, %rdi
callq 0x24a0
callq 0x2030
movl (%rax), %r14d
movl %r14d, %eax
addq $0x30, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
leaq -0x50(%rbp), %rdi
callq 0x20e0
jmp 0x25ba
movq %rax, %rbx
movq %r14, %rdi
callq 0x2180
movq %rbx, %rdi
callq 0x2220
// File: /workspace/github_cpp_makefile_star2_O2/maydali28[P]cpp-socket/matrix_hal/socketAddr.cpp
// Function: matrix_hal::socketAddr::to_sockaddr_in()
struct sockaddr_in socketAddr::to_sockaddr_in(){
    struct sockaddr_in addr;
    //addr = (struct sockaddr_in *) malloc(sizeof(struct sockaddr_in));
    memset(&addr,0,sizeof(addr));

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

    return addr;
  }

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %rbx
subq $0x18, %rsp
leaq -0x14(%rbp), %rbx
andl $0x0, 0x8(%rbx)
andq $0x0, (%rbx)
movw $0x2, -0x4(%rbx)
movzwl 0x20(%rdi), %eax
rolw $0x8, %ax
movw %ax, -0x2(%rbx)
movq (%rdi), %rdi
movq %rbx, %rsi
callq 0x2110
movq -0x4(%rbx), %rax
movq 0x4(%rbx), %rdx
addq $0x18, %rsp
popq %rbx
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O2/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
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %rsi, %r12
movq %rdi, %rbx
leaq -0x2c(%rbp), %r13
movl $0x10, (%r13)
movl $0x400, %edi            # imm = 0x400
callq 0x21d0
leaq 0x20(%rbx), %rcx
movq %rcx, 0x10(%rbx)
andq $0x0, 0x18(%rbx)
movq %rax, %r14
leaq 0x10(%rbx), %r15
movb $0x0, 0x20(%rbx)
movl (%r12), %edi
pushq $0x8
popq %rdx
leaq -0x3c(%rbp), %r8
movq %rax, %rsi
xorl %ecx, %ecx
movq %r13, %r9
callq 0x2130
testq %rax, %rax
je 0x2866
movq %r15, %rdi
movq %r14, %rsi
callq 0x2240
movups -0x3c(%rbp), %xmm0
movups %xmm0, (%rbx)
movq %r14, %rdi
callq 0x21b0
movq %rbx, %rax
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
movq %r15, %rdi
callq 0x20e0
movq %rbx, %rdi
callq 0x2220
nop
// File: /workspace/github_cpp_makefile_star2_O2/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 $0x10, %rsp
leaq -0x10(%rbp), %r8
movw $0x2, (%r8)
movzwl 0x6(%rdi), %eax
movw %ax, 0x2(%r8)
movl 0x8(%rdi), %eax
movl %eax, 0x4(%r8)
movl (%rdi), %edi
movq (%rsi), %rax
movq 0x8(%rsi), %rdx
incq %rdx
pushq $0x10
popq %r9
movq %rax, %rsi
xorl %ecx, %ecx
callq 0x2050
xorl %ecx, %ecx
cmpq $-0x1, %rax
setne %cl
movl %ecx, %eax
addq $0x10, %rsp
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O2/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
pushq %r14
pushq %rbx
subq $0x10, %rsp
movq %rdx, %rbx
movq %rdi, %r14
leaq -0x1c(%rbp), %rax
movw $0x2, -0x4(%rax)
movzwl 0x6(%rdi), %ecx
movw %cx, -0x2(%rax)
movq (%rsi), %rdi
movq %rax, %rsi
callq 0x2110
movl (%r14), %edi
movq (%rbx), %rsi
movq 0x8(%rbx), %rdx
incq %rdx
leaq -0x20(%rbp), %r8
pushq $0x10
popq %r9
xorl %ecx, %ecx
callq 0x2050
xorl %ecx, %ecx
cmpq $-0x1, %rax
setne %cl
movl %ecx, %eax
addq $0x10, %rsp
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/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
pushq %r14
pushq %rbx
subq $0x10, %rsp
movq %rcx, %rbx
movq %rdi, %r14
leaq -0x1c(%rbp), %rax
movw $0x2, -0x4(%rax)
rolw $0x8, %dx
movw %dx, -0x2(%rax)
movq (%rsi), %rdi
movq %rax, %rsi
callq 0x2110
movl (%r14), %edi
movq (%rbx), %rsi
movq 0x8(%rbx), %rdx
incq %rdx
leaq -0x20(%rbp), %r8
pushq $0x10
popq %r9
xorl %ecx, %ecx
callq 0x2050
xorl %ecx, %ecx
cmpq $-0x1, %rax
setne %cl
movl %ecx, %eax
addq $0x10, %rsp
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/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::valarray<short>, int)
int socketUDP::send(std::string ip, int port,std::valarray<int16_t> buf, int length){
      std::ostringstream oss;
      if (buf.size())
      {
        // Convert all but the last element to avoid a trailing ","
        std::copy(std::begin(buf), std::end(buf)-1,
            std::ostream_iterator<int16_t>(oss, ","));

        // Now add the last element with no delimiter
        oss << buf[buf.size()-1 ];
      }
      std::cout << oss.str() <<"\n";
      std::string packet = oss.str();
      int result = send(ip,port, packet);
      return result;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x1e8, %rsp            # imm = 0x1E8
movq %rcx, %r12
movl %edx, %ebx
movq %rsi, %r15
movq %rdi, %r14
leaq -0x210(%rbp), %r13
movq %r13, %rdi
callq 0x21e0
movq (%r12), %rax
testq %rax, %rax
je 0x2a12
movq 0x8(%r12), %rsi
leaq (%rsi,%rax,2), %rdx
addq $-0x2, %rdx
leaq -0x98(%rbp), %rcx
movq %r13, (%rcx)
leaq 0x628(%rip), %rax       # 0x3013
movq %rax, 0x8(%rcx)
leaq -0x48(%rbp), %rdi
callq 0x2b16
movq (%r12), %rax
movq 0x8(%r12), %rcx
movswl -0x2(%rcx,%rax,2), %esi
leaq -0x210(%rbp), %rdi
callq 0x2170
leaq -0x208(%rbp), %r12
leaq -0x48(%rbp), %rdi
movq %r12, %rsi
callq 0x2210
movq 0x25ac(%rip), %rdi      # 0x4fd8
leaq -0x48(%rbp), %rsi
callq 0x2160
leaq 0x5d5(%rip), %rsi       # 0x3011
movq %rax, %rdi
callq 0x2190
leaq -0x48(%rbp), %rdi
callq 0x20e0
leaq -0x48(%rbp), %rdi
movq %r12, %rsi
callq 0x2210
leaq -0x88(%rbp), %rdi
movq %r15, %rsi
callq 0x21f0
leaq -0x68(%rbp), %rdi
leaq -0x48(%rbp), %rsi
callq 0x21f0
leaq -0x88(%rbp), %rsi
leaq -0x68(%rbp), %rcx
movq %r14, %rdi
movl %ebx, %edx
callq 0x2938
movl %eax, %ebx
leaq -0x68(%rbp), %rdi
callq 0x20e0
leaq -0x88(%rbp), %rdi
callq 0x20e0
leaq -0x48(%rbp), %rdi
callq 0x20e0
leaq -0x210(%rbp), %rdi
callq 0x2070
movl %ebx, %eax
addq $0x1e8, %rsp            # imm = 0x1E8
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
jmp 0x2af1
jmp 0x2af1
movq %rax, %rbx
leaq -0x68(%rbp), %rdi
callq 0x20e0
jmp 0x2adf
movq %rax, %rbx
leaq -0x88(%rbp), %rdi
callq 0x20e0
jmp 0x2af9
jmp 0x2af6
jmp 0x2af1
movq %rax, %rbx
jmp 0x2b02
movq %rax, %rbx
leaq -0x48(%rbp), %rdi
callq 0x20e0
leaq -0x210(%rbp), %rdi
callq 0x2070
movq %rbx, %rdi
callq 0x2220
// File: /workspace/github_cpp_makefile_star2_O2/maydali28[P]cpp-socket/prog.cpp
// Function: main
int main(void){
  matrix_hal::server *srv = new matrix_hal::server(8080);
  int err = srv->bind();
  if(err != 0){
    std::cout<<strerror(err)<<std::endl;
    exit(err);
  }
  matrix_hal::socketUDP* socket = srv->getConnexion();
  if(!socket->valid()){
    delete socket;
    exit(0);
  }

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


}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x50, %rsp
pushq $0x38
popq %rdi
callq 0x21a0
movq %rax, %r14
movq %rax, %rdi
movl $0x1f90, %esi           # imm = 0x1F90
callq 0x23fc
movq %r14, %rdi
callq 0x24b4
testl %eax, %eax
jne 0x2d9b
movq %r14, %rdi
callq 0x25ca
movq %rax, %rbx
movq %rax, %rdi
callq 0x27cc
testb %al, %al
je 0x2dc2
movq $0xa, -0x38(%rbp)
pushq $0x14
popq %rdi
callq 0x21a0
movq %rax, %r14
movq %rax, -0x30(%rbp)
movups 0x336(%rip), %xmm0      # 0x3016
movups %xmm0, (%rax)
movl $0xa0009, 0x10(%rax)    # imm = 0xA0009
movl $0x400, %r12d           # imm = 0x400
leaq 0x318(%rip), %r15       # 0x300f
subl $0x1, %r12d
jb 0x2d0e
movq %r15, %rdi
movl $0x2b67, %esi           # imm = 0x2B67
xorl %eax, %eax
callq 0x2040
jmp 0x2cf7
leaq 0x315(%rip), %rsi       # 0x302a
leaq -0x68(%rbp), %rdi
leaq -0x21(%rbp), %rdx
callq 0x20b0
leaq -0x48(%rbp), %rdi
leaq -0x38(%rbp), %rsi
callq 0x2e0e
movl -0x38(%rbp), %r8d
leaq -0x68(%rbp), %rsi
leaq -0x48(%rbp), %rcx
movq %rbx, %rdi
movl $0x7dc, %edx            # imm = 0x7DC
callq 0x2996
cmpl $0x1, %eax
leaq 0x2e6(%rip), %rax       # 0x3038
leaq 0x2db(%rip), %rsi       # 0x3034
cmoveq %rax, %rsi
movq 0x2274(%rip), %rdi      # 0x4fd8
callq 0x2190
movq %rax, %rdi
callq 0x20f0
movq -0x40(%rbp), %rdi
callq 0x2180
leaq -0x68(%rbp), %rdi
callq 0x20e0
movq -0x30(%rbp), %rdi
callq 0x2180
xorl %eax, %eax
addq $0x50, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
movl %eax, %ebx
movl %eax, %edi
callq 0x20a0
movq 0x222d(%rip), %rdi      # 0x4fd8
movq %rax, %rsi
callq 0x2190
movq %rax, %rdi
callq 0x20f0
movl %ebx, %edi
callq 0x21c0
movq %rbx, %rdi
callq 0x2780
movq %rbx, %rdi
callq 0x2180
xorl %edi, %edi
callq 0x21c0
movq %rax, %rbx
jmp 0x2df1
jmp 0x2de0
movq %rax, %rbx
jmp 0x2dfe
movq %rax, %rbx
movq -0x40(%rbp), %rdi
callq 0x2180
leaq -0x68(%rbp), %rdi
callq 0x20e0
movq -0x30(%rbp), %r14
movq %r14, %rdi
callq 0x2180
movq %rbx, %rdi
callq 0x2220
// File: /workspace/github_cpp_makefile_star2_O2/dannycalegari[P]circle_pack/./Trigonometry_routine.cc
// Function: midpoint(Point, Point)
Point midpoint(Point P, Point Q){
	Point R;
	R.x=(P.x+Q.x)/2.0;
	R.y=(P.y+Q.y)/2.0;
	R.z=(P.z+Q.z)/2.0;
	return(R);
}

// Assembly:
movq %rdi, %rax
movupd 0x20(%rsp), %xmm0
addpd 0x8(%rsp), %xmm0
mulpd 0x6a71(%rip), %xmm0     # 0x9010
movupd %xmm0, (%rdi)
movsd 0x18(%rsp), %xmm0
addsd 0x30(%rsp), %xmm0
mulsd 0x6ac9(%rip), %xmm0     # 0x9080
movsd %xmm0, 0x10(%rdi)
retq
// File: /workspace/github_cpp_makefile_star2_O2/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:
movq %rdi, %rax
movapd %xmm0, %xmm1
unpcklpd %xmm0, %xmm1            # xmm1 = xmm1[0],xmm0[0]
mulpd 0x8(%rsp), %xmm1
movupd %xmm1, (%rdi)
mulsd 0x18(%rsp), %xmm0
movsd %xmm0, 0x10(%rdi)
retq
// File: /workspace/github_cpp_makefile_star2_O2/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:
movq %rdi, %rax
movupd 0x20(%rsp), %xmm0
addpd 0x8(%rsp), %xmm0
movupd %xmm0, (%rdi)
movsd 0x18(%rsp), %xmm0
addsd 0x30(%rsp), %xmm0
movsd %xmm0, 0x10(%rdi)
retq
// File: /workspace/github_cpp_makefile_star2_O2/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:
movq %rdi, %rax
movsd 0x8(%rsp), %xmm0
movsd 0x20(%rsp), %xmm1
movupd 0x10(%rsp), %xmm2
movupd 0x28(%rsp), %xmm3
movapd %xmm2, %xmm4
shufpd $0x1, %xmm0, %xmm4      # xmm4 = xmm4[1],xmm0[0]
mulsd %xmm3, %xmm0
mulpd %xmm3, %xmm4
shufpd $0x1, %xmm1, %xmm3      # xmm3 = xmm3[1],xmm1[0]
mulsd %xmm2, %xmm1
subsd %xmm1, %xmm0
movsd %xmm0, 0x10(%rdi)
mulpd %xmm2, %xmm3
subpd %xmm4, %xmm3
movupd %xmm3, (%rdi)
retq
// File: /workspace/github_cpp_makefile_star2_O2/dannycalegari[P]circle_pack/./Trigonometry_routine.cc
// Function: write_Matrix(Matrix)
void write_Matrix(Matrix M){
	int i,j;
	for(i=0;i<3;i++){
		for(j=0;j<3;j++){
			cout << M.e[i][j] << " ";
		};
		cout << "\n";
	};
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rdi, %rbx
xorl %r13d, %r13d
movq 0xa897(%rip), %r14      # 0xcfd0
leaq 0x6f88(%rip), %r12      # 0x96c8
cmpq $0x3, %r13
je 0x278c
imulq $0x18, %r13, %rbp
xorl %r15d, %r15d
cmpq $0x3, %r15
je 0x2778
movq (%rbx), %rax
movq (%rax,%rbp), %rax
movsd (%rax,%r15,8), %xmm0
movq %r14, %rdi
callq 0x2340
movq %rax, %rdi
movq %r12, %rsi
callq 0x21e0
incq %r15
jmp 0x274d
movq %r14, %rdi
leaq 0x6faf(%rip), %rsi      # 0x9731
callq 0x21e0
incq %r13
jmp 0x2740
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/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 %r14
pushq %rbx
subq $0x38, %rsp
movsd %xmm0, 0x30(%rsp)
movq %rdi, %rbx
xorps %xmm0, %xmm0
movups %xmm0, (%rdi)
andq $0x0, 0x10(%rdi)
callq 0x7558
leaq 0x10(%rsp), %r14
xorps %xmm0, %xmm0
movaps %xmm0, (%r14)
andq $0x0, 0x10(%r14)
movsd 0x30(%rsp), %xmm0
callq 0x23e0
leaq 0x8(%rsp), %rsi
movsd %xmm0, (%rsi)
movq %r14, %rdi
callq 0x7d62
movsd 0x30(%rsp), %xmm0
callq 0x2060
xorps 0x6826(%rip), %xmm0     # 0x9020
leaq 0x8(%rsp), %rsi
movlps %xmm0, (%rsi)
leaq 0x10(%rsp), %rdi
callq 0x7d62
leaq 0x8(%rsp), %rsi
andq $0x0, (%rsi)
leaq 0x10(%rsp), %rdi
callq 0x7d62
leaq 0x10(%rsp), %rsi
movq %rbx, %rdi
callq 0x7560
movq 0x10(%rsp), %rax
cmpq %rax, 0x18(%rsp)
je 0x283d
movq %rax, 0x18(%rsp)
movsd 0x30(%rsp), %xmm0
callq 0x2060
leaq 0x8(%rsp), %rsi
movsd %xmm0, (%rsi)
leaq 0x10(%rsp), %rdi
callq 0x7d62
movsd 0x30(%rsp), %xmm0
callq 0x23e0
leaq 0x8(%rsp), %rsi
movsd %xmm0, (%rsi)
leaq 0x10(%rsp), %rdi
callq 0x7d62
leaq 0x8(%rsp), %rsi
andq $0x0, (%rsi)
leaq 0x10(%rsp), %rdi
callq 0x7d62
leaq 0x10(%rsp), %rsi
movq %rbx, %rdi
callq 0x7560
movq 0x10(%rsp), %rax
cmpq %rax, 0x18(%rsp)
je 0x28aa
movq %rax, 0x18(%rsp)
leaq 0x8(%rsp), %rsi
andq $0x0, (%rsi)
leaq 0x10(%rsp), %rdi
callq 0x7d62
leaq 0x8(%rsp), %rsi
andq $0x0, (%rsi)
leaq 0x10(%rsp), %rdi
callq 0x7d62
movabsq $0x3ff0000000000000, %rax # imm = 0x3FF0000000000000
leaq 0x8(%rsp), %rsi
movq %rax, (%rsi)
leaq 0x10(%rsp), %rdi
callq 0x7d62
leaq 0x10(%rsp), %rsi
movq %rbx, %rdi
callq 0x7560
leaq 0x10(%rsp), %rdi
callq 0x7b58
movq %rbx, %rax
addq $0x38, %rsp
popq %rbx
popq %r14
retq
jmp 0x2920
jmp 0x2920
jmp 0x2920
jmp 0x2920
jmp 0x2920
jmp 0x2920
jmp 0x2920
jmp 0x2920
jmp 0x2920
movq %rax, %r14
leaq 0x10(%rsp), %rdi
callq 0x7b58
movq %rbx, %rdi
callq 0x78f0
movq %r14, %rdi
callq 0x23c0
// File: /workspace/github_cpp_makefile_star2_O2/dannycalegari[P]circle_pack/./Trigonometry_routine.cc
// Function: XZ_ROT(double)
Matrix XZ_ROT(double angle){	// rotation in xz-plane
	// returns matrix C=cos(angle), S=sin(angle)
	// (C  0 -S)
	// (0  1  0)
	// (S  0  C)
	Matrix M;
	M.e.clear();
	vector<double> row;
	row.clear();
	row.push_back(cos(angle));
	row.push_back(0.0);
	row.push_back(-sin(angle));
	M.e.push_back(row);
	row.clear();
	row.push_back(0.0);
	row.push_back(1.0);
	row.push_back(0.0);
	M.e.push_back(row);
	row.clear();
	row.push_back(sin(angle));
	row.push_back(0.0);
	row.push_back(cos(angle));
	M.e.push_back(row);
	return(M);
}

// Assembly:
pushq %r14
pushq %rbx
subq $0x38, %rsp
movsd %xmm0, 0x30(%rsp)
movq %rdi, %rbx
xorps %xmm0, %xmm0
movups %xmm0, (%rdi)
andq $0x0, 0x10(%rdi)
callq 0x7558
leaq 0x10(%rsp), %r14
xorps %xmm0, %xmm0
movaps %xmm0, (%r14)
andq $0x0, 0x10(%r14)
movsd 0x30(%rsp), %xmm0
callq 0x23e0
leaq 0x8(%rsp), %rsi
movsd %xmm0, (%rsi)
movq %r14, %rdi
callq 0x7d62
leaq 0x8(%rsp), %rsi
andq $0x0, (%rsi)
leaq 0x10(%rsp), %rdi
callq 0x7d62
movsd 0x30(%rsp), %xmm0
callq 0x2060
xorps 0x6671(%rip), %xmm0     # 0x9020
leaq 0x8(%rsp), %rsi
movlps %xmm0, (%rsi)
leaq 0x10(%rsp), %rdi
callq 0x7d62
leaq 0x10(%rsp), %rsi
movq %rbx, %rdi
callq 0x7560
movq 0x10(%rsp), %rax
cmpq %rax, 0x18(%rsp)
je 0x29df
movq %rax, 0x18(%rsp)
leaq 0x8(%rsp), %rsi
andq $0x0, (%rsi)
leaq 0x10(%rsp), %rdi
callq 0x7d62
movabsq $0x3ff0000000000000, %rax # imm = 0x3FF0000000000000
leaq 0x8(%rsp), %rsi
movq %rax, (%rsi)
leaq 0x10(%rsp), %rdi
callq 0x7d62
leaq 0x8(%rsp), %rsi
andq $0x0, (%rsi)
leaq 0x10(%rsp), %rdi
callq 0x7d62
leaq 0x10(%rsp), %rsi
movq %rbx, %rdi
callq 0x7560
movq 0x10(%rsp), %rax
cmpq %rax, 0x18(%rsp)
je 0x2a3f
movq %rax, 0x18(%rsp)
movsd 0x30(%rsp), %xmm0
callq 0x2060
leaq 0x8(%rsp), %rsi
movsd %xmm0, (%rsi)
leaq 0x10(%rsp), %rdi
callq 0x7d62
leaq 0x8(%rsp), %rsi
andq $0x0, (%rsi)
leaq 0x10(%rsp), %rdi
callq 0x7d62
movsd 0x30(%rsp), %xmm0
callq 0x23e0
leaq 0x8(%rsp), %rsi
movsd %xmm0, (%rsi)
leaq 0x10(%rsp), %rdi
callq 0x7d62
leaq 0x10(%rsp), %rsi
movq %rbx, %rdi
callq 0x7560
leaq 0x10(%rsp), %rdi
callq 0x7b58
movq %rbx, %rax
addq $0x38, %rsp
popq %rbx
popq %r14
retq
jmp 0x2ac2
jmp 0x2ac2
jmp 0x2ac2
jmp 0x2ac2
jmp 0x2ac2
jmp 0x2ac2
jmp 0x2ac2
jmp 0x2ac2
jmp 0x2ac2
movq %rax, %r14
leaq 0x10(%rsp), %rdi
callq 0x7b58
movq %rbx, %rdi
callq 0x78f0
movq %r14, %rdi
callq 0x23c0
// File: /workspace/github_cpp_makefile_star2_O2/dannycalegari[P]circle_pack/./Trigonometry_routine.cc
// Function: YZ_ROT(double)
Matrix YZ_ROT(double angle){	// rotation in xz-plane
	// returns matrix C=cos(angle), S=sin(angle)
	// (1  0  0)
	// (0  C -S)
	// (0  S  C)
	Matrix M;
	M.e.clear();
	vector<double> row;
	row.clear();
	row.push_back(1.0);
	row.push_back(0.0);
	row.push_back(0.0);
	M.e.push_back(row);
	row.clear();
	row.push_back(0.0);
	row.push_back(cos(angle));
	row.push_back(-sin(angle));
	M.e.push_back(row);
	row.clear();
	row.push_back(0.0);
	row.push_back(sin(angle));
	row.push_back(cos(angle));
	M.e.push_back(row);
	return(M);
}

// Assembly:
pushq %r14
pushq %rbx
subq $0x38, %rsp
movsd %xmm0, 0x30(%rsp)
movq %rdi, %rbx
xorps %xmm0, %xmm0
movups %xmm0, (%rdi)
andq $0x0, 0x10(%rdi)
callq 0x7558
leaq 0x10(%rsp), %rdi
andq $0x0, 0x10(%rdi)
xorps %xmm0, %xmm0
movaps %xmm0, (%rdi)
movabsq $0x3ff0000000000000, %rax # imm = 0x3FF0000000000000
leaq 0x8(%rsp), %rsi
movq %rax, (%rsi)
callq 0x7d62
leaq 0x8(%rsp), %rsi
andq $0x0, (%rsi)
leaq 0x10(%rsp), %rdi
callq 0x7d62
leaq 0x8(%rsp), %rsi
andq $0x0, (%rsi)
leaq 0x10(%rsp), %rdi
callq 0x7d62
leaq 0x10(%rsp), %rsi
movq %rbx, %rdi
callq 0x7560
movq 0x10(%rsp), %rax
cmpq %rax, 0x18(%rsp)
je 0x2b6a
movq %rax, 0x18(%rsp)
leaq 0x8(%rsp), %rsi
andq $0x0, (%rsi)
leaq 0x10(%rsp), %rdi
callq 0x7d62
movsd 0x30(%rsp), %xmm0
callq 0x23e0
leaq 0x8(%rsp), %rsi
movsd %xmm0, (%rsi)
leaq 0x10(%rsp), %rdi
callq 0x7d62
movsd 0x30(%rsp), %xmm0
callq 0x2060
xorps 0x6473(%rip), %xmm0     # 0x9020
leaq 0x8(%rsp), %rsi
movlps %xmm0, (%rsi)
leaq 0x10(%rsp), %rdi
callq 0x7d62
leaq 0x10(%rsp), %rsi
movq %rbx, %rdi
callq 0x7560
movq 0x10(%rsp), %rax
cmpq %rax, 0x18(%rsp)
je 0x2bdd
movq %rax, 0x18(%rsp)
leaq 0x8(%rsp), %rsi
andq $0x0, (%rsi)
leaq 0x10(%rsp), %rdi
callq 0x7d62
movsd 0x30(%rsp), %xmm0
callq 0x2060
leaq 0x8(%rsp), %rsi
movsd %xmm0, (%rsi)
leaq 0x10(%rsp), %rdi
callq 0x7d62
movsd 0x30(%rsp), %xmm0
callq 0x23e0
leaq 0x8(%rsp), %rsi
movsd %xmm0, (%rsi)
leaq 0x10(%rsp), %rdi
callq 0x7d62
leaq 0x10(%rsp), %rsi
movq %rbx, %rdi
callq 0x7560
leaq 0x10(%rsp), %rdi
callq 0x7b58
movq %rbx, %rax
addq $0x38, %rsp
popq %rbx
popq %r14
retq
jmp 0x2c60
jmp 0x2c60
jmp 0x2c60
jmp 0x2c60
jmp 0x2c60
jmp 0x2c60
jmp 0x2c60
jmp 0x2c60
jmp 0x2c60
movq %rax, %r14
leaq 0x10(%rsp), %rdi
callq 0x7b58
movq %rbx, %rdi
callq 0x78f0
movq %r14, %rdi
callq 0x23c0