LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O0/bobrippling[P]tim/word.c
// Function: word_seek_to_end
void word_seek_to_end(list_t *l, int dir, point_t *to, bool big_words)
{
	/* put us on the start/end of the word */
	const enum word_state st = word_state(l, to->x, big_words);

	if(st != W_NONE)
		while(word_state(l, to->x + dir, big_words) == st)
			to->x += dir;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movb %cl, %al
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movq %rdx, -0x18(%rbp)
andb $0x1, %al
movb %al, -0x19(%rbp)
movq -0x8(%rbp), %rdi
movq -0x18(%rbp), %rax
movl (%rax), %esi
movb -0x19(%rbp), %al
andb $0x1, %al
movzbl %al, %edx
callq 0x12a20
movl %eax, -0x20(%rbp)
cmpl $0x0, -0x20(%rbp)
je 0x12bea
jmp 0x12bbc
movq -0x8(%rbp), %rdi
movq -0x18(%rbp), %rax
movl (%rax), %esi
addl -0xc(%rbp), %esi
movb -0x19(%rbp), %al
andb $0x1, %al
movzbl %al, %edx
callq 0x12a20
cmpl -0x20(%rbp), %eax
jne 0x12be8
movl -0xc(%rbp), %ecx
movq -0x18(%rbp), %rax
addl (%rax), %ecx
movl %ecx, (%rax)
jmp 0x12bbc
jmp 0x12bea
addq $0x20, %rsp
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O0/bobrippling[P]tim/buffers.c
// Function: buffers_find
buffer_t *buffers_find(const char *fname)
{
	if(!windows_cur()) /* called on startup */
		return NULL;

	for(tab *tab = tabs_first(); tab; tab = tab->next){
		window *win;
		ITER_WINDOWS_FROM(win, tab->win){
			buffer_t *buf = win->buf;
			const char *thisfname = buffer_fname(buf);

			if(thisfname && !strcmp(thisfname, fname))
				return buf;
		}
	}

	return NULL;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x10(%rbp)
callq 0x13c60
cmpq $0x0, %rax
jne 0x12c14
movq $0x0, -0x8(%rbp)
jmp 0x12ccc
callq 0x13ef0
movq %rax, -0x18(%rbp)
cmpq $0x0, -0x18(%rbp)
je 0x12cc4
movq -0x18(%rbp), %rax
movq (%rax), %rdi
callq 0x13010
movq %rax, -0x20(%rbp)
movq -0x20(%rbp), %rax
movq %rax, -0x28(%rbp)
cmpq $0x0, -0x28(%rbp)
je 0x12cb1
movq -0x28(%rbp), %rax
movq %rax, -0x20(%rbp)
cmpq $0x0, -0x20(%rbp)
je 0x12ca1
movq -0x20(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x30(%rbp)
movq -0x30(%rbp), %rdi
callq 0xbb30
movq %rax, -0x38(%rbp)
cmpq $0x0, -0x38(%rbp)
je 0x12c91
movq -0x38(%rbp), %rdi
movq -0x10(%rbp), %rsi
callq 0x42d0
cmpl $0x0, %eax
jne 0x12c91
movq -0x30(%rbp), %rax
movq %rax, -0x8(%rbp)
jmp 0x12ccc
jmp 0x12c93
movq -0x20(%rbp), %rax
movq 0x58(%rax), %rax
movq %rax, -0x20(%rbp)
jmp 0x12c4f
jmp 0x12ca3
movq -0x28(%rbp), %rax
movq 0x50(%rax), %rax
movq %rax, -0x28(%rbp)
jmp 0x12c40
jmp 0x12cb3
movq -0x18(%rbp), %rax
movq 0x8(%rax), %rax
movq %rax, -0x18(%rbp)
jmp 0x12c1d
movq $0x0, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x40, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/bobrippling[P]tim/buffers.c
// Function: buffers_modified_excluding
window *buffers_modified_excluding(buffer_t *excluding, tab **const ptab)
{
	if(ptab)
		*ptab = NULL;

	for(tab *tab = tabs_first(); tab; tab = tab->next){
		window *win;
		ITER_WINDOWS_FROM(win, tab->win){
			buffer_t *buf = win->buf;
			if(buf != excluding && buf->modified){
				if(ptab)
					*ptab = tab;
				return win;
			}
		}
	}

	return NULL;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
cmpq $0x0, -0x18(%rbp)
je 0x12d42
movq -0x18(%rbp), %rax
movq $0x0, (%rax)
callq 0x13ef0
movq %rax, -0x20(%rbp)
cmpq $0x0, -0x20(%rbp)
je 0x12df2
movq -0x20(%rbp), %rax
movq (%rax), %rdi
callq 0x13010
movq %rax, -0x28(%rbp)
movq -0x28(%rbp), %rax
movq %rax, -0x30(%rbp)
cmpq $0x0, -0x30(%rbp)
je 0x12ddf
movq -0x30(%rbp), %rax
movq %rax, -0x28(%rbp)
cmpq $0x0, -0x28(%rbp)
je 0x12dcf
movq -0x28(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x38(%rbp)
movq -0x38(%rbp), %rax
cmpq -0x10(%rbp), %rax
je 0x12dbf
movq -0x38(%rbp), %rax
testb $0x1, 0x39(%rax)
je 0x12dbf
cmpq $0x0, -0x18(%rbp)
je 0x12db5
movq -0x20(%rbp), %rcx
movq -0x18(%rbp), %rax
movq %rcx, (%rax)
movq -0x28(%rbp), %rax
movq %rax, -0x8(%rbp)
jmp 0x12dfa
jmp 0x12dc1
movq -0x28(%rbp), %rax
movq 0x58(%rax), %rax
movq %rax, -0x28(%rbp)
jmp 0x12d7d
jmp 0x12dd1
movq -0x30(%rbp), %rax
movq 0x50(%rax), %rax
movq %rax, -0x30(%rbp)
jmp 0x12d6e
jmp 0x12de1
movq -0x20(%rbp), %rax
movq 0x8(%rax), %rax
movq %rax, -0x20(%rbp)
jmp 0x12d4b
movq $0x0, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x40, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
nop
// File: /workspace/github_c_makefile_star2_O0/bobrippling[P]tim/window.c
// Function: window_next
window *window_next(window *cur)
{
#define RET_IF(x) if(x) return x
	RET_IF(cur->neighbours.below);
	RET_IF(cur->neighbours.above);
	RET_IF(cur->neighbours.right);
	RET_IF(cur->neighbours.left);
#undef RET_IF
	return NULL;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x10(%rbp)
movq -0x10(%rbp), %rax
cmpq $0x0, 0x58(%rax)
je 0x12fb1
movq -0x10(%rbp), %rax
movq 0x58(%rax), %rax
movq %rax, -0x8(%rbp)
jmp 0x13004
movq -0x10(%rbp), %rax
cmpq $0x0, 0x60(%rax)
je 0x12fca
movq -0x10(%rbp), %rax
movq 0x60(%rax), %rax
movq %rax, -0x8(%rbp)
jmp 0x13004
movq -0x10(%rbp), %rax
cmpq $0x0, 0x50(%rax)
je 0x12fe3
movq -0x10(%rbp), %rax
movq 0x50(%rax), %rax
movq %rax, -0x8(%rbp)
jmp 0x13004
movq -0x10(%rbp), %rax
cmpq $0x0, 0x48(%rax)
je 0x12ffc
movq -0x10(%rbp), %rax
movq 0x48(%rax), %rax
movq %rax, -0x8(%rbp)
jmp 0x13004
movq $0x0, -0x8(%rbp)
movq -0x8(%rbp), %rax
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/bobrippling[P]tim/window.c
// Function: neighbour_is_vertical
bool neighbour_is_vertical(enum neighbour n)
{
	switch(n){
		case neighbour_up:
		case neighbour_down:
			return true;
		case neighbour_left:
		case neighbour_right:
			break;
	}
	return false;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movl %edi, -0x8(%rbp)
movl -0x8(%rbp), %eax
movl %eax, -0xc(%rbp)
subl $0x2, %eax
jb 0x13381
jmp 0x13374
movl -0xc(%rbp), %eax
addl $-0x2, %eax
subl $0x2, %eax
jb 0x13387
jmp 0x13389
movb $0x1, -0x1(%rbp)
jmp 0x1338d
jmp 0x13389
movb $0x0, -0x1(%rbp)
movb -0x1(%rbp), %al
andb $0x1, %al
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/bobrippling[P]tim/window.c
// Function: window_new
window *window_new(buffer_t *b)
{
	window *win = umalloc(sizeof *win);

	win->buf = retain(b);

	win->ui_pos = &win->ui_npos;
	win->ui_mode = UI_NORMAL;
	win->ui_paren = (point_t){ -1, -1 };

	return win;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movl $0x68, %edi
callq 0x5f20
movq %rax, -0x10(%rbp)
movq -0x8(%rbp), %rdi
callq 0x12020
movq %rax, %rcx
movq -0x10(%rbp), %rax
movq %rcx, (%rax)
movq -0x10(%rbp), %rcx
addq $0x20, %rcx
movq -0x10(%rbp), %rax
movq %rcx, 0x30(%rax)
movq -0x10(%rbp), %rax
movl $0x1, 0x40(%rax)
movq -0x10(%rbp), %rax
movl $0xffffffff, -0x18(%rbp) # imm = 0xFFFFFFFF
movl $0xffffffff, -0x14(%rbp) # imm = 0xFFFFFFFF
movq -0x18(%rbp), %rcx
movq %rcx, 0x38(%rax)
movq -0x10(%rbp), %rax
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/bobrippling[P]tim/window.c
// Function: window_togglev
void window_togglev(window *win, bool corner_toggle)
{
	if(corner_toggle){
		point_t *alt = window_uipos_alt(win);

		int tmp = win->ui_pos->x;
		win->ui_pos->x = alt->x;
		alt->x = tmp;
	}else{
		win->ui_pos = (win->ui_pos == &win->ui_npos)
			? &win->ui_vpos
			: &win->ui_npos;
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movb %sil, %al
movq %rdi, -0x8(%rbp)
andb $0x1, %al
movb %al, -0x9(%rbp)
testb $0x1, -0x9(%rbp)
je 0x1370f
movq -0x8(%rbp), %rdi
callq 0x13750
movq %rax, -0x18(%rbp)
movq -0x8(%rbp), %rax
movq 0x30(%rax), %rax
movl (%rax), %eax
movl %eax, -0x1c(%rbp)
movq -0x18(%rbp), %rax
movl (%rax), %ecx
movq -0x8(%rbp), %rax
movq 0x30(%rax), %rax
movl %ecx, (%rax)
movl -0x1c(%rbp), %ecx
movq -0x18(%rbp), %rax
movl %ecx, (%rax)
jmp 0x1374a
movq -0x8(%rbp), %rax
movq 0x30(%rax), %rax
movq -0x8(%rbp), %rcx
addq $0x20, %rcx
cmpq %rcx, %rax
jne 0x13732
movq -0x8(%rbp), %rax
addq $0x28, %rax
movq %rax, -0x28(%rbp)
jmp 0x1373e
movq -0x8(%rbp), %rax
addq $0x20, %rax
movq %rax, -0x28(%rbp)
movq -0x28(%rbp), %rcx
movq -0x8(%rbp), %rax
movq %rcx, 0x30(%rax)
addq $0x30, %rsp
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O0/bobrippling[P]tim/window.c
// Function: window_toscreen
point_t window_toscreen(const window *win, point_t const *pt)
{
	list_t *l = list_seek(win->buf->head, win->ui_pos->y, 0);
	int xoff = 0;

	if(l && l->len_line > 0)
		for(int x = MIN((unsigned)win->ui_pos->x, l->len_line - 1);
				x >= 0;
				x--)
			xoff += nc_charlen(l->line[x]) - 1;

	return (point_t){
		win->screen_coord.x + pt->x - win->ui_start.x + xoff,
		win->screen_coord.y + pt->y - win->ui_start.y
	};
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x10(%rbp), %rax
movq (%rax), %rax
movq 0x8(%rax), %rdi
movq -0x10(%rbp), %rax
movq 0x30(%rax), %rax
movl 0x4(%rax), %esi
xorl %edx, %edx
callq 0xcd50
movq %rax, -0x20(%rbp)
movl $0x0, -0x24(%rbp)
cmpq $0x0, -0x20(%rbp)
je 0x138ec
movq -0x20(%rbp), %rax
cmpq $0x0, 0x8(%rax)
jbe 0x138ec
movq -0x10(%rbp), %rax
movq 0x30(%rax), %rax
movl (%rax), %eax
movq -0x20(%rbp), %rcx
movq 0x8(%rcx), %rcx
subq $0x1, %rcx
cmpq %rcx, %rax
jae 0x138a5
movq -0x10(%rbp), %rax
movq 0x30(%rax), %rax
movl (%rax), %eax
movq %rax, -0x30(%rbp)
jmp 0x138b5
movq -0x20(%rbp), %rax
movq 0x8(%rax), %rax
subq $0x1, %rax
movq %rax, -0x30(%rbp)
movq -0x30(%rbp), %rax
movl %eax, -0x28(%rbp)
cmpl $0x0, -0x28(%rbp)
jl 0x138ea
movq -0x20(%rbp), %rax
movq (%rax), %rax
movslq -0x28(%rbp), %rcx
movsbl (%rax,%rcx), %edi
callq 0x4bc0
subl $0x1, %eax
addl -0x24(%rbp), %eax
movl %eax, -0x24(%rbp)
movl -0x28(%rbp), %eax
addl $-0x1, %eax
movl %eax, -0x28(%rbp)
jmp 0x138bc
jmp 0x138ec
movq -0x10(%rbp), %rax
movl 0x10(%rax), %eax
movq -0x18(%rbp), %rcx
addl (%rcx), %eax
movq -0x10(%rbp), %rcx
subl 0x8(%rcx), %eax
addl -0x24(%rbp), %eax
movl %eax, -0x8(%rbp)
movq -0x10(%rbp), %rax
movl 0x14(%rax), %eax
movq -0x18(%rbp), %rcx
addl 0x4(%rcx), %eax
movq -0x10(%rbp), %rcx
subl 0xc(%rcx), %eax
movl %eax, -0x4(%rbp)
movq -0x8(%rbp), %rax
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/bobrippling[P]tim/window.c
// Function: window_setmode
int window_setmode(window *win, enum buf_mode m)
{
	if(!m || (m & (m - 1))){
		return -1;
	}else{
		if(win->ui_mode & UI_INSERT_ANY)
			win->buf->prev_insert = *win->ui_pos;

		if(m & UI_VISUAL_ANY){
			if((win->ui_mode & UI_VISUAL_ANY) == 0){
				/* from non-visual to visual */
				*window_uipos_alt(win) = *win->ui_pos;
			}
		}else{
			/* from a visual, save state */
			win->buf->prev_visual.mode = win->ui_mode;

			win->buf->prev_visual.npos = *win->ui_pos;
			win->buf->prev_visual.vpos = *window_uipos_alt(win);
		}

		win->ui_mode = m;
		return 0;
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movl %esi, -0x14(%rbp)
cmpl $0x0, -0x14(%rbp)
je 0x13955
movl -0x14(%rbp), %eax
movl -0x14(%rbp), %ecx
subl $0x1, %ecx
andl %ecx, %eax
cmpl $0x0, %eax
je 0x13961
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
jmp 0x13a13
movq -0x10(%rbp), %rax
movl 0x40(%rax), %eax
andl $0x6, %eax
cmpl $0x0, %eax
je 0x13986
movq -0x10(%rbp), %rax
movq (%rax), %rax
movq -0x10(%rbp), %rcx
movq 0x30(%rcx), %rcx
movq (%rcx), %rcx
movq %rcx, 0x24(%rax)
movl -0x14(%rbp), %eax
andl $0x38, %eax
cmpl $0x0, %eax
je 0x139b9
movq -0x10(%rbp), %rax
movl 0x40(%rax), %eax
andl $0x38, %eax
cmpl $0x0, %eax
jne 0x139b7
movq -0x10(%rbp), %rdi
callq 0x13750
movq -0x10(%rbp), %rcx
movq 0x30(%rcx), %rcx
movq (%rcx), %rcx
movq %rcx, (%rax)
jmp 0x13a02
movq -0x10(%rbp), %rax
movl 0x40(%rax), %ecx
movq -0x10(%rbp), %rax
movq (%rax), %rax
movl %ecx, 0x20(%rax)
movq -0x10(%rbp), %rax
movq (%rax), %rax
movq -0x10(%rbp), %rcx
movq 0x30(%rcx), %rcx
movq (%rcx), %rcx
movq %rcx, 0x10(%rax)
movq -0x10(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x20(%rbp)
movq -0x10(%rbp), %rdi
callq 0x13750
movq %rax, %rcx
movq -0x20(%rbp), %rax
movq (%rcx), %rcx
movq %rcx, 0x18(%rax)
movl -0x14(%rbp), %ecx
movq -0x10(%rbp), %rax
movl %ecx, 0x40(%rax)
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/bobrippling[P]tim/window.c
// Function: window_inschar
void window_inschar(window *win, char ch)
{
	if(win->ui_mode != UI_INSERT_COL || isnewline(ch)){
		/* can't col-insert a newline, revert */
		if(win->ui_mode == UI_INSERT_COL)
			window_setmode(win, UI_INSERT);

		buffer_inscolchar(win->buf, ch, 1, win->ui_pos);
	}else{
		buffer_inscolchar(win->buf, ch, win->buf->col_insert_height, win->ui_pos);
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movb %sil, %al
movq %rdi, -0x8(%rbp)
movb %al, -0x9(%rbp)
movq -0x8(%rbp), %rax
cmpl $0x4, 0x40(%rax)
jne 0x13a4e
movsbl -0x9(%rbp), %eax
cmpl $0xa, %eax
je 0x13a4e
movsbl -0x9(%rbp), %eax
cmpl $0xd, %eax
jne 0x13a87
movq -0x8(%rbp), %rax
cmpl $0x4, 0x40(%rax)
jne 0x13a66
movq -0x8(%rbp), %rdi
movl $0x2, %esi
callq 0x13930
movq -0x8(%rbp), %rax
movq (%rax), %rdi
movb -0x9(%rbp), %al
movq -0x8(%rbp), %rcx
movq 0x30(%rcx), %rcx
movl $0x1, %edx
movsbl %al, %esi
callq 0xbe80
jmp 0x13aab
movq -0x8(%rbp), %rax
movq (%rax), %rdi
movb -0x9(%rbp), %al
movq -0x8(%rbp), %rcx
movq (%rcx), %rcx
movl 0x48(%rcx), %edx
movq -0x8(%rbp), %rcx
movq 0x30(%rcx), %rcx
movsbl %al, %esi
callq 0xbe80
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/bobrippling[P]tim/window.c
// Function: window_replace_fname
bool window_replace_fname(window *win, const char *fname, const char **const err)
{
	buffer_t *buf = NULL;
	buffer_new_fname(&buf, fname, err);

	if(!*err){
		window_replace_buffer(win, buf);
		buffer_release(buf);
	}

	return !*err;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq $0x0, -0x20(%rbp)
movq -0x10(%rbp), %rsi
movq -0x18(%rbp), %rdx
leaq -0x20(%rbp), %rdi
callq 0xb970
movq -0x18(%rbp), %rax
cmpq $0x0, (%rax)
jne 0x13ba4
movq -0x8(%rbp), %rdi
movq -0x20(%rbp), %rsi
callq 0x13ac0
movq -0x20(%rbp), %rdi
leaq -0x848f(%rip), %rsi     # 0xb710
callq 0x12040
movq -0x18(%rbp), %rax
cmpq $0x0, (%rax)
setne %al
xorb $-0x1, %al
andb $0x1, %al
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/bobrippling[P]tim/window.c
// Function: window_reload_buffer
bool window_reload_buffer(window *win, const char **const err)
{
	const char *fname = buffer_fname(win->buf);
	if(!fname)
		return false;

	/* need to update the buffer's list, not the window,
	 * since there may be multiple windows with the old buffer */
	buffer_replace_fname(win->buf, fname, err);

	return !*err;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x10(%rbp), %rax
movq (%rax), %rdi
callq 0xbb30
movq %rax, -0x20(%rbp)
cmpq $0x0, -0x20(%rbp)
jne 0x13bed
movb $0x0, -0x1(%rbp)
jmp 0x13c13
movq -0x10(%rbp), %rax
movq (%rax), %rdi
movq -0x20(%rbp), %rsi
movq -0x18(%rbp), %rdx
callq 0xb7d0
movq -0x18(%rbp), %rax
cmpq $0x0, (%rax)
setne %al
xorb $-0x1, %al
andb $0x1, %al
movb %al, -0x1(%rbp)
movb -0x1(%rbp), %al
andb $0x1, %al
addq $0x20, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/bobrippling[P]tim/tab.c
// Function: tab_free
void tab_free(tab *t)
{
	if(t->win){
		window_free(t->win);
		t->win = NULL;
	}

	if(t == tabs_first())
		tabs_set_first(t->next);

	free(t);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
cmpq $0x0, (%rax)
je 0x13d3d
movq -0x8(%rbp), %rax
movq (%rax), %rdi
callq 0x13690
movq -0x8(%rbp), %rax
movq $0x0, (%rax)
movq -0x8(%rbp), %rax
movq %rax, -0x10(%rbp)
callq 0x13ef0
movq %rax, %rcx
movq -0x10(%rbp), %rax
cmpq %rcx, %rax
jne 0x13d63
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rdi
callq 0x13f00
movq -0x8(%rbp), %rdi
callq 0x4080
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/bobrippling[P]tim/tab.c
// Function: tab_evict
void tab_evict(tab *t)
{
	tab *i;

	for(i = tabs_first(); i; i = i->next){
		if(i->next == t){
			i->next = t->next;
			break;
		}
	}

	t->next = NULL;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
callq 0x13ef0
movq %rax, -0x10(%rbp)
cmpq $0x0, -0x10(%rbp)
je 0x13dec
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rax
cmpq -0x8(%rbp), %rax
jne 0x13ddc
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rcx
movq -0x10(%rbp), %rax
movq %rcx, 0x8(%rax)
jmp 0x13dec
jmp 0x13dde
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rax
movq %rax, -0x10(%rbp)
jmp 0x13db5
movq -0x8(%rbp), %rax
movq $0x0, 0x8(%rax)
addq $0x10, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/bobrippling[P]tim/tab.c
// Function: tab_contains_buffer
bool tab_contains_buffer(tab *t, buffer_t *b)
{
	window *win;
	ITER_WINDOWS_FROM(win, t->win)
		if(win->buf == b)
			return true;

	return false;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x10(%rbp), %rax
movq (%rax), %rdi
callq 0x13010
movq %rax, -0x20(%rbp)
movq -0x20(%rbp), %rax
movq %rax, -0x28(%rbp)
cmpq $0x0, -0x28(%rbp)
je 0x13eb1
movq -0x28(%rbp), %rax
movq %rax, -0x20(%rbp)
cmpq $0x0, -0x20(%rbp)
je 0x13ea1
movq -0x20(%rbp), %rax
movq (%rax), %rax
cmpq -0x18(%rbp), %rax
jne 0x13e91
movb $0x1, -0x1(%rbp)
jmp 0x13eb5
jmp 0x13e93
movq -0x20(%rbp), %rax
movq 0x58(%rax), %rax
movq %rax, -0x20(%rbp)
jmp 0x13e77
jmp 0x13ea3
movq -0x28(%rbp), %rax
movq 0x50(%rax), %rax
movq %rax, -0x28(%rbp)
jmp 0x13e68
movb $0x0, -0x1(%rbp)
movb -0x1(%rbp), %al
andb $0x1, %al
addq $0x30, %rsp
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O0/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
movq %rsp, %rbp
subq $0x50, %rsp
movl %edi, -0x4(%rbp)
movl %esi, -0x8(%rbp)
movl $0x1, %edi
callq 0x4650
movq %rax, -0x10(%rbp)
cmpq $0x0, -0x10(%rbp)
je 0x140cc
movq $0x0, -0x18(%rbp)
movq -0x10(%rbp), %rdi
leaq 0x1b96(%rip), %rsi      # 0x15b60
callq 0x42d0
cmpl $0x0, %eax
jne 0x14032
movq 0x7fc5(%rip), %rax      # 0x1bfa0
movq (%rax), %rdi
callq 0xb920
movq %rax, -0x20(%rbp)
movq -0x20(%rbp), %rax
movb $0x1, 0x39(%rax)
movq 0x7faa(%rip), %rax      # 0x1bfa0
movq (%rax), %rdi
callq 0x40f0
cmpl $0x0, %eax
je 0x14013
callq 0x40a0
movl (%rax), %edi
callq 0x44d0
movq %rax, -0x18(%rbp)
movq 0x7f86(%rip), %rax      # 0x1bfa0
movq (%rax), %rdx
leaq 0x1b3e(%rip), %rdi      # 0x15b62
leaq 0x14ae(%rip), %rsi      # 0x154d9
callq 0x4250
jmp 0x14043
movq -0x10(%rbp), %rsi
leaq -0x20(%rbp), %rdi
leaq -0x18(%rbp), %rdx
callq 0xb970
cmpq $0x0, -0x18(%rbp)
je 0x14060
movq -0x10(%rbp), %rsi
movq -0x18(%rbp), %rdx
leaq 0x1b12(%rip), %rdi      # 0x15b6b
movb $0x0, %al
callq 0x4f30
movq -0x20(%rbp), %rdi
callq 0x13620
movq %rax, %rdi
callq 0x13cd0
movq %rax, -0x28(%rbp)
movq -0x20(%rbp), %rdi
leaq -0x8970(%rip), %rsi     # 0xb710
callq 0x12040
movq -0x28(%rbp), %rdi
callq 0x13ed0
movl -0x4(%rbp), %eax
movl %eax, -0x44(%rbp)
testl %eax, %eax
je 0x140ae
jmp 0x1409a
movl -0x44(%rbp), %eax
subl $0x1, %eax
je 0x140b0
jmp 0x140a4
movl -0x44(%rbp), %eax
subl $0x2, %eax
je 0x140be
jmp 0x140ca
jmp 0x140ca
leaq 0xf9(%rip), %rdi        # 0x141b0
callq 0x14130
jmp 0x140ca
leaq 0x11b(%rip), %rdi       # 0x141e0
callq 0x14130
jmp 0x14108
callq 0xb750
movq %rax, -0x30(%rbp)
movq -0x30(%rbp), %rdi
callq 0x13620
movq %rax, -0x38(%rbp)
movq -0x30(%rbp), %rdi
leaq -0x89dd(%rip), %rsi     # 0xb710
callq 0x12040
movq -0x38(%rbp), %rdi
callq 0x13cd0
movq %rax, -0x40(%rbp)
movq -0x40(%rbp), %rdi
callq 0x13ed0
callq 0x13ec0
movq %rax, %rdi
callq 0x13f00
movl -0x8(%rbp), %eax
movl %eax, -0x48(%rbp)
callq 0x13c60
movl -0x48(%rbp), %ecx
movq 0x30(%rax), %rax
movl %ecx, 0x4(%rax)
addq $0x50, %rsp
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O0/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
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
callq 0x13c60
movq %rax, -0x10(%rbp)
movl $0x1, %edi
callq 0x4650
movq %rax, -0x18(%rbp)
cmpq $0x0, %rax
je 0x1419f
movq -0x18(%rbp), %rsi
leaq -0x20(%rbp), %rdi
leaq -0x28(%rbp), %rdx
callq 0xb970
movq -0x20(%rbp), %rdi
callq 0x13620
movq %rax, -0x30(%rbp)
movq -0x20(%rbp), %rdi
leaq -0x8a72(%rip), %rsi     # 0xb710
callq 0x12040
movq -0x8(%rbp), %rax
movq -0x10(%rbp), %rdi
movq -0x30(%rbp), %rsi
callq *%rax
movq -0x30(%rbp), %rax
movq %rax, -0x10(%rbp)
jmp 0x14145
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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
movq %rsp, %rbp
subq $0x150, %rsp            # imm = 0x150
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
leaq 0x191a(%rip), %rdi      # 0x15b74
leaq 0x1278(%rip), %rsi      # 0x154d9
callq 0x4440
movq %rax, -0x20(%rbp)
cmpq $0x0, -0x20(%rbp)
jne 0x1427a
movb $0x0, -0x1(%rbp)
jmp 0x143c2
movb $0x0, -0x21(%rbp)
leaq -0x130(%rbp), %rdi
movq -0x20(%rbp), %rdx
movl $0x100, %esi            # imm = 0x100
callq 0x42c0
cmpq $0x0, %rax
je 0x143b1
leaq -0x130(%rbp), %rdi
movl $0x9, %esi
callq 0x41c0
movq %rax, -0x138(%rbp)
cmpq $0x0, -0x138(%rbp)
je 0x142cc
movq -0x138(%rbp), %rax
cmpb $0x0, 0x1(%rax)
jne 0x142ce
jmp 0x1427e
movq -0x138(%rbp), %rax
movb $0x0, (%rax)
leaq -0x130(%rbp), %rdi
movq -0x10(%rbp), %rsi
callq 0x42d0
cmpl $0x0, %eax
jne 0x143ac
movq -0x138(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x140(%rbp)
movq -0x138(%rbp), %rdi
addq $0x1, %rdi
movl $0x9, %esi
callq 0x41c0
movq %rax, -0x138(%rbp)
cmpq $0x0, -0x138(%rbp)
je 0x14336
movq -0x138(%rbp), %rax
cmpb $0x0, 0x1(%rax)
jne 0x1433b
jmp 0x1427e
movq -0x138(%rbp), %rax
movb $0x0, (%rax)
movq -0x138(%rbp), %rdi
addq $0x1, %rdi
movl $0xa, %esi
callq 0x41c0
movq %rax, -0x148(%rbp)
cmpq $0x0, -0x148(%rbp)
je 0x14375
movq -0x148(%rbp), %rax
movb $0x0, (%rax)
movq -0x140(%rbp), %rdi
callq 0x5fa0
movq %rax, %rcx
movq -0x18(%rbp), %rax
movq %rcx, (%rax)
movq -0x138(%rbp), %rdi
addq $0x1, %rdi
callq 0x5fa0
movq %rax, %rcx
movq -0x18(%rbp), %rax
movq %rcx, 0x8(%rax)
movb $0x1, -0x21(%rbp)
jmp 0x143b1
jmp 0x1427e
movq -0x20(%rbp), %rdi
callq 0x4150
movb -0x21(%rbp), %al
andb $0x1, %al
movb %al, -0x1(%rbp)
movb -0x1(%rbp), %al
andb $0x1, %al
addq $0x150, %rsp            # imm = 0x150
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O0/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
subq $0x10, %rsp
movl $0x1, -0xc(%rbp)
movl -0xc(%rbp), %edi
leaq 0xe9b(%rip), %rsi       # 0x2004
movl $0x8, %edx
callq 0x11c0
movq %rax, -0x8(%rbp)
cmpq $0x0, %rax
je 0x11ae
movl -0xc(%rbp), %esi
leaq 0xe86(%rip), %rdi       # 0x200d
movb $0x0, %al
callq 0x1030
movq -0x8(%rbp), %rdi
leaq 0xe6b(%rip), %rsi       # 0x2004
movl $0xa, %edx
callq 0x13c0
movl -0xc(%rbp), %eax
addl $0x1, %eax
movl %eax, -0xc(%rbp)
jmp 0x115f
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
nop
// File: /workspace/github_c_makefile_star2_O0/ohkimur[P]the-c-programming-language-2nd-edition-solutions/chapter_4/exercise_4_14/swap.c
// Function: main
int main(void)
{
  int x = 2, y = 3;

  printf("x: %d, y: %d\n", x, y);

  swap(int, x, y);
  printf("x: %d, y: %d\n", x, y);

  return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movl $0x0, -0x4(%rbp)
movl $0x2, -0x8(%rbp)
movl $0x3, -0xc(%rbp)
movl -0x8(%rbp), %esi
movl -0xc(%rbp), %edx
leaq 0xe9a(%rip), %rdi       # 0x2004
movb $0x0, %al
callq 0x1030
movl -0x8(%rbp), %eax
movl %eax, -0x10(%rbp)
movl -0xc(%rbp), %eax
movl %eax, -0x8(%rbp)
movl -0x10(%rbp), %eax
movl %eax, -0xc(%rbp)
movl -0x8(%rbp), %esi
movl -0xc(%rbp), %edx
leaq 0xe74(%rip), %rdi       # 0x2004
movb $0x0, %al
callq 0x1030
xorl %eax, %eax
addq $0x10, %rsp
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O0/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 %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x18(%rbp)
movq -0x8(%rbp), %rdi
callq 0x2090
movq %rax, %rcx
movq -0x18(%rbp), %rax
addq %rcx, %rax
movq %rax, -0x10(%rbp)
movq -0x10(%rbp), %rcx
xorl %eax, %eax
cmpq -0x8(%rbp), %rcx
movb %al, -0x19(%rbp)
jbe 0x27aa
callq 0x2200
movq (%rax), %rax
movq -0x10(%rbp), %rcx
movq %rcx, %rdx
addq $-0x1, %rdx
movq %rdx, -0x10(%rbp)
movzbl -0x1(%rcx), %ecx
movslq %ecx, %rcx
movzwl (%rax,%rcx,2), %eax
andl $0x2000, %eax           # imm = 0x2000
cmpl $0x0, %eax
setne %al
movb %al, -0x19(%rbp)
movb -0x19(%rbp), %al
testb $0x1, %al
jne 0x27b3
jmp 0x27bc
movq -0x10(%rbp), %rax
movb $0x0, (%rax)
jmp 0x276b
movq -0x8(%rbp), %rax
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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
movq %rsp, %rbp
subq $0x20, %rsp
movb %sil, %al
movq %rdi, -0x8(%rbp)
movb %al, -0x9(%rbp)
movl $0x0, -0x10(%rbp)
movq -0x8(%rbp), %rax
movsbl (%rax), %ecx
xorl %eax, %eax
cmpl $0x0, %ecx
movb %al, -0x11(%rbp)
je 0x2831
movq -0x8(%rbp), %rax
movsbl (%rax), %ecx
movsbl -0x9(%rbp), %edx
xorl %eax, %eax
cmpl %edx, %ecx
movb %al, -0x11(%rbp)
je 0x2831
xorl %eax, %eax
cmpl $0x0, -0x10(%rbp)
movb %al, -0x12(%rbp)
je 0x2829
movq -0x8(%rbp), %rax
movsbl (%rax), %eax
cmpl $0x3b, %eax
sete %al
movb %al, -0x12(%rbp)
movb -0x12(%rbp), %al
xorb $-0x1, %al
movb %al, -0x11(%rbp)
movb -0x11(%rbp), %al
testb $0x1, %al
jne 0x283a
jmp 0x2866
callq 0x2200
movq (%rax), %rax
movq -0x8(%rbp), %rcx
movzbl (%rcx), %ecx
movslq %ecx, %rcx
movzwl (%rax,%rcx,2), %eax
andl $0x2000, %eax           # imm = 0x2000
movl %eax, -0x10(%rbp)
movq -0x8(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x8(%rbp)
jmp 0x27e9
movq -0x8(%rbp), %rax
addq $0x20, %rsp
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O0/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 %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movq -0x10(%rbp), %rdi
leaq 0x2735(%rip), %rsi      # 0x5004
callq 0x2180
movq %rax, -0x28(%rbp)
cmpq $0x0, -0x28(%rbp)
jne 0x28e8
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
jmp 0x290b
movq -0x28(%rbp), %rdi
movq -0x18(%rbp), %rsi
movq -0x20(%rbp), %rdx
callq 0x2310
movl %eax, -0x2c(%rbp)
movq -0x28(%rbp), %rdi
callq 0x2080
movl -0x2c(%rbp), %eax
movl %eax, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
nop
// File: /workspace/github_c_makefile_star2_O0/darwin-on-arm[P]darwin-sdk/xcode_tools/xcrun/xcrun.c
// Function: main
int main(int argc, char *argv[])
{
	int call_state;

	/* Strip out any path name that may have been passed into argv[0] */
	progname = basename(argv[0]);

	/* Get our developer dir */
	if (!get_developer_path(developer_dir))
		return 1;

	/* Check if we are being treated as a multi-call binary. */
	call_state = get_multicall_state(progname, multicall_tool_names, 4);

	/* Execute based on the state that we were called in. */
	switch (call_state) {
		case 1: /* xcrun */
			return xcrun_main(argc, argv);
			break;
		case 2: /* xcrun_log */
			logging_mode = 1;
			return xcrun_main(argc, argv);
			break;
		case 3: /* xcrun_verbose */
			verbose_mode = 1;
			return xcrun_main(argc, argv);
			break;
		case 4: /* xcrun_nocache */
			return xcrun_main(argc, argv);
			break;
		case -1:
		default: /* called as tool name */
			/* Locate and execute the command */
			if (request_command(progname, argc, argv) != -1) {
				return 1; /* NOREACH */
			} else {
				fprintf(stderr, "xcrun: error: failed to execute command \'%s\'. aborting.\n", progname);
			}
			break;
	}

	return 1;
}

// 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), %rdi
callq 0x2150
movq %rax, 0x5a07(%rip)      # 0x8350
leaq 0x5a10(%rip), %rdi      # 0x8360
callq 0x2a60
cmpl $0x0, %eax
jne 0x2966
movl $0x1, -0x4(%rbp)
jmp 0x2a4b
movq 0x59e3(%rip), %rdi      # 0x8350
leaq 0x57ac(%rip), %rsi      # 0x8120
movl $0x4, %edx
callq 0x2c70
movl %eax, -0x14(%rbp)
movl -0x14(%rbp), %eax
incl %eax
movl %eax, %ecx
movq %rcx, -0x20(%rbp)
subl $0x5, %eax
ja 0x2a02
movq -0x20(%rbp), %rax
leaq 0x266c(%rip), %rcx      # 0x5008
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
movl -0x8(%rbp), %edi
movq -0x10(%rbp), %rsi
callq 0x2ce0
movl %eax, -0x4(%rbp)
jmp 0x2a4b
movl $0x1, 0x699d(%rip)      # 0x9360
movl -0x8(%rbp), %edi
movq -0x10(%rbp), %rsi
callq 0x2ce0
movl %eax, -0x4(%rbp)
jmp 0x2a4b
movl $0x1, 0x6986(%rip)      # 0x9364
movl -0x8(%rbp), %edi
movq -0x10(%rbp), %rsi
callq 0x2ce0
movl %eax, -0x4(%rbp)
jmp 0x2a4b
movl -0x8(%rbp), %edi
movq -0x10(%rbp), %rsi
callq 0x2ce0
movl %eax, -0x4(%rbp)
jmp 0x2a4b
jmp 0x2a02
movq 0x5947(%rip), %rdi      # 0x8350
movl -0x8(%rbp), %esi
movq -0x10(%rbp), %rdx
callq 0x3650
cmpl $-0x1, %eax
je 0x2a23
movl $0x1, -0x4(%rbp)
jmp 0x2a4b
movq 0x55ce(%rip), %rax      # 0x7ff8
movq (%rax), %rdi
movq 0x591c(%rip), %rdx      # 0x8350
leaq 0x2649(%rip), %rsi      # 0x5084
movb $0x0, %al
callq 0x2120
jmp 0x2a44
movl $0x1, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/darwin-on-arm[P]darwin-sdk/xcode_tools/xcrun/xcrun.c
// Function: get_multicall_state
static int get_multicall_state(const char *cmd, const char *state[], int state_size)
{
	int i;

	for (i = 0; i < (state_size - 1); i++) {
		if (strcmp(cmd, state[i]) == 0)
			return (i + 1);
	}

	return -1;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movl %edx, -0x1c(%rbp)
movl $0x0, -0x20(%rbp)
movl -0x20(%rbp), %eax
movl -0x1c(%rbp), %ecx
subl $0x1, %ecx
cmpl %ecx, %eax
jge 0x2cc9
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rax
movslq -0x20(%rbp), %rcx
movq (%rax,%rcx,8), %rsi
callq 0x2110
cmpl $0x0, %eax
jne 0x2cbc
movl -0x20(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x4(%rbp)
jmp 0x2cd0
jmp 0x2cbe
movl -0x20(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x20(%rbp)
jmp 0x2c8a
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
movl -0x4(%rbp), %eax
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/darwin-on-arm[P]darwin-sdk/xcode_tools/xcrun/xcrun.c
// Function: verbose_printf
static void verbose_printf(FILE *fp, const char *str, ...)
{
	va_list args;

	if (verbose_mode) {
		va_start(args, str);
		vfprintf(fp, str, args);
		va_end(args);
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0xe0, %rsp
testb %al, %al
je 0x3c38
movaps %xmm0, -0xb0(%rbp)
movaps %xmm1, -0xa0(%rbp)
movaps %xmm2, -0x90(%rbp)
movaps %xmm3, -0x80(%rbp)
movaps %xmm4, -0x70(%rbp)
movaps %xmm5, -0x60(%rbp)
movaps %xmm6, -0x50(%rbp)
movaps %xmm7, -0x40(%rbp)
movq %r9, -0xb8(%rbp)
movq %r8, -0xc0(%rbp)
movq %rcx, -0xc8(%rbp)
movq %rdx, -0xd0(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
cmpl $0x0, 0x5701(%rip)      # 0x9364
je 0x3c9e
leaq -0x30(%rbp), %rax
leaq -0xe0(%rbp), %rcx
movq %rcx, 0x10(%rax)
leaq 0x10(%rbp), %rcx
movq %rcx, 0x8(%rax)
movl $0x30, 0x4(%rax)
movl $0x10, (%rax)
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
leaq -0x30(%rbp), %rdx
callq 0x21a0
leaq -0x30(%rbp), %rax
addq $0xe0, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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 %rbp
movq %rsp, %rbp
subq $0xb0, %rsp
movq %rdi, -0x10(%rbp)
movq -0x10(%rbp), %rdi
leaq -0xa0(%rbp), %rsi
callq 0x2140
cmpl $0x0, %eax
je 0x3d54
movq 0x42ed(%rip), %rax      # 0x7ff8
movq (%rax), %rax
movq %rax, -0xb0(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0xa8(%rbp)
callq 0x2050
movl (%rax), %edi
callq 0x21f0
movq -0xb0(%rbp), %rdi
movq -0xa8(%rbp), %rdx
movq %rax, %rcx
leaq 0x1bc8(%rip), %rsi      # 0x590c
movb $0x0, %al
callq 0x2120
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
jmp 0x3d9d
movl -0x88(%rbp), %eax
andl $0xf000, %eax           # imm = 0xF000
cmpl $0x4000, %eax           # imm = 0x4000
sete %al
andb $0x1, %al
movzbl %al, %eax
cmpl $0x0, %eax
jne 0x3d96
movq 0x4280(%rip), %rax      # 0x7ff8
movq (%rax), %rdi
movq -0x10(%rbp), %rdx
leaq 0x1bb7(%rip), %rsi      # 0x593d
movb $0x0, %al
callq 0x2120
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
jmp 0x3d9d
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0xb0, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/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 %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x10(%rbp), %rdi
movl $0x2e, %esi
callq 0x20a0
movq %rax, -0x20(%rbp)
cmpq $0x0, %rax
je 0x3de8
movq -0x20(%rbp), %rax
movq -0x10(%rbp), %rcx
subq %rcx, %rax
movl %eax, -0x14(%rbp)
jmp 0x3df4
movq -0x10(%rbp), %rdi
callq 0x2090
movl %eax, -0x14(%rbp)
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
movslq -0x14(%rbp), %rdx
callq 0x2060
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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 %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x18(%rbp)
movq -0x18(%rbp), %rdi
leaq 0x429(%rip), %rsi       # 0x4280
leaq -0x10(%rbp), %rdx
callq 0x28b0
cmpl $-0x1, %eax
je 0x3e73
movq -0x10(%rbp), %rax
movq -0x8(%rbp), %rdx
addq $0x30, %rsp
popq %rbp
retq
movq 0x417e(%rip), %rax      # 0x7ff8
movq (%rax), %rax
movq %rax, -0x28(%rbp)
movq -0x18(%rbp), %rax
movq %rax, -0x20(%rbp)
callq 0x2050
movl (%rax), %edi
callq 0x21f0
movq -0x28(%rbp), %rdi
movq -0x20(%rbp), %rdx
movq %rax, %rcx
leaq 0x1ad6(%rip), %rsi      # 0x597d
movb $0x0, %al
callq 0x2120
movl $0x1, %edi
callq 0x21d0
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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 %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
leaq 0x448d(%rip), %rax      # 0x8360
movq %rax, -0x10(%rbp)
movl $0x1000, %edi           # imm = 0x1000
movl $0x1, %esi
callq 0x2100
movq %rax, -0x18(%rbp)
cmpq $0x0, -0x10(%rbp)
jne 0x3f0b
movq 0x4100(%rip), %rax      # 0x7ff8
movq (%rax), %rdi
leaq 0x1acd(%rip), %rsi      # 0x59cf
movb $0x0, %al
callq 0x2120
jmp 0x3f59
movq -0x18(%rbp), %rdi
movq -0x10(%rbp), %rdx
movq -0x8(%rbp), %rcx
leaq 0x1af7(%rip), %rsi      # 0x5a15
movb $0x0, %al
callq 0x21c0
movq -0x18(%rbp), %rdi
callq 0x3ce0
cmpl $-0x1, %eax
je 0x3f3d
movq -0x18(%rbp), %rax
addq $0x20, %rsp
popq %rbp
retq
movq 0x40b4(%rip), %rax      # 0x7ff8
movq (%rax), %rdi
movq -0x18(%rbp), %rdx
leaq 0x1ad2(%rip), %rsi      # 0x5a24
movb $0x0, %al
callq 0x2120
movq -0x18(%rbp), %rdi
callq 0x2040
movl $0x1, %edi
callq 0x21d0
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/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 %rbp
movq %rsp, %rbp
subq $0x1030, %rsp           # imm = 0x1030
movq %rdi, -0x1018(%rbp)
movq %rdi, -0x1020(%rbp)
movq %rsi, -0x8(%rbp)
leaq -0x1010(%rbp), %rdi
xorl %esi, %esi
movl $0x1000, %edx           # imm = 0x1000
callq 0x20c0
leaq -0x1010(%rbp), %rdi
movq -0x8(%rbp), %rdx
leaq 0x1a9f(%rip), %rsi      # 0x5a51
movb $0x0, %al
callq 0x21c0
movq -0x1018(%rbp), %rdx
leaq -0x1010(%rbp), %rdi
leaq 0x372(%rip), %rsi       # 0x4340
callq 0x28b0
cmpl $-0x1, %eax
je 0x3fe8
movq -0x1020(%rbp), %rax
addq $0x1030, %rsp           # imm = 0x1030
popq %rbp
retq
movq 0x4009(%rip), %rax      # 0x7ff8
movq (%rax), %rax
movq %rax, -0x1030(%rbp)
leaq -0x1010(%rbp), %rax
movq %rax, -0x1028(%rbp)
callq 0x2050
movl (%rax), %edi
callq 0x21f0
movq -0x1030(%rbp), %rdi
movq -0x1028(%rbp), %rdx
movq %rax, %rcx
leaq 0x1a32(%rip), %rsi      # 0x5a5d
movb $0x0, %al
callq 0x2120
movl $0x1, %edi
callq 0x21d0
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/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 %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
leaq 0x430d(%rip), %rax      # 0x8360
movq %rax, -0x10(%rbp)
movl $0x1000, %edi           # imm = 0x1000
movl $0x1, %esi
callq 0x2100
movq %rax, -0x18(%rbp)
cmpq $0x0, -0x10(%rbp)
jne 0x408b
movq 0x3f80(%rip), %rax      # 0x7ff8
movq (%rax), %rdi
leaq 0x194d(%rip), %rsi      # 0x59cf
movb $0x0, %al
callq 0x2120
jmp 0x40d9
movq -0x18(%rbp), %rdi
movq -0x10(%rbp), %rdx
movq -0x8(%rbp), %rcx
leaq 0x1a3b(%rip), %rsi      # 0x5ad9
movb $0x0, %al
callq 0x21c0
movq -0x18(%rbp), %rdi
callq 0x3ce0
cmpl $-0x1, %eax
je 0x40bd
movq -0x18(%rbp), %rax
addq $0x20, %rsp
popq %rbp
retq
movq 0x3f34(%rip), %rax      # 0x7ff8
movq (%rax), %rdi
movq -0x18(%rbp), %rdx
leaq 0x1a22(%rip), %rsi      # 0x5af4
movb $0x0, %al
callq 0x2120
movq -0x18(%rbp), %rdi
callq 0x2040
movl $0x1, %edi
callq 0x21d0
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/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 %rbp
movq %rsp, %rbp
subq $0x1030, %rsp           # imm = 0x1030
movq %rdi, -0x18(%rbp)
leaq -0x1020(%rbp), %rdi
xorl %esi, %esi
movl $0x1000, %edx           # imm = 0x1000
callq 0x20c0
leaq -0x1020(%rbp), %rdi
movq -0x18(%rbp), %rdx
leaq 0x192d(%rip), %rsi      # 0x5a51
movb $0x0, %al
callq 0x21c0
leaq -0x1020(%rbp), %rdi
leaq 0x407(%rip), %rsi       # 0x4540
leaq -0x10(%rbp), %rdx
callq 0x28b0
cmpl $-0x1, %eax
je 0x4158
movq -0x10(%rbp), %rax
movq -0x8(%rbp), %rdx
addq $0x1030, %rsp           # imm = 0x1030
popq %rbp
retq
movq 0x3e99(%rip), %rax      # 0x7ff8
movq (%rax), %rax
movq %rax, -0x1030(%rbp)
leaq -0x1020(%rbp), %rax
movq %rax, -0x1028(%rbp)
callq 0x2050
movl (%rax), %edi
callq 0x21f0
movq -0x1030(%rbp), %rdi
movq -0x1028(%rbp), %rdx
movq %rax, %rcx
leaq 0x198c(%rip), %rsi      # 0x5b27
movb $0x0, %al
callq 0x2120
movl $0x1, %edi
callq 0x21d0
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/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 %rbp
movq %rsp, %rbp
subq $0x80, %rsp
movq %rdi, -0x10(%rbp)
leaq 0x19a2(%rip), %rdi      # 0x5b68
callq 0x2030
movq %rax, -0x18(%rbp)
cmpq $0x0, %rax
je 0x41e2
movq -0x18(%rbp), %rax
movq %rax, -0x8(%rbp)
jmp 0x4272
movl $0xff, %edi
movl $0x1, %esi
callq 0x2100
movq %rax, -0x18(%rbp)
movq -0x10(%rbp), %rdi
callq 0x3ec0
movq %rax, %rsi
leaq -0x50(%rbp), %rdi
callq 0x3f70
movq -0x38(%rbp), %rdi
callq 0x21e0
movq %rax, -0x20(%rbp)
cmpq $0x0, %rax
jne 0x4227
movq $0x0, -0x8(%rbp)
jmp 0x4272
movq -0x10(%rbp), %rdi
callq 0x3ec0
movq %rax, %rsi
leaq -0x78(%rbp), %rdi
callq 0x3f70
movq -0x58(%rbp), %rdi
callq 0x21e0
movq %rax, -0x28(%rbp)
cmpq $0x0, %rax
jne 0x4259
movq $0x0, -0x8(%rbp)
jmp 0x4272
movq -0x18(%rbp), %rdi
movq -0x28(%rbp), %rsi
movq -0x20(%rbp), %rdx
callq 0x4600
movq -0x18(%rbp), %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x80, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/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
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movq %rcx, -0x28(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x30(%rbp)
movq -0x18(%rbp), %rdi
leaq 0x1711(%rip), %rsi      # 0x59bc
callq 0x2110
cmpl $0x0, %eax
jne 0x42df
movq -0x20(%rbp), %rdi
leaq 0x1700(%rip), %rsi      # 0x59c0
callq 0x2110
cmpl $0x0, %eax
jne 0x42df
movq -0x28(%rbp), %rdi
callq 0x21e0
movq %rax, %rcx
movq -0x30(%rbp), %rax
movq %rcx, (%rax)
jmp 0x432a
movq -0x18(%rbp), %rdi
leaq 0x16db(%rip), %rsi      # 0x59c5
callq 0x2110
cmpl $0x0, %eax
jne 0x431f
movq -0x20(%rbp), %rdi
leaq 0x16c1(%rip), %rsi      # 0x59c0
callq 0x2110
cmpl $0x0, %eax
jne 0x431f
movq -0x28(%rbp), %rdi
callq 0x21e0
movq %rax, %rcx
movq -0x30(%rbp), %rax
movq %rcx, 0x8(%rax)
jmp 0x4328
movl $0x0, -0x4(%rbp)
jmp 0x4331
jmp 0x432a
movl $0x1, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x30, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movq %rcx, -0x28(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x30(%rbp)
movq -0x18(%rbp), %rdi
leaq 0x145a(%rip), %rsi      # 0x59c5
callq 0x2110
cmpl $0x0, %eax
jne 0x459f
movq -0x20(%rbp), %rdi
leaq 0x1440(%rip), %rsi      # 0x59c0
callq 0x2110
cmpl $0x0, %eax
jne 0x459f
movq -0x28(%rbp), %rdi
callq 0x21e0
movq %rax, %rcx
movq -0x30(%rbp), %rax
movq %rcx, (%rax)
jmp 0x45ea
movq -0x18(%rbp), %rdi
leaq 0x141b(%rip), %rsi      # 0x59c5
callq 0x2110
cmpl $0x0, %eax
jne 0x45df
movq -0x20(%rbp), %rdi
leaq 0xcfc(%rip), %rsi       # 0x52bb
callq 0x2110
cmpl $0x0, %eax
jne 0x45df
movq -0x28(%rbp), %rdi
callq 0x21e0
movq %rax, %rcx
movq -0x30(%rbp), %rax
movq %rcx, 0x8(%rax)
jmp 0x45e8
movl $0x0, -0x4(%rbp)
jmp 0x45f1
jmp 0x45ea
movl $0x1, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x30, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/darwin-on-arm[P]darwin-sdk/xcode_tools/xcrun/xcrun.c
// Function: test_sdk_authenticity
static int test_sdk_authenticity(const char *path)
{
	int retval = 0;
	char fname[PATH_MAX];

	sprintf(fname, "%s/info.ini", path);
	if (access(fname, F_OK) != (-1))
		retval = 1;

	return retval;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x1010, %rsp           # imm = 0x1010
movq %rdi, -0x8(%rbp)
movl $0x0, -0xc(%rbp)
leaq -0x1010(%rbp), %rdi
movq -0x8(%rbp), %rdx
leaq 0x1249(%rip), %rsi      # 0x5a51
movb $0x0, %al
callq 0x21c0
leaq -0x1010(%rbp), %rdi
xorl %esi, %esi
callq 0x2170
cmpl $-0x1, %eax
je 0x4829
movl $0x1, -0xc(%rbp)
movl -0xc(%rbp), %eax
addq $0x1010, %rsp           # imm = 0x1010
popq %rbp
retq
nopw %cs:(%rax,%rax)