LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O0/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
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 0x108ec
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 0x10899
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
jne 0x108c7
movq -0x10(%rbp), %rax
movl $0x1, 0x94(%rax)
movq -0x10(%rbp), %rdi
movl $0x1, %esi
xorl %edx, %edx
callq 0xa9a0
cmpl $0x0, %eax
jne 0x108c5
movl $0x0, -0x4(%rbp)
jmp 0x10909
jmp 0x108e7
movq -0x10(%rbp), %rdi
movl $0x1, %edx
movl %edx, %esi
callq 0xaeb0
cmpl $0x0, %eax
jne 0x108e5
movl $0x0, -0x4(%rbp)
jmp 0x10909
jmp 0x108e7
jmp 0x1083f
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
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/MikeGray-APH[P]LibLouisAPH/source/languages/generic-common.c
// Function: generic_match_rule
static const struct rule* generic_match_rule(struct translate *translate, const enum table_hash_type hash_type, const enum rule_direction direction, const unsigned int contract)
{
	const struct rule *rule;
	const unichar *input;
	int len;

	for(translate->table_crs = 0; translate->table_crs < translate->table_cnt; translate->table_crs++)
	{
		input = &translate->input[translate->input_crs];
		len = translate->input_len - translate->input_crs;

		rule = table_match_rule(translate->tables[translate->table_crs], hash_type, direction, input, len, NULL);

		while(rule)
		{
#ifdef PATTERN_OUTPUT_TRACE
			current_hash_type = hash_type;
#endif
			if(contract || !(rule->attrs & RULE_CONTRACTION))
			if(!rule_is_filtered(translate, rule, direction))
				return rule;

			rule = table_match_rule(translate->tables[translate->table_crs], hash_type, direction, input, len, rule);
		}
	}

	return NULL;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x10(%rbp)
movl %esi, -0x14(%rbp)
movl %edx, -0x18(%rbp)
movl %ecx, -0x1c(%rbp)
movq -0x10(%rbp), %rax
movl $0x0, 0x8(%rax)
movq -0x10(%rbp), %rax
movl 0x8(%rax), %eax
movq -0x10(%rbp), %rcx
cmpl 0xc(%rcx), %eax
jge 0x10c8e
movq -0x10(%rbp), %rax
movq 0x38(%rax), %rax
movq -0x10(%rbp), %rcx
movslq 0x40(%rcx), %rcx
shlq %rcx
addq %rcx, %rax
movq %rax, -0x30(%rbp)
movq -0x10(%rbp), %rax
movl 0x44(%rax), %eax
movq -0x10(%rbp), %rcx
subl 0x40(%rcx), %eax
movl %eax, -0x34(%rbp)
movq -0x10(%rbp), %rax
movq (%rax), %rax
movq -0x10(%rbp), %rcx
movslq 0x8(%rcx), %rcx
movq (%rax,%rcx,8), %rdi
movl -0x14(%rbp), %esi
movl -0x18(%rbp), %edx
movq -0x30(%rbp), %rcx
movl -0x34(%rbp), %r8d
xorl %eax, %eax
movl %eax, %r9d
callq 0x3e20
movq %rax, -0x28(%rbp)
cmpq $0x0, -0x28(%rbp)
je 0x10c7a
cmpl $0x0, -0x1c(%rbp)
jne 0x10c29
movq -0x28(%rbp), %rax
movl (%rax), %eax
andl $0x1, %eax
cmpl $0x0, %eax
jne 0x10c4a
movq -0x10(%rbp), %rdi
movq -0x28(%rbp), %rsi
movl -0x18(%rbp), %edx
callq 0x10d10
cmpl $0x0, %eax
jne 0x10c48
movq -0x28(%rbp), %rax
movq %rax, -0x8(%rbp)
jmp 0x10c96
jmp 0x10c4a
movq -0x10(%rbp), %rax
movq (%rax), %rax
movq -0x10(%rbp), %rcx
movslq 0x8(%rcx), %rcx
movq (%rax,%rcx,8), %rdi
movl -0x14(%rbp), %esi
movl -0x18(%rbp), %edx
movq -0x30(%rbp), %rcx
movl -0x34(%rbp), %r8d
movq -0x28(%rbp), %r9
callq 0x3e20
movq %rax, -0x28(%rbp)
jmp 0x10c0e
jmp 0x10c7c
movq -0x10(%rbp), %rax
movl 0x8(%rax), %ecx
addl $0x1, %ecx
movl %ecx, 0x8(%rax)
jmp 0x10ba0
movq $0x0, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x40, %rsp
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O0/MikeGray-APH[P]LibLouisAPH/source/languages/generic-common.c
// Function: generic_apply_rule
static int generic_apply_rule(struct translate *translate, const struct rule *rule, const enum rule_direction direction)
{
	switch(direction)
	{
	case FORWARD:   return generic_apply_rule_forward(translate, rule);
	case BACKWARD:  return generic_apply_rule_backward(translate, rule);
	case BOTH:  ;
	}

	ASSERT(0)
	return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movl %edx, -0x1c(%rbp)
movl -0x1c(%rbp), %eax
movl %eax, -0x20(%rbp)
subl $-0x1, %eax
je 0x10ce5
jmp 0x10cc0
movl -0x20(%rbp), %eax
testl %eax, %eax
je 0x10cf7
jmp 0x10cc9
movl -0x20(%rbp), %eax
subl $0x1, %eax
jne 0x10cf9
jmp 0x10cd3
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rsi
callq 0x10f90
movl %eax, -0x4(%rbp)
jmp 0x10cfe
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rsi
callq 0x110c0
movl %eax, -0x4(%rbp)
jmp 0x10cfe
jmp 0x10cf9
callq 0x1050
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/languages/generic-common.c
// Function: generic_apply_rule_forward
static int generic_apply_rule_forward(struct translate *translate, const struct rule *rule)
{
	int i;

	if(!translate_check_output_max(translate, rule->dots_len))
		return 0;

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

		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 < rule->chars_len; i++)

	/*   no mapping when rule just removes input   */
	if(rule->dots_len <= 0)
		translate_remap_input(translate, i, 1);
	else
		translate_remap_input(translate, i, 0);

	translate_increment(translate, rule->chars_len, rule->dots_len);

	return 1;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rax
movl 0x78(%rax), %esi
callq 0xa830
cmpl $0x0, %eax
jne 0x10fc1
movl $0x0, -0x4(%rbp)
jmp 0x110b7
movl $0x0, -0x1c(%rbp)
movl -0x1c(%rbp), %eax
movq -0x18(%rbp), %rcx
cmpl 0x78(%rcx), %eax
jge 0x1103f
movq -0x18(%rbp), %rax
movslq -0x1c(%rbp), %rcx
movw 0x46(%rax,%rcx,2), %dx
movq -0x10(%rbp), %rax
movq 0x60(%rax), %rax
movq -0x10(%rbp), %rcx
movl 0x68(%rcx), %ecx
addl -0x1c(%rbp), %ecx
movslq %ecx, %rcx
movw %dx, (%rax,%rcx,2)
movq -0x10(%rbp), %rax
cmpl $0x0, 0x90(%rax)
je 0x11032
movq -0x10(%rbp), %rax
movq 0x50(%rax), %rax
movq -0x10(%rbp), %rcx
movslq 0x40(%rcx), %rcx
movl (%rax,%rcx,4), %edx
movq -0x10(%rbp), %rax
movq 0x78(%rax), %rax
movq -0x10(%rbp), %rcx
movl 0x68(%rcx), %ecx
addl -0x1c(%rbp), %ecx
movslq %ecx, %rcx
movl %edx, (%rax,%rcx,4)
jmp 0x11034
movl -0x1c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x1c(%rbp)
jmp 0x10fc8
movq -0x10(%rbp), %rax
cmpl $0x0, 0x90(%rax)
je 0x11099
movl $0x0, -0x1c(%rbp)
movl -0x1c(%rbp), %eax
movq -0x18(%rbp), %rcx
cmpl 0x74(%rcx), %eax
jge 0x11097
movq -0x18(%rbp), %rax
cmpl $0x0, 0x78(%rax)
jg 0x1107c
movq -0x10(%rbp), %rdi
movl -0x1c(%rbp), %esi
movl $0x1, %edx
callq 0x111f0
jmp 0x1108a
movq -0x10(%rbp), %rdi
movl -0x1c(%rbp), %esi
xorl %edx, %edx
callq 0x111f0
jmp 0x1108c
movl -0x1c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x1c(%rbp)
jmp 0x11053
jmp 0x11099
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rax
movl 0x74(%rax), %esi
movq -0x18(%rbp), %rax
movl 0x78(%rax), %edx
callq 0x11340
movl $0x1, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x20, %rsp
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O0/MikeGray-APH[P]LibLouisAPH/source/languages/generic-common.c
// Function: generic_apply_rule_backward
static int generic_apply_rule_backward(struct translate *translate, const struct rule *rule)
{
	int i;

	if(!translate_check_output_max(translate, rule->chars_len))
		return 0;

	for(i = 0; i < rule->chars_len; i++)
	{
		translate->output[translate->output_len + i] = rule->chars[i];

		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 < rule->dots_len; i++)

	/*   no mapping when rule just removes input   */
	if(rule->chars_len <= 0)
		translate_remap_input(translate, i, 1);
	else
		translate_remap_input(translate, i, 0);

	translate_increment(translate, rule->dots_len, rule->chars_len);

	return 1;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rax
movl 0x74(%rax), %esi
callq 0xa830
cmpl $0x0, %eax
jne 0x110f1
movl $0x0, -0x4(%rbp)
jmp 0x111e7
movl $0x0, -0x1c(%rbp)
movl -0x1c(%rbp), %eax
movq -0x18(%rbp), %rcx
cmpl 0x74(%rcx), %eax
jge 0x1116f
movq -0x18(%rbp), %rax
movslq -0x1c(%rbp), %rcx
movw 0x18(%rax,%rcx,2), %dx
movq -0x10(%rbp), %rax
movq 0x60(%rax), %rax
movq -0x10(%rbp), %rcx
movl 0x68(%rcx), %ecx
addl -0x1c(%rbp), %ecx
movslq %ecx, %rcx
movw %dx, (%rax,%rcx,2)
movq -0x10(%rbp), %rax
cmpl $0x0, 0x90(%rax)
je 0x11162
movq -0x10(%rbp), %rax
movq 0x50(%rax), %rax
movq -0x10(%rbp), %rcx
movslq 0x40(%rcx), %rcx
movl (%rax,%rcx,4), %edx
movq -0x10(%rbp), %rax
movq 0x78(%rax), %rax
movq -0x10(%rbp), %rcx
movl 0x68(%rcx), %ecx
addl -0x1c(%rbp), %ecx
movslq %ecx, %rcx
movl %edx, (%rax,%rcx,4)
jmp 0x11164
movl -0x1c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x1c(%rbp)
jmp 0x110f8
movq -0x10(%rbp), %rax
cmpl $0x0, 0x90(%rax)
je 0x111c9
movl $0x0, -0x1c(%rbp)
movl -0x1c(%rbp), %eax
movq -0x18(%rbp), %rcx
cmpl 0x78(%rcx), %eax
jge 0x111c7
movq -0x18(%rbp), %rax
cmpl $0x0, 0x74(%rax)
jg 0x111ac
movq -0x10(%rbp), %rdi
movl -0x1c(%rbp), %esi
movl $0x1, %edx
callq 0x111f0
jmp 0x111ba
movq -0x10(%rbp), %rdi
movl -0x1c(%rbp), %esi
xorl %edx, %edx
callq 0x111f0
jmp 0x111bc
movl -0x1c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x1c(%rbp)
jmp 0x11183
jmp 0x111c9
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rax
movl 0x78(%rax), %esi
movq -0x18(%rbp), %rax
movl 0x74(%rax), %edx
callq 0x11340
movl $0x1, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x20, %rsp
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O0/MikeGray-APH[P]LibLouisAPH/source/translate.h
// Function: translate_get_init_chars_hash_cnt
static inline int translate_get_init_chars_hash_cnt(const struct translate *translate)
{
	int cnt, i;

	cnt = 0;
	for(i = 0; i < translate->table_cnt; i++)
		cnt += translate->tables[i]->init_chars_hash_cnt;
	return cnt;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movl $0x0, -0xc(%rbp)
movl $0x0, -0x10(%rbp)
movl -0x10(%rbp), %eax
movq -0x8(%rbp), %rcx
cmpl 0xc(%rcx), %eax
jge 0x119e8
movq -0x8(%rbp), %rax
movq (%rax), %rax
movslq -0x10(%rbp), %rcx
movq (%rax,%rcx,8), %rax
movl 0x288(%rax), %eax
addl -0xc(%rbp), %eax
movl %eax, -0xc(%rbp)
movl -0x10(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x10(%rbp)
jmp 0x119b6
movl -0xc(%rbp), %eax
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/MikeGray-APH[P]LibLouisAPH/source/translate.h
// Function: translate_get_premode_chars_hash_cnt
static inline int translate_get_premode_chars_hash_cnt(const struct translate *translate)
{
	int cnt, i;

	cnt = 0;
	for(i = 0; i < translate->table_cnt; i++)
		cnt += translate->tables[i]->premode_chars_hash_cnt;
	return cnt;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movl $0x0, -0xc(%rbp)
movl $0x0, -0x10(%rbp)
movl -0x10(%rbp), %eax
movq -0x8(%rbp), %rcx
cmpl 0xc(%rcx), %eax
jge 0x122f8
movq -0x8(%rbp), %rax
movq (%rax), %rax
movslq -0x10(%rbp), %rcx
movq (%rax,%rcx,8), %rax
movl 0x2a0(%rax), %eax
addl -0xc(%rbp), %eax
movl %eax, -0xc(%rbp)
movl -0x10(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x10(%rbp)
jmp 0x122c6
movl -0xc(%rbp), %eax
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/MikeGray-APH[P]LibLouisAPH/source/translate.h
// Function: translate_get_postmode_chars_hash_cnt
static inline int translate_get_postmode_chars_hash_cnt(const struct translate *translate)
{
	int cnt, i;

	cnt = 0;
	for(i = 0; i < translate->table_cnt; i++)
		cnt += translate->tables[i]->postmode_chars_hash_cnt;
	return cnt;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movl $0x0, -0xc(%rbp)
movl $0x0, -0x10(%rbp)
movl -0x10(%rbp), %eax
movq -0x8(%rbp), %rcx
cmpl 0xc(%rcx), %eax
jge 0x12e38
movq -0x8(%rbp), %rax
movq (%rax), %rax
movslq -0x10(%rbp), %rcx
movq (%rax,%rcx,8), %rax
movl 0x2b8(%rax), %eax
addl -0xc(%rbp), %eax
movl %eax, -0xc(%rbp)
movl -0x10(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x10(%rbp)
jmp 0x12e06
movl -0xc(%rbp), %eax
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/MikeGray-APH[P]LibLouisAPH/source/translate.h
// Function: translate_get_pretrans_chars_hash_cnt
static inline int translate_get_pretrans_chars_hash_cnt(const struct translate *translate)
{
	int cnt, i;

	cnt = 0;
	for(i = 0; i < translate->table_cnt; i++)
		cnt += translate->tables[i]->pretrans_chars_hash_cnt;
	return cnt;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movl $0x0, -0xc(%rbp)
movl $0x0, -0x10(%rbp)
movl -0x10(%rbp), %eax
movq -0x8(%rbp), %rcx
cmpl 0xc(%rcx), %eax
jge 0x12e88
movq -0x8(%rbp), %rax
movq (%rax), %rax
movslq -0x10(%rbp), %rcx
movq (%rax,%rcx,8), %rax
movl 0x2d0(%rax), %eax
addl -0xc(%rbp), %eax
movl %eax, -0xc(%rbp)
movl -0x10(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x10(%rbp)
jmp 0x12e56
movl -0xc(%rbp), %eax
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/MikeGray-APH[P]LibLouisAPH/source/translate.h
// Function: translate_get_trans_chars_hash_cnt
static inline int translate_get_trans_chars_hash_cnt(const struct translate *translate)
{
	int cnt, i;

	cnt = 0;
	for(i = 0; i < translate->table_cnt; i++)
		cnt += translate->tables[i]->trans_chars_hash_cnt;
	return cnt;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movl $0x0, -0xc(%rbp)
movl $0x0, -0x10(%rbp)
movl -0x10(%rbp), %eax
movq -0x8(%rbp), %rcx
cmpl 0xc(%rcx), %eax
jge 0x12ed8
movq -0x8(%rbp), %rax
movq (%rax), %rax
movslq -0x10(%rbp), %rcx
movq (%rax,%rcx,8), %rax
movl 0x2e8(%rax), %eax
addl -0xc(%rbp), %eax
movl %eax, -0xc(%rbp)
movl -0x10(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x10(%rbp)
jmp 0x12ea6
movl -0xc(%rbp), %eax
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/MikeGray-APH[P]LibLouisAPH/source/translate.h
// Function: translate_get_posttrans_chars_hash_cnt
static inline int translate_get_posttrans_chars_hash_cnt(const struct translate *translate)
{
	int cnt, i;

	cnt = 0;
	for(i = 0; i < translate->table_cnt; i++)
		cnt += translate->tables[i]->posttrans_chars_hash_cnt;
	return cnt;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movl $0x0, -0xc(%rbp)
movl $0x0, -0x10(%rbp)
movl -0x10(%rbp), %eax
movq -0x8(%rbp), %rcx
cmpl 0xc(%rcx), %eax
jge 0x12f28
movq -0x8(%rbp), %rax
movq (%rax), %rax
movslq -0x10(%rbp), %rcx
movq (%rax,%rcx,8), %rax
movl 0x300(%rax), %eax
addl -0xc(%rbp), %eax
movl %eax, -0xc(%rbp)
movl -0x10(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x10(%rbp)
jmp 0x12ef6
movl -0xc(%rbp), %eax
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/MikeGray-APH[P]LibLouisAPH/source/translate.h
// Function: translate_get_fini_chars_hash_cnt
static inline int translate_get_fini_chars_hash_cnt(const struct translate *translate)
{
	int cnt, i;

	cnt = 0;
	for(i = 0; i < translate->table_cnt; i++)
		cnt += translate->tables[i]->fini_chars_hash_cnt;
	return cnt;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movl $0x0, -0xc(%rbp)
movl $0x0, -0x10(%rbp)
movl -0x10(%rbp), %eax
movq -0x8(%rbp), %rcx
cmpl 0xc(%rcx), %eax
jge 0x12f78
movq -0x8(%rbp), %rax
movq (%rax), %rax
movslq -0x10(%rbp), %rcx
movq (%rax,%rcx,8), %rax
movl 0x318(%rax), %eax
addl -0xc(%rbp), %eax
movl %eax, -0xc(%rbp)
movl -0x10(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x10(%rbp)
jmp 0x12f46
movl -0xc(%rbp), %eax
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/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:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movl %edx, -0x1c(%rbp)
movl %ecx, -0x20(%rbp)
movl -0x1c(%rbp), %eax
addl $0x2, %eax
movq -0x10(%rbp), %rcx
movl 0x44(%rcx), %ecx
subl -0x20(%rbp), %ecx
cmpl %ecx, %eax
jle 0x13012
movl $0x0, -0x4(%rbp)
jmp 0x13094
movl $0x0, -0x24(%rbp)
movl -0x24(%rbp), %eax
cmpl -0x1c(%rbp), %eax
jge 0x1305f
movq -0x18(%rbp), %rax
movslq -0x24(%rbp), %rcx
movzwl (%rax,%rcx,2), %eax
movq -0x10(%rbp), %rcx
movq 0x38(%rcx), %rcx
movl -0x20(%rbp), %edx
addl $0x1, %edx
addl -0x24(%rbp), %edx
movslq %edx, %rdx
movzwl (%rcx,%rdx,2), %ecx
cmpl %ecx, %eax
je 0x13052
movl $0x0, -0x4(%rbp)
jmp 0x13094
jmp 0x13054
movl -0x24(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x24(%rbp)
jmp 0x13019
movq -0x10(%rbp), %rax
movq 0x38(%rax), %rax
movl -0x20(%rbp), %ecx
addl $0x1, %ecx
addl -0x24(%rbp), %ecx
movslq %ecx, %rcx
movzwl (%rax,%rcx,2), %eax
movq -0x10(%rbp), %rcx
movq 0x38(%rcx), %rcx
movslq -0x20(%rbp), %rdx
movzwl (%rcx,%rdx,2), %ecx
cmpl %ecx, %eax
sete %al
andb $0x1, %al
movzbl %al, %eax
movl %eax, -0x4(%rbp)
movl -0x4(%rbp), %eax
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/MikeGray-APH[P]LibLouisAPH/source/languages/generic-forward.c
// Function: add_indicators_nodes
static int add_indicators_nodes(struct indicator_node *nodes, struct mode *mode, unsigned int *indicators, const int indicators_len)
{
	int i;

	for(i = 0; i < indicators_len; i++)
	if(indicators[i])
		nodes = add_indicators_node(nodes, mode, indicators[i], i);

	return 1;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movl %ecx, -0x1c(%rbp)
movl $0x0, -0x20(%rbp)
movl -0x20(%rbp), %eax
cmpl -0x1c(%rbp), %eax
jge 0x13d10
movq -0x18(%rbp), %rax
movslq -0x20(%rbp), %rcx
cmpl $0x0, (%rax,%rcx,4)
je 0x13d03
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
movq -0x18(%rbp), %rax
movslq -0x20(%rbp), %rcx
movl (%rax,%rcx,4), %edx
movl -0x20(%rbp), %ecx
callq 0x14560
movq %rax, -0x8(%rbp)
jmp 0x13d05
movl -0x20(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x20(%rbp)
jmp 0x13cce
movl $0x1, %eax
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/MikeGray-APH[P]LibLouisAPH/source/languages/generic-forward.c
// Function: sort_indicators
static void sort_indicators(struct indicator_node *node)
{
	struct indicator *indicator;

	while(node)
	{
		indicator = node->indicator;

		while(indicator)
		if(indicator->type == (EMP_WORD | EMP_END))
			break;
		else
			indicator = indicator->nxt;
		if(indicator)
			sort_word_end(indicator);

		indicator = node->indicator;

		while(indicator)
		if(indicator->type == EMP_WORD)
			break;
		else
			indicator = indicator->nxt;
		if(indicator)
			sort_word_begin(indicator);

		indicator = node->indicator;

		while(indicator)
		if(indicator->type == EMP_END)
			break;
		else
			indicator = indicator->nxt;
		if(indicator)
			sort_passage_end(indicator);

		indicator = node->indicator;

		while(indicator)
		if(indicator->type == EMP_BEGIN)
			break;
		else
			indicator = indicator->nxt;
		if(indicator)
			sort_passage_begin(indicator);

		while(node->indicator->prv)
			node->indicator = node->indicator->prv;

		node = node->nxt;
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
cmpq $0x0, -0x8(%rbp)
je 0x13e60
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rax
movq %rax, -0x10(%rbp)
cmpq $0x0, -0x10(%rbp)
je 0x13d64
movq -0x10(%rbp), %rax
cmpl $0x6, 0x18(%rax)
jne 0x13d56
jmp 0x13d64
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rax
movq %rax, -0x10(%rbp)
jmp 0x13d43
cmpq $0x0, -0x10(%rbp)
je 0x13d74
movq -0x10(%rbp), %rdi
callq 0x149f0
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rax
movq %rax, -0x10(%rbp)
cmpq $0x0, -0x10(%rbp)
je 0x13da1
movq -0x10(%rbp), %rax
cmpl $0x4, 0x18(%rax)
jne 0x13d93
jmp 0x13da1
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rax
movq %rax, -0x10(%rbp)
jmp 0x13d80
cmpq $0x0, -0x10(%rbp)
je 0x13db1
movq -0x10(%rbp), %rdi
callq 0x14ad0
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rax
movq %rax, -0x10(%rbp)
cmpq $0x0, -0x10(%rbp)
je 0x13dde
movq -0x10(%rbp), %rax
cmpl $0x2, 0x18(%rax)
jne 0x13dd0
jmp 0x13dde
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rax
movq %rax, -0x10(%rbp)
jmp 0x13dbd
cmpq $0x0, -0x10(%rbp)
je 0x13dee
movq -0x10(%rbp), %rdi
callq 0x14bb0
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rax
movq %rax, -0x10(%rbp)
cmpq $0x0, -0x10(%rbp)
je 0x13e1b
movq -0x10(%rbp), %rax
cmpl $0x1, 0x18(%rax)
jne 0x13e0d
jmp 0x13e1b
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rax
movq %rax, -0x10(%rbp)
jmp 0x13dfa
cmpq $0x0, -0x10(%rbp)
je 0x13e2b
movq -0x10(%rbp), %rdi
callq 0x14c90
jmp 0x13e2d
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rax
cmpq $0x0, (%rax)
je 0x13e50
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rax
movq (%rax), %rcx
movq -0x8(%rbp), %rax
movq %rcx, 0x8(%rax)
jmp 0x13e2d
movq -0x8(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x8(%rbp)
jmp 0x13d2c
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/MikeGray-APH[P]LibLouisAPH/source/languages/generic-forward.c
// Function: insert_indicator_nodes
static int insert_indicator_nodes(struct translate *translate, const struct table *table, struct indicator_node *node)
{
	if(!node)
		return 1;

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

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

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

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

	if(!translate_output_to_input(translate))
		return 0;

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

	return 1;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
cmpq $0x0, -0x20(%rbp)
jne 0x13e97
movl $0x1, -0x4(%rbp)
jmp 0x13f83
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rsi
movq -0x20(%rbp), %rax
movq (%rax), %rdx
callq 0x13e70
cmpl $0x0, %eax
jne 0x13ebc
movl $0x0, -0x4(%rbp)
jmp 0x13f83
movq -0x10(%rbp), %rax
movl $0x0, 0x40(%rax)
movq -0x10(%rbp), %rdi
movq -0x20(%rbp), %rax
movl 0x10(%rax), %esi
movl $0x1, %edx
callq 0xaeb0
cmpl $0x0, %eax
jne 0x13eed
movl $0x0, -0x4(%rbp)
jmp 0x13f83
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rsi
movq -0x20(%rbp), %rax
movq 0x8(%rax), %rdx
movq -0x20(%rbp), %rax
movl 0x10(%rax), %ecx
callq 0x14d50
cmpl $0x0, %eax
jne 0x13f17
movl $0x0, -0x4(%rbp)
jmp 0x13f83
movq -0x20(%rbp), %rax
movl 0x10(%rax), %ecx
movq -0x10(%rbp), %rax
movl %ecx, 0x40(%rax)
movq -0x10(%rbp), %rdi
movq -0x10(%rbp), %rax
movl 0x44(%rax), %esi
movq -0x20(%rbp), %rax
subl 0x10(%rax), %esi
movl $0x1, %edx
callq 0xaeb0
cmpl $0x0, %eax
jne 0x13f4f
movl $0x0, -0x4(%rbp)
jmp 0x13f83
movq -0x10(%rbp), %rdi
callq 0xb370
cmpl $0x0, %eax
jne 0x13f66
movl $0x0, -0x4(%rbp)
jmp 0x13f83
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)
// File: /workspace/github_c_makefile_star2_O0/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:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
cmpq $0x0, -0x8(%rbp)
jne 0x13fa5
jmp 0x13fc7
movq -0x8(%rbp), %rax
movq (%rax), %rdi
callq 0x13f90
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rdi
callq 0x14ed0
movq -0x8(%rbp), %rdi
callq 0x1040
addq $0x10, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/MikeGray-APH[P]LibLouisAPH/source/translate.h
// Function: translate_on_indicator_or_modifier_marker_at
static inline int translate_on_indicator_or_modifier_marker_at(const struct translate *translate, const int at)
{
	const struct table *table;

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

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

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movq -0x8(%rbp), %rax
movq (%rax), %rax
movq -0x8(%rbp), %rcx
movl 0xc(%rcx), %ecx
subl $0x1, %ecx
movslq %ecx, %rcx
movq (%rax,%rcx,8), %rax
movq %rax, -0x18(%rbp)
movq -0x8(%rbp), %rax
movq 0x38(%rax), %rax
movslq -0xc(%rbp), %rcx
movzwl (%rax,%rcx,2), %ecx
movq -0x18(%rbp), %rax
movzwl 0x1ee(%rax), %edx
movb $0x1, %al
cmpl %edx, %ecx
movb %al, -0x19(%rbp)
je 0x14062
movq -0x8(%rbp), %rax
movq 0x38(%rax), %rax
movslq -0xc(%rbp), %rcx
movzwl (%rax,%rcx,2), %ecx
movq -0x18(%rbp), %rax
movzwl 0x1f0(%rax), %edx
movb $0x1, %al
cmpl %edx, %ecx
movb %al, -0x19(%rbp)
je 0x14062
movq -0x8(%rbp), %rax
movq 0x38(%rax), %rax
movslq -0xc(%rbp), %rcx
movzwl (%rax,%rcx,2), %eax
movq -0x18(%rbp), %rcx
movzwl 0x1f2(%rcx), %ecx
cmpl %ecx, %eax
sete %al
movb %al, -0x19(%rbp)
movb -0x19(%rbp), %al
andb $0x1, %al
movzbl %al, %eax
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/MikeGray-APH[P]LibLouisAPH/source/languages/generic-forward.c
// Function: is_word_start
static int is_word_start(const unsigned char *words, const struct translate *translate, const int at)
{
	if(at >= translate->input_len)
		return 0;

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

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

	return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movl %edx, -0x1c(%rbp)
movl -0x1c(%rbp), %eax
movq -0x18(%rbp), %rcx
cmpl 0x44(%rcx), %eax
jl 0x14098
movl $0x0, -0x4(%rbp)
jmp 0x140ff
movq -0x18(%rbp), %rdi
movl -0x1c(%rbp), %esi
callq 0x142a0
cmpl $0x0, %eax
je 0x140d9
movq -0x10(%rbp), %rax
movq %rax, -0x30(%rbp)
movq -0x18(%rbp), %rax
movq %rax, -0x28(%rbp)
movq -0x18(%rbp), %rdi
movl -0x1c(%rbp), %esi
callq 0x143b0
movq -0x30(%rbp), %rdi
movq -0x28(%rbp), %rsi
movl %eax, %edx
callq 0x14070
movl %eax, -0x4(%rbp)
jmp 0x140ff
movq -0x18(%rbp), %rdi
movl -0x1c(%rbp), %esi
movl $0x1, %edx
callq 0x14440
cmpl $0x0, %eax
jne 0x140f8
movl $0x1, -0x4(%rbp)
jmp 0x140ff
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/MikeGray-APH[P]LibLouisAPH/source/languages/generic-forward.c
// Function: get_before_indicators
static int get_before_indicators(unsigned char *words, const int at)
{
	int i;

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

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movl -0xc(%rbp), %eax
movl %eax, -0x10(%rbp)
cmpl $0x0, -0x10(%rbp)
jl 0x1418a
movq -0x8(%rbp), %rax
movslq -0x10(%rbp), %rcx
movzbl (%rax,%rcx), %eax
andl $0x4, %eax
cmpl $0x0, %eax
jne 0x1417d
jmp 0x1418a
jmp 0x1417f
movl -0x10(%rbp), %eax
addl $-0x1, %eax
movl %eax, -0x10(%rbp)
jmp 0x14161
movl -0x10(%rbp), %eax
addl $0x1, %eax
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/MikeGray-APH[P]LibLouisAPH/source/translate.h
// Function: translate_on_marker_at
static inline int translate_on_marker_at(const struct translate *translate, const int at)
{
	const struct table *table;

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

	return   translate->input[at] == table->marker_user
	       || translate->input[at] == table->marker_begin
	       || translate->input[at] == table->marker_end
	       || translate->input[at] == table->marker_hard
	       || translate->input[at] == table->marker_soft
	       || translate->input[at] == table->marker_internal;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movq -0x8(%rbp), %rax
movq (%rax), %rax
movq -0x8(%rbp), %rcx
movl 0xc(%rcx), %ecx
subl $0x1, %ecx
movslq %ecx, %rcx
movq (%rax,%rcx,8), %rax
movq %rax, -0x18(%rbp)
movq -0x8(%rbp), %rax
movq 0x38(%rax), %rax
movslq -0xc(%rbp), %rcx
movzwl (%rax,%rcx,2), %ecx
movq -0x18(%rbp), %rax
movzwl 0x1e8(%rax), %edx
movb $0x1, %al
cmpl %edx, %ecx
movb %al, -0x19(%rbp)
je 0x143a6
movq -0x8(%rbp), %rax
movq 0x38(%rax), %rax
movslq -0xc(%rbp), %rcx
movzwl (%rax,%rcx,2), %ecx
movq -0x18(%rbp), %rax
movzwl 0x1ea(%rax), %edx
movb $0x1, %al
cmpl %edx, %ecx
movb %al, -0x19(%rbp)
je 0x143a6
movq -0x8(%rbp), %rax
movq 0x38(%rax), %rax
movslq -0xc(%rbp), %rcx
movzwl (%rax,%rcx,2), %ecx
movq -0x18(%rbp), %rax
movzwl 0x1ec(%rax), %edx
movb $0x1, %al
cmpl %edx, %ecx
movb %al, -0x19(%rbp)
je 0x143a6
movq -0x8(%rbp), %rax
movq 0x38(%rax), %rax
movslq -0xc(%rbp), %rcx
movzwl (%rax,%rcx,2), %ecx
movq -0x18(%rbp), %rax
movzwl 0x1f0(%rax), %edx
movb $0x1, %al
cmpl %edx, %ecx
movb %al, -0x19(%rbp)
je 0x143a6
movq -0x8(%rbp), %rax
movq 0x38(%rax), %rax
movslq -0xc(%rbp), %rcx
movzwl (%rax,%rcx,2), %ecx
movq -0x18(%rbp), %rax
movzwl 0x1f2(%rax), %edx
movb $0x1, %al
cmpl %edx, %ecx
movb %al, -0x19(%rbp)
je 0x143a6
movq -0x8(%rbp), %rax
movq 0x38(%rax), %rax
movslq -0xc(%rbp), %rcx
movzwl (%rax,%rcx,2), %eax
movq -0x18(%rbp), %rcx
movzwl 0x1f4(%rcx), %ecx
cmpl %ecx, %eax
sete %al
movb %al, -0x19(%rbp)
movb -0x19(%rbp), %al
andb $0x1, %al
movzbl %al, %eax
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O0/MikeGray-APH[P]LibLouisAPH/source/languages/generic-forward.c
// Function: get_after_next_delimiter
static int get_after_next_delimiter(const struct translate *translate, const int at)
{
	int i;

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

	return i;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x10(%rbp)
movl %esi, -0x14(%rbp)
movl -0x14(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x18(%rbp)
movl -0x18(%rbp), %eax
movq -0x10(%rbp), %rcx
cmpl 0x44(%rcx), %eax
jge 0x14403
movq -0x10(%rbp), %rax
movq 0x38(%rax), %rax
movslq -0x18(%rbp), %rcx
movzwl (%rax,%rcx,2), %eax
movq -0x10(%rbp), %rcx
movq 0x38(%rcx), %rcx
movslq -0x14(%rbp), %rdx
movzwl (%rcx,%rdx,2), %ecx
cmpl %ecx, %eax
jne 0x143f6
jmp 0x14403
jmp 0x143f8
movl -0x18(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x18(%rbp)
jmp 0x143c4
movl -0x18(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x18(%rbp)
movl -0x18(%rbp), %eax
movq -0x10(%rbp), %rcx
cmpl 0x44(%rcx), %eax
jle 0x1442a
movq -0x10(%rbp), %rax
movl 0x44(%rax), %eax
movl %eax, -0x18(%rbp)
movl -0x18(%rbp), %eax
movl %eax, -0x4(%rbp)
jmp 0x14430
movl -0x18(%rbp), %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-forward.c
// Function: convert_to_passage
static void convert_to_passage(unsigned int *indicators, unsigned char *words, const int pass_begin, const int pass_end)
{
	int i;

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

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

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl %edx, -0x14(%rbp)
movl %ecx, -0x18(%rbp)
movl -0x14(%rbp), %eax
movl %eax, -0x1c(%rbp)
movl -0x1c(%rbp), %eax
cmpl -0x18(%rbp), %eax
jg 0x1452e
movq -0x8(%rbp), %rax
movslq -0x1c(%rbp), %rcx
movl (%rax,%rcx,4), %edx
andl $-0xd, %edx
movl %edx, (%rax,%rcx,4)
movq -0x10(%rbp), %rax
movslq -0x1c(%rbp), %rcx
movzbl (%rax,%rcx), %edx
andl $-0x3, %edx
movb %dl, (%rax,%rcx)
movl -0x1c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x1c(%rbp)
jmp 0x144f8
movq -0x8(%rbp), %rax
movslq -0x14(%rbp), %rcx
movl (%rax,%rcx,4), %edx
orl $0x1, %edx
movl %edx, (%rax,%rcx,4)
movq -0x8(%rbp), %rax
movslq -0x18(%rbp), %rcx
movl (%rax,%rcx,4), %edx
orl $0x2, %edx
movl %edx, (%rax,%rcx,4)
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/MikeGray-APH[P]LibLouisAPH/source/languages/generic-forward.c
// Function: sort_word_end
static void sort_word_end(struct indicator *indicator)
{
	struct indicator *nxt;

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

	sort_word_end(indicator->nxt);

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

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

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

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

		sort_word_end(indicator);
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
cmpq $0x0, 0x8(%rax)
jne 0x14a0c
jmp 0x14abd
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rax
cmpl $0x6, 0x18(%rax)
je 0x14a1f
jmp 0x14abd
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rdi
callq 0x149f0
movq -0x8(%rbp), %rax
movl 0x1c(%rax), %eax
movq -0x8(%rbp), %rcx
movq 0x8(%rcx), %rcx
cmpl 0x1c(%rcx), %eax
jge 0x14abd
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rax
movq %rax, -0x10(%rbp)
movq -0x8(%rbp), %rax
cmpq $0x0, (%rax)
je 0x14a65
movq -0x10(%rbp), %rcx
movq -0x8(%rbp), %rax
movq (%rax), %rax
movq %rcx, 0x8(%rax)
movq -0x10(%rbp), %rax
cmpq $0x0, 0x8(%rax)
je 0x14a7f
movq -0x8(%rbp), %rcx
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rax
movq %rcx, (%rax)
movq -0x8(%rbp), %rax
movq (%rax), %rcx
movq -0x10(%rbp), %rax
movq %rcx, (%rax)
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rcx
movq -0x8(%rbp), %rax
movq %rcx, 0x8(%rax)
movq -0x8(%rbp), %rcx
movq -0x10(%rbp), %rax
movq %rcx, 0x8(%rax)
movq -0x10(%rbp), %rcx
movq -0x8(%rbp), %rax
movq %rcx, (%rax)
movq -0x8(%rbp), %rdi
callq 0x149f0
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/MikeGray-APH[P]LibLouisAPH/source/languages/generic-forward.c
// Function: sort_word_begin
static void sort_word_begin(struct indicator *indicator)
{
	struct indicator *nxt;

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

	sort_word_begin(indicator->nxt);

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

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

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

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

		sort_word_begin(indicator);
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
cmpq $0x0, 0x8(%rax)
jne 0x14aec
jmp 0x14b9d
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rax
cmpl $0x4, 0x18(%rax)
je 0x14aff
jmp 0x14b9d
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rdi
callq 0x14ad0
movq -0x8(%rbp), %rax
movl 0x1c(%rax), %eax
movq -0x8(%rbp), %rcx
movq 0x8(%rcx), %rcx
cmpl 0x1c(%rcx), %eax
jle 0x14b9d
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rax
movq %rax, -0x10(%rbp)
movq -0x8(%rbp), %rax
cmpq $0x0, (%rax)
je 0x14b45
movq -0x10(%rbp), %rcx
movq -0x8(%rbp), %rax
movq (%rax), %rax
movq %rcx, 0x8(%rax)
movq -0x10(%rbp), %rax
cmpq $0x0, 0x8(%rax)
je 0x14b5f
movq -0x8(%rbp), %rcx
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rax
movq %rcx, (%rax)
movq -0x8(%rbp), %rax
movq (%rax), %rcx
movq -0x10(%rbp), %rax
movq %rcx, (%rax)
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rcx
movq -0x8(%rbp), %rax
movq %rcx, 0x8(%rax)
movq -0x8(%rbp), %rcx
movq -0x10(%rbp), %rax
movq %rcx, 0x8(%rax)
movq -0x10(%rbp), %rcx
movq -0x8(%rbp), %rax
movq %rcx, (%rax)
movq -0x8(%rbp), %rdi
callq 0x14ad0
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/MikeGray-APH[P]LibLouisAPH/source/languages/generic-forward.c
// Function: sort_passage_end
static void sort_passage_end(struct indicator *indicator)
{
	struct indicator *nxt;

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

	sort_passage_end(indicator->nxt);

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

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

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

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

		sort_passage_end(indicator);
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
cmpq $0x0, 0x8(%rax)
jne 0x14bcc
jmp 0x14c7d
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rax
cmpl $0x2, 0x18(%rax)
je 0x14bdf
jmp 0x14c7d
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rdi
callq 0x14bb0
movq -0x8(%rbp), %rax
movl 0x1c(%rax), %eax
movq -0x8(%rbp), %rcx
movq 0x8(%rcx), %rcx
cmpl 0x1c(%rcx), %eax
jge 0x14c7d
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rax
movq %rax, -0x10(%rbp)
movq -0x8(%rbp), %rax
cmpq $0x0, (%rax)
je 0x14c25
movq -0x10(%rbp), %rcx
movq -0x8(%rbp), %rax
movq (%rax), %rax
movq %rcx, 0x8(%rax)
movq -0x10(%rbp), %rax
cmpq $0x0, 0x8(%rax)
je 0x14c3f
movq -0x8(%rbp), %rcx
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rax
movq %rcx, (%rax)
movq -0x8(%rbp), %rax
movq (%rax), %rcx
movq -0x10(%rbp), %rax
movq %rcx, (%rax)
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rcx
movq -0x8(%rbp), %rax
movq %rcx, 0x8(%rax)
movq -0x8(%rbp), %rcx
movq -0x10(%rbp), %rax
movq %rcx, 0x8(%rax)
movq -0x10(%rbp), %rcx
movq -0x8(%rbp), %rax
movq %rcx, (%rax)
movq -0x8(%rbp), %rdi
callq 0x14bb0
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/MikeGray-APH[P]LibLouisAPH/source/languages/generic-forward.c
// Function: sort_passage_begin
static void sort_passage_begin(struct indicator *indicator)
{
	struct indicator *nxt;

	if(!indicator->nxt)
		return;

	sort_passage_begin(indicator->nxt);

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

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

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

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

		sort_passage_begin(indicator);
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
cmpq $0x0, 0x8(%rax)
jne 0x14cac
jmp 0x14d4a
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rdi
callq 0x14c90
movq -0x8(%rbp), %rax
movl 0x1c(%rax), %eax
movq -0x8(%rbp), %rcx
movq 0x8(%rcx), %rcx
cmpl 0x1c(%rcx), %eax
jle 0x14d4a
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rax
movq %rax, -0x10(%rbp)
movq -0x8(%rbp), %rax
cmpq $0x0, (%rax)
je 0x14cf2
movq -0x10(%rbp), %rcx
movq -0x8(%rbp), %rax
movq (%rax), %rax
movq %rcx, 0x8(%rax)
movq -0x10(%rbp), %rax
cmpq $0x0, 0x8(%rax)
je 0x14d0c
movq -0x8(%rbp), %rcx
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rax
movq %rcx, (%rax)
movq -0x8(%rbp), %rax
movq (%rax), %rcx
movq -0x10(%rbp), %rax
movq %rcx, (%rax)
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rcx
movq -0x8(%rbp), %rax
movq %rcx, 0x8(%rax)
movq -0x8(%rbp), %rcx
movq -0x10(%rbp), %rax
movq %rcx, 0x8(%rax)
movq -0x10(%rbp), %rcx
movq -0x8(%rbp), %rax
movq %rcx, (%rax)
movq -0x8(%rbp), %rdi
callq 0x14c90
addq $0x10, %rsp
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O0/MikeGray-APH[P]LibLouisAPH/source/languages/generic-forward.c
// Function: insert_indicator_node
static int insert_indicator_node(struct translate *translate, const struct table *table, struct indicator *indicator, const int at)
{
	if(!indicator)
		return 1;
	insert_indicator_node(translate, table, indicator->nxt, at);

	switch(indicator->type)
	{
	case EMP_BEGIN:           return generic_insert_marked(translate, indicator->mode->begin, indicator->mode->begin_len, table->marker_hard);
	case EMP_END:             return generic_insert_marked(translate, indicator->mode->end, indicator->mode->end_len, table->marker_hard);
	case EMP_WORD:            return generic_insert_marked(translate, indicator->mode->word, indicator->mode->word_len, table->marker_hard);
	case EMP_WORD | EMP_END:  return generic_insert_marked(translate, indicator->mode->term, indicator->mode->term_len, table->marker_hard);
	case EMP_SYMBOL:          return generic_insert_marked(translate, indicator->mode->symbol, indicator->mode->symbol_len, table->marker_hard);
	}

	ASSERT(0)
	return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movl %ecx, -0x24(%rbp)
cmpq $0x0, -0x20(%rbp)
jne 0x14d7a
movl $0x1, -0x4(%rbp)
jmp 0x14eb9
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rsi
movq -0x20(%rbp), %rax
movq 0x8(%rax), %rdx
movl -0x24(%rbp), %ecx
callq 0x14d50
movq -0x20(%rbp), %rax
movl 0x18(%rax), %eax
decl %eax
movl %eax, %ecx
movq %rcx, -0x30(%rbp)
subl $0x7, %eax
ja 0x14eb4
movq -0x30(%rbp), %rax
leaq 0xa0db(%rip), %rcx      # 0x1ee90
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
movq -0x10(%rbp), %rdi
movq -0x20(%rbp), %rax
movq 0x10(%rax), %rsi
addq $0xc, %rsi
movq -0x20(%rbp), %rax
movq 0x10(%rax), %rax
movl 0x54(%rax), %edx
movq -0x18(%rbp), %rax
movzwl 0x1f0(%rax), %ecx
callq 0x102a0
movl %eax, -0x4(%rbp)
jmp 0x14eb9
movq -0x10(%rbp), %rdi
movq -0x20(%rbp), %rax
movq 0x10(%rax), %rsi
addq $0x1a, %rsi
movq -0x20(%rbp), %rax
movq 0x10(%rax), %rax
movl 0x58(%rax), %edx
movq -0x18(%rbp), %rax
movzwl 0x1f0(%rax), %ecx
callq 0x102a0
movl %eax, -0x4(%rbp)
jmp 0x14eb9
movq -0x10(%rbp), %rdi
movq -0x20(%rbp), %rax
movq 0x10(%rax), %rsi
addq $0x28, %rsi
movq -0x20(%rbp), %rax
movq 0x10(%rax), %rax
movl 0x5c(%rax), %edx
movq -0x18(%rbp), %rax
movzwl 0x1f0(%rax), %ecx
callq 0x102a0
movl %eax, -0x4(%rbp)
jmp 0x14eb9
movq -0x10(%rbp), %rdi
movq -0x20(%rbp), %rax
movq 0x10(%rax), %rsi
addq $0x36, %rsi
movq -0x20(%rbp), %rax
movq 0x10(%rax), %rax
movl 0x60(%rax), %edx
movq -0x18(%rbp), %rax
movzwl 0x1f0(%rax), %ecx
callq 0x102a0
movl %eax, -0x4(%rbp)
jmp 0x14eb9
movq -0x10(%rbp), %rdi
movq -0x20(%rbp), %rax
movq 0x10(%rax), %rsi
addq $0x44, %rsi
movq -0x20(%rbp), %rax
movq 0x10(%rax), %rax
movl 0x64(%rax), %edx
movq -0x18(%rbp), %rax
movzwl 0x1f0(%rax), %ecx
callq 0x102a0
movl %eax, -0x4(%rbp)
jmp 0x14eb9
callq 0x1050
movl -0x4(%rbp), %eax
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/MikeGray-APH[P]LibLouisAPH/source/languages/generic-forward.c
// Function: indicator_free
static void indicator_free(struct indicator *indicator)
{
	if(!indicator)
		return;
	indicator_free(indicator->nxt);
	FREE(indicator);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
cmpq $0x0, -0x8(%rbp)
jne 0x14ee5
jmp 0x14efb
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rdi
callq 0x14ed0
movq -0x8(%rbp), %rdi
callq 0x1040
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/MikeGray-APH[P]LibLouisAPH/source/languages/generic-forward.c
// Function: mark_nonalphabetic_words
static void mark_nonalphabetic_words(unsigned int *indicators, unsigned char *words, const struct translate *translate)
{
	int word_begin, letter_cnt, i;

	word_begin = -1;
	letter_cnt = 0;

	for(i = 0; i < translate->input_len; i++)
	{
		/*   skip indicators   */
		if(words[i] & WORD_INDICATOR)
			continue;

		if(word_begin < 0)
		{
			if(indicators[i] & (EMP_WORD | EMP_SYMBOL))
			{
				word_begin = i;
				letter_cnt = 0;
			}
		}

		if(word_begin >= 0)
		{
			if(translate_has_attributes_at(translate, i, CHAR_LETTER))
				letter_cnt++;
			else if(translate_has_attributes_at(translate, i, CHAR_SPACE | CHAR_SEQUENCE_DELIMITER))
			{
				if(!letter_cnt)
					words[word_begin] |= WORD_NONLETTER;
				word_begin = -1;
			}
		}
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movl $0xffffffff, -0x1c(%rbp) # imm = 0xFFFFFFFF
movl $0x0, -0x20(%rbp)
movl $0x0, -0x24(%rbp)
movl -0x24(%rbp), %eax
movq -0x18(%rbp), %rcx
cmpl 0x44(%rcx), %eax
jge 0x1521a
movq -0x10(%rbp), %rax
movslq -0x24(%rbp), %rcx
movzbl (%rax,%rcx), %eax
andl $0x4, %eax
cmpl $0x0, %eax
je 0x15182
jmp 0x1520c
cmpl $0x0, -0x1c(%rbp)
jge 0x151aa
movq -0x8(%rbp), %rax
movslq -0x24(%rbp), %rcx
movl (%rax,%rcx,4), %eax
andl $0xc, %eax
cmpl $0x0, %eax
je 0x151a8
movl -0x24(%rbp), %eax
movl %eax, -0x1c(%rbp)
movl $0x0, -0x20(%rbp)
jmp 0x151aa
cmpl $0x0, -0x1c(%rbp)
jl 0x1520a
movq -0x18(%rbp), %rdi
movl -0x24(%rbp), %esi
movl $0x40, %edx
callq 0x14440
cmpl $0x0, %eax
je 0x151d1
movl -0x20(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x20(%rbp)
jmp 0x15208
movq -0x18(%rbp), %rdi
movl -0x24(%rbp), %esi
movl $0x3, %edx
callq 0x14440
cmpl $0x0, %eax
je 0x15206
cmpl $0x0, -0x20(%rbp)
jne 0x151ff
movq -0x10(%rbp), %rax
movslq -0x1c(%rbp), %rcx
movzbl (%rax,%rcx), %edx
orl $0x8, %edx
movb %dl, (%rax,%rcx)
movl $0xffffffff, -0x1c(%rbp) # imm = 0xFFFFFFFF
jmp 0x15208
jmp 0x1520a
jmp 0x1520c
movl -0x24(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x24(%rbp)
jmp 0x15159
addq $0x30, %rsp
popq %rbp
retq