LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O2/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 %rax
xorl %eax, %eax
negl %edx
sbbl %eax, %eax
movslq 0x40(%rdi), %rdx
movslq %esi, %rcx
addq %rdx, %rcx
cmpl 0x44(%rdi), %ecx
jge 0x6b07
movq 0x50(%rdi), %rsi
movslq (%rsi,%rcx,4), %rcx
testq %rcx, %rcx
js 0x6b05
orl 0x68(%rdi), %eax
testl %edx, %edx
je 0x6ad2
movl -0x4(%rsi,%rdx,4), %r8d
cmpl (%rsi,%rdx,4), %r8d
je 0x6b05
movq 0x48(%rdi), %rdx
cmpl $0x0, (%rdx,%rcx,4)
js 0x6b05
movq %rcx, %rsi
leal 0x1(%rsi), %r8d
cmpl %r8d, 0x20(%rdi)
jle 0x6b02
movl 0x4(%rdx,%rsi,4), %r8d
testl %r8d, %r8d
js 0x6b02
cmpl (%rdx,%rcx,4), %r8d
jne 0x6b02
movl %eax, 0x4(%rdx,%rsi,4)
incq %rsi
jmp 0x6adf
movl %eax, (%rdx,%rcx,4)
popq %rax
retq
callq 0x1060
// File: /workspace/github_c_makefile_star2_O2/MikeGray-APH[P]LibLouisAPH/source/translate.c
// Function: translate_copy_to_output
int translate_copy_to_output(struct translate *translate, const int count, const int do_map)
{
	int cnt, i;

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

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

	for(i = 0; i < cnt; i++)
	{
		ASSERT(translate->output_len + i < translate->output_max)
		translate->output[translate->output_len + i] = translate->input[translate->input_crs + i];
		translate->output_mask[translate->output_len + i] = translate->input_mask[translate->input_crs + i];
		if(translate->maps_use)
		if(do_map)
		{
			translate->output_to_input_map[translate->output_len + i] = translate->input_map[translate->input_crs + i];
			translate_remap_input(translate, i, 0);
		}
		else
		{
			translate->output_to_input_map[translate->output_len + i] = -1;
			translate_remap_input(translate, i, 1);
		}
	}

	translate_increment(translate, cnt, cnt);

	return 1;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movl %edx, %ebp
movq %rdi, %rbx
movl 0x40(%rdi), %eax
movl 0x44(%rdi), %ecx
movl %ecx, %r14d
subl %eax, %r14d
addl %esi, %eax
cmpl %ecx, %eax
cmovlel %esi, %r14d
movl %r14d, %esi
callq 0x67c5
testl %eax, %eax
je 0x6bf4
xorl %r15d, %r15d
testl %r14d, %r14d
movl $0x0, %r12d
cmovgl %r14d, %r12d
pushq $-0x1
popq %r13
cmpl %r15d, %r12d
je 0x6be1
movslq 0x68(%rbx), %rax
leal (%r15,%rax), %ecx
cmpl 0x6c(%rbx), %ecx
jge 0x6c05
movslq 0x40(%rbx), %rcx
leaq (%r15,%rcx), %rdx
movq 0x38(%rbx), %rsi
movq 0x60(%rbx), %rdi
movzwl (%rsi,%rdx,2), %edx
leaq (%r15,%rax), %rsi
movw %dx, (%rdi,%rsi,2)
addq 0x58(%rbx), %rcx
addq 0x80(%rbx), %rax
movb (%r15,%rcx), %cl
movb %cl, (%r15,%rax)
cmpl $0x0, 0x90(%rbx)
je 0x6bd9
movl %r13d, %eax
pushq $0x1
popq %rdx
testl %ebp, %ebp
je 0x6bc0
movq 0x50(%rbx), %rax
movslq 0x40(%rbx), %rcx
addq %r15, %rcx
movl (%rax,%rcx,4), %eax
xorl %edx, %edx
movq 0x78(%rbx), %rcx
movslq 0x68(%rbx), %rsi
addq %r15, %rsi
movl %eax, (%rcx,%rsi,4)
movq %rbx, %rdi
movl %r15d, %esi
callq 0x6a9d
incq %r15
jmp 0x6b54
movq %rbx, %rdi
movl %r14d, %esi
movl %r14d, %edx
callq 0x68f9
pushq $0x1
popq %rax
jmp 0x6bf6
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
callq 0x1060
// File: /workspace/github_c_makefile_star2_O2/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), %rcx
movq (%rdi), %rdx
movq 0x38(%rdi), %rax
movq -0x8(%rdx,%rcx,8), %rsi
movslq 0x40(%rdi), %rdx
movzwl (%rax,%rdx,2), %ecx
cmpw 0x1e8(%rsi), %cx
je 0x6c3d
cmpw 0x1ea(%rsi), %cx
je 0x6c3d
cmpw 0x1ec(%rsi), %cx
jne 0x6c68
movslq 0x44(%rdi), %r8
incq %rdx
pushq $0x2
popq %r9
movl %r9d, %esi
cmpq %r8, %rdx
jge 0x6c61
leal 0x1(%rsi), %r9d
leaq 0x1(%rdx), %r10
cmpw %cx, (%rax,%rdx,2)
movq %r10, %rdx
jne 0x6c48
xorl %edx, %edx
jmp 0x6b0c
pushq $-0x1
popq %rax
retq
// File: /workspace/github_c_makefile_star2_O2/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), %rcx
movq (%rdi), %rdx
movq 0x38(%rdi), %rax
movq -0x8(%rdx,%rcx,8), %rsi
movslq 0x40(%rdi), %rdx
movzwl (%rax,%rdx,2), %ecx
cmpw 0x1f0(%rsi), %cx
je 0x6c96
cmpw 0x1f2(%rsi), %cx
jne 0x6cc1
movslq 0x44(%rdi), %r8
incq %rdx
pushq $0x2
popq %r9
movl %r9d, %esi
cmpq %r8, %rdx
jge 0x6cba
leal 0x1(%rsi), %r9d
leaq 0x1(%rdx), %r10
cmpw %cx, (%rax,%rdx,2)
movq %r10, %rdx
jne 0x6ca1
xorl %edx, %edx
jmp 0x6b0c
pushq $-0x1
popq %rax
retq
// File: /workspace/github_c_makefile_star2_O2/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), %rcx
movq (%rdi), %rdx
movq 0x38(%rdi), %rax
movq -0x8(%rdx,%rcx,8), %rsi
movslq 0x40(%rdi), %rdx
movzwl (%rax,%rdx,2), %ecx
cmpw 0x1ee(%rsi), %cx
je 0x6cf8
cmpw 0x1f0(%rsi), %cx
je 0x6cf8
cmpw 0x1f2(%rsi), %cx
jne 0x6d24
movslq 0x44(%rdi), %r8
incq %rdx
pushq $0x2
popq %r9
movl %r9d, %esi
cmpq %r8, %rdx
jge 0x6d1c
leal 0x1(%rsi), %r9d
leaq 0x1(%rdx), %r10
cmpw %cx, (%rax,%rdx,2)
movq %r10, %rdx
jne 0x6d03
pushq $0x1
popq %rdx
jmp 0x6b0c
pushq $-0x1
popq %rax
retq
// File: /workspace/github_c_makefile_star2_O2/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)
andl $0x0, 0x40(%rbx)
movslq 0x6c(%rbx), %r14
leaq (%r14,%r14), %rsi
pushq $0x1
popq %rdi
callq 0x1150
movq %rax, 0x60(%rbx)
testq %rax, %rax
je 0x6dda
andl $0x0, 0x68(%rbx)
pushq $0x1
popq %rdi
movq %r14, %rsi
callq 0x1150
movq %rax, 0x80(%rbx)
testq %rax, %rax
je 0x6dfb
pushq $0x1
popq %rbp
cmpl $0x0, 0x90(%rbx)
je 0x6e1b
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 0x6e22
movq %rax, %rdi
movl $0xff, %esi
movq %r14, %rdx
callq 0x1110
jmp 0x6e1b
leaq 0xa45b(%rip), %rsi      # 0x1123c
leaq 0xac28(%rip), %rdx      # 0x11a10
xorl %ebp, %ebp
pushq $0x7
popq %rdi
movl $0x134, %ecx            # imm = 0x134
xorl %eax, %eax
callq 0x9174
jmp 0x6e1b
leaq 0xa43a(%rip), %rsi      # 0x1123c
leaq 0xac07(%rip), %rdx      # 0x11a10
pushq $0x7
popq %rdi
movl $0x13d, %ecx            # imm = 0x13D
xorl %eax, %eax
callq 0x9174
pushq $-0x1
popq %rbp
movl %ebp, %eax
popq %rbx
popq %r14
popq %rbp
retq
leaq 0xa413(%rip), %rsi      # 0x1123c
leaq 0xabe0(%rip), %rdx      # 0x11a10
xorl %ebp, %ebp
pushq $0x7
popq %rdi
movl $0x14b, %ecx            # imm = 0x14B
jmp 0x6df2
// File: /workspace/github_c_makefile_star2_O2/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 0x748f
pushq %rbx
movq %rdi, %rbx
movq (%rdi), %rdi
callq 0x745a
movq 0x8(%rbx), %rdi
callq 0x1040
movq 0x10(%rbx), %rdi
callq 0x1040
movq 0x18(%rbx), %rdi
callq 0x1040
movq %rbx, %rdi
popq %rbx
jmp 0x1040
retq
// File: /workspace/github_c_makefile_star2_O2/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 %r12
pushq %rbx
subq $0x10, %rsp
movq %r9, %r14
movl %ecx, %r15d
movq %rdx, %r12
movl %esi, %ebp
movq %rdi, %rbx
movq %r8, %rdi
callq 0x7524
leaq 0xc(%rsp), %rdx
andl $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 0x755d
popq %rcx
popq %rdx
xorl %r14d, %r14d
testl %eax, %eax
je 0x7514
addw $0x3, (%rbx)
pushq $0x2
popq %rsi
movq %rbx, %rdi
movl %ebp, %edx
movq %rbx, %rcx
callq 0x7637
testl %eax, %eax
je 0x7514
pushq $0x2
popq %rsi
movq %rbx, %rdi
movl %ebp, %edx
movq %rbx, %rcx
callq 0x7729
testl %eax, %eax
je 0x7514
movzwl (%rbx), %r14d
movl %r14d, %eax
addq $0x10, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/MikeGray-APH[P]LibLouisAPH/source/pattern-private.h
// Function: set_attrs_chars
static void set_attrs_chars(const char *cchars)
{
	int len, i;

	if(cchars)
	{
		len = strlen(cchars);
		if(len > 32)
			len = 32;
		for(i = 0; i < len; i++)
			attrs_chars[i] = cchars[i];
	}
}

// Assembly:
testq %rdi, %rdi
je 0x755c
pushq %rbx
movq %rdi, %rbx
callq 0x10b0
cmpl $0x20, %eax
pushq $0x20
popq %rcx
cmovll %eax, %ecx
xorl %eax, %eax
testl %ecx, %ecx
cmovlel %eax, %ecx
leaq 0xfbc7(%rip), %rdx      # 0x17110
cmpq %rax, %rcx
je 0x755b
movb (%rbx,%rax), %sil
movb %sil, (%rax,%rdx)
incq %rax
jmp 0x7549
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O2/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, %r14
movq %rdi, (%rsp)
movzwl (%r9), %eax
leal 0x6(%rax), %ecx
cmpl %r8d, %ecx
jge 0x7622
movq %r9, %rbx
movl %r8d, %ebp
movq %rdx, %r15
movl %esi, %r12d
movw $0x1, (%r14,%rax,2)
movzwl (%r9), %ecx
orw $-0x1, 0x2(%r14,%rcx,2)
movzwl (%r9), %ecx
addl $0x3, %ecx
movw %cx, (%r9)
movw %cx, 0x4(%r14,%rax,2)
movzwl (%r9), %ecx
orw $-0x1, (%r14,%rcx,2)
movzwl (%r9), %ecx
movw %ax, 0x2(%r14,%rcx,2)
movzwl (%rbx), %eax
orw $-0x1, 0x4(%r14,%rax,2)
movzwl (%rbx), %eax
movzwl %ax, %r13d
cmpl %r12d, (%r15)
jge 0x7625
movq (%rsp), %rdi
movl %r12d, %esi
movq %r15, %rdx
movq %r14, %rcx
movl %ebp, %r8d
movq %rbx, %r9
pushq 0x48(%rsp)
pushq 0x48(%rsp)
callq 0x7ad8
popq %rcx
popq %rdx
testl %eax, %eax
je 0x7622
movzwl (%rbx), %eax
leal 0x3(%rax), %ecx
cmpl %ebp, %ecx
jae 0x7622
movw %ax, 0x4(%r14,%r13,2)
movzwl (%rbx), %eax
orw $-0x1, (%r14,%rax,2)
movzwl (%rbx), %eax
movw %r13w, 0x2(%r14,%rax,2)
jmp 0x75c2
xorl %r13d, %r13d
movl %r13d, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/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 %r12
pushq %rbx
movq %rcx, %rbx
movl %edx, %ebp
movq %rdi, %r14
pushq $0x1
popq %r15
movl %esi, %r12d
movzwl (%r14,%r12,2), %eax
movzwl %ax, %ecx
leal -0x2(%rcx), %edx
cmpl $0x2, %edx
jae 0x7683
movslq %r12d, %rax
movzwl 0x6(%r14,%rax,2), %esi
movq %r14, %rdi
movl %ebp, %edx
movq %rbx, %rcx
callq 0x7637
testl %eax, %eax
je 0x7719
movzwl (%r14,%r12,2), %eax
jmp 0x768f
cmpl $0xffff, %ecx           # imm = 0xFFFF
je 0x771d
addl $-0x4, %eax
cmpw $0x3, %ax
jae 0x770b
movzwl (%rbx), %edx
leal 0x6(%rdx), %ecx
xorl %eax, %eax
cmpl %ebp, %ecx
jge 0x7720
movslq %r12d, %rcx
movzwl 0x2(%r14,%rcx,2), %esi
cmpw $0x1, (%r14,%rsi,2)
je 0x7720
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
orw $-0x1, (%r14,%rdi,2)
movw %si, 0x2(%r14,%rdi,2)
movw %r12w, 0x4(%r14,%rdi,2)
addw $0x3, (%rbx)
movw %dx, 0x6(%r14,%rcx,2)
movw %r12w, 0x4(%r14,%rax,2)
movw %ax, 0x2(%r14,%rcx,2)
movw %dx, 0x2(%r14,%rsi,2)
movw %di, 0x4(%r14,%rsi,2)
jmp 0x770e
movslq %r12d, %rcx
movzwl 0x4(%r14,%rcx,2), %esi
jmp 0x764b
xorl %eax, %eax
jmp 0x7720
movl %r15d, %eax
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/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
pushq %rax
movslq %esi, %rax
movzwl 0x4(%rdi,%rax,2), %r15d
movzwl (%rdi,%r15,2), %ecx
cmpw $-0x1, %cx
je 0x79d4
movq %rdi, %rbx
movzwl %r15w, %r12d
cmpw $-0x1, %cx
je 0x7946
movzwl 0x4(%rbx,%r12,2), %r15d
movzwl (%rbx,%r15,2), %ecx
jmp 0x792f
movzwl 0x2(%rbx,%r12,2), %ebp
movl %esi, 0x4(%rsp)
movzwl %bp, %esi
movzwl 0x2(%rbx,%rsi,2), %r13d
movw %si, 0x4(%rbx,%rax,2)
movw %ax, 0x2(%rbx,%rsi,2)
movw %r13w, 0x4(%rbx,%rsi,2)
movq %rbx, %rdi
callq 0x8295
movl %ebp, %edx
movl 0x4(%rsp), %ecx
movzwl %r13w, %r14d
cmpl %ecx, %r14d
je 0x79b3
movzwl 0x2(%rbx,%r14,2), %ebp
movq %rbx, %rdi
movl %r14d, %esi
callq 0x8295
movl 0x4(%rsp), %ecx
cmpl %ecx, %ebp
je 0x79b9
movzwl 0x4(%rbx,%r14,2), %eax
movw %ax, 0x2(%rbx,%r14,2)
movw %bp, 0x4(%rbx,%r14,2)
movl %r13d, %edx
movl %ebp, %r13d
jmp 0x7977
movzwl %dx, %r14d
jmp 0x79bc
movl %r13d, %edx
movzwl 0x4(%rbx,%r14,2), %eax
movw %ax, 0x2(%rbx,%r14,2)
movw %r15w, 0x4(%rbx,%r14,2)
movw %dx, 0x2(%rbx,%r12,2)
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/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, %r15
movq %rdi, %r12
movq 0x40(%rsp), %rdi
leaq 0x4(%rsp), %r13
movl %edx, (%r13)
callq 0x7524
movq %r12, 0x11839(%rip)     # 0x19250
andl $0x0, 0x1183a(%rip)     # 0x19258
movq %r15, %rdi
movq %r13, %rsi
movl %r14d, %edx
movl %ebp, %ecx
movq %rbx, %r8
movq 0x48(%rsp), %r9
callq 0x7a45
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/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, %r14
movl %ecx, %ebp
movl %edx, %r12d
movq %rsi, %r13
movq %rdi, %rbx
movzwl 0x2(%r8), %esi
shll $0x2, %esi
pushq $0x1
popq %rdi
callq 0x1150
testq %rax, %rax
je 0x7aaa
movq %rax, %r15
movq %rbx, %rdi
movq %r13, %rsi
movl %r12d, %edx
movl %ebp, %ecx
movq %r14, %r8
movq (%rsp), %r9
pushq %rax
pushq $0x0
pushq $0x0
pushq $0x2
callq 0x82df
addq $0x20, %rsp
movl %eax, %ebx
movq %r15, %rdi
callq 0x1040
movl %ebx, %eax
jmp 0x7ac9
leaq 0x978b(%rip), %rsi      # 0x1123c
leaq 0x9fe4(%rip), %rdx      # 0x11a9c
pushq $0x7
popq %rdi
movl $0x53d, %ecx            # imm = 0x53D
xorl %eax, %eax
callq 0x9174
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_O2/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:
movq %rdi, %rax
xorl %ecx, %ecx
testl %edx, %edx
cmovgl %edx, %ecx
testq %rax, %rax
je 0x8294
cmpl %edx, 0x20(%rax)
jne 0x828f
xorl %edi, %edi
cmpq %rdi, %rcx
je 0x8289
movq 0x8(%rax), %r8
movzwl (%r8,%rdi,2), %r8d
cmpw (%rsi,%rdi,2), %r8w
jne 0x828b
incq %rdi
jmp 0x826f
movl %ecx, %edi
cmpl %edx, %edi
je 0x8294
movq (%rax), %rax
jmp 0x8263
retq
// File: /workspace/github_c_makefile_star2_O2/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 0x82c2
movzwl 0x6(%rbx,%r14,2), %esi
movq %rbx, %rdi
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x7909
cmpl $0x7, %eax
jne 0x82d7
movzwl 0x8(%rbx,%r14,2), %esi
movq %rbx, %rdi
callq 0x7909
jmp 0x82ad
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O2/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 %rax
movq 0x10ad0(%rip), %rdi     # 0x19260
callq 0x1def
andq $0x0, 0x10ac3(%rip)     # 0x19260
movq 0x10ac4(%rip), %rdi     # 0x19268
callq 0x2b25
andq $0x0, 0x10ab7(%rip)     # 0x19268
movq 0x10ab8(%rip), %rdi     # 0x19270
testq %rdi, %rdi
je 0x87d1
callq 0x1040
andq $0x0, 0x10aa6(%rip)     # 0x19270
andl $0x0, 0x10aa7(%rip)     # 0x19278
popq %rax
retq
// File: /workspace/github_c_makefile_star2_O2/MikeGray-APH[P]LibLouisAPH/source/lookup.c
// Function: check_env
static inline void check_env(void)
{
	if(env_checked)
		return;
	env_checked = 1;
	lookup_env();
}

// Assembly:
pushq %rbx
cmpb $0x0, 0x10a6c(%rip)     # 0x1927c
jne 0x8846
movb $0x1, 0x10a63(%rip)     # 0x1927c
leaq 0x9310(%rip), %rdi      # 0x11b30
callq 0x1030
testq %rax, %rax
je 0x8846
cmpq $0x0, 0x10a3e(%rip)     # 0x19270
je 0x8848
leaq 0x92ce(%rip), %rsi      # 0x11b09
pushq $0x7
popq %rdi
xorl %eax, %eax
popq %rbx
jmp 0x9174
popq %rbx
retq
movq %rax, %rbx
movq %rax, %rdi
callq 0x10b0
movl %eax, 0x10a1f(%rip)     # 0x19278
incl %eax
movslq %eax, %rdi
callq 0x1190
movq %rax, 0x10a06(%rip)     # 0x19270
testq %rax, %rax
je 0x887b
movq %rax, %rdi
movq %rbx, %rsi
popq %rbx
jmp 0x1080
leaq 0x89ba(%rip), %rsi      # 0x1123c
leaq 0x9224(%rip), %rdx      # 0x11aad
pushq $0x7
popq %rdi
pushq $0x4a
popq %rcx
xorl %eax, %eax
popq %rbx
jmp 0x9174
// File: /workspace/github_c_makefile_star2_O2/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 %r14
pushq %rbx
movl %esi, %r14d
movq %rdi, %rbx
callq 0x8808
movq 0x109c3(%rip), %rsi     # 0x19270
testq %rsi, %rsi
je 0x88d5
movl 0x109c0(%rip), %eax     # 0x19278
leal -0x1(%r14), %ebp
cmpl %r14d, %eax
cmovll %eax, %ebp
movslq %ebp, %r14
movq %rbx, %rdi
movq %r14, %rdx
callq 0x1180
addq %r14, %rbx
jmp 0x88d7
xorl %ebp, %ebp
movb $0x0, (%rbx)
movl %ebp, %eax
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/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 %r14
pushq %rbx
pushq %rax
movq %rdi, %r14
callq 0x8808
movq 0x1097c(%rip), %rdi     # 0x19270
callq 0x1040
testq %r14, %r14
je 0x8932
movq %r14, %rdi
callq 0x10b0
movq %rax, %rbx
movl %ebx, 0x10969(%rip)     # 0x19278
incl %eax
movslq %eax, %rdi
callq 0x1190
movq %rax, 0x10950(%rip)     # 0x19270
testq %rax, %rax
je 0x8946
movq %rax, %rdi
movq %r14, %rsi
callq 0x1080
jmp 0x8965
andq $0x0, 0x10936(%rip)     # 0x19270
andl $0x0, 0x10937(%rip)     # 0x19278
pushq $0x1
popq %rbx
jmp 0x8965
leaq 0x88ef(%rip), %rsi      # 0x1123c
leaq 0x9159(%rip), %rdx      # 0x11aad
xorl %ebx, %ebx
pushq $0x7
popq %rdi
movl $0xab, %ecx
xorl %eax, %eax
callq 0x9174
movl %ebx, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O2/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, %r14
callq 0x8808
testq %r14, %r14
je 0x89f3
movq 0x108e5(%rip), %r15     # 0x19270
movq %r14, %rdi
callq 0x10b0
movq %rax, %rbx
testq %r15, %r15
je 0x89fb
movslq %ebx, %r12
movslq 0x108d3(%rip), %rax     # 0x19278
leaq (%r12,%rax), %rbx
incq %rbx
movl %ebx, 0x108c6(%rip)     # 0x19278
leaq (%r12,%rax), %rsi
addq $0x2, %rsi
movq %r15, %rdi
callq 0x11c0
movq %rax, 0x108a7(%rip)     # 0x19270
testq %rax, %rax
je 0x8a26
movq %rax, %r15
incq %r12
movq %rax, %rdi
callq 0x10b0
movw $0x3a, (%r15,%rax)
movslq %r12d, %rdx
movq %r15, %rdi
movq %r14, %rsi
callq 0x1120
jmp 0x8a5f
movl 0x1087f(%rip), %ebx     # 0x19278
jmp 0x8a5f
movl %ebx, 0x10877(%rip)     # 0x19278
movl %ebx, %eax
incl %eax
movslq %eax, %rdi
callq 0x1190
movq %rax, 0x1085c(%rip)     # 0x19270
testq %rax, %rax
je 0x8a40
movq %rax, %rdi
movq %r14, %rsi
callq 0x1080
jmp 0x8a5f
leaq 0x880f(%rip), %rsi      # 0x1123c
leaq 0x9079(%rip), %rdx      # 0x11aad
xorl %ebx, %ebx
pushq $0x7
popq %rdi
movl $0xce, %ecx
jmp 0x8a58
leaq 0x87f5(%rip), %rsi      # 0x1123c
leaq 0x905f(%rip), %rdx      # 0x11aad
xorl %ebx, %ebx
pushq $0x7
popq %rdi
movl $0xc2, %ecx
xorl %eax, %eax
callq 0x9174
movl %ebx, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O2/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 0x8c6d
movq %r8, %rbx
movq %rdi, %r15
movl %ecx, %eax
xorl %r14d, %r14d
cmpq %r14, %rax
je 0x8c34
cmpb $0x3a, (%rdx,%r14)
je 0x8c37
incq %r14
jmp 0x8c23
movl %eax, %r14d
notl %r9d
addl %esi, %r9d
cmpl %r9d, %r14d
jge 0x8c6d
testl %r14d, %r14d
je 0x8c7f
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 0x8c70
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_O2/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
movl %ecx, %ebp
movl %edx, %r15d
movq %rsi, %r12
movq %rdi, %rbx
movl $0x1, 0x94(%rdi)
movzwl %bp, %r14d
testl %ecx, %ecx
je 0x9794
movq %rbx, %rdi
movl %r14d, %esi
callq 0x97d2
testl %eax, %eax
je 0x97c3
movq %rbx, %rdi
movq %r12, %rsi
movl %r15d, %edx
callq 0x693d
xorl %r15d, %r15d
testl %eax, %eax
je 0x97c6
testw %bp, %bp
je 0x97bd
movq %rbx, %rdi
movl %r14d, %esi
callq 0x97d2
testl %eax, %eax
je 0x97c6
pushq $0x1
popq %r15
jmp 0x97c6
xorl %r15d, %r15d
movl %r15d, %eax
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/MikeGray-APH[P]LibLouisAPH/source/languages/generic-common.c
// Function: generic_remove_internal
int generic_remove_internal(struct translate *translate)
{
	const struct table *table;
	int off, crs;

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

	off =
	crs = 0;
	while(off < translate->input_len)
	{
		if(translate->input[off] == table->marker_internal)
		{
			off = get_next_delimiter(translate, off, table->marker_internal);
			if(!off)
				return 0;
			CHANGE_MARK
		}
		else
		{
			translate->output[crs] = translate->input[off];
			translate->output_mask[crs] = translate->input_mask[off];
			if(translate->maps_use)
				translate->output_to_input_map[crs] = translate->input_map[off];
			off++;
			crs++;
			if(crs >= translate->output_max)
				return 0;
		}
	}

	translate->output_len = crs;

#ifdef DEBUG
	translate->output[translate->output_len] = 0;
#endif

	return 1;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
movq (%rdi), %rax
movslq 0xc(%rdi), %rcx
movq -0x8(%rax,%rcx,8), %r14
decq %rcx
movl %ecx, 0x8(%rdi)
xorl %eax, %eax
xorl %ebp, %ebp
movl 0x44(%rbx), %r15d
movl %ebp, %ecx
cmpl %r15d, %eax
jge 0x9884
movq 0x38(%rbx), %rsi
movslq %eax, %rdx
movzwl (%rsi,%rdx,2), %esi
cmpw 0x1f4(%r14), %si
jne 0x9845
movzwl %si, %edx
movq %rbx, %rdi
movl %eax, %esi
callq 0x989e
testl %eax, %eax
je 0x9880
movl $0x1, 0x94(%rbx)
jmp 0x980c
movq 0x60(%rbx), %rdi
movw %si, (%rdi,%rcx,2)
movq 0x58(%rbx), %rsi
movq 0x80(%rbx), %rdi
movb (%rsi,%rdx), %sil
movb %sil, (%rdi,%rcx)
cmpl $0x0, 0x90(%rbx)
je 0x9877
movq 0x50(%rbx), %rsi
movq 0x78(%rbx), %rdi
movl (%rsi,%rdx,4), %edx
movl %edx, (%rdi,%rcx,4)
incl %eax
incl %ebp
cmpl 0x6c(%rbx), %ebp
jl 0x9808
xorl %eax, %eax
jmp 0x9893
movl %ebp, 0x68(%rbx)
movq 0x60(%rbx), %rax
andw $0x0, (%rax,%rcx,2)
pushq $0x1
popq %rax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/MikeGray-APH[P]LibLouisAPH/source/languages/generic-common.c
// Function: get_next_delimiter
static inline int get_next_delimiter(struct translate *translate, const int at, const unichar delimiter)
{
	int off;

	for(off = at + 1; off < translate->input_len; off++)
	if(translate->input[off] == delimiter)
		break;
	if(off >= translate->input_len)
		return 0;
	return off + 1;
}

// Assembly:
movslq 0x44(%rdi), %rcx
movslq %esi, %rax
leal 0x2(%rax), %r9d
incq %rax
movl %r9d, %esi
movq %rax, %r8
cmpq %rcx, %rax
jge 0x98ca
movq 0x38(%rdi), %r10
leal 0x1(%rsi), %r9d
leaq 0x1(%r8), %rax
cmpw %dx, (%r10,%r8,2)
jne 0x98ac
xorl %eax, %eax
cmpq %rcx, %r8
cmovll %esi, %eax
retq
// File: /workspace/github_c_makefile_star2_O2/MikeGray-APH[P]LibLouisAPH/source/languages/generic-common.c
// Function: generic_remove_modifier_delimiters
int generic_remove_modifier_delimiters(struct translate *translate)
{
	const struct table *table;

	/*   only remove indicators contained in last table in tables   */
	table = translate->tables[translate->table_cnt - 1];
	translate->table_crs = translate->table_cnt - 1;

	translate->input_crs =
	translate->output_len = 0;
	while(translate->input_crs < translate->input_len)
	{
		if(translate->input[translate->input_crs] == table->marker_modifier)
		{
			CHANGE_MARK
			if(!translate_skip(translate, 1, 0))
				return 0;
		}
		else if(!translate_copy_to_output(translate, 1, 1))
				return 0;
	}

#ifdef DEBUG
	translate->output[translate->output_len] = 0;
#endif

	return 1;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
movq (%rdi), %rax
movslq 0xc(%rdi), %rcx
movq -0x8(%rax,%rcx,8), %r15
decq %rcx
movl %ecx, 0x8(%rdi)
andl $0x0, 0x68(%rdi)
andl $0x0, 0x40(%rdi)
xorl %eax, %eax
pushq $0x1
popq %rbp
xorl %r14d, %r14d
cmpl 0x44(%rbx), %eax
jge 0x99ff
movq 0x38(%rbx), %rcx
cltq
movzwl (%rcx,%rax,2), %eax
cmpw 0x1ee(%r15), %ax
jne 0x99ea
movl $0x1, 0x94(%rbx)
movq %rbx, %rdi
movl %ebp, %esi
xorl %edx, %edx
callq 0x6885
testl %eax, %eax
jne 0x99fa
jmp 0x9a14
movq %rbx, %rdi
movl %ebp, %esi
movl %ebp, %edx
callq 0x6b0c
testl %eax, %eax
je 0x9a11
movl 0x40(%rbx), %eax
jmp 0x99b5
movq 0x60(%rbx), %rax
movslq 0x68(%rbx), %rcx
andw $0x0, (%rax,%rcx,2)
movl %ebp, %r14d
jmp 0x9a14
xorl %r14d, %r14d
movl %r14d, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/MikeGray-APH[P]LibLouisAPH/source/languages/generic-common.c
// Function: generic_remove_hard_and_modifier_delimiters
int generic_remove_hard_and_modifier_delimiters(struct translate *translate)
{
	const struct table *table;

	/*   only remove indicators contained in last table in tables   */
	table = translate->tables[translate->table_cnt - 1];
	translate->table_crs = translate->table_cnt - 1;

	translate->input_crs =
	translate->output_len = 0;
	while(translate->input_crs < translate->input_len)
	{
		if(   translate->input[translate->input_crs] == table->marker_modifier
		   || translate->input[translate->input_crs] == table->marker_hard)
		{
			CHANGE_MARK
			if(!translate_skip(translate, 1, 0))
				return 0;
		}
		else if(!translate_copy_to_output(translate, 1, 1))
			return 0;
	}

#ifdef DEBUG
	translate->output[translate->output_len] = 0;
#endif

	return 1;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
movq (%rdi), %rax
movslq 0xc(%rdi), %rcx
movq -0x8(%rax,%rcx,8), %r15
decq %rcx
movl %ecx, 0x8(%rdi)
andl $0x0, 0x68(%rdi)
andl $0x0, 0x40(%rdi)
xorl %eax, %eax
pushq $0x1
popq %rbp
xorl %r14d, %r14d
cmpl 0x44(%rbx), %eax
jge 0x9aa2
movq 0x38(%rbx), %rcx
cltq
movzwl (%rcx,%rax,2), %eax
cmpw 0x1ee(%r15), %ax
je 0x9a71
cmpw 0x1f0(%r15), %ax
jne 0x9a8d
movl $0x1, 0x94(%rbx)
movq %rbx, %rdi
movl %ebp, %esi
xorl %edx, %edx
callq 0x6885
testl %eax, %eax
jne 0x9a9d
jmp 0x9ab2
movq %rbx, %rdi
movl %ebp, %esi
movl %ebp, %edx
callq 0x6b0c
testl %eax, %eax
je 0x9ac0
movl 0x40(%rbx), %eax
jmp 0x9a4e
movq 0x60(%rbx), %rax
movslq 0x68(%rbx), %rcx
andw $0x0, (%rax,%rcx,2)
movl %ebp, %r14d
movl %r14d, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
xorl %r14d, %r14d
jmp 0x9ab2
// File: /workspace/github_c_makefile_star2_O2/MikeGray-APH[P]LibLouisAPH/source/languages/generic-forward.c
// Function: is_marked_equal_to_at
static int is_marked_equal_to_at(const struct translate *translate, const unichar *name, const int name_len, const int at)
{
	int i;

	/*   at least this much should be left   */
	if(name_len + 2 > translate->input_len - at)
		return 0;

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

	return translate->input[at + 1 + i] == translate->input[at];
}

// Assembly:
leal 0x2(%rdx), %eax
movl 0x44(%rdi), %r8d
subl %ecx, %r8d
cmpl %r8d, %eax
jle 0xc5c7
xorl %eax, %eax
retq
pushq %rbx
leal 0x1(%rcx), %eax
movslq %eax, %r8
xorl %r9d, %r9d
testl %edx, %edx
cmovlel %r9d, %edx
addq %r8, %r8
cmpq %r9, %rdx
je 0xc5fd
movzwl (%rsi,%r9,2), %r10d
movq 0x38(%rdi), %r11
addq %r8, %r11
leaq 0x1(%r9), %rbx
cmpw (%r11,%r9,2), %r10w
movq %rbx, %r9
je 0xc5da
xorl %eax, %eax
jmp 0xc615
movq 0x38(%rdi), %rsi
addl %edx, %eax
cltq
movzwl (%rsi,%rax,2), %edx
movslq %ecx, %rcx
xorl %eax, %eax
cmpw (%rsi,%rcx,2), %dx
sete %al
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O2/MikeGray-APH[P]LibLouisAPH/source/languages/generic-forward.c
// Function: insert_indicator_nodes
static int insert_indicator_nodes(struct translate *translate, const struct table *table, struct indicator_node *node)
{
	if(!node)
		return 1;

	if(!insert_indicator_nodes(translate, table, node->nxt))
		return 0;

	translate->input_crs = 0;
	if(!translate_copy_to_output(translate, node->at, 1))
		return 0;

	if(!insert_indicator_node(translate, table, node->indicator, node->at))
		return 0;

	translate->input_crs = node->at;
	if(!translate_copy_to_output(translate, translate->input_len - node->at, 1))
		return 0;

	if(!translate_output_to_input(translate))
		return 0;

#ifdef DEBUG
	translate->output[translate->output_len] = 0;
#endif

	return 1;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
testq %rdx, %rdx
je 0xc88d
movq %rdx, %r15
movq %rsi, %r12
movq %rdi, %r14
movq (%rdx), %rdx
callq 0xc802
xorl %ebx, %ebx
testl %eax, %eax
je 0xc890
andl $0x0, 0x40(%r14)
movl 0x10(%r15), %esi
pushq $0x1
popq %rdx
movq %r14, %rdi
callq 0x6b0c
testl %eax, %eax
je 0xc890
movq 0x8(%r15), %rdx
movq %r14, %rdi
movq %r12, %rsi
callq 0xcba8
testl %eax, %eax
je 0xc890
movl 0x10(%r15), %eax
movl %eax, 0x40(%r14)
movl 0x44(%r14), %esi
subl %eax, %esi
pushq $0x1
popq %rbp
movq %r14, %rdi
movl %ebp, %edx
callq 0x6b0c
testl %eax, %eax
je 0xc890
movq %r14, %rdi
callq 0x6d28
testl %eax, %eax
je 0xc890
movq 0x60(%r14), %rax
movslq 0x68(%r14), %rcx
andw $0x0, (%rax,%rcx,2)
movl %ebp, %ebx
jmp 0xc890
pushq $0x1
popq %rbx
movl %ebx, %eax
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/MikeGray-APH[P]LibLouisAPH/source/languages/generic-forward.c
// Function: indicator_node_free
static void indicator_node_free(struct indicator_node *node)
{
	if(!node)
		return;
	indicator_node_free(node->nxt);
	indicator_free(node->indicator);
	FREE(node);
}

// Assembly:
testq %rdi, %rdi
je 0xc8be
pushq %rbx
movq %rdi, %rbx
movq (%rdi), %rdi
callq 0xc89b
movq 0x8(%rbx), %rdi
callq 0xcc41
movq %rbx, %rdi
popq %rbx
jmp 0x1040
retq
// File: /workspace/github_c_makefile_star2_O2/MikeGray-APH[P]LibLouisAPH/source/translate.h
// Function: translate_on_indicator_or_modifier_marker_at
static inline int translate_on_indicator_or_modifier_marker_at(const struct translate *translate, const int at)
{
	const struct table *table;

	/*   only check indicators from last table in tables   */
	table = translate->tables[translate->table_cnt - 1];

	return   translate->input[at] == table->marker_modifier
	       || translate->input[at] == table->marker_hard
	       || translate->input[at] == table->marker_soft;
}

// Assembly:
movslq 0xc(%rdi), %rax
movq (%rdi), %rcx
movq 0x38(%rdi), %rdx
movq -0x8(%rcx,%rax,8), %rcx
movslq %esi, %rax
movzwl (%rdx,%rax,2), %edx
pushq $0x1
popq %rax
cmpw 0x1ee(%rcx), %dx
je 0xc8f7
cmpw 0x1f0(%rcx), %dx
je 0xc8f7
xorl %eax, %eax
cmpw 0x1f2(%rcx), %dx
sete %al
retq
// File: /workspace/github_c_makefile_star2_O2/MikeGray-APH[P]LibLouisAPH/source/languages/generic-forward.c
// Function: is_word_start
static int is_word_start(const unsigned char *words, const struct translate *translate, const int at)
{
	if(at >= translate->input_len)
		return 0;

	if(translate_on_marker_at(translate, at))
		return is_word_start(words, translate, get_after_next_delimiter(translate, at));

	if(!translate_has_attributes_at(translate, at, CHAR_SPACE))
		return 1;

	return 0;
}

// Assembly:
pushq %rax
movslq 0x44(%rdi), %rax
cmpl %esi, %eax
jle 0xc988
movslq 0xc(%rdi), %rdx
movq (%rdi), %r8
movq 0x38(%rdi), %rcx
movq -0x8(%r8,%rdx,8), %r9
movslq %esi, %r8
movzwl (%rcx,%r8,2), %edx
cmpw 0x1e8(%r9), %dx
je 0xc959
cmpw 0x1ea(%r9), %dx
je 0xc959
cmpw 0x1ec(%r9), %dx
je 0xc959
cmpw 0x1f0(%r9), %dx
je 0xc959
cmpw 0x1f2(%r9), %dx
je 0xc959
cmpw 0x1f4(%r9), %dx
jne 0xc98c
addl $0x2, %esi
incq %r8
movl %esi, %r9d
cmpq %rax, %r8
jge 0xc979
leal 0x1(%r9), %esi
leaq 0x1(%r8), %r10
cmpw %dx, (%rcx,%r8,2)
movq %r10, %r8
jne 0xc95f
cmpl %eax, %r9d
cmovgel %eax, %r9d
movl %r9d, %esi
jmp 0xc8fd
xorl %eax, %eax
popq %rcx
retq
pushq $0x1
popq %rdx
callq 0xca1b
movl %eax, %ecx
xorl %eax, %eax
testl %ecx, %ecx
sete %al
jmp 0xc98a
// File: /workspace/github_c_makefile_star2_O2/MikeGray-APH[P]LibLouisAPH/source/languages/generic-forward.c
// Function: get_before_indicators
static int get_before_indicators(unsigned char *words, const int at)
{
	int i;

	for(i = at; i >= 0; i--)
	if(!(words[i] & WORD_INDICATOR))
		break;
	return i + 1;
}

// Assembly:
cmpl $-0x1, %esi
pushq $-0x1
popq %rax
cmovll %esi, %eax
testl %esi, %esi
js 0xc9cb
movl %esi, %ecx
testb $0x4, (%rdi,%rcx)
je 0xc9c9
decl %esi
jmp 0xc9b9
movl %esi, %eax
incl %eax
retq
// File: /workspace/github_c_makefile_star2_O2/MikeGray-APH[P]LibLouisAPH/source/languages/generic-forward.c
// Function: convert_to_passage
static void convert_to_passage(unsigned int *indicators, unsigned char *words, const int pass_begin, const int pass_end)
{
	int i;

	for(i = pass_begin; i <= pass_end; i++)
	{
		indicators[i] &= ~(EMP_SYMBOL | EMP_WORD);
		words[i] &= ~WORD_WHOLE;
	}

	indicators[pass_begin] |= EMP_BEGIN;
	indicators[pass_end] |= EMP_END;
}

// Assembly:
movslq %edx, %rax
movslq %ecx, %rcx
movq %rax, %rdx
cmpq %rcx, %rdx
jg 0xca61
andb $-0xd, (%rdi,%rdx,4)
andb $-0x3, (%rsi,%rdx)
incq %rdx
jmp 0xca4f
orb $0x1, (%rdi,%rax,4)
orb $0x2, (%rdi,%rcx,4)
retq
// File: /workspace/github_c_makefile_star2_O2/MikeGray-APH[P]LibLouisAPH/source/languages/generic-forward.c
// Function: sort_word_end
static void sort_word_end(struct indicator *indicator)
{
	struct indicator *nxt;

	if(!indicator->nxt)
		return;
	if(indicator->nxt->type != (EMP_WORD | EMP_END))
		return;

	sort_word_end(indicator->nxt);

	if(indicator->len < indicator->nxt->len)
	{
		nxt = indicator->nxt;

		if(indicator->prv)
			indicator->prv->nxt = nxt;
		if(nxt->nxt)
			nxt->nxt->prv = indicator;

		nxt->prv = indicator->prv;
		indicator->nxt = nxt->nxt;

		nxt->nxt = indicator;
		indicator->prv = nxt;

		sort_word_end(indicator);
	}
}

// Assembly:
pushq %rbx
movq %rdi, %rbx
movq 0x8(%rbx), %rdi
testq %rdi, %rdi
je 0xcab9
cmpl $0x6, 0x18(%rdi)
jne 0xcab9
callq 0xca6a
movl 0x1c(%rbx), %ecx
movq 0x8(%rbx), %rax
cmpl 0x1c(%rax), %ecx
jge 0xcab9
movq (%rbx), %rcx
testq %rcx, %rcx
je 0xca9a
movq %rax, 0x8(%rcx)
movq 0x8(%rax), %rdx
testq %rdx, %rdx
je 0xcaa9
movq %rbx, (%rdx)
movq (%rbx), %rcx
movq %rcx, (%rax)
movq %rdx, 0x8(%rbx)
movq %rbx, 0x8(%rax)
movq %rax, (%rbx)
jmp 0xca6e
popq %rbx
retq