LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O2/bobrippling[P]tim/tabs.c
// Function: tabs_init
void tabs_init(enum init_args init_args, unsigned off)
{
	char *next = args_next_fname(true);

	if(next){
		const char *err = NULL;
		buffer_t *buf;

		if(!strcmp(next, "-")){
			buf = buffer_new_file_nofind(stdin);
			buf->modified = true; /* editing a stream */
			/* no filename */

			if(ferror(stdin))
				err = strerror(errno);

			freopen("/dev/tty", "r", stdin);
			/* if we can't open it we'll exit soon anyway */

		}else{
			buffer_new_fname(&buf, next, &err);
		}

		if(err)
			ui_err("\"%s\": %s", next, err);

		tab *tab = tab_new(window_new(buf));
		buffer_release(buf);

		tabs_set_cur(tab);

		switch(init_args){
			case INIT_NONE:
				break;

			case INIT_VALL:
				load_argv(win_add_splitright);
				break;

			case INIT_HALL:
				load_argv(win_add_splittop);
				break;
		}

	}else{
		buffer_t *empty = buffer_new();

		window *win = window_new(empty);
		buffer_release(empty);

		tab *tab = tab_new(win);

		tabs_set_cur(tab);
	}

	tabs_set_first(tabs_cur());

	windows_cur()->ui_pos->y = off;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movl %esi, %ebx
movl %edi, %ebp
pushq $0x1
popq %rdi
callq 0x465c
testq %rax, %rax
je 0xd345
movq %rax, %r14
andq $0x0, 0x10(%rsp)
cmpb $0x2d, (%rax)
jne 0xd2d4
cmpb $0x0, 0x1(%r14)
je 0xd3ad
leaq 0x8(%rsp), %rdi
leaq 0x10(%rsp), %r15
movq %r14, %rsi
movq %r15, %rdx
callq 0x8ba2
movq (%r15), %r15
testq %r15, %r15
je 0xd305
leaq 0x1781(%rip), %rdi      # 0xea79
movq %r14, %rsi
movq %r15, %rdx
xorl %eax, %eax
callq 0x4c34
movq 0x8(%rsp), %rdi
callq 0xce57
movq %rax, %rdi
callq 0xd19c
movq %rax, %r14
movq 0x8(%rsp), %rdi
leaq -0x48ee(%rip), %rsi     # 0x8a38
callq 0xc25f
movq %r14, 0x90e6(%rip)      # 0x16418
cmpl $0x1, %ebp
je 0xd378
cmpl $0x2, %ebp
jne 0xd384
leaq 0x150(%rip), %rdi       # 0xd493
jmp 0xd37f
callq 0x8a57
movq %rax, %r14
movq %rax, %rdi
callq 0xce57
movq %rax, %r15
leaq -0x4927(%rip), %rsi     # 0x8a38
movq %r14, %rdi
callq 0xc25f
movq %r15, %rdi
callq 0xd19c
movq %rax, 0x90a2(%rip)      # 0x16418
jmp 0xd38b
leaq 0x109(%rip), %rdi       # 0xd488
callq 0xd40e
movq 0x908d(%rip), %rax      # 0x16418
movq %rax, 0x908e(%rip)      # 0x16420
callq 0xd170
movq 0x30(%rax), %rax
movl %ebx, 0x4(%rax)
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq 0x8bec(%rip), %r13      # 0x15fa0
movq (%r13), %rdi
callq 0x8b6f
movq %rax, 0x8(%rsp)
movb $0x1, 0x39(%rax)
movq (%r13), %r12
movq %r12, %rdi
callq 0x40f0
testl %eax, %eax
je 0xd3f0
callq 0x40a0
movl (%rax), %edi
callq 0x44e0
movq %rax, %r15
movq %rax, 0x10(%rsp)
movq (%r13), %r12
jmp 0xd3f3
xorl %r15d, %r15d
leaq 0x1676(%rip), %rdi      # 0xea70
leaq 0xfec(%rip), %rsi       # 0xe3ed
movq %r12, %rdx
callq 0x4250
jmp 0xd2ec
// File: /workspace/github_c_makefile_star2_O2/bobrippling[P]tim/tabs.c
// Function: load_argv
static void load_argv(void onload(window *cur, window *new))
{
	window *prev_win = windows_cur();
	char *next;

	while((next = args_next_fname(true))){
		buffer_t *buf;
		const char *err;

		buffer_new_fname(&buf, next, &err);

		window *w = window_new(buf);

		buffer_release(buf);

		onload(prev_win, w);

		prev_win = w;
	}
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %rdi, %rbx
callq 0xd170
movq %rax, %r14
pushq $0x1
popq %rbp
leaq 0x10(%rsp), %r15
leaq -0x49fe(%rip), %r13     # 0x8a38
movl %ebp, %edi
callq 0x465c
testq %rax, %rax
je 0xd479
leaq 0x8(%rsp), %rdi
movq %rax, %rsi
movq %r15, %rdx
callq 0x8ba2
movq 0x8(%rsp), %rdi
callq 0xce57
movq %rax, %r12
movq 0x8(%rsp), %rdi
movq %r13, %rsi
callq 0xc25f
movq %r14, %rdi
movq %r12, %rsi
callq *%rbx
movq %r12, %r14
jmp 0xd436
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/bobrippling[P]tim/ctags.c
// Function: ctag_search
bool ctag_search(const char *ident, struct ctag_result *tag)
{
	FILE *f = fopen("tags", "r");
	if(!f)
		return false;

	bool found = false;

	char buf[256];
	while(fgets(buf, sizeof buf, f)){
		char *end = strchr(buf, '\t');
		if(!end || !end[1])
			continue;
		*end = '\0';
		if(!strcmp(buf, ident)){
			char *fname = end + 1;
			end = strchr(end + 1, '\t');
			if(!end || !end[1])
				continue;
			*end = '\0';

			char *nl = strchr(end + 1, '\n');
			if(nl)
				*nl = '\0';

			tag->fname = ustrdup(fname);
			tag->line = ustrdup(end + 1);
			found = true;
			break;
		}
	}

	fclose(f);
	return found;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x118, %rsp            # imm = 0x118
movq %rsi, %rbx
movq %rdi, %r15
leaq 0x15a4(%rip), %rdi      # 0xea82
leaq 0xf08(%rip), %rsi       # 0xe3ed
callq 0x4440
testq %rax, %rax
je 0xd5a2
movq %rax, %r14
movq %rbx, 0x8(%rsp)
leaq 0x10(%rsp), %r12
pushq $0x9
popq %rbx
movq %r12, %rdi
movl $0x100, %esi            # imm = 0x100
movq %r14, %rdx
callq 0x42c0
testq %rax, %rax
setne %bpl
je 0xd598
movq %r12, %rdi
movl %ebx, %esi
callq 0x41c0
testq %rax, %rax
je 0xd503
movq %rax, %r13
cmpb $0x0, 0x1(%rax)
je 0xd503
movb $0x0, (%r13)
movq %r12, %rdi
movq %r15, %rsi
callq 0x42e0
testl %eax, %eax
jne 0xd503
incq %r13
movq %r13, %rdi
movl %ebx, %esi
callq 0x41c0
testq %rax, %rax
je 0xd503
cmpb $0x0, 0x1(%rax)
je 0xd503
movq %rax, %rbx
incq %rbx
movb $0x0, (%rax)
pushq $0xa
popq %rsi
movq %rbx, %rdi
callq 0x41c0
testq %rax, %rax
je 0xd57c
movb $0x0, (%rax)
movq %r13, %rdi
callq 0x5672
movq 0x8(%rsp), %r15
movq %rax, (%r15)
movq %rbx, %rdi
callq 0x5672
movq %rax, 0x8(%r15)
movq %r14, %rdi
callq 0x4150
jmp 0xd5a4
xorl %ebp, %ebp
movl %ebp, %eax
addq $0x118, %rsp            # imm = 0x118
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/codeniko[P]CS214-Malloc-Free/Test11.c
// Function: main
void main()
{
    void* p;
    int i;
    for(i = 1; (p = malloc(i)) != NULL; i++){
        printf("%d bytes allocated\n", i);
        free(p);
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
pushq $0x1
popq %rbx
leaq 0xea0(%rip), %r14       # 0x2004
pushq $0x8
popq %r15
pushq $0xa
popq %r13
movl %ebx, %edi
movq %r14, %rsi
movl %r15d, %edx
callq 0x11b4
testq %rax, %rax
je 0x11a3
movq %rax, %r12
leaq 0xe85(%rip), %rdi       # 0x200d
movl %ebx, %esi
xorl %eax, %eax
callq 0x1030
movq %r12, %rdi
movq %r14, %rsi
movl %r13d, %edx
callq 0x12ed
incl %ebx
jmp 0x116c
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O2/darwin-on-arm[P]darwin-sdk/xcode_tools/xcrun/ini.c
// Function: rstrip
static char* rstrip(char* s)
{
    char* p = s + strlen(s);
    while (p > s && isspace((unsigned char)(*--p)))
        *p = '\0';
    return s;
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
callq 0x20a0
movq %rax, %r14
addq %rbx, %r14
cmpq %rbx, %r14
jbe 0x2588
callq 0x2220
movq (%rax), %rax
movzbl -0x1(%r14), %ecx
testb $0x20, 0x1(%rax,%rcx,2)
je 0x2588
decq %r14
movb $0x0, (%r14)
jmp 0x2566
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O2/darwin-on-arm[P]darwin-sdk/xcode_tools/xcrun/ini.c
// Function: find_char_or_comment
static char* find_char_or_comment(const char* s, char c)
{
    int was_whitespace = 0;
    while (*s && *s != c && !(was_whitespace && *s == ';')) {
        was_whitespace = isspace((unsigned char)(*s));
        s++;
    }
    return (char*)s;
}

// Assembly:
pushq %rbp
pushq %r14
pushq %rbx
movl %esi, %ebp
movq %rdi, %rbx
xorl %eax, %eax
movzbl (%rbx), %r14d
testq %r14, %r14
je 0x25cd
cmpb %bpl, %r14b
je 0x25cd
testl %eax, %eax
je 0x25b6
cmpb $0x3b, %r14b
je 0x25cd
callq 0x2220
movq (%rax), %rax
movzwl (%rax,%r14,2), %eax
andl $0x2000, %eax           # imm = 0x2000
incq %rbx
jmp 0x259e
movq %rbx, %rax
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/darwin-on-arm[P]darwin-sdk/xcode_tools/xcrun/ini.c
// Function: ini_parse
int ini_parse(const char* filename,
              int (*handler)(void*, const char*, const char*, const char*),
              void* user)
{
    FILE* file;
    int error;

    file = fopen(filename, "r");
    if (!file)
        return -1;
    error = ini_parse_file(file, handler, user);
    fclose(file);
    return error;
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rdx, %rbx
movq %rsi, %r14
leaq 0x1a08(%rip), %rsi      # 0x4004
callq 0x2190
testq %rax, %rax
je 0x2625
movq %rax, %r15
movq %rax, %rdi
movq %r14, %rsi
movq %rbx, %rdx
callq 0x232c
movl %eax, %ebx
movq %r15, %rdi
callq 0x2090
movl %ebx, %eax
jmp 0x2628
pushq $-0x1
popq %rax
popq %rbx
popq %r14
popq %r15
retq
nop
// File: /workspace/github_c_makefile_star2_O2/darwin-on-arm[P]darwin-sdk/xcode_tools/xcrun/xcrun.c
// Function: validate_directory_path
static int validate_directory_path(const char *dir)
{
	struct stat fstat;

	if (stat(dir, &fstat) != 0) {
		fprintf(stderr, "xcrun: error: unable to validate path \'%s\' (%s)\n", dir, strerror(errno));
		return -1;
	}

	if (S_ISDIR(fstat.st_mode) == 0) {
		fprintf(stderr, "xcrun: error: \'%s\' is not a valid path\n", dir);
		return -1;
	}

	return 0;
}

// Assembly:
pushq %r14
pushq %rbx
subq $0x98, %rsp
movq %rdi, %rbx
leaq 0x8(%rsp), %rsi
callq 0x2150
testl %eax, %eax
jne 0x3745
movl $0xf000, %ecx           # imm = 0xF000
andl 0x20(%rsp), %ecx
xorl %eax, %eax
cmpl $0x4000, %ecx           # imm = 0x4000
jne 0x3774
addq $0x98, %rsp
popq %rbx
popq %r14
retq
movq 0x38a4(%rip), %rax      # 0x6ff0
movq (%rax), %r14
callq 0x2050
movl (%rax), %edi
callq 0x2210
leaq 0x11a5(%rip), %rsi      # 0x4907
movq %r14, %rdi
movq %rbx, %rdx
movq %rax, %rcx
xorl %eax, %eax
callq 0x2130
jmp 0x378f
movq 0x3875(%rip), %rax      # 0x6ff0
movq (%rax), %rdi
leaq 0x11b3(%rip), %rsi      # 0x4938
movq %rbx, %rdx
xorl %eax, %eax
callq 0x2130
pushq $-0x1
popq %rax
jmp 0x373a
// File: /workspace/github_c_makefile_star2_O2/darwin-on-arm[P]darwin-sdk/xcode_tools/xcrun/xcrun.c
// Function: stripext
static void stripext(char *dst, const char *src)
{
	int len;
	char *s;

	if ((s = strchr(src, '.')) != NULL)
		len = (s - src);
	else
		len = strlen(src);

	strncpy(dst, src, len);
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq %rdi, %r14
pushq $0x2e
popq %rsi
movq %rbx, %rdi
callq 0x20b0
testq %rax, %rax
je 0x37b3
subq %rbx, %rax
jmp 0x37bb
movq %rbx, %rdi
callq 0x20a0
movslq %eax, %rdx
movq %r14, %rdi
movq %rbx, %rsi
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x2060
// File: /workspace/github_c_makefile_star2_O2/darwin-on-arm[P]darwin-sdk/xcode_tools/xcrun/xcrun.c
// Function: get_default_info
static default_config get_default_info(const char *path)
{
	default_config config;

	if (ini_parse(path, default_cfg_handler, &config) != (-1))
		return config;

	fprintf(stderr, "xcrun: error: failed to retrieve default info from '\%s\'. (%s)\n", path, strerror(errno));

	exit(1);
}

// Assembly:
pushq %rbx
subq $0x10, %rsp
leaq 0xbe3(%rip), %rdi       # 0x43bf
leaq 0x3cc(%rip), %rsi       # 0x3baf
movq %rsp, %rdx
callq 0x25ea
cmpl $-0x1, %eax
je 0x37ff
movq (%rsp), %rax
movq 0x8(%rsp), %rdx
addq $0x10, %rsp
popq %rbx
retq
movq 0x37ea(%rip), %rax      # 0x6ff0
movq (%rax), %rbx
callq 0x2050
movl (%rax), %edi
callq 0x2210
leaq 0x115c(%rip), %rsi      # 0x4978
leaq 0xb9c(%rip), %rdx       # 0x43bf
movq %rbx, %rdi
movq %rax, %rcx
xorl %eax, %eax
callq 0x2130
pushq $0x1
popq %rdi
callq 0x21e0
// File: /workspace/github_c_makefile_star2_O2/darwin-on-arm[P]darwin-sdk/xcode_tools/xcrun/xcrun.c
// Function: get_sdk_path
static char *get_sdk_path(const char *name)
{
	char *devpath, *path;

	devpath = developer_dir;
	path = (char *)calloc(PATH_MAX, sizeof(char));

	if (devpath == NULL) {
		fprintf(stderr, "xcrun: error: failed to retrieve developer path, do you have it set?\n");
		goto failure;
	}

	sprintf(path, "%s/SDKs/%s.sdk", devpath, name);
	if (validate_directory_path(path) != (-1))
		return path;

	fprintf(stderr, "xcrun: error: \'%s\' is not a valid sdk path.\n", path);

failure:
	free(path);
	exit(1);
}

// Assembly:
pushq %rbx
pushq $0x1
popq %rsi
movl $0x1000, %edi           # imm = 0x1000
callq 0x2110
movq %rax, %rbx
leaq 0x117a(%rip), %rsi      # 0x49ca
leaq 0x3af9(%rip), %rdx      # 0x7350
leaq 0x4b52(%rip), %rcx      # 0x83b0
movq %rax, %rdi
xorl %eax, %eax
callq 0x21d0
movq %rbx, %rdi
callq 0x370c
cmpl $-0x1, %eax
je 0x387a
movq %rbx, %rax
popq %rbx
retq
movq 0x376f(%rip), %rax      # 0x6ff0
movq (%rax), %rdi
leaq 0x114e(%rip), %rsi      # 0x49d9
movq %rbx, %rdx
xorl %eax, %eax
callq 0x2130
movq %rbx, %rdi
callq 0x2040
pushq $0x1
popq %rdi
callq 0x21e0
// File: /workspace/github_c_makefile_star2_O2/darwin-on-arm[P]darwin-sdk/xcode_tools/xcrun/xcrun.c
// Function: get_sdk_info
static sdk_config get_sdk_info(const char *path)
{
	sdk_config config;
	char info_path[PATH_MAX] = { 0 };

	sprintf(info_path, "%s/info.ini", path);

	if (ini_parse(info_path, sdk_cfg_handler, &config) != (-1))
		return config;

	fprintf(stderr, "xcrun: error: failed to retrieve sdk info from '\%s\'. (%s)\n", info_path, strerror(errno));

	exit(1);
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
subq $0x1000, %rsp           # imm = 0x1000
movq %rsi, %r14
movq %rdi, %rbx
movq %rsp, %r15
movl $0x1000, %edx           # imm = 0x1000
movq %r15, %rdi
xorl %esi, %esi
callq 0x20d0
leaq 0x1136(%rip), %rsi      # 0x4a06
movq %r15, %rdi
movq %r14, %rdx
xorl %eax, %eax
callq 0x21d0
leaq 0x354(%rip), %rsi       # 0x3c38
movq %r15, %rdi
movq %rbx, %rdx
callq 0x25ea
cmpl $-0x1, %eax
je 0x3904
movq %rbx, %rax
addq $0x1000, %rsp           # imm = 0x1000
popq %rbx
popq %r14
popq %r15
retq
movq 0x36e5(%rip), %rax      # 0x6ff0
movq (%rax), %rbx
callq 0x2050
movl (%rax), %edi
callq 0x2210
leaq 0x10f1(%rip), %rsi      # 0x4a12
movq %rsp, %rdx
movq %rbx, %rdi
movq %rax, %rcx
xorl %eax, %eax
callq 0x2130
pushq $0x1
popq %rdi
callq 0x21e0
// File: /workspace/github_c_makefile_star2_O2/darwin-on-arm[P]darwin-sdk/xcode_tools/xcrun/xcrun.c
// Function: get_toolchain_path
static char *get_toolchain_path(const char *name)
{
	char *devpath, *path;

	devpath = developer_dir;
	path = (char *)calloc(PATH_MAX, sizeof(char));

	if (devpath == NULL) {
		fprintf(stderr, "xcrun: error: failed to retrieve developer path, do you have it set?\n");
		goto failure;
	}

	sprintf(path, "%s/Toolchains/%s.toolchain", devpath, name);
	if (validate_directory_path(path) != (-1))
		return path;

	fprintf(stderr, "xcrun: error: \'%s\' is not a valid toolchain path.\n", path);

failure:
	free(path);
	exit(1);
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %r14
pushq $0x1
popq %rsi
movl $0x1000, %edi           # imm = 0x1000
callq 0x2110
movq %rax, %rbx
leaq 0x1137(%rip), %rsi      # 0x4a8e
leaq 0x39f2(%rip), %rdx      # 0x7350
movq %rax, %rdi
movq %r14, %rcx
xorl %eax, %eax
callq 0x21d0
movq %rbx, %rdi
callq 0x370c
cmpl $-0x1, %eax
je 0x3983
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
movq 0x3666(%rip), %rax      # 0x6ff0
movq (%rax), %rdi
leaq 0x1115(%rip), %rsi      # 0x4aa9
movq %rbx, %rdx
xorl %eax, %eax
callq 0x2130
movq %rbx, %rdi
callq 0x2040
pushq $0x1
popq %rdi
callq 0x21e0
// File: /workspace/github_c_makefile_star2_O2/darwin-on-arm[P]darwin-sdk/xcode_tools/xcrun/xcrun.c
// Function: get_toolchain_info
static toolchain_config get_toolchain_info(const char *path)
{
	toolchain_config config;
	char info_path[PATH_MAX] = { 0 };

	sprintf(info_path, "%s/info.ini", path);

	if (ini_parse(info_path, toolchain_cfg_handler, &config) != (-1))
		return config;

	fprintf(stderr, "xcrun: error: failed to retrieve toolchain info from '\%s\'. (%s)\n", info_path, strerror(errno));

	exit(1);
}

// Assembly:
pushq %r14
pushq %rbx
subq $0x1018, %rsp           # imm = 0x1018
movq %rdi, %rbx
leaq 0x10(%rsp), %r14
movl $0x1000, %edx           # imm = 0x1000
movq %r14, %rdi
xorl %esi, %esi
callq 0x20d0
leaq 0x1030(%rip), %rsi      # 0x4a06
movq %r14, %rdi
movq %rbx, %rdx
xorl %eax, %eax
callq 0x21d0
leaq 0x35d(%rip), %rsi       # 0x3d47
movq %rsp, %rdx
movq %r14, %rdi
callq 0x25ea
cmpl $-0x1, %eax
je 0x3a0e
movq (%rsp), %rax
movq 0x8(%rsp), %rdx
addq $0x1018, %rsp           # imm = 0x1018
popq %rbx
popq %r14
retq
movq 0x35db(%rip), %rax      # 0x6ff0
movq (%rax), %rbx
callq 0x2050
movl (%rax), %edi
callq 0x2210
leaq 0x10b1(%rip), %rsi      # 0x4adc
leaq 0x10(%rsp), %rdx
movq %rbx, %rdi
movq %rax, %rcx
xorl %eax, %eax
callq 0x2130
pushq $0x1
popq %rdi
callq 0x21e0
// File: /workspace/github_c_makefile_star2_O2/darwin-on-arm[P]darwin-sdk/xcode_tools/xcrun/xcrun.c
// Function: get_target_triple
static char *get_target_triple(const char *current_sdk)
{
	char *triple, *default_arch, *deployment_target;

	if ((triple = getenv("TARGET_TRIPLE")) != NULL)
		return triple;

	triple = (char *)calloc(NAME_MAX, sizeof(char));

	if ((default_arch = strdup(get_sdk_info(get_sdk_path(current_sdk)).default_arch)) == NULL)
		return NULL;

	if ((deployment_target = strdup(get_sdk_info(get_sdk_path(current_sdk)).deployment_target)) == NULL)
		return NULL;

	parse_target_triple(triple, deployment_target, default_arch);

	return triple;
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
subq $0x50, %rsp
leaq 0x10c8(%rip), %rdi      # 0x4b1d
callq 0x2030
movq %rax, %rbx
testq %rax, %rax
jne 0x3b95
pushq $0x1
popq %rsi
movl $0xff, %edi
callq 0x2110
movq %rax, %rbx
callq 0x3838
leaq 0x28(%rsp), %r14
movq %r14, %rdi
movq %rax, %rsi
callq 0x38a5
movq 0x18(%r14), %rdi
callq 0x2200
testq %rax, %rax
je 0x3aea
movq %rax, %r14
callq 0x3838
movq %rsp, %r15
movq %r15, %rdi
movq %rax, %rsi
callq 0x38a5
movq 0x20(%r15), %rdi
callq 0x2200
testq %rax, %rax
je 0x3aea
movq %rax, %r15
leaq 0x1064(%rip), %rsi      # 0x4b2b
movq %r14, %rdi
callq 0x2120
testl %eax, %eax
je 0x3af1
leaq 0x1058(%rip), %rsi      # 0x4b32
movq %r14, %rdi
callq 0x2120
testl %eax, %eax
je 0x3af1
xorl %eax, %eax
jmp 0x3af3
xorl %ebx, %ebx
jmp 0x3b95
movb $0x1, %al
xorl %ecx, %ecx
pushq $0x1
popq %rsi
pushq $0x2
popq %rdi
movl %esi, %r8d
xorl %edx, %edx
movsbl (%r15), %r9d
leal -0x30(%r9), %r10d
cmpb $0x9, %r10b
ja 0x3b28
cmpl $0x2, %r8d
je 0x3b2d
cmpl $0x1, %r8d
jne 0x3b39
imull $0xa, %ecx, %ecx
addl %r9d, %ecx
addl $-0x30, %ecx
movl %esi, %r8d
jmp 0x3b39
incl %r8d
jmp 0x3b39
imull $0xa, %edx, %edx
addl %r9d, %edx
addl $-0x30, %edx
movl %edi, %r8d
incq %r15
testb %r9b, %r9b
jne 0x3b00
addl $-0x2, %ecx
cmpl $0x9, %ecx
ja 0x3b5d
leaq 0x50c(%rip), %rsi       # 0x405c
movslq (%rsi,%rcx,4), %rcx
addq %rsi, %rcx
jmpq *%rcx
pushq $0xe
jmp 0x3b80
pushq $0x9
jmp 0x3b80
pushq $0x11
jmp 0x3b80
pushq $0xd
jmp 0x3b80
pushq $0xf
jmp 0x3b80
xorl %ecx, %ecx
cmpl $0x3, %edx
setl %cl
xorl $0xb, %ecx
jmp 0x3b81
pushq $0xb
jmp 0x3b80
pushq $0xa
popq %rcx
leaq 0xfaf(%rip), %rsi       # 0x4b37
movq %rbx, %rdi
movq %r14, %rdx
xorl %eax, %eax
callq 0x21d0
movq %rbx, %rax
addq $0x50, %rsp
popq %rbx
popq %r14
popq %r15
retq
addl $0x4, %edx
testb %al, %al
pushq $0x10
popq %rcx
cmovnel %edx, %ecx
jmp 0x3b81
// File: /workspace/github_c_makefile_star2_O2/darwin-on-arm[P]darwin-sdk/xcode_tools/xcrun/xcrun.c
// Function: default_cfg_handler
static int default_cfg_handler(void *user, const char *section, const char *name, const char *value)
{
	default_config *config = (default_config *)user;

	if (MATCH_INI_STON("SDK", "name"))
		config->sdk = strdup(value);
	else if (MATCH_INI_STON("TOOLCHAIN", "name"))
		config->toolchain = strdup(value);
	else
		return 0;

	return 1;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movq %rcx, %r14
movq %rdx, %r15
movq %rsi, %r12
movq %rdi, %rbx
leaq 0xded(%rip), %rsi       # 0x49b7
movq %r12, %rdi
callq 0x2120
testl %eax, %eax
jne 0x3be9
leaq 0xdde(%rip), %rsi       # 0x49bb
movq %r15, %rdi
callq 0x2120
testl %eax, %eax
je 0x3c1f
leaq 0xdd0(%rip), %rsi       # 0x49c0
movq %r12, %rdi
callq 0x2120
xorl %ebp, %ebp
testl %eax, %eax
jne 0x3c2d
leaq 0xdb6(%rip), %rsi       # 0x49bb
movq %r15, %rdi
callq 0x2120
testl %eax, %eax
jne 0x3c2d
movq %r14, %rdi
callq 0x2200
movq %rax, 0x8(%rbx)
jmp 0x3c2a
movq %r14, %rdi
callq 0x2200
movq %rax, (%rbx)
pushq $0x1
popq %rbp
movl %ebp, %eax
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/darwin-on-arm[P]darwin-sdk/xcode_tools/xcrun/xcrun.c
// Function: sdk_cfg_handler
static int sdk_cfg_handler(void *user, const char *section, const char *name, const char *value)
{
	sdk_config *config = (sdk_config *)user;

	if (MATCH_INI_STON("SDK", "name"))
		config->name = strdup(value);
	else if (MATCH_INI_STON("SDK", "version"))
		config->version = strdup(value);
	else if (MATCH_INI_STON("SDK", "toolchain"))
		config->toolchain = strdup(value);
	else if (MATCH_INI_STON("SDK", "default_arch"))
		config->default_arch = strdup(value);
	else if (MATCH_INI_STON("SDK", "iphoneos_deployment_target")) {
		ios_deployment_target_set = 1;
		macosx_deployment_target_set = 0;
		config->deployment_target = strdup(value);
	} else if (MATCH_INI_STON("SDK", "macosx_deployment_target")) {
		ios_deployment_target_set = 0;
		macosx_deployment_target_set = 1;
		config->deployment_target = strdup(value);
	} else
		return 0;

	return 1;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rcx, %r14
movq %rdx, %r15
movq %rsi, %rax
movq %rdi, %rbx
leaq 0xd65(%rip), %rsi       # 0x49b7
movq %rax, %rdi
callq 0x2120
xorl %ebp, %ebp
testl %eax, %eax
jne 0x3d3a
leaq 0xd50(%rip), %rsi       # 0x49bb
movq %r15, %rdi
callq 0x2120
testl %eax, %eax
je 0x3ce6
leaq 0x63b(%rip), %rsi       # 0x42b9
movq %r15, %rdi
callq 0x2120
testl %eax, %eax
je 0x3cf3
leaq 0xe0e(%rip), %rsi       # 0x4a9f
movq %r15, %rdi
callq 0x2120
testl %eax, %eax
je 0x3d01
leaq 0xda9(%rip), %rsi       # 0x4a4d
movq %r15, %rdi
callq 0x2120
testl %eax, %eax
je 0x3d0f
leaq 0xda3(%rip), %rsi       # 0x4a5a
movq %r15, %rdi
callq 0x2120
testl %eax, %eax
je 0x3d1d
leaq 0xdab(%rip), %rsi       # 0x4a75
movq %r15, %rdi
callq 0x2120
testl %eax, %eax
jne 0x3d3a
movb $0x0, 0x66e7(%rip)      # 0xa3c4
movb $0x1, 0x66e4(%rip)      # 0xa3c8
jmp 0x3d2b
movq %r14, %rdi
callq 0x2200
movq %rax, (%rbx)
jmp 0x3d37
movq %r14, %rdi
callq 0x2200
movq %rax, 0x8(%rbx)
jmp 0x3d37
movq %r14, %rdi
callq 0x2200
movq %rax, 0x10(%rbx)
jmp 0x3d37
movq %r14, %rdi
callq 0x2200
movq %rax, 0x18(%rbx)
jmp 0x3d37
movb $0x1, 0x66a0(%rip)      # 0xa3c4
movb $0x0, 0x669d(%rip)      # 0xa3c8
movq %r14, %rdi
callq 0x2200
movq %rax, 0x20(%rbx)
pushq $0x1
popq %rbp
movl %ebp, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/darwin-on-arm[P]darwin-sdk/xcode_tools/xcrun/xcrun.c
// Function: toolchain_cfg_handler
static int toolchain_cfg_handler(void *user, const char *section, const char *name, const char *value)
{
	toolchain_config *config = (toolchain_config *)user;

	if (MATCH_INI_STON("TOOLCHAIN", "name"))
		config->name = strdup(value);
	else if (MATCH_INI_STON("TOOLCHAIN", "version"))
		config->version = strdup(value);
	else
		return 0;

	return 1;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rcx, %r14
movq %rdx, %r15
movq %rsi, %rax
movq %rdi, %rbx
leaq 0xc5f(%rip), %rsi       # 0x49c0
movq %rax, %rdi
callq 0x2120
xorl %ebp, %ebp
testl %eax, %eax
jne 0x3db1
leaq 0xc45(%rip), %rsi       # 0x49bb
movq %r15, %rdi
callq 0x2120
testl %eax, %eax
je 0x3da3
leaq 0x530(%rip), %rsi       # 0x42b9
movq %r15, %rdi
callq 0x2120
testl %eax, %eax
jne 0x3db1
movq %r14, %rdi
callq 0x2200
movq %rax, 0x8(%rbx)
jmp 0x3dae
movq %r14, %rdi
callq 0x2200
movq %rax, (%rbx)
pushq $0x1
popq %rbp
movl %ebp, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/chatziko-k08[P]lecture-code/tests/../modules/UsingHashTable/ADTMap.c
// Function: map_create
Map map_create(CompareFunc compare, DestroyFunc destroy_key, DestroyFunc destroy_value) {
	// Δεσμεύουμε κατάλληλα τον χώρο που χρειαζόμαστε για το hash table
	Map map = malloc(sizeof(*map));
	map->capacity = prime_sizes[0];
	map->array = malloc(map->capacity * sizeof(struct map_node));

	// Αρχικοποιούμε τους κόμβους που έχουμε σαν διαθέσιμους.
	for (int i = 0; i < map->capacity; i++)
		map->array[i].state = EMPTY;

	map->size = 0;
	map->deleted = 0;
	map->compare = compare;
	map->destroy_key = destroy_key;
	map->destroy_value = destroy_value;

	return map;
}

// Assembly:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
movq %rdx, %rbx
movq %rsi, %r14
movq %rdi, %r15
pushq $0x38
popq %rdi
callq 0x2190
movq %rax, %r12
movslq 0x3610(%rip), %r13      # 0x8170
movl %r13d, 0x8(%rax)
imulq $0x18, %r13, %rdi
callq 0x2190
movq %rax, (%r12)
xorl %ecx, %ecx
testl %r13d, %r13d
movl $0x0, %edx
cmovgl %r13d, %edx
imulq $0x18, %rdx, %rdx
cmpq %rcx, %rdx
je 0x4b93
andl $0x0, 0x10(%rax,%rcx)
addq $0x18, %rcx
jmp 0x4b83
andq $0x0, 0xc(%r12)
movq %r15, 0x18(%r12)
movq %r14, 0x28(%r12)
movq %rbx, 0x30(%r12)
movq %r12, %rax
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O2/chatziko-k08[P]lecture-code/tests/../modules/UsingHashTable/ADTMap.c
// Function: map_remove
bool map_remove(Map map, Pointer key) {
	MapNode node = map_find_node(map, key);
	if (node == MAP_EOF)
		return false;

	// destroy
	if (map->destroy_key != NULL)
		map->destroy_key(node->key);
	if (map->destroy_value != NULL)
		map->destroy_value(node->value);

	// θέτουμε ως "deleted", ώστε να μην διακόπτεται η αναζήτηση, αλλά ταυτόχρονα να γίνεται ομαλά η εισαγωγή
	node->state = DELETED;
	map->deleted++;
	map->size--;

	return true;
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
callq 0x4db8
movq %rax, %r14
testq %rax, %rax
je 0x4daa
movq 0x28(%rbx), %rax
testq %rax, %rax
je 0x4d81
movq (%r14), %rdi
callq *%rax
movq 0x30(%rbx), %rax
testq %rax, %rax
je 0x4d90
movq 0x8(%r14), %rdi
callq *%rax
movl $0x2, 0x10(%r14)
movq 0xc(%rbx), %xmm0
paddd 0x11fb(%rip), %xmm0     # 0x5fa0
movq %xmm0, 0xc(%rbx)
testq %r14, %r14
setne %al
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O2/chatziko-k08[P]lecture-code/tests/../modules/UsingHashTable/ADTMap.c
// Function: map_find_node
MapNode map_find_node(Map map, Pointer key) {
	// Διασχίζουμε τον πίνακα, ξεκινώντας από τη θέση που κάνει hash το key, και για όσο δε βρίσκουμε EMPTY
	for (uint pos = map->hash_function(key) % map->capacity;		// ξεκινώντας από τη θέση που κάνει hash το key
		map->array[pos].state != EMPTY;							// αν φτάσουμε σε EMPTY σταματάμε
		pos = (pos + 1) % map->capacity) {						// linear probing, γυρνώντας στην αρχή όταν φτάσουμε στη τέλος του πίνακα

		// Μόνο σε OCCUPIED θέσεις (όχι DELETED), ελέγχουμε αν το key είναι εδώ
		if (map->array[pos].state == OCCUPIED && map->compare(map->array[pos].key, key) == 0)
			return &map->array[pos];
	}

	return MAP_EOF;
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rsi, %r14
movq %rdi, %rbx
movq %rsi, %rdi
callq *0x20(%rbx)
movl 0x8(%rbx), %ecx
xorl %edx, %edx
divl %ecx
movq (%rbx), %rax
movl %edx, %r15d
imulq $0x18, %r15, %r12
movl 0x10(%rax,%r12), %edx
cmpl $0x1, %edx
je 0x4ded
testl %edx, %edx
jne 0x4e00
jmp 0x4e08
addq %r12, %rax
movq (%rax), %rdi
movq %r14, %rsi
callq *0x18(%rbx)
testl %eax, %eax
je 0x4e0d
movl 0x8(%rbx), %ecx
incl %r15d
movl %r15d, %eax
jmp 0x4dcf
xorl %r12d, %r12d
jmp 0x4e10
addq (%rbx), %r12
movq %r12, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O2/chatziko-k08[P]lecture-code/tests/../modules/UsingHashTable/ADTMap.c
// Function: map_find
Pointer map_find(Map map, Pointer key) {
	MapNode node = map_find_node(map, key);
	if (node != MAP_EOF)
		return node->value;
	else
		return NULL;
}

// Assembly:
pushq %rax
callq 0x4db8
testq %rax, %rax
je 0x4e30
movq 0x8(%rax), %rax
jmp 0x4e32
xorl %eax, %eax
popq %rcx
retq
// File: /workspace/github_c_makefile_star2_O2/chatziko-k08[P]lecture-code/tests/../modules/UsingHashTable/ADTMap.c
// Function: map_destroy
void map_destroy(Map map) {
	for (int i = 0; i < map->capacity; i++) {
		if (map->array[i].state == OCCUPIED) {
			if (map->destroy_key != NULL)
				map->destroy_key(map->array[i].key);
			if (map->destroy_value != NULL)
				map->destroy_value(map->array[i].value);
		}
	}

	free(map->array);
	free(map);
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rdi, %rbx
xorl %r14d, %r14d
xorl %r15d, %r15d
movslq 0x8(%rbx), %rax
movq (%rbx), %rdi
cmpq %rax, %r15
jge 0x4e93
cmpl $0x1, 0x10(%rdi,%r14)
jne 0x4e8a
movq 0x28(%rbx), %rax
testq %rax, %rax
je 0x4e77
movq (%rdi,%r14), %rdi
callq *%rax
movq 0x30(%rbx), %rax
testq %rax, %rax
je 0x4e8a
movq (%rbx), %rcx
movq 0x8(%rcx,%r14), %rdi
callq *%rax
incq %r15
addq $0x18, %r14
jmp 0x4e54
callq 0x2290
movq %rbx, %rdi
popq %rbx
popq %r14
popq %r15
jmp 0x2290
// File: /workspace/github_c_makefile_star2_O2/chatziko-k08[P]lecture-code/tests/../modules/UsingHashTable/ADTMap.c
// Function: map_first
MapNode map_first(Map map) {
	//Ξεκινάμε την επανάληψή μας απο το 1ο στοιχείο, μέχρι να βρούμε κάτι όντως τοποθετημένο
	for (int i = 0; i < map->capacity; i++)
		if (map->array[i].state == OCCUPIED)
			return &map->array[i];

	return MAP_EOF;
}

// Assembly:
movslq 0x8(%rdi), %rcx
pushq $-0x18
popq %rsi
pushq $-0x1
popq %rdx
xorl %eax, %eax
incq %rdx
cmpq %rcx, %rdx
jge 0x4ed1
leaq 0x18(%rsi), %r8
movq (%rdi), %r9
cmpl $0x1, 0x28(%r9,%rsi)
movq %r8, %rsi
jne 0x4eb1
addq %r8, %r9
movq %r9, %rax
retq
// File: /workspace/github_c_makefile_star2_O2/chatziko-k08[P]lecture-code/tests/../modules/UsingHashTable/ADTMap.c
// Function: map_next
MapNode map_next(Map map, MapNode node) {
	// Το node είναι pointer στο i-οστό στοιχείο του array, οπότε node - array == i  (pointer arithmetic!)
	for (int i = node - map->array + 1; i < map->capacity; i++)
		if (map->array[i].state == OCCUPIED)
			return &map->array[i];

	return MAP_EOF;
}

// Assembly:
movq %rsi, %rax
movq (%rdi), %rsi
subq %rsi, %rax
pushq $0x18
popq %rcx
cqto
idivq %rcx
movl 0x8(%rdi), %edx
incl %eax
xorl %ecx, %ecx
cmpl %edx, %eax
jge 0x4f04
movslq %eax, %rdi
imulq $0x18, %rdi, %rdi
incl %eax
cmpl $0x1, 0x10(%rsi,%rdi)
jne 0x4eea
addq %rdi, %rsi
movq %rsi, %rcx
movq %rcx, %rax
retq
// File: /workspace/github_c_makefile_star2_O2/chatziko-k08[P]lecture-code/tests/../modules/UsingHashTable/ADTMap.c
// Function: hash_string
uint hash_string(Pointer value) {
	// djb2 hash function, απλή, γρήγορη, και σε γενικές γραμμές αποδοτική
    uint hash = 5381;
    for (char* s = value; *s != '\0'; s++)
		hash = (hash << 5) + hash + *s;			// hash = (hash * 33) + *s. Το foo << 5 είναι γρηγορότερη εκδοχή του foo * 32.
    return hash;
}

// Assembly:
movl $0x1505, %eax           # imm = 0x1505
movsbl (%rdi), %ecx
testl %ecx, %ecx
je 0x4f2c
imull $0x21, %eax, %eax
addl %ecx, %eax
incq %rdi
jmp 0x4f1b
retq
// File: /workspace/github_c_makefile_star2_O2/jacereda[P]fsatrace/src/unix/fsatraceso.c
// Function: init
static void __attribute((constructor(101))) init()
{
	int r;
	D;
	r = emitInit();
	if (r)
		err("init", r);
	else {
		char b[PATH_MAX];
		procPath(b);
		emit('r', b);
	}
	DD;
}

// Assembly:
pushq %rbx
subq $0x1000, %rsp           # imm = 0x1000
xorl %eax, %eax
callq 0x2140
testl %eax, %eax
jne 0x2325
movq %rsp, %rbx
movq %rbx, %rdi
callq 0x2160
pushq $0x72
popq %rdi
movq %rbx, %rsi
callq 0x232e
addq $0x1000, %rsp           # imm = 0x1000
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O2/jacereda[P]fsatrace/src/unix/fsatraceso.c
// Function: fopen
FILE *
fopen(const char *p, const char *m)
{
	FILE *r;
	static FILE *(*ofopen)(const char *, const char *) = 0;
	DP;
	R(fopen);
	r = ofopen(p, m);
	if (r)
		emit(strchr(m, 'r') ? 'r' : 'w', p);
	DD;
	return r;
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rsi, %r15
movq %rdi, %rbx
leaq 0x3d9c(%rip), %rdi      # 0x6128
leaq 0x1c6d(%rip), %rsi      # 0x4000
callq 0x23d6
movq %rbx, %rdi
movq %r15, %rsi
callq *0x3d84(%rip)           # 0x6128
movq %rax, %r14
testq %rax, %rax
je 0x23cd
pushq $0x72
popq %rsi
movq %r15, %rdi
callq 0x20f0
xorl %ecx, %ecx
testq %rax, %rax
sete %cl
leal (%rcx,%rcx,4), %edi
addl $0x72, %edi
movq %rbx, %rsi
callq 0x232e
movq %r14, %rax
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O2/jacereda[P]fsatrace/src/unix/fsatraceso.c
// Function: resolv
static void
resolv(void **p, const char *n)
{
	if (!*p) {
		SE;
		*p = dlsym(RTLD_NEXT, n);
		RE;
	}
	assert(*p);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
cmpq $0x0, (%rdi)
jne 0x2409
movq %rsi, %r14
movq %rdi, %rbx
callq 0x2050
movq %rax, %r15
movl (%rax), %ebp
pushq $-0x1
popq %rdi
movq %r14, %rsi
callq 0x21e0
movq %rax, (%rbx)
movl %ebp, (%r15)
testq %rax, %rax
je 0x2414
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
leaq 0x1c8e(%rip), %rdi      # 0x40a9
leaq 0x1c8a(%rip), %rsi      # 0x40ac
leaq 0x1c99(%rip), %rcx      # 0x40c2
movl $0x9b, %edx
callq 0x2130
// File: /workspace/github_c_makefile_star2_O2/jacereda[P]fsatrace/src/unix/fsatraceso.c
// Function: fopen64
FILE *
fopen64(const char *p, const char *m)
{
	FILE *r;
	static FILE *(*ofopen64)(const char *, const char *) = 0;
	DP;
	R(fopen64);
	r = ofopen64(p, m);
	if (r)
		emit(strchr(m, 'r') ? 'r' : 'w', p);
	DD;
	return r;
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rsi, %r15
movq %rdi, %rbx
leaq 0x3ceb(%rip), %rdi      # 0x6130
leaq 0x1bba(%rip), %rsi      # 0x4006
callq 0x23d6
movq %rbx, %rdi
movq %r15, %rsi
callq *0x3cd3(%rip)           # 0x6130
movq %rax, %r14
testq %rax, %rax
je 0x2486
pushq $0x72
popq %rsi
movq %r15, %rdi
callq 0x20f0
xorl %ecx, %ecx
testq %rax, %rax
sete %cl
leal (%rcx,%rcx,4), %edi
addl $0x72, %edi
movq %rbx, %rsi
callq 0x232e
movq %r14, %rax
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O2/jacereda[P]fsatrace/src/unix/fsatraceso.c
// Function: open
int
open(const char *p, int f, mode_t m)
{
	int r;
	static int (*oopen)(const char *, int, mode_t) = 0;
	DP;
	R(open);
	r = oopen(p, f, m);
	if (r >= 0)
		emit(f & wmode ? 'w' : 'r', p);
	DD;
	return r;
}

// Assembly:
pushq %rbp
pushq %r14
pushq %rbx
movl %edx, %r14d
movl %esi, %ebp
movq %rdi, %rbx
leaq 0x3c96(%rip), %rdi      # 0x6138
leaq 0x1b58(%rip), %rsi      # 0x4001
callq 0x23d6
movq %rbx, %rdi
movl %ebp, %esi
movl %r14d, %edx
callq *0x3c7c(%rip)           # 0x6138
movl %eax, %r14d
testl %eax, %eax
js 0x24db
xorl %eax, %eax
testw $0x643, %bp             # imm = 0x643
setne %al
leal (%rax,%rax,4), %edi
addl $0x72, %edi
movq %rbx, %rsi
callq 0x232e
movl %r14d, %eax
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/jacereda[P]fsatrace/src/unix/fsatraceso.c
// Function: open64
int
open64(const char *p, int f, mode_t m)
{
	int r;
	static int (*oopen64)(const char *, int, mode_t) = 0;
	DP;
	R(open64);
	r = oopen64(p, f, m);
	if (r >= 0)
		emit(f & wmode ? 'w' : 'r', p);
	DD;
	return r;
}

// Assembly:
pushq %rbp
pushq %r14
pushq %rbx
movl %edx, %r14d
movl %esi, %ebp
movq %rdi, %rbx
leaq 0x3c4a(%rip), %rdi      # 0x6140
leaq 0x1b0a(%rip), %rsi      # 0x4007
callq 0x23d6
movq %rbx, %rdi
movl %ebp, %esi
movl %r14d, %edx
callq *0x3c30(%rip)           # 0x6140
movl %eax, %r14d
testl %eax, %eax
js 0x252f
xorl %eax, %eax
testw $0x643, %bp             # imm = 0x643
setne %al
leal (%rax,%rax,4), %edi
addl $0x72, %edi
movq %rbx, %rsi
callq 0x232e
movl %r14d, %eax
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/jacereda[P]fsatrace/src/unix/fsatraceso.c
// Function: openat
int
openat(int fd, const char *p, int f, mode_t m)
{
	int r;
	DP;
	static int (*oopenat)(int, const char *, int, mode_t) = 0;
	R(openat);
	r = oopenat(fd, p, f, m);
	if (r >= 0)
		fdemit(f & wmode ? 'w' : 'r', r);
	DD;
	return r;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movl %ecx, %ebp
movl %edx, %ebx
movq %rsi, %r14
movl %edi, %r15d
leaq 0x3bf9(%rip), %rdi      # 0x6148
leaq 0x1ab8(%rip), %rsi      # 0x400e
callq 0x23d6
movl %r15d, %edi
movq %r14, %rsi
movl %ebx, %edx
movl %ebp, %ecx
callq *0x3bdd(%rip)           # 0x6148
movl %eax, %ebp
testl %eax, %eax
js 0x2588
xorl %eax, %eax
testw $0x643, %bx             # imm = 0x643
setne %al
leal (%rax,%rax,4), %edi
addl $0x72, %edi
movl %ebp, %esi
callq 0x2595
movl %ebp, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/jacereda[P]fsatrace/src/unix/fsatraceso.c
// Function: fdemit
static void
fdemit(int c, int fd)
{
	char ap[PATH_MAX];
	int  ok;
	SE;
	ok = fdpath(fd, ap, sizeof(ap));
	emitOp(c, ok ? ap : 0, 0);
	RE;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x1000, %rsp           # imm = 0x1000
movl %esi, %ebx
movl %edi, %ebp
callq 0x2050
movq %rax, %r14
movl (%rax), %r12d
movq %rsp, %r15
movl %ebx, %edi
movq %r15, %rsi
callq 0x2ce5
xorl %ecx, %ecx
testl %eax, %eax
cmoveq %rcx, %r15
movl %ebp, %edi
movq %r15, %rsi
xorl %edx, %edx
callq 0x2120
movl %r12d, (%r14)
addq $0x1000, %rsp           # imm = 0x1000
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/jacereda[P]fsatrace/src/unix/fsatraceso.c
// Function: openat64
int
openat64(int fd, const char *p, int f, mode_t m)
{
	int r;
	DP;
	static int (*oopenat64)(int, const char *, int, mode_t) = 0;
	R(openat64);
	r = oopenat64(fd, p, f, m);
	if (r >= 0)
		fdemit(f & wmode ? 'w' : 'r', r);
	DD;
	return r;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movl %ecx, %ebp
movl %edx, %ebx
movq %rsi, %r14
movl %edi, %r15d
leaq 0x3b51(%rip), %rdi      # 0x6150
leaq 0x1a0f(%rip), %rsi      # 0x4015
callq 0x23d6
movl %r15d, %edi
movq %r14, %rsi
movl %ebx, %edx
movl %ebp, %ecx
callq *0x3b35(%rip)           # 0x6150
movl %eax, %ebp
testl %eax, %eax
js 0x2638
xorl %eax, %eax
testw $0x643, %bx             # imm = 0x643
setne %al
leal (%rax,%rax,4), %edi
addl $0x72, %edi
movl %ebp, %esi
callq 0x2595
movl %ebp, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/jacereda[P]fsatrace/src/unix/fsatraceso.c
// Function: rename
int
rename(const char *p1, const char *p2)
{
	int   r;
	char  b1[PATH_MAX];
	char *rp1 = realpath(p1, b1);
	static int (*orename)(const char *, const char *) = 0;
	D;
	R(rename);
	r = orename(p1, p2);
	if (!r) {
		char  b2[PATH_MAX];
		char *rp2 = realpath(p2, b2);
		emitOp(rp1 ? 'm' : 'M', rp2, rp1);
	}
	DD;
	return r;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
subq $0x2008, %rsp           # imm = 0x2008
movq %rsi, %r14
movq %rdi, %r15
leaq 0x1000(%rsp), %rsi
callq 0x2180
movq %rax, %rbx
leaq 0x3ae9(%rip), %rdi      # 0x6158
leaq 0x19a8(%rip), %rsi      # 0x401e
callq 0x23d6
movq %r15, %rdi
movq %r14, %rsi
callq *0x3ad1(%rip)           # 0x6158
movl %eax, %ebp
testl %eax, %eax
jne 0x26b2
movq %rsp, %rsi
movq %r14, %rdi
callq 0x2180
xorl %edi, %edi
testq %rbx, %rbx
setne %dil
shll $0x5, %edi
orl $0x4d, %edi
movq %rax, %rsi
movq %rbx, %rdx
callq 0x2120
movl %ebp, %eax
addq $0x2008, %rsp           # imm = 0x2008
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/jacereda[P]fsatrace/src/unix/fsatraceso.c
// Function: renamex_np
int
renamex_np(const char *p1, const char *p2, unsigned fl)
{
	int   r;
	char  b1[PATH_MAX];
	char *rp1 = realpath(p1, b1);
	static int (*orenamex_np)(const char *, const char *, unsigned) = 0;
	D;
	R(renamex_np);
	r = orenamex_np(p1, p2, fl);
	if (!r) {
		char  b2[PATH_MAX];
		char *rp2 = realpath(p2, b2);
		emitOp(rp1 ? 'm' : 'M', rp2, rp1);
	}
	DD;
	return r;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
subq $0x2008, %rsp           # imm = 0x2008
movl %edx, %ebp
movq %rsi, %r14
movq %rdi, %r15
leaq 0x1000(%rsp), %rsi
callq 0x2180
movq %rax, %rbx
leaq 0x3a72(%rip), %rdi      # 0x6160
leaq 0x1930(%rip), %rsi      # 0x4025
callq 0x23d6
movq %r15, %rdi
movq %r14, %rsi
movl %ebp, %edx
callq *0x3a58(%rip)           # 0x6160
movl %eax, %ebp
testl %eax, %eax
jne 0x2733
movq %rsp, %rsi
movq %r14, %rdi
callq 0x2180
xorl %edi, %edi
testq %rbx, %rbx
setne %dil
shll $0x5, %edi
orl $0x4d, %edi
movq %rax, %rsi
movq %rbx, %rdx
callq 0x2120
movl %ebp, %eax
addq $0x2008, %rsp           # imm = 0x2008
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/jacereda[P]fsatrace/src/unix/fsatraceso.c
// Function: renameat2
int
renameat2(int fd1, const char *p1, int fd2, const char *p2, unsigned fl)
{
	int r;
	D;
	static int (*orenameat2)(
	    int, const char *, int, const char *, unsigned) = 0;
	char b[PATH_MAX];
	R(renameat2);
	realpathat(fd1, p1, b, sizeof(b));
	r = orenameat2(fd1, p1, fd2, p2, fl);
	if (!r)
		atemit('m', fd2, p2, b);
	DD;
	return r;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x1000, %rsp           # imm = 0x1000
movl %r8d, %r14d
movq %rcx, %rbx
movl %edx, %ebp
movq %rsi, %r15
movl %edi, %r12d
leaq 0x3a01(%rip), %rdi      # 0x6168
leaq 0x18c2(%rip), %rsi      # 0x4030
callq 0x23d6
movq %rsp, %rdx
movl %r12d, %edi
movq %r15, %rsi
callq 0x27bf
movl %r12d, %edi
movq %r15, %rsi
movl %ebp, %edx
movq %rbx, %rcx
movl %r14d, %r8d
callq *0x39d3(%rip)           # 0x6168
movl %eax, %r14d
testl %eax, %eax
jne 0x27ac
pushq $0x6d
popq %rdi
movq %rsp, %rcx
movl %ebp, %esi
movq %rbx, %rdx
callq 0x284b
movl %r14d, %eax
addq $0x1000, %rsp           # imm = 0x1000
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/jacereda[P]fsatrace/src/unix/fsatraceso.c
// Function: realpathat
static char *
realpathat(int ifd, const char *p, char *ap, size_t sz)
{
	int f;
	int ok;
	int fd;
	int cur = ifd == AT_FDCWD;
	static int (*oopenat)(int, const char *, int, mode_t) = 0;
	R(openat);
	if (cur)
		fd = oopenat(AT_FDCWD, ".", O_RDONLY, 0);
	else
		fd = ifd;
	f = oopenat(fd, p, O_RDONLY, 0);
	ok = fdpath(f, ap, sz);
	close(f);
	if (cur)
		close(fd);
	return ok ? ap : NULL;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movq %rdx, %rbx
movq %rsi, %r14
movl %edi, %ebp
leaq 0x3a02(%rip), %rdi      # 0x61d8
leaq 0x1831(%rip), %rsi      # 0x400e
callq 0x23d6
movl %ebp, %r15d
cmpl $-0x64, %ebp
jne 0x2801
leaq 0x1905(%rip), %rsi      # 0x40f6
pushq $-0x64
popq %rdi
xorl %edx, %edx
xorl %ecx, %ecx
callq *0x39da(%rip)           # 0x61d8
movl %eax, %r15d
movl %r15d, %edi
movq %r14, %rsi
xorl %edx, %edx
xorl %ecx, %ecx
callq *0x39c7(%rip)           # 0x61d8
movl %eax, %r12d
movl %eax, %edi
movq %rbx, %rsi
callq 0x2ce5
movl %eax, %r14d
movl %r12d, %edi
callq 0x2150
cmpl $-0x64, %ebp
jne 0x2836
movl %r15d, %edi
callq 0x2150
xorl %eax, %eax
testl %r14d, %r14d
cmoveq %rax, %rbx
movq %rbx, %rax
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/jacereda[P]fsatrace/src/unix/fsatraceso.c
// Function: renameat
int
renameat(int fd1, const char *p1, int fd2, const char *p2)
{
	int r;
	D;
	static int (*orenameat)(int, const char *, int, const char *) = 0;
	char b[PATH_MAX];
	R(renameat);
	realpathat(fd1, p1, b, sizeof(b));
	r = orenameat(fd1, p1, fd2, p2);
	if (!r)
		atemit('m', fd2, p2, b);
	DD;
	return r;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
subq $0x1008, %rsp           # imm = 0x1008
movq %rcx, %rbx
movl %edx, %ebp
movq %rsi, %r14
movl %edi, %r15d
leaq 0x38ae(%rip), %rdi      # 0x6170
leaq 0x1771(%rip), %rsi      # 0x403a
callq 0x23d6
movq %rsp, %rdx
movl %r15d, %edi
movq %r14, %rsi
callq 0x27bf
movl %r15d, %edi
movq %r14, %rsi
movl %ebp, %edx
movq %rbx, %rcx
callq *0x3883(%rip)           # 0x6170
movl %eax, %r14d
testl %eax, %eax
jne 0x2904
pushq $0x6d
popq %rdi
movq %rsp, %rcx
movl %ebp, %esi
movq %rbx, %rdx
callq 0x284b
movl %r14d, %eax
addq $0x1008, %rsp           # imm = 0x1008
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/jacereda[P]fsatrace/src/unix/fsatraceso.c
// Function: renameatx_np
int
renameatx_np(int fd1, const char *p1, int fd2, const char *p2, unsigned fl)
{
	int  r;
	char b[PATH_MAX];
	D;
	static int (*orenameatx_np)(
	    int, const char *, int, const char *, unsigned) = 0;
	R(renameatx_np);
	realpathat(fd1, p1, b, sizeof(b));
	r = orenameatx_np(fd1, p1, fd2, p2, fl);
	if (!r)
		atemit('m', fd2, p2, b);
	DD;
	return r;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x1000, %rsp           # imm = 0x1000
movl %r8d, %r14d
movq %rcx, %rbx
movl %edx, %ebp
movq %rsi, %r15
movl %edi, %r12d
leaq 0x383f(%rip), %rdi      # 0x6178
leaq 0x1703(%rip), %rsi      # 0x4043
callq 0x23d6
movq %rsp, %rdx
movl %r12d, %edi
movq %r15, %rsi
callq 0x27bf
movl %r12d, %edi
movq %r15, %rsi
movl %ebp, %edx
movq %rbx, %rcx
movl %r14d, %r8d
callq *0x3811(%rip)           # 0x6178
movl %eax, %r14d
testl %eax, %eax
jne 0x297e
pushq $0x6d
popq %rdi
movq %rsp, %rcx
movl %ebp, %esi
movq %rbx, %rdx
callq 0x284b
movl %r14d, %eax
addq $0x1000, %rsp           # imm = 0x1000
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/jacereda[P]fsatrace/src/unix/fsatraceso.c
// Function: unlink
int
unlink(const char *p)
{
	int   r;
	char  b[PATH_MAX];
	char *rp;
	static int (*ounlink)(const char *) = 0;
	DP;
	R(unlink);
	rp = realpath(p, b);
	r = ounlink(p);
	if (!r)
		emitOp('d', rp, 0);
	DD;
	return r;
}

// Assembly:
pushq %rbp
pushq %r14
pushq %rbx
subq $0x1000, %rsp           # imm = 0x1000
movq %rdi, %r14
leaq 0x37da(%rip), %rdi      # 0x6180
leaq 0x16a3(%rip), %rsi      # 0x4050
callq 0x23d6
movq %rsp, %rsi
movq %r14, %rdi
callq 0x2180
movq %rax, %rbx
movq %r14, %rdi
callq *0x37b7(%rip)           # 0x6180
movl %eax, %ebp
testl %eax, %eax
jne 0x29dc
pushq $0x64
popq %rdi
movq %rbx, %rsi
xorl %edx, %edx
callq 0x2120
movl %ebp, %eax
addq $0x1000, %rsp           # imm = 0x1000
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/jacereda[P]fsatrace/src/unix/fsatraceso.c
// Function: unlinkat
int
unlinkat(int fd, const char *p, int f)
{
	int r;
	DP;
	char  b[PATH_MAX];
	char *rp = realpathat(fd, p, b, sizeof(b));
	static int (*ounlinkat)(int, const char *, int);
	R(unlinkat);
	r = ounlinkat(fd, p, f);
	if (!r)
		emitOp(rp ? 'd' : 'D', rp ? rp : p, 0);
	DD;
	return r;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
subq $0x1008, %rsp           # imm = 0x1008
movl %edx, %ebp
movq %rsi, %rbx
movl %edi, %r15d
movq %rsp, %rdx
callq 0x27bf
movq %rax, %r14
leaq 0x3777(%rip), %rdi      # 0x6188
leaq 0x163f(%rip), %rsi      # 0x4057
callq 0x23d6
movl %r15d, %edi
movq %rbx, %rsi
movl %ebp, %edx
callq *0x375d(%rip)           # 0x6188
movl %eax, %ebp
testl %eax, %eax
jne 0x2a4e
xorl %edi, %edi
testq %r14, %r14
setne %dil
cmovneq %r14, %rbx
shll $0x5, %edi
orl $0x44, %edi
movq %rbx, %rsi
xorl %edx, %edx
callq 0x2120
movl %ebp, %eax
addq $0x1008, %rsp           # imm = 0x1008
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/jacereda[P]fsatrace/src/unix/fsatraceso.c
// Function: futimes
int
futimes(int fd, const struct timeval t[2])
{
	int r;
	static int (*ofutimes)(int, const struct timeval[2]);
	D;
	R(futimes);
	r = ofutimes(fd, t);
	if (!r)
		fdemit('t', fd);
	DD;
	return r;
}

// Assembly:
pushq %rbp
pushq %r14
pushq %rbx
movq %rsi, %r14
movl %edi, %ebx
leaq 0x3722(%rip), %rdi      # 0x6190
leaq 0x15eb(%rip), %rsi      # 0x4060
callq 0x23d6
movl %ebx, %edi
movq %r14, %rsi
callq *0x370b(%rip)           # 0x6190
movl %eax, %ebp
testl %eax, %eax
jne 0x2a95
pushq $0x74
popq %rdi
movl %ebx, %esi
callq 0x2595
movl %ebp, %eax
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/jacereda[P]fsatrace/src/unix/fsatraceso.c
// Function: utimes
int
utimes(const char *p, const struct timeval t[2])
{
	int r;
	static int (*outimes)(const char *, const struct timeval[2]);
	DP;
	R(utimes);
	r = outimes(p, t);
	if (!r)
		emit('t', p);
	DD;
	return r;
}

// Assembly:
pushq %rbp
pushq %r14
pushq %rbx
movq %rsi, %r14
movq %rdi, %rbx
leaq 0x36eb(%rip), %rdi      # 0x6198
leaq 0x15ad(%rip), %rsi      # 0x4061
callq 0x23d6
movq %rbx, %rdi
movq %r14, %rsi
callq *0x36d3(%rip)           # 0x6198
movl %eax, %ebp
testl %eax, %eax
jne 0x2ad6
pushq $0x74
popq %rdi
movq %rbx, %rsi
callq 0x232e
movl %ebp, %eax
popq %rbx
popq %r14
popq %rbp
retq