LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O0/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
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
cmpq $0x0, -0x8(%rbp)
je 0xe939
jmp 0xe958
leaq 0x3f221(%rip), %rdi     # 0x4db61
leaq 0x3ed84(%rip), %rsi     # 0x4d6cb
movl $0x107, %edx            # imm = 0x107
leaq 0x389d4(%rip), %rcx     # 0x47327
callq 0xa0b0
cmpq $0x0, -0x10(%rbp)
je 0xe961
jmp 0xe980
leaq 0x3c71f(%rip), %rdi     # 0x4b087
leaq 0x3ed5c(%rip), %rsi     # 0x4d6cb
movl $0x108, %edx            # imm = 0x108
leaq 0x389ac(%rip), %rcx     # 0x47327
callq 0xa0b0
movq -0x10(%rbp), %rax
cmpq $0x0, 0x50(%rax)
je 0xe999
movq -0x10(%rbp), %rax
movq 0x50(%rax), %rax
movq -0x10(%rbp), %rdi
callq *%rax
movq -0x10(%rbp), %rax
cmpq $0x0, 0x48(%rax)
je 0xe9b1
movq -0x10(%rbp), %rax
movq 0x48(%rax), %rdi
callq 0xa1b0
movq -0x10(%rbp), %rax
movq 0x38(%rax), %rax
movq %rax, -0x18(%rbp)
cmpq $0x0, -0x18(%rbp)
je 0xe9e7
movq -0x18(%rbp), %rax
movq %rax, -0x20(%rbp)
movq -0x18(%rbp), %rax
movq 0x10(%rax), %rax
movq %rax, -0x18(%rbp)
movq -0x8(%rbp), %rdi
movq -0x20(%rbp), %rsi
callq 0xec10
jmp 0xe9bd
movq -0x10(%rbp), %rdi
callq 0xa1b0
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
cmpq $0x0, -0x8(%rbp)
je 0xec29
jmp 0xec48
leaq 0x3ef31(%rip), %rdi     # 0x4db61
leaq 0x3ea94(%rip), %rsi     # 0x4d6cb
movl $0x233, %edx            # imm = 0x233
leaq 0x389a6(%rip), %rcx     # 0x475e9
callq 0xa0b0
cmpq $0x0, -0x10(%rbp)
je 0xec51
jmp 0xec70
leaq 0x389ca(%rip), %rdi     # 0x47622
leaq 0x3ea6c(%rip), %rsi     # 0x4d6cb
movl $0x234, %edx            # imm = 0x234
leaq 0x3897e(%rip), %rcx     # 0x475e9
callq 0xa0b0
movq -0x10(%rbp), %rax
movq 0x18(%rax), %rax
movq %rax, -0x18(%rbp)
cmpq $0x0, -0x18(%rbp)
je 0xecbb
movq -0x18(%rbp), %rax
movq 0x10(%rax), %rax
movq %rax, -0x20(%rbp)
movq -0x18(%rbp), %rax
cmpq $0x0, 0x20(%rax)
je 0xeca8
movq -0x18(%rbp), %rax
movq 0x20(%rax), %rax
movq -0x18(%rbp), %rdi
callq *%rax
movq -0x18(%rbp), %rdi
callq 0xa1b0
movq -0x20(%rbp), %rax
movq %rax, -0x18(%rbp)
jmp 0xec7c
movq -0x10(%rbp), %rax
cmpq $0x0, 0x20(%rax)
je 0xecd4
movq -0x10(%rbp), %rax
movq 0x20(%rax), %rax
movq -0x10(%rbp), %rdi
callq *%rax
movq -0x10(%rbp), %rdi
callq 0xa1b0
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
cmpq $0x0, -0x8(%rbp)
je 0xed0d
jmp 0xed2c
leaq 0x3ee4d(%rip), %rdi     # 0x4db61
leaq 0x3e9b0(%rip), %rsi     # 0x4d6cb
movl $0x121, %edx            # imm = 0x121
leaq 0x38638(%rip), %rcx     # 0x4735f
callq 0xa0b0
cmpq $0x0, -0x10(%rbp)
je 0xed35
jmp 0xed54
leaq 0x38670(%rip), %rdi     # 0x473ac
leaq 0x3e988(%rip), %rsi     # 0x4d6cb
movl $0x122, %edx            # imm = 0x122
leaq 0x38610(%rip), %rcx     # 0x4735f
callq 0xa0b0
movq -0x10(%rbp), %rax
cmpq $0x0, (%rax)
je 0xed60
jmp 0xed7f
leaq 0x38644(%rip), %rdi     # 0x473ab
leaq 0x3e95d(%rip), %rsi     # 0x4d6cb
movl $0x123, %edx            # imm = 0x123
leaq 0x385e5(%rip), %rcx     # 0x4735f
callq 0xa0b0
cmpq $0x0, -0x18(%rbp)
je 0xed88
jmp 0xeda7
leaq 0x3c2f8(%rip), %rdi     # 0x4b087
leaq 0x3e935(%rip), %rsi     # 0x4d6cb
movl $0x124, %edx            # imm = 0x124
leaq 0x385bd(%rip), %rcx     # 0x4735f
callq 0xa0b0
movq -0x10(%rbp), %rax
movq (%rax), %rax
movq 0x30(%rax), %rcx
movq -0x18(%rbp), %rax
movq %rcx, 0x30(%rax)
movq -0x10(%rbp), %rax
movq (%rax), %rax
movq 0x18(%rax), %rcx
movq -0x18(%rbp), %rax
movq %rcx, 0x18(%rax)
movq -0x10(%rbp), %rax
movq (%rax), %rax
movl 0x20(%rax), %ecx
movq -0x18(%rbp), %rax
movl %ecx, 0x20(%rax)
movq -0x10(%rbp), %rax
movq (%rax), %rax
movl 0x24(%rax), %ecx
movq -0x18(%rbp), %rax
movl %ecx, 0x24(%rax)
movq -0x18(%rbp), %rcx
movq -0x10(%rbp), %rax
movq (%rax), %rax
movq %rcx, 0x30(%rax)
movq -0x8(%rbp), %rdi
movq -0x18(%rbp), %rsi
movq -0x10(%rbp), %rax
movq (%rax), %rdx
callq 0xee30
movq -0x18(%rbp), %rcx
movq -0x10(%rbp), %rax
movq %rcx, (%rax)
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movq %rdx, -0x18(%rbp)
movq %rcx, -0x20(%rbp)
movq %r8, -0x28(%rbp)
cmpq $0x0, -0x8(%rbp)
je 0xf004
jmp 0xf023
leaq 0x3eb56(%rip), %rdi     # 0x4db61
leaq 0x3e6b9(%rip), %rsi     # 0x4d6cb
movl $0x15e, %edx            # imm = 0x15E
leaq 0x383eb(%rip), %rcx     # 0x47409
callq 0xa0b0
cmpl $0x0, -0xc(%rbp)
je 0xf02b
jmp 0xf04a
leaq 0x3842b(%rip), %rdi     # 0x4745d
leaq 0x3e692(%rip), %rsi     # 0x4d6cb
movl $0x15f, %edx            # imm = 0x15F
leaq 0x383c4(%rip), %rcx     # 0x47409
callq 0xa0b0
cmpq $0x0, -0x18(%rbp)
je 0xf053
jmp 0xf072
leaq 0x374e0(%rip), %rdi     # 0x4653a
leaq 0x3e66a(%rip), %rsi     # 0x4d6cb
movl $0x160, %edx            # imm = 0x160
leaq 0x3839c(%rip), %rcx     # 0x47409
callq 0xa0b0
cmpq $0x0, -0x20(%rbp)
jbe 0xf0a3
cmpq $0x0, -0x28(%rbp)
je 0xf082
jmp 0xf0a1
leaq 0x381ff(%rip), %rdi     # 0x47288
leaq 0x3e63b(%rip), %rsi     # 0x4d6cb
movl $0x162, %edx            # imm = 0x162
leaq 0x3836d(%rip), %rcx     # 0x47409
callq 0xa0b0
jmp 0xf0cd
cmpq $0x0, -0x28(%rbp)
jne 0xf0ac
jmp 0xf0cb
leaq 0x381e2(%rip), %rdi     # 0x47295
leaq 0x3e611(%rip), %rsi     # 0x4d6cb
movl $0x164, %edx            # imm = 0x164
leaq 0x38343(%rip), %rcx     # 0x47409
callq 0xa0b0
jmp 0xf0cd
movq -0x20(%rbp), %rdi
addq $0x30, %rdi
callq 0xa130
movq %rax, -0x30(%rbp)
cmpq $0x0, -0x30(%rbp)
jne 0xf0f3
movq -0x8(%rbp), %rax
movq 0x38(%rax), %rax
movq -0x8(%rbp), %rdi
callq *%rax
movl -0xc(%rbp), %ecx
movq -0x30(%rbp), %rax
movl %ecx, (%rax)
movq -0x18(%rbp), %rcx
movq -0x30(%rbp), %rax
movq %rcx, 0x8(%rax)
movq -0x30(%rbp), %rax
movq $0x0, 0x10(%rax)
movq -0x30(%rbp), %rax
movq $0x0, 0x18(%rax)
movq -0x30(%rbp), %rax
movq $0x0, 0x20(%rax)
movq -0x20(%rbp), %rcx
movq -0x30(%rbp), %rax
movq %rcx, 0x28(%rax)
movq -0x30(%rbp), %rdi
addq $0x30, %rdi
movq -0x28(%rbp), %rsi
movq -0x20(%rbp), %rdx
callq 0xa120
movq -0x30(%rbp), %rax
addq $0x30, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
cmpq $0x0, -0x8(%rbp)
je 0xf179
jmp 0xf198
leaq 0x3e9e1(%rip), %rdi     # 0x4db61
leaq 0x3e544(%rip), %rsi     # 0x4d6cb
movl $0x17d, %edx            # imm = 0x17D
leaq 0x382d4(%rip), %rcx     # 0x47467
callq 0xa0b0
cmpq $0x0, -0x10(%rbp)
je 0xf1a1
jmp 0xf1c0
leaq 0x373f3(%rip), %rdi     # 0x4659b
leaq 0x3e51c(%rip), %rsi     # 0x4d6cb
movl $0x17e, %edx            # imm = 0x17E
leaq 0x382ac(%rip), %rcx     # 0x47467
callq 0xa0b0
movq -0x10(%rbp), %rax
movq 0x28(%rax), %rax
addq $0x30, %rax
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rdi
callq 0xa130
movq %rax, -0x20(%rbp)
cmpq $0x0, -0x20(%rbp)
jne 0xf1f2
movq -0x8(%rbp), %rax
movq 0x38(%rax), %rax
movq -0x8(%rbp), %rdi
callq *%rax
movq -0x20(%rbp), %rdi
movq -0x10(%rbp), %rsi
movq -0x18(%rbp), %rdx
callq 0xa120
movq -0x20(%rbp), %rax
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/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
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
cmpq $0x0, -0x8(%rbp)
je 0xf22d
jmp 0xf24c
leaq 0x3e92d(%rip), %rdi     # 0x4db61
leaq 0x3e490(%rip), %rsi     # 0x4d6cb
movl $0x1ac, %edx            # imm = 0x1AC
leaq 0x38263(%rip), %rcx     # 0x474aa
callq 0xa0b0
cmpq $0x0, -0x10(%rbp)
je 0xf255
jmp 0xf274
leaq 0x3be2b(%rip), %rdi     # 0x4b087
leaq 0x3e468(%rip), %rsi     # 0x4d6cb
movl $0x1ad, %edx            # imm = 0x1AD
leaq 0x3823b(%rip), %rcx     # 0x474aa
callq 0xa0b0
cmpq $0x0, -0x18(%rbp)
je 0xf27d
jmp 0xf29c
leaq 0x38280(%rip), %rdi     # 0x47504
leaq 0x3e440(%rip), %rsi     # 0x4d6cb
movl $0x1ae, %edx            # imm = 0x1AE
leaq 0x38213(%rip), %rcx     # 0x474aa
callq 0xa0b0
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
movq -0x18(%rbp), %rax
movq 0x8(%rax), %rcx
xorl %edx, %edx
callq 0xf300
cmpq $0x0, %rax
je 0xf2d6
movq -0x8(%rbp), %rax
movq 0x50(%rax), %rax
movq -0x8(%rbp), %rdi
movq -0x18(%rbp), %rcx
movq 0x8(%rcx), %rsi
leaq 0x38237(%rip), %rdx     # 0x4750b
callq *%rax
movq -0x10(%rbp), %rax
movq 0x38(%rax), %rcx
movq -0x18(%rbp), %rax
movq %rcx, 0x10(%rax)
movq -0x18(%rbp), %rcx
movq -0x10(%rbp), %rax
movq %rcx, 0x38(%rax)
movq -0x18(%rbp), %rax
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/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
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movl %edx, -0x1c(%rbp)
movq %rcx, -0x28(%rbp)
cmpq $0x0, -0x10(%rbp)
je 0xf320
jmp 0xf33f
leaq 0x3e83a(%rip), %rdi     # 0x4db61
leaq 0x3e39d(%rip), %rsi     # 0x4d6cb
movl $0x21f, %edx            # imm = 0x21F
leaq 0x38250(%rip), %rcx     # 0x4758a
callq 0xa0b0
cmpq $0x0, -0x18(%rbp)
je 0xf348
jmp 0xf367
leaq 0x3bd38(%rip), %rdi     # 0x4b087
leaq 0x3e375(%rip), %rsi     # 0x4d6cb
movl $0x220, %edx            # imm = 0x220
leaq 0x38228(%rip), %rcx     # 0x4758a
callq 0xa0b0
cmpq $0x0, -0x28(%rbp)
je 0xf370
jmp 0xf38f
leaq 0x371c3(%rip), %rdi     # 0x4653a
leaq 0x3e34d(%rip), %rsi     # 0x4d6cb
movl $0x221, %edx            # imm = 0x221
leaq 0x38200(%rip), %rcx     # 0x4758a
callq 0xa0b0
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rax
movq 0x38(%rax), %rsi
movl -0x1c(%rbp), %edx
movq -0x28(%rbp), %rcx
callq 0xf6e0
movq %rax, -0x30(%rbp)
cmpq $0x0, -0x30(%rbp)
je 0xf3bc
movq -0x30(%rbp), %rax
movq %rax, -0x8(%rbp)
jmp 0xf3ed
movq -0x18(%rbp), %rax
cmpq $0x0, 0x30(%rax)
je 0xf3e5
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rax
movq 0x30(%rax), %rsi
movl -0x1c(%rbp), %edx
movq -0x28(%rbp), %rcx
callq 0xf300
movq %rax, -0x8(%rbp)
jmp 0xf3ed
movq $0x0, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x30, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl %edx, -0x14(%rbp)
movq %rcx, -0x20(%rbp)
movq %r8, -0x28(%rbp)
movq %r9, -0x30(%rbp)
cmpq $0x0, -0x8(%rbp)
je 0xf428
jmp 0xf447
leaq 0x3e732(%rip), %rdi     # 0x4db61
leaq 0x3e295(%rip), %rsi     # 0x4d6cb
movl $0x1c7, %edx            # imm = 0x1C7
leaq 0x380db(%rip), %rcx     # 0x4751d
callq 0xa0b0
cmpq $0x0, -0x10(%rbp)
je 0xf450
jmp 0xf46f
leaq 0x3bc30(%rip), %rdi     # 0x4b087
leaq 0x3e26d(%rip), %rsi     # 0x4d6cb
movl $0x1c8, %edx            # imm = 0x1C8
leaq 0x380b3(%rip), %rcx     # 0x4751d
callq 0xa0b0
cmpl $0x0, -0x14(%rbp)
je 0xf477
jmp 0xf496
leaq 0x37fdf(%rip), %rdi     # 0x4745d
leaq 0x3e246(%rip), %rsi     # 0x4d6cb
movl $0x1c9, %edx            # imm = 0x1C9
leaq 0x3808c(%rip), %rcx     # 0x4751d
callq 0xa0b0
cmpq $0x0, -0x20(%rbp)
je 0xf49f
jmp 0xf4be
leaq 0x37094(%rip), %rdi     # 0x4653a
leaq 0x3e21e(%rip), %rsi     # 0x4d6cb
movl $0x1ca, %edx            # imm = 0x1CA
leaq 0x38064(%rip), %rcx     # 0x4751d
callq 0xa0b0
cmpq $0x0, -0x28(%rbp)
jbe 0xf4ef
cmpq $0x0, -0x30(%rbp)
je 0xf4ce
jmp 0xf4ed
leaq 0x37db3(%rip), %rdi     # 0x47288
leaq 0x3e1ef(%rip), %rsi     # 0x4d6cb
movl $0x1cc, %edx            # imm = 0x1CC
leaq 0x38035(%rip), %rcx     # 0x4751d
callq 0xa0b0
jmp 0xf519
cmpq $0x0, -0x30(%rbp)
jne 0xf4f8
jmp 0xf517
leaq 0x37d96(%rip), %rdi     # 0x47295
leaq 0x3e1c5(%rip), %rsi     # 0x4d6cb
movl $0x1ce, %edx            # imm = 0x1CE
leaq 0x3800b(%rip), %rcx     # 0x4751d
callq 0xa0b0
jmp 0xf519
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
movq -0x20(%rbp), %rcx
xorl %edx, %edx
callq 0xf300
cmpq $0x0, %rax
je 0xf54b
movq -0x8(%rbp), %rax
movq 0x50(%rax), %rax
movq -0x8(%rbp), %rdi
movq -0x20(%rbp), %rsi
leaq 0x37fc2(%rip), %rdx     # 0x4750b
callq *%rax
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
addq $0x38, %rsi
movl -0x14(%rbp), %edx
movq -0x20(%rbp), %rcx
movq -0x28(%rbp), %r8
movq -0x30(%rbp), %r9
callq 0xf580
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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
subq $0x40, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl %edx, -0x14(%rbp)
movq %rcx, -0x20(%rbp)
movq %r8, -0x28(%rbp)
movq %r9, -0x30(%rbp)
cmpq $0x0, -0x8(%rbp)
je 0xf5a8
jmp 0xf5c7
leaq 0x3e5b2(%rip), %rdi     # 0x4db61
leaq 0x3e115(%rip), %rsi     # 0x4d6cb
movl $0x194, %edx            # imm = 0x194
leaq 0x3844a(%rip), %rcx     # 0x47a0c
callq 0xa0b0
cmpq $0x0, -0x10(%rbp)
je 0xf5d0
jmp 0xf5ef
leaq 0x3849b(%rip), %rdi     # 0x47a72
leaq 0x3e0ed(%rip), %rsi     # 0x4d6cb
movl $0x195, %edx            # imm = 0x195
leaq 0x38422(%rip), %rcx     # 0x47a0c
callq 0xa0b0
cmpl $0x0, -0x14(%rbp)
je 0xf5f7
jmp 0xf616
leaq 0x37e5f(%rip), %rdi     # 0x4745d
leaq 0x3e0c6(%rip), %rsi     # 0x4d6cb
movl $0x196, %edx            # imm = 0x196
leaq 0x383fb(%rip), %rcx     # 0x47a0c
callq 0xa0b0
cmpq $0x0, -0x20(%rbp)
je 0xf61f
jmp 0xf63e
leaq 0x36f14(%rip), %rdi     # 0x4653a
leaq 0x3e09e(%rip), %rsi     # 0x4d6cb
movl $0x197, %edx            # imm = 0x197
leaq 0x383d3(%rip), %rcx     # 0x47a0c
callq 0xa0b0
cmpq $0x0, -0x28(%rbp)
jbe 0xf66f
cmpq $0x0, -0x30(%rbp)
je 0xf64e
jmp 0xf66d
leaq 0x37c33(%rip), %rdi     # 0x47288
leaq 0x3e06f(%rip), %rsi     # 0x4d6cb
movl $0x199, %edx            # imm = 0x199
leaq 0x383a4(%rip), %rcx     # 0x47a0c
callq 0xa0b0
jmp 0xf699
cmpq $0x0, -0x30(%rbp)
jne 0xf678
jmp 0xf697
leaq 0x37c16(%rip), %rdi     # 0x47295
leaq 0x3e045(%rip), %rsi     # 0x4d6cb
movl $0x19b, %edx            # imm = 0x19B
leaq 0x3837a(%rip), %rcx     # 0x47a0c
callq 0xa0b0
jmp 0xf699
movq -0x8(%rbp), %rdi
movl -0x14(%rbp), %esi
movq -0x20(%rbp), %rdx
movq -0x28(%rbp), %rcx
movq -0x30(%rbp), %r8
callq 0xefe0
movq %rax, -0x38(%rbp)
movq -0x10(%rbp), %rax
movq (%rax), %rcx
movq -0x38(%rbp), %rax
movq %rcx, 0x10(%rax)
movq -0x38(%rbp), %rcx
movq -0x10(%rbp), %rax
movq %rcx, (%rax)
movq -0x38(%rbp), %rax
addq $0x40, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/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
subq $0x40, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movl %edx, -0x1c(%rbp)
movq %rcx, -0x28(%rbp)
cmpq $0x0, -0x10(%rbp)
je 0xf700
jmp 0xf71f
leaq 0x3e45a(%rip), %rdi     # 0x4db61
leaq 0x3dfbd(%rip), %rsi     # 0x4d6cb
movl $0x1e2, %edx            # imm = 0x1E2
leaq 0x3835f(%rip), %rcx     # 0x47a79
callq 0xa0b0
cmpq $0x0, -0x28(%rbp)
je 0xf728
jmp 0xf747
leaq 0x36e0b(%rip), %rdi     # 0x4653a
leaq 0x3df95(%rip), %rsi     # 0x4d6cb
movl $0x1e3, %edx            # imm = 0x1E3
leaq 0x38337(%rip), %rcx     # 0x47a79
callq 0xa0b0
movq -0x18(%rbp), %rax
movq %rax, -0x30(%rbp)
cmpq $0x0, -0x30(%rbp)
je 0xf79e
movq -0x30(%rbp), %rax
movq 0x8(%rax), %rax
movq %rax, -0x38(%rbp)
movq -0x28(%rbp), %rdi
movq -0x38(%rbp), %rsi
callq 0xc410
testb $0x1, %al
jne 0xf775
jmp 0xf790
cmpl $0x0, -0x1c(%rbp)
je 0xf786
movl -0x1c(%rbp), %eax
movq -0x30(%rbp), %rcx
cmpl (%rcx), %eax
jne 0xf790
movq -0x30(%rbp), %rax
movq %rax, -0x8(%rbp)
jmp 0xf7a6
movq -0x30(%rbp), %rax
movq 0x10(%rax), %rax
movq %rax, -0x30(%rbp)
jmp 0xf74f
movq $0x0, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x40, %rsp
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O0/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
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
cmpq $0x0, -0x8(%rbp)
je 0xf7cd
jmp 0xf7ec
leaq 0x3e38d(%rip), %rdi     # 0x4db61
leaq 0x3def0(%rip), %rsi     # 0x4d6cb
movl $0x24b, %edx            # imm = 0x24B
leaq 0x37e42(%rip), %rcx     # 0x47629
callq 0xa0b0
cmpq $0x0, -0x10(%rbp)
je 0xf7f5
jmp 0xf814
leaq 0x37e26(%rip), %rdi     # 0x47622
leaq 0x3dec8(%rip), %rsi     # 0x4d6cb
movl $0x24c, %edx            # imm = 0x24C
leaq 0x37e1a(%rip), %rcx     # 0x47629
callq 0xa0b0
cmpq $0x0, -0x18(%rbp)
je 0xf81d
jmp 0xf83c
leaq 0x37ce0(%rip), %rdi     # 0x47504
leaq 0x3dea0(%rip), %rsi     # 0x4d6cb
movl $0x24d, %edx            # imm = 0x24D
leaq 0x37df2(%rip), %rcx     # 0x47629
callq 0xa0b0
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rax
movq 0x18(%rax), %rsi
movq -0x18(%rbp), %rax
movq 0x8(%rax), %rcx
xorl %edx, %edx
callq 0xf6e0
cmpq $0x0, %rax
je 0xf87a
movq -0x8(%rbp), %rax
movq 0x50(%rax), %rax
movq -0x8(%rbp), %rdi
movq -0x18(%rbp), %rcx
movq 0x8(%rcx), %rsi
leaq 0x37c93(%rip), %rdx     # 0x4750b
callq *%rax
movq -0x10(%rbp), %rax
movq 0x18(%rax), %rcx
movq -0x18(%rbp), %rax
movq %rcx, 0x10(%rax)
movq -0x18(%rbp), %rcx
movq -0x10(%rbp), %rax
movq %rcx, 0x18(%rax)
movq -0x18(%rbp), %rax
addq $0x20, %rsp
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O0/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
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl %edx, -0x14(%rbp)
movq %rcx, -0x20(%rbp)
movq %r8, -0x28(%rbp)
movq %r9, -0x30(%rbp)
cmpq $0x0, -0x8(%rbp)
je 0xf8c8
jmp 0xf8e7
leaq 0x3e292(%rip), %rdi     # 0x4db61
leaq 0x3ddf5(%rip), %rsi     # 0x4d6cb
movl $0x266, %edx            # imm = 0x266
leaq 0x37da2(%rip), %rcx     # 0x47684
callq 0xa0b0
cmpq $0x0, -0x10(%rbp)
je 0xf8f0
jmp 0xf90f
leaq 0x37d2b(%rip), %rdi     # 0x47622
leaq 0x3ddcd(%rip), %rsi     # 0x4d6cb
movl $0x267, %edx            # imm = 0x267
leaq 0x37d7a(%rip), %rcx     # 0x47684
callq 0xa0b0
cmpl $0x0, -0x14(%rbp)
je 0xf917
jmp 0xf936
leaq 0x37b3f(%rip), %rdi     # 0x4745d
leaq 0x3dda6(%rip), %rsi     # 0x4d6cb
movl $0x268, %edx            # imm = 0x268
leaq 0x37d53(%rip), %rcx     # 0x47684
callq 0xa0b0
cmpq $0x0, -0x20(%rbp)
je 0xf93f
jmp 0xf95e
leaq 0x36bf4(%rip), %rdi     # 0x4653a
leaq 0x3dd7e(%rip), %rsi     # 0x4d6cb
movl $0x269, %edx            # imm = 0x269
leaq 0x37d2b(%rip), %rcx     # 0x47684
callq 0xa0b0
cmpq $0x0, -0x28(%rbp)
jbe 0xf98f
cmpq $0x0, -0x30(%rbp)
je 0xf96e
jmp 0xf98d
leaq 0x37913(%rip), %rdi     # 0x47288
leaq 0x3dd4f(%rip), %rsi     # 0x4d6cb
movl $0x26b, %edx            # imm = 0x26B
leaq 0x37cfc(%rip), %rcx     # 0x47684
callq 0xa0b0
jmp 0xf9b9
cmpq $0x0, -0x30(%rbp)
jne 0xf998
jmp 0xf9b7
leaq 0x378f6(%rip), %rdi     # 0x47295
leaq 0x3dd25(%rip), %rsi     # 0x4d6cb
movl $0x26d, %edx            # imm = 0x26D
leaq 0x37cd2(%rip), %rcx     # 0x47684
callq 0xa0b0
jmp 0xf9b9
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rax
movq 0x18(%rax), %rsi
movq -0x20(%rbp), %rcx
xorl %edx, %edx
callq 0xf6e0
cmpq $0x0, %rax
je 0xf9ef
movq -0x8(%rbp), %rax
movq 0x50(%rax), %rax
movq -0x8(%rbp), %rdi
movq -0x20(%rbp), %rsi
leaq 0x37b1e(%rip), %rdx     # 0x4750b
callq *%rax
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
addq $0x18, %rsi
movl -0x14(%rbp), %edx
movq -0x20(%rbp), %rcx
movq -0x28(%rbp), %r8
movq -0x30(%rbp), %r9
callq 0xf580
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl %edx, -0x14(%rbp)
movq %rcx, -0x20(%rbp)
cmpq $0x0, -0x8(%rbp)
je 0xfa40
jmp 0xfa5f
leaq 0x3e11a(%rip), %rdi     # 0x4db61
leaq 0x3dc7d(%rip), %rsi     # 0x4d6cb
movl $0x281, %edx            # imm = 0x281
leaq 0x37c98(%rip), %rcx     # 0x476f2
callq 0xa0b0
cmpq $0x0, -0x10(%rbp)
je 0xfa68
jmp 0xfa87
leaq 0x37bb3(%rip), %rdi     # 0x47622
leaq 0x3dc55(%rip), %rsi     # 0x4d6cb
movl $0x282, %edx            # imm = 0x282
leaq 0x37c70(%rip), %rcx     # 0x476f2
callq 0xa0b0
cmpq $0x0, -0x20(%rbp)
je 0xfa90
jmp 0xfaaf
leaq 0x36aa3(%rip), %rdi     # 0x4653a
leaq 0x3dc2d(%rip), %rsi     # 0x4d6cb
movl $0x283, %edx            # imm = 0x283
leaq 0x37c48(%rip), %rcx     # 0x476f2
callq 0xa0b0
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rax
movq 0x18(%rax), %rsi
movl -0x14(%rbp), %edx
movq -0x20(%rbp), %rcx
callq 0xf6e0
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/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
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl %edx, -0x14(%rbp)
movq %rcx, -0x20(%rbp)
cmpq $0x0, -0x8(%rbp)
je 0xfaf0
jmp 0xfb0f
leaq 0x3e06a(%rip), %rdi     # 0x4db61
leaq 0x3dbcd(%rip), %rsi     # 0x4d6cb
movl $0x28e, %edx            # imm = 0x28E
leaq 0x37c48(%rip), %rcx     # 0x47752
callq 0xa0b0
cmpq $0x0, -0x10(%rbp)
je 0xfb18
jmp 0xfb37
leaq 0x37b03(%rip), %rdi     # 0x47622
leaq 0x3dba5(%rip), %rsi     # 0x4d6cb
movl $0x28f, %edx            # imm = 0x28F
leaq 0x37c20(%rip), %rcx     # 0x47752
callq 0xa0b0
cmpq $0x0, -0x20(%rbp)
je 0xfb40
jmp 0xfb5f
leaq 0x369f3(%rip), %rdi     # 0x4653a
leaq 0x3db7d(%rip), %rsi     # 0x4d6cb
movl $0x290, %edx            # imm = 0x290
leaq 0x37bf8(%rip), %rcx     # 0x47752
callq 0xa0b0
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rax
movq 0x18(%rax), %rsi
movl -0x14(%rbp), %edx
movq -0x20(%rbp), %rcx
callq 0xfb80
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/Ihsoh[P]ilang/parser.c
// Function: parser_get_symbol_index
static int _parser_get_symbol_index(
	ParserContext *ctx,
	ParserSymbol *symtbl,
	int type,
	LexerToken *token
) {
	assert(ctx);
	assert(token);

	// TODO: 因为符号是从链表的前方插入。。。这就导致符号的顺序是反过来的，
	//		最尾部的符号才是第一个符号。。。
	int size = 0;
	ParserSymbol *symbol = symtbl;
	while (symbol) {
		symbol = symbol->next;
		size++;
	}

	int index = 0;

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

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

		symbol = symbol->next;
		index++;
	}

	assert(0);
	return -1;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl %edx, -0x14(%rbp)
movq %rcx, -0x20(%rbp)
cmpq $0x0, -0x8(%rbp)
je 0xfba0
jmp 0xfbbf
leaq 0x3dfba(%rip), %rdi     # 0x4db61
leaq 0x3db1d(%rip), %rsi     # 0x4d6cb
movl $0x1fa, %edx            # imm = 0x1FA
leaq 0x37f14(%rip), %rcx     # 0x47ace
callq 0xa0b0
cmpq $0x0, -0x20(%rbp)
je 0xfbc8
jmp 0xfbe7
leaq 0x3696b(%rip), %rdi     # 0x4653a
leaq 0x3daf5(%rip), %rsi     # 0x4d6cb
movl $0x1fb, %edx            # imm = 0x1FB
leaq 0x37eec(%rip), %rcx     # 0x47ace
callq 0xa0b0
movl $0x0, -0x24(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x30(%rbp)
cmpq $0x0, -0x30(%rbp)
je 0xfc14
movq -0x30(%rbp), %rax
movq 0x10(%rax), %rax
movq %rax, -0x30(%rbp)
movl -0x24(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x24(%rbp)
jmp 0xfbf6
movl $0x0, -0x34(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x30(%rbp)
cmpq $0x0, -0x30(%rbp)
je 0xfc80
movq -0x30(%rbp), %rax
movq 0x8(%rax), %rax
movq %rax, -0x40(%rbp)
movq -0x20(%rbp), %rdi
movq -0x40(%rbp), %rsi
callq 0xc410
testb $0x1, %al
jne 0xfc49
jmp 0xfc69
cmpl $0x0, -0x14(%rbp)
je 0xfc5a
movl -0x14(%rbp), %eax
movq -0x30(%rbp), %rcx
cmpl (%rcx), %eax
jne 0xfc69
movl -0x24(%rbp), %eax
subl -0x34(%rbp), %eax
subl $0x1, %eax
addq $0x40, %rsp
popq %rbp
retq
movq -0x30(%rbp), %rax
movq 0x10(%rax), %rax
movq %rax, -0x30(%rbp)
movl -0x34(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x34(%rbp)
jmp 0xfc23
leaq 0x377de(%rip), %rdi     # 0x47465
leaq 0x3da3d(%rip), %rsi     # 0x4d6cb
movl $0x215, %edx            # imm = 0x215
leaq 0x37e34(%rip), %rcx     # 0x47ace
callq 0xa0b0
nop
// File: /workspace/github_c_makefile_star2_O0/Ihsoh[P]ilang/string.c
// Function: rstr_init
void rstr_init(ResizableString *rstr) {
	assert(rstr);

	rstr->size = 0;
	rstr->len = 0;
	rstr->buffer = NULL;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
cmpq $0x0, -0x8(%rbp)
je 0xfcb5
jmp 0xfcd4
leaq 0x37e63(%rip), %rdi     # 0x47b1f
leaq 0x37e61(%rip), %rsi     # 0x47b24
movl $0xf, %edx
leaq 0x37e5e(%rip), %rcx     # 0x47b2d
callq 0xa0b0
movq -0x8(%rbp), %rax
movl $0x0, (%rax)
movq -0x8(%rbp), %rax
movl $0x0, 0x4(%rax)
movq -0x8(%rbp), %rax
movq $0x0, 0x8(%rax)
addq $0x10, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
cmpq $0x0, -0x8(%rbp)
je 0xfd19
jmp 0xfd38
leaq 0x37dff(%rip), %rdi     # 0x47b1f
leaq 0x37dfd(%rip), %rsi     # 0x47b24
movl $0x1a, %edx
leaq 0x37e1c(%rip), %rcx     # 0x47b4f
callq 0xa0b0
cmpq $0x0, -0x10(%rbp)
je 0xfd41
jmp 0xfd60
leaq 0x37e41(%rip), %rdi     # 0x47b89
leaq 0x37dd5(%rip), %rsi     # 0x47b24
movl $0x1b, %edx
leaq 0x37df4(%rip), %rcx     # 0x47b4f
callq 0xa0b0
movq -0x8(%rbp), %rdi
callq 0xfca0
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
callq 0xfd80
addq $0x10, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/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
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
cmpq $0x0, -0x8(%rbp)
je 0xfd99
jmp 0xfdb8
leaq 0x362c9(%rip), %rdi     # 0x46069
leaq 0x37d7d(%rip), %rsi     # 0x47b24
movl $0x90, %edx
leaq 0x37f02(%rip), %rcx     # 0x47cb5
callq 0xa0b0
cmpq $0x0, -0x10(%rbp)
je 0xfdc1
jmp 0xfde0
leaq 0x381f4(%rip), %rdi     # 0x47fbc
leaq 0x37d55(%rip), %rsi     # 0x47b24
movl $0x91, %edx
leaq 0x37eda(%rip), %rcx     # 0x47cb5
callq 0xa0b0
movq -0x10(%rbp), %rdi
callq 0xa080
movl %eax, -0x14(%rbp)
cmpl $0x0, -0x14(%rbp)
jne 0xfdf4
jmp 0xfe48
movq -0x8(%rbp), %rax
movl 0x4(%rax), %eax
addl -0x14(%rbp), %eax
movq -0x8(%rbp), %rcx
cmpl (%rcx), %eax
jle 0xfe12
movq -0x8(%rbp), %rdi
movl -0x14(%rbp), %esi
callq 0x103f0
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rdi
movq -0x8(%rbp), %rax
movslq 0x4(%rax), %rax
addq %rax, %rdi
movq -0x10(%rbp), %rsi
movslq -0x14(%rbp), %rdx
callq 0xa120
movl -0x14(%rbp), %ecx
movq -0x8(%rbp), %rax
addl 0x4(%rax), %ecx
movl %ecx, 0x4(%rax)
movq -0x8(%rbp), %rdi
callq 0x104c0
addq $0x20, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/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
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl %edx, -0x14(%rbp)
cmpq $0x0, -0x8(%rbp)
je 0xff0c
jmp 0xff2b
leaq 0x37c0c(%rip), %rdi     # 0x47b1f
leaq 0x37c0a(%rip), %rsi     # 0x47b24
movl $0x30, %edx
leaq 0x37c9a(%rip), %rcx     # 0x47bc0
callq 0xa0b0
cmpq $0x0, -0x10(%rbp)
je 0xff34
jmp 0xff53
leaq 0x37c4e(%rip), %rdi     # 0x47b89
leaq 0x37be2(%rip), %rsi     # 0x47b24
movl $0x31, %edx
leaq 0x37c72(%rip), %rcx     # 0x47bc0
callq 0xa0b0
cmpl $0x0, -0x14(%rbp)
jl 0xff5b
jmp 0xff7a
leaq 0x36640(%rip), %rdi     # 0x465a2
leaq 0x37bbb(%rip), %rsi     # 0x47b24
movl $0x32, %edx
leaq 0x37c4b(%rip), %rcx     # 0x47bc0
callq 0xa0b0
movq -0x8(%rbp), %rdi
callq 0xfca0
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
movl -0x14(%rbp), %edx
callq 0xffa0
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/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
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl %edx, -0x14(%rbp)
cmpq $0x0, -0x8(%rbp)
je 0xffbc
jmp 0xffdb
leaq 0x360a6(%rip), %rdi     # 0x46069
leaq 0x37b5a(%rip), %rsi     # 0x47b24
movl $0xaa, %edx
leaq 0x37d1b(%rip), %rcx     # 0x47cf1
callq 0xa0b0
cmpq $0x0, -0x10(%rbp)
je 0xffe4
jmp 0x10003
leaq 0x37fd1(%rip), %rdi     # 0x47fbc
leaq 0x37b32(%rip), %rsi     # 0x47b24
movl $0xab, %edx
leaq 0x37cf3(%rip), %rcx     # 0x47cf1
callq 0xa0b0
cmpl $0x0, -0x14(%rbp)
jl 0x1000b
jmp 0x1002a
leaq 0x36590(%rip), %rdi     # 0x465a2
leaq 0x37b0b(%rip), %rsi     # 0x47b24
movl $0xac, %edx
leaq 0x37ccc(%rip), %rcx     # 0x47cf1
callq 0xa0b0
cmpl $0x0, -0x14(%rbp)
jne 0x10032
jmp 0x10086
movq -0x8(%rbp), %rax
movl 0x4(%rax), %eax
addl -0x14(%rbp), %eax
movq -0x8(%rbp), %rcx
cmpl (%rcx), %eax
jle 0x10050
movq -0x8(%rbp), %rdi
movl -0x14(%rbp), %esi
callq 0x103f0
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rdi
movq -0x8(%rbp), %rax
movslq 0x4(%rax), %rax
addq %rax, %rdi
movq -0x10(%rbp), %rsi
movslq -0x14(%rbp), %rdx
callq 0xa120
movl -0x14(%rbp), %ecx
movq -0x8(%rbp), %rax
addl 0x4(%rax), %ecx
movl %ecx, 0x4(%rax)
movq -0x8(%rbp), %rdi
callq 0x104c0
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/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
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
cmpq $0x0, -0x8(%rbp)
je 0x100a9
jmp 0x100c8
leaq 0x35fb9(%rip), %rdi     # 0x46069
leaq 0x37a6d(%rip), %rsi     # 0x47b24
movl $0x3c, %edx
leaq 0x37b3b(%rip), %rcx     # 0x47bfe
callq 0xa0b0
cmpq $0x0, -0x10(%rbp)
je 0x100d1
jmp 0x100f0
leaq 0x37ee4(%rip), %rdi     # 0x47fbc
leaq 0x37a45(%rip), %rsi     # 0x47b24
movl $0x3d, %edx
leaq 0x37b13(%rip), %rcx     # 0x47bfe
callq 0xa0b0
movq -0x8(%rbp), %rdi
callq 0xfca0
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
callq 0x10110
addq $0x10, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/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
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
cmpq $0x0, -0x8(%rbp)
je 0x10129
jmp 0x10148
leaq 0x35f39(%rip), %rdi     # 0x46069
leaq 0x379ed(%rip), %rsi     # 0x47b24
movl $0xbd, %edx
leaq 0x37bee(%rip), %rcx     # 0x47d31
callq 0xa0b0
cmpq $0x0, -0x10(%rbp)
je 0x10151
jmp 0x10170
leaq 0x37e64(%rip), %rdi     # 0x47fbc
leaq 0x379c5(%rip), %rsi     # 0x47b24
movl $0xbe, %edx
leaq 0x37bc6(%rip), %rcx     # 0x47d31
callq 0xa0b0
movq -0x10(%rbp), %rax
cmpl $0x0, 0x4(%rax)
jne 0x1017c
jmp 0x101e4
movq -0x8(%rbp), %rax
movl 0x4(%rax), %eax
movq -0x10(%rbp), %rcx
addl 0x4(%rcx), %eax
movq -0x8(%rbp), %rcx
cmpl (%rcx), %eax
jle 0x101a2
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rax
movl 0x4(%rax), %esi
callq 0x103f0
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rdi
movq -0x8(%rbp), %rax
movslq 0x4(%rax), %rax
addq %rax, %rdi
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rsi
movq -0x10(%rbp), %rax
movslq 0x4(%rax), %rdx
callq 0xa120
movq -0x10(%rbp), %rax
movl 0x4(%rax), %ecx
movq -0x8(%rbp), %rax
addl 0x4(%rax), %ecx
movl %ecx, 0x4(%rax)
movq -0x8(%rbp), %rdi
callq 0x104c0
addq $0x10, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
cmpq $0x0, -0x8(%rbp)
je 0x10235
jmp 0x10254
leaq 0x3794d(%rip), %rdi     # 0x47b89
leaq 0x378e1(%rip), %rsi     # 0x47b24
movl $0x4d, %edx
leaq 0x379ee(%rip), %rcx     # 0x47c3d
callq 0xa0b0
callq 0x101f0
movq %rax, -0x10(%rbp)
movq -0x10(%rbp), %rdi
movq -0x8(%rbp), %rsi
callq 0xfd80
movq -0x10(%rbp), %rax
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/Ihsoh[P]ilang/string.c
// Function: rstr_free
void rstr_free(ResizableString *rstr) {
	assert(rstr);

	if (rstr->buffer != NULL) {
		free(rstr->buffer);
	}
	rstr->size = 0;
	rstr->len = 0;
	rstr->buffer = NULL;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
cmpq $0x0, -0x8(%rbp)
je 0x10335
jmp 0x10354
leaq 0x377e3(%rip), %rdi     # 0x47b1f
leaq 0x377e1(%rip), %rsi     # 0x47b24
movl $0x6d, %edx
leaq 0x37920(%rip), %rcx     # 0x47c6f
callq 0xa0b0
movq -0x8(%rbp), %rax
cmpq $0x0, 0x8(%rax)
je 0x1036c
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rdi
callq 0xa1b0
movq -0x8(%rbp), %rax
movl $0x0, (%rax)
movq -0x8(%rbp), %rax
movl $0x0, 0x4(%rax)
movq -0x8(%rbp), %rax
movq $0x0, 0x8(%rax)
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/Ihsoh[P]ilang/string.c
// Function: inc_buffer_size
static void _inc_buffer_size(ResizableString *rstr, int inc_size) {
	assert(rstr);
	assert(inc_size > 0);

	rstr->size = rstr->size + 2 * inc_size;
	if (rstr->buffer == NULL) {
		rstr->buffer = (char *)malloc(rstr->size + 1);
	} else {
		rstr->buffer = (char *)realloc(rstr->buffer, rstr->size + 1);
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
cmpq $0x0, -0x8(%rbp)
je 0x10408
jmp 0x10427
leaq 0x37710(%rip), %rdi     # 0x47b1f
leaq 0x3770e(%rip), %rsi     # 0x47b24
movl $0x80, %edx
leaq 0x380d4(%rip), %rcx     # 0x484f6
callq 0xa0b0
cmpl $0x0, -0xc(%rbp)
jle 0x1042f
jmp 0x1044e
leaq 0x35fc1(%rip), %rdi     # 0x463f7
leaq 0x376e7(%rip), %rsi     # 0x47b24
movl $0x81, %edx
leaq 0x380ad(%rip), %rcx     # 0x484f6
callq 0xa0b0
movq -0x8(%rbp), %rax
movl (%rax), %ecx
movl -0xc(%rbp), %eax
shll %eax
addl %eax, %ecx
movq -0x8(%rbp), %rax
movl %ecx, (%rax)
movq -0x8(%rbp), %rax
cmpq $0x0, 0x8(%rax)
jne 0x1048a
movq -0x8(%rbp), %rax
movl (%rax), %eax
addl $0x1, %eax
movslq %eax, %rdi
callq 0xa130
movq %rax, %rcx
movq -0x8(%rbp), %rax
movq %rcx, 0x8(%rax)
jmp 0x104ae
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rdi
movq -0x8(%rbp), %rax
movl (%rax), %eax
addl $0x1, %eax
movslq %eax, %rsi
callq 0xa140
movq %rax, %rcx
movq -0x8(%rbp), %rax
movq %rcx, 0x8(%rax)
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/Ihsoh[P]ilang/string.c
// Function: rstr_appendf
void rstr_appendf(ResizableString *dst, const char *fmt, ...) {
	char buffer[64 * 1024];

	va_list argptr;
    va_start(argptr, fmt);

	vsnprintf(buffer, sizeof(buffer), fmt, argptr);
	rstr_append_with_cstr(dst, buffer);

	va_end(argptr);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x100f0, %rsp          # imm = 0x100F0
testb %al, %al
je 0x10527
movaps %xmm0, -0x100b0(%rbp)
movaps %xmm1, -0x100a0(%rbp)
movaps %xmm2, -0x10090(%rbp)
movaps %xmm3, -0x10080(%rbp)
movaps %xmm4, -0x10070(%rbp)
movaps %xmm5, -0x10060(%rbp)
movaps %xmm6, -0x10050(%rbp)
movaps %xmm7, -0x10040(%rbp)
movq %r9, -0x100b8(%rbp)
movq %r8, -0x100c0(%rbp)
movq %rcx, -0x100c8(%rbp)
movq %rdx, -0x100d0(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
leaq -0x100e0(%rbp), %rax
movq %rax, -0x10020(%rbp)
leaq 0x10(%rbp), %rax
movq %rax, -0x10028(%rbp)
movl $0x30, -0x1002c(%rbp)
movl $0x10, -0x10030(%rbp)
movq -0x10(%rbp), %rdx
leaq -0x10010(%rbp), %rdi
movq %rdi, -0x100e8(%rbp)
movl $0x10000, %esi          # imm = 0x10000
leaq -0x10030(%rbp), %rcx
callq 0xa060
movq -0x100e8(%rbp), %rsi
movq -0x8(%rbp), %rdi
callq 0xfd80
addq $0x100f0, %rsp          # imm = 0x100F0
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/Ihsoh[P]ilang/string.c
// Function: rstr_insert_with_cstr
void rstr_insert_with_cstr(ResizableString *dst, const char *src, int pos) {
	assert(dst);
	assert(src);
	assert(pos >= 0);

	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 + pos + len_src, dst->buffer + pos, dst->len - pos);
	memcpy(dst->buffer + pos, src, len_src);
	dst->len += len_src;

	_append_null_terminated_char(dst);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl %edx, -0x14(%rbp)
cmpq $0x0, -0x8(%rbp)
je 0x105dc
jmp 0x105fb
leaq 0x35a86(%rip), %rdi     # 0x46069
leaq 0x3753a(%rip), %rsi     # 0x47b24
movl $0xdb, %edx
leaq 0x37782(%rip), %rcx     # 0x47d78
callq 0xa0b0
cmpq $0x0, -0x10(%rbp)
je 0x10604
jmp 0x10623
leaq 0x379b1(%rip), %rdi     # 0x47fbc
leaq 0x37512(%rip), %rsi     # 0x47b24
movl $0xdc, %edx
leaq 0x3775a(%rip), %rcx     # 0x47d78
callq 0xa0b0
cmpl $0x0, -0x14(%rbp)
jl 0x1062b
jmp 0x1064a
leaq 0x37787(%rip), %rdi     # 0x47db9
leaq 0x374eb(%rip), %rsi     # 0x47b24
movl $0xdd, %edx
leaq 0x37733(%rip), %rcx     # 0x47d78
callq 0xa0b0
movq -0x10(%rbp), %rdi
callq 0xa080
movl %eax, -0x18(%rbp)
cmpl $0x0, -0x18(%rbp)
jne 0x10661
jmp 0x106e8
movq -0x8(%rbp), %rax
movl 0x4(%rax), %eax
addl -0x18(%rbp), %eax
movq -0x8(%rbp), %rcx
cmpl (%rcx), %eax
jle 0x1067f
movq -0x8(%rbp), %rdi
movl -0x18(%rbp), %esi
callq 0x103f0
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rdi
movslq -0x14(%rbp), %rax
addq %rax, %rdi
movslq -0x18(%rbp), %rax
addq %rax, %rdi
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rsi
movslq -0x14(%rbp), %rax
addq %rax, %rsi
movq -0x8(%rbp), %rax
movl 0x4(%rax), %eax
subl -0x14(%rbp), %eax
movslq %eax, %rdx
callq 0xa120
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rdi
movslq -0x14(%rbp), %rax
addq %rax, %rdi
movq -0x10(%rbp), %rsi
movslq -0x18(%rbp), %rdx
callq 0xa120
movl -0x18(%rbp), %ecx
movq -0x8(%rbp), %rax
addl 0x4(%rax), %ecx
movl %ecx, 0x4(%rax)
movq -0x8(%rbp), %rdi
callq 0x104c0
addq $0x20, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/Ihsoh[P]ilang/string.c
// Function: rstr_insert_with_raw
void rstr_insert_with_raw(ResizableString *dst, const char *src, unsigned int len, int pos) {
	assert(dst);
	assert(src);
	assert(len >= 0);
	assert(pos >= 0);

	if (len == 0) {
		return;
	}

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

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

	_append_null_terminated_char(dst);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl %edx, -0x14(%rbp)
movl %ecx, -0x18(%rbp)
cmpq $0x0, -0x8(%rbp)
je 0x1075f
jmp 0x1077e
leaq 0x35903(%rip), %rdi     # 0x46069
leaq 0x373b7(%rip), %rsi     # 0x47b24
movl $0xf7, %edx
leaq 0x37649(%rip), %rcx     # 0x47dc2
callq 0xa0b0
cmpq $0x0, -0x10(%rbp)
je 0x10787
jmp 0x107a6
leaq 0x3782e(%rip), %rdi     # 0x47fbc
leaq 0x3738f(%rip), %rsi     # 0x47b24
movl $0xf8, %edx
leaq 0x37621(%rip), %rcx     # 0x47dc2
callq 0xa0b0
cmpl $0x0, -0x14(%rbp)
jb 0x107ae
jmp 0x107cd
leaq 0x35ded(%rip), %rdi     # 0x465a2
leaq 0x37368(%rip), %rsi     # 0x47b24
movl $0xf9, %edx
leaq 0x375fa(%rip), %rcx     # 0x47dc2
callq 0xa0b0
cmpl $0x0, -0x18(%rbp)
jl 0x107d5
jmp 0x107f4
leaq 0x375dd(%rip), %rdi     # 0x47db9
leaq 0x37341(%rip), %rsi     # 0x47b24
movl $0xfa, %edx
leaq 0x375d3(%rip), %rcx     # 0x47dc2
callq 0xa0b0
cmpl $0x0, -0x14(%rbp)
jne 0x107ff
jmp 0x10886
movq -0x8(%rbp), %rax
movl 0x4(%rax), %eax
addl -0x14(%rbp), %eax
movq -0x8(%rbp), %rcx
cmpl (%rcx), %eax
jbe 0x1081d
movq -0x8(%rbp), %rdi
movl -0x14(%rbp), %esi
callq 0x103f0
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rdi
movslq -0x18(%rbp), %rax
addq %rax, %rdi
movl -0x14(%rbp), %eax
addq %rax, %rdi
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rsi
movslq -0x18(%rbp), %rax
addq %rax, %rsi
movq -0x8(%rbp), %rax
movl 0x4(%rax), %eax
subl -0x18(%rbp), %eax
movslq %eax, %rdx
callq 0xa120
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rdi
movslq -0x18(%rbp), %rax
addq %rax, %rdi
movq -0x10(%rbp), %rsi
movl -0x14(%rbp), %eax
movl %eax, %edx
callq 0xa120
movl -0x14(%rbp), %ecx
movq -0x8(%rbp), %rax
addl 0x4(%rax), %ecx
movl %ecx, 0x4(%rax)
movq -0x8(%rbp), %rdi
callq 0x104c0
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/Ihsoh[P]ilang/string.c
// Function: rstr_insert_with_rstr
void rstr_insert_with_rstr(ResizableString *dst, const ResizableString *src, int pos) {
	assert(dst);
	assert(src);
	assert(pos >= 0);

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

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

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

	_append_null_terminated_char(dst);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl %edx, -0x14(%rbp)
cmpq $0x0, -0x8(%rbp)
je 0x108ac
jmp 0x108cb
leaq 0x357b6(%rip), %rdi     # 0x46069
leaq 0x3726a(%rip), %rsi     # 0x47b24
movl $0x10c, %edx            # imm = 0x10C
leaq 0x3754a(%rip), %rcx     # 0x47e10
callq 0xa0b0
cmpq $0x0, -0x10(%rbp)
je 0x108d4
jmp 0x108f3
leaq 0x376e1(%rip), %rdi     # 0x47fbc
leaq 0x37242(%rip), %rsi     # 0x47b24
movl $0x10d, %edx            # imm = 0x10D
leaq 0x37522(%rip), %rcx     # 0x47e10
callq 0xa0b0
cmpl $0x0, -0x14(%rbp)
jl 0x108fb
jmp 0x1091a
leaq 0x374b7(%rip), %rdi     # 0x47db9
leaq 0x3721b(%rip), %rsi     # 0x47b24
movl $0x10e, %edx            # imm = 0x10E
leaq 0x374fb(%rip), %rcx     # 0x47e10
callq 0xa0b0
movq -0x10(%rbp), %rax
cmpl $0x0, 0x4(%rax)
jne 0x10929
jmp 0x109c8
movq -0x8(%rbp), %rax
movl 0x4(%rax), %eax
movq -0x10(%rbp), %rcx
addl 0x4(%rcx), %eax
movq -0x8(%rbp), %rcx
cmpl (%rcx), %eax
jle 0x1094f
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rax
movl 0x4(%rax), %esi
callq 0x103f0
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rdi
movslq -0x14(%rbp), %rax
addq %rax, %rdi
movq -0x10(%rbp), %rax
movslq 0x4(%rax), %rax
addq %rax, %rdi
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rsi
movslq -0x14(%rbp), %rax
addq %rax, %rsi
movq -0x8(%rbp), %rax
movl 0x4(%rax), %eax
subl -0x14(%rbp), %eax
movslq %eax, %rdx
callq 0xa120
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rdi
movslq -0x14(%rbp), %rax
addq %rax, %rdi
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rsi
movq -0x10(%rbp), %rax
movslq 0x4(%rax), %rdx
callq 0xa120
movq -0x10(%rbp), %rax
movl 0x4(%rax), %ecx
movq -0x8(%rbp), %rax
addl 0x4(%rax), %ecx
movl %ecx, 0x4(%rax)
movq -0x8(%rbp), %rdi
callq 0x104c0
addq $0x20, %rsp
popq %rbp
retq
nop