LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O0/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:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movq -0x10(%rbp), %rax
movq (%rax), %rax
movq -0x10(%rbp), %rcx
movl 0xc(%rcx), %ecx
subl $0x1, %ecx
movslq %ecx, %rcx
movq (%rax,%rcx,8), %rax
movq %rax, -0x18(%rbp)
movq -0x10(%rbp), %rax
movq 0x38(%rax), %rax
movq -0x10(%rbp), %rcx
movslq 0x40(%rcx), %rcx
movzwl (%rax,%rcx,2), %eax
movq -0x18(%rbp), %rcx
movzwl 0x1e8(%rcx), %ecx
cmpl %ecx, %eax
je 0xb0ea
movq -0x10(%rbp), %rax
movq 0x38(%rax), %rax
movq -0x10(%rbp), %rcx
movslq 0x40(%rcx), %rcx
movzwl (%rax,%rcx,2), %eax
movq -0x18(%rbp), %rcx
movzwl 0x1ea(%rcx), %ecx
cmpl %ecx, %eax
je 0xb0ea
movq -0x10(%rbp), %rax
movq 0x38(%rax), %rax
movq -0x10(%rbp), %rcx
movslq 0x40(%rcx), %rcx
movzwl (%rax,%rcx,2), %eax
movq -0x18(%rbp), %rcx
movzwl 0x1ec(%rcx), %ecx
cmpl %ecx, %eax
je 0xb0ea
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
jmp 0xb155
movq -0x10(%rbp), %rax
movl 0x40(%rax), %eax
addl $0x1, %eax
movl %eax, -0x1c(%rbp)
movl -0x1c(%rbp), %eax
movq -0x10(%rbp), %rcx
cmpl 0x44(%rcx), %eax
jge 0xb13a
movq -0x10(%rbp), %rax
movq 0x38(%rax), %rax
movslq -0x1c(%rbp), %rcx
movzwl (%rax,%rcx,2), %eax
movq -0x10(%rbp), %rcx
movq 0x38(%rcx), %rcx
movq -0x10(%rbp), %rdx
movslq 0x40(%rdx), %rdx
movzwl (%rcx,%rdx,2), %ecx
cmpl %ecx, %eax
jne 0xb12d
jmp 0xb13a
jmp 0xb12f
movl -0x1c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x1c(%rbp)
jmp 0xb0f7
movq -0x10(%rbp), %rdi
movl -0x1c(%rbp), %esi
movq -0x10(%rbp), %rax
subl 0x40(%rax), %esi
addl $0x1, %esi
xorl %edx, %edx
callq 0xaeb0
movl %eax, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x20, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/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:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movq -0x10(%rbp), %rax
movq (%rax), %rax
movq -0x10(%rbp), %rcx
movl 0xc(%rcx), %ecx
subl $0x1, %ecx
movslq %ecx, %rcx
movq (%rax,%rcx,8), %rax
movq %rax, -0x18(%rbp)
movq -0x10(%rbp), %rax
movq 0x38(%rax), %rax
movq -0x10(%rbp), %rcx
movslq 0x40(%rcx), %rcx
movzwl (%rax,%rcx,2), %eax
movq -0x18(%rbp), %rcx
movzwl 0x1f0(%rcx), %ecx
cmpl %ecx, %eax
je 0xb1d7
movq -0x10(%rbp), %rax
movq 0x38(%rax), %rax
movq -0x10(%rbp), %rcx
movslq 0x40(%rcx), %rcx
movzwl (%rax,%rcx,2), %eax
movq -0x18(%rbp), %rcx
movzwl 0x1f2(%rcx), %ecx
cmpl %ecx, %eax
je 0xb1d7
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
jmp 0xb242
movq -0x10(%rbp), %rax
movl 0x40(%rax), %eax
addl $0x1, %eax
movl %eax, -0x1c(%rbp)
movl -0x1c(%rbp), %eax
movq -0x10(%rbp), %rcx
cmpl 0x44(%rcx), %eax
jge 0xb227
movq -0x10(%rbp), %rax
movq 0x38(%rax), %rax
movslq -0x1c(%rbp), %rcx
movzwl (%rax,%rcx,2), %eax
movq -0x10(%rbp), %rcx
movq 0x38(%rcx), %rcx
movq -0x10(%rbp), %rdx
movslq 0x40(%rdx), %rdx
movzwl (%rcx,%rdx,2), %ecx
cmpl %ecx, %eax
jne 0xb21a
jmp 0xb227
jmp 0xb21c
movl -0x1c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x1c(%rbp)
jmp 0xb1e4
movq -0x10(%rbp), %rdi
movl -0x1c(%rbp), %esi
movq -0x10(%rbp), %rax
subl 0x40(%rax), %esi
addl $0x1, %esi
xorl %edx, %edx
callq 0xaeb0
movl %eax, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movq -0x10(%rbp), %rax
movq (%rax), %rax
movq -0x10(%rbp), %rcx
movl 0xc(%rcx), %ecx
subl $0x1, %ecx
movslq %ecx, %rcx
movq (%rax,%rcx,8), %rax
movq %rax, -0x18(%rbp)
movq -0x10(%rbp), %rax
movq 0x38(%rax), %rax
movq -0x10(%rbp), %rcx
movslq 0x40(%rcx), %rcx
movzwl (%rax,%rcx,2), %eax
movq -0x18(%rbp), %rcx
movzwl 0x1ee(%rcx), %ecx
cmpl %ecx, %eax
je 0xb2ea
movq -0x10(%rbp), %rax
movq 0x38(%rax), %rax
movq -0x10(%rbp), %rcx
movslq 0x40(%rcx), %rcx
movzwl (%rax,%rcx,2), %eax
movq -0x18(%rbp), %rcx
movzwl 0x1f0(%rcx), %ecx
cmpl %ecx, %eax
je 0xb2ea
movq -0x10(%rbp), %rax
movq 0x38(%rax), %rax
movq -0x10(%rbp), %rcx
movslq 0x40(%rcx), %rcx
movzwl (%rax,%rcx,2), %eax
movq -0x18(%rbp), %rcx
movzwl 0x1f2(%rcx), %ecx
cmpl %ecx, %eax
je 0xb2ea
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
jmp 0xb358
movq -0x10(%rbp), %rax
movl 0x40(%rax), %eax
addl $0x1, %eax
movl %eax, -0x1c(%rbp)
movl -0x1c(%rbp), %eax
movq -0x10(%rbp), %rcx
cmpl 0x44(%rcx), %eax
jge 0xb33a
movq -0x10(%rbp), %rax
movq 0x38(%rax), %rax
movslq -0x1c(%rbp), %rcx
movzwl (%rax,%rcx,2), %eax
movq -0x10(%rbp), %rcx
movq 0x38(%rcx), %rcx
movq -0x10(%rbp), %rdx
movslq 0x40(%rdx), %rdx
movzwl (%rcx,%rdx,2), %ecx
cmpl %ecx, %eax
jne 0xb32d
jmp 0xb33a
jmp 0xb32f
movl -0x1c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x1c(%rbp)
jmp 0xb2f7
movq -0x10(%rbp), %rdi
movl -0x1c(%rbp), %esi
movq -0x10(%rbp), %rax
subl 0x40(%rax), %esi
addl $0x1, %esi
movl $0x1, %edx
callq 0xaeb0
movl %eax, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/MikeGray-APH[P]LibLouisAPH/source/translate.c
// Function: 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:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
cmpq $0x0, -0x10(%rbp)
jne 0xbcfc
callq 0x1050
movl $0x0, -0x14(%rbp)
movl -0x14(%rbp), %eax
movq -0x8(%rbp), %rcx
cmpl 0x68(%rcx), %eax
jge 0xbdb0
movq -0x8(%rbp), %rax
movq 0x60(%rax), %rax
movslq -0x14(%rbp), %rcx
movzwl (%rax,%rcx,2), %eax
cmpl $0x2800, %eax           # imm = 0x2800
jl 0xbd75
movq -0x8(%rbp), %rax
movq 0x60(%rax), %rax
movslq -0x14(%rbp), %rcx
movzwl (%rax,%rcx,2), %eax
cmpl $0x28ff, %eax           # imm = 0x28FF
jg 0xbd75
movq -0x10(%rbp), %rax
movq -0x8(%rbp), %rcx
movq 0x60(%rcx), %rcx
movslq -0x14(%rbp), %rdx
movzwl (%rcx,%rdx,2), %ecx
andl $0xff, %ecx
movslq %ecx, %rcx
movw 0x10(%rax,%rcx,2), %dx
movq -0x8(%rbp), %rax
movq 0x60(%rax), %rax
movslq -0x14(%rbp), %rcx
movw %dx, (%rax,%rcx,2)
jmp 0xbda0
movq -0x10(%rbp), %rax
cmpw $0x0, 0x210(%rax)
je 0xbd9e
movq -0x10(%rbp), %rax
movw 0x210(%rax), %dx
movq -0x8(%rbp), %rax
movq 0x60(%rax), %rax
movslq -0x14(%rbp), %rcx
movw %dx, (%rax,%rcx,2)
jmp 0xbda0
jmp 0xbda2
movl -0x14(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x14(%rbp)
jmp 0xbd03
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/MikeGray-APH[P]LibLouisAPH/source/translate.c
// Function: convert_input
static void convert_input(struct translate *translate, const struct conversion *conversion)
{
	int i;

	ASSERT(conversion)

	for(i = 0; i < translate->input_len; i++)
		translate->input[i] = convert_from_output(conversion, translate->input[i]);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
cmpq $0x0, -0x10(%rbp)
jne 0xbddc
callq 0x1050
movl $0x0, -0x14(%rbp)
movl -0x14(%rbp), %eax
movq -0x8(%rbp), %rcx
cmpl 0x44(%rcx), %eax
jge 0xbe26
movq -0x10(%rbp), %rdi
movq -0x8(%rbp), %rax
movq 0x38(%rax), %rax
movslq -0x14(%rbp), %rcx
movzwl (%rax,%rcx,2), %esi
callq 0xbe30
movw %ax, %dx
movq -0x8(%rbp), %rax
movq 0x38(%rax), %rax
movslq -0x14(%rbp), %rcx
movw %dx, (%rax,%rcx,2)
movl -0x14(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x14(%rbp)
jmp 0xbde3
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/MikeGray-APH[P]LibLouisAPH/source/translate.c
// Function: convert_from_output
static unichar convert_from_output(const struct conversion *conversion, const unichar uchar)
{
	int i;

	for(i = 0; i < 0x100; i++)
	if(uchar == conversion->converts[i])
		return i + 0x2800;

	return conversion->unknown;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movw %si, %ax
movq %rdi, -0x10(%rbp)
movw %ax, -0x12(%rbp)
movl $0x0, -0x18(%rbp)
cmpl $0x100, -0x18(%rbp)     # imm = 0x100
jge 0xbe7f
movzwl -0x12(%rbp), %eax
movq -0x10(%rbp), %rcx
movslq -0x18(%rbp), %rdx
movzwl 0x10(%rcx,%rdx,2), %ecx
cmpl %ecx, %eax
jne 0xbe72
movl -0x18(%rbp), %eax
addl $0x2800, %eax           # imm = 0x2800
movw %ax, -0x2(%rbp)
jmp 0xbe8e
jmp 0xbe74
movl -0x18(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x18(%rbp)
jmp 0xbe46
movq -0x10(%rbp), %rax
movw 0x210(%rax), %ax
movw %ax, -0x2(%rbp)
movw -0x2(%rbp), %ax
popq %rbp
retq
nopw %cs:(%rax,%rax)
nop
// File: /workspace/github_c_makefile_star2_O0/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 %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movl $0x30, %edi
callq 0x1160
movq %rax, -0x10(%rbp)
cmpq $0x0, -0x10(%rbp)
jne 0xbee6
movl $0x7, %edi
leaq 0x123af(%rip), %rsi     # 0x1e278
leaq 0x12d1c(%rip), %rdx     # 0x1ebec
movl $0xdd, %ecx
movb $0x0, %al
callq 0xf610
movq $0x0, -0x8(%rbp)
jmp 0xbefe
movq -0x10(%rbp), %rdi
xorl %esi, %esi
movl $0x30, %edx
callq 0x1100
movq -0x10(%rbp), %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x10, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
cmpq $0x0, -0x8(%rbp)
jne 0xbf25
jmp 0xbf82
movq -0x8(%rbp), %rax
movq (%rax), %rdi
callq 0xbf10
movq -0x8(%rbp), %rax
cmpq $0x0, 0x8(%rax)
je 0xbf49
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rdi
callq 0x1040
movq -0x8(%rbp), %rax
cmpq $0x0, 0x10(%rax)
je 0xbf61
movq -0x8(%rbp), %rax
movq 0x10(%rax), %rdi
callq 0x1040
movq -0x8(%rbp), %rax
cmpq $0x0, 0x18(%rax)
je 0xbf79
movq -0x8(%rbp), %rax
movq 0x18(%rax), %rdi
callq 0x1040
movq -0x8(%rbp), %rdi
callq 0x1040
addq $0x10, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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
movq %rsp, %rbp
subq $0x50, %rsp
movq %rdi, -0x10(%rbp)
movl %esi, -0x14(%rbp)
movq %rdx, -0x20(%rbp)
movl %ecx, -0x24(%rbp)
movq %r8, -0x30(%rbp)
movq %r9, -0x38(%rbp)
movq -0x30(%rbp), %rdi
callq 0xc080
movl $0x0, -0x3c(%rbp)
movq -0x10(%rbp), %rax
movw $0x2, (%rax)
movq -0x10(%rbp), %rax
movw $0x0, 0x2(%rax)
movq -0x20(%rbp), %rdi
movl -0x24(%rbp), %esi
movq -0x10(%rbp), %rcx
movl -0x14(%rbp), %r8d
movq -0x10(%rbp), %r9
movq -0x10(%rbp), %r10
addq $0x2, %r10
movq -0x38(%rbp), %rax
leaq -0x3c(%rbp), %rdx
movq %r10, (%rsp)
movq %rax, 0x8(%rsp)
callq 0xc0f0
cmpl $0x0, %eax
jne 0xc010
movl $0x0, -0x4(%rbp)
jmp 0xc06d
movq -0x10(%rbp), %rax
movzwl (%rax), %ecx
addl $0x3, %ecx
movw %cx, (%rax)
movq -0x10(%rbp), %rdi
movl -0x14(%rbp), %edx
movq -0x10(%rbp), %rcx
movl $0x2, %esi
callq 0xc2c0
cmpl $0x0, %eax
jne 0xc040
movl $0x0, -0x4(%rbp)
jmp 0xc06d
movq -0x10(%rbp), %rdi
movl -0x14(%rbp), %edx
movq -0x10(%rbp), %rcx
movl $0x2, %esi
callq 0xc550
cmpl $0x0, %eax
jne 0xc063
movl $0x0, -0x4(%rbp)
jmp 0xc06d
movq -0x10(%rbp), %rax
movzwl (%rax), %eax
movl %eax, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x50, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
cmpq $0x0, -0x8(%rbp)
je 0xc0e1
movq -0x8(%rbp), %rdi
callq 0x10a0
movl %eax, -0xc(%rbp)
cmpl $0x20, -0xc(%rbp)
jle 0xc0ac
movl $0x20, -0xc(%rbp)
movl $0x0, -0x10(%rbp)
movl -0x10(%rbp), %eax
cmpl -0xc(%rbp), %eax
jge 0xc0df
movq -0x8(%rbp), %rax
movslq -0x10(%rbp), %rcx
movb (%rax,%rcx), %dl
movslq -0x10(%rbp), %rcx
leaq 0x1800f(%rip), %rax     # 0x240e0
movb %dl, (%rax,%rcx)
movl -0x10(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x10(%rbp)
jmp 0xc0b3
jmp 0xc0e1
addq $0x10, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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
movq %rsp, %rbp
subq $0x30, %rsp
movq 0x18(%rbp), %rax
movq 0x10(%rbp), %rax
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl %edx, -0x14(%rbp)
movl %ecx, -0x18(%rbp)
movl %r8d, -0x1c(%rbp)
movq %r9, -0x28(%rbp)
movl -0x14(%rbp), %eax
movl %eax, -0x2c(%rbp)
movq 0x10(%rbp), %rdi
callq 0xc080
movq -0x8(%rbp), %rax
movq %rax, 0x195c0(%rip)     # 0x26220
movl $0x0, 0x195be(%rip)     # 0x26228
movq -0x10(%rbp), %rdi
movl -0x18(%rbp), %edx
movl -0x1c(%rbp), %ecx
movq -0x28(%rbp), %r8
movq 0x18(%rbp), %r9
leaq -0x2c(%rbp), %rsi
callq 0xcc90
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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
movq %rsp, %rbp
subq $0x60, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movl %edx, -0x1c(%rbp)
movl %ecx, -0x20(%rbp)
movq %r8, -0x28(%rbp)
movq %r9, -0x30(%rbp)
movq -0x28(%rbp), %rax
movzwl 0x2(%rax), %eax
movl %eax, %edi
shlq $0x2, %rdi
callq 0x1160
movq %rax, -0x40(%rbp)
cmpq $0x0, -0x40(%rbp)
jne 0xccf4
movl $0x7, %edi
leaq 0x115a0(%rip), %rsi     # 0x1e278
leaq 0x11f0d(%rip), %rdx     # 0x1ebec
movl $0x53d, %ecx            # imm = 0x53D
movb $0x0, %al
callq 0xf610
movl $0x0, -0x4(%rbp)
jmp 0xcd5d
movq -0x40(%rbp), %rdi
movq -0x28(%rbp), %rax
movzwl 0x2(%rax), %eax
movl %eax, %edx
shlq $0x2, %rdx
xorl %esi, %esi
callq 0x1100
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rsi
movl -0x1c(%rbp), %edx
movl -0x20(%rbp), %ecx
movq -0x28(%rbp), %r8
movq -0x30(%rbp), %r9
movq -0x40(%rbp), %rax
xorl %r10d, %r10d
movl $0x2, (%rsp)
movl $0x0, 0x8(%rsp)
movl $0x0, 0x10(%rsp)
movq %rax, 0x18(%rsp)
callq 0xdd50
movl %eax, -0x34(%rbp)
movq -0x40(%rbp), %rdi
callq 0x1040
movl -0x34(%rbp), %eax
movl %eax, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x60, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/MikeGray-APH[P]LibLouisAPH/source/pattern.c
// Function: attr_from_char
static void attr_from_char(unichar *attrs0, unichar *attrs1, const unichar uchar)
{
	int i;

	for(i = 0; i < 16; i++)
	if(attrs_chars[i] == uchar)
	{
		*attrs0 |= BIT(i);
		return;
	}

	for(i = 16; i < 32; i++)
	if(attrs_chars[i] == uchar)
	{
		*attrs1 |= BIT(i - 16);
		return;
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movw %dx, %ax
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movw %ax, -0x12(%rbp)
movl $0x0, -0x18(%rbp)
cmpl $0x10, -0x18(%rbp)
jge 0xdbe0
movslq -0x18(%rbp), %rcx
leaq 0x16535(%rip), %rax     # 0x240e0
movsbl (%rax,%rcx), %eax
movzwl -0x12(%rbp), %ecx
cmpl %ecx, %eax
jne 0xdbd3
movl -0x18(%rbp), %eax
movl %eax, %ecx
movl $0x1, %edx
shlq %cl, %rdx
movq -0x8(%rbp), %rax
movzwl (%rax), %ecx
orq %rdx, %rcx
movw %cx, (%rax)
jmp 0xdc32
jmp 0xdbd5
movl -0x18(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x18(%rbp)
jmp 0xdb9a
movl $0x10, -0x18(%rbp)
cmpl $0x20, -0x18(%rbp)
jge 0xdc32
movslq -0x18(%rbp), %rcx
leaq 0x164e8(%rip), %rax     # 0x240e0
movsbl (%rax,%rcx), %eax
movzwl -0x12(%rbp), %ecx
cmpl %ecx, %eax
jne 0xdc25
movl -0x18(%rbp), %eax
subl $0x10, %eax
movl %eax, %eax
movl %eax, %ecx
movl $0x1, %edx
shlq %cl, %rdx
movq -0x10(%rbp), %rax
movzwl (%rax), %ecx
orq %rdx, %rcx
movw %cx, (%rax)
jmp 0xdc32
jmp 0xdc27
movl -0x18(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x18(%rbp)
jmp 0xdbe7
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movl %edx, -0x1c(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x28(%rbp)
cmpq $0x0, -0x28(%rbp)
je 0xdcc9
movq -0x28(%rbp), %rax
movl 0x20(%rax), %eax
cmpl -0x1c(%rbp), %eax
jne 0xdcbc
movl $0x0, -0x2c(%rbp)
movl -0x2c(%rbp), %eax
cmpl -0x1c(%rbp), %eax
jge 0xdca8
movq -0x28(%rbp), %rax
movq 0x8(%rax), %rax
movslq -0x2c(%rbp), %rcx
movzwl (%rax,%rcx,2), %eax
movq -0x18(%rbp), %rcx
movslq -0x2c(%rbp), %rdx
movzwl (%rcx,%rdx,2), %ecx
cmpl %ecx, %eax
je 0xdc9b
jmp 0xdca8
jmp 0xdc9d
movl -0x2c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x2c(%rbp)
jmp 0xdc71
movl -0x2c(%rbp), %eax
cmpl -0x1c(%rbp), %eax
jne 0xdcba
movq -0x28(%rbp), %rax
movq %rax, -0x8(%rbp)
jmp 0xdcd1
jmp 0xdcbc
movq -0x28(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x28(%rbp)
jmp 0xdc57
movq $0x0, -0x8(%rbp)
movq -0x8(%rbp), %rax
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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 %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movq -0x8(%rbp), %rax
movslq -0xc(%rbp), %rcx
movzwl (%rax,%rcx,2), %eax
movl %eax, -0x10(%rbp)
addl $-0x2, %eax
subl $0x5, %eax
jb 0xdd2c
jmp 0xdd08
movl -0x10(%rbp), %eax
subl $0x7, %eax
jne 0xdd46
jmp 0xdd12
movq -0x8(%rbp), %rdi
movq -0x8(%rbp), %rax
movl -0xc(%rbp), %ecx
addl $0x4, %ecx
movslq %ecx, %rcx
movzwl (%rax,%rcx,2), %esi
callq 0xca50
movq -0x8(%rbp), %rdi
movq -0x8(%rbp), %rax
movl -0xc(%rbp), %ecx
addl $0x3, %ecx
movslq %ecx, %rcx
movzwl (%rax,%rcx,2), %esi
callq 0xca50
addq $0x10, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/MikeGray-APH[P]LibLouisAPH/source/pattern.c
// Function: pattern_check_attrs
static int pattern_check_attrs(const unichar input_char, const unichar *expr_data)
{
	int attrs;

	attrs = ((expr_data[1] << 16) | expr_data[0]);
	if(!(table_get_character_attributes(translate->tables[translate->table_crs], input_char) & attrs))
		return 0;
	return 1;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movw %di, %ax
movw %ax, -0x6(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x10(%rbp), %rax
movzwl 0x2(%rax), %eax
shll $0x10, %eax
movq -0x10(%rbp), %rcx
movzwl (%rcx), %ecx
orl %ecx, %eax
movl %eax, -0x14(%rbp)
movq 0x17ccf(%rip), %rax     # 0x26220
movq (%rax), %rax
movq 0x17cc5(%rip), %rcx     # 0x26220
movslq 0x8(%rcx), %rcx
movq (%rax,%rcx,8), %rdi
movzwl -0x6(%rbp), %esi
callq 0xe600
andl -0x14(%rbp), %eax
cmpl $0x0, %eax
jne 0xe57d
movl $0x0, -0x4(%rbp)
jmp 0xe584
movl $0x1, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/MikeGray-APH[P]LibLouisAPH/source/pattern.c
// Function: pattern_check_chars
static int pattern_check_chars(const unichar input_char, const unichar *expr_data)
{
	int expr_cnt, i;

	expr_cnt = expr_data[0] + 1;

	for(i = 1; i < expr_cnt; i++)
	if(input_char == expr_data[i])
		break;

	if(i == expr_cnt)
		return 0;
	return 1;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movw %di, %ax
movw %ax, -0x6(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x10(%rbp), %rax
movzwl (%rax), %eax
addl $0x1, %eax
movl %eax, -0x14(%rbp)
movl $0x1, -0x18(%rbp)
movl -0x18(%rbp), %eax
cmpl -0x14(%rbp), %eax
jge 0xe5de
movzwl -0x6(%rbp), %eax
movq -0x10(%rbp), %rcx
movslq -0x18(%rbp), %rdx
movzwl (%rcx,%rdx,2), %ecx
cmpl %ecx, %eax
jne 0xe5d1
jmp 0xe5de
jmp 0xe5d3
movl -0x18(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x18(%rbp)
jmp 0xe5b3
movl -0x18(%rbp), %eax
cmpl -0x14(%rbp), %eax
jne 0xe5ef
movl $0x0, -0x4(%rbp)
jmp 0xe5f6
movl $0x1, -0x4(%rbp)
movl -0x4(%rbp), %eax
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/MikeGray-APH[P]LibLouisAPH/source/table.h
// Function: table_get_character_attributes
static inline unsigned int table_get_character_attributes(const struct table *table, const unichar uchar)
{
	struct character *character;

	character = table_find_character(table, uchar);
	if(character)
		return character->attrs;
	else
		return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movw %si, %ax
movq %rdi, -0x10(%rbp)
movw %ax, -0x12(%rbp)
movq -0x10(%rbp), %rdi
movzwl -0x12(%rbp), %esi
callq 0x2900
movq %rax, -0x20(%rbp)
cmpq $0x0, -0x20(%rbp)
je 0xe637
movq -0x20(%rbp), %rax
movl 0x24(%rax), %eax
movl %eax, -0x4(%rbp)
jmp 0xe63e
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x20, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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 %rbp
movq %rsp, %rbp
movq 0x17bd5(%rip), %rdi     # 0x26230
callq 0x2850
movq $0x0, 0x17bc5(%rip) # 0x26230
movq 0x17bc6(%rip), %rdi     # 0x26238
callq 0x46d0
movq $0x0, 0x17bb6(%rip) # 0x26238
cmpq $0x0, 0x17bb6(%rip)     # 0x26240
je 0xe6ad
movq 0x17bad(%rip), %rdi     # 0x26240
callq 0x1040
movq $0x0, 0x17b9d(%rip) # 0x26240
movl $0x0, 0x17b9b(%rip)     # 0x26248
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/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 %rbp
movq %rsp, %rbp
cmpl $0x0, 0x17b21(%rip)     # 0x2624c
je 0xe72f
jmp 0xe73e
movl $0x1, 0x17b13(%rip)     # 0x2624c
callq 0xf530
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O0/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
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movl %esi, -0x14(%rbp)
callq 0xe720
cmpq $0x0, 0x17ae4(%rip)     # 0x26240
jne 0xe76e
movq -0x10(%rbp), %rax
movb $0x0, (%rax)
movl $0x0, -0x4(%rbp)
jmp 0xe7b3
movl 0x17ad4(%rip), %eax     # 0x26248
cmpl -0x14(%rbp), %eax
jl 0xe784
movl -0x14(%rbp), %eax
subl $0x1, %eax
movl %eax, -0x18(%rbp)
jmp 0xe78d
movl 0x17abe(%rip), %eax     # 0x26248
movl %eax, -0x18(%rbp)
movq -0x10(%rbp), %rdi
movq 0x17aa8(%rip), %rsi     # 0x26240
movslq -0x18(%rbp), %rdx
callq 0x1150
movq -0x10(%rbp), %rax
movslq -0x18(%rbp), %rcx
movb $0x0, (%rax,%rcx)
movl -0x18(%rbp), %eax
movl %eax, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/MikeGray-APH[P]LibLouisAPH/source/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 %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x10(%rbp)
callq 0xe720
cmpq $0x0, 0x17a67(%rip)     # 0x26240
je 0xe7e7
movq 0x17a5e(%rip), %rdi     # 0x26240
callq 0x1040
cmpq $0x0, -0x10(%rbp)
jne 0xe80c
movq $0x0, 0x17a47(%rip) # 0x26240
movl $0x0, 0x17a45(%rip)     # 0x26248
movl $0x1, -0x4(%rbp)
jmp 0xe87e
movq -0x10(%rbp), %rdi
callq 0x10a0
movl %eax, 0x17a2d(%rip)     # 0x26248
movl 0x17a27(%rip), %eax     # 0x26248
addl $0x1, %eax
movslq %eax, %rdi
callq 0x1160
movq %rax, 0x17a0d(%rip)     # 0x26240
cmpq $0x0, 0x17a05(%rip)     # 0x26240
jne 0xe865
movl $0x7, %edi
leaq 0xfa2f(%rip), %rsi      # 0x1e278
leaq 0x103ad(%rip), %rdx     # 0x1ebfd
movl $0xab, %ecx
movb $0x0, %al
callq 0xf610
movl $0x0, -0x4(%rbp)
jmp 0xe87e
movq 0x179d4(%rip), %rdi     # 0x26240
movq -0x10(%rbp), %rsi
callq 0x1070
movl 0x179cd(%rip), %eax     # 0x26248
movl %eax, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x10, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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 %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
callq 0xe720
cmpq $0x0, -0x10(%rbp)
jne 0xe8b6
movl 0x1799a(%rip), %eax     # 0x26248
movl %eax, -0x4(%rbp)
jmp 0xe9da
cmpq $0x0, 0x17982(%rip)     # 0x26240
jne 0xe931
movq -0x10(%rbp), %rdi
callq 0x10a0
movl %eax, 0x17979(%rip)     # 0x26248
movl 0x17973(%rip), %eax     # 0x26248
addl $0x1, %eax
movslq %eax, %rdi
callq 0x1160
movq %rax, 0x17959(%rip)     # 0x26240
cmpq $0x0, 0x17951(%rip)     # 0x26240
jne 0xe91c
movl $0x7, %edi
leaq 0xf97b(%rip), %rsi      # 0x1e278
leaq 0x102f9(%rip), %rdx     # 0x1ebfd
movl $0xc2, %ecx
movb $0x0, %al
callq 0xf610
movl $0x0, -0x4(%rbp)
jmp 0xe9da
movq 0x1791d(%rip), %rdi     # 0x26240
movq -0x10(%rbp), %rsi
callq 0x1070
jmp 0xe9d1
movq -0x10(%rbp), %rdi
callq 0x10a0
movl %eax, -0x14(%rbp)
movl -0x14(%rbp), %eax
addl $0x1, %eax
addl 0x178ff(%rip), %eax     # 0x26248
movl %eax, 0x178f9(%rip)     # 0x26248
movq 0x178ea(%rip), %rdi     # 0x26240
movl 0x178ec(%rip), %eax     # 0x26248
addl $0x1, %eax
movslq %eax, %rsi
callq 0x1180
movq %rax, 0x178d2(%rip)     # 0x26240
cmpq $0x0, 0x178ca(%rip)     # 0x26240
jne 0xe9a0
movl $0x7, %edi
leaq 0xf8f4(%rip), %rsi      # 0x1e278
leaq 0x10272(%rip), %rdx     # 0x1ebfd
movl $0xce, %ecx
movb $0x0, %al
callq 0xf610
movl $0x0, -0x4(%rbp)
jmp 0xe9da
movq 0x17899(%rip), %rdi     # 0x26240
leaq 0x1025f(%rip), %rsi     # 0x1ec0d
movl $0x2, %edx
callq 0x1110
movq 0x17881(%rip), %rdi     # 0x26240
movq -0x10(%rbp), %rsi
movl -0x14(%rbp), %eax
addl $0x1, %eax
movslq %eax, %rdx
callq 0x1110
movl 0x17871(%rip), %eax     # 0x26248
movl %eax, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/MikeGray-APH[P]LibLouisAPH/source/lookup.c
// Function: find_table
static struct table* find_table(const char *file_name, const int file_name_max)
{
	struct table *table;

	table = table_list;
	while(table)
	{
		if(!strncmp(file_name, table->file_name, file_name_max))
			return table;
		table = table->nxt;
	}
	return NULL;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movl %esi, -0x14(%rbp)
movq 0x1760a(%rip), %rax     # 0x26230
movq %rax, -0x20(%rbp)
cmpq $0x0, -0x20(%rbp)
je 0xec62
movq -0x10(%rbp), %rdi
movq -0x20(%rbp), %rax
movq 0x10(%rax), %rsi
movslq -0x14(%rbp), %rdx
callq 0x1060
cmpl $0x0, %eax
jne 0xec55
movq -0x20(%rbp), %rax
movq %rax, -0x8(%rbp)
jmp 0xec6a
movq -0x20(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x20(%rbp)
jmp 0xec2a
movq $0x0, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/MikeGray-APH[P]LibLouisAPH/source/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 %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x10(%rbp)
movl %esi, -0x14(%rbp)
movq %rdx, -0x20(%rbp)
movl %ecx, -0x24(%rbp)
movq %r8, -0x30(%rbp)
movl %r9d, -0x34(%rbp)
cmpl $0x1, -0x24(%rbp)
jge 0xecb0
movl $0x0, -0x4(%rbp)
jmp 0xed40
movl $0x0, -0x38(%rbp)
movl -0x38(%rbp), %eax
cmpl -0x24(%rbp), %eax
jge 0xecdf
movq -0x20(%rbp), %rax
movslq -0x38(%rbp), %rcx
movsbl (%rax,%rcx), %eax
cmpl $0x3a, %eax
jne 0xecd2
jmp 0xecdf
jmp 0xecd4
movl -0x38(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x38(%rbp)
jmp 0xecb7
movl -0x38(%rbp), %eax
movl -0x14(%rbp), %ecx
movl -0x34(%rbp), %edx
addl $0x1, %edx
subl %edx, %ecx
cmpl %ecx, %eax
jl 0xecfa
movl $0x0, -0x4(%rbp)
jmp 0xed40
cmpl $0x0, -0x38(%rbp)
jg 0xed05
callq 0x1050
movq -0x10(%rbp), %rdi
movq -0x20(%rbp), %rsi
movslq -0x38(%rbp), %rdx
callq 0x1150
movq -0x10(%rbp), %rax
movslq -0x38(%rbp), %rcx
movb $0x2f, (%rax,%rcx)
movq -0x10(%rbp), %rdi
movl -0x38(%rbp), %eax
addl $0x1, %eax
cltq
addq %rax, %rdi
movq -0x30(%rbp), %rsi
callq 0x1070
movl -0x38(%rbp), %eax
movl %eax, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x40, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/MikeGray-APH[P]LibLouisAPH/source/lookup.c
// Function: find_conversion
static struct conversion* find_conversion(const char *file_name, const int file_name_max)
{
	struct conversion *conversion;

	conversion = conversion_list;
	while(conversion)
	{
		if(!strncmp(file_name, conversion->file_name, file_name_max))
			return conversion;
		conversion = conversion->nxt;
	}
	return NULL;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movl %esi, -0x14(%rbp)
movq 0x16fb2(%rip), %rax     # 0x26238
movq %rax, -0x20(%rbp)
cmpq $0x0, -0x20(%rbp)
je 0xf2c2
movq -0x10(%rbp), %rdi
movq -0x20(%rbp), %rax
movq 0x8(%rax), %rsi
movslq -0x14(%rbp), %rdx
callq 0x1060
cmpl $0x0, %eax
jne 0xf2b5
movq -0x20(%rbp), %rax
movq %rax, -0x8(%rbp)
jmp 0xf2ca
movq -0x20(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x20(%rbp)
jmp 0xf28a
movq $0x0, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/MikeGray-APH[P]LibLouisAPH/source/lookup.c
// Function: lookup_env
static void lookup_env(void)
{
	char *env;

	env = getenv("LOUIS_TABLEPATH");
	if(!env)
		return;

	if(table_paths)
	{
		log_message(LOG_FATAL, "table_paths already set while checking LOUIS_TABLEPATH");
		return;
	}

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

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
leaq 0xf743(%rip), %rdi      # 0x1ec82
callq 0x1030
movq %rax, -0x8(%rbp)
cmpq $0x0, -0x8(%rbp)
jne 0xf554
jmp 0xf5d5
cmpq $0x0, 0x16ce4(%rip)     # 0x26240
je 0xf573
movl $0x7, %edi
leaq 0xf6f1(%rip), %rsi      # 0x1ec5b
movb $0x0, %al
callq 0xf610
jmp 0xf5d5
movq -0x8(%rbp), %rdi
callq 0x10a0
movl %eax, 0x16cc6(%rip)     # 0x26248
movl 0x16cc0(%rip), %eax     # 0x26248
addl $0x1, %eax
movslq %eax, %rdi
callq 0x1160
movq %rax, 0x16ca6(%rip)     # 0x26240
cmpq $0x0, 0x16c9e(%rip)     # 0x26240
jne 0xf5c5
movl $0x7, %edi
leaq 0xecc8(%rip), %rsi      # 0x1e278
leaq 0xf646(%rip), %rdx      # 0x1ebfd
movl $0x4a, %ecx
movb $0x0, %al
callq 0xf610
jmp 0xf5d5
movq 0x16c74(%rip), %rdi     # 0x26240
movq -0x8(%rbp), %rsi
callq 0x1070
addq $0x10, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/MikeGray-APH[P]LibLouisAPH/source/log.c
// Function: convert_number
static int convert_number(char *buffer, const int buffer_max, const unsigned int number, const int base)
{
	unsigned int digit;
	char *crs, remain;
	char buf[71];
	int buf_len, cnt;

	crs = buf;
	digit = number;
	buf_len = 0;
	do
	{
		remain = (char)(digit % base);
		*crs++ = (remain < 10) ? remain + '0' : (remain - 10) + 'a';
		buf_len++;
		if(buf_len >= 71)
			break;
 	}
 	while(digit /= base);

 	crs--;
 	for(cnt = 0; cnt < buffer_max - 1; cnt++)
 	{
		buffer[cnt] = *crs;
		crs--;
		if(crs < buf)
			break;
	}
	cnt++;
	buffer[cnt] = 0;

	/*   return buf_len instead of cnt to behave like snprintf   */
	return buf_len;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movl %edx, -0x10(%rbp)
movl %ecx, -0x14(%rbp)
leaq -0x70(%rbp), %rax
movq %rax, -0x20(%rbp)
movl -0x10(%rbp), %eax
movl %eax, -0x18(%rbp)
movl $0x0, -0x74(%rbp)
movl -0x18(%rbp), %eax
xorl %edx, %edx
divl -0x14(%rbp)
movb %dl, %al
movb %al, -0x21(%rbp)
movsbl -0x21(%rbp), %eax
cmpl $0xa, %eax
jge 0x101d8
movsbl -0x21(%rbp), %eax
addl $0x30, %eax
movl %eax, -0x7c(%rbp)
jmp 0x101e5
movsbl -0x21(%rbp), %eax
subl $0xa, %eax
addl $0x61, %eax
movl %eax, -0x7c(%rbp)
movl -0x7c(%rbp), %eax
movb %al, %cl
movq -0x20(%rbp), %rax
movq %rax, %rdx
addq $0x1, %rdx
movq %rdx, -0x20(%rbp)
movb %cl, (%rax)
movl -0x74(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x74(%rbp)
cmpl $0x47, -0x74(%rbp)
jl 0x1020c
jmp 0x10220
jmp 0x1020e
movl -0x14(%rbp), %ecx
movl -0x18(%rbp), %eax
xorl %edx, %edx
divl %ecx
movl %eax, -0x18(%rbp)
cmpl $0x0, %eax
jne 0x101b6
movq -0x20(%rbp), %rax
addq $-0x1, %rax
movq %rax, -0x20(%rbp)
movl $0x0, -0x78(%rbp)
movl -0x78(%rbp), %eax
movl -0xc(%rbp), %ecx
subl $0x1, %ecx
cmpl %ecx, %eax
jge 0x10279
movq -0x20(%rbp), %rax
movb (%rax), %dl
movq -0x8(%rbp), %rax
movslq -0x78(%rbp), %rcx
movb %dl, (%rax,%rcx)
movq -0x20(%rbp), %rax
addq $-0x1, %rax
movq %rax, -0x20(%rbp)
movq -0x20(%rbp), %rax
leaq -0x70(%rbp), %rcx
cmpq %rcx, %rax
jae 0x1026c
jmp 0x10279
jmp 0x1026e
movl -0x78(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x78(%rbp)
jmp 0x10233
movl -0x78(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x78(%rbp)
movq -0x8(%rbp), %rax
movslq -0x78(%rbp), %rcx
movb $0x0, (%rax,%rcx)
movl -0x74(%rbp), %eax
popq %rbp
retq
nopw %cs:(%rax,%rax)
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/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
movq %rsp, %rbp
subq $0x20, %rsp
movw %cx, %ax
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movl %edx, -0x1c(%rbp)
movw %ax, -0x1e(%rbp)
movq -0x10(%rbp), %rax
movl $0x1, 0x94(%rax)
cmpw $0x0, -0x1e(%rbp)
je 0x102ec
movq -0x10(%rbp), %rdi
movzwl -0x1e(%rbp), %esi
callq 0x10340
cmpl $0x0, %eax
jne 0x102ea
movl $0x0, -0x4(%rbp)
jmp 0x10335
jmp 0x102ec
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rsi
movl -0x1c(%rbp), %edx
callq 0xab20
cmpl $0x0, %eax
jne 0x1030a
movl $0x0, -0x4(%rbp)
jmp 0x10335
cmpw $0x0, -0x1e(%rbp)
je 0x1032e
movq -0x10(%rbp), %rdi
movzwl -0x1e(%rbp), %esi
callq 0x10340
cmpl $0x0, %eax
jne 0x1032c
movl $0x0, -0x4(%rbp)
jmp 0x10335
jmp 0x1032e
movl $0x1, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x20, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/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
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movq -0x10(%rbp), %rax
movq (%rax), %rax
movq -0x10(%rbp), %rcx
movl 0xc(%rcx), %ecx
subl $0x1, %ecx
movslq %ecx, %rcx
movq (%rax,%rcx,8), %rax
movq %rax, -0x18(%rbp)
movq -0x10(%rbp), %rax
movl 0xc(%rax), %ecx
subl $0x1, %ecx
movq -0x10(%rbp), %rax
movl %ecx, 0x8(%rax)
movl $0x0, -0x20(%rbp)
movl $0x0, -0x1c(%rbp)
movl -0x1c(%rbp), %eax
movq -0x10(%rbp), %rcx
cmpl 0x44(%rcx), %eax
jge 0x104bf
movq -0x10(%rbp), %rax
movq 0x38(%rax), %rax
movslq -0x1c(%rbp), %rcx
movzwl (%rax,%rcx,2), %eax
movq -0x18(%rbp), %rcx
movzwl 0x1f4(%rcx), %ecx
cmpl %ecx, %eax
jne 0x10425
movq -0x10(%rbp), %rdi
movl -0x1c(%rbp), %esi
movq -0x18(%rbp), %rax
movzwl 0x1f4(%rax), %edx
callq 0x104f0
movl %eax, -0x1c(%rbp)
cmpl $0x0, -0x1c(%rbp)
jne 0x10412
movl $0x0, -0x4(%rbp)
jmp 0x104e6
movq -0x10(%rbp), %rax
movl $0x1, 0x94(%rax)
jmp 0x104ba
movq -0x10(%rbp), %rax
movq 0x38(%rax), %rax
movslq -0x1c(%rbp), %rcx
movw (%rax,%rcx,2), %dx
movq -0x10(%rbp), %rax
movq 0x60(%rax), %rax
movslq -0x20(%rbp), %rcx
movw %dx, (%rax,%rcx,2)
movq -0x10(%rbp), %rax
movq 0x58(%rax), %rax
movslq -0x1c(%rbp), %rcx
movb (%rax,%rcx), %dl
movq -0x10(%rbp), %rax
movq 0x80(%rax), %rax
movslq -0x20(%rbp), %rcx
movb %dl, (%rax,%rcx)
movq -0x10(%rbp), %rax
cmpl $0x0, 0x90(%rax)
je 0x10491
movq -0x10(%rbp), %rax
movq 0x50(%rax), %rax
movslq -0x1c(%rbp), %rcx
movl (%rax,%rcx,4), %edx
movq -0x10(%rbp), %rax
movq 0x78(%rax), %rax
movslq -0x20(%rbp), %rcx
movl %edx, (%rax,%rcx,4)
movl -0x1c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x1c(%rbp)
movl -0x20(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x20(%rbp)
movl -0x20(%rbp), %eax
movq -0x10(%rbp), %rcx
cmpl 0x6c(%rcx), %eax
jl 0x104b8
movl $0x0, -0x4(%rbp)
jmp 0x104e6
jmp 0x104ba
jmp 0x103b7
movl -0x20(%rbp), %ecx
movq -0x10(%rbp), %rax
movl %ecx, 0x68(%rax)
movq -0x10(%rbp), %rax
movq 0x60(%rax), %rax
movq -0x10(%rbp), %rcx
movslq 0x68(%rcx), %rcx
movw $0x0, (%rax,%rcx,2)
movl $0x1, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x20, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/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:
pushq %rbp
movq %rsp, %rbp
movw %dx, %ax
movq %rdi, -0x10(%rbp)
movl %esi, -0x14(%rbp)
movw %ax, -0x16(%rbp)
movl -0x14(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x1c(%rbp)
movl -0x1c(%rbp), %eax
movq -0x10(%rbp), %rcx
cmpl 0x44(%rcx), %eax
jge 0x1053e
movq -0x10(%rbp), %rax
movq 0x38(%rax), %rax
movslq -0x1c(%rbp), %rcx
movzwl (%rax,%rcx,2), %eax
movzwl -0x16(%rbp), %ecx
cmpl %ecx, %eax
jne 0x10531
jmp 0x1053e
jmp 0x10533
movl -0x1c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x1c(%rbp)
jmp 0x1050b
movl -0x1c(%rbp), %eax
movq -0x10(%rbp), %rcx
cmpl 0x44(%rcx), %eax
jl 0x10553
movl $0x0, -0x4(%rbp)
jmp 0x1055c
movl -0x1c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x4(%rbp)
movl -0x4(%rbp), %eax
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/MikeGray-APH[P]LibLouisAPH/source/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
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movq -0x10(%rbp), %rax
movq (%rax), %rax
movq -0x10(%rbp), %rcx
movl 0xc(%rcx), %ecx
subl $0x1, %ecx
movslq %ecx, %rcx
movq (%rax,%rcx,8), %rax
movq %rax, -0x18(%rbp)
movq -0x10(%rbp), %rax
movl 0xc(%rax), %ecx
subl $0x1, %ecx
movq -0x10(%rbp), %rax
movl %ecx, 0x8(%rax)
movq -0x10(%rbp), %rax
movl $0x0, 0x68(%rax)
movq -0x10(%rbp), %rax
movl $0x0, 0x40(%rax)
movq -0x10(%rbp), %rax
movl 0x40(%rax), %eax
movq -0x10(%rbp), %rcx
cmpl 0x44(%rcx), %eax
jge 0x107c5
movq -0x10(%rbp), %rax
movq 0x38(%rax), %rax
movq -0x10(%rbp), %rcx
movslq 0x40(%rcx), %rcx
movzwl (%rax,%rcx,2), %eax
movq -0x18(%rbp), %rcx
movzwl 0x1ee(%rcx), %ecx
cmpl %ecx, %eax
jne 0x107a0
movq -0x10(%rbp), %rax
movl $0x1, 0x94(%rax)
movq -0x10(%rbp), %rdi
movl $0x1, %esi
xorl %edx, %edx
callq 0xa9a0
cmpl $0x0, %eax
jne 0x1079e
movl $0x0, -0x4(%rbp)
jmp 0x107e2
jmp 0x107c0
movq -0x10(%rbp), %rdi
movl $0x1, %edx
movl %edx, %esi
callq 0xaeb0
cmpl $0x0, %eax
jne 0x107be
movl $0x0, -0x4(%rbp)
jmp 0x107e2
jmp 0x107c0
jmp 0x1073f
movq -0x10(%rbp), %rax
movq 0x60(%rax), %rax
movq -0x10(%rbp), %rcx
movslq 0x68(%rcx), %rcx
movw $0x0, (%rax,%rcx,2)
movl $0x1, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax,%rax)