LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O0/qpfiffer[P]lair/src/main.c
// Function: repl_mode
int _repl_mode() {
	size_t text_size = 1;
	char *text = calloc(text_size, 1);
	char buf[256] = {0};

	printf(">>> ");
	while (fgets(buf, sizeof(buf), stdin)) {
		text_size += strnlen(buf, sizeof(buf));
		text = realloc(text, text_size);
		if (!text)
			return 1;
		strncat(text, buf, text_size);
	}
	printf("%s\n", text);
	free(text);
	return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x120, %rsp            # imm = 0x120
movq $0x1, -0x10(%rbp)
movq -0x10(%rbp), %rdi
movl $0x1, %esi
callq 0x1110
movq %rax, -0x18(%rbp)
leaq -0x120(%rbp), %rdi
xorl %esi, %esi
movl $0x100, %edx            # imm = 0x100
callq 0x10b0
leaq 0x4c5d(%rip), %rdi      # 0x602c
movb $0x0, %al
callq 0x1080
leaq -0x120(%rbp), %rdi
movq 0x7bfc(%rip), %rax      # 0x8fe0
movq (%rax), %rdx
movl $0x100, %esi            # imm = 0x100
callq 0x10f0
cmpq $0x0, %rax
je 0x1447
leaq -0x120(%rbp), %rdi
movl $0x100, %esi            # imm = 0x100
callq 0x10c0
addq -0x10(%rbp), %rax
movq %rax, -0x10(%rbp)
movq -0x18(%rbp), %rdi
movq -0x10(%rbp), %rsi
callq 0x1160
movq %rax, -0x18(%rbp)
cmpq $0x0, -0x18(%rbp)
jne 0x1431
movl $0x1, -0x4(%rbp)
jmp 0x1469
movq -0x18(%rbp), %rdi
leaq -0x120(%rbp), %rsi
movq -0x10(%rbp), %rdx
callq 0x10d0
jmp 0x13d6
movq -0x18(%rbp), %rsi
leaq 0x4c2c(%rip), %rdi      # 0x607e
movb $0x0, %al
callq 0x1080
movq -0x18(%rbp), %rdi
callq 0x1030
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x120, %rsp            # imm = 0x120
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/qpfiffer[P]lair/src/main.c
// Function: main
int main(const int argc, const char *argv[]) {
	if (argc < 1) {
		_print_usage(argv[0]);
		exit(0);
	}

	if (argc >= 2)
		return _load_file(argv);
	return _repl_mode();
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movl $0x0, -0x4(%rbp)
movl %edi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
cmpl $0x1, -0x8(%rbp)
jge 0x14af
movq -0x10(%rbp), %rax
movq (%rax), %rdi
callq 0x14e0
xorl %edi, %edi
callq 0x11c0
cmpl $0x2, -0x8(%rbp)
jl 0x14c3
movq -0x10(%rbp), %rdi
callq 0x12e0
movl %eax, -0x4(%rbp)
jmp 0x14cb
callq 0x1390
movl %eax, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/qpfiffer[P]lair/src/vector.c
// Function: vector_new
vector *vector_new(const size_t item_size, const size_t initial_element_count) {
	vector _vec = {
		.item_size = item_size,
		.max_size = initial_element_count,
		.count = 0,
		.items = malloc(initial_element_count * item_size + 1)
	};

	vector *to_return = malloc(sizeof(vector));
	memcpy(to_return, &_vec, sizeof(vector));

	return to_return;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x30(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x28(%rbp)
movq $0x0, -0x20(%rbp)
movq -0x10(%rbp), %rdi
imulq -0x8(%rbp), %rdi
addq $0x1, %rdi
callq 0x1150
movq %rax, -0x18(%rbp)
movl $0x20, %edi
callq 0x1150
movq %rax, -0x38(%rbp)
movq -0x38(%rbp), %rax
movq -0x30(%rbp), %rcx
movq %rcx, (%rax)
movq -0x28(%rbp), %rcx
movq %rcx, 0x8(%rax)
movq -0x20(%rbp), %rcx
movq %rcx, 0x10(%rax)
movq -0x18(%rbp), %rcx
movq %rcx, 0x18(%rax)
movq -0x38(%rbp), %rax
addq $0x40, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/qpfiffer[P]lair/src/vector.c
// Function: vector_append_ptr
inline int vector_append_ptr(vector *vec, const void *pointer) {
	if (vec->item_size != sizeof(pointer))
		return 0;

	if (vec->count == vec->max_size) {
		vec->max_size *= 2;
		void *array = realloc(vec->items, (vec->max_size * vec->item_size));
		if (!array)
			return 0;
		vec->items = array;
	}

	memcpy(nth(vec->count), &pointer, sizeof(void *));
	vec->count++;
	return 1;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x10(%rbp), %rax
cmpq $0x8, (%rax)
je 0x1706
movl $0x0, -0x4(%rbp)
jmp 0x179b
movq -0x10(%rbp), %rax
movq 0x10(%rax), %rax
movq -0x10(%rbp), %rcx
cmpq 0x8(%rcx), %rax
jne 0x1764
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rcx
shlq %rcx
movq %rcx, 0x8(%rax)
movq -0x10(%rbp), %rax
movq 0x18(%rax), %rdi
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rsi
movq -0x10(%rbp), %rax
imulq (%rax), %rsi
callq 0x1160
movq %rax, -0x20(%rbp)
cmpq $0x0, -0x20(%rbp)
jne 0x1758
movl $0x0, -0x4(%rbp)
jmp 0x179b
movq -0x20(%rbp), %rcx
movq -0x10(%rbp), %rax
movq %rcx, 0x18(%rax)
movq -0x10(%rbp), %rax
movq 0x18(%rax), %rax
movq -0x10(%rbp), %rcx
movq 0x10(%rcx), %rcx
movq -0x10(%rbp), %rdx
imulq (%rdx), %rcx
movq -0x18(%rbp), %rdx
movq %rdx, (%rax,%rcx)
movq -0x10(%rbp), %rax
movq 0x10(%rax), %rcx
addq $0x1, %rcx
movq %rcx, 0x10(%rax)
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/qpfiffer[P]lair/src/error.c
// Function: print_error
void print_error(const ERROR_TYPE err_type, const char *msg) {
	const char *friendly_err = _friendly_err(err_type);
	char buf[256] = {0};

	snprintf(buf, sizeof(buf), "%c[%dm%s%c[%dm", 0x1B, 31, friendly_err, 0x1B, 0x0);
	snprintf(buf + strlen(buf), sizeof(buf), ": %s\n", msg);
	printf("%s", buf);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x140, %rsp            # imm = 0x140
movl %edi, -0x4(%rbp)
movq %rsi, -0x10(%rbp)
movl -0x4(%rbp), %edi
callq 0x19c0
movq %rax, -0x18(%rbp)
leaq -0x120(%rbp), %rdi
xorl %esi, %esi
movl $0x100, %edx            # imm = 0x100
callq 0x10b0
leaq -0x120(%rbp), %rdi
movq -0x18(%rbp), %r9
movl $0x100, %esi            # imm = 0x100
leaq 0x4735(%rip), %rdx      # 0x606d
movl $0x1b, %ecx
movl $0x1f, %r8d
xorl %eax, %eax
movl $0x1b, (%rsp)
movl $0x0, 0x8(%rsp)
movb $0x0, %al
callq 0x1090
leaq -0x120(%rbp), %rax
movq %rax, -0x128(%rbp)
leaq -0x120(%rbp), %rdi
callq 0x1060
movq -0x128(%rbp), %rdi
addq %rax, %rdi
movq -0x10(%rbp), %rcx
movl $0x100, %esi            # imm = 0x100
leaq 0x46ed(%rip), %rdx      # 0x607c
movb $0x0, %al
callq 0x1090
leaq -0x120(%rbp), %rsi
leaq 0x4dbe(%rip), %rdi      # 0x6762
movb $0x0, %al
callq 0x1080
addq $0x140, %rsp            # imm = 0x140
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/qpfiffer[P]lair/src/error.c
// Function: friendly_err
static inline const char *_friendly_err(const ERROR_TYPE err) {
	switch (err) {
		case ERR_PARSE:			return "ERR_PARSE";
		case ERR_RUNTIME:		return "ERR_RUNTIME";
		case ERR_SYNTAX:		return "ERR_SYNTAX";
		default:				return "ERROR";
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movl %edi, -0xc(%rbp)
movl -0xc(%rbp), %eax
movl %eax, -0x10(%rbp)
testl %eax, %eax
je 0x19e7
jmp 0x19d3
movl -0x10(%rbp), %eax
subl $0x1, %eax
je 0x1a01
jmp 0x19dd
movl -0x10(%rbp), %eax
subl $0x2, %eax
je 0x19f4
jmp 0x1a0e
leaq 0x4694(%rip), %rax      # 0x6082
movq %rax, -0x8(%rbp)
jmp 0x1a19
leaq 0x4691(%rip), %rax      # 0x608c
movq %rax, -0x8(%rbp)
jmp 0x1a19
leaq 0x4690(%rip), %rax      # 0x6098
movq %rax, -0x8(%rbp)
jmp 0x1a19
leaq 0x468e(%rip), %rax      # 0x60a3
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/qpfiffer[P]lair/src/lair_std.c
// Function: lair_builtin_print
const struct _lair_type *_lair_builtin_print(LAIR_FUNCTION_SIG) {
	check(r, argc == 1, ERR_RUNTIME, "Incorrect number of arguments to 'print' function.");

	if (argv[0] == NULL) {
		printf("(null)");
		return NULL;
	}

	switch (argv[0]->type) {
	case LR_STRING:
		printf("%s", argv[0]->value.str);
		break;
	case LR_NUM:
		printf("%i", argv[0]->value.num);
		break;
	case LR_FUNCTION_DEF:
	case LR_FUNCTION_CALL:
		printf("<%s!: %s>", _friendly_enum(argv[0]->type), argv[0]->value.str);
		break;
	default:
		printf("<%s: %p>", _friendly_enum(argv[0]->type), argv[0]);
		break;
	}

	return NULL;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movl %esi, -0x14(%rbp)
movq %rdx, -0x20(%rbp)
movq -0x10(%rbp), %rdi
cmpl $0x1, -0x14(%rbp)
sete %al
andb $0x1, %al
movzbl %al, %esi
movl $0x2, %edx
leaq 0x424c(%rip), %rcx      # 0x628b
callq 0x1830
movq -0x20(%rbp), %rax
cmpq $0x0, (%rax)
jne 0x2069
leaq 0x4269(%rip), %rdi      # 0x62be
movb $0x0, %al
callq 0x1080
movq $0x0, -0x8(%rbp)
jmp 0x2121
movq -0x20(%rbp), %rax
movq (%rax), %rax
movl (%rax), %eax
movl %eax, -0x24(%rbp)
decl %eax
subl $0x2, %eax
jb 0x20c7
jmp 0x207e
movl -0x24(%rbp), %eax
subl $0xa, %eax
je 0x2092
jmp 0x2088
movl -0x24(%rbp), %eax
subl $0xf, %eax
je 0x20ad
jmp 0x20f3
movq -0x20(%rbp), %rax
movq (%rax), %rax
movq 0x8(%rax), %rsi
leaq 0x46be(%rip), %rdi      # 0x6762
movb $0x0, %al
callq 0x1080
jmp 0x2119
movq -0x20(%rbp), %rax
movq (%rax), %rax
movl 0x8(%rax), %esi
leaq 0x4257(%rip), %rdi      # 0x6315
movb $0x0, %al
callq 0x1080
jmp 0x2119
movq -0x20(%rbp), %rax
movq (%rax), %rax
movl (%rax), %edi
callq 0x3d10
movq %rax, %rsi
movq -0x20(%rbp), %rax
movq (%rax), %rax
movq 0x8(%rax), %rdx
leaq 0x41db(%rip), %rdi      # 0x62c5
movb $0x0, %al
callq 0x1080
jmp 0x2119
movq -0x20(%rbp), %rax
movq (%rax), %rax
movl (%rax), %edi
callq 0x3d10
movq %rax, %rsi
movq -0x20(%rbp), %rax
movq (%rax), %rdx
leaq 0x41bd(%rip), %rdi      # 0x62cf
movb $0x0, %al
callq 0x1080
movq $0x0, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/qpfiffer[P]lair/src/lair_std.c
// Function: lair_builtin_println
const struct _lair_type *_lair_builtin_println(LAIR_FUNCTION_SIG) {
	check(r, argc == 1, ERR_RUNTIME, "Incorrect number of arguments to 'println' function.");
	_lair_builtin_print(r, argc, argv);
	printf("\n");

	return NULL;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x8(%rbp), %rdi
cmpl $0x1, -0xc(%rbp)
sete %al
andb $0x1, %al
movzbl %al, %esi
movl $0x2, %edx
leaq 0x4179(%rip), %rcx      # 0x62d8
callq 0x1830
movq -0x8(%rbp), %rdi
movl -0xc(%rbp), %esi
movq -0x18(%rbp), %rdx
callq 0x2010
leaq 0x45ee(%rip), %rdi      # 0x6769
movb $0x0, %al
callq 0x1080
xorl %eax, %eax
addq $0x20, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/qpfiffer[P]lair/src/eval.c
// Function: lair_standard_env
struct _lair_env *_lair_standard_env(struct _lair_runtime *r) {
	struct _lair_env *std_env = calloc(1, sizeof(struct _lair_env));

	int rc = 0;
	ADD_TO_STD_ENV(r, "print", 1, &_lair_builtin_print);
	ADD_TO_STD_ENV(r, "println", 1, &_lair_builtin_println);
	ADD_TO_STD_ENV(r, "+", 2, &_lair_builtin_operator_plus);
	ADD_TO_STD_ENV(r, "-", 2, &_lair_builtin_operator_minus);
	ADD_TO_STD_ENV(r, "=", 2, &_lair_builtin_operator_eq);
	ADD_TO_STD_ENV(r, "str", 2, &_lair_builtin_str);

	return std_env;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movl $0x1, %edi
movl $0x30, %esi
callq 0x1110
movq %rax, -0x10(%rbp)
movl $0x0, -0x14(%rbp)
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
leaq 0x3ea3(%rip), %rdx      # 0x63a8
movl $0x1, %ecx
leaq -0x501(%rip), %r8       # 0x2010
callq 0x2660
movl %eax, -0x14(%rbp)
cmpl $0x0, -0x14(%rbp)
je 0x2530
movl $0x2, %edi
leaq 0x3e83(%rip), %rsi      # 0x63ae
callq 0x18c0
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
leaq 0x3e8d(%rip), %rdx      # 0x63cc
movl $0x1, %ecx
leaq -0x41b(%rip), %r8       # 0x2130
callq 0x2660
movl %eax, -0x14(%rbp)
cmpl $0x0, -0x14(%rbp)
je 0x256a
movl $0x2, %edi
leaq 0x3e49(%rip), %rsi      # 0x63ae
callq 0x18c0
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
leaq 0x3e5b(%rip), %rdx      # 0x63d4
movl $0x2, %ecx
leaq -0xb65(%rip), %r8       # 0x1a20
callq 0x2660
movl %eax, -0x14(%rbp)
cmpl $0x0, -0x14(%rbp)
je 0x25a4
movl $0x2, %edi
leaq 0x3e0f(%rip), %rsi      # 0x63ae
callq 0x18c0
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
leaq 0x3e23(%rip), %rdx      # 0x63d6
movl $0x2, %ecx
leaq -0x92f(%rip), %r8       # 0x1c90
callq 0x2660
movl %eax, -0x14(%rbp)
cmpl $0x0, -0x14(%rbp)
je 0x25de
movl $0x2, %edi
leaq 0x3dd5(%rip), %rsi      # 0x63ae
callq 0x18c0
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
leaq 0x3deb(%rip), %rdx      # 0x63d8
movl $0x2, %ecx
leaq -0x7d9(%rip), %r8       # 0x1e20
callq 0x2660
movl %eax, -0x14(%rbp)
cmpl $0x0, -0x14(%rbp)
je 0x2618
movl $0x2, %edi
leaq 0x3d9b(%rip), %rsi      # 0x63ae
callq 0x18c0
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
leaq 0x3db3(%rip), %rdx      # 0x63da
movl $0x2, %ecx
leaq -0x4a3(%rip), %r8       # 0x2190
callq 0x2660
movl %eax, -0x14(%rbp)
cmpl $0x0, -0x14(%rbp)
je 0x2652
movl $0x2, %edi
leaq 0x3d61(%rip), %rsi      # 0x63ae
callq 0x18c0
movq -0x10(%rbp), %rax
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/qpfiffer[P]lair/src/eval.c
// Function: lair_add_builtin_function
int _lair_add_builtin_function(
		struct _lair_runtime *r,
		struct _lair_env *env,
		const char *name,
		const int argc,
		const struct _lair_type *(*func_ptr)(LAIR_FUNCTION_SIG)) {
	check(r, name != NULL, ERR_RUNTIME, "Function name cannot be NULL.");
	check(r, env != NULL, ERR_RUNTIME, "Environment cannot be NULL.");
	check(r, strlen(name) > 0, ERR_RUNTIME, "Function name must be more than 0 chars.");

	/* Check to see if that function already exists: */
	const struct _lair_function *existing_func = _tst_map_get(env->c_functions, name, strlen(name));
	if (existing_func != NULL)
		throw_exception(r, ERR_RUNTIME, "Cannot override builtin functions.");

	struct _lair_function _stack_func = {
		.argc = argc,
		.argv = calloc(argc, sizeof(struct _lair_type)),
		.function_ptr = func_ptr
	};

	return _tst_map_insert(&(env->c_functions), name, strlen(name), &_stack_func, sizeof(struct _lair_function));
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x70, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movl %ecx, -0x1c(%rbp)
movq %r8, -0x28(%rbp)
movq -0x8(%rbp), %rdi
cmpq $0x0, -0x18(%rbp)
setne %al
andb $0x1, %al
movzbl %al, %esi
movl $0x2, %edx
leaq 0x3d46(%rip), %rcx      # 0x63de
callq 0x1830
movq -0x8(%rbp), %rdi
cmpq $0x0, -0x10(%rbp)
setne %al
andb $0x1, %al
movzbl %al, %esi
movl $0x2, %edx
leaq 0x3d42(%rip), %rcx      # 0x63fc
callq 0x1830
movq -0x8(%rbp), %rax
movq %rax, -0x60(%rbp)
movq -0x18(%rbp), %rdi
callq 0x1060
movq -0x60(%rbp), %rdi
cmpq $0x0, %rax
seta %al
andb $0x1, %al
movzbl %al, %esi
movl $0x2, %edx
leaq 0x3d2c(%rip), %rcx      # 0x6418
callq 0x1830
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rax
movq %rax, -0x58(%rbp)
movq -0x18(%rbp), %rax
movq %rax, -0x50(%rbp)
movq -0x18(%rbp), %rdi
callq 0x1060
movq -0x58(%rbp), %rdi
movq -0x50(%rbp), %rsi
movq %rax, %rdx
callq 0x3a90
movq %rax, -0x30(%rbp)
cmpq $0x0, -0x30(%rbp)
je 0x273e
movq -0x8(%rbp), %rdi
movl $0x2, %esi
leaq 0x3d08(%rip), %rdx      # 0x6441
callq 0x1870
movl -0x1c(%rbp), %eax
movl %eax, -0x48(%rbp)
movslq -0x1c(%rbp), %rdi
movl $0x10, %esi
callq 0x1110
movq %rax, -0x40(%rbp)
movq -0x28(%rbp), %rax
movq %rax, -0x38(%rbp)
movq -0x10(%rbp), %rax
addq $0x8, %rax
movq %rax, -0x70(%rbp)
movq -0x18(%rbp), %rax
movq %rax, -0x68(%rbp)
movq -0x18(%rbp), %rdi
callq 0x1060
movq -0x70(%rbp), %rdi
movq -0x68(%rbp), %rsi
movq %rax, %rdx
leaq -0x48(%rbp), %rcx
movl $0x18, %r8d
callq 0x3890
addq $0x70, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/qpfiffer[P]lair/src/eval.c
// Function: evalute_if_statement
static inline const struct _lair_ast *_evalute_if_statement(struct _lair_runtime *r, const struct _lair_ast *ast, struct _lair_env *env) {
	const struct _lair_type *result = _lair_call_function(r, ast->next, env);
	const unsigned int initial_indent_level = ast->indent_level;
	if (result == _lair_canonical_true()) {
		/* If we're true then we want to jump to the next AST item and make sure
		 * that it's indentation level is *higher* than ours.
		 */
		while (ast->indent_level == initial_indent_level) {
			if (ast->next == NULL)
				error_and_die(ERR_SYNTAX, "No 'true' branch on if statement.");
			ast = ast->next;
		}

		check(r, ast->indent_level > initial_indent_level, ERR_SYNTAX, "No 'True' condition to follow.");
	} else {
		/* If we're false we just continue on to the next ast node LESS THAN OR EQUAL to ours.
		*/
		unsigned int skip_indent_level = ast->indent_level;
		while (ast->indent_level == skip_indent_level) {
			if (ast->next == NULL)
				error_and_die(ERR_SYNTAX, "Unexpected EOF.");
			ast = ast->next;
			if (ast->atom.type == LR_INDENT && ast->indent_level > initial_indent_level)
				skip_indent_level = ast->indent_level;
			if (ast->indent_level < skip_indent_level)
				break;
		}
	}

	return ast;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rsi
movq -0x18(%rbp), %rdx
callq 0x2a40
movq %rax, -0x20(%rbp)
movq -0x10(%rbp), %rax
movl 0x20(%rax), %eax
movl %eax, -0x24(%rbp)
movq -0x20(%rbp), %rax
movq %rax, -0x30(%rbp)
callq 0x24c0
movq %rax, %rcx
movq -0x30(%rbp), %rax
cmpq %rcx, %rax
jne 0x2d91
jmp 0x2d32
movq -0x10(%rbp), %rax
movl 0x20(%rax), %eax
cmpl -0x24(%rbp), %eax
jne 0x2d68
movq -0x10(%rbp), %rax
cmpq $0x0, 0x8(%rax)
jne 0x2d5a
movl $0x1, %edi
leaq 0x3821(%rip), %rsi      # 0x6576
callq 0x18c0
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rax
movq %rax, -0x10(%rbp)
jmp 0x2d32
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rax
movl 0x20(%rax), %eax
cmpl -0x24(%rbp), %eax
seta %al
andb $0x1, %al
movzbl %al, %esi
movl $0x1, %edx
leaq 0x380e(%rip), %rcx      # 0x6598
callq 0x1830
jmp 0x2e01
movq -0x10(%rbp), %rax
movl 0x20(%rax), %eax
movl %eax, -0x28(%rbp)
movq -0x10(%rbp), %rax
movl 0x20(%rax), %eax
cmpl -0x28(%rbp), %eax
jne 0x2dff
movq -0x10(%rbp), %rax
cmpq $0x0, 0x8(%rax)
jne 0x2dc3
movl $0x1, %edi
leaq 0x37f9(%rip), %rsi      # 0x65b7
callq 0x18c0
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rax
movq %rax, -0x10(%rbp)
movq -0x10(%rbp), %rax
cmpl $0x7, 0x28(%rax)
jne 0x2def
movq -0x10(%rbp), %rax
movl 0x20(%rax), %eax
cmpl -0x24(%rbp), %eax
jbe 0x2def
movq -0x10(%rbp), %rax
movl 0x20(%rax), %eax
movl %eax, -0x28(%rbp)
movq -0x10(%rbp), %rax
movl 0x20(%rax), %eax
cmpl -0x28(%rbp), %eax
jae 0x2dfd
jmp 0x2dff
jmp 0x2d9b
jmp 0x2e01
movq -0x10(%rbp), %rax
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/qpfiffer[P]lair/src/eval.c
// Function: lair_add_simple_function
static int _lair_add_simple_function(struct _lair_env *env, const char *name, const struct _lair_type *value) {
	/* This is kind of dumb but whatever. */
	struct _lair_ast val = {
		.atom = {
			.type = value->type,
			/* HOLY SHIT UNIONS ARE AWESOME */
			.value = value->value
		}
	};

	return _tst_map_insert(&(env->not_variables), name, strlen(name), &val, sizeof(struct _lair_ast));
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x60, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
leaq -0x50(%rbp), %rdi
xorl %esi, %esi
movl $0x38, %edx
callq 0x10b0
movq -0x18(%rbp), %rax
movl (%rax), %eax
movl %eax, -0x28(%rbp)
movq -0x18(%rbp), %rax
movq 0x8(%rax), %rax
movq %rax, -0x20(%rbp)
movq -0x8(%rbp), %rax
addq $0x18, %rax
movq %rax, -0x60(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x58(%rbp)
movq -0x10(%rbp), %rdi
callq 0x1060
movq -0x60(%rbp), %rdi
movq -0x58(%rbp), %rsi
movq %rax, %rdx
leaq -0x50(%rbp), %rcx
movl $0x38, %r8d
callq 0x3890
addq $0x60, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/qpfiffer[P]lair/src/eval.c
// Function: continue
static inline const struct _lair_ast *_continue(const struct _lair_ast *ast) {
	/* Jump to next line here. */
	while (ast->atom.type != LR_INDENT) {
		ast = ast->next;
		if (ast == NULL || ast->atom.type == LR_EOF)
			break;
	}
	return ast;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
cmpl $0x7, 0x28(%rax)
je 0x3033
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rax
movq %rax, -0x8(%rbp)
cmpq $0x0, -0x8(%rbp)
je 0x302f
movq -0x8(%rbp), %rax
cmpl $0x9, 0x28(%rax)
jne 0x3031
jmp 0x3033
jmp 0x3008
movq -0x8(%rbp), %rax
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/qpfiffer[P]lair/src/eval.c
// Function: is_callable
static inline int _is_callable(const struct _lair_ast *n) {
	const LAIR_TOKEN t = n->atom.type;

	switch (t) {
		case LR_ATOM:
		case LR_IF:
		case LR_OPERATOR:
		case LR_FUNCTION_DEF:
		case LR_FUNCTION_CALL:
			return 1;
		default:
			return 0;
	}

	return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x10(%rbp)
movq -0x10(%rbp), %rax
movl 0x28(%rax), %eax
movl %eax, -0x14(%rbp)
movl -0x14(%rbp), %eax
movl %eax, -0x18(%rbp)
decl %eax
subl $0x3, %eax
jb 0x3075
jmp 0x3061
movl -0x18(%rbp), %eax
subl $0xc, %eax
je 0x3075
jmp 0x306b
movl -0x18(%rbp), %eax
subl $0xe, %eax
jne 0x307e
jmp 0x3075
movl $0x1, -0x4(%rbp)
jmp 0x3085
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/qpfiffer[P]lair/src/eval.c
// Function: lair_eval
int _lair_eval(struct _lair_runtime *r, const struct _lair_ast *root) {
	struct _lair_env *std_env = _lair_standard_env(r);
	const struct _lair_ast *cur_ast_node = root->children;

	while (cur_ast_node != NULL) {
		if (cur_ast_node->atom.type == LR_CALL) {
			_lair_env_eval(r, cur_ast_node, std_env);
		} else if (cur_ast_node->atom.type == LR_FUNCTION_DEF) {
			const char *func_name = cur_ast_node->atom.value.str;
			const size_t func_name_len = strlen(func_name);

			const void *is_std_func = _tst_map_get(
					std_env->functions, func_name, func_name_len);
			const void *is_c_func = _tst_map_get(
					std_env->c_functions, func_name, func_name_len);
			if (!is_std_func && !is_c_func) {
				/* We're defining a function so insert it. */
				_tst_map_insert(&std_env->functions,
						func_name,
						func_name_len,
						cur_ast_node,
						sizeof(struct _lair_ast));
			} else {
				/* Call the function instead of defining it. */
				_lair_call_function(r, cur_ast_node, std_env);
			}
		}

		cur_ast_node = cur_ast_node->sibling;
	}

	_lair_free_env(std_env);
	return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rdi
callq 0x24d0
movq %rax, -0x18(%rbp)
movq -0x10(%rbp), %rax
movq 0x10(%rax), %rax
movq %rax, -0x20(%rbp)
cmpq $0x0, -0x20(%rbp)
je 0x31d2
movq -0x20(%rbp), %rax
cmpl $0xb, 0x28(%rax)
jne 0x3124
movq -0x8(%rbp), %rdi
movq -0x20(%rbp), %rsi
movq -0x18(%rbp), %rdx
callq 0x27e0
jmp 0x31c1
movq -0x20(%rbp), %rax
cmpl $0x1, 0x28(%rax)
jne 0x31bf
movq -0x20(%rbp), %rax
movq 0x30(%rax), %rax
movq %rax, -0x28(%rbp)
movq -0x28(%rbp), %rdi
callq 0x1060
movq %rax, -0x30(%rbp)
movq -0x18(%rbp), %rax
movq 0x10(%rax), %rdi
movq -0x28(%rbp), %rsi
movq -0x30(%rbp), %rdx
callq 0x3a90
movq %rax, -0x38(%rbp)
movq -0x18(%rbp), %rax
movq 0x8(%rax), %rdi
movq -0x28(%rbp), %rsi
movq -0x30(%rbp), %rdx
callq 0x3a90
movq %rax, -0x40(%rbp)
cmpq $0x0, -0x38(%rbp)
jne 0x31ac
cmpq $0x0, -0x40(%rbp)
jne 0x31ac
movq -0x18(%rbp), %rdi
addq $0x10, %rdi
movq -0x28(%rbp), %rsi
movq -0x30(%rbp), %rdx
movq -0x20(%rbp), %rcx
movl $0x38, %r8d
callq 0x3890
jmp 0x31bd
movq -0x8(%rbp), %rdi
movq -0x20(%rbp), %rsi
movq -0x18(%rbp), %rdx
callq 0x2a40
jmp 0x31bf
jmp 0x31c1
movq -0x20(%rbp), %rax
movq 0x18(%rax), %rax
movq %rax, -0x20(%rbp)
jmp 0x30f9
movq -0x18(%rbp), %rdi
callq 0x31f0
xorl %eax, %eax
addq $0x40, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/qpfiffer[P]lair/src/eval.c
// Function: is_callable_runtime
static inline int _is_callable_runtime(const struct _lair_env *env, const struct _lair_ast *n) {
	const char *func_name = n->atom.value.str;
	const size_t func_name_len = strlen(func_name);

	const void *is_std_func = _tst_map_get(
			env->functions, func_name, func_name_len);
	const void *is_c_func = _tst_map_get(
			env->c_functions, func_name, func_name_len);

	return _is_callable(n) || is_std_func != NULL || is_c_func != NULL;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x10(%rbp), %rax
movq 0x30(%rax), %rax
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rdi
callq 0x1060
movq %rax, -0x20(%rbp)
movq -0x8(%rbp), %rax
movq 0x10(%rax), %rdi
movq -0x18(%rbp), %rsi
movq -0x20(%rbp), %rdx
callq 0x3a90
movq %rax, -0x28(%rbp)
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rdi
movq -0x18(%rbp), %rsi
movq -0x20(%rbp), %rdx
callq 0x3a90
movq %rax, -0x30(%rbp)
movq -0x10(%rbp), %rdi
callq 0x3040
movl %eax, %ecx
movb $0x1, %al
cmpl $0x0, %ecx
movb %al, -0x31(%rbp)
jne 0x3877
movb $0x1, %al
cmpq $0x0, -0x28(%rbp)
movb %al, -0x31(%rbp)
jne 0x3877
cmpq $0x0, -0x30(%rbp)
setne %al
movb %al, -0x31(%rbp)
movb -0x31(%rbp), %al
andb $0x1, %al
movzbl %al, %eax
addq $0x40, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
nop
// File: /workspace/github_c_makefile_star2_O0/qpfiffer[P]lair/src/map.c
// Function: tst_map_insert
int _tst_map_insert(struct _tst_map_node **root, const char *key, const size_t klen, const void *value, const size_t vsiz) {
	assert(key != NULL);
	assert(klen > 0);

	size_t _klen = klen;
	return _tst_insert(root, key, _klen, value, vsiz);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq %rcx, -0x20(%rbp)
movq %r8, -0x28(%rbp)
cmpq $0x0, -0x10(%rbp)
je 0x38b5
jmp 0x38d4
leaq 0x2d31(%rip), %rdi      # 0x65ed
leaq 0x2d36(%rip), %rsi      # 0x65f9
movl $0x24, %edx
leaq 0x2d34(%rip), %rcx      # 0x6603
callq 0x10a0
cmpq $0x0, -0x18(%rbp)
jbe 0x38dd
jmp 0x38fc
leaq 0x2d84(%rip), %rdi      # 0x6668
leaq 0x2d0e(%rip), %rsi      # 0x65f9
movl $0x25, %edx
leaq 0x2d0c(%rip), %rcx      # 0x6603
callq 0x10a0
movq -0x18(%rbp), %rax
movq %rax, -0x30(%rbp)
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
movq -0x30(%rbp), %rdx
movq -0x20(%rbp), %rcx
movq -0x28(%rbp), %r8
callq 0x3930
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/qpfiffer[P]lair/src/map.c
// Function: tst_insert
static int _tst_insert(struct _tst_map_node **cur_node, const char *key, size_t klen, const void *value, const size_t vsiz) {
	/* This function is just scary looking because we're passing around pointers
	 * to pointers. It's not that bad.
	 */
	const char current_char = key[0];

	if (*cur_node == NULL) {
		*cur_node = calloc(1, sizeof(struct _tst_map_node));
		(*cur_node)->node_char = current_char;
	}

	if (current_char < (*cur_node)->node_char) {
		return _tst_insert(&((*cur_node)->lokid), key, klen, value, vsiz);
	} else if (current_char == (*cur_node)->node_char) {
		if (klen > 1) {
			return _tst_insert(&(*cur_node)->eqkid, key + 1, klen - 1, value, vsiz);
		} else {
			if ((*cur_node)->value != NULL) // Duplicate?
				return 1;

			(*cur_node)->value = calloc(1, vsiz);
			memcpy((*cur_node)->value, value, vsiz);
			return 0;
		}
	} else {
		return _tst_insert(&((*cur_node)->hikid), key, klen, value, vsiz);
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movq %rcx, -0x28(%rbp)
movq %r8, -0x30(%rbp)
movq -0x18(%rbp), %rax
movb (%rax), %al
movb %al, -0x31(%rbp)
movq -0x10(%rbp), %rax
cmpq $0x0, (%rax)
jne 0x3985
movl $0x1, %edi
movl $0x28, %esi
callq 0x1110
movq %rax, %rcx
movq -0x10(%rbp), %rax
movq %rcx, (%rax)
movb -0x31(%rbp), %cl
movq -0x10(%rbp), %rax
movq (%rax), %rax
movb %cl, 0x18(%rax)
movsbl -0x31(%rbp), %eax
movq -0x10(%rbp), %rcx
movq (%rcx), %rcx
movsbl 0x18(%rcx), %ecx
cmpl %ecx, %eax
jge 0x39c0
movq -0x10(%rbp), %rax
movq (%rax), %rdi
addq $0x10, %rdi
movq -0x18(%rbp), %rsi
movq -0x20(%rbp), %rdx
movq -0x28(%rbp), %rcx
movq -0x30(%rbp), %r8
callq 0x3930
movl %eax, -0x4(%rbp)
jmp 0x3a7e
movsbl -0x31(%rbp), %eax
movq -0x10(%rbp), %rcx
movq (%rcx), %rcx
movsbl 0x18(%rcx), %ecx
cmpl %ecx, %eax
jne 0x3a5f
cmpq $0x1, -0x20(%rbp)
jbe 0x3a0b
movq -0x10(%rbp), %rax
movq (%rax), %rdi
addq $0x8, %rdi
movq -0x18(%rbp), %rsi
addq $0x1, %rsi
movq -0x20(%rbp), %rdx
subq $0x1, %rdx
movq -0x28(%rbp), %rcx
movq -0x30(%rbp), %r8
callq 0x3930
movl %eax, -0x4(%rbp)
jmp 0x3a7e
movq -0x10(%rbp), %rax
movq (%rax), %rax
cmpq $0x0, 0x20(%rax)
je 0x3a22
movl $0x1, -0x4(%rbp)
jmp 0x3a7e
movq -0x30(%rbp), %rsi
movl $0x1, %edi
callq 0x1110
movq %rax, %rcx
movq -0x10(%rbp), %rax
movq (%rax), %rax
movq %rcx, 0x20(%rax)
movq -0x10(%rbp), %rax
movq (%rax), %rax
movq 0x20(%rax), %rdi
movq -0x28(%rbp), %rsi
movq -0x30(%rbp), %rdx
callq 0x1140
movl $0x0, -0x4(%rbp)
jmp 0x3a7e
movq -0x10(%rbp), %rax
movq (%rax), %rdi
movq -0x18(%rbp), %rsi
movq -0x20(%rbp), %rdx
movq -0x28(%rbp), %rcx
movq -0x30(%rbp), %r8
callq 0x3930
movl %eax, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x40, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/qpfiffer[P]lair/src/map.c
// Function: tst_map_get
const void *_tst_map_get(struct _tst_map_node *current_node, const char *key, const size_t klen) {
	const char current_char = key[0];

	if (current_node == NULL)
		return NULL;

	if (current_char < current_node->node_char) {
		return _tst_map_get(current_node->lokid, key, klen);
	} else if (current_char == current_node->node_char) {
		if (klen > 1)
			return _tst_map_get(current_node->eqkid, key + 1, klen - 1);
		return current_node->value;
	} else {
		return _tst_map_get(current_node->hikid, key, klen);
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movq -0x18(%rbp), %rax
movb (%rax), %al
movb %al, -0x21(%rbp)
cmpq $0x0, -0x10(%rbp)
jne 0x3ac1
movq $0x0, -0x8(%rbp)
jmp 0x3b4c
movsbl -0x21(%rbp), %eax
movq -0x10(%rbp), %rcx
movsbl 0x18(%rcx), %ecx
cmpl %ecx, %eax
jge 0x3aec
movq -0x10(%rbp), %rax
movq 0x10(%rax), %rdi
movq -0x18(%rbp), %rsi
movq -0x20(%rbp), %rdx
callq 0x3a90
movq %rax, -0x8(%rbp)
jmp 0x3b4c
movsbl -0x21(%rbp), %eax
movq -0x10(%rbp), %rcx
movsbl 0x18(%rcx), %ecx
cmpl %ecx, %eax
jne 0x3b34
cmpq $0x1, -0x20(%rbp)
jbe 0x3b26
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rdi
movq -0x18(%rbp), %rsi
addq $0x1, %rsi
movq -0x20(%rbp), %rdx
subq $0x1, %rdx
callq 0x3a90
movq %rax, -0x8(%rbp)
jmp 0x3b4c
movq -0x10(%rbp), %rax
movq 0x20(%rax), %rax
movq %rax, -0x8(%rbp)
jmp 0x3b4c
movq -0x10(%rbp), %rax
movq (%rax), %rdi
movq -0x18(%rbp), %rsi
movq -0x20(%rbp), %rdx
callq 0x3a90
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/qpfiffer[P]lair/src/map.c
// Function: tst_map_destroy
void _tst_map_destroy(struct _tst_map_node *root, void (*per_value_cleanup)(void *data)) {
	if (root == NULL)
		return;
	/* TODO: This whole function. */
	struct destroy_queue *top = calloc(1, sizeof(struct destroy_queue));
	dq_push(&top, root);

	while (top->next != NULL) {
		struct _tst_map_node *cur_node = (struct _tst_map_node *)dq_pop(&top);

		if (cur_node->lokid != NULL)
			dq_push(&top, (void *)cur_node->lokid);

		if (cur_node->eqkid != NULL)
			dq_push(&top, (void *)cur_node->eqkid);

		if (cur_node->hikid != NULL)
			dq_push(&top, (void *)cur_node->hikid);

		if (per_value_cleanup != NULL && cur_node->value != NULL)
			per_value_cleanup(cur_node->value);
		free(cur_node->value);
		free(cur_node);
	}

	free(top);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
cmpq $0x0, -0x8(%rbp)
jne 0x3b7c
jmp 0x3c4d
movl $0x1, %edi
movl $0x10, %esi
callq 0x1110
movq %rax, -0x18(%rbp)
movq -0x8(%rbp), %rsi
leaq -0x18(%rbp), %rdi
callq 0x3c60
movq -0x18(%rbp), %rax
cmpq $0x0, (%rax)
je 0x3c44
leaq -0x18(%rbp), %rdi
callq 0x3cc0
movq %rax, -0x20(%rbp)
movq -0x20(%rbp), %rax
cmpq $0x0, 0x10(%rax)
je 0x3bd3
movq -0x20(%rbp), %rax
movq 0x10(%rax), %rsi
leaq -0x18(%rbp), %rdi
callq 0x3c60
movq -0x20(%rbp), %rax
cmpq $0x0, 0x8(%rax)
je 0x3bef
movq -0x20(%rbp), %rax
movq 0x8(%rax), %rsi
leaq -0x18(%rbp), %rdi
callq 0x3c60
movq -0x20(%rbp), %rax
cmpq $0x0, (%rax)
je 0x3c09
movq -0x20(%rbp), %rax
movq (%rax), %rsi
leaq -0x18(%rbp), %rdi
callq 0x3c60
cmpq $0x0, -0x10(%rbp)
je 0x3c29
movq -0x20(%rbp), %rax
cmpq $0x0, 0x20(%rax)
je 0x3c29
movq -0x10(%rbp), %rax
movq -0x20(%rbp), %rcx
movq 0x20(%rcx), %rdi
callq *%rax
movq -0x20(%rbp), %rax
movq 0x20(%rax), %rdi
callq 0x1030
movq -0x20(%rbp), %rdi
callq 0x1030
jmp 0x3b9c
movq -0x18(%rbp), %rdi
callq 0x1030
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/qpfiffer[P]lair/src/map.c
// Function: dq_push
static inline void dq_push(struct destroy_queue **top, void *data) {
	struct destroy_queue *to_push = NULL;
	to_push = calloc(1, sizeof(struct destroy_queue));
	to_push->next = *top;
	to_push->data = data;
	*top = to_push;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq $0x0, -0x18(%rbp)
movl $0x1, %edi
movl $0x10, %esi
callq 0x1110
movq %rax, -0x18(%rbp)
movq -0x8(%rbp), %rax
movq (%rax), %rcx
movq -0x18(%rbp), %rax
movq %rcx, (%rax)
movq -0x10(%rbp), %rcx
movq -0x18(%rbp), %rax
movq %rcx, 0x8(%rax)
movq -0x18(%rbp), %rcx
movq -0x8(%rbp), %rax
movq %rcx, (%rax)
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/qpfiffer[P]lair/src/map.c
// Function: dq_pop
static inline void *dq_pop(struct destroy_queue **stack) {
	struct destroy_queue *top = *stack;
	*stack = top->next;
	void *data = top->data;

	free(top);
	return data;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x10(%rbp)
movq -0x10(%rbp), %rax
movq (%rax), %rcx
movq -0x8(%rbp), %rax
movq %rcx, (%rax)
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rax
movq %rax, -0x18(%rbp)
movq -0x10(%rbp), %rdi
callq 0x1030
movq -0x18(%rbp), %rax
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
nop
// File: /workspace/github_c_makefile_star2_O0/qpfiffer[P]lair/src/parse.c
// Function: friendly_enum
inline char *_friendly_enum(const LAIR_TOKEN val) {
	switch (val) {
		case LR_ERR:			return "ERR";
		case LR_FUNCTION_CALL:	return "FUNCTION_CALL";
		case LR_FUNCTION_DEF:	return "FUNCTION_DEF";
		case LR_FUNCTION_ARG:	return "FUNCTION_ARG";
		case LR_OPERATOR:		return "OP";
		case LR_RETURN:			return "RETURN";
		case LR_VARIABLE:		return "VAR";
		case LR_INDENT:			return "INDENT";
		case LR_DEDENT:			return "DEDENT";
		case LR_STRING:			return "STRING";
		case LR_ATOM:			return "ATOM";
		case LR_NUM:			return "NUM";
		case LR_CALL:			return "CALL";
		case LR_IF:				return "IF";
		case LR_BOOL:			return "BOOL";
		case LR_EOF:			return "EOF";
		default:				return "ERR";
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movl %edi, -0xc(%rbp)
movl -0xc(%rbp), %eax
movq %rax, -0x18(%rbp)
subq $0xf, %rax
ja 0x3e21
movq -0x18(%rbp), %rax
leaq 0x2941(%rip), %rcx      # 0x6674
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
leaq 0x29b5(%rip), %rax      # 0x66f8
movq %rax, -0x8(%rbp)
jmp 0x3e2c
leaq 0x29a9(%rip), %rax      # 0x66fc
movq %rax, -0x8(%rbp)
jmp 0x3e2c
leaq 0x29a7(%rip), %rax      # 0x670a
movq %rax, -0x8(%rbp)
jmp 0x3e2c
leaq 0x29a4(%rip), %rax      # 0x6717
movq %rax, -0x8(%rbp)
jmp 0x3e2c
leaq 0x29a1(%rip), %rax      # 0x6724
movq %rax, -0x8(%rbp)
jmp 0x3e2c
leaq 0x2994(%rip), %rax      # 0x6727
movq %rax, -0x8(%rbp)
jmp 0x3e2c
leaq 0x298b(%rip), %rax      # 0x672e
movq %rax, -0x8(%rbp)
jmp 0x3e2c
leaq 0x297f(%rip), %rax      # 0x6732
movq %rax, -0x8(%rbp)
jmp 0x3e2c
leaq 0x26aa(%rip), %rax      # 0x646a
movq %rax, -0x8(%rbp)
jmp 0x3e2c
leaq 0x296c(%rip), %rax      # 0x6739
movq %rax, -0x8(%rbp)
jmp 0x3e2c
leaq 0x2966(%rip), %rax      # 0x6740
movq %rax, -0x8(%rbp)
jmp 0x3e2c
leaq 0x295e(%rip), %rax      # 0x6745
movq %rax, -0x8(%rbp)
jmp 0x3e2c
leaq 0x2911(%rip), %rax      # 0x6705
movq %rax, -0x8(%rbp)
jmp 0x3e2c
leaq 0x2948(%rip), %rax      # 0x6749
movq %rax, -0x8(%rbp)
jmp 0x3e2c
leaq 0x293e(%rip), %rax      # 0x674c
movq %rax, -0x8(%rbp)
jmp 0x3e2c
leaq 0x2936(%rip), %rax      # 0x6751
movq %rax, -0x8(%rbp)
jmp 0x3e2c
leaq 0x28d0(%rip), %rax      # 0x66f8
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/qpfiffer[P]lair/src/parse.c
// Function: lair_print_tokens
void lair_print_tokens(const struct _lair_token *tokens) {
	const struct _lair_token *cur_tok = tokens;
	unsigned int last_indent_level = 0;
	while (cur_tok != NULL) {
		const char *frnd = _friendly_enum(cur_tok->token_type);
		switch (cur_tok->token_type) {
			case LR_FUNCTION_DEF:
			case LR_FUNCTION_CALL:
				printf("%s %s ", frnd, cur_tok->token_str);
				break;
			case LR_DEDENT:
				printf("\n}\n");
				break;
			case LR_INDENT: {
				char lvl[cur_tok->indent_level + 1];
				memset(lvl, ' ', cur_tok->indent_level);
				lvl[cur_tok->indent_level] = '\0';
				if (last_indent_level < cur_tok->indent_level) {
					printf("{\n%s", lvl);
				} else {
					printf("\n%s", lvl);
				}
				last_indent_level = cur_tok->indent_level;
				break;
			}
			case LR_ERR:
			default:
				printf("%s ", frnd);
		}
		cur_tok = cur_tok->next;
	}
	printf("\n---\n");
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x10(%rbp)
movl $0x0, -0x14(%rbp)
cmpq $0x0, -0x10(%rbp)
je 0x3f88
movq -0x10(%rbp), %rax
movl 0x8(%rax), %edi
callq 0x3d10
movq %rax, -0x20(%rbp)
movq -0x10(%rbp), %rax
movl 0x8(%rax), %eax
movq %rax, -0x38(%rbp)
subq $0x8, %rax
ja 0x3f65
movq -0x38(%rbp), %rax
leaq 0x281e(%rip), %rcx      # 0x66b4
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
movq -0x20(%rbp), %rsi
movq -0x10(%rbp), %rax
movq (%rax), %rdx
leaq 0x28a4(%rip), %rdi      # 0x6755
movb $0x0, %al
callq 0x1080
jmp 0x3f77
leaq 0x2898(%rip), %rdi      # 0x675c
movb $0x0, %al
callq 0x1080
jmp 0x3f77
movq -0x10(%rbp), %rax
movl 0xc(%rax), %eax
incl %eax
movq %rsp, %rcx
movq %rcx, -0x28(%rbp)
movq %rax, %rcx
addq $0xf, %rcx
andq $-0x10, %rcx
movq %rsp, %rdi
subq %rcx, %rdi
movq %rdi, -0x40(%rbp)
movq %rdi, %rsp
movq %rax, -0x30(%rbp)
movq -0x10(%rbp), %rax
movl 0xc(%rax), %eax
movl %eax, %edx
movl $0x20, %esi
callq 0x10b0
movq -0x40(%rbp), %rax
movq -0x10(%rbp), %rcx
movl 0xc(%rcx), %ecx
movb $0x0, (%rax,%rcx)
movl -0x14(%rbp), %eax
movq -0x10(%rbp), %rcx
cmpl 0xc(%rcx), %eax
jae 0x3f3e
movq -0x40(%rbp), %rsi
leaq 0x282b(%rip), %rdi      # 0x6760
movb $0x0, %al
callq 0x1080
jmp 0x3f50
movq -0x40(%rbp), %rsi
leaq 0x2818(%rip), %rdi      # 0x6761
movb $0x0, %al
callq 0x1080
movq -0x10(%rbp), %rax
movl 0xc(%rax), %eax
movl %eax, -0x14(%rbp)
movq -0x28(%rbp), %rax
movq %rax, %rsp
jmp 0x3f77
jmp 0x3f65
movq -0x20(%rbp), %rsi
leaq 0x27e8(%rip), %rdi      # 0x6758
movb $0x0, %al
callq 0x1080
movq -0x10(%rbp), %rax
movq 0x10(%rax), %rax
movq %rax, -0x10(%rbp)
jmp 0x3e5b
leaq 0x27d6(%rip), %rdi      # 0x6765
movb $0x0, %al
callq 0x1080
movq %rbp, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/qpfiffer[P]lair/src/parse.c
// Function: intuit_token_type
void _intuit_token_type(
		struct _lair_runtime *r,
		struct _lair_token *new_token,
		const char *stripped) {
	const size_t stripped_len = strlen(stripped);
	if (stripped_len == 1) {
		if (stripped[0] == ':')
			new_token->token_type = LR_RETURN;
		else if (stripped[0] == '!')
			new_token->token_type = LR_CALL;
		else if (stripped[0] == '?')
			new_token->token_type = LR_IF;
		else if (_is_operator(stripped, stripped_len))
			new_token->token_type = LR_OPERATOR;
		else if (_is_valid_string(stripped, stripped_len))
			new_token->token_type = LR_STRING;
		else if (_is_all_numbers(stripped))
			new_token->token_type = LR_NUM;
		else
			new_token->token_type = LR_ATOM;
	} else {
		if (stripped[0] == '"') {
			if (!_is_valid_string(stripped, stripped_len))
				throw_exception(r, ERR_SYNTAX, "String has no ending \".");
			else
				new_token->token_type = LR_STRING;
		} else if (_is_all_numbers(stripped))
			new_token->token_type = LR_NUM;
		else
			new_token->token_type = LR_ATOM;
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x18(%rbp), %rdi
callq 0x1060
movq %rax, -0x20(%rbp)
cmpq $0x1, -0x20(%rbp)
jne 0x408d
movq -0x18(%rbp), %rax
movsbl (%rax), %eax
cmpl $0x3a, %eax
jne 0x3fe8
movq -0x10(%rbp), %rax
movl $0x4, 0x8(%rax)
jmp 0x408b
movq -0x18(%rbp), %rax
movsbl (%rax), %eax
cmpl $0x21, %eax
jne 0x4004
movq -0x10(%rbp), %rax
movl $0xb, 0x8(%rax)
jmp 0x4089
movq -0x18(%rbp), %rax
movsbl (%rax), %eax
cmpl $0x3f, %eax
jne 0x401d
movq -0x10(%rbp), %rax
movl $0xc, 0x8(%rax)
jmp 0x4087
movq -0x18(%rbp), %rdi
movq -0x20(%rbp), %rsi
callq 0x4100
cmpl $0x0, %eax
je 0x403c
movq -0x10(%rbp), %rax
movl $0x3, 0x8(%rax)
jmp 0x4085
movq -0x18(%rbp), %rdi
movq -0x20(%rbp), %rsi
callq 0x4170
cmpl $0x0, %eax
je 0x405b
movq -0x10(%rbp), %rax
movl $0xa, 0x8(%rax)
jmp 0x4083
movq -0x18(%rbp), %rdi
callq 0x41c0
cmpl $0x0, %eax
je 0x4076
movq -0x10(%rbp), %rax
movl $0xf, 0x8(%rax)
jmp 0x4081
movq -0x10(%rbp), %rax
movl $0xe, 0x8(%rax)
jmp 0x4083
jmp 0x4085
jmp 0x4087
jmp 0x4089
jmp 0x408b
jmp 0x40f9
movq -0x18(%rbp), %rax
movsbl (%rax), %eax
cmpl $0x22, %eax
jne 0x40cf
movq -0x18(%rbp), %rdi
movq -0x20(%rbp), %rsi
callq 0x4170
cmpl $0x0, %eax
jne 0x40c2
movq -0x8(%rbp), %rdi
movl $0x1, %esi
leaq 0x26b0(%rip), %rdx      # 0x676b
callq 0x1870
jmp 0x40cd
movq -0x10(%rbp), %rax
movl $0xa, 0x8(%rax)
jmp 0x40f7
movq -0x18(%rbp), %rdi
callq 0x41c0
cmpl $0x0, %eax
je 0x40ea
movq -0x10(%rbp), %rax
movl $0xf, 0x8(%rax)
jmp 0x40f5
movq -0x10(%rbp), %rax
movl $0xe, 0x8(%rax)
jmp 0x40f7
jmp 0x40f9
addq $0x20, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/qpfiffer[P]lair/src/parse.c
// Function: is_operator
static int _is_operator(const char *stripped, const size_t stripped_len) {
	if (stripped_len != 0)
		return 0;

	switch (stripped[0]) {
		case '+':
		case '-':
		case '=':
		case '%':
		case '?':
			return 1;
		default:
			return 0;
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
cmpq $0x0, -0x18(%rbp)
je 0x411c
movl $0x0, -0x4(%rbp)
jmp 0x4165
movq -0x10(%rbp), %rax
movsbl (%rax), %eax
movl %eax, -0x1c(%rbp)
subl $0x25, %eax
je 0x4155
jmp 0x412d
movl -0x1c(%rbp), %eax
subl $0x2b, %eax
je 0x4155
jmp 0x4137
movl -0x1c(%rbp), %eax
subl $0x2d, %eax
je 0x4155
jmp 0x4141
movl -0x1c(%rbp), %eax
subl $0x3d, %eax
je 0x4155
jmp 0x414b
movl -0x1c(%rbp), %eax
subl $0x3f, %eax
jne 0x415e
jmp 0x4155
movl $0x1, -0x4(%rbp)
jmp 0x4165
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/qpfiffer[P]lair/src/parse.c
// Function: is_all_numbers
static inline int _is_all_numbers(const char *token) {
	unsigned int i = 0;
	for (; i < strlen(token); i++) {
		/* ASCII numerical values are between 0x30 and 0x39. */
		if ((int)token[i] < 0x30 || (int)token[i] > 0x39)
			return 0;
	}
	return 1;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movl $0x0, -0x14(%rbp)
movl -0x14(%rbp), %eax
movq %rax, -0x20(%rbp)
movq -0x10(%rbp), %rdi
callq 0x1060
movq %rax, %rcx
movq -0x20(%rbp), %rax
cmpq %rcx, %rax
jae 0x4225
movq -0x10(%rbp), %rax
movl -0x14(%rbp), %ecx
movsbl (%rax,%rcx), %eax
cmpl $0x30, %eax
jl 0x420f
movq -0x10(%rbp), %rax
movl -0x14(%rbp), %ecx
movsbl (%rax,%rcx), %eax
cmpl $0x39, %eax
jle 0x4218
movl $0x0, -0x4(%rbp)
jmp 0x422c
jmp 0x421a
movl -0x14(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x14(%rbp)
jmp 0x41d3
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/qpfiffer[P]lair/src/parse.c
// Function: read_line
static struct _str read_line(const char *buf) {
	char c = '\0';

	size_t num_read = 0;
	while (1) {
		c = buf[num_read];
		num_read++;
		if (c == '\0' || c == '\n' || c == '\r')
			break;
	}

	char *data = calloc(1, num_read + 1);
	strncpy(data, buf, num_read);

	struct _str to_return = {
		.size = num_read,
		.data = data
	};

	return to_return;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x18(%rbp)
movb $0x0, -0x19(%rbp)
movq $0x0, -0x28(%rbp)
movq -0x18(%rbp), %rax
movq -0x28(%rbp), %rcx
movb (%rax,%rcx), %al
movb %al, -0x19(%rbp)
movq -0x28(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x28(%rbp)
movsbl -0x19(%rbp), %eax
cmpl $0x0, %eax
je 0x48fd
movsbl -0x19(%rbp), %eax
cmpl $0xa, %eax
je 0x48fd
movsbl -0x19(%rbp), %eax
cmpl $0xd, %eax
jne 0x48ff
jmp 0x4901
jmp 0x48c8
movq -0x28(%rbp), %rsi
incq %rsi
movl $0x1, %edi
callq 0x1110
movq %rax, -0x30(%rbp)
movq -0x30(%rbp), %rdi
movq -0x18(%rbp), %rsi
movq -0x28(%rbp), %rdx
callq 0x1040
movq -0x28(%rbp), %rax
movq %rax, -0x10(%rbp)
movq -0x30(%rbp), %rax
movq %rax, -0x8(%rbp)
movq -0x10(%rbp), %rax
movq -0x8(%rbp), %rdx
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/qpfiffer[P]lair/src/parse.c
// Function: is_newline
static inline int _is_newline(const char *token) {
	if (strncmp(token, "\n", strlen("\n")) == 0 ||
		strncmp(token, "\r", strlen("\r")) == 0)
		return 1;
	return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x10(%rbp)
movq -0x10(%rbp), %rdi
leaq 0x1e02(%rip), %rsi      # 0x6769
movl $0x1, %edx
callq 0x1050
cmpl $0x0, %eax
je 0x4990
movq -0x10(%rbp), %rdi
leaq 0x1e72(%rip), %rsi      # 0x67f3
movl $0x1, %edx
callq 0x1050
cmpl $0x0, %eax
jne 0x4999
movl $0x1, -0x4(%rbp)
jmp 0x49a0
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x10, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/qpfiffer[P]lair/src/parse.c
// Function: insert_token
static void _insert_token(struct _lair_token **head, struct _lair_token *to_insert) {
	if (*head == NULL) {
		*head = to_insert;
		return;
	}

	struct _lair_token *current = *head;
	while (current->next != NULL) {
		current = current->next;
	}
	current->next = to_insert;
	to_insert->prev = current;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rax
cmpq $0x0, (%rax)
jne 0x49d3
movq -0x10(%rbp), %rcx
movq -0x8(%rbp), %rax
movq %rcx, (%rax)
jmp 0x4a0f
movq -0x8(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rax
cmpq $0x0, 0x10(%rax)
je 0x49f7
movq -0x18(%rbp), %rax
movq 0x10(%rax), %rax
movq %rax, -0x18(%rbp)
jmp 0x49de
movq -0x10(%rbp), %rcx
movq -0x18(%rbp), %rax
movq %rcx, 0x10(%rax)
movq -0x18(%rbp), %rcx
movq -0x10(%rbp), %rax
movq %rcx, 0x18(%rax)
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/qpfiffer[P]lair/src/parse.c
// Function: strip
static inline void _strip(const char *from, char *to) {
	unsigned int i = 0, j = 0;
	for (;i < strlen(from);) {
		while (from[i] == '\n' || from[i] == '\r')
			i++;
		if (i >= strlen(from))
			break;
		to[j] = from[i];
		j++;
		i++;
	}
	to[++j] = '\0';
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl $0x0, -0x14(%rbp)
movl $0x0, -0x18(%rbp)
movl -0x14(%rbp), %eax
movq %rax, -0x20(%rbp)
movq -0x8(%rbp), %rdi
callq 0x1060
movq %rax, %rcx
movq -0x20(%rbp), %rax
cmpq %rcx, %rax
jae 0x4ae6
jmp 0x4a60
movq -0x8(%rbp), %rax
movl -0x14(%rbp), %ecx
movsbl (%rax,%rcx), %ecx
movb $0x1, %al
cmpl $0xa, %ecx
movb %al, -0x21(%rbp)
je 0x4a89
movq -0x8(%rbp), %rax
movl -0x14(%rbp), %ecx
movsbl (%rax,%rcx), %eax
cmpl $0xd, %eax
sete %al
movb %al, -0x21(%rbp)
movb -0x21(%rbp), %al
testb $0x1, %al
jne 0x4a92
jmp 0x4a9d
movl -0x14(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x14(%rbp)
jmp 0x4a60
movl -0x14(%rbp), %eax
movq %rax, -0x30(%rbp)
movq -0x8(%rbp), %rdi
callq 0x1060
movq %rax, %rcx
movq -0x30(%rbp), %rax
cmpq %rcx, %rax
jb 0x4abb
jmp 0x4ae6
movq -0x8(%rbp), %rax
movl -0x14(%rbp), %ecx
movb (%rax,%rcx), %dl
movq -0x10(%rbp), %rax
movl -0x18(%rbp), %ecx
movb %dl, (%rax,%rcx)
movl -0x18(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x18(%rbp)
movl -0x14(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x14(%rbp)
jmp 0x4a3e
movq -0x10(%rbp), %rax
movl -0x18(%rbp), %ecx
addl $0x1, %ecx
movl %ecx, -0x18(%rbp)
movl %ecx, %ecx
movb $0x0, (%rax,%rcx)
addq $0x30, %rsp
popq %rbp
retq
nop