LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O0/MikeGray-APH[P]LibLouisAPH/source/outputs/table-output.c
// Function: character_output
static void character_output(FILE *output, const struct character *character)
{
	int i;

	utf16_output_char_escape(output, character->uchar);
	fputs("\t", output);
	fprintf(output, "0x%04x   0x%08x", character->uchar, character->attrs);

	fputs("   ", output);
	for(i = 0; i < UNICHAR_JOIN_MAX; i++)
	{
		fputs("[", output);
		if(character->joins[i])
			utf16_output_char_escape(output, character->joins[i]->uchar);
		else
			fputs(" ", output);
		fputs("]", output);
	}

	fputs("\n", output);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rax
movzwl 0x20(%rax), %esi
callq 0x1a360
movq -0x8(%rbp), %rsi
leaq 0x296f(%rip), %rdi      # 0x1f11b
callq 0x10f0
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rax
movzwl 0x20(%rax), %edx
movq -0x10(%rbp), %rax
movl 0x24(%rax), %ecx
leaq 0x2bdb(%rip), %rsi      # 0x1f3a6
movb $0x0, %al
callq 0x1130
movq -0x8(%rbp), %rsi
leaq 0x2c08(%rip), %rdi      # 0x1f3e5
callq 0x10f0
movl $0x0, -0x14(%rbp)
cmpl $0x3, -0x14(%rbp)
jge 0x1c856
movq -0x8(%rbp), %rsi
leaq 0x2867(%rip), %rdi      # 0x1f061
callq 0x10f0
movq -0x10(%rbp), %rax
movslq -0x14(%rbp), %rcx
cmpq $0x0, 0x8(%rax,%rcx,8)
je 0x1c82b
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rax
movslq -0x14(%rbp), %rcx
movq 0x8(%rax,%rcx,8), %rax
movzwl 0x20(%rax), %esi
callq 0x1a360
jmp 0x1c83b
movq -0x8(%rbp), %rsi
leaq 0x2bb1(%rip), %rdi      # 0x1f3e7
callq 0x10f0
movq -0x8(%rbp), %rsi
leaq 0x2b74(%rip), %rdi      # 0x1f3ba
callq 0x10f0
movl -0x14(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x14(%rbp)
jmp 0x1c7e9
movq -0x8(%rbp), %rsi
leaq 0x296f(%rip), %rdi      # 0x1f1d0
callq 0x10f0
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/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 %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl %edx, -0x14(%rbp)
movslq -0x14(%rbp), %rdi
shlq %rdi
callq 0x1160
movq %rax, -0x20(%rbp)
movq -0x20(%rbp), %rdi
movq -0x10(%rbp), %rsi
movslq -0x14(%rbp), %rdx
shlq %rdx
callq 0x1150
movq -0x20(%rbp), %rdi
callq 0xca30
movq -0x8(%rbp), %rdi
movq -0x20(%rbp), %rsi
leaq 0x9961(%rip), %rdx      # 0x26280
callq 0x1b290
movq -0x20(%rbp), %rdi
callq 0x1040
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/MikeGray-APH[P]LibLouisAPH/source/outputs/table-output.c
// Function: output_dots_string
static void output_dots_string(FILE *output, const unichar *dots, const int dots_len)
{
	int i;

	for(i = 0; i < dots_len; i++)
	{
		if(!(dots[i] & 0xff))
			fputs("0", output);
		if(dots[i] & 0x01)
			fputs("1", output);
		if(dots[i] & 0x02)
			fputs("2", output);
		if(dots[i] & 0x04)
			fputs("3", output);
		if(dots[i] & 0x08)
			fputs("4", output);
		if(dots[i] & 0x10)
			fputs("5", output);
		if(dots[i] & 0x20)
			fputs("6", output);
		if(dots[i] & 0x40)
			fputs("7", output);
		if(dots[i] & 0x80)
			fputs("8", output);
		if(i < dots_len - 1)
			fputs("-", output);
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl %edx, -0x14(%rbp)
movl $0x0, -0x18(%rbp)
movl -0x18(%rbp), %eax
cmpl -0x14(%rbp), %eax
jge 0x1cadb
movq -0x10(%rbp), %rax
movslq -0x18(%rbp), %rcx
movzwl (%rax,%rcx,2), %eax
andl $0xff, %eax
cmpl $0x0, %eax
jne 0x1c98c
movq -0x8(%rbp), %rsi
leaq 0x2a72(%rip), %rdi      # 0x1f3f9
callq 0x10f0
movq -0x10(%rbp), %rax
movslq -0x18(%rbp), %rcx
movzwl (%rax,%rcx,2), %eax
andl $0x1, %eax
cmpl $0x0, %eax
je 0x1c9b0
movq -0x8(%rbp), %rsi
leaq 0x2a50(%rip), %rdi      # 0x1f3fb
callq 0x10f0
movq -0x10(%rbp), %rax
movslq -0x18(%rbp), %rcx
movzwl (%rax,%rcx,2), %eax
andl $0x2, %eax
cmpl $0x0, %eax
je 0x1c9d4
movq -0x8(%rbp), %rsi
leaq 0x2a2e(%rip), %rdi      # 0x1f3fd
callq 0x10f0
movq -0x10(%rbp), %rax
movslq -0x18(%rbp), %rcx
movzwl (%rax,%rcx,2), %eax
andl $0x4, %eax
cmpl $0x0, %eax
je 0x1c9f8
movq -0x8(%rbp), %rsi
leaq 0x2a0c(%rip), %rdi      # 0x1f3ff
callq 0x10f0
movq -0x10(%rbp), %rax
movslq -0x18(%rbp), %rcx
movzwl (%rax,%rcx,2), %eax
andl $0x8, %eax
cmpl $0x0, %eax
je 0x1ca1c
movq -0x8(%rbp), %rsi
leaq 0x29ea(%rip), %rdi      # 0x1f401
callq 0x10f0
movq -0x10(%rbp), %rax
movslq -0x18(%rbp), %rcx
movzwl (%rax,%rcx,2), %eax
andl $0x10, %eax
cmpl $0x0, %eax
je 0x1ca40
movq -0x8(%rbp), %rsi
leaq 0x29c8(%rip), %rdi      # 0x1f403
callq 0x10f0
movq -0x10(%rbp), %rax
movslq -0x18(%rbp), %rcx
movzwl (%rax,%rcx,2), %eax
andl $0x20, %eax
cmpl $0x0, %eax
je 0x1ca64
movq -0x8(%rbp), %rsi
leaq 0x29a6(%rip), %rdi      # 0x1f405
callq 0x10f0
movq -0x10(%rbp), %rax
movslq -0x18(%rbp), %rcx
movzwl (%rax,%rcx,2), %eax
andl $0x40, %eax
cmpl $0x0, %eax
je 0x1ca88
movq -0x8(%rbp), %rsi
leaq 0x2984(%rip), %rdi      # 0x1f407
callq 0x10f0
movq -0x10(%rbp), %rax
movslq -0x18(%rbp), %rcx
movzwl (%rax,%rcx,2), %eax
andl $0x80, %eax
cmpl $0x0, %eax
je 0x1caae
movq -0x8(%rbp), %rsi
leaq 0x2960(%rip), %rdi      # 0x1f409
callq 0x10f0
movl -0x18(%rbp), %eax
movl -0x14(%rbp), %ecx
subl $0x1, %ecx
cmpl %ecx, %eax
jge 0x1cacb
movq -0x8(%rbp), %rsi
leaq 0x2912(%rip), %rdi      # 0x1f3d8
callq 0x10f0
jmp 0x1cacd
movl -0x18(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x18(%rbp)
jmp 0x1c95a
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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 %rbp
movq %rsp, %rbp
subq $0x4020, %rsp           # imm = 0x4020
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
cmpl $0x0, -0xc(%rbp)
jle 0x1cb0f
cmpq $0x0, -0x8(%rbp)
jne 0x1cb2c
leaq 0x2606(%rip), %rdi      # 0x1f11c
callq 0x1080
movq 0x74b6(%rip), %rax      # 0x23fd8
movq (%rax), %rdi
callq 0x1170
jmp 0x1cb98
leaq -0x4010(%rbp), %rdi
xorl %esi, %esi
movl $0x4000, %edx           # imm = 0x4000
callq 0x1100
leaq -0x4010(%rbp), %rdi
movq -0x8(%rbp), %rdx
movl -0xc(%rbp), %ecx
movl $0x4000, %esi           # imm = 0x4000
xorl %eax, %eax
movl %eax, %r8d
callq 0x1ab0
movl %eax, -0x4014(%rbp)
leaq -0x4010(%rbp), %rdi
movl -0x4014(%rbp), %esi
callq 0x1cbb0
leaq -0x4010(%rbp), %rsi
leaq 0x20a2(%rip), %rdi      # 0x1ec24
movb $0x0, %al
callq 0x10b0
movq 0x7448(%rip), %rax      # 0x23fd8
movq (%rax), %rdi
callq 0x1170
addq $0x4020, %rsp           # imm = 0x4020
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movl $0x0, -0x10(%rbp)
movl -0x10(%rbp), %eax
cmpl -0xc(%rbp), %eax
jge 0x1cc18
movq -0x8(%rbp), %rax
movslq -0x10(%rbp), %rcx
cmpb $0x0, (%rax,%rcx)
jne 0x1cbda
jmp 0x1cc18
movq -0x8(%rbp), %rax
movslq -0x10(%rbp), %rcx
movsbl (%rax,%rcx), %eax
movl %eax, -0x14(%rbp)
addl $-0x9, %eax
subl $0x2, %eax
jb 0x1cbfd
jmp 0x1cbf3
movl -0x14(%rbp), %eax
subl $0xd, %eax
jne 0x1cc09
jmp 0x1cbfd
movq -0x8(%rbp), %rax
movslq -0x10(%rbp), %rcx
movb $0x20, (%rax,%rcx)
jmp 0x1cc0b
jmp 0x1cc0d
movl -0x10(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x10(%rbp)
jmp 0x1cbc2
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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 %rbp
movq %rsp, %rbp
subq $0x4020, %rsp           # imm = 0x4020
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movq 0x739f(%rip), %rax      # 0x23fd8
movq (%rax), %rdi
callq 0x10c0
cmpl $0x0, -0xc(%rbp)
jle 0x1cc4e
cmpq $0x0, -0x8(%rbp)
jne 0x1cc6b
leaq 0x24c7(%rip), %rdi      # 0x1f11c
callq 0x1080
movq 0x7377(%rip), %rax      # 0x23fd8
movq (%rax), %rdi
callq 0x1170
jmp 0x1ccd7
leaq -0x4010(%rbp), %rdi
xorl %esi, %esi
movl $0x4000, %edx           # imm = 0x4000
callq 0x1100
leaq -0x4010(%rbp), %rdi
movq -0x8(%rbp), %rdx
movl -0xc(%rbp), %ecx
movl $0x4000, %esi           # imm = 0x4000
xorl %eax, %eax
movl %eax, %r8d
callq 0x1ab0
movl %eax, -0x4014(%rbp)
leaq -0x4010(%rbp), %rdi
movl -0x4014(%rbp), %esi
callq 0x1cbb0
leaq -0x4010(%rbp), %rsi
leaq 0x1f79(%rip), %rdi      # 0x1ec3a
movb $0x0, %al
callq 0x10b0
movq 0x7309(%rip), %rax      # 0x23fd8
movq (%rax), %rdi
callq 0x1170
addq $0x4020, %rsp           # imm = 0x4020
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O0/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
movq %rsp, %rbp
subq $0x4020, %rsp           # imm = 0x4020
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
cmpl $0x0, -0xc(%rbp)
jle 0x1ccff
cmpq $0x0, -0x8(%rbp)
jne 0x1cd1f
leaq 0x2416(%rip), %rdi      # 0x1f11c
callq 0x1080
movq 0x72c6(%rip), %rax      # 0x23fd8
movq (%rax), %rdi
callq 0x1170
jmp 0x1cdc7
leaq -0x4010(%rbp), %rdi
xorl %esi, %esi
movl $0x4000, %edx           # imm = 0x4000
callq 0x1100
leaq -0x4010(%rbp), %rdi
movq -0x8(%rbp), %rdx
movl -0xc(%rbp), %ecx
movl $0x4000, %esi           # imm = 0x4000
xorl %eax, %eax
movl %eax, %r8d
callq 0x1ab0
movl %eax, -0x4014(%rbp)
leaq -0x4010(%rbp), %rdi
movl -0x4014(%rbp), %esi
callq 0x1cbb0
leaq -0x4010(%rbp), %rsi
leaq 0x1eaf(%rip), %rdi      # 0x1ec24
movb $0x0, %al
callq 0x10b0
leaq -0x4010(%rbp), %rdi
callq 0x10a0
movl %eax, -0x4018(%rbp)
movl -0x4018(%rbp), %eax
cmpl -0xc(%rbp), %eax
jge 0x1cdb8
leaq 0x2647(%rip), %rdi      # 0x1f3e7
movb $0x0, %al
callq 0x10b0
movl -0x4018(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x4018(%rbp)
jmp 0x1cd8e
movq 0x7219(%rip), %rax      # 0x23fd8
movq (%rax), %rdi
callq 0x1170
addq $0x4020, %rsp           # imm = 0x4020
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O0/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
movq %rsp, %rbp
subq $0x4020, %rsp           # imm = 0x4020
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
cmpl $0x0, -0xc(%rbp)
jle 0x1cdef
cmpq $0x0, -0x8(%rbp)
jne 0x1ce0f
leaq 0x2326(%rip), %rdi      # 0x1f11c
callq 0x1080
movq 0x71d6(%rip), %rax      # 0x23fd8
movq (%rax), %rdi
callq 0x1170
jmp 0x1cf37
leaq -0x4010(%rbp), %rdi
xorl %esi, %esi
movl $0x4000, %edx           # imm = 0x4000
callq 0x1100
leaq -0x4010(%rbp), %rdi
movq -0x8(%rbp), %rdx
movl -0xc(%rbp), %ecx
movl $0x4000, %esi           # imm = 0x4000
xorl %eax, %eax
movl %eax, %r8d
callq 0x1ab0
movl %eax, -0x401c(%rbp)
leaq -0x4010(%rbp), %rdi
movl -0x401c(%rbp), %esi
callq 0x1cbb0
leaq -0x4010(%rbp), %rax
movq %rax, -0x4018(%rbp)
movq -0x4018(%rbp), %rax
cmpb $0x0, (%rax)
je 0x1ce87
jmp 0x1ce73
movq -0x4018(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x4018(%rbp)
jmp 0x1ce65
movq -0x4018(%rbp), %rax
addq $-0x1, %rax
movq %rax, -0x4018(%rbp)
movq -0x4018(%rbp), %rcx
leaq -0x4010(%rbp), %rdx
xorl %eax, %eax
cmpq %rdx, %rcx
movb %al, -0x401d(%rbp)
jb 0x1ceed
movq -0x4018(%rbp), %rax
movsbl (%rax), %ecx
movb $0x1, %al
cmpl $0xa, %ecx
movb %al, -0x401e(%rbp)
je 0x1cee1
movq -0x4018(%rbp), %rax
movsbl (%rax), %eax
cmpl $0xd, %eax
sete %al
movb %al, -0x401e(%rbp)
movb -0x401e(%rbp), %al
movb %al, -0x401d(%rbp)
movb -0x401d(%rbp), %al
testb $0x1, %al
jne 0x1cef9
jmp 0x1cf13
movq -0x4018(%rbp), %rax
movq %rax, %rcx
addq $-0x1, %rcx
movq %rcx, -0x4018(%rbp)
movb $0x0, (%rax)
jmp 0x1ce99
leaq -0x4010(%rbp), %rsi
leaq 0x1d03(%rip), %rdi      # 0x1ec24
movb $0x0, %al
callq 0x10b0
movq 0x70a9(%rip), %rax      # 0x23fd8
movq (%rax), %rdi
callq 0x1170
addq $0x4020, %rsp           # imm = 0x4020
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O0/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 %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movw %di, %ax
movw %ax, -0x2(%rbp)
movzwl -0x2(%rbp), %eax
movl %eax, -0x28(%rbp)
addl $-0x9, %eax
subl $0x2, %eax
jb 0x1cf80
jmp 0x1cf60
movl -0x28(%rbp), %eax
subl $0xd, %eax
je 0x1cf80
jmp 0x1cf6a
movl -0x28(%rbp), %eax
subl $0x20, %eax
je 0x1cf80
jmp 0x1cf74
movl -0x28(%rbp), %eax
subl $0xa0, %eax
jne 0x1cf90
jmp 0x1cf80
leaq 0x2460(%rip), %rdi      # 0x1f3e7
movb $0x0, %al
callq 0x10b0
jmp 0x1cfcc
movw -0x2(%rbp), %ax
movw %ax, -0x24(%rbp)
movw $0x0, -0x22(%rbp)
leaq -0x20(%rbp), %rdi
leaq -0x24(%rbp), %rdx
movl $0x10, %esi
movl $0x2, %ecx
xorl %eax, %eax
movl %eax, %r8d
callq 0x1ab0
leaq -0x20(%rbp), %rsi
leaq 0x1c5f(%rip), %rdi      # 0x1ec24
movb $0x0, %al
callq 0x10b0
movq 0x7005(%rip), %rax      # 0x23fd8
movq (%rax), %rdi
callq 0x1170
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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 %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movw %di, %ax
movw %ax, -0x2(%rbp)
movzwl -0x2(%rbp), %eax
movl %eax, -0x28(%rbp)
subl $0x9, %eax
je 0x1d077
jmp 0x1d00d
movl -0x28(%rbp), %eax
subl $0xa, %eax
je 0x1d057
jmp 0x1d017
movl -0x28(%rbp), %eax
subl $0xd, %eax
je 0x1d067
jmp 0x1d021
movl -0x28(%rbp), %eax
subl $0x20, %eax
je 0x1d047
jmp 0x1d02b
movl -0x28(%rbp), %eax
subl $0xa0, %eax
jne 0x1d087
jmp 0x1d037
leaq 0x1f86(%rip), %rdi      # 0x1efc4
movb $0x0, %al
callq 0x10b0
jmp 0x1d0c3
leaq 0x1f79(%rip), %rdi      # 0x1efc7
movb $0x0, %al
callq 0x10b0
jmp 0x1d0c3
leaq 0x1f6c(%rip), %rdi      # 0x1efca
movb $0x0, %al
callq 0x10b0
jmp 0x1d0c3
leaq 0x1f5f(%rip), %rdi      # 0x1efcd
movb $0x0, %al
callq 0x10b0
jmp 0x1d0c3
leaq 0x1f52(%rip), %rdi      # 0x1efd0
movb $0x0, %al
callq 0x10b0
jmp 0x1d0c3
movw -0x2(%rbp), %ax
movw %ax, -0x24(%rbp)
movw $0x0, -0x22(%rbp)
leaq -0x20(%rbp), %rdi
leaq -0x24(%rbp), %rdx
movl $0x10, %esi
movl $0x2, %ecx
xorl %eax, %eax
movl %eax, %r8d
callq 0x1ab0
leaq -0x20(%rbp), %rsi
leaq 0x1b68(%rip), %rdi      # 0x1ec24
movb $0x0, %al
callq 0x10b0
movq 0x6f0e(%rip), %rax      # 0x23fd8
movq (%rax), %rdi
callq 0x1170
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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:
pushq %rbp
movq %rsp, %rbp
subq $0x8020, %rsp           # imm = 0x8020
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl %edx, -0x14(%rbp)
cmpl $0x3fff, -0x14(%rbp)    # imm = 0x3FFF
jle 0x1d114
movl $0x6, %edi
leaq 0x231d(%rip), %rsi      # 0x1f428
movb $0x0, %al
callq 0xf610
jmp 0x1d16a
leaq -0x8020(%rbp), %rdi
xorl %esi, %esi
movl $0x8000, %edx           # imm = 0x8000
callq 0x1100
leaq -0x8020(%rbp), %rdi
movq -0x10(%rbp), %rsi
movslq -0x14(%rbp), %rdx
shlq %rdx
callq 0x1150
movq -0x8(%rbp), %rdi
leaq -0x8020(%rbp), %rsi
movl -0x14(%rbp), %edx
callq 0x1d180
movq 0x6e80(%rip), %rax      # 0x23fd8
movq (%rax), %rdi
leaq -0x8020(%rbp), %rsi
movl -0x14(%rbp), %edx
callq 0x1a220
addq $0x8020, %rsp           # imm = 0x8020
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/MikeGray-APH[P]LibLouisAPH/debug/main.c
// Function: log_callback
static void log_callback(const int level, const char *message)
{
	switch(level)
	{
	case LOG_ALL:      printf("ALL:  ");      break;
	case LOG_TRACE:    printf("TRACE:  ");    break;
	case LOG_DEBUG:    printf("DEBUG:  ");    break;
	case LOG_INFO:     printf("INFO:  ");     break;
	case LOG_WARNING:  printf("WARNING:  ");  break;
	case LOG_ERROR:    printf("ERROR:  ");    break;
	case LOG_FATAL:    printf("FATAL:  ");    break;
	}

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

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movl %edi, -0x4(%rbp)
movq %rsi, -0x10(%rbp)
movl -0x4(%rbp), %eax
decl %eax
movl %eax, %ecx
movq %rcx, -0x18(%rbp)
subl $0x6, %eax
ja 0x1d5d5
movq -0x18(%rbp), %rax
leaq 0x1ed6(%rip), %rcx      # 0x1f434
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
leaq 0x1f28(%rip), %rdi      # 0x1f496
movb $0x0, %al
callq 0x10b0
jmp 0x1d5d5
leaq 0x1f1f(%rip), %rdi      # 0x1f49d
movb $0x0, %al
callq 0x10b0
jmp 0x1d5d5
leaq 0x1f18(%rip), %rdi      # 0x1f4a6
movb $0x0, %al
callq 0x10b0
jmp 0x1d5d5
leaq 0x1f11(%rip), %rdi      # 0x1f4af
movb $0x0, %al
callq 0x10b0
jmp 0x1d5d5
leaq 0x1f09(%rip), %rdi      # 0x1f4b7
movb $0x0, %al
callq 0x10b0
jmp 0x1d5d5
leaq 0x1f04(%rip), %rdi      # 0x1f4c2
movb $0x0, %al
callq 0x10b0
jmp 0x1d5d5
leaq 0x1efd(%rip), %rdi      # 0x1f4cb
movb $0x0, %al
callq 0x10b0
movq -0x10(%rbp), %rsi
leaq 0x165a(%rip), %rdi      # 0x1ec3a
movb $0x0, %al
callq 0x10b0
movq 0x69ea(%rip), %rax      # 0x23fd8
movq (%rax), %rdi
callq 0x1170
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/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 %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq $0x0, -0x20(%rbp)
movq -0x10(%rbp), %rsi
addq -0x20(%rbp), %rsi
movq -0x18(%rbp), %rdx
subq -0x20(%rbp), %rdx
xorl %edi, %edi
callq 0x1070
movq %rax, -0x28(%rbp)
cmpq $0x0, -0x28(%rbp)
jge 0x1216
callq 0x1040
cmpl $0x4, (%rax)
jne 0x1216
jmp 0x1274
cmpq $0x0, -0x28(%rbp)
jge 0x123f
movq 0x6dd4(%rip), %rax      # 0x7ff8
movq (%rax), %rdi
leaq 0x3dd6(%rip), %rsi      # 0x5004
movb $0x0, %al
callq 0x1080
movq -0x28(%rbp), %rax
movq %rax, -0x8(%rbp)
jmp 0x128a
cmpq $0x0, -0x28(%rbp)
jne 0x1268
movq 0x6dab(%rip), %rax      # 0x7ff8
movq (%rax), %rdi
leaq 0x3dc7(%rip), %rsi      # 0x501e
movb $0x0, %al
callq 0x1080
movq -0x28(%rbp), %rax
movq %rax, -0x8(%rbp)
jmp 0x128a
movq -0x28(%rbp), %rax
addq -0x20(%rbp), %rax
movq %rax, -0x20(%rbp)
movq -0x20(%rbp), %rax
cmpq -0x18(%rbp), %rax
jb 0x11e8
movq -0x18(%rbp), %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq $0x0, -0x20(%rbp)
movq -0x10(%rbp), %rsi
addq -0x20(%rbp), %rsi
movq -0x18(%rbp), %rdx
subq -0x20(%rbp), %rdx
movl $0x1, %edi
callq 0x1050
movq %rax, -0x28(%rbp)
cmpq $0x0, -0x28(%rbp)
jge 0x12e9
callq 0x1040
cmpl $0x4, (%rax)
jne 0x12e9
jmp 0x131e
cmpq $0x0, -0x28(%rbp)
jge 0x1312
movq 0x6d01(%rip), %rax      # 0x7ff8
movq (%rax), %rdi
leaq 0x3d38(%rip), %rsi      # 0x5039
movb $0x0, %al
callq 0x1080
movq -0x28(%rbp), %rax
movq %rax, -0x8(%rbp)
jmp 0x1330
movq -0x28(%rbp), %rax
addq -0x20(%rbp), %rax
movq %rax, -0x20(%rbp)
movq -0x20(%rbp), %rax
cmpq -0x18(%rbp), %rax
jb 0x12b8
movq -0x18(%rbp), %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x30, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/videolan[P]bitstream/examples/dvb_ecmg.c
// Function: send_channel_test
static void send_channel_test(void)
{
    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 test on channel ID=0x%hx\n", i_channelid);

    tlvh_set_version(p_tlv_h, i_version);
    ecmg_init(p_tlv);
    tlv_set_type(p_tlv, ECMG_TYPE_CHANNEL_TEST);
    /* 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);

    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
movq %rsp, %rbp
subq $0x410, %rsp            # imm = 0x410
leaq -0x400(%rbp), %rdi
callq 0x1770
movq %rax, -0x408(%rbp)
movq 0x6843(%rip), %rax      # 0x7ff8
movq (%rax), %rdi
movzwl 0x68c9(%rip), %edx      # 0x8088
leaq 0x38b2(%rip), %rsi      # 0x5078
movb $0x0, %al
callq 0x1080
leaq -0x400(%rbp), %rdi
movzbl 0x689e(%rip), %esi      # 0x8079
callq 0x2490
movq -0x408(%rbp), %rdi
callq 0x24b0
movq -0x408(%rbp), %rdi
movl $0x2, %esi
callq 0x24d0
movq -0x408(%rbp), %rdi
movl $0x3f7, %esi            # imm = 0x3F7
callq 0x2510
movq -0x408(%rbp), %rdi
movzwl 0x686c(%rip), %esi      # 0x8088
callq 0x2550
movq -0x408(%rbp), %rdi
xorl %edx, %edx
movl %edx, %esi
callq 0x2620
movq %rax, -0x410(%rbp)
movq -0x408(%rbp), %rdi
movq -0x410(%rbp), %rax
movq -0x408(%rbp), %rcx
subq %rcx, %rax
subq $0x4, %rax
movzwl %ax, %esi
callq 0x2510
leaq -0x400(%rbp), %rdi
movq -0x410(%rbp), %rsi
leaq -0x400(%rbp), %rax
subq %rax, %rsi
callq 0x12a0
addq $0x410, %rsp            # imm = 0x410
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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
movq %rsp, %rbp
subq $0x410, %rsp            # imm = 0x410
movw %si, %ax
movw %di, %cx
movw %cx, -0x2(%rbp)
movw %ax, -0x4(%rbp)
leaq -0x400(%rbp), %rdi
callq 0x1770
movq %rax, -0x408(%rbp)
movq 0x6705(%rip), %rax      # 0x7ff8
movq (%rax), %rdi
movzwl -0x2(%rbp), %edx
movzwl -0x4(%rbp), %ecx
leaq 0x3795(%rip), %rsi      # 0x509a
movb $0x0, %al
callq 0x1080
leaq -0x400(%rbp), %rdi
movzbl 0x675f(%rip), %esi      # 0x8079
callq 0x2490
movq -0x408(%rbp), %rdi
callq 0x24b0
movq -0x408(%rbp), %rdi
movl $0x5, %esi
callq 0x24d0
movq -0x408(%rbp), %rdi
movl $0x3f7, %esi            # imm = 0x3F7
callq 0x2510
movq -0x408(%rbp), %rdi
movzwl -0x2(%rbp), %esi
callq 0x2550
movq -0x408(%rbp), %rdi
movzwl -0x4(%rbp), %esi
callq 0x2850
movq -0x408(%rbp), %rdi
xorl %edx, %edx
movl %edx, %esi
callq 0x2620
movq %rax, -0x410(%rbp)
movq -0x408(%rbp), %rdi
movq -0x410(%rbp), %rax
movq -0x408(%rbp), %rcx
subq %rcx, %rax
subq $0x4, %rax
movzwl %ax, %esi
callq 0x2510
leaq -0x400(%rbp), %rdi
movq -0x410(%rbp), %rsi
leaq -0x400(%rbp), %rax
subq %rax, %rsi
callq 0x12a0
addq $0x410, %rsp            # imm = 0x410
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/videolan[P]bitstream/examples/./bitstream/dvb/sim.h
// Function: tlv_validate
static inline bool tlv_validate(const uint8_t *p_tlv)
{
    uint16_t i_tlv_size = tlv_get_length(p_tlv);
    const uint8_t *p_tlv_n = p_tlv + TLV_HEADER_SIZE;

    while (p_tlv_n - p_tlv <= i_tlv_size
            && p_tlv_n + tlv_get_length(p_tlv_n) - p_tlv <= i_tlv_size)
        p_tlv_n += TLV_HEADER_SIZE + tlv_get_length(p_tlv_n);

    return (p_tlv_n - p_tlv - TLV_HEADER_SIZE == i_tlv_size);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
callq 0x1890
movw %ax, -0xa(%rbp)
movq -0x8(%rbp), %rax
addq $0x4, %rax
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rcx
movq -0x8(%rbp), %rax
subq %rax, %rcx
movzwl -0xa(%rbp), %eax
movl %eax, %edx
xorl %eax, %eax
cmpq %rdx, %rcx
movb %al, -0x19(%rbp)
jg 0x1a65
movq -0x18(%rbp), %rax
movq %rax, -0x28(%rbp)
movq -0x18(%rbp), %rdi
callq 0x1890
movw %ax, %cx
movq -0x28(%rbp), %rax
movzwl %cx, %ecx
movslq %ecx, %rcx
addq %rcx, %rax
movq -0x8(%rbp), %rcx
subq %rcx, %rax
movzwl -0xa(%rbp), %ecx
cmpq %rcx, %rax
setle %al
movb %al, -0x19(%rbp)
movb -0x19(%rbp), %al
testb $0x1, %al
jne 0x1a6e
jmp 0x1a8d
movq -0x18(%rbp), %rdi
callq 0x1890
movzwl %ax, %ecx
addl $0x4, %ecx
movq -0x18(%rbp), %rax
movslq %ecx, %rcx
addq %rcx, %rax
movq %rax, -0x18(%rbp)
jmp 0x1a15
movq -0x18(%rbp), %rax
movq -0x8(%rbp), %rcx
subq %rcx, %rax
subq $0x4, %rax
movzwl -0xa(%rbp), %ecx
cmpq %rcx, %rax
sete %al
andb $0x1, %al
addq $0x30, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/videolan[P]bitstream/examples/dvb_ecmg.c
// Function: handle_channel_setup
static void handle_channel_setup(uint8_t *p_tlv)
{
    uint16_t i_wanted_channelid = ecmg_find_channelid(p_tlv, 0);

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

    i_channelid = i_wanted_channelid;
    i_supercasid = ecmg_find_supercasid(p_tlv, 0);

    fprintf(stderr,
            "starting channel ID=0x%hx version=%hhu super CAS ID=0x%x\n",
            i_channelid, i_version, i_supercasid);
    b_init = false;

    send_channel_status();
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
xorl %esi, %esi
callq 0x2a70
movw %ax, -0xa(%rbp)
testb $0x1, 0x6396(%rip)      # 0x8078
jne 0x1d03
movzwl -0xa(%rbp), %eax
movzwl 0x6399(%rip), %ecx      # 0x8088
cmpl %ecx, %eax
je 0x1d01
movl $0x6, %esi
movzwl -0xa(%rbp), %edi
callq 0x18c0
jmp 0x1d58
movw -0xa(%rbp), %ax
movw %ax, 0x637a(%rip)       # 0x8088
movq -0x8(%rbp), %rdi
xorl %esi, %esi
callq 0x2b00
movl %eax, 0x636d(%rip)      # 0x808c
movq 0x62d2(%rip), %rax      # 0x7ff8
movq (%rax), %rdi
movzwl 0x6358(%rip), %edx      # 0x8088
movzbl 0x6342(%rip), %ecx      # 0x8079
movl 0x634e(%rip), %r8d      # 0x808c
leaq 0x3384(%rip), %rsi      # 0x50c9
movb $0x0, %al
callq 0x1080
movb $0x0, 0x6325(%rip)      # 0x8078
callq 0x2b90
addq $0x10, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/videolan[P]bitstream/examples/dvb_ecmg.c
// Function: handle_channel_test
static void handle_channel_test(uint8_t *p_tlv)
{
    uint16_t i_wanted_channelid = ecmg_find_channelid(p_tlv, 0);

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

    send_channel_status();
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
xorl %esi, %esi
callq 0x2a70
movw %ax, -0xa(%rbp)
movzwl -0xa(%rbp), %eax
movzwl 0x6302(%rip), %ecx      # 0x8088
cmpl %ecx, %eax
je 0x1d9a
movl $0x6, %esi
movzwl -0xa(%rbp), %edi
callq 0x18c0
jmp 0x1d9f
callq 0x2b90
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/videolan[P]bitstream/examples/dvb_ecmg.c
// Function: handle_channel_close
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 %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
xorl %esi, %esi
callq 0x2a70
movw %ax, -0xa(%rbp)
movzwl -0xa(%rbp), %eax
movzwl 0x62b2(%rip), %ecx      # 0x8088
cmpl %ecx, %eax
je 0x1dea
movl $0x6, %esi
movzwl -0xa(%rbp), %edi
callq 0x18c0
jmp 0x1e62
movq 0x6207(%rip), %rax      # 0x7ff8
movq (%rax), %rdi
movzwl 0x628d(%rip), %edx      # 0x8088
leaq 0x3301(%rip), %rsi      # 0x5103
movb $0x0, %al
callq 0x1080
movb $0x1, 0x6268(%rip)      # 0x8078
movl $0x0, -0x10(%rbp)
movl -0x10(%rbp), %eax
cmpl 0x6270(%rip), %eax      # 0x8090
jge 0x1e41
movq 0x626f(%rip), %rax      # 0x8098
movslq -0x10(%rbp), %rcx
movq (%rax,%rcx,8), %rdi
callq 0x1030
movl -0x10(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x10(%rbp)
jmp 0x1e17
movq 0x6250(%rip), %rdi      # 0x8098
callq 0x1030
movq $0x0, 0x6240(%rip) # 0x8098
movl $0x0, 0x622e(%rip)      # 0x8090
addq $0x10, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/videolan[P]bitstream/examples/dvb_ecmg.c
// Function: handle_stream_test
static void handle_stream_test(uint8_t *p_tlv)
{
    uint16_t i_wanted_channelid = ecmg_find_channelid(p_tlv, 0);
    uint16_t i_streamid = ecmg_find_streamid(p_tlv, 0);
    stream_t *p_stream;

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

    if ((p_stream = find_stream(i_streamid)) == NULL) {
        send_stream_error(i_streamid, 0x7);
        return;
    }

    send_stream_status(p_stream);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
xorl %esi, %esi
callq 0x2a70
movw %ax, -0xa(%rbp)
movq -0x8(%rbp), %rdi
xorl %esi, %esi
callq 0x34b0
movw %ax, -0xc(%rbp)
movzwl -0xa(%rbp), %eax
movzwl 0x5fa3(%rip), %ecx      # 0x8088
cmpl %ecx, %eax
je 0x20f9
movl $0x6, %esi
movzwl -0xa(%rbp), %edi
callq 0x18c0
jmp 0x2125
movzwl -0xc(%rbp), %edi
callq 0x3540
movq %rax, -0x18(%rbp)
cmpq $0x0, %rax
jne 0x211c
movl $0x7, %esi
movzwl -0xc(%rbp), %edi
callq 0x35c0
jmp 0x2125
movq -0x18(%rbp), %rdi
callq 0x3810
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/videolan[P]bitstream/examples/dvb_ecmg.c
// Function: handle_stream_close
static void handle_stream_close(uint8_t *p_tlv)
{
    uint16_t i_wanted_channelid = ecmg_find_channelid(p_tlv, 0);
    uint16_t i_streamid = ecmg_find_streamid(p_tlv, 0);
    stream_t *p_stream;
    int i;

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

    if ((p_stream = find_stream(i_streamid)) == NULL) {
        send_stream_error(i_streamid, 0x7);
        return;
    }

    fprintf(stderr, "stopping stream ID=0x%hx\n", i_streamid);
    send_stream_close(p_stream);

    for (i = 0; i < i_nb_streams; i++) {
        if (pp_streams[i] == p_stream) {
            pp_streams[i] = NULL;
            break;
        }
    }

    free(p_stream);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
xorl %esi, %esi
callq 0x2a70
movw %ax, -0xa(%rbp)
movq -0x8(%rbp), %rdi
xorl %esi, %esi
callq 0x34b0
movw %ax, -0xc(%rbp)
movzwl -0xa(%rbp), %eax
movzwl 0x5f23(%rip), %ecx      # 0x8088
cmpl %ecx, %eax
je 0x217c
movl $0x6, %esi
movzwl -0xa(%rbp), %edi
callq 0x18c0
jmp 0x2216
movzwl -0xc(%rbp), %edi
callq 0x3540
movq %rax, -0x18(%rbp)
cmpq $0x0, %rax
jne 0x219f
movl $0x7, %esi
movzwl -0xc(%rbp), %edi
callq 0x35c0
jmp 0x2216
movq 0x5e52(%rip), %rax      # 0x7ff8
movq (%rax), %rdi
movzwl -0xc(%rbp), %edx
leaq 0x3001(%rip), %rsi      # 0x51b5
movb $0x0, %al
callq 0x1080
movq -0x18(%rbp), %rdi
callq 0x3ba0
movl $0x0, -0x1c(%rbp)
movl -0x1c(%rbp), %eax
cmpl 0x5ebc(%rip), %eax      # 0x8090
jge 0x220d
movq 0x5ebb(%rip), %rax      # 0x8098
movslq -0x1c(%rbp), %rcx
movq (%rax,%rcx,8), %rax
cmpq -0x18(%rbp), %rax
jne 0x2200
movq 0x5ea6(%rip), %rax      # 0x8098
movslq -0x1c(%rbp), %rcx
movq $0x0, (%rax,%rcx,8)
jmp 0x220d
jmp 0x2202
movl -0x1c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x1c(%rbp)
jmp 0x21cb
movq -0x18(%rbp), %rdi
callq 0x1030
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/videolan[P]bitstream/examples/dvb_ecmg.c
// Function: handle_stream_error
static void handle_stream_error(uint8_t *p_tlv)
{
    uint16_t i_wanted_channelid = ecmg_find_channelid(p_tlv, 0);
    uint16_t i_streamid = ecmg_find_streamid(p_tlv, 0);

    fprintf(stderr,
            "receiving error channel ID=0x%hu stream ID=0x%hx error=0x%hx\n",
            i_wanted_channelid, i_streamid, ecmg_find_errorstatus(p_tlv, 0));
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
xorl %esi, %esi
callq 0x2a70
movw %ax, -0xa(%rbp)
movq -0x8(%rbp), %rdi
xorl %esi, %esi
callq 0x34b0
movw %ax, -0xc(%rbp)
movq 0x5da7(%rip), %rax      # 0x7ff8
movq (%rax), %rax
movq %rax, -0x20(%rbp)
movzwl -0xa(%rbp), %eax
movl %eax, -0x14(%rbp)
movzwl -0xc(%rbp), %eax
movl %eax, -0x10(%rbp)
movq -0x8(%rbp), %rdi
xorl %esi, %esi
callq 0x3420
movq -0x20(%rbp), %rdi
movl -0x14(%rbp), %edx
movl -0x10(%rbp), %ecx
movzwl %ax, %r8d
leaq 0x2f49(%rip), %rsi      # 0x51cf
movb $0x0, %al
callq 0x1080
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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
movq %rsp, %rbp
subq $0x30, %rsp
movw %dx, %ax
movw %si, %cx
movq %rdi, -0x10(%rbp)
movw %cx, -0x12(%rbp)
movw %ax, -0x14(%rbp)
movb $0x0, -0x21(%rbp)
movq -0x10(%rbp), %rdi
movzbl -0x21(%rbp), %eax
movzwl %ax, %esi
callq 0x2770
movq %rax, -0x20(%rbp)
cmpq $0x0, %rax
je 0x2693
movb -0x21(%rbp), %al
addb $0x1, %al
movb %al, -0x21(%rbp)
movq -0x20(%rbp), %rdi
callq 0x19d0
movzwl %ax, %eax
movzwl -0x12(%rbp), %ecx
cmpl %ecx, %eax
jne 0x2691
cmpw $0x0, -0x14(%rbp)
jne 0x2685
movq -0x20(%rbp), %rax
movq %rax, -0x8(%rbp)
jmp 0x269b
movw -0x14(%rbp), %ax
addw $-0x1, %ax
movw %ax, -0x14(%rbp)
jmp 0x263e
movq $0x0, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movw %si, %ax
movq %rdi, -0x10(%rbp)
movw %ax, -0x12(%rbp)
movq -0x10(%rbp), %rdi
callq 0x1890
movw %ax, -0x14(%rbp)
movq -0x10(%rbp), %rax
addq $0x4, %rax
movq %rax, -0x20(%rbp)
movq -0x20(%rbp), %rax
movq -0x10(%rbp), %rcx
subq %rcx, %rax
subq $0x4, %rax
movzwl -0x14(%rbp), %ecx
cmpq %rcx, %rax
jle 0x27be
movq $0x0, -0x8(%rbp)
jmp 0x283a
jmp 0x27c0
cmpw $0x0, -0x12(%rbp)
je 0x2810
movq -0x20(%rbp), %rax
movq -0x10(%rbp), %rcx
subq %rcx, %rax
movzwl -0x14(%rbp), %ecx
cmpq %rcx, %rax
jle 0x27e5
movq $0x0, -0x8(%rbp)
jmp 0x283a
movq -0x20(%rbp), %rdi
callq 0x1890
movzwl %ax, %ecx
addl $0x4, %ecx
movq -0x20(%rbp), %rax
movslq %ecx, %rcx
addq %rcx, %rax
movq %rax, -0x20(%rbp)
movw -0x12(%rbp), %ax
addw $-0x1, %ax
movw %ax, -0x12(%rbp)
jmp 0x27c0
movq -0x20(%rbp), %rax
movq -0x10(%rbp), %rcx
subq %rcx, %rax
subq $0x4, %rax
movzwl -0x14(%rbp), %ecx
cmpq %rcx, %rax
jl 0x2832
movq $0x0, -0x8(%rbp)
jmp 0x283a
movq -0x20(%rbp), %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/videolan[P]bitstream/examples/./bitstream/dvb/sim.h
// Function: ecmg_validate_param
static inline bool ecmg_validate_param(const uint8_t *p_tlv_n)
{
    static const uint16_t pi_ecmg_params_minlength[] = {
        /*  0x0 */ 0, 4, 1, 2, 2, 2, 2, 2,
        /*  0x8 */ 2, 2, 1, 1, 2, 0, 2, 2,
        /* 0x10 */ 2, 1, 2, 2, 0, 0, 2, 2,
        /* 0x18 */ 0, 2
    };
    uint16_t i_type = tlv_get_type(p_tlv_n);
    uint16_t i_length = tlv_get_length(p_tlv_n);

    if (i_type <= ECMG_PARAM_ECMID) {
        if (i_length < pi_ecmg_params_minlength[i_type]) return false;

    } else if (i_type == ECMG_PARAM_ERRORSTATUS) {
        if (i_length < 2) return false;
    }

    return true;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movq -0x10(%rbp), %rdi
callq 0x19d0
movw %ax, -0x12(%rbp)
movq -0x10(%rbp), %rdi
callq 0x1890
movw %ax, -0x14(%rbp)
movzwl -0x12(%rbp), %eax
cmpl $0x19, %eax
jg 0x29d0
movzwl -0x14(%rbp), %eax
movzwl -0x12(%rbp), %ecx
movl %ecx, %edx
leaq 0x29f0(%rip), %rcx      # 0x53b0
movzwl (%rcx,%rdx,2), %ecx
cmpl %ecx, %eax
jge 0x29ce
movb $0x0, -0x1(%rbp)
jmp 0x29f2
jmp 0x29ee
movzwl -0x12(%rbp), %eax
cmpl $0x7000, %eax           # imm = 0x7000
jne 0x29ec
movzwl -0x14(%rbp), %eax
cmpl $0x2, %eax
jge 0x29ea
movb $0x0, -0x1(%rbp)
jmp 0x29f2
jmp 0x29ec
jmp 0x29ee
movb $0x1, -0x1(%rbp)
movb -0x1(%rbp), %al
andb $0x1, %al
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/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
movq %rsp, %rbp
subq $0x20, %rsp
movw %si, %ax
movq %rdi, -0x8(%rbp)
movw %ax, -0xa(%rbp)
movw $0x0, -0xc(%rbp)
movw $0x0, -0x1a(%rbp)
movq -0x8(%rbp), %rdi
movzwl -0x1a(%rbp), %esi
callq 0x2770
movq %rax, -0x18(%rbp)
cmpq $0x0, %rax
je 0x2a64
movw -0x1a(%rbp), %ax
addw $0x1, %ax
movw %ax, -0x1a(%rbp)
movq -0x18(%rbp), %rdi
callq 0x19d0
movzwl %ax, %eax
movzwl -0xa(%rbp), %ecx
cmpl %ecx, %eax
jne 0x2a62
movw -0xc(%rbp), %ax
addw $0x1, %ax
movw %ax, -0xc(%rbp)
jmp 0x2a1f
movw -0xc(%rbp), %ax
addq $0x20, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/videolan[P]bitstream/examples/dvb_ecmg.c
// Function: send_channel_status
static void send_channel_status(void)
{
    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_CHANNEL_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_sectiontspkt(p_tlv, 0x0); /* sections */
    ecmg_append_delaystart(p_tlv, DELAY_START);
    ecmg_append_delaystop(p_tlv, DELAY_STOP);
    ecmg_append_repperiod(p_tlv, REP_PERIOD);
    ecmg_append_maxstreams(p_tlv, MAX_STREAMS);
    ecmg_append_mincpdur(p_tlv, MIN_CP_DUR);
    ecmg_append_leadcw(p_tlv, LEAD_CW);
    ecmg_append_cwpermsg(p_tlv, CW_PER_MSG);
    ecmg_append_maxcomptime(p_tlv, MAX_COMP_TIME);

    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
movq %rsp, %rbp
subq $0x410, %rsp            # imm = 0x410
leaq -0x400(%rbp), %rdi
callq 0x1770
movq %rax, -0x408(%rbp)
leaq -0x400(%rbp), %rdi
movzbl 0x54bd(%rip), %esi      # 0x8079
callq 0x2490
movq -0x408(%rbp), %rdi
callq 0x24b0
movq -0x408(%rbp), %rdi
movl $0x3, %esi
callq 0x24d0
movq -0x408(%rbp), %rdi
movl $0x3f7, %esi            # imm = 0x3F7
callq 0x2510
movq -0x408(%rbp), %rdi
movzwl 0x548b(%rip), %esi      # 0x8088
callq 0x2550
movq -0x408(%rbp), %rdi
xorl %esi, %esi
callq 0x2d00
movq -0x408(%rbp), %rdi
movl $0xc8, %esi
callq 0x2dc0
movq -0x408(%rbp), %rdi
xorl %esi, %esi
callq 0x2e90
movq -0x408(%rbp), %rdi
movl $0x12c, %esi            # imm = 0x12C
callq 0x2f60
movq -0x408(%rbp), %rdi
movl $0x1f4, %esi            # imm = 0x1F4
callq 0x3030
movq -0x408(%rbp), %rdi
movl $0x3, %esi
callq 0x3100
movq -0x408(%rbp), %rdi
movl $0x1, %esi
callq 0x31d0
movq -0x408(%rbp), %rdi
movl $0x2, %esi
callq 0x3290
movq -0x408(%rbp), %rdi
movl $0x64, %esi
callq 0x3350
movq -0x408(%rbp), %rdi
xorl %edx, %edx
movl %edx, %esi
callq 0x2620
movq %rax, -0x410(%rbp)
movq -0x408(%rbp), %rdi
movq -0x410(%rbp), %rax
movq -0x408(%rbp), %rcx
subq %rcx, %rax
subq $0x4, %rax
movzwl %ax, %esi
callq 0x2510
leaq -0x400(%rbp), %rdi
movq -0x410(%rbp), %rsi
leaq -0x400(%rbp), %rax
subq %rax, %rsi
callq 0x12a0
addq $0x410, %rsp            # imm = 0x410
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/videolan[P]bitstream/examples/dvb_ecmg.c
// Function: find_stream
static stream_t *find_stream(uint16_t i_streamid)
{
    int i;

    for (i = 0; i < i_nb_streams; i++)
        if (pp_streams[i] != NULL && pp_streams[i]->i_streamid == i_streamid)
            return pp_streams[i];

    return NULL;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movw %di, %ax
movw %ax, -0xa(%rbp)
movl $0x0, -0x10(%rbp)
movl -0x10(%rbp), %eax
cmpl 0x4b35(%rip), %eax      # 0x8090
jge 0x35ab
movq 0x4b34(%rip), %rax      # 0x8098
movslq -0x10(%rbp), %rcx
cmpq $0x0, (%rax,%rcx,8)
je 0x359e
movq 0x4b22(%rip), %rax      # 0x8098
movslq -0x10(%rbp), %rcx
movq (%rax,%rcx,8), %rax
movzwl (%rax), %eax
movzwl -0xa(%rbp), %ecx
cmpl %ecx, %eax
jne 0x359e
movq 0x4b08(%rip), %rax      # 0x8098
movslq -0x10(%rbp), %rcx
movq (%rax,%rcx,8), %rax
movq %rax, -0x8(%rbp)
jmp 0x35b3
jmp 0x35a0
movl -0x10(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x10(%rbp)
jmp 0x3552
movq $0x0, -0x8(%rbp)
movq -0x8(%rbp), %rax
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/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
movq %rsp, %rbp
subq $0x410, %rsp            # imm = 0x410
movw %si, %ax
movw %di, %cx
movw %cx, -0x2(%rbp)
movw %ax, -0x4(%rbp)
leaq -0x400(%rbp), %rdi
callq 0x1770
movq %rax, -0x408(%rbp)
movq 0x4a05(%rip), %rax      # 0x7ff8
movq (%rax), %rdi
movzwl -0x2(%rbp), %edx
movzwl -0x4(%rbp), %ecx
leaq 0x1b82(%rip), %rsi      # 0x5187
movb $0x0, %al
callq 0x1080
leaq -0x400(%rbp), %rdi
movzbl 0x4a5f(%rip), %esi      # 0x8079
callq 0x2490
movq -0x408(%rbp), %rdi
callq 0x24b0
movq -0x408(%rbp), %rdi
movl $0x106, %esi            # imm = 0x106
callq 0x24d0
movq -0x408(%rbp), %rdi
movl $0x3f7, %esi            # imm = 0x3F7
callq 0x2510
movq -0x408(%rbp), %rdi
movzwl 0x4a2d(%rip), %esi      # 0x8088
callq 0x2550
movq -0x408(%rbp), %rdi
movzwl -0x2(%rbp), %esi
callq 0x3930
movq -0x408(%rbp), %rdi
movzwl -0x4(%rbp), %esi
callq 0x2850
movq -0x408(%rbp), %rdi
xorl %edx, %edx
movl %edx, %esi
callq 0x2620
movq %rax, -0x410(%rbp)
movq -0x408(%rbp), %rdi
movq -0x410(%rbp), %rax
movq -0x408(%rbp), %rcx
subq %rcx, %rax
subq $0x4, %rax
movzwl %ax, %esi
callq 0x2510
leaq -0x400(%rbp), %rdi
movq -0x410(%rbp), %rsi
leaq -0x400(%rbp), %rax
subq %rax, %rsi
callq 0x12a0
addq $0x410, %rsp            # imm = 0x410
popq %rbp
retq
nopw %cs:(%rax,%rax)