LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O1/Ihsoh[P]ilang/map.c
// Function: key_comparer
static bool _key_comparer(void *node_data, void *data) {
	assert(node_data);
	assert(data);

	MapEntry *entry = (MapEntry *) node_data;
	Map *map = entry->map;
	return map->key_comparer(entry->key, data);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
testq %rdi, %rdi
je 0xc736
testq %rsi, %rsi
je 0xc755
movq (%rdi), %rax
movq 0x8(%rdi), %rdi
movq 0x28(%rax), %rax
popq %rbp
jmpq *%rax
leaq 0x229e6(%rip), %rdi     # 0x2f123
leaq 0x22627(%rip), %rsi     # 0x2ed6b
leaq 0x229e2(%rip), %rcx     # 0x2f12d
movl $0x5a, %edx
callq 0xa0b0
leaq 0x2ae98(%rip), %rdi     # 0x375f4
leaq 0x22608(%rip), %rsi     # 0x2ed6b
leaq 0x229c3(%rip), %rcx     # 0x2f12d
movl $0x5b, %edx
callq 0xa0b0
// File: /workspace/github_c_makefile_star2_O1/Ihsoh[P]ilang/map.c
// Function: map_get_entry
MapEntry * map_get_entry(
	Map *map,
	void *key
) {
	assert(map);
	assert(key);

	LinkedListNode *node = _get_node(map, key);
	if (node != NULL) {
		return (MapEntry *) node->data;
	} else {
		return NULL;
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
testq %rdi, %rdi
je 0xc7a0
movq %rsi, %rdx
testq %rsi, %rsi
je 0xc7bf
leaq -0x72(%rip), %rsi       # 0xc71a
callq 0xc00a
testq %rax, %rax
je 0xc79c
movq 0x8(%rax), %rax
jmp 0xc79e
xorl %eax, %eax
popq %rbp
retq
leaq 0x22966(%rip), %rdi     # 0x2f10d
leaq 0x225bd(%rip), %rsi     # 0x2ed6b
leaq 0x22634(%rip), %rcx     # 0x2ede9
movl $0x91, %edx
callq 0xa0b0
leaq 0x2261f(%rip), %rdi     # 0x2ede5
leaq 0x2259e(%rip), %rsi     # 0x2ed6b
leaq 0x22615(%rip), %rcx     # 0x2ede9
movl $0x92, %edx
callq 0xa0b0
// File: /workspace/github_c_makefile_star2_O1/Ihsoh[P]ilang/map.c
// Function: map_get
void * map_get(
	Map *map,
	void *key
) {
	assert(map);
	assert(key);

	MapEntry *entry = map_get_entry(map, key);
	if (entry != NULL) {
		return entry->value;
	} else {
		return NULL;
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
testq %rdi, %rdi
je 0xc817
movq %rsi, %rdx
testq %rsi, %rsi
je 0xc836
leaq -0xdc(%rip), %rsi       # 0xc71a
callq 0xc00a
testq %rax, %rax
je 0xc806
movq 0x8(%rax), %rax
jmp 0xc808
xorl %eax, %eax
testq %rax, %rax
je 0xc813
movq 0x10(%rax), %rax
jmp 0xc815
xorl %eax, %eax
popq %rbp
retq
leaq 0x228ef(%rip), %rdi     # 0x2f10d
leaq 0x22546(%rip), %rsi     # 0x2ed6b
leaq 0x225e4(%rip), %rcx     # 0x2ee10
movl $0xa0, %edx
callq 0xa0b0
leaq 0x225a8(%rip), %rdi     # 0x2ede5
leaq 0x22527(%rip), %rsi     # 0x2ed6b
leaq 0x225c5(%rip), %rcx     # 0x2ee10
movl $0xa1, %edx
callq 0xa0b0
// File: /workspace/github_c_makefile_star2_O1/Ihsoh[P]ilang/map.c
// Function: map_remove
bool map_remove(
	Map *map,
	void *key,
	bool free_key,
	bool free_value
) {
	assert(map);
	assert(key);

	LinkedListNode *node = _get_node(map, key);
	if (node != NULL) {
		MapEntry *entry = (MapEntry *) node->data;
		if (free_key
				&& entry->key != NULL) {
			map->key_releaser(entry->key);
		}
		if (free_value
				&& entry->value != NULL) {
			map->value_releaser(entry->value);
		}
		llst_delete(&(map->llst), node, true);
		return true;
	} else {
		return false;
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
testq %rdi, %rdi
je 0xc8dc
movl %edx, %r12d
movq %rsi, %rdx
testq %rsi, %rsi
je 0xc8fb
movl %ecx, %r15d
movq %rdi, %rbx
leaq -0x16a(%rip), %rsi      # 0xc71a
callq 0xc00a
movq %rax, %r14
testq %rax, %rax
je 0xc8c7
movq 0x8(%r14), %r13
testb %r12b, %r12b
je 0xc8a6
movq 0x8(%r13), %rdi
testq %rdi, %rdi
je 0xc8a6
callq *0x38(%rbx)
testb %r15b, %r15b
je 0xc8b7
movq 0x10(%r13), %rdi
testq %rdi, %rdi
je 0xc8b7
callq *0x40(%rbx)
movq %rbx, %rdi
movq %r14, %rsi
movl $0x1, %edx
callq 0xbf83
testq %r14, %r14
setne %al
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
leaq 0x2282a(%rip), %rdi     # 0x2f10d
leaq 0x22481(%rip), %rsi     # 0x2ed6b
leaq 0x2253c(%rip), %rcx     # 0x2ee2d
movl $0xb1, %edx
callq 0xa0b0
leaq 0x224e3(%rip), %rdi     # 0x2ede5
leaq 0x22462(%rip), %rsi     # 0x2ed6b
leaq 0x2251d(%rip), %rcx     # 0x2ee2d
movl $0xb2, %edx
callq 0xa0b0
// File: /workspace/github_c_makefile_star2_O1/Ihsoh[P]ilang/map.c
// Function: map_exists_key
bool map_exists_key(
	Map *map,
	void *key
) {
	assert(map);
	assert(key);

	MapEntry *entry = map_get_entry(map, key);

	return entry != NULL;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
testq %rdi, %rdi
je 0xc94a
movq %rsi, %rdx
testq %rsi, %rsi
je 0xc969
leaq -0x218(%rip), %rsi      # 0xc71a
callq 0xc00a
testq %rax, %rax
je 0xc946
cmpq $0x0, 0x8(%rax)
setne %al
jmp 0xc948
xorl %eax, %eax
popq %rbp
retq
leaq 0x227bc(%rip), %rdi     # 0x2f10d
leaq 0x22413(%rip), %rsi     # 0x2ed6b
leaq 0x224fc(%rip), %rcx     # 0x2ee5b
movl $0xca, %edx
callq 0xa0b0
leaq 0x22475(%rip), %rdi     # 0x2ede5
leaq 0x223f4(%rip), %rsi     # 0x2ed6b
leaq 0x224dd(%rip), %rcx     # 0x2ee5b
movl $0xcb, %edx
callq 0xa0b0
// File: /workspace/github_c_makefile_star2_O1/Ihsoh[P]ilang/map.c
// Function: map_iter_next
MapEntry * map_iter_next(
	Map *map,
	MapEntryIterator *iter
) {
	assert(map);
	assert(iter);

	if (iter->node == NULL) {
		return NULL;
	}

	LinkedListNode *current = iter->node;
	iter->node = current->next;

	return (MapEntry *)current->data;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
testq %rdi, %rdi
je 0xca03
testq %rsi, %rsi
je 0xca22
movq (%rsi), %rax
testq %rax, %rax
je 0xc9ff
movq 0x18(%rax), %rcx
movq %rcx, (%rsi)
movq 0x8(%rax), %rax
jmp 0xca01
xorl %eax, %eax
popq %rbp
retq
leaq 0x22703(%rip), %rdi     # 0x2f10d
leaq 0x2235a(%rip), %rsi     # 0x2ed6b
leaq 0x22495(%rip), %rcx     # 0x2eead
movl $0xe3, %edx
callq 0xa0b0
leaq 0x24400(%rip), %rdi     # 0x30e29
leaq 0x2233b(%rip), %rsi     # 0x2ed6b
leaq 0x22476(%rip), %rcx     # 0x2eead
movl $0xe4, %edx
callq 0xa0b0
// File: /workspace/github_c_makefile_star2_O1/Ihsoh[P]ilang/myassert.c
// Function: myerror
void myerror(const char *file, int line, const char *fmt, ...) {
	char buffer[4096];

	va_list args;
	va_start(args, fmt);
	vsnprintf(buffer, sizeof(buffer), fmt, args);
	va_end(args);

	fprintf(stderr, "ASSERT FAILED(%s:%d): %s\n", file, line, buffer);

	exit(0);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
subq $0x10c8, %rsp           # imm = 0x10C8
movl %esi, %ebx
movq %rdi, %r14
leaq -0xe0(%rbp), %rsi
movq %rcx, 0x18(%rsi)
movq %r8, 0x20(%rsi)
movq %r9, 0x28(%rsi)
testb %al, %al
je 0xd0e1
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)
leaq -0x30(%rbp), %rcx
movq %rsi, 0x10(%rcx)
leaq 0x10(%rbp), %rax
movq %rax, 0x8(%rcx)
movabsq $0x3000000018, %rax     # imm = 0x3000000018
movq %rax, (%rcx)
leaq -0x10e0(%rbp), %r15
movl $0x1000, %esi           # imm = 0x1000
movq %r15, %rdi
callq 0xa060
movq 0x32edf(%rip), %rax     # 0x3fff8
movq (%rax), %rdi
leaq 0x2202e(%rip), %rsi     # 0x2f151
movq %r14, %rdx
movl %ebx, %ecx
movq %r15, %r8
xorl %eax, %eax
callq 0xa0f0
xorl %edi, %edi
callq 0xa160
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O1/Ihsoh[P]ilang/parser.c
// Function: parser_new_context_with_data
ParserContext * parser_new_context_with_data(
	LexerContext *lexctx,
	size_t szdata,
	void *data
) {
	assert(lexctx);
	if (szdata > 0) {
		assert(data != NULL);
	} else {
		assert(data == NULL);
	}

	ParserContext *ctx = (ParserContext *)malloc(sizeof(ParserContext) + szdata);
	if (ctx == NULL) {
		return NULL;
	}
	memcpy(&(ctx->data[0]), data, szdata);

	ctx->lexctx = lexctx;
	
	ctx->ast = NULL;

	ctx->nodes = NULL;

	ctx->previous_node = NULL;
	ctx->last_node = NULL;

	ctx->current_token = NULL;

	ctx->arch = 0;

	ctx->alloc_mem_error = _default_alloc_mem_error;
	ctx->syntax_error = _default_syntax_error;
	ctx->syntax_error_msg = _default_syntax_error_msg;
	ctx->syntax_error_token_msg = _default_syntax_error_token_msg;
	ctx->syntax_error_node_msg = _default_syntax_error_node_msg;

	return ctx;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
testq %rdi, %rdi
je 0xd20b
movq %rdx, %r12
movq %rsi, %r15
movq %rdi, %rbx
testq %rsi, %rsi
je 0xd182
testq %r12, %r12
jne 0xd18b
leaq 0x2204d(%rip), %rdi     # 0x2f1b7
leaq 0x28366(%rip), %rsi     # 0x354d7
leaq 0x21ff3(%rip), %rcx     # 0x2f16b
movl $0x92, %edx
callq 0xa0b0
testq %r12, %r12
jne 0xd22a
leaq 0x68(%r15), %rdi
callq 0xa120
testq %rax, %rax
je 0xd1fc
movq %rax, %r14
movq %rax, %rdi
addq $0x68, %rdi
movq %r12, %rsi
movq %r15, %rdx
callq 0xa110
movq %rbx, (%r14)
xorps %xmm0, %xmm0
movups %xmm0, 0x8(%r14)
movups %xmm0, 0x18(%r14)
movups %xmm0, 0x24(%r14)
leaq 0x7f(%rip), %rax        # 0xd249
movq %rax, 0x38(%r14)
leaq 0xef(%rip), %rax        # 0xd2c4
movq %rax, 0x40(%r14)
leaq 0x177(%rip), %rax       # 0xd357
movq %rax, 0x48(%r14)
leaq 0x1dd(%rip), %rax       # 0xd3c8
movq %rax, 0x50(%r14)
leaq 0x2af(%rip), %rax       # 0xd4a5
movq %rax, 0x58(%r14)
jmp 0xd1ff
xorl %r14d, %r14d
movq %r14, %rax
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
leaq 0x2878d(%rip), %rdi     # 0x3599f
leaq 0x282be(%rip), %rsi     # 0x354d7
leaq 0x21f4b(%rip), %rcx     # 0x2f16b
movl $0x90, %edx
callq 0xa0b0
leaq 0x21f93(%rip), %rdi     # 0x2f1c4
leaq 0x2829f(%rip), %rsi     # 0x354d7
leaq 0x21f2c(%rip), %rcx     # 0x2f16b
movl $0x94, %edx
callq 0xa0b0
// File: /workspace/github_c_makefile_star2_O1/Ihsoh[P]ilang/parser.c
// Function: default_alloc_mem_error
static void _default_alloc_mem_error(ParserContext *ctx) {
	assert(ctx);

	if (ctx->current_token != NULL) {
		LexerToken *token = ctx->current_token;
		fprintf(
			stderr,
			"Parser Error(%s:%d,%d): cannot allocate memory!\n",
			token->file,
			token->line,
			token->column
		);
	} else {
		fprintf(
			stderr,
			"Parser Error: cannot allocate memory!\n"
		);
	}

	exit(1);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
testq %rdi, %rdi
jne 0xd271
leaq 0x294fd(%rip), %rdi     # 0x36756
leaq 0x28277(%rip), %rsi     # 0x354d7
leaq 0x22476(%rip), %rcx     # 0x2f6dd
movl $0x14, %edx
callq 0xa0b0
movq 0x28(%rdi), %rsi
movq 0x32d7c(%rip), %rax     # 0x3fff8
movq (%rax), %rcx
testq %rsi, %rsi
jne 0xd29c
leaq 0x224b2(%rip), %rdi     # 0x2f73d
movl $0x26, %esi
movl $0x1, %edx
callq 0xa170
jmp 0xd2ba
movq 0x10(%rsi), %rdx
movl 0x18(%rsi), %eax
movl 0x1c(%rsi), %r8d
leaq 0x2245e(%rip), %rsi     # 0x2f70c
movq %rcx, %rdi
movl %eax, %ecx
xorl %eax, %eax
callq 0xa0f0
movl $0x1, %edi
callq 0xa160
// File: /workspace/github_c_makefile_star2_O1/Ihsoh[P]ilang/parser.c
// Function: default_syntax_error
static void _default_syntax_error(ParserContext *ctx) {
	assert(ctx);

	if (ctx->current_token != NULL) {
		LexerToken *token = ctx->current_token;
		fprintf(
			stderr,
			"Parser Error(%s:%d,%d): syntax error!\n",
			token->file,
			token->line,
			token->column
		);
		cmn_print_code_by_token(stderr, token, 20, 20);
	} else {
		fprintf(
			stderr,
			"Parser Error: syntax error!\n"
		);
	}

	exit(1);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
testq %rdi, %rdi
jne 0xd2ef
leaq 0x2947f(%rip), %rdi     # 0x36756
leaq 0x281f9(%rip), %rsi     # 0x354d7
leaq 0x2247f(%rip), %rcx     # 0x2f764
movl $0x2a, %edx
callq 0xa0b0
movq 0x28(%rdi), %rbx
movq 0x32cfe(%rip), %r14     # 0x3fff8
movq (%r14), %rcx
testq %rbx, %rbx
jne 0xd31a
leaq 0x224ae(%rip), %rdi     # 0x2f7b7
movl $0x1c, %esi
movl $0x1, %edx
callq 0xa170
jmp 0xd34d
movq 0x10(%rbx), %rdx
movl 0x18(%rbx), %eax
movl 0x1c(%rbx), %r8d
leaq 0x22464(%rip), %rsi     # 0x2f790
movq %rcx, %rdi
movl %eax, %ecx
xorl %eax, %eax
callq 0xa0f0
movq (%r14), %rdi
movq %rbx, %rsi
movl $0x14, %edx
movl $0x14, %ecx
callq 0xac19
movl $0x1, %edi
callq 0xa160
// File: /workspace/github_c_makefile_star2_O1/Ihsoh[P]ilang/parser.c
// Function: default_syntax_error_msg
static void _default_syntax_error_msg(
	ParserContext *ctx,
	const char *msg
) {
	assert(ctx);
	assert(msg);

	fprintf(
		stderr,
		"Parser Error: syntax error, %s\n",
		msg
	);

	exit(1);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
testq %rdi, %rdi
jne 0xd37f
leaq 0x293ef(%rip), %rdi     # 0x36756
leaq 0x28169(%rip), %rsi     # 0x354d7
leaq 0x2245f(%rip), %rcx     # 0x2f7d4
movl $0x44, %edx
callq 0xa0b0
movq %rsi, %rdx
testq %rsi, %rsi
jne 0xd3a6
leaq 0x22484(%rip), %rdi     # 0x2f812
leaq 0x28142(%rip), %rsi     # 0x354d7
leaq 0x22438(%rip), %rcx     # 0x2f7d4
movl $0x45, %edx
callq 0xa0b0
movq 0x32c4b(%rip), %rax     # 0x3fff8
movq (%rax), %rdi
leaq 0x2245f(%rip), %rsi     # 0x2f816
xorl %eax, %eax
callq 0xa0f0
movl $0x1, %edi
callq 0xa160
// File: /workspace/github_c_makefile_star2_O1/Ihsoh[P]ilang/parser.c
// Function: default_syntax_error_token_msg
static void _default_syntax_error_token_msg(
	ParserContext *ctx,
	LexerToken *token,
	const char *msg
) {
	assert(ctx);
	assert(token);
	assert(msg);

	fprintf(
		stderr,
		"Parser Error(%s:%d:%d): syntax error, token '",
		token->file,
		token->line,
		token->column
	);
	cmn_print_token(token, stderr);
	fprintf(
		stderr,
		"', %s\n",
		msg
	);

	cmn_print_code_by_token(stderr, token, 20, 20);

	exit(1);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
testq %rdi, %rdi
jne 0xd3f6
leaq 0x29378(%rip), %rdi     # 0x36756
leaq 0x280f2(%rip), %rsi     # 0x354d7
leaq 0x2244a(%rip), %rcx     # 0x2f836
movl $0x55, %edx
callq 0xa0b0
movq %rsi, %rbx
testq %rsi, %rsi
jne 0xd41d
leaq 0x210c5(%rip), %rdi     # 0x2e4ca
leaq 0x280cb(%rip), %rsi     # 0x354d7
leaq 0x22423(%rip), %rcx     # 0x2f836
movl $0x56, %edx
callq 0xa0b0
movq %rdx, %r14
testq %rdx, %rdx
jne 0xd444
leaq 0x223e6(%rip), %rdi     # 0x2f812
leaq 0x280a4(%rip), %rsi     # 0x354d7
leaq 0x223fc(%rip), %rcx     # 0x2f836
movl $0x57, %edx
callq 0xa0b0
movq 0x32bad(%rip), %r15     # 0x3fff8
movq (%r15), %rdi
movq 0x10(%rbx), %rdx
movl 0x18(%rbx), %ecx
movl 0x1c(%rbx), %r8d
leaq 0x22428(%rip), %rsi     # 0x2f888
xorl %eax, %eax
callq 0xa0f0
movq (%r15), %rsi
movq %rbx, %rdi
callq 0xabd8
movq (%r15), %rdi
leaq 0x2243a(%rip), %rsi     # 0x2f8b6
movq %r14, %rdx
xorl %eax, %eax
callq 0xa0f0
movq (%r15), %rdi
movq %rbx, %rsi
movl $0x14, %edx
movl $0x14, %ecx
callq 0xac19
movl $0x1, %edi
callq 0xa160
// File: /workspace/github_c_makefile_star2_O1/Ihsoh[P]ilang/parser.c
// Function: default_syntax_error_node_msg
static void _default_syntax_error_node_msg(
	ParserContext *ctx,
	ParserASTNode *node,
	const char *msg
) {
	assert(ctx);
	assert(msg);

	if (node->file != NULL) {
		fprintf(
			stderr,
			"Parser Error(%s:%d,%d): syntax error, %s\n",
			node->file,
			node->line,
			node->column,
			msg
		);
	} else {
		fprintf(
			stderr,
			"Parser Error: syntax error, %s\n",
			msg
		);
	}

	exit(1);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
testq %rdi, %rdi
jne 0xd4cd
leaq 0x292a1(%rip), %rdi     # 0x36756
leaq 0x2801b(%rip), %rsi     # 0x354d7
leaq 0x223fa(%rip), %rcx     # 0x2f8bd
movl $0x71, %edx
callq 0xa0b0
movq %rdx, %r9
testq %rdx, %rdx
jne 0xd4f4
leaq 0x22336(%rip), %rdi     # 0x2f812
leaq 0x27ff4(%rip), %rsi     # 0x354d7
leaq 0x223d3(%rip), %rcx     # 0x2f8bd
movl $0x72, %edx
callq 0xa0b0
movq 0x18(%rsi), %rdx
movq 0x32af9(%rip), %rax     # 0x3fff8
movq (%rax), %rdi
testq %rdx, %rdx
jne 0xd51a
leaq 0x22308(%rip), %rsi     # 0x2f816
movq %r9, %rdx
xorl %eax, %eax
callq 0xa0f0
jmp 0xd52f
movl 0x20(%rsi), %ecx
movl 0x24(%rsi), %r8d
leaq 0x223e9(%rip), %rsi     # 0x2f911
xorl %eax, %eax
callq 0xa0f0
movl $0x1, %edi
callq 0xa160
// File: /workspace/github_c_makefile_star2_O1/Ihsoh[P]ilang/parser.c
// Function: parser_free_context
void parser_free_context(
	ParserContext *ctx
) {
	assert(ctx);

	ParserASTNode *node = ctx->nodes;
	while (node != NULL) {
		ParserASTNode *temp = node;
		node = node->next;
		parser_free_node(ctx, temp);
	}

	free(ctx);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
testq %rdi, %rdi
je 0xd57f
movq %rdi, %rbx
movq 0x10(%rdi), %rsi
testq %rsi, %rsi
je 0xd573
movq 0x28(%rsi), %r14
movq %rbx, %rdi
callq 0xd59e
movq %r14, %rsi
testq %r14, %r14
jne 0xd55f
movq %rbx, %rdi
popq %rbx
popq %r14
popq %rbp
jmp 0xa190
leaq 0x291d0(%rip), %rdi     # 0x36756
leaq 0x27f4a(%rip), %rsi     # 0x354d7
leaq 0x21c3d(%rip), %rcx     # 0x2f1d1
movl $0xbc, %edx
callq 0xa0b0
// File: /workspace/github_c_makefile_star2_O1/Ihsoh[P]ilang/parser.c
// Function: parser_free_node
void parser_free_node(
	ParserContext *ctx,
	ParserASTNode *node
) {
	assert(ctx);
	assert(node);

	if (node->releaser != NULL) {
		node->releaser(node);
	}

	if (node->childs != NULL) {
		free(node->childs);
	}

	ParserSymbol *symbol = node->symtbl;
	while (symbol != NULL) {
		ParserSymbol *temp = symbol;
		symbol = symbol->next;
		parser_free_symbol(ctx, temp);
	}

	free(node);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
testq %rdi, %rdi
je 0xd603
movq %rsi, %rbx
testq %rsi, %rsi
je 0xd622
movq %rdi, %r14
movq 0x50(%rbx), %rax
testq %rax, %rax
je 0xd5c6
movq %rbx, %rdi
callq *%rax
movq 0x48(%rbx), %rdi
testq %rdi, %rdi
je 0xd5d4
callq 0xa190
movq 0x38(%rbx), %rsi
testq %rsi, %rsi
je 0xd5f1
movq 0x10(%rsi), %r15
movq %r14, %rdi
callq 0xd79e
movq %r15, %rsi
testq %r15, %r15
jne 0xd5dd
movq %rbx, %rdi
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
jmp 0xa190
leaq 0x2914c(%rip), %rdi     # 0x36756
leaq 0x27ec6(%rip), %rsi     # 0x354d7
leaq 0x21c3e(%rip), %rcx     # 0x2f256
movl $0x107, %edx            # imm = 0x107
callq 0xa0b0
leaq 0x256d2(%rip), %rdi     # 0x32cfb
leaq 0x27ea7(%rip), %rsi     # 0x354d7
leaq 0x21c1f(%rip), %rcx     # 0x2f256
movl $0x108, %edx            # imm = 0x108
callq 0xa0b0
// File: /workspace/github_c_makefile_star2_O1/Ihsoh[P]ilang/parser.c
// Function: parser_new_node
ParserASTNode * parser_new_node(
	ParserContext *ctx,
	int type,
	char *type_name,
	LexerToken *token,
	size_t szdata,
	void *data
) {
	assert(ctx);
	if (szdata > 0) {
		assert(data != NULL);
	} else {
		assert(data == NULL);
	}

	ParserASTNode *node = (ParserASTNode *)malloc(sizeof(ParserASTNode) + szdata);
	if (node == NULL) {
		ctx->alloc_mem_error(ctx);
	}
	memcpy(&(node->data[0]), data, szdata);

	node->type = type;
	node->type_name = type_name;

	node->token = token;

	if (token != NULL) {
		node->file = token->file;
		node->line = token->line;
		node->column = token->column;
	} else {
		LexerToken *current_token = ctx->current_token;
		if (current_token != NULL) {
			node->file = current_token->file;
			node->line = current_token->line;
			node->column = current_token->column;
		} else {
			node->file = NULL;
			node->line = -1;
			node->column = -1;
		}
	}

	node->next = ctx->nodes;
	node->parent = NULL;

	ctx->nodes = node;

	node->symtbl = NULL;

	node->szchilds = 0;
	node->nchilds = 0;
	node->childs = NULL;

	node->releaser = NULL;

	return node;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
testq %rdi, %rdi
je 0xd760
movq %r9, %r13
movq %r8, %r12
movq %rcx, %r15
movq %rdi, %rbx
testq %r8, %r8
movq %rdx, -0x38(%rbp)
movl %esi, -0x2c(%rbp)
je 0xd697
testq %r13, %r13
jne 0xd6a0
leaq 0x21b38(%rip), %rdi     # 0x2f1b7
leaq 0x27e51(%rip), %rsi     # 0x354d7
leaq 0x21b6e(%rip), %rcx     # 0x2f1fb
movl $0xd2, %edx
callq 0xa0b0
testq %r13, %r13
jne 0xd77f
leaq 0x60(%r12), %rdi
callq 0xa120
movq %rax, %r14
testq %rax, %rax
jne 0xd6b8
movq %rbx, %rdi
callq *0x38(%rbx)
movq %r14, %rdi
addq $0x60, %rdi
movq %r13, %rsi
movq %r12, %rdx
callq 0xa110
movl -0x2c(%rbp), %eax
movl %eax, (%r14)
movq -0x38(%rbp), %rax
movq %rax, 0x8(%r14)
movq %r15, 0x10(%r14)
testq %r15, %r15
je 0xd6f7
movq 0x10(%r15), %rax
movq %rax, 0x18(%r14)
movl 0x18(%r15), %eax
movl %eax, 0x20(%r14)
movl 0x1c(%r15), %eax
jmp 0xd729
movq 0x28(%rbx), %rax
testq %rax, %rax
je 0xd714
movq 0x10(%rax), %rcx
movq %rcx, 0x18(%r14)
movl 0x18(%rax), %ecx
movl %ecx, 0x20(%r14)
movl 0x1c(%rax), %eax
jmp 0xd729
movq $0x0, 0x18(%r14)
movl $0xffffffff, 0x20(%r14) # imm = 0xFFFFFFFF
movl $0xffffffff, %eax       # imm = 0xFFFFFFFF
movl %eax, 0x24(%r14)
movq 0x10(%rbx), %rax
movq %rax, 0x28(%r14)
movq $0x0, 0x30(%r14)
movq %r14, 0x10(%rbx)
xorps %xmm0, %xmm0
movups %xmm0, 0x48(%r14)
movups %xmm0, 0x38(%r14)
movq %r14, %rax
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
leaq 0x28fef(%rip), %rdi     # 0x36756
leaq 0x27d69(%rip), %rsi     # 0x354d7
leaq 0x21a86(%rip), %rcx     # 0x2f1fb
movl $0xd0, %edx
callq 0xa0b0
leaq 0x21a3e(%rip), %rdi     # 0x2f1c4
leaq 0x27d4a(%rip), %rsi     # 0x354d7
leaq 0x21a67(%rip), %rcx     # 0x2f1fb
movl $0xd4, %edx
callq 0xa0b0
// File: /workspace/github_c_makefile_star2_O1/Ihsoh[P]ilang/parser.c
// Function: parser_free_symbol
void parser_free_symbol(
	ParserContext *ctx,
	ParserSymbol *symbol
) {
	assert(ctx);
	assert(symbol);

	ParserSymbol *sym = symbol->symtbl;
	while (sym) {
		ParserSymbol *temp = sym->next;
		if (sym->releaser != NULL) {
			sym->releaser(sym);
		}
		free(sym);
		sym = temp;
	}

	if (symbol->releaser != NULL) {
		symbol->releaser(symbol);
	}
	free(symbol);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
testq %rdi, %rdi
je 0xd800
movq %rsi, %rbx
testq %rsi, %rsi
je 0xd81f
movq 0x18(%rbx), %r14
testq %r14, %r14
je 0xd7e0
movq 0x10(%r14), %r15
movq 0x20(%r14), %rax
testq %rax, %rax
je 0xd7d0
movq %r14, %rdi
callq *%rax
movq %r14, %rdi
callq 0xa190
movq %r15, %r14
testq %r15, %r15
jne 0xd7be
movq 0x20(%rbx), %rax
testq %rax, %rax
je 0xd7ee
movq %rbx, %rdi
callq *%rax
movq %rbx, %rdi
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
jmp 0xa190
leaq 0x28f4f(%rip), %rdi     # 0x36756
leaq 0x27cc9(%rip), %rsi     # 0x354d7
leaq 0x21d03(%rip), %rcx     # 0x2f518
movl $0x233, %edx            # imm = 0x233
callq 0xa0b0
leaq 0x21d2b(%rip), %rdi     # 0x2f551
leaq 0x27caa(%rip), %rsi     # 0x354d7
leaq 0x21ce4(%rip), %rcx     # 0x2f518
movl $0x234, %edx            # imm = 0x234
callq 0xa0b0
// File: /workspace/github_c_makefile_star2_O1/Ihsoh[P]ilang/parser.c
// Function: parser_insert_node
void parser_insert_node(
	ParserContext *ctx,
	ParserASTNode **pos,
	ParserASTNode *node
) {
	assert(ctx);
	assert(pos);
	assert(*pos);
	assert(node);

	node->parent = (*pos)->parent;
	node->file = (*pos)->file;
	node->line = (*pos)->line;
	node->column = (*pos)->column;

	(*pos)->parent = node;

	parser_add_child(ctx, node, *pos);
	
	*pos = node;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
testq %rdi, %rdi
je 0xd8a3
movq %rsi, %r14
testq %rsi, %rsi
je 0xd8c2
movq (%r14), %rax
testq %rax, %rax
je 0xd8e1
movq %rdx, %rbx
testq %rdx, %rdx
je 0xd900
movq 0x30(%rax), %rax
movq %rax, 0x30(%rbx)
movq (%r14), %rax
movq 0x18(%rax), %rax
movq %rax, 0x18(%rbx)
movq (%r14), %rax
movl 0x20(%rax), %ecx
movl %ecx, 0x20(%rbx)
movl 0x24(%rax), %ecx
movl %ecx, 0x24(%rbx)
movq %rbx, 0x30(%rax)
movq (%r14), %rdx
movq %rbx, %rsi
callq 0xd91f
movq %rbx, (%r14)
popq %rbx
popq %r14
popq %rbp
retq
leaq 0x28eac(%rip), %rdi     # 0x36756
leaq 0x27c26(%rip), %rsi     # 0x354d7
leaq 0x219d6(%rip), %rcx     # 0x2f28e
movl $0x121, %edx            # imm = 0x121
callq 0xa0b0
leaq 0x21a12(%rip), %rdi     # 0x2f2db
leaq 0x27c07(%rip), %rsi     # 0x354d7
leaq 0x219b7(%rip), %rcx     # 0x2f28e
movl $0x122, %edx            # imm = 0x122
callq 0xa0b0
leaq 0x219f2(%rip), %rdi     # 0x2f2da
leaq 0x27be8(%rip), %rsi     # 0x354d7
leaq 0x21998(%rip), %rcx     # 0x2f28e
movl $0x123, %edx            # imm = 0x123
callq 0xa0b0
leaq 0x253f4(%rip), %rdi     # 0x32cfb
leaq 0x27bc9(%rip), %rsi     # 0x354d7
leaq 0x21979(%rip), %rcx     # 0x2f28e
movl $0x124, %edx            # imm = 0x124
callq 0xa0b0
// File: /workspace/github_c_makefile_star2_O1/Ihsoh[P]ilang/parser.c
// Function: parser_add_child
ParserASTNode * parser_add_child(
	ParserContext *ctx,
	ParserASTNode *node,
	ParserASTNode *child
) {
	assert(ctx);
	assert(node);
	assert(child);

	if (node->nchilds < node->szchilds) {
		node->childs[node->nchilds++] = child;
		return node;
	} else {
		int old_szchilds = node->szchilds;
		int old_size = old_szchilds * sizeof(ParserASTNode *);
		int new_szchilds = old_szchilds == 0 ? 1 : 2 * old_szchilds;
		int new_size = new_szchilds * sizeof(ParserASTNode *);

		ParserASTNode **new_childs = (ParserASTNode **)malloc(new_size);
		if (new_childs == NULL) {
			ctx->alloc_mem_error(ctx);
		}

		ParserASTNode **old_childs = node->childs;
		if (old_childs != NULL) {
			memcpy(new_childs, old_childs, old_size);
			free(old_childs);
		}

		node->childs = new_childs;
		node->childs[node->nchilds++] = child;
		node->szchilds = new_szchilds;

		return node;
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
testq %rdi, %rdi
je 0xd9ee
movq %rsi, %rbx
testq %rsi, %rsi
je 0xda0d
testq %rdx, %rdx
je 0xda2c
movslq 0x44(%rbx), %rax
movl 0x40(%rbx), %r14d
cmpl %r14d, %eax
jge 0xd968
movq 0x48(%rbx), %rcx
leal 0x1(%rax), %esi
movl %esi, 0x44(%rbx)
movq %rdx, (%rcx,%rax,8)
jmp 0xd9dc
movq %rdi, %r15
movq %rdx, -0x30(%rbp)
leal (%r14,%r14), %eax
testl %r14d, %r14d
movl $0x1, %r13d
cmovnel %eax, %r13d
leal (,%r13,8), %eax
movslq %eax, %rdi
callq 0xa120
movq %rax, %r12
testq %rax, %rax
jne 0xd99f
movq %r15, %rdi
callq *0x38(%r15)
movq 0x48(%rbx), %r15
testq %r15, %r15
je 0xd9c2
shll $0x3, %r14d
movslq %r14d, %rdx
movq %r12, %rdi
movq %r15, %rsi
callq 0xa110
movq %r15, %rdi
callq 0xa190
movq %r12, 0x48(%rbx)
movslq 0x44(%rbx), %rax
leal 0x1(%rax), %ecx
movl %ecx, 0x44(%rbx)
movq -0x30(%rbp), %rcx
movq %rcx, (%r12,%rax,8)
movl %r13d, 0x40(%rbx)
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
leaq 0x28d61(%rip), %rdi     # 0x36756
leaq 0x27adb(%rip), %rsi     # 0x354d7
leaq 0x218dc(%rip), %rcx     # 0x2f2df
movl $0x137, %edx            # imm = 0x137
callq 0xa0b0
leaq 0x252e7(%rip), %rdi     # 0x32cfb
leaq 0x27abc(%rip), %rsi     # 0x354d7
leaq 0x218bd(%rip), %rcx     # 0x2f2df
movl $0x138, %edx            # imm = 0x138
callq 0xa0b0
leaq 0x218ff(%rip), %rdi     # 0x2f332
leaq 0x27a9d(%rip), %rsi     # 0x354d7
leaq 0x2189e(%rip), %rcx     # 0x2f2df
movl $0x139, %edx            # imm = 0x139
callq 0xa0b0
// File: /workspace/github_c_makefile_star2_O1/Ihsoh[P]ilang/parser.c
// Function: parser_new_symbol
ParserSymbol * parser_new_symbol(
	ParserContext *ctx,
	int type,
	LexerToken *token,
	size_t szdata,
	void *data
) {
	assert(ctx);
	assert(type != 0);
	assert(token);
	if (szdata > 0) {
		assert(data != NULL);
	} else {
		assert(data == NULL);
	}

	ParserSymbol *symbol = (ParserSymbol *)malloc(sizeof(ParserSymbol) + szdata);
	if (symbol == NULL) {
		ctx->alloc_mem_error(ctx);
	}

	symbol->type = type;
	symbol->token = token;
	symbol->next = NULL;
	symbol->symtbl = NULL;

	symbol->releaser = NULL;

	symbol->szdata = szdata;
	memcpy(&(symbol->data[0]), data, szdata);

	return symbol;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
testq %rdi, %rdi
je 0xdb0d
movl %esi, %r12d
testl %esi, %esi
je 0xdb2c
movq %rdx, %r15
testq %rdx, %rdx
je 0xdb4b
movq %rcx, %rbx
movq %rdi, %r13
testq %rcx, %rcx
movq %r8, -0x30(%rbp)
je 0xdaac
testq %r8, %r8
jne 0xdab5
leaq 0x21723(%rip), %rdi     # 0x2f1b7
leaq 0x27a3c(%rip), %rsi     # 0x354d7
leaq 0x21896(%rip), %rcx     # 0x2f338
movl $0x162, %edx            # imm = 0x162
callq 0xa0b0
testq %r8, %r8
jne 0xdb6a
leaq 0x30(%rbx), %rdi
callq 0xa120
movq %rax, %r14
testq %rax, %rax
jne 0xdacd
movq %r13, %rdi
callq *0x38(%r13)
movl %r12d, (%r14)
movq %r15, 0x8(%r14)
xorps %xmm0, %xmm0
movups %xmm0, 0x10(%r14)
movq $0x0, 0x20(%r14)
movq %rbx, 0x28(%r14)
movq %r14, %rdi
addq $0x30, %rdi
movq -0x30(%rbp), %rsi
movq %rbx, %rdx
callq 0xa110
movq %r14, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
leaq 0x28c42(%rip), %rdi     # 0x36756
leaq 0x279bc(%rip), %rsi     # 0x354d7
leaq 0x21816(%rip), %rcx     # 0x2f338
movl $0x15e, %edx            # imm = 0x15E
callq 0xa0b0
leaq 0x21859(%rip), %rdi     # 0x2f38c
leaq 0x2799d(%rip), %rsi     # 0x354d7
leaq 0x217f7(%rip), %rcx     # 0x2f338
movl $0x15f, %edx            # imm = 0x15F
callq 0xa0b0
leaq 0x20978(%rip), %rdi     # 0x2e4ca
leaq 0x2797e(%rip), %rsi     # 0x354d7
leaq 0x217d8(%rip), %rcx     # 0x2f338
movl $0x160, %edx            # imm = 0x160
callq 0xa0b0
leaq 0x21653(%rip), %rdi     # 0x2f1c4
leaq 0x2795f(%rip), %rsi     # 0x354d7
leaq 0x217b9(%rip), %rcx     # 0x2f338
movl $0x164, %edx            # imm = 0x164
callq 0xa0b0
// File: /workspace/github_c_makefile_star2_O1/Ihsoh[P]ilang/parser.c
// Function: parser_clone_symbol
ParserSymbol * parser_clone_symbol(
	ParserContext *ctx,
	ParserSymbol *source
) {
	assert(ctx);
	assert(source);

	size_t size = sizeof(ParserSymbol) + source->szdata;

	ParserSymbol *symbol = (ParserSymbol *)malloc(size);
	if (symbol == NULL) {
		ctx->alloc_mem_error(ctx);
	}

	memcpy(symbol, source, size);

	return symbol;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
testq %rdi, %rdi
je 0xdbd9
movq %rsi, %rbx
testq %rsi, %rsi
je 0xdbf8
movq %rdi, %r14
movq 0x28(%rbx), %r15
addq $0x30, %r15
movq %r15, %rdi
callq 0xa120
movq %rax, %r12
testq %rax, %rax
jne 0xdbc3
movq %r14, %rdi
callq *0x38(%r14)
movq %r12, %rdi
movq %rbx, %rsi
movq %r15, %rdx
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
jmp 0xa110
leaq 0x28b76(%rip), %rdi     # 0x36756
leaq 0x278f0(%rip), %rsi     # 0x354d7
leaq 0x217a8(%rip), %rcx     # 0x2f396
movl $0x17d, %edx            # imm = 0x17D
callq 0xa0b0
leaq 0x20947(%rip), %rdi     # 0x2e546
leaq 0x278d1(%rip), %rsi     # 0x354d7
leaq 0x21789(%rip), %rcx     # 0x2f396
movl $0x17e, %edx            # imm = 0x17E
callq 0xa0b0
// File: /workspace/github_c_makefile_star2_O1/Ihsoh[P]ilang/parser.c
// Function: parser_add_symptr_to_node
ParserSymbol * parser_add_symptr_to_node(
	ParserContext *ctx,
	ParserASTNode *node,
	ParserSymbol *symptr
) {
	assert(ctx);
	assert(node);
	assert(symptr);

	if (parser_get_symbol_from_node(ctx, node, 0, symptr->token)) {
		ctx->syntax_error_token_msg(
			ctx,
			symptr->token,
			"redefined symbol."
		);
	}

	symptr->next = node->symtbl;

	node->symtbl = symptr;

	return symptr;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
testq %rdi, %rdi
je 0xdc7c
movq %rsi, %r14
testq %rsi, %rsi
je 0xdc9b
movq %rdx, %rbx
testq %rdx, %rdx
je 0xdcba
movq %rdi, %r15
movq 0x8(%rbx), %rcx
movq %r14, %rsi
xorl %edx, %edx
callq 0xdcd9
testq %rax, %rax
je 0xdc62
movq 0x8(%rbx), %rsi
leaq 0x217df(%rip), %rdx     # 0x2f43a
movq %r15, %rdi
callq *0x50(%r15)
movq 0x38(%r14), %rax
movq %rax, 0x10(%rbx)
movq %rbx, 0x38(%r14)
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
leaq 0x28ad3(%rip), %rdi     # 0x36756
leaq 0x2784d(%rip), %rsi     # 0x354d7
leaq 0x21748(%rip), %rcx     # 0x2f3d9
movl $0x1ac, %edx            # imm = 0x1AC
callq 0xa0b0
leaq 0x25059(%rip), %rdi     # 0x32cfb
leaq 0x2782e(%rip), %rsi     # 0x354d7
leaq 0x21729(%rip), %rcx     # 0x2f3d9
movl $0x1ad, %edx            # imm = 0x1AD
callq 0xa0b0
leaq 0x21772(%rip), %rdi     # 0x2f433
leaq 0x2780f(%rip), %rsi     # 0x354d7
leaq 0x2170a(%rip), %rcx     # 0x2f3d9
movl $0x1ae, %edx            # imm = 0x1AE
callq 0xa0b0
// File: /workspace/github_c_makefile_star2_O1/Ihsoh[P]ilang/parser.c
// Function: parser_get_symbol_from_node
ParserSymbol * parser_get_symbol_from_node(
	ParserContext *ctx,
	ParserASTNode *node,
	int type,
	LexerToken *token
) {
	assert(ctx);
	assert(node);
	assert(token);

	ParserSymbol *symbol = _parser_get_symbol(ctx, node->symtbl, type, token);
	if (symbol != NULL) {
		return symbol;
	} else {
		if (node->parent != NULL) {
			return parser_get_symbol_from_node(ctx, node->parent, type, token);
		} else {
			return NULL;
		}
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rcx, %rbx
movl %edx, %r14d
movq %rsi, %r15
movq %rdi, -0x30(%rbp)
cmpq $0x0, -0x30(%rbp)
je 0xdd6a
testq %r15, %r15
je 0xdd89
testq %rbx, %rbx
je 0xdda8
movq 0x38(%r15), %r13
testq %r13, %r13
je 0xdd44
movq 0x8(%r13), %rsi
movq %rbx, %rdi
callq 0xba3e
testb %al, %al
je 0xdd38
testl %r14d, %r14d
je 0xdd31
cmpl %r14d, (%r13)
jne 0xdd38
xorl %eax, %eax
movq %r13, %r12
jmp 0xdd3e
movq 0x10(%r13), %r13
movb $0x1, %al
testb %al, %al
jne 0xdd11
jmp 0xdd47
xorl %r12d, %r12d
testq %r12, %r12
jne 0xdd58
movq 0x30(%r15), %r15
testq %r15, %r15
jne 0xdcf4
xorl %r12d, %r12d
movq %r12, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
leaq 0x289e5(%rip), %rdi     # 0x36756
leaq 0x2775f(%rip), %rsi     # 0x354d7
leaq 0x2173a(%rip), %rcx     # 0x2f4b9
movl $0x21f, %edx            # imm = 0x21F
callq 0xa0b0
leaq 0x24f6b(%rip), %rdi     # 0x32cfb
leaq 0x27740(%rip), %rsi     # 0x354d7
leaq 0x2171b(%rip), %rcx     # 0x2f4b9
movl $0x220, %edx            # imm = 0x220
callq 0xa0b0
leaq 0x2071b(%rip), %rdi     # 0x2e4ca
leaq 0x27721(%rip), %rsi     # 0x354d7
leaq 0x216fc(%rip), %rcx     # 0x2f4b9
movl $0x221, %edx            # imm = 0x221
callq 0xa0b0
// File: /workspace/github_c_makefile_star2_O1/Ihsoh[P]ilang/parser.c
// Function: parser_add_symbol_to_node
ParserSymbol * parser_add_symbol_to_node(
	ParserContext *ctx,
	ParserASTNode *node,
	int type,
	LexerToken *token,
	size_t szdata,
	void *data
) {
	assert(ctx);
	assert(node);
	assert(type != 0);
	assert(token);
	if (szdata > 0) {
		assert(data != NULL);
	} else {
		assert(data == NULL);
	}

	if (parser_get_symbol_from_node(ctx, node, 0, token)) {
		ctx->syntax_error_token_msg(
			ctx,
			token,
			"redefined symbol."
		);
	}

	return _parser_add_symbol(ctx, &(node->symtbl), type, token, szdata, data);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
testq %rdi, %rdi
je 0xde8c
movq %rsi, %r13
testq %rsi, %rsi
je 0xdeab
movl %edx, %r12d
testl %edx, %edx
je 0xdeca
movq %rcx, %r15
testq %rcx, %rcx
je 0xdee9
movq %r8, %r14
movq %rdi, %rbx
testq %r8, %r8
movq %r9, -0x30(%rbp)
je 0xde34
testq %r9, %r9
jne 0xde3d
leaq 0x2139b(%rip), %rdi     # 0x2f1b7
leaq 0x276b4(%rip), %rsi     # 0x354d7
leaq 0x21622(%rip), %rcx     # 0x2f44c
movl $0x1cc, %edx            # imm = 0x1CC
callq 0xa0b0
testq %r9, %r9
jne 0xdf08
movq %rbx, %rdi
movq %r13, %rsi
xorl %edx, %edx
movq %r15, %rcx
callq 0xdcd9
testq %rax, %rax
je 0xde62
leaq 0x215e1(%rip), %rdx     # 0x2f43a
movq %rbx, %rdi
movq %r15, %rsi
callq *0x50(%rbx)
addq $0x38, %r13
movq %rbx, %rdi
movq %r13, %rsi
movl %r12d, %edx
movq %r15, %rcx
movq %r14, %r8
movq -0x30(%rbp), %r9
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0xdf27
leaq 0x288c3(%rip), %rdi     # 0x36756
leaq 0x2763d(%rip), %rsi     # 0x354d7
leaq 0x215ab(%rip), %rcx     # 0x2f44c
movl $0x1c7, %edx            # imm = 0x1C7
callq 0xa0b0
leaq 0x24e49(%rip), %rdi     # 0x32cfb
leaq 0x2761e(%rip), %rsi     # 0x354d7
leaq 0x2158c(%rip), %rcx     # 0x2f44c
movl $0x1c8, %edx            # imm = 0x1C8
callq 0xa0b0
leaq 0x214bb(%rip), %rdi     # 0x2f38c
leaq 0x275ff(%rip), %rsi     # 0x354d7
leaq 0x2156d(%rip), %rcx     # 0x2f44c
movl $0x1c9, %edx            # imm = 0x1C9
callq 0xa0b0
leaq 0x205da(%rip), %rdi     # 0x2e4ca
leaq 0x275e0(%rip), %rsi     # 0x354d7
leaq 0x2154e(%rip), %rcx     # 0x2f44c
movl $0x1ca, %edx            # imm = 0x1CA
callq 0xa0b0
leaq 0x212b5(%rip), %rdi     # 0x2f1c4
leaq 0x275c1(%rip), %rsi     # 0x354d7
leaq 0x2152f(%rip), %rcx     # 0x2f44c
movl $0x1ce, %edx            # imm = 0x1CE
callq 0xa0b0
// File: /workspace/github_c_makefile_star2_O1/Ihsoh[P]ilang/parser.c
// Function: parser_add_symbol
static ParserSymbol * _parser_add_symbol(
	ParserContext *ctx,
	ParserSymbol **symtbl,
	int type,
	LexerToken *token,
	size_t szdata,
	void *data
) {
	assert(ctx);
	assert(symtbl);
	assert(type != 0);
	assert(token);
	if (szdata > 0) {
		assert(data != NULL);
	} else {
		assert(data == NULL);
	}

	ParserSymbol *symbol = parser_new_symbol(ctx, type, token, szdata, data);

	symbol->next = *symtbl;

	*symtbl = symbol;

	return symbol;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %rbx
pushq %rax
testq %rsi, %rsi
je 0xdf84
movq %rsi, %rbx
testq %r8, %r8
je 0xdf5e
testq %r9, %r9
jne 0xdf63
leaq 0x21271(%rip), %rdi     # 0x2f1b7
leaq 0x2758a(%rip), %rsi     # 0x354d7
leaq 0x219e7(%rip), %rcx     # 0x2f93b
movl $0x199, %edx            # imm = 0x199
callq 0xa0b0
testq %r9, %r9
jne 0xdfa3
movl %edx, %esi
movq %rcx, %rdx
movq %r8, %rcx
movq %r9, %r8
callq 0xda4b
movq (%rbx), %rcx
movq %rcx, 0x10(%rax)
movq %rax, (%rbx)
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
leaq 0x21a16(%rip), %rdi     # 0x2f9a1
leaq 0x27545(%rip), %rsi     # 0x354d7
leaq 0x219a2(%rip), %rcx     # 0x2f93b
movl $0x195, %edx            # imm = 0x195
callq 0xa0b0
leaq 0x2121a(%rip), %rdi     # 0x2f1c4
leaq 0x27526(%rip), %rsi     # 0x354d7
leaq 0x21983(%rip), %rcx     # 0x2f93b
movl $0x19b, %edx            # imm = 0x19B
callq 0xa0b0
// File: /workspace/github_c_makefile_star2_O1/Ihsoh[P]ilang/parser.c
// Function: parser_get_symbol
static ParserSymbol * _parser_get_symbol(
	ParserContext *ctx,
	ParserSymbol *symtbl,
	int type,
	LexerToken *token
) {
	assert(ctx);
	assert(token);

	ParserSymbol *symbol = symtbl;
	while (symbol) {
		LexerToken *t = symbol->token;

		if (lexer_compare_token(token, t)
				&& (type == 0 || type == symbol->type)) {
			return symbol;
		}

		symbol = symbol->next;
	}

	return NULL;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
testq %rdx, %rdx
je 0xe01c
movq %rdx, %rbx
movl %esi, %r14d
movq %rdi, %r15
testq %r15, %r15
je 0xe00d
movq 0x8(%r15), %rsi
movq %rbx, %rdi
callq 0xba3e
testb %al, %al
je 0xe001
testl %r14d, %r14d
je 0xdffa
cmpl %r14d, (%r15)
jne 0xe001
xorl %eax, %eax
movq %r15, %r12
jmp 0xe007
movq 0x10(%r15), %r15
movb $0x1, %al
testb %al, %al
jne 0xdfdb
jmp 0xe010
xorl %r12d, %r12d
movq %r12, %rax
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
leaq 0x204a7(%rip), %rdi     # 0x2e4ca
leaq 0x274ad(%rip), %rsi     # 0x354d7
leaq 0x21977(%rip), %rcx     # 0x2f9a8
movl $0x1e3, %edx            # imm = 0x1E3
callq 0xa0b0
// File: /workspace/github_c_makefile_star2_O1/Ihsoh[P]ilang/parser.c
// Function: parser_add_symptr_to_symbol
ParserSymbol * parser_add_symptr_to_symbol(
	ParserContext *ctx,
	ParserSymbol *symbol,
	ParserSymbol *symptr
) {
	assert(ctx);
	assert(symbol);
	assert(symptr);

	if (_parser_get_symbol(ctx, symbol->symtbl, 0, symptr->token)) {
		ctx->syntax_error_token_msg(
			ctx,
			symptr->token,
			"redefined symbol."
		);
	}

	symptr->next = symbol->symtbl;

	symbol->symtbl = symptr;

	return symptr;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
testq %rdi, %rdi
je 0xe0a1
movq %rsi, %r14
testq %rsi, %rsi
je 0xe0c0
movq %rdx, %rbx
testq %rdx, %rdx
je 0xe0df
movq %rdi, %r15
movq 0x18(%r14), %rdi
movq 0x8(%rbx), %rdx
xorl %esi, %esi
callq 0xdfc2
testq %rax, %rax
je 0xe087
movq 0x8(%rbx), %rsi
leaq 0x213ba(%rip), %rdx     # 0x2f43a
movq %r15, %rdi
callq *0x50(%r15)
movq 0x18(%r14), %rax
movq %rax, 0x10(%rbx)
movq %rbx, 0x18(%r14)
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
leaq 0x286ae(%rip), %rdi     # 0x36756
leaq 0x27428(%rip), %rsi     # 0x354d7
leaq 0x214a2(%rip), %rcx     # 0x2f558
movl $0x24b, %edx            # imm = 0x24B
callq 0xa0b0
leaq 0x2148a(%rip), %rdi     # 0x2f551
leaq 0x27409(%rip), %rsi     # 0x354d7
leaq 0x21483(%rip), %rcx     # 0x2f558
movl $0x24c, %edx            # imm = 0x24C
callq 0xa0b0
leaq 0x2134d(%rip), %rdi     # 0x2f433
leaq 0x273ea(%rip), %rsi     # 0x354d7
leaq 0x21464(%rip), %rcx     # 0x2f558
movl $0x24d, %edx            # imm = 0x24D
callq 0xa0b0
// File: /workspace/github_c_makefile_star2_O1/Ihsoh[P]ilang/parser.c
// Function: parser_add_symbol_to_symbol
ParserSymbol * parser_add_symbol_to_symbol(
	ParserContext *ctx,
	ParserSymbol *symbol,
	int type,
	LexerToken *token,
	size_t szdata,
	void *data
) {
	assert(ctx);
	assert(symbol);
	assert(type != 0);
	assert(token);
	if (szdata > 0) {
		assert(data != NULL);
	} else {
		assert(data == NULL);
	}

	if (_parser_get_symbol(ctx, symbol->symtbl, 0, token)) {
		ctx->syntax_error_token_msg(
			ctx,
			token,
			"redefined symbol."
		);
	}

	return _parser_add_symbol(ctx, &(symbol->symtbl), type, token, szdata, data);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
testq %rdi, %rdi
je 0xe1e3
movq %rsi, %r13
testq %rsi, %rsi
je 0xe202
testl %edx, %edx
je 0xe221
movq %rcx, %r15
testq %rcx, %rcx
je 0xe240
movq %rdi, %rbx
testq %r8, %r8
movq %r9, -0x40(%rbp)
movq %r8, -0x38(%rbp)
movl %edx, -0x2c(%rbp)
je 0xe16f
testq %r9, %r9
jne 0xe178
leaq 0x21060(%rip), %rdi     # 0x2f1b7
leaq 0x27379(%rip), %rsi     # 0x354d7
leaq 0x2144e(%rip), %rcx     # 0x2f5b3
movl $0x26b, %edx            # imm = 0x26B
callq 0xa0b0
testq %r9, %r9
jne 0xe25f
movq 0x18(%r13), %r14
addq $0x18, %r13
testq %r14, %r14
je 0xe1a4
movq 0x8(%r14), %rsi
movq %r15, %rdi
callq 0xba3e
testb %al, %al
je 0xe19a
movq %r14, %r12
jmp 0xe19e
movq 0x10(%r14), %r14
testb %al, %al
je 0xe180
jmp 0xe1a7
xorl %r12d, %r12d
testq %r12, %r12
je 0xe1bc
leaq 0x21287(%rip), %rdx     # 0x2f43a
movq %rbx, %rdi
movq %r15, %rsi
callq *0x50(%rbx)
movq %rbx, %rdi
movq %r13, %rsi
movl -0x2c(%rbp), %edx
movq %r15, %rcx
movq -0x38(%rbp), %r8
movq -0x40(%rbp), %r9
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0xdf27
leaq 0x2856c(%rip), %rdi     # 0x36756
leaq 0x272e6(%rip), %rsi     # 0x354d7
leaq 0x213bb(%rip), %rcx     # 0x2f5b3
movl $0x266, %edx            # imm = 0x266
callq 0xa0b0
leaq 0x21348(%rip), %rdi     # 0x2f551
leaq 0x272c7(%rip), %rsi     # 0x354d7
leaq 0x2139c(%rip), %rcx     # 0x2f5b3
movl $0x267, %edx            # imm = 0x267
callq 0xa0b0
leaq 0x21164(%rip), %rdi     # 0x2f38c
leaq 0x272a8(%rip), %rsi     # 0x354d7
leaq 0x2137d(%rip), %rcx     # 0x2f5b3
movl $0x268, %edx            # imm = 0x268
callq 0xa0b0
leaq 0x20283(%rip), %rdi     # 0x2e4ca
leaq 0x27289(%rip), %rsi     # 0x354d7
leaq 0x2135e(%rip), %rcx     # 0x2f5b3
movl $0x269, %edx            # imm = 0x269
callq 0xa0b0
leaq 0x20f5e(%rip), %rdi     # 0x2f1c4
leaq 0x2726a(%rip), %rsi     # 0x354d7
leaq 0x2133f(%rip), %rcx     # 0x2f5b3
movl $0x26d, %edx            # imm = 0x26D
callq 0xa0b0
// File: /workspace/github_c_makefile_star2_O1/Ihsoh[P]ilang/parser.c
// Function: parser_get_symbol_from_symbol
ParserSymbol * parser_get_symbol_from_symbol(
	ParserContext *ctx,
	ParserSymbol *symbol,
	int type,
	LexerToken *token
) {
	assert(ctx);
	assert(symbol);
	assert(token);

	return _parser_get_symbol(ctx, symbol->symtbl, type, token);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
testq %rdi, %rdi
je 0xe2ea
testq %rsi, %rsi
je 0xe309
movq %rcx, %rbx
testq %rcx, %rcx
je 0xe328
movl %edx, %r14d
movq 0x18(%rsi), %r12
testq %r12, %r12
je 0xe2db
movq 0x8(%r12), %rsi
movq %rbx, %rdi
callq 0xba3e
testb %al, %al
je 0xe2ce
testl %r14d, %r14d
je 0xe2c7
cmpl %r14d, (%r12)
jne 0xe2ce
xorl %eax, %eax
movq %r12, %r15
jmp 0xe2d5
movq 0x10(%r12), %r12
movb $0x1, %al
testb %al, %al
jne 0xe2a6
jmp 0xe2de
xorl %r15d, %r15d
movq %r15, %rax
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
leaq 0x28465(%rip), %rdi     # 0x36756
leaq 0x271df(%rip), %rsi     # 0x354d7
leaq 0x21322(%rip), %rcx     # 0x2f621
movl $0x281, %edx            # imm = 0x281
callq 0xa0b0
leaq 0x21241(%rip), %rdi     # 0x2f551
leaq 0x271c0(%rip), %rsi     # 0x354d7
leaq 0x21303(%rip), %rcx     # 0x2f621
movl $0x282, %edx            # imm = 0x282
callq 0xa0b0
leaq 0x2019b(%rip), %rdi     # 0x2e4ca
leaq 0x271a1(%rip), %rsi     # 0x354d7
leaq 0x212e4(%rip), %rcx     # 0x2f621
movl $0x283, %edx            # imm = 0x283
callq 0xa0b0
// File: /workspace/github_c_makefile_star2_O1/Ihsoh[P]ilang/parser.c
// Function: parser_get_symbol_index_from_symbol
int parser_get_symbol_index_from_symbol(
	ParserContext *ctx,
	ParserSymbol *symbol,
	int type,
	LexerToken *token
) {
	assert(ctx);
	assert(symbol);
	assert(token);

	return _parser_get_symbol_index(ctx, symbol->symtbl, type, token);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movl %edx, -0x2c(%rbp)
testq %rdi, %rdi
je 0xe40b
testq %rsi, %rsi
je 0xe42a
movq %rcx, %rbx
testq %rcx, %rcx
je 0xe449
movq 0x18(%rsi), %r12
xorl %r13d, %r13d
movl $0x0, %r14d
testq %r12, %r12
je 0xe39a
xorl %r14d, %r14d
movq %r12, %rax
movq 0x10(%rax), %rax
incl %r14d
testq %rax, %rax
jne 0xe38e
testq %r12, %r12
je 0xe3ec
movq 0x8(%r12), %rsi
movq %rbx, %rdi
callq 0xba3e
testb %al, %al
je 0xe3cc
cmpl $0x0, -0x2c(%rbp)
je 0xe3bf
movl -0x2c(%rbp), %eax
cmpl %eax, (%r12)
jne 0xe3cc
movl %r13d, %r15d
notl %r15d
addl %r14d, %r15d
xorl %eax, %eax
jmp 0xe3d6
movq 0x10(%r12), %r12
incl %r13d
movb $0x1, %al
testb %al, %al
jne 0xe39a
movl %r15d, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
leaq 0x20fa1(%rip), %rdi     # 0x2f394
leaq 0x270dd(%rip), %rsi     # 0x354d7
leaq 0x215fc(%rip), %rcx     # 0x2f9fd
movl $0x215, %edx            # imm = 0x215
callq 0xa0b0
leaq 0x28344(%rip), %rdi     # 0x36756
leaq 0x270be(%rip), %rsi     # 0x354d7
leaq 0x21261(%rip), %rcx     # 0x2f681
movl $0x28e, %edx            # imm = 0x28E
callq 0xa0b0
leaq 0x21120(%rip), %rdi     # 0x2f551
leaq 0x2709f(%rip), %rsi     # 0x354d7
leaq 0x21242(%rip), %rcx     # 0x2f681
movl $0x28f, %edx            # imm = 0x28F
callq 0xa0b0
leaq 0x2007a(%rip), %rdi     # 0x2e4ca
leaq 0x27080(%rip), %rsi     # 0x354d7
leaq 0x21223(%rip), %rcx     # 0x2f681
movl $0x290, %edx            # imm = 0x290
callq 0xa0b0
// File: /workspace/github_c_makefile_star2_O1/Ihsoh[P]ilang/string.c
// Function: rstr_init_with_cstr
void rstr_init_with_cstr(
	ResizableString *rstr,
	const char *cstr
) {
	assert(rstr);
	assert(cstr);

	rstr_init(rstr);
	rstr_append_with_cstr(rstr, cstr);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
testq %rdi, %rdi
je 0xe4b1
testq %rsi, %rsi
je 0xe4d0
xorps %xmm0, %xmm0
movups %xmm0, (%rdi)
popq %rbp
jmp 0xe4ef
leaq 0x215a8(%rip), %rdi     # 0x2fa60
leaq 0x215a6(%rip), %rsi     # 0x2fa65
leaq 0x215ca(%rip), %rcx     # 0x2fa90
movl $0x1a, %edx
callq 0xa0b0
leaq 0x215f3(%rip), %rdi     # 0x2faca
leaq 0x21587(%rip), %rsi     # 0x2fa65
leaq 0x215ab(%rip), %rcx     # 0x2fa90
movl $0x1b, %edx
callq 0xa0b0
// File: /workspace/github_c_makefile_star2_O1/Ihsoh[P]ilang/string.c
// Function: rstr_append_with_cstr
void rstr_append_with_cstr(ResizableString *dst, const char *src) {
	assert(dst);
	assert(src);

	int len_src = strlen(src);
	if (len_src == 0) {
		return;
	}

	if (dst->len + len_src > dst->size) {
		_inc_buffer_size(dst, len_src);
	}

	memcpy(dst->buffer + dst->len, src, len_src);
	dst->len += len_src;

	_append_null_terminated_char(dst);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
testq %rdi, %rdi
je 0xe561
movq %rsi, %r14
testq %rsi, %rsi
je 0xe580
movq %rdi, %rbx
movq %r14, %rdi
callq 0xa080
movq %rax, %r15
testl %r15d, %r15d
je 0xe556
movl 0x4(%rbx), %eax
addl %r15d, %eax
cmpl (%rbx), %eax
jle 0xe52e
movq %rbx, %rdi
movl %r15d, %esi
callq 0xe9ef
movslq 0x4(%rbx), %rdi
addq 0x8(%rbx), %rdi
movslq %r15d, %rdx
movq %r14, %rsi
callq 0xa110
movslq 0x4(%rbx), %rax
movslq %r15d, %rcx
addq %rax, %rcx
movl %ecx, 0x4(%rbx)
movq 0x8(%rbx), %rax
movb $0x0, (%rax,%rcx)
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
leaq 0x1fb01(%rip), %rdi     # 0x2e069
leaq 0x214f6(%rip), %rsi     # 0x2fa65
leaq 0x21680(%rip), %rcx     # 0x2fbf6
movl $0x90, %edx
callq 0xa0b0
leaq 0x21976(%rip), %rdi     # 0x2fefd
leaq 0x214d7(%rip), %rsi     # 0x2fa65
leaq 0x21661(%rip), %rcx     # 0x2fbf6
movl $0x91, %edx
callq 0xa0b0
// File: /workspace/github_c_makefile_star2_O1/Ihsoh[P]ilang/string.c
// Function: rstr_init_with_raw
void rstr_init_with_raw(
	ResizableString *rstr,
	const char *cstr,
	int len
) {
	assert(rstr);
	assert(cstr);
	assert(len >= 0);

	rstr_init(rstr);
	rstr_append_with_raw(rstr, cstr, len);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
testq %rdi, %rdi
je 0xe62b
testq %rsi, %rsi
je 0xe64a
testl %edx, %edx
js 0xe669
xorps %xmm0, %xmm0
movups %xmm0, (%rdi)
popq %rbp
jmp 0xe688
leaq 0x2142e(%rip), %rdi     # 0x2fa60
leaq 0x2142c(%rip), %rsi     # 0x2fa65
leaq 0x214c1(%rip), %rcx     # 0x2fb01
movl $0x30, %edx
callq 0xa0b0
leaq 0x21479(%rip), %rdi     # 0x2faca
leaq 0x2140d(%rip), %rsi     # 0x2fa65
leaq 0x214a2(%rip), %rcx     # 0x2fb01
movl $0x31, %edx
callq 0xa0b0
leaq 0x1fedd(%rip), %rdi     # 0x2e54d
leaq 0x213ee(%rip), %rsi     # 0x2fa65
leaq 0x21483(%rip), %rcx     # 0x2fb01
movl $0x32, %edx
callq 0xa0b0