LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O0/CkTD[P]btree/table.c
// Function: table_index_new_by_meta
static TableIndex *table_index_new_by_meta(const char *dir, TableMeta *meta)
{
    TableIndex *index;
    
    index = (TableIndex *)malloc(sizeof(TableIndex));

    index->dir = dir;
    memset(index->index_trees, 0, sizeof(BTree *) * COLUMNS);
    memcpy(index->index_flag, meta->index_flag, sizeof(uint64_t) * COLUMNS);

    return index;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl $0x648, %edi            # imm = 0x648
callq 0x1100
movq %rax, -0x18(%rbp)
movq -0x8(%rbp), %rcx
movq -0x18(%rbp), %rax
movq %rcx, (%rax)
movq -0x18(%rbp), %rdi
addq $0x328, %rdi            # imm = 0x328
xorl %esi, %esi
movl $0x320, %edx            # imm = 0x320
callq 0x10c0
movq -0x18(%rbp), %rdi
addq $0x8, %rdi
movq -0x10(%rbp), %rsi
addq $0x10, %rsi
movl $0x320, %edx            # imm = 0x320
callq 0x10e0
movq -0x18(%rbp), %rax
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/CkTD[P]btree/table.c
// Function: table_content_get_path
static char *table_content_get_path(const char *dir)
{
    int   len;
    char *full_path;
    const char *fixed_name = "/table";  // 6 characters
    len = strlen(dir);
    full_path = (char *)malloc(len + 7);
    strcpy(full_path, dir);
    strcpy(full_path + len, fixed_name);
    return full_path;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
leaq 0x1af5(%rip), %rax      # 0x6b48
movq %rax, -0x20(%rbp)
movq -0x8(%rbp), %rdi
callq 0x1070
movl %eax, -0xc(%rbp)
movl -0xc(%rbp), %eax
addl $0x7, %eax
movslq %eax, %rdi
callq 0x1100
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rdi
movq -0x8(%rbp), %rsi
callq 0x1040
movq -0x18(%rbp), %rdi
movslq -0xc(%rbp), %rax
addq %rax, %rdi
movq -0x20(%rbp), %rsi
callq 0x1040
movq -0x18(%rbp), %rax
addq $0x20, %rsp
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O0/CkTD[P]btree/table.c
// Function: table_content_new_empty
static TableContent *table_content_new_empty(const char* dir)
{
    TableContent *content;

    content = (TableContent *)malloc(sizeof(TableContent));

    content->file_path = table_content_get_path(dir);
    content->file_fd = -1;
    content->next_rowid_to_flush = 0;
    content->rows = table_rows_new_empty();

    content->meta.file_magic = TABLE_FILE_MAGIC;
    content->meta.row_counts = 0;
    memset(content->meta.index_flag, 0, sizeof(uint64_t) * COLUMNS);
    return content;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movl $0x350, %edi            # imm = 0x350
callq 0x1100
movq %rax, -0x10(%rbp)
movq -0x8(%rbp), %rdi
callq 0x5040
movq %rax, %rcx
movq -0x10(%rbp), %rax
movq %rcx, (%rax)
movq -0x10(%rbp), %rax
movl $0xffffffff, 0x8(%rax)  # imm = 0xFFFFFFFF
movq -0x10(%rbp), %rax
movq $0x0, 0x10(%rax)
callq 0x4dc0
movq %rax, %rcx
movq -0x10(%rbp), %rax
movq %rcx, 0x18(%rax)
movq -0x10(%rbp), %rax
movl $0xaaaaaaaa, %ecx       # imm = 0xAAAAAAAA
movq %rcx, 0x20(%rax)
movq -0x10(%rbp), %rax
movq $0x0, 0x28(%rax)
movq -0x10(%rbp), %rdi
addq $0x20, %rdi
addq $0x10, %rdi
xorl %esi, %esi
movl $0x320, %edx            # imm = 0x320
callq 0x10c0
movq -0x10(%rbp), %rax
addq $0x10, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/CkTD[P]btree/table.c
// Function: table_index_new_empty
static TableIndex *table_index_new_empty(const char *dir)
{
    TableIndex *index;
    
    index = (TableIndex *)malloc(sizeof(TableIndex));

    index->dir = dir;
    memset(index->index_trees, 0, sizeof(BTree *) * COLUMNS);
    memset(index->index_flag, 0, sizeof(uint64_t) * COLUMNS);

    return index;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movl $0x648, %edi            # imm = 0x648
callq 0x1100
movq %rax, -0x10(%rbp)
movq -0x8(%rbp), %rcx
movq -0x10(%rbp), %rax
movq %rcx, (%rax)
movq -0x10(%rbp), %rdi
addq $0x328, %rdi            # imm = 0x328
xorl %esi, %esi
movl $0x320, %edx            # imm = 0x320
callq 0x10c0
movq -0x10(%rbp), %rdi
addq $0x8, %rdi
xorl %esi, %esi
movl $0x320, %edx            # imm = 0x320
callq 0x10c0
movq -0x10(%rbp), %rax
addq $0x10, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/nmmmnu[P]HM2/test_hm.c
// Function: hm_memtable_test
void hm_memtable_test(){
	hm_memtable_t *v = hm_memtable_createa();

	_hm_memtable_test_dump(v);
	_hm_memtable_test_overwrite(v);
	_hm_memtable_test_remove(v);

	hm_memtable_destroy(v);
	free(v);
}

// Assembly:
pushq %rax
movb $0x0, %al
callq 0x28d0
movq %rax, (%rsp)
movq (%rsp), %rdi
callq 0x14f0
movq (%rsp), %rdi
callq 0x15f0
movq (%rsp), %rdi
callq 0x16d0
movq (%rsp), %rdi
callq 0x2900
movq (%rsp), %rdi
callq 0x1030
popq %rax
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/nmmmnu[P]HM2/test_hm.c
// Function: hm_memtable_test_dump
static void _hm_memtable_test_dump(hm_memtable_t *v){
	size_t size = _hm_memtable_populate(v);

	const hm_pair_t *pair;
	hm_memtable_it_t *it = hm_memtable_it_open(v);
	if (it)
		for(pair = hm_memtable_it_first(it); pair; pair = hm_memtable_it_next(it))
			hm_pair_printf(pair);

	hm_memtable_it_close(it);

	PRINTF_TEST("hm_memtable_t", "sizeof",	hm_memtable_sizeof(v) == size		);
	PRINTF_TEST("hm_memtable_t", "put",		1					);
	PRINTF_TEST("hm_memtable_t", "free",	1					);
}

// Assembly:
subq $0x28, %rsp
movq %rdi, 0x20(%rsp)
movq 0x20(%rsp), %rdi
callq 0x18c0
movq %rax, 0x18(%rsp)
movq 0x20(%rsp), %rdi
callq 0x29d0
movq %rax, 0x8(%rsp)
cmpq $0x0, 0x8(%rsp)
je 0x1553
movq 0x8(%rsp), %rdi
callq 0x29f0
movq %rax, 0x10(%rsp)
cmpq $0x0, 0x10(%rsp)
je 0x1551
movq 0x10(%rsp), %rdi
callq 0x1e00
movq 0x8(%rsp), %rdi
callq 0x2a00
movq %rax, 0x10(%rsp)
jmp 0x152e
jmp 0x1553
movq 0x8(%rsp), %rdi
callq 0x29e0
movq 0x20(%rsp), %rdi
callq 0x29c0
movq %rax, %rdx
movq 0x18(%rsp), %rsi
leaq 0x1ad3(%rip), %rcx      # 0x3049
leaq 0x1ac9(%rip), %rax      # 0x3046
cmpq %rsi, %rdx
cmoveq %rax, %rcx
leaq 0x1a8f(%rip), %rdi      # 0x301a
leaq 0x1af5(%rip), %rsi      # 0x3087
leaq 0x1afc(%rip), %rdx      # 0x3095
movb $0x0, %al
callq 0x1050
leaq 0x1a73(%rip), %rdi      # 0x301a
leaq 0x1ad9(%rip), %rsi      # 0x3087
leaq 0x1ae7(%rip), %rdx      # 0x309c
leaq 0x1a8a(%rip), %rcx      # 0x3046
movb $0x0, %al
callq 0x1050
leaq 0x1a50(%rip), %rdi      # 0x301a
leaq 0x1ab6(%rip), %rsi      # 0x3087
leaq 0x1ac8(%rip), %rdx      # 0x30a0
leaq 0x1a67(%rip), %rcx      # 0x3046
movb $0x0, %al
callq 0x1050
addq $0x28, %rsp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/nmmmnu[P]HM2/test_hm.c
// Function: hm_memtable_test_overwrite
static void _hm_memtable_test_overwrite(hm_memtable_t *v){
	_hm_memtable_populate(v);

	const char *overwr = "overwritten";

	hm_memtable_put(v, hm_pair_create("2 val", "original")	);
	hm_memtable_put(v, hm_pair_create("2 val", overwr)	);

	const hm_pair_t *p = hm_memtable_get(v,"2 val");
	PRINTF_TEST("hm_memtable_t", "overwrite",	! strcmp(hm_pair_getval(p), overwr)	);
}

// Assembly:
subq $0x28, %rsp
movq %rdi, 0x20(%rsp)
movq 0x20(%rsp), %rdi
callq 0x18c0
leaq 0x1ac8(%rip), %rax      # 0x30d2
movq %rax, 0x18(%rsp)
movq 0x20(%rsp), %rax
movq %rax, (%rsp)
leaq 0x1abf(%rip), %rdi      # 0x30de
leaq 0x1abe(%rip), %rsi      # 0x30e4
callq 0x1460
movq (%rsp), %rdi
movq %rax, %rsi
callq 0x2920
movq 0x20(%rsp), %rax
movq %rax, 0x8(%rsp)
movq 0x18(%rsp), %rsi
leaq 0x1a91(%rip), %rdi      # 0x30de
callq 0x1460
movq 0x8(%rsp), %rdi
movq %rax, %rsi
callq 0x2920
movq 0x20(%rsp), %rdi
leaq 0x1a73(%rip), %rsi      # 0x30de
callq 0x2950
movq %rax, 0x10(%rsp)
movq 0x10(%rsp), %rdi
callq 0x1c40
movq %rax, %rdi
movq 0x18(%rsp), %rsi
callq 0x1070
cmpl $0x0, %eax
setne %dl
xorb $-0x1, %dl
leaq 0x19ad(%rip), %rcx      # 0x3049
leaq 0x19a3(%rip), %rax      # 0x3046
testb $0x1, %dl
cmovneq %rax, %rcx
leaq 0x1969(%rip), %rdi      # 0x301a
leaq 0x19cf(%rip), %rsi      # 0x3087
leaq 0x1a2e(%rip), %rdx      # 0x30ed
movb $0x0, %al
callq 0x1050
addq $0x28, %rsp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/nmmmnu[P]HM2/test_hm.c
// Function: hm_memtable_test_remove
static void _hm_memtable_test_remove(hm_memtable_t *v){
	_hm_memtable_populate(v);

	// remove middle
	hm_memtable_remove(v, "2 age");
	// remove first
	hm_memtable_remove(v, "1 name");
	// remove middle
	hm_memtable_remove(v, "4 os");

	const hm_pair_t *p = hm_memtable_get(v,"3 city");
	PRINTF_TEST("hm_memtable_t", "remove",	! strcmp(hm_pair_getval(p), "Sofia")	);
	PRINTF_TEST("hm_memtable_t", "remove",	hm_memtable_count(v) == 1			);

	// remove last
	hm_memtable_remove(v, "3 city");

	PRINTF_TEST("hm_memtable_t", "remove",	hm_memtable_count(v) == 0			);
}

// Assembly:
subq $0x18, %rsp
movq %rdi, 0x10(%rsp)
movq 0x10(%rsp), %rdi
callq 0x18c0
movq 0x10(%rsp), %rdi
leaq 0x19cf(%rip), %rsi      # 0x30be
callq 0x2980
movq 0x10(%rsp), %rdi
leaq 0x19b2(%rip), %rsi      # 0x30b2
callq 0x2980
movq 0x10(%rsp), %rdi
leaq 0x19b6(%rip), %rsi      # 0x30c7
callq 0x2980
movq 0x10(%rsp), %rdi
leaq 0x1983(%rip), %rsi      # 0x30a5
callq 0x2950
movq %rax, 0x8(%rsp)
movq 0x8(%rsp), %rdi
callq 0x1c40
movq %rax, %rdi
leaq 0x196c(%rip), %rsi      # 0x30ac
callq 0x1070
cmpl $0x0, %eax
setne %dl
xorb $-0x1, %dl
leaq 0x18f4(%rip), %rcx      # 0x3049
leaq 0x18ea(%rip), %rax      # 0x3046
testb $0x1, %dl
cmovneq %rax, %rcx
leaq 0x18b0(%rip), %rdi      # 0x301a
leaq 0x1916(%rip), %rsi      # 0x3087
leaq 0x197f(%rip), %rdx      # 0x30f7
movb $0x0, %al
callq 0x1050
movq 0x10(%rsp), %rdi
callq 0x29b0
movq %rax, %rdx
leaq 0x18b6(%rip), %rcx      # 0x3049
leaq 0x18ac(%rip), %rax      # 0x3046
cmpq $0x1, %rdx
cmoveq %rax, %rcx
leaq 0x1871(%rip), %rdi      # 0x301a
leaq 0x18d7(%rip), %rsi      # 0x3087
leaq 0x1940(%rip), %rdx      # 0x30f7
movb $0x0, %al
callq 0x1050
movq 0x10(%rsp), %rdi
leaq 0x18db(%rip), %rsi      # 0x30a5
callq 0x2980
movq 0x10(%rsp), %rdi
callq 0x29b0
movq %rax, %rdx
leaq 0x1866(%rip), %rcx      # 0x3049
leaq 0x185c(%rip), %rax      # 0x3046
cmpq $0x0, %rdx
cmoveq %rax, %rcx
leaq 0x1821(%rip), %rdi      # 0x301a
leaq 0x1887(%rip), %rsi      # 0x3087
leaq 0x18f0(%rip), %rdx      # 0x30f7
movb $0x0, %al
callq 0x1050
addq $0x18, %rsp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/nmmmnu[P]HM2/test_hm.c
// Function: hm_memtable_populate
static size_t _hm_memtable_populate(hm_memtable_t *v){
	hm_memtable_removeall(v);

	hm_pair_t *p;
	size_t size = 0;

	// go to empty list
	p = hm_pair_create("3 city", "Sofia");	size += hm_pair_sizeof(p);	hm_memtable_put(v, p);
	// go first
	p = hm_pair_create("1 name", "Niki");	size += hm_pair_sizeof(p);	hm_memtable_put(v, p);
	// go middle
	p = hm_pair_create("2 age", "22");	size += hm_pair_sizeof(p);	hm_memtable_put(v, p);
	// go last
	p = hm_pair_create("4 os", "Linux");	size += hm_pair_sizeof(p);	hm_memtable_put(v, p);

	return size;
}

// Assembly:
subq $0x18, %rsp
movq %rdi, 0x10(%rsp)
movq 0x10(%rsp), %rdi
callq 0x2910
movq $0x0, (%rsp)
leaq 0x17c3(%rip), %rdi      # 0x30a5
leaq 0x17c3(%rip), %rsi      # 0x30ac
callq 0x1460
movq %rax, 0x8(%rsp)
movq 0x8(%rsp), %rdi
callq 0x1c10
addq (%rsp), %rax
movq %rax, (%rsp)
movq 0x10(%rsp), %rdi
movq 0x8(%rsp), %rsi
callq 0x2920
leaq 0x1797(%rip), %rdi      # 0x30b2
leaq 0x1797(%rip), %rsi      # 0x30b9
callq 0x1460
movq %rax, 0x8(%rsp)
movq 0x8(%rsp), %rdi
callq 0x1c10
addq (%rsp), %rax
movq %rax, (%rsp)
movq 0x10(%rsp), %rdi
movq 0x8(%rsp), %rsi
callq 0x2920
leaq 0x176a(%rip), %rdi      # 0x30be
leaq 0x1769(%rip), %rsi      # 0x30c4
callq 0x1460
movq %rax, 0x8(%rsp)
movq 0x8(%rsp), %rdi
callq 0x1c10
addq (%rsp), %rax
movq %rax, (%rsp)
movq 0x10(%rsp), %rdi
movq 0x8(%rsp), %rsi
callq 0x2920
leaq 0x173a(%rip), %rdi      # 0x30c7
leaq 0x1738(%rip), %rsi      # 0x30cc
callq 0x1460
movq %rax, 0x8(%rsp)
movq 0x8(%rsp), %rdi
callq 0x1c10
addq (%rsp), %rax
movq %rax, (%rsp)
movq 0x10(%rsp), %rdi
movq 0x8(%rsp), %rsi
callq 0x2920
movq (%rsp), %rax
addq $0x18, %rsp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/albinoloverats[P]hide/src/webp.c
// Function: init
extern image_type_t *init(void)
{
	static image_type_t webp;
	webp.type = "WEBP";
	webp.is_type = is_webp;
	webp.read = read_webp;
	webp.write = write_webp;
	webp.info = info_webp;
	webp.free = free_webp;
	return &webp;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
leaq 0xe35(%rip), %rax       # 0x2000
movq %rax, 0x2eb6(%rip)      # 0x4088
leaq 0x57(%rip), %rax        # 0x1230
movq %rax, 0x2eb0(%rip)      # 0x4090
leaq 0xd9(%rip), %rax        # 0x12c0
movq %rax, 0x2eaa(%rip)      # 0x4098
leaq 0x35b(%rip), %rax       # 0x1550
movq %rax, 0x2ea4(%rip)      # 0x40a0
leaq 0x4dd(%rip), %rax       # 0x16e0
movq %rax, 0x2e9e(%rip)      # 0x40a8
leaq 0x50f(%rip), %rax       # 0x1720
movq %rax, 0x2e98(%rip)      # 0x40b0
leaq 0x2e69(%rip), %rax      # 0x4088
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/albinoloverats[P]hide/src/webp.c
// Function: is_webp
static bool is_webp(char *file_name)
{
	FILE *fp = fopen(file_name, "rb");
	if (!fp)
		return false;

	uint8_t header[1024];
	fread(header, 1, sizeof header, fp);
	fclose(fp);

	return WebPGetInfo(header, sizeof header, NULL, NULL);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x420, %rsp            # imm = 0x420
movq %rdi, -0x10(%rbp)
movq -0x10(%rbp), %rdi
leaq 0xdbb(%rip), %rsi       # 0x2005
callq 0x1090
movq %rax, -0x18(%rbp)
cmpq $0x0, -0x18(%rbp)
jne 0x1260
movb $0x0, -0x1(%rbp)
jmp 0x12a6
leaq -0x420(%rbp), %rdi
movq -0x18(%rbp), %rcx
movl $0x1, %esi
movl $0x400, %edx            # imm = 0x400
callq 0x1050
movq -0x18(%rbp), %rdi
callq 0x1060
leaq -0x420(%rbp), %rdi
movl $0x400, %esi            # imm = 0x400
xorl %eax, %eax
movl %eax, %ecx
movq %rcx, %rdx
callq 0x1070
cmpl $0x0, %eax
setne %al
andb $0x1, %al
movb %al, -0x1(%rbp)
movb -0x1(%rbp), %al
andb $0x1, %al
addq $0x420, %rsp            # imm = 0x420
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/albinoloverats[P]hide/src/webp.c
// Function: write_webp
static int write_webp(image_info_t image_info, void (*progress_update)(uint64_t, uint64_t))
{
	errno = EXIT_SUCCESS;

	FILE *fp = fopen(image_info.file, "wb");
	if (!fp)
		return errno;

	uint8_t *raw = NULL;
	uint64_t l = image_info.width * image_info.bpp;
	uint8_t *img = malloc(l * image_info.height);
	for (uint64_t y = 0; y < image_info.height; y++)
	{
		memcpy(img + y * l, image_info.buffer[y], l);
		free(image_info.buffer[y]);
		if (progress_update)
			progress_update(y, image_info.height);
	}
	free(image_info.buffer);

	size_t (*webpencode)(const uint8_t *, int, int, int, uint8_t **) = image_info.bpp == 4 ? WebPEncodeLosslessRGBA : WebPEncodeLosslessRGB;
	l = webpencode(img, image_info.width, image_info.height, l, &raw);

	fwrite(raw, 1, l, fp);
	free(raw);
	free(img);
	fclose(fp);

	return errno;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
leaq 0x10(%rbp), %rax
movq %rax, -0x48(%rbp)
movq %rdi, -0x10(%rbp)
callq 0x1040
movq %rax, %rcx
movq -0x48(%rbp), %rax
movl $0x0, (%rcx)
movq (%rax), %rdi
leaq 0xa88(%rip), %rsi       # 0x2008
callq 0x1090
movq %rax, -0x18(%rbp)
cmpq $0x0, -0x18(%rbp)
jne 0x159f
callq 0x1040
movl (%rax), %eax
movl %eax, -0x4(%rbp)
jmp 0x16d5
movq -0x48(%rbp), %rax
movq $0x0, -0x20(%rbp)
movq 0x30(%rax), %rcx
movzwl 0x38(%rax), %edx
imulq %rdx, %rcx
movq %rcx, -0x28(%rbp)
movq -0x28(%rbp), %rdi
imulq 0x28(%rax), %rdi
callq 0x10b0
movq %rax, -0x30(%rbp)
movq $0x0, -0x38(%rbp)
movq -0x48(%rbp), %rcx
movq -0x38(%rbp), %rax
cmpq 0x28(%rcx), %rax
jae 0x164a
movq -0x48(%rbp), %rax
movq -0x30(%rbp), %rdi
movq -0x38(%rbp), %rcx
imulq -0x28(%rbp), %rcx
addq %rcx, %rdi
movq 0x40(%rax), %rax
movq -0x38(%rbp), %rcx
movq (%rax,%rcx,8), %rsi
movq -0x28(%rbp), %rdx
callq 0x10a0
movq -0x48(%rbp), %rax
movq 0x40(%rax), %rax
movq -0x38(%rbp), %rcx
movq (%rax,%rcx,8), %rdi
callq 0x1030
cmpq $0x0, -0x10(%rbp)
je 0x163a
movq -0x48(%rbp), %rcx
movq -0x10(%rbp), %rax
movq -0x38(%rbp), %rdi
movq 0x28(%rcx), %rsi
callq *%rax
jmp 0x163c
movq -0x38(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x38(%rbp)
jmp 0x15d5
movq -0x48(%rbp), %rax
movq 0x40(%rax), %rdi
callq 0x1030
movq -0x48(%rbp), %rcx
movzwl 0x38(%rcx), %esi
movq 0x2982(%rip), %rax      # 0x3fe8
movq 0x295b(%rip), %rdx      # 0x3fc8
cmpl $0x4, %esi
cmoveq %rdx, %rax
movq %rax, -0x40(%rbp)
movq -0x40(%rbp), %rax
movq -0x30(%rbp), %rdi
movq 0x30(%rcx), %rdx
movl %edx, %esi
movq 0x28(%rcx), %rcx
movl %ecx, %edx
movq -0x28(%rbp), %rcx
leaq -0x20(%rbp), %r8
callq *%rax
movq %rax, -0x28(%rbp)
movq -0x20(%rbp), %rdi
movq -0x28(%rbp), %rdx
movq -0x18(%rbp), %rcx
movl $0x1, %esi
callq 0x10e0
movq -0x20(%rbp), %rdi
callq 0x1030
movq -0x30(%rbp), %rdi
callq 0x1030
movq -0x18(%rbp), %rdi
callq 0x1060
callq 0x1040
movl (%rax), %eax
movl %eax, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x50, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/jalalium[P]graph_algorithms_task/src_path/aux_funcs.c
// Function: append
t_vect	*append(t_vect *src, int add)
{
	t_vect		*copy = (t_vect*)malloc(sizeof(t_vect));

	init_vector(copy);
	for (int i = 0;i < src->used; i++)
		push_back(copy, src->tab[i]);
	push_back(copy, add);
	return copy;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movl $0x18, %edi
callq 0x1070
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rdi
callq 0x2240
movl $0x0, -0x1c(%rbp)
movslq -0x1c(%rbp), %rax
movq -0x8(%rbp), %rcx
cmpq 0x10(%rcx), %rax
jae 0x12bd
movq -0x18(%rbp), %rdi
movq -0x8(%rbp), %rax
movq (%rax), %rax
movslq -0x1c(%rbp), %rcx
movl (%rax,%rcx,4), %esi
callq 0x2370
movl -0x1c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x1c(%rbp)
jmp 0x128d
movq -0x18(%rbp), %rdi
movl -0xc(%rbp), %esi
callq 0x2370
movq -0x18(%rbp), %rax
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/jalalium[P]graph_algorithms_task/src_path/free.c
// Function: free_paths
void	free_paths(t_graph *g)
{
	for (int i = 0; i < g->paths->size; i++)
		free(g->paths->path[i].tab);
	free(g->paths->path);
	free(g->paths);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movl $0x0, -0xc(%rbp)
movslq -0xc(%rbp), %rax
movq -0x8(%rbp), %rcx
movq 0x8(%rcx), %rcx
cmpq 0x8(%rcx), %rax
jae 0x146e
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rax
movq (%rax), %rax
movslq -0xc(%rbp), %rcx
imulq $0x18, %rcx, %rcx
addq %rcx, %rax
movq (%rax), %rdi
callq 0x1030
movl -0xc(%rbp), %eax
addl $0x1, %eax
movl %eax, -0xc(%rbp)
jmp 0x1433
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rax
movq (%rax), %rdi
callq 0x1030
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rdi
callq 0x1030
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/jalalium[P]graph_algorithms_task/src_path/free.c
// Function: free_graph
void	free_graph(t_graph *g)
{
	for (int i = 0; i < g->vertx; i++)
		free(g->adj[i].tab);
	free(g->adj);
	free_paths(g);
	free(g);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movl $0x0, -0xc(%rbp)
movl -0xc(%rbp), %eax
movq -0x8(%rbp), %rcx
cmpl 0x10(%rcx), %eax
jge 0x14e4
movq -0x8(%rbp), %rax
movq (%rax), %rax
movslq -0xc(%rbp), %rcx
imulq $0x18, %rcx, %rcx
addq %rcx, %rax
movq (%rax), %rdi
callq 0x1030
movl -0xc(%rbp), %eax
addl $0x1, %eax
movl %eax, -0xc(%rbp)
jmp 0x14b3
movq -0x8(%rbp), %rax
movq (%rax), %rdi
callq 0x1030
movq -0x8(%rbp), %rdi
callq 0x1420
movq -0x8(%rbp), %rdi
callq 0x1030
addq $0x10, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/jalalium[P]graph_algorithms_task/src_path/graph.c
// Function: get_dimensions
int		get_dimensions(t_graph *new)
{
	int n, m, dir, node;

	scanf("%d %d %d %d", &n, &m, &dir, &node);
	if (!valid_dimensions(n,m,new))
	{
		free(new);
		return 0;
	}
	if (!valid_params(dir, node, new))
	{
		free(new);
		return 0;
	}
	if (!init_adj(new))
		return 0;
	return 1;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
leaq 0x19c3(%rip), %rdi      # 0x3046
leaq -0x14(%rbp), %rsi
leaq -0x18(%rbp), %rdx
leaq -0x1c(%rbp), %rcx
leaq -0x20(%rbp), %r8
movb $0x0, %al
callq 0x1080
movl -0x14(%rbp), %edi
movl -0x18(%rbp), %esi
movq -0x10(%rbp), %rdx
callq 0x21f0
cmpl $0x0, %eax
jne 0x16c0
movq -0x10(%rbp), %rdi
callq 0x1030
movl $0x0, -0x4(%rbp)
jmp 0x1704
movl -0x1c(%rbp), %edi
movl -0x20(%rbp), %esi
movq -0x10(%rbp), %rdx
callq 0x2090
cmpl $0x0, %eax
jne 0x16e6
movq -0x10(%rbp), %rdi
callq 0x1030
movl $0x0, -0x4(%rbp)
jmp 0x1704
movq -0x10(%rbp), %rdi
callq 0x15e0
cmpl $0x0, %eax
jne 0x16fd
movl $0x0, -0x4(%rbp)
jmp 0x1704
movl $0x1, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/jalalium[P]graph_algorithms_task/src_path/main_paths.c
// Function: main
int main()
{
	t_graph *g;
	g = generate_graph();
	find_all_paths(g);
	print_paths(g);
	free_graph(g);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movb $0x0, %al
callq 0x17d0
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rdi
callq 0x1820
movq -0x8(%rbp), %rdi
callq 0x1d80
movq -0x8(%rbp), %rdi
callq 0x14a0
xorl %eax, %eax
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/jalalium[P]graph_algorithms_task/src_path/path_routines.c
// Function: init_paths
void	init_paths(t_graph *g)
{
	t_paths *new = (t_paths*)malloc(sizeof(t_paths));

	new->path = (t_vect*)malloc(sizeof(t_vect)*50);
	for (int i = 0; i < 50; i++)
		init_vector(&new->path[i]);
	new->size = 50;
	new->used = 0;
	g->paths = new;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movl $0x18, %edi
callq 0x1070
movq %rax, -0x10(%rbp)
movl $0x4b0, %edi            # imm = 0x4B0
callq 0x1070
movq %rax, %rcx
movq -0x10(%rbp), %rax
movq %rcx, (%rax)
movl $0x0, -0x14(%rbp)
cmpl $0x32, -0x14(%rbp)
jge 0x1abd
movq -0x10(%rbp), %rax
movq (%rax), %rdi
movslq -0x14(%rbp), %rax
imulq $0x18, %rax, %rax
addq %rax, %rdi
callq 0x2240
movl -0x14(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x14(%rbp)
jmp 0x1a95
movq -0x10(%rbp), %rax
movq $0x32, 0x8(%rax)
movq -0x10(%rbp), %rax
movq $0x0, 0x10(%rax)
movq -0x10(%rbp), %rcx
movq -0x8(%rbp), %rax
movq %rcx, 0x8(%rax)
addq $0x20, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/jalalium[P]graph_algorithms_task/src_path/path_routines.c
// Function: extend_paths
void	extend_paths(t_graph *g)
{
	size_t new_size = g->paths->size * 2;

	t_vect *copy = (t_vect*)malloc(sizeof(t_vect)*new_size); 
	for (int i = 0; i < new_size; i++)
		init_vector(&copy[i]);
	for (int i = 0; i < g->paths->size; i++)
	{
		for (int j = 0; j < g->paths->path[i].used; j++)
			push_back(&copy[i],g->paths->path[i].tab[j]);
		free(g->paths->path[i].tab);
	}
	free(g->paths->path);
	g->paths->path = copy;
	g->paths->size = new_size;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rax
movq 0x8(%rax), %rax
shlq %rax
movq %rax, -0x10(%rbp)
imulq $0x18, -0x10(%rbp), %rdi
callq 0x1070
movq %rax, -0x18(%rbp)
movl $0x0, -0x1c(%rbp)
movslq -0x1c(%rbp), %rax
cmpq -0x10(%rbp), %rax
jae 0x1b4d
movq -0x18(%rbp), %rdi
movslq -0x1c(%rbp), %rax
imulq $0x18, %rax, %rax
addq %rax, %rdi
callq 0x2240
movl -0x1c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x1c(%rbp)
jmp 0x1b24
movl $0x0, -0x20(%rbp)
movslq -0x20(%rbp), %rax
movq -0x8(%rbp), %rcx
movq 0x8(%rcx), %rcx
cmpq 0x8(%rcx), %rax
jae 0x1bfc
movl $0x0, -0x24(%rbp)
movslq -0x24(%rbp), %rax
movq -0x8(%rbp), %rcx
movq 0x8(%rcx), %rcx
movq (%rcx), %rcx
movslq -0x20(%rbp), %rdx
imulq $0x18, %rdx, %rdx
addq %rdx, %rcx
cmpq 0x10(%rcx), %rax
jae 0x1bd0
movq -0x18(%rbp), %rdi
movslq -0x20(%rbp), %rax
imulq $0x18, %rax, %rax
addq %rax, %rdi
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rax
movq (%rax), %rax
movslq -0x20(%rbp), %rcx
imulq $0x18, %rcx, %rcx
addq %rcx, %rax
movq (%rax), %rax
movslq -0x24(%rbp), %rcx
movl (%rax,%rcx,4), %esi
callq 0x2370
movl -0x24(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x24(%rbp)
jmp 0x1b71
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rax
movq (%rax), %rax
movslq -0x20(%rbp), %rcx
imulq $0x18, %rcx, %rcx
addq %rcx, %rax
movq (%rax), %rdi
callq 0x1030
movl -0x20(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x20(%rbp)
jmp 0x1b54
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rax
movq (%rax), %rdi
callq 0x1030
movq -0x18(%rbp), %rcx
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rax
movq %rcx, (%rax)
movq -0x10(%rbp), %rcx
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rax
movq %rcx, 0x8(%rax)
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/jalalium[P]graph_algorithms_task/src_path/path_routines.c
// Function: add_path
void	add_path(t_graph *g, t_vect *new)
{
	size_t pos = g->paths->used;
	size_t size = g->paths->size;

	if (pos >= size)
		extend_paths(g);
	for (int i = 0 ; i < new->used; i++)
		push_back(&g->paths->path[pos], new->tab[i]);
	g->paths->used++;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rax
movq 0x10(%rax), %rax
movq %rax, -0x18(%rbp)
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rax
movq 0x8(%rax), %rax
movq %rax, -0x20(%rbp)
movq -0x18(%rbp), %rax
cmpq -0x20(%rbp), %rax
jb 0x1c83
movq -0x8(%rbp), %rdi
callq 0x1af0
movl $0x0, -0x24(%rbp)
movslq -0x24(%rbp), %rax
movq -0x10(%rbp), %rcx
cmpq 0x10(%rcx), %rax
jae 0x1cc9
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rax
movq (%rax), %rdi
imulq $0x18, -0x18(%rbp), %rax
addq %rax, %rdi
movq -0x10(%rbp), %rax
movq (%rax), %rax
movslq -0x24(%rbp), %rcx
movl (%rax,%rcx,4), %esi
callq 0x2370
movl -0x24(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x24(%rbp)
jmp 0x1c8a
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rax
movq 0x10(%rax), %rcx
addq $0x1, %rcx
movq %rcx, 0x10(%rax)
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/jalalium[P]graph_algorithms_task/src_path/print_paths.c
// Function: print_path_nb
void 	print_path_nb(t_graph *g)
{
	if (g->paths->used == 0)
		printf(BOLDWHITE "There is no path from vertex %d\n" RESET , g->start + 1);
	else if (g->paths->used == 1)
		printf(BOLDWHITE "There is 1 path from vertex %d\n" RESET , g->start + 1);
	else
		printf(BOLDWHITE "There are %zu paths from vertex %d\n" RESET , g->paths->used ,g->start + 1);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rax
cmpq $0x0, 0x10(%rax)
jne 0x1d25
movq -0x8(%rbp), %rax
movl 0x1c(%rax), %esi
addl $0x1, %esi
leaq 0x1336(%rip), %rdi      # 0x3052
movb $0x0, %al
callq 0x1060
jmp 0x1d74
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rax
cmpq $0x1, 0x10(%rax)
jne 0x1d4e
movq -0x8(%rbp), %rax
movl 0x1c(%rax), %esi
addl $0x1, %esi
leaq 0x133b(%rip), %rdi      # 0x3080
movb $0x0, %al
callq 0x1060
jmp 0x1d72
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rax
movq 0x10(%rax), %rsi
movq -0x8(%rbp), %rax
movl 0x1c(%rax), %edx
addl $0x1, %edx
leaq 0x1342(%rip), %rdi      # 0x30ad
movb $0x0, %al
callq 0x1060
jmp 0x1d74
addq $0x10, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/jalalium[P]graph_algorithms_task/src_path/print_paths.c
// Function: print_paths
void	print_paths(t_graph *g)
{
	size_t i = 0;

	print_path_nb(g);
	qsort(g->paths->path,g->paths->used, sizeof(t_vect), cmp_path);
	while (i < g->paths->used)
	{
		int dest = g->paths->path[i].tab[g->paths->path[i].used - 1];
		printf(CYAN "Paths to vertex %d\n" RESET , dest + 1);
		while (i < g->paths->used && g->paths->path[i].tab[g->paths->path[i].used - 1] == dest)
		{
			for (int j = 0; j < g->paths->path[i].used; j++)
				printf("%d ", g->paths->path[i].tab[j] + 1);
			puts("");
			i++;
		}
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq $0x0, -0x10(%rbp)
movq -0x8(%rbp), %rdi
callq 0x1cf0
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rax
movq (%rax), %rdi
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rax
movq 0x10(%rax), %rsi
movl $0x18, %edx
leaq -0xae0(%rip), %rcx      # 0x12e0
callq 0x1050
movq -0x10(%rbp), %rax
movq -0x8(%rbp), %rcx
movq 0x8(%rcx), %rcx
cmpq 0x10(%rcx), %rax
jae 0x1f02
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rax
movq (%rax), %rax
imulq $0x18, -0x10(%rbp), %rcx
addq %rcx, %rax
movq (%rax), %rax
movq -0x8(%rbp), %rcx
movq 0x8(%rcx), %rcx
movq (%rcx), %rcx
imulq $0x18, -0x10(%rbp), %rdx
addq %rdx, %rcx
movq 0x10(%rcx), %rcx
subq $0x1, %rcx
movl (%rax,%rcx,4), %eax
movl %eax, -0x14(%rbp)
movl -0x14(%rbp), %esi
addl $0x1, %esi
leaq 0x12bf(%rip), %rdi      # 0x30de
movb $0x0, %al
callq 0x1060
movq -0x10(%rbp), %rcx
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rdx
xorl %eax, %eax
cmpq 0x10(%rdx), %rcx
movb %al, -0x19(%rbp)
jae 0x1e7a
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rax
movq (%rax), %rax
imulq $0x18, -0x10(%rbp), %rcx
addq %rcx, %rax
movq (%rax), %rax
movq -0x8(%rbp), %rcx
movq 0x8(%rcx), %rcx
movq (%rcx), %rcx
imulq $0x18, -0x10(%rbp), %rdx
addq %rdx, %rcx
movq 0x10(%rcx), %rcx
subq $0x1, %rcx
movl (%rax,%rcx,4), %eax
cmpl -0x14(%rbp), %eax
sete %al
movb %al, -0x19(%rbp)
movb -0x19(%rbp), %al
testb $0x1, %al
jne 0x1e83
jmp 0x1efd
movl $0x0, -0x18(%rbp)
movslq -0x18(%rbp), %rax
movq -0x8(%rbp), %rcx
movq 0x8(%rcx), %rcx
movq (%rcx), %rcx
imulq $0x18, -0x10(%rbp), %rdx
addq %rdx, %rcx
cmpq 0x10(%rcx), %rax
jae 0x1ee0
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rax
movq (%rax), %rax
imulq $0x18, -0x10(%rbp), %rcx
addq %rcx, %rax
movq (%rax), %rax
movslq -0x18(%rbp), %rcx
movl (%rax,%rcx,4), %esi
addl $0x1, %esi
leaq 0x122d(%rip), %rdi      # 0x30fb
movb $0x0, %al
callq 0x1060
movl -0x18(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x18(%rbp)
jmp 0x1e8a
leaq 0x112f(%rip), %rdi      # 0x3016
callq 0x1040
movq -0x10(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x10(%rbp)
jmp 0x1e26
jmp 0x1dc5
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/jalalium[P]graph_algorithms_task/src_path/validation.c
// Function: valid_params
int		valid_params(int dir, int node, t_graph *g)
{
	if (dir != 0 && dir != 1)
		return 0;
	if (node <= 0 || node > g->vertx)
		return 0;
	g->start = node - 1;
	g->direct = dir;
	return 1;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movl %edi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movq %rdx, -0x18(%rbp)
cmpl $0x0, -0x8(%rbp)
je 0x20b3
cmpl $0x1, -0x8(%rbp)
je 0x20b3
movl $0x0, -0x4(%rbp)
jmp 0x20ec
cmpl $0x0, -0xc(%rbp)
jle 0x20c5
movl -0xc(%rbp), %eax
movq -0x18(%rbp), %rcx
cmpl 0x10(%rcx), %eax
jle 0x20ce
movl $0x0, -0x4(%rbp)
jmp 0x20ec
movl -0xc(%rbp), %ecx
subl $0x1, %ecx
movq -0x18(%rbp), %rax
movl %ecx, 0x1c(%rax)
movl -0x8(%rbp), %ecx
movq -0x18(%rbp), %rax
movl %ecx, 0x20(%rax)
movl $0x1, -0x4(%rbp)
movl -0x4(%rbp), %eax
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/eric-lo[P]3150/3-ProcessUser/system_implement_2.c
// Function: system_ver_3150
int system_ver_3150(const char *cmd_str) {
	if(cmd_str == NULL)
		return -1;

	if(fork() == 0) {
		execl(cmd_str, cmd_str, NULL);
		fprintf(stderr, "%s: command not found\n", cmd_str);
		exit(-1);
	}

	wait(NULL);
	return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x10(%rbp)
cmpq $0x0, -0x10(%rbp)
jne 0x11bc
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
jmp 0x120f
callq 0x1090
cmpl $0x0, %eax
jne 0x11ff
movq -0x10(%rbp), %rdi
movq -0x10(%rbp), %rsi
xorl %eax, %eax
movl %eax, %edx
movb $0x0, %al
callq 0x1070
movq 0x2e18(%rip), %rax      # 0x3ff8
movq (%rax), %rdi
movq -0x10(%rbp), %rdx
leaq 0xe16(%rip), %rsi       # 0x2004
movb $0x0, %al
callq 0x1040
movl $0xffffffff, %edi       # imm = 0xFFFFFFFF
callq 0x1060
xorl %eax, %eax
movl %eax, %edi
callq 0x1080
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x10, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/tomcatzh[P]RealityBenchmark/md_bench.c
// Function: mdContent
static CONTENTS* mdContent(const CONTENTS* data) {
#if OPENSSL_VERSION_NUMBER < 0x010100000L
    EVP_MD_CTX mdctx;
#endif
    EVP_MD_CTX *ctx;
    CONTENTS *mdResult = NULL;
    int i = 0;

    mdResult = calloc(1, sizeof(CONTENTS));
    assert(mdResult);
    mdResult->body = malloc(EVP_MAX_MD_SIZE);
    assert(mdResult->body);

    unsigned int md_len;

#if OPENSSL_VERSION_NUMBER < 0x010100000L
    EVP_MD_CTX_init(&mdctx);
    ctx = &mdctx;
#else
    ctx = EVP_MD_CTX_new();
#endif

    i = EVP_DigestInit_ex(ctx, md, NULL);
    assert(i==1);

    i = EVP_DigestUpdate(ctx, data->body, data->size);
    assert(i==1);

    i = EVP_DigestFinal_ex(ctx, mdResult->body, &md_len);
    assert(i==1);
    mdResult->size = md_len;

#if OPENSSL_VERSION_NUMBER < 0x010100000L
    EVP_MD_CTX_cleanup(&mdctx);
#else
    EVP_MD_CTX_free(ctx);
#endif

    return mdResult;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq $0x0, -0x18(%rbp)
movl $0x0, -0x1c(%rbp)
movl $0x1, %edi
movl $0x10, %esi
callq 0x2130
movq %rax, -0x18(%rbp)
cmpq $0x0, -0x18(%rbp)
je 0x2767
jmp 0x2786
leaq 0x7b1a(%rip), %rdi      # 0xa288
leaq 0x79a3(%rip), %rsi      # 0xa118
movl $0x1b, %edx
leaq 0x7b10(%rip), %rcx      # 0xa291
callq 0x2120
movl $0x40, %edi
callq 0x2310
movq %rax, %rcx
movq -0x18(%rbp), %rax
movq %rcx, (%rax)
movq -0x18(%rbp), %rax
cmpq $0x0, (%rax)
je 0x27a6
jmp 0x27c5
leaq 0x7b0a(%rip), %rdi      # 0xa2b7
leaq 0x7964(%rip), %rsi      # 0xa118
movl $0x1d, %edx
leaq 0x7ad1(%rip), %rcx      # 0xa291
callq 0x2120
callq 0x21f0
movq %rax, -0x10(%rbp)
movq -0x10(%rbp), %rdi
movq 0xb9d7(%rip), %rsi      # 0xe1b0
xorl %eax, %eax
movl %eax, %edx
callq 0x2150
movl %eax, -0x1c(%rbp)
cmpl $0x1, -0x1c(%rbp)
jne 0x27ed
jmp 0x280c
leaq 0x7ad2(%rip), %rdi      # 0xa2c6
leaq 0x791d(%rip), %rsi      # 0xa118
movl $0x29, %edx
leaq 0x7a8a(%rip), %rcx      # 0xa291
callq 0x2120
movq -0x10(%rbp), %rdi
movq -0x8(%rbp), %rax
movq (%rax), %rsi
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rdx
callq 0x22e0
movl %eax, -0x1c(%rbp)
cmpl $0x1, -0x1c(%rbp)
jne 0x282f
jmp 0x284e
leaq 0x7a90(%rip), %rdi      # 0xa2c6
leaq 0x78db(%rip), %rsi      # 0xa118
movl $0x2c, %edx
leaq 0x7a48(%rip), %rcx      # 0xa291
callq 0x2120
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rax
movq (%rax), %rsi
leaq -0x20(%rbp), %rdx
callq 0x2100
movl %eax, -0x1c(%rbp)
cmpl $0x1, -0x1c(%rbp)
jne 0x286d
jmp 0x288c
leaq 0x7a52(%rip), %rdi      # 0xa2c6
leaq 0x789d(%rip), %rsi      # 0xa118
movl $0x2f, %edx
leaq 0x7a0a(%rip), %rcx      # 0xa291
callq 0x2120
movl -0x20(%rbp), %eax
movl %eax, %ecx
movq -0x18(%rbp), %rax
movq %rcx, 0x8(%rax)
movq -0x10(%rbp), %rdi
callq 0x22c0
movq -0x18(%rbp), %rax
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/ramirezsebas[P]TP-LISTINGS/./src/capitulo_2/2.1/arglist.c
// Function: main
int main (int argc, char* argv[])
{
  printf ("The name of this program is ‘%s’.\n", argv[0]);
  printf ("This program was invoked with %d arguments.\n", argc - 1);
  /* Were any command-line arguments specified?*/
  if (argc > 1) {
    /* Yes, print them. */
    int i;
    printf ("The arguments are:\n");
    for (i = 1; i < argc; ++i)
      printf ("  %s\n", argv[i]);
  }
  return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movl $0x0, -0x4(%rbp)
movl %edi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x10(%rbp), %rax
movq (%rax), %rsi
leaq 0xea0(%rip), %rdi       # 0x2004
movb $0x0, %al
callq 0x1030
movl -0x8(%rbp), %esi
subl $0x1, %esi
leaq 0xeb3(%rip), %rdi       # 0x202b
movb $0x0, %al
callq 0x1030
cmpl $0x1, -0x8(%rbp)
jle 0x11c9
leaq 0xecc(%rip), %rdi       # 0x2058
movb $0x0, %al
callq 0x1030
movl $0x1, -0x14(%rbp)
movl -0x14(%rbp), %eax
cmpl -0x8(%rbp), %eax
jge 0x11c7
movq -0x10(%rbp), %rax
movslq -0x14(%rbp), %rcx
movq (%rax,%rcx,8), %rsi
leaq 0xeb7(%rip), %rdi       # 0x206c
movb $0x0, %al
callq 0x1030
movl -0x14(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x14(%rbp)
jmp 0x119a
jmp 0x11c9
xorl %eax, %eax
addq $0x20, %rsp
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O0/g3ida[P]g3idaCompiler/vm.cpp
// Function: unilexId(char const*)
static InstructionSet unilexId (const char * s)
{ int i;
  for (i=0;i<(int)NUM_ELEMENTS;i++)
    if (!strcmp(s,reserved[i].str))
      return reserved[i].is;
  return NUM_ELEMENTS;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movl $0x0, -0x14(%rbp)
cmpl $0x19, -0x14(%rbp)
jge 0x2753
movq -0x10(%rbp), %rdi
movslq -0x14(%rbp), %rcx
leaq 0xba38(%rip), %rax      # 0xe150
shlq $0x4, %rcx
addq %rcx, %rax
movq (%rax), %rsi
callq 0x21d0
cmpl $0x0, %eax
jne 0x2746
movslq -0x14(%rbp), %rcx
leaq 0xba19(%rip), %rax      # 0xe150
shlq $0x4, %rcx
addq %rcx, %rax
movl 0x8(%rax), %eax
movl %eax, -0x4(%rbp)
jmp 0x275a
jmp 0x2748
movl -0x14(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x14(%rbp)
jmp 0x2703
movl $0x19, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/g3ida[P]g3idaCompiler/vm.cpp
// Function: unilexIdNumArgs(char const*)
static int unilexIdNumArgs (const char * s)
{ int i;
  for (i=0;i<(int)NUM_ELEMENTS;i++)
    if (!strcmp(s,reserved[i].str))
      return reserved[i].argc;
  return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movl $0x0, -0x14(%rbp)
cmpl $0x19, -0x14(%rbp)
jge 0x27d3
movq -0x10(%rbp), %rdi
movslq -0x14(%rbp), %rcx
leaq 0xb9b8(%rip), %rax      # 0xe150
shlq $0x4, %rcx
addq %rcx, %rax
movq (%rax), %rsi
callq 0x21d0
cmpl $0x0, %eax
jne 0x27c6
movslq -0x14(%rbp), %rcx
leaq 0xb999(%rip), %rax      # 0xe150
shlq $0x4, %rcx
addq %rcx, %rax
movl 0xc(%rax), %eax
movl %eax, -0x4(%rbp)
jmp 0x27da
jmp 0x27c8
movl -0x14(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x14(%rbp)
jmp 0x2783
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/openshmem-org[P]openshmem-examples/c/dtrand.c
// Function: table_update
void
table_update(int nv, int idx)
{
    const int q = OWNER(idx);   /* PE that owns this index */
    const int off = OFFSET(idx);    /* local table offset */

    shmem_set_lock(&lock[idx]);

    shmem_int_p(&table[off], nv, q);

    shmem_clear_lock(&lock[idx]);
}

// Assembly:
subq $0x18, %rsp
movl %edi, 0x14(%rsp)
movl %esi, 0x10(%rsp)
movl 0x10(%rsp), %eax
cltd
idivl 0x2e71(%rip)            # 0x40a8
movl %eax, 0xc(%rsp)
movl 0x10(%rsp), %eax
cltd
idivl 0x2e62(%rip)            # 0x40a8
movl %edx, 0x8(%rsp)
movq 0x2e5f(%rip), %rdi      # 0x40b0
movslq 0x10(%rsp), %rax
shlq $0x3, %rax
addq %rax, %rdi
callq 0x1060
movq 0x2e4f(%rip), %rdi      # 0x40b8
movslq 0x8(%rsp), %rax
shlq $0x2, %rax
addq %rax, %rdi
movl 0x14(%rsp), %esi
movl 0xc(%rsp), %edx
callq 0x1040
movq 0x2e27(%rip), %rdi      # 0x40b0
movslq 0x10(%rsp), %rax
shlq $0x3, %rax
addq %rax, %rdi
callq 0x1050
addq $0x18, %rsp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/openshmem-org[P]openshmem-examples/c/dtrand.c
// Function: table_dump
void
table_dump(void)
{
    int i;

    for (i = 0; i < ip_pe; i += 1) {
        printf("PE %4d: table[local %4d](global %4d) = %d\n",
               me, i, (me * ip_pe) + i, table[i]);
    }
}

// Assembly:
pushq %rax
movl $0x0, 0x4(%rsp)
movl 0x4(%rsp), %eax
cmpl 0x2df5(%rip), %eax      # 0x40a8
jge 0x12fb
movl 0x2e05(%rip), %esi      # 0x40c0
movl 0x4(%rsp), %edx
movl 0x2dfb(%rip), %ecx      # 0x40c0
imull 0x2ddc(%rip), %ecx      # 0x40a8
addl 0x4(%rsp), %ecx
movq 0x2de1(%rip), %rax      # 0x40b8
movslq 0x4(%rsp), %rdi
movl (%rax,%rdi,4), %r8d
leaq 0xd21(%rip), %rdi       # 0x2008
movb $0x0, %al
callq 0x1030
movl 0x4(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x4(%rsp)
jmp 0x12a9
popq %rax
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/adelciotto[P]plasma/src/palette_plasma.c
// Function: GetDisplayRefreshRate
int GetDisplayRefreshRate(SDL_DisplayMode displayMode) {
    int result = displayMode.refresh_rate;

    if (result == 0) {
        return DEFAULT_REFRESH_RATE;
    }

    return result;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
leaq 0x10(%rbp), %rax
movl 0xc(%rax), %eax
movl %eax, -0x8(%rbp)
cmpl $0x0, -0x8(%rbp)
jne 0x14fd
movl $0x3c, -0x4(%rbp)
jmp 0x1503
movl -0x8(%rbp), %eax
movl %eax, -0x4(%rbp)
movl -0x4(%rbp), %eax
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/adelciotto[P]plasma/src/palette_plasma.c
// Function: InitSDL
int InitSDL(void) {
    SDL_Init(SDL_INIT_VIDEO);

    if (SDL_GetDesktopDisplayMode(0, &displayMode) != 0) {
        return -1;
    }

    window = SDL_CreateWindow(WINDOW_TITLE, SDL_WINDOWPOS_CENTERED,
                              SDL_WINDOWPOS_CENTERED, width, height,
                              SDL_WINDOW_SHOWN | SDL_WINDOW_RESIZABLE);
    if (window == NULL) {
        return -1;
    }
    LogInfo("window created with size %dx%d", width, height);

    if (fullscreen) {
        SDL_SetWindowFullscreen(window, SDL_WINDOW_FULLSCREEN_DESKTOP);
    }

    SDL_ShowCursor(SDL_DISABLE);

    renderer = SDL_CreateRenderer(
        window, -1, SDL_RENDERER_ACCELERATED | SDL_RENDERER_PRESENTVSYNC);
    if (renderer == NULL) {
        return -1;
    }
    LogInfo("renderer created with logical size %dx%d", width, height);

    SDL_RenderSetLogicalSize(renderer, width, height);

    texture = SDL_CreateTexture(renderer, SDL_PIXELFORMAT_RGB888,
                                SDL_TEXTUREACCESS_STREAMING, width, height);
    if (texture == NULL) {
        return -1;
    }

    return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movl $0x20, %edi
callq 0x1150
xorl %edi, %edi
leaq 0x2c45(%rip), %rsi      # 0x4170
callq 0x11f0
cmpl $0x0, %eax
je 0x1541
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
jmp 0x1669
movl 0x2be1(%rip), %ecx      # 0x4128
movl 0x2bde(%rip), %r8d      # 0x412c
leaq 0xb33(%rip), %rdi       # 0x2088
movl $0x2fff0000, %edx       # imm = 0x2FFF0000
movl $0x24, %r9d
movl %edx, %esi
callq 0x1060
movq %rax, 0x2bd2(%rip)      # 0x4140
cmpq $0x0, 0x2bca(%rip)      # 0x4140
jne 0x1584
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
jmp 0x1669
movl 0x2b9e(%rip), %edx      # 0x4128
movl 0x2b9c(%rip), %ecx      # 0x412c
xorl %edi, %edi
leaq 0xafe(%rip), %rsi       # 0x2097
movb $0x0, %al
callq 0x1200
cmpl $0x0, 0x2bc1(%rip)      # 0x4168
je 0x15ba
movq 0x2b90(%rip), %rdi      # 0x4140
movl $0x1001, %esi           # imm = 0x1001
callq 0x1180
xorl %edi, %edi
callq 0x1220
movq 0x2b78(%rip), %rdi      # 0x4140
movl $0xffffffff, %esi       # imm = 0xFFFFFFFF
movl $0x6, %edx
callq 0x1040
movq %rax, 0x2b6a(%rip)      # 0x4148
cmpq $0x0, 0x2b62(%rip)      # 0x4148
jne 0x15f1
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
jmp 0x1669
movl 0x2b31(%rip), %edx      # 0x4128
movl 0x2b2f(%rip), %ecx      # 0x412c
xorl %edi, %edi
leaq 0xab0(%rip), %rsi       # 0x20b6
movb $0x0, %al
callq 0x1200
movq 0x2b34(%rip), %rdi      # 0x4148
movl 0x2b0e(%rip), %esi      # 0x4128
movl 0x2b0c(%rip), %edx      # 0x412c
callq 0x10b0
movq 0x2b1c(%rip), %rdi      # 0x4148
movl 0x2af6(%rip), %ecx      # 0x4128
movl 0x2af3(%rip), %r8d      # 0x412c
movl $0x16161804, %esi       # imm = 0x16161804
movl $0x1, %edx
callq 0x1210
movq %rax, 0x2b01(%rip)      # 0x4150
cmpq $0x0, 0x2af9(%rip)      # 0x4150
jne 0x1662
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
jmp 0x1669
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/adelciotto[P]plasma/src/palette_plasma.c
// Function: InitPalette
void InitPalette(void) {
    for (int x = 0; x < PALETTE_SIZE; x++) {
        Uint8 r = (Uint8)Max(128.0 + 128 * sin(PI * x / 32.0), 255);
        Uint8 b = (Uint8)Max(128.0 + 128 * sin(PI * x / 64.0), 255);
        palette[x] = RGBToUint32(r, 0, b);
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movl $0x0, -0x4(%rbp)
cmpl $0x100, -0x4(%rbp)      # imm = 0x100
jge 0x175d
cvtsi2sdl -0x4(%rbp), %xmm0
movsd 0x98f(%rip), %xmm1      # 0x2038
movsd %xmm1, -0x20(%rbp)
mulsd %xmm1, %xmm0
movsd 0x986(%rip), %xmm1      # 0x2040
mulsd %xmm1, %xmm0
callq 0x1090
movsd 0x97d(%rip), %xmm1      # 0x2048
movsd %xmm1, -0x18(%rbp)
mulsd %xmm1, %xmm0
addsd %xmm1, %xmm0
movsd 0x970(%rip), %xmm1      # 0x2050
movsd %xmm1, -0x10(%rbp)
callq 0x1330
movsd -0x20(%rbp), %xmm1
cvttsd2si %xmm0, %eax
movb %al, -0x5(%rbp)
cvtsi2sdl -0x4(%rbp), %xmm0
mulsd %xmm1, %xmm0
movsd 0x951(%rip), %xmm1      # 0x2058
mulsd %xmm1, %xmm0
callq 0x1090
movsd -0x18(%rbp), %xmm2
movsd -0x10(%rbp), %xmm1
mulsd %xmm2, %xmm0
addsd %xmm2, %xmm0
callq 0x1330
cvttsd2si %xmm0, %eax
movb %al, -0x6(%rbp)
movb -0x5(%rbp), %al
xorl %esi, %esi
movzbl %al, %edi
movzbl -0x6(%rbp), %edx
callq 0x1390
movl %eax, %edx
movslq -0x4(%rbp), %rcx
leaq 0x2a44(%rip), %rax      # 0x4190
movl %edx, (%rax,%rcx,4)
movl -0x4(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x4(%rbp)
jmp 0x168f
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/adelciotto[P]plasma/src/palette_plasma.c
// Function: DrawFrame
void DrawFrame(double elapsedTimeInMs) {
    int paletteShift = (int)(elapsedTimeInMs / 32.0);

    for (int y = 0; y < height; y++) {
        for (int x = 0; x < width; x++) {
            int index = Get1DArrayIndex(x, y, width);

            pixelBuffer[index] =
                palette[(plasmaBuffer[index] + paletteShift) % PALETTE_SIZE];
        }
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movsd %xmm0, -0x8(%rbp)
movsd -0x8(%rbp), %xmm0
movsd 0x6ee(%rip), %xmm1      # 0x2078
divsd %xmm1, %xmm0
cvttsd2si %xmm0, %eax
movl %eax, -0xc(%rbp)
movl $0x0, -0x10(%rbp)
movl -0x10(%rbp), %eax
cmpl 0x2787(%rip), %eax      # 0x412c
jge 0x1a17
movl $0x0, -0x14(%rbp)
movl -0x14(%rbp), %eax
cmpl 0x2771(%rip), %eax      # 0x4128
jge 0x1a0a
movl -0x14(%rbp), %edi
movl -0x10(%rbp), %esi
movl 0x2763(%rip), %edx      # 0x4128
callq 0x1370
movl %eax, -0x18(%rbp)
movq 0x278c(%rip), %rax      # 0x4160
movslq -0x18(%rbp), %rcx
movl (%rax,%rcx,4), %eax
addl -0xc(%rbp), %eax
andl $0xff, %eax
movl %eax, %eax
movl %eax, %ecx
leaq 0x27a2(%rip), %rax      # 0x4190
movl (%rax,%rcx,4), %edx
movq 0x2760(%rip), %rax      # 0x4158
movslq -0x18(%rbp), %rcx
movl %edx, (%rax,%rcx,4)
movl -0x14(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x14(%rbp)
jmp 0x19ae
jmp 0x1a0c
movl -0x10(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x10(%rbp)
jmp 0x199c
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/adelciotto[P]plasma/src/palette_plasma.c
// Function: DestroySDL
void DestroySDL(void) {
    SDL_DestroyTexture(texture);
    SDL_DestroyRenderer(renderer);
    SDL_DestroyWindow(window);
    SDL_Quit();
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq 0x2725(%rip), %rdi      # 0x4150
callq 0x1100
movq 0x2711(%rip), %rdi      # 0x4148
callq 0x10c0
movq 0x26fd(%rip), %rdi      # 0x4140
callq 0x1030
callq 0x1070
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/OhYee[P]computer_application_programming_experiment/hash_search/bf_search/bf_search.c
// Function: bg_init
bit_group *bg_init(unsigned long long size) {
    bit_group *bg = mp_new(sizeof(bit_group));
    bg->group_number = size / group_type_size;
    bg->bits = mp_new(sizeof(group_type) * bg->group_number);
    bg_reset(bg);
    return bg;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movl $0x10, %edi
callq 0x32a0
movq %rax, -0x10(%rbp)
movq -0x8(%rbp), %rcx
shrq $0x5, %rcx
movq -0x10(%rbp), %rax
movq %rcx, 0x8(%rax)
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rax
shlq $0x2, %rax
movl %eax, %edi
callq 0x32a0
movq %rax, %rcx
movq -0x10(%rbp), %rax
movq %rcx, (%rax)
movq -0x10(%rbp), %rdi
callq 0x48b0
movq -0x10(%rbp), %rax
addq $0x10, %rsp
popq %rbp
retq
nopw (%rax,%rax)