LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O1/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 0x7431
cmpl $0x0, 0x90(%rdi)
je 0x7431
testl %eax, %eax
jle 0x7431
movq 0x50(%rdi), %rcx
xorl %edx, %edx
movslq 0x40(%rdi), %r8
leaq (%rdx,%r8), %rsi
movslq (%rcx,%rsi,4), %rsi
testq %rsi, %rsi
js 0x742a
movl %r8d, %r8d
addq %rdx, %r8
cmpl 0x44(%rdi), %r8d
jge 0x746e
movq 0x48(%rdi), %r8
movl $0xffffffff, (%r8,%rsi,4) # imm = 0xFFFFFFFF
incq %rdx
cmpl %eax, %edx
jl 0x7401
testl %eax, %eax
je 0x7464
cmpl $0x0, 0x8c(%rdi)
jne 0x7464
movl 0x40(%rdi), %ecx
movl 0x88(%rdi), %edx
cmpl %ecx, %edx
jl 0x7464
addl %eax, %ecx
cmpl %ecx, %edx
jge 0x7464
movl $0x1, 0x8c(%rdi)
movl 0x68(%rdi), %ecx
movl %ecx, 0x88(%rdi)
addl %eax, 0x40(%rdi)
movl $0x1, %eax
popq %rcx
retq
callq 0x1060
// File: /workspace/github_c_makefile_star2_O1/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 0x72d8
testl %eax, %eax
je 0x74ec
testl %ebx, %ebx
jle 0x74e1
movl %ebx, %eax
xorl %ecx, %ecx
movslq 0x68(%r14), %rdx
leal (%rcx,%rdx), %esi
cmpl 0x6c(%r14), %esi
jge 0x74f4
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 0x74d9
movq 0x78(%r14), %rdx
movslq 0x68(%r14), %rsi
addq %rcx, %rsi
movl $0xffffffff, (%rdx,%rsi,4) # imm = 0xFFFFFFFF
incq %rcx
cmpq %rcx, %rax
jne 0x7493
addl %ebx, 0x68(%r14)
movl $0x1, %eax
jmp 0x74ee
xorl %eax, %eax
popq %rbx
popq %r14
popq %r15
retq
callq 0x1060
// File: /workspace/github_c_makefile_star2_O1/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 0x72d8
testl %eax, %eax
je 0x7654
testl %ebx, %ebx
jle 0x757a
movl %ebx, %eax
xorl %ecx, %ecx
movslq 0x68(%r14), %rdx
leal (%rcx,%rdx), %esi
cmpl 0x6c(%r14), %esi
jge 0x7661
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 0x7572
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 0x7521
cmpl $0x0, 0x90(%r14)
sete %al
testl %ebp, %ebp
setle %cl
orb %al, %cl
jne 0x7604
xorl %eax, %eax
movslq 0x40(%r14), %rsi
movslq %eax, %rcx
addq %rsi, %rcx
cmpl 0x44(%r14), %ecx
jge 0x7661
movq 0x50(%r14), %rdi
movslq (%rdi,%rcx,4), %rcx
testq %rcx, %rcx
js 0x75fe
movl 0x68(%r14), %edx
testl %esi, %esi
je 0x75c4
movl -0x4(%rdi,%rsi,4), %r8d
cmpl (%rdi,%rsi,4), %r8d
je 0x75fe
movq 0x48(%r14), %rsi
cmpl $0x0, (%rsi,%rcx,4)
js 0x75fe
leal 0x1(%rcx), %edi
cmpl 0x20(%r14), %edi
jge 0x75fb
movl %edi, %r8d
leaq (%rsi,%r8,4), %r8
movl (%r8), %r9d
testl %r9d, %r9d
js 0x75fb
cmpl (%rsi,%rcx,4), %r9d
jne 0x75fb
movl %edx, (%r8)
incl %edi
addq $0x4, %r8
cmpl %edi, 0x20(%r14)
jg 0x75de
movl %edx, (%rsi,%rcx,4)
incl %eax
cmpl %ebp, %eax
jne 0x7590
testl %ebp, %ebp
je 0x7645
cmpl $0x0, 0x8c(%r14)
jne 0x7645
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 0x7645
movl $0x1, 0x8c(%r14)
movl 0x68(%r14), %eax
movl %eax, 0x88(%r14)
addl %ebp, 0x40(%r14)
addl %ebx, 0x68(%r14)
movl $0x1, %eax
jmp 0x7656
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
callq 0x1060
// File: /workspace/github_c_makefile_star2_O1/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 0x787f
cmpw 0x1ea(%rsi), %dx
je 0x787f
cmpw 0x1ec(%rsi), %dx
jne 0x78be
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 0x78af
incl %esi
leaq 0x1(%r10), %r11
cmpw %dx, (%rcx,%r10,2)
movq %r11, %r10
jne 0x7898
jmp 0x78b2
movl %r9d, %esi
subl %eax, %esi
addl $0x2, %esi
xorl %edx, %edx
jmp 0x7666
movl $0xffffffff, %eax       # imm = 0xFFFFFFFF
retq
// File: /workspace/github_c_makefile_star2_O1/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 0x78ee
cmpw 0x1f2(%rsi), %dx
jne 0x792d
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 0x791e
incl %esi
leaq 0x1(%r10), %r11
cmpw %dx, (%rcx,%r10,2)
movq %r11, %r10
jne 0x7907
jmp 0x7921
movl %r9d, %esi
subl %eax, %esi
addl $0x2, %esi
xorl %edx, %edx
jmp 0x7666
movl $0xffffffff, %eax       # imm = 0xFFFFFFFF
retq
// File: /workspace/github_c_makefile_star2_O1/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 0x7966
cmpw 0x1f0(%rsi), %dx
je 0x7966
cmpw 0x1f2(%rsi), %dx
jne 0x79a8
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 0x7996
incl %esi
leaq 0x1(%r10), %r11
cmpw %dx, (%rcx,%r10,2)
movq %r11, %r10
jne 0x797f
jmp 0x7999
movl %r9d, %esi
subl %eax, %esi
addl $0x2, %esi
movl $0x1, %edx
jmp 0x7666
movl $0xffffffff, %eax       # imm = 0xFFFFFFFF
retq
// File: /workspace/github_c_makefile_star2_O1/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 %r15
pushq %r14
pushq %rbx
pushq %rax
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), %r15
movq %r15, %rdi
callq 0x1180
movq %rax, 0x60(%rbx)
testq %rax, %rax
je 0x7a8a
movq %rax, %rdi
xorl %esi, %esi
movq %r15, %rdx
callq 0x1110
movl $0x0, 0x68(%rbx)
movq %r14, %rdi
callq 0x1180
movq %rax, 0x80(%rbx)
testq %rax, %rax
je 0x7aad
movq %rax, %rdi
xorl %esi, %esi
movq %r14, %rdx
callq 0x1110
movl $0x1, %ebp
cmpl $0x0, 0x90(%rbx)
je 0x7ad1
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 0x1180
movq %rax, 0x78(%rbx)
testq %rax, %rax
je 0x7ade
movq %rax, %rdi
movl $0xff, %esi
movq %r14, %rdx
callq 0x1110
jmp 0x7ad1
leaq 0xb763(%rip), %rsi      # 0x131f4
leaq 0xbf3a(%rip), %rdx      # 0x139d2
xorl %ebp, %ebp
movl $0x7, %edi
movl $0x134, %ecx            # imm = 0x134
xorl %eax, %eax
callq 0xa36c
jmp 0x7ad1
leaq 0xb740(%rip), %rsi      # 0x131f4
leaq 0xbf17(%rip), %rdx      # 0x139d2
movl $0x7, %edi
movl $0x13d, %ecx            # imm = 0x13D
xorl %eax, %eax
callq 0xa36c
movl $0xffffffff, %ebp       # imm = 0xFFFFFFFF
movl %ebp, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
leaq 0xb70f(%rip), %rsi      # 0x131f4
leaq 0xbee6(%rip), %rdx      # 0x139d2
xorl %ebp, %ebp
movl $0x7, %edi
movl $0x14b, %ecx            # imm = 0x14B
jmp 0x7aa4
// File: /workspace/github_c_makefile_star2_O1/MikeGray-APH[P]LibLouisAPH/source/translate.c
// Function: convert_output
static void convert_output(struct translate *translate, const struct conversion *conversion)
{
	int i;

	ASSERT(conversion)

	for(i = 0; i < translate->output_len; i++)
	if(translate->output[i] >= 0x2800 && translate->output[i] <= 0x28ff)
		translate->output[i] = conversion->converts[translate->output[i] & 0xff];
	else if(conversion->unknown)
		translate->output[i] = conversion->unknown;
}

// Assembly:
movslq 0x68(%rdi), %rax
testq %rax, %rax
jle 0x80bb
movq 0x60(%rdi), %rcx
xorl %edx, %edx
movzwl (%rcx,%rdx,2), %edi
movl %edi, %r8d
andl $0xff00, %r8d           # imm = 0xFF00
cmpl $0x2800, %r8d           # imm = 0x2800
jne 0x80a3
movzbl %dil, %edi
movzwl 0x10(%rsi,%rdi,2), %edi
jmp 0x80af
movzwl 0x210(%rsi), %edi
testw %di, %di
je 0x80b3
movw %di, (%rcx,%rdx,2)
incq %rdx
cmpq %rdx, %rax
jne 0x8081
retq
// File: /workspace/github_c_makefile_star2_O1/MikeGray-APH[P]LibLouisAPH/source/pattern.c
// Function: subpattern_allocate
subpattern* subpattern_allocate(void)
{
	struct subpattern *subpattern;

	subpattern = MALLOC(sizeof(struct subpattern));
	LOG_ALLOCATE_FAIL_RETURN_NULL(subpattern)
	memset(subpattern, 0, sizeof(struct subpattern));
	return subpattern;
}

// Assembly:
pushq %rax
movl $0x30, %edi
callq 0x1180
testq %rax, %rax
je 0x80dc
xorps %xmm0, %xmm0
movups %xmm0, 0x20(%rax)
movups %xmm0, 0x10(%rax)
movups %xmm0, (%rax)
popq %rcx
retq
leaq 0xb111(%rip), %rsi      # 0x131f4
leaq 0xb972(%rip), %rdx      # 0x13a5c
movl $0x7, %edi
movl $0xdd, %ecx
xorl %eax, %eax
callq 0xa36c
xorl %eax, %eax
popq %rcx
retq
// File: /workspace/github_c_makefile_star2_O1/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 0x8143
pushq %rbx
movq %rdi, %rbx
movq (%rdi), %rdi
callq 0x80ff
movq 0x8(%rbx), %rdi
testq %rdi, %rdi
je 0x811e
callq 0x1040
movq 0x10(%rbx), %rdi
testq %rdi, %rdi
je 0x812c
callq 0x1040
movq 0x18(%rbx), %rdi
testq %rdi, %rdi
je 0x813a
callq 0x1040
movq %rbx, %rdi
popq %rbx
jmp 0x1040
retq
// File: /workspace/github_c_makefile_star2_O1/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 0x8196
movq %r8, %r13
movq %r8, %rdi
callq 0x10b0
testl %eax, %eax
jle 0x8196
cmpl $0x20, %eax
movl $0x20, %ecx
cmovll %eax, %ecx
cmpl $0x2, %ecx
movl $0x1, %edx
cmovgel %ecx, %edx
leaq 0xff72(%rip), %rdi      # 0x18100
movq %r13, %rsi
callq 0x1170
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 0x8213
addq $0x10, %rsp
xorl %r14d, %r14d
testl %eax, %eax
je 0x8201
addw $0x3, (%rbx)
movq %rbx, %rdi
movl $0x2, %esi
movl %ebp, %edx
movq %rbx, %rcx
callq 0x830a
testl %eax, %eax
je 0x8201
movq %rbx, %rdi
movl $0x2, %esi
movl %ebp, %edx
movq %rbx, %rcx
callq 0x83f5
testl %eax, %eax
je 0x8201
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_O1/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 0x82fb
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 0x82f3
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 0x87d0
addq $0x10, %rsp
testl %eax, %eax
je 0x82f9
movzwl (%r14), %eax
leal 0x3(%rax), %ecx
cmpl %ebp, %ecx
jge 0x82f9
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 0x828c
movzwl (%r14), %eax
jmp 0x82fb
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_O1/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
leal -0x2(%rax), %ecx
cmpl $0x2, %ecx
jae 0x8348
movslq %r15d, %rax
movzwl 0x6(%r14,%rax,2), %esi
movq %r14, %rdi
movl %ebp, %edx
movq %rbx, %rcx
callq 0x830a
testl %eax, %eax
jne 0x8353
jmp 0x83e1
cmpl $0xffff, %eax           # imm = 0xFFFF
je 0x83e5
movzwl (%r14,%r15,2), %eax
addl $-0x4, %eax
cmpw $0x2, %ax
ja 0x83d3
movzwl (%rbx), %ecx
leal 0x6(%rcx), %edx
xorl %eax, %eax
cmpl %ebp, %edx
jge 0x83ea
movslq %r15d, %rsi
movzwl 0x2(%r14,%rsi,2), %edx
cmpw $0x1, (%r14,%rdx,2)
je 0x83ea
movzwl 0x2(%r14,%rdx,2), %eax
movl $0xffff0001, (%r14,%rcx,2) # imm = 0xFFFF0001
movw %dx, 0x4(%r14,%rcx,2)
movzwl (%rbx), %edi
addl $0x3, %edi
movw %di, (%rbx)
movzwl %di, %edi
movw $0xffff, (%r14,%rdi,2)  # imm = 0xFFFF
movw %dx, 0x2(%r14,%rdi,2)
movw %r15w, 0x4(%r14,%rdi,2)
addw $0x3, (%rbx)
movw %cx, 0x6(%r14,%rsi,2)
movw %r15w, 0x4(%r14,%rax,2)
movw %ax, 0x2(%r14,%rsi,2)
movw %cx, 0x2(%r14,%rdx,2)
movw %di, 0x4(%r14,%rdx,2)
movslq %r15d, %rax
movzwl 0x4(%r14,%rax,2), %esi
jmp 0x8319
xorl %eax, %eax
jmp 0x83ea
movl $0x1, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/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
movl %esi, 0x4(%rsp)
movslq %esi, %rbp
movzwl 0x4(%rdi,%rbp,2), %r14d
cmpw $-0x1, (%rdi,%r14,2)
je 0x8683
movq %rdi, %rbx
cmpw $-0x1, (%rbx,%r14,2)
je 0x8603
movzwl 0x4(%rbx,%r14,2), %r14d
jmp 0x85f3
movzwl 0x2(%rbx,%r14,2), %r15d
movzwl %r15w, %esi
movzwl 0x2(%rbx,%rsi,2), %r13d
movw %si, 0x4(%rbx,%rbp,2)
movw %bp, 0x2(%rbx,%rsi,2)
movw %r13w, 0x4(%rbx,%rsi,2)
movq %rbx, %rdi
callq 0x8fa0
movzwl %r13w, %r12d
cmpl %ebp, %r12d
je 0x8669
movl %r13d, %r15d
movl %r12d, %esi
movzwl %r13w, %ebp
movzwl 0x2(%rbx,%rbp,2), %r13d
movzwl %r13w, %r12d
movq %rbx, %rdi
callq 0x8fa0
cmpl 0x4(%rsp), %r12d
je 0x8669
movzwl 0x4(%rbx,%rbp,2), %eax
movw %ax, 0x2(%rbx,%rbp,2)
movw %r12w, 0x4(%rbx,%rbp,2)
jne 0x8634
movzwl %r15w, %eax
movzwl 0x4(%rbx,%rax,2), %ecx
movw %cx, 0x2(%rbx,%rax,2)
movw %r14w, 0x4(%rbx,%rax,2)
movw %ax, 0x2(%rbx,%r14,2)
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/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 0x86eb
movq %r15, %rdi
callq 0x10b0
testl %eax, %eax
jle 0x86eb
cmpl $0x20, %eax
movl $0x20, %ecx
cmovll %eax, %ecx
cmpl $0x2, %ecx
movl $0x1, %edx
cmovgel %ecx, %edx
leaq 0xfa1d(%rip), %rdi      # 0x18100
movq %r15, %rsi
callq 0x1170
movq %r13, 0x11b4e(%rip)     # 0x1a240
movl $0x0, 0x11b4c(%rip)     # 0x1a248
leaq 0x4(%rsp), %rsi
movq %r12, %rdi
movl %r14d, %edx
movl %ebp, %ecx
movq %rbx, %r8
movq 0x48(%rsp), %r9
callq 0x8725
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/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
subq $0x18, %rsp
movq %r9, 0x10(%rsp)
movq %r8, %r15
movl %ecx, 0xc(%rsp)
movl %edx, %r12d
movq %rsi, %r13
movq %rdi, %r14
movzwl 0x2(%r8), %ebp
shll $0x2, %ebp
movq %rbp, %rdi
callq 0x1180
testq %rax, %rax
je 0x87a0
movq %rax, %rbx
movq %rax, %rdi
xorl %esi, %esi
movq %rbp, %rdx
callq 0x1110
movq %r14, %rdi
movq %r13, %rsi
movl %r12d, %edx
movl 0xc(%rsp), %ecx
movq %r15, %r8
movq 0x10(%rsp), %r9
pushq %rbx
xorl %eax, %eax
pushq %rax
pushq %rax
pushq $0x2
callq 0x8fea
addq $0x20, %rsp
movl %eax, %ebp
movq %rbx, %rdi
callq 0x1040
movl %ebp, %eax
jmp 0x87c1
leaq 0xaa4d(%rip), %rsi      # 0x131f4
leaq 0xb2ae(%rip), %rdx      # 0x13a5c
movl $0x7, %edi
movl $0x53d, %ecx            # imm = 0x53D
xorl %eax, %eax
callq 0xa36c
xorl %eax, %eax
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/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 0x8f9d
movq %rdi, %rax
movl %edx, %ecx
cmpl %edx, 0x20(%rax)
jne 0x8f95
testl %edx, %edx
jle 0x8f8f
movq 0x8(%rax), %r8
xorl %edi, %edi
movzwl (%r8,%rdi,2), %r9d
cmpw (%rsi,%rdi,2), %r9w
jne 0x8f91
incq %rdi
cmpq %rdi, %rcx
jne 0x8f77
movl %ecx, %edi
jmp 0x8f91
xorl %edi, %edi
cmpl %edx, %edi
je 0x8f9f
movq (%rax), %rax
testq %rax, %rax
jne 0x8f68
xorl %eax, %eax
retq
// File: /workspace/github_c_makefile_star2_O1/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 0x8fcd
movzwl 0x6(%rbx,%r14,2), %esi
movq %rbx, %rdi
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x85cc
cmpl $0x7, %eax
jne 0x8fe2
movzwl 0x8(%rbx,%r14,2), %esi
movq %rbx, %rdi
callq 0x85cc
jmp 0x8fb8
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O1/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 0x10d54(%rip), %rdi     # 0x1a250
callq 0x1e2f
xorl %ebx, %ebx
movq %rbx, 0x10d46(%rip)     # 0x1a250
movq 0x10d47(%rip), %rdi     # 0x1a258
callq 0x2cf2
movq %rbx, 0x10d3b(%rip)     # 0x1a258
movq 0x10d3c(%rip), %rdi     # 0x1a260
testq %rdi, %rdi
je 0x9543
callq 0x1040
movq $0x0, 0x10d27(%rip) # 0x1a260
movl $0x0, 0x10d25(%rip)     # 0x1a268
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O1/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 %rbx
pushq %rax
movl %esi, %r14d
movq %rdi, %rbx
cmpb $0x0, 0x10c49(%rip)     # 0x1a26c
jne 0x96b3
movb $0x1, 0x10c3c(%rip)     # 0x1a26c
leaq 0xa4b9(%rip), %rdi      # 0x13af0
callq 0x1030
testq %rax, %rax
je 0x96b3
cmpq $0x0, 0x10c17(%rip)     # 0x1a260
je 0x9660
leaq 0xa477(%rip), %rsi      # 0x13ac9
movl $0x7, %edi
xorl %eax, %eax
callq 0xa36c
jmp 0x96b3
movq %rax, %r15
movq %rax, %rdi
callq 0x10b0
movl %eax, 0x10bf7(%rip)     # 0x1a268
incl %eax
movslq %eax, %rdi
callq 0x1180
movq %rax, 0x10bde(%rip)     # 0x1a260
testq %rax, %rax
je 0x9694
movq %rax, %rdi
movq %r15, %rsi
callq 0x1080
jmp 0x96b3
leaq 0x9b59(%rip), %rsi      # 0x131f4
leaq 0xa3cb(%rip), %rdx      # 0x13a6d
movl $0x7, %edi
movl $0x4a, %ecx
xorl %eax, %eax
callq 0xa36c
movq 0x10ba6(%rip), %rsi     # 0x1a260
testq %rsi, %rsi
je 0x96e2
movl 0x10ba3(%rip), %eax     # 0x1a268
leal -0x1(%r14), %ebp
cmpl %r14d, %eax
cmovll %eax, %ebp
movslq %ebp, %r14
movq %rbx, %rdi
movq %r14, %rdx
callq 0x1170
addq %r14, %rbx
jmp 0x96e4
xorl %ebp, %ebp
movb $0x0, (%rbx)
movl %ebp, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/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, %rbx
cmpb $0x0, 0x10b6a(%rip)     # 0x1a26c
jne 0x9792
movb $0x1, 0x10b5d(%rip)     # 0x1a26c
leaq 0xa3da(%rip), %rdi      # 0x13af0
callq 0x1030
testq %rax, %rax
je 0x9792
cmpq $0x0, 0x10b38(%rip)     # 0x1a260
je 0x973f
leaq 0xa398(%rip), %rsi      # 0x13ac9
movl $0x7, %edi
xorl %eax, %eax
callq 0xa36c
jmp 0x9792
movq %rax, %r14
movq %rax, %rdi
callq 0x10b0
movl %eax, 0x10b18(%rip)     # 0x1a268
incl %eax
movslq %eax, %rdi
callq 0x1180
movq %rax, 0x10aff(%rip)     # 0x1a260
testq %rax, %rax
je 0x9773
movq %rax, %rdi
movq %r14, %rsi
callq 0x1080
jmp 0x9792
leaq 0x9a7a(%rip), %rsi      # 0x131f4
leaq 0xa2ec(%rip), %rdx      # 0x13a6d
movl $0x7, %edi
movl $0x4a, %ecx
xorl %eax, %eax
callq 0xa36c
movq 0x10ac7(%rip), %rdi     # 0x1a260
testq %rdi, %rdi
je 0x97a3
callq 0x1040
testq %rbx, %rbx
je 0x97dd
movq %rbx, %rdi
callq 0x10b0
movq %rax, %r14
movl %r14d, 0x10aae(%rip)    # 0x1a268
incl %eax
movslq %eax, %rdi
callq 0x1180
movq %rax, 0x10a95(%rip)     # 0x1a260
testq %rax, %rax
je 0x97fa
movq %rax, %rdi
movq %rbx, %rsi
callq 0x1080
jmp 0x981c
movq $0x0, 0x10a78(%rip) # 0x1a260
movl $0x0, 0x10a76(%rip)     # 0x1a268
movl $0x1, %r14d
jmp 0x981c
leaq 0x99f3(%rip), %rsi      # 0x131f4
leaq 0xa265(%rip), %rdx      # 0x13a6d
xorl %r14d, %r14d
movl $0x7, %edi
movl $0xab, %ecx
xorl %eax, %eax
callq 0xa36c
movl %r14d, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O1/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 %rbx
movq %rdi, %rbx
cmpb $0x0, 0x10a36(%rip)     # 0x1a26c
jne 0x98c6
movb $0x1, 0x10a29(%rip)     # 0x1a26c
leaq 0xa2a6(%rip), %rdi      # 0x13af0
callq 0x1030
testq %rax, %rax
je 0x98c6
cmpq $0x0, 0x10a04(%rip)     # 0x1a260
je 0x9873
leaq 0xa264(%rip), %rsi      # 0x13ac9
movl $0x7, %edi
xorl %eax, %eax
callq 0xa36c
jmp 0x98c6
movq %rax, %r14
movq %rax, %rdi
callq 0x10b0
movl %eax, 0x109e4(%rip)     # 0x1a268
incl %eax
movslq %eax, %rdi
callq 0x1180
movq %rax, 0x109cb(%rip)     # 0x1a260
testq %rax, %rax
je 0x98a7
movq %rax, %rdi
movq %r14, %rsi
callq 0x1080
jmp 0x98c6
leaq 0x9946(%rip), %rsi      # 0x131f4
leaq 0xa1b8(%rip), %rdx      # 0x13a6d
movl $0x7, %edi
movl $0x4a, %ecx
xorl %eax, %eax
callq 0xa36c
testq %rbx, %rbx
je 0x9962
movq 0x1098a(%rip), %r14     # 0x1a260
movq %rbx, %rdi
callq 0x10b0
testq %r14, %r14
je 0x993b
movslq %eax, %r15
movslq 0x1097b(%rip), %rax     # 0x1a268
leaq (%r15,%rax), %rcx
incq %rcx
movl %ecx, 0x1096e(%rip)     # 0x1a268
leaq (%r15,%rax), %rsi
addq $0x2, %rsi
movq %r14, %rdi
callq 0x11a0
movq %rax, 0x1094f(%rip)     # 0x1a260
testq %rax, %rax
je 0x996a
movq %rax, %r14
incq %r15
movq %rax, %rdi
callq 0x10b0
movw $0x3a, (%r14,%rax)
movslq %r15d, %rdx
movq %r14, %rdi
movq %rbx, %rsi
callq 0x1120
jmp 0x9962
movl %eax, 0x10927(%rip)     # 0x1a268
incl %eax
movslq %eax, %rdi
callq 0x1180
movq %rax, 0x1090e(%rip)     # 0x1a260
testq %rax, %rax
je 0x9986
movq %rax, %rdi
movq %rbx, %rsi
callq 0x1080
movl 0x10900(%rip), %ebx     # 0x1a268
jmp 0x99a7
leaq 0x9883(%rip), %rsi      # 0x131f4
leaq 0xa0f5(%rip), %rdx      # 0x13a6d
xorl %ebx, %ebx
movl $0x7, %edi
movl $0xce, %ecx
jmp 0x99a0
leaq 0x9867(%rip), %rsi      # 0x131f4
leaq 0xa0d9(%rip), %rdx      # 0x13a6d
xorl %ebx, %ebx
movl $0x7, %edi
movl $0xc2, %ecx
xorl %eax, %eax
callq 0xa36c
movl %ebx, %eax
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O1/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 0x9c91
movq %r8, %rbx
movq %rdi, %r15
movl %ecx, %eax
xorl %r14d, %r14d
cmpb $0x3a, (%rdx,%r14)
je 0x9c5b
incq %r14
cmpq %r14, %rax
jne 0x9c49
movl %eax, %r14d
notl %r9d
addl %esi, %r9d
cmpl %r9d, %r14d
jge 0x9c91
testl %r14d, %r14d
je 0x9ca3
movl %r14d, %r12d
movq %r15, %rdi
movq %rdx, %rsi
movq %r12, %rdx
callq 0x1170
leaq (%r15,%r12), %rdi
incq %rdi
movb $0x2f, -0x1(%rdi)
movq %rbx, %rsi
callq 0x1080
jmp 0x9c94
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_O1/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 %rbx
pushq %rax
movl %ecx, %ebx
movl %edx, %ebp
movq %rsi, %r15
movq %rdi, %r14
movl $0x1, 0x94(%rdi)
testl %ecx, %ecx
je 0xa9b0
leaq 0x4(%rsp), %rsi
movw %bx, (%rsi)
movq %r14, %rdi
movl $0x1, %edx
callq 0x7473
testl %eax, %eax
je 0xa9e8
movq %r14, %rdi
movq %r15, %rsi
movl %ebp, %edx
callq 0x7473
xorl %ebp, %ebp
testl %eax, %eax
je 0xa9ea
testw %bx, %bx
je 0xa9e1
leaq 0x6(%rsp), %rsi
movw %bx, (%rsi)
movq %r14, %rdi
movl $0x1, %edx
callq 0x7473
testl %eax, %eax
je 0xa9ea
movl $0x1, %ebp
jmp 0xa9ea
xorl %ebp, %ebp
movl %ebp, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/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 %rbx
movq (%rdi), %rax
movslq 0xc(%rdi), %rdx
movq -0x8(%rax,%rdx,8), %rcx
decq %rdx
movl %edx, 0x8(%rdi)
movl 0x44(%rdi), %r8d
xorl %edx, %edx
testl %r8d, %r8d
jle 0xaace
xorl %esi, %esi
movq 0x38(%rdi), %r9
movslq %esi, %rax
movzwl (%r9,%rax,2), %r11d
movzwl 0x1f4(%rcx), %r10d
cmpw %r10w, %r11w
jne 0xaa62
movslq %r8d, %r8
leal 0x1(%rsi), %r11d
cmpl %r11d, %r8d
cmovgl %r8d, %r11d
decl %r11d
decl %esi
incq %rax
movq %rax, %rbx
cmpq %r8, %rax
jge 0xaaa5
incl %esi
leaq 0x1(%rbx), %rax
cmpw %r10w, (%r9,%rbx,2)
jne 0xaa4b
jmp 0xaaa8
movq 0x60(%rdi), %r9
movslq %edx, %r8
movw %r11w, (%r9,%r8,2)
movq 0x58(%rdi), %r9
movq 0x80(%rdi), %r10
movb (%r9,%rax), %r9b
movb %r9b, (%r10,%r8)
cmpl $0x0, 0x90(%rdi)
je 0xaa9a
movq 0x50(%rdi), %r9
movq 0x78(%rdi), %r10
movl (%r9,%rax,4), %eax
movl %eax, (%r10,%r8,4)
incl %edx
cmpl 0x6c(%rdi), %edx
jge 0xaae5
incl %esi
jmp 0xaac1
movl %r11d, %esi
addl $0x2, %esi
xorl %eax, %eax
cmpq %r8, %rbx
cmovgel %eax, %esi
testl %esi, %esi
je 0xaae3
movl $0x1, 0x94(%rdi)
movl 0x44(%rdi), %r8d
cmpl %r8d, %esi
jl 0xaa1b
movl %edx, 0x68(%rdi)
movq 0x60(%rdi), %rax
movslq %edx, %rcx
movw $0x0, (%rax,%rcx,2)
movl $0x1, %eax
popq %rbx
retq
xorl %eax, %eax
jmp 0xaae3
// File: /workspace/github_c_makefile_star2_O1/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 %r14
pushq %rbx
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
movl %eax, 0x68(%rdi)
movl %eax, 0x40(%rdi)
cmpl %eax, 0x44(%rdi)
jle 0xac54
xorl %ebp, %ebp
movq 0x38(%rbx), %rcx
cltq
movzwl (%rcx,%rax,2), %eax
cmpw 0x1ee(%r14), %ax
jne 0xac36
movl $0x1, 0x94(%rbx)
movq %rbx, %rdi
movl $0x1, %esi
xorl %edx, %edx
callq 0x73d5
testl %eax, %eax
jne 0xac4c
jmp 0xac67
movq %rbx, %rdi
movl $0x1, %esi
movl $0x1, %edx
callq 0x7666
testl %eax, %eax
je 0xac6e
movl 0x40(%rbx), %eax
cmpl 0x44(%rbx), %eax
jl 0xac03
movq 0x60(%rbx), %rax
movslq 0x68(%rbx), %rcx
movw $0x0, (%rax,%rcx,2)
movl $0x1, %ebp
movl %ebp, %eax
popq %rbx
popq %r14
popq %rbp
retq
xorl %ebp, %ebp
jmp 0xac67
// File: /workspace/github_c_makefile_star2_O1/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 %r14
pushq %rbx
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
movl %eax, 0x68(%rdi)
movl %eax, 0x40(%rdi)
cmpl %eax, 0x44(%rdi)
jle 0xacf5
xorl %ebp, %ebp
movq 0x38(%rbx), %rcx
cltq
movzwl (%rcx,%rax,2), %eax
cmpw 0x1ee(%r14), %ax
je 0xacb8
cmpw 0x1f0(%r14), %ax
jne 0xacd7
movl $0x1, 0x94(%rbx)
movq %rbx, %rdi
movl $0x1, %esi
xorl %edx, %edx
callq 0x73d5
testl %eax, %eax
jne 0xaced
jmp 0xad08
movq %rbx, %rdi
movl $0x1, %esi
movl $0x1, %edx
callq 0x7666
testl %eax, %eax
je 0xad0f
movl 0x40(%rbx), %eax
cmpl 0x44(%rbx), %eax
jl 0xac9a
movq 0x60(%rbx), %rax
movslq 0x68(%rbx), %rcx
movw $0x0, (%rax,%rcx,2)
movl $0x1, %ebp
movl %ebp, %eax
popq %rbx
popq %r14
popq %rbp
retq
xorl %ebp, %ebp
jmp 0xad08
// File: /workspace/github_c_makefile_star2_O1/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), %r8d
movl 0x44(%rdi), %r9d
subl %ecx, %r9d
xorl %eax, %eax
cmpl %r9d, %r8d
jg 0xde22
pushq %rbx
movslq %ecx, %r8
testl %edx, %edx
jle 0xde06
movq 0x38(%rdi), %rax
movl %edx, %r9d
leaq (%rax,%r8,2), %r10
addq $0x2, %r10
xorl %eax, %eax
xorl %r11d, %r11d
movzwl (%rsi,%r11,2), %ebx
cmpw (%r10,%r11,2), %bx
jne 0xde21
incq %r11
cmpq %r11, %r9
jne 0xddf0
jmp 0xde08
xorl %edx, %edx
movq 0x38(%rdi), %rsi
leal (%rcx,%rdx), %eax
incl %eax
cltq
movzwl (%rsi,%rax,2), %ecx
xorl %eax, %eax
cmpw (%rsi,%r8,2), %cx
sete %al
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O1/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 %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
testq %rdx, %rdx
je 0xe0ea
movq %rdx, %r15
movq %rsi, %r12
movq %rdi, %r14
movq (%rdx), %rdx
callq 0xe059
xorl %ebx, %ebx
testl %eax, %eax
je 0xe0ef
movl $0x0, 0x40(%r14)
movl 0x10(%r15), %esi
movq %r14, %rdi
movl $0x1, %edx
callq 0x7666
testl %eax, %eax
je 0xe0ef
movq 0x8(%r15), %rdx
movq %r14, %rdi
movq %r12, %rsi
callq 0xe363
testl %eax, %eax
je 0xe0ef
movl 0x10(%r15), %eax
movl %eax, 0x40(%r14)
movl 0x44(%r14), %esi
subl %eax, %esi
movq %r14, %rdi
movl $0x1, %edx
callq 0x7666
testl %eax, %eax
je 0xe0ef
movq %r14, %rdi
callq 0x79ae
testl %eax, %eax
je 0xe0ef
movq 0x60(%r14), %rax
movslq 0x68(%r14), %rcx
movw $0x0, (%rax,%rcx,2)
movl $0x1, %ebx
movl %ebx, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O1/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 0xe120
pushq %rbx
movq %rdi, %rbx
movq (%rdi), %rdi
callq 0xe0fd
movq 0x8(%rbx), %rdi
callq 0xe3fe
movq %rbx, %rdi
popq %rbx
jmp 0x1040
retq