LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O2/KhuramAli[P]JAM-Benchmark/lock_and_lockfree/code13.cpp
// Function: threadfunc_atomic_read_acquire()
void threadfunc_atomic_read_acquire()
    {
      start_wait();
      // Wait until main() sends data
      long i,j;
      uint64_t current;
      j = 0;
      for (i = 1; i <= count; i++) {
        current = atomic_uint.load(std::memory_order_acquire);
        if (current > 0) {
          j++;
        }
        else {
          std::cout << "Error!";
        }
      }
      if (j != count) {
        std::cout << "Not matched count j=" << j << "count=" << count <<"\n";
      }
    }

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
callq 0x23eb
pushq $0x1
popq %r12
xorl %ebx, %ebx
movq 0x355b(%rip), %r14      # 0x5fd0
leaq 0x15be(%rip), %r15      # 0x403a
movq 0x3735(%rip), %rax      # 0x61b8
cmpq %rax, %r12
jg 0x2aa9
movq 0x3721(%rip), %rax      # 0x61b0
testq %rax, %rax
je 0x2a99
incq %rbx
jmp 0x2aa4
movq %r14, %rdi
movq %r15, %rsi
callq 0x2150
incq %r12
jmp 0x2a7c
cmpq %rax, %rbx
jne 0x2aba
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
movq 0x350f(%rip), %rdi      # 0x5fd0
leaq 0x154e(%rip), %rsi      # 0x4016
callq 0x2150
movq %rax, %rdi
movq %rbx, %rsi
callq 0x2140
leaq 0x154c(%rip), %rsi      # 0x402b
movq %rax, %rdi
callq 0x2150
movq 0x36ca(%rip), %rsi      # 0x61b8
movq %rax, %rdi
callq 0x2140
leaq 0x1620(%rip), %rsi      # 0x411d
movq %rax, %rdi
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
jmp 0x2150
// File: /workspace/github_c_makefile_star2_O2/KhuramAli[P]JAM-Benchmark/lock_and_lockfree/code13.cpp
// Function: threadfunc_atomic_weak()
void threadfunc_atomic_weak()
    {
      start_wait();
      // Wait until main() sends data
      long i;
      uint64_t next;
      for (i = 1; i <= count; i++) {
        do {
          next = atomic_uint.load(std::memory_order_relaxed);
        }
        while (!atomic_uint.compare_exchange_weak(next,
                                                  next + 1,
                                                  std::memory_order_release,
                                                  std::memory_order_relaxed));
      }
    }

// Assembly:
pushq %rax
callq 0x23eb
pushq $0x1
popq %rcx
cmpq 0x3698(%rip), %rcx      # 0x61b8
jg 0x2b3d
movq 0x3687(%rip), %rax      # 0x61b0
leaq 0x1(%rax), %rdx
lock
cmpxchgq %rdx, 0x367a(%rip)      # 0x61b0
jne 0x2b22
incq %rcx
jmp 0x2b19
popq %rax
retq
// File: /workspace/github_c_makefile_star2_O2/Ihsoh[P]ilang/array.c
// Function: rarr_init
void rarr_init(
	ResizableArray *rarr,
	size_t item_size
) {
	assert(rarr);
	assert(item_size > 0);

	rarr->size = 0;
	rarr->len = 0;
	rarr->item_size = item_size;
	rarr->buffer = NULL;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
testq %rdi, %rdi
je 0xa2ab
testq %rsi, %rsi
je 0xa2c4
xorps %xmm0, %xmm0
movups %xmm0, (%rdi)
movq %rsi, 0x10(%rdi)
andq $0x0, 0x18(%rdi)
popq %rbp
retq
leaq 0x21d52(%rip), %rdi     # 0x2c004
leaq 0x21d50(%rip), %rsi     # 0x2c009
leaq 0x21d51(%rip), %rcx     # 0x2c011
pushq $0xf
jmp 0xa2db
leaq 0x21d6f(%rip), %rdi     # 0x2c03a
leaq 0x21d37(%rip), %rsi     # 0x2c009
leaq 0x21d38(%rip), %rcx     # 0x2c011
pushq $0x10
popq %rdx
callq 0xa0b0
// File: /workspace/github_c_makefile_star2_O2/Ihsoh[P]ilang/array.c
// Function: rarr_free
void rarr_free(ResizableArray *rarr) {
	assert(rarr);

	if (rarr->buffer != NULL) {
		free(rarr->buffer);	
	}

	rarr->size = 0;
	rarr->len = 0;
	rarr->item_size = 0;
	rarr->buffer = NULL;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %rbx
pushq %rax
testq %rdi, %rdi
je 0xa309
movq %rdi, %rbx
movq 0x18(%rdi), %rdi
callq 0xa190
xorps %xmm0, %xmm0
movups %xmm0, 0x10(%rbx)
movups %xmm0, (%rbx)
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
leaq 0x21cf4(%rip), %rdi     # 0x2c004
leaq 0x21cf2(%rip), %rsi     # 0x2c009
leaq 0x21d2a(%rip), %rcx     # 0x2c048
pushq $0x19
popq %rdx
callq 0xa0b0
// File: /workspace/github_c_makefile_star2_O2/Ihsoh[P]ilang/array.c
// Function: rarr_append_with_raw
void rarr_append_with_raw(
	ResizableArray *dst,
	void *src,
	size_t len
) {
	assert(dst);
	assert(src);
	
	if (len == 0) {
		return;
	}

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

	memcpy((uint8_t *)(dst->buffer) + _BYTE_COUNT(dst, dst->len), src, _BYTE_COUNT(dst, len));
	dst->len += len;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
testq %rdi, %rdi
je 0xa38b
movq %rsi, %r15
testq %rsi, %rsi
je 0xa3a4
movq %rdx, %rbx
testq %rdx, %rdx
je 0xa380
movq %rdi, %r14
movq 0x8(%rdi), %rdi
leaq (%rdi,%rbx), %rax
cmpq (%r14), %rax
jbe 0xa364
movq %r14, %rdi
movq %rbx, %rsi
callq 0xa3c1
movq 0x8(%r14), %rdi
movq 0x10(%r14), %rdx
imulq %rdx, %rdi
addq 0x18(%r14), %rdi
imulq %rbx, %rdx
movq %r15, %rsi
callq 0xa110
addq %rbx, 0x8(%r14)
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
leaq 0x21cd7(%rip), %rdi     # 0x2c069
leaq 0x21c70(%rip), %rsi     # 0x2c009
leaq 0x21ccd(%rip), %rcx     # 0x2c06d
pushq $0x39
jmp 0xa3bb
leaq 0x23b32(%rip), %rdi     # 0x2dedd
leaq 0x21c57(%rip), %rsi     # 0x2c009
leaq 0x21cb4(%rip), %rcx     # 0x2c06d
pushq $0x3a
popq %rdx
callq 0xa0b0
// File: /workspace/github_c_makefile_star2_O2/Ihsoh[P]ilang/array.c
// Function: inc_buffer_size
static void _inc_buffer_size(
	ResizableArray *rarr,
	size_t inc_size
) {
	assert(rarr);
	assert(inc_size > 0);

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

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %rbx
pushq %rax
movq %rdi, %rbx
addq %rsi, %rsi
addq (%rdi), %rsi
movq %rsi, (%rdi)
movq 0x18(%rdi), %rdi
imulq 0x10(%rbx), %rsi
testq %rdi, %rdi
je 0xa3e8
callq 0xa130
jmp 0xa3f0
movq %rsi, %rdi
callq 0xa120
movq %rax, 0x18(%rbx)
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/Ihsoh[P]ilang/array.c
// Function: rarr_append_with_rarr
void rarr_append_with_rarr(
	ResizableArray *dst,
	ResizableArray *src
) {
	assert(dst);
	assert(src);
	assert(dst->item_size == src->item_size);

	rarr_append_with_raw(dst, src->buffer, src->len);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
testq %rdi, %rdi
je 0xa421
testq %rsi, %rsi
je 0xa43a
movq 0x10(%rdi), %rax
cmpq 0x10(%rsi), %rax
jne 0xa453
movq 0x8(%rsi), %rdx
movq 0x18(%rsi), %rsi
popq %rbp
jmp 0xa326
leaq 0x21c41(%rip), %rdi     # 0x2c069
leaq 0x21bda(%rip), %rsi     # 0x2c009
leaq 0x21c73(%rip), %rcx     # 0x2c0a9
pushq $0x4c
jmp 0xa46a
leaq 0x23a9c(%rip), %rdi     # 0x2dedd
leaq 0x21bc1(%rip), %rsi     # 0x2c009
leaq 0x21c5a(%rip), %rcx     # 0x2c0a9
pushq $0x4d
jmp 0xa46a
leaq 0x21c8e(%rip), %rdi     # 0x2c0e8
leaq 0x21ba8(%rip), %rsi     # 0x2c009
leaq 0x21c41(%rip), %rcx     # 0x2c0a9
pushq $0x4e
popq %rdx
callq 0xa0b0
// File: /workspace/github_c_makefile_star2_O2/Ihsoh[P]ilang/array.c
// Function: rarr_insert_with_raw
void rarr_insert_with_raw(
	ResizableArray *dst,
	void *src,
	size_t len,
	size_t pos
) {
	assert(dst);
	assert(src);

	if (len == 0) {
		return;
	}

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

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

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
testq %rdi, %rdi
je 0xa508
movq %rsi, %r12
testq %rsi, %rsi
je 0xa521
movq %rdx, %rbx
testq %rdx, %rdx
je 0xa4ff
movq %rcx, %r15
movq %rdi, %r14
movq 0x8(%rdi), %rdx
leaq (%rdx,%rbx), %rax
cmpq (%rdi), %rax
jbe 0xa4ba
movq %r14, %rdi
movq %rbx, %rsi
callq 0xa3c1
movq 0x8(%r14), %rdx
movq 0x10(%r14), %rsi
movq 0x18(%r14), %rax
leaq (%r15,%rbx), %rdi
imulq %rsi, %rdi
addq %rax, %rdi
subq %r15, %rdx
imulq %rsi, %rdx
imulq %r15, %rsi
addq %rax, %rsi
callq 0xa110
movq 0x10(%r14), %rdx
imulq %rdx, %r15
addq 0x18(%r14), %r15
imulq %rbx, %rdx
movq %r15, %rdi
movq %r12, %rsi
callq 0xa110
addq %rbx, 0x8(%r14)
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
leaq 0x21b5a(%rip), %rdi     # 0x2c069
leaq 0x21af3(%rip), %rsi     # 0x2c009
leaq 0x21bec(%rip), %rcx     # 0x2c109
pushq $0x59
jmp 0xa538
leaq 0x239b5(%rip), %rdi     # 0x2dedd
leaq 0x21ada(%rip), %rsi     # 0x2c009
leaq 0x21bd3(%rip), %rcx     # 0x2c109
pushq $0x5a
popq %rdx
callq 0xa0b0
// File: /workspace/github_c_makefile_star2_O2/Ihsoh[P]ilang/lexer.c
// Function: lexer_new_context
LexerContext * lexer_new_context(
	const char *file,
	const char *source,
	int len,
	LexerTokenMatcher *matchers
) {
	assert(file);
	assert(source);
	assert(len >= 0);
	assert(matchers[0].name != NULL);

	LexerContext *ctx = (LexerContext *)malloc(sizeof(LexerContext));
	if (ctx == NULL) {
		return NULL;
	}

	ctx->file = file;
	rarr_init(&(ctx->rarr_file), sizeof(char *));
	
	ctx->source = source;
	ctx->len = len;
	ctx->index = -1;
	ctx->line = 1;
	ctx->column = 0;

	ctx->stored_index = -1;
	ctx->stored_line = 1;
	ctx->stored_column = 0;

	ctx->head = NULL;
	ctx->tail = NULL;
	ctx->current = NULL;

	ctx->tokens = NULL;

	ctx->curstack_top = -1;

	ctx->matchers = matchers;

	ctx->data = NULL;

	ctx->invalid_token = _default_invalid_token;
	ctx->alloc_mem_error = _default_alloc_mem_error;

	return ctx;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
testq %rdi, %rdi
je 0xad35
movq %rsi, %r15
testq %rsi, %rsi
je 0xad4e
movl %edx, %r14d
testl %edx, %edx
js 0xad67
movq %rcx, %rbx
cmpq $0x0, (%rcx)
je 0xad80
movq %rdi, %r13
movl $0x2098, %edi           # imm = 0x2098
callq 0xa120
movq %rax, %r12
testq %rax, %rax
je 0xad23
movq %r13, (%r12)
movq %r12, %rdi
addq $0x8, %rdi
pushq $0x8
popq %rsi
callq 0xa28c
movq %r15, 0x28(%r12)
movl %r14d, 0x30(%r12)
movaps 0x21800(%rip), %xmm0    # 0x2c4d0
movups %xmm0, 0x34(%r12)
movq $0x1, 0x44(%r12)
xorps %xmm0, %xmm0
movups %xmm0, 0x50(%r12)
movups %xmm0, 0x60(%r12)
orl $-0x1, 0x70(%r12)
movq %rbx, 0x2078(%r12)
andq $0x0, 0x2080(%r12)
leaq 0x91(%rip), %rax        # 0xad9d
movq %rax, 0x2088(%r12)
leaq 0x195(%rip), %rax       # 0xaeb0
movq %rax, 0x2090(%r12)
movq %r12, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
leaq 0x21ccd(%rip), %rdi     # 0x2ca09
leaq 0x27284(%rip), %rsi     # 0x31fc7
leaq 0x21796(%rip), %rcx     # 0x2c4e0
pushq $0x67
jmp 0xad97
leaq 0x217e1(%rip), %rdi     # 0x2c536
leaq 0x2726b(%rip), %rsi     # 0x31fc7
leaq 0x2177d(%rip), %rcx     # 0x2c4e0
pushq $0x68
jmp 0xad97
leaq 0x217cf(%rip), %rdi     # 0x2c53d
leaq 0x27252(%rip), %rsi     # 0x31fc7
leaq 0x21764(%rip), %rcx     # 0x2c4e0
pushq $0x69
jmp 0xad97
leaq 0x21af8(%rip), %rdi     # 0x2c87f
leaq 0x27239(%rip), %rsi     # 0x31fc7
leaq 0x2174b(%rip), %rcx     # 0x2c4e0
pushq $0x6a
popq %rdx
callq 0xa0b0
// File: /workspace/github_c_makefile_star2_O2/Ihsoh[P]ilang/lexer.c
// Function: default_invalid_token
static void _default_invalid_token(LexerContext *ctx) {
	assert(ctx);
	assert(ctx->file);

	fprintf(
		stderr,
		"Lexer Error(%s:%d,%d): invalid token, near:\n",
		ctx->file, ctx->line, ctx->column
	);

	fputc('\n', stderr);
	fputc('\t', stderr);

	bool flag = true;
	for (int i = 0; i < 60 && ctx->index + i < ctx->len; i++) {
		char chr = ctx->source[ctx->index + i];
		if (isspace(chr)) {
			if (flag) {
				fputc(' ', stderr);
				flag = false;
			}
		} else {
			fputc(chr, stderr);
			flag = true;
		}
	}

	fputc('\n', stderr);
	fputc('\n', stderr);
	exit(1);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
testq %rdi, %rdi
je 0xae7a
movq %rdi, %rbx
movq (%rdi), %rdx
testq %rdx, %rdx
je 0xae93
movq 0x3322e(%rip), %r14     # 0x3dff8
movq (%r14), %rdi
movl 0x38(%rbx), %ecx
movl 0x3c(%rbx), %r8d
leaq 0x21c33(%rip), %rsi     # 0x2ca0e
xorl %r12d, %r12d
xorl %eax, %eax
callq 0xa0f0
movq (%r14), %rsi
pushq $0xa
popq %rdi
callq 0xa0d0
movq (%r14), %rsi
pushq $0x9
popq %rdi
callq 0xa0d0
movb $0x1, %r15b
cmpl $0x3c, %r12d
je 0xae54
movslq 0x34(%rbx), %rax
leal (%r12,%rax), %ecx
cmpl 0x30(%rbx), %ecx
jge 0xae54
addq 0x28(%rbx), %rax
movsbq (%r12,%rax), %r14
callq 0xa180
movq (%rax), %rax
testb $0x20, 0x1(%rax,%r14,2)
sete %r13b
je 0xae3a
pushq $0x20
popq %rax
movl %eax, %r14d
testb $0x1, %r15b
je 0xae4c
movq 0x331b7(%rip), %rax     # 0x3dff8
movq (%rax), %rsi
movl %r14d, %edi
callq 0xa0d0
incq %r12
movl %r13d, %r15d
jmp 0xadfe
movq 0x3319d(%rip), %r14     # 0x3dff8
movq (%r14), %rsi
pushq $0xa
popq %rbx
movl %ebx, %edi
callq 0xa0d0
movq (%r14), %rsi
movl %ebx, %edi
callq 0xa0d0
pushq $0x1
popq %rdi
callq 0xa160
leaq 0x23f53(%rip), %rdi     # 0x2edd4
leaq 0x2713f(%rip), %rsi     # 0x31fc7
leaq 0x21b49(%rip), %rcx     # 0x2c9d8
pushq $0x39
jmp 0xaeaa
leaq 0x21b6a(%rip), %rdi     # 0x2ca04
leaq 0x27126(%rip), %rsi     # 0x31fc7
leaq 0x21b30(%rip), %rcx     # 0x2c9d8
pushq $0x3a
popq %rdx
callq 0xa0b0
// File: /workspace/github_c_makefile_star2_O2/Ihsoh[P]ilang/lexer.c
// Function: default_alloc_mem_error
static void _default_alloc_mem_error(LexerContext *ctx) {
	assert(ctx);
	assert(ctx->file);

	fprintf(stderr, "Lexer Error(%s:%d,%d): cannot allocate memory!\n", ctx->file, ctx->line, ctx->column);
	exit(1);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
testq %rdi, %rdi
jne 0xaed2
leaq 0x23f14(%rip), %rdi     # 0x2edd4
leaq 0x27100(%rip), %rsi     # 0x31fc7
leaq 0x21b6d(%rip), %rcx     # 0x2ca3b
pushq $0x59
jmp 0xaef1
movq (%rdi), %rdx
testq %rdx, %rdx
jne 0xaef7
leaq 0x21b23(%rip), %rdi     # 0x2ca04
leaq 0x270df(%rip), %rsi     # 0x31fc7
leaq 0x21b4c(%rip), %rcx     # 0x2ca3b
pushq $0x5a
popq %rdx
callq 0xa0b0
movq 0x330fa(%rip), %rax     # 0x3dff8
movq (%rax), %rax
movl 0x38(%rdi), %ecx
movl 0x3c(%rdi), %r8d
leaq 0x21b5a(%rip), %rsi     # 0x2ca69
movq %rax, %rdi
xorl %eax, %eax
callq 0xa0f0
pushq $0x1
popq %rdi
callq 0xa160
// File: /workspace/github_c_makefile_star2_O2/Ihsoh[P]ilang/lexer.c
// Function: lexer_free_context
void lexer_free_context(LexerContext * ctx) {
	assert(ctx);

	for (int i = 0; i < RARR_LEN(&(ctx->rarr_file)); i++) {
		free(RARR_ELEMENT(&(ctx->rarr_file), i, char *));
	}
	rarr_free(&(ctx->rarr_file));

	LexerToken *token = ctx->tokens;
	while (token != NULL) {
		LexerToken *temp = token;
		token = token->tks_next;
		lexer_free_token(ctx, temp);
	}

	free(ctx);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
testq %rdi, %rdi
je 0xaf7f
movq %rdi, %rbx
xorl %r14d, %r14d
cmpq %r14, 0x10(%rbx)
jbe 0xaf53
movq 0x20(%rbx), %rax
movq 0x18(%rbx), %rcx
imulq %r14, %rcx
movq (%rax,%rcx), %rdi
callq 0xa190
incq %r14
jmp 0xaf33
leaq 0x8(%rbx), %rdi
callq 0xa2e1
movq 0x68(%rbx), %rdi
testq %rdi, %rdi
je 0xaf73
movq 0x30(%rdi), %r14
callq 0xa190
movq %r14, %rdi
jmp 0xaf60
movq %rbx, %rdi
popq %rbx
popq %r14
popq %rbp
jmp 0xa190
leaq 0x23e4e(%rip), %rdi     # 0x2edd4
leaq 0x2703a(%rip), %rsi     # 0x31fc7
leaq 0x215b2(%rip), %rcx     # 0x2c546
movl $0x91, %edx
callq 0xa0b0
// File: /workspace/github_c_makefile_star2_O2/Ihsoh[P]ilang/lexer.c
// Function: lexer_next_char
int lexer_next_char(LexerContext *ctx) {
	assert(ctx);

	if (ctx->index + 1 < ctx->len) {
		ctx->index++;
		char chr = ctx->source[ctx->index];
		if (chr == '\n') {
			ctx->line++;
			ctx->column = 0;
		} else {
			ctx->column++;
		}
		return chr;
	} else {
		ctx->index = ctx->len;
		return -1;
	}
}

// Assembly:
testq %rdi, %rdi
je 0xb02c
movslq 0x34(%rdi), %rax
incq %rax
movl 0x30(%rdi), %ecx
cmpl %ecx, %eax
jge 0xb021
movl %eax, 0x34(%rdi)
movq 0x28(%rdi), %rcx
movsbl (%rcx,%rax), %eax
cmpl $0xa, %eax
jne 0xb028
incl 0x38(%rdi)
andl $0x0, 0x3c(%rdi)
pushq $0xa
jmp 0xb026
movl %ecx, 0x34(%rdi)
pushq $-0x1
popq %rax
retq
incl 0x3c(%rdi)
retq
pushq %rbp
movq %rsp, %rbp
leaq 0x23d9d(%rip), %rdi     # 0x2edd4
leaq 0x26f89(%rip), %rsi     # 0x31fc7
leaq 0x21529(%rip), %rcx     # 0x2c56e
movl $0xa6, %edx
callq 0xa0b0
// File: /workspace/github_c_makefile_star2_O2/Ihsoh[P]ilang/lexer.c
// Function: lexer_match_string
bool lexer_match_string(
	LexerContext *ctx,
	const char *str
) {
	assert(ctx);
	assert(str);

	size_t len = strlen(str);
	for (int i = 0; i < len; i++) {
		if (lexer_peek_char(ctx, 1 + i) != str[i]) {
			return false;
		}
	}

	return true;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
testq %rdi, %rdi
je 0xb0b0
movq %rsi, %rbx
testq %rsi, %rsi
je 0xb0cf
movq %rdi, %r14
movq %rbx, %rdi
callq 0xa080
movq %rax, %r15
xorl %r12d, %r12d
movq %r12, %r13
cmpq %r12, %r15
je 0xb09b
leaq 0x1(%r13), %r12
movq %r14, %rdi
movl %r12d, %esi
callq 0xb0ee
movsbl (%rbx,%r13), %ecx
cmpl %ecx, %eax
je 0xb07b
cmpq %r13, %r15
setbe %al
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
leaq 0x23d1d(%rip), %rdi     # 0x2edd4
leaq 0x26f09(%rip), %rsi     # 0x31fc7
leaq 0x214cd(%rip), %rcx     # 0x2c592
movl $0xbc, %edx
callq 0xa0b0
leaq 0x229d5(%rip), %rdi     # 0x2daab
leaq 0x26eea(%rip), %rsi     # 0x31fc7
leaq 0x214ae(%rip), %rcx     # 0x2c592
movl $0xbd, %edx
callq 0xa0b0
// File: /workspace/github_c_makefile_star2_O2/Ihsoh[P]ilang/lexer.c
// Function: lexer_peek_char
int lexer_peek_char(LexerContext *ctx, int n) {
	assert(ctx);

	int index = ctx->index + n;
	if (index < 0 || index >= ctx->len) {
		return -1;
	} else {
		return ctx->source[index];
	}
}

// Assembly:
testq %rdi, %rdi
je 0xb10b
addl 0x34(%rdi), %esi
pushq $-0x1
popq %rax
js 0xb10a
cmpl 0x30(%rdi), %esi
jge 0xb10a
movq 0x28(%rdi), %rax
movl %esi, %ecx
movsbl (%rax,%rcx), %eax
retq
pushq %rbp
movq %rsp, %rbp
leaq 0x23cbe(%rip), %rdi     # 0x2edd4
leaq 0x26eaa(%rip), %rsi     # 0x31fc7
leaq 0x214a5(%rip), %rcx     # 0x2c5c9
movl $0xca, %edx
callq 0xa0b0
// File: /workspace/github_c_makefile_star2_O2/Ihsoh[P]ilang/lexer.c
// Function: lexer_next_token
LexerToken * lexer_next_token(LexerContext *ctx) {
	assert(ctx);

	LexerToken *token = ctx->current;

	if (token != NULL) {
		ctx->current = token->next;
	}

	return token;
}

// Assembly:
testq %rdi, %rdi
je 0xb17e
movq 0x60(%rdi), %rax
testq %rax, %rax
je 0xb17d
movq 0x28(%rax), %rcx
movq %rcx, 0x60(%rdi)
retq
pushq %rbp
movq %rsp, %rbp
leaq 0x23c4b(%rip), %rdi     # 0x2edd4
leaq 0x26e37(%rip), %rsi     # 0x31fc7
leaq 0x21487(%rip), %rcx     # 0x2c61e
movl $0xe2, %edx
callq 0xa0b0
// File: /workspace/github_c_makefile_star2_O2/Ihsoh[P]ilang/lexer.c
// Function: lexer_prev_token
LexerToken * lexer_prev_token(LexerContext *ctx) {
	assert(ctx);

	LexerToken *token = ctx->current;

	if (token != NULL) {
		ctx->current = token->prev;
	}

	return ctx->current;
}

// Assembly:
testq %rdi, %rdi
je 0xb1bb
movq 0x60(%rdi), %rax
testq %rax, %rax
je 0xb1b8
movq 0x20(%rax), %rax
movq %rax, 0x60(%rdi)
retq
xorl %eax, %eax
retq
pushq %rbp
movq %rsp, %rbp
leaq 0x23c0e(%rip), %rdi     # 0x2edd4
leaq 0x26dfa(%rip), %rsi     # 0x31fc7
leaq 0x21477(%rip), %rcx     # 0x2c64b
movl $0xee, %edx
callq 0xa0b0
// File: /workspace/github_c_makefile_star2_O2/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
testq %rdi, %rdi
je 0xb24f
testq %rsi, %rsi
je 0xb26e
movl %edx, (%rsi)
movl $0x1, 0x4(%rsi)
movslq 0x34(%rdi), %rax
addq 0x28(%rdi), %rax
movq %rax, 0x8(%rsi)
movq (%rdi), %rax
movq %rax, 0x10(%rsi)
movl 0x38(%rdi), %eax
movl %eax, 0x18(%rsi)
movl 0x3c(%rdi), %eax
movl %eax, 0x1c(%rsi)
andq $0x0, 0x38(%rsi)
xorps %xmm0, %xmm0
movups %xmm0, 0x20(%rsi)
popq %rbp
retq
leaq 0x23b7e(%rip), %rdi     # 0x2edd4
leaq 0x26d6a(%rip), %rsi     # 0x31fc7
leaq 0x2144d(%rip), %rcx     # 0x2c6b1
movl $0x103, %edx            # imm = 0x103
callq 0xa0b0
leaq 0x21245(%rip), %rdi     # 0x2c4ba
leaq 0x26d4b(%rip), %rsi     # 0x31fc7
leaq 0x2142e(%rip), %rcx     # 0x2c6b1
movl $0x104, %edx            # imm = 0x104
callq 0xa0b0
// File: /workspace/github_c_makefile_star2_O2/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 %r15
pushq %r14
pushq %rbx
pushq %rax
testq %rdi, %rdi
je 0xb2e3
movl %esi, %r14d
movq %rdi, %rbx
pushq $0x40
popq %rdi
callq 0xa120
movq %rax, %r15
testq %rax, %rax
jne 0xb2bb
movq %rbx, %rdi
callq *0x2090(%rbx)
movq %rbx, %rdi
movq %r15, %rsi
movl %r14d, %edx
callq 0xb20b
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 0x23aea(%rip), %rdi     # 0x2edd4
leaq 0x26cd6(%rip), %rsi     # 0x31fc7
leaq 0x213f2(%rip), %rcx     # 0x2c6ea
movl $0x116, %edx            # imm = 0x116
callq 0xa0b0
// File: /workspace/github_c_makefile_star2_O2/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 0xb375
movq %rsi, %r14
testq %rsi, %rsi
je 0xb394
movq %rdi, %rbx
pushq $0x40
popq %rdi
callq 0xa120
movq %rax, %r15
testq %rax, %rax
jne 0xb335
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 0x23a58(%rip), %rdi     # 0x2edd4
leaq 0x26c44(%rip), %rsi     # 0x31fc7
leaq 0x21391(%rip), %rcx     # 0x2c71b
movl $0x126, %edx            # imm = 0x126
callq 0xa0b0
leaq 0x2111f(%rip), %rdi     # 0x2c4ba
leaq 0x26c25(%rip), %rsi     # 0x31fc7
leaq 0x21372(%rip), %rcx     # 0x2c71b
movl $0x127, %edx            # imm = 0x127
callq 0xa0b0
// File: /workspace/github_c_makefile_star2_O2/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 0xb5ed
movq %rdi, %rbx
movq 0x2078(%rdi), %rax
movq %rax, -0x40(%rbp)
cmpq $0x0, (%rax)
jne 0xb5c6
leaq 0x21370(%rip), %rdi     # 0x2c87a
leaq 0x26ab6(%rip), %rsi     # 0x31fc7
leaq 0x21341(%rip), %rcx     # 0x2c859
movl $0x154, %edx            # imm = 0x154
callq 0xa0b0
movq $0x0, -0x38(%rbp)
xorl %r12d, %r12d
pushq $-0x1
popq %r14
movq -0x40(%rbp), %r13
xorl %r15d, %r15d
cmpq $0x0, (%r13)
je 0xb58e
movl %eax, 0x40(%rbx)
movq 0x38(%rbx), %rax
movq %rax, 0x44(%rbx)
movq %rbx, %rdi
leaq -0x2c(%rbp), %rsi
callq *0x8(%r13)
testq %rax, %rax
je 0xb57a
testq %r15, %r15
je 0xb568
movl 0x4(%rax), %ecx
cmpl 0x4(%r15), %ecx
jle 0xb57a
movl -0x2c(%rbp), %ecx
movq %rcx, -0x38(%rbp)
movl 0x38(%rbx), %r12d
movl 0x3c(%rbx), %r14d
movq %rax, %r15
movl 0x40(%rbx), %eax
movl %eax, 0x34(%rbx)
movq 0x44(%rbx), %rcx
movq %rcx, 0x38(%rbx)
addq $0x10, %r13
jmp 0xb538
testq %r15, %r15
je 0xb5b5
addl 0x4(%r15), %eax
movl %eax, 0x34(%rbx)
movl %r12d, 0x38(%rbx)
movl %r14d, 0x3c(%rbx)
cmpl $0x0, -0x38(%rbp)
jne 0xb5c6
movq %rbx, %rdi
movq %r15, %rsi
callq 0xb60c
jmp 0xb5c6
movq %rbx, %rdi
callq 0xaff3
movq %rbx, %rdi
callq *0x2088(%rbx)
movl 0x30(%rbx), %ecx
movl 0x34(%rbx), %eax
decl %ecx
cmpl %ecx, %eax
jl 0xb522
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 0x237e0(%rip), %rdi     # 0x2edd4
leaq 0x269cc(%rip), %rsi     # 0x31fc7
leaq 0x21257(%rip), %rcx     # 0x2c859
movl $0x153, %edx            # imm = 0x153
callq 0xa0b0
// File: /workspace/github_c_makefile_star2_O2/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 0xb620
testq %rcx, %rcx
jne 0xb627
jmp 0xb656
testq %rcx, %rcx
jne 0xb656
xorl %ecx, %ecx
movq 0x60(%rdi), %rdx
testq %rdx, %rdx
je 0xb63b
movq %rsi, 0x28(%rdx)
movq %rsi, 0x58(%rdi)
movq %rsi, %rcx
movq %rsi, 0x60(%rdi)
movq %rdx, 0x20(%rsi)
andq $0x0, 0x28(%rsi)
orq %rcx, %rax
jne 0xb655
movq %rsi, 0x50(%rdi)
movq %rsi, 0x58(%rdi)
retq
pushq %rbp
movq %rsp, %rbp
leaq 0x21466(%rip), %rdi     # 0x2cac7
leaq 0x2695f(%rip), %rsi     # 0x31fc7
leaq 0x2142a(%rip), %rcx     # 0x2ca99
pushq $0x11
popq %rdx
callq 0xa0b0
// File: /workspace/github_c_makefile_star2_O2/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
subq $0x18, %rsp
testq %rdi, %rdi
je 0xb780
movq %rdi, %rbx
movq 0x2078(%rdi), %rax
movq %rax, -0x38(%rbp)
cmpq $0x0, (%rax)
jne 0xb759
leaq 0x211ca(%rip), %rdi     # 0x2c87a
leaq 0x26910(%rip), %rsi     # 0x31fc7
leaq 0x211da(%rip), %rcx     # 0x2c898
movl $0x17b, %edx            # imm = 0x17B
callq 0xa0b0
xorl %eax, %eax
xorl %r13d, %r13d
xorl %r12d, %r12d
pushq $-0x1
popq %r15
xorl %edx, %edx
movq -0x38(%rbp), %r14
testb $0x1, %dl
jne 0xb723
cmpq $0x0, (%r14)
je 0xb723
movl %ecx, 0x40(%rbx)
movq 0x38(%rbx), %rax
movq %rax, 0x44(%rbx)
movq %rbx, %rdi
leaq -0x2c(%rbp), %rsi
callq *0x8(%r14)
testq %rax, %rax
setne %dl
je 0xb70f
movl -0x2c(%rbp), %r13d
movl 0x38(%rbx), %r12d
movl 0x3c(%rbx), %r15d
movl 0x40(%rbx), %ecx
movl %ecx, 0x34(%rbx)
movq 0x44(%rbx), %rsi
movq %rsi, 0x38(%rbx)
addq $0x10, %r14
jmp 0xb6da
testq %rax, %rax
je 0xb748
addl 0x4(%rax), %ecx
movl %ecx, 0x34(%rbx)
movl %r12d, 0x38(%rbx)
movl %r15d, 0x3c(%rbx)
testl %r13d, %r13d
jne 0xb759
movq %rbx, %rdi
movq %rax, %rsi
callq 0xb60c
jmp 0xb759
movq %rbx, %rdi
callq 0xaff3
movq %rbx, %rdi
callq *0x2088(%rbx)
movl 0x30(%rbx), %eax
movl 0x34(%rbx), %ecx
decl %eax
cmpl %eax, %ecx
jl 0xb6c8
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 0x2364d(%rip), %rdi     # 0x2edd4
leaq 0x26839(%rip), %rsi     # 0x31fc7
leaq 0x21103(%rip), %rcx     # 0x2c898
movl $0x17a, %edx            # imm = 0x17A
callq 0xa0b0
// File: /workspace/github_c_makefile_star2_O2/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 0xb87a
movq %rsi, %r14
testq %rsi, %rsi
je 0xb899
movq %rdi, %rbx
movslq 0x4(%r14), %r15
leaq 0x1(%r15), %rdi
callq 0xa120
movq %rax, %r12
leaq -0x30(%rbp), %r13
movq %rax, (%r13)
movq 0x8(%r14), %rsi
movq %rax, %rdi
movq %r15, %rdx
callq 0xa110
movb $0x0, (%r12,%r15)
movq %r12, (%rbx)
addq $0x8, %rbx
pushq $0x1
popq %rdx
movq %rbx, %rdi
movq %r13, %rsi
callq 0xa326
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
leaq 0x23553(%rip), %rdi     # 0x2edd4
leaq 0x2673f(%rip), %rsi     # 0x31fc7
leaq 0x21066(%rip), %rcx     # 0x2c8f5
movl $0x1af, %edx            # imm = 0x1AF
callq 0xa0b0
leaq 0x20c1a(%rip), %rdi     # 0x2c4ba
leaq 0x26720(%rip), %rsi     # 0x31fc7
leaq 0x21047(%rip), %rcx     # 0x2c8f5
movl $0x1b0, %edx            # imm = 0x1B0
callq 0xa0b0
// File: /workspace/github_c_makefile_star2_O2/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 0xb96a
movq %rsi, %rbx
testq %rsi, %rsi
je 0xb989
movq %rdi, %r14
leaq 0x21087(%rip), %rdi     # 0x2c965
movq %rbx, %rsi
callq 0xa0c0
movq %r14, %rdi
movq %rbx, %rsi
callq 0xaa60
pushq $0xa
popq %rdi
movq %rbx, %rsi
callq 0xa0d0
movl 0x4(%r14), %edx
leaq 0x21065(%rip), %rsi     # 0x2c96c
movq %rbx, %rdi
xorl %eax, %eax
callq 0xa0f0
movl (%r14), %ecx
leaq 0x2105d(%rip), %rsi     # 0x2c978
movq %rbx, %rdi
movl %ecx, %edx
xorl %eax, %eax
callq 0xa0f0
movq 0x10(%r14), %rdx
leaq 0x21056(%rip), %rsi     # 0x2c988
movq %rbx, %rdi
xorl %eax, %eax
callq 0xa0f0
movl 0x18(%r14), %edx
leaq 0x2104b(%rip), %rsi     # 0x2c992
movq %rbx, %rdi
xorl %eax, %eax
callq 0xa0f0
movl 0x1c(%r14), %edx
leaq 0x21040(%rip), %rsi     # 0x2c99c
movq %rbx, %rdi
xorl %eax, %eax
popq %rbx
popq %r14
popq %rbp
jmp 0xa0f0
leaq 0x20b49(%rip), %rdi     # 0x2c4ba
leaq 0x2664f(%rip), %rsi     # 0x31fc7
leaq 0x20fb4(%rip), %rcx     # 0x2c933
movl $0x1be, %edx            # imm = 0x1BE
callq 0xa0b0
leaq 0x21079(%rip), %rdi     # 0x2ca09
leaq 0x26630(%rip), %rsi     # 0x31fc7
leaq 0x20f95(%rip), %rcx     # 0x2c933
movl $0x1bf, %edx            # imm = 0x1BF
callq 0xa0b0
// File: /workspace/github_c_makefile_star2_O2/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 %r15
pushq %r14
pushq %rbx
pushq %rax
testq %rdi, %rdi
je 0xb9f9
movq %rsi, %rbx
testq %rsi, %rsi
je 0xba18
movq %rdi, %r14
addq $0x50, %r14
pushq $0xa
popq %r15
movq (%r14), %r14
testq %r14, %r14
je 0xb9ee
movq %r14, %rdi
movq %rbx, %rsi
callq 0xb8b8
movl %r15d, %edi
movq %rbx, %rsi
callq 0xa0d0
addq $0x28, %r14
jmp 0xb9ca
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
leaq 0x233d4(%rip), %rdi     # 0x2edd4
leaq 0x265c0(%rip), %rsi     # 0x31fc7
leaq 0x20f9a(%rip), %rcx     # 0x2c9a8
movl $0x1d0, %edx            # imm = 0x1D0
callq 0xa0b0
leaq 0x20fea(%rip), %rdi     # 0x2ca09
leaq 0x265a1(%rip), %rsi     # 0x31fc7
leaq 0x20f7b(%rip), %rcx     # 0x2c9a8
movl $0x1d1, %edx            # imm = 0x1D1
callq 0xa0b0
nop
// File: /workspace/github_c_makefile_star2_O2/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:
testq %rdi, %rdi
je 0xba6d
andq $0x0, 0x10(%rdi)
testq %rsi, %rsi
xorps %xmm0, %xmm0
movups %xmm0, (%rdi)
leaq 0x3c(%rip), %rax        # 0xba8e
cmovneq %rsi, %rax
movq %rax, 0x18(%rdi)
testq %rdx, %rdx
leaq 0x4b(%rip), %rax        # 0xbaaf
cmovneq %rdx, %rax
movq %rax, 0x20(%rdi)
retq
pushq %rbp
movq %rsp, %rbp
leaq 0x2117a(%rip), %rdi     # 0x2cbf2
leaq 0x2109d(%rip), %rsi     # 0x2cb1c
leaq 0x2109d(%rip), %rcx     # 0x2cb23
pushq $0x18
popq %rdx
callq 0xa0b0
// File: /workspace/github_c_makefile_star2_O2/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 0xbb18
movl %esi, %ebx
movq %rdi, %r14
movq (%rdi), %r15
testq %r15, %r15
je 0xbb0f
testb %bl, %bl
je 0xbafe
movq 0x8(%r15), %rdi
testq %rdi, %rdi
je 0xbafe
callq *0x20(%r14)
movq 0x18(%r15), %r12
movq %r15, %rdi
callq 0xa190
movq %r12, %r15
jmp 0xbae8
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
leaq 0x210d3(%rip), %rdi     # 0x2cbf2
leaq 0x20ff6(%rip), %rsi     # 0x2cb1c
leaq 0x2103b(%rip), %rcx     # 0x2cb68
pushq $0x2f
popq %rdx
callq 0xa0b0
// File: /workspace/github_c_makefile_star2_O2/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
pushq $0x20
popq %rdi
callq 0xa120
movq %rbx, (%rax)
movq %r14, 0x8(%rax)
cmpq $0x0, (%rbx)
movq 0x8(%rbx), %rcx
je 0xbb73
testq %rcx, %rcx
je 0xbb8f
movq %rax, 0x18(%rcx)
movq %rcx, 0x10(%rax)
andq $0x0, 0x18(%rax)
movq %rax, 0x8(%rbx)
jmp 0xbb86
testq %rcx, %rcx
jne 0xbb8f
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 0x217da(%rip), %rdi     # 0x2d370
leaq 0x20f7f(%rip), %rsi     # 0x2cb1c
leaq 0x20fe8(%rip), %rcx     # 0x2cb8c
pushq $0x51
popq %rdx
callq 0xa0b0
// File: /workspace/github_c_makefile_star2_O2/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 0xbc1c
testq %rsi, %rsi
je 0xbc35
cmpq %rdi, (%rsi)
jne 0xbc4e
movq 0x8(%rdi), %rax
cmpq %rsi, (%rdi)
je 0xbbe3
cmpq %rsi, %rax
je 0xbbf6
movq 0x10(%rsi), %rax
movq 0x18(%rsi), %rcx
movq %rcx, 0x18(%rax)
movq %rax, 0x10(%rcx)
jmp 0xbc0b
cmpq %rsi, %rax
je 0xbc05
movq 0x18(%rsi), %rax
andq $0x0, 0x10(%rax)
movq %rax, (%rdi)
jmp 0xbc0b
movq 0x10(%rsi), %rax
andq $0x0, 0x18(%rax)
movq %rax, 0x8(%rdi)
jmp 0xbc0b
xorps %xmm0, %xmm0
movups %xmm0, (%rdi)
decq 0x10(%rdi)
andq $0x0, (%rsi)
xorps %xmm0, %xmm0
movups %xmm0, 0x10(%rsi)
popq %rbp
retq
leaq 0x20fcf(%rip), %rdi     # 0x2cbf2
leaq 0x20ef2(%rip), %rsi     # 0x2cb1c
leaq 0x20f82(%rip), %rcx     # 0x2cbb3
pushq $0x5b
jmp 0xbc65
leaq 0x2507f(%rip), %rdi     # 0x30cbb
leaq 0x20ed9(%rip), %rsi     # 0x2cb1c
leaq 0x20f69(%rip), %rcx     # 0x2cbb3
pushq $0x5c
jmp 0xbc65
leaq 0x20f8f(%rip), %rdi     # 0x2cbe4
leaq 0x20ec0(%rip), %rsi     # 0x2cb1c
leaq 0x20f50(%rip), %rcx     # 0x2cbb3
pushq $0x5d
popq %rdx
callq 0xa0b0
// File: /workspace/github_c_makefile_star2_O2/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 0xbcb4
movq %rsi, %rbx
testq %rsi, %rsi
je 0xbccd
movl %edx, %r15d
movq %rdi, %r14
movq %rbx, %rsi
callq 0xbbac
testb %r15b, %r15b
je 0xbca2
movq 0x8(%rbx), %rdi
testq %rdi, %rdi
je 0xbca2
callq *0x20(%r14)
movq %rbx, %rdi
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
jmp 0xa190
leaq 0x20f37(%rip), %rdi     # 0x2cbf2
leaq 0x20e5a(%rip), %rsi     # 0x2cb1c
leaq 0x20f2e(%rip), %rcx     # 0x2cbf7
pushq $0x7a
jmp 0xbce4
leaq 0x24fe7(%rip), %rdi     # 0x30cbb
leaq 0x20e41(%rip), %rsi     # 0x2cb1c
leaq 0x20f15(%rip), %rcx     # 0x2cbf7
pushq $0x7b
popq %rdx
callq 0xa0b0
// File: /workspace/github_c_makefile_star2_O2/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 0xbd36
movq %rsi, %r15
testq %rsi, %rsi
je 0xbd55
movq %rdx, %rbx
testq %rdx, %rdx
je 0xbd74
movq %rdi, %r14
movq (%r14), %r14
testq %r14, %r14
je 0xbd28
movq 0x8(%r14), %rdi
movq %rbx, %rsi
callq *%r15
testb %al, %al
jne 0xbd28
addq $0x18, %r14
jmp 0xbd0c
movq %r14, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
leaq 0x20eb5(%rip), %rdi     # 0x2cbf2
leaq 0x20dd8(%rip), %rsi     # 0x2cb1c
leaq 0x20ee4(%rip), %rcx     # 0x2cc2f
movl $0x8a, %edx
callq 0xa0b0
leaq 0x20f5b(%rip), %rdi     # 0x2ccb7
leaq 0x20db9(%rip), %rsi     # 0x2cb1c
leaq 0x20ec5(%rip), %rcx     # 0x2cc2f
movl $0x8b, %edx
callq 0xa0b0
leaq 0x29870(%rip), %rdi     # 0x355eb
leaq 0x20d9a(%rip), %rsi     # 0x2cb1c
leaq 0x20ea6(%rip), %rcx     # 0x2cc2f
movl $0x8c, %edx
callq 0xa0b0
// File: /workspace/github_c_makefile_star2_O2/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
testq %rdi, %rdi
je 0xbdb3
movq %rsi, %rdx
movq 0x18(%rdi), %rsi
testq %rsi, %rsi
je 0xbdd2
testq %rdx, %rdx
je 0xbdf1
popq %rbp
jmp 0xbcea
leaq 0x20e38(%rip), %rdi     # 0x2cbf2
leaq 0x20d5b(%rip), %rsi     # 0x2cb1c
leaq 0x20eb9(%rip), %rcx     # 0x2cc81
movl $0x9d, %edx
callq 0xa0b0
leaq 0x20ed8(%rip), %rdi     # 0x2ccb1
leaq 0x20d3c(%rip), %rsi     # 0x2cb1c
leaq 0x20e9a(%rip), %rcx     # 0x2cc81
movl $0x9e, %edx
callq 0xa0b0
leaq 0x297f3(%rip), %rdi     # 0x355eb
leaq 0x20d1d(%rip), %rsi     # 0x2cb1c
leaq 0x20e7b(%rip), %rcx     # 0x2cc81
movl $0x9f, %edx
callq 0xa0b0
// File: /workspace/github_c_makefile_star2_O2/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 0xc1b5
movq %r8, %rbx
movq %rcx, %r15
movq %rdx, %r12
movq %rsi, %r13
movq %rdi, %r14
movq 0x31e5b(%rip), %rdx     # 0x3dfc0
xorl %esi, %esi
callq 0xba38
testq %r13, %r13
leaq 0x5c(%rip), %rax        # 0xc1d2
cmoveq %rax, %r13
movq %r13, 0x28(%r14)
testq %r12, %r12
cmoveq %rax, %r12
movq %r12, 0x30(%r14)
testq %r15, %r15
leaq 0x60(%rip), %rax        # 0xc1f3
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 0x20f2d(%rip), %rdi     # 0x2d0e9
leaq 0x20b84(%rip), %rsi     # 0x2cd47
leaq 0x20b83(%rip), %rcx     # 0x2cd4d
pushq $0x1d
popq %rdx
callq 0xa0b0
// File: /workspace/github_c_makefile_star2_O2/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 0xc278
movq %rbx, %r12
movq (%r12), %r12
testq %r12, %r12
je 0xc278
movq 0x8(%r12), %r13
testb %r15b, %r15b
je 0xc25c
movq 0x8(%r13), %rdi
testq %rdi, %rdi
je 0xc25c
callq *0x38(%rbx)
andq $0x0, 0x8(%r13)
testb %r14b, %r14b
je 0xc272
movq 0x10(%r13), %rdi
testq %rdi, %rdi
je 0xc272
callq *0x40(%rbx)
andq $0x0, 0x10(%r13)
addq $0x18, %r12
jmp 0xc238
pushq $0x1
popq %rsi
movq %rbx, %rdi
callq 0xbad0
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_O2/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 0xc31b
movq %rsi, %r15
testq %rsi, %rsi
je 0xc334
movl %ecx, %r12d
movq %rdx, %rbx
movq %rdi, %r14
leaq 0x8c(%rip), %rsi        # 0xc351
movq %r15, %rdx
callq 0xbcea
testq %rax, %rax
je 0xc2f5
movq 0x8(%rax), %r15
testb %r12b, %r12b
je 0xc2e8
movq 0x10(%r15), %rdi
testq %rdi, %rdi
je 0xc2e8
callq *0x40(%r14)
movq %rbx, 0x10(%r15)
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
pushq $0x18
popq %rdi
callq 0xa120
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 0xbb35
leaq 0x20dc7(%rip), %rdi     # 0x2d0e9
leaq 0x20a1e(%rip), %rsi     # 0x2cd47
leaq 0x20a66(%rip), %rcx     # 0x2cd96
pushq $0x68
jmp 0xc34b
leaq 0x20a86(%rip), %rdi     # 0x2cdc1
leaq 0x20a05(%rip), %rsi     # 0x2cd47
leaq 0x20a4d(%rip), %rcx     # 0x2cd96
pushq $0x69
popq %rdx
callq 0xa0b0
// File: /workspace/github_c_makefile_star2_O2/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 0xc36d
testq %rsi, %rsi
je 0xc386
movq (%rdi), %rax
movq 0x8(%rdi), %rdi
movq 0x28(%rax), %rax
popq %rbp
jmpq *%rax
leaq 0x20d8b(%rip), %rdi     # 0x2d0ff
leaq 0x209cc(%rip), %rsi     # 0x2cd47
leaq 0x20d87(%rip), %rcx     # 0x2d109
pushq $0x5a
jmp 0xc39d
leaq 0x2925e(%rip), %rdi     # 0x355eb
leaq 0x209b3(%rip), %rsi     # 0x2cd47
leaq 0x20d6e(%rip), %rcx     # 0x2d109
pushq $0x5b
popq %rdx
callq 0xa0b0
// File: /workspace/github_c_makefile_star2_O2/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 0xc3c5
testq %rsi, %rsi
je 0xc3e4
callq 0xc403
testq %rax, %rax
je 0xc3c1
movq 0x8(%rax), %rax
jmp 0xc3c3
xorl %eax, %eax
popq %rbp
retq
leaq 0x20d1d(%rip), %rdi     # 0x2d0e9
leaq 0x20974(%rip), %rsi     # 0x2cd47
leaq 0x209eb(%rip), %rcx     # 0x2cdc5
movl $0x91, %edx
callq 0xa0b0
leaq 0x209d6(%rip), %rdi     # 0x2cdc1
leaq 0x20955(%rip), %rsi     # 0x2cd47
leaq 0x209cc(%rip), %rcx     # 0x2cdc5
movl $0x92, %edx
callq 0xa0b0
// File: /workspace/github_c_makefile_star2_O2/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 0xc439
testq %rsi, %rsi
je 0xc458
callq 0xc3a3
testq %rax, %rax
je 0xc435
movq 0x10(%rax), %rax
jmp 0xc437
xorl %eax, %eax
popq %rbp
retq
leaq 0x20ca9(%rip), %rdi     # 0x2d0e9
leaq 0x20900(%rip), %rsi     # 0x2cd47
leaq 0x2099e(%rip), %rcx     # 0x2cdec
movl $0xa0, %edx
callq 0xa0b0
leaq 0x20962(%rip), %rdi     # 0x2cdc1
leaq 0x208e1(%rip), %rsi     # 0x2cd47
leaq 0x2097f(%rip), %rcx     # 0x2cdec
movl $0xa1, %edx
callq 0xa0b0