LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O3/Ihsoh[P]ilang/lexer.c
// Function: lexer_new_token
LexerToken * lexer_new_token(LexerContext *ctx, int type) {
	assert(ctx);

	LexerToken *token = (LexerToken *)malloc(sizeof(LexerToken));
	if (token == NULL) {
		ctx->alloc_mem_error(ctx);
	}

	lexer_init_token(ctx, token, type);

	token->tks_next = ctx->tokens;
	ctx->tokens = token;

	return token;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
testq %rdi, %rdi
je 0xb4ff
movl %esi, %r14d
movq %rdi, %rbx
movl $0x40, %edi
callq 0xa130
testq %rax, %rax
je 0xb51e
movl %r14d, (%rax)
movl $0x1, 0x4(%rax)
movslq 0x34(%rbx), %rcx
addq 0x28(%rbx), %rcx
movq %rcx, 0x8(%rax)
movq (%rbx), %rcx
movq %rcx, 0x10(%rax)
movl 0x38(%rbx), %ecx
movl %ecx, 0x18(%rax)
movl 0x3c(%rbx), %ecx
movl %ecx, 0x1c(%rax)
movq $0x0, 0x38(%rax)
xorps %xmm0, %xmm0
movups %xmm0, 0x20(%rax)
movq 0x68(%rbx), %rcx
movq %rcx, 0x30(%rax)
movq %rax, 0x68(%rbx)
popq %rbx
popq %r14
popq %rbp
retq
leaq 0x248be(%rip), %rdi     # 0x2fdc4
leaq 0x27aaa(%rip), %rsi     # 0x32fb7
leaq 0x221d6(%rip), %rcx     # 0x2d6ea
movl $0x116, %edx            # imm = 0x116
callq 0xa0b0
movq %rbx, %rdi
callq *0x2090(%rbx)
leaq 0x21f8c(%rip), %rdi     # 0x2d4ba
leaq 0x27a82(%rip), %rsi     # 0x32fb7
leaq 0x22175(%rip), %rcx     # 0x2d6b1
movl $0x104, %edx            # imm = 0x104
callq 0xa0b0
// File: /workspace/github_c_makefile_star2_O3/Ihsoh[P]ilang/lexer.c
// Function: lexer_clone_token
LexerToken * lexer_clone_token(LexerContext *ctx, LexerToken *token) {
	assert(ctx);
	assert(token);

	LexerToken *new_token = (LexerToken *)malloc(sizeof(LexerToken));
	if (new_token == NULL) {
		ctx->alloc_mem_error(ctx);
	}

	memcpy(new_token, token, sizeof(LexerToken));

	new_token->tks_next = ctx->tokens;
	ctx->tokens = new_token;

	return new_token;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
testq %rdi, %rdi
je 0xb5bb
movq %rsi, %r14
testq %rsi, %rsi
je 0xb5da
movq %rdi, %rbx
movl $0x40, %edi
callq 0xa130
movq %rax, %r15
testq %rax, %rax
jne 0xb57b
movq %rbx, %rdi
callq *0x2090(%rbx)
movups (%r14), %xmm0
movups 0x10(%r14), %xmm1
movups 0x20(%r14), %xmm2
movups 0x30(%r14), %xmm3
movups %xmm3, 0x30(%r15)
movups %xmm2, 0x20(%r15)
movups %xmm1, 0x10(%r15)
movups %xmm0, (%r15)
movq 0x68(%rbx), %rax
movq %rax, 0x30(%r15)
movq %r15, 0x68(%rbx)
movq %r15, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
leaq 0x24802(%rip), %rdi     # 0x2fdc4
leaq 0x279ee(%rip), %rsi     # 0x32fb7
leaq 0x2214b(%rip), %rcx     # 0x2d71b
movl $0x126, %edx            # imm = 0x126
callq 0xa0b0
leaq 0x21ed9(%rip), %rdi     # 0x2d4ba
leaq 0x279cf(%rip), %rsi     # 0x32fb7
leaq 0x2212c(%rip), %rcx     # 0x2d71b
movl $0x127, %edx            # imm = 0x127
callq 0xa0b0
// File: /workspace/github_c_makefile_star2_O3/Ihsoh[P]ilang/lexer.c
// Function: lexer_parse
void lexer_parse(LexerContext *ctx) {
	assert(ctx);
	assert(ctx->matchers[0].name != NULL);

	const LexerTokenMatcher *matchers = ctx->matchers;

	while (ctx->index < ctx->len - 1) {
		LexerToken *token = NULL;
		int abandon = 0;
		int last_line = 0, last_column = -1;
		for (const LexerTokenMatcher *matcher = matchers; matcher->name != NULL;matcher++) {
			_store_char_context(ctx);
			int a;
			LexerToken *t = matcher->match(ctx, &a);
			if (t != NULL && (token == NULL || t->len > token->len)) {
				token = t;
				abandon = a;
				last_line = ctx->line;
				last_column = ctx->column;
			}
			_resume_char_context(ctx);
		}

		if (token != NULL) {
			ctx->index += token->len;
			ctx->line = last_line;
			ctx->column = last_column;
			if (!abandon) {
				_add_token(ctx, token);
			}
		} else {
			lexer_next_char(ctx);
			ctx->invalid_token(ctx);
		}
	}

	lexer_reset_token(ctx, 1);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
testq %rdi, %rdi
je 0xb842
movq %rdi, %rbx
movq 0x2078(%rdi), %rax
movq %rax, -0x38(%rbp)
cmpq $0x0, (%rax)
je 0xb861
movl 0x30(%rbx), %ecx
movl 0x34(%rbx), %eax
decl %ecx
cmpl %ecx, %eax
jge 0xb82b
movq -0x38(%rbp), %rcx
addq $0x10, %rcx
movq %rcx, -0x40(%rbp)
movq -0x38(%rbp), %rcx
cmpq $0x0, (%rcx)
je 0xb80a
movl 0x38(%rbx), %ecx
movl 0x3c(%rbx), %edx
xorl %r15d, %r15d
movl $0xffffffff, -0x2c(%rbp) # imm = 0xFFFFFFFF
movq -0x40(%rbp), %r13
xorl %r14d, %r14d
xorl %r12d, %r12d
movl %eax, 0x40(%rbx)
movl %ecx, 0x44(%rbx)
movl %edx, 0x48(%rbx)
movq %rbx, %rdi
leaq -0x30(%rbp), %rsi
callq *-0x8(%r13)
testq %rax, %rax
je 0xb7c5
testq %r15, %r15
je 0xb7b4
movl 0x4(%rax), %ecx
cmpl 0x4(%r15), %ecx
jle 0xb7c5
movl -0x30(%rbp), %r12d
movl 0x38(%rbx), %r14d
movl 0x3c(%rbx), %ecx
movl %ecx, -0x2c(%rbp)
movq %rax, %r15
movl 0x40(%rbx), %eax
movl 0x44(%rbx), %ecx
movl %eax, 0x34(%rbx)
movl %ecx, 0x38(%rbx)
movl 0x48(%rbx), %edx
movl %edx, 0x3c(%rbx)
cmpq $0x0, (%r13)
leaq 0x10(%r13), %r13
jne 0xb78d
testq %r15, %r15
je 0xb80a
addl 0x4(%r15), %eax
movl %eax, 0x34(%rbx)
movl %r14d, 0x38(%rbx)
movl -0x2c(%rbp), %eax
movl %eax, 0x3c(%rbx)
testl %r12d, %r12d
jne 0xb81b
movq %rbx, %rdi
movq %r15, %rsi
callq 0xb880
jmp 0xb81b
movq %rbx, %rdi
callq 0xb1ec
movq %rbx, %rdi
callq *0x2088(%rbx)
movl 0x30(%rbx), %ecx
movl 0x34(%rbx), %eax
decl %ecx
cmpl %ecx, %eax
jl 0xb765
movq 0x50(%rbx), %rax
movq %rax, 0x60(%rbx)
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
leaq 0x2457b(%rip), %rdi     # 0x2fdc4
leaq 0x27767(%rip), %rsi     # 0x32fb7
leaq 0x22002(%rip), %rcx     # 0x2d859
movl $0x153, %edx            # imm = 0x153
callq 0xa0b0
leaq 0x22012(%rip), %rdi     # 0x2d87a
leaq 0x27748(%rip), %rsi     # 0x32fb7
leaq 0x21fe3(%rip), %rcx     # 0x2d859
movl $0x154, %edx            # imm = 0x154
callq 0xa0b0
// File: /workspace/github_c_makefile_star2_O3/Ihsoh[P]ilang/lexer.c
// Function: add_token
static void _add_token(LexerContext *ctx, LexerToken *token) {
	assert(ctx);
	assert(token);
	assert((ctx->head == NULL && ctx->tail == NULL) || (ctx->head != NULL && ctx->tail != NULL));

	if (ctx->current == NULL) {
		ctx->current = token;
		token->prev = NULL;
		token->next = NULL;
	} else {
		ctx->current->next = token;
		token->prev = ctx->current;
		token->next = NULL;
		ctx->current = token;
		ctx->tail = token;
	}

	if (ctx->head == NULL && ctx->tail == NULL) {
		ctx->head = ctx->current;
		ctx->tail = ctx->current;
	}
}

// Assembly:
movq 0x50(%rdi), %rax
movq 0x58(%rdi), %rcx
testq %rax, %rax
je 0xb894
testq %rcx, %rcx
jne 0xb89b
jmp 0xb8cd
testq %rcx, %rcx
jne 0xb8cd
xorl %ecx, %ecx
movq 0x60(%rdi), %rdx
testq %rdx, %rdx
je 0xb8af
movq %rsi, 0x28(%rdx)
movq %rsi, 0x58(%rdi)
movq %rsi, %rcx
movq %rsi, 0x60(%rdi)
movq %rdx, 0x20(%rsi)
movq $0x0, 0x28(%rsi)
orq %rcx, %rax
jne 0xb8cc
movq %rsi, 0x50(%rdi)
movq %rsi, 0x58(%rdi)
retq
pushq %rbp
movq %rsp, %rbp
leaq 0x221ef(%rip), %rdi     # 0x2dac7
leaq 0x276d8(%rip), %rsi     # 0x32fb7
leaq 0x221b3(%rip), %rcx     # 0x2da99
movl $0x11, %edx
callq 0xa0b0
// File: /workspace/github_c_makefile_star2_O3/Ihsoh[P]ilang/lexer.c
// Function: lexer_parse_first
void lexer_parse_first(LexerContext *ctx) {
	assert(ctx);
	assert(ctx->matchers[0].name != NULL);

	const LexerTokenMatcher *matchers = ctx->matchers;

	while (ctx->index < ctx->len - 1) {
		LexerToken *token = NULL;
		int abandon = 0;
		int last_line = 0, last_column = -1;
		bool finded = false;
		for (const LexerTokenMatcher *matcher = matchers; !finded && matcher->name != NULL;matcher++) {
			_store_char_context(ctx);
			int a;
			token = matcher->match(ctx, &a);
			if (token != NULL) {
				abandon = a;
				last_line = ctx->line;
				last_column = ctx->column;
				finded = true;
			}
			_resume_char_context(ctx);
		}

		if (token != NULL) {
			ctx->index += token->len;
			ctx->line = last_line;
			ctx->column = last_column;
			if (!abandon) {
				_add_token(ctx, token);
			}
		} else {
			lexer_next_char(ctx);
			ctx->invalid_token(ctx);
		}
	}

	lexer_reset_token(ctx, 1);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
testq %rdi, %rdi
je 0xb9bb
movq %rdi, %rbx
movq 0x2078(%rdi), %r15
cmpq $0x0, (%r15)
je 0xb9da
movl 0x30(%rbx), %ecx
movl 0x34(%rbx), %eax
decl %ecx
cmpl %ecx, %eax
jge 0xb9a4
leaq 0x10(%r15), %r12
leaq -0x2c(%rbp), %r14
cmpq $0x0, (%r15)
je 0xb96b
movq %r12, %r13
movl %eax, 0x40(%rbx)
movq 0x38(%rbx), %rax
movq %rax, 0x44(%rbx)
movq %rbx, %rdi
movq %r14, %rsi
callq *-0x8(%r13)
testq %rax, %rax
jne 0xb97e
movl 0x40(%rbx), %eax
movl %eax, 0x34(%rbx)
movq 0x44(%rbx), %rcx
movq %rcx, 0x38(%rbx)
cmpq $0x0, (%r13)
leaq 0x10(%r13), %r13
jne 0xb938
movq %rbx, %rdi
callq 0xb1ec
movq %rbx, %rdi
callq *0x2088(%rbx)
jmp 0xb998
movl 0x40(%rbx), %ecx
addl 0x4(%rax), %ecx
cmpl $0x0, -0x2c(%rbp)
movl %ecx, 0x34(%rbx)
jne 0xb998
movq %rbx, %rdi
movq %rax, %rsi
callq 0xb880
movl 0x30(%rbx), %ecx
movl 0x34(%rbx), %eax
decl %ecx
cmpl %ecx, %eax
jl 0xb92f
movq 0x50(%rbx), %rax
movq %rax, 0x60(%rbx)
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
leaq 0x24402(%rip), %rdi     # 0x2fdc4
leaq 0x275ee(%rip), %rsi     # 0x32fb7
leaq 0x21ec8(%rip), %rcx     # 0x2d898
movl $0x17a, %edx            # imm = 0x17A
callq 0xa0b0
leaq 0x21e99(%rip), %rdi     # 0x2d87a
leaq 0x275cf(%rip), %rsi     # 0x32fb7
leaq 0x21ea9(%rip), %rcx     # 0x2d898
movl $0x17b, %edx            # imm = 0x17B
callq 0xa0b0
// File: /workspace/github_c_makefile_star2_O3/Ihsoh[P]ilang/lexer.c
// Function: lexer_change_file_by_token
void lexer_change_file_by_token(
	LexerContext *ctx,
	LexerToken *token
) {
	assert(ctx);
	assert(token);

	char *cstr = (char *)malloc(token->len + 1);
	memcpy(cstr, token->content, token->len);
	cstr[token->len] = '\0';

	ctx->file = cstr;
	rarr_append_with_raw(&(ctx->rarr_file), &cstr, 1);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
testq %rdi, %rdi
je 0xbad6
movq %rsi, %r14
testq %rsi, %rsi
je 0xbaf5
movq %rdi, %rbx
movslq 0x4(%r14), %r15
leaq 0x1(%r15), %rdi
callq 0xa130
movq %rax, %r12
leaq -0x30(%rbp), %r13
movq %rax, (%r13)
movq 0x8(%r14), %rsi
movq %rax, %rdi
movq %r15, %rdx
callq 0xa120
movb $0x0, (%r12,%r15)
movq %r12, (%rbx)
addq $0x8, %rbx
movl $0x1, %edx
movq %rbx, %rdi
movq %r13, %rsi
callq 0xa3f8
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
leaq 0x242e7(%rip), %rdi     # 0x2fdc4
leaq 0x274d3(%rip), %rsi     # 0x32fb7
leaq 0x21e0a(%rip), %rcx     # 0x2d8f5
movl $0x1af, %edx            # imm = 0x1AF
callq 0xa0b0
leaq 0x219be(%rip), %rdi     # 0x2d4ba
leaq 0x274b4(%rip), %rsi     # 0x32fb7
leaq 0x21deb(%rip), %rcx     # 0x2d8f5
movl $0x1b0, %edx            # imm = 0x1B0
callq 0xa0b0
// File: /workspace/github_c_makefile_star2_O3/Ihsoh[P]ilang/lexer.c
// Function: lexer_print_token_info
void lexer_print_token_info(
	LexerToken *token,
	FILE *file
) {
	assert(token);
	assert(file);

	fputs("Name: ", file);
	cmn_print_token(token, file);
	fputc('\n', file);

	fprintf(file, "Length: %d\n", token->len);
	fprintf(file, "Type: 0x%x(%d)\n", token->type, token->type);
	fprintf(file, "File: %s\n", token->file);
	fprintf(file, "Line: %d\n", token->line);
	fprintf(file, "Column: %d\n", token->column);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
testq %rdi, %rdi
je 0xbbc8
movq %rsi, %rbx
testq %rsi, %rsi
je 0xbbe7
movq %rdi, %r14
leaq 0x21e2b(%rip), %rdi     # 0x2d965
movq %rbx, %rsi
callq 0xa0c0
movq %r14, %rdi
movq %rbx, %rsi
callq 0xabcc
movl $0xa, %edi
movq %rbx, %rsi
callq 0xa0d0
movl 0x4(%r14), %edx
leaq 0x21e07(%rip), %rsi     # 0x2d96c
movq %rbx, %rdi
xorl %eax, %eax
callq 0xa100
movl (%r14), %ecx
leaq 0x21dff(%rip), %rsi     # 0x2d978
movq %rbx, %rdi
movl %ecx, %edx
xorl %eax, %eax
callq 0xa100
movq 0x10(%r14), %rdx
leaq 0x21df8(%rip), %rsi     # 0x2d988
movq %rbx, %rdi
xorl %eax, %eax
callq 0xa100
movl 0x18(%r14), %edx
leaq 0x21ded(%rip), %rsi     # 0x2d992
movq %rbx, %rdi
xorl %eax, %eax
callq 0xa100
movl 0x1c(%r14), %edx
leaq 0x21de2(%rip), %rsi     # 0x2d99c
movq %rbx, %rdi
xorl %eax, %eax
popq %rbx
popq %r14
popq %rbp
jmp 0xa100
leaq 0x218eb(%rip), %rdi     # 0x2d4ba
leaq 0x273e1(%rip), %rsi     # 0x32fb7
leaq 0x21d56(%rip), %rcx     # 0x2d933
movl $0x1be, %edx            # imm = 0x1BE
callq 0xa0b0
leaq 0x21e1b(%rip), %rdi     # 0x2da09
leaq 0x273c2(%rip), %rsi     # 0x32fb7
leaq 0x21d37(%rip), %rcx     # 0x2d933
movl $0x1bf, %edx            # imm = 0x1BF
callq 0xa0b0
// File: /workspace/github_c_makefile_star2_O3/Ihsoh[P]ilang/lexer.c
// Function: lexer_print_tokens
void lexer_print_tokens(
	LexerContext * ctx,
	FILE *file
) {
	assert(ctx);
	assert(file);

	LexerToken *token = ctx->head;
	
	while (token != NULL) {
		lexer_print_token_info(token, file);
		fputc('\n', file);

		token = token->next;
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
testq %rdi, %rdi
je 0xbc46
movq %rsi, %rbx
testq %rsi, %rsi
je 0xbc65
movq 0x50(%rdi), %r14
testq %r14, %r14
je 0xbc41
movq %r14, %rdi
movq %rbx, %rsi
callq 0xbb14
movl $0xa, %edi
movq %rbx, %rsi
callq 0xa0d0
movq 0x28(%r14), %r14
jmp 0xbc1e
popq %rbx
popq %r14
popq %rbp
retq
leaq 0x24177(%rip), %rdi     # 0x2fdc4
leaq 0x27363(%rip), %rsi     # 0x32fb7
leaq 0x21d4d(%rip), %rcx     # 0x2d9a8
movl $0x1d0, %edx            # imm = 0x1D0
callq 0xa0b0
leaq 0x21d9d(%rip), %rdi     # 0x2da09
leaq 0x27344(%rip), %rsi     # 0x32fb7
leaq 0x21d2e(%rip), %rcx     # 0x2d9a8
movl $0x1d1, %edx            # imm = 0x1D1
callq 0xa0b0
// File: /workspace/github_c_makefile_star2_O3/Ihsoh[P]ilang/list.c
// Function: llst_free
void llst_free(
	LinkedList *llst,
	bool free_data
) {
	assert(llst);

	LinkedListNode *node = llst->head;
	while (node != NULL) {
		if (free_data
				&& node->data != NULL) {
			llst->releaser(node->data);
			node->data = NULL;
		}
		LinkedListNode *tmp = node;
		node = node->next;
		free(tmp);
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
testq %rdi, %rdi
je 0xbd70
movq %rdi, %r14
movq (%rdi), %r15
testq %r15, %r15
je 0xbd67
movl %esi, %ebx
testb %bl, %bl
je 0xbd53
movq 0x8(%r15), %rdi
testq %rdi, %rdi
je 0xbd53
callq *0x20(%r14)
movq 0x18(%r15), %r12
movq %r15, %rdi
callq 0xa1a0
movq %r12, %r15
testq %r12, %r12
jne 0xbd42
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
leaq 0x21e7b(%rip), %rdi     # 0x2dbf2
leaq 0x21d9e(%rip), %rsi     # 0x2db1c
leaq 0x21de3(%rip), %rcx     # 0x2db68
movl $0x2f, %edx
callq 0xa0b0
// File: /workspace/github_c_makefile_star2_O3/Ihsoh[P]ilang/list.c
// Function: llst_append
void llst_append(
	LinkedList *llst,
	void *data
) {
	LinkedListNode *node = (LinkedListNode *)malloc(sizeof(LinkedListNode));
	node->llst = llst;
	node->data = data;

	if (llst->head == NULL && llst->tail == NULL) {
		llst->head = node;
		llst->tail = node;
		node->previous = NULL;
		node->next = NULL;
	} else if (llst->head != NULL && llst->tail != NULL) {
		llst->tail->next = node;
		node->previous = llst->tail;
		node->next = NULL;
		llst->tail = node;
	} else {
		assert(0);
	}

	llst->count++;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
movq %rsi, %r14
movq %rdi, %rbx
movl $0x20, %edi
callq 0xa130
movq %rbx, (%rax)
movq %r14, 0x8(%rax)
cmpq $0x0, (%rbx)
movq 0x8(%rbx), %rcx
je 0xbdd2
testq %rcx, %rcx
je 0xbdee
movq %rax, 0x18(%rcx)
movq %rcx, 0x10(%rax)
movq $0x0, 0x18(%rax)
movq %rax, 0x8(%rbx)
jmp 0xbde5
testq %rcx, %rcx
jne 0xbdee
movq %rax, (%rbx)
movq %rax, 0x8(%rbx)
xorps %xmm0, %xmm0
movups %xmm0, 0x10(%rax)
incq 0x10(%rbx)
popq %rbx
popq %r14
popq %rbp
retq
leaq 0x2257b(%rip), %rdi     # 0x2e370
leaq 0x21d20(%rip), %rsi     # 0x2db1c
leaq 0x21d89(%rip), %rcx     # 0x2db8c
movl $0x51, %edx
callq 0xa0b0
// File: /workspace/github_c_makefile_star2_O3/Ihsoh[P]ilang/list.c
// Function: llst_remove
void llst_remove(
	LinkedList *llst,
	LinkedListNode *node
) {
	assert(llst);
	assert(node);
	assert(node->llst == llst);

	if (llst->head == node && llst->tail == node) {
		llst->head = NULL;
		llst->tail = NULL;
	} else if (llst->head == node && llst->tail != node) {
		node->next->previous = NULL;
		llst->head = node->next;
	} else if (llst->head != node && llst->tail == node) {
		node->previous->next = NULL;
		llst->tail = node->previous;
	} else if (llst->head != node && llst->tail != node) {
		node->previous->next = node->next;
		node->next->previous = node->previous;
	} else {
		assert(0);
	}

	llst->count--;
	node->llst = NULL;
	node->previous = NULL;
	node->next = NULL;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
testq %rdi, %rdi
je 0xbe8a
testq %rsi, %rsi
je 0xbea9
cmpq %rdi, (%rsi)
jne 0xbec8
movq 0x8(%rdi), %rax
cmpq %rsi, (%rdi)
je 0xbe48
cmpq %rsi, %rax
je 0xbe5e
movq 0x10(%rsi), %rax
movq 0x18(%rsi), %rcx
movq %rcx, 0x18(%rax)
movq %rax, 0x10(%rcx)
jmp 0xbe76
cmpq %rsi, %rax
je 0xbe70
movq 0x18(%rsi), %rax
movq $0x0, 0x10(%rax)
movq %rax, (%rdi)
jmp 0xbe76
movq 0x10(%rsi), %rax
movq $0x0, 0x18(%rax)
movq %rax, 0x8(%rdi)
jmp 0xbe76
xorps %xmm0, %xmm0
movups %xmm0, (%rdi)
decq 0x10(%rdi)
movq $0x0, (%rsi)
xorps %xmm0, %xmm0
movups %xmm0, 0x10(%rsi)
popq %rbp
retq
leaq 0x21d61(%rip), %rdi     # 0x2dbf2
leaq 0x21c84(%rip), %rsi     # 0x2db1c
leaq 0x21d14(%rip), %rcx     # 0x2dbb3
movl $0x5b, %edx
callq 0xa0b0
leaq 0x25dfb(%rip), %rdi     # 0x31cab
leaq 0x21c65(%rip), %rsi     # 0x2db1c
leaq 0x21cf5(%rip), %rcx     # 0x2dbb3
movl $0x5c, %edx
callq 0xa0b0
leaq 0x21d15(%rip), %rdi     # 0x2dbe4
leaq 0x21c46(%rip), %rsi     # 0x2db1c
leaq 0x21cd6(%rip), %rcx     # 0x2dbb3
movl $0x5d, %edx
callq 0xa0b0
// File: /workspace/github_c_makefile_star2_O3/Ihsoh[P]ilang/list.c
// Function: llst_delete
void llst_delete(
	LinkedList *llst,
	LinkedListNode *node,
	bool free_data
) {
	assert(llst);
	assert(node);

	llst_remove(llst, node);
	if (free_data
			&& node->data != NULL) {
		llst->releaser(node->data);
	}
	free(node);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
testq %rdi, %rdi
je 0xbf30
movq %rsi, %rbx
testq %rsi, %rsi
je 0xbf4f
movl %edx, %r15d
movq %rdi, %r14
movq %rbx, %rsi
callq 0xbe0d
testb %r15b, %r15b
je 0xbf1e
movq 0x8(%rbx), %rdi
testq %rdi, %rdi
je 0xbf1e
callq *0x20(%r14)
movq %rbx, %rdi
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
jmp 0xa1a0
leaq 0x21cbb(%rip), %rdi     # 0x2dbf2
leaq 0x21bde(%rip), %rsi     # 0x2db1c
leaq 0x21cb2(%rip), %rcx     # 0x2dbf7
movl $0x7a, %edx
callq 0xa0b0
leaq 0x25d55(%rip), %rdi     # 0x31cab
leaq 0x21bbf(%rip), %rsi     # 0x2db1c
leaq 0x21c93(%rip), %rcx     # 0x2dbf7
movl $0x7b, %edx
callq 0xa0b0
// File: /workspace/github_c_makefile_star2_O3/Ihsoh[P]ilang/list.c
// Function: llst_find_with_comparer
LinkedListNode *llst_find_with_comparer(
	LinkedList *llst,
	LinkedListComparer comparer,
	void *data
) {
	assert(llst);
	assert(comparer);
	assert(data);

	LinkedListNode *node = llst->head;
	while (node != NULL) {
		if (comparer(node->data, data)) {
			return node;
		}
		node = node->next;
	}

	return NULL;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
testq %rdi, %rdi
je 0xbfba
movq %rsi, %r14
testq %rsi, %rsi
je 0xbfd9
movq %rdx, %rbx
testq %rdx, %rdx
je 0xbff8
movq (%rdi), %r15
testq %r15, %r15
je 0xbfa9
movq 0x8(%r15), %rdi
movq %rbx, %rsi
callq *%r14
testb %al, %al
jne 0xbfac
movq 0x18(%r15), %r15
jmp 0xbf90
xorl %r15d, %r15d
movq %r15, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
leaq 0x21c31(%rip), %rdi     # 0x2dbf2
leaq 0x21b54(%rip), %rsi     # 0x2db1c
leaq 0x21c60(%rip), %rcx     # 0x2dc2f
movl $0x8a, %edx
callq 0xa0b0
leaq 0x21cd7(%rip), %rdi     # 0x2dcb7
leaq 0x21b35(%rip), %rsi     # 0x2db1c
leaq 0x21c41(%rip), %rcx     # 0x2dc2f
movl $0x8b, %edx
callq 0xa0b0
leaq 0x2a55c(%rip), %rdi     # 0x3655b
leaq 0x21b16(%rip), %rsi     # 0x2db1c
leaq 0x21c22(%rip), %rcx     # 0x2dc2f
movl $0x8c, %edx
callq 0xa0b0
// File: /workspace/github_c_makefile_star2_O3/Ihsoh[P]ilang/list.c
// Function: llst_find
LinkedListNode *llst_find(
	LinkedList *llst,
	void *data
) {
	assert(llst);
	assert(llst->comparer);
	assert(data);

	return llst_find_with_comparer(llst, llst->comparer, data);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
testq %rdi, %rdi
je 0xc064
movq 0x18(%rdi), %r15
testq %r15, %r15
je 0xc083
movq %rsi, %rbx
testq %rsi, %rsi
je 0xc0a2
movq (%rdi), %r14
testq %r14, %r14
je 0xc053
movq 0x8(%r14), %rdi
movq %rbx, %rsi
callq *%r15
testb %al, %al
jne 0xc056
movq 0x18(%r14), %r14
jmp 0xc03a
xorl %r14d, %r14d
movq %r14, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
leaq 0x21b87(%rip), %rdi     # 0x2dbf2
leaq 0x21aaa(%rip), %rsi     # 0x2db1c
leaq 0x21c08(%rip), %rcx     # 0x2dc81
movl $0x9d, %edx
callq 0xa0b0
leaq 0x21c27(%rip), %rdi     # 0x2dcb1
leaq 0x21a8b(%rip), %rsi     # 0x2db1c
leaq 0x21be9(%rip), %rcx     # 0x2dc81
movl $0x9e, %edx
callq 0xa0b0
leaq 0x2a4b2(%rip), %rdi     # 0x3655b
leaq 0x21a6c(%rip), %rsi     # 0x2db1c
leaq 0x21bca(%rip), %rcx     # 0x2dc81
movl $0x9f, %edx
callq 0xa0b0
// File: /workspace/github_c_makefile_star2_O3/Ihsoh[P]ilang/map.c
// Function: map_init
void map_init(
	Map *map,
	MapComparer key_comparer,
	MapComparer value_comparer,
	MapReleaser key_releaser,
	MapReleaser value_releaser
) {
	assert(map);

	llst_init(&(map->llst), NULL, free);

	if (key_comparer == NULL) {
		map->key_comparer = _invalid_comparer;
	} else {
		map->key_comparer = key_comparer;
	}
	if (value_comparer == NULL) {
		map->value_comparer = _invalid_comparer;
	} else {
		map->value_comparer = value_comparer;
	}

	if (key_releaser == NULL) {
		map->key_releaser = _invalid_releaser;
	} else {
		map->key_releaser = key_releaser;
	}
	if (value_releaser == NULL) {
		map->value_releaser = _invalid_releaser;
	} else {
		map->value_releaser = value_releaser;
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
testq %rdi, %rdi
je 0xc479
movq %r8, %rbx
movq %rcx, %r15
movq %rdx, %r12
movq %rsi, %r13
movq %rdi, %r14
movq 0x32b97(%rip), %rdx     # 0x3efc0
xorl %esi, %esi
callq 0xbc84
testq %r13, %r13
leaq 0x5e(%rip), %rax        # 0xc498
cmoveq %rax, %r13
movq %r13, 0x28(%r14)
testq %r12, %r12
cmoveq %rax, %r12
movq %r12, 0x30(%r14)
testq %r15, %r15
leaq 0x64(%rip), %rax        # 0xc4bb
cmoveq %rax, %r15
movq %r15, 0x38(%r14)
testq %rbx, %rbx
cmoveq %rax, %rbx
movq %rbx, 0x40(%r14)
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
leaq 0x21c69(%rip), %rdi     # 0x2e0e9
leaq 0x218c0(%rip), %rsi     # 0x2dd47
leaq 0x218bf(%rip), %rcx     # 0x2dd4d
movl $0x1d, %edx
callq 0xa0b0
// File: /workspace/github_c_makefile_star2_O3/Ihsoh[P]ilang/map.c
// Function: map_free
void map_free(
	Map *map,
	bool free_key,
	bool free_value
) {
	if (free_key || free_value) {
		LinkedListNode *node = map->llst.head;
		while (node != NULL) {
			MapEntry *entry = (MapEntry *) node->data;

			if (free_key
					&& entry->key != NULL) {
				map->key_releaser(entry->key);
				entry->key = NULL;
			}

			if (free_value
					&& entry->value != NULL) {
				map->value_releaser(entry->value);
				entry->value = NULL;
			}

			node = node->next;
		}
	}

	llst_free(&(map->llst), true);
	map->key_comparer = NULL;
	map->value_comparer = NULL;
	map->key_releaser = NULL;
	map->value_releaser = NULL;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movl %edx, %r14d
movl %esi, %r15d
movq %rdi, %rbx
movl %r15d, %eax
orb %r14b, %al
cmpb $0x1, %al
jne 0xc545
movq (%rbx), %r12
testq %r12, %r12
je 0xc545
movq 0x8(%r12), %r13
testb %r15b, %r15b
je 0xc525
movq 0x8(%r13), %rdi
testq %rdi, %rdi
je 0xc525
callq *0x38(%rbx)
movq $0x0, 0x8(%r13)
testb %r14b, %r14b
je 0xc53e
movq 0x10(%r13), %rdi
testq %rdi, %rdi
je 0xc53e
callq *0x40(%rbx)
movq $0x0, 0x10(%r13)
movq 0x18(%r12), %r12
jmp 0xc502
movq %rbx, %rdi
movl $0x1, %esi
callq 0xbd25
xorps %xmm0, %xmm0
movups %xmm0, 0x38(%rbx)
movups %xmm0, 0x28(%rbx)
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/Ihsoh[P]ilang/map.c
// Function: map_set
void map_set(
	Map *map,
	void *key,
	void *value,
	bool free_old_value
) {
	assert(map);
	assert(key);

	LinkedList *llst = &(map->llst);
	LinkedListNode *node = llst_find_with_comparer(llst, _key_comparer, key);
	if (node != NULL) {
		MapEntry *entry = (MapEntry *) node->data;

		if (free_old_value
				&& entry->value != NULL) {
			map->value_releaser(entry->value);
		}

		entry->value = value;
	} else {
		MapEntry *entry = (MapEntry *) malloc(sizeof(MapEntry));

		entry->map = map;
		entry->key = key;
		entry->value = value;

		llst_append(llst, entry);
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
testq %rdi, %rdi
je 0xc5f0
movq %rsi, %r15
testq %rsi, %rsi
je 0xc60f
movl %ecx, %r12d
movq %rdx, %rbx
movq %rdi, %r14
leaq 0x96(%rip), %rsi        # 0xc62e
movq %r15, %rdx
callq 0xbf6e
testq %rax, %rax
je 0xc5c8
movq 0x8(%rax), %r15
testb %r12b, %r12b
je 0xc5bb
movq 0x10(%r15), %rdi
testq %rdi, %rdi
je 0xc5bb
callq *0x40(%r14)
movq %rbx, 0x10(%r15)
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
movl $0x18, %edi
callq 0xa130
movq %r14, (%rax)
movq %r15, 0x8(%rax)
movq %rbx, 0x10(%rax)
movq %r14, %rdi
movq %rax, %rsi
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
jmp 0xbd8f
leaq 0x21af2(%rip), %rdi     # 0x2e0e9
leaq 0x21749(%rip), %rsi     # 0x2dd47
leaq 0x21791(%rip), %rcx     # 0x2dd96
movl $0x68, %edx
callq 0xa0b0
leaq 0x217ab(%rip), %rdi     # 0x2ddc1
leaq 0x2172a(%rip), %rsi     # 0x2dd47
leaq 0x21772(%rip), %rcx     # 0x2dd96
movl $0x69, %edx
callq 0xa0b0
// File: /workspace/github_c_makefile_star2_O3/Ihsoh[P]ilang/map.c
// Function: key_comparer
static bool _key_comparer(void *node_data, void *data) {
	assert(node_data);
	assert(data);

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

// Assembly:
pushq %rbp
movq %rsp, %rbp
testq %rdi, %rdi
je 0xc64a
testq %rsi, %rsi
je 0xc669
movq (%rdi), %rax
movq 0x8(%rdi), %rdi
movq 0x28(%rax), %rax
popq %rbp
jmpq *%rax
leaq 0x21aae(%rip), %rdi     # 0x2e0ff
leaq 0x216ef(%rip), %rsi     # 0x2dd47
leaq 0x21aaa(%rip), %rcx     # 0x2e109
movl $0x5a, %edx
callq 0xa0b0
leaq 0x29eeb(%rip), %rdi     # 0x3655b
leaq 0x216d0(%rip), %rsi     # 0x2dd47
leaq 0x21a8b(%rip), %rcx     # 0x2e109
movl $0x5b, %edx
callq 0xa0b0
// File: /workspace/github_c_makefile_star2_O3/Ihsoh[P]ilang/map.c
// Function: map_get_entry
MapEntry * map_get_entry(
	Map *map,
	void *key
) {
	assert(map);
	assert(key);

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

// Assembly:
pushq %rbp
movq %rsp, %rbp
testq %rdi, %rdi
je 0xc6b4
movq %rsi, %rdx
testq %rsi, %rsi
je 0xc6d3
leaq -0x72(%rip), %rsi       # 0xc62e
callq 0xbf6e
testq %rax, %rax
je 0xc6b0
movq 0x8(%rax), %rax
jmp 0xc6b2
xorl %eax, %eax
popq %rbp
retq
leaq 0x21a2e(%rip), %rdi     # 0x2e0e9
leaq 0x21685(%rip), %rsi     # 0x2dd47
leaq 0x216fc(%rip), %rcx     # 0x2ddc5
movl $0x91, %edx
callq 0xa0b0
leaq 0x216e7(%rip), %rdi     # 0x2ddc1
leaq 0x21666(%rip), %rsi     # 0x2dd47
leaq 0x216dd(%rip), %rcx     # 0x2ddc5
movl $0x92, %edx
callq 0xa0b0
// File: /workspace/github_c_makefile_star2_O3/Ihsoh[P]ilang/map.c
// Function: map_get
void * map_get(
	Map *map,
	void *key
) {
	assert(map);
	assert(key);

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

// Assembly:
pushq %rbp
movq %rsp, %rbp
testq %rdi, %rdi
je 0xc727
movq %rsi, %rdx
testq %rsi, %rsi
je 0xc746
leaq -0xdc(%rip), %rsi       # 0xc62e
callq 0xbf6e
testq %rax, %rax
je 0xc723
movq 0x8(%rax), %rax
testq %rax, %rax
je 0xc723
movq 0x10(%rax), %rax
jmp 0xc725
xorl %eax, %eax
popq %rbp
retq
leaq 0x219bb(%rip), %rdi     # 0x2e0e9
leaq 0x21612(%rip), %rsi     # 0x2dd47
leaq 0x216b0(%rip), %rcx     # 0x2ddec
movl $0xa0, %edx
callq 0xa0b0
leaq 0x21674(%rip), %rdi     # 0x2ddc1
leaq 0x215f3(%rip), %rsi     # 0x2dd47
leaq 0x21691(%rip), %rcx     # 0x2ddec
movl $0xa1, %edx
callq 0xa0b0
// File: /workspace/github_c_makefile_star2_O3/Ihsoh[P]ilang/map.c
// Function: map_remove
bool map_remove(
	Map *map,
	void *key,
	bool free_key,
	bool free_value
) {
	assert(map);
	assert(key);

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

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
testq %rdi, %rdi
je 0xc7ec
movl %edx, %r12d
movq %rsi, %rdx
testq %rsi, %rsi
je 0xc80b
movl %ecx, %r15d
movq %rdi, %rbx
leaq -0x166(%rip), %rsi      # 0xc62e
callq 0xbf6e
movq %rax, %r14
testq %rax, %rax
je 0xc7d7
movq 0x8(%r14), %r13
testb %r12b, %r12b
je 0xc7b6
movq 0x8(%r13), %rdi
testq %rdi, %rdi
je 0xc7b6
callq *0x38(%rbx)
testb %r15b, %r15b
je 0xc7c7
movq 0x10(%r13), %rdi
testq %rdi, %rdi
je 0xc7c7
callq *0x40(%rbx)
movq %rbx, %rdi
movq %r14, %rsi
movl $0x1, %edx
callq 0xbee7
testq %r14, %r14
setne %al
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
leaq 0x218f6(%rip), %rdi     # 0x2e0e9
leaq 0x2154d(%rip), %rsi     # 0x2dd47
leaq 0x21608(%rip), %rcx     # 0x2de09
movl $0xb1, %edx
callq 0xa0b0
leaq 0x215af(%rip), %rdi     # 0x2ddc1
leaq 0x2152e(%rip), %rsi     # 0x2dd47
leaq 0x215e9(%rip), %rcx     # 0x2de09
movl $0xb2, %edx
callq 0xa0b0
// File: /workspace/github_c_makefile_star2_O3/Ihsoh[P]ilang/map.c
// Function: map_exists_key
bool map_exists_key(
	Map *map,
	void *key
) {
	assert(map);
	assert(key);

	MapEntry *entry = map_get_entry(map, key);

	return entry != NULL;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
testq %rdi, %rdi
je 0xc85a
movq %rsi, %rdx
testq %rsi, %rsi
je 0xc879
leaq -0x214(%rip), %rsi      # 0xc62e
callq 0xbf6e
testq %rax, %rax
je 0xc856
cmpq $0x0, 0x8(%rax)
setne %al
jmp 0xc858
xorl %eax, %eax
popq %rbp
retq
leaq 0x21888(%rip), %rdi     # 0x2e0e9
leaq 0x214df(%rip), %rsi     # 0x2dd47
leaq 0x215c8(%rip), %rcx     # 0x2de37
movl $0xca, %edx
callq 0xa0b0
leaq 0x21541(%rip), %rdi     # 0x2ddc1
leaq 0x214c0(%rip), %rsi     # 0x2dd47
leaq 0x215a9(%rip), %rcx     # 0x2de37
movl $0xcb, %edx
callq 0xa0b0
// File: /workspace/github_c_makefile_star2_O3/Ihsoh[P]ilang/map.c
// Function: map_iter_next
MapEntry * map_iter_next(
	Map *map,
	MapEntryIterator *iter
) {
	assert(map);
	assert(iter);

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

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

	return (MapEntry *)current->data;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
testq %rdi, %rdi
je 0xc913
testq %rsi, %rsi
je 0xc932
movq (%rsi), %rax
testq %rax, %rax
je 0xc90f
movq 0x18(%rax), %rcx
movq %rcx, (%rsi)
movq 0x8(%rax), %rax
jmp 0xc911
xorl %eax, %eax
popq %rbp
retq
leaq 0x217cf(%rip), %rdi     # 0x2e0e9
leaq 0x21426(%rip), %rsi     # 0x2dd47
leaq 0x21561(%rip), %rcx     # 0x2de89
movl $0xe3, %edx
callq 0xa0b0
leaq 0x234a0(%rip), %rdi     # 0x2fdd9
leaq 0x21407(%rip), %rsi     # 0x2dd47
leaq 0x21542(%rip), %rcx     # 0x2de89
movl $0xe4, %edx
callq 0xa0b0
// File: /workspace/github_c_makefile_star2_O3/Ihsoh[P]ilang/myassert.c
// Function: myerror
void myerror(const char *file, int line, const char *fmt, ...) {
	char buffer[4096];

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

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

	exit(0);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
subq $0x10c8, %rsp           # imm = 0x10C8
movl %esi, %ebx
movq %rdi, %r14
leaq -0xe0(%rbp), %rsi
movq %rcx, 0x18(%rsi)
movq %r8, 0x20(%rsi)
movq %r9, 0x28(%rsi)
testb %al, %al
je 0xcfad
movaps %xmm0, -0xb0(%rbp)
movaps %xmm1, -0xa0(%rbp)
movaps %xmm2, -0x90(%rbp)
movaps %xmm3, -0x80(%rbp)
movaps %xmm4, -0x70(%rbp)
movaps %xmm5, -0x60(%rbp)
movaps %xmm6, -0x50(%rbp)
movaps %xmm7, -0x40(%rbp)
leaq -0x30(%rbp), %rcx
movq %rsi, 0x10(%rcx)
leaq 0x10(%rbp), %rax
movq %rax, 0x8(%rcx)
movabsq $0x3000000018, %rax     # imm = 0x3000000018
movq %rax, (%rcx)
leaq -0x10e0(%rbp), %r15
movl $0x1000, %esi           # imm = 0x1000
movq %r15, %rdi
callq 0xa060
movq 0x32013(%rip), %rax     # 0x3eff8
movq (%rax), %rdi
leaq 0x2113e(%rip), %rsi     # 0x2e12d
movq %r14, %rdx
movl %ebx, %ecx
movq %r15, %r8
xorl %eax, %eax
callq 0xa100
xorl %edi, %edi
callq 0xa170
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O3/Ihsoh[P]ilang/parser.c
// Function: parser_new_context_with_data
ParserContext * parser_new_context_with_data(
	LexerContext *lexctx,
	size_t szdata,
	void *data
) {
	assert(lexctx);
	if (szdata > 0) {
		assert(data != NULL);
	} else {
		assert(data == NULL);
	}

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

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

	ctx->nodes = NULL;

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

	ctx->current_token = NULL;

	ctx->arch = 0;

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

	return ctx;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
testq %rdi, %rdi
je 0xd0db
movq %rdx, %r15
movq %rsi, %r14
movq %rdi, %rbx
testq %rsi, %rsi
je 0xd04e
testq %r15, %r15
jne 0xd057
leaq 0x2115d(%rip), %rdi     # 0x2e193
leaq 0x2744a(%rip), %rsi     # 0x34487
leaq 0x21103(%rip), %rcx     # 0x2e147
movl $0x92, %edx
callq 0xa0b0
testq %r15, %r15
jne 0xd0fa
leaq 0x68(%r14), %rdi
callq 0xa130
movq %rax, %r12
testq %rax, %rax
je 0xd0cf
movq %r12, %rdi
addq $0x68, %rdi
movq %r15, %rsi
movq %r14, %rdx
callq 0xa120
movq %rbx, (%r12)
xorps %xmm0, %xmm0
movups %xmm0, 0x8(%r12)
movups %xmm0, 0x18(%r12)
movups %xmm0, 0x24(%r12)
leaq 0x7f(%rip), %rax        # 0xd119
movq %rax, 0x38(%r12)
leaq 0xee(%rip), %rax        # 0xd194
movq %rax, 0x40(%r12)
leaq 0x175(%rip), %rax       # 0xd227
movq %rax, 0x48(%r12)
leaq 0x1da(%rip), %rax       # 0xd298
movq %rax, 0x50(%r12)
leaq 0x2ab(%rip), %rax       # 0xd375
movq %rax, 0x58(%r12)
movq %r12, %rax
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
leaq 0x2786d(%rip), %rdi     # 0x3494f
leaq 0x2739e(%rip), %rsi     # 0x34487
leaq 0x21057(%rip), %rcx     # 0x2e147
movl $0x90, %edx
callq 0xa0b0
leaq 0x2109f(%rip), %rdi     # 0x2e1a0
leaq 0x2737f(%rip), %rsi     # 0x34487
leaq 0x21038(%rip), %rcx     # 0x2e147
movl $0x94, %edx
callq 0xa0b0
// File: /workspace/github_c_makefile_star2_O3/Ihsoh[P]ilang/parser.c
// Function: default_alloc_mem_error
static void _default_alloc_mem_error(ParserContext *ctx) {
	assert(ctx);

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

	exit(1);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
testq %rdi, %rdi
jne 0xd141
leaq 0x22c9b(%rip), %rdi     # 0x2fdc4
leaq 0x27357(%rip), %rsi     # 0x34487
leaq 0x21582(%rip), %rcx     # 0x2e6b9
movl $0x14, %edx
callq 0xa0b0
movq 0x28(%rdi), %rsi
movq 0x31eac(%rip), %rax     # 0x3eff8
movq (%rax), %rcx
testq %rsi, %rsi
jne 0xd16c
leaq 0x215be(%rip), %rdi     # 0x2e719
movl $0x26, %esi
movl $0x1, %edx
callq 0xa180
jmp 0xd18a
movq 0x10(%rsi), %rdx
movl 0x18(%rsi), %eax
movl 0x1c(%rsi), %r8d
leaq 0x2156a(%rip), %rsi     # 0x2e6e8
movq %rcx, %rdi
movl %eax, %ecx
xorl %eax, %eax
callq 0xa100
movl $0x1, %edi
callq 0xa170
// File: /workspace/github_c_makefile_star2_O3/Ihsoh[P]ilang/parser.c
// Function: default_syntax_error
static void _default_syntax_error(ParserContext *ctx) {
	assert(ctx);

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

	exit(1);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
testq %rdi, %rdi
jne 0xd1bf
leaq 0x22c1d(%rip), %rdi     # 0x2fdc4
leaq 0x272d9(%rip), %rsi     # 0x34487
leaq 0x2158b(%rip), %rcx     # 0x2e740
movl $0x2a, %edx
callq 0xa0b0
movq 0x28(%rdi), %rbx
movq 0x31e2e(%rip), %r14     # 0x3eff8
movq (%r14), %rcx
testq %rbx, %rbx
jne 0xd1ea
leaq 0x215ba(%rip), %rdi     # 0x2e793
movl $0x1c, %esi
movl $0x1, %edx
callq 0xa180
jmp 0xd21d
movq 0x10(%rbx), %rdx
movl 0x18(%rbx), %eax
movl 0x1c(%rbx), %r8d
leaq 0x21570(%rip), %rsi     # 0x2e76c
movq %rcx, %rdi
movl %eax, %ecx
xorl %eax, %eax
callq 0xa100
movq (%r14), %rdi
movq %rbx, %rsi
movl $0x14, %edx
movl $0x14, %ecx
callq 0xac0d
movl $0x1, %edi
callq 0xa170
// File: /workspace/github_c_makefile_star2_O3/Ihsoh[P]ilang/parser.c
// Function: default_syntax_error_msg
static void _default_syntax_error_msg(
	ParserContext *ctx,
	const char *msg
) {
	assert(ctx);
	assert(msg);

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

	exit(1);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
testq %rdi, %rdi
jne 0xd24f
leaq 0x22b8d(%rip), %rdi     # 0x2fdc4
leaq 0x27249(%rip), %rsi     # 0x34487
leaq 0x2156b(%rip), %rcx     # 0x2e7b0
movl $0x44, %edx
callq 0xa0b0
movq %rsi, %rdx
testq %rsi, %rsi
jne 0xd276
leaq 0x21590(%rip), %rdi     # 0x2e7ee
leaq 0x27222(%rip), %rsi     # 0x34487
leaq 0x21544(%rip), %rcx     # 0x2e7b0
movl $0x45, %edx
callq 0xa0b0
movq 0x31d7b(%rip), %rax     # 0x3eff8
movq (%rax), %rdi
leaq 0x2156b(%rip), %rsi     # 0x2e7f2
xorl %eax, %eax
callq 0xa100
movl $0x1, %edi
callq 0xa170
// File: /workspace/github_c_makefile_star2_O3/Ihsoh[P]ilang/parser.c
// Function: default_syntax_error_token_msg
static void _default_syntax_error_token_msg(
	ParserContext *ctx,
	LexerToken *token,
	const char *msg
) {
	assert(ctx);
	assert(token);
	assert(msg);

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

	cmn_print_code_by_token(stderr, token, 20, 20);

	exit(1);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
testq %rdi, %rdi
jne 0xd2c6
leaq 0x22b16(%rip), %rdi     # 0x2fdc4
leaq 0x271d2(%rip), %rsi     # 0x34487
leaq 0x21556(%rip), %rcx     # 0x2e812
movl $0x55, %edx
callq 0xa0b0
movq %rsi, %rbx
testq %rsi, %rsi
jne 0xd2ed
leaq 0x201e5(%rip), %rdi     # 0x2d4ba
leaq 0x271ab(%rip), %rsi     # 0x34487
leaq 0x2152f(%rip), %rcx     # 0x2e812
movl $0x56, %edx
callq 0xa0b0
movq %rdx, %r14
testq %rdx, %rdx
jne 0xd314
leaq 0x214f2(%rip), %rdi     # 0x2e7ee
leaq 0x27184(%rip), %rsi     # 0x34487
leaq 0x21508(%rip), %rcx     # 0x2e812
movl $0x57, %edx
callq 0xa0b0
movq 0x31cdd(%rip), %r15     # 0x3eff8
movq (%r15), %rdi
movq 0x10(%rbx), %rdx
movl 0x18(%rbx), %ecx
movl 0x1c(%rbx), %r8d
leaq 0x21534(%rip), %rsi     # 0x2e864
xorl %eax, %eax
callq 0xa100
movq (%r15), %rsi
movq %rbx, %rdi
callq 0xabcc
movq (%r15), %rdi
leaq 0x21546(%rip), %rsi     # 0x2e892
movq %r14, %rdx
xorl %eax, %eax
callq 0xa100
movq (%r15), %rdi
movq %rbx, %rsi
movl $0x14, %edx
movl $0x14, %ecx
callq 0xac0d
movl $0x1, %edi
callq 0xa170
// File: /workspace/github_c_makefile_star2_O3/Ihsoh[P]ilang/parser.c
// Function: default_syntax_error_node_msg
static void _default_syntax_error_node_msg(
	ParserContext *ctx,
	ParserASTNode *node,
	const char *msg
) {
	assert(ctx);
	assert(msg);

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

	exit(1);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
testq %rdi, %rdi
jne 0xd39d
leaq 0x22a3f(%rip), %rdi     # 0x2fdc4
leaq 0x270fb(%rip), %rsi     # 0x34487
leaq 0x21506(%rip), %rcx     # 0x2e899
movl $0x71, %edx
callq 0xa0b0
movq %rdx, %r9
testq %rdx, %rdx
jne 0xd3c4
leaq 0x21442(%rip), %rdi     # 0x2e7ee
leaq 0x270d4(%rip), %rsi     # 0x34487
leaq 0x214df(%rip), %rcx     # 0x2e899
movl $0x72, %edx
callq 0xa0b0
movq 0x18(%rsi), %rdx
movq 0x31c29(%rip), %rax     # 0x3eff8
movq (%rax), %rdi
testq %rdx, %rdx
jne 0xd3ea
leaq 0x21414(%rip), %rsi     # 0x2e7f2
movq %r9, %rdx
xorl %eax, %eax
callq 0xa100
jmp 0xd3ff
movl 0x20(%rsi), %ecx
movl 0x24(%rsi), %r8d
leaq 0x214f5(%rip), %rsi     # 0x2e8ed
xorl %eax, %eax
callq 0xa100
movl $0x1, %edi
callq 0xa170
// File: /workspace/github_c_makefile_star2_O3/Ihsoh[P]ilang/parser.c
// Function: parser_free_context
void parser_free_context(
	ParserContext *ctx
) {
	assert(ctx);

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

	free(ctx);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
testq %rdi, %rdi
je 0xd44f
movq %rdi, %rbx
movq 0x10(%rdi), %rsi
testq %rsi, %rsi
je 0xd443
movq 0x28(%rsi), %r14
movq %rbx, %rdi
callq 0xd46e
movq %r14, %rsi
testq %r14, %r14
jne 0xd42f
movq %rbx, %rdi
popq %rbx
popq %r14
popq %rbp
jmp 0xa1a0
leaq 0x2296e(%rip), %rdi     # 0x2fdc4
leaq 0x2702a(%rip), %rsi     # 0x34487
leaq 0x20d49(%rip), %rcx     # 0x2e1ad
movl $0xbc, %edx
callq 0xa0b0
// File: /workspace/github_c_makefile_star2_O3/Ihsoh[P]ilang/parser.c
// Function: parser_free_node
void parser_free_node(
	ParserContext *ctx,
	ParserASTNode *node
) {
	assert(ctx);
	assert(node);

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

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

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

	free(node);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
testq %rdi, %rdi
je 0xd4d3
movq %rsi, %rbx
testq %rsi, %rsi
je 0xd4f2
movq %rdi, %r14
movq 0x50(%rbx), %rax
testq %rax, %rax
je 0xd496
movq %rbx, %rdi
callq *%rax
movq 0x48(%rbx), %rdi
testq %rdi, %rdi
je 0xd4a4
callq 0xa1a0
movq 0x38(%rbx), %rsi
testq %rsi, %rsi
je 0xd4c1
movq 0x10(%rsi), %r15
movq %r14, %rdi
callq 0xd66e
movq %r15, %rsi
testq %r15, %r15
jne 0xd4ad
movq %rbx, %rdi
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
jmp 0xa1a0
leaq 0x228ea(%rip), %rdi     # 0x2fdc4
leaq 0x26fa6(%rip), %rsi     # 0x34487
leaq 0x20d4a(%rip), %rcx     # 0x2e232
movl $0x107, %edx            # imm = 0x107
callq 0xa0b0
leaq 0x247b2(%rip), %rdi     # 0x31cab
leaq 0x26f87(%rip), %rsi     # 0x34487
leaq 0x20d2b(%rip), %rcx     # 0x2e232
movl $0x108, %edx            # imm = 0x108
callq 0xa0b0
// File: /workspace/github_c_makefile_star2_O3/Ihsoh[P]ilang/parser.c
// Function: parser_new_node
ParserASTNode * parser_new_node(
	ParserContext *ctx,
	int type,
	char *type_name,
	LexerToken *token,
	size_t szdata,
	void *data
) {
	assert(ctx);
	if (szdata > 0) {
		assert(data != NULL);
	} else {
		assert(data == NULL);
	}

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

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

	node->token = token;

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

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

	ctx->nodes = node;

	node->symtbl = NULL;

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

	node->releaser = NULL;

	return node;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
testq %rdi, %rdi
je 0xd630
movq %r9, %r13
movq %r8, %r12
movq %rcx, %r15
movq %rdi, %rbx
testq %r8, %r8
movq %rdx, -0x38(%rbp)
movl %esi, -0x2c(%rbp)
je 0xd567
testq %r13, %r13
jne 0xd570
leaq 0x20c44(%rip), %rdi     # 0x2e193
leaq 0x26f31(%rip), %rsi     # 0x34487
leaq 0x20c7a(%rip), %rcx     # 0x2e1d7
movl $0xd2, %edx
callq 0xa0b0
testq %r13, %r13
jne 0xd64f
leaq 0x60(%r12), %rdi
callq 0xa130
movq %rax, %r14
testq %rax, %rax
jne 0xd588
movq %rbx, %rdi
callq *0x38(%rbx)
movq %r14, %rdi
addq $0x60, %rdi
movq %r13, %rsi
movq %r12, %rdx
callq 0xa120
movl -0x2c(%rbp), %eax
movl %eax, (%r14)
movq -0x38(%rbp), %rax
movq %rax, 0x8(%r14)
movq %r15, 0x10(%r14)
testq %r15, %r15
je 0xd5c7
movq 0x10(%r15), %rax
movq %rax, 0x18(%r14)
movl 0x18(%r15), %eax
movl %eax, 0x20(%r14)
movl 0x1c(%r15), %eax
jmp 0xd5f9
movq 0x28(%rbx), %rax
testq %rax, %rax
je 0xd5e4
movq 0x10(%rax), %rcx
movq %rcx, 0x18(%r14)
movl 0x18(%rax), %ecx
movl %ecx, 0x20(%r14)
movl 0x1c(%rax), %eax
jmp 0xd5f9
movq $0x0, 0x18(%r14)
movl $0xffffffff, 0x20(%r14) # imm = 0xFFFFFFFF
movl $0xffffffff, %eax       # imm = 0xFFFFFFFF
movl %eax, 0x24(%r14)
movq 0x10(%rbx), %rax
movq %rax, 0x28(%r14)
movq $0x0, 0x30(%r14)
movq %r14, 0x10(%rbx)
xorps %xmm0, %xmm0
movups %xmm0, 0x48(%r14)
movups %xmm0, 0x38(%r14)
movq %r14, %rax
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
leaq 0x2278d(%rip), %rdi     # 0x2fdc4
leaq 0x26e49(%rip), %rsi     # 0x34487
leaq 0x20b92(%rip), %rcx     # 0x2e1d7
movl $0xd0, %edx
callq 0xa0b0
leaq 0x20b4a(%rip), %rdi     # 0x2e1a0
leaq 0x26e2a(%rip), %rsi     # 0x34487
leaq 0x20b73(%rip), %rcx     # 0x2e1d7
movl $0xd4, %edx
callq 0xa0b0
// File: /workspace/github_c_makefile_star2_O3/Ihsoh[P]ilang/parser.c
// Function: parser_free_symbol
void parser_free_symbol(
	ParserContext *ctx,
	ParserSymbol *symbol
) {
	assert(ctx);
	assert(symbol);

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

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

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
testq %rdi, %rdi
je 0xd6d0
movq %rsi, %rbx
testq %rsi, %rsi
je 0xd6ef
movq 0x18(%rbx), %r14
testq %r14, %r14
je 0xd6b0
movq 0x10(%r14), %r15
movq 0x20(%r14), %rax
testq %rax, %rax
je 0xd6a0
movq %r14, %rdi
callq *%rax
movq %r14, %rdi
callq 0xa1a0
movq %r15, %r14
testq %r15, %r15
jne 0xd68e
movq 0x20(%rbx), %rax
testq %rax, %rax
je 0xd6be
movq %rbx, %rdi
callq *%rax
movq %rbx, %rdi
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
jmp 0xa1a0
leaq 0x226ed(%rip), %rdi     # 0x2fdc4
leaq 0x26da9(%rip), %rsi     # 0x34487
leaq 0x20e0f(%rip), %rcx     # 0x2e4f4
movl $0x233, %edx            # imm = 0x233
callq 0xa0b0
leaq 0x20e37(%rip), %rdi     # 0x2e52d
leaq 0x26d8a(%rip), %rsi     # 0x34487
leaq 0x20df0(%rip), %rcx     # 0x2e4f4
movl $0x234, %edx            # imm = 0x234
callq 0xa0b0