LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O0/MikeGray-APH[P]LibLouisAPH/source/compile.c
// Function: compile_config
static int compile_config(void)
{
	if(!token_parse())
	{
		log_message(LOG_ERROR, "%s:%d  empty config", table_file_names[include_depth], table_file_lines[include_depth]);
		return 0;
	}

	if(token_is_equal("process", 7))
		return compile_process();
	if(token_is_equal("attrs_chars", 11))
		return compile_attrs_chars();
	if(token_is_equal("control", 7))
		return compile_control();

	return 1;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
callq 0x6190
cmpl $0x0, %eax
jne 0x6ad1
movslq 0x1d6ff(%rip), %rcx     # 0x24198
leaq 0x1d720(%rip), %rax     # 0x241c0
movq (%rax,%rcx,8), %rdx
movslq 0x1d6ed(%rip), %rcx     # 0x24198
leaq 0x1d6ee(%rip), %rax     # 0x241a0
movl (%rax,%rcx,4), %ecx
movl $0x6, %edi
leaq 0x17ac8(%rip), %rsi     # 0x1e589
movb $0x0, %al
callq 0xf610
movl $0x0, -0x4(%rbp)
jmp 0x6b38
leaq 0x17b12(%rip), %rdi     # 0x1e5ea
movl $0x7, %esi
callq 0x57f0
cmpl $0x0, %eax
je 0x6af1
callq 0x91b0
movl %eax, -0x4(%rbp)
jmp 0x6b38
leaq 0x17aa5(%rip), %rdi     # 0x1e59d
movl $0xb, %esi
callq 0x57f0
cmpl $0x0, %eax
je 0x6b11
callq 0x92c0
movl %eax, -0x4(%rbp)
jmp 0x6b38
leaq 0x17a91(%rip), %rdi     # 0x1e5a9
movl $0x7, %esi
callq 0x57f0
cmpl $0x0, %eax
je 0x6b31
callq 0x93b0
movl %eax, -0x4(%rbp)
jmp 0x6b38
movl $0x1, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/MikeGray-APH[P]LibLouisAPH/source/compile.c
// Function: compile_set
static int compile_set(void)
{
	unichar *var_name;
	int var_len, value;

	if(!token_parse())
		return 0;

	token_convert_escapes();

	if(token_crs[0] == u'=')
	{
		if(token_parse())
			var_enum = utf16_convert_to_int(token_crs, token_len);
		else
			var_enum = 0;

		return 1;
	}

	var_name = token_crs;
	var_len = token_len;

	if(token_parse())
	{
		if(token_convert_to_int())
			value = token_int;
		else
			return 0;
	}
	else
		value = var_enum++;

	if(!variable_add(var_name, var_len, value))
		return 0;

	return 1;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
callq 0x6190
cmpl $0x0, %eax
jne 0x6b6e
movl $0x0, -0x4(%rbp)
jmp 0x6c30
callq 0x9670
movq 0x1f68e(%rip), %rax     # 0x26208
movzwl (%rax), %eax
cmpl $0x3d, %eax
jne 0x6bb9
callq 0x6190
cmpl $0x0, %eax
je 0x6ba6
movq 0x1f675(%rip), %rdi     # 0x26208
movl 0x1f667(%rip), %esi     # 0x26200
callq 0x12a0
movl %eax, 0x1d5ec(%rip)     # 0x24190
jmp 0x6bb0
movl $0x0, 0x1d5e0(%rip)     # 0x24190
movl $0x1, -0x4(%rbp)
jmp 0x6c30
movq 0x1f648(%rip), %rax     # 0x26208
movq %rax, -0x10(%rbp)
movl 0x1f636(%rip), %eax     # 0x26200
movl %eax, -0x14(%rbp)
callq 0x6190
cmpl $0x0, %eax
je 0x6bf7
callq 0x96b0
cmpl $0x0, %eax
je 0x6bec
movl 0x1f631(%rip), %eax     # 0x26218
movl %eax, -0x18(%rbp)
jmp 0x6bf5
movl $0x0, -0x4(%rbp)
jmp 0x6c30
jmp 0x6c0b
movl 0x1d593(%rip), %eax     # 0x24190
movl %eax, %ecx
addl $0x1, %ecx
movl %ecx, 0x1d588(%rip)     # 0x24190
movl %eax, -0x18(%rbp)
movq -0x10(%rbp), %rdi
movl -0x14(%rbp), %esi
movl -0x18(%rbp), %edx
callq 0x9890
cmpq $0x0, %rax
jne 0x6c29
movl $0x0, -0x4(%rbp)
jmp 0x6c30
movl $0x1, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/MikeGray-APH[P]LibLouisAPH/source/compile.c
// Function: compile_chars
static int compile_chars(void)
{
	struct character *character;
	unichar *uchars;
	unsigned int uchars_len, bit, i;

	if(!token_parse())
	{
		log_message(LOG_ERROR, "%s:%d  missing characters", table_file_names[include_depth], table_file_lines[include_depth]);
		return 0;
	}

	token_convert_escapes_with_dots();
	if(token_len <= 0)
	{
		log_message(LOG_ERROR, "%s:%d  invalid characters", table_file_names[include_depth], table_file_lines[include_depth]);
		return 0;
	}
	uchars = token_crs;
	uchars_len = token_len;

	bit = chars_scan_bits();
	if(!bit)
		return 0;

	for(i = 0; i < uchars_len; i++)
	{
		character = table_find_or_add_character(table, uchars[i]);
		if(!character)
			return 0;
		character->attrs |= bit;
	}

	return 1;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
callq 0x6190
cmpl $0x0, %eax
jne 0x6fb4
movslq 0x1d21f(%rip), %rcx     # 0x24198
leaq 0x1d240(%rip), %rax     # 0x241c0
movq (%rax,%rcx,8), %rdx
movslq 0x1d20d(%rip), %rcx     # 0x24198
leaq 0x1d20e(%rip), %rax     # 0x241a0
movl (%rax,%rcx,4), %ecx
movl $0x6, %edi
leaq 0x177a7(%rip), %rsi     # 0x1e748
movb $0x0, %al
callq 0xf610
movl $0x0, -0x4(%rbp)
jmp 0x7088
callq 0xa0a0
cmpl $0x0, 0x1f240(%rip)     # 0x26200
jg 0x7004
movslq 0x1d1cf(%rip), %rcx     # 0x24198
leaq 0x1d1f0(%rip), %rax     # 0x241c0
movq (%rax,%rcx,8), %rdx
movslq 0x1d1bd(%rip), %rcx     # 0x24198
leaq 0x1d1be(%rip), %rax     # 0x241a0
movl (%rax,%rcx,4), %ecx
movl $0x6, %edi
leaq 0x17771(%rip), %rsi     # 0x1e762
movb $0x0, %al
callq 0xf610
movl $0x0, -0x4(%rbp)
jmp 0x7088
movq 0x1f1fd(%rip), %rax     # 0x26208
movq %rax, -0x18(%rbp)
movl 0x1f1eb(%rip), %eax     # 0x26200
movl %eax, -0x1c(%rbp)
callq 0xa0d0
movl %eax, -0x20(%rbp)
cmpl $0x0, -0x20(%rbp)
jne 0x702f
movl $0x0, -0x4(%rbp)
jmp 0x7088
movl $0x0, -0x24(%rbp)
movl -0x24(%rbp), %eax
cmpl -0x1c(%rbp), %eax
jae 0x7081
movq 0x1d11b(%rip), %rdi     # 0x24160
movq -0x18(%rbp), %rax
movl -0x24(%rbp), %ecx
movzwl (%rax,%rcx,2), %esi
callq 0x2990
movq %rax, -0x10(%rbp)
cmpq $0x0, -0x10(%rbp)
jne 0x7069
movl $0x0, -0x4(%rbp)
jmp 0x7088
movl -0x20(%rbp), %ecx
movq -0x10(%rbp), %rax
orl 0x24(%rax), %ecx
movl %ecx, 0x24(%rax)
movl -0x24(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x24(%rbp)
jmp 0x7036
movl $0x1, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/MikeGray-APH[P]LibLouisAPH/source/compile.c
// Function: compile_attrs
static int compile_attrs(void)
{
	if(!token_parse())
		goto return_fail;

	if(token_crs[0] == u'=')
	{
		if(token_len != 1)
			goto return_fail;

		if(!token_parse())
			rule_attrs = 0;
		else if(token_convert_to_int())
			rule_attrs = token_int;
	}
	else if(token_crs[0] == u'+')
	{
		if(token_len != 1)
			goto return_fail;

		if(!token_parse())
			rule_attrs = 0;
		else if(token_convert_to_int())
			rule_attrs |= token_int;
	}
	else if(token_crs[0] == u'-')
	{
		if(token_len != 1)
			goto return_fail;

		if(!token_parse())
			rule_attrs = 0;
		else if(token_convert_to_int())
			rule_attrs &= ~token_int;
	}
	else
		goto return_fail;

	return 1;

	return_fail:
	log_message(LOG_ERROR, "%s:%d  invalid attribute", table_file_names[include_depth], table_file_lines[include_depth]);
	return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
callq 0x6190
cmpl $0x0, %eax
jne 0x73a7
jmp 0x74ac
movq 0x1ee5a(%rip), %rax     # 0x26208
movzwl (%rax), %eax
cmpl $0x3d, %eax
jne 0x73f7
cmpl $0x1, 0x1ee43(%rip)     # 0x26200
je 0x73c4
jmp 0x74ac
callq 0x6190
cmpl $0x0, %eax
jne 0x73da
movl $0x0, 0x1cd90(%rip)     # 0x24168
jmp 0x73f2
callq 0x96b0
cmpl $0x0, %eax
je 0x73f0
movl 0x1ee2e(%rip), %eax     # 0x26218
movl %eax, 0x1cd78(%rip)     # 0x24168
jmp 0x73f2
jmp 0x74a3
movq 0x1ee0a(%rip), %rax     # 0x26208
movzwl (%rax), %eax
cmpl $0x2b, %eax
jne 0x744a
cmpl $0x1, 0x1edf3(%rip)     # 0x26200
je 0x7414
jmp 0x74ac
callq 0x6190
cmpl $0x0, %eax
jne 0x742a
movl $0x0, 0x1cd40(%rip)     # 0x24168
jmp 0x7448
callq 0x96b0
cmpl $0x0, %eax
je 0x7446
movl 0x1edde(%rip), %eax     # 0x26218
orl 0x1cd28(%rip), %eax     # 0x24168
movl %eax, 0x1cd22(%rip)     # 0x24168
jmp 0x7448
jmp 0x74a1
movq 0x1edb7(%rip), %rax     # 0x26208
movzwl (%rax), %eax
cmpl $0x2d, %eax
jne 0x749d
cmpl $0x1, 0x1eda0(%rip)     # 0x26200
je 0x7464
jmp 0x74ac
callq 0x6190
cmpl $0x0, %eax
jne 0x747a
movl $0x0, 0x1ccf0(%rip)     # 0x24168
jmp 0x749b
callq 0x96b0
cmpl $0x0, %eax
je 0x7499
movl 0x1ed8e(%rip), %eax     # 0x26218
xorl $-0x1, %eax
andl 0x1ccd5(%rip), %eax     # 0x24168
movl %eax, 0x1cccf(%rip)     # 0x24168
jmp 0x749b
jmp 0x749f
jmp 0x74ac
jmp 0x74a1
jmp 0x74a3
movl $0x1, -0x4(%rbp)
jmp 0x74e9
movslq 0x1cce5(%rip), %rcx     # 0x24198
leaq 0x1cd06(%rip), %rax     # 0x241c0
movq (%rax,%rcx,8), %rdx
movslq 0x1ccd3(%rip), %rcx     # 0x24198
leaq 0x1ccd4(%rip), %rax     # 0x241a0
movl (%rax,%rcx,4), %ecx
movl $0x6, %edi
leaq 0x1730c(%rip), %rsi     # 0x1e7e7
movb $0x0, %al
callq 0xf610
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/MikeGray-APH[P]LibLouisAPH/source/compile.c
// Function: compile_use
static int compile_use(void)
{
	if(!token_parse())
	{
		rule_filter_forward = NULL;
		rule_filter_backward = NULL;
		return 1;
	}

	if(token_is_equal("-", 1))
		rule_filter_forward = NULL;
	else if(!token_is_equal("=", 1))
		rule_filter_forward = token_get_filter();

	if(!token_parse())
	{
		rule_filter_backward = NULL;
		return 1;
	}

	if(token_is_equal("-", 1))
		rule_filter_backward = NULL;
	else if(!token_is_equal("=", 1))
		rule_filter_backward = token_get_filter();

	return 1;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
callq 0x6190
cmpl $0x0, %eax
jne 0x7d64
movq $0x0, 0x1c42b(%rip) # 0x24178
movq $0x0, 0x1c418(%rip) # 0x24170
movl $0x1, -0x4(%rbp)
jmp 0x7e17
leaq 0x1766d(%rip), %rdi     # 0x1f3d8
movl $0x1, %esi
callq 0x57f0
cmpl $0x0, %eax
je 0x7d87
movq $0x0, 0x1c3f3(%rip) # 0x24178
jmp 0x7dab
leaq 0x16ad6(%rip), %rdi     # 0x1e864
movl $0x1, %esi
callq 0x57f0
cmpl $0x0, %eax
jne 0x7da9
callq 0xa370
movq %rax, 0x1c3cf(%rip)     # 0x24178
jmp 0x7dab
callq 0x6190
cmpl $0x0, %eax
jne 0x7dc9
movq $0x0, 0x1c3b0(%rip) # 0x24170
movl $0x1, -0x4(%rbp)
jmp 0x7e17
leaq 0x17608(%rip), %rdi     # 0x1f3d8
movl $0x1, %esi
callq 0x57f0
cmpl $0x0, %eax
je 0x7dec
movq $0x0, 0x1c386(%rip) # 0x24170
jmp 0x7e10
leaq 0x16a71(%rip), %rdi     # 0x1e864
movl $0x1, %esi
callq 0x57f0
cmpl $0x0, %eax
jne 0x7e0e
callq 0xa370
movq %rax, 0x1c362(%rip)     # 0x24170
jmp 0x7e10
movl $0x1, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x10, %rsp
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O0/MikeGray-APH[P]LibLouisAPH/source/compile.c
// Function: compile_uses
static int compile_uses(void)
{
	struct filter *forward, *backward;
	int status;

	if(!token_parse())
		goto return_fail;

	forward = rule_filter_forward;
	backward = rule_filter_backward;

	if(token_is_equal("-", 1))
		rule_filter_forward = NULL;
	else if(!token_is_equal("=", 1))
	{
		rule_filter_forward = token_get_filter();
		if(!rule_filter_forward)
			goto return_fail;
	}

	if(!token_parse())
	{
		rule_filter_forward = forward;
		goto return_fail;
	}

	if(token_is_equal("-", 1))
		rule_filter_backward = NULL;
	else if(!token_is_equal("=", 1))
	{
		rule_filter_backward = token_get_filter();
		if(!rule_filter_backward)
			goto return_fail;
	}

	if(!token_parse())
	{
		rule_filter_forward = forward;
		rule_filter_backward = backward;
		goto return_fail;
	}

	status = token_compile();

	rule_filter_forward = forward;
	rule_filter_backward = backward;
	return status;

	return_fail:
	log_message(LOG_ERROR, "%s:%d  invalid uses", table_file_names[include_depth], table_file_lines[include_depth]);
	return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
callq 0x6190
cmpl $0x0, %eax
jne 0x7e37
jmp 0x7f5c
movq 0x1c33a(%rip), %rax     # 0x24178
movq %rax, -0x10(%rbp)
movq 0x1c327(%rip), %rax     # 0x24170
movq %rax, -0x18(%rbp)
leaq 0x17584(%rip), %rdi     # 0x1f3d8
movl $0x1, %esi
callq 0x57f0
cmpl $0x0, %eax
je 0x7e70
movq $0x0, 0x1c30a(%rip) # 0x24178
jmp 0x7ea5
leaq 0x169ed(%rip), %rdi     # 0x1e864
movl $0x1, %esi
callq 0x57f0
cmpl $0x0, %eax
jne 0x7ea3
callq 0xa370
movq %rax, 0x1c2e6(%rip)     # 0x24178
cmpq $0x0, 0x1c2de(%rip)     # 0x24178
jne 0x7ea1
jmp 0x7f5c
jmp 0x7ea3
jmp 0x7ea5
callq 0x6190
cmpl $0x0, %eax
jne 0x7ebf
movq -0x10(%rbp), %rax
movq %rax, 0x1c2be(%rip)     # 0x24178
jmp 0x7f5c
leaq 0x17512(%rip), %rdi     # 0x1f3d8
movl $0x1, %esi
callq 0x57f0
cmpl $0x0, %eax
je 0x7ee2
movq $0x0, 0x1c290(%rip) # 0x24170
jmp 0x7f14
leaq 0x1697b(%rip), %rdi     # 0x1e864
movl $0x1, %esi
callq 0x57f0
cmpl $0x0, %eax
jne 0x7f12
callq 0xa370
movq %rax, 0x1c26c(%rip)     # 0x24170
cmpq $0x0, 0x1c264(%rip)     # 0x24170
jne 0x7f10
jmp 0x7f5c
jmp 0x7f12
jmp 0x7f14
callq 0x6190
cmpl $0x0, %eax
jne 0x7f36
movq -0x10(%rbp), %rax
movq %rax, 0x1c24f(%rip)     # 0x24178
movq -0x18(%rbp), %rax
movq %rax, 0x1c23c(%rip)     # 0x24170
jmp 0x7f5c
callq 0x5f40
movl %eax, -0x1c(%rbp)
movq -0x10(%rbp), %rax
movq %rax, 0x1c22f(%rip)     # 0x24178
movq -0x18(%rbp), %rax
movq %rax, 0x1c21c(%rip)     # 0x24170
movl -0x1c(%rbp), %eax
movl %eax, -0x4(%rbp)
jmp 0x7f99
movslq 0x1c235(%rip), %rcx     # 0x24198
leaq 0x1c256(%rip), %rax     # 0x241c0
movq (%rax,%rcx,8), %rdx
movslq 0x1c223(%rip), %rcx     # 0x24198
leaq 0x1c224(%rip), %rax     # 0x241a0
movl (%rax,%rcx,4), %ecx
movl $0x6, %edi
leaq 0x168f7(%rip), %rsi     # 0x1e882
movb $0x0, %al
callq 0xf610
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/MikeGray-APH[P]LibLouisAPH/source/compile.c
// Function: macro_find
static struct macro* macro_find(const unichar *uchars, const int uchars_len)
{
	struct macro *macro;

	macro = macros;
	while(macro)
	if(utf16_are_equal(uchars, uchars_len, macro->tag, macro->tag_len))
		break;
	else
		macro = macro->nxt;

	return macro;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movq 0x1b092(%rip), %rax     # 0x24188
movq %rax, -0x18(%rbp)
cmpq $0x0, -0x18(%rbp)
je 0x9130
movq -0x8(%rbp), %rdi
movl -0xc(%rbp), %esi
movq -0x18(%rbp), %rax
movq 0x10(%rax), %rdx
movq -0x18(%rbp), %rax
movl 0x20(%rax), %ecx
callq 0x9140
cmpl $0x0, %eax
je 0x9123
jmp 0x9130
movq -0x18(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x18(%rbp)
jmp 0x90fa
movq -0x18(%rbp), %rax
addq $0x20, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/MikeGray-APH[P]LibLouisAPH/source/utf.h
// Function: utf16_are_equal
static inline int utf16_are_equal(const unichar *uchars0, const int uchars0_len, const unichar *uchars1, const int uchars1_len)
{
	int i;

	if(uchars0_len != uchars1_len)
		return 0;
	for(i = 0; i < uchars0_len; i++)
	if(uchars0[i] != uchars1[i])
		return 0;
	return 1;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x10(%rbp)
movl %esi, -0x14(%rbp)
movq %rdx, -0x20(%rbp)
movl %ecx, -0x24(%rbp)
movl -0x14(%rbp), %eax
cmpl -0x24(%rbp), %eax
je 0x9163
movl $0x0, -0x4(%rbp)
jmp 0x91ab
movl $0x0, -0x28(%rbp)
movl -0x28(%rbp), %eax
cmpl -0x14(%rbp), %eax
jge 0x91a4
movq -0x10(%rbp), %rax
movslq -0x28(%rbp), %rcx
movzwl (%rax,%rcx,2), %eax
movq -0x20(%rbp), %rcx
movslq -0x28(%rbp), %rdx
movzwl (%rcx,%rdx,2), %ecx
cmpl %ecx, %eax
je 0x9197
movl $0x0, -0x4(%rbp)
jmp 0x91ab
jmp 0x9199
movl -0x28(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x28(%rbp)
jmp 0x916a
movl $0x1, -0x4(%rbp)
movl -0x4(%rbp), %eax
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O0/MikeGray-APH[P]LibLouisAPH/source/compile.c
// Function: compile_process
static int compile_process(void)
{
	if(!token_parse())
	{
		log_message(LOG_ERROR, "%s:%d  missing process", table_file_names[include_depth], table_file_lines[include_depth]);
		return 0;
	}

	if(table->process == PROCESS_GENERIC)
	{
		     if(token_is_equal("generic", 7))
			table->process = PROCESS_GENERIC;
		else if(token_is_equal("nemeth-ueb", 10))
			table->process = PROCESS_NEMETH_UEB;
		else
		{
			log_message(LOG_ERROR, "%s:%d  invalid process", table_file_names[include_depth], table_file_lines[include_depth]);
			return 0;
		}
	}

	return 1;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
callq 0x6190
cmpl $0x0, %eax
jne 0x9204
movslq 0x1afcf(%rip), %rcx     # 0x24198
leaq 0x1aff0(%rip), %rax     # 0x241c0
movq (%rax,%rcx,8), %rdx
movslq 0x1afbd(%rip), %rcx     # 0x24198
leaq 0x1afbe(%rip), %rax     # 0x241a0
movl (%rax,%rcx,4), %ecx
movl $0x6, %edi
leaq 0x153c0(%rip), %rsi     # 0x1e5b1
movb $0x0, %al
callq 0xf610
movl $0x0, -0x4(%rbp)
jmp 0x92ab
movq 0x1af55(%rip), %rax     # 0x24160
cmpl $0x0, 0x18(%rax)
jne 0x92a4
leaq 0x153ac(%rip), %rdi     # 0x1e5c8
movl $0x7, %esi
callq 0x57f0
cmpl $0x0, %eax
je 0x923b
movq 0x1af2e(%rip), %rax     # 0x24160
movl $0x0, 0x18(%rax)
jmp 0x92a2
leaq 0x1538e(%rip), %rdi     # 0x1e5d0
movl $0xa, %esi
callq 0x57f0
cmpl $0x0, %eax
je 0x9261
movq 0x1af08(%rip), %rax     # 0x24160
movl $0x1, 0x18(%rax)
jmp 0x92a0
movslq 0x1af30(%rip), %rcx     # 0x24198
leaq 0x1af51(%rip), %rax     # 0x241c0
movq (%rax,%rcx,8), %rdx
movslq 0x1af1e(%rip), %rcx     # 0x24198
leaq 0x1af1f(%rip), %rax     # 0x241a0
movl (%rax,%rcx,4), %ecx
movl $0x6, %edi
leaq 0x1534b(%rip), %rsi     # 0x1e5db
movb $0x0, %al
callq 0xf610
movl $0x0, -0x4(%rbp)
jmp 0x92ab
jmp 0x92a2
jmp 0x92a4
movl $0x1, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/MikeGray-APH[P]LibLouisAPH/source/compile.c
// Function: compile_attrs_chars
static int compile_attrs_chars(void)
{
	int i;

	if(!token_parse())
	{
		log_message(LOG_ERROR, "%s:%d  missing attrs chars", table_file_names[include_depth], table_file_lines[include_depth]);
		return 0;
	}

	if(token_len > 32)
	{
		log_message(LOG_ERROR, "%s:%d  too many attrs chars", table_file_names[include_depth], table_file_lines[include_depth]);
		return 0;
	}

	for(i = 0; i < token_len; i++)
		table->attrs_chars[i] = (char)token_crs[i];

	return 1;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
callq 0x6190
cmpl $0x0, %eax
jne 0x9314
movslq 0x1aebf(%rip), %rcx     # 0x24198
leaq 0x1aee0(%rip), %rax     # 0x241c0
movq (%rax,%rcx,8), %rdx
movslq 0x1aead(%rip), %rcx     # 0x24198
leaq 0x1aeae(%rip), %rax     # 0x241a0
movl (%rax,%rcx,4), %ecx
movl $0x6, %edi
leaq 0x152f1(%rip), %rsi     # 0x1e5f2
movb $0x0, %al
callq 0xf610
movl $0x0, -0x4(%rbp)
jmp 0x93a0
cmpl $0x20, 0x1cee5(%rip)    # 0x26200
jle 0x935c
movslq 0x1ae74(%rip), %rcx     # 0x24198
leaq 0x1ae95(%rip), %rax     # 0x241c0
movq (%rax,%rcx,8), %rdx
movslq 0x1ae62(%rip), %rcx     # 0x24198
leaq 0x1ae63(%rip), %rax     # 0x241a0
movl (%rax,%rcx,4), %ecx
movl $0x6, %edi
leaq 0x152c1(%rip), %rsi     # 0x1e60d
movb $0x0, %al
callq 0xf610
movl $0x0, -0x4(%rbp)
jmp 0x93a0
movl $0x0, -0x8(%rbp)
movl -0x8(%rbp), %eax
cmpl 0x1ce94(%rip), %eax     # 0x26200
jge 0x9399
movq 0x1ce93(%rip), %rax     # 0x26208
movslq -0x8(%rbp), %rcx
movw (%rax,%rcx,2), %ax
movb %al, %dl
movq 0x1adda(%rip), %rax     # 0x24160
movslq -0x8(%rbp), %rcx
movb %dl, 0x30(%rax,%rcx)
movl -0x8(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x8(%rbp)
jmp 0x9363
movl $0x1, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x10, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/MikeGray-APH[P]LibLouisAPH/source/compile.c
// Function: variable_add
static struct variable* variable_add(const unichar *uchars, const int uchars_len, const int value)
{
	struct variable *var;

	var = MALLOC(sizeof(struct variable));
	LOG_ALLOCATE_FAIL_RETURN_NULL(var)

	var->uchars = MALLOC((uchars_len + 1) * sizeof(unichar));
	if(!var->uchars)
	{
		LOG_ALLOCATE_FAIL
		FREE(var);
		return 0;
	}
	var->uchars_len = uchars_len;
	utf16_copy(var->uchars, uchars, uchars_len + 1);

	var->value = value;

	var->nxt = variables;
	variables = var;

	return var;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movl %esi, -0x14(%rbp)
movl %edx, -0x18(%rbp)
movl $0x18, %edi
callq 0x1160
movq %rax, -0x20(%rbp)
cmpq $0x0, -0x20(%rbp)
jne 0x98e3
movl $0x7, %edi
leaq 0x149b5(%rip), %rsi     # 0x1e278
leaq 0x14a57(%rip), %rdx     # 0x1e321
movl $0x17b, %ecx            # imm = 0x17B
movb $0x0, %al
callq 0xf610
movq $0x0, -0x8(%rbp)
jmp 0x9988
movl -0x14(%rbp), %eax
addl $0x1, %eax
movslq %eax, %rdi
shlq %rdi
callq 0x1160
movq %rax, %rcx
movq -0x20(%rbp), %rax
movq %rcx, 0x8(%rax)
movq -0x20(%rbp), %rax
cmpq $0x0, 0x8(%rax)
jne 0x993c
movl $0x7, %edi
leaq 0x14962(%rip), %rsi     # 0x1e278
leaq 0x14a04(%rip), %rdx     # 0x1e321
movl $0x180, %ecx            # imm = 0x180
movb $0x0, %al
callq 0xf610
movq -0x20(%rbp), %rdi
callq 0x1040
movq $0x0, -0x8(%rbp)
jmp 0x9988
movl -0x14(%rbp), %ecx
movq -0x20(%rbp), %rax
movl %ecx, 0x10(%rax)
movq -0x20(%rbp), %rax
movq 0x8(%rax), %rdi
movq -0x10(%rbp), %rsi
movl -0x14(%rbp), %edx
addl $0x1, %edx
callq 0x6290
movl -0x18(%rbp), %ecx
movq -0x20(%rbp), %rax
movl %ecx, 0x14(%rax)
movq 0x1a812(%rip), %rcx     # 0x24180
movq -0x20(%rbp), %rax
movq %rcx, (%rax)
movq -0x20(%rbp), %rax
movq %rax, 0x1a800(%rip)     # 0x24180
movq -0x20(%rbp), %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/MikeGray-APH[P]LibLouisAPH/source/compile.c
// Function: variable_find
static struct variable* variable_find(const unichar *uchars, const int uchars_len)
{
	struct variable *var;

	var = variables;
	while(var)
	if(utf16_are_equal(uchars, uchars_len, var->uchars, var->uchars_len))
		break;
	else
		var = var->nxt;

	return var;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movq 0x1a7ca(%rip), %rax     # 0x24180
movq %rax, -0x18(%rbp)
cmpq $0x0, -0x18(%rbp)
je 0x99f0
movq -0x8(%rbp), %rdi
movl -0xc(%rbp), %esi
movq -0x18(%rbp), %rax
movq 0x8(%rax), %rdx
movq -0x18(%rbp), %rax
movl 0x10(%rax), %ecx
callq 0x9140
cmpl $0x0, %eax
je 0x99e3
jmp 0x99f0
movq -0x18(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x18(%rbp)
jmp 0x99ba
movq -0x18(%rbp), %rax
addq $0x20, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/MikeGray-APH[P]LibLouisAPH/source/utf.h
// Function: utf16_is_equal_cchars
static inline int utf16_is_equal_cchars(const unichar *uchars, const int uchars_len, const char *cchars, const int cchars_len)
{
	int i;

	if(uchars_len != cchars_len)
		return 0;
	for(i = 0; i < cchars_len; i++)
	if(uchars[i] != (unichar)cchars[i])
		return 0;
	return 1;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x10(%rbp)
movl %esi, -0x14(%rbp)
movq %rdx, -0x20(%rbp)
movl %ecx, -0x24(%rbp)
movl -0x14(%rbp), %eax
cmpl -0x24(%rbp), %eax
je 0x9e73
movl $0x0, -0x4(%rbp)
jmp 0x9ebe
movl $0x0, -0x28(%rbp)
movl -0x28(%rbp), %eax
cmpl -0x24(%rbp), %eax
jge 0x9eb7
movq -0x10(%rbp), %rax
movslq -0x28(%rbp), %rcx
movzwl (%rax,%rcx,2), %eax
movq -0x20(%rbp), %rcx
movslq -0x28(%rbp), %rdx
movsbl (%rcx,%rdx), %ecx
movzwl %cx, %ecx
cmpl %ecx, %eax
je 0x9eaa
movl $0x0, -0x4(%rbp)
jmp 0x9ebe
jmp 0x9eac
movl -0x28(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x28(%rbp)
jmp 0x9e7a
movl $0x1, -0x4(%rbp)
movl -0x4(%rbp), %eax
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/MikeGray-APH[P]LibLouisAPH/source/compile.c
// Function: chars_scan_bits
static unsigned int chars_scan_bits(void)
{
	unsigned int bit;

	bit = 0;
	while(token_parse())
	{
		if(token_crs[0] == u'#' && token_len == 1)
			break;
		else if(token_convert_to_int())
			bit |= token_int;
	}

	return bit;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movl $0x0, -0x4(%rbp)
callq 0x6190
cmpl $0x0, %eax
je 0xa11d
movq 0x1c118(%rip), %rax     # 0x26208
movzwl (%rax), %eax
cmpl $0x23, %eax
jne 0xa103
cmpl $0x1, 0x1c101(%rip)     # 0x26200
jne 0xa103
jmp 0xa11d
callq 0x96b0
cmpl $0x0, %eax
je 0xa119
movl 0x1c105(%rip), %eax     # 0x26218
orl -0x4(%rbp), %eax
movl %eax, -0x4(%rbp)
jmp 0xa11b
jmp 0xa0df
movl -0x4(%rbp), %eax
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/MikeGray-APH[P]LibLouisAPH/source/compile.c
// Function: token_get_filter
static struct filter* token_get_filter(void)
{
	struct filter *filter;

	filter = filter_find(token_crs, token_len);
	if(!filter)
	{
		log_message(LOG_ERROR, "%s:%d  filter %#S not found", table_file_names[include_depth], table_file_lines[include_depth], token_crs, token_len);
		return NULL;
	}
	return filter;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq 0x1be89(%rip), %rdi     # 0x26208
movl 0x1be7b(%rip), %esi     # 0x26200
callq 0xa400
movq %rax, -0x10(%rbp)
cmpq $0x0, -0x10(%rbp)
jne 0xa3e3
movslq 0x19dfc(%rip), %rcx     # 0x24198
leaq 0x19e1d(%rip), %rax     # 0x241c0
movq (%rax,%rcx,8), %rdx
movslq 0x19dea(%rip), %rcx     # 0x24198
leaq 0x19deb(%rip), %rax     # 0x241a0
movl (%rax,%rcx,4), %ecx
movq 0x1be49(%rip), %r8      # 0x26208
movl 0x1be3a(%rip), %r9d     # 0x26200
movl $0x6, %edi
leaq 0x14494(%rip), %rsi     # 0x1e866
movb $0x0, %al
callq 0xf610
movq $0x0, -0x8(%rbp)
jmp 0xa3eb
movq -0x10(%rbp), %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/MikeGray-APH[P]LibLouisAPH/source/compile.c
// Function: filter_find
static struct filter* filter_find(const unichar *uchars, const int uchars_len)
{
	struct filter *filter;

	filter = table->filters;
	while(filter)
	if(utf16_are_equal(uchars, uchars_len, filter->name, filter->name_len))
		break;
	else
		filter = filter->nxt;

	return filter;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movq 0x19d4a(%rip), %rax     # 0x24160
movq 0x20(%rax), %rax
movq %rax, -0x18(%rbp)
cmpq $0x0, -0x18(%rbp)
je 0xa454
movq -0x8(%rbp), %rdi
movl -0xc(%rbp), %esi
movq -0x18(%rbp), %rax
movq 0x20(%rax), %rdx
movq -0x18(%rbp), %rax
movl 0x28(%rax), %ecx
callq 0x9140
cmpl $0x0, %eax
je 0xa447
jmp 0xa454
movq -0x18(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x18(%rbp)
jmp 0xa41e
movq -0x18(%rbp), %rax
addq $0x20, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/MikeGray-APH[P]LibLouisAPH/source/compile.c
// Function: macro_fini
static void macro_fini(struct macro *macro)
{
	int i;

	if(!macro)
		return;

	ASSERT(!macro->processing)

	if(macro->ctag)
		FREE(macro->ctag);
	if(macro->tag)
		FREE(macro->tag);
	if(macro->file_name)
		FREE(macro->file_name);

	if(macro->lines)
	{
		/*   lines[] could be null if error while compiling macro   */
		for(i = 0; i < macro->lines_cnt; i++)
		if(macro->lines[i])
			FREE(macro->lines[i]);
		FREE(macro->lines);
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
cmpq $0x0, -0x8(%rbp)
jne 0xa478
jmp 0xa52f
movq -0x8(%rbp), %rax
cmpl $0x0, 0x28(%rax)
je 0xa487
callq 0x1050
movq -0x8(%rbp), %rax
cmpq $0x0, 0x8(%rax)
je 0xa49f
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rdi
callq 0x1040
movq -0x8(%rbp), %rax
cmpq $0x0, 0x10(%rax)
je 0xa4b7
movq -0x8(%rbp), %rax
movq 0x10(%rax), %rdi
callq 0x1040
movq -0x8(%rbp), %rax
cmpq $0x0, 0x30(%rax)
je 0xa4cf
movq -0x8(%rbp), %rax
movq 0x30(%rax), %rdi
callq 0x1040
movq -0x8(%rbp), %rax
cmpq $0x0, 0x18(%rax)
je 0xa52f
movl $0x0, -0xc(%rbp)
movl -0xc(%rbp), %eax
movq -0x8(%rbp), %rcx
cmpl 0x24(%rcx), %eax
jge 0xa522
movq -0x8(%rbp), %rax
movq 0x18(%rax), %rax
movslq -0xc(%rbp), %rcx
cmpq $0x0, (%rax,%rcx,8)
je 0xa515
movq -0x8(%rbp), %rax
movq 0x18(%rax), %rax
movslq -0xc(%rbp), %rcx
movq (%rax,%rcx,8), %rdi
callq 0x1040
jmp 0xa517
movl -0xc(%rbp), %eax
addl $0x1, %eax
movl %eax, -0xc(%rbp)
jmp 0xa4e1
movq -0x8(%rbp), %rax
movq 0x18(%rax), %rdi
callq 0x1040
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
nop
// File: /workspace/github_c_makefile_star2_O0/MikeGray-APH[P]LibLouisAPH/source/translate.c
// Function: translate_is_marked_name_at
int translate_is_marked_name_at(const struct translate *translate, const unichar mark, const unichar *name, const int name_len, const int at)
{
	int i;

	if(at < 0 || at + name_len + 1 >= translate->input_len)
		return 0;
	if(translate->input[at] != mark)
		return 0;
	if(translate->input[at + name_len + 1] != mark)
		return 0;
	for(i = 0; i < name_len; i++)
	if(translate->input[at + 1 + i] != name[i])
		return 0;

	return 1;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movw %si, %ax
movq %rdi, -0x10(%rbp)
movw %ax, -0x12(%rbp)
movq %rdx, -0x20(%rbp)
movl %ecx, -0x24(%rbp)
movl %r8d, -0x28(%rbp)
cmpl $0x0, -0x28(%rbp)
jl 0xa572
movl -0x28(%rbp), %eax
addl -0x24(%rbp), %eax
addl $0x1, %eax
movq -0x10(%rbp), %rcx
cmpl 0x44(%rcx), %eax
jl 0xa57e
movl $0x0, -0x4(%rbp)
jmp 0xa61c
movq -0x10(%rbp), %rax
movq 0x38(%rax), %rax
movslq -0x28(%rbp), %rcx
movzwl (%rax,%rcx,2), %eax
movzwl -0x12(%rbp), %ecx
cmpl %ecx, %eax
je 0xa59f
movl $0x0, -0x4(%rbp)
jmp 0xa61c
movq -0x10(%rbp), %rax
movq 0x38(%rax), %rax
movl -0x28(%rbp), %ecx
addl -0x24(%rbp), %ecx
addl $0x1, %ecx
movslq %ecx, %rcx
movzwl (%rax,%rcx,2), %eax
movzwl -0x12(%rbp), %ecx
cmpl %ecx, %eax
je 0xa5c8
movl $0x0, -0x4(%rbp)
jmp 0xa61c
movl $0x0, -0x2c(%rbp)
movl -0x2c(%rbp), %eax
cmpl -0x24(%rbp), %eax
jge 0xa615
movq -0x10(%rbp), %rax
movq 0x38(%rax), %rax
movl -0x28(%rbp), %ecx
addl $0x1, %ecx
addl -0x2c(%rbp), %ecx
movslq %ecx, %rcx
movzwl (%rax,%rcx,2), %eax
movq -0x20(%rbp), %rcx
movslq -0x2c(%rbp), %rdx
movzwl (%rcx,%rdx,2), %ecx
cmpl %ecx, %eax
je 0xa608
movl $0x0, -0x4(%rbp)
jmp 0xa61c
jmp 0xa60a
movl -0x2c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x2c(%rbp)
jmp 0xa5cf
movl $0x1, -0x4(%rbp)
movl -0x4(%rbp), %eax
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/MikeGray-APH[P]LibLouisAPH/source/translate.c
// Function: translate_get_mode_indicator
enum mode_type translate_get_mode_indicator(const struct translate *translate, const struct table *table, const struct mode *mode)
{

	if(translate->input[translate->input_crs] != table->marker_hard && translate->input[translate->input_crs] != table->marker_soft)
		return NONE;

	if(translate_is_equal_at(translate, mode->begin, mode->begin_len, translate->input_crs + 1))
		return BEGIN;
	if(translate_is_equal_at(translate, mode->end, mode->end_len, translate->input_crs + 1))
		return END;
	if(translate_is_equal_at(translate, mode->word, mode->word_len, translate->input_crs + 1))
		return WORD;
	if(translate_is_equal_at(translate, mode->term, mode->term_len, translate->input_crs + 1))
		return TERM;
	if(translate_is_equal_at(translate, mode->symbol, mode->symbol_len, translate->input_crs + 1))
		return SYMBOL;

	return NONE;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movq -0x10(%rbp), %rax
movq 0x38(%rax), %rax
movq -0x10(%rbp), %rcx
movslq 0x40(%rcx), %rcx
movzwl (%rax,%rcx,2), %eax
movq -0x18(%rbp), %rcx
movzwl 0x1f0(%rcx), %ecx
cmpl %ecx, %eax
je 0xa696
movq -0x10(%rbp), %rax
movq 0x38(%rax), %rax
movq -0x10(%rbp), %rcx
movslq 0x40(%rcx), %rcx
movzwl (%rax,%rcx,2), %eax
movq -0x18(%rbp), %rcx
movzwl 0x1f2(%rcx), %ecx
cmpl %ecx, %eax
je 0xa696
movl $0x1, -0x4(%rbp)
jmp 0xa793
movq -0x10(%rbp), %rdi
movq -0x20(%rbp), %rsi
addq $0xc, %rsi
movq -0x20(%rbp), %rax
movl 0x54(%rax), %edx
movq -0x10(%rbp), %rax
movl 0x40(%rax), %ecx
addl $0x1, %ecx
callq 0xa7a0
cmpl $0x0, %eax
je 0xa6c9
movl $0x2, -0x4(%rbp)
jmp 0xa793
movq -0x10(%rbp), %rdi
movq -0x20(%rbp), %rsi
addq $0x1a, %rsi
movq -0x20(%rbp), %rax
movl 0x58(%rax), %edx
movq -0x10(%rbp), %rax
movl 0x40(%rax), %ecx
addl $0x1, %ecx
callq 0xa7a0
cmpl $0x0, %eax
je 0xa6fc
movl $0x3, -0x4(%rbp)
jmp 0xa793
movq -0x10(%rbp), %rdi
movq -0x20(%rbp), %rsi
addq $0x28, %rsi
movq -0x20(%rbp), %rax
movl 0x5c(%rax), %edx
movq -0x10(%rbp), %rax
movl 0x40(%rax), %ecx
addl $0x1, %ecx
callq 0xa7a0
cmpl $0x0, %eax
je 0xa72c
movl $0x4, -0x4(%rbp)
jmp 0xa793
movq -0x10(%rbp), %rdi
movq -0x20(%rbp), %rsi
addq $0x36, %rsi
movq -0x20(%rbp), %rax
movl 0x60(%rax), %edx
movq -0x10(%rbp), %rax
movl 0x40(%rax), %ecx
addl $0x1, %ecx
callq 0xa7a0
cmpl $0x0, %eax
je 0xa75c
movl $0x5, -0x4(%rbp)
jmp 0xa793
movq -0x10(%rbp), %rdi
movq -0x20(%rbp), %rsi
addq $0x44, %rsi
movq -0x20(%rbp), %rax
movl 0x64(%rax), %edx
movq -0x10(%rbp), %rax
movl 0x40(%rax), %ecx
addl $0x1, %ecx
callq 0xa7a0
cmpl $0x0, %eax
je 0xa78c
movl $0x6, -0x4(%rbp)
jmp 0xa793
movl $0x1, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/MikeGray-APH[P]LibLouisAPH/source/translate.h
// Function: translate_is_equal_at
static inline int translate_is_equal_at(const struct translate *translate, const unichar *uchars, const int uchars_len, const int at)
{
	int i;

	if(!uchars_len)
		return 0;

	if(at + uchars_len > translate->input_len)
		return 0;

	for(i = 0; i < uchars_len; i++)
	if(translate->input[at + i] != uchars[i])
		return 0;

	return uchars_len;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movl %edx, -0x1c(%rbp)
movl %ecx, -0x20(%rbp)
cmpl $0x0, -0x1c(%rbp)
jne 0xa7c1
movl $0x0, -0x4(%rbp)
jmp 0xa829
movl -0x20(%rbp), %eax
addl -0x1c(%rbp), %eax
movq -0x10(%rbp), %rcx
cmpl 0x44(%rcx), %eax
jle 0xa7d9
movl $0x0, -0x4(%rbp)
jmp 0xa829
movl $0x0, -0x24(%rbp)
movl -0x24(%rbp), %eax
cmpl -0x1c(%rbp), %eax
jge 0xa823
movq -0x10(%rbp), %rax
movq 0x38(%rax), %rax
movl -0x20(%rbp), %ecx
addl -0x24(%rbp), %ecx
movslq %ecx, %rcx
movzwl (%rax,%rcx,2), %eax
movq -0x18(%rbp), %rcx
movslq -0x24(%rbp), %rdx
movzwl (%rcx,%rdx,2), %ecx
cmpl %ecx, %eax
je 0xa816
movl $0x0, -0x4(%rbp)
jmp 0xa829
jmp 0xa818
movl -0x24(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x24(%rbp)
jmp 0xa7e0
movl -0x1c(%rbp), %eax
movl %eax, -0x4(%rbp)
movl -0x4(%rbp), %eax
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/MikeGray-APH[P]LibLouisAPH/source/translate.c
// Function: translate_check_output_max
int translate_check_output_max(struct translate *translate, const int increment)
{
	if(translate->output_len + increment < translate->output_max)
		return 1;

	while(translate->output_len + increment >= translate->output_max)
		translate->output_max += translate->output_inc;
	translate->output = REALLOC(translate->output, translate->output_max * sizeof(unichar));
	if(!translate->output)
	{
		LOG_ALLOCATE_FAIL
		return 0;
	}

	translate->output_mask = REALLOC(translate->output_mask, translate->output_max);
	if(!translate->output_mask)
	{
		LOG_ALLOCATE_FAIL
		return 0;
	}

	if(translate->maps_use)
	{
		translate->output_to_input_map = REALLOC(translate->output_to_input_map, translate->output_max * sizeof(int));
		if(!translate->output_to_input_map)
			return 0;
	}

	return 1;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movl %esi, -0x14(%rbp)
movq -0x10(%rbp), %rax
movl 0x68(%rax), %eax
addl -0x14(%rbp), %eax
movq -0x10(%rbp), %rcx
cmpl 0x6c(%rcx), %eax
jge 0xa85e
movl $0x1, -0x4(%rbp)
jmp 0xa989
jmp 0xa860
movq -0x10(%rbp), %rax
movl 0x68(%rax), %eax
addl -0x14(%rbp), %eax
movq -0x10(%rbp), %rcx
cmpl 0x6c(%rcx), %eax
jl 0xa886
movq -0x10(%rbp), %rax
movl 0x70(%rax), %ecx
movq -0x10(%rbp), %rax
addl 0x6c(%rax), %ecx
movl %ecx, 0x6c(%rax)
jmp 0xa860
movq -0x10(%rbp), %rax
movq 0x60(%rax), %rdi
movq -0x10(%rbp), %rax
movslq 0x6c(%rax), %rsi
shlq %rsi
callq 0x1180
movq %rax, %rcx
movq -0x10(%rbp), %rax
movq %rcx, 0x60(%rax)
movq -0x10(%rbp), %rax
cmpq $0x0, 0x60(%rax)
jne 0xa8df
movl $0x7, %edi
leaq 0x139b8(%rip), %rsi     # 0x1e278
leaq 0x1418d(%rip), %rdx     # 0x1ea54
movl $0x64, %ecx
movb $0x0, %al
callq 0xf610
movl $0x0, -0x4(%rbp)
jmp 0xa989
movq -0x10(%rbp), %rax
movq 0x80(%rax), %rdi
movq -0x10(%rbp), %rax
movslq 0x6c(%rax), %rsi
callq 0x1180
movq %rax, %rcx
movq -0x10(%rbp), %rax
movq %rcx, 0x80(%rax)
movq -0x10(%rbp), %rax
cmpq $0x0, 0x80(%rax)
jne 0xa93b
movl $0x7, %edi
leaq 0x13959(%rip), %rsi     # 0x1e278
leaq 0x1412e(%rip), %rdx     # 0x1ea54
movl $0x6b, %ecx
movb $0x0, %al
callq 0xf610
movl $0x0, -0x4(%rbp)
jmp 0xa989
movq -0x10(%rbp), %rax
cmpl $0x0, 0x90(%rax)
je 0xa982
movq -0x10(%rbp), %rax
movq 0x78(%rax), %rdi
movq -0x10(%rbp), %rax
movslq 0x6c(%rax), %rsi
shlq $0x2, %rsi
callq 0x1180
movq %rax, %rcx
movq -0x10(%rbp), %rax
movq %rcx, 0x78(%rax)
movq -0x10(%rbp), %rax
cmpq $0x0, 0x78(%rax)
jne 0xa980
movl $0x0, -0x4(%rbp)
jmp 0xa989
jmp 0xa982
movl $0x1, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/MikeGray-APH[P]LibLouisAPH/source/translate.c
// Function: translate_skip
int translate_skip(struct translate *translate, const int chars_cnt, const int clear_map)
{
	int cnt, i;

	/*   ensure chars_cnt is still within range   */
	if(translate->input_crs + chars_cnt > translate->input_len)
		cnt = translate->input_len - translate->input_crs;
	else
		cnt = chars_cnt;

	if(clear_map)
	if(translate->maps_use)
	for(i = 0; i < cnt; i++)
	if(translate->input_map[translate->input_crs + i] >= 0)
	{
		ASSERT(translate->input_crs + i < translate->input_len)
		translate->input_to_output_map[translate->input_map[translate->input_crs + i]] = -1;
	}

	translate_increment(translate, cnt, 0);

	return 1;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movl %edx, -0x10(%rbp)
movq -0x8(%rbp), %rax
movl 0x40(%rax), %eax
addl -0xc(%rbp), %eax
movq -0x8(%rbp), %rcx
cmpl 0x44(%rcx), %eax
jle 0xa9d8
movq -0x8(%rbp), %rax
movl 0x44(%rax), %eax
movq -0x8(%rbp), %rcx
subl 0x40(%rcx), %eax
movl %eax, -0x14(%rbp)
jmp 0xa9de
movl -0xc(%rbp), %eax
movl %eax, -0x14(%rbp)
cmpl $0x0, -0x10(%rbp)
je 0xaa70
movq -0x8(%rbp), %rax
cmpl $0x0, 0x90(%rax)
je 0xaa6e
movl $0x0, -0x18(%rbp)
movl -0x18(%rbp), %eax
cmpl -0x14(%rbp), %eax
jge 0xaa6c
movq -0x8(%rbp), %rax
movq 0x50(%rax), %rax
movq -0x8(%rbp), %rcx
movl 0x40(%rcx), %ecx
addl -0x18(%rbp), %ecx
movslq %ecx, %rcx
cmpl $0x0, (%rax,%rcx,4)
jl 0xaa5f
movq -0x8(%rbp), %rax
movl 0x40(%rax), %eax
addl -0x18(%rbp), %eax
movq -0x8(%rbp), %rcx
cmpl 0x44(%rcx), %eax
jl 0xaa37
callq 0x1050
movq -0x8(%rbp), %rax
movq 0x48(%rax), %rax
movq -0x8(%rbp), %rcx
movq 0x50(%rcx), %rcx
movq -0x8(%rbp), %rdx
movl 0x40(%rdx), %edx
addl -0x18(%rbp), %edx
movslq %edx, %rdx
movslq (%rcx,%rdx,4), %rcx
movl $0xffffffff, (%rax,%rcx,4) # imm = 0xFFFFFFFF
jmp 0xaa61
movl -0x18(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x18(%rbp)
jmp 0xa9fc
jmp 0xaa6e
jmp 0xaa70
movq -0x8(%rbp), %rdi
movl -0x14(%rbp), %esi
xorl %edx, %edx
callq 0xaa90
movl $0x1, %eax
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/MikeGray-APH[P]LibLouisAPH/source/translate.h
// Function: translate_increment
static inline void translate_increment(struct translate *translate, const int chars_cnt, const int dots_cnt)
{
	if(chars_cnt)
	if(!translate->cursor_set)
	if(translate->cursor_pos >= translate->input_crs && translate->cursor_pos < translate->input_crs + chars_cnt)
	{
		translate->cursor_set = 1;
		translate->cursor_pos = translate->output_len;
	}
	translate->input_crs += chars_cnt;
	translate->output_len += dots_cnt;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movl %edx, -0x10(%rbp)
cmpl $0x0, -0xc(%rbp)
je 0xaaff
movq -0x8(%rbp), %rax
cmpl $0x0, 0x8c(%rax)
jne 0xaafd
movq -0x8(%rbp), %rax
movl 0x88(%rax), %eax
movq -0x8(%rbp), %rcx
cmpl 0x40(%rcx), %eax
jl 0xaafb
movq -0x8(%rbp), %rax
movl 0x88(%rax), %eax
movq -0x8(%rbp), %rcx
movl 0x40(%rcx), %ecx
addl -0xc(%rbp), %ecx
cmpl %ecx, %eax
jge 0xaafb
movq -0x8(%rbp), %rax
movl $0x1, 0x8c(%rax)
movq -0x8(%rbp), %rax
movl 0x68(%rax), %ecx
movq -0x8(%rbp), %rax
movl %ecx, 0x88(%rax)
jmp 0xaafd
jmp 0xaaff
movl -0xc(%rbp), %ecx
movq -0x8(%rbp), %rax
addl 0x40(%rax), %ecx
movl %ecx, 0x40(%rax)
movl -0x10(%rbp), %ecx
movq -0x8(%rbp), %rax
addl 0x68(%rax), %ecx
movl %ecx, 0x68(%rax)
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/MikeGray-APH[P]LibLouisAPH/source/translate.c
// Function: translate_insert_dots
int translate_insert_dots(struct translate *translate, const unichar *dots, const int dots_len)
{
	int i;

	if(!translate_check_output_max(translate, dots_len))
		return 0;

	for(i = 0; i < dots_len; i++)
	{
		ASSERT(translate->output_len + i < translate->output_max)
		translate->output[translate->output_len + i] = dots[i];
		translate->output_mask[translate->output_len + i] = 0;

		if(translate->maps_use)
			translate->output_to_input_map[translate->output_len + i] = -1;
	}

	translate->output_len += dots_len;

	return 1;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movl %edx, -0x1c(%rbp)
movq -0x10(%rbp), %rdi
movl -0x1c(%rbp), %esi
callq 0xa830
cmpl $0x0, %eax
jne 0xab50
movl $0x0, -0x4(%rbp)
jmp 0xac09
movl $0x0, -0x20(%rbp)
movl -0x20(%rbp), %eax
cmpl -0x1c(%rbp), %eax
jge 0xabf5
movq -0x10(%rbp), %rax
movl 0x68(%rax), %eax
addl -0x20(%rbp), %eax
movq -0x10(%rbp), %rcx
cmpl 0x6c(%rcx), %eax
jl 0xab7b
callq 0x1050
movq -0x18(%rbp), %rax
movslq -0x20(%rbp), %rcx
movw (%rax,%rcx,2), %dx
movq -0x10(%rbp), %rax
movq 0x60(%rax), %rax
movq -0x10(%rbp), %rcx
movl 0x68(%rcx), %ecx
addl -0x20(%rbp), %ecx
movslq %ecx, %rcx
movw %dx, (%rax,%rcx,2)
movq -0x10(%rbp), %rax
movq 0x80(%rax), %rax
movq -0x10(%rbp), %rcx
movl 0x68(%rcx), %ecx
addl -0x20(%rbp), %ecx
movslq %ecx, %rcx
movb $0x0, (%rax,%rcx)
movq -0x10(%rbp), %rax
cmpl $0x0, 0x90(%rax)
je 0xabe5
movq -0x10(%rbp), %rax
movq 0x78(%rax), %rax
movq -0x10(%rbp), %rcx
movl 0x68(%rcx), %ecx
addl -0x20(%rbp), %ecx
movslq %ecx, %rcx
movl $0xffffffff, (%rax,%rcx,4) # imm = 0xFFFFFFFF
jmp 0xabe7
movl -0x20(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x20(%rbp)
jmp 0xab57
movl -0x1c(%rbp), %ecx
movq -0x10(%rbp), %rax
addl 0x68(%rax), %ecx
movl %ecx, 0x68(%rax)
movl $0x1, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/MikeGray-APH[P]LibLouisAPH/source/translate.c
// Function: translate_insert_dots_for_chars
int translate_insert_dots_for_chars(struct translate *translate, const unichar *dots, const int dots_len, const int chars_cnt)
{
	int i;

	if(!translate_check_output_max(translate, dots_len))
		return 0;

	for(i = 0; i < dots_len; i++)
	{
		ASSERT(translate->output_len + i < translate->output_max)
		translate->output[translate->output_len + i] = dots[i];
		translate->output_mask[translate->output_len + i] = 0;

		if(translate->maps_use)
			translate->output_to_input_map[translate->output_len + i] = translate->input_map[translate->input_crs];
	}
	if(translate->maps_use)
	for(i = 0; i < chars_cnt; i++)
		translate_remap_input(translate, i, 0);

	translate_increment(translate, chars_cnt, dots_len);

	return 1;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movl %edx, -0x1c(%rbp)
movl %ecx, -0x20(%rbp)
movq -0x10(%rbp), %rdi
movl -0x1c(%rbp), %esi
callq 0xa830
cmpl $0x0, %eax
jne 0xac53
movl $0x0, -0x4(%rbp)
jmp 0xad54
movl $0x0, -0x24(%rbp)
movl -0x24(%rbp), %eax
cmpl -0x1c(%rbp), %eax
jge 0xad07
movq -0x10(%rbp), %rax
movl 0x68(%rax), %eax
addl -0x24(%rbp), %eax
movq -0x10(%rbp), %rcx
cmpl 0x6c(%rcx), %eax
jl 0xac7e
callq 0x1050
movq -0x18(%rbp), %rax
movslq -0x24(%rbp), %rcx
movw (%rax,%rcx,2), %dx
movq -0x10(%rbp), %rax
movq 0x60(%rax), %rax
movq -0x10(%rbp), %rcx
movl 0x68(%rcx), %ecx
addl -0x24(%rbp), %ecx
movslq %ecx, %rcx
movw %dx, (%rax,%rcx,2)
movq -0x10(%rbp), %rax
movq 0x80(%rax), %rax
movq -0x10(%rbp), %rcx
movl 0x68(%rcx), %ecx
addl -0x24(%rbp), %ecx
movslq %ecx, %rcx
movb $0x0, (%rax,%rcx)
movq -0x10(%rbp), %rax
cmpl $0x0, 0x90(%rax)
je 0xacf7
movq -0x10(%rbp), %rax
movq 0x50(%rax), %rax
movq -0x10(%rbp), %rcx
movslq 0x40(%rcx), %rcx
movl (%rax,%rcx,4), %edx
movq -0x10(%rbp), %rax
movq 0x78(%rax), %rax
movq -0x10(%rbp), %rcx
movl 0x68(%rcx), %ecx
addl -0x24(%rbp), %ecx
movslq %ecx, %rcx
movl %edx, (%rax,%rcx,4)
jmp 0xacf9
movl -0x24(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x24(%rbp)
jmp 0xac5a
movq -0x10(%rbp), %rax
cmpl $0x0, 0x90(%rax)
je 0xad3e
movl $0x0, -0x24(%rbp)
movl -0x24(%rbp), %eax
cmpl -0x20(%rbp), %eax
jge 0xad3c
movq -0x10(%rbp), %rdi
movl -0x24(%rbp), %esi
xorl %edx, %edx
callq 0xad60
movl -0x24(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x24(%rbp)
jmp 0xad1b
jmp 0xad3e
movq -0x10(%rbp), %rdi
movl -0x20(%rbp), %esi
movl -0x1c(%rbp), %edx
callq 0xaa90
movl $0x1, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/MikeGray-APH[P]LibLouisAPH/source/translate.h
// Function: translate_remap_input
static inline void translate_remap_input(struct translate *translate, const int offset, const int clear_map)
{
	int map, i, m;

	map = translate->output_len;
	if(clear_map)
		map = -1;

	ASSERT(translate->input_crs + offset < translate->input_len)
	if(translate->input_map[translate->input_crs + offset] >= 0)
	if(translate->input_crs == 0 || (translate->input_map[translate->input_crs - 1] != translate->input_map[translate->input_crs]))
	{
		/*   remap whole input block   */
		m = translate->input_map[translate->input_crs + offset];
		if(translate->input_to_output_map[m] >= 0)
		{
			for(i = m + 1; i < translate->chars_len; i++)
			if(translate->input_to_output_map[i] >= 0 && translate->input_to_output_map[i] == translate->input_to_output_map[m])
				translate->input_to_output_map[i] = map;
			else
				break;

			translate->input_to_output_map[m] = map;
		}
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movl %edx, -0x10(%rbp)
movq -0x8(%rbp), %rax
movl 0x68(%rax), %eax
movl %eax, -0x14(%rbp)
cmpl $0x0, -0x10(%rbp)
je 0xad89
movl $0xffffffff, -0x14(%rbp) # imm = 0xFFFFFFFF
movq -0x8(%rbp), %rax
movl 0x40(%rax), %eax
addl -0xc(%rbp), %eax
movq -0x8(%rbp), %rcx
cmpl 0x44(%rcx), %eax
jl 0xada1
callq 0x1050
movq -0x8(%rbp), %rax
movq 0x50(%rax), %rax
movq -0x8(%rbp), %rcx
movl 0x40(%rcx), %ecx
addl -0xc(%rbp), %ecx
movslq %ecx, %rcx
cmpl $0x0, (%rax,%rcx,4)
jl 0xaea8
movq -0x8(%rbp), %rax
cmpl $0x0, 0x40(%rax)
je 0xadfb
movq -0x8(%rbp), %rax
movq 0x50(%rax), %rax
movq -0x8(%rbp), %rcx
movl 0x40(%rcx), %ecx
subl $0x1, %ecx
movslq %ecx, %rcx
movl (%rax,%rcx,4), %eax
movq -0x8(%rbp), %rcx
movq 0x50(%rcx), %rcx
movq -0x8(%rbp), %rdx
movslq 0x40(%rdx), %rdx
cmpl (%rcx,%rdx,4), %eax
je 0xaea6
movq -0x8(%rbp), %rax
movq 0x50(%rax), %rax
movq -0x8(%rbp), %rcx
movl 0x40(%rcx), %ecx
addl -0xc(%rbp), %ecx
movslq %ecx, %rcx
movl (%rax,%rcx,4), %eax
movl %eax, -0x1c(%rbp)
movq -0x8(%rbp), %rax
movq 0x48(%rax), %rax
movslq -0x1c(%rbp), %rcx
cmpl $0x0, (%rax,%rcx,4)
jl 0xaea4
movl -0x1c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x18(%rbp)
movl -0x18(%rbp), %eax
movq -0x8(%rbp), %rcx
cmpl 0x20(%rcx), %eax
jge 0xae92
movq -0x8(%rbp), %rax
movq 0x48(%rax), %rax
movslq -0x18(%rbp), %rcx
cmpl $0x0, (%rax,%rcx,4)
jl 0xae83
movq -0x8(%rbp), %rax
movq 0x48(%rax), %rax
movslq -0x18(%rbp), %rcx
movl (%rax,%rcx,4), %eax
movq -0x8(%rbp), %rcx
movq 0x48(%rcx), %rcx
movslq -0x1c(%rbp), %rdx
cmpl (%rcx,%rdx,4), %eax
jne 0xae83
movl -0x14(%rbp), %edx
movq -0x8(%rbp), %rax
movq 0x48(%rax), %rax
movslq -0x18(%rbp), %rcx
movl %edx, (%rax,%rcx,4)
jmp 0xae85
jmp 0xae92
jmp 0xae87
movl -0x18(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x18(%rbp)
jmp 0xae31
movl -0x14(%rbp), %edx
movq -0x8(%rbp), %rax
movq 0x48(%rax), %rax
movslq -0x1c(%rbp), %rcx
movl %edx, (%rax,%rcx,4)
jmp 0xaea6
jmp 0xaea8
addq $0x20, %rsp
popq %rbp
retq
nop