LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O2/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(%rbx), %rdi
testq %rdi, %rdi
je 0xcb0a
cmpl $0x4, 0x18(%rdi)
jne 0xcb0a
callq 0xcabb
movl 0x1c(%rbx), %ecx
movq 0x8(%rbx), %rax
cmpl 0x1c(%rax), %ecx
jle 0xcb0a
movq (%rbx), %rcx
testq %rcx, %rcx
je 0xcaeb
movq %rax, 0x8(%rcx)
movq 0x8(%rax), %rdx
testq %rdx, %rdx
je 0xcafa
movq %rbx, (%rdx)
movq (%rbx), %rcx
movq %rcx, (%rax)
movq %rdx, 0x8(%rbx)
movq %rbx, 0x8(%rax)
movq %rax, (%rbx)
jmp 0xcabf
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O2/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(%rbx), %rdi
testq %rdi, %rdi
je 0xcb5b
cmpl $0x2, 0x18(%rdi)
jne 0xcb5b
callq 0xcb0c
movl 0x1c(%rbx), %ecx
movq 0x8(%rbx), %rax
cmpl 0x1c(%rax), %ecx
jge 0xcb5b
movq (%rbx), %rcx
testq %rcx, %rcx
je 0xcb3c
movq %rax, 0x8(%rcx)
movq 0x8(%rax), %rdx
testq %rdx, %rdx
je 0xcb4b
movq %rbx, (%rdx)
movq (%rbx), %rcx
movq %rcx, (%rax)
movq %rdx, 0x8(%rbx)
movq %rbx, 0x8(%rax)
movq %rax, (%rbx)
jmp 0xcb10
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O2/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(%rbx), %rdi
testq %rdi, %rdi
je 0xcba6
callq 0xcb5d
movl 0x1c(%rbx), %ecx
movq 0x8(%rbx), %rax
cmpl 0x1c(%rax), %ecx
jle 0xcba6
movq (%rbx), %rcx
testq %rcx, %rcx
je 0xcb87
movq %rax, 0x8(%rcx)
movq 0x8(%rax), %rdx
testq %rdx, %rdx
je 0xcb96
movq %rbx, (%rdx)
movq (%rbx), %rcx
movq %rcx, (%rax)
movq %rdx, 0x8(%rbx)
movq %rbx, 0x8(%rax)
movq %rax, (%rbx)
jmp 0xcb61
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O2/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 0xcbec
movq %rdx, %r15
movq %rsi, %r14
movq %rdi, %rbx
movq 0x8(%rdx), %rdx
callq 0xcba8
movl 0x18(%r15), %eax
decl %eax
cmpl $0x7, %eax
ja 0xcc3c
leaq 0x5052(%rip), %rcx      # 0x11c28
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
movq 0x10(%r15), %rsi
movl 0x54(%rsi), %edx
addq $0xc, %rsi
jmp 0xcc27
pushq $0x1
popq %rax
popq %rbx
popq %r14
popq %r15
retq
movq 0x10(%r15), %rsi
movl 0x64(%rsi), %edx
addq $0x44, %rsi
jmp 0xcc27
movq 0x10(%r15), %rsi
movl 0x5c(%rsi), %edx
addq $0x28, %rsi
jmp 0xcc27
movq 0x10(%r15), %rsi
movl 0x60(%rsi), %edx
addq $0x36, %rsi
jmp 0xcc27
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 0x9760
callq 0x1060
// File: /workspace/github_c_makefile_star2_O2/MikeGray-APH[P]LibLouisAPH/source/languages/generic-forward.c
// Function: is_indicator_delimiter
static int is_indicator_delimiter(const struct table *table, const unichar uchar)
{
	if(uchar == table->marker_user)
		return 1;
	if(uchar == table->marker_begin)
		return 1;
	if(uchar == table->marker_end)
		return 1;
	if(uchar == table->marker_hard)
		return 1;
	if(uchar == table->marker_soft)
		return 1;
	return 0;
}

// Assembly:
pushq $0x1
popq %rax
cmpw %si, 0x1e8(%rdi)
je 0xcc90
cmpw %si, 0x1ea(%rdi)
je 0xcc90
cmpw %si, 0x1ec(%rdi)
je 0xcc90
cmpw %si, 0x1f0(%rdi)
je 0xcc90
xorl %eax, %eax
cmpw %si, 0x1f2(%rdi)
sete %al
retq
// File: /workspace/github_c_makefile_star2_O2/MikeGray-APH[P]LibLouisAPH/source/languages/generic-forward.c
// Function: get_word_capital_whole
static int get_word_capital_whole(unsigned char *words, const int word_start, const struct translate *translate)
{
	int i;

	for(i = word_start; i < translate->input_len; i++)
	{
		if(!(words[i] & WORD_CHAR))
			break;
		if(words[i] & WORD_WHOLE)
			return i;
	}
	return -1;
}

// Assembly:
movslq 0x44(%rdx), %rdx
movslq %esi, %rcx
pushq $-0x1
popq %rax
cmpq %rdx, %rcx
jge 0xccb7
movzbl (%rdi,%rcx), %esi
testb $0x1, %sil
je 0xccb7
testb $0x2, %sil
jne 0xccb5
incq %rcx
jmp 0xcc9b
movl %ecx, %eax
retq
// File: /workspace/github_c_makefile_star2_O2/MikeGray-APH[P]LibLouisAPH/source/languages/generic.h
// Function: generic_digit_to_uchar
static inline unichar generic_digit_to_uchar(const struct table *table, const unichar digit)
{
	struct character *character;

	character = table_find_character(table, digit);
	if(!character)
		return digit;
	if(!(character->attrs & CHAR_NUMERIC_DIGIT))
		return digit;

	return character->joins[1]->uchar;
}

// Assembly:
pushq %rbx
movl %esi, %ebx
callq 0x1e48
testq %rax, %rax
je 0xcd4f
testb $0x8, 0x25(%rax)
je 0xcd4f
movq 0x10(%rax), %rax
movzwl 0x20(%rax), %ebx
movl %ebx, %eax
popq %rbx
retq
nop
// File: /workspace/github_c_makefile_star2_O2/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 0xece0
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 0x16db
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_O2/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 0xed02
movl %esi, %eax
movabsq $0x100002600, %rcx      # imm = 0x100002600
btq %rax, %rcx
jb 0xed0a
cmpl $0xa0, %esi
jne 0xed29
leaq 0x3486(%rip), %rdi      # 0x12197
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)
andw $0x0, 0x2(%rdx)
leaq 0x10(%rsp), %r14
pushq $0x10
popq %rsi
pushq $0x2
popq %rcx
movq %r14, %rdi
xorl %r8d, %r8d
callq 0x16db
movq %r14, %rdi
jmp 0xed11
// File: /workspace/github_c_makefile_star2_O2/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 $0x9, %esi
je 0xedc3
cmpl $0xa, %esi
je 0xed80
cmpl $0xd, %esi
je 0xed92
cmpl $0x20, %esi
je 0xed89
cmpl $0xa0, %esi
jne 0xed9b
leaq 0x2ff6(%rip), %rdi      # 0x11d74
jmp 0xedca
leaq 0x2ff3(%rip), %rdi      # 0x11d7a
jmp 0xedca
leaq 0x2fe7(%rip), %rdi      # 0x11d77
jmp 0xedca
leaq 0x2fe4(%rip), %rdi      # 0x11d7d
jmp 0xedca
leaq 0xc(%rsp), %rdx
movw %si, (%rdx)
andw $0x0, 0x2(%rdx)
leaq 0x10(%rsp), %r14
pushq $0x10
popq %rsi
pushq $0x2
popq %rcx
movq %r14, %rdi
xorl %r8d, %r8d
callq 0x16db
movq %r14, %rdi
jmp 0xedca
leaq 0x2fb6(%rip), %rdi      # 0x11d80
movq %rbx, %rsi
callq 0x1100
movq %rbx, %rdi
callq 0x11a0
addq $0x28, %rsp
popq %rbx
popq %r14
retq
nop
// File: /workspace/github_c_makefile_star2_O2/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 0x2ff2(%rip), %rdi      # 0x11de4
xorl %eax, %eax
callq 0x10c0
movzwl 0x2(%rbx), %esi
leaq 0x2fef(%rip), %rdi      # 0x11df3
xorl %eax, %eax
callq 0x10c0
movzwl (%rbx), %eax
testl %eax, %eax
je 0xee24
cmpl $0xffff, %eax           # imm = 0xFFFF
je 0xee24
pushq $0x2
popq %rsi
movq %rbx, %rdi
callq 0xee34
movq 0x81ad(%rip), %rax      # 0x16fd8
movq (%rax), %rdi
popq %rbx
jmp 0x11a0
// File: /workspace/github_c_makefile_star2_O2/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 0xf5e8
movq %rdx, %r15
movq %rdx, %rdi
callq 0x10b0
cmpl $0x20, %eax
pushq $0x20
popq %rcx
cmovll %eax, %ecx
xorl %eax, %eax
testl %ecx, %ecx
cmovlel %eax, %ecx
leaq 0x7b8a(%rip), %rdx      # 0x17160
cmpq %rax, %rcx
je 0xf5e8
movb (%r15,%rax), %sil
movb %sil, (%rax,%rdx)
incq %rax
jmp 0xf5d6
movzwl (%r14), %eax
testl %eax, %eax
je 0xf605
cmpl $0xffff, %eax           # imm = 0xFFFF
je 0xf605
pushq $0x2
popq %rdx
movq %rbx, %rdi
movq %r14, %rsi
callq 0xf25d
movq %rbx, %rdi
popq %rbx
popq %r14
popq %r15
jmp 0x11a0
// File: /workspace/github_c_makefile_star2_O2/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 0xf756
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %rsi, %r14
movq %rdi, %rbx
movq 0x8(%rsi), %rdx
leaq 0x248c(%rip), %rsi      # 0x11ae8
xorl %r13d, %r13d
xorl %eax, %eax
callq 0x1160
leaq 0x28a1(%rip), %rdi      # 0x11f0e
movq %rbx, %rsi
callq 0x1100
movzwl 0x210(%r14), %esi
movq %rbx, %rdi
callq 0xed51
leaq 0x28f4(%rip), %r15      # 0x11f80
movq %r15, %rdi
movq %rbx, %rsi
callq 0x1100
movq %r15, %rdi
movq %rbx, %rsi
callq 0x1100
addq $0x10, %r14
movw $0x2800, %ax            # imm = 0x2800
leaq 0x2ae6(%rip), %r12      # 0x12197
cmpq $0x10, %r13
je 0xf740
movq %r13, 0x10(%rsp)
movl %eax, 0xc(%rsp)
movzwl %ax, %r13d
xorl %r15d, %r15d
cmpq $0x10, %r15
je 0xf718
leaq (%r15,%r13), %rbp
movzwl (%r14,%r15,2), %eax
cmpw %ax, %bp
jne 0xf6ec
movq %r12, %rdi
movq %rbx, %rsi
callq 0x1100
jmp 0xf6f7
movzwl %ax, %esi
movq %rbx, %rdi
callq 0xece1
movzwl %bp, %esi
movq %rbx, %rdi
callq 0xece1
cmpq $0xf, %r15
je 0xf713
movq %r12, %rdi
movq %rbx, %rsi
callq 0x1100
incq %r15
jmp 0xf6cb
leaq 0x2861(%rip), %rdi      # 0x11f80
movq %rbx, %rsi
callq 0x1100
movq 0x10(%rsp), %r13
incq %r13
addq $0x20, %r14
addl 0xc(%rsp), %r15d
movl %r15d, %eax
jmp 0xf6b1
movq %rbx, %rdi
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x11a0
retq
nop
// File: /workspace/github_c_makefile_star2_O2/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 0xfff2
pushq %r15
pushq %r14
pushq %rbx
movq %rsi, %r14
movq %rdi, %rbx
movq (%rsi), %rsi
callq 0xff76
leaq 0x2200(%rip), %r15      # 0x12195
movq %r15, %rdi
movq %rbx, %rsi
callq 0x1100
movq 0x8(%r14), %rsi
movl 0x20(%r14), %edx
movq %rbx, %rdi
callq 0xec74
movq %r15, %rdi
movq %rbx, %rsi
callq 0x1100
movq 0x18(%r14), %rsi
movl 0x28(%r14), %edx
movq %rbx, %rdi
callq 0xec74
movl 0x28(%r14), %eax
xorl %ecx, %ecx
cmpl %eax, %ecx
jge 0x10015
movq 0x18(%r14), %rdx
movslq %ecx, %rsi
movzwl (%rdx,%rsi,2), %edx
cmpl $0x5c, %edx
je 0xffec
cmpl $0x40, %edx
jne 0xffee
jmp 0xfff3
incl %ecx
incl %ecx
jmp 0xffd1
retq
leaq 0x219b(%rip), %rdi      # 0x12195
movq %rbx, %rsi
callq 0x1100
movq 0x10(%r14), %rsi
leaq 0x92a3(%rip), %rdx      # 0x192b0
movq %rbx, %rdi
callq 0xf5a4
leaq 0x1f64(%rip), %rdi      # 0x11f80
movq %rbx, %rsi
popq %rbx
popq %r14
popq %r15
jmp 0x1100
// File: /workspace/github_c_makefile_star2_O2/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 0x10066
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %r14
movq %rdi, %rbx
movq (%rsi), %rsi
callq 0x10029
leaq 0x214e(%rip), %rdi      # 0x12195
movq %rbx, %rsi
callq 0x1100
movq 0x20(%r14), %rsi
testq %rsi, %rsi
je 0x10067
movl 0x28(%r14), %edx
movq %rbx, %rdi
callq 0xec74
jmp 0x10076
retq
leaq 0x2117(%rip), %rdi      # 0x12185
movq %rbx, %rsi
callq 0x1100
leaq 0x2118(%rip), %rdi      # 0x12195
movq %rbx, %rsi
callq 0x1100
movq 0x8(%r14), %rsi
testq %rsi, %rsi
je 0x1009c
movl 0x18(%r14), %edx
movq %rbx, %rdi
callq 0x103ec
jmp 0x100ab
leaq 0x20e5(%rip), %rdi      # 0x12188
movq %rbx, %rsi
callq 0x1100
leaq 0x20e3(%rip), %rdi      # 0x12195
movq %rbx, %rsi
callq 0x1100
movq 0x10(%r14), %rsi
testq %rsi, %rsi
je 0x100d4
leaq 0x91e6(%rip), %rdx      # 0x192b0
movq %rbx, %rdi
callq 0xf5a4
jmp 0x100e3
leaq 0x20ad(%rip), %rdi      # 0x12188
movq %rbx, %rsi
callq 0x1100
leaq 0x1e96(%rip), %rdi      # 0x11f80
movq %rbx, %rsi
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x1100
// File: /workspace/github_c_makefile_star2_O2/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 0x7904
leaq 0x8e88(%rip), %rdx      # 0x192b0
movq %r14, %rdi
movq %r12, %rsi
callq 0xf5a4
movq %r12, %rdi
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
jmp 0x1040
nop
// File: /workspace/github_c_makefile_star2_O2/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 0x104c6
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 0x16db
movq %r15, %rdi
movl %eax, %esi
callq 0x104e9
leaq 0x1632(%rip), %rdi      # 0x11ad2
movq %r15, %rsi
xorl %eax, %eax
callq 0x10c0
movq 0x6b27(%rip), %rax      # 0x16fd8
movq (%rax), %rdi
callq 0x11a0
addq $0x4000, %rsp           # imm = 0x4000
popq %rbx
popq %r14
popq %r15
retq
pushq $0xa
popq %rdi
callq 0x1050
movq 0x6b03(%rip), %rax      # 0x16fd8
movq (%rax), %rdi
addq $0x4000, %rsp           # imm = 0x4000
popq %rbx
popq %r14
popq %r15
jmp 0x11a0
// File: /workspace/github_c_makefile_star2_O2/MikeGray-APH[P]LibLouisAPH/debug/debug.c
// Function: cchars_convert_spaces
static inline void cchars_convert_spaces(char *cchars, const int cchars_len)
{
	int i;

	for(i = 0; i < cchars_len; i++)
	if(!cchars[i])
		return;
	else switch(cchars[i])
	{
	case '\n':
	case '\r':
	case '\t':  cchars[i] = ' ';
	}
}

// Assembly:
xorl %eax, %eax
testl %esi, %esi
cmovlel %eax, %esi
cmpq %rax, %rsi
je 0x10515
movzbl (%rdi,%rax), %ecx
leal -0x9(%rcx), %edx
cmpl $0x2, %edx
jb 0x1050c
cmpl $0xd, %ecx
je 0x1050c
testl %ecx, %ecx
jne 0x10510
jmp 0x10515
movb $0x20, (%rdi,%rax)
incq %rax
jmp 0x104f0
retq
// File: /workspace/github_c_makefile_star2_O2/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 0x6aa8(%rip), %r12      # 0x16fd8
movq (%r12), %rdi
callq 0x10d0
testl %ebx, %ebx
setg %al
testq %r14, %r14
setne %cl
testb %al, %cl
je 0x10599
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 0x16db
movq %r15, %rdi
movl %eax, %esi
callq 0x104e9
movq %r15, %rdi
callq 0x1090
movq (%r12), %rdi
callq 0x11a0
addq $0x4008, %rsp           # imm = 0x4008
popq %rbx
popq %r12
popq %r14
popq %r15
retq
pushq $0xa
popq %rdi
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_O2/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 %rbp
pushq %r15
pushq %r14
pushq %rbx
subq $0x4008, %rsp           # imm = 0x4008
testl %esi, %esi
setg %al
testq %rdi, %rdi
setne %cl
testb %al, %cl
je 0x1065b
movl %esi, %ebx
movq %rdi, %r15
movq %rsp, %r14
movl $0x4000, %edx           # imm = 0x4000
movq %r14, %rdi
xorl %esi, %esi
callq 0x1110
movq %r14, %rdi
movl $0x4000, %esi           # imm = 0x4000
movq %r15, %rdx
movl %ebx, %ecx
xorl %r8d, %r8d
callq 0x16db
movq %r14, %rdi
movl %eax, %esi
callq 0x104e9
leaq 0x14bd(%rip), %rdi      # 0x11ad2
movq %r14, %rsi
xorl %eax, %eax
callq 0x10c0
movq %r14, %rdi
callq 0x10b0
movq %rax, %r14
pushq $0x20
popq %rbp
cmpl %ebx, %r14d
jge 0x1063e
movl %ebp, %edi
callq 0x1050
incl %r14d
jmp 0x1062d
movq 0x6993(%rip), %rax      # 0x16fd8
movq (%rax), %rdi
callq 0x11a0
addq $0x4008, %rsp           # imm = 0x4008
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
pushq $0xa
popq %rdi
callq 0x1050
movq 0x696e(%rip), %rax      # 0x16fd8
movq (%rax), %rdi
addq $0x4008, %rsp           # imm = 0x4008
popq %rbx
popq %r14
popq %r15
popq %rbp
jmp 0x11a0
// File: /workspace/github_c_makefile_star2_O2/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 0x10728
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 0x16db
movq %rbx, %rdi
movl %eax, %esi
callq 0x104e9
leaq -0x2(%rsp), %rax
cmpb $0x0, 0x2(%rax)
leaq 0x1(%rax), %rax
jne 0x106d8
jmp 0x106f7
movzbl (%rax), %ecx
cmpl $0xd, %ecx
je 0x106f1
cmpl $0xa, %ecx
jne 0x106fc
movb $0x0, (%rax)
decq %rax
cmpq %rbx, %rax
jae 0x106e4
leaq 0x13cf(%rip), %rdi      # 0x11ad2
movq %rsp, %rsi
xorl %eax, %eax
callq 0x10c0
movq 0x68c4(%rip), %rax      # 0x16fd8
movq (%rax), %rdi
callq 0x11a0
addq $0x4000, %rsp           # imm = 0x4000
popq %rbx
popq %r14
popq %rbp
retq
pushq $0xa
popq %rdi
callq 0x1050
movq 0x68a1(%rip), %rax      # 0x16fd8
movq (%rax), %rdi
addq $0x4000, %rsp           # imm = 0x4000
popq %rbx
popq %r14
popq %rbp
jmp 0x11a0
// File: /workspace/github_c_makefile_star2_O2/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 0x10766
movl %edi, %eax
movabsq $0x100002600, %rcx      # imm = 0x100002600
btq %rax, %rcx
jb 0x1076e
cmpl $0xa0, %edi
jne 0x1078b
pushq $0x20
popq %rdi
callq 0x1050
movq 0x685b(%rip), %rax      # 0x16fd8
movq (%rax), %rdi
callq 0x11a0
addq $0x20, %rsp
popq %rbx
retq
leaq 0xc(%rsp), %rdx
movw %di, (%rdx)
andw $0x0, 0x2(%rdx)
leaq 0x10(%rsp), %rbx
pushq $0x10
popq %rsi
pushq $0x2
popq %rcx
movq %rbx, %rdi
xorl %r8d, %r8d
callq 0x16db
leaq 0x131d(%rip), %rdi      # 0x11ad2
movq %rbx, %rsi
xorl %eax, %eax
callq 0x10c0
jmp 0x10776
// File: /workspace/github_c_makefile_star2_O2/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 $0x9, %edi
je 0x1083c
cmpl $0xa, %edi
je 0x107eb
cmpl $0xd, %edi
je 0x107fd
cmpl $0x20, %edi
je 0x107f4
cmpl $0xa0, %edi
jne 0x10806
leaq 0x158b(%rip), %rdi      # 0x11d74
jmp 0x10843
leaq 0x1588(%rip), %rdi      # 0x11d7a
jmp 0x10843
leaq 0x157c(%rip), %rdi      # 0x11d77
jmp 0x10843
leaq 0x1579(%rip), %rdi      # 0x11d7d
jmp 0x10843
leaq 0xc(%rsp), %rdx
movw %di, (%rdx)
andw $0x0, 0x2(%rdx)
leaq 0x10(%rsp), %rbx
pushq $0x10
popq %rsi
pushq $0x2
popq %rcx
movq %rbx, %rdi
xorl %r8d, %r8d
callq 0x16db
leaq 0x12a2(%rip), %rdi      # 0x11ad2
movq %rbx, %rsi
xorl %eax, %eax
callq 0x10c0
jmp 0x1084a
leaq 0x153d(%rip), %rdi      # 0x11d80
xorl %eax, %eax
callq 0x10c0
movq 0x6787(%rip), %rax      # 0x16fd8
movq (%rax), %rdi
callq 0x11a0
addq $0x20, %rsp
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O2/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 0x10878
leaq 0x193b(%rip), %rsi      # 0x121a9
pushq $0x6
popq %rdi
xorl %eax, %eax
jmp 0x9174
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x8000, %rsp           # imm = 0x8000
movl %edx, %ebx
movq %rsi, %r15
movq %rdi, %r14
movq %rsp, %r12
xorl %r13d, %r13d
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 0x10943
testl %ebx, %ebx
movl $0x0, %eax
cmovgl %ebx, %eax
cmpq %r13, %rax
je 0x1097b
movzwl (%rsp,%r13,2), %ecx
movw $0x27d8, %dx            # imm = 0x27D8
cmpw 0x1e8(%r14), %cx
je 0x10939
movw $0x27ea, %dx            # imm = 0x27EA
cmpw 0x1ea(%r14), %cx
je 0x10939
movw $0x27eb, %dx            # imm = 0x27EB
cmpw 0x1ec(%r14), %cx
je 0x10939
movw $0x2605, %dx            # imm = 0x2605
cmpw 0x1ee(%r14), %cx
je 0x10939
movw $0x27e0, %dx            # imm = 0x27E0
cmpw 0x1f0(%r14), %cx
je 0x10939
movw $0x27ca, %dx            # imm = 0x27CA
cmpw 0x1f2(%r14), %cx
je 0x10939
movw $0x2623, %dx            # imm = 0x2623
cmpw 0x1f4(%r14), %cx
jne 0x1093e
movw %dx, (%rsp,%r13,2)
incq %r13
jmp 0x108c9
testl %ebx, %ebx
movl $0x0, %eax
cmovgl %ebx, %eax
leaq 0x185e(%rip), %rcx      # 0x121b2
cmpq %r13, %rax
je 0x1097b
movzwl (%rsp,%r13,2), %edx
addl $0xfff, %edx            # imm = 0xFFF
cmpw $0x6, %dx
ja 0x10976
movzwl %dx, %edx
movzwl (%rcx,%rdx,2), %edx
movw %dx, (%rsp,%r13,2)
incq %r13
jmp 0x10954
movq 0x6656(%rip), %rax      # 0x16fd8
movq (%rax), %rdi
movq %rsp, %rsi
movl %ebx, %edx
callq 0xec74
addq $0x8000, %rsp           # imm = 0x8000
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O2/MikeGray-APH[P]LibLouisAPH/debug/main.c
// Function: main
static int test_input_tables(void)
{
	struct table **tables;
	struct conversion *conversion;
	int table_cnt, i;

	tables = NULL;
	conversion = NULL;

	MEM_INIT

	log_set_callback(log_callback);

	//unsetenv("LOUIS_TABLEPATH");
	//setenv("LOUIS_TABLEPATH", "tables", 0);
	//lookup_add_paths("test/tables:tables");

	//tables = lookup_tables(&table_cnt, "debug/table.rst");
	tables = lookup_tables(&table_cnt, "tables/english-ueb-grade2.rst");
	//tables = lookup_tables(&table_cnt, "tables/nemeth-ueb.rst");
	//tables = lookup_tables(&table_cnt, "tables/english-ueb-math.rst");
	//tables = lookup_tables(&table_cnt, "debug/table.rst~tables/english-ueb-grade2.rst");
	//tables = lookup_tables(&table_cnt, "tables/english-ueb-grade2.rst~debug/table.rst");
	if(!tables)
		return 1;
	//for(i = 0; i < table_cnt; i++){  table_output(stdout, tables[i]);  puts("");  }

	//conversion = lookup_conversion("tables/ascii.cvt");  if(!conversion) return 1;
	//conversion_output(stdout, conversion);  puts("");

	//TEST_INPUT("notransxxnotrans");
	//TEST_INPUT("3+3");
	TEST_INPUT("LibLouisAPH");

	FREE(tables);
	lookup_fini();
	MEM_FINI

	return 0;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x38, %rsp
leaq 0x15d(%rip), %rdi       # 0x10b6e
callq 0x916c
leaq 0x17a3(%rip), %rsi      # 0x121c0
leaq 0x34(%rsp), %rdi
callq 0x8c84
testq %rax, %rax
je 0x10b3e
movq %rax, %rbx
movl 0x34(%rsp), %ebp
pushq $0x1
popq %r15
pushq $0x18
popq %rsi
movq %r15, %rdi
callq 0x1150
movq %rax, %r14
movl $0x202, %esi            # imm = 0x202
movq %r15, %rdi
callq 0x1150
movq %rax, %r15
leaq 0x177e(%rip), %rdx      # 0x121de
pushq $0xc
popq %rsi
pushq $0xb
popq %rcx
movq %r14, %rdi
xorl %r8d, %r8d
callq 0x146a
movslq %ebp, %r12
movq -0x8(%rbx,%r12,8), %rdi
movq %r14, %rsi
movl %eax, %edx
callq 0x1f67
movq %r14, %rdi
movl %eax, %esi
callq 0x132c
movl %eax, %ebp
xorps %xmm0, %xmm0
movups %xmm0, 0x10(%rsp)
andq $0x0, 0x20(%rsp)
andq $0x0, (%rsp)
movl $0x1, 0x8(%rsp)
movq %r15, %rdi
movl $0x100, %esi            # imm = 0x100
movq %r14, %rdx
movl %eax, %ecx
movq %rbx, %r8
movl %r12d, %r9d
callq 0x6e3c
cmpl $-0x1, %eax
je 0x10b50
movl %eax, %r13d
movq -0x8(%rbx,%r12,8), %rdi
movq %r14, %rsi
movl %ebp, %edx
callq 0x10ba8
movq %r14, %rdi
movl %ebp, %esi
callq 0x1067f
pushq $0xa
popq %rbp
movl %ebp, %edi
callq 0x1050
movq -0x8(%rbx,%r12,8), %rdi
movq %r15, %rsi
movl $0x100, %edx            # imm = 0x100
callq 0x10ba8
movq %r15, %rdi
movl %r13d, %esi
callq 0x1067f
movl %ebp, %edi
callq 0x1050
movq %r14, %rdi
callq 0x1040
movq %r15, %rdi
callq 0x1040
pushq $0xa
popq %rdi
callq 0x1050
movq %rbx, %rdi
callq 0x1040
callq 0x87d3
xorl %eax, %eax
jmp 0x10b41
pushq $0x1
popq %rax
addq $0x38, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq 0x64a1(%rip), %rax      # 0x16ff8
movq (%rax), %rcx
leaq 0x16c7(%rip), %rdi      # 0x12228
pushq $0x5
popq %rsi
pushq $0x1
popq %rdx
callq 0x11e0
jmp 0x10b25
// File: /workspace/github_c_makefile_star2_O2/MikeGray-APH[P]LibLouisAPH/source/outputs/table-output.h
// Function: table_convert_markers
static inline void table_convert_markers(const struct table *table, unichar *uchars, const int uchars_len)
{
	int i;

	if(table)
	{
		for(i = 0; i < uchars_len; i++)
		     if(uchars[i] == table->marker_user)
			uchars[i] = u'⟘';
		else if(uchars[i] == table->marker_begin)
			uchars[i] = u'⟪';
		else if(uchars[i] == table->marker_end)
			uchars[i] = u'⟫';
		else if(uchars[i] == table->marker_modifier)
			uchars[i] = u'★';
		else if(uchars[i] == table->marker_hard)
			uchars[i] = u'⟠';
		else if(uchars[i] == table->marker_soft)
			uchars[i] = u'⟊';
		else if(uchars[i] == table->marker_internal)
			uchars[i] = u'☣';
	}
	else for(i = 0; i < uchars_len; i++)
	switch(uchars[i])
	{
	case TABLE_MARKER_USER:      uchars[i] = u'⟘';  break;
	case TABLE_MARKER_BEGIN:     uchars[i] = u'⟪';  break;
	case TABLE_MARKER_END:       uchars[i] = u'⟫';  break;
	case TABLE_MARKER_MODIFIER:  uchars[i] = u'★';  break;
	case TABLE_MARKER_HARD:      uchars[i] = u'⟠';  break;
	case TABLE_MARKER_SOFT:      uchars[i] = u'⟊';  break;
	case TABLE_MARKER_INTERNAL:  uchars[i] = u'☣';  break;
	//case :                     uchars[i] = u'⟨';  break;
	//case :                     uchars[i] = u'⟩';  break;
	//case :                     uchars[i] = u'☓';  break;
	}
}

// Assembly:
xorl %eax, %eax
testq %rdi, %rdi
je 0x10c2d
testl %edx, %edx
cmovlel %eax, %edx
cmpq %rax, %rdx
je 0x10c5e
movzwl (%rsi,%rax,2), %ecx
movw $0x27d8, %r8w           # imm = 0x27D8
cmpw 0x1e8(%rdi), %cx
je 0x10c23
movw $0x27ea, %r8w           # imm = 0x27EA
cmpw 0x1ea(%rdi), %cx
je 0x10c23
movw $0x27eb, %r8w           # imm = 0x27EB
cmpw 0x1ec(%rdi), %cx
je 0x10c23
movw $0x2605, %r8w           # imm = 0x2605
cmpw 0x1ee(%rdi), %cx
je 0x10c23
movw $0x27e0, %r8w           # imm = 0x27E0
cmpw 0x1f0(%rdi), %cx
je 0x10c23
movw $0x27ca, %r8w           # imm = 0x27CA
cmpw 0x1f2(%rdi), %cx
je 0x10c23
movw $0x2623, %r8w           # imm = 0x2623
cmpw 0x1f4(%rdi), %cx
jne 0x10c28
movw %r8w, (%rsi,%rax,2)
incq %rax
jmp 0x10bb4
testl %edx, %edx
cmovlel %eax, %edx
leaq 0x1613(%rip), %rcx      # 0x1224c
cmpq %rax, %rdx
je 0x10c5e
movzwl (%rsi,%rax,2), %edi
addl $0xfff, %edi            # imm = 0xFFF
cmpw $0x6, %di
ja 0x10c59
movzwl %di, %edi
movzwl (%rcx,%rdi,2), %edi
movw %di, (%rsi,%rax,2)
incq %rax
jmp 0x10c39
retq
// File: /workspace/github_c_makefile_star2_O2/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 0x11ed
je 0x120b
addq %r15, %r12
jmp 0x11f7
callq 0x1040
cmpl $0x4, (%rax)
jne 0x122b
cmpq %rbx, %r12
jb 0x11cd
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
movq 0x3de6(%rip), %rax      # 0x4ff8
movq (%rax), %rcx
leaq 0x2032(%rip), %rdi      # 0x324e
pushq $0x1a
popq %rsi
pushq $0x1
popq %rdx
callq 0x10b0
xorl %ebx, %ebx
jmp 0x11fc
movq 0x3dc6(%rip), %rax      # 0x4ff8
movq (%rax), %rdi
leaq 0x1ff8(%rip), %rsi      # 0x3234
xorl %eax, %eax
callq 0x1070
movq %r15, %rbx
jmp 0x11fc
// File: /workspace/github_c_makefile_star2_O2/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 %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movq %rsi, %rbx
movq %rdi, %r14
xorl %r12d, %r12d
pushq $0x1
popq %rbp
leaq (%r14,%r12), %rsi
movq %rbx, %rdx
subq %r12, %rdx
movl %ebp, %edi
callq 0x1050
movq %rax, %r15
testq %rax, %rax
js 0x127a
addq %r15, %r12
jmp 0x1284
callq 0x1040
cmpl $0x4, (%rax)
jne 0x1295
cmpq %rbx, %r12
jb 0x125c
movq %rbx, %rax
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
movq 0x3d5c(%rip), %rax      # 0x4ff8
movq (%rax), %rdi
leaq 0x1fc3(%rip), %rsi      # 0x3269
xorl %eax, %eax
callq 0x1070
movq %r15, %rbx
jmp 0x1289
// File: /workspace/github_c_makefile_star2_O2/videolan[P]bitstream/examples/dvb_ecmg.c
// Function: send_channel_error
static void send_channel_error(uint16_t i_wanted_channelid, uint16_t i_error)
{
    uint8_t p_tlv_h[MAX_TLV_SIZE];
    uint8_t *p_tlv = tlvh_get_tlv(p_tlv_h);
    uint8_t *p_tlv_n;

    fprintf(stderr, "sending error on channel ID=0x%hx error=0x%hx\n",
            i_wanted_channelid, i_error);

    tlvh_set_version(p_tlv_h, i_version);
    ecmg_init(p_tlv);
    tlv_set_type(p_tlv, ECMG_TYPE_CHANNEL_ERROR);
    /* length will be written at the end */
    tlv_set_length(p_tlv, MAX_TLV_SIZE - TLV_HEADER_SIZE - TLVH_HEADER_SIZE);

    ecmg_append_channelid(p_tlv, i_wanted_channelid);
    ecmg_append_errorstatus(p_tlv, i_error);

    p_tlv_n = tlv_find_param(p_tlv, TLV_PARAM_EMPTY, 0);
    tlv_set_length(p_tlv, p_tlv_n - p_tlv - TLV_HEADER_SIZE);
    write_wrapper(p_tlv_h, p_tlv_n - p_tlv_h);
}

// Assembly:
pushq %rbp
pushq %r14
pushq %rbx
subq $0x400, %rsp            # imm = 0x400
movl %esi, %ebp
movl %edi, %r14d
leaq 0x1(%rsp), %rbx
movq 0x3215(%rip), %rax      # 0x4ff8
movq (%rax), %rdi
leaq 0x14dd(%rip), %rsi      # 0x32ca
movl %r14d, %edx
movl %ebp, %ecx
xorl %eax, %eax
callq 0x1070
movb 0x3271(%rip), %al       # 0x5070
movb %al, -0x1(%rbx)
andw $0x0, 0x4(%rbx)
movl $0xf7030500, (%rbx)     # imm = 0xF7030500
movq %rbx, %rdi
movl %r14d, %esi
callq 0x1e57
movq %rbx, %rdi
movl %ebp, %esi
callq 0x1f2b
movq %rbx, %rdi
xorl %esi, %esi
xorl %edx, %edx
callq 0x1e9c
movl %eax, %ecx
subl %ebx, %ecx
addl $-0x4, %ecx
rolw $0x8, %cx
movw %cx, 0x2(%rbx)
movq %rsp, %rdi
subq %rdi, %rax
movq %rax, %rsi
callq 0x1248
addq $0x400, %rsp            # imm = 0x400
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/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:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movl %esi, %ebx
movq %rdi, %r14
testl %edx, %edx
sete %r15b
xorl %ebp, %ebp
movzbl %bpl, %esi
movq %r14, %rdi
callq 0x1ee4
testq %rax, %rax
je 0x1ed9
incb %bpl
movzwl (%rax), %ecx
rolw $0x8, %cx
cmpw %bx, %cx
jne 0x1eb0
testb $0x1, %r15b
movb $0x1, %r15b
je 0x1eb0
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/videolan[P]bitstream/examples/./bitstream/dvb/sim.h
// Function: tlv_get_param
static inline uint8_t *tlv_get_param(uint8_t *p_tlv, uint16_t n)
{
    uint16_t i_tlv_size = tlv_get_length(p_tlv);
    uint8_t *p_tlv_n = p_tlv + TLV_HEADER_SIZE;
    if (p_tlv_n - p_tlv - TLV_HEADER_SIZE > i_tlv_size) return NULL;

    while (n) {
        if (p_tlv_n - p_tlv > i_tlv_size)
            return NULL;
        p_tlv_n += TLV_HEADER_SIZE + tlv_get_length(p_tlv_n);
        n--;
    }
    if (p_tlv_n - p_tlv - TLV_HEADER_SIZE >= i_tlv_size) return NULL;
    return p_tlv_n;
}

// Assembly:
movzwl 0x2(%rdi), %eax
rolw $0x8, %ax
movzwl %ax, %edx
leaq 0x4(%rdi), %rcx
xorl %eax, %eax
movq %rcx, %r8
subq %rdi, %r8
subw $0x1, %si
jb 0x1f1d
cmpq %rdx, %r8
jg 0x1f2a
movzwl 0x2(%rcx), %r8d
rolw $0x8, %r8w
movzwl %r8w, %r8d
addq %r8, %rcx
addq $0x4, %rcx
jmp 0x1ef5
addq $-0x4, %r8
xorl %eax, %eax
cmpq %rdx, %r8
cmovlq %rcx, %rax
retq
// File: /workspace/github_c_makefile_star2_O2/videolan[P]bitstream/examples/./bitstream/dvb/sim.h
// Function: tlv_count_param
static inline uint16_t tlv_count_param(uint8_t *p_tlv, uint16_t i_type)
{
    uint16_t i_count = 0;
    uint8_t *p_tlv_n;
    uint16_t j = 0;

    while ((p_tlv_n = tlv_get_param(p_tlv, j)) != NULL) {
        j++;
        if (tlv_get_type(p_tlv_n) == i_type)
            i_count++;
    }
    return i_count;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movl %esi, %ebx
movq %rdi, %r14
xorl %ebp, %ebp
xorl %r15d, %r15d
movzwl %r15w, %esi
movq %r14, %rdi
callq 0x1ee4
testq %rax, %rax
je 0x1fa8
incl %r15d
movzwl (%rax), %eax
rolw $0x8, %ax
xorl %ecx, %ecx
cmpw %bx, %ax
sete %cl
addl %ecx, %ebp
jmp 0x1f81
movl %ebp, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/videolan[P]bitstream/examples/dvb_ecmg.c
// Function: send_stream_error
static void send_stream_error(uint16_t i_wanted_streamid, uint16_t i_error)
{
    uint8_t p_tlv_h[MAX_TLV_SIZE];
    uint8_t *p_tlv = tlvh_get_tlv(p_tlv_h);
    uint8_t *p_tlv_n;

    fprintf(stderr, "sending error on stream ID=0x%hx error=0x%hx\n",
            i_wanted_streamid, i_error);

    tlvh_set_version(p_tlv_h, i_version);
    ecmg_init(p_tlv);
    tlv_set_type(p_tlv, ECMG_TYPE_STREAM_ERROR);
    /* length will be written at the end */
    tlv_set_length(p_tlv, MAX_TLV_SIZE - TLV_HEADER_SIZE - TLVH_HEADER_SIZE);

    ecmg_append_channelid(p_tlv, i_channelid);
    ecmg_append_streamid(p_tlv, i_wanted_streamid);
    ecmg_append_errorstatus(p_tlv, i_error);

    p_tlv_n = tlv_find_param(p_tlv, TLV_PARAM_EMPTY, 0);
    tlv_set_length(p_tlv, p_tlv_n - p_tlv - TLV_HEADER_SIZE);
    write_wrapper(p_tlv_h, p_tlv_n - p_tlv_h);
}

// Assembly:
pushq %rbp
pushq %r14
pushq %rbx
subq $0x400, %rsp            # imm = 0x400
movl %esi, %ebp
movl %edi, %r14d
leaq 0x1(%rsp), %rbx
movq 0x2d77(%rip), %rax      # 0x4ff8
movq (%rax), %rdi
leaq 0x112c(%rip), %rsi      # 0x33b7
movl %r14d, %edx
movl %ebp, %ecx
xorl %eax, %eax
callq 0x1070
movb 0x2dd3(%rip), %al       # 0x5070
movb %al, -0x1(%rbx)
andw $0x0, 0x4(%rbx)
movl $0xf7030601, (%rbx)     # imm = 0xF7030601
movzwl 0x2dd0(%rip), %esi      # 0x5082
movq %rbx, %rdi
callq 0x1e57
movq %rbx, %rdi
movl %r14d, %esi
callq 0x23f7
movq %rbx, %rdi
movl %ebp, %esi
callq 0x1f2b
movq %rbx, %rdi
xorl %esi, %esi
xorl %edx, %edx
callq 0x1e9c
movl %eax, %ecx
subl %ebx, %ecx
addl $-0x4, %ecx
rolw $0x8, %cx
movw %cx, 0x2(%rbx)
movq %rsp, %rdi
subq %rdi, %rax
movq %rax, %rsi
callq 0x1248
addq $0x400, %rsp            # imm = 0x400
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/videolan[P]bitstream/examples/dvb_ecmg.c
// Function: send_stream_status
static void send_stream_status(stream_t *p_stream)
{
    uint8_t p_tlv_h[MAX_TLV_SIZE];
    uint8_t *p_tlv = tlvh_get_tlv(p_tlv_h);
    uint8_t *p_tlv_n;

    tlvh_set_version(p_tlv_h, i_version);
    ecmg_init(p_tlv);
    tlv_set_type(p_tlv, ECMG_TYPE_STREAM_STATUS);
    /* length will be written at the end */
    tlv_set_length(p_tlv, MAX_TLV_SIZE - TLV_HEADER_SIZE - TLVH_HEADER_SIZE);

    ecmg_append_channelid(p_tlv, i_channelid);
    ecmg_append_streamid(p_tlv, p_stream->i_streamid);
    if (i_version >= 2)
        ecmg_append_ecmid(p_tlv, p_stream->i_ecmid);
    ecmg_append_accesscritmode(p_tlv, true);

    p_tlv_n = tlv_find_param(p_tlv, TLV_PARAM_EMPTY, 0);
    tlv_set_length(p_tlv, p_tlv_n - p_tlv - TLV_HEADER_SIZE);
    write_wrapper(p_tlv_h, p_tlv_n - p_tlv_h);
}

// Assembly:
pushq %rbp
pushq %r14
pushq %rbx
subq $0x400, %rsp            # imm = 0x400
leaq 0x1(%rsp), %rbx
movb 0x2d55(%rip), %bpl      # 0x5070
movb %bpl, -0x1(%rbx)
andw $0x0, 0x4(%rbx)
movq %rdi, %r14
movl $0xf7030301, (%rbx)     # imm = 0xF7030301
movzwl 0x2d4e(%rip), %esi      # 0x5082
movq %rbx, %rdi
callq 0x1e57
movzwl (%r14), %esi
movq %rbx, %rdi
callq 0x23f7
cmpb $0x1, %bpl
jbe 0x238b
movq %rbx, %rdi
xorl %esi, %esi
xorl %edx, %edx
callq 0x1e9c
movzwl 0x3(%rsp), %ecx
rolw $0x8, %cx
movzwl %cx, %ecx
movq %rax, %rdx
subq %rbx, %rdx
addq $0x4, %rdx
cmpq %rcx, %rdx
jg 0x238b
movzwl 0x2(%r14), %ecx
movl $0x2001900, (%rax)      # imm = 0x2001900
movb %ch, 0x4(%rax)
movb %cl, 0x5(%rax)
andw $0x0, 0x6(%rax)
movq %rbx, %rdi
xorl %esi, %esi
xorl %edx, %edx
callq 0x1e9c
movzwl 0x3(%rsp), %ecx
rolw $0x8, %cx
movzwl %cx, %ecx
movq %rax, %rdx
subq %rbx, %rdx
addq $0x3, %rdx
cmpq %rcx, %rdx
jg 0x23c2
movl $0x1001100, (%rax)      # imm = 0x1001100
movw $0x1, 0x4(%rax)
movb $0x0, 0x6(%rax)
movq %rbx, %rdi
xorl %esi, %esi
xorl %edx, %edx
callq 0x1e9c
movl %eax, %ecx
subl %ebx, %ecx
addl $-0x4, %ecx
rolw $0x8, %cx
movq %rsp, %rdi
movw %cx, 0x3(%rdi)
subq %rdi, %rax
movq %rax, %rsi
callq 0x1248
addq $0x400, %rsp            # imm = 0x400
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/dubeyalok7[P]crypto-algo/des/feistal_algo/feistal.c
// Function: help
void help(){
  printf("Usage:\n");
  printf("./feistal -i <infile_name> -o <outfile_name> -<op>\n\
      -i      input file name\n\
      -o      output file name\noption (op): \n\
      -e      encrypt given file\n\
      -d      decrypt given file\n\n");
  printf("Note: Use ./feistal -g to generate 64 bits keys. ");
  printf("Keys should be 64 bits i.e. 8 characters.\n\n");
  return;
}

// Assembly:
pushq %rax
leaq 0xe3e(%rip), %rdi       # 0x2042
callq 0x1040
leaq 0xe39(%rip), %rdi       # 0x2049
callq 0x1040
leaq 0xde8(%rip), %rdi       # 0x2004
xorl %eax, %eax
callq 0x1080
leaq 0xee0(%rip), %rdi       # 0x210a
popq %rax
jmp 0x1040