LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O1/KhuramAli[P]JAM-Benchmark/lock_and_lockfree/code13.cpp
// Function: threadfunc_atomic_set_relaxed()
void threadfunc_atomic_set_relaxed()
    {
      start_wait();
      // Wait until main() sends data
      long i;
      for (i = 1; i <= count; i++) {
        atomic_uint.store(i, std::memory_order_relaxed);
      }
    }

// Assembly:
pushq %rax
callq 0x242b
cmpq $0x0, 0x373c(%rip)      # 0x61d0
jle 0x2aab
xorl %eax, %eax
incq %rax
movq %rax, 0x3726(%rip)      # 0x61c8
cmpq 0x3727(%rip), %rax      # 0x61d0
jl 0x2a98
popq %rax
retq
// File: /workspace/github_c_makefile_star2_O1/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 0x242b
movq 0x35de(%rip), %rax      # 0x61d0
testq %rax, %rax
jle 0x2c3c
xorl %r12d, %r12d
movq 0x33cf(%rip), %r14      # 0x5fd0
leaq 0x1432(%rip), %r15      # 0x403a
xorl %ebx, %ebx
movq 0x35b7(%rip), %rax      # 0x61c8
testq %rax, %rax
je 0x2c1b
incq %rbx
jmp 0x2c2b
movl $0x6, %edx
movq %r14, %rdi
movq %r15, %rsi
callq 0x2170
movq 0x359e(%rip), %rax      # 0x61d0
incq %r12
cmpq %rax, %r12
jl 0x2c0a
jmp 0x2c3e
xorl %ebx, %ebx
cmpq %rax, %rbx
jne 0x2c4f
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
movq 0x337a(%rip), %r14      # 0x5fd0
leaq 0x13b9(%rip), %rsi      # 0x4016
movl $0x14, %edx
movq %r14, %rdi
callq 0x2170
movq %r14, %rdi
movq %rbx, %rsi
callq 0x2140
movq %rax, %rbx
leaq 0x13ac(%rip), %rsi      # 0x402b
movl $0x6, %edx
movq %rax, %rdi
callq 0x2170
movq 0x353d(%rip), %rsi      # 0x61d0
movq %rbx, %rdi
callq 0x2140
leaq 0x147b(%rip), %rsi      # 0x411d
movl $0x1, %edx
movq %rax, %rdi
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
jmp 0x2170
// File: /workspace/github_c_makefile_star2_O1/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 0x242b
cmpq $0x0, 0x3508(%rip)      # 0x61d0
jle 0x2cf5
movl $0x1, %ecx
movq 0x34f2(%rip), %rax      # 0x61c8
leaq 0x1(%rax), %rdx
lock
cmpxchgq %rdx, 0x34e5(%rip)      # 0x61c8
jne 0x2ccf
leaq 0x1(%rcx), %rax
cmpq 0x34e0(%rip), %rcx      # 0x61d0
movq %rax, %rcx
jl 0x2ccf
popq %rax
retq
// File: /workspace/github_c_makefile_star2_O1/dropletzhu[P]msuite/msender6.c
// Function: usage
void usage()
{
    printf("Usage: ./msender -s source -g group -p port -h hops -l length -c count\n");
	printf(" -s souruce	the source ip\n");
	printf(" -i ifname 	the outgoing interface name\n");
	printf(" -g group	the group ip\n");
	printf(" -p port	the port\n");
	printf(" -h hops	the hops, default hops is 1\n");
	printf(" -l length	the packet length, default length is 256 bytes\n");
	printf(" -c count	the packet count, default count is unlimited\n");
    printf(" Version	%s\n",version);
}

// Assembly:
pushq %rax
leaq 0xe93(%rip), %rdi       # 0x20a7
callq 0x1040
leaq 0xece(%rip), %rdi       # 0x20ee
callq 0x1040
leaq 0xedc(%rip), %rdi       # 0x2108
callq 0x1040
leaq 0xef8(%rip), %rdi       # 0x2130
callq 0x1040
leaq 0xf03(%rip), %rdi       # 0x2147
callq 0x1040
leaq 0xf09(%rip), %rdi       # 0x2159
callq 0x1040
leaq 0xf22(%rip), %rdi       # 0x217e
callq 0x1040
leaq 0xf50(%rip), %rdi       # 0x21b8
callq 0x1040
leaq 0xdd4(%rip), %rdi       # 0x2048
leaq 0xdda(%rip), %rsi       # 0x2055
xorl %eax, %eax
popq %rcx
jmp 0x1060
// File: /workspace/github_c_makefile_star2_O1/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 0xa35e
testq %rsi, %rsi
je 0xa37d
xorps %xmm0, %xmm0
movups %xmm0, (%rdi)
movq %rsi, 0x10(%rdi)
movq $0x0, 0x18(%rdi)
popq %rbp
retq
leaq 0x23c9f(%rip), %rdi     # 0x2e004
leaq 0x23c9d(%rip), %rsi     # 0x2e009
leaq 0x23c9e(%rip), %rcx     # 0x2e011
movl $0xf, %edx
callq 0xa0b0
leaq 0x23cb6(%rip), %rdi     # 0x2e03a
leaq 0x23c7e(%rip), %rsi     # 0x2e009
leaq 0x23c7f(%rip), %rcx     # 0x2e011
movl $0x10, %edx
callq 0xa0b0
// File: /workspace/github_c_makefile_star2_O1/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 0xa3c9
movq %rdi, %rbx
movq 0x18(%rdi), %rdi
testq %rdi, %rdi
je 0xa3b8
callq 0xa190
xorps %xmm0, %xmm0
movups %xmm0, 0x10(%rbx)
movups %xmm0, (%rbx)
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
leaq 0x23c34(%rip), %rdi     # 0x2e004
leaq 0x23c32(%rip), %rsi     # 0x2e009
leaq 0x23c6a(%rip), %rcx     # 0x2e048
movl $0x19, %edx
callq 0xa0b0
// File: /workspace/github_c_makefile_star2_O1/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 0xa44c
movq %rsi, %r15
testq %rsi, %rsi
je 0xa46b
movq %rdx, %rbx
testq %rdx, %rdx
je 0xa441
movq %rdi, %r14
movq 0x8(%rdi), %rax
addq %rbx, %rax
cmpq (%rdi), %rax
jbe 0xa421
movq %r14, %rdi
movq %rbx, %rsi
callq 0xa48a
movq 0x10(%r14), %rdx
movq 0x8(%r14), %rdi
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 0x23c16(%rip), %rdi     # 0x2e069
leaq 0x23baf(%rip), %rsi     # 0x2e009
leaq 0x23c0c(%rip), %rcx     # 0x2e06d
movl $0x39, %edx
callq 0xa0b0
leaq 0x25a8b(%rip), %rdi     # 0x2fefd
leaq 0x23b90(%rip), %rsi     # 0x2e009
leaq 0x23bed(%rip), %rcx     # 0x2e06d
movl $0x3a, %edx
callq 0xa0b0
// File: /workspace/github_c_makefile_star2_O1/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 0xa4b1
callq 0xa130
jmp 0xa4b9
movq %rsi, %rdi
callq 0xa120
movq %rax, 0x18(%rbx)
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/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 0xa4ea
testq %rsi, %rsi
je 0xa509
movq 0x10(%rdi), %rax
cmpq 0x10(%rsi), %rax
jne 0xa528
movq 0x8(%rsi), %rdx
movq 0x18(%rsi), %rsi
popq %rbp
jmp 0xa3e8
leaq 0x23b78(%rip), %rdi     # 0x2e069
leaq 0x23b11(%rip), %rsi     # 0x2e009
leaq 0x23baa(%rip), %rcx     # 0x2e0a9
movl $0x4c, %edx
callq 0xa0b0
leaq 0x259ed(%rip), %rdi     # 0x2fefd
leaq 0x23af2(%rip), %rsi     # 0x2e009
leaq 0x23b8b(%rip), %rcx     # 0x2e0a9
movl $0x4d, %edx
callq 0xa0b0
leaq 0x23bb9(%rip), %rdi     # 0x2e0e8
leaq 0x23ad3(%rip), %rsi     # 0x2e009
leaq 0x23b6c(%rip), %rcx     # 0x2e0a9
movl $0x4e, %edx
callq 0xa0b0
// File: /workspace/github_c_makefile_star2_O1/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 0xa5de
movq %rsi, %r12
testq %rsi, %rsi
je 0xa5fd
movq %rdx, %rbx
testq %rdx, %rdx
je 0xa5d5
movq %rcx, %r15
movq %rdi, %r14
movq 0x8(%rdi), %rax
addq %rbx, %rax
cmpq (%rdi), %rax
jbe 0xa58c
movq %r14, %rdi
movq %rbx, %rsi
callq 0xa48a
movq 0x18(%r14), %rax
leaq (%r15,%rbx), %rdi
movq 0x8(%r14), %rdx
movq 0x10(%r14), %rsi
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 0x23a84(%rip), %rdi     # 0x2e069
leaq 0x23a1d(%rip), %rsi     # 0x2e009
leaq 0x23b16(%rip), %rcx     # 0x2e109
movl $0x59, %edx
callq 0xa0b0
leaq 0x258f9(%rip), %rdi     # 0x2fefd
leaq 0x239fe(%rip), %rsi     # 0x2e009
leaq 0x23af7(%rip), %rcx     # 0x2e109
movl $0x5a, %edx
callq 0xa0b0
// File: /workspace/github_c_makefile_star2_O1/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 0xaf0d
movq %rsi, %r15
testq %rsi, %rsi
je 0xaf2c
movl %edx, %r14d
testl %edx, %edx
js 0xaf4b
movq %rcx, %rbx
cmpq $0x0, (%rcx)
je 0xaf6a
movq %rdi, %r13
movl $0x2098, %edi           # imm = 0x2098
callq 0xa120
testq %rax, %rax
je 0xaef8
movq %rax, %r12
movq %r13, (%rax)
movq %rax, %rdi
addq $0x8, %rdi
movl $0x8, %esi
callq 0xa33c
movq %r15, 0x28(%r12)
movl %r14d, 0x30(%r12)
movaps 0x23643(%rip), %xmm0    # 0x2e4e0
movups %xmm0, 0x34(%r12)
movq $0x1, 0x44(%r12)
xorps %xmm0, %xmm0
movups %xmm0, 0x50(%r12)
movups %xmm0, 0x60(%r12)
movl $0xffffffff, 0x70(%r12) # imm = 0xFFFFFFFF
movq %rbx, 0x2078(%r12)
movq $0x0, 0x2080(%r12)
leaq 0xaa(%rip), %rax        # 0xaf89
movq %rax, 0x2088(%r12)
leaq 0x1b0(%rip), %rax       # 0xb09e
movq %rax, 0x2090(%r12)
jmp 0xaefb
xorl %r12d, %r12d
movq %r12, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
leaq 0x23b05(%rip), %rdi     # 0x2ea19
leaq 0x290ec(%rip), %rsi     # 0x34007
leaq 0x235ce(%rip), %rcx     # 0x2e4f0
movl $0x67, %edx
callq 0xa0b0
leaq 0x23613(%rip), %rdi     # 0x2e546
leaq 0x290cd(%rip), %rsi     # 0x34007
leaq 0x235af(%rip), %rcx     # 0x2e4f0
movl $0x68, %edx
callq 0xa0b0
leaq 0x235fb(%rip), %rdi     # 0x2e54d
leaq 0x290ae(%rip), %rsi     # 0x34007
leaq 0x23590(%rip), %rcx     # 0x2e4f0
movl $0x69, %edx
callq 0xa0b0
leaq 0x2391e(%rip), %rdi     # 0x2e88f
leaq 0x2908f(%rip), %rsi     # 0x34007
leaq 0x23571(%rip), %rcx     # 0x2e4f0
movl $0x6a, %edx
callq 0xa0b0
// File: /workspace/github_c_makefile_star2_O1/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 0xb060
movq %rdi, %rbx
movq (%rdi), %rdx
testq %rdx, %rdx
je 0xb07f
movq 0x35042(%rip), %r15     # 0x3fff8
movq (%r15), %rdi
movl 0x38(%rbx), %ecx
movl 0x3c(%rbx), %r8d
leaq 0x23a57(%rip), %rsi     # 0x2ea1e
xorl %r12d, %r12d
xorl %eax, %eax
callq 0xa0f0
movq (%r15), %rsi
movl $0xa, %edi
callq 0xa0d0
movq (%r15), %rsi
movl $0x9, %edi
callq 0xa0d0
movb $0x1, %r13b
movslq 0x34(%rbx), %rax
leal (%r12,%rax), %ecx
cmpl 0x30(%rbx), %ecx
jge 0xb03c
addq 0x28(%rbx), %rax
movsbq (%r12,%rax), %r14
callq 0xa180
movq (%rax), %rax
testb $0x20, 0x1(%rax,%r14,2)
jne 0xb019
movb $0x1, %r13b
jmp 0xb028
testb $0x1, %r13b
je 0xb033
movl $0x20, %r14d
xorl %r13d, %r13d
movq (%r15), %rsi
movl %r14d, %edi
callq 0xa0d0
incq %r12
cmpl $0x3c, %r12d
jne 0xafee
movq (%r15), %rsi
movl $0xa, %edi
callq 0xa0d0
movq (%r15), %rsi
movl $0xa, %edi
callq 0xa0d0
movl $0x1, %edi
callq 0xa160
leaq 0x2b6ef(%rip), %rdi     # 0x36756
leaq 0x28f99(%rip), %rsi     # 0x34007
leaq 0x23973(%rip), %rcx     # 0x2e9e8
movl $0x39, %edx
callq 0xa0b0
leaq 0x2398e(%rip), %rdi     # 0x2ea14
leaq 0x28f7a(%rip), %rsi     # 0x34007
leaq 0x23954(%rip), %rcx     # 0x2e9e8
movl $0x3a, %edx
callq 0xa0b0
// File: /workspace/github_c_makefile_star2_O1/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 0xb0c6
leaq 0x2b6a8(%rip), %rdi     # 0x36756
leaq 0x28f52(%rip), %rsi     # 0x34007
leaq 0x2398f(%rip), %rcx     # 0x2ea4b
movl $0x59, %edx
callq 0xa0b0
movq (%rdi), %rdx
testq %rdx, %rdx
jne 0xb0ed
leaq 0x2393f(%rip), %rdi     # 0x2ea14
leaq 0x28f2b(%rip), %rsi     # 0x34007
leaq 0x23968(%rip), %rcx     # 0x2ea4b
movl $0x5a, %edx
callq 0xa0b0
movq 0x34f04(%rip), %rax     # 0x3fff8
movq (%rax), %rax
movl 0x38(%rdi), %ecx
movl 0x3c(%rdi), %r8d
leaq 0x23974(%rip), %rsi     # 0x2ea79
movq %rax, %rdi
xorl %eax, %eax
callq 0xa0f0
movl $0x1, %edi
callq 0xa160
// File: /workspace/github_c_makefile_star2_O1/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 0xb17f
movq %rdi, %rbx
cmpq $0x0, 0x10(%rdi)
je 0xb150
xorl %r14d, %r14d
movq 0x20(%rbx), %rax
movq 0x18(%rbx), %rcx
imulq %r14, %rcx
movq (%rax,%rcx), %rdi
callq 0xa190
incq %r14
cmpq %r14, 0x10(%rbx)
ja 0xb132
leaq 0x8(%rbx), %rdi
callq 0xa39c
movq 0x68(%rbx), %rdi
testq %rdi, %rdi
je 0xb173
movq 0x30(%rdi), %r14
callq 0xa190
movq %r14, %rdi
testq %r14, %r14
jne 0xb162
movq %rbx, %rdi
popq %rbx
popq %r14
popq %rbp
jmp 0xa190
leaq 0x2b5d0(%rip), %rdi     # 0x36756
leaq 0x28e7a(%rip), %rsi     # 0x34007
leaq 0x233c2(%rip), %rcx     # 0x2e556
movl $0x91, %edx
callq 0xa0b0
// File: /workspace/github_c_makefile_star2_O1/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 0xb22e
movslq 0x34(%rdi), %rax
incq %rax
movl 0x30(%rdi), %ecx
cmpl %ecx, %eax
jge 0xb221
movl %eax, 0x34(%rdi)
movq 0x28(%rdi), %rcx
movsbl (%rcx,%rax), %eax
cmpl $0xa, %eax
jne 0xb22a
incl 0x38(%rdi)
movl $0x0, 0x3c(%rdi)
retq
movl %ecx, 0x34(%rdi)
movl $0xffffffff, %eax       # imm = 0xFFFFFFFF
retq
incl 0x3c(%rdi)
retq
pushq %rbp
movq %rsp, %rbp
leaq 0x2b51d(%rip), %rdi     # 0x36756
leaq 0x28dc7(%rip), %rsi     # 0x34007
leaq 0x23337(%rip), %rcx     # 0x2e57e
movl $0xa6, %edx
callq 0xa0b0
// File: /workspace/github_c_makefile_star2_O1/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 %r14
pushq %rbx
testq %rdi, %rdi
je 0xb2b5
movq %rsi, %rbx
testq %rsi, %rsi
je 0xb2d4
movq %rdi, %r14
movq %rbx, %rdi
callq 0xa080
xorl %esi, %esi
movq %rsi, %rcx
cmpq %rsi, %rax
je 0xb2aa
movl 0x34(%r14), %edx
leaq (%rcx,%rdx), %rsi
incq %rsi
movl $0xffffffff, %edx       # imm = 0xFFFFFFFF
testl %esi, %esi
js 0xb29e
cmpl 0x30(%r14), %esi
jge 0xb29e
movq 0x28(%r14), %rdx
movl %esi, %esi
movsbl (%rdx,%rsi), %edx
movsbl (%rbx,%rcx), %edi
leaq 0x1(%rcx), %rsi
cmpl %edi, %edx
je 0xb272
cmpq %rcx, %rax
setbe %al
popq %rbx
popq %r14
popq %rbp
retq
leaq 0x2b49a(%rip), %rdi     # 0x36756
leaq 0x28d44(%rip), %rsi     # 0x34007
leaq 0x232d8(%rip), %rcx     # 0x2e5a2
movl $0xbc, %edx
callq 0xa0b0
leaq 0x247f0(%rip), %rdi     # 0x2facb
leaq 0x28d25(%rip), %rsi     # 0x34007
leaq 0x232b9(%rip), %rcx     # 0x2e5a2
movl $0xbd, %edx
callq 0xa0b0
// File: /workspace/github_c_makefile_star2_O1/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 0xb312
addl 0x34(%rdi), %esi
movl $0xffffffff, %eax       # imm = 0xFFFFFFFF
js 0xb311
cmpl 0x30(%rdi), %esi
jge 0xb311
movq 0x28(%rdi), %rax
movl %esi, %ecx
movsbl (%rax,%rcx), %eax
retq
pushq %rbp
movq %rsp, %rbp
leaq 0x2b439(%rip), %rdi     # 0x36756
leaq 0x28ce3(%rip), %rsi     # 0x34007
leaq 0x232ae(%rip), %rcx     # 0x2e5d9
movl $0xca, %edx
callq 0xa0b0
// File: /workspace/github_c_makefile_star2_O1/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 0xb385
movq 0x60(%rdi), %rax
testq %rax, %rax
je 0xb384
movq 0x28(%rax), %rcx
movq %rcx, 0x60(%rdi)
retq
pushq %rbp
movq %rsp, %rbp
leaq 0x2b3c6(%rip), %rdi     # 0x36756
leaq 0x28c70(%rip), %rsi     # 0x34007
leaq 0x23290(%rip), %rcx     # 0x2e62e
movl $0xe2, %edx
callq 0xa0b0
// File: /workspace/github_c_makefile_star2_O1/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 0xb3c3
movq 0x60(%rdi), %rax
testq %rax, %rax
je 0xb3be
movq 0x20(%rax), %rax
movq %rax, 0x60(%rdi)
movq 0x60(%rdi), %rax
retq
pushq %rbp
movq %rsp, %rbp
leaq 0x2b388(%rip), %rdi     # 0x36756
leaq 0x28c32(%rip), %rsi     # 0x34007
leaq 0x2327f(%rip), %rcx     # 0x2e65b
movl $0xee, %edx
callq 0xa0b0
// File: /workspace/github_c_makefile_star2_O1/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 0xb45a
testq %rsi, %rsi
je 0xb479
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)
movq $0x0, 0x38(%rsi)
xorps %xmm0, %xmm0
movups %xmm0, 0x20(%rsi)
popq %rbp
retq
leaq 0x2b2f5(%rip), %rdi     # 0x36756
leaq 0x28b9f(%rip), %rsi     # 0x34007
leaq 0x23252(%rip), %rcx     # 0x2e6c1
movl $0x103, %edx            # imm = 0x103
callq 0xa0b0
leaq 0x2304a(%rip), %rdi     # 0x2e4ca
leaq 0x28b80(%rip), %rsi     # 0x34007
leaq 0x23233(%rip), %rcx     # 0x2e6c1
movl $0x104, %edx            # imm = 0x104
callq 0xa0b0
// File: /workspace/github_c_makefile_star2_O1/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 0xb4f0
movl %esi, %r14d
movq %rdi, %rbx
movl $0x40, %edi
callq 0xa120
movq %rax, %r15
testq %rax, %rax
jne 0xb4c8
movq %rbx, %rdi
callq *0x2090(%rbx)
movq %rbx, %rdi
movq %r15, %rsi
movl %r14d, %edx
callq 0xb413
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 0x2b25f(%rip), %rdi     # 0x36756
leaq 0x28b09(%rip), %rsi     # 0x34007
leaq 0x231f5(%rip), %rcx     # 0x2e6fa
movl $0x116, %edx            # imm = 0x116
callq 0xa0b0
// File: /workspace/github_c_makefile_star2_O1/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 0xb584
movq %rsi, %r14
testq %rsi, %rsi
je 0xb5a3
movq %rdi, %rbx
movl $0x40, %edi
callq 0xa120
movq %rax, %r15
testq %rax, %rax
jne 0xb544
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 0x2b1cb(%rip), %rdi     # 0x36756
leaq 0x28a75(%rip), %rsi     # 0x34007
leaq 0x23192(%rip), %rcx     # 0x2e72b
movl $0x126, %edx            # imm = 0x126
callq 0xa0b0
leaq 0x22f20(%rip), %rdi     # 0x2e4ca
leaq 0x28a56(%rip), %rsi     # 0x34007
leaq 0x23173(%rip), %rcx     # 0x2e72b
movl $0x127, %edx            # imm = 0x127
callq 0xa0b0
// File: /workspace/github_c_makefile_star2_O1/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 0xb811
movq %rdi, %rbx
movq 0x2078(%rdi), %rax
movq %rax, -0x38(%rbp)
cmpq $0x0, (%rax)
je 0xb830
movl 0x30(%rbx), %eax
decl %eax
cmpl %eax, 0x34(%rbx)
jge 0xb7fa
movq -0x38(%rbp), %rax
addq $0x10, %rax
movq %rax, -0x40(%rbp)
movq -0x38(%rbp), %rax
cmpq $0x0, (%rax)
je 0xb7aa
xorl %r15d, %r15d
movl $0xffffffff, -0x2c(%rbp) # imm = 0xFFFFFFFF
movq -0x40(%rbp), %r14
xorl %r12d, %r12d
xorl %r13d, %r13d
movl 0x34(%rbx), %eax
movl %eax, 0x40(%rbx)
movq 0x38(%rbx), %rax
movq %rax, 0x44(%rbx)
movq %rbx, %rdi
leaq -0x30(%rbp), %rsi
callq *-0x8(%r14)
testq %rax, %rax
je 0xb787
testq %r15, %r15
je 0xb776
movl 0x4(%rax), %ecx
cmpl 0x4(%r15), %ecx
jle 0xb787
movl -0x30(%rbp), %r13d
movl 0x38(%rbx), %r12d
movl 0x3c(%rbx), %ecx
movl %ecx, -0x2c(%rbp)
movq %rax, %r15
movl 0x40(%rbx), %eax
movl %eax, 0x34(%rbx)
movq 0x44(%rbx), %rax
movq %rax, 0x38(%rbx)
cmpq $0x0, (%r14)
leaq 0x10(%r14), %r14
jne 0xb74a
testl %r13d, %r13d
sete %al
movl -0x2c(%rbp), %edx
jmp 0xb7b7
movl $0xffffffff, %edx       # imm = 0xFFFFFFFF
xorl %r12d, %r12d
movb $0x1, %al
xorl %r15d, %r15d
testq %r15, %r15
je 0xb7db
movl 0x4(%r15), %ecx
addl %ecx, 0x34(%rbx)
movl %r12d, 0x38(%rbx)
movl %edx, 0x3c(%rbx)
testb %al, %al
je 0xb7ec
movq %rbx, %rdi
movq %r15, %rsi
callq 0xb84f
jmp 0xb7ec
movq %rbx, %rdi
callq 0xb1f3
movq %rbx, %rdi
callq *0x2088(%rbx)
movl 0x30(%rbx), %eax
decl %eax
cmpl %eax, 0x34(%rbx)
jl 0xb72c
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 0x2af3e(%rip), %rdi     # 0x36756
leaq 0x287e8(%rip), %rsi     # 0x34007
leaq 0x23043(%rip), %rcx     # 0x2e869
movl $0x153, %edx            # imm = 0x153
callq 0xa0b0
leaq 0x23053(%rip), %rdi     # 0x2e88a
leaq 0x287c9(%rip), %rsi     # 0x34007
leaq 0x23024(%rip), %rcx     # 0x2e869
movl $0x154, %edx            # imm = 0x154
callq 0xa0b0
// File: /workspace/github_c_makefile_star2_O1/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
testq %rax, %rax
jne 0xb864
cmpq $0x0, 0x58(%rdi)
je 0xb86b
testq %rax, %rax
je 0xb8b3
cmpq $0x0, 0x58(%rdi)
je 0xb8b3
movq 0x60(%rdi), %rcx
testq %rcx, %rcx
je 0xb88e
movq %rsi, 0x28(%rcx)
movq %rcx, 0x20(%rsi)
movq $0x0, 0x28(%rsi)
movq %rsi, 0x60(%rdi)
movq %rsi, 0x58(%rdi)
jmp 0xb899
movq %rsi, 0x60(%rdi)
xorps %xmm0, %xmm0
movups %xmm0, 0x20(%rsi)
testq %rax, %rax
je 0xb89f
retq
cmpq $0x0, 0x58(%rdi)
jne 0xb89e
movq 0x60(%rdi), %rax
movq %rax, 0x50(%rdi)
movq %rax, 0x58(%rdi)
retq
pushq %rbp
movq %rsp, %rbp
leaq 0x23219(%rip), %rdi     # 0x2ead7
leaq 0x28742(%rip), %rsi     # 0x34007
leaq 0x231dd(%rip), %rcx     # 0x2eaa9
movl $0x11, %edx
callq 0xa0b0
// File: /workspace/github_c_makefile_star2_O1/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 0xba00
movq %rdi, %rbx
movq 0x2078(%rdi), %rax
movq %rax, -0x38(%rbp)
cmpq $0x0, (%rax)
je 0xba1f
movl 0x30(%rbx), %eax
decl %eax
cmpl %eax, 0x34(%rbx)
jge 0xb9e9
movq -0x38(%rbp), %rax
addq $0x10, %rax
movq %rax, -0x40(%rbp)
movq -0x38(%rbp), %rax
cmpq $0x0, (%rax)
je 0xb999
movl $0xffffffff, -0x2c(%rbp) # imm = 0xFFFFFFFF
xorl %r12d, %r12d
movq -0x40(%rbp), %r14
xorl %r15d, %r15d
xorl %r13d, %r13d
movl 0x34(%rbx), %eax
movl %eax, 0x40(%rbx)
movq 0x38(%rbx), %rax
movq %rax, 0x44(%rbx)
movq %rbx, %rdi
leaq -0x30(%rbp), %rsi
callq *-0x8(%r14)
testq %rax, %rax
je 0xb96f
movl -0x30(%rbp), %r12d
movl 0x38(%rbx), %r15d
movl 0x3c(%rbx), %ecx
movl %ecx, -0x2c(%rbp)
movb $0x1, %r13b
movl 0x40(%rbx), %ecx
movl %ecx, 0x34(%rbx)
movq 0x44(%rbx), %rcx
movq %rcx, 0x38(%rbx)
testb $0x1, %r13b
jne 0xb98d
cmpq $0x0, (%r14)
leaq 0x10(%r14), %r14
jne 0xb940
testl %r12d, %r12d
sete %cl
movl -0x2c(%rbp), %r12d
jmp 0xb9a6
movl $0xffffffff, %r12d      # imm = 0xFFFFFFFF
xorl %eax, %eax
movb $0x1, %cl
xorl %r15d, %r15d
testq %rax, %rax
je 0xb9ca
movl 0x4(%rax), %edx
addl %edx, 0x34(%rbx)
movl %r15d, 0x38(%rbx)
movl %r12d, 0x3c(%rbx)
testb %cl, %cl
je 0xb9db
movq %rbx, %rdi
movq %rax, %rsi
callq 0xb84f
jmp 0xb9db
movq %rbx, %rdi
callq 0xb1f3
movq %rbx, %rdi
callq *0x2088(%rbx)
movl 0x30(%rbx), %eax
decl %eax
cmpl %eax, 0x34(%rbx)
jl 0xb922
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 0x2ad4f(%rip), %rdi     # 0x36756
leaq 0x285f9(%rip), %rsi     # 0x34007
leaq 0x22e93(%rip), %rcx     # 0x2e8a8
movl $0x17a, %edx            # imm = 0x17A
callq 0xa0b0
leaq 0x22e64(%rip), %rdi     # 0x2e88a
leaq 0x285da(%rip), %rsi     # 0x34007
leaq 0x22e74(%rip), %rcx     # 0x2e8a8
movl $0x17b, %edx            # imm = 0x17B
callq 0xa0b0
// File: /workspace/github_c_makefile_star2_O1/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 0xbb1b
movq %rsi, %r14
testq %rsi, %rsi
je 0xbb3a
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
movl $0x1, %edx
movq %rbx, %rdi
movq %r13, %rsi
callq 0xa3e8
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
leaq 0x2ac34(%rip), %rdi     # 0x36756
leaq 0x284de(%rip), %rsi     # 0x34007
leaq 0x22dd5(%rip), %rcx     # 0x2e905
movl $0x1af, %edx            # imm = 0x1AF
callq 0xa0b0
leaq 0x22989(%rip), %rdi     # 0x2e4ca
leaq 0x284bf(%rip), %rsi     # 0x34007
leaq 0x22db6(%rip), %rcx     # 0x2e905
movl $0x1b0, %edx            # imm = 0x1B0
callq 0xa0b0
// File: /workspace/github_c_makefile_star2_O1/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 0xbc0d
movq %rsi, %rbx
testq %rsi, %rsi
je 0xbc2c
movq %rdi, %r14
leaq 0x22df6(%rip), %rdi     # 0x2e975
movq %rbx, %rsi
callq 0xa0c0
movq %r14, %rdi
movq %rbx, %rsi
callq 0xabd8
movl $0xa, %edi
movq %rbx, %rsi
callq 0xa0d0
movl 0x4(%r14), %edx
leaq 0x22dd2(%rip), %rsi     # 0x2e97c
movq %rbx, %rdi
xorl %eax, %eax
callq 0xa0f0
movl (%r14), %ecx
leaq 0x22dca(%rip), %rsi     # 0x2e988
movq %rbx, %rdi
movl %ecx, %edx
xorl %eax, %eax
callq 0xa0f0
movq 0x10(%r14), %rdx
leaq 0x22dc3(%rip), %rsi     # 0x2e998
movq %rbx, %rdi
xorl %eax, %eax
callq 0xa0f0
movl 0x18(%r14), %edx
leaq 0x22db8(%rip), %rsi     # 0x2e9a2
movq %rbx, %rdi
xorl %eax, %eax
callq 0xa0f0
movl 0x1c(%r14), %edx
leaq 0x22dad(%rip), %rsi     # 0x2e9ac
movq %rbx, %rdi
xorl %eax, %eax
popq %rbx
popq %r14
popq %rbp
jmp 0xa0f0
leaq 0x228b6(%rip), %rdi     # 0x2e4ca
leaq 0x283ec(%rip), %rsi     # 0x34007
leaq 0x22d21(%rip), %rcx     # 0x2e943
movl $0x1be, %edx            # imm = 0x1BE
callq 0xa0b0
leaq 0x22de6(%rip), %rdi     # 0x2ea19
leaq 0x283cd(%rip), %rsi     # 0x34007
leaq 0x22d02(%rip), %rcx     # 0x2e943
movl $0x1bf, %edx            # imm = 0x1BF
callq 0xa0b0
// File: /workspace/github_c_makefile_star2_O1/Ihsoh[P]ilang/lexer.c
// Function: lexer_print_tokens
void lexer_print_tokens(
	LexerContext * ctx,
	FILE *file
) {
	assert(ctx);
	assert(file);

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

		token = token->next;
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
testq %rdi, %rdi
je 0xbc8b
movq %rsi, %rbx
testq %rsi, %rsi
je 0xbcaa
movq 0x50(%rdi), %r14
testq %r14, %r14
je 0xbc86
movq %r14, %rdi
movq %rbx, %rsi
callq 0xbb59
movl $0xa, %edi
movq %rbx, %rsi
callq 0xa0d0
movq 0x28(%r14), %r14
jmp 0xbc63
popq %rbx
popq %r14
popq %rbp
retq
leaq 0x2aac4(%rip), %rdi     # 0x36756
leaq 0x2836e(%rip), %rsi     # 0x34007
leaq 0x22d18(%rip), %rcx     # 0x2e9b8
movl $0x1d0, %edx            # imm = 0x1D0
callq 0xa0b0
leaq 0x22d68(%rip), %rdi     # 0x2ea19
leaq 0x2834f(%rip), %rsi     # 0x34007
leaq 0x22cf9(%rip), %rcx     # 0x2e9b8
movl $0x1d1, %edx            # imm = 0x1D1
callq 0xa0b0
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O1/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 0xbdc0
movq %rdi, %r14
movq (%rdi), %r15
testq %r15, %r15
je 0xbdb7
movl %esi, %ebx
testb %bl, %bl
je 0xbda3
movq 0x8(%r15), %rdi
testq %rdi, %rdi
je 0xbda3
callq *0x20(%r14)
movq $0x0, 0x8(%r15)
movq 0x18(%r15), %r12
movq %r15, %rdi
callq 0xa190
movq %r12, %r15
testq %r12, %r12
jne 0xbd8a
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
leaq 0x22e3b(%rip), %rdi     # 0x2ec02
leaq 0x22d5e(%rip), %rsi     # 0x2eb2c
leaq 0x22da3(%rip), %rcx     # 0x2eb78
movl $0x2f, %edx
callq 0xa0b0
// File: /workspace/github_c_makefile_star2_O1/Ihsoh[P]ilang/list.c
// Function: llst_append
void llst_append(
	LinkedList *llst,
	void *data
) {
	LinkedListNode *node = (LinkedListNode *)malloc(sizeof(LinkedListNode));
	node->llst = llst;
	node->data = data;

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

	llst->count++;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
movq %rsi, %r14
movq %rdi, %rbx
movl $0x20, %edi
callq 0xa120
movq %rbx, (%rax)
movq %r14, 0x8(%rax)
movq (%rbx), %rcx
testq %rcx, %rcx
jne 0xbe11
cmpq $0x0, 0x8(%rbx)
je 0xbe37
testq %rcx, %rcx
je 0xbe47
movq 0x8(%rbx), %rcx
testq %rcx, %rcx
je 0xbe47
movq %rax, 0x18(%rcx)
movq %rcx, 0x10(%rax)
movq $0x0, 0x18(%rax)
movq %rax, 0x8(%rbx)
incq 0x10(%rbx)
popq %rbx
popq %r14
popq %rbp
retq
movq %rax, (%rbx)
movq %rax, 0x8(%rbx)
xorps %xmm0, %xmm0
movups %xmm0, 0x10(%rax)
jmp 0xbe2e
leaq 0x23546(%rip), %rdi     # 0x2f394
leaq 0x22cd7(%rip), %rsi     # 0x2eb2c
leaq 0x22d40(%rip), %rcx     # 0x2eb9c
movl $0x51, %edx
callq 0xa0b0
// File: /workspace/github_c_makefile_star2_O1/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 0xbf26
testq %rsi, %rsi
je 0xbf45
cmpq %rdi, (%rsi)
jne 0xbf64
movq (%rdi), %rax
cmpq %rsi, %rax
je 0xbeb4
cmpq %rsi, 0x8(%rdi)
je 0xbed6
cmpq %rsi, %rax
je 0xbf07
cmpq %rsi, 0x8(%rdi)
je 0xbf07
movq 0x10(%rsi), %rax
movq 0x18(%rsi), %rcx
movq %rcx, 0x18(%rax)
movq 0x18(%rsi), %rcx
movq %rax, 0x10(%rcx)
jmp 0xbeee
cmpq %rsi, 0x8(%rdi)
je 0xbee8
cmpq %rsi, %rax
jne 0xbe8d
cmpq %rsi, 0x8(%rdi)
je 0xbf02
movq 0x18(%rsi), %rax
movq $0x0, 0x10(%rax)
movq %rax, (%rdi)
jmp 0xbeee
movq 0x10(%rsi), %rax
movq $0x0, 0x18(%rax)
movq %rax, 0x8(%rdi)
jmp 0xbeee
xorps %xmm0, %xmm0
movups %xmm0, (%rdi)
decq 0x10(%rdi)
movq $0x0, (%rsi)
xorps %xmm0, %xmm0
movups %xmm0, 0x10(%rsi)
popq %rbp
retq
cmpq %rsi, %rax
jne 0xbe8d
leaq 0x23486(%rip), %rdi     # 0x2f394
leaq 0x22c17(%rip), %rsi     # 0x2eb2c
leaq 0x22ca7(%rip), %rcx     # 0x2ebc3
movl $0x6c, %edx
callq 0xa0b0
leaq 0x22cd5(%rip), %rdi     # 0x2ec02
leaq 0x22bf8(%rip), %rsi     # 0x2eb2c
leaq 0x22c88(%rip), %rcx     # 0x2ebc3
movl $0x5b, %edx
callq 0xa0b0
leaq 0x26daf(%rip), %rdi     # 0x32cfb
leaq 0x22bd9(%rip), %rsi     # 0x2eb2c
leaq 0x22c69(%rip), %rcx     # 0x2ebc3
movl $0x5c, %edx
callq 0xa0b0
leaq 0x22c89(%rip), %rdi     # 0x2ebf4
leaq 0x22bba(%rip), %rsi     # 0x2eb2c
leaq 0x22c4a(%rip), %rcx     # 0x2ebc3
movl $0x5d, %edx
callq 0xa0b0
// File: /workspace/github_c_makefile_star2_O1/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 0xbfcc
movq %rsi, %rbx
testq %rsi, %rsi
je 0xbfeb
movl %edx, %r15d
movq %rdi, %r14
movq %rbx, %rsi
callq 0xbe66
testb %r15b, %r15b
je 0xbfba
movq 0x8(%rbx), %rdi
testq %rdi, %rdi
je 0xbfba
callq *0x20(%r14)
movq %rbx, %rdi
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
jmp 0xa190
leaq 0x22c2f(%rip), %rdi     # 0x2ec02
leaq 0x22b52(%rip), %rsi     # 0x2eb2c
leaq 0x22c26(%rip), %rcx     # 0x2ec07
movl $0x7a, %edx
callq 0xa0b0
leaq 0x26d09(%rip), %rdi     # 0x32cfb
leaq 0x22b33(%rip), %rsi     # 0x2eb2c
leaq 0x22c07(%rip), %rcx     # 0x2ec07
movl $0x7b, %edx
callq 0xa0b0
// File: /workspace/github_c_makefile_star2_O1/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 0xc056
movq %rsi, %r14
testq %rsi, %rsi
je 0xc075
movq %rdx, %rbx
testq %rdx, %rdx
je 0xc094
movq (%rdi), %r15
testq %r15, %r15
je 0xc045
movq 0x8(%r15), %rdi
movq %rbx, %rsi
callq *%r14
testb %al, %al
jne 0xc048
movq 0x18(%r15), %r15
jmp 0xc02c
xorl %r15d, %r15d
movq %r15, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
leaq 0x22ba5(%rip), %rdi     # 0x2ec02
leaq 0x22ac8(%rip), %rsi     # 0x2eb2c
leaq 0x22bd4(%rip), %rcx     # 0x2ec3f
movl $0x8a, %edx
callq 0xa0b0
leaq 0x22c4b(%rip), %rdi     # 0x2ecc7
leaq 0x22aa9(%rip), %rsi     # 0x2eb2c
leaq 0x22bb5(%rip), %rcx     # 0x2ec3f
movl $0x8b, %edx
callq 0xa0b0
leaq 0x2b559(%rip), %rdi     # 0x375f4
leaq 0x22a8a(%rip), %rsi     # 0x2eb2c
leaq 0x22b96(%rip), %rcx     # 0x2ec3f
movl $0x8c, %edx
callq 0xa0b0
// File: /workspace/github_c_makefile_star2_O1/Ihsoh[P]ilang/list.c
// Function: llst_find
LinkedListNode *llst_find(
	LinkedList *llst,
	void *data
) {
	assert(llst);
	assert(llst->comparer);
	assert(data);

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

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
testq %rdi, %rdi
je 0xc100
movq 0x18(%rdi), %r15
testq %r15, %r15
je 0xc11f
movq %rsi, %rbx
testq %rsi, %rsi
je 0xc13e
movq (%rdi), %r14
testq %r14, %r14
je 0xc0ef
movq 0x8(%r14), %rdi
movq %rbx, %rsi
callq *%r15
testb %al, %al
jne 0xc0f2
movq 0x18(%r14), %r14
jmp 0xc0d6
xorl %r14d, %r14d
movq %r14, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
leaq 0x22afb(%rip), %rdi     # 0x2ec02
leaq 0x22a1e(%rip), %rsi     # 0x2eb2c
leaq 0x22b7c(%rip), %rcx     # 0x2ec91
movl $0x9d, %edx
callq 0xa0b0
leaq 0x22b9b(%rip), %rdi     # 0x2ecc1
leaq 0x229ff(%rip), %rsi     # 0x2eb2c
leaq 0x22b5d(%rip), %rcx     # 0x2ec91
movl $0x9e, %edx
callq 0xa0b0
leaq 0x2b4af(%rip), %rdi     # 0x375f4
leaq 0x229e0(%rip), %rsi     # 0x2eb2c
leaq 0x22b3e(%rip), %rcx     # 0x2ec91
movl $0x9f, %edx
callq 0xa0b0
// File: /workspace/github_c_makefile_star2_O1/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 0xc565
movq %r8, %rbx
movq %rcx, %r15
movq %rdx, %r12
movq %rsi, %r13
movq %rdi, %r14
movq 0x33aab(%rip), %rdx     # 0x3ffc0
xorl %esi, %esi
callq 0xbccc
testq %r13, %r13
leaq 0x5e(%rip), %rax        # 0xc584
cmoveq %rax, %r13
movq %r13, 0x28(%r14)
testq %r12, %r12
cmoveq %rax, %r12
movq %r12, 0x30(%r14)
testq %r15, %r15
leaq 0x64(%rip), %rax        # 0xc5a7
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 0x22ba1(%rip), %rdi     # 0x2f10d
leaq 0x227f8(%rip), %rsi     # 0x2ed6b
leaq 0x227f7(%rip), %rcx     # 0x2ed71
movl $0x1d, %edx
callq 0xa0b0
// File: /workspace/github_c_makefile_star2_O1/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 0xc631
movq (%rbx), %r12
testq %r12, %r12
je 0xc631
movq 0x8(%r12), %r13
testb %r15b, %r15b
je 0xc611
movq 0x8(%r13), %rdi
testq %rdi, %rdi
je 0xc611
callq *0x38(%rbx)
movq $0x0, 0x8(%r13)
testb %r14b, %r14b
je 0xc62a
movq 0x10(%r13), %rdi
testq %rdi, %rdi
je 0xc62a
callq *0x40(%rbx)
movq $0x0, 0x10(%r13)
movq 0x18(%r12), %r12
jmp 0xc5ee
movq %rbx, %rdi
movl $0x1, %esi
callq 0xbd6d
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_O1/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 0xc6dc
movq %rsi, %r15
testq %rsi, %rsi
je 0xc6fb
movl %ecx, %r12d
movq %rdx, %rbx
movq %rdi, %r14
leaq 0x96(%rip), %rsi        # 0xc71a
movq %r15, %rdx
callq 0xc00a
testq %rax, %rax
je 0xc6b4
movq 0x8(%rax), %r15
testb %r12b, %r12b
je 0xc6a7
movq 0x10(%r15), %rdi
testq %rdi, %rdi
je 0xc6a7
callq *0x40(%r14)
movq %rbx, 0x10(%r15)
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
movl $0x18, %edi
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 0xbddf
leaq 0x22a2a(%rip), %rdi     # 0x2f10d
leaq 0x22681(%rip), %rsi     # 0x2ed6b
leaq 0x226c9(%rip), %rcx     # 0x2edba
movl $0x68, %edx
callq 0xa0b0
leaq 0x226e3(%rip), %rdi     # 0x2ede5
leaq 0x22662(%rip), %rsi     # 0x2ed6b
leaq 0x226aa(%rip), %rcx     # 0x2edba
movl $0x69, %edx
callq 0xa0b0