LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O2/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 0xc4ee
testq %rsi, %rsi
je 0xc50d
movl %ecx, %r15d
movl %edx, %r12d
movq %rdi, %rbx
callq 0xc403
movq %rax, %r14
testq %rax, %rax
je 0xc4d9
movq 0x8(%r14), %r13
testb %r12b, %r12b
je 0xc4ba
movq 0x8(%r13), %rdi
testq %rdi, %rdi
je 0xc4ba
callq *0x38(%rbx)
testb %r15b, %r15b
je 0xc4cb
movq 0x10(%r13), %rdi
testq %rdi, %rdi
je 0xc4cb
callq *0x40(%rbx)
pushq $0x1
popq %rdx
movq %rbx, %rdi
movq %r14, %rsi
callq 0xbc6b
testq %r14, %r14
setne %al
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
leaq 0x20bf4(%rip), %rdi     # 0x2d0e9
leaq 0x2084b(%rip), %rsi     # 0x2cd47
leaq 0x20906(%rip), %rcx     # 0x2ce09
movl $0xb1, %edx
callq 0xa0b0
leaq 0x208ad(%rip), %rdi     # 0x2cdc1
leaq 0x2082c(%rip), %rsi     # 0x2cd47
leaq 0x208e7(%rip), %rcx     # 0x2ce09
movl $0xb2, %edx
callq 0xa0b0
// File: /workspace/github_c_makefile_star2_O2/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 0xc547
testq %rsi, %rsi
je 0xc566
callq 0xc3a3
testq %rax, %rax
setne %al
popq %rbp
retq
leaq 0x20b9b(%rip), %rdi     # 0x2d0e9
leaq 0x207f2(%rip), %rsi     # 0x2cd47
leaq 0x208db(%rip), %rcx     # 0x2ce37
movl $0xca, %edx
callq 0xa0b0
leaq 0x20854(%rip), %rdi     # 0x2cdc1
leaq 0x207d3(%rip), %rsi     # 0x2cd47
leaq 0x208bc(%rip), %rcx     # 0x2ce37
movl $0xcb, %edx
callq 0xa0b0
// File: /workspace/github_c_makefile_star2_O2/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 0xc600
testq %rsi, %rsi
je 0xc61f
movq (%rsi), %rax
testq %rax, %rax
je 0xc5fc
movq 0x18(%rax), %rcx
movq %rcx, (%rsi)
movq 0x8(%rax), %rax
jmp 0xc5fe
xorl %eax, %eax
popq %rbp
retq
leaq 0x20ae2(%rip), %rdi     # 0x2d0e9
leaq 0x20739(%rip), %rsi     # 0x2cd47
leaq 0x20874(%rip), %rcx     # 0x2ce89
movl $0xe3, %edx
callq 0xa0b0
leaq 0x227c3(%rip), %rdi     # 0x2ede9
leaq 0x2071a(%rip), %rsi     # 0x2cd47
leaq 0x20855(%rip), %rcx     # 0x2ce89
movl $0xe4, %edx
callq 0xa0b0
// File: /workspace/github_c_makefile_star2_O2/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 0xcbd9
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 0x313e7(%rip), %rax     # 0x3dff8
movq (%rax), %rdi
leaq 0x20512(%rip), %rsi     # 0x2d12d
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_O2/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 0xcd07
movq %rdx, %r15
movq %rsi, %r14
movq %rdi, %rbx
testq %rsi, %rsi
je 0xcc7a
testq %r15, %r15
jne 0xcc83
leaq 0x20531(%rip), %rdi     # 0x2d193
leaq 0x2685a(%rip), %rsi     # 0x334c3
leaq 0x204d7(%rip), %rcx     # 0x2d147
movl $0x92, %edx
callq 0xa0b0
testq %r15, %r15
jne 0xcd26
leaq 0x68(%r14), %rdi
callq 0xa120
movq %rax, %r12
testq %rax, %rax
je 0xccfb
movq %r12, %rdi
addq $0x68, %rdi
movq %r15, %rsi
movq %r14, %rdx
callq 0xa110
movq %rbx, (%r12)
xorps %xmm0, %xmm0
movups %xmm0, 0x8(%r12)
movups %xmm0, 0x18(%r12)
movups %xmm0, 0x24(%r12)
leaq 0x7f(%rip), %rax        # 0xcd45
movq %rax, 0x38(%r12)
leaq 0xe6(%rip), %rax        # 0xcdb8
movq %rax, 0x40(%r12)
leaq 0x160(%rip), %rax       # 0xce3e
movq %rax, 0x48(%r12)
leaq 0x1bb(%rip), %rax       # 0xcea5
movq %rax, 0x50(%r12)
leaq 0x277(%rip), %rax       # 0xcf6d
movq %rax, 0x58(%r12)
movq %r12, %rax
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
leaq 0x26c7d(%rip), %rdi     # 0x3398b
leaq 0x267ae(%rip), %rsi     # 0x334c3
leaq 0x2042b(%rip), %rcx     # 0x2d147
movl $0x90, %edx
callq 0xa0b0
leaq 0x20473(%rip), %rdi     # 0x2d1a0
leaq 0x2678f(%rip), %rsi     # 0x334c3
leaq 0x2040c(%rip), %rcx     # 0x2d147
movl $0x94, %edx
callq 0xa0b0
// File: /workspace/github_c_makefile_star2_O2/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 0xcd6b
leaq 0x2207f(%rip), %rdi     # 0x2edd4
leaq 0x26767(%rip), %rsi     # 0x334c3
leaq 0x20956(%rip), %rcx     # 0x2d6b9
pushq $0x14
popq %rdx
callq 0xa0b0
movq 0x28(%rdi), %rsi
movq 0x31282(%rip), %rax     # 0x3dff8
movq (%rax), %rcx
testq %rsi, %rsi
jne 0xcd92
leaq 0x20994(%rip), %rdi     # 0x2d719
pushq $0x26
popq %rsi
pushq $0x1
popq %rdx
callq 0xa170
jmp 0xcdb0
movq 0x10(%rsi), %rdx
movl 0x18(%rsi), %eax
movl 0x1c(%rsi), %r8d
leaq 0x20944(%rip), %rsi     # 0x2d6e8
movq %rcx, %rdi
movl %eax, %ecx
xorl %eax, %eax
callq 0xa0f0
pushq $0x1
popq %rdi
callq 0xa160
// File: /workspace/github_c_makefile_star2_O2/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 0xcde1
leaq 0x22009(%rip), %rdi     # 0x2edd4
leaq 0x266f1(%rip), %rsi     # 0x334c3
leaq 0x20967(%rip), %rcx     # 0x2d740
pushq $0x2a
popq %rdx
callq 0xa0b0
movq 0x28(%rdi), %rbx
movq 0x3120c(%rip), %r14     # 0x3dff8
movq (%r14), %rcx
testq %rbx, %rbx
jne 0xce08
leaq 0x20998(%rip), %rdi     # 0x2d793
pushq $0x1c
popq %rsi
pushq $0x1
popq %rdx
callq 0xa170
jmp 0xce36
movq 0x10(%rbx), %rdx
movl 0x18(%rbx), %eax
movl 0x1c(%rbx), %r8d
leaq 0x20952(%rip), %rsi     # 0x2d76c
movq %rcx, %rdi
movl %eax, %ecx
xorl %eax, %eax
callq 0xa0f0
movq (%r14), %rdi
pushq $0x14
popq %rcx
movq %rbx, %rsi
movl %ecx, %edx
callq 0xaa9d
pushq $0x1
popq %rdi
callq 0xa160
// File: /workspace/github_c_makefile_star2_O2/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 0xce60
leaq 0x21f86(%rip), %rdi     # 0x2edd4
leaq 0x2666e(%rip), %rsi     # 0x334c3
leaq 0x20954(%rip), %rcx     # 0x2d7b0
pushq $0x44
jmp 0xce7f
movq %rsi, %rdx
testq %rsi, %rsi
jne 0xce85
leaq 0x2097f(%rip), %rdi     # 0x2d7ee
leaq 0x2664d(%rip), %rsi     # 0x334c3
leaq 0x20933(%rip), %rcx     # 0x2d7b0
pushq $0x45
popq %rdx
callq 0xa0b0
movq 0x3116c(%rip), %rax     # 0x3dff8
movq (%rax), %rdi
leaq 0x2095c(%rip), %rsi     # 0x2d7f2
xorl %eax, %eax
callq 0xa0f0
pushq $0x1
popq %rdi
callq 0xa160
// File: /workspace/github_c_makefile_star2_O2/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 0xcecd
leaq 0x21f19(%rip), %rdi     # 0x2edd4
leaq 0x26601(%rip), %rsi     # 0x334c3
leaq 0x20949(%rip), %rcx     # 0x2d812
pushq $0x55
jmp 0xcf0d
movq %rsi, %rbx
testq %rsi, %rsi
jne 0xceee
leaq 0x1f5de(%rip), %rdi     # 0x2c4ba
leaq 0x265e0(%rip), %rsi     # 0x334c3
leaq 0x20928(%rip), %rcx     # 0x2d812
pushq $0x56
jmp 0xcf0d
movq %rdx, %r14
testq %rdx, %rdx
jne 0xcf13
leaq 0x208f1(%rip), %rdi     # 0x2d7ee
leaq 0x265bf(%rip), %rsi     # 0x334c3
leaq 0x20907(%rip), %rcx     # 0x2d812
pushq $0x57
popq %rdx
callq 0xa0b0
movq 0x310de(%rip), %r15     # 0x3dff8
movq (%r15), %rdi
movq 0x10(%rbx), %rdx
movl 0x18(%rbx), %ecx
movl 0x1c(%rbx), %r8d
leaq 0x20935(%rip), %rsi     # 0x2d864
xorl %eax, %eax
callq 0xa0f0
movq (%r15), %rsi
movq %rbx, %rdi
callq 0xaa60
movq (%r15), %rdi
leaq 0x20947(%rip), %rsi     # 0x2d892
movq %r14, %rdx
xorl %eax, %eax
callq 0xa0f0
movq (%r15), %rdi
pushq $0x14
popq %rcx
movq %rbx, %rsi
movl %ecx, %edx
callq 0xaa9d
pushq $0x1
popq %rdi
callq 0xa160
// File: /workspace/github_c_makefile_star2_O2/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 0xcf8f
leaq 0x21e57(%rip), %rdi     # 0x2edd4
leaq 0x2653f(%rip), %rsi     # 0x334c3
leaq 0x2090e(%rip), %rcx     # 0x2d899
pushq $0x71
jmp 0xcfae
movq %rdx, %r9
testq %rdx, %rdx
jne 0xcfb4
leaq 0x20850(%rip), %rdi     # 0x2d7ee
leaq 0x2651e(%rip), %rsi     # 0x334c3
leaq 0x208ed(%rip), %rcx     # 0x2d899
pushq $0x72
popq %rdx
callq 0xa0b0
movq 0x18(%rsi), %rdx
movq 0x31039(%rip), %rax     # 0x3dff8
movq (%rax), %rdi
testq %rdx, %rdx
jne 0xcfda
leaq 0x20824(%rip), %rsi     # 0x2d7f2
movq %r9, %rdx
xorl %eax, %eax
callq 0xa0f0
jmp 0xcfef
movl 0x20(%rsi), %ecx
movl 0x24(%rsi), %r8d
leaq 0x20905(%rip), %rsi     # 0x2d8ed
xorl %eax, %eax
callq 0xa0f0
pushq $0x1
popq %rdi
callq 0xa160
// File: /workspace/github_c_makefile_star2_O2/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 0xd03a
movq %rdi, %rbx
movq 0x10(%rdi), %rsi
testq %rsi, %rsi
je 0xd02e
movq 0x28(%rsi), %r14
movq %rbx, %rdi
callq 0xd059
movq %r14, %rsi
jmp 0xd018
movq %rbx, %rdi
popq %rbx
popq %r14
popq %rbp
jmp 0xa190
leaq 0x21d93(%rip), %rdi     # 0x2edd4
leaq 0x2647b(%rip), %rsi     # 0x334c3
leaq 0x2015e(%rip), %rcx     # 0x2d1ad
movl $0xbc, %edx
callq 0xa0b0
// File: /workspace/github_c_makefile_star2_O2/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 0xd0b6
movq %rsi, %rbx
testq %rsi, %rsi
je 0xd0d5
movq %rdi, %r14
movq 0x50(%rbx), %rax
testq %rax, %rax
je 0xd081
movq %rbx, %rdi
callq *%rax
movq 0x48(%rbx), %rdi
callq 0xa190
movq 0x38(%rbx), %rsi
testq %rsi, %rsi
je 0xd0a4
movq 0x10(%rsi), %r15
movq %r14, %rdi
callq 0xd246
movq %r15, %rsi
jmp 0xd08e
movq %rbx, %rdi
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
jmp 0xa190
leaq 0x21d17(%rip), %rdi     # 0x2edd4
leaq 0x263ff(%rip), %rsi     # 0x334c3
leaq 0x20167(%rip), %rcx     # 0x2d232
movl $0x107, %edx            # imm = 0x107
callq 0xa0b0
leaq 0x23bdf(%rip), %rdi     # 0x30cbb
leaq 0x263e0(%rip), %rsi     # 0x334c3
leaq 0x20148(%rip), %rcx     # 0x2d232
movl $0x108, %edx            # imm = 0x108
callq 0xa0b0
// File: /workspace/github_c_makefile_star2_O2/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 0xd208
movq %r9, %r13
movq %r8, %r12
movq %rcx, %r15
movq %rdi, %rbx
testq %r8, %r8
movq %rdx, -0x38(%rbp)
movl %esi, -0x2c(%rbp)
je 0xd14a
testq %r13, %r13
jne 0xd153
leaq 0x20061(%rip), %rdi     # 0x2d193
leaq 0x2638a(%rip), %rsi     # 0x334c3
leaq 0x20097(%rip), %rcx     # 0x2d1d7
movl $0xd2, %edx
callq 0xa0b0
testq %r13, %r13
jne 0xd227
leaq 0x60(%r12), %rdi
callq 0xa120
movq %rax, %r14
testq %rax, %rax
jne 0xd16b
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 0xd1aa
movq 0x10(%r15), %rax
movq %rax, 0x18(%r14)
movl 0x18(%r15), %eax
movl %eax, 0x20(%r14)
movl 0x1c(%r15), %eax
jmp 0xd1d4
movq 0x28(%rbx), %rax
testq %rax, %rax
je 0xd1c7
movq 0x10(%rax), %rcx
movq %rcx, 0x18(%r14)
movl 0x18(%rax), %ecx
movl %ecx, 0x20(%r14)
movl 0x1c(%rax), %eax
jmp 0xd1d4
andq $0x0, 0x18(%r14)
orl $-0x1, 0x20(%r14)
pushq $-0x1
popq %rax
movl %eax, 0x24(%r14)
movq 0x10(%rbx), %rax
movq %rax, 0x28(%r14)
andq $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 0x21bc5(%rip), %rdi     # 0x2edd4
leaq 0x262ad(%rip), %rsi     # 0x334c3
leaq 0x1ffba(%rip), %rcx     # 0x2d1d7
movl $0xd0, %edx
callq 0xa0b0
leaq 0x1ff72(%rip), %rdi     # 0x2d1a0
leaq 0x2628e(%rip), %rsi     # 0x334c3
leaq 0x1ff9b(%rip), %rcx     # 0x2d1d7
movl $0xd4, %edx
callq 0xa0b0
// File: /workspace/github_c_makefile_star2_O2/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 0xd2a5
movq %rsi, %rbx
testq %rsi, %rsi
je 0xd2c4
movq 0x18(%rbx), %r14
testq %r14, %r14
je 0xd285
movq 0x10(%r14), %r15
movq 0x20(%r14), %rax
testq %rax, %rax
je 0xd278
movq %r14, %rdi
callq *%rax
movq %r14, %rdi
callq 0xa190
movq %r15, %r14
jmp 0xd261
movq 0x20(%rbx), %rax
testq %rax, %rax
je 0xd293
movq %rbx, %rdi
callq *%rax
movq %rbx, %rdi
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
jmp 0xa190
leaq 0x21b28(%rip), %rdi     # 0x2edd4
leaq 0x26210(%rip), %rsi     # 0x334c3
leaq 0x2023a(%rip), %rcx     # 0x2d4f4
movl $0x233, %edx            # imm = 0x233
callq 0xa0b0
leaq 0x20262(%rip), %rdi     # 0x2d52d
leaq 0x261f1(%rip), %rsi     # 0x334c3
leaq 0x2021b(%rip), %rcx     # 0x2d4f4
movl $0x234, %edx            # imm = 0x234
callq 0xa0b0
// File: /workspace/github_c_makefile_star2_O2/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 0xd348
movq %rsi, %r14
testq %rsi, %rsi
je 0xd367
movq (%r14), %rax
testq %rax, %rax
je 0xd386
movq %rdx, %rbx
testq %rdx, %rdx
je 0xd3a5
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 0xd3c4
movq %rbx, (%r14)
popq %rbx
popq %r14
popq %rbp
retq
leaq 0x21a85(%rip), %rdi     # 0x2edd4
leaq 0x2616d(%rip), %rsi     # 0x334c3
leaq 0x1ff0d(%rip), %rcx     # 0x2d26a
movl $0x121, %edx            # imm = 0x121
callq 0xa0b0
leaq 0x1ff49(%rip), %rdi     # 0x2d2b7
leaq 0x2614e(%rip), %rsi     # 0x334c3
leaq 0x1feee(%rip), %rcx     # 0x2d26a
movl $0x122, %edx            # imm = 0x122
callq 0xa0b0
leaq 0x1ff29(%rip), %rdi     # 0x2d2b6
leaq 0x2612f(%rip), %rsi     # 0x334c3
leaq 0x1fecf(%rip), %rcx     # 0x2d26a
movl $0x123, %edx            # imm = 0x123
callq 0xa0b0
leaq 0x2390f(%rip), %rdi     # 0x30cbb
leaq 0x26110(%rip), %rsi     # 0x334c3
leaq 0x1feb0(%rip), %rcx     # 0x2d26a
movl $0x124, %edx            # imm = 0x124
callq 0xa0b0
// File: /workspace/github_c_makefile_star2_O2/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 0xd491
movq %rsi, %rbx
testq %rsi, %rsi
je 0xd4b0
testq %rdx, %rdx
je 0xd4cf
movslq 0x44(%rbx), %rax
movl 0x40(%rbx), %r14d
cmpl %r14d, %eax
jge 0xd40d
movq 0x48(%rbx), %rcx
leal 0x1(%rax), %esi
movl %esi, 0x44(%rbx)
movq %rdx, (%rcx,%rax,8)
jmp 0xd47f
movq %rdi, %r15
movq %rdx, -0x30(%rbp)
leal (%r14,%r14), %eax
testl %r14d, %r14d
pushq $0x1
popq %r13
cmovnel %eax, %r13d
leal (,%r13,8), %eax
movslq %eax, %rdi
callq 0xa120
movq %rax, %r12
testq %rax, %rax
jne 0xd442
movq %r15, %rdi
callq *0x38(%r15)
movq 0x48(%rbx), %r15
testq %r15, %r15
je 0xd465
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 0x2193c(%rip), %rdi     # 0x2edd4
leaq 0x26024(%rip), %rsi     # 0x334c3
leaq 0x1fe15(%rip), %rcx     # 0x2d2bb
movl $0x137, %edx            # imm = 0x137
callq 0xa0b0
leaq 0x23804(%rip), %rdi     # 0x30cbb
leaq 0x26005(%rip), %rsi     # 0x334c3
leaq 0x1fdf6(%rip), %rcx     # 0x2d2bb
movl $0x138, %edx            # imm = 0x138
callq 0xa0b0
leaq 0x1fe38(%rip), %rdi     # 0x2d30e
leaq 0x25fe6(%rip), %rsi     # 0x334c3
leaq 0x1fdd7(%rip), %rcx     # 0x2d2bb
movl $0x139, %edx            # imm = 0x139
callq 0xa0b0
// File: /workspace/github_c_makefile_star2_O2/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 0xd5ad
movl %esi, %r12d
testl %esi, %esi
je 0xd5cc
movq %rdx, %r15
testq %rdx, %rdx
je 0xd5eb
movq %rcx, %rbx
movq %rdi, %r13
testq %rcx, %rcx
movq %r8, -0x30(%rbp)
je 0xd54f
testq %r8, %r8
jne 0xd558
leaq 0x1fc5c(%rip), %rdi     # 0x2d193
leaq 0x25f85(%rip), %rsi     # 0x334c3
leaq 0x1fdcf(%rip), %rcx     # 0x2d314
movl $0x162, %edx            # imm = 0x162
callq 0xa0b0
testq %r8, %r8
jne 0xd60a
leaq 0x30(%rbx), %rdi
callq 0xa120
movq %rax, %r14
testq %rax, %rax
jne 0xd570
movq %r13, %rdi
callq *0x38(%r13)
movl %r12d, (%r14)
movq %r15, 0x8(%r14)
xorps %xmm0, %xmm0
andq $0x0, 0x20(%r14)
movups %xmm0, 0x10(%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 0x21820(%rip), %rdi     # 0x2edd4
leaq 0x25f08(%rip), %rsi     # 0x334c3
leaq 0x1fd52(%rip), %rcx     # 0x2d314
movl $0x15e, %edx            # imm = 0x15E
callq 0xa0b0
leaq 0x1fd95(%rip), %rdi     # 0x2d368
leaq 0x25ee9(%rip), %rsi     # 0x334c3
leaq 0x1fd33(%rip), %rcx     # 0x2d314
movl $0x15f, %edx            # imm = 0x15F
callq 0xa0b0
leaq 0x1eec8(%rip), %rdi     # 0x2c4ba
leaq 0x25eca(%rip), %rsi     # 0x334c3
leaq 0x1fd14(%rip), %rcx     # 0x2d314
movl $0x160, %edx            # imm = 0x160
callq 0xa0b0
leaq 0x1fb8f(%rip), %rdi     # 0x2d1a0
leaq 0x25eab(%rip), %rsi     # 0x334c3
leaq 0x1fcf5(%rip), %rcx     # 0x2d314
movl $0x164, %edx            # imm = 0x164
callq 0xa0b0
// File: /workspace/github_c_makefile_star2_O2/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 0xd679
movq %rsi, %rbx
testq %rsi, %rsi
je 0xd698
movq %rdi, %r14
movq 0x28(%rbx), %r15
addq $0x30, %r15
movq %r15, %rdi
callq 0xa120
movq %rax, %r12
testq %rax, %rax
jne 0xd663
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 0x21754(%rip), %rdi     # 0x2edd4
leaq 0x25e3c(%rip), %rsi     # 0x334c3
leaq 0x1fce4(%rip), %rcx     # 0x2d372
movl $0x17d, %edx            # imm = 0x17D
callq 0xa0b0
leaq 0x1ee97(%rip), %rdi     # 0x2c536
leaq 0x25e1d(%rip), %rsi     # 0x334c3
leaq 0x1fcc5(%rip), %rcx     # 0x2d372
movl $0x17e, %edx            # imm = 0x17E
callq 0xa0b0
// File: /workspace/github_c_makefile_star2_O2/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 0xd71c
movq %rsi, %r14
testq %rsi, %rsi
je 0xd73b
movq %rdx, %rbx
testq %rdx, %rdx
je 0xd75a
movq %rdi, %r15
movq 0x8(%rbx), %rcx
movq %r14, %rsi
xorl %edx, %edx
callq 0xd779
testq %rax, %rax
je 0xd702
movq 0x8(%rbx), %rsi
leaq 0x1fd1b(%rip), %rdx     # 0x2d416
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 0x216b1(%rip), %rdi     # 0x2edd4
leaq 0x25d99(%rip), %rsi     # 0x334c3
leaq 0x1fc84(%rip), %rcx     # 0x2d3b5
movl $0x1ac, %edx            # imm = 0x1AC
callq 0xa0b0
leaq 0x23579(%rip), %rdi     # 0x30cbb
leaq 0x25d7a(%rip), %rsi     # 0x334c3
leaq 0x1fc65(%rip), %rcx     # 0x2d3b5
movl $0x1ad, %edx            # imm = 0x1AD
callq 0xa0b0
leaq 0x1fcae(%rip), %rdi     # 0x2d40f
leaq 0x25d5b(%rip), %rsi     # 0x334c3
leaq 0x1fc46(%rip), %rcx     # 0x2d3b5
movl $0x1ae, %edx            # imm = 0x1AE
callq 0xa0b0
// File: /workspace/github_c_makefile_star2_O2/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 %rbx
pushq %rax
testq %rdi, %rdi
je 0xd801
movq %rcx, %rbx
movl %edx, %r14d
movq %rsi, %r15
testq %r15, %r15
je 0xd7c3
testq %rbx, %rbx
je 0xd7e2
movq 0x38(%r15), %rdi
movl %r14d, %esi
movq %rbx, %rdx
callq 0xda1b
testq %rax, %rax
jne 0xd7b8
movq 0x30(%r15), %r15
testq %r15, %r15
jne 0xd791
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
leaq 0x234f1(%rip), %rdi     # 0x30cbb
leaq 0x25cf2(%rip), %rsi     # 0x334c3
leaq 0x1fcbd(%rip), %rcx     # 0x2d495
movl $0x220, %edx            # imm = 0x220
callq 0xa0b0
leaq 0x1ecd1(%rip), %rdi     # 0x2c4ba
leaq 0x25cd3(%rip), %rsi     # 0x334c3
leaq 0x1fc9e(%rip), %rcx     # 0x2d495
movl $0x221, %edx            # imm = 0x221
callq 0xa0b0
leaq 0x215cc(%rip), %rdi     # 0x2edd4
leaq 0x25cb4(%rip), %rsi     # 0x334c3
leaq 0x1fc7f(%rip), %rcx     # 0x2d495
movl $0x21f, %edx            # imm = 0x21F
callq 0xa0b0
// File: /workspace/github_c_makefile_star2_O2/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 0xd8e5
movq %rsi, %r13
testq %rsi, %rsi
je 0xd904
movl %edx, %r12d
testl %edx, %edx
je 0xd923
movq %rcx, %r15
testq %rcx, %rcx
je 0xd942
movq %r8, %r14
movq %rdi, %rbx
testq %r8, %r8
movq %r9, -0x30(%rbp)
je 0xd88d
testq %r9, %r9
jne 0xd896
leaq 0x1f91e(%rip), %rdi     # 0x2d193
leaq 0x25c47(%rip), %rsi     # 0x334c3
leaq 0x1fba5(%rip), %rcx     # 0x2d428
movl $0x1cc, %edx            # imm = 0x1CC
callq 0xa0b0
testq %r9, %r9
jne 0xd961
movq %rbx, %rdi
movq %r13, %rsi
xorl %edx, %edx
movq %r15, %rcx
callq 0xd779
testq %rax, %rax
je 0xd8bb
leaq 0x1fb64(%rip), %rdx     # 0x2d416
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 0xd980
leaq 0x214e8(%rip), %rdi     # 0x2edd4
leaq 0x25bd0(%rip), %rsi     # 0x334c3
leaq 0x1fb2e(%rip), %rcx     # 0x2d428
movl $0x1c7, %edx            # imm = 0x1C7
callq 0xa0b0
leaq 0x233b0(%rip), %rdi     # 0x30cbb
leaq 0x25bb1(%rip), %rsi     # 0x334c3
leaq 0x1fb0f(%rip), %rcx     # 0x2d428
movl $0x1c8, %edx            # imm = 0x1C8
callq 0xa0b0
leaq 0x1fa3e(%rip), %rdi     # 0x2d368
leaq 0x25b92(%rip), %rsi     # 0x334c3
leaq 0x1faf0(%rip), %rcx     # 0x2d428
movl $0x1c9, %edx            # imm = 0x1C9
callq 0xa0b0
leaq 0x1eb71(%rip), %rdi     # 0x2c4ba
leaq 0x25b73(%rip), %rsi     # 0x334c3
leaq 0x1fad1(%rip), %rcx     # 0x2d428
movl $0x1ca, %edx            # imm = 0x1CA
callq 0xa0b0
leaq 0x1f838(%rip), %rdi     # 0x2d1a0
leaq 0x25b54(%rip), %rsi     # 0x334c3
leaq 0x1fab2(%rip), %rcx     # 0x2d428
movl $0x1ce, %edx            # imm = 0x1CE
callq 0xa0b0
// File: /workspace/github_c_makefile_star2_O2/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 0xd9dd
movq %rsi, %rbx
testq %r8, %r8
je 0xd9b7
testq %r9, %r9
jne 0xd9bc
leaq 0x1f7f4(%rip), %rdi     # 0x2d193
leaq 0x25b1d(%rip), %rsi     # 0x334c3
leaq 0x1ff6a(%rip), %rcx     # 0x2d917
movl $0x199, %edx            # imm = 0x199
callq 0xa0b0
testq %r9, %r9
jne 0xd9fc
movl %edx, %esi
movq %rcx, %rdx
movq %r8, %rcx
movq %r9, %r8
callq 0xd4ee
movq (%rbx), %rcx
movq %rcx, 0x10(%rax)
movq %rax, (%rbx)
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
leaq 0x1ff99(%rip), %rdi     # 0x2d97d
leaq 0x25ad8(%rip), %rsi     # 0x334c3
leaq 0x1ff25(%rip), %rcx     # 0x2d917
movl $0x195, %edx            # imm = 0x195
callq 0xa0b0
leaq 0x1f79d(%rip), %rdi     # 0x2d1a0
leaq 0x25ab9(%rip), %rsi     # 0x334c3
leaq 0x1ff06(%rip), %rcx     # 0x2d917
movl $0x19b, %edx            # imm = 0x19B
callq 0xa0b0
// File: /workspace/github_c_makefile_star2_O2/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 %rbx
pushq %rax
testq %rdx, %rdx
je 0xda66
movq %rdx, %rbx
movl %esi, %r15d
movq %rdi, %r14
testq %r14, %r14
je 0xda58
movq 0x8(%r14), %rsi
movq %rbx, %rdi
callq 0xb79f
testb %al, %al
je 0xda52
testl %r15d, %r15d
je 0xda58
cmpl %r15d, (%r14)
je 0xda58
movq 0x10(%r14), %r14
jmp 0xda33
movq %r14, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
leaq 0x1ea4d(%rip), %rdi     # 0x2c4ba
leaq 0x25a4f(%rip), %rsi     # 0x334c3
leaq 0x1ff09(%rip), %rcx     # 0x2d984
movl $0x1e3, %edx            # imm = 0x1E3
callq 0xa0b0
// File: /workspace/github_c_makefile_star2_O2/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 0xdaeb
movq %rsi, %r14
testq %rsi, %rsi
je 0xdb0a
movq %rdx, %rbx
testq %rdx, %rdx
je 0xdb29
movq %rdi, %r15
movq 0x18(%r14), %rdi
movq 0x8(%rbx), %rdx
xorl %esi, %esi
callq 0xda1b
testq %rax, %rax
je 0xdad1
movq 0x8(%rbx), %rsi
leaq 0x1f94c(%rip), %rdx     # 0x2d416
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 0x212e2(%rip), %rdi     # 0x2edd4
leaq 0x259ca(%rip), %rsi     # 0x334c3
leaq 0x1fa34(%rip), %rcx     # 0x2d534
movl $0x24b, %edx            # imm = 0x24B
callq 0xa0b0
leaq 0x1fa1c(%rip), %rdi     # 0x2d52d
leaq 0x259ab(%rip), %rsi     # 0x334c3
leaq 0x1fa15(%rip), %rcx     # 0x2d534
movl $0x24c, %edx            # imm = 0x24C
callq 0xa0b0
leaq 0x1f8df(%rip), %rdi     # 0x2d40f
leaq 0x2598c(%rip), %rsi     # 0x334c3
leaq 0x1f9f6(%rip), %rcx     # 0x2d534
movl $0x24d, %edx            # imm = 0x24D
callq 0xa0b0
// File: /workspace/github_c_makefile_star2_O2/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
pushq %rax
testq %rdi, %rdi
je 0xdc0b
movq %rsi, %r13
testq %rsi, %rsi
je 0xdc2a
movl %edx, %r12d
testl %edx, %edx
je 0xdc49
movq %rcx, %r15
testq %rcx, %rcx
je 0xdc68
movq %r8, %r14
movq %rdi, %rbx
testq %r8, %r8
movq %r9, -0x30(%rbp)
je 0xdbb5
testq %r9, %r9
jne 0xdbbe
leaq 0x1f5f6(%rip), %rdi     # 0x2d193
leaq 0x2591f(%rip), %rsi     # 0x334c3
leaq 0x1f9e4(%rip), %rcx     # 0x2d58f
movl $0x26b, %edx            # imm = 0x26B
callq 0xa0b0
testq %r9, %r9
jne 0xdc87
movq 0x18(%r13), %rdi
addq $0x18, %r13
xorl %esi, %esi
movq %r15, %rdx
callq 0xda1b
testq %rax, %rax
je 0xdbe5
leaq 0x1f83a(%rip), %rdx     # 0x2d416
movq %rbx, %rdi
movq %r15, %rsi
callq *0x50(%rbx)
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 0xd980
leaq 0x211c2(%rip), %rdi     # 0x2edd4
leaq 0x258aa(%rip), %rsi     # 0x334c3
leaq 0x1f96f(%rip), %rcx     # 0x2d58f
movl $0x266, %edx            # imm = 0x266
callq 0xa0b0
leaq 0x1f8fc(%rip), %rdi     # 0x2d52d
leaq 0x2588b(%rip), %rsi     # 0x334c3
leaq 0x1f950(%rip), %rcx     # 0x2d58f
movl $0x267, %edx            # imm = 0x267
callq 0xa0b0
leaq 0x1f718(%rip), %rdi     # 0x2d368
leaq 0x2586c(%rip), %rsi     # 0x334c3
leaq 0x1f931(%rip), %rcx     # 0x2d58f
movl $0x268, %edx            # imm = 0x268
callq 0xa0b0
leaq 0x1e84b(%rip), %rdi     # 0x2c4ba
leaq 0x2584d(%rip), %rsi     # 0x334c3
leaq 0x1f912(%rip), %rcx     # 0x2d58f
movl $0x269, %edx            # imm = 0x269
callq 0xa0b0
leaq 0x1f512(%rip), %rdi     # 0x2d1a0
leaq 0x2582e(%rip), %rsi     # 0x334c3
leaq 0x1f8f3(%rip), %rcx     # 0x2d58f
movl $0x26d, %edx            # imm = 0x26D
callq 0xa0b0
// File: /workspace/github_c_makefile_star2_O2/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
testq %rdi, %rdi
je 0xdcc8
testq %rsi, %rsi
je 0xdce7
testq %rcx, %rcx
je 0xdd06
movq 0x18(%rsi), %rdi
movl %edx, %esi
movq %rcx, %rdx
popq %rbp
jmp 0xda1b
leaq 0x21105(%rip), %rdi     # 0x2edd4
leaq 0x257ed(%rip), %rsi     # 0x334c3
leaq 0x1f920(%rip), %rcx     # 0x2d5fd
movl $0x281, %edx            # imm = 0x281
callq 0xa0b0
leaq 0x1f83f(%rip), %rdi     # 0x2d52d
leaq 0x257ce(%rip), %rsi     # 0x334c3
leaq 0x1f901(%rip), %rcx     # 0x2d5fd
movl $0x282, %edx            # imm = 0x282
callq 0xa0b0
leaq 0x1e7ad(%rip), %rdi     # 0x2c4ba
leaq 0x257af(%rip), %rsi     # 0x334c3
leaq 0x1f8e2(%rip), %rcx     # 0x2d5fd
movl $0x283, %edx            # imm = 0x283
callq 0xa0b0
// File: /workspace/github_c_makefile_star2_O2/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 %r12
pushq %rbx
testq %rdi, %rdi
je 0xddbe
testq %rsi, %rsi
je 0xdddd
movq %rcx, %rbx
testq %rcx, %rcx
je 0xddfc
movl %edx, %r14d
movq 0x18(%rsi), %r12
pushq $-0x1
popq %r15
movq %r12, %rax
testq %rax, %rax
je 0xdd78
movq 0x10(%rax), %rax
incl %r15d
jmp 0xdd5c
cmpl %r14d, (%r12)
je 0xdd93
movq 0x10(%r12), %r12
decl %r15d
testq %r12, %r12
je 0xdd9f
movq 0x8(%r12), %rsi
movq %rbx, %rdi
callq 0xb79f
testb %al, %al
je 0xdd70
testl %r14d, %r14d
jne 0xdd6a
movl %r15d, %eax
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
leaq 0x1f5ca(%rip), %rdi     # 0x2d370
leaq 0x25716(%rip), %rsi     # 0x334c3
leaq 0x1fc25(%rip), %rcx     # 0x2d9d9
movl $0x215, %edx            # imm = 0x215
callq 0xa0b0
leaq 0x2100f(%rip), %rdi     # 0x2edd4
leaq 0x256f7(%rip), %rsi     # 0x334c3
leaq 0x1f88a(%rip), %rcx     # 0x2d65d
movl $0x28e, %edx            # imm = 0x28E
callq 0xa0b0
leaq 0x1f749(%rip), %rdi     # 0x2d52d
leaq 0x256d8(%rip), %rsi     # 0x334c3
leaq 0x1f86b(%rip), %rcx     # 0x2d65d
movl $0x28f, %edx            # imm = 0x28F
callq 0xa0b0
leaq 0x1e6b7(%rip), %rdi     # 0x2c4ba
leaq 0x256b9(%rip), %rsi     # 0x334c3
leaq 0x1f84c(%rip), %rcx     # 0x2d65d
movl $0x290, %edx            # imm = 0x290
callq 0xa0b0
nop
// File: /workspace/github_c_makefile_star2_O2/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 0xde63
testq %rsi, %rsi
je 0xde7c
xorps %xmm0, %xmm0
movups %xmm0, (%rdi)
popq %rbp
jmp 0xde99
leaq 0x1fbd6(%rip), %rdi     # 0x2da40
leaq 0x1fbd4(%rip), %rsi     # 0x2da45
leaq 0x1fbf8(%rip), %rcx     # 0x2da70
pushq $0x1a
jmp 0xde93
leaq 0x1fc27(%rip), %rdi     # 0x2daaa
leaq 0x1fbbb(%rip), %rsi     # 0x2da45
leaq 0x1fbdf(%rip), %rcx     # 0x2da70
pushq $0x1b
popq %rdx
callq 0xa0b0
// File: /workspace/github_c_makefile_star2_O2/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 0xdf0e
movq %rsi, %r14
testq %rsi, %rsi
je 0xdf2d
movq %rdi, %rbx
movq %r14, %rdi
callq 0xa080
movq %rax, %r15
testl %r15d, %r15d
je 0xdf03
movl 0x4(%rbx), %eax
leal (%rax,%r15), %ecx
cmpl (%rbx), %ecx
jle 0xdedc
movq %rbx, %rdi
movl %r15d, %esi
callq 0xe338
movl 0x4(%rbx), %eax
movslq %eax, %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 0x1e154(%rip), %rdi     # 0x2c069
leaq 0x1fb29(%rip), %rsi     # 0x2da45
leaq 0x1fcb3(%rip), %rcx     # 0x2dbd6
movl $0x90, %edx
callq 0xa0b0
leaq 0x1ffa9(%rip), %rdi     # 0x2dedd
leaq 0x1fb0a(%rip), %rsi     # 0x2da45
leaq 0x1fc94(%rip), %rcx     # 0x2dbd6
movl $0x91, %edx
callq 0xa0b0
// File: /workspace/github_c_makefile_star2_O2/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 0xdfc0
testq %rsi, %rsi
je 0xdfd9
testl %edx, %edx
js 0xdff2
xorps %xmm0, %xmm0
movups %xmm0, (%rdi)
popq %rbp
jmp 0xe00f
leaq 0x1fa79(%rip), %rdi     # 0x2da40
leaq 0x1fa77(%rip), %rsi     # 0x2da45
leaq 0x1fb0c(%rip), %rcx     # 0x2dae1
pushq $0x30
jmp 0xe009
leaq 0x1faca(%rip), %rdi     # 0x2daaa
leaq 0x1fa5e(%rip), %rsi     # 0x2da45
leaq 0x1faf3(%rip), %rcx     # 0x2dae1
pushq $0x31
jmp 0xe009
leaq 0x1e544(%rip), %rdi     # 0x2c53d
leaq 0x1fa45(%rip), %rsi     # 0x2da45
leaq 0x1fada(%rip), %rcx     # 0x2dae1
pushq $0x32
popq %rdx
callq 0xa0b0
// File: /workspace/github_c_makefile_star2_O2/Ihsoh[P]ilang/string.c
// Function: rstr_append_with_raw
void rstr_append_with_raw(ResizableString *dst, const char *src, int len) {
	assert(dst);
	assert(src);
	assert(len >= 0);

	if (len == 0) {
		return;
	}

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

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

	_append_null_terminated_char(dst);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
testq %rdi, %rdi
je 0xe081
movq %rsi, %r15
testq %rsi, %rsi
je 0xe0a0
movl %edx, %r14d
testl %edx, %edx
js 0xe0bf
je 0xe076
movq %rdi, %rbx
movl 0x4(%rdi), %eax
leal (%rax,%r14), %ecx
cmpl (%rdi), %ecx
jle 0xe04f
movq %rbx, %rdi
movl %r14d, %esi
callq 0xe338
movl 0x4(%rbx), %eax
movslq %eax, %rdi
addq 0x8(%rbx), %rdi
movl %r14d, %edx
movq %r15, %rsi
callq 0xa110
movslq 0x4(%rbx), %rax
movslq %r14d, %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 0x1dfe1(%rip), %rdi     # 0x2c069
leaq 0x1f9b6(%rip), %rsi     # 0x2da45
leaq 0x1fb7c(%rip), %rcx     # 0x2dc12
movl $0xaa, %edx
callq 0xa0b0
leaq 0x1fe36(%rip), %rdi     # 0x2dedd
leaq 0x1f997(%rip), %rsi     # 0x2da45
leaq 0x1fb5d(%rip), %rcx     # 0x2dc12
movl $0xab, %edx
callq 0xa0b0
leaq 0x1e477(%rip), %rdi     # 0x2c53d
leaq 0x1f978(%rip), %rsi     # 0x2da45
leaq 0x1fb3e(%rip), %rcx     # 0x2dc12
movl $0xac, %edx
callq 0xa0b0
// File: /workspace/github_c_makefile_star2_O2/Ihsoh[P]ilang/string.c
// Function: rstr_init_with_rstr
void rstr_init_with_rstr(
	ResizableString *dst,
	ResizableString *src
) {
	assert(dst);
	assert(src);

	rstr_init(dst);
	rstr_append_with_rstr(dst, src);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
testq %rdi, %rdi
je 0xe0f8
testq %rsi, %rsi
je 0xe111
xorps %xmm0, %xmm0
movups %xmm0, (%rdi)
popq %rbp
jmp 0xe12e
leaq 0x1df6a(%rip), %rdi     # 0x2c069
leaq 0x1f93f(%rip), %rsi     # 0x2da45
leaq 0x1fa12(%rip), %rcx     # 0x2db1f
pushq $0x3c
jmp 0xe128
leaq 0x1fdc5(%rip), %rdi     # 0x2dedd
leaq 0x1f926(%rip), %rsi     # 0x2da45
leaq 0x1f9f9(%rip), %rcx     # 0x2db1f
pushq $0x3d
popq %rdx
callq 0xa0b0
// File: /workspace/github_c_makefile_star2_O2/Ihsoh[P]ilang/string.c
// Function: rstr_append_with_rstr
void rstr_append_with_rstr(ResizableString *dst, const ResizableString *src) {
	assert(dst);
	assert(src);

	if (src->len == 0) {
		return;
	}

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

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

	_append_null_terminated_char(dst);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
testq %rdi, %rdi
je 0xe197
movq %rsi, %r14
testq %rsi, %rsi
je 0xe1b6
movl 0x4(%r14), %esi
testl %esi, %esi
je 0xe192
movq %rdi, %rbx
movl 0x4(%rdi), %eax
leal (%rax,%rsi), %ecx
cmpl (%rdi), %ecx
jle 0xe166
movq %rbx, %rdi
callq 0xe338
movl 0x4(%rbx), %eax
movl 0x4(%r14), %esi
movslq %eax, %rdi
addq 0x8(%rbx), %rdi
movq 0x8(%r14), %rax
movslq %esi, %rdx
movq %rax, %rsi
callq 0xa110
movslq 0x4(%r14), %rax
movslq 0x4(%rbx), %rcx
addq %rax, %rcx
movl %ecx, 0x4(%rbx)
movq 0x8(%rbx), %rax
movb $0x0, (%rax,%rcx)
popq %rbx
popq %r14
popq %rbp
retq
leaq 0x1decb(%rip), %rdi     # 0x2c069
leaq 0x1f8a0(%rip), %rsi     # 0x2da45
leaq 0x1faa6(%rip), %rcx     # 0x2dc52
movl $0xbd, %edx
callq 0xa0b0
leaq 0x1fd20(%rip), %rdi     # 0x2dedd
leaq 0x1f881(%rip), %rsi     # 0x2da45
leaq 0x1fa87(%rip), %rcx     # 0x2dc52
movl $0xbe, %edx
callq 0xa0b0
// File: /workspace/github_c_makefile_star2_O2/Ihsoh[P]ilang/string.c
// Function: rstr_new_with_cstr
ResizableString * rstr_new_with_cstr(const char *cstr) {
	assert(cstr);

	ResizableString *rstr = rstr_new();
	rstr_append_with_cstr(rstr, cstr);
	return rstr;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
testq %rdi, %rdi
je 0xe222
movq %rdi, %rbx
callq 0xe1d5
movq %rax, %r14
movq %rax, %rdi
movq %rbx, %rsi
callq 0xde99
movq %r14, %rax
popq %rbx
popq %r14
popq %rbp
retq
leaq 0x1f881(%rip), %rdi     # 0x2daaa
leaq 0x1f815(%rip), %rsi     # 0x2da45
leaq 0x1f927(%rip), %rcx     # 0x2db5e
pushq $0x4d
popq %rdx
callq 0xa0b0