LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O3/MikeGray-APH[P]LibLouisAPH/source/compile.c
// Function: convert_to_dots
static int convert_to_dots(unichar *uchars, const int uchars_len)
{
	unichar cell;
	int crs, off;

	cell = 0;
	crs = 0;
	for(off = 0; off < uchars_len; off++)
	{
		if(uchars[off] >= 0x2800 && uchars[off] <= 0x28ff)
		{
			if(cell)
			{
				uchars[crs++] = cell | 0x2800;
				cell = 0;
			}
			uchars[crs++] = uchars[off];
		}
		else if(uchars[off] == u'0')
			cell = 0x2800;
		else if(uchars[off] >= u'1' && uchars[off] <= u'8')
			cell |= (unichar)BIT(uchars[off] - u'1');
		else if(uchars[off] == u'-')
		{
			if(cell)
			{
				uchars[crs++] = cell | 0x2800;
				cell = 0;
			}
		}
		else
			return -1;
	}

	if(cell)
	{
		uchars[crs++] = cell | 0x2800;
		cell = 0;
	}

	return crs;
}

// Assembly:
testl %esi, %esi
jle 0x6ce1
movl %esi, %edx
xorl %esi, %esi
xorl %eax, %eax
xorl %r8d, %r8d
movzwl (%rdi,%rsi,2), %ecx
movl %ecx, %r9d
andl $0xff00, %r9d           # imm = 0xFF00
cmpl $0x2800, %r9d           # imm = 0x2800
jne 0x6c76
testw %r8w, %r8w
je 0x6c67
orl $0x2800, %r8d           # imm = 0x2800
movslq %eax, %rcx
incl %eax
movw %r8w, (%rdi,%rcx,2)
movzwl (%rdi,%rsi,2), %ecx
movslq %eax, %r8
incl %eax
movw %cx, (%rdi,%r8,2)
xorl %r8d, %r8d
jmp 0x6ca0
cmpw $0x30, %cx
jne 0x6c83
movw $0x2800, %r8w           # imm = 0x2800
jmp 0x6ca0
leal -0x31(%rcx), %r9d
cmpw $0x7, %r9w
ja 0x6caa
movzwl %cx, %ecx
addb $-0x31, %cl
movl $0x1, %r9d
shlq %cl, %r9
orl %r9d, %r8d
incq %rsi
cmpq %rsi, %rdx
jne 0x6c35
jmp 0x6cc9
cmpw $0x2d, %cx
jne 0x6ce4
testw %r8w, %r8w
je 0x6c71
orl $0x2800, %r8d           # imm = 0x2800
movslq %eax, %rcx
incl %eax
movw %r8w, (%rdi,%rcx,2)
jmp 0x6c71
testw %r8w, %r8w
je 0x6ce0
orl $0x2800, %r8d           # imm = 0x2800
movslq %eax, %rcx
incl %eax
movw %r8w, (%rdi,%rcx,2)
retq
xorl %eax, %eax
retq
movl $0xffffffff, %eax       # imm = 0xFFFFFFFF
retq
// File: /workspace/github_c_makefile_star2_O3/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 %rbx
movq 0x133b3(%rip), %r8      # 0x1a228
movl 0x133a4(%rip), %r9d     # 0x1a220
movq 0x112fd(%rip), %rax     # 0x18180
movq 0x20(%rax), %rbx
testq %rbx, %rbx
je 0x6eb7
cmpl %r9d, 0x28(%rbx)
jne 0x6eb2
testl %r9d, %r9d
jle 0x6ee8
movq 0x20(%rbx), %rax
xorl %ecx, %ecx
movzwl (%r8,%rcx,2), %edx
cmpw (%rax,%rcx,2), %dx
jne 0x6eb2
incq %rcx
cmpq %rcx, %r9
jne 0x6e9d
jmp 0x6ee8
movq (%rbx), %rbx
jmp 0x6e87
movslq 0x112fa(%rip), %rax     # 0x181b8
leaq 0x1131b(%rip), %rcx     # 0x181e0
movq (%rcx,%rax,8), %rdx
leaq 0x112f0(%rip), %rcx     # 0x181c0
movl (%rcx,%rax,4), %ecx
leaq 0xc9a6(%rip), %rsi      # 0x13880
xorl %ebx, %ebx
movl $0x6, %edi
xorl %eax, %eax
callq 0xa278
movq %rbx, %rax
popq %rbx
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O3/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:
xorl %eax, %eax
testl %r8d, %r8d
js 0x6f47
leal (%r8,%rcx), %r9d
incl %r9d
cmpl 0x44(%rdi), %r9d
jge 0x6f47
movq 0x38(%rdi), %rdi
movl %r8d, %r10d
cmpw %si, (%rdi,%r10,2)
jne 0x6f47
movslq %r9d, %r9
cmpw %si, (%rdi,%r9,2)
jne 0x6f47
movl $0x1, %eax
testl %ecx, %ecx
jle 0x6f47
incl %r8d
movl %r8d, %esi
movl %ecx, %ecx
leaq (%rdi,%rsi,2), %rsi
xorl %edi, %edi
movzwl (%rsi,%rdi,2), %r8d
cmpw (%rdx,%rdi,2), %r8w
jne 0x6f48
incq %rdi
cmpq %rdi, %rcx
jne 0x6f33
retq
xorl %eax, %eax
retq
// File: /workspace/github_c_makefile_star2_O3/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:
movq 0x38(%rdi), %rcx
movslq 0x40(%rdi), %r8
movzwl (%rcx,%r8,2), %r9d
cmpw 0x1f0(%rsi), %r9w
je 0x6f75
movl $0x1, %eax
cmpw 0x1f2(%rsi), %r9w
jne 0x70d1
movl 0x54(%rdx), %esi
incq %r8
testq %rsi, %rsi
je 0x6f8d
leal (%rsi,%r8), %eax
cmpl 0x44(%rdi), %eax
jle 0x7017
movl 0x58(%rdx), %esi
testq %rsi, %rsi
je 0x6fa2
leal (%rsi,%r8), %eax
cmpl 0x44(%rdi), %eax
jle 0x7049
movl 0x5c(%rdx), %esi
testq %rsi, %rsi
je 0x6fb7
leal (%rsi,%r8), %eax
cmpl 0x44(%rdi), %eax
jle 0x7077
movl 0x60(%rdx), %esi
testq %rsi, %rsi
je 0x6fcc
leal (%rsi,%r8), %eax
cmpl 0x44(%rdi), %eax
jle 0x70a5
movl 0x64(%rdx), %esi
movl $0x1, %eax
testq %rsi, %rsi
je 0x70d1
leal (%rsi,%r8), %r9d
cmpl 0x44(%rdi), %r9d
jg 0x70d1
testl %esi, %esi
jle 0x7011
movslq %r8d, %rdi
leaq (%rcx,%rdi,2), %rcx
xorl %edi, %edi
movzwl (%rcx,%rdi,2), %r8d
cmpw 0x44(%rdx,%rdi,2), %r8w
jne 0x70d1
incq %rdi
cmpq %rdi, %rsi
jne 0x6ff8
movl $0x6, %eax
retq
movl $0x2, %eax
testl %esi, %esi
jle 0x70d1
leaq (%rcx,%r8,2), %r9
xorl %r10d, %r10d
movzwl (%r9,%r10,2), %r11d
cmpw 0xc(%rdx,%r10,2), %r11w
jne 0x6f8d
incq %r10
cmpq %r10, %rsi
jne 0x702b
jmp 0x70d1
movl $0x3, %eax
testl %esi, %esi
jle 0x70d1
movslq %r8d, %r9
leaq (%rcx,%r9,2), %r9
xorl %r10d, %r10d
movzwl (%r9,%r10,2), %r11d
cmpw 0x1a(%rdx,%r10,2), %r11w
jne 0x6fa2
incq %r10
cmpq %r10, %rsi
jne 0x705c
jmp 0x70d1
movl $0x4, %eax
testl %esi, %esi
jle 0x70d1
movslq %r8d, %r9
leaq (%rcx,%r9,2), %r9
xorl %r10d, %r10d
movzwl (%r9,%r10,2), %r11d
cmpw 0x28(%rdx,%r10,2), %r11w
jne 0x6fb7
incq %r10
cmpq %r10, %rsi
jne 0x708a
jmp 0x70d1
movl $0x5, %eax
testl %esi, %esi
jle 0x70d1
movslq %r8d, %r9
leaq (%rcx,%r9,2), %r9
xorl %r10d, %r10d
movzwl (%r9,%r10,2), %r11d
cmpw 0x36(%rdx,%r10,2), %r11w
jne 0x6fcc
incq %r10
cmpq %r10, %rsi
jne 0x70b8
retq
// File: /workspace/github_c_makefile_star2_O3/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 %r14
pushq %rbx
pushq %rax
addl 0x68(%rdi), %esi
movl 0x6c(%rdi), %ecx
movl $0x1, %ebx
cmpl %ecx, %esi
jl 0x71c2
movq %rdi, %r14
movl 0x70(%rdi), %edi
incl %esi
leal (%rcx,%rdi), %eax
xorl %r8d, %r8d
cmpl %eax, %esi
cmovlel %eax, %esi
setg %r8b
addl %r8d, %eax
subl %eax, %esi
cmpl $0x1, %edi
movl %edi, %r9d
adcl $0x0, %r9d
movl %esi, %eax
xorl %edx, %edx
divl %r9d
addl %r8d, %eax
incl %eax
imull %edi, %eax
addl %ecx, %eax
movl %eax, 0x6c(%r14)
movq 0x60(%r14), %rdi
movslq %eax, %rsi
addq %rsi, %rsi
callq 0x11b0
movq %rax, 0x60(%r14)
testq %rax, %rax
je 0x717e
movq 0x80(%r14), %rdi
movslq 0x6c(%r14), %rsi
callq 0x11b0
movq %rax, 0x80(%r14)
testq %rax, %rax
je 0x71a1
cmpl $0x0, 0x90(%r14)
je 0x71c2
movq 0x78(%r14), %rdi
movslq 0x6c(%r14), %rsi
shlq $0x2, %rsi
callq 0x11b0
movq %rax, 0x78(%r14)
testq %rax, %rax
jne 0x71c2
jmp 0x719d
leaq 0xc0b7(%rip), %rsi      # 0x1323c
leaq 0xc914(%rip), %rdx      # 0x13aa0
movl $0x7, %edi
movl $0x64, %ecx
xorl %eax, %eax
callq 0xa278
xorl %ebx, %ebx
jmp 0x71c2
leaq 0xc094(%rip), %rsi      # 0x1323c
leaq 0xc8f1(%rip), %rdx      # 0x13aa0
xorl %ebx, %ebx
movl $0x7, %edi
movl $0x6b, %ecx
xorl %eax, %eax
callq 0xa278
movl %ebx, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O3/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 %rax
movl 0x40(%rdi), %ecx
movl 0x44(%rdi), %r8d
movl %r8d, %eax
subl %ecx, %eax
addl %esi, %ecx
cmpl %r8d, %ecx
cmovlel %esi, %eax
testl %edx, %edx
je 0x7228
cmpl $0x0, 0x90(%rdi)
je 0x7228
testl %eax, %eax
jle 0x7228
movq 0x50(%rdi), %rcx
xorl %edx, %edx
movslq 0x40(%rdi), %r8
leaq (%rdx,%r8), %rsi
movslq (%rcx,%rsi,4), %rsi
testq %rsi, %rsi
js 0x7221
movl %r8d, %r8d
addq %rdx, %r8
cmpl 0x44(%rdi), %r8d
jge 0x726d
movq 0x48(%rdi), %r8
movl $0xffffffff, (%r8,%rsi,4) # imm = 0xFFFFFFFF
incq %rdx
cmpl %eax, %edx
jl 0x71f8
testl %eax, %eax
je 0x725e
cmpl $0x0, 0x8c(%rdi)
movl 0x40(%rdi), %ecx
jne 0x7261
movl 0x88(%rdi), %edx
cmpl %ecx, %edx
jl 0x7261
leal (%rcx,%rax), %esi
cmpl %esi, %edx
jge 0x7261
movl $0x1, 0x8c(%rdi)
movl 0x68(%rdi), %edx
movl %edx, 0x88(%rdi)
jmp 0x7261
movl 0x40(%rdi), %ecx
addl %eax, %ecx
movl %ecx, 0x40(%rdi)
movl $0x1, %eax
popq %rcx
retq
callq 0x1060
// File: /workspace/github_c_makefile_star2_O3/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 %r15
pushq %r14
pushq %rbx
movl %edx, %ebx
movq %rsi, %r15
movq %rdi, %r14
movl %edx, %esi
callq 0x70d2
testl %eax, %eax
je 0x72eb
testl %ebx, %ebx
jle 0x72e0
movl %ebx, %eax
xorl %ecx, %ecx
movslq 0x68(%r14), %rdx
leal (%rcx,%rdx), %esi
cmpl 0x6c(%r14), %esi
jge 0x72f3
movzwl (%r15,%rcx,2), %esi
movq 0x60(%r14), %rdi
leaq (%rcx,%rdx), %r8
movw %si, (%rdi,%r8,2)
addq 0x80(%r14), %rdx
movb $0x0, (%rcx,%rdx)
cmpl $0x0, 0x90(%r14)
je 0x72d8
movq 0x78(%r14), %rdx
movslq 0x68(%r14), %rsi
addq %rcx, %rsi
movl $0xffffffff, (%rdx,%rsi,4) # imm = 0xFFFFFFFF
incq %rcx
cmpq %rcx, %rax
jne 0x7292
addl %ebx, 0x68(%r14)
movl $0x1, %eax
jmp 0x72ed
xorl %eax, %eax
popq %rbx
popq %r14
popq %r15
retq
callq 0x1060
// File: /workspace/github_c_makefile_star2_O3/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
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movl %ecx, %ebp
movl %edx, %ebx
movq %rsi, %r15
movq %rdi, %r14
movl %edx, %esi
callq 0x70d2
testl %eax, %eax
je 0x7405
testl %ebx, %ebx
jle 0x7379
movl %ebx, %eax
xorl %ecx, %ecx
movslq 0x68(%r14), %rdx
leal (%rcx,%rdx), %esi
cmpl 0x6c(%r14), %esi
jge 0x7462
movzwl (%r15,%rcx,2), %esi
movq 0x60(%r14), %rdi
leaq (%rcx,%rdx), %r8
movw %si, (%rdi,%r8,2)
addq 0x80(%r14), %rdx
movb $0x0, (%rcx,%rdx)
cmpl $0x0, 0x90(%r14)
je 0x7371
movslq 0x40(%r14), %rdx
movq 0x50(%r14), %rsi
movq 0x78(%r14), %rdi
movl (%rsi,%rdx,4), %edx
movslq 0x68(%r14), %rsi
addq %rcx, %rsi
movl %edx, (%rdi,%rsi,4)
incq %rcx
cmpq %rcx, %rax
jne 0x7320
cmpl $0x0, 0x90(%r14)
sete %al
testl %ebp, %ebp
setle %cl
orb %al, %cl
jne 0x7409
xorl %eax, %eax
movslq 0x40(%r14), %rsi
movslq %eax, %rcx
addq %rsi, %rcx
cmpl 0x44(%r14), %ecx
jge 0x7462
movq 0x50(%r14), %rdi
movslq (%rdi,%rcx,4), %rcx
testq %rcx, %rcx
js 0x73fd
movl 0x68(%r14), %edx
testl %esi, %esi
je 0x73c3
movl -0x4(%rdi,%rsi,4), %r8d
cmpl (%rdi,%rsi,4), %r8d
je 0x73fd
movq 0x48(%r14), %rsi
cmpl $0x0, (%rsi,%rcx,4)
js 0x73fd
leal 0x1(%rcx), %edi
cmpl 0x20(%r14), %edi
jge 0x73fa
movl %edi, %r8d
leaq (%rsi,%r8,4), %r8
movl (%r8), %r9d
testl %r9d, %r9d
js 0x73fa
cmpl (%rsi,%rcx,4), %r9d
jne 0x73fa
movl %edx, (%r8)
incl %edi
addq $0x4, %r8
cmpl %edi, 0x20(%r14)
jg 0x73dd
movl %edx, (%rsi,%rcx,4)
incl %eax
cmpl %ebp, %eax
jne 0x738f
jmp 0x740d
xorl %eax, %eax
jmp 0x7457
testl %ebp, %ebp
je 0x744a
cmpl $0x0, 0x8c(%r14)
jne 0x744a
movl 0x40(%r14), %eax
movl 0x88(%r14), %ecx
cmpl %eax, %ecx
setge %dl
addl %ebp, %eax
cmpl %eax, %ecx
setl %al
andb %dl, %al
cmpb $0x1, %al
jne 0x744a
movl $0x1, 0x8c(%r14)
movl 0x68(%r14), %eax
movl %eax, 0x88(%r14)
addl %ebp, 0x40(%r14)
addl %ebx, 0x68(%r14)
movl $0x1, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
callq 0x1060
// File: /workspace/github_c_makefile_star2_O3/MikeGray-APH[P]LibLouisAPH/source/translate.c
// Function: translate_copy_marked_user
int translate_copy_marked_user(struct translate *translate)
{
	const struct table *table;
	int i;

	/*   only copy indicators from last table in tables
	     don't change translate->table_crs   */
	table = translate->tables[translate->table_cnt - 1];

	if(   translate->input[translate->input_crs] != table->marker_user
	   && translate->input[translate->input_crs] != table->marker_begin
	   && translate->input[translate->input_crs] != table->marker_end)
		return -1;

	for(i = translate->input_crs + 1; i < translate->input_len; i++)
	if(translate->input[i] == translate->input[translate->input_crs])
		break;

	return translate_copy_to_output(translate, i - translate->input_crs + 1, 0);
}

// Assembly:
movslq 0xc(%rdi), %rax
movq (%rdi), %rdx
movq 0x38(%rdi), %rcx
movq -0x8(%rdx,%rax,8), %rsi
movslq 0x40(%rdi), %rax
movzwl (%rcx,%rax,2), %edx
cmpw 0x1e8(%rsi), %dx
je 0x7690
cmpw 0x1ea(%rsi), %dx
je 0x7690
cmpw 0x1ec(%rsi), %dx
jne 0x76cf
movslq 0x44(%rdi), %r8
leal 0x1(%rax), %r9d
cmpl %r9d, %r8d
cmovgl %r8d, %r9d
decl %r9d
leal -0x1(%rax), %esi
leaq 0x1(%rax), %r10
cmpq %r8, %r10
jge 0x76c0
incl %esi
leaq 0x1(%r10), %r11
cmpw %dx, (%rcx,%r10,2)
movq %r11, %r10
jne 0x76a9
jmp 0x76c3
movl %r9d, %esi
subl %eax, %esi
addl $0x2, %esi
xorl %edx, %edx
jmp 0x7467
movl $0xffffffff, %eax       # imm = 0xFFFFFFFF
retq
// File: /workspace/github_c_makefile_star2_O3/MikeGray-APH[P]LibLouisAPH/source/translate.c
// Function: translate_copy_marked_indicators
int translate_copy_marked_indicators(struct translate *translate)
{
	const struct table *table;
	int i;

	/*   only copy indicators from last table in tables
	     don't change translate->table_crs   */
	table = translate->tables[translate->table_cnt - 1];

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

	for(i = translate->input_crs + 1; i < translate->input_len; i++)
	if(translate->input[i] == translate->input[translate->input_crs])
		break;

	return translate_copy_to_output(translate, i - translate->input_crs + 1, 0);
}

// Assembly:
movslq 0xc(%rdi), %rax
movq (%rdi), %rdx
movq 0x38(%rdi), %rcx
movq -0x8(%rdx,%rax,8), %rsi
movslq 0x40(%rdi), %rax
movzwl (%rcx,%rax,2), %edx
cmpw 0x1f0(%rsi), %dx
je 0x76ff
cmpw 0x1f2(%rsi), %dx
jne 0x773e
movslq 0x44(%rdi), %r8
leal 0x1(%rax), %r9d
cmpl %r9d, %r8d
cmovgl %r8d, %r9d
decl %r9d
leal -0x1(%rax), %esi
leaq 0x1(%rax), %r10
cmpq %r8, %r10
jge 0x772f
incl %esi
leaq 0x1(%r10), %r11
cmpw %dx, (%rcx,%r10,2)
movq %r11, %r10
jne 0x7718
jmp 0x7732
movl %r9d, %esi
subl %eax, %esi
addl $0x2, %esi
xorl %edx, %edx
jmp 0x7467
movl $0xffffffff, %eax       # imm = 0xFFFFFFFF
retq
// File: /workspace/github_c_makefile_star2_O3/MikeGray-APH[P]LibLouisAPH/source/translate.c
// Function: translate_copy_marked_indicators_or_modifiers
int translate_copy_marked_indicators_or_modifiers(struct translate *translate)
{
	const struct table *table;
	int i;

	/*   only copy indicators from last table in tables
	     don't change translate->table_crs   */
	table = translate->tables[translate->table_cnt - 1];

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

	for(i = translate->input_crs + 1; i < translate->input_len; i++)
	if(translate->input[i] == translate->input[translate->input_crs])
		break;

	return translate_copy_to_output(translate, i - translate->input_crs + 1, 1);
}

// Assembly:
movslq 0xc(%rdi), %rax
movq (%rdi), %rdx
movq 0x38(%rdi), %rcx
movq -0x8(%rdx,%rax,8), %rsi
movslq 0x40(%rdi), %rax
movzwl (%rcx,%rax,2), %edx
cmpw 0x1ee(%rsi), %dx
je 0x7777
cmpw 0x1f0(%rsi), %dx
je 0x7777
cmpw 0x1f2(%rsi), %dx
jne 0x77b9
movslq 0x44(%rdi), %r8
leal 0x1(%rax), %r9d
cmpl %r9d, %r8d
cmovgl %r8d, %r9d
decl %r9d
leal -0x1(%rax), %esi
leaq 0x1(%rax), %r10
cmpq %r8, %r10
jge 0x77a7
incl %esi
leaq 0x1(%r10), %r11
cmpw %dx, (%rcx,%r10,2)
movq %r11, %r10
jne 0x7790
jmp 0x77aa
movl %r9d, %esi
subl %eax, %esi
addl $0x2, %esi
movl $0x1, %edx
jmp 0x7467
movl $0xffffffff, %eax       # imm = 0xFFFFFFFF
retq
// File: /workspace/github_c_makefile_star2_O3/MikeGray-APH[P]LibLouisAPH/source/translate.c
// Function: translate_output_to_input
int translate_output_to_input(struct translate *translate)
{
	FREE(translate->input);
	FREE(translate->input_mask);
	translate->input = translate->output;
	translate->input_mask = translate->output_mask;
	translate->input_len = translate->output_len;
	translate->input_crs = 0;

	translate->output = MALLOC(translate->output_max * sizeof(unichar));
	if(!translate->output)
	{
		LOG_ALLOCATE_FAIL
		return 0;
	}
	DB_MEMSET(translate->output, 0, translate->output_max * sizeof(unichar));
	translate->output_len = 0;

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

	if(!translate->maps_use)
		return 1;

	FREE(translate->input_map);
	translate->input_map = translate->output_to_input_map;

	translate->output_to_input_map = MALLOC(translate->output_max * sizeof(int));
	if(!translate->output_to_input_map)
	{
		LOG_ALLOCATE_FAIL
		return 0;
	}
	DB_MEMSET(translate->output_to_input_map, -1, translate->output_max * sizeof(int));

	return 1;
}

// Assembly:
pushq %rbp
pushq %r14
pushq %rbx
movq %rdi, %rbx
movq 0x38(%rdi), %rdi
callq 0x1040
movq 0x58(%rbx), %rdi
callq 0x1040
movq 0x60(%rbx), %rax
movq %rax, 0x38(%rbx)
movq 0x80(%rbx), %rax
movq %rax, 0x58(%rbx)
movl 0x68(%rbx), %eax
movl %eax, 0x44(%rbx)
movl $0x0, 0x40(%rbx)
movslq 0x6c(%rbx), %r14
leaq (%r14,%r14), %rsi
movl $0x1, %edi
callq 0x1150
movq %rax, 0x60(%rbx)
testq %rax, %rax
je 0x7881
movl $0x0, 0x68(%rbx)
movl $0x1, %edi
movq %r14, %rsi
callq 0x1150
movq %rax, 0x80(%rbx)
testq %rax, %rax
je 0x78a4
movl $0x1, %ebp
cmpl $0x0, 0x90(%rbx)
je 0x78c8
movq 0x50(%rbx), %rdi
callq 0x1040
movq 0x78(%rbx), %rax
movq %rax, 0x50(%rbx)
movslq 0x6c(%rbx), %r14
shlq $0x2, %r14
movq %r14, %rdi
callq 0x1190
movq %rax, 0x78(%rbx)
testq %rax, %rax
je 0x78cf
movq %rax, %rdi
movl $0xff, %esi
movq %r14, %rdx
callq 0x1110
jmp 0x78c8
leaq 0xb9b4(%rip), %rsi      # 0x1323c
leaq 0xc211(%rip), %rdx      # 0x13aa0
xorl %ebp, %ebp
movl $0x7, %edi
movl $0x134, %ecx            # imm = 0x134
xorl %eax, %eax
callq 0xa278
jmp 0x78c8
leaq 0xb991(%rip), %rsi      # 0x1323c
leaq 0xc1ee(%rip), %rdx      # 0x13aa0
movl $0x7, %edi
movl $0x13d, %ecx            # imm = 0x13D
xorl %eax, %eax
callq 0xa278
movl $0xffffffff, %ebp       # imm = 0xFFFFFFFF
movl %ebp, %eax
popq %rbx
popq %r14
popq %rbp
retq
leaq 0xb966(%rip), %rsi      # 0x1323c
leaq 0xc1c3(%rip), %rdx      # 0x13aa0
xorl %ebp, %ebp
movl $0x7, %edi
movl $0x14b, %ecx            # imm = 0x14B
jmp 0x789b
// File: /workspace/github_c_makefile_star2_O3/MikeGray-APH[P]LibLouisAPH/source/pattern.c
// Function: subpattern_free
void subpattern_free(struct subpattern *subpattern)
{
	if(!subpattern)
		return;

	subpattern_free(subpattern->nxt);
	if(subpattern->tag)
		FREE(subpattern->tag);
	if(subpattern->expr_data)
		FREE(subpattern->expr_data);
	if(subpattern->src_data)
		FREE(subpattern->src_data);
	FREE(subpattern);
}

// Assembly:
testq %rdi, %rdi
je 0x8060
pushq %rbx
movq %rdi, %rbx
movq (%rdi), %rdi
callq 0x801c
movq 0x8(%rbx), %rdi
testq %rdi, %rdi
je 0x803b
callq 0x1040
movq 0x10(%rbx), %rdi
testq %rdi, %rdi
je 0x8049
callq 0x1040
movq 0x18(%rbx), %rdi
testq %rdi, %rdi
je 0x8057
callq 0x1040
movq %rbx, %rdi
popq %rbx
jmp 0x1040
retq
// File: /workspace/github_c_makefile_star2_O3/MikeGray-APH[P]LibLouisAPH/source/pattern.c
// Function: pattern_compile
int pattern_compile(
	unichar *expr_data,
	const int expr_len,
	const unichar *input,
	const int input_len,
	const char *attrs_chars_,
	struct subpattern *subpatterns)
{
	int input_crs;

	set_attrs_chars(attrs_chars_);

	input_crs = 0;
	expr_data[0] = 2;
	expr_data[1] = 0;

	if(!pattern_compile_1(input, input_len, &input_crs, expr_data, expr_len, &expr_data[0], &expr_data[1], subpatterns))
		return 0;

	/*   shift past the last end   */
	expr_data[0] += 3;

	if(!pattern_compile_2(expr_data, 2, expr_len, &expr_data[0]))
		return 0;

	if(!pattern_compile_3(expr_data, 2, expr_len, &expr_data[0]))
		return 0;

	return expr_data[0];
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %r9, %r14
movl %ecx, %r15d
movq %rdx, %r12
movl %esi, %ebp
movq %rdi, %rbx
testq %r8, %r8
je 0x80a8
movq %r8, %r13
movq %r8, %rdi
callq 0x10b0
testl %eax, %eax
jle 0x80a8
cmpl $0x20, %eax
movl $0x20, %edx
cmovbl %eax, %edx
leaq 0x10060(%rip), %rdi     # 0x18100
movq %r13, %rsi
callq 0x1180
leaq 0x4(%rsp), %rdx
movl $0x0, (%rdx)
movl $0x2, (%rbx)
leaq 0x2(%rbx), %rax
movq %r12, %rdi
movl %r15d, %esi
movq %rbx, %rcx
movl %ebp, %r8d
movq %rbx, %r9
pushq %r14
pushq %rax
callq 0x8125
addq $0x10, %rsp
xorl %r14d, %r14d
testl %eax, %eax
je 0x8113
addw $0x3, (%rbx)
movq %rbx, %rdi
movl $0x2, %esi
movl %ebp, %edx
movq %rbx, %rcx
callq 0x821c
testl %eax, %eax
je 0x8113
movq %rbx, %rdi
movl $0x2, %esi
movl %ebp, %edx
movq %rbx, %rcx
callq 0x830e
testl %eax, %eax
je 0x8113
movzwl (%rbx), %r14d
movl %r14d, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/MikeGray-APH[P]LibLouisAPH/source/pattern.c
// Function: pattern_compile_1
static int pattern_compile_1(
	const unichar *input,
	const int input_len,
	int *input_crs,
	unichar *expr_data,
	const int expr_len,
	unichar *expr_crs,
	unichar *loop_cnts,
	struct subpattern *subpatterns)
{
	int expr_crs_prv;

	if(*expr_crs + 6 >= expr_len)
		return 0;

	expr_crs_prv = *expr_crs;

	/*   setup start expression   */
	EXPR_TYPE(*expr_crs) = PTN_START;
	EXPR_PRV(*expr_crs) = PTN_END;
	*expr_crs += 3;
	EXPR_NXT(expr_crs_prv) = *expr_crs;

	/*   setup end expression   */
	EXPR_TYPE(*expr_crs) = PTN_END;
	EXPR_PRV(*expr_crs) = expr_crs_prv;
	EXPR_NXT(*expr_crs) = PTN_END;

	while(*input_crs < input_len)
	{
		expr_crs_prv = *expr_crs;
		if(!pattern_compile_expression(input, input_len, input_crs, expr_data, expr_len, expr_crs, loop_cnts, subpatterns))
			return 0;

		/*   setup end expression   */
		if(*expr_crs + 3 >= expr_len)
			return 0;
		EXPR_NXT(expr_crs_prv) = *expr_crs;
		EXPR_TYPE(*expr_crs) = PTN_END;
		EXPR_PRV(*expr_crs) = expr_crs_prv;
		EXPR_NXT(*expr_crs) = PTN_END;
	}

	return *expr_crs;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rcx, %r15
movq %rdx, %r12
movq %rdi, (%rsp)
movzwl (%r9), %edx
leal 0x6(%rdx), %ecx
xorl %eax, %eax
cmpl %r8d, %ecx
jge 0x820d
movq %r9, %r14
movl %esi, %r13d
movw $0x1, (%r15,%rdx,2)
movzwl (%r9), %ecx
movw $0xffff, %si            # imm = 0xFFFF
movw %si, 0x2(%r15,%rcx,2)
movzwl (%r9), %ecx
addl $0x3, %ecx
movw %cx, (%r9)
movw %cx, 0x4(%r15,%rdx,2)
movzwl (%r9), %ecx
movw %si, (%r15,%rcx,2)
movzwl (%r9), %ecx
movw %dx, 0x2(%r15,%rcx,2)
movzwl (%r9), %eax
movw %si, 0x4(%r15,%rax,2)
cmpl %r13d, (%r12)
jge 0x8205
movl %r8d, %ebp
movzwl (%r14), %ebx
movq (%rsp), %rdi
movl %r13d, %esi
movq %r12, %rdx
movq %r15, %rcx
movl %ebp, %r8d
movq %r14, %r9
pushq 0x48(%rsp)
pushq 0x48(%rsp)
callq 0x86fc
addq $0x10, %rsp
testl %eax, %eax
je 0x820b
movzwl (%r14), %eax
leal 0x3(%rax), %ecx
cmpl %ebp, %ecx
jae 0x820b
movzwl %bx, %ecx
movw %ax, 0x4(%r15,%rcx,2)
movzwl (%r14), %eax
movw $0xffff, %dx            # imm = 0xFFFF
movw %dx, (%r15,%rax,2)
movzwl (%r14), %eax
movw %cx, 0x2(%r15,%rax,2)
movzwl (%r14), %eax
movw %dx, 0x4(%r15,%rax,2)
cmpl %r13d, (%r12)
jl 0x819e
movzwl (%r14), %eax
jmp 0x820d
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/MikeGray-APH[P]LibLouisAPH/source/pattern.c
// Function: pattern_compile_2
static int pattern_compile_2(unichar *expr_data, int expr_at, const int expr_len, unichar *expr_crs)
{
	int expr_start, expr_end, expr_prv, expr_sub;

	while(EXPR_TYPE(expr_at) != PTN_END)
	{
		if(EXPR_TYPE(expr_at) == PTN_GROUP || EXPR_TYPE(expr_at) == PTN_NOT)
		{
			if(!pattern_compile_2(expr_data, EXPR_DATA_0(expr_at), expr_len, expr_crs))
				return 0;
		}

		if(   EXPR_TYPE(expr_at) == PTN_ZERO_MORE
		   || EXPR_TYPE(expr_at) == PTN_ONE_MORE
		   || EXPR_TYPE(expr_at) == PTN_OPTIONAL)
		{
			if(*expr_crs + 6 >= expr_len)
				return 0;

			/*   get previous expressions, there must
			     be at least something and a PTN_START   */
			expr_sub = EXPR_PRV(expr_at);
			if(EXPR_TYPE(expr_sub) == PTN_START)
				return 0;
			expr_prv = EXPR_PRV(expr_sub);

			/*   create start expression   */
			expr_start = *expr_crs;
			EXPR_TYPE(expr_start) = PTN_START;
			EXPR_PRV(expr_start) = PTN_END;
			EXPR_NXT(expr_start) = expr_sub;
			*expr_crs += 3;

			/*   create end expression   */
			expr_end = *expr_crs;
			EXPR_TYPE(expr_end) = PTN_END;
			EXPR_PRV(expr_end) = expr_sub;
			EXPR_NXT(expr_end) = expr_at;
			*expr_crs += 3;

			/*   relink previous expression before sub expression   */
			EXPR_DATA_0(expr_at) = expr_start;
			EXPR_NXT(expr_prv) = expr_at;
			EXPR_PRV(expr_at) = expr_prv;

			/*   relink sub expression to start and end   */
			EXPR_PRV(expr_sub) = expr_start;
			EXPR_NXT(expr_sub) = expr_end;
		}

		expr_at = EXPR_NXT(expr_at);
	}

	return 1;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rcx, %rbx
movl %edx, %ebp
movq %rdi, %r14
movl %esi, %r15d
movzwl (%r14,%r15,2), %eax
movzwl %ax, %ecx
leal -0x2(%rcx), %edx
cmpl $0x2, %edx
jae 0x8263
movslq %r15d, %rax
movzwl 0x6(%r14,%rax,2), %esi
movq %r14, %rdi
movl %ebp, %edx
movq %rbx, %rcx
callq 0x821c
testl %eax, %eax
je 0x82fa
movzwl (%r14,%r15,2), %eax
jmp 0x826f
cmpl $0xffff, %ecx           # imm = 0xFFFF
je 0x82fe
addl $-0x4, %eax
cmpw $0x3, %ax
jae 0x82ec
movzwl (%rbx), %edx
leal 0x6(%rdx), %ecx
xorl %eax, %eax
cmpl %ebp, %ecx
jge 0x8303
movslq %r15d, %rcx
movzwl 0x2(%r14,%rcx,2), %esi
cmpw $0x1, (%r14,%rsi,2)
je 0x8303
movzwl 0x2(%r14,%rsi,2), %eax
movl $0xffff0001, (%r14,%rdx,2) # imm = 0xFFFF0001
movw %si, 0x4(%r14,%rdx,2)
movzwl (%rbx), %edi
addl $0x3, %edi
movw %di, (%rbx)
movzwl %di, %edi
movw $0xffff, (%r14,%rdi,2)  # imm = 0xFFFF
movw %si, 0x2(%r14,%rdi,2)
movw %r15w, 0x4(%r14,%rdi,2)
addw $0x3, (%rbx)
movw %dx, 0x6(%r14,%rcx,2)
movw %r15w, 0x4(%r14,%rax,2)
movw %ax, 0x2(%r14,%rcx,2)
movw %dx, 0x2(%r14,%rsi,2)
movw %di, 0x4(%r14,%rsi,2)
jmp 0x82ef
movslq %r15d, %rcx
movzwl 0x4(%r14,%rcx,2), %esi
jmp 0x822b
xorl %eax, %eax
jmp 0x8303
movl $0x1, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/MikeGray-APH[P]LibLouisAPH/source/pattern.c
// Function: pattern_reverse_expression
static void pattern_reverse_expression(unichar *expr_data, const int expr_start)
{
	unichar expr_end, expr_crs, expr_prv;

	expr_end = EXPR_NXT(expr_start);

	/*   empty expression   */
	if(EXPR_TYPE(expr_end) == PTN_END)
		return;

	/*   find end expression   */
	while(EXPR_TYPE(expr_end) != PTN_END)
		expr_end = EXPR_NXT(expr_end);

	expr_crs = EXPR_PRV(expr_end);
	expr_prv = EXPR_PRV(expr_crs);

	/*   relink expression before end expression   */
	EXPR_NXT(expr_start) = expr_crs;
	EXPR_PRV(expr_crs)   = expr_start;
	EXPR_NXT(expr_crs)   = expr_prv;

	/*   reverse any branching expressions   */
	pattern_reverse_branch(expr_data, expr_crs);

	while(expr_prv != expr_start)
	{
		/*   shift current expression   */
		expr_crs = expr_prv;
		expr_prv = EXPR_PRV(expr_prv);

		/*   reverse any branching expressions   */
		pattern_reverse_branch(expr_data, expr_crs);

		if(expr_prv == expr_start)
			break;

		/*   relink current expression   */
		EXPR_PRV(expr_crs) = EXPR_NXT(expr_crs);
		EXPR_NXT(expr_crs) = expr_prv;
	}

	/*   relink expression after start expression   */
	EXPR_PRV(expr_crs) = EXPR_NXT(expr_crs);
	EXPR_NXT(expr_crs) = expr_end;
	EXPR_PRV(expr_end) = expr_crs;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movslq %esi, %rax
movzwl 0x4(%rdi,%rax,2), %r12d
cmpw $-0x1, (%rdi,%r12,2)
je 0x85cd
movl %esi, %ebp
movq %rdi, %rbx
movzwl 0x4(%rbx,%r12,2), %r12d
cmpw $-0x1, (%rbx,%r12,2)
jne 0x850f
movzwl 0x2(%rbx,%r12,2), %r13d
movzwl %r13w, %r14d
movzwl 0x2(%rbx,%r14,2), %ecx
movw %cx, 0xe(%rsp)
movzwl %cx, %r15d
movw %r14w, 0x4(%rbx,%rax,2)
movw %ax, 0x2(%rbx,%r14,2)
movw %r15w, 0x4(%rbx,%r14,2)
movq %rbx, %rdi
movl %r14d, %esi
movq %rax, 0x10(%rsp)
callq 0x8e88
cmpl 0x10(%rsp), %r15d
je 0x85b5
movq %r15, %rax
movq %r15, %r14
movzwl 0x2(%rbx,%rax,2), %r15d
movq %rbx, %rdi
movl %r14d, %esi
callq 0x8e88
movzwl %r15w, %esi
cmpl %ebp, %esi
jne 0x8586
movzwl 0xe(%rsp), %r13d
jmp 0x85b5
movl %r15d, %r13d
movzwl 0x4(%rbx,%r14,2), %eax
movw %ax, 0x2(%rbx,%r14,2)
movw %r15w, 0x4(%rbx,%r14,2)
movzwl %r15w, %r14d
movzwl 0x2(%rbx,%r14,2), %r15d
movq %rbx, %rdi
callq 0x8e88
movzwl %r15w, %esi
cmpl %ebp, %esi
jne 0x8586
movzwl 0x4(%rbx,%r14,2), %eax
movw %ax, 0x2(%rbx,%r14,2)
movw %r12w, 0x4(%rbx,%r14,2)
movw %r13w, 0x2(%rbx,%r12,2)
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/MikeGray-APH[P]LibLouisAPH/source/pattern.c
// Function: pattern_check
int pattern_check(
	const struct translate *translate_,
	const unichar *input,
	const int input_start,
	const int input_minmax,
	const int input_dir,
	const unichar *expr_data,
	const char *attrs_chars_,
	struct subpattern *subpatterns)
{
	int input_crs;

	input_crs = input_start;
	set_attrs_chars(attrs_chars_);
	translate = translate_;
	subpattern_level = 0;
	return subpattern_check(input, &input_crs, input_minmax, input_dir, expr_data, subpatterns);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %r9, %rbx
movl %r8d, %ebp
movl %ecx, %r14d
movq %rsi, %r12
movq %rdi, %r13
movq 0x40(%rsp), %r15
movl %edx, 0x4(%rsp)
testq %r15, %r15
je 0x862a
movq %r15, %rdi
callq 0x10b0
testl %eax, %eax
jle 0x862a
cmpl $0x20, %eax
movl $0x20, %edx
cmovbl %eax, %edx
leaq 0xfade(%rip), %rdi      # 0x18100
movq %r15, %rsi
callq 0x1180
movq %r13, 0x11c0f(%rip)     # 0x1a240
movl $0x0, 0x11c0d(%rip)     # 0x1a248
leaq 0x4(%rsp), %rsi
movq %r12, %rdi
movl %r14d, %edx
movl %ebp, %ecx
movq %rbx, %r8
movq 0x48(%rsp), %r9
callq 0x8664
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/MikeGray-APH[P]LibLouisAPH/source/pattern.c
// Function: subpattern_check
static int subpattern_check(
	const unichar *input,
	int *input_crs,
	const int input_minmax,
	const int input_dir,
	const unichar *expr_data,
	struct subpattern *subpatterns)
{
	int ret, *loop_cnts;

#ifdef PATTERN_OUTPUT_TRACE
	if(subpattern_level)
		puts("");
	else
		puts("----------------------------------------");
	printf("[%d]\n", *input_crs);
	pattern_print(stdout, expr_data, attrs_chars);
	puts("");
	printf(" ");
	utf16_output(stdout, input, 0x100);
	puts("");
	for(int i = 0; i <= *input_crs; i++)
		printf(" ");
	if(input_dir > 0)
		puts(">");
	else
		puts("<");
	//pattern_output(expr_data);
	fflush(stdout);
#endif

	loop_cnts = MALLOC(expr_data[1] * sizeof(int));
	if(!loop_cnts)
	{
		LOG_ALLOCATE_FAIL
		return 0;
	}
	memset(loop_cnts, 0, expr_data[1] * sizeof(int));
	ret = pattern_check_expression(input, input_crs, input_minmax, input_dir, expr_data, subpatterns, 2, 0, 0, loop_cnts);
	FREE(loop_cnts);

#ifdef PATTERN_OUTPUT_TRACE
	puts("");
#endif
	return ret;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %r9, (%rsp)
movq %r8, %r15
movl %ecx, %ebp
movl %edx, %r12d
movq %rsi, %r13
movq %rdi, %rbx
movzwl 0x2(%r8), %esi
shll $0x2, %esi
movl $0x1, %edi
callq 0x1150
testq %rax, %rax
je 0x86cc
movq %rax, %r14
xorl %eax, %eax
movq %rbx, %rdi
movq %r13, %rsi
movl %r12d, %edx
movl %ebp, %ecx
movq %r15, %r8
movq (%rsp), %r9
pushq %r14
pushq %rax
pushq %rax
pushq $0x2
callq 0x8ed2
addq $0x20, %rsp
movl %eax, %ebx
movq %r14, %rdi
callq 0x1040
movl %ebx, %eax
jmp 0x86ed
leaq 0xab69(%rip), %rsi      # 0x1323c
leaq 0xb452(%rip), %rdx      # 0x13b2c
movl $0x7, %edi
movl $0x53d, %ecx            # imm = 0x53D
xorl %eax, %eax
callq 0xa278
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/MikeGray-APH[P]LibLouisAPH/source/pattern.c
// Function: subpattern_find
static struct subpattern* subpattern_find(struct subpattern *subpatterns, const unichar *uchars, const int uchars_len)
{
	struct subpattern *subpattern;
	int i;

	subpattern = subpatterns;
	while(subpattern)
	{
		if(subpattern->tag_len == uchars_len)
		{
			for(i = 0; i < uchars_len; i++)
			if(subpattern->tag[i] != uchars[i])
				break;
			if(i == uchars_len)
				return subpattern;
		}
		subpattern = subpattern->nxt;
	}
	return NULL;
}

// Assembly:
testq %rdi, %rdi
je 0x8e85
movq %rdi, %rax
movl %edx, %ecx
cmpl %edx, 0x20(%rax)
jne 0x8e7d
testl %edx, %edx
jle 0x8e77
movq 0x8(%rax), %r8
xorl %edi, %edi
movzwl (%r8,%rdi,2), %r9d
cmpw (%rsi,%rdi,2), %r9w
jne 0x8e79
incq %rdi
cmpq %rdi, %rcx
jne 0x8e61
jmp 0x8e87
xorl %edi, %edi
cmpl %edx, %edi
je 0x8e87
movq (%rax), %rax
testq %rax, %rax
jne 0x8e52
xorl %eax, %eax
retq
// File: /workspace/github_c_makefile_star2_O3/MikeGray-APH[P]LibLouisAPH/source/pattern.c
// Function: pattern_reverse_branch
static void pattern_reverse_branch(unichar *expr_data, const int expr_at)
{
	switch(EXPR_TYPE(expr_at))
	{
	case PTN_ALTERNATE:

#ifdef PATTERN_REVERSE_ALTERNATE_ORDER
		pattern_reverse_expression(expr_data, EXPR_DATA_0(expr_at));
		expr_swap = EXPR_DATA_0(expr_at);
		EXPR_DATA_0(expr_at) = EXPR_DATA_1(expr_at);
		EXPR_DATA_1(expr_at) = expr_swap;
#else
		pattern_reverse_expression(expr_data, EXPR_DATA_1(expr_at));
#endif

	case PTN_GROUP:
	case PTN_NOT:
	case PTN_ONE_MORE:
	case PTN_ZERO_MORE:
	case PTN_OPTIONAL:

		pattern_reverse_expression(expr_data, EXPR_DATA_0(expr_at));
	}
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
movl %esi, %eax
movzwl (%rdi,%rax,2), %eax
leal -0x2(%rax), %ecx
movslq %esi, %r14
cmpl $0x5, %ecx
jae 0x8eb5
movzwl 0x6(%rbx,%r14,2), %esi
movq %rbx, %rdi
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x84e7
cmpl $0x7, %eax
jne 0x8eca
movzwl 0x8(%rbx,%r14,2), %esi
movq %rbx, %rdi
callq 0x84e7
jmp 0x8ea0
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O3/MikeGray-APH[P]LibLouisAPH/source/lookup.c
// Function: lookup_clear
void lookup_clear(void)
{
	table_free(table_list);
	table_list = NULL;
	conversion_free(conversion_list);
	conversion_list = NULL;
	if(table_paths)
	{
		FREE(table_paths);
		table_paths = NULL;
		table_paths_len = 0;
	}
}

// Assembly:
pushq %rbx
movq 0x10e88(%rip), %rdi     # 0x1a250
callq 0x1e96
xorl %ebx, %ebx
movq %rbx, 0x10e7a(%rip)     # 0x1a250
movq 0x10e7b(%rip), %rdi     # 0x1a258
callq 0x2c53
movq %rbx, 0x10e6f(%rip)     # 0x1a258
movq 0x10e70(%rip), %rdi     # 0x1a260
testq %rdi, %rdi
je 0x940f
callq 0x1040
movq $0x0, 0x10e5b(%rip) # 0x1a260
movl $0x0, 0x10e59(%rip)     # 0x1a268
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O3/MikeGray-APH[P]LibLouisAPH/source/lookup.c
// Function: lookup_get_paths
int lookup_get_paths(char *paths, const int paths_max)
{
	int len;

	check_env();

	if(!table_paths)
	{
		paths[0] = 0;
		return 0;
	}

	if(table_paths_len >= paths_max)
		len = paths_max - 1;
	else
		len = table_paths_len;

	memcpy(paths, table_paths, len);
	paths[len] = 0;

	return len;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movl %esi, %r14d
movq %rdi, %rbx
cmpb $0x0, 0x10d79(%rip)     # 0x1a26c
jne 0x952a
movb $0x1, 0x10d70(%rip)     # 0x1a26c
leaq 0xa6bd(%rip), %rdi      # 0x13bc0
callq 0x1030
testq %rax, %rax
je 0x952a
cmpq $0x0, 0x10d4b(%rip)     # 0x1a260
je 0x9574
leaq 0xa67b(%rip), %rsi      # 0x13b99
movl $0x7, %edi
xorl %eax, %eax
callq 0xa278
movq 0x10d2f(%rip), %r13     # 0x1a260
testq %r13, %r13
je 0x955e
movl 0x10d2b(%rip), %r15d    # 0x1a268
leal -0x1(%r14), %ebp
cmpl %r14d, %r15d
cmovll %r15d, %ebp
movslq %ebp, %r14
movq %rbx, %rdi
movq %r13, %rsi
movq %r14, %rdx
callq 0x1180
addq %r14, %rbx
jmp 0x9560
xorl %ebp, %ebp
movb $0x0, (%rbx)
movl %ebp, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %r12
movq %rax, %rdi
callq 0x10b0
movq %rax, %r15
movl %r15d, 0x10cdf(%rip)    # 0x1a268
incl %eax
movslq %eax, %rdi
callq 0x1190
movq %rax, 0x10cc6(%rip)     # 0x1a260
testq %rax, %rax
je 0x95af
movq %rax, %r13
movq %rax, %rdi
movq %r12, %rsi
callq 0x1080
jmp 0x953d
leaq 0x9c86(%rip), %rsi      # 0x1323c
leaq 0xa580(%rip), %rdx      # 0x13b3d
movl $0x7, %edi
movl $0x4a, %ecx
xorl %eax, %eax
callq 0xa278
jmp 0x952a
// File: /workspace/github_c_makefile_star2_O3/MikeGray-APH[P]LibLouisAPH/source/lookup.c
// Function: lookup_set_paths
int lookup_set_paths(const char *paths)
{
	check_env();

	if(table_paths)
		FREE(table_paths);

	if(!paths)
	{
		table_paths = NULL;
		table_paths_len = 0;
		return 1;
	}

	table_paths_len = strlen(paths);
	table_paths = MALLOC(table_paths_len + 1);
	if(!table_paths)
	{
		LOG_ALLOCATE_FAIL
		return 0;
	}
	strcpy(table_paths, paths);

	return table_paths_len;
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rdi, %rbx
cmpb $0x0, 0x10c8a(%rip)     # 0x1a26c
jne 0x961d
movb $0x1, 0x10c81(%rip)     # 0x1a26c
leaq 0xa5ce(%rip), %rdi      # 0x13bc0
callq 0x1030
testq %rax, %rax
je 0x961d
cmpq $0x0, 0x10c5c(%rip)     # 0x1a260
je 0x96b3
leaq 0xa588(%rip), %rsi      # 0x13b99
movl $0x7, %edi
xorl %eax, %eax
callq 0xa278
movq 0x10c3c(%rip), %r15     # 0x1a260
testq %r15, %r15
je 0x9631
movq %r15, %rdi
callq 0x1040
testq %rbx, %rbx
je 0x966b
movq %rbx, %rdi
callq 0x10b0
movq %rax, %r14
movl %r14d, 0x10c20(%rip)    # 0x1a268
incl %eax
movslq %eax, %rdi
callq 0x1190
movq %rax, 0x10c07(%rip)     # 0x1a260
testq %rax, %rax
je 0x9688
movq %rax, %rdi
movq %rbx, %rsi
callq 0x1080
jmp 0x96aa
movq $0x0, 0x10bea(%rip) # 0x1a260
movl $0x0, 0x10be8(%rip)     # 0x1a268
movl $0x1, %r14d
jmp 0x96aa
leaq 0x9bad(%rip), %rsi      # 0x1323c
leaq 0xa4a7(%rip), %rdx      # 0x13b3d
xorl %r14d, %r14d
movl $0x7, %edi
movl $0xab, %ecx
xorl %eax, %eax
callq 0xa278
movl %r14d, %eax
popq %rbx
popq %r14
popq %r15
retq
movq %rax, %r14
movq %rax, %rdi
callq 0x10b0
movl %eax, 0x10ba4(%rip)     # 0x1a268
incl %eax
movslq %eax, %rdi
callq 0x1190
movq %rax, 0x10b8b(%rip)     # 0x1a260
testq %rax, %rax
je 0x96ed
movq %rax, %r15
movq %rax, %rdi
movq %r14, %rsi
callq 0x1080
jmp 0x9629
leaq 0x9b48(%rip), %rsi      # 0x1323c
leaq 0xa442(%rip), %rdx      # 0x13b3d
movl $0x7, %edi
movl $0x4a, %ecx
xorl %eax, %eax
callq 0xa278
jmp 0x961d
// File: /workspace/github_c_makefile_star2_O3/MikeGray-APH[P]LibLouisAPH/source/lookup.c
// Function: lookup_add_paths
int lookup_add_paths(const char *paths)
{
	int len;

	check_env();

	if(!paths)
		return table_paths_len;

	if(!table_paths)
	{
		table_paths_len = strlen(paths);
		table_paths = MALLOC(table_paths_len + 1);
		if(!table_paths)
		{
			LOG_ALLOCATE_FAIL
			return 0;
		}
		strcpy(table_paths, paths);
	}
	else
	{
		len = strlen(paths);
		table_paths_len += len + 1;
		table_paths = REALLOC(table_paths, table_paths_len + 1);
		if(!table_paths)
		{
			LOG_ALLOCATE_FAIL
			return 0;
		}
		strncat(table_paths, PATH_SEPARATOR_STRING, 2);
		strncat(table_paths, paths, len + 1);
	}

	return table_paths_len;
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rdi, %rbx
cmpb $0x0, 0x10b49(%rip)     # 0x1a26c
jne 0x97b3
movb $0x1, 0x10b3c(%rip)     # 0x1a26c
leaq 0xa489(%rip), %rdi      # 0x13bc0
callq 0x1030
testq %rax, %rax
je 0x97b3
cmpq $0x0, 0x10b17(%rip)     # 0x1a260
je 0x9760
leaq 0xa447(%rip), %rsi      # 0x13b99
movl $0x7, %edi
xorl %eax, %eax
callq 0xa278
jmp 0x97b3
movq %rax, %r14
movq %rax, %rdi
callq 0x10b0
movl %eax, 0x10af7(%rip)     # 0x1a268
incl %eax
movslq %eax, %rdi
callq 0x1190
movq %rax, 0x10ade(%rip)     # 0x1a260
testq %rax, %rax
je 0x9794
movq %rax, %rdi
movq %r14, %rsi
callq 0x1080
jmp 0x97b3
leaq 0x9aa1(%rip), %rsi      # 0x1323c
leaq 0xa39b(%rip), %rdx      # 0x13b3d
movl $0x7, %edi
movl $0x4a, %ecx
xorl %eax, %eax
callq 0xa278
testq %rbx, %rbx
je 0x9828
movq 0x10aa1(%rip), %r15     # 0x1a260
movq %rbx, %rdi
callq 0x10b0
movq %rax, %r14
testq %r15, %r15
je 0x9831
movslq %r14d, %r12
movslq 0x10a8f(%rip), %rax     # 0x1a268
leaq (%r12,%rax), %r14
incq %r14
movl %r14d, 0x10a81(%rip)    # 0x1a268
leaq (%r12,%rax), %rsi
addq $0x2, %rsi
movq %r15, %rdi
callq 0x11b0
movq %rax, 0x10a62(%rip)     # 0x1a260
testq %rax, %rax
je 0x985e
movq %rax, %r15
incq %r12
movq %rax, %rdi
callq 0x10b0
movw $0x3a, (%r15,%rax)
movslq %r12d, %rdx
movq %r15, %rdi
movq %rbx, %rsi
callq 0x1120
jmp 0x989d
movl 0x10a39(%rip), %r14d    # 0x1a268
jmp 0x989d
movl %r14d, 0x10a30(%rip)    # 0x1a268
movl %r14d, %eax
incl %eax
movslq %eax, %rdi
callq 0x1190
movq %rax, 0x10a14(%rip)     # 0x1a260
testq %rax, %rax
je 0x987b
movq %rax, %rdi
movq %rbx, %rsi
callq 0x1080
jmp 0x989d
leaq 0x99d7(%rip), %rsi      # 0x1323c
leaq 0xa2d1(%rip), %rdx      # 0x13b3d
xorl %r14d, %r14d
movl $0x7, %edi
movl $0xce, %ecx
jmp 0x9896
leaq 0x99ba(%rip), %rsi      # 0x1323c
leaq 0xa2b4(%rip), %rdx      # 0x13b3d
xorl %r14d, %r14d
movl $0x7, %edi
movl $0xc2, %ecx
xorl %eax, %eax
callq 0xa278
movl %r14d, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O3/MikeGray-APH[P]LibLouisAPH/source/lookup.c
// Function: create_path_file_name
static int create_path_file_name(
	char *path,
	const int path_max,
	const char *paths,
	const int paths_len,
	const char *file_name,
	const int file_name_len)
{
	int len;

	if(paths_len < 1)
		return 0;

	/*   find path separator   */
	for(len = 0; len < paths_len; len++)
	if(paths[len] == PATH_SEPARATOR_CHAR)
		break;

	/*   check space   */
	if(len >= path_max - (file_name_len + 1))
		return 0;

	/*   create path name   */
	ASSERT(len > 0)
	memcpy(path, paths, len);
	path[len] = FILE_SEPARATOR_CHAR;
	strcpy(&path[len + 1], file_name);

	return len;
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
testl %ecx, %ecx
jle 0x9b93
movq %r8, %rbx
movq %rdi, %r15
movl %ecx, %eax
xorl %r14d, %r14d
cmpb $0x3a, (%rdx,%r14)
je 0x9b5d
incq %r14
cmpq %r14, %rax
jne 0x9b4b
movl %eax, %r14d
notl %r9d
addl %esi, %r9d
cmpl %r9d, %r14d
jge 0x9b93
testl %r14d, %r14d
je 0x9ba5
movl %r14d, %r12d
movq %r15, %rdi
movq %rdx, %rsi
movq %r12, %rdx
callq 0x1180
leaq (%r15,%r12), %rdi
incq %rdi
movb $0x2f, -0x1(%rdi)
movq %rbx, %rsi
callq 0x1080
jmp 0x9b96
xorl %r14d, %r14d
movl %r14d, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
callq 0x1060
// File: /workspace/github_c_makefile_star2_O3/MikeGray-APH[P]LibLouisAPH/source/languages/generic-common.c
// Function: generic_insert_marked
int generic_insert_marked(struct translate *translate, const unichar *indicator, const int indicator_len, const unichar delimiter)
{
	CHANGE_MARK

	if(delimiter)
	if(!translate_insert_dot(translate, delimiter))
		return 0;

	if(!translate_insert_dots(translate, indicator, indicator_len))
		return 0;

	if(delimiter)
	if(!translate_insert_dot(translate, delimiter))
		return 0;

	return 1;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x10, %rsp
movl %edx, %r15d
movq %rsi, %r12
movq %rdi, %r14
movl $0x1, 0x94(%rdi)
testl %ecx, %ecx
je 0xa8f1
movl %ecx, %ebp
leaq 0xc(%rsp), %rsi
movw %bp, (%rsi)
movq %r14, %rdi
movl $0x1, %edx
callq 0x7272
xorl %ebx, %ebx
testl %eax, %eax
je 0xa90c
movq %r14, %rdi
movq %r12, %rsi
movl %r15d, %edx
callq 0x7272
testl %eax, %eax
je 0xa90c
leaq 0xe(%rsp), %rsi
movw %bp, (%rsi)
movq %r14, %rdi
movl $0x1, %edx
callq 0x7272
testl %eax, %eax
jne 0xa903
jmp 0xa90c
movq %r14, %rdi
movq %r12, %rsi
movl %r15d, %edx
callq 0x7272
testl %eax, %eax
je 0xa90a
movl $0x1, %ebx
jmp 0xa90c
xorl %ebx, %ebx
movl %ebx, %eax
addq $0x10, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq