LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O3/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 0xd773
movq %rsi, %r14
testq %rsi, %rsi
je 0xd792
movq (%r14), %rax
testq %rax, %rax
je 0xd7b1
movq %rdx, %rbx
testq %rdx, %rdx
je 0xd7d0
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 0xd7ef
movq %rbx, (%r14)
popq %rbx
popq %r14
popq %rbp
retq
leaq 0x2264a(%rip), %rdi     # 0x2fdc4
leaq 0x26d06(%rip), %rsi     # 0x34487
leaq 0x20ae2(%rip), %rcx     # 0x2e26a
movl $0x121, %edx            # imm = 0x121
callq 0xa0b0
leaq 0x20b1e(%rip), %rdi     # 0x2e2b7
leaq 0x26ce7(%rip), %rsi     # 0x34487
leaq 0x20ac3(%rip), %rcx     # 0x2e26a
movl $0x122, %edx            # imm = 0x122
callq 0xa0b0
leaq 0x20afe(%rip), %rdi     # 0x2e2b6
leaq 0x26cc8(%rip), %rsi     # 0x34487
leaq 0x20aa4(%rip), %rcx     # 0x2e26a
movl $0x123, %edx            # imm = 0x123
callq 0xa0b0
leaq 0x244d4(%rip), %rdi     # 0x31cab
leaq 0x26ca9(%rip), %rsi     # 0x34487
leaq 0x20a85(%rip), %rcx     # 0x2e26a
movl $0x124, %edx            # imm = 0x124
callq 0xa0b0
// File: /workspace/github_c_makefile_star2_O3/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 0xd8be
movq %rsi, %rbx
testq %rsi, %rsi
je 0xd8dd
testq %rdx, %rdx
je 0xd8fc
movslq 0x44(%rbx), %rax
movl 0x40(%rbx), %r14d
cmpl %r14d, %eax
jge 0xd838
movq 0x48(%rbx), %rcx
leal 0x1(%rax), %esi
movl %esi, 0x44(%rbx)
movq %rdx, (%rcx,%rax,8)
jmp 0xd8ac
movq %rdi, %r15
movq %rdx, -0x30(%rbp)
leal (%r14,%r14), %eax
testl %r14d, %r14d
movl $0x1, %r13d
cmovnel %eax, %r13d
leal (,%r13,8), %eax
movslq %eax, %rdi
callq 0xa130
movq %rax, %r12
testq %rax, %rax
jne 0xd86f
movq %r15, %rdi
callq *0x38(%r15)
movq 0x48(%rbx), %r15
testq %r15, %r15
je 0xd892
shll $0x3, %r14d
movslq %r14d, %rdx
movq %r12, %rdi
movq %r15, %rsi
callq 0xa120
movq %r15, %rdi
callq 0xa1a0
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 0x224ff(%rip), %rdi     # 0x2fdc4
leaq 0x26bbb(%rip), %rsi     # 0x34487
leaq 0x209e8(%rip), %rcx     # 0x2e2bb
movl $0x137, %edx            # imm = 0x137
callq 0xa0b0
leaq 0x243c7(%rip), %rdi     # 0x31cab
leaq 0x26b9c(%rip), %rsi     # 0x34487
leaq 0x209c9(%rip), %rcx     # 0x2e2bb
movl $0x138, %edx            # imm = 0x138
callq 0xa0b0
leaq 0x20a0b(%rip), %rdi     # 0x2e30e
leaq 0x26b7d(%rip), %rsi     # 0x34487
leaq 0x209aa(%rip), %rcx     # 0x2e2bb
movl $0x139, %edx            # imm = 0x139
callq 0xa0b0
// File: /workspace/github_c_makefile_star2_O3/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 0xd9dd
movl %esi, %r12d
testl %esi, %esi
je 0xd9fc
movq %rdx, %r15
testq %rdx, %rdx
je 0xda1b
movq %rcx, %rbx
movq %rdi, %r13
testq %rcx, %rcx
movq %r8, -0x30(%rbp)
je 0xd97c
testq %r8, %r8
jne 0xd985
leaq 0x2082f(%rip), %rdi     # 0x2e193
leaq 0x26b1c(%rip), %rsi     # 0x34487
leaq 0x209a2(%rip), %rcx     # 0x2e314
movl $0x162, %edx            # imm = 0x162
callq 0xa0b0
testq %r8, %r8
jne 0xda3a
leaq 0x30(%rbx), %rdi
callq 0xa130
movq %rax, %r14
testq %rax, %rax
jne 0xd99d
movq %r13, %rdi
callq *0x38(%r13)
movl %r12d, (%r14)
movq %r15, 0x8(%r14)
xorps %xmm0, %xmm0
movups %xmm0, 0x10(%r14)
movq $0x0, 0x20(%r14)
movq %rbx, 0x28(%r14)
movq %r14, %rdi
addq $0x30, %rdi
movq -0x30(%rbp), %rsi
movq %rbx, %rdx
callq 0xa120
movq %r14, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
leaq 0x223e0(%rip), %rdi     # 0x2fdc4
leaq 0x26a9c(%rip), %rsi     # 0x34487
leaq 0x20922(%rip), %rcx     # 0x2e314
movl $0x15e, %edx            # imm = 0x15E
callq 0xa0b0
leaq 0x20965(%rip), %rdi     # 0x2e368
leaq 0x26a7d(%rip), %rsi     # 0x34487
leaq 0x20903(%rip), %rcx     # 0x2e314
movl $0x15f, %edx            # imm = 0x15F
callq 0xa0b0
leaq 0x1fa98(%rip), %rdi     # 0x2d4ba
leaq 0x26a5e(%rip), %rsi     # 0x34487
leaq 0x208e4(%rip), %rcx     # 0x2e314
movl $0x160, %edx            # imm = 0x160
callq 0xa0b0
leaq 0x2075f(%rip), %rdi     # 0x2e1a0
leaq 0x26a3f(%rip), %rsi     # 0x34487
leaq 0x208c5(%rip), %rcx     # 0x2e314
movl $0x164, %edx            # imm = 0x164
callq 0xa0b0
// File: /workspace/github_c_makefile_star2_O3/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 0xdaa9
movq %rsi, %rbx
testq %rsi, %rsi
je 0xdac8
movq %rdi, %r14
movq 0x28(%rbx), %r15
addq $0x30, %r15
movq %r15, %rdi
callq 0xa130
movq %rax, %r12
testq %rax, %rax
jne 0xda93
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 0xa120
leaq 0x22314(%rip), %rdi     # 0x2fdc4
leaq 0x269d0(%rip), %rsi     # 0x34487
leaq 0x208b4(%rip), %rcx     # 0x2e372
movl $0x17d, %edx            # imm = 0x17D
callq 0xa0b0
leaq 0x1fa67(%rip), %rdi     # 0x2d536
leaq 0x269b1(%rip), %rsi     # 0x34487
leaq 0x20895(%rip), %rcx     # 0x2e372
movl $0x17e, %edx            # imm = 0x17E
callq 0xa0b0
// File: /workspace/github_c_makefile_star2_O3/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 0xdb4c
movq %rsi, %r14
testq %rsi, %rsi
je 0xdb6b
movq %rdx, %rbx
testq %rdx, %rdx
je 0xdb8a
movq %rdi, %r15
movq 0x8(%rbx), %rcx
movq %r14, %rsi
xorl %edx, %edx
callq 0xdba9
testq %rax, %rax
je 0xdb32
movq 0x8(%rbx), %rsi
leaq 0x208eb(%rip), %rdx     # 0x2e416
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 0x22271(%rip), %rdi     # 0x2fdc4
leaq 0x2692d(%rip), %rsi     # 0x34487
leaq 0x20854(%rip), %rcx     # 0x2e3b5
movl $0x1ac, %edx            # imm = 0x1AC
callq 0xa0b0
leaq 0x24139(%rip), %rdi     # 0x31cab
leaq 0x2690e(%rip), %rsi     # 0x34487
leaq 0x20835(%rip), %rcx     # 0x2e3b5
movl $0x1ad, %edx            # imm = 0x1AD
callq 0xa0b0
leaq 0x2087e(%rip), %rdi     # 0x2e40f
leaq 0x268ef(%rip), %rsi     # 0x34487
leaq 0x20816(%rip), %rcx     # 0x2e3b5
movl $0x1ae, %edx            # imm = 0x1AE
callq 0xa0b0
// File: /workspace/github_c_makefile_star2_O3/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 0xdc31
movq %rcx, %rbx
movl %edx, %r14d
movq %rsi, %r15
testq %r15, %r15
je 0xdbf3
testq %rbx, %rbx
je 0xdc12
movq 0x38(%r15), %rdi
movl %r14d, %esi
movq %rbx, %rdx
callq 0xde57
testq %rax, %rax
jne 0xdbe8
movq 0x30(%r15), %r15
testq %r15, %r15
jne 0xdbc1
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
leaq 0x240b1(%rip), %rdi     # 0x31cab
leaq 0x26886(%rip), %rsi     # 0x34487
leaq 0x2088d(%rip), %rcx     # 0x2e495
movl $0x220, %edx            # imm = 0x220
callq 0xa0b0
leaq 0x1f8a1(%rip), %rdi     # 0x2d4ba
leaq 0x26867(%rip), %rsi     # 0x34487
leaq 0x2086e(%rip), %rcx     # 0x2e495
movl $0x221, %edx            # imm = 0x221
callq 0xa0b0
leaq 0x2218c(%rip), %rdi     # 0x2fdc4
leaq 0x26848(%rip), %rsi     # 0x34487
leaq 0x2084f(%rip), %rcx     # 0x2e495
movl $0x21f, %edx            # imm = 0x21F
callq 0xa0b0
// File: /workspace/github_c_makefile_star2_O3/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 0xdd15
movq %rsi, %r13
testq %rsi, %rsi
je 0xdd34
movl %edx, %r12d
testl %edx, %edx
je 0xdd53
movq %rcx, %r15
testq %rcx, %rcx
je 0xdd72
movq %r8, %r14
movq %rdi, %rbx
testq %r8, %r8
movq %r9, -0x30(%rbp)
je 0xdcbd
testq %r9, %r9
jne 0xdcc6
leaq 0x204ee(%rip), %rdi     # 0x2e193
leaq 0x267db(%rip), %rsi     # 0x34487
leaq 0x20775(%rip), %rcx     # 0x2e428
movl $0x1cc, %edx            # imm = 0x1CC
callq 0xa0b0
testq %r9, %r9
jne 0xdd91
movq %rbx, %rdi
movq %r13, %rsi
xorl %edx, %edx
movq %r15, %rcx
callq 0xdba9
testq %rax, %rax
je 0xdceb
leaq 0x20734(%rip), %rdx     # 0x2e416
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 0xddb0
leaq 0x220a8(%rip), %rdi     # 0x2fdc4
leaq 0x26764(%rip), %rsi     # 0x34487
leaq 0x206fe(%rip), %rcx     # 0x2e428
movl $0x1c7, %edx            # imm = 0x1C7
callq 0xa0b0
leaq 0x23f70(%rip), %rdi     # 0x31cab
leaq 0x26745(%rip), %rsi     # 0x34487
leaq 0x206df(%rip), %rcx     # 0x2e428
movl $0x1c8, %edx            # imm = 0x1C8
callq 0xa0b0
leaq 0x2060e(%rip), %rdi     # 0x2e368
leaq 0x26726(%rip), %rsi     # 0x34487
leaq 0x206c0(%rip), %rcx     # 0x2e428
movl $0x1c9, %edx            # imm = 0x1C9
callq 0xa0b0
leaq 0x1f741(%rip), %rdi     # 0x2d4ba
leaq 0x26707(%rip), %rsi     # 0x34487
leaq 0x206a1(%rip), %rcx     # 0x2e428
movl $0x1ca, %edx            # imm = 0x1CA
callq 0xa0b0
leaq 0x20408(%rip), %rdi     # 0x2e1a0
leaq 0x266e8(%rip), %rsi     # 0x34487
leaq 0x20682(%rip), %rcx     # 0x2e428
movl $0x1ce, %edx            # imm = 0x1CE
callq 0xa0b0
// File: /workspace/github_c_makefile_star2_O3/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 0xddfa
movq %rsi, %rbx
testq %r8, %r8
je 0xddd5
testq %r9, %r9
je 0xde19
movl %edx, %esi
movq %rcx, %rdx
movq %r8, %rcx
movq %r9, %r8
jmp 0xdde4
testq %r9, %r9
jne 0xde38
movl %edx, %esi
movq %rcx, %rdx
xorl %ecx, %ecx
xorl %r8d, %r8d
callq 0xd91b
movq (%rbx), %rcx
movq %rcx, 0x10(%rax)
movq %rax, (%rbx)
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
leaq 0x20b7c(%rip), %rdi     # 0x2e97d
leaq 0x2667f(%rip), %rsi     # 0x34487
leaq 0x20b08(%rip), %rcx     # 0x2e917
movl $0x195, %edx            # imm = 0x195
callq 0xa0b0
leaq 0x20373(%rip), %rdi     # 0x2e193
leaq 0x26660(%rip), %rsi     # 0x34487
leaq 0x20ae9(%rip), %rcx     # 0x2e917
movl $0x199, %edx            # imm = 0x199
callq 0xa0b0
leaq 0x20361(%rip), %rdi     # 0x2e1a0
leaq 0x26641(%rip), %rsi     # 0x34487
leaq 0x20aca(%rip), %rcx     # 0x2e917
movl $0x19b, %edx            # imm = 0x19B
callq 0xa0b0
// File: /workspace/github_c_makefile_star2_O3/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 0xdea7
movq %rdi, %rbx
testq %rdi, %rdi
je 0xde97
movq %rdx, %r14
movl %esi, %r15d
movq 0x8(%rbx), %rsi
movq %r14, %rdi
callq 0xb9f9
testb %al, %al
je 0xde8e
testl %r15d, %r15d
je 0xde99
cmpl %r15d, (%rbx)
je 0xde99
movq 0x10(%rbx), %rbx
testq %rbx, %rbx
jne 0xde74
xorl %ebx, %ebx
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
leaq 0x1f60c(%rip), %rdi     # 0x2d4ba
leaq 0x265d2(%rip), %rsi     # 0x34487
leaq 0x20ac8(%rip), %rcx     # 0x2e984
movl $0x1e3, %edx            # imm = 0x1E3
callq 0xa0b0
// File: /workspace/github_c_makefile_star2_O3/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 0xdf2c
movq %rsi, %r14
testq %rsi, %rsi
je 0xdf4b
movq %rdx, %rbx
testq %rdx, %rdx
je 0xdf6a
movq %rdi, %r15
movq 0x18(%r14), %rdi
movq 0x8(%rbx), %rdx
xorl %esi, %esi
callq 0xde57
testq %rax, %rax
je 0xdf12
movq 0x8(%rbx), %rsi
leaq 0x2050b(%rip), %rdx     # 0x2e416
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 0x21e91(%rip), %rdi     # 0x2fdc4
leaq 0x2654d(%rip), %rsi     # 0x34487
leaq 0x205f3(%rip), %rcx     # 0x2e534
movl $0x24b, %edx            # imm = 0x24B
callq 0xa0b0
leaq 0x205db(%rip), %rdi     # 0x2e52d
leaq 0x2652e(%rip), %rsi     # 0x34487
leaq 0x205d4(%rip), %rcx     # 0x2e534
movl $0x24c, %edx            # imm = 0x24C
callq 0xa0b0
leaq 0x2049e(%rip), %rdi     # 0x2e40f
leaq 0x2650f(%rip), %rsi     # 0x34487
leaq 0x205b5(%rip), %rcx     # 0x2e534
movl $0x24d, %edx            # imm = 0x24D
callq 0xa0b0
// File: /workspace/github_c_makefile_star2_O3/Ihsoh[P]ilang/parser.c
// Function: parser_add_symbol_to_symbol
ParserSymbol * parser_add_symbol_to_symbol(
	ParserContext *ctx,
	ParserSymbol *symbol,
	int type,
	LexerToken *token,
	size_t szdata,
	void *data
) {
	assert(ctx);
	assert(symbol);
	assert(type != 0);
	assert(token);
	if (szdata > 0) {
		assert(data != NULL);
	} else {
		assert(data == NULL);
	}

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

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

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
testq %rdi, %rdi
je 0xe05d
movq %rsi, %r13
testq %rsi, %rsi
je 0xe07c
movl %edx, %r12d
testl %edx, %edx
je 0xe09b
movq %rcx, %r15
testq %rcx, %rcx
je 0xe0ba
movq %rdi, %rbx
testq %r8, %r8
movq %r9, -0x38(%rbp)
movq %r8, -0x30(%rbp)
je 0xdffa
testq %r9, %r9
jne 0xe003
leaq 0x201b1(%rip), %rdi     # 0x2e193
leaq 0x2649e(%rip), %rsi     # 0x34487
leaq 0x2059f(%rip), %rcx     # 0x2e58f
movl $0x26b, %edx            # imm = 0x26B
callq 0xa0b0
testq %r9, %r9
jne 0xe0d9
movq 0x18(%r13), %r14
addq $0x18, %r13
testq %r14, %r14
je 0xe036
movq 0x8(%r14), %rsi
movq %r15, %rdi
callq 0xb9f9
testb %al, %al
jne 0xe026
movq 0x10(%r14), %r14
jmp 0xe00b
leaq 0x203e9(%rip), %rdx     # 0x2e416
movq %rbx, %rdi
movq %r15, %rsi
callq *0x50(%rbx)
movq %rbx, %rdi
movq %r13, %rsi
movl %r12d, %edx
movq %r15, %rcx
movq -0x30(%rbp), %r8
movq -0x38(%rbp), %r9
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0xddb0
leaq 0x21d60(%rip), %rdi     # 0x2fdc4
leaq 0x2641c(%rip), %rsi     # 0x34487
leaq 0x2051d(%rip), %rcx     # 0x2e58f
movl $0x266, %edx            # imm = 0x266
callq 0xa0b0
leaq 0x204aa(%rip), %rdi     # 0x2e52d
leaq 0x263fd(%rip), %rsi     # 0x34487
leaq 0x204fe(%rip), %rcx     # 0x2e58f
movl $0x267, %edx            # imm = 0x267
callq 0xa0b0
leaq 0x202c6(%rip), %rdi     # 0x2e368
leaq 0x263de(%rip), %rsi     # 0x34487
leaq 0x204df(%rip), %rcx     # 0x2e58f
movl $0x268, %edx            # imm = 0x268
callq 0xa0b0
leaq 0x1f3f9(%rip), %rdi     # 0x2d4ba
leaq 0x263bf(%rip), %rsi     # 0x34487
leaq 0x204c0(%rip), %rcx     # 0x2e58f
movl $0x269, %edx            # imm = 0x269
callq 0xa0b0
leaq 0x200c0(%rip), %rdi     # 0x2e1a0
leaq 0x263a0(%rip), %rsi     # 0x34487
leaq 0x204a1(%rip), %rcx     # 0x2e58f
movl $0x26d, %edx            # imm = 0x26D
callq 0xa0b0
// File: /workspace/github_c_makefile_star2_O3/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 0xe11a
testq %rsi, %rsi
je 0xe139
testq %rcx, %rcx
je 0xe158
movq 0x18(%rsi), %rdi
movl %edx, %esi
movq %rcx, %rdx
popq %rbp
jmp 0xde57
leaq 0x21ca3(%rip), %rdi     # 0x2fdc4
leaq 0x2635f(%rip), %rsi     # 0x34487
leaq 0x204ce(%rip), %rcx     # 0x2e5fd
movl $0x281, %edx            # imm = 0x281
callq 0xa0b0
leaq 0x203ed(%rip), %rdi     # 0x2e52d
leaq 0x26340(%rip), %rsi     # 0x34487
leaq 0x204af(%rip), %rcx     # 0x2e5fd
movl $0x282, %edx            # imm = 0x282
callq 0xa0b0
leaq 0x1f35b(%rip), %rdi     # 0x2d4ba
leaq 0x26321(%rip), %rsi     # 0x34487
leaq 0x20490(%rip), %rcx     # 0x2e5fd
movl $0x283, %edx            # imm = 0x283
callq 0xa0b0
// File: /workspace/github_c_makefile_star2_O3/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 0xe217
testq %rsi, %rsi
je 0xe236
movq %rcx, %rbx
testq %rcx, %rcx
je 0xe255
movq 0x18(%rsi), %r12
testq %r12, %r12
je 0xe1f8
movl %edx, %r14d
movl $0xffffffff, %r15d      # imm = 0xFFFFFFFF
movq %r12, %rax
movq 0x10(%rax), %rax
incl %r15d
testq %rax, %rax
jne 0xe1b5
jmp 0xe1d6
cmpl %r14d, (%r12)
je 0xe1ec
movq 0x10(%r12), %r12
decl %r15d
testq %r12, %r12
je 0xe1f8
movq 0x8(%r12), %rsi
movq %rbx, %rdi
callq 0xb9f9
testb %al, %al
je 0xe1c9
testl %r14d, %r14d
jne 0xe1c3
movl %r15d, %eax
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
leaq 0x20171(%rip), %rdi     # 0x2e370
leaq 0x26281(%rip), %rsi     # 0x34487
leaq 0x207cc(%rip), %rcx     # 0x2e9d9
movl $0x215, %edx            # imm = 0x215
callq 0xa0b0
leaq 0x21ba6(%rip), %rdi     # 0x2fdc4
leaq 0x26262(%rip), %rsi     # 0x34487
leaq 0x20431(%rip), %rcx     # 0x2e65d
movl $0x28e, %edx            # imm = 0x28E
callq 0xa0b0
leaq 0x202f0(%rip), %rdi     # 0x2e52d
leaq 0x26243(%rip), %rsi     # 0x34487
leaq 0x20412(%rip), %rcx     # 0x2e65d
movl $0x28f, %edx            # imm = 0x28F
callq 0xa0b0
leaq 0x1f25e(%rip), %rdi     # 0x2d4ba
leaq 0x26224(%rip), %rsi     # 0x34487
leaq 0x203f3(%rip), %rcx     # 0x2e65d
movl $0x290, %edx            # imm = 0x290
callq 0xa0b0
// File: /workspace/github_c_makefile_star2_O3/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 0xe2bd
testq %rsi, %rsi
je 0xe2dc
xorps %xmm0, %xmm0
movups %xmm0, (%rdi)
popq %rbp
jmp 0xe2fb
leaq 0x2077c(%rip), %rdi     # 0x2ea40
leaq 0x2077a(%rip), %rsi     # 0x2ea45
leaq 0x2079e(%rip), %rcx     # 0x2ea70
movl $0x1a, %edx
callq 0xa0b0
leaq 0x207c7(%rip), %rdi     # 0x2eaaa
leaq 0x2075b(%rip), %rsi     # 0x2ea45
leaq 0x2077f(%rip), %rcx     # 0x2ea70
movl $0x1b, %edx
callq 0xa0b0
// File: /workspace/github_c_makefile_star2_O3/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 0xe370
movq %rsi, %r14
testq %rsi, %rsi
je 0xe38f
movq %rdi, %rbx
movq %r14, %rdi
callq 0xa080
movq %rax, %r15
testl %r15d, %r15d
je 0xe365
movl 0x4(%rbx), %eax
leal (%rax,%r15), %ecx
cmpl (%rbx), %ecx
jle 0xe33e
movq %rbx, %rdi
movl %r15d, %esi
callq 0xe803
movl 0x4(%rbx), %eax
movslq %eax, %rdi
addq 0x8(%rbx), %rdi
movslq %r15d, %rdx
movq %r14, %rsi
callq 0xa120
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 0x1ecf2(%rip), %rdi     # 0x2d069
leaq 0x206c7(%rip), %rsi     # 0x2ea45
leaq 0x20851(%rip), %rcx     # 0x2ebd6
movl $0x90, %edx
callq 0xa0b0
leaq 0x20b47(%rip), %rdi     # 0x2eedd
leaq 0x206a8(%rip), %rsi     # 0x2ea45
leaq 0x20832(%rip), %rcx     # 0x2ebd6
movl $0x91, %edx
callq 0xa0b0
// File: /workspace/github_c_makefile_star2_O3/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 0xe43a
testq %rsi, %rsi
je 0xe459
testl %edx, %edx
js 0xe478
xorps %xmm0, %xmm0
movups %xmm0, (%rdi)
popq %rbp
jmp 0xe497
leaq 0x205ff(%rip), %rdi     # 0x2ea40
leaq 0x205fd(%rip), %rsi     # 0x2ea45
leaq 0x20692(%rip), %rcx     # 0x2eae1
movl $0x30, %edx
callq 0xa0b0
leaq 0x2064a(%rip), %rdi     # 0x2eaaa
leaq 0x205de(%rip), %rsi     # 0x2ea45
leaq 0x20673(%rip), %rcx     # 0x2eae1
movl $0x31, %edx
callq 0xa0b0
leaq 0x1f0be(%rip), %rdi     # 0x2d53d
leaq 0x205bf(%rip), %rsi     # 0x2ea45
leaq 0x20654(%rip), %rcx     # 0x2eae1
movl $0x32, %edx
callq 0xa0b0
// File: /workspace/github_c_makefile_star2_O3/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 0xe509
movq %rsi, %r15
testq %rsi, %rsi
je 0xe528
movl %edx, %r14d
testl %edx, %edx
js 0xe547
je 0xe4fe
movq %rdi, %rbx
movl 0x4(%rdi), %eax
leal (%rax,%r14), %ecx
cmpl (%rdi), %ecx
jle 0xe4d7
movq %rbx, %rdi
movl %r14d, %esi
callq 0xe803
movl 0x4(%rbx), %eax
movslq %eax, %rdi
addq 0x8(%rbx), %rdi
movl %r14d, %edx
movq %r15, %rsi
callq 0xa120
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 0x1eb59(%rip), %rdi     # 0x2d069
leaq 0x2052e(%rip), %rsi     # 0x2ea45
leaq 0x206f4(%rip), %rcx     # 0x2ec12
movl $0xaa, %edx
callq 0xa0b0
leaq 0x209ae(%rip), %rdi     # 0x2eedd
leaq 0x2050f(%rip), %rsi     # 0x2ea45
leaq 0x206d5(%rip), %rcx     # 0x2ec12
movl $0xab, %edx
callq 0xa0b0
leaq 0x1efef(%rip), %rdi     # 0x2d53d
leaq 0x204f0(%rip), %rsi     # 0x2ea45
leaq 0x206b6(%rip), %rcx     # 0x2ec12
movl $0xac, %edx
callq 0xa0b0
// File: /workspace/github_c_makefile_star2_O3/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 0xe580
testq %rsi, %rsi
je 0xe59f
xorps %xmm0, %xmm0
movups %xmm0, (%rdi)
popq %rbp
jmp 0xe5be
leaq 0x1eae2(%rip), %rdi     # 0x2d069
leaq 0x204b7(%rip), %rsi     # 0x2ea45
leaq 0x2058a(%rip), %rcx     # 0x2eb1f
movl $0x3c, %edx
callq 0xa0b0
leaq 0x20937(%rip), %rdi     # 0x2eedd
leaq 0x20498(%rip), %rsi     # 0x2ea45
leaq 0x2056b(%rip), %rcx     # 0x2eb1f
movl $0x3d, %edx
callq 0xa0b0
// File: /workspace/github_c_makefile_star2_O3/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 0xe627
movq %rsi, %r14
testq %rsi, %rsi
je 0xe646
movl 0x4(%r14), %esi
testl %esi, %esi
je 0xe622
movq %rdi, %rbx
movl 0x4(%rdi), %eax
leal (%rax,%rsi), %ecx
cmpl (%rdi), %ecx
jle 0xe5f6
movq %rbx, %rdi
callq 0xe803
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 0xa120
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 0x1ea3b(%rip), %rdi     # 0x2d069
leaq 0x20410(%rip), %rsi     # 0x2ea45
leaq 0x20616(%rip), %rcx     # 0x2ec52
movl $0xbd, %edx
callq 0xa0b0
leaq 0x20890(%rip), %rdi     # 0x2eedd
leaq 0x203f1(%rip), %rsi     # 0x2ea45
leaq 0x205f7(%rip), %rcx     # 0x2ec52
movl $0xbe, %edx
callq 0xa0b0
// File: /workspace/github_c_makefile_star2_O3/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 0xe6c8
movq %rdi, %rbx
callq 0xe665
movq %rax, %r14
movq %rax, %rdi
movq %rbx, %rsi
callq 0xe2fb
movq %r14, %rax
popq %rbx
popq %r14
popq %rbp
retq
leaq 0x203db(%rip), %rdi     # 0x2eaaa
leaq 0x2036f(%rip), %rsi     # 0x2ea45
leaq 0x20481(%rip), %rcx     # 0x2eb5e
movl $0x4d, %edx
callq 0xa0b0
// File: /workspace/github_c_makefile_star2_O3/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
pushq %rbx
pushq %rax
testq %rdi, %rdi
je 0xe79b
movq %rdi, %rbx
movq 0x8(%rdi), %rdi
testq %rdi, %rdi
je 0xe78e
callq 0xa1a0
xorps %xmm0, %xmm0
movups %xmm0, (%rbx)
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
leaq 0x2029e(%rip), %rdi     # 0x2ea40
leaq 0x2029c(%rip), %rsi     # 0x2ea45
leaq 0x203e0(%rip), %rcx     # 0x2eb90
movl $0x6d, %edx
callq 0xa0b0
// File: /workspace/github_c_makefile_star2_O3/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
pushq %rbx
pushq %rax
testl %esi, %esi
jle 0xe846
movq %rdi, %rbx
movslq (%rdi), %rax
movslq %esi, %rcx
leaq (%rax,%rcx,2), %rdx
movl %edx, (%rdi)
movq 0x8(%rdi), %rdi
leaq (%rax,%rcx,2), %rsi
incq %rsi
testq %rdi, %rdi
je 0xe833
callq 0xa140
jmp 0xe83b
movq %rsi, %rdi
callq 0xa130
movq %rax, 0x8(%rbx)
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
leaq 0x20bd0(%rip), %rdi     # 0x2f41d
leaq 0x201f1(%rip), %rsi     # 0x2ea45
leaq 0x20b94(%rip), %rcx     # 0x2f3ef
movl $0x81, %edx
callq 0xa0b0
// File: /workspace/github_c_makefile_star2_O3/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
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
testq %rdi, %rdi
je 0xe9b9
movq %rsi, %r14
testq %rsi, %rsi
je 0xe9d8
movl %edx, %r15d
testl %edx, %edx
js 0xe9f7
movq %rdi, %rbx
movq %r14, %rdi
callq 0xa080
movq %rax, %r12
testl %r12d, %r12d
je 0xe9aa
movq %r14, -0x30(%rbp)
movl 0x4(%rbx), %eax
leal (%rax,%r12), %ecx
cmpl (%rbx), %ecx
jle 0xe966
movq %rbx, %rdi
movl %r12d, %esi
callq 0xe803
movl 0x4(%rbx), %eax
movl %r15d, %r13d
movq 0x8(%rbx), %rsi
addq %r13, %rsi
movslq %r12d, %r14
leaq (%rsi,%r14), %rdi
subl %r15d, %eax
movslq %eax, %rdx
callq 0xa120
addq 0x8(%rbx), %r13
movq %r13, %rdi
movq -0x30(%rbp), %rsi
movq %r14, %rdx
callq 0xa120
movslq 0x4(%rbx), %rax
movslq %r12d, %rcx
addq %rax, %rcx
movl %ecx, 0x4(%rbx)
movq 0x8(%rbx), %rax
movb $0x0, (%rax,%rcx)
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
leaq 0x1e6a9(%rip), %rdi     # 0x2d069
leaq 0x2007e(%rip), %rsi     # 0x2ea45
leaq 0x202cb(%rip), %rcx     # 0x2ec99
movl $0xdb, %edx
callq 0xa0b0
leaq 0x204fe(%rip), %rdi     # 0x2eedd
leaq 0x2005f(%rip), %rsi     # 0x2ea45
leaq 0x202ac(%rip), %rcx     # 0x2ec99
movl $0xdc, %edx
callq 0xa0b0
leaq 0x202dc(%rip), %rdi     # 0x2ecda
leaq 0x20040(%rip), %rsi     # 0x2ea45
leaq 0x2028d(%rip), %rcx     # 0x2ec99
movl $0xdd, %edx
callq 0xa0b0
// File: /workspace/github_c_makefile_star2_O3/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
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
testq %rdi, %rdi
je 0xead9
testq %rsi, %rsi
je 0xeaf8
movl %ecx, %r12d
testl %ecx, %ecx
js 0xeb17
movl %edx, %ebx
testl %edx, %edx
je 0xeaca
movq %rdi, %r14
movq %rsi, -0x30(%rbp)
movl 0x4(%rdi), %eax
leal (%rax,%rbx), %ecx
cmpl (%rdi), %ecx
jbe 0xea88
movq %r14, %rdi
movl %ebx, %esi
callq 0xe803
movl 0x4(%r14), %eax
movl %r12d, %r13d
movq 0x8(%r14), %rsi
addq %r13, %rsi
movl %ebx, %r15d
leaq (%rsi,%r15), %rdi
subl %r12d, %eax
movslq %eax, %rdx
callq 0xa120
addq 0x8(%r14), %r13
movq %r13, %rdi
movq -0x30(%rbp), %rsi
movq %r15, %rdx
callq 0xa120
addl 0x4(%r14), %ebx
movl %ebx, 0x4(%r14)
movq 0x8(%r14), %rax
movslq %ebx, %rcx
movb $0x0, (%rax,%rcx)
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
leaq 0x1e589(%rip), %rdi     # 0x2d069
leaq 0x1ff5e(%rip), %rsi     # 0x2ea45
leaq 0x201f5(%rip), %rcx     # 0x2ece3
movl $0xf7, %edx
callq 0xa0b0
leaq 0x203de(%rip), %rdi     # 0x2eedd
leaq 0x1ff3f(%rip), %rsi     # 0x2ea45
leaq 0x201d6(%rip), %rcx     # 0x2ece3
movl $0xf8, %edx
callq 0xa0b0
leaq 0x201bc(%rip), %rdi     # 0x2ecda
leaq 0x1ff20(%rip), %rsi     # 0x2ea45
leaq 0x201b7(%rip), %rcx     # 0x2ece3
movl $0xfa, %edx
callq 0xa0b0
// File: /workspace/github_c_makefile_star2_O3/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
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
testq %rdi, %rdi
je 0xebd6
movq %rsi, %r14
testq %rsi, %rsi
je 0xebf5
movl %edx, %r15d
testl %edx, %edx
js 0xec14
movl 0x4(%r14), %esi
testl %esi, %esi
je 0xebcd
movq %rdi, %rbx
movl 0x4(%rdi), %ecx
leal (%rcx,%rsi), %eax
cmpl (%rdi), %eax
jle 0xeb85
movq %rbx, %rdi
callq 0xe803
movl 0x4(%r14), %esi
movl 0x4(%rbx), %ecx
movl %r15d, %r12d
movq 0x8(%rbx), %rax
addq %r12, %rax
movslq %esi, %rdi
addq %rax, %rdi
subl %r15d, %ecx
movslq %ecx, %rdx
movq %rax, %rsi
callq 0xa120
addq 0x8(%rbx), %r12
movq 0x8(%r14), %rsi
movslq 0x4(%r14), %rdx
movq %r12, %rdi
callq 0xa120
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 %r12
popq %r14
popq %r15
popq %rbp
retq
leaq 0x1e48c(%rip), %rdi     # 0x2d069
leaq 0x1fe61(%rip), %rsi     # 0x2ea45
leaq 0x20146(%rip), %rcx     # 0x2ed31
movl $0x10c, %edx            # imm = 0x10C
callq 0xa0b0
leaq 0x202e1(%rip), %rdi     # 0x2eedd
leaq 0x1fe42(%rip), %rsi     # 0x2ea45
leaq 0x20127(%rip), %rcx     # 0x2ed31
movl $0x10d, %edx            # imm = 0x10D
callq 0xa0b0
leaq 0x200bf(%rip), %rdi     # 0x2ecda
leaq 0x1fe23(%rip), %rsi     # 0x2ea45
leaq 0x20108(%rip), %rcx     # 0x2ed31
movl $0x10e, %edx            # imm = 0x10E
callq 0xa0b0
// File: /workspace/github_c_makefile_star2_O3/Ihsoh[P]ilang/string.c
// Function: rstr_compare
bool rstr_compare(ResizableString *a, ResizableString *b) {
	return a != NULL
		&& b != NULL
		&& a->len == b->len
		&& (a->buffer == NULL || strcmp(a->buffer, b->buffer) == 0);
}

// Assembly:
testq %rdi, %rdi
sete %al
testq %rsi, %rsi
sete %cl
orb %al, %cl
jne 0xedf6
movl 0x4(%rdi), %eax
cmpl 0x4(%rsi), %eax
jne 0xedf6
movq 0x8(%rdi), %rdi
testq %rdi, %rdi
je 0xedf9
pushq %rbp
movq %rsp, %rbp
movq 0x8(%rsi), %rsi
callq 0xa0f0
testl %eax, %eax
sete %al
popq %rbp
retq
xorl %eax, %eax
retq
movb $0x1, %al
retq
// File: /workspace/github_c_makefile_star2_O3/Ihsoh[P]ilang/string.c
// Function: rstr_split
void rstr_split(
	LinkedList *llst,
	ResizableString *rstr,
	const char *seperator,
	bool ignore_empty
) {
	assert(llst);
	assert(rstr);
	assert(seperator);

	size_t sep_len = strlen(seperator);

	#define	_GET_STR(i) ((i) >= rstr->len ? NULL : &(rstr->buffer[(i)]))

	int idx = 0;
	while (_GET_STR(idx) != NULL) {
		ResizableString *item = rstr_new();

		while (_GET_STR(idx) != NULL && strncmp(_GET_STR(idx), seperator, sep_len) != 0) {
			rstr_append_with_char(item, *_GET_STR(idx));
			idx++;
		}

		if (_GET_STR(idx) != NULL && strncmp(_GET_STR(idx), seperator, sep_len) == 0) {
			idx += sep_len;
		}

		if (ignore_empty
				&& item->len == 0) {
			rstr_delete(item);
		} else {
			llst_append(llst, item);
		}
	}

	#undef	_GET_STR
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x28, %rsp
movq %rdi, -0x50(%rbp)
testq %rdi, %rdi
je 0xef3f
movq %rsi, %r15
testq %rsi, %rsi
je 0xef5e
testq %rdx, %rdx
je 0xef7d
movl %ecx, %r14d
movq %rdx, -0x48(%rbp)
movq %rdx, %rdi
callq 0xa080
movq %rax, -0x40(%rbp)
cmpl $0x0, 0x4(%r15)
jle 0xef30
xorl %ebx, %ebx
movl %r14d, -0x30(%rbp)
cmpq $0x0, 0x8(%r15)
je 0xef30
callq 0xe665
movq %rax, -0x38(%rbp)
cmpl 0x4(%r15), %ebx
jge 0xeefd
movslq %ebx, %rbx
movq %rbx, %r13
shlq $0x20, %r13
movq 0x8(%r15), %r12
testq %r12, %r12
je 0xeef9
leaq (%r12,%rbx), %r14
movq %r14, %rdi
movq -0x48(%rbp), %rsi
movq -0x40(%rbp), %rdx
callq 0xa040
testl %eax, %eax
je 0xeed0
movb (%r14), %al
movw $0x0, -0x2a(%rbp)
movb %al, -0x2a(%rbp)
movq -0x38(%rbp), %rdi
leaq -0x2a(%rbp), %rsi
callq 0xe2fb
incq %rbx
movslq 0x4(%r15), %rax
movabsq $0x100000000, %rcx      # imm = 0x100000000
addq %rcx, %r13
cmpq %rax, %rbx
jl 0xee7b
jmp 0xeef9
sarq $0x20, %r13
addq %r13, %r12
movq %r12, %rdi
movq -0x48(%rbp), %rsi
movq -0x40(%rbp), %r14
movq %r14, %rdx
callq 0xa040
testl %eax, %eax
movl $0x0, %eax
cmovel %r14d, %eax
addl %ebx, %eax
movl %eax, %ebx
movl -0x30(%rbp), %r14d
testb %r14b, %r14b
je 0xef0c
movq -0x38(%rbp), %rax
cmpl $0x0, 0x4(%rax)
je 0xef25
movq -0x50(%rbp), %rdi
movq -0x38(%rbp), %rsi
callq 0xbd8f
cmpl 0x4(%r15), %ebx
jl 0xee53
jmp 0xef30
movq -0x38(%rbp), %rdi
callq 0xe7ba
jmp 0xef19
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
leaq 0x1ecac(%rip), %rdi     # 0x2dbf2
leaq 0x1faf8(%rip), %rsi     # 0x2ea45
leaq 0x1fe29(%rip), %rcx     # 0x2ed7d
movl $0x15a, %edx            # imm = 0x15A
callq 0xa0b0
leaq 0x1fadb(%rip), %rdi     # 0x2ea40
leaq 0x1fad9(%rip), %rsi     # 0x2ea45
leaq 0x1fe0a(%rip), %rcx     # 0x2ed7d
movl $0x15b, %edx            # imm = 0x15B
callq 0xa0b0
leaq 0x1fe3f(%rip), %rdi     # 0x2edc3
leaq 0x1faba(%rip), %rsi     # 0x2ea45
leaq 0x1fdeb(%rip), %rcx     # 0x2ed7d
movl $0x15c, %edx            # imm = 0x15C
callq 0xa0b0
// File: /workspace/github_c_makefile_star2_O3/Ihsoh[P]ilang/string.c
// Function: rstr_split_by_char
void rstr_split_by_char(
	LinkedList *llst,
	ResizableString *rstr,
	char seperator,
	bool ignore_empty
) {
	assert(llst);
	assert(rstr);

	char temp[2] = {'\0', '\0'};
	temp[0] = seperator;

	rstr_split(llst, rstr, temp, ignore_empty);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
testq %rdi, %rdi
je 0xefca
testq %rsi, %rsi
je 0xefe9
leaq -0x2(%rbp), %rax
movw $0x0, (%rax)
movb %dl, (%rax)
movzbl %cl, %ecx
movq %rax, %rdx
callq 0xedfc
addq $0x10, %rsp
popq %rbp
retq
leaq 0x1ec21(%rip), %rdi     # 0x2dbf2
leaq 0x1fa6d(%rip), %rsi     # 0x2ea45
leaq 0x1fdee(%rip), %rcx     # 0x2edcd
movl $0x180, %edx            # imm = 0x180
callq 0xa0b0
leaq 0x1fa50(%rip), %rdi     # 0x2ea40
leaq 0x1fa4e(%rip), %rsi     # 0x2ea45
leaq 0x1fdcf(%rip), %rcx     # 0x2edcd
movl $0x181, %edx            # imm = 0x181
callq 0xa0b0
// File: /workspace/github_c_makefile_star2_O3/Ihsoh[P]ilang/string.c
// Function: rstr_index_of
int rstr_index_of(
	ResizableString *rstr,
	const char *search_value
) {
	assert(rstr);
	assert(search_value);

	size_t search_value_len = strlen(search_value);
	if (search_value_len == 0) {
		return -1;
	}

	for (int i = 0; RSTR_CSTR(rstr)[i] != '\0'; i++) {
		if (strncmp(&(RSTR_CSTR(rstr)[i]), search_value, search_value_len) == 0) {
			return i;
		}
	}

	return -1;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
testq %rdi, %rdi
je 0xf093
movq %rsi, %rbx
testq %rsi, %rsi
je 0xf0b2
movq %rdi, %r12
movq %rbx, %rdi
callq 0xa080
movl $0xffffffff, %r14d      # imm = 0xFFFFFFFF
testq %rax, %rax
je 0xf081
movq %rax, %r15
movq 0x8(%r12), %rax
testq %rax, %rax
leaq 0x1f743(%rip), %r12     # 0x2e792
cmovneq %rax, %r12
cmpb $0x0, (%r12)
je 0xf081
xorl %r13d, %r13d
leaq (%r12,%r13), %rdi
movq %rbx, %rsi
movq %r15, %rdx
callq 0xa040
testl %eax, %eax
je 0xf07e
cmpb $0x0, 0x1(%r12,%r13)
leaq 0x1(%r13), %r13
jne 0xf05d
jmp 0xf081
movl %r13d, %r14d
movl %r14d, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
leaq 0x1f9a6(%rip), %rdi     # 0x2ea40
leaq 0x1f9a4(%rip), %rsi     # 0x2ea45
leaq 0x1fd6b(%rip), %rcx     # 0x2ee13
movl $0x18d, %edx            # imm = 0x18D
callq 0xa0b0
leaq 0x1fd8d(%rip), %rdi     # 0x2ee46
leaq 0x1f985(%rip), %rsi     # 0x2ea45
leaq 0x1fd4c(%rip), %rcx     # 0x2ee13
movl $0x18e, %edx            # imm = 0x18E
callq 0xa0b0
// File: /workspace/github_c_makefile_star2_O3/Ihsoh[P]ilang/string.c
// Function: rstr_last_index_of
int rstr_last_index_of(
	ResizableString *rstr,
	const char *search_value
) {
	assert(rstr);
	assert(search_value);

	size_t search_value_len = strlen(search_value);
	if (search_value_len == 0) {
		return -1;
	}

	size_t len = RSTR_LEN(rstr);

	for (int i = len; i >= 0; i--) {
		if (strncmp(&(RSTR_CSTR(rstr)[i]), search_value, search_value_len) == 0) {
			return i;
		}
	}

	return -1;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
testq %rdi, %rdi
je 0xf15c
movq %rsi, %rbx
testq %rsi, %rsi
je 0xf17b
movq %rdi, %r12
movq %rbx, %rdi
callq 0xa080
movl $0xffffffff, %r14d      # imm = 0xFFFFFFFF
testq %rax, %rax
je 0xf14a
movslq 0x4(%r12), %r13
testq %r13, %r13
js 0xf14a
movq %rax, %r15
movq 0x8(%r12), %rax
testq %rax, %rax
leaq 0x1f670(%rip), %r12     # 0x2e792
cmovneq %rax, %r12
leaq (%r12,%r13), %rdi
movq %rbx, %rsi
movq %r15, %rdx
callq 0xa040
testl %eax, %eax
je 0xf147
leaq -0x1(%r13), %rax
testq %r13, %r13
movq %rax, %r13
jg 0xf126
jmp 0xf14a
movl %r13d, %r14d
movl %r14d, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
leaq 0x1f8dd(%rip), %rdi     # 0x2ea40
leaq 0x1f8db(%rip), %rsi     # 0x2ea45
leaq 0x1fce2(%rip), %rcx     # 0x2ee53
movl $0x1a2, %edx            # imm = 0x1A2
callq 0xa0b0
leaq 0x1fcc4(%rip), %rdi     # 0x2ee46
leaq 0x1f8bc(%rip), %rsi     # 0x2ea45
leaq 0x1fcc3(%rip), %rcx     # 0x2ee53
movl $0x1a3, %edx            # imm = 0x1A3
callq 0xa0b0
// File: /workspace/github_c_makefile_star2_O3/Ihsoh[P]ilang/string.c
// Function: rstr_sub_string
void rstr_sub_string(
	ResizableString *dst,
	ResizableString *src,
	size_t start,
	size_t len
) {
	assert(dst);
	assert(src);
	assert(dst != src);

	for (int i = start; i < start + len && RSTR_CHAR(src, i) != -1; i++) {
		rstr_append_with_char(dst, RSTR_CHAR(src, i));
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
testq %rdi, %rdi
je 0xf222
movq %rsi, %r14
testq %rsi, %rsi
je 0xf241
movq %rdi, %r15
cmpq %r14, %rdi
je 0xf260
movq %rcx, %rbx
addq %rdx, %rbx
movslq %edx, %r13
cmpq %r13, %rbx
jbe 0xf213
leaq 0x1f5b8(%rip), %r12     # 0x2e792
movslq 0x4(%r14), %rax
cmpq %rax, %r13
jge 0xf213
movq 0x8(%r14), %rax
testq %rax, %rax
cmoveq %r12, %rax
movb (%rax,%r13), %al
cmpb $-0x1, %al
je 0xf213
movw $0x0, -0x2a(%rbp)
movb %al, -0x2a(%rbp)
movq %r15, %rdi
leaq -0x2a(%rbp), %rsi
callq 0xe2fb
incq %r13
cmpq %r13, %rbx
ja 0xf1da
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
leaq 0x1de40(%rip), %rdi     # 0x2d069
leaq 0x1f815(%rip), %rsi     # 0x2ea45
leaq 0x1fc54(%rip), %rcx     # 0x2ee8b
movl $0x1bb, %edx            # imm = 0x1BB
callq 0xa0b0
leaq 0x1fc95(%rip), %rdi     # 0x2eedd
leaq 0x1f7f6(%rip), %rsi     # 0x2ea45
leaq 0x1fc35(%rip), %rcx     # 0x2ee8b
movl $0x1bc, %edx            # imm = 0x1BC
callq 0xa0b0
leaq 0x1fc6f(%rip), %rdi     # 0x2eed6
leaq 0x1f7d7(%rip), %rsi     # 0x2ea45
leaq 0x1fc16(%rip), %rcx     # 0x2ee8b
movl $0x1bd, %edx            # imm = 0x1BD
callq 0xa0b0
// File: /workspace/github_c_makefile_star2_O3/Ihsoh[P]ilang/string.c
// Function: rstr_ltrim_ex
void rstr_ltrim_ex(
	ResizableString *dst,
	ResizableString *src,
	RstrCharComparer comparer
) {
	assert(dst);
	assert(src);
	assert(dst != src);
	assert(comparer);

	int start = 0;
	for (; start < RSTR_LEN(src) && comparer(RSTR_CHAR(src, start)); start++);

	rstr_sub_string(dst, src, start, RSTR_LEN(src) - start);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
testq %rdi, %rdi
je 0xf368
movq %rsi, %rbx
testq %rsi, %rsi
je 0xf387
movq %rdi, %r14
cmpq %rbx, %rdi
je 0xf3a6
movq %rdx, %r15
testq %rdx, %rdx
je 0xf3c5
movl 0x4(%rbx), %ecx
xorl %r12d, %r12d
testl %ecx, %ecx
jle 0xf346
leaq 0x1f471(%rip), %r13     # 0x2e792
movq 0x8(%rbx), %rax
testq %rax, %rax
cmoveq %r13, %rax
movsbl (%rax,%r12), %edi
callq *%r15
movl 0x4(%rbx), %ecx
testb %al, %al
je 0xf346
movslq %ecx, %rax
incq %r12
cmpq %rax, %r12
jl 0xf321
movl %r12d, %edx
subl %r12d, %ecx
movslq %ecx, %rcx
movq %r14, %rdi
movq %rbx, %rsi
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0xf19a
leaq 0x1dcfa(%rip), %rdi     # 0x2d069
leaq 0x1f6cf(%rip), %rsi     # 0x2ea45
leaq 0x1fb87(%rip), %rcx     # 0x2ef04
movl $0x1d9, %edx            # imm = 0x1D9
callq 0xa0b0
leaq 0x1fb4f(%rip), %rdi     # 0x2eedd
leaq 0x1f6b0(%rip), %rsi     # 0x2ea45
leaq 0x1fb68(%rip), %rcx     # 0x2ef04
movl $0x1da, %edx            # imm = 0x1DA
callq 0xa0b0
leaq 0x1fb29(%rip), %rdi     # 0x2eed6
leaq 0x1f691(%rip), %rsi     # 0x2ea45
leaq 0x1fb49(%rip), %rcx     # 0x2ef04
movl $0x1db, %edx            # imm = 0x1DB
callq 0xa0b0
leaq 0x1e8eb(%rip), %rdi     # 0x2dcb7
leaq 0x1f672(%rip), %rsi     # 0x2ea45
leaq 0x1fb2a(%rip), %rcx     # 0x2ef04
movl $0x1dc, %edx            # imm = 0x1DC
callq 0xa0b0