LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O3/MikeGray-APH[P]LibLouisAPH/source/languages/generic-common.c
// Function: generic_remove_internal
int generic_remove_internal(struct translate *translate)
{
	const struct table *table;
	int off, crs;

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

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

	translate->output_len = crs;

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

	return 1;
}

// Assembly:
pushq %rbx
movq (%rdi), %rax
movslq 0xc(%rdi), %rdx
movq -0x8(%rax,%rdx,8), %rcx
decq %rdx
movl %edx, 0x8(%rdi)
movl 0x44(%rdi), %r8d
xorl %edx, %edx
testl %r8d, %r8d
jle 0xa9d2
xorl %esi, %esi
movq 0x38(%rdi), %r11
movslq %esi, %r9
movzwl (%r11,%r9,2), %r10d
cmpw 0x1f4(%rcx), %r10w
jne 0xa984
movslq %r8d, %rbx
incq %r9
xorl %eax, %eax
cmpq %rbx, %r9
jge 0xa9e7
leaq 0x1(%r9), %rsi
cmpw %r10w, (%r11,%r9,2)
movq %rsi, %r9
jne 0xa95b
testl %esi, %esi
je 0xa9e7
movl $0x1, 0x94(%rdi)
jmp 0xa9c9
movq 0x60(%rdi), %r8
movslq %edx, %rax
movw %r10w, (%r8,%rax,2)
movq 0x58(%rdi), %r8
movq 0x80(%rdi), %r10
movb (%r8,%r9), %r8b
movb %r8b, (%r10,%rax)
cmpl $0x0, 0x90(%rdi)
je 0xa9bc
movq 0x50(%rdi), %r8
movq 0x78(%rdi), %r10
movl (%r8,%r9,4), %r8d
movl %r8d, (%r10,%rax,4)
incl %edx
cmpl 0x6c(%rdi), %edx
jge 0xa9e9
incl %esi
movl 0x44(%rdi), %r8d
cmpl %r8d, %esi
jl 0xa93f
movl %edx, 0x68(%rdi)
movq 0x60(%rdi), %rax
movslq %edx, %rcx
movw $0x0, (%rax,%rcx,2)
movl $0x1, %eax
popq %rbx
retq
xorl %eax, %eax
jmp 0xa9e7
// File: /workspace/github_c_makefile_star2_O3/MikeGray-APH[P]LibLouisAPH/source/languages/generic-common.c
// Function: generic_remove_modifier_delimiters
int generic_remove_modifier_delimiters(struct translate *translate)
{
	const struct table *table;

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

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

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

	return 1;
}

// Assembly:
pushq %rbp
pushq %r14
pushq %rbx
movq %rdi, %rbx
movq (%rdi), %rax
movslq 0xc(%rdi), %rcx
movq -0x8(%rax,%rcx,8), %r14
decq %rcx
movl %ecx, 0x8(%rdi)
xorl %eax, %eax
movl %eax, 0x68(%rdi)
movl %eax, 0x40(%rdi)
cmpl %eax, 0x44(%rdi)
jle 0xab3c
xorl %ebp, %ebp
movq 0x38(%rbx), %rcx
cltq
movzwl (%rcx,%rax,2), %eax
cmpw 0x1ee(%r14), %ax
jne 0xab1a
movl $0x1, 0x94(%rbx)
movq %rbx, %rdi
movl $0x1, %esi
xorl %edx, %edx
callq 0x71cc
testl %eax, %eax
jne 0xab30
jmp 0xab4b
movq %rbx, %rdi
movl $0x1, %esi
movl $0x1, %edx
callq 0x7467
testl %eax, %eax
je 0xab52
movl 0x40(%rbx), %eax
cmpl 0x44(%rbx), %eax
jl 0xaae7
movslq 0x68(%rbx), %rax
movq 0x60(%rbx), %rcx
movw $0x0, (%rcx,%rax,2)
movl $0x1, %ebp
movl %ebp, %eax
popq %rbx
popq %r14
popq %rbp
retq
xorl %ebp, %ebp
jmp 0xab4b
// File: /workspace/github_c_makefile_star2_O3/MikeGray-APH[P]LibLouisAPH/source/languages/generic-common.c
// Function: generic_remove_hard_and_modifier_delimiters
int generic_remove_hard_and_modifier_delimiters(struct translate *translate)
{
	const struct table *table;

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

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

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

	return 1;
}

// Assembly:
pushq %rbp
pushq %r14
pushq %rbx
movq %rdi, %rbx
movq (%rdi), %rax
movslq 0xc(%rdi), %rcx
movq -0x8(%rax,%rcx,8), %r14
decq %rcx
movl %ecx, 0x8(%rdi)
xorl %eax, %eax
movl %eax, 0x68(%rdi)
movl %eax, 0x40(%rdi)
cmpl %eax, 0x44(%rdi)
jle 0xabdd
xorl %ebp, %ebp
movq 0x38(%rbx), %rcx
cltq
movzwl (%rcx,%rax,2), %eax
cmpw 0x1ee(%r14), %ax
je 0xab9c
cmpw 0x1f0(%r14), %ax
jne 0xabbb
movl $0x1, 0x94(%rbx)
movq %rbx, %rdi
movl $0x1, %esi
xorl %edx, %edx
callq 0x71cc
testl %eax, %eax
jne 0xabd1
jmp 0xabec
movq %rbx, %rdi
movl $0x1, %esi
movl $0x1, %edx
callq 0x7467
testl %eax, %eax
je 0xabf3
movl 0x40(%rbx), %eax
cmpl 0x44(%rbx), %eax
jl 0xab7e
movslq 0x68(%rbx), %rax
movq 0x60(%rbx), %rcx
movw $0x0, (%rcx,%rax,2)
movl $0x1, %ebp
movl %ebp, %eax
popq %rbx
popq %r14
popq %rbp
retq
xorl %ebp, %ebp
jmp 0xabec
// File: /workspace/github_c_makefile_star2_O3/MikeGray-APH[P]LibLouisAPH/source/languages/generic-forward.c
// Function: is_marked_equal_to_at
static int is_marked_equal_to_at(const struct translate *translate, const unichar *name, const int name_len, const int at)
{
	int i;

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

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

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

// Assembly:
leal 0x2(%rdx), %r8d
movl 0x44(%rdi), %r9d
subl %ecx, %r9d
xorl %eax, %eax
cmpl %r9d, %r8d
jg 0xdd58
pushq %rbx
leal 0x1(%rcx), %r8d
movq 0x38(%rdi), %rdi
testl %edx, %edx
jle 0xdd3f
movslq %r8d, %rax
movl %edx, %r9d
leaq (%rdi,%rax,2), %r10
xorl %eax, %eax
xorl %r11d, %r11d
movzwl (%rsi,%r11,2), %ebx
cmpw (%r10,%r11,2), %bx
jne 0xdd57
incq %r11
cmpq %r11, %r9
jne 0xdd29
jmp 0xdd41
xorl %edx, %edx
addl %edx, %r8d
movslq %r8d, %rax
movzwl (%rdi,%rax,2), %edx
movslq %ecx, %rcx
xorl %eax, %eax
cmpw (%rdi,%rcx,2), %dx
sete %al
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O3/MikeGray-APH[P]LibLouisAPH/source/languages/generic-forward.c
// Function: insert_indicator_nodes
static int insert_indicator_nodes(struct translate *translate, const struct table *table, struct indicator_node *node)
{
	if(!node)
		return 1;

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

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

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

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

	if(!translate_output_to_input(translate))
		return 0;

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

	return 1;
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
testq %rdx, %rdx
je 0xdfd5
movq %rdx, %r15
movq %rsi, %r12
movq %rdi, %r14
movq (%rdx), %rdx
callq 0xdf44
xorl %ebx, %ebx
testl %eax, %eax
je 0xdfda
movl $0x0, 0x40(%r14)
movl 0x10(%r15), %esi
movq %r14, %rdi
movl $0x1, %edx
callq 0x7467
testl %eax, %eax
je 0xdfda
movq 0x8(%r15), %rdx
movq %r14, %rdi
movq %r12, %rsi
callq 0xe25a
testl %eax, %eax
je 0xdfda
movl 0x10(%r15), %eax
movl %eax, 0x40(%r14)
movl 0x44(%r14), %esi
subl %eax, %esi
movq %r14, %rdi
movl $0x1, %edx
callq 0x7467
testl %eax, %eax
je 0xdfda
movq %r14, %rdi
callq 0x77bf
testl %eax, %eax
je 0xdfda
movq 0x60(%r14), %rax
movslq 0x68(%r14), %rcx
movw $0x0, (%rax,%rcx,2)
movl $0x1, %ebx
movl %ebx, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O3/MikeGray-APH[P]LibLouisAPH/source/languages/generic-forward.c
// Function: indicator_node_free
static void indicator_node_free(struct indicator_node *node)
{
	if(!node)
		return;
	indicator_node_free(node->nxt);
	indicator_free(node->indicator);
	FREE(node);
}

// Assembly:
testq %rdi, %rdi
je 0xe00b
pushq %rbx
movq %rdi, %rbx
movq (%rdi), %rdi
callq 0xdfe8
movq 0x8(%rbx), %rdi
callq 0xe2f5
movq %rbx, %rdi
popq %rbx
jmp 0x1040
retq
// File: /workspace/github_c_makefile_star2_O3/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 %r15
pushq %r14
pushq %rbx
movslq 0x44(%rdi), %rax
xorl %ebx, %ebx
cmpl %esi, %eax
jle 0xe0a4
movq (%rdi), %rcx
movq 0x38(%rdi), %rdx
movslq 0xc(%rdi), %r8
movq -0x8(%rcx,%r8,8), %r8
movzwl 0x1e8(%r8), %r9d
leal -0x1(%rax), %r10d
movslq %esi, %r14
movzwl (%rdx,%r14,2), %r11d
cmpw %r9w, %r11w
je 0xe07b
cmpw 0x1ea(%r8), %r11w
je 0xe07b
cmpw 0x1ec(%r8), %r11w
je 0xe07b
cmpw 0x1f0(%r8), %r11w
je 0xe07b
cmpw 0x1f2(%r8), %r11w
je 0xe07b
cmpw 0x1f4(%r8), %r11w
jne 0xe0ac
decl %esi
incq %r14
cmpq %rax, %r14
jge 0xe097
incl %esi
leaq 0x1(%r14), %r15
cmpw %r11w, (%rdx,%r14,2)
movq %r15, %r14
jne 0xe080
jmp 0xe09a
movl %r10d, %esi
addl $0x2, %esi
cmpl %eax, %esi
cmovgel %eax, %esi
jl 0xe03b
movl %ebx, %eax
popq %rbx
popq %r14
popq %r15
retq
testl %esi, %esi
js 0xe0cd
movslq 0x8(%rdi), %rax
movq (%rcx,%rax,8), %rdi
movzwl %r11w, %esi
callq 0x1ef5
testq %rax, %rax
je 0xe0cd
movl 0x24(%rax), %eax
testb $0x1, %al
jne 0xe0a4
movl $0x1, %ebx
jmp 0xe0a4
// File: /workspace/github_c_makefile_star2_O3/MikeGray-APH[P]LibLouisAPH/source/languages/generic-forward.c
// Function: sort_word_end
static void sort_word_end(struct indicator *indicator)
{
	struct indicator *nxt;

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

	sort_word_end(indicator->nxt);

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

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

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

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

		sort_word_end(indicator);
	}
}

// Assembly:
pushq %rbx
movq %rdi, %rbx
movq 0x8(%rdi), %rdi
testq %rdi, %rdi
je 0xe15f
cmpl $0x6, 0x18(%rdi)
jne 0xe15f
callq 0xe10c
movl 0x1c(%rbx), %ecx
movq 0x8(%rbx), %rax
cmpl 0x1c(%rax), %ecx
jge 0xe15f
movq (%rbx), %rcx
testq %rcx, %rcx
je 0xe13c
movq %rax, 0x8(%rcx)
movq 0x8(%rax), %rdx
testq %rdx, %rdx
je 0xe14b
movq %rbx, (%rdx)
movq (%rbx), %rcx
movq %rcx, (%rax)
movq %rdx, 0x8(%rbx)
movq %rbx, 0x8(%rax)
movq %rax, (%rbx)
movq 0x8(%rbx), %rdi
jmp 0xe114
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O3/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 %rbx
movq %rdi, %rbx
movq 0x8(%rdi), %rdi
testq %rdi, %rdi
je 0xe1b4
cmpl $0x4, 0x18(%rdi)
jne 0xe1b4
callq 0xe161
movl 0x1c(%rbx), %ecx
movq 0x8(%rbx), %rax
cmpl 0x1c(%rax), %ecx
jle 0xe1b4
movq (%rbx), %rcx
testq %rcx, %rcx
je 0xe191
movq %rax, 0x8(%rcx)
movq 0x8(%rax), %rdx
testq %rdx, %rdx
je 0xe1a0
movq %rbx, (%rdx)
movq (%rbx), %rcx
movq %rcx, (%rax)
movq %rdx, 0x8(%rbx)
movq %rbx, 0x8(%rax)
movq %rax, (%rbx)
movq 0x8(%rbx), %rdi
jmp 0xe169
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O3/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 %rbx
movq %rdi, %rbx
movq 0x8(%rdi), %rdi
testq %rdi, %rdi
je 0xe209
cmpl $0x2, 0x18(%rdi)
jne 0xe209
callq 0xe1b6
movl 0x1c(%rbx), %ecx
movq 0x8(%rbx), %rax
cmpl 0x1c(%rax), %ecx
jge 0xe209
movq (%rbx), %rcx
testq %rcx, %rcx
je 0xe1e6
movq %rax, 0x8(%rcx)
movq 0x8(%rax), %rdx
testq %rdx, %rdx
je 0xe1f5
movq %rbx, (%rdx)
movq (%rbx), %rcx
movq %rcx, (%rax)
movq %rdx, 0x8(%rbx)
movq %rbx, 0x8(%rax)
movq %rax, (%rbx)
movq 0x8(%rbx), %rdi
jmp 0xe1be
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O3/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 %rbx
movq %rdi, %rbx
movq 0x8(%rdi), %rdi
testq %rdi, %rdi
je 0xe258
callq 0xe20b
movl 0x1c(%rbx), %ecx
movq 0x8(%rbx), %rax
cmpl 0x1c(%rax), %ecx
jle 0xe258
movq (%rbx), %rcx
testq %rcx, %rcx
je 0xe235
movq %rax, 0x8(%rcx)
movq 0x8(%rax), %rdx
testq %rdx, %rdx
je 0xe244
movq %rbx, (%rdx)
movq (%rbx), %rcx
movq %rcx, (%rax)
movq %rdx, 0x8(%rbx)
movq %rbx, 0x8(%rax)
movq %rax, (%rbx)
movq 0x8(%rbx), %rdi
jmp 0xe213
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O3/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 %r15
pushq %r14
pushq %rbx
testq %rdx, %rdx
je 0xe29e
movq %rdx, %r15
movq %rsi, %r14
movq %rdi, %rbx
movq 0x8(%rdx), %rdx
callq 0xe25a
movl 0x18(%r15), %eax
decl %eax
cmpl $0x7, %eax
ja 0xe2f0
leaq 0x5a30(%rip), %rcx      # 0x13cb8
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
movq 0x10(%r15), %rsi
movl 0x54(%rsi), %edx
addq $0xc, %rsi
jmp 0xe2db
movl $0x1, %eax
popq %rbx
popq %r14
popq %r15
retq
movq 0x10(%r15), %rsi
movl 0x64(%rsi), %edx
addq $0x44, %rsi
jmp 0xe2db
movq 0x10(%r15), %rsi
movl 0x5c(%rsi), %edx
addq $0x28, %rsi
jmp 0xe2db
movq 0x10(%r15), %rsi
movl 0x60(%rsi), %edx
addq $0x36, %rsi
jmp 0xe2db
movq 0x10(%r15), %rsi
movl 0x58(%rsi), %edx
addq $0x1a, %rsi
movzwl 0x1f0(%r14), %ecx
movq %rbx, %rdi
popq %rbx
popq %r14
popq %r15
jmp 0xa884
callq 0x1060
// File: /workspace/github_c_makefile_star2_O3/MikeGray-APH[P]LibLouisAPH/source/outputs/utf-output.c
// Function: utf16_output
void utf16_output(FILE *output, const unichar *uchars, const int uchars_len)
{
	char *cchars;
	int cchars_len;

	if(uchars_len <= 0 || !uchars)
		return;

	cchars_len = uchars_len * 8;
	cchars = MALLOC(cchars_len + 1);

	utf16_convert_to_utf8(cchars, (cchars_len + 1), uchars, uchars_len, NULL);
	fprintf(output, "%s", cchars);
	fflush(output);

	FREE(cchars);
}

// Assembly:
testl %edx, %edx
setle %al
testq %rsi, %rsi
sete %cl
orb %al, %cl
jne 0x10928
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
movl %edx, %r14d
movq %rsi, %r15
movq %rdi, %rbx
leal 0x1(,%r14,8), %r12d
movq %r12, %rdi
callq 0x1190
movq %rax, %r13
movq %rax, %rdi
movl %r12d, %esi
movq %r15, %rdx
movl %r14d, %ecx
xorl %r8d, %r8d
callq 0x170a
movq %r13, %rdi
movq %rbx, %rsi
callq 0x1100
movq %rbx, %rdi
callq 0x11a0
movq %r13, %rdi
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
jmp 0x1040
retq
// File: /workspace/github_c_makefile_star2_O3/MikeGray-APH[P]LibLouisAPH/source/outputs/utf-output.c
// Function: utf16_output_char
void utf16_output_char(FILE *output, const unichar uchar)
{
	char cchars[16];
	unichar uchars[2];

	switch(uchar)
	{
	case 0xa0:
	case u' ':
	case u'\n':
	case u'\r':
	case u'\t':  fputs(" ", output);  break;
	default:

		uchars[0] = uchar;
		uchars[1] = 0;
		utf16_convert_to_utf8(cchars, 16, uchars, 2, NULL);
		fprintf(output, "%s", cchars);
	}

	fflush(output);
}

// Assembly:
pushq %r14
pushq %rbx
subq $0x28, %rsp
movq %rdi, %rbx
cmpl $0x20, %esi
ja 0x1094a
movl %esi, %eax
movabsq $0x100002600, %rcx      # imm = 0x100002600
btq %rax, %rcx
jb 0x10952
cmpl $0xa0, %esi
jne 0x10971
leaq 0x390a(%rip), %rdi      # 0x14263
movq %rbx, %rsi
callq 0x1100
movq %rbx, %rdi
callq 0x11a0
addq $0x28, %rsp
popq %rbx
popq %r14
retq
leaq 0xc(%rsp), %rdx
movw %si, (%rdx)
movw $0x0, 0x2(%rdx)
leaq 0x10(%rsp), %r14
movq %r14, %rdi
movl $0x10, %esi
movl $0x2, %ecx
xorl %r8d, %r8d
callq 0x170a
movq %r14, %rdi
jmp 0x10959
// File: /workspace/github_c_makefile_star2_O3/MikeGray-APH[P]LibLouisAPH/source/outputs/utf-output.c
// Function: utf16_output_char_escape
void utf16_output_char_escape(FILE *output, const unichar uchar)
{
	char cchars[16];
	unichar uchars[2];

	switch(uchar)
	{
	case 0xa0:   fputs("\\S", output);  break;
	case u' ':   fputs("\\s", output);  break;
	case u'\n':  fputs("\\n", output);  break;
	case u'\r':  fputs("\\r", output);  break;
	case u'\t':  fputs("\\t", output);  break;
	default:

		uchars[0] = uchar;
		uchars[1] = 0;
		utf16_convert_to_utf8(cchars, 16, uchars, 2, NULL);
		fprintf(output, "%s", cchars);
	}

	fflush(output);
}

// Assembly:
pushq %r14
pushq %rbx
subq $0x28, %rsp
movq %rdi, %rbx
cmpl $0xc, %esi
jle 0x109c8
cmpl $0xd, %esi
je 0x109db
cmpl $0x20, %esi
je 0x109e4
cmpl $0xa0, %esi
jne 0x109f6
leaq 0x343e(%rip), %rdi      # 0x13e04
jmp 0x10a21
cmpl $0x9, %esi
je 0x109ed
cmpl $0xa, %esi
jne 0x109f6
leaq 0x3431(%rip), %rdi      # 0x13e0a
jmp 0x10a21
leaq 0x342b(%rip), %rdi      # 0x13e0d
jmp 0x10a21
leaq 0x341c(%rip), %rdi      # 0x13e07
jmp 0x10a21
leaq 0x341c(%rip), %rdi      # 0x13e10
jmp 0x10a21
leaq 0xc(%rsp), %rdx
movw %si, (%rdx)
movw $0x0, 0x2(%rdx)
leaq 0x10(%rsp), %r14
movq %r14, %rdi
movl $0x10, %esi
movl $0x2, %ecx
xorl %r8d, %r8d
callq 0x170a
movq %r14, %rdi
movq %rbx, %rsi
callq 0x1100
movq %rbx, %rdi
callq 0x11a0
addq $0x28, %rsp
popq %rbx
popq %r14
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O3/MikeGray-APH[P]LibLouisAPH/source/outputs/pattern-output.c
// Function: pattern_output
void pattern_output(const unichar *expr_data)
{
	printf("%d    \tlength\n", expr_data[0]);
	printf("%d    \tloops\n", expr_data[1]);
	if(expr_data[0] > 0 && expr_data[0] != PTN_END)
		pattern_output_expression(expr_data, 2);
	fflush(stdout);
}

// Assembly:
pushq %rbx
movq %rdi, %rbx
movzwl (%rdi), %esi
leaq 0x3466(%rip), %rdi      # 0x13eb0
xorl %eax, %eax
callq 0x10c0
movzwl 0x2(%rbx), %esi
leaq 0x3463(%rip), %rdi      # 0x13ebf
xorl %eax, %eax
callq 0x10c0
movzwl (%rbx), %eax
testl %eax, %eax
je 0x10a7e
cmpl $0xffff, %eax           # imm = 0xFFFF
je 0x10a7e
movq %rbx, %rdi
movl $0x2, %esi
callq 0x10a8e
movq 0x7553(%rip), %rax      # 0x17fd8
movq (%rax), %rdi
popq %rbx
jmp 0x11a0
// File: /workspace/github_c_makefile_star2_O3/MikeGray-APH[P]LibLouisAPH/source/outputs/pattern-output.c
// Function: pattern_print
void pattern_print(FILE *output, const unichar *expr_data, const char *attrs_chars_)
{
	set_attrs_chars(attrs_chars_);

	if(expr_data[0] > 0 && expr_data[0] != PTN_END)
		pattern_print_expression(output, expr_data, 2);
	fflush(output);
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rsi, %r14
movq %rdi, %rbx
testq %rdx, %rdx
je 0x11394
movq %rdx, %r15
movq %rdx, %rdi
callq 0x10b0
testl %eax, %eax
jle 0x11394
cmpl $0x20, %eax
movl $0x20, %edx
cmovbl %eax, %edx
leaq 0x6dc4(%rip), %rdi      # 0x18150
movq %r15, %rsi
callq 0x1180
movzwl (%r14), %eax
testl %eax, %eax
je 0x113b3
cmpl $0xffff, %eax           # imm = 0xFFFF
je 0x113b3
movq %rbx, %rdi
movq %r14, %rsi
movl $0x2, %edx
callq 0x10f12
movq %rbx, %rdi
popq %rbx
popq %r14
popq %r15
jmp 0x11a0
// File: /workspace/github_c_makefile_star2_O3/MikeGray-APH[P]LibLouisAPH/source/outputs/conversion-output.c
// Function: conversion_output
void conversion_output(FILE *output, const struct conversion *conversion)
{
	unichar uchar, cell;
	int x, y;

	if(!conversion)
		return;

	fprintf(output, "%s\n", conversion->file_name);

	fputs("unknown:  ", output);
	utf16_output_char_escape(output, conversion->unknown);
	fputs("\n", output);

	fputs("\n", output);

	cell = 0x2800;
	for(y = 0; y < 16; y++)
	{
		for(x = 0; x < 16; x++)
		{
			uchar = conversion->converts[(y * 16) + x];
			if(uchar != cell)
				utf16_output_char(output, uchar);
			else
				fputs(" ", output);
			utf16_output_char(output, cell);
			if(x != 15)
				fputs(" ", output);
			cell++;
		}
		fputs("\n", output);
	}

	fflush(output);
}

// Assembly:
testq %rsi, %rsi
je 0x114df
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rsi, %r14
movq %rdi, %rbx
movq 0x8(%rsi), %rdx
leaq 0x276f(%rip), %rsi      # 0x13b78
xorl %r13d, %r13d
xorl %eax, %eax
callq 0x1160
leaq 0x2bc0(%rip), %rdi      # 0x13fda
movq %rbx, %rsi
callq 0x1100
movzwl 0x210(%r14), %esi
movq %rbx, %rdi
callq 0x1099e
leaq 0x2c13(%rip), %r15      # 0x1404c
movq %r15, %rdi
movq %rbx, %rsi
callq 0x1100
movq %r15, %rdi
movq %rbx, %rsi
callq 0x1100
addq $0x10, %r14
movw $0x2800, %bp            # imm = 0x2800
leaq 0x2e05(%rip), %r12      # 0x14263
movq $-0x1e, %r15
movzwl 0x1e(%r14,%r15), %eax
cmpw %ax, %bp
jne 0x1147d
movq %r12, %rdi
movq %rbx, %rsi
callq 0x1100
jmp 0x11488
movzwl %ax, %esi
movq %rbx, %rdi
callq 0x10929
movzwl %bp, %esi
movq %rbx, %rdi
callq 0x10929
testq %r15, %r15
je 0x114ab
movq %r12, %rdi
movq %rbx, %rsi
callq 0x1100
incl %ebp
addq $0x2, %r15
jmp 0x11465
incl %ebp
leaq 0x2b98(%rip), %rdi      # 0x1404c
movq %rbx, %rsi
callq 0x1100
incq %r13
addq $0x20, %r14
cmpq $0x10, %r13
jne 0x1145e
movq %rbx, %rdi
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x11a0
retq
// File: /workspace/github_c_makefile_star2_O3/MikeGray-APH[P]LibLouisAPH/source/outputs/table-output.c
// Function: subpattern_output
static void subpattern_output(FILE *output, const struct subpattern *subpattern)
{
	int i;

	if(!subpattern)
		return;

	subpattern_output(output, subpattern->nxt);

	fputs("   ", output);

	utf16_output(output, subpattern->tag, subpattern->tag_len);

	fputs("   ", output);

	utf16_output(output, subpattern->src_data, subpattern->src_len);

	for(i = 0; i < subpattern->src_len; i++)
	{
		if(subpattern->src_data[i] == u'\\')
		{
			i++;
			continue;
		}
		if(subpattern->src_data[i] == u'@')
		{
			fputs("   ", output);
			pattern_print(output, subpattern->expr_data, attrs_chars);
			break;
		}
	}

	fputs("\n", output);
}

// Assembly:
testq %rsi, %rsi
je 0x11d96
pushq %r15
pushq %r14
pushq %rbx
movq %rsi, %r14
movq %rdi, %rbx
movq (%rsi), %rsi
callq 0x11d16
leaq 0x252c(%rip), %r15      # 0x14261
movq %r15, %rdi
movq %rbx, %rsi
callq 0x1100
movq 0x8(%r14), %rsi
movl 0x20(%r14), %edx
movq %rbx, %rdi
callq 0x108bc
movq %r15, %rdi
movq %rbx, %rsi
callq 0x1100
movq 0x18(%r14), %rsi
movl 0x28(%r14), %edx
movq %rbx, %rdi
callq 0x108bc
movl 0x28(%r14), %eax
testl %eax, %eax
jle 0x11db9
movq 0x18(%r14), %rcx
xorl %edx, %edx
movslq %edx, %rsi
movzwl (%rcx,%rsi,2), %esi
cmpl $0x5c, %esi
je 0x11d8c
cmpl $0x40, %esi
jne 0x11d8e
jmp 0x11d97
incl %edx
incl %edx
cmpl %eax, %edx
jl 0x11d79
jmp 0x11db9
retq
leaq 0x24c3(%rip), %rdi      # 0x14261
movq %rbx, %rsi
callq 0x1100
movq 0x10(%r14), %rsi
leaq 0x84ef(%rip), %rdx      # 0x1a2a0
movq %rbx, %rdi
callq 0x1135b
leaq 0x228c(%rip), %rdi      # 0x1404c
movq %rbx, %rsi
popq %rbx
popq %r14
popq %r15
jmp 0x1100
// File: /workspace/github_c_makefile_star2_O3/MikeGray-APH[P]LibLouisAPH/source/outputs/table-output.c
// Function: filter_output
static void filter_output(FILE *output, const struct filter *filter)
{
	if(!filter)
		return;

	filter_output(output, filter->nxt);

	fputs("   ", output);
	if(filter->name)
		utf16_output(output, filter->name, filter->name_len);
	else
		fputs("   -", output);

	fputs("   ", output);
	if(filter->before)
		pattern_print_reverse(output, filter->before, filter->before_len);
	else
		fputs("-", output);

	fputs("   ", output);
	if(filter->after)
		pattern_print(output, filter->after, attrs_chars);
	else
		fputs("-", output);

	fputs("\n", output);
}

// Assembly:
testq %rsi, %rsi
je 0x11e0a
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %r14
movq %rdi, %rbx
movq (%rsi), %rsi
callq 0x11dcd
leaq 0x2476(%rip), %rdi      # 0x14261
movq %rbx, %rsi
callq 0x1100
movq 0x20(%r14), %rsi
testq %rsi, %rsi
je 0x11e0b
movl 0x28(%r14), %edx
movq %rbx, %rdi
callq 0x108bc
jmp 0x11e1a
retq
leaq 0x243f(%rip), %rdi      # 0x14251
movq %rbx, %rsi
callq 0x1100
leaq 0x2440(%rip), %rdi      # 0x14261
movq %rbx, %rsi
callq 0x1100
movq 0x8(%r14), %rsi
testq %rsi, %rsi
je 0x11e40
movl 0x18(%r14), %edx
movq %rbx, %rdi
callq 0x12171
jmp 0x11e4f
leaq 0x240d(%rip), %rdi      # 0x14254
movq %rbx, %rsi
callq 0x1100
leaq 0x240b(%rip), %rdi      # 0x14261
movq %rbx, %rsi
callq 0x1100
movq 0x10(%r14), %rsi
testq %rsi, %rsi
je 0x11e78
leaq 0x8432(%rip), %rdx      # 0x1a2a0
movq %rbx, %rdi
callq 0x1135b
jmp 0x11e87
leaq 0x23d5(%rip), %rdi      # 0x14254
movq %rbx, %rsi
callq 0x1100
leaq 0x21be(%rip), %rdi      # 0x1404c
movq %rbx, %rsi
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x1100
// File: /workspace/github_c_makefile_star2_O3/MikeGray-APH[P]LibLouisAPH/source/outputs/table-output.c
// Function: pattern_print_reverse
static void pattern_print_reverse(FILE *output, unichar *expr_data, const int expr_len)
{
	unichar *expr_rev;

	expr_rev = MALLOC(expr_len * sizeof(unichar));
	memcpy(expr_rev, expr_data, expr_len * sizeof(unichar));
	pattern_reverse(expr_rev);
	pattern_print(output, expr_rev, attrs_chars);
	FREE(expr_rev);
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq %rdi, %r14
movslq %edx, %r15
addq %r15, %r15
movq %r15, %rdi
callq 0x1190
movq %rax, %r12
movq %rax, %rdi
movq %rbx, %rsi
movq %r15, %rdx
callq 0x1180
movq %r12, %rdi
callq 0x84e0
leaq 0x80f3(%rip), %rdx      # 0x1a2a0
movq %r14, %rdi
movq %r12, %rsi
callq 0x1135b
movq %r12, %rdi
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
jmp 0x1040
nop
// File: /workspace/github_c_makefile_star2_O3/MikeGray-APH[P]LibLouisAPH/debug/debug.c
// Function: debug_output
void debug_output(const unichar *uchars, const int uchars_len)
{
	char cchars[0x4000];
	int cchars_len;

	if(uchars_len <= 0 || !uchars)
	{
		puts("");
		fflush(stdout);
		return;
	}

	memset(cchars, 0, 0x4000);
	cchars_len = utf16_convert_to_utf8(cchars, 0x4000, uchars, uchars_len, NULL);
	cchars_convert_spaces(cchars, cchars_len);

	printf("%s", cchars);
	fflush(stdout);
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
subq $0x4000, %rsp           # imm = 0x4000
testl %esi, %esi
setg %al
testq %rdi, %rdi
setne %cl
testb %al, %cl
je 0x1226f
movl %esi, %ebx
movq %rdi, %r14
movq %rsp, %r15
movl $0x4000, %edx           # imm = 0x4000
movq %r15, %rdi
xorl %esi, %esi
callq 0x1110
movq %r15, %rdi
movl $0x4000, %esi           # imm = 0x4000
movq %r14, %rdx
movl %ebx, %ecx
xorl %r8d, %r8d
callq 0x170a
testl %eax, %eax
jle 0x12242
movl %eax, %eax
xorl %ecx, %ecx
movzbl (%rsp,%rcx), %edx
leal -0x9(%rdx), %esi
cmpl $0x2, %esi
jb 0x12236
cmpl $0xd, %edx
je 0x12236
testl %edx, %edx
jne 0x1223a
jmp 0x12242
movb $0x20, (%rsp,%rcx)
incq %rcx
cmpq %rcx, %rax
jne 0x1221f
leaq 0x1919(%rip), %rdi      # 0x13b62
movq %rsp, %rsi
xorl %eax, %eax
callq 0x10c0
movq 0x5d7e(%rip), %rax      # 0x17fd8
movq (%rax), %rdi
callq 0x11a0
addq $0x4000, %rsp           # imm = 0x4000
popq %rbx
popq %r14
popq %r15
retq
movl $0xa, %edi
callq 0x1050
movq 0x5d58(%rip), %rax      # 0x17fd8
movq (%rax), %rdi
addq $0x4000, %rsp           # imm = 0x4000
popq %rbx
popq %r14
popq %r15
jmp 0x11a0
// File: /workspace/github_c_makefile_star2_O3/MikeGray-APH[P]LibLouisAPH/debug/debug.c
// Function: debug_output_line
void debug_output_line(const unichar *uchars, const int uchars_len)
{
	char cchars[0x4000];
	int cchars_len;

	rewind(stdout);

	if(uchars_len <= 0 || !uchars)
	{
		puts("");
		fflush(stdout);
		return;
	}

	memset(cchars, 0, 0x4000);
	cchars_len = utf16_convert_to_utf8(cchars, 0x4000, uchars, uchars_len, NULL);
	cchars_convert_spaces(cchars, cchars_len);

	printf("%s\n", cchars);
	fflush(stdout);
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x4008, %rsp           # imm = 0x4008
movl %esi, %ebx
movq %rdi, %r14
movq 0x5d2a(%rip), %r12      # 0x17fd8
movq (%r12), %rdi
callq 0x10d0
testl %ebx, %ebx
setg %al
testq %r14, %r14
setne %cl
testb %al, %cl
je 0x12338
movq %rsp, %r15
movl $0x4000, %edx           # imm = 0x4000
movq %r15, %rdi
xorl %esi, %esi
callq 0x1110
movq %r15, %rdi
movl $0x4000, %esi           # imm = 0x4000
movq %r14, %rdx
movl %ebx, %ecx
xorl %r8d, %r8d
callq 0x170a
testl %eax, %eax
jle 0x12318
movl %eax, %eax
xorl %ecx, %ecx
movzbl (%rsp,%rcx), %edx
leal -0x9(%rdx), %esi
cmpl $0x2, %esi
jb 0x1230c
cmpl $0xd, %edx
je 0x1230c
testl %edx, %edx
jne 0x12310
jmp 0x12318
movb $0x20, (%rsp,%rcx)
incq %rcx
cmpq %rcx, %rax
jne 0x122f5
movq %rsp, %rdi
callq 0x1090
movq (%r12), %rdi
callq 0x11a0
addq $0x4008, %rsp           # imm = 0x4008
popq %rbx
popq %r12
popq %r14
popq %r15
retq
movl $0xa, %edi
callq 0x1050
movq (%r12), %rdi
addq $0x4008, %rsp           # imm = 0x4008
popq %rbx
popq %r12
popq %r14
popq %r15
jmp 0x11a0
// File: /workspace/github_c_makefile_star2_O3/MikeGray-APH[P]LibLouisAPH/debug/debug.c
// Function: debug_output_pad
void debug_output_pad(const unichar *uchars, const int uchars_len)
{
	char cchars[0x4000];
	int cchars_len, i;

	if(uchars_len <= 0 || !uchars)
	{
		puts("");
		fflush(stdout);
		return;
	}

	memset(cchars, 0, 0x4000);
	cchars_len = utf16_convert_to_utf8(cchars, 0x4000, uchars, uchars_len, NULL);
	cchars_convert_spaces(cchars, cchars_len);

	printf("%s", cchars);
	for(i = strlen(cchars); i < uchars_len; i++)
		printf(" ");
	fflush(stdout);
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
subq $0x4000, %rsp           # imm = 0x4000
testl %esi, %esi
setg %al
testq %rdi, %rdi
setne %cl
testb %al, %cl
je 0x12419
movl %esi, %ebx
movq %rdi, %r14
movq %rsp, %r15
movl $0x4000, %edx           # imm = 0x4000
movq %r15, %rdi
xorl %esi, %esi
callq 0x1110
movq %r15, %rdi
movl $0x4000, %esi           # imm = 0x4000
movq %r14, %rdx
movl %ebx, %ecx
xorl %r8d, %r8d
callq 0x170a
testl %eax, %eax
jle 0x123cf
movl %eax, %eax
xorl %ecx, %ecx
movzbl (%rsp,%rcx), %edx
leal -0x9(%rdx), %esi
cmpl $0x2, %esi
jb 0x123c3
cmpl $0xd, %edx
je 0x123c3
testl %edx, %edx
jne 0x123c7
jmp 0x123cf
movb $0x20, (%rsp,%rcx)
incq %rcx
cmpq %rcx, %rax
jne 0x123ac
leaq 0x178c(%rip), %rdi      # 0x13b62
movq %rsp, %r14
movq %r14, %rsi
xorl %eax, %eax
callq 0x10c0
movq %r14, %rdi
callq 0x10b0
subl %eax, %ebx
jle 0x123fd
movl $0x20, %edi
callq 0x1050
decl %ebx
jne 0x123ef
movq 0x5bd4(%rip), %rax      # 0x17fd8
movq (%rax), %rdi
callq 0x11a0
addq $0x4000, %rsp           # imm = 0x4000
popq %rbx
popq %r14
popq %r15
retq
movl $0xa, %edi
callq 0x1050
movq 0x5bae(%rip), %rax      # 0x17fd8
movq (%rax), %rdi
addq $0x4000, %rsp           # imm = 0x4000
popq %rbx
popq %r14
popq %r15
jmp 0x11a0
// File: /workspace/github_c_makefile_star2_O3/MikeGray-APH[P]LibLouisAPH/debug/debug.c
// Function: debug_output_chomp
void debug_output_chomp(const unichar *uchars, const int uchars_len)
{
	char cchars[0x4000], *crs;
	int cchars_len;

	if(uchars_len <= 0 || !uchars)
	{
		puts("");
		fflush(stdout);
		return;
	}

	memset(cchars, 0, 0x4000);
	cchars_len = utf16_convert_to_utf8(cchars, 0x4000, uchars, uchars_len, NULL);
	cchars_convert_spaces(cchars, cchars_len);

	for(crs = cchars; *crs; crs++);
	crs--;
	while(crs >= cchars && (*crs == '\n' || *crs == '\r'))
		*crs-- = 0;
	printf("%s", cchars);
	fflush(stdout);
}

// Assembly:
pushq %rbp
pushq %r14
pushq %rbx
subq $0x4000, %rsp           # imm = 0x4000
testl %esi, %esi
setg %al
testq %rdi, %rdi
setne %cl
testb %al, %cl
je 0x12508
movl %esi, %ebp
movq %rdi, %r14
movq %rsp, %rbx
movl $0x4000, %edx           # imm = 0x4000
movq %rbx, %rdi
xorl %esi, %esi
callq 0x1110
movq %rbx, %rdi
movl $0x4000, %esi           # imm = 0x4000
movq %r14, %rdx
movl %ebp, %ecx
xorl %r8d, %r8d
callq 0x170a
testl %eax, %eax
jle 0x124b3
movl %eax, %eax
xorl %ecx, %ecx
movzbl (%rsp,%rcx), %edx
leal -0x9(%rdx), %esi
cmpl $0x2, %esi
jb 0x124a7
cmpl $0xd, %edx
je 0x124a7
testl %edx, %edx
jne 0x124ab
jmp 0x124b3
movb $0x20, (%rsp,%rcx)
incq %rcx
cmpq %rcx, %rax
jne 0x12490
leaq -0x2(%rsp), %rax
cmpb $0x0, 0x2(%rax)
leaq 0x1(%rax), %rax
jne 0x124b8
jmp 0x124d7
movzbl (%rax), %ecx
cmpl $0xd, %ecx
je 0x124d1
cmpl $0xa, %ecx
jne 0x124dc
movb $0x0, (%rax)
decq %rax
cmpq %rbx, %rax
jae 0x124c4
leaq 0x167f(%rip), %rdi      # 0x13b62
movq %rsp, %rsi
xorl %eax, %eax
callq 0x10c0
movq 0x5ae4(%rip), %rax      # 0x17fd8
movq (%rax), %rdi
callq 0x11a0
addq $0x4000, %rsp           # imm = 0x4000
popq %rbx
popq %r14
popq %rbp
retq
movl $0xa, %edi
callq 0x1050
movq 0x5abf(%rip), %rax      # 0x17fd8
movq (%rax), %rdi
addq $0x4000, %rsp           # imm = 0x4000
popq %rbx
popq %r14
popq %rbp
jmp 0x11a0
// File: /workspace/github_c_makefile_star2_O3/MikeGray-APH[P]LibLouisAPH/debug/debug.c
// Function: debug_output_uchar
void debug_output_uchar(const unichar uchar)
{
	char cchars[16];
	unichar uchars[2];

	switch(uchar)
	{
	case 0xa0:
	case u' ':
	case u'\n':
	case u'\r':
	case u'\t':  printf(" ");  break;
	default:

		uchars[0] = uchar;
		uchars[1] = 0;
		utf16_convert_to_utf8(cchars, 16, uchars, 2, NULL);
		printf("%s", cchars);
	}

	fflush(stdout);
}

// Assembly:
pushq %rbx
subq $0x20, %rsp
cmpl $0x20, %edi
ja 0x12548
movl %edi, %eax
movabsq $0x100002600, %rcx      # imm = 0x100002600
btq %rax, %rcx
jb 0x12550
cmpl $0xa0, %edi
jne 0x1256f
movl $0x20, %edi
callq 0x1050
movq 0x5a77(%rip), %rax      # 0x17fd8
movq (%rax), %rdi
callq 0x11a0
addq $0x20, %rsp
popq %rbx
retq
leaq 0xc(%rsp), %rdx
movw %di, (%rdx)
movw $0x0, 0x2(%rdx)
leaq 0x10(%rsp), %rbx
movq %rbx, %rdi
movl $0x10, %esi
movl $0x2, %ecx
xorl %r8d, %r8d
callq 0x170a
leaq 0x15c4(%rip), %rdi      # 0x13b62
movq %rbx, %rsi
xorl %eax, %eax
callq 0x10c0
jmp 0x1255a
// File: /workspace/github_c_makefile_star2_O3/MikeGray-APH[P]LibLouisAPH/debug/debug.c
// Function: debug_output_uchar_escape
void debug_output_uchar_escape(const unichar uchar)
{
	char cchars[16];
	unichar uchars[2];

	switch(uchar)
	{
	case 0xa0:   printf("\\S");  break;
	case u' ':   printf("\\s");  break;
	case u'\n':  printf("\\n");  break;
	case u'\r':  printf("\\r");  break;
	case u'\t':  printf("\\t");  break;
	default:

		uchars[0] = uchar;
		uchars[1] = 0;
		utf16_convert_to_utf8(cchars, 16, uchars, 2, NULL);
		printf("%s", cchars);
	}

	fflush(stdout);
}

// Assembly:
pushq %rbx
subq $0x20, %rsp
cmpl $0xc, %edi
jle 0x125cf
cmpl $0xd, %edi
je 0x125e2
cmpl $0x20, %edi
je 0x125eb
cmpl $0xa0, %edi
jne 0x12617
leaq 0x1837(%rip), %rdi      # 0x13e04
jmp 0x125fb
cmpl $0x9, %edi
je 0x125f4
cmpl $0xa, %edi
jne 0x12617
leaq 0x182a(%rip), %rdi      # 0x13e0a
jmp 0x125fb
leaq 0x1824(%rip), %rdi      # 0x13e0d
jmp 0x125fb
leaq 0x1815(%rip), %rdi      # 0x13e07
jmp 0x125fb
leaq 0x1815(%rip), %rdi      # 0x13e10
xorl %eax, %eax
callq 0x10c0
movq 0x59cf(%rip), %rax      # 0x17fd8
movq (%rax), %rdi
callq 0x11a0
addq $0x20, %rsp
popq %rbx
retq
leaq 0xc(%rsp), %rdx
movw %di, (%rdx)
movw $0x0, 0x2(%rdx)
leaq 0x10(%rsp), %rbx
movq %rbx, %rdi
movl $0x10, %esi
movl $0x2, %ecx
xorl %r8d, %r8d
callq 0x170a
leaq 0x151c(%rip), %rdi      # 0x13b62
movq %rbx, %rsi
xorl %eax, %eax
callq 0x10c0
jmp 0x12602
// File: /workspace/github_c_makefile_star2_O3/MikeGray-APH[P]LibLouisAPH/debug/debug.c
// Function: debug_output_convert_private
void debug_output_convert_private(const struct table *table, const unichar *uchars, const int uchars_len)
{
	unichar convert[0x4000];

	if(uchars_len > 0x3fff)
	{
		log_message(LOG_ERROR, "TOO LONG");
		return;
	}

	memset(convert, 0, 0x4000 * sizeof(unichar));
	memcpy(convert, uchars, uchars_len * sizeof(unichar));
	table_convert_markers(table, convert, uchars_len);
	utf16_output(stdout, convert, uchars_len);
}

// Assembly:
cmpl $0x4000, %edx           # imm = 0x4000
jl 0x1266d
leaq 0x1c14(%rip), %rsi      # 0x14275
movl $0x6, %edi
xorl %eax, %eax
jmp 0xa278
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x8008, %rsp           # imm = 0x8008
movl %edx, %ebx
movq %rsi, %r15
movq %rdi, %r14
movq %rsp, %r12
movl $0x8000, %edx           # imm = 0x8000
movq %r12, %rdi
xorl %esi, %esi
callq 0x1110
movslq %ebx, %rdx
addq %rdx, %rdx
movq %r12, %rdi
movq %r15, %rsi
callq 0x1180
testq %r14, %r14
je 0x12732
testl %ebx, %ebx
jle 0x12764
movl %ebx, %eax
movzwl 0x1e8(%r14), %ecx
xorl %edx, %edx
movzwl (%rsp,%rdx,2), %esi
movw $0x27d8, %di            # imm = 0x27D8
cmpw %cx, %si
je 0x12724
movw $0x27ea, %di            # imm = 0x27EA
cmpw 0x1ea(%r14), %si
je 0x12724
movw $0x27eb, %di            # imm = 0x27EB
cmpw 0x1ec(%r14), %si
je 0x12724
movw $0x2605, %di            # imm = 0x2605
cmpw 0x1ee(%r14), %si
je 0x12724
movw $0x27e0, %di            # imm = 0x27E0
cmpw 0x1f0(%r14), %si
je 0x12724
movw $0x27ca, %di            # imm = 0x27CA
cmpw 0x1f2(%r14), %si
je 0x12724
movw $0x2623, %di            # imm = 0x2623
cmpw 0x1f4(%r14), %si
jne 0x12728
movw %di, (%rsp,%rdx,2)
incq %rdx
cmpq %rdx, %rax
jne 0x126c3
jmp 0x12764
testl %ebx, %ebx
jle 0x12764
movl %ebx, %eax
xorl %ecx, %ecx
leaq 0x1b3d(%rip), %rdx      # 0x1427e
movzwl (%rsp,%rcx,2), %esi
addl $0xfff, %esi            # imm = 0xFFF
cmpw $0x6, %si
ja 0x1275c
movzwl %si, %esi
movzwl (%rdx,%rsi,2), %esi
movw %si, (%rsp,%rcx,2)
incq %rcx
cmpq %rcx, %rax
jne 0x12741
movq 0x586d(%rip), %rax      # 0x17fd8
movq (%rax), %rdi
movq %rsp, %rsi
movl %ebx, %edx
callq 0x108bc
addq $0x8008, %rsp           # imm = 0x8008
popq %rbx
popq %r12
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O3/videolan[P]bitstream/examples/dvb_ecmg.c
// Function: main.cold.3
static void handle_channel_close(uint8_t *p_tlv)
{
    uint16_t i_wanted_channelid = ecmg_find_channelid(p_tlv, 0);
    int i;

    if (i_wanted_channelid != i_channelid) {
        send_channel_error(i_wanted_channelid, 0x6);
        return;
    }

    fprintf(stderr, "stopping channel ID=0x%x\n", i_channelid);

    b_init = true;

    for (i = 0; i < i_nb_streams; i++)
        free(pp_streams[i]);
    free(pp_streams);
    pp_streams = NULL;
    i_nb_streams = 0;
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movzwl %di, %edx
movq 0x48e4(%rip), %rax      # 0x5ff8
movq (%rax), %rdi
leaq 0x2c25(%rip), %rsi      # 0x4343
xorl %eax, %eax
callq 0x1070
movb $0x0, 0x495c(%rip)      # 0x6088
movslq 0x4959(%rip), %r14      # 0x608c
movq 0x4956(%rip), %rbx      # 0x6090
testq %r14, %r14
jle 0x1753
xorl %r15d, %r15d
movq (%rbx,%r15,8), %rdi
callq 0x1030
incq %r15
cmpq %r15, %r14
jne 0x1742
movq %rbx, %rdi
callq 0x1030
andq $0x0, 0x492d(%rip)      # 0x6090
andl $0x0, 0x4922(%rip)      # 0x608c
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O3/videolan[P]bitstream/examples/dvb_ecmg.c
// Function: read_wrapper
ssize_t read_wrapper(void *p_buf, size_t i_count)
{
    size_t i_received = 0;

    do {
        ssize_t i_read = read(STDIN_FILENO, p_buf + i_received,
                              i_count - i_received);
        if (i_read < 0 && errno == EINTR) continue;
        if (i_read < 0) {
            fprintf(stderr, "read error, aborting (%m)");
            return i_read;
        }
        if (!i_read) {
            fprintf(stderr, "read end-of-file, aborting");
            return i_read;
        }
        i_received += i_read;
    } while (i_received < i_count);

    return i_count;
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq %rdi, %r14
xorl %r12d, %r12d
leaq (%r14,%r12), %rsi
movq %rbx, %rdx
subq %r12, %rdx
xorl %edi, %edi
callq 0x1060
movq %rax, %r15
testq %rax, %rax
js 0x192d
je 0x194b
addq %r15, %r12
jmp 0x1937
callq 0x1040
cmpl $0x4, (%rax)
jne 0x1954
cmpq %rbx, %r12
jb 0x190d
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
callq 0x1518
xorl %ebx, %ebx
jmp 0x193c
callq 0x1534
movq %r15, %rbx
jmp 0x193c
// File: /workspace/github_c_makefile_star2_O3/videolan[P]bitstream/examples/dvb_ecmg.c
// Function: write_wrapper
ssize_t write_wrapper(const void *p_buf, size_t i_count)
{
    size_t i_sent = 0;

    do {
        ssize_t i_written = write(STDOUT_FILENO,
                                  p_buf + i_sent, i_count - i_sent);
        if (i_written < 0 && errno == EINTR) continue;
        if (i_written < 0) {
            fprintf(stderr, "write error (%m)");
            return i_written;
        }
        i_sent += i_written;
    } while (i_sent < i_count);

    return i_count;
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq %rdi, %r14
xorl %r12d, %r12d
leaq (%r14,%r12), %rsi
movq %rbx, %rdx
subq %r12, %rdx
movl $0x1, %edi
callq 0x1050
movq %rax, %r15
testq %rax, %rax
js 0x1990
addq %r15, %r12
jmp 0x199a
callq 0x1040
cmpl $0x4, (%rax)
jne 0x19ae
cmpq %rbx, %r12
jb 0x196f
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
callq 0x154c
movq %r15, %rbx
jmp 0x199f
// File: /workspace/github_c_makefile_star2_O3/videolan[P]bitstream/examples/./bitstream/dvb/sim.h
// Function: tlv_find_param
static inline uint8_t *tlv_find_param(uint8_t *p_tlv, uint16_t i_type,
                                      uint16_t n)
{
    uint8_t *p_param;
    uint8_t j = 0;

    while ((p_param = tlv_get_param(p_tlv, j)) != NULL) {
        j++;
        if (tlv_get_type(p_param) == i_type) {
            if (!n) return p_param;
            n--;
        }
    }

    return NULL;
}

// Assembly:
movzwl 0x2(%rdi), %eax
rolw $0x8, %ax
movzwl %ax, %eax
leaq 0x4(%rdi), %rcx
testl %edx, %edx
sete %r8b
xorl %edx, %edx
movq %rcx, %r9
testb %dl, %dl
je 0x2b6c
movzbl %dl, %r10d
movq %rcx, %r9
movq %r9, %r11
subq %rdi, %r11
cmpq %rax, %r11
jg 0x2b95
movzwl 0x2(%r9), %r11d
rolw $0x8, %r11w
movzwl %r11w, %r11d
addq %r11, %r9
addq $0x4, %r9
decw %r10w
jne 0x2b46
movq %r9, %r10
subq %rdi, %r10
addq $-0x4, %r10
cmpq %rax, %r10
jge 0x2b95
incb %dl
movzwl (%r9), %r9d
rolw $0x8, %r9w
cmpw %si, %r9w
jne 0x2b38
testb $0x1, %r8b
movb $0x1, %r8b
je 0x2b38
retq
// File: /workspace/github_c_makefile_star2_O3/dubeyalok7[P]crypto-algo/des/feistal_algo/feistal.c
// Function: fesital
void fesital(FILE *ifile, FILE *ofile, int op)
{
  uint32_t keys[ROUNDS] = { 0xDEAD, 0xBEEF, 0xBAAD, 0xF00D, 0xFEED, 0xFACE, 0xCAFE, 0xBABE, 0xDEAD, 0xBABE, 0xD15, 0xEA5E, 0xDECE, 0xA5ED, 0xBAAD, 0xAC1D };
  char *key = getKey();
  if(!generateSubKeys(key, keys)){
    help();
    printf("Error: key generation getting failed\n");
    return;
  }
  switch(op){
    case 0:
      encrypt_ecb(ifile, ofile, keys);
      printf("Encrypted file is generated\n");
      break;
    case 1:
      decrypt_ecb(ifile, ofile, keys);
      printf("Decrypted file is generated\n");
      break;
    default:
      printf("Invalid option\n");
      break;
  }
  free(key);
  return;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x68, %rsp
movl %edx, %ebp
movq %rsi, 0x8(%rsp)
movq %rdi, %r15
movaps 0xf91(%rip), %xmm0      # 0x21e0
leaq 0x20(%rsp), %r12
movaps %xmm0, 0x30(%r12)
movaps 0xf6f(%rip), %xmm0      # 0x21d0
movaps %xmm0, 0x20(%r12)
movaps 0xf52(%rip), %xmm0      # 0x21c0
movaps %xmm0, 0x10(%r12)
movaps 0xf35(%rip), %xmm0      # 0x21b0
movaps %xmm0, (%r12)
movl $0x1, %edi
movl $0xa, %esi
callq 0x10a0
leaq 0x18(%rsp), %r13
movq %rax, (%r13)
leaq 0x10(%rsp), %r14
movq $0xa, (%r14)
leaq 0xd8b(%rip), %rdi       # 0x2036
xorl %ebx, %ebx
xorl %eax, %eax
callq 0x1080
movq 0x2d25(%rip), %rax      # 0x3fe0
movq (%rax), %rdx
movq %r13, %rdi
movq %r14, %rsi
callq 0x10d0
movq (%r13), %r14
movq %r14, %rdi
callq 0x1070
cmpq $0x9, %rax
cmoveq %r14, %rbx
movq %rbx, %rdi
movq %r12, %rsi
callq 0x150c
testl %eax, %eax
je 0x1310
cmpl $0x1, %ebp
je 0x1323
testl %ebp, %ebp
jne 0x133e
leaq 0x20(%rsp), %rdx
movq %r15, %rdi
movq 0x8(%rsp), %rsi
callq 0x1364
leaq 0xe68(%rip), %rdi       # 0x2176
jmp 0x1345
callq 0x11fc
leaq 0xe19(%rip), %rdi       # 0x2135
callq 0x1040
jmp 0x1352
leaq 0x20(%rsp), %rdx
movq %r15, %rdi
movq 0x8(%rsp), %rsi
callq 0x1438
leaq 0xe1e(%rip), %rdi       # 0x215a
jmp 0x1345
leaq 0xe4d(%rip), %rdi       # 0x2192
callq 0x1040
movq %rbx, %rdi
callq 0x1030
addq $0x68, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O3/dubeyalok7[P]crypto-algo/des/feistal_algo/feistal_encrypt.c
// Function: encrypt_ecb
void encrypt_ecb(FILE *infile, FILE *outfile, uint32_t keys[])
{
  uint32_t left, right;
  size_t ret;
  uint64_t sblock;
  memset(&sblock,0,sizeof(sblock));
  while(fread(&sblock, sizeof(sblock), 1, infile)){    
    left = (sblock>>32);
    right = ((sblock<<32)>>32);
    sblock = encrypt(left, right, keys);
    fwrite(&sblock,1,sizeof(sblock), outfile);
    memset(&sblock,0,sizeof(sblock));
  }
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %rdx, %rbx
movq %rsi, 0x10(%rsp)
movq %rdi, %r15
leaq 0x8(%rsp), %rdi
movq $0x0, (%rdi)
movl $0x8, %esi
movl $0x1, %edx
movq %r15, %rcx
callq 0x1050
testq %rax, %rax
je 0x1426
leaq 0x8(%rsp), %r12
movq 0x8(%rsp), %rcx
movq %rcx, %r14
shrq $0x20, %r14
movq $-0x10, %r13
movl %ecx, %ebp
movl 0x40(%rbx,%r13,4), %esi
movl %ecx, %edi
callq 0x1534
xorl %r14d, %eax
movl %eax, %ecx
incq %r13
cmovel %ebp, %ecx
movl %ebp, %r14d
cmovel %eax, %r14d
jne 0x13bc
shlq $0x20, %rax
movl %ebp, %ecx
orq %rax, %rcx
movq %rcx, 0x8(%rsp)
movl $0x1, %esi
movl $0x8, %edx
movq %r12, %rdi
movq 0x10(%rsp), %rcx
callq 0x10e0
movq $0x0, 0x8(%rsp)
movl $0x8, %esi
movl $0x1, %edx
movq %r12, %rdi
movq %r15, %rcx
callq 0x1050
testq %rax, %rax
jne 0x13a9
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
nopl (%rax)