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

	token->len = 1;
	token->content = ctx->source + ctx->index;

	token->file = ctx->file;
	token->line = ctx->line;
	token->column = ctx->column;

	token->prev = NULL;
	token->next = NULL;

	token->matcher_data = NULL;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl %edx, -0x14(%rbp)
cmpq $0x0, -0x8(%rbp)
je 0xba9c
jmp 0xbabb
leaq 0x420be(%rip), %rdi     # 0x4db61
leaq 0x408e9(%rip), %rsi     # 0x4c393
movl $0x103, %edx            # imm = 0x103
leaq 0x3ac60(%rip), %rcx     # 0x46716
callq 0xa0b0
cmpq $0x0, -0x10(%rbp)
je 0xbac4
jmp 0xbae3
leaq 0x3aa6f(%rip), %rdi     # 0x4653a
leaq 0x408c1(%rip), %rsi     # 0x4c393
movl $0x104, %edx            # imm = 0x104
leaq 0x3ac38(%rip), %rcx     # 0x46716
callq 0xa0b0
movl -0x14(%rbp), %ecx
movq -0x10(%rbp), %rax
movl %ecx, (%rax)
movq -0x10(%rbp), %rax
movl $0x1, 0x4(%rax)
movq -0x8(%rbp), %rax
movq 0x28(%rax), %rcx
movq -0x8(%rbp), %rax
movslq 0x34(%rax), %rax
addq %rax, %rcx
movq -0x10(%rbp), %rax
movq %rcx, 0x8(%rax)
movq -0x8(%rbp), %rax
movq (%rax), %rcx
movq -0x10(%rbp), %rax
movq %rcx, 0x10(%rax)
movq -0x8(%rbp), %rax
movl 0x38(%rax), %ecx
movq -0x10(%rbp), %rax
movl %ecx, 0x18(%rax)
movq -0x8(%rbp), %rax
movl 0x3c(%rax), %ecx
movq -0x10(%rbp), %rax
movl %ecx, 0x1c(%rax)
movq -0x10(%rbp), %rax
movq $0x0, 0x20(%rax)
movq -0x10(%rbp), %rax
movq $0x0, 0x28(%rax)
movq -0x10(%rbp), %rax
movq $0x0, 0x38(%rax)
addq $0x20, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
cmpq $0x0, -0x8(%rbp)
je 0xbb88
jmp 0xbba7
leaq 0x41fd2(%rip), %rdi     # 0x4db61
leaq 0x407fd(%rip), %rsi     # 0x4c393
movl $0x116, %edx            # imm = 0x116
leaq 0x3abad(%rip), %rcx     # 0x4674f
callq 0xa0b0
movl $0x40, %edi
callq 0xa130
movq %rax, -0x18(%rbp)
cmpq $0x0, -0x18(%rbp)
jne 0xbbcd
movq -0x8(%rbp), %rax
movq 0x2090(%rax), %rax
movq -0x8(%rbp), %rdi
callq *%rax
movq -0x8(%rbp), %rdi
movq -0x18(%rbp), %rsi
movl -0xc(%rbp), %edx
callq 0xba80
movq -0x8(%rbp), %rax
movq 0x68(%rax), %rcx
movq -0x18(%rbp), %rax
movq %rcx, 0x30(%rax)
movq -0x18(%rbp), %rcx
movq -0x8(%rbp), %rax
movq %rcx, 0x68(%rax)
movq -0x18(%rbp), %rax
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
cmpq $0x0, -0x8(%rbp)
je 0xbc29
jmp 0xbc48
leaq 0x41f31(%rip), %rdi     # 0x4db61
leaq 0x4075c(%rip), %rsi     # 0x4c393
movl $0x126, %edx            # imm = 0x126
leaq 0x3ab3d(%rip), %rcx     # 0x46780
callq 0xa0b0
cmpq $0x0, -0x10(%rbp)
je 0xbc51
jmp 0xbc70
leaq 0x3a8e2(%rip), %rdi     # 0x4653a
leaq 0x40734(%rip), %rsi     # 0x4c393
movl $0x127, %edx            # imm = 0x127
leaq 0x3ab15(%rip), %rcx     # 0x46780
callq 0xa0b0
movl $0x40, %edi
callq 0xa130
movq %rax, -0x18(%rbp)
cmpq $0x0, -0x18(%rbp)
jne 0xbc96
movq -0x8(%rbp), %rax
movq 0x2090(%rax), %rax
movq -0x8(%rbp), %rdi
callq *%rax
movq -0x18(%rbp), %rdi
movq -0x10(%rbp), %rsi
movl $0x40, %edx
callq 0xa120
movq -0x8(%rbp), %rax
movq 0x68(%rax), %rcx
movq -0x18(%rbp), %rax
movq %rcx, 0x30(%rax)
movq -0x18(%rbp), %rcx
movq -0x8(%rbp), %rax
movq %rcx, 0x68(%rax)
movq -0x18(%rbp), %rax
addq $0x20, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/Ihsoh[P]ilang/lexer.c
// Function: store_char_context
static void _store_char_context(LexerContext *ctx) {
	assert(ctx);

	ctx->stored_index = ctx->index;
	ctx->stored_line = ctx->line;
	ctx->stored_column = ctx->column;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
cmpq $0x0, -0x8(%rbp)
je 0xc035
jmp 0xc054
leaq 0x41b25(%rip), %rdi     # 0x4db61
leaq 0x40350(%rip), %rsi     # 0x4c393
movl $0x26, %edx
leaq 0x3aaaf(%rip), %rcx     # 0x46afe
callq 0xa0b0
movq -0x8(%rbp), %rax
movl 0x34(%rax), %ecx
movq -0x8(%rbp), %rax
movl %ecx, 0x40(%rax)
movq -0x8(%rbp), %rax
movl 0x38(%rax), %ecx
movq -0x8(%rbp), %rax
movl %ecx, 0x44(%rax)
movq -0x8(%rbp), %rax
movl 0x3c(%rax), %ecx
movq -0x8(%rbp), %rax
movl %ecx, 0x48(%rax)
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/Ihsoh[P]ilang/lexer.c
// Function: resume_char_context
static void _resume_char_context(LexerContext *ctx) {
	assert(ctx);

	ctx->index = ctx->stored_index;
	ctx->line = ctx->stored_line;
	ctx->column = ctx->stored_column;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
cmpq $0x0, -0x8(%rbp)
je 0xc0a5
jmp 0xc0c4
leaq 0x41ab5(%rip), %rdi     # 0x4db61
leaq 0x402e0(%rip), %rsi     # 0x4c393
movl $0x2e, %edx
leaq 0x3aa68(%rip), %rcx     # 0x46b27
callq 0xa0b0
movq -0x8(%rbp), %rax
movl 0x40(%rax), %ecx
movq -0x8(%rbp), %rax
movl %ecx, 0x34(%rax)
movq -0x8(%rbp), %rax
movl 0x44(%rax), %ecx
movq -0x8(%rbp), %rax
movl %ecx, 0x38(%rax)
movq -0x8(%rbp), %rax
movl 0x48(%rax), %ecx
movq -0x8(%rbp), %rax
movl %ecx, 0x3c(%rax)
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
cmpq $0x0, -0x8(%rbp)
je 0xc119
jmp 0xc138
leaq 0x41a41(%rip), %rdi     # 0x4db61
leaq 0x4026c(%rip), %rsi     # 0x4c393
movl $0xf, %edx
leaq 0x3aa1e(%rip), %rcx     # 0x46b51
callq 0xa0b0
cmpq $0x0, -0x10(%rbp)
je 0xc141
jmp 0xc160
leaq 0x3a3f2(%rip), %rdi     # 0x4653a
leaq 0x40244(%rip), %rsi     # 0x4c393
movl $0x10, %edx
leaq 0x3a9f6(%rip), %rcx     # 0x46b51
callq 0xa0b0
movq -0x8(%rbp), %rax
cmpq $0x0, 0x50(%rax)
jne 0xc176
movq -0x8(%rbp), %rax
cmpq $0x0, 0x58(%rax)
je 0xc18c
movq -0x8(%rbp), %rax
cmpq $0x0, 0x50(%rax)
je 0xc18e
movq -0x8(%rbp), %rax
cmpq $0x0, 0x58(%rax)
je 0xc18e
jmp 0xc1ad
leaq 0x3a9ea(%rip), %rdi     # 0x46b7f
leaq 0x401f7(%rip), %rsi     # 0x4c393
movl $0x11, %edx
leaq 0x3a9a9(%rip), %rcx     # 0x46b51
callq 0xa0b0
movq -0x8(%rbp), %rax
cmpq $0x0, 0x60(%rax)
jne 0xc1de
movq -0x10(%rbp), %rcx
movq -0x8(%rbp), %rax
movq %rcx, 0x60(%rax)
movq -0x10(%rbp), %rax
movq $0x0, 0x20(%rax)
movq -0x10(%rbp), %rax
movq $0x0, 0x28(%rax)
jmp 0xc222
movq -0x10(%rbp), %rcx
movq -0x8(%rbp), %rax
movq 0x60(%rax), %rax
movq %rcx, 0x28(%rax)
movq -0x8(%rbp), %rax
movq 0x60(%rax), %rcx
movq -0x10(%rbp), %rax
movq %rcx, 0x20(%rax)
movq -0x10(%rbp), %rax
movq $0x0, 0x28(%rax)
movq -0x10(%rbp), %rcx
movq -0x8(%rbp), %rax
movq %rcx, 0x60(%rax)
movq -0x10(%rbp), %rcx
movq -0x8(%rbp), %rax
movq %rcx, 0x58(%rax)
movq -0x8(%rbp), %rax
cmpq $0x0, 0x50(%rax)
jne 0xc258
movq -0x8(%rbp), %rax
cmpq $0x0, 0x58(%rax)
jne 0xc258
movq -0x8(%rbp), %rax
movq 0x60(%rax), %rcx
movq -0x8(%rbp), %rax
movq %rcx, 0x50(%rax)
movq -0x8(%rbp), %rax
movq 0x60(%rax), %rcx
movq -0x8(%rbp), %rax
movq %rcx, 0x58(%rax)
addq $0x10, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/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
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
cmpq $0x0, -0x8(%rbp)
je 0xc4d9
jmp 0xc4f8
leaq 0x41681(%rip), %rdi     # 0x4db61
leaq 0x3feac(%rip), %rsi     # 0x4c393
movl $0x1af, %edx            # imm = 0x1AF
leaq 0x3a467(%rip), %rcx     # 0x4695a
callq 0xa0b0
cmpq $0x0, -0x10(%rbp)
je 0xc501
jmp 0xc520
leaq 0x3a032(%rip), %rdi     # 0x4653a
leaq 0x3fe84(%rip), %rsi     # 0x4c393
movl $0x1b0, %edx            # imm = 0x1B0
leaq 0x3a43f(%rip), %rcx     # 0x4695a
callq 0xa0b0
movq -0x10(%rbp), %rax
movl 0x4(%rax), %eax
addl $0x1, %eax
movslq %eax, %rdi
callq 0xa130
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rdi
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rsi
movq -0x10(%rbp), %rax
movslq 0x4(%rax), %rdx
callq 0xa120
movq -0x18(%rbp), %rax
movq -0x10(%rbp), %rcx
movslq 0x4(%rcx), %rcx
movb $0x0, (%rax,%rcx)
movq -0x18(%rbp), %rcx
movq -0x8(%rbp), %rax
movq %rcx, (%rax)
movq -0x8(%rbp), %rdi
addq $0x8, %rdi
leaq -0x18(%rbp), %rsi
movl $0x1, %edx
callq 0xa3e0
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
cmpq $0x0, -0x8(%rbp)
je 0xc5a9
jmp 0xc5c8
leaq 0x39f8a(%rip), %rdi     # 0x4653a
leaq 0x3fddc(%rip), %rsi     # 0x4c393
movl $0x1be, %edx            # imm = 0x1BE
leaq 0x3a3d5(%rip), %rcx     # 0x46998
callq 0xa0b0
cmpq $0x0, -0x10(%rbp)
je 0xc5d1
jmp 0xc5f0
leaq 0x3a496(%rip), %rdi     # 0x46a6e
leaq 0x3fdb4(%rip), %rsi     # 0x4c393
movl $0x1bf, %edx            # imm = 0x1BF
leaq 0x3a3ad(%rip), %rcx     # 0x46998
callq 0xa0b0
movq -0x10(%rbp), %rsi
leaq 0x3a3cf(%rip), %rdi     # 0x469ca
callq 0xa0c0
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
callq 0xae90
movq -0x10(%rbp), %rsi
movl $0xa, %edi
callq 0xa0e0
movq -0x10(%rbp), %rdi
movq -0x8(%rbp), %rax
movl 0x4(%rax), %edx
leaq 0x3a3a4(%rip), %rsi     # 0x469d1
movb $0x0, %al
callq 0xa100
movq -0x10(%rbp), %rdi
movq -0x8(%rbp), %rax
movl (%rax), %edx
movq -0x8(%rbp), %rax
movl (%rax), %ecx
leaq 0x3a392(%rip), %rsi     # 0x469dd
movb $0x0, %al
callq 0xa100
movq -0x10(%rbp), %rdi
movq -0x8(%rbp), %rax
movq 0x10(%rax), %rdx
leaq 0x3a388(%rip), %rsi     # 0x469ed
movb $0x0, %al
callq 0xa100
movq -0x10(%rbp), %rdi
movq -0x8(%rbp), %rax
movl 0x18(%rax), %edx
leaq 0x3a379(%rip), %rsi     # 0x469f7
movb $0x0, %al
callq 0xa100
movq -0x10(%rbp), %rdi
movq -0x8(%rbp), %rax
movl 0x1c(%rax), %edx
leaq 0x3a36a(%rip), %rsi     # 0x46a01
movb $0x0, %al
callq 0xa100
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
cmpq $0x0, -0x8(%rbp)
je 0xc6c9
jmp 0xc6e8
leaq 0x41491(%rip), %rdi     # 0x4db61
leaq 0x3fcbc(%rip), %rsi     # 0x4c393
movl $0x1d0, %edx            # imm = 0x1D0
leaq 0x3a32a(%rip), %rcx     # 0x46a0d
callq 0xa0b0
cmpq $0x0, -0x10(%rbp)
je 0xc6f1
jmp 0xc710
leaq 0x3a376(%rip), %rdi     # 0x46a6e
leaq 0x3fc94(%rip), %rsi     # 0x4c393
movl $0x1d1, %edx            # imm = 0x1D1
leaq 0x3a302(%rip), %rcx     # 0x46a0d
callq 0xa0b0
movq -0x8(%rbp), %rax
movq 0x50(%rax), %rax
movq %rax, -0x18(%rbp)
cmpq $0x0, -0x18(%rbp)
je 0xc74c
movq -0x18(%rbp), %rdi
movq -0x10(%rbp), %rsi
callq 0xc590
movq -0x10(%rbp), %rsi
movl $0xa, %edi
callq 0xa0e0
movq -0x18(%rbp), %rax
movq 0x28(%rax), %rax
movq %rax, -0x18(%rbp)
jmp 0xc71c
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/Ihsoh[P]ilang/list.c
// Function: llst_init
void llst_init(
	LinkedList *llst,
	LinkedListComparer comparer,
	LinkedListReleaser releaser
) {
	assert(llst);

	llst->head = NULL;
	llst->tail = NULL;
	llst->count = 0;

	if (comparer == NULL) {
		llst->comparer = _invalid_comparer;
	} else {
		llst->comparer = comparer;
	}

	if (releaser == NULL) {
		llst->releaser = _invalid_releaser;
	} else {
		llst->releaser = releaser;
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
cmpq $0x0, -0x8(%rbp)
je 0xc77d
jmp 0xc79c
leaq 0x3a526(%rip), %rdi     # 0x46caa
leaq 0x3a449(%rip), %rsi     # 0x46bd4
movl $0x18, %edx
leaq 0x3a444(%rip), %rcx     # 0x46bdb
callq 0xa0b0
movq -0x8(%rbp), %rax
movq $0x0, (%rax)
movq -0x8(%rbp), %rax
movq $0x0, 0x8(%rax)
movq -0x8(%rbp), %rax
movq $0x0, 0x10(%rax)
cmpq $0x0, -0x10(%rbp)
jne 0xc7d7
movq -0x8(%rbp), %rax
leaq 0x3f(%rip), %rcx        # 0xc810
movq %rcx, 0x18(%rax)
jmp 0xc7e3
movq -0x10(%rbp), %rcx
movq -0x8(%rbp), %rax
movq %rcx, 0x18(%rax)
cmpq $0x0, -0x18(%rbp)
jne 0xc7fb
movq -0x8(%rbp), %rax
leaq 0x4b(%rip), %rcx        # 0xc840
movq %rcx, 0x20(%rax)
jmp 0xc807
movq -0x18(%rbp), %rcx
movq -0x8(%rbp), %rax
movq %rcx, 0x20(%rax)
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/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
subq $0x20, %rsp
movb %sil, %al
movq %rdi, -0x8(%rbp)
andb $0x1, %al
movb %al, -0x9(%rbp)
cmpq $0x0, -0x8(%rbp)
je 0xc88d
jmp 0xc8ac
leaq 0x3a416(%rip), %rdi     # 0x46caa
leaq 0x3a339(%rip), %rsi     # 0x46bd4
movl $0x2f, %edx
leaq 0x3a379(%rip), %rcx     # 0x46c20
callq 0xa0b0
movq -0x8(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x18(%rbp)
cmpq $0x0, -0x18(%rbp)
je 0xc90c
testb $0x1, -0x9(%rbp)
je 0xc8ed
movq -0x18(%rbp), %rax
cmpq $0x0, 0x8(%rax)
je 0xc8ed
movq -0x8(%rbp), %rax
movq 0x20(%rax), %rax
movq -0x18(%rbp), %rcx
movq 0x8(%rcx), %rdi
callq *%rax
movq -0x18(%rbp), %rax
movq $0x0, 0x8(%rax)
movq -0x18(%rbp), %rax
movq %rax, -0x20(%rbp)
movq -0x18(%rbp), %rax
movq 0x18(%rax), %rax
movq %rax, -0x18(%rbp)
movq -0x20(%rbp), %rdi
callq 0xa1b0
jmp 0xc8b7
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl $0x20, %edi
callq 0xa130
movq %rax, -0x18(%rbp)
movq -0x8(%rbp), %rcx
movq -0x18(%rbp), %rax
movq %rcx, (%rax)
movq -0x10(%rbp), %rcx
movq -0x18(%rbp), %rax
movq %rcx, 0x8(%rax)
movq -0x8(%rbp), %rax
cmpq $0x0, (%rax)
jne 0xc99b
movq -0x8(%rbp), %rax
cmpq $0x0, 0x8(%rax)
jne 0xc99b
movq -0x18(%rbp), %rcx
movq -0x8(%rbp), %rax
movq %rcx, (%rax)
movq -0x18(%rbp), %rcx
movq -0x8(%rbp), %rax
movq %rcx, 0x8(%rax)
movq -0x18(%rbp), %rax
movq $0x0, 0x10(%rax)
movq -0x18(%rbp), %rax
movq $0x0, 0x18(%rax)
jmp 0xca0b
movq -0x8(%rbp), %rax
cmpq $0x0, (%rax)
je 0xc9ea
movq -0x8(%rbp), %rax
cmpq $0x0, 0x8(%rax)
je 0xc9ea
movq -0x18(%rbp), %rcx
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rax
movq %rcx, 0x18(%rax)
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rcx
movq -0x18(%rbp), %rax
movq %rcx, 0x10(%rax)
movq -0x18(%rbp), %rax
movq $0x0, 0x18(%rax)
movq -0x18(%rbp), %rcx
movq -0x8(%rbp), %rax
movq %rcx, 0x8(%rax)
jmp 0xca09
leaq 0x3aa74(%rip), %rdi     # 0x47465
leaq 0x3a1dc(%rip), %rsi     # 0x46bd4
movl $0x51, %edx
leaq 0x3a240(%rip), %rcx     # 0x46c44
callq 0xa0b0
jmp 0xca0b
movq -0x8(%rbp), %rax
movq 0x10(%rax), %rcx
addq $0x1, %rcx
movq %rcx, 0x10(%rax)
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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
subq $0x20, %rsp
movb %dl, %al
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
andb $0x1, %al
movb %al, -0x11(%rbp)
cmpq $0x0, -0x8(%rbp)
je 0xcc40
jmp 0xcc5f
leaq 0x3a063(%rip), %rdi     # 0x46caa
leaq 0x39f86(%rip), %rsi     # 0x46bd4
movl $0x7a, %edx
leaq 0x3a055(%rip), %rcx     # 0x46caf
callq 0xa0b0
cmpq $0x0, -0x10(%rbp)
je 0xcc68
jmp 0xcc87
leaq 0x3e418(%rip), %rdi     # 0x4b087
leaq 0x39f5e(%rip), %rsi     # 0x46bd4
movl $0x7b, %edx
leaq 0x3a02d(%rip), %rcx     # 0x46caf
callq 0xa0b0
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
callq 0xca30
testb $0x1, -0x11(%rbp)
je 0xccb7
movq -0x10(%rbp), %rax
cmpq $0x0, 0x8(%rax)
je 0xccb7
movq -0x8(%rbp), %rax
movq 0x20(%rax), %rax
movq -0x10(%rbp), %rcx
movq 0x8(%rcx), %rdi
callq *%rax
movq -0x10(%rbp), %rdi
callq 0xa1b0
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/Ihsoh[P]ilang/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
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
cmpq $0x0, -0x10(%rbp)
je 0xcced
jmp 0xcd0c
leaq 0x39fb6(%rip), %rdi     # 0x46caa
leaq 0x39ed9(%rip), %rsi     # 0x46bd4
movl $0x8a, %edx
leaq 0x39fe0(%rip), %rcx     # 0x46ce7
callq 0xa0b0
cmpq $0x0, -0x18(%rbp)
je 0xcd15
jmp 0xcd34
leaq 0x3a053(%rip), %rdi     # 0x46d6f
leaq 0x39eb1(%rip), %rsi     # 0x46bd4
movl $0x8b, %edx
leaq 0x39fb8(%rip), %rcx     # 0x46ce7
callq 0xa0b0
cmpq $0x0, -0x20(%rbp)
je 0xcd3d
jmp 0xcd5c
leaq 0x432ab(%rip), %rdi     # 0x4ffef
leaq 0x39e89(%rip), %rsi     # 0x46bd4
movl $0x8c, %edx
leaq 0x39f90(%rip), %rcx     # 0x46ce7
callq 0xa0b0
movq -0x10(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x28(%rbp)
cmpq $0x0, -0x28(%rbp)
je 0xcd9e
movq -0x18(%rbp), %rax
movq -0x28(%rbp), %rcx
movq 0x8(%rcx), %rdi
movq -0x20(%rbp), %rsi
callq *%rax
testb $0x1, %al
jne 0xcd86
jmp 0xcd90
movq -0x28(%rbp), %rax
movq %rax, -0x8(%rbp)
jmp 0xcda6
movq -0x28(%rbp), %rax
movq 0x18(%rax), %rax
movq %rax, -0x28(%rbp)
jmp 0xcd67
movq $0x0, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x30, %rsp
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O0/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
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
cmpq $0x0, -0x8(%rbp)
je 0xcdc9
jmp 0xcde8
leaq 0x39eda(%rip), %rdi     # 0x46caa
leaq 0x39dfd(%rip), %rsi     # 0x46bd4
movl $0x9d, %edx
leaq 0x39f56(%rip), %rcx     # 0x46d39
callq 0xa0b0
movq -0x8(%rbp), %rax
cmpq $0x0, 0x18(%rax)
je 0xcdf5
jmp 0xce14
leaq 0x39f6d(%rip), %rdi     # 0x46d69
leaq 0x39dd1(%rip), %rsi     # 0x46bd4
movl $0x9e, %edx
leaq 0x39f2a(%rip), %rcx     # 0x46d39
callq 0xa0b0
cmpq $0x0, -0x10(%rbp)
je 0xce1d
jmp 0xce3c
leaq 0x431cb(%rip), %rdi     # 0x4ffef
leaq 0x39da9(%rip), %rsi     # 0x46bd4
movl $0x9f, %edx
leaq 0x39f02(%rip), %rcx     # 0x46d39
callq 0xa0b0
movq -0x8(%rbp), %rdi
movq -0x8(%rbp), %rax
movq 0x18(%rax), %rsi
movq -0x10(%rbp), %rdx
callq 0xccd0
addq $0x10, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq %rcx, -0x20(%rbp)
movq %r8, -0x28(%rbp)
cmpq $0x0, -0x8(%rbp)
je 0xd235
jmp 0xd254
leaq 0x39f79(%rip), %rdi     # 0x471b5
leaq 0x39bd0(%rip), %rsi     # 0x46e13
movl $0x1d, %edx
leaq 0x39bca(%rip), %rcx     # 0x46e19
callq 0xa0b0
movq -0x8(%rbp), %rdi
xorl %eax, %eax
movl %eax, %esi
movq 0x4ad5d(%rip), %rdx     # 0x57fc0
callq 0xc760
cmpq $0x0, -0x10(%rbp)
jne 0xd280
movq -0x8(%rbp), %rax
leaq 0x86(%rip), %rcx        # 0xd300
movq %rcx, 0x28(%rax)
jmp 0xd28c
movq -0x10(%rbp), %rcx
movq -0x8(%rbp), %rax
movq %rcx, 0x28(%rax)
cmpq $0x0, -0x18(%rbp)
jne 0xd2a4
movq -0x8(%rbp), %rax
leaq 0x62(%rip), %rcx        # 0xd300
movq %rcx, 0x30(%rax)
jmp 0xd2b0
movq -0x18(%rbp), %rcx
movq -0x8(%rbp), %rax
movq %rcx, 0x30(%rax)
cmpq $0x0, -0x20(%rbp)
jne 0xd2c8
movq -0x8(%rbp), %rax
leaq 0x6e(%rip), %rcx        # 0xd330
movq %rcx, 0x38(%rax)
jmp 0xd2d4
movq -0x20(%rbp), %rcx
movq -0x8(%rbp), %rax
movq %rcx, 0x38(%rax)
cmpq $0x0, -0x28(%rbp)
jne 0xd2ec
movq -0x8(%rbp), %rax
leaq 0x4a(%rip), %rcx        # 0xd330
movq %rcx, 0x40(%rax)
jmp 0xd2f8
movq -0x28(%rbp), %rcx
movq -0x8(%rbp), %rax
movq %rcx, 0x40(%rax)
addq $0x30, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/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
subq $0x20, %rsp
movb %dl, %al
movb %sil, %cl
movq %rdi, -0x8(%rbp)
andb $0x1, %cl
movb %cl, -0x9(%rbp)
andb $0x1, %al
movb %al, -0xa(%rbp)
testb $0x1, -0x9(%rbp)
jne 0xd38c
testb $0x1, -0xa(%rbp)
je 0xd418
movq -0x8(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x18(%rbp)
cmpq $0x0, -0x18(%rbp)
je 0xd416
movq -0x18(%rbp), %rax
movq 0x8(%rax), %rax
movq %rax, -0x20(%rbp)
testb $0x1, -0x9(%rbp)
je 0xd3d9
movq -0x20(%rbp), %rax
cmpq $0x0, 0x8(%rax)
je 0xd3d9
movq -0x8(%rbp), %rax
movq 0x38(%rax), %rax
movq -0x20(%rbp), %rcx
movq 0x8(%rcx), %rdi
callq *%rax
movq -0x20(%rbp), %rax
movq $0x0, 0x8(%rax)
testb $0x1, -0xa(%rbp)
je 0xd408
movq -0x20(%rbp), %rax
cmpq $0x0, 0x10(%rax)
je 0xd408
movq -0x8(%rbp), %rax
movq 0x40(%rax), %rax
movq -0x20(%rbp), %rcx
movq 0x10(%rcx), %rdi
callq *%rax
movq -0x20(%rbp), %rax
movq $0x0, 0x10(%rax)
movq -0x18(%rbp), %rax
movq 0x18(%rax), %rax
movq %rax, -0x18(%rbp)
jmp 0xd397
jmp 0xd418
movq -0x8(%rbp), %rdi
movl $0x1, %esi
callq 0xc870
movq -0x8(%rbp), %rax
movq $0x0, 0x28(%rax)
movq -0x8(%rbp), %rax
movq $0x0, 0x30(%rax)
movq -0x8(%rbp), %rax
movq $0x0, 0x38(%rax)
movq -0x8(%rbp), %rax
movq $0x0, 0x40(%rax)
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/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
subq $0x40, %rsp
movb %cl, %al
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
andb $0x1, %al
movb %al, -0x19(%rbp)
cmpq $0x0, -0x8(%rbp)
je 0xd484
jmp 0xd4a3
leaq 0x39d2a(%rip), %rdi     # 0x471b5
leaq 0x39981(%rip), %rsi     # 0x46e13
movl $0x68, %edx
leaq 0x399c4(%rip), %rcx     # 0x46e62
callq 0xa0b0
cmpq $0x0, -0x10(%rbp)
je 0xd4ac
jmp 0xd4cb
leaq 0x399da(%rip), %rdi     # 0x46e8d
leaq 0x39959(%rip), %rsi     # 0x46e13
movl $0x69, %edx
leaq 0x3999c(%rip), %rcx     # 0x46e62
callq 0xa0b0
movq -0x8(%rbp), %rax
movq %rax, -0x28(%rbp)
movq -0x28(%rbp), %rdi
movq -0x10(%rbp), %rdx
leaq 0x9e(%rip), %rsi        # 0xd580
callq 0xccd0
movq %rax, -0x30(%rbp)
cmpq $0x0, -0x30(%rbp)
je 0xd52f
movq -0x30(%rbp), %rax
movq 0x8(%rax), %rax
movq %rax, -0x38(%rbp)
testb $0x1, -0x19(%rbp)
je 0xd521
movq -0x38(%rbp), %rax
cmpq $0x0, 0x10(%rax)
je 0xd521
movq -0x8(%rbp), %rax
movq 0x40(%rax), %rax
movq -0x38(%rbp), %rcx
movq 0x10(%rcx), %rdi
callq *%rax
movq -0x18(%rbp), %rcx
movq -0x38(%rbp), %rax
movq %rcx, 0x10(%rax)
jmp 0xd56d
movl $0x18, %edi
callq 0xa130
movq %rax, -0x40(%rbp)
movq -0x8(%rbp), %rcx
movq -0x40(%rbp), %rax
movq %rcx, (%rax)
movq -0x10(%rbp), %rcx
movq -0x40(%rbp), %rax
movq %rcx, 0x8(%rax)
movq -0x18(%rbp), %rcx
movq -0x40(%rbp), %rax
movq %rcx, 0x10(%rax)
movq -0x28(%rbp), %rdi
movq -0x40(%rbp), %rsi
callq 0xc920
addq $0x40, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
cmpq $0x0, -0x8(%rbp)
je 0xd599
jmp 0xd5b8
leaq 0x39c2b(%rip), %rdi     # 0x471cb
leaq 0x3986c(%rip), %rsi     # 0x46e13
movl $0x5a, %edx
leaq 0x39c22(%rip), %rcx     # 0x471d5
callq 0xa0b0
cmpq $0x0, -0x10(%rbp)
je 0xd5c1
jmp 0xd5e0
leaq 0x42a27(%rip), %rdi     # 0x4ffef
leaq 0x39844(%rip), %rsi     # 0x46e13
movl $0x5b, %edx
leaq 0x39bfa(%rip), %rcx     # 0x471d5
callq 0xa0b0
movq -0x8(%rbp), %rax
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x20(%rbp)
movq -0x20(%rbp), %rax
movq 0x28(%rax), %rax
movq -0x18(%rbp), %rcx
movq 0x8(%rcx), %rdi
movq -0x10(%rbp), %rsi
callq *%rax
andb $0x1, %al
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
cmpq $0x0, -0x10(%rbp)
je 0xd639
jmp 0xd658
leaq 0x39b75(%rip), %rdi     # 0x471b5
leaq 0x397cc(%rip), %rsi     # 0x46e13
movl $0x91, %edx
leaq 0x3983e(%rip), %rcx     # 0x46e91
callq 0xa0b0
cmpq $0x0, -0x18(%rbp)
je 0xd661
jmp 0xd680
leaq 0x39825(%rip), %rdi     # 0x46e8d
leaq 0x397a4(%rip), %rsi     # 0x46e13
movl $0x92, %edx
leaq 0x39816(%rip), %rcx     # 0x46e91
callq 0xa0b0
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rsi
callq 0xd6c0
movq %rax, -0x20(%rbp)
cmpq $0x0, -0x20(%rbp)
je 0xd6a6
movq -0x20(%rbp), %rax
movq 0x8(%rax), %rax
movq %rax, -0x8(%rbp)
jmp 0xd6ae
movq $0x0, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/Ihsoh[P]ilang/map.c
// Function: get_node
static LinkedListNode * _get_node(
	Map *map,
	void *key
) {
	assert(map);
	assert(key);

	LinkedList *llst = &(map->llst);
	LinkedListNode *node = llst_find_with_comparer(llst, _key_comparer, key);
	return node;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
cmpq $0x0, -0x8(%rbp)
je 0xd6d9
jmp 0xd6f8
leaq 0x39ad5(%rip), %rdi     # 0x471b5
leaq 0x3972c(%rip), %rsi     # 0x46e13
movl $0x85, %edx
leaq 0x39b06(%rip), %rcx     # 0x471f9
callq 0xa0b0
cmpq $0x0, -0x10(%rbp)
je 0xd701
jmp 0xd720
leaq 0x39785(%rip), %rdi     # 0x46e8d
leaq 0x39704(%rip), %rsi     # 0x46e13
movl $0x86, %edx
leaq 0x39ade(%rip), %rcx     # 0x471f9
callq 0xa0b0
movq -0x8(%rbp), %rax
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rdi
movq -0x10(%rbp), %rdx
leaq -0x1b7(%rip), %rsi      # 0xd580
callq 0xccd0
movq %rax, -0x20(%rbp)
movq -0x20(%rbp), %rax
addq $0x20, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
cmpq $0x0, -0x10(%rbp)
je 0xd769
jmp 0xd788
leaq 0x39a45(%rip), %rdi     # 0x471b5
leaq 0x3969c(%rip), %rsi     # 0x46e13
movl $0xa0, %edx
leaq 0x39735(%rip), %rcx     # 0x46eb8
callq 0xa0b0
cmpq $0x0, -0x18(%rbp)
je 0xd791
jmp 0xd7b0
leaq 0x396f5(%rip), %rdi     # 0x46e8d
leaq 0x39674(%rip), %rsi     # 0x46e13
movl $0xa1, %edx
leaq 0x3970d(%rip), %rcx     # 0x46eb8
callq 0xa0b0
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rsi
callq 0xd620
movq %rax, -0x20(%rbp)
cmpq $0x0, -0x20(%rbp)
je 0xd7d6
movq -0x20(%rbp), %rax
movq 0x10(%rax), %rax
movq %rax, -0x8(%rbp)
jmp 0xd7de
movq $0x0, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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
subq $0x30, %rsp
movb %cl, %al
movb %dl, %cl
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
andb $0x1, %cl
movb %cl, -0x19(%rbp)
andb $0x1, %al
movb %al, -0x1a(%rbp)
cmpq $0x0, -0x10(%rbp)
je 0xd818
jmp 0xd837
leaq 0x39996(%rip), %rdi     # 0x471b5
leaq 0x395ed(%rip), %rsi     # 0x46e13
movl $0xb1, %edx
leaq 0x396a3(%rip), %rcx     # 0x46ed5
callq 0xa0b0
cmpq $0x0, -0x18(%rbp)
je 0xd840
jmp 0xd85f
leaq 0x39646(%rip), %rdi     # 0x46e8d
leaq 0x395c5(%rip), %rsi     # 0x46e13
movl $0xb2, %edx
leaq 0x3967b(%rip), %rcx     # 0x46ed5
callq 0xa0b0
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rsi
callq 0xd6c0
movq %rax, -0x28(%rbp)
cmpq $0x0, -0x28(%rbp)
je 0xd8e1
movq -0x28(%rbp), %rax
movq 0x8(%rax), %rax
movq %rax, -0x30(%rbp)
testb $0x1, -0x19(%rbp)
je 0xd8a6
movq -0x30(%rbp), %rax
cmpq $0x0, 0x8(%rax)
je 0xd8a6
movq -0x10(%rbp), %rax
movq 0x38(%rax), %rax
movq -0x30(%rbp), %rcx
movq 0x8(%rcx), %rdi
callq *%rax
testb $0x1, -0x1a(%rbp)
je 0xd8c9
movq -0x30(%rbp), %rax
cmpq $0x0, 0x10(%rax)
je 0xd8c9
movq -0x10(%rbp), %rax
movq 0x40(%rax), %rax
movq -0x30(%rbp), %rcx
movq 0x10(%rcx), %rdi
callq *%rax
movq -0x10(%rbp), %rdi
movq -0x28(%rbp), %rsi
movl $0x1, %edx
callq 0xcc20
movb $0x1, -0x1(%rbp)
jmp 0xd8e5
movb $0x0, -0x1(%rbp)
movb -0x1(%rbp), %al
andb $0x1, %al
addq $0x30, %rsp
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O0/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
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
cmpq $0x0, -0x8(%rbp)
je 0xd909
jmp 0xd928
leaq 0x398a5(%rip), %rdi     # 0x471b5
leaq 0x394fc(%rip), %rsi     # 0x46e13
movl $0xca, %edx
leaq 0x395e0(%rip), %rcx     # 0x46f03
callq 0xa0b0
cmpq $0x0, -0x10(%rbp)
je 0xd931
jmp 0xd950
leaq 0x39555(%rip), %rdi     # 0x46e8d
leaq 0x394d4(%rip), %rsi     # 0x46e13
movl $0xcb, %edx
leaq 0x395b8(%rip), %rcx     # 0x46f03
callq 0xa0b0
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
callq 0xd620
movq %rax, -0x18(%rbp)
cmpq $0x0, -0x18(%rbp)
setne %al
andb $0x1, %al
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
cmpq $0x0, -0x10(%rbp)
je 0xda19
jmp 0xda38
leaq 0x39795(%rip), %rdi     # 0x471b5
leaq 0x393ec(%rip), %rsi     # 0x46e13
movl $0xe3, %edx
leaq 0x39522(%rip), %rcx     # 0x46f55
callq 0xa0b0
cmpq $0x0, -0x18(%rbp)
je 0xda41
jmp 0xda60
leaq 0x3b4a1(%rip), %rdi     # 0x48ee9
leaq 0x393c4(%rip), %rsi     # 0x46e13
movl $0xe4, %edx
leaq 0x394fa(%rip), %rcx     # 0x46f55
callq 0xa0b0
movq -0x18(%rbp), %rax
cmpq $0x0, (%rax)
jne 0xda74
movq $0x0, -0x8(%rbp)
jmp 0xda9a
movq -0x18(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x20(%rbp)
movq -0x20(%rbp), %rax
movq 0x18(%rax), %rcx
movq -0x18(%rbp), %rax
movq %rcx, (%rax)
movq -0x20(%rbp), %rax
movq 0x8(%rax), %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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
subq $0x10f0, %rsp           # imm = 0x10F0
testb %al, %al
je 0xe287
movaps %xmm0, -0x10c0(%rbp)
movaps %xmm1, -0x10b0(%rbp)
movaps %xmm2, -0x10a0(%rbp)
movaps %xmm3, -0x1090(%rbp)
movaps %xmm4, -0x1080(%rbp)
movaps %xmm5, -0x1070(%rbp)
movaps %xmm6, -0x1060(%rbp)
movaps %xmm7, -0x1050(%rbp)
movq %r9, -0x10c8(%rbp)
movq %r8, -0x10d0(%rbp)
movq %rcx, -0x10d8(%rbp)
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movq %rdx, -0x18(%rbp)
leaq -0x1040(%rbp), %rax
leaq -0x10f0(%rbp), %rcx
movq %rcx, 0x10(%rax)
leaq 0x10(%rbp), %rcx
movq %rcx, 0x8(%rax)
movl $0x30, 0x4(%rax)
movl $0x18, (%rax)
leaq -0x1020(%rbp), %rdi
movq -0x18(%rbp), %rdx
leaq -0x1040(%rbp), %rcx
movl $0x1000, %esi           # imm = 0x1000
callq 0xa060
leaq -0x1040(%rbp), %rax
movq 0x49d00(%rip), %rax     # 0x57ff8
movq (%rax), %rdi
movq -0x8(%rbp), %rdx
movl -0xc(%rbp), %ecx
leaq -0x1020(%rbp), %r8
leaq 0x38f12(%rip), %rsi     # 0x47222
movb $0x0, %al
callq 0xa100
xorl %edi, %edi
callq 0xa180
nop
// File: /workspace/github_c_makefile_star2_O0/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
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
cmpq $0x0, -0x10(%rbp)
je 0xe33d
jmp 0xe35c
leaq 0x3f855(%rip), %rdi     # 0x4db99
leaq 0x3f380(%rip), %rsi     # 0x4d6cb
movl $0x90, %edx
leaq 0x38ee5(%rip), %rcx     # 0x4723c
callq 0xa0b0
cmpq $0x0, -0x18(%rbp)
jbe 0xe38d
cmpq $0x0, -0x20(%rbp)
je 0xe36c
jmp 0xe38b
leaq 0x38f15(%rip), %rdi     # 0x47288
leaq 0x3f351(%rip), %rsi     # 0x4d6cb
movl $0x92, %edx
leaq 0x38eb6(%rip), %rcx     # 0x4723c
callq 0xa0b0
jmp 0xe3b7
cmpq $0x0, -0x20(%rbp)
jne 0xe396
jmp 0xe3b5
leaq 0x38ef8(%rip), %rdi     # 0x47295
leaq 0x3f327(%rip), %rsi     # 0x4d6cb
movl $0x94, %edx
leaq 0x38e8c(%rip), %rcx     # 0x4723c
callq 0xa0b0
jmp 0xe3b7
movq -0x18(%rbp), %rdi
addq $0x68, %rdi
callq 0xa130
movq %rax, -0x28(%rbp)
cmpq $0x0, -0x28(%rbp)
jne 0xe3dc
movq $0x0, -0x8(%rbp)
jmp 0xe496
movq -0x28(%rbp), %rdi
addq $0x68, %rdi
movq -0x20(%rbp), %rsi
movq -0x18(%rbp), %rdx
callq 0xa120
movq -0x10(%rbp), %rcx
movq -0x28(%rbp), %rax
movq %rcx, (%rax)
movq -0x28(%rbp), %rax
movq $0x0, 0x8(%rax)
movq -0x28(%rbp), %rax
movq $0x0, 0x10(%rax)
movq -0x28(%rbp), %rax
movq $0x0, 0x18(%rax)
movq -0x28(%rbp), %rax
movq $0x0, 0x20(%rax)
movq -0x28(%rbp), %rax
movq $0x0, 0x28(%rax)
movq -0x28(%rbp), %rax
movl $0x0, 0x30(%rax)
movq -0x28(%rbp), %rax
leaq 0x52(%rip), %rcx        # 0xe4a0
movq %rcx, 0x38(%rax)
movq -0x28(%rbp), %rax
leaq 0xe3(%rip), %rcx        # 0xe540
movq %rcx, 0x40(%rax)
movq -0x28(%rbp), %rax
leaq 0x194(%rip), %rcx       # 0xe600
movq %rcx, 0x48(%rax)
movq -0x28(%rbp), %rax
leaq 0x215(%rip), %rcx       # 0xe690
movq %rcx, 0x50(%rax)
movq -0x28(%rbp), %rax
leaq 0x316(%rip), %rcx       # 0xe7a0
movq %rcx, 0x58(%rax)
movq -0x28(%rbp), %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x30, %rsp
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O0/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
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
cmpq $0x0, -0x8(%rbp)
je 0xe4b5
jmp 0xe4d4
leaq 0x3f6a5(%rip), %rdi     # 0x4db61
leaq 0x3f208(%rip), %rsi     # 0x4d6cb
movl $0x14, %edx
leaq 0x392df(%rip), %rcx     # 0x477ae
callq 0xa0b0
movq -0x8(%rbp), %rax
cmpq $0x0, 0x28(%rax)
je 0xe51c
movq -0x8(%rbp), %rax
movq 0x28(%rax), %rax
movq %rax, -0x10(%rbp)
movq 0x49b06(%rip), %rax     # 0x57ff8
movq (%rax), %rdi
movq -0x10(%rbp), %rax
movq 0x10(%rax), %rdx
movq -0x10(%rbp), %rax
movl 0x18(%rax), %ecx
movq -0x10(%rbp), %rax
movl 0x1c(%rax), %r8d
leaq 0x392ca(%rip), %rsi     # 0x477dd
movb $0x0, %al
callq 0xa100
jmp 0xe534
movq 0x49ad5(%rip), %rax     # 0x57ff8
movq (%rax), %rdi
leaq 0x392e1(%rip), %rsi     # 0x4780e
movb $0x0, %al
callq 0xa100
movl $0x1, %edi
callq 0xa180
nop
// File: /workspace/github_c_makefile_star2_O0/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
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
cmpq $0x0, -0x8(%rbp)
je 0xe555
jmp 0xe574
leaq 0x3f605(%rip), %rdi     # 0x4db61
leaq 0x3f168(%rip), %rsi     # 0x4d6cb
movl $0x2a, %edx
leaq 0x392c6(%rip), %rcx     # 0x47835
callq 0xa0b0
movq -0x8(%rbp), %rax
cmpq $0x0, 0x28(%rax)
je 0xe5d6
movq -0x8(%rbp), %rax
movq 0x28(%rax), %rax
movq %rax, -0x10(%rbp)
movq 0x49a66(%rip), %rax     # 0x57ff8
movq (%rax), %rdi
movq -0x10(%rbp), %rax
movq 0x10(%rax), %rdx
movq -0x10(%rbp), %rax
movl 0x18(%rax), %ecx
movq -0x10(%rbp), %rax
movl 0x1c(%rax), %r8d
leaq 0x392ae(%rip), %rsi     # 0x47861
movb $0x0, %al
callq 0xa100
movq 0x49a37(%rip), %rax     # 0x57ff8
movq (%rax), %rdi
movq -0x10(%rbp), %rsi
movl $0x14, %ecx
movl %ecx, %edx
callq 0xaee0
jmp 0xe5ee
movq 0x49a1b(%rip), %rax     # 0x57ff8
movq (%rax), %rdi
leaq 0x392a1(%rip), %rsi     # 0x47888
movb $0x0, %al
callq 0xa100
movl $0x1, %edi
callq 0xa180
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
cmpq $0x0, -0x8(%rbp)
je 0xe619
jmp 0xe638
leaq 0x3f541(%rip), %rdi     # 0x4db61
leaq 0x3f0a4(%rip), %rsi     # 0x4d6cb
movl $0x44, %edx
leaq 0x39272(%rip), %rcx     # 0x478a5
callq 0xa0b0
cmpq $0x0, -0x10(%rbp)
je 0xe641
jmp 0xe660
leaq 0x3929b(%rip), %rdi     # 0x478e3
leaq 0x3f07c(%rip), %rsi     # 0x4d6cb
movl $0x45, %edx
leaq 0x3924a(%rip), %rcx     # 0x478a5
callq 0xa0b0
movq 0x49991(%rip), %rax     # 0x57ff8
movq (%rax), %rdi
movq -0x10(%rbp), %rdx
leaq 0x39272(%rip), %rsi     # 0x478e7
movb $0x0, %al
callq 0xa100
movl $0x1, %edi
callq 0xa180
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
cmpq $0x0, -0x8(%rbp)
je 0xe6ad
jmp 0xe6cc
leaq 0x3f4ad(%rip), %rdi     # 0x4db61
leaq 0x3f010(%rip), %rsi     # 0x4d6cb
movl $0x55, %edx
leaq 0x39240(%rip), %rcx     # 0x47907
callq 0xa0b0
cmpq $0x0, -0x10(%rbp)
je 0xe6d5
jmp 0xe6f4
leaq 0x37e5e(%rip), %rdi     # 0x4653a
leaq 0x3efe8(%rip), %rsi     # 0x4d6cb
movl $0x56, %edx
leaq 0x39218(%rip), %rcx     # 0x47907
callq 0xa0b0
cmpq $0x0, -0x18(%rbp)
je 0xe6fd
jmp 0xe71c
leaq 0x391df(%rip), %rdi     # 0x478e3
leaq 0x3efc0(%rip), %rsi     # 0x4d6cb
movl $0x57, %edx
leaq 0x391f0(%rip), %rcx     # 0x47907
callq 0xa0b0
movq 0x498d5(%rip), %rax     # 0x57ff8
movq (%rax), %rdi
movq -0x10(%rbp), %rax
movq 0x10(%rax), %rdx
movq -0x10(%rbp), %rax
movl 0x18(%rax), %ecx
movq -0x10(%rbp), %rax
movl 0x1c(%rax), %r8d
leaq 0x39215(%rip), %rsi     # 0x47959
movb $0x0, %al
callq 0xa100
movq -0x10(%rbp), %rdi
movq 0x498a2(%rip), %rax     # 0x57ff8
movq (%rax), %rsi
callq 0xae90
movq 0x49893(%rip), %rax     # 0x57ff8
movq (%rax), %rdi
movq -0x18(%rbp), %rdx
leaq 0x39214(%rip), %rsi     # 0x47987
movb $0x0, %al
callq 0xa100
movq 0x49877(%rip), %rax     # 0x57ff8
movq (%rax), %rdi
movq -0x10(%rbp), %rsi
movl $0x14, %ecx
movl %ecx, %edx
callq 0xaee0
movl $0x1, %edi
callq 0xa180
nop
// File: /workspace/github_c_makefile_star2_O0/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
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
cmpq $0x0, -0x8(%rbp)
je 0xe7bd
jmp 0xe7dc
leaq 0x3f39d(%rip), %rdi     # 0x4db61
leaq 0x3ef00(%rip), %rsi     # 0x4d6cb
movl $0x71, %edx
leaq 0x391b7(%rip), %rcx     # 0x4798e
callq 0xa0b0
cmpq $0x0, -0x18(%rbp)
je 0xe7e5
jmp 0xe804
leaq 0x390f7(%rip), %rdi     # 0x478e3
leaq 0x3eed8(%rip), %rsi     # 0x4d6cb
movl $0x72, %edx
leaq 0x3918f(%rip), %rcx     # 0x4798e
callq 0xa0b0
movq -0x10(%rbp), %rax
cmpq $0x0, 0x18(%rax)
je 0xe844
movq 0x497e2(%rip), %rax     # 0x57ff8
movq (%rax), %rdi
movq -0x10(%rbp), %rax
movq 0x18(%rax), %rdx
movq -0x10(%rbp), %rax
movl 0x20(%rax), %ecx
movq -0x10(%rbp), %rax
movl 0x24(%rax), %r8d
movq -0x18(%rbp), %r9
leaq 0x391a7(%rip), %rsi     # 0x479e2
movb $0x0, %al
callq 0xa100
jmp 0xe860
movq 0x497ad(%rip), %rax     # 0x57ff8
movq (%rax), %rdi
movq -0x18(%rbp), %rdx
leaq 0x3908e(%rip), %rsi     # 0x478e7
movb $0x0, %al
callq 0xa100
movl $0x1, %edi
callq 0xa180
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
cmpq $0x0, -0x8(%rbp)
je 0xe8b5
jmp 0xe8d4
leaq 0x3f2a5(%rip), %rdi     # 0x4db61
leaq 0x3ee08(%rip), %rsi     # 0x4d6cb
movl $0xbc, %edx
leaq 0x389d3(%rip), %rcx     # 0x472a2
callq 0xa0b0
movq -0x8(%rbp), %rax
movq 0x10(%rax), %rax
movq %rax, -0x10(%rbp)
cmpq $0x0, -0x10(%rbp)
je 0xe90a
movq -0x10(%rbp), %rax
movq %rax, -0x18(%rbp)
movq -0x10(%rbp), %rax
movq 0x28(%rax), %rax
movq %rax, -0x10(%rbp)
movq -0x8(%rbp), %rdi
movq -0x18(%rbp), %rsi
callq 0xe920
jmp 0xe8e0
movq -0x8(%rbp), %rdi
callq 0xa1b0
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax)