LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O0/loversmile[P]sugarcrm/sugar_function.c
// Function: cleanSGContactItem
void cleanSGContactItem(struct __sg_contact_item *contact_item)
{
    if (contact_item) {
        SAFE_FREE(contact_item->title);
        SAFE_FREE(contact_item->first_name);
        SAFE_FREE(contact_item->last_name);
        SAFE_FREE(contact_item->phone_home);
        SAFE_FREE(contact_item->phone_work);
        SAFE_FREE(contact_item->phone_mobile);
        SAFE_FREE(contact_item->phone_other);
        SAFE_FREE(contact_item->phone_fax);
		SAFE_FREE(contact_item->description);
    }
    SAFE_FREE(contact_item);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
cmpq $0x0, -0x8(%rbp)
je 0x7106a
movq -0x8(%rbp), %rax
cmpq $0x0, (%rax)
je 0x70f48
movq -0x8(%rbp), %rax
movq (%rax), %rdi
callq 0x3030
movq -0x8(%rbp), %rax
movq $0x0, (%rax)
movq -0x8(%rbp), %rax
cmpq $0x0, 0x8(%rax)
je 0x70f6c
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rdi
callq 0x3030
movq -0x8(%rbp), %rax
movq $0x0, 0x8(%rax)
movq -0x8(%rbp), %rax
cmpq $0x0, 0x10(%rax)
je 0x70f90
movq -0x8(%rbp), %rax
movq 0x10(%rax), %rdi
callq 0x3030
movq -0x8(%rbp), %rax
movq $0x0, 0x10(%rax)
movq -0x8(%rbp), %rax
cmpq $0x0, 0x18(%rax)
je 0x70fb4
movq -0x8(%rbp), %rax
movq 0x18(%rax), %rdi
callq 0x3030
movq -0x8(%rbp), %rax
movq $0x0, 0x18(%rax)
movq -0x8(%rbp), %rax
cmpq $0x0, 0x28(%rax)
je 0x70fd8
movq -0x8(%rbp), %rax
movq 0x28(%rax), %rdi
callq 0x3030
movq -0x8(%rbp), %rax
movq $0x0, 0x28(%rax)
movq -0x8(%rbp), %rax
cmpq $0x0, 0x20(%rax)
je 0x70ffc
movq -0x8(%rbp), %rax
movq 0x20(%rax), %rdi
callq 0x3030
movq -0x8(%rbp), %rax
movq $0x0, 0x20(%rax)
movq -0x8(%rbp), %rax
cmpq $0x0, 0x30(%rax)
je 0x71020
movq -0x8(%rbp), %rax
movq 0x30(%rax), %rdi
callq 0x3030
movq -0x8(%rbp), %rax
movq $0x0, 0x30(%rax)
movq -0x8(%rbp), %rax
cmpq $0x0, 0x38(%rax)
je 0x71044
movq -0x8(%rbp), %rax
movq 0x38(%rax), %rdi
callq 0x3030
movq -0x8(%rbp), %rax
movq $0x0, 0x38(%rax)
movq -0x8(%rbp), %rax
cmpq $0x0, 0x40(%rax)
je 0x71068
movq -0x8(%rbp), %rax
movq 0x40(%rax), %rdi
callq 0x3030
movq -0x8(%rbp), %rax
movq $0x0, 0x40(%rax)
jmp 0x7106a
cmpq $0x0, -0x8(%rbp)
je 0x71082
movq -0x8(%rbp), %rdi
callq 0x3030
movq $0x0, -0x8(%rbp)
addq $0x10, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/loversmile[P]sugarcrm/sugar_function.c
// Function: initSGAccountItem
struct __sg_account_item *initSGAccountItem(struct __sg_account_item *account_item)
{
	account_item = (struct __sg_account_item*)malloc(sizeof(struct __sg_account_item));
	account_item->name = NULL;
	account_item->phone_office = NULL;
	account_item->phone_alternate = NULL;
	account_item->phone_fax = NULL;
	account_item->description = NULL;
	return account_item;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movl $0x28, %edi
callq 0x3290
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq $0x0, (%rax)
movq -0x8(%rbp), %rax
movq $0x0, 0x8(%rax)
movq -0x8(%rbp), %rax
movq $0x0, 0x10(%rax)
movq -0x8(%rbp), %rax
movq $0x0, 0x18(%rax)
movq -0x8(%rbp), %rax
movq $0x0, 0x20(%rax)
movq -0x8(%rbp), %rax
addq $0x10, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/loversmile[P]sugarcrm/sugar_function.c
// Function: cleanSGAccountItem
void cleanSGAccountItem(struct __sg_account_item *account_item)
{
	if (account_item) {
        SAFE_FREE(account_item->name);
        SAFE_FREE(account_item->phone_office);
        SAFE_FREE(account_item->phone_alternate);
        SAFE_FREE(account_item->phone_fax);
		SAFE_FREE(account_item->description);
    }
    SAFE_FREE(account_item);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
cmpq $0x0, -0x8(%rbp)
je 0x711ba
movq -0x8(%rbp), %rax
cmpq $0x0, (%rax)
je 0x71128
movq -0x8(%rbp), %rax
movq (%rax), %rdi
callq 0x3030
movq -0x8(%rbp), %rax
movq $0x0, (%rax)
movq -0x8(%rbp), %rax
cmpq $0x0, 0x8(%rax)
je 0x7114c
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rdi
callq 0x3030
movq -0x8(%rbp), %rax
movq $0x0, 0x8(%rax)
movq -0x8(%rbp), %rax
cmpq $0x0, 0x10(%rax)
je 0x71170
movq -0x8(%rbp), %rax
movq 0x10(%rax), %rdi
callq 0x3030
movq -0x8(%rbp), %rax
movq $0x0, 0x10(%rax)
movq -0x8(%rbp), %rax
cmpq $0x0, 0x18(%rax)
je 0x71194
movq -0x8(%rbp), %rax
movq 0x18(%rax), %rdi
callq 0x3030
movq -0x8(%rbp), %rax
movq $0x0, 0x18(%rax)
movq -0x8(%rbp), %rax
cmpq $0x0, 0x20(%rax)
je 0x711b8
movq -0x8(%rbp), %rax
movq 0x20(%rax), %rdi
callq 0x3030
movq -0x8(%rbp), %rax
movq $0x0, 0x20(%rax)
jmp 0x711ba
cmpq $0x0, -0x8(%rbp)
je 0x711d2
movq -0x8(%rbp), %rdi
callq 0x3030
movq $0x0, -0x8(%rbp)
addq $0x10, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/loversmile[P]sugarcrm/sugar_function.c
// Function: initSGLeadItem
struct __sg_lead_item *initSGLeadItem(struct __sg_lead_item *lead_item)
{
	lead_item = (struct __sg_lead_item*)malloc(sizeof(struct __sg_lead_item));
	lead_item->title = NULL;
	lead_item->first_name = NULL;
	lead_item->last_name = NULL;
	lead_item->phone_home = NULL;
	lead_item->phone_work = NULL;
	lead_item->phone_mobile = NULL;
	lead_item->phone_other = NULL;
	lead_item->phone_fax = NULL;
	lead_item->description = NULL;
	return lead_item;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movl $0x48, %edi
callq 0x3290
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq $0x0, (%rax)
movq -0x8(%rbp), %rax
movq $0x0, 0x8(%rax)
movq -0x8(%rbp), %rax
movq $0x0, 0x10(%rax)
movq -0x8(%rbp), %rax
movq $0x0, 0x18(%rax)
movq -0x8(%rbp), %rax
movq $0x0, 0x28(%rax)
movq -0x8(%rbp), %rax
movq $0x0, 0x20(%rax)
movq -0x8(%rbp), %rax
movq $0x0, 0x30(%rax)
movq -0x8(%rbp), %rax
movq $0x0, 0x38(%rax)
movq -0x8(%rbp), %rax
movq $0x0, 0x40(%rax)
movq -0x8(%rbp), %rax
addq $0x10, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/loversmile[P]sugarcrm/sugar_function.c
// Function: cleanSGLeadItem
void cleanSGLeadItem(struct __sg_lead_item *lead_item)
{
	if (lead_item) {
        SAFE_FREE(lead_item->title);
        SAFE_FREE(lead_item->first_name);
        SAFE_FREE(lead_item->last_name);
        SAFE_FREE(lead_item->phone_home);
        SAFE_FREE(lead_item->phone_work);
        SAFE_FREE(lead_item->phone_mobile);
        SAFE_FREE(lead_item->phone_other);
        SAFE_FREE(lead_item->phone_fax);
		SAFE_FREE(lead_item->description);
    }
    SAFE_FREE(lead_item);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
cmpq $0x0, -0x8(%rbp)
je 0x713ca
movq -0x8(%rbp), %rax
cmpq $0x0, (%rax)
je 0x712a8
movq -0x8(%rbp), %rax
movq (%rax), %rdi
callq 0x3030
movq -0x8(%rbp), %rax
movq $0x0, (%rax)
movq -0x8(%rbp), %rax
cmpq $0x0, 0x8(%rax)
je 0x712cc
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rdi
callq 0x3030
movq -0x8(%rbp), %rax
movq $0x0, 0x8(%rax)
movq -0x8(%rbp), %rax
cmpq $0x0, 0x10(%rax)
je 0x712f0
movq -0x8(%rbp), %rax
movq 0x10(%rax), %rdi
callq 0x3030
movq -0x8(%rbp), %rax
movq $0x0, 0x10(%rax)
movq -0x8(%rbp), %rax
cmpq $0x0, 0x18(%rax)
je 0x71314
movq -0x8(%rbp), %rax
movq 0x18(%rax), %rdi
callq 0x3030
movq -0x8(%rbp), %rax
movq $0x0, 0x18(%rax)
movq -0x8(%rbp), %rax
cmpq $0x0, 0x28(%rax)
je 0x71338
movq -0x8(%rbp), %rax
movq 0x28(%rax), %rdi
callq 0x3030
movq -0x8(%rbp), %rax
movq $0x0, 0x28(%rax)
movq -0x8(%rbp), %rax
cmpq $0x0, 0x20(%rax)
je 0x7135c
movq -0x8(%rbp), %rax
movq 0x20(%rax), %rdi
callq 0x3030
movq -0x8(%rbp), %rax
movq $0x0, 0x20(%rax)
movq -0x8(%rbp), %rax
cmpq $0x0, 0x30(%rax)
je 0x71380
movq -0x8(%rbp), %rax
movq 0x30(%rax), %rdi
callq 0x3030
movq -0x8(%rbp), %rax
movq $0x0, 0x30(%rax)
movq -0x8(%rbp), %rax
cmpq $0x0, 0x38(%rax)
je 0x713a4
movq -0x8(%rbp), %rax
movq 0x38(%rax), %rdi
callq 0x3030
movq -0x8(%rbp), %rax
movq $0x0, 0x38(%rax)
movq -0x8(%rbp), %rax
cmpq $0x0, 0x40(%rax)
je 0x713c8
movq -0x8(%rbp), %rax
movq 0x40(%rax), %rdi
callq 0x3030
movq -0x8(%rbp), %rax
movq $0x0, 0x40(%rax)
jmp 0x713ca
cmpq $0x0, -0x8(%rbp)
je 0x713e2
movq -0x8(%rbp), %rdi
callq 0x3030
movq $0x0, -0x8(%rbp)
addq $0x10, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/loversmile[P]sugarcrm/sugar_function.c
// Function: initSGCallsItem
struct __sg_calls_item *initSGCallsItem(struct __sg_calls_item *calls_item)
{
	calls_item = (struct __sg_calls_item *)malloc(sizeof(struct __sg_calls_item));
	calls_item->call_id = NULL;
	calls_item->call_item = initSGCallItem(calls_item->call_item);
	calls_item->next = NULL;
	return calls_item;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movl $0x18, %edi
callq 0x3290
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq $0x0, (%rax)
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rdi
callq 0x70e50
movq %rax, %rcx
movq -0x8(%rbp), %rax
movq %rcx, 0x8(%rax)
movq -0x8(%rbp), %rax
movq $0x0, 0x10(%rax)
movq -0x8(%rbp), %rax
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/loversmile[P]sugarcrm/sugar_function.c
// Function: cleanSGCallsItem
void cleanSGCallsItem(struct __sg_calls_item *calls_item)
{
	struct __sg_calls_item *tmp_node = calls_item;
	while (calls_item)
	{
		if (calls_item->next)
		{
			tmp_node = calls_item->next;
			SAFE_FREE(calls_item->call_id);
			cleanSGCallItem(calls_item->call_item);
			SAFE_FREE(calls_item);
			calls_item = tmp_node;
		}
		else
		{
			SAFE_FREE(calls_item->call_id);
			cleanSGCallItem(calls_item->call_item);
			free(calls_item);
			calls_item = NULL;
		}
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x10(%rbp)
cmpq $0x0, -0x8(%rbp)
je 0x7154a
movq -0x8(%rbp), %rax
cmpq $0x0, 0x10(%rax)
je 0x71506
movq -0x8(%rbp), %rax
movq 0x10(%rax), %rax
movq %rax, -0x10(%rbp)
movq -0x8(%rbp), %rax
cmpq $0x0, (%rax)
je 0x714d7
movq -0x8(%rbp), %rax
movq (%rax), %rdi
callq 0x3030
movq -0x8(%rbp), %rax
movq $0x0, (%rax)
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rdi
callq 0x70c40
cmpq $0x0, -0x8(%rbp)
je 0x714fc
movq -0x8(%rbp), %rdi
callq 0x3030
movq $0x0, -0x8(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x8(%rbp)
jmp 0x71545
movq -0x8(%rbp), %rax
cmpq $0x0, (%rax)
je 0x71527
movq -0x8(%rbp), %rax
movq (%rax), %rdi
callq 0x3030
movq -0x8(%rbp), %rax
movq $0x0, (%rax)
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rdi
callq 0x70c40
movq -0x8(%rbp), %rdi
callq 0x3030
movq $0x0, -0x8(%rbp)
jmp 0x71494
addq $0x10, %rsp
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O0/loversmile[P]sugarcrm/sugar_function.c
// Function: cleanSGContactsID
void cleanSGContactsID(struct __sg_contacts_id *contacts_id)
{
	struct __sg_contacts_id *tmp_node = contacts_id;
	while (contacts_id)
	{
		if (contacts_id->next)
		{
			tmp_node = contacts_id->next;
			SAFE_FREE(contacts_id->id);
			SAFE_FREE(contacts_id);
			contacts_id = tmp_node;
		}
		else
		{
			SAFE_FREE(contacts_id->id);
			free(contacts_id);
			contacts_id = NULL;
		}
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x10(%rbp)
cmpq $0x0, -0x8(%rbp)
je 0x71640
movq -0x8(%rbp), %rax
cmpq $0x0, 0x8(%rax)
je 0x71609
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rax
movq %rax, -0x10(%rbp)
movq -0x8(%rbp), %rax
cmpq $0x0, (%rax)
je 0x715e7
movq -0x8(%rbp), %rax
movq (%rax), %rdi
callq 0x3030
movq -0x8(%rbp), %rax
movq $0x0, (%rax)
cmpq $0x0, -0x8(%rbp)
je 0x715ff
movq -0x8(%rbp), %rdi
callq 0x3030
movq $0x0, -0x8(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x8(%rbp)
jmp 0x7163b
movq -0x8(%rbp), %rax
cmpq $0x0, (%rax)
je 0x7162a
movq -0x8(%rbp), %rax
movq (%rax), %rdi
callq 0x3030
movq -0x8(%rbp), %rax
movq $0x0, (%rax)
movq -0x8(%rbp), %rdi
callq 0x3030
movq $0x0, -0x8(%rbp)
jmp 0x715a4
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/loversmile[P]sugarcrm/sugar_function.c
// Function: cleanSGLinksID
void cleanSGLinksID(struct __sg_links_id *links_id)
{
	struct __sg_links_id *tmp_node = links_id;
	while (links_id)
	{
		if (links_id->next)
		{
			tmp_node = links_id->next;
			SAFE_FREE(links_id->id);
			SAFE_FREE(links_id);
			links_id = tmp_node;
		}
		else
		{
			SAFE_FREE(links_id->id);
			free(links_id);
			links_id = NULL;
		}
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x10(%rbp)
cmpq $0x0, -0x8(%rbp)
je 0x71740
movq -0x8(%rbp), %rax
cmpq $0x0, 0x8(%rax)
je 0x71709
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rax
movq %rax, -0x10(%rbp)
movq -0x8(%rbp), %rax
cmpq $0x0, (%rax)
je 0x716e7
movq -0x8(%rbp), %rax
movq (%rax), %rdi
callq 0x3030
movq -0x8(%rbp), %rax
movq $0x0, (%rax)
cmpq $0x0, -0x8(%rbp)
je 0x716ff
movq -0x8(%rbp), %rdi
callq 0x3030
movq $0x0, -0x8(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x8(%rbp)
jmp 0x7173b
movq -0x8(%rbp), %rax
cmpq $0x0, (%rax)
je 0x7172a
movq -0x8(%rbp), %rax
movq (%rax), %rdi
callq 0x3030
movq -0x8(%rbp), %rax
movq $0x0, (%rax)
movq -0x8(%rbp), %rdi
callq 0x3030
movq $0x0, -0x8(%rbp)
jmp 0x716a4
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/loversmile[P]sugarcrm/sugar_function.c
// Function: cleanSGReturnCallsID
void cleanSGReturnCallsID(struct __sg_return_calls_id *return_calls_id)
{
	struct __sg_return_calls_id *tmp_node = return_calls_id;
	while (return_calls_id)
	{
		if (return_calls_id->next)
		{
			tmp_node = return_calls_id->next;
			SAFE_FREE(return_calls_id->return_call_id);
			SAFE_FREE(return_calls_id);
			return_calls_id = tmp_node;
		}
		else
		{
			SAFE_FREE(return_calls_id->return_call_id);
			free(return_calls_id);
			return_calls_id = NULL;
		}
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x10(%rbp)
cmpq $0x0, -0x8(%rbp)
je 0x71840
movq -0x8(%rbp), %rax
cmpq $0x0, 0x8(%rax)
je 0x71809
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rax
movq %rax, -0x10(%rbp)
movq -0x8(%rbp), %rax
cmpq $0x0, (%rax)
je 0x717e7
movq -0x8(%rbp), %rax
movq (%rax), %rdi
callq 0x3030
movq -0x8(%rbp), %rax
movq $0x0, (%rax)
cmpq $0x0, -0x8(%rbp)
je 0x717ff
movq -0x8(%rbp), %rdi
callq 0x3030
movq $0x0, -0x8(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x8(%rbp)
jmp 0x7183b
movq -0x8(%rbp), %rax
cmpq $0x0, (%rax)
je 0x7182a
movq -0x8(%rbp), %rax
movq (%rax), %rdi
callq 0x3030
movq -0x8(%rbp), %rax
movq $0x0, (%rax)
movq -0x8(%rbp), %rdi
callq 0x3030
movq $0x0, -0x8(%rbp)
jmp 0x717a4
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/loversmile[P]sugarcrm/sugar_function.c
// Function: sugarLogout
int sugarLogout(struct soap *soap, const char *soap_endpoint, char *session, struct ns1__logoutResponse *_param_2)
{
    char soap_action[128] = {0};
    memset(soap_action, 0, sizeof(soap_action));
    snprintf(soap_action, sizeof(soap_action), "%s/logout", soap_endpoint);
    return soap_call_ns1__logout(soap, soap_endpoint, soap_action, session, _param_2); 
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0xa0, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq %rcx, -0x20(%rbp)
leaq -0xa0(%rbp), %rdi
xorl %esi, %esi
movl $0x80, %edx
callq 0x3190
leaq -0xa0(%rbp), %rdi
xorl %esi, %esi
movl $0x80, %edx
callq 0x3190
leaq -0xa0(%rbp), %rdi
movq -0x10(%rbp), %rcx
movl $0x80, %esi
leaq 0xa8a3(%rip), %rdx      # 0x7c34b
movb $0x0, %al
callq 0x3150
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
leaq -0xa0(%rbp), %rdx
movq -0x18(%rbp), %rcx
movq -0x20(%rbp), %r8
callq 0x49e90
addq $0xa0, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/loversmile[P]sugarcrm/sugar_function.c
// Function: setRelationship
int setRelationship(struct soap *soap, const char *soap_endpoint, const char *soap_action, char *session,  
     char *module_USCOREname, char *module_USCOREid, char *link_USCOREfield_USCOREname, struct select_USCOREfields *related_USCOREids, struct               
     name_USCOREvalue_USCORElist *name_USCOREvalue_USCORElist, int delete_, struct ns1__set_USCORErelationshipResponse *_param_6)
{
    printf("module_USCOREid = %s\n", module_USCOREid);
    return soap_call_ns1__set_USCORErelationship(soap, soap_endpoint, soap_action,session, module_USCOREname,
                        module_USCOREid, link_USCOREfield_USCOREname, related_USCOREids, name_USCOREvalue_USCORElist, 
                        delete_,  _param_6);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
subq $0x60, %rsp
movq 0x30(%rbp), %rax
movl 0x28(%rbp), %eax
movq 0x20(%rbp), %rax
movq 0x18(%rbp), %rax
movq 0x10(%rbp), %rax
movq %rdi, -0x18(%rbp)
movq %rsi, -0x20(%rbp)
movq %rdx, -0x28(%rbp)
movq %rcx, -0x30(%rbp)
movq %r8, -0x38(%rbp)
movq %r9, -0x40(%rbp)
movq -0x40(%rbp), %rsi
leaq 0xa524(%rip), %rdi      # 0x7c355
movb $0x0, %al
callq 0x3140
movq -0x18(%rbp), %rdi
movq -0x20(%rbp), %rsi
movq -0x28(%rbp), %rdx
movq -0x30(%rbp), %rcx
movq -0x38(%rbp), %r8
movq -0x40(%rbp), %r9
movq 0x10(%rbp), %r14
movq 0x18(%rbp), %rbx
movq 0x20(%rbp), %r11
movl 0x28(%rbp), %r10d
movq 0x30(%rbp), %rax
movq %r14, (%rsp)
movq %rbx, 0x8(%rsp)
movq %r11, 0x10(%rsp)
movl %r10d, 0x18(%rsp)
movq %rax, 0x20(%rsp)
callq 0x4ab10
addq $0x60, %rsp
popq %rbx
popq %r14
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/loversmile[P]sugarcrm/sugar_function.c
// Function: SGCRMLogin
int SGCRMLogin(SGServerInfo *server_info, char *username, char *password, SGLoginReturn *login_return)
{
    int ret = -1;
    struct ns1__loginResponse *_param_1;
    _param_1 = (struct ns1__loginResponse*)soap_malloc(server_info->soap, sizeof(struct ns1__entry_USCOREvalue));
    ret = sugarLogin(server_info->soap, server_info->soap_endpoint, username, password, _param_1);
    if (ret == SOAP_OK) {
        printf("CRMLogin Success!\n");
        if (login_return) {
            login_return->session_id = strdup(_param_1->return_->id);
        }

        int value_size = _param_1->return_->name_USCOREvalue_USCORElist->__size;
        int i = 0;
        for (i = 0; i < value_size; i++){
            if (!strcmp(_param_1->return_->name_USCOREvalue_USCORElist->__ptr[i]->name, "user_id") && login_return) {
                login_return->user_id = strdup(_param_1->return_->name_USCOREvalue_USCORElist->__ptr[i]->value);
            }
        }
    } else {
        soap_print_fault(server_info->soap, stderr);
    }
    return ret;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq %rcx, -0x20(%rbp)
movl $0xffffffff, -0x24(%rbp) # imm = 0xFFFFFFFF
movq -0x8(%rbp), %rax
movq (%rax), %rdi
movl $0x18, %esi
callq 0x518f0
movq %rax, -0x30(%rbp)
movq -0x8(%rbp), %rax
movq (%rax), %rdi
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rsi
movq -0x10(%rbp), %rdx
movq -0x18(%rbp), %rcx
movq -0x30(%rbp), %r8
callq 0x71850
movl %eax, -0x24(%rbp)
cmpl $0x0, -0x24(%rbp)
jne 0x77160
leaq 0x558b(%rip), %rdi      # 0x7c633
movb $0x0, %al
callq 0x3140
cmpq $0x0, -0x20(%rbp)
je 0x770cf
movq -0x30(%rbp), %rax
movq (%rax), %rax
movq (%rax), %rdi
callq 0x33a0
movq %rax, %rcx
movq -0x20(%rbp), %rax
movq %rcx, (%rax)
movq -0x30(%rbp), %rax
movq (%rax), %rax
movq 0x10(%rax), %rax
movl 0x8(%rax), %eax
movl %eax, -0x34(%rbp)
movl $0x0, -0x38(%rbp)
movl $0x0, -0x38(%rbp)
movl -0x38(%rbp), %eax
cmpl -0x34(%rbp), %eax
jge 0x7715e
movq -0x30(%rbp), %rax
movq (%rax), %rax
movq 0x10(%rax), %rax
movq (%rax), %rax
movslq -0x38(%rbp), %rcx
movq (%rax,%rcx,8), %rax
movq (%rax), %rdi
leaq 0x2486(%rip), %rsi      # 0x7959c
callq 0x3210
cmpl $0x0, %eax
jne 0x77151
cmpq $0x0, -0x20(%rbp)
je 0x77151
movq -0x30(%rbp), %rax
movq (%rax), %rax
movq 0x10(%rax), %rax
movq (%rax), %rax
movslq -0x38(%rbp), %rcx
movq (%rax,%rcx,8), %rax
movq 0x8(%rax), %rdi
callq 0x33a0
movq %rax, %rcx
movq -0x20(%rbp), %rax
movq %rcx, 0x8(%rax)
jmp 0x77153
movl -0x38(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x38(%rbp)
jmp 0x770ee
jmp 0x77176
movq -0x8(%rbp), %rax
movq (%rax), %rdi
movq 0x17e8a(%rip), %rax     # 0x8eff8
movq (%rax), %rsi
callq 0x6e2c0
movl -0x24(%rbp), %eax
addq $0x40, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/loversmile[P]sugarcrm/sugar_function.c
// Function: searchAccounts
int searchAccounts(SGServerInfo *server_info, char *session, char *search_string, SGSearchResult *search_result)
{
    int ret = -1;
    ret = searchModule(server_info->soap, server_info->soap_endpoint, session, CRM_MODULE_ACCOUNTS, search_string,
                CRM_TYPE_PHONE, search_result);
	return ret;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq %rcx, -0x20(%rbp)
movl $0xffffffff, -0x24(%rbp) # imm = 0xFFFFFFFF
movq -0x8(%rbp), %rax
movq (%rax), %rdi
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rsi
movq -0x10(%rbp), %rdx
movq -0x18(%rbp), %r8
movq -0x20(%rbp), %rax
xorl %ecx, %ecx
movl $0x1, %r9d
movq %rax, (%rsp)
callq 0x71f70
movl %eax, -0x24(%rbp)
movl -0x24(%rbp), %eax
addq $0x30, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/loversmile[P]sugarcrm/sugar_function.c
// Function: searchContacts
int searchContacts(SGServerInfo *server_info, char *session, char *search_string, SGSearchResult *search_result)
{
    int ret = -1;
    ret = searchModule(server_info->soap, server_info->soap_endpoint, session, CRM_MODULE_CONTACTS, search_string,
                CRM_TYPE_PHONE, search_result);
	return ret;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq %rcx, -0x20(%rbp)
movl $0xffffffff, -0x24(%rbp) # imm = 0xFFFFFFFF
movq -0x8(%rbp), %rax
movq (%rax), %rdi
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rsi
movq -0x10(%rbp), %rdx
movq -0x18(%rbp), %r8
movq -0x20(%rbp), %rax
movl $0x1, %r9d
movl %r9d, %ecx
movq %rax, (%rsp)
callq 0x71f70
movl %eax, -0x24(%rbp)
movl -0x24(%rbp), %eax
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/loversmile[P]sugarcrm/sugar_function.c
// Function: searchCalls
int searchCalls(SGServerInfo *server_info, char *session, char *search_string, SGSearchResult *search_result)
{
    int ret = -1;
    ret = searchModule(server_info->soap, server_info->soap_endpoint, session, CRM_MODULE_CALLS, search_string,
                CRM_TYPE_PHONE, search_result);
	return ret;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq %rcx, -0x20(%rbp)
movl $0xffffffff, -0x24(%rbp) # imm = 0xFFFFFFFF
movq -0x8(%rbp), %rax
movq (%rax), %rdi
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rsi
movq -0x10(%rbp), %rdx
movq -0x18(%rbp), %r8
movq -0x20(%rbp), %rax
movl $0x3, %ecx
movl $0x1, %r9d
movq %rax, (%rsp)
callq 0x71f70
movl %eax, -0x24(%rbp)
movl -0x24(%rbp), %eax
addq $0x30, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/loversmile[P]sugarcrm/sugar_function.c
// Function: contactsLinkCalls
int contactsLinkCalls(SGServerInfo *server_info, char *session, SGContactsID *contacts_id, SGLinksID *links_id, int num, SGLinkReturn *link_return)
{
	int ret = -1;
	ret = setContactRelations(server_info->soap, server_info->soap_endpoint, session, contacts_id, 
							"calls", links_id, num, link_return);
	return ret;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq %rcx, -0x20(%rbp)
movl %r8d, -0x24(%rbp)
movq %r9, -0x30(%rbp)
movl $0xffffffff, -0x34(%rbp) # imm = 0xFFFFFFFF
movq -0x8(%rbp), %rax
movq (%rax), %rdi
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rsi
movq -0x10(%rbp), %rdx
movq -0x18(%rbp), %rcx
movq -0x20(%rbp), %r9
movl -0x24(%rbp), %r10d
movq -0x30(%rbp), %rax
leaq 0x4f0a(%rip), %r8       # 0x7c65b
movl %r10d, (%rsp)
movq %rax, 0x8(%rsp)
callq 0x74e80
movl %eax, -0x34(%rbp)
movl -0x34(%rbp), %eax
addq $0x50, %rsp
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O0/mjosaarinen[P]brutus/crypto_aead/lunarkeyakv2/reference/KeccakP-1600-reference.c
// Function: KeccakP1600_AddBytes
void KeccakP1600_AddBytes(void *state, const unsigned char *data, unsigned int offset, unsigned int length)
{
    unsigned int i;

    assert(offset < 200);
    assert(offset+length <= 200);
    for(i=0; i<length; i++)
        ((unsigned char *)state)[offset+i] ^= data[i];
}

// Assembly:
subq $0x28, %rsp
movq %rdi, 0x20(%rsp)
movq %rsi, 0x18(%rsp)
movl %edx, 0x14(%rsp)
movl %ecx, 0x10(%rsp)
cmpl $0xc8, 0x14(%rsp)
jae 0x58b2
jmp 0x58d1
leaq 0x10747(%rip), %rdi     # 0x16000
leaq 0x1074d(%rip), %rsi     # 0x1600d
movl $0x9a, %edx
leaq 0x107bb(%rip), %rcx     # 0x16087
callq 0x5190
movl 0x14(%rsp), %eax
addl 0x10(%rsp), %eax
cmpl $0xc8, %eax
ja 0x58e2
jmp 0x5901
leaq 0x107f3(%rip), %rdi     # 0x160dc
leaq 0x1071d(%rip), %rsi     # 0x1600d
movl $0x9b, %edx
leaq 0x1078b(%rip), %rcx     # 0x16087
callq 0x5190
movl $0x0, 0xc(%rsp)
movl 0xc(%rsp), %eax
cmpl 0x10(%rsp), %eax
jae 0x5945
movq 0x18(%rsp), %rax
movl 0xc(%rsp), %ecx
movzbl (%rax,%rcx), %esi
movq 0x20(%rsp), %rax
movl 0x14(%rsp), %ecx
addl 0xc(%rsp), %ecx
movl %ecx, %ecx
movzbl (%rax,%rcx), %edx
xorl %esi, %edx
movb %dl, (%rax,%rcx)
movl 0xc(%rsp), %eax
addl $0x1, %eax
movl %eax, 0xc(%rsp)
jmp 0x5909
addq $0x28, %rsp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/mjosaarinen[P]brutus/crypto_aead/lunarkeyakv2/reference/KeccakP-1600-reference.c
// Function: KeccakP1600_ExtractAndAddBytes
void KeccakP1600_ExtractAndAddBytes(const void *state, const unsigned char *input, unsigned char *output, unsigned int offset, unsigned int length)
{
    unsigned int i;

    assert(offset < 200);
    assert(offset+length <= 200);
    for(i=0; i<length; i++)
        output[i] = input[i] ^ ((unsigned char *)state)[offset+i];
}

// Assembly:
subq $0x28, %rsp
movq %rdi, 0x20(%rsp)
movq %rsi, 0x18(%rsp)
movq %rdx, 0x10(%rsp)
movl %ecx, 0xc(%rsp)
movl %r8d, 0x8(%rsp)
cmpl $0xc8, 0xc(%rsp)
jae 0x6308
jmp 0x6327
leaq 0xfcf1(%rip), %rdi      # 0x16000
leaq 0xfcf7(%rip), %rsi      # 0x1600d
movl $0x16e, %edx            # imm = 0x16E
leaq 0xfecf(%rip), %rcx      # 0x161f1
callq 0x5190
movl 0xc(%rsp), %eax
addl 0x8(%rsp), %eax
cmpl $0xc8, %eax
ja 0x6338
jmp 0x6357
leaq 0xfd9d(%rip), %rdi      # 0x160dc
leaq 0xfcc7(%rip), %rsi      # 0x1600d
movl $0x16f, %edx            # imm = 0x16F
leaq 0xfe9f(%rip), %rcx      # 0x161f1
callq 0x5190
movl $0x0, 0x4(%rsp)
movl 0x4(%rsp), %eax
cmpl 0x8(%rsp), %eax
jae 0x63a6
movq 0x18(%rsp), %rax
movl 0x4(%rsp), %ecx
movzbl (%rax,%rcx), %eax
movq 0x20(%rsp), %rcx
movl 0xc(%rsp), %edx
addl 0x4(%rsp), %edx
movl %edx, %edx
movzbl (%rcx,%rdx), %ecx
xorl %ecx, %eax
movb %al, %dl
movq 0x10(%rsp), %rax
movl 0x4(%rsp), %ecx
movb %dl, (%rax,%rcx)
movl 0x4(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x4(%rsp)
jmp 0x635f
addq $0x28, %rsp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/mjosaarinen[P]brutus/crypto_aead/lunarkeyakv2/reference/KeccakP-1600-reference.c
// Function: KeccakP1600_DisplayRoundConstants
void KeccakP1600_DisplayRoundConstants(FILE *f)
{
    unsigned int i;

    for(i=0; i<maxNrRounds; i++) {
        fprintf(f, "RC[%02i][0][0] = ", i);
        fprintf(f, "%08X", (unsigned int)(KeccakRoundConstants[i] >> 32));
        fprintf(f, "%08X", (unsigned int)(KeccakRoundConstants[i] & 0xFFFFFFFFULL));
        fprintf(f, "\n");
    }
    fprintf(f, "\n");
}

// Assembly:
subq $0x18, %rsp
movq %rdi, 0x10(%rsp)
movl $0x0, 0xc(%rsp)
cmpl $0x18, 0xc(%rsp)
jae 0x6460
movq 0x10(%rsp), %rdi
movl 0xc(%rsp), %edx
leaq 0xfe8b(%rip), %rsi      # 0x16267
movb $0x0, %al
callq 0x56b0
movq 0x10(%rsp), %rdi
movl 0xc(%rsp), %eax
movl %eax, %ecx
leaq 0xfeab(%rip), %rax      # 0x162a0
movq (%rax,%rcx,8), %rax
shrq $0x20, %rax
movl %eax, %edx
leaq 0x108f2(%rip), %rsi     # 0x16cf8
movb $0x0, %al
callq 0x56b0
movq 0x10(%rsp), %rdi
movl 0xc(%rsp), %eax
movl %eax, %edx
leaq 0xfe81(%rip), %rcx      # 0x162a0
movabsq $0xffffffff, %rax       # imm = 0xFFFFFFFF
andq (%rcx,%rdx,8), %rax
movl %eax, %edx
leaq 0x108c2(%rip), %rsi     # 0x16cf8
movb $0x0, %al
callq 0x56b0
movq 0x10(%rsp), %rdi
leaq 0x108ca(%rip), %rsi     # 0x16d13
movb $0x0, %al
callq 0x56b0
movl 0xc(%rsp), %eax
addl $0x1, %eax
movl %eax, 0xc(%rsp)
jmp 0x63c1
movq 0x10(%rsp), %rdi
leaq 0x108a7(%rip), %rsi     # 0x16d13
movb $0x0, %al
callq 0x56b0
addq $0x18, %rsp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/mflatt[P]gc-demo/gc/mark_and_sweep.c
// Function: allocate
struct node *allocate()
{
  struct gc_node *nh;
  
  if (!free_list) {
    collect_garbage();
    if (!free_list)
      get_more_memory();
  }

  nh = free_list;
  free_list = free_list->next_free;

  return &nh->n;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
cmpq $0x0, 0x2b20(%rip)      # 0x4060
jne 0x155a
movb $0x0, %al
callq 0x1520
cmpq $0x0, 0x2b0f(%rip)      # 0x4060
jne 0x1558
callq 0x1640
jmp 0x155a
movq 0x2aff(%rip), %rax      # 0x4060
movq %rax, -0x8(%rbp)
movq 0x2af4(%rip), %rax      # 0x4060
movq (%rax), %rax
movq %rax, 0x2aea(%rip)      # 0x4060
movq -0x8(%rbp), %rax
addq $0x8, %rax
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/mflatt[P]gc-demo/gc/mark_and_sweep.c
// Function: mark_and_sweep_from_roots
void mark_and_sweep_from_roots()
{
  // printf("Collect garbage\n");

  reset_all_marks();

  /* mark (i.e., find all referenced) */
  for (int i = 0; i < num_roots; i++)
    mark(*(root_addrs[i]));

  /* sweep (i.e., add unmarked to the free list) */
  sweep();
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
callq 0x1710
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
cmpl 0x2abb(%rip), %eax      # 0x4068
jge 0x15d1
movslq -0x4(%rbp), %rcx
leaq 0x2ac6(%rip), %rax      # 0x4080
movq (%rax,%rcx,8), %rax
movq (%rax), %rdi
callq 0x15e0
movl -0x4(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x4(%rbp)
jmp 0x15a4
callq 0x1770
addq $0x10, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/mflatt[P]gc-demo/gc/mark_and_sweep.c
// Function: mark
static void mark(struct node *n)
{
  if (n != NULL) {
    struct gc_node *nh;
    nh = NODE_TO_GC(n);
    
    if (!nh->marked) {
      nh->marked = 1;

      /* Recur to keep referenced objects live: */
      mark(nh->n.left);
      mark(nh->n.right);
    }
  }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
cmpq $0x0, -0x8(%rbp)
je 0x162e
movq -0x8(%rbp), %rax
addq $-0x8, %rax
movq %rax, -0x10(%rbp)
movq -0x10(%rbp), %rax
cmpl $0x0, (%rax)
jne 0x162c
movq -0x10(%rbp), %rax
movl $0x1, (%rax)
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rdi
callq 0x15e0
movq -0x10(%rbp), %rax
movq 0x10(%rax), %rdi
callq 0x15e0
jmp 0x162e
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/mflatt[P]gc-demo/gc/mark_and_sweep.c
// Function: get_more_memory
static void get_more_memory()
{
  // printf("Allocate more\n");

  struct gc_chunk *c = raw_malloc(sizeof(struct gc_chunk));
  c->next = chunks;
  chunks = c;
  num_chunks++;

  c->mem = raw_malloc(NODES_PER_CHUNK * sizeof(struct gc_node));

  /* Add everything in the new chunk to the free list: */
  for (int i = 0; i < NODES_PER_CHUNK; i++) {
    struct gc_node *nh = c->mem + i;
    nh->next_free = free_list;
    free_list = nh;
  }

  num_chunked_nodes += NODES_PER_CHUNK;
  num_free_nodes += NODES_PER_CHUNK;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movl $0x18, %edi
callq 0x1490
movq %rax, -0x8(%rbp)
movq 0x2a13(%rip), %rcx      # 0x4070
movq -0x8(%rbp), %rax
movq %rcx, (%rax)
movq -0x8(%rbp), %rax
movq %rax, 0x2a01(%rip)      # 0x4070
movl 0x2e0b(%rip), %eax      # 0x4480
addl $0x1, %eax
movl %eax, 0x2e02(%rip)      # 0x4480
movl $0xc0000, %edi          # imm = 0xC0000
callq 0x1490
movq %rax, %rcx
movq -0x8(%rbp), %rax
movq %rcx, 0x8(%rax)
movl $0x0, -0xc(%rbp)
cmpl $0x8000, -0xc(%rbp)     # imm = 0x8000
jge 0x16de
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rax
movslq -0xc(%rbp), %rcx
imulq $0x18, %rcx, %rcx
addq %rcx, %rax
movq %rax, -0x18(%rbp)
movq 0x299f(%rip), %rcx      # 0x4060
movq -0x18(%rbp), %rax
movq %rcx, (%rax)
movq -0x18(%rbp), %rax
movq %rax, 0x298d(%rip)      # 0x4060
movl -0xc(%rbp), %eax
addl $0x1, %eax
movl %eax, -0xc(%rbp)
jmp 0x169a
movl 0x2da0(%rip), %eax      # 0x4484
addl $0x8000, %eax           # imm = 0x8000
movl %eax, 0x2d95(%rip)      # 0x4484
movl 0x2d93(%rip), %eax      # 0x4488
addl $0x8000, %eax           # imm = 0x8000
movl %eax, 0x2d88(%rip)      # 0x4488
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/mflatt[P]gc-demo/gc/mark_and_sweep.c
// Function: sweep
static void sweep()
{
  free_list = NULL;
  for (struct gc_chunk *c = chunks; c; c = c->next) {
    c->num_marked_nodes = 0;
    for (int i = 0; i < NODES_PER_CHUNK; i++) {
      if (!c->mem[i].marked) {
        c->mem[i].next_free = free_list;
        free_list = &c->mem[i];
        num_free_nodes++;
      } else
        c->num_marked_nodes++;
    }
  }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq $0x0, 0x28e1(%rip) # 0x4060
movq 0x28ea(%rip), %rax      # 0x4070
movq %rax, -0x8(%rbp)
cmpq $0x0, -0x8(%rbp)
je 0x183f
movq -0x8(%rbp), %rax
movl $0x0, 0x10(%rax)
movl $0x0, -0xc(%rbp)
cmpl $0x8000, -0xc(%rbp)     # imm = 0x8000
jge 0x182d
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rax
movslq -0xc(%rbp), %rcx
imulq $0x18, %rcx, %rcx
addq %rcx, %rax
cmpl $0x0, (%rax)
jne 0x1810
movq 0x2891(%rip), %rcx      # 0x4060
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rax
movslq -0xc(%rbp), %rdx
imulq $0x18, %rdx, %rdx
addq %rdx, %rax
movq %rcx, (%rax)
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rax
movslq -0xc(%rbp), %rcx
imulq $0x18, %rcx, %rcx
addq %rcx, %rax
movq %rax, 0x2861(%rip)      # 0x4060
movl 0x2c83(%rip), %eax      # 0x4488
addl $0x1, %eax
movl %eax, 0x2c7a(%rip)      # 0x4488
jmp 0x181d
movq -0x8(%rbp), %rax
movl 0x10(%rax), %ecx
addl $0x1, %ecx
movl %ecx, 0x10(%rax)
jmp 0x181f
movl -0xc(%rbp), %eax
addl $0x1, %eax
movl %eax, -0xc(%rbp)
jmp 0x17a7
jmp 0x182f
movq -0x8(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x8(%rbp)
jmp 0x178a
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O0/ohkimur[P]the-c-programming-language-2nd-edition-solutions/chapter_1/exercise_1_17/line_80.c
// Function: main
int main(void)
{
  int len;
  char line[MAXLINE];

  while ((len = get_line(line, MAXLINE)) > 0)
  {
    if (len > LIMIT)
    {
      printf("%s", line);
    }
  }

  return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x3f0, %rsp            # imm = 0x3F0
movl $0x0, -0x4(%rbp)
leaq -0x3f0(%rbp), %rdi
movl $0x3e8, %esi            # imm = 0x3E8
callq 0x11b0
movl %eax, -0x8(%rbp)
cmpl $0x0, %eax
jle 0x1198
cmpl $0x50, -0x8(%rbp)
jle 0x1196
leaq -0x3f0(%rbp), %rsi
leaq 0xe75(%rip), %rdi       # 0x2004
movb $0x0, %al
callq 0x1030
jmp 0x1162
xorl %eax, %eax
addq $0x3f0, %rsp            # imm = 0x3F0
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/ohkimur[P]the-c-programming-language-2nd-edition-solutions/chapter_1/exercise_1_17/line_80.c
// Function: get_line
int get_line(char line[], int max_line_len)
{
  int c, i;

  for (i = 0; i < max_line_len - 1 && (c = getchar()) != EOF && c != '\n'; ++i)
  {
    line[i] = c;
  }

  if (c == '\n')
  {
    line[i] = c;
    ++i;
  }

  line[i] = '\0';

  return i;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movl $0x0, -0x14(%rbp)
movl -0x14(%rbp), %ecx
movl -0xc(%rbp), %edx
subl $0x1, %edx
xorl %eax, %eax
cmpl %edx, %ecx
movb %al, -0x15(%rbp)
jge 0x11f6
callq 0x1040
movl %eax, %ecx
movl %ecx, -0x10(%rbp)
xorl %eax, %eax
cmpl $-0x1, %ecx
movb %al, -0x15(%rbp)
je 0x11f6
cmpl $0xa, -0x10(%rbp)
setne %al
movb %al, -0x15(%rbp)
movb -0x15(%rbp), %al
testb $0x1, %al
jne 0x11ff
jmp 0x121a
movl -0x10(%rbp), %eax
movb %al, %dl
movq -0x8(%rbp), %rax
movslq -0x14(%rbp), %rcx
movb %dl, (%rax,%rcx)
movl -0x14(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x14(%rbp)
jmp 0x11c6
cmpl $0xa, -0x10(%rbp)
jne 0x1239
movl -0x10(%rbp), %eax
movb %al, %dl
movq -0x8(%rbp), %rax
movslq -0x14(%rbp), %rcx
movb %dl, (%rax,%rcx)
movl -0x14(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x14(%rbp)
movq -0x8(%rbp), %rax
movslq -0x14(%rbp), %rcx
movb $0x0, (%rax,%rcx)
movl -0x14(%rbp), %eax
addq $0x20, %rsp
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O0/openshmem-org[P]openshmem-examples/c++/version.cxx
// Function: main
int
main()
{
    struct utsname u;
    uname(&u);

    shmem_init();

    const int me = shmem_my_pe();
    const int npes = shmem_n_pes();

    int maj, min;
    shmem_info_get_version(&maj, &min);

    char verstring[SHMEM_MAX_NAME_LEN];
    shmem_info_get_name(verstring);

    std::cout << u.nodename
              << " \"" << verstring << "\" "
              << "version " << maj << "." << min
              << " on PE " << me << " of " << npes
              << "\n";

    shmem_finalize();
}

// Assembly:
subq $0x298, %rsp            # imm = 0x298
leaq 0x112(%rsp), %rdi
callq 0x1030
callq 0x10d0
callq 0x10a0
movl %eax, 0x10c(%rsp)
callq 0x1080
movl %eax, 0x108(%rsp)
leaq 0x104(%rsp), %rdi
leaq 0x100(%rsp), %rsi
callq 0x1040
movq %rsp, %rdi
callq 0x1050
leaq 0x112(%rsp), %rsi
addq $0x41, %rsi
movq 0x2d57(%rip), %rdi      # 0x3fd8
callq 0x1090
movq %rax, %rdi
leaq 0xd74(%rip), %rsi       # 0x2004
callq 0x1090
movq %rax, %rdi
movq %rsp, %rsi
callq 0x1090
movq %rax, %rdi
leaq 0xd5d(%rip), %rsi       # 0x2007
callq 0x1090
movq %rax, %rdi
leaq 0xd51(%rip), %rsi       # 0x200a
callq 0x1090
movq %rax, %rdi
movl 0x104(%rsp), %esi
callq 0x10c0
movq %rax, %rdi
leaq 0xd3c(%rip), %rsi       # 0x2013
callq 0x1090
movq %rax, %rdi
movl 0x100(%rsp), %esi
callq 0x10c0
movq %rax, %rdi
leaq 0xd20(%rip), %rsi       # 0x2015
callq 0x1090
movq %rax, %rdi
movl 0x10c(%rsp), %esi
callq 0x10c0
movq %rax, %rdi
leaq 0xd0a(%rip), %rsi       # 0x201d
callq 0x1090
movq %rax, %rdi
movl 0x108(%rsp), %esi
callq 0x10c0
movq %rax, %rdi
leaq 0xcf1(%rip), %rsi       # 0x2022
callq 0x1090
callq 0x1060
xorl %eax, %eax
addq $0x298, %rsp            # imm = 0x298
retq
// File: /workspace/github_c_makefile_star2_O0/antonblanchard[P]will-it-scale/tests/pthread_mutex2.c
// Function: testcase
void testcase(unsigned long long *iterations, unsigned long nr)
{
	pthread_mutex_t mutex = PTHREAD_MUTEX_INITIALIZER;

	while (1) {
		pthread_mutex_lock(&mutex);
		pthread_mutex_unlock(&mutex);

		(*iterations)++;
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
leaq -0x38(%rbp), %rdi
xorl %esi, %esi
movl $0x28, %edx
callq 0x2110
leaq -0x38(%rbp), %rdi
callq 0x22a0
leaq -0x38(%rbp), %rdi
callq 0x2180
movq -0x8(%rbp), %rax
movq (%rax), %rcx
addq $0x1, %rcx
movq %rcx, (%rax)
jmp 0x2fd0
// File: /workspace/github_c_makefile_star2_O0/ramirezsebas[P]TP-LISTINGS/./src/capitulo_3/3.7/sigchld.c
// Function: main
int main ()
{
	/* Handle SIGCHLD by calling clean_up_child_process. */
	struct sigaction sigchld_action;
	memset (&sigchld_action, 0, sizeof (sigchld_action));
	sigchld_action.sa_handler = &clean_up_child_process;
	sigaction (SIGCHLD, &sigchld_action, NULL);

	pid_t pidc;

	if((pidc = fork()) == 0) {
    		printf ("Child process: %d\n", (int)getpid());
    		pid_t pidcc;

		if ((pidcc = fork()) == 0) {
			printf("Child's child process: %d\n", (int)getpid());
		} else {
      			kill((int)getpid(),SIGCHLD);
		}
	}else {
   	 	printf ("Parent process: %d\n", (int)getpid());
      		kill((int)getpid(),SIGCHLD);
	}

	return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0xb0, %rsp
movl $0x0, -0x4(%rbp)
leaq -0xa0(%rbp), %rdi
xorl %esi, %esi
movl $0x98, %edx
callq 0x1050
leaq -0x5c(%rip), %rax       # 0x11a0
movq %rax, -0xa0(%rbp)
movl $0x11, %edi
leaq -0xa0(%rbp), %rsi
xorl %eax, %eax
movl %eax, %edx
callq 0x1070
callq 0x1040
movl %eax, -0xa4(%rbp)
cmpl $0x0, %eax
jne 0x1277
callq 0x1090
movl %eax, %esi
leaq 0xdce(%rip), %rdi       # 0x2004
movb $0x0, %al
callq 0x1030
callq 0x1040
movl %eax, -0xa8(%rbp)
cmpl $0x0, %eax
jne 0x1264
callq 0x1090
movl %eax, %esi
leaq 0xdbc(%rip), %rdi       # 0x2017
movb $0x0, %al
callq 0x1030
jmp 0x1275
callq 0x1090
movl %eax, %edi
movl $0x11, %esi
callq 0x1080
jmp 0x129d
callq 0x1090
movl %eax, %esi
leaq 0xdad(%rip), %rdi       # 0x2032
movb $0x0, %al
callq 0x1030
callq 0x1090
movl %eax, %edi
movl $0x11, %esi
callq 0x1080
xorl %eax, %eax
addq $0xb0, %rsp
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O0/chriso[P]columnix/lib/column.c
// Function: cx_column_new_size
static struct cx_column *cx_column_new_size(enum cx_column_type type,
                                            enum cx_encoding_type encoding,
                                            size_t size, size_t count)
{
    struct cx_column *column = calloc(1, sizeof(*column));
    if (!column)
        return NULL;
    if (size) {
#ifdef CX_COLUMN_OVER_ALLOC
        size += CX_COLUMN_OVER_ALLOC;
#endif
        column->buffer.mutable = malloc(size);
        if (!column->buffer.mutable)
            goto error;
#ifdef CX_COLUMN_OVER_ALLOC
        memset(column->buffer.mutable, 0, size);
#endif
        column->size = size;
    }
    column->type = type;
    column->encoding = encoding;
    column->count = count;
    return column;
error:
    free(column);
    return NULL;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movl %edi, -0xc(%rbp)
movl %esi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq %rcx, -0x20(%rbp)
movl $0x1, %edi
movl $0x30, %esi
callq 0x54d0
movq %rax, -0x28(%rbp)
cmpq $0x0, -0x28(%rbp)
jne 0x5c2a
movq $0x0, -0x8(%rbp)
jmp 0x5c97
cmpq $0x0, -0x18(%rbp)
je 0x5c5c
movq -0x18(%rbp), %rdi
callq 0x5630
movq %rax, %rcx
movq -0x28(%rbp), %rax
movq %rcx, (%rax)
movq -0x28(%rbp), %rax
cmpq $0x0, (%rax)
jne 0x5c50
jmp 0x5c86
movq -0x18(%rbp), %rcx
movq -0x28(%rbp), %rax
movq %rcx, 0x18(%rax)
movl -0xc(%rbp), %ecx
movq -0x28(%rbp), %rax
movl %ecx, 0x20(%rax)
movl -0x10(%rbp), %ecx
movq -0x28(%rbp), %rax
movl %ecx, 0x24(%rax)
movq -0x20(%rbp), %rcx
movq -0x28(%rbp), %rax
movq %rcx, 0x8(%rax)
movq -0x28(%rbp), %rax
movq %rax, -0x8(%rbp)
jmp 0x5c97
movq -0x28(%rbp), %rdi
callq 0x50a0
movq $0x0, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/chriso[P]columnix/lib/column.c
// Function: cx_column_new_mmapped
struct cx_column *cx_column_new_mmapped(enum cx_column_type type,
                                        enum cx_encoding_type encoding,
                                        const void *ptr, size_t size,
                                        size_t count)
{
    struct cx_column *column = cx_column_new_size(type, encoding, 0, count);
    if (!column)
        return NULL;
    column->offset = size;
    column->size = size;
    column->mmapped = true;
    column->buffer.mmapped = ptr;
    return column;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movl %edi, -0xc(%rbp)
movl %esi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq %rcx, -0x20(%rbp)
movq %r8, -0x28(%rbp)
movl -0xc(%rbp), %edi
movl -0x10(%rbp), %esi
movq -0x28(%rbp), %rcx
xorl %eax, %eax
movl %eax, %edx
callq 0x5bf0
movq %rax, -0x30(%rbp)
cmpq $0x0, -0x30(%rbp)
jne 0x5cf2
movq $0x0, -0x8(%rbp)
jmp 0x5d25
movq -0x20(%rbp), %rcx
movq -0x30(%rbp), %rax
movq %rcx, 0x10(%rax)
movq -0x20(%rbp), %rcx
movq -0x30(%rbp), %rax
movq %rcx, 0x18(%rax)
movq -0x30(%rbp), %rax
movb $0x1, 0x28(%rax)
movq -0x18(%rbp), %rcx
movq -0x30(%rbp), %rax
movq %rcx, (%rax)
movq -0x30(%rbp), %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x30, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/chriso[P]columnix/lib/column.c
// Function: cx_column_new_compressed
struct cx_column *cx_column_new_compressed(enum cx_column_type type,
                                           enum cx_encoding_type encoding,
                                           void **ptr, size_t size,
                                           size_t count)
{
    if (!size)
        return NULL;
    struct cx_column *column = cx_column_new_size(type, encoding, size, count);
    if (!column)
        return NULL;
    column->offset = size;
    *ptr = column->buffer.mutable;
    return column;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movl %edi, -0xc(%rbp)
movl %esi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq %rcx, -0x20(%rbp)
movq %r8, -0x28(%rbp)
cmpq $0x0, -0x20(%rbp)
jne 0x5d5b
movq $0x0, -0x8(%rbp)
jmp 0x5da5
movl -0xc(%rbp), %edi
movl -0x10(%rbp), %esi
movq -0x20(%rbp), %rdx
movq -0x28(%rbp), %rcx
callq 0x5bf0
movq %rax, -0x30(%rbp)
cmpq $0x0, -0x30(%rbp)
jne 0x5d83
movq $0x0, -0x8(%rbp)
jmp 0x5da5
movq -0x20(%rbp), %rcx
movq -0x30(%rbp), %rax
movq %rcx, 0x10(%rax)
movq -0x30(%rbp), %rax
movq (%rax), %rcx
movq -0x18(%rbp), %rax
movq %rcx, (%rax)
movq -0x30(%rbp), %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x30, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/chriso[P]columnix/lib/column.c
// Function: cx_column_put_bit
bool cx_column_put_bit(struct cx_column *column, bool value)
{
    if (column->count % 64 == 0) {
        uint64_t bitset = value != 0;
        return cx_column_put(column, CX_COLUMN_BIT, &bitset, sizeof(uint64_t));
    } else if (column->type != CX_COLUMN_BIT || column->mmapped)
        return false;
    if (value) {
        uint64_t *bitset = (uint64_t *)cx_column_offset(
            column, column->offset - sizeof(uint64_t));
        *bitset |= (uint64_t)1 << column->count;
    }
    column->count++;
    return true;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movb %sil, %al
movq %rdi, -0x10(%rbp)
andb $0x1, %al
movb %al, -0x11(%rbp)
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rax
andq $0x3f, %rax
cmpq $0x0, %rax
jne 0x5f0a
movb -0x11(%rbp), %al
andb $0x1, %al
movzbl %al, %eax
cmpl $0x0, %eax
setne %al
andb $0x1, %al
movzbl %al, %eax
cltq
movq %rax, -0x20(%rbp)
movq -0x10(%rbp), %rdi
xorl %esi, %esi
leaq -0x20(%rbp), %rdx
movl $0x8, %ecx
callq 0x5f90
andb $0x1, %al
movb %al, -0x1(%rbp)
jmp 0x5f76
movq -0x10(%rbp), %rax
cmpl $0x0, 0x20(%rax)
jne 0x5f1e
movq -0x10(%rbp), %rax
testb $0x1, 0x28(%rax)
je 0x5f24
movb $0x0, -0x1(%rbp)
jmp 0x5f76
jmp 0x5f26
testb $0x1, -0x11(%rbp)
je 0x5f62
movq -0x10(%rbp), %rdi
movq -0x10(%rbp), %rax
movq 0x10(%rax), %rsi
subq $0x8, %rsi
callq 0x6050
movq %rax, -0x28(%rbp)
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rcx
movl $0x1, %eax
shlq %cl, %rax
movq %rax, %rcx
movq -0x28(%rbp), %rax
orq (%rax), %rcx
movq %rcx, (%rax)
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rcx
addq $0x1, %rcx
movq %rcx, 0x8(%rax)
movb $0x1, -0x1(%rbp)
movb -0x1(%rbp), %al
andb $0x1, %al
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/chriso[P]columnix/lib/column.c
// Function: cx_column_put
static bool cx_column_put(struct cx_column *column, enum cx_column_type type,
                          const void *value, size_t size)
{
    if (column->mmapped || column->type != type || !value)
        return false;
    if (column->offset + size > column->size)
        if (!cx_column_resize(column, size))
            return false;
    void *slot = (void *)cx_column_tail(column);
    memcpy(slot, value, size);
    column->count++;
    column->offset += size;
    return true;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movl %esi, -0x14(%rbp)
movq %rdx, -0x20(%rbp)
movq %rcx, -0x28(%rbp)
movq -0x10(%rbp), %rax
testb $0x1, 0x28(%rax)
jne 0x5fc4
movq -0x10(%rbp), %rax
movl 0x20(%rax), %eax
cmpl -0x14(%rbp), %eax
jne 0x5fc4
cmpq $0x0, -0x20(%rbp)
jne 0x5fca
movb $0x0, -0x1(%rbp)
jmp 0x603b
movq -0x10(%rbp), %rax
movq 0x10(%rax), %rax
addq -0x28(%rbp), %rax
movq -0x10(%rbp), %rcx
cmpq 0x18(%rcx), %rax
jbe 0x5ff9
movq -0x10(%rbp), %rdi
movq -0x28(%rbp), %rsi
callq 0x6990
testb $0x1, %al
jne 0x5ff7
movb $0x0, -0x1(%rbp)
jmp 0x603b
jmp 0x5ff9
movq -0x10(%rbp), %rdi
callq 0x62f0
movq %rax, -0x30(%rbp)
movq -0x30(%rbp), %rdi
movq -0x20(%rbp), %rsi
movq -0x28(%rbp), %rdx
callq 0x5570
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rcx
addq $0x1, %rcx
movq %rcx, 0x8(%rax)
movq -0x28(%rbp), %rcx
movq -0x10(%rbp), %rax
addq 0x10(%rax), %rcx
movq %rcx, 0x10(%rax)
movb $0x1, -0x1(%rbp)
movb -0x1(%rbp), %al
andb $0x1, %al
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)