LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O0/MikeGray-APH[P]LibLouisAPH/source/languages/generic-forward.c
// Function: mark_capital_whole_words
static void mark_capital_whole_words(unsigned int *indicators, unsigned char *words, const struct translate *translate)
{
	int emp_word, word_begin, letter_cnt, i;

	word_begin =
	emp_word = -1;
	letter_cnt = 0;

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

		if(word_begin < 0)
		{
			if(words[i] & WORD_CHAR)
			{
				word_begin = i;
				emp_word = -1;
				letter_cnt = 0;
			}
		}

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

			if(translate_has_attributes_at(translate, i, CHAR_LOWER))
				letter_cnt++;

			if(!(words[i] & WORD_CHAR))
			{
				if(!letter_cnt)
				if(emp_word >= 0)
					words[emp_word] |= WORD_WHOLE;
				word_begin = -1;
				emp_word = -1;
				letter_cnt = 0;
			}
		}
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movl $0xffffffff, -0x1c(%rbp) # imm = 0xFFFFFFFF
movl $0xffffffff, -0x20(%rbp) # imm = 0xFFFFFFFF
movl $0x0, -0x24(%rbp)
movl $0x0, -0x28(%rbp)
movl -0x28(%rbp), %eax
movq -0x18(%rbp), %rcx
cmpl 0x44(%rcx), %eax
jge 0x1534e
movq -0x10(%rbp), %rax
movslq -0x28(%rbp), %rcx
movzbl (%rax,%rcx), %eax
andl $0x4, %eax
cmpl $0x0, %eax
je 0x15279
jmp 0x15340
cmpl $0x0, -0x20(%rbp)
jge 0x152a9
movq -0x10(%rbp), %rax
movslq -0x28(%rbp), %rcx
movzbl (%rax,%rcx), %eax
andl $0x1, %eax
cmpl $0x0, %eax
je 0x152a7
movl -0x28(%rbp), %eax
movl %eax, -0x20(%rbp)
movl $0xffffffff, -0x1c(%rbp) # imm = 0xFFFFFFFF
movl $0x0, -0x24(%rbp)
jmp 0x152a9
cmpl $0x0, -0x20(%rbp)
jl 0x1533e
cmpl $0x0, -0x1c(%rbp)
jge 0x152d4
movq -0x8(%rbp), %rax
movslq -0x28(%rbp), %rcx
movl (%rax,%rcx,4), %eax
andl $0xc, %eax
cmpl $0x0, %eax
je 0x152d2
movl -0x28(%rbp), %eax
movl %eax, -0x1c(%rbp)
jmp 0x152d4
movq -0x18(%rbp), %rdi
movl -0x28(%rbp), %esi
movl $0x100, %edx            # imm = 0x100
callq 0x14440
cmpl $0x0, %eax
je 0x152f3
movl -0x24(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x24(%rbp)
movq -0x10(%rbp), %rax
movslq -0x28(%rbp), %rcx
movzbl (%rax,%rcx), %eax
andl $0x1, %eax
cmpl $0x0, %eax
jne 0x1533c
cmpl $0x0, -0x24(%rbp)
jne 0x15327
cmpl $0x0, -0x1c(%rbp)
jl 0x15325
movq -0x10(%rbp), %rax
movslq -0x1c(%rbp), %rcx
movzbl (%rax,%rcx), %edx
orl $0x2, %edx
movb %dl, (%rax,%rcx)
jmp 0x15327
movl $0xffffffff, -0x20(%rbp) # imm = 0xFFFFFFFF
movl $0xffffffff, -0x1c(%rbp) # imm = 0xFFFFFFFF
movl $0x0, -0x24(%rbp)
jmp 0x1533e
jmp 0x15340
movl -0x28(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x28(%rbp)
jmp 0x15250
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/MikeGray-APH[P]LibLouisAPH/source/languages/generic-forward.c
// Function: 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 %rbp
movq %rsp, %rbp
movw %si, %ax
movq %rdi, -0x10(%rbp)
movw %ax, -0x12(%rbp)
movzwl -0x12(%rbp), %eax
movq -0x10(%rbp), %rcx
movzwl 0x1e8(%rcx), %ecx
cmpl %ecx, %eax
jne 0x15d7b
movl $0x1, -0x4(%rbp)
jmp 0x15df2
movzwl -0x12(%rbp), %eax
movq -0x10(%rbp), %rcx
movzwl 0x1ea(%rcx), %ecx
cmpl %ecx, %eax
jne 0x15d97
movl $0x1, -0x4(%rbp)
jmp 0x15df2
movzwl -0x12(%rbp), %eax
movq -0x10(%rbp), %rcx
movzwl 0x1ec(%rcx), %ecx
cmpl %ecx, %eax
jne 0x15db3
movl $0x1, -0x4(%rbp)
jmp 0x15df2
movzwl -0x12(%rbp), %eax
movq -0x10(%rbp), %rcx
movzwl 0x1f0(%rcx), %ecx
cmpl %ecx, %eax
jne 0x15dcf
movl $0x1, -0x4(%rbp)
jmp 0x15df2
movzwl -0x12(%rbp), %eax
movq -0x10(%rbp), %rcx
movzwl 0x1f2(%rcx), %ecx
cmpl %ecx, %eax
jne 0x15deb
movl $0x1, -0x4(%rbp)
jmp 0x15df2
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/MikeGray-APH[P]LibLouisAPH/source/languages/generic-forward.c
// Function: is_indicator_delimiter_capital
static int is_indicator_delimiter_capital(const struct translate *translate, const struct table *table, const int at)
{
	if(translate->input[at] == table->marker_user)
		return is_indicator_in_word(translate, at);
	if(translate->input[at] == table->marker_begin)
		return is_indicator_in_word(translate, at);
	if(translate->input[at] == table->marker_end)
		return is_indicator_in_word(translate, at);
	if(translate->input[at] == table->marker_hard)
		return is_indicator_in_word(translate, at);
	if(translate->input[at] == table->marker_soft)
		return is_indicator_in_word(translate, at);
	return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movl %edx, -0x1c(%rbp)
movq -0x10(%rbp), %rax
movq 0x38(%rax), %rax
movslq -0x1c(%rbp), %rcx
movzwl (%rax,%rcx,2), %eax
movq -0x18(%rbp), %rcx
movzwl 0x1e8(%rcx), %ecx
cmpl %ecx, %eax
jne 0x15e46
movq -0x10(%rbp), %rdi
movl -0x1c(%rbp), %esi
callq 0x15f90
movl %eax, -0x4(%rbp)
jmp 0x15f10
movq -0x10(%rbp), %rax
movq 0x38(%rax), %rax
movslq -0x1c(%rbp), %rcx
movzwl (%rax,%rcx,2), %eax
movq -0x18(%rbp), %rcx
movzwl 0x1ea(%rcx), %ecx
cmpl %ecx, %eax
jne 0x15e79
movq -0x10(%rbp), %rdi
movl -0x1c(%rbp), %esi
callq 0x15f90
movl %eax, -0x4(%rbp)
jmp 0x15f10
movq -0x10(%rbp), %rax
movq 0x38(%rax), %rax
movslq -0x1c(%rbp), %rcx
movzwl (%rax,%rcx,2), %eax
movq -0x18(%rbp), %rcx
movzwl 0x1ec(%rcx), %ecx
cmpl %ecx, %eax
jne 0x15ea9
movq -0x10(%rbp), %rdi
movl -0x1c(%rbp), %esi
callq 0x15f90
movl %eax, -0x4(%rbp)
jmp 0x15f10
movq -0x10(%rbp), %rax
movq 0x38(%rax), %rax
movslq -0x1c(%rbp), %rcx
movzwl (%rax,%rcx,2), %eax
movq -0x18(%rbp), %rcx
movzwl 0x1f0(%rcx), %ecx
cmpl %ecx, %eax
jne 0x15ed9
movq -0x10(%rbp), %rdi
movl -0x1c(%rbp), %esi
callq 0x15f90
movl %eax, -0x4(%rbp)
jmp 0x15f10
movq -0x10(%rbp), %rax
movq 0x38(%rax), %rax
movslq -0x1c(%rbp), %rcx
movzwl (%rax,%rcx,2), %eax
movq -0x18(%rbp), %rcx
movzwl 0x1f2(%rcx), %ecx
cmpl %ecx, %eax
jne 0x15f09
movq -0x10(%rbp), %rdi
movl -0x1c(%rbp), %esi
callq 0x15f90
movl %eax, -0x4(%rbp)
jmp 0x15f10
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/MikeGray-APH[P]LibLouisAPH/source/languages/generic-forward.c
// Function: 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:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x10(%rbp)
movl %esi, -0x14(%rbp)
movq %rdx, -0x20(%rbp)
movl -0x14(%rbp), %eax
movl %eax, -0x24(%rbp)
movl -0x24(%rbp), %eax
movq -0x20(%rbp), %rcx
cmpl 0x44(%rcx), %eax
jge 0x15f80
movq -0x10(%rbp), %rax
movslq -0x24(%rbp), %rcx
movzbl (%rax,%rcx), %eax
andl $0x1, %eax
cmpl $0x0, %eax
jne 0x15f57
jmp 0x15f80
movq -0x10(%rbp), %rax
movslq -0x24(%rbp), %rcx
movzbl (%rax,%rcx), %eax
andl $0x2, %eax
cmpl $0x0, %eax
je 0x15f73
movl -0x24(%rbp), %eax
movl %eax, -0x4(%rbp)
jmp 0x15f87
jmp 0x15f75
movl -0x24(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x24(%rbp)
jmp 0x15f35
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
movl -0x4(%rbp), %eax
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/MikeGray-APH[P]LibLouisAPH/source/languages/generic-forward.c
// Function: is_indicator_in_word
static int is_indicator_in_word(const struct translate *translate, const int at)
{
	int crs;

	for(crs = at + 1; crs < translate->input_len; crs++)
	if(translate->input[crs] == translate->input[at])
		break;

	crs++;
	if(translate_has_attributes_at(translate, crs, CHAR_UPPER))
		return 1;
	return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movl %esi, -0x14(%rbp)
movl -0x14(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x18(%rbp)
movl -0x18(%rbp), %eax
movq -0x10(%rbp), %rcx
cmpl 0x44(%rcx), %eax
jge 0x15fe7
movq -0x10(%rbp), %rax
movq 0x38(%rax), %rax
movslq -0x18(%rbp), %rcx
movzwl (%rax,%rcx,2), %eax
movq -0x10(%rbp), %rcx
movq 0x38(%rcx), %rcx
movslq -0x14(%rbp), %rdx
movzwl (%rcx,%rdx,2), %ecx
cmpl %ecx, %eax
jne 0x15fda
jmp 0x15fe7
jmp 0x15fdc
movl -0x18(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x18(%rbp)
jmp 0x15fa8
movl -0x18(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x18(%rbp)
movq -0x10(%rbp), %rdi
movl -0x18(%rbp), %esi
movl $0x80, %edx
callq 0x14440
cmpl $0x0, %eax
je 0x1600f
movl $0x1, -0x4(%rbp)
jmp 0x16016
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x20, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/MikeGray-APH[P]LibLouisAPH/source/languages/generic-forward.c
// Function: insert_indicators_capital_at
static int insert_indicators_capital_at(struct translate *translate, const struct table *table, const unsigned int indicator, const struct mode *mode)
{
	switch(indicator & EMP_EMPHASIS)
	{
	case EMP_BEGIN:

		if(!generic_insert_marked(translate, mode->begin, mode->begin_len, table->marker_hard))
			return 0;
		break;

	case EMP_END:

		if(!generic_insert_marked(translate, mode->end, mode->end_len, table->marker_hard))
			return 0;
		break;

	case EMP_WORD:

		if(!generic_insert_marked(translate, mode->word, mode->word_len, table->marker_hard))
			return 0;
		break;

	case EMP_END | EMP_WORD:

		if(!generic_insert_marked(translate, mode->term, mode->term_len, table->marker_hard))
			return 0;
		break;

	case EMP_SYMBOL:

		if(!generic_insert_marked(translate, mode->symbol, mode->symbol_len, table->marker_hard))
			return 0;
		break;
	}

	return 1;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movl %edx, -0x1c(%rbp)
movq %rcx, -0x28(%rbp)
movl -0x1c(%rbp), %eax
andl $0xf, %eax
decl %eax
movl %eax, %ecx
movq %rcx, -0x30(%rbp)
subl $0x7, %eax
ja 0x1616d
movq -0x30(%rbp), %rax
leaq 0x8e57(%rip), %rcx      # 0x1eeb0
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
movq -0x10(%rbp), %rdi
movq -0x28(%rbp), %rsi
addq $0xc, %rsi
movq -0x28(%rbp), %rax
movl 0x54(%rax), %edx
movq -0x18(%rbp), %rax
movzwl 0x1f0(%rax), %ecx
callq 0x102a0
cmpl $0x0, %eax
jne 0x16096
movl $0x0, -0x4(%rbp)
jmp 0x16174
jmp 0x1616d
movq -0x10(%rbp), %rdi
movq -0x28(%rbp), %rsi
addq $0x1a, %rsi
movq -0x28(%rbp), %rax
movl 0x58(%rax), %edx
movq -0x18(%rbp), %rax
movzwl 0x1f0(%rax), %ecx
callq 0x102a0
cmpl $0x0, %eax
jne 0x160cf
movl $0x0, -0x4(%rbp)
jmp 0x16174
jmp 0x1616d
movq -0x10(%rbp), %rdi
movq -0x28(%rbp), %rsi
addq $0x28, %rsi
movq -0x28(%rbp), %rax
movl 0x5c(%rax), %edx
movq -0x18(%rbp), %rax
movzwl 0x1f0(%rax), %ecx
callq 0x102a0
cmpl $0x0, %eax
jne 0x16105
movl $0x0, -0x4(%rbp)
jmp 0x16174
jmp 0x1616d
movq -0x10(%rbp), %rdi
movq -0x28(%rbp), %rsi
addq $0x36, %rsi
movq -0x28(%rbp), %rax
movl 0x60(%rax), %edx
movq -0x18(%rbp), %rax
movzwl 0x1f0(%rax), %ecx
callq 0x102a0
cmpl $0x0, %eax
jne 0x16138
movl $0x0, -0x4(%rbp)
jmp 0x16174
jmp 0x1616d
movq -0x10(%rbp), %rdi
movq -0x28(%rbp), %rsi
addq $0x44, %rsi
movq -0x28(%rbp), %rax
movl 0x64(%rax), %edx
movq -0x18(%rbp), %rax
movzwl 0x1f0(%rax), %ecx
callq 0x102a0
cmpl $0x0, %eax
jne 0x1616b
movl $0x0, -0x4(%rbp)
jmp 0x16174
jmp 0x1616d
movl $0x1, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/MikeGray-APH[P]LibLouisAPH/source/languages/generic.h
// Function: generic_upper_to_lower
static inline unichar generic_upper_to_lower(const struct table *table, const unichar uchar)
{
	struct character *character;

	character = table_find_character(table, uchar);
	if(!character)
		return uchar;
	if(!(character->attrs & CHAR_UPPER))
		return uchar;

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

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movw %si, %ax
movq %rdi, -0x10(%rbp)
movw %ax, -0x12(%rbp)
movq -0x10(%rbp), %rdi
movzwl -0x12(%rbp), %esi
callq 0x2900
movq %rax, -0x20(%rbp)
cmpq $0x0, -0x20(%rbp)
jne 0x161b5
movw -0x12(%rbp), %ax
movw %ax, -0x2(%rbp)
jmp 0x161e0
movq -0x20(%rbp), %rax
movl 0x24(%rax), %eax
andl $0x80, %eax
cmpl $0x0, %eax
jne 0x161d0
movw -0x12(%rbp), %ax
movw %ax, -0x2(%rbp)
jmp 0x161e0
movq -0x20(%rbp), %rax
movq 0x8(%rax), %rax
movw 0x20(%rax), %ax
movw %ax, -0x2(%rbp)
movw -0x2(%rbp), %ax
addq $0x20, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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 %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movw %si, %ax
movq %rdi, -0x10(%rbp)
movw %ax, -0x12(%rbp)
movq -0x10(%rbp), %rdi
movzwl -0x12(%rbp), %esi
callq 0x2900
movq %rax, -0x20(%rbp)
cmpq $0x0, -0x20(%rbp)
jne 0x162f5
movw -0x12(%rbp), %ax
movw %ax, -0x2(%rbp)
jmp 0x16320
movq -0x20(%rbp), %rax
movl 0x24(%rax), %eax
andl $0x800, %eax            # imm = 0x800
cmpl $0x0, %eax
jne 0x16310
movw -0x12(%rbp), %ax
movw %ax, -0x2(%rbp)
jmp 0x16320
movq -0x20(%rbp), %rax
movq 0x10(%rax), %rax
movw 0x20(%rax), %ax
movw %ax, -0x2(%rbp)
movw -0x2(%rbp), %ax
addq $0x20, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/MikeGray-APH[P]LibLouisAPH/source/languages/generic-forward.c
// Function: is_letter_before
static int is_letter_before(const struct translate *translate, const struct table *table)
{
	unsigned int attrs;
	int i;

	for(i = translate->input_crs - 1; i >= 0; i--)
	{
		attrs = table_get_character_attributes(table, translate->input[i]);
		if(attrs & CHAR_LETTER)
			return 1;
		if(!(attrs & CHAR_NUMERIC_CONT))
			break;
	}
	return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x10(%rbp), %rax
movl 0x40(%rax), %eax
subl $0x1, %eax
movl %eax, -0x20(%rbp)
cmpl $0x0, -0x20(%rbp)
jl 0x1639f
movq -0x18(%rbp), %rdi
movq -0x10(%rbp), %rax
movq 0x38(%rax), %rax
movslq -0x20(%rbp), %rcx
movzwl (%rax,%rcx,2), %esi
callq 0x14490
movl %eax, -0x1c(%rbp)
movl -0x1c(%rbp), %eax
andl $0x40, %eax
cmpl $0x0, %eax
je 0x16383
movl $0x1, -0x4(%rbp)
jmp 0x163a6
movl -0x1c(%rbp), %eax
andl $0x2000, %eax           # imm = 0x2000
cmpl $0x0, %eax
jne 0x16392
jmp 0x1639f
jmp 0x16394
movl -0x20(%rbp), %eax
addl $-0x1, %eax
movl %eax, -0x20(%rbp)
jmp 0x1634d
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x20, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/MikeGray-APH[P]LibLouisAPH/source/languages/generic-forward.c
// Function: is_digit_after
static int is_digit_after(const struct translate *translate, const struct table *table)
{
	unsigned int attrs;
	int i;

	for(i = translate->input_crs + 1; i < translate->input_len; i++)
	{
		attrs = table_get_character_attributes(table, translate->input[i]);
		if(attrs & CHAR_NUMERIC_DIGIT)
			return 1;
		if(!(attrs & CHAR_NUMERIC_CONT))
			break;
	}
	return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x10(%rbp), %rax
movl 0x40(%rax), %eax
addl $0x1, %eax
movl %eax, -0x20(%rbp)
movl -0x20(%rbp), %eax
movq -0x10(%rbp), %rcx
cmpl 0x44(%rcx), %eax
jge 0x16427
movq -0x18(%rbp), %rdi
movq -0x10(%rbp), %rax
movq 0x38(%rax), %rax
movslq -0x20(%rbp), %rcx
movzwl (%rax,%rcx,2), %esi
callq 0x14490
movl %eax, -0x1c(%rbp)
movl -0x1c(%rbp), %eax
andl $0x800, %eax            # imm = 0x800
cmpl $0x0, %eax
je 0x1640b
movl $0x1, -0x4(%rbp)
jmp 0x1642e
movl -0x1c(%rbp), %eax
andl $0x2000, %eax           # imm = 0x2000
cmpl $0x0, %eax
jne 0x1641a
jmp 0x16427
jmp 0x1641c
movl -0x20(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x20(%rbp)
jmp 0x163cd
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x20, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/MikeGray-APH[P]LibLouisAPH/source/translate.h
// Function: translate_get_init_dots_hash_cnt
static inline int translate_get_init_dots_hash_cnt(const struct translate *translate)
{
	int cnt, i;

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

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

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

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

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

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

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

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

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

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

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

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movl $0x0, -0xc(%rbp)
movl $0x0, -0x10(%rbp)
movl -0x10(%rbp), %eax
movq -0x8(%rbp), %rcx
cmpl 0xc(%rcx), %eax
jge 0x17be8
movq -0x8(%rbp), %rax
movq (%rax), %rax
movslq -0x10(%rbp), %rcx
movq (%rax,%rcx,8), %rax
movl 0x31c(%rax), %eax
addl -0xc(%rbp), %eax
movl %eax, -0xc(%rbp)
movl -0x10(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x10(%rbp)
jmp 0x17bb6
movl -0xc(%rbp), %eax
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/MikeGray-APH[P]LibLouisAPH/source/languages/generic.h
// Function: generic_lower_to_upper
static inline unichar generic_lower_to_upper(const struct table *table, const unichar uchar)
{
	struct character *character;

	character = table_find_character(table, uchar);
	if(!character)
		return uchar;
	if(!(character->attrs & CHAR_LOWER))
		return uchar;

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

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movw %si, %ax
movq %rdi, -0x10(%rbp)
movw %ax, -0x12(%rbp)
movq -0x10(%rbp), %rdi
movzwl -0x12(%rbp), %esi
callq 0x2900
movq %rax, -0x20(%rbp)
cmpq $0x0, -0x20(%rbp)
jne 0x18295
movw -0x12(%rbp), %ax
movw %ax, -0x2(%rbp)
jmp 0x182c0
movq -0x20(%rbp), %rax
movl 0x24(%rax), %eax
andl $0x100, %eax            # imm = 0x100
cmpl $0x0, %eax
jne 0x182b0
movw -0x12(%rbp), %ax
movw %ax, -0x2(%rbp)
jmp 0x182c0
movq -0x20(%rbp), %rax
movq 0x8(%rax), %rax
movw 0x20(%rax), %ax
movw %ax, -0x2(%rbp)
movw -0x2(%rbp), %ax
addq $0x20, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/MikeGray-APH[P]LibLouisAPH/source/languages/generic.h
// Function: generic_uchar_to_digit
static inline unichar generic_uchar_to_digit(const struct table *table, const unichar uchar)
{
	struct character *character;

	character = table_find_character(table, uchar);
	if(!character)
		return uchar;
	if(!(character->attrs & CHAR_NUMERIC_UCHAR))
		return uchar;

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

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movw %si, %ax
movq %rdi, -0x10(%rbp)
movw %ax, -0x12(%rbp)
movq -0x10(%rbp), %rdi
movzwl -0x12(%rbp), %esi
callq 0x2900
movq %rax, -0x20(%rbp)
cmpq $0x0, -0x20(%rbp)
jne 0x18345
movw -0x12(%rbp), %ax
movw %ax, -0x2(%rbp)
jmp 0x18370
movq -0x20(%rbp), %rax
movl 0x24(%rax), %eax
andl $0x1000, %eax           # imm = 0x1000
cmpl $0x0, %eax
jne 0x18360
movw -0x12(%rbp), %ax
movw %ax, -0x2(%rbp)
jmp 0x18370
movq -0x20(%rbp), %rax
movq 0x10(%rax), %rax
movw 0x20(%rax), %ax
movw %ax, -0x2(%rbp)
movw -0x2(%rbp), %ax
addq $0x20, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/MikeGray-APH[P]LibLouisAPH/source/languages/nemeth-forward.c
// Function: convert_nemeth_roots
static int convert_nemeth_roots(struct translate *translate)
{
	unichar levels[SEPS_MAX];
	int level_cnt;

	translate->table_crs = translate->table_cnt - 1;

	level_cnt =
	translate->input_crs =
	translate->output_len = 0;
	while(translate->input_crs < translate->input_len)
	{
		switch(translate->input[translate->input_crs])
		{

		case u'\uf5b0':/*   start root   */
		case u'\uf5b3':/*   start square root   */

			CHANGE_MARK
			if(level_cnt)
			if(!translate_insert_dots(translate, levels, level_cnt))
				return 0;
			levels[level_cnt++] = u'⠨';
			break;

		case u'\uf5b2':/*   end root   */
		case u'\uf5b4':/*   end square root   */

			CHANGE_MARK
			level_cnt--;
			if(level_cnt)
			if(!translate_insert_dots(translate, levels, level_cnt))
				return 0;
			break;

		case u'\uf5b1':/*   enter root   */
		default: ;
		}

		if(!translate_copy_to_output(translate, 1, 1))
			return 0;
	}

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

	return 1;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x1f0, %rsp            # imm = 0x1F0
movq %rdi, -0x10(%rbp)
movq -0x10(%rbp), %rax
movl 0xc(%rax), %ecx
subl $0x1, %ecx
movq -0x10(%rbp), %rax
movl %ecx, 0x8(%rax)
movq -0x10(%rbp), %rax
movl $0x0, 0x68(%rax)
movq -0x10(%rbp), %rax
movl $0x0, 0x40(%rax)
movl $0x0, -0x1e4(%rbp)
movq -0x10(%rbp), %rax
movl 0x40(%rax), %eax
movq -0x10(%rbp), %rcx
cmpl 0x44(%rcx), %eax
jge 0x18a76
movq -0x10(%rbp), %rcx
movq 0x38(%rcx), %rax
movslq 0x40(%rcx), %rcx
movzwl (%rax,%rcx,2), %eax
addl $0xffff0a50, %eax       # imm = 0xFFFF0A50
movl %eax, %ecx
movq %rcx, -0x1f0(%rbp)
subl $0x4, %eax
ja 0x18a51
movq -0x1f0(%rbp), %rax
leaq 0x6617(%rip), %rcx      # 0x1efb0
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
movq -0x10(%rbp), %rax
movl $0x1, 0x94(%rax)
cmpl $0x0, -0x1e4(%rbp)
je 0x189e2
movq -0x10(%rbp), %rdi
leaq -0x1e0(%rbp), %rsi
movl -0x1e4(%rbp), %edx
callq 0xab20
cmpl $0x0, %eax
jne 0x189e0
movl $0x0, -0x4(%rbp)
jmp 0x18a93
jmp 0x189e2
movl -0x1e4(%rbp), %eax
movl %eax, %ecx
addl $0x1, %ecx
movl %ecx, -0x1e4(%rbp)
cltq
movw $0x2828, -0x1e0(%rbp,%rax,2) # imm = 0x2828
jmp 0x18a53
movq -0x10(%rbp), %rax
movl $0x1, 0x94(%rax)
movl -0x1e4(%rbp), %eax
addl $-0x1, %eax
movl %eax, -0x1e4(%rbp)
cmpl $0x0, -0x1e4(%rbp)
je 0x18a4d
movq -0x10(%rbp), %rdi
leaq -0x1e0(%rbp), %rsi
movl -0x1e4(%rbp), %edx
callq 0xab20
cmpl $0x0, %eax
jne 0x18a4b
movl $0x0, -0x4(%rbp)
jmp 0x18a93
jmp 0x18a4d
jmp 0x18a53
jmp 0x18a51
jmp 0x18a53
movq -0x10(%rbp), %rdi
movl $0x1, %edx
movl %edx, %esi
callq 0xaeb0
cmpl $0x0, %eax
jne 0x18a71
movl $0x0, -0x4(%rbp)
jmp 0x18a93
jmp 0x18950
movq -0x10(%rbp), %rax
movq 0x60(%rax), %rax
movq -0x10(%rbp), %rcx
movslq 0x68(%rcx), %rcx
movw $0x0, (%rax,%rcx,2)
movl $0x1, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x1f0, %rsp            # imm = 0x1F0
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/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:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl %edx, -0x14(%rbp)
cmpl $0x0, -0x14(%rbp)
jle 0x1a240
cmpq $0x0, -0x10(%rbp)
jne 0x1a242
jmp 0x1a2a0
movl -0x14(%rbp), %eax
shll $0x3, %eax
movl %eax, -0x24(%rbp)
movl -0x24(%rbp), %eax
addl $0x1, %eax
movslq %eax, %rdi
callq 0x1160
movq %rax, -0x20(%rbp)
movq -0x20(%rbp), %rdi
movl -0x24(%rbp), %esi
addl $0x1, %esi
movq -0x10(%rbp), %rdx
movl -0x14(%rbp), %ecx
xorl %eax, %eax
movl %eax, %r8d
callq 0x1ab0
movq -0x8(%rbp), %rdi
movq -0x20(%rbp), %rdx
leaq 0x499d(%rip), %rsi      # 0x1ec24
movb $0x0, %al
callq 0x1130
movq -0x8(%rbp), %rdi
callq 0x1170
movq -0x20(%rbp), %rdi
callq 0x1040
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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 %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movw %si, %ax
movq %rdi, -0x8(%rbp)
movw %ax, -0xa(%rbp)
movzwl -0xa(%rbp), %eax
movl %eax, -0x28(%rbp)
addl $-0x9, %eax
subl $0x2, %eax
jb 0x1a2f4
jmp 0x1a2d4
movl -0x28(%rbp), %eax
subl $0xd, %eax
je 0x1a2f4
jmp 0x1a2de
movl -0x28(%rbp), %eax
subl $0x20, %eax
je 0x1a2f4
jmp 0x1a2e8
movl -0x28(%rbp), %eax
subl $0xa0, %eax
jne 0x1a306
jmp 0x1a2f4
movq -0x8(%rbp), %rsi
leaq 0x50e8(%rip), %rdi      # 0x1f3e7
callq 0x10f0
jmp 0x1a346
movw -0xa(%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
movq -0x8(%rbp), %rdi
leaq -0x20(%rbp), %rdx
leaq 0x48e5(%rip), %rsi      # 0x1ec24
movb $0x0, %al
callq 0x1130
movq -0x8(%rbp), %rdi
callq 0x1170
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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 %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movw %si, %ax
movq %rdi, -0x8(%rbp)
movw %ax, -0xa(%rbp)
movzwl -0xa(%rbp), %eax
movl %eax, -0x28(%rbp)
subl $0x9, %eax
je 0x1a3f6
jmp 0x1a381
movl -0x28(%rbp), %eax
subl $0xa, %eax
je 0x1a3d2
jmp 0x1a38b
movl -0x28(%rbp), %eax
subl $0xd, %eax
je 0x1a3e4
jmp 0x1a395
movl -0x28(%rbp), %eax
subl $0x20, %eax
je 0x1a3c0
jmp 0x1a39f
movl -0x28(%rbp), %eax
subl $0xa0, %eax
jne 0x1a408
jmp 0x1a3ab
movq -0x8(%rbp), %rsi
leaq 0x4c0e(%rip), %rdi      # 0x1efc4
callq 0x10f0
jmp 0x1a448
movq -0x8(%rbp), %rsi
leaq 0x4bfc(%rip), %rdi      # 0x1efc7
callq 0x10f0
jmp 0x1a448
movq -0x8(%rbp), %rsi
leaq 0x4bed(%rip), %rdi      # 0x1efca
callq 0x10f0
jmp 0x1a448
movq -0x8(%rbp), %rsi
leaq 0x4bde(%rip), %rdi      # 0x1efcd
callq 0x10f0
jmp 0x1a448
movq -0x8(%rbp), %rsi
leaq 0x4bcf(%rip), %rdi      # 0x1efd0
callq 0x10f0
jmp 0x1a448
movw -0xa(%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
movq -0x8(%rbp), %rdi
leaq -0x20(%rbp), %rdx
leaq 0x47e3(%rip), %rsi      # 0x1ec24
movb $0x0, %al
callq 0x1130
movq -0x8(%rbp), %rdi
callq 0x1170
addq $0x30, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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 %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movzwl (%rax), %esi
leaq 0x4bba(%rip), %rdi      # 0x1f034
movb $0x0, %al
callq 0x10b0
movq -0x8(%rbp), %rax
movzwl 0x2(%rax), %esi
leaq 0x4bb3(%rip), %rdi      # 0x1f043
movb $0x0, %al
callq 0x10b0
movq -0x8(%rbp), %rax
movzwl (%rax), %eax
cmpl $0x0, %eax
jle 0x1a4bf
movq -0x8(%rbp), %rax
movzwl (%rax), %eax
cmpl $0xffff, %eax           # imm = 0xFFFF
je 0x1a4bf
movq -0x8(%rbp), %rdi
movl $0x2, %esi
callq 0x1a4e0
movq 0x9b12(%rip), %rax      # 0x23fd8
movq (%rax), %rdi
callq 0x1170
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/MikeGray-APH[P]LibLouisAPH/source/outputs/pattern-output.c
// Function: attrs_output_brackets
static void attrs_output_brackets(const unichar attrs0, const unichar attrs1)
{
	int cnt, i;

	cnt = 0;
	for(i = 0; i < 16; i++)
	if(attrs0 & BIT(i))
		cnt++;
	for(i = 0; i < 16; i++)
	if(attrs1 & BIT(i))
		cnt++;

	if(cnt > 1)
		printf("[");

	for(i = 0; i < 16; i++)
	if(attrs0 & BIT(i))
		utf16_output_char_escape(stdout, attrs_chars[i]);
	for(i = 0; i < 16; i++)
	if(attrs1 & BIT(i))
		utf16_output_char_escape(stdout, attrs_chars[i + 16]);

	if(cnt > 1)
		printf("]");
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movw %si, %ax
movw %di, %cx
movw %cx, -0x2(%rbp)
movw %ax, -0x4(%rbp)
movl $0x0, -0x8(%rbp)
movl $0x0, -0xc(%rbp)
cmpl $0x10, -0xc(%rbp)
jge 0x1b16b
movzwl -0x2(%rbp), %eax
movl -0xc(%rbp), %ecx
movl $0x1, %edx
shlq %cl, %rdx
movq %rdx, %rcx
andq %rcx, %rax
cmpq $0x0, %rax
je 0x1b15e
movl -0x8(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x8(%rbp)
jmp 0x1b160
movl -0xc(%rbp), %eax
addl $0x1, %eax
movl %eax, -0xc(%rbp)
jmp 0x1b134
movl $0x0, -0xc(%rbp)
cmpl $0x10, -0xc(%rbp)
jge 0x1b1a9
movzwl -0x4(%rbp), %eax
movl -0xc(%rbp), %ecx
movl $0x1, %edx
shlq %cl, %rdx
movq %rdx, %rcx
andq %rcx, %rax
cmpq $0x0, %rax
je 0x1b19c
movl -0x8(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x8(%rbp)
jmp 0x1b19e
movl -0xc(%rbp), %eax
addl $0x1, %eax
movl %eax, -0xc(%rbp)
jmp 0x1b172
cmpl $0x1, -0x8(%rbp)
jle 0x1b1bd
leaq 0x3eab(%rip), %rdi      # 0x1f061
movb $0x0, %al
callq 0x10b0
movl $0x0, -0xc(%rbp)
cmpl $0x10, -0xc(%rbp)
jge 0x1b213
movzwl -0x2(%rbp), %eax
movl -0xc(%rbp), %ecx
movl $0x1, %edx
shlq %cl, %rdx
movq %rdx, %rcx
andq %rcx, %rax
cmpq $0x0, %rax
je 0x1b206
movq 0x8dec(%rip), %rax      # 0x23fd8
movq (%rax), %rdi
movslq -0xc(%rbp), %rcx
leaq 0x8f36(%rip), %rax      # 0x24130
movsbl (%rax,%rcx), %eax
movzwl %ax, %esi
callq 0x1a360
jmp 0x1b208
movl -0xc(%rbp), %eax
addl $0x1, %eax
movl %eax, -0xc(%rbp)
jmp 0x1b1c4
movl $0x0, -0xc(%rbp)
cmpl $0x10, -0xc(%rbp)
jge 0x1b26e
movzwl -0x4(%rbp), %eax
movl -0xc(%rbp), %ecx
movl $0x1, %edx
shlq %cl, %rdx
movq %rdx, %rcx
andq %rcx, %rax
cmpq $0x0, %rax
je 0x1b261
movq 0x8d96(%rip), %rax      # 0x23fd8
movq (%rax), %rdi
movl -0xc(%rbp), %eax
addl $0x10, %eax
movslq %eax, %rcx
leaq 0x8edb(%rip), %rax      # 0x24130
movsbl (%rax,%rcx), %eax
movzwl %ax, %esi
callq 0x1a360
jmp 0x1b263
movl -0xc(%rbp), %eax
addl $0x1, %eax
movl %eax, -0xc(%rbp)
jmp 0x1b21a
cmpl $0x1, -0x8(%rbp)
jle 0x1b282
leaq 0x413f(%rip), %rdi      # 0x1f3ba
movb $0x0, %al
callq 0x10b0
addq $0x10, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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 %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x18(%rbp), %rdi
callq 0x1b2f0
movq -0x10(%rbp), %rax
movzwl (%rax), %eax
cmpl $0x0, %eax
jle 0x1b2d9
movq -0x10(%rbp), %rax
movzwl (%rax), %eax
cmpl $0xffff, %eax           # imm = 0xFFFF
je 0x1b2d9
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
movl $0x2, %edx
callq 0x1ad40
movq -0x8(%rbp), %rdi
callq 0x1170
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/MikeGray-APH[P]LibLouisAPH/source/outputs/pattern-output.c
// Function: attrs_output
static void attrs_output(const unichar attrs0, const unichar attrs1)
{
	int i;

	for(i = 0; i < 16; i++)
	if(attrs0 & BIT(i))
		utf16_output_char_escape(stdout, attrs_chars[i]);
	for(i = 0; i < 16; i++)
	if(attrs1 & BIT(i))
		utf16_output_char_escape(stdout, attrs_chars[i + 16]);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movw %si, %ax
movw %di, %cx
movw %cx, -0x2(%rbp)
movw %ax, -0x4(%rbp)
movl $0x0, -0x8(%rbp)
cmpl $0x10, -0x8(%rbp)
jge 0x1b41c
movzwl -0x2(%rbp), %eax
movl -0x8(%rbp), %ecx
movl $0x1, %edx
shlq %cl, %rdx
movq %rdx, %rcx
andq %rcx, %rax
cmpq $0x0, %rax
je 0x1b40f
movq 0x8be3(%rip), %rax      # 0x23fd8
movq (%rax), %rdi
movslq -0x8(%rbp), %rcx
leaq 0x8d2d(%rip), %rax      # 0x24130
movsbl (%rax,%rcx), %eax
movzwl %ax, %esi
callq 0x1a360
jmp 0x1b411
movl -0x8(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x8(%rbp)
jmp 0x1b3cd
movl $0x0, -0x8(%rbp)
cmpl $0x10, -0x8(%rbp)
jge 0x1b477
movzwl -0x4(%rbp), %eax
movl -0x8(%rbp), %ecx
movl $0x1, %edx
shlq %cl, %rdx
movq %rdx, %rcx
andq %rcx, %rax
cmpq $0x0, %rax
je 0x1b46a
movq 0x8b8d(%rip), %rax      # 0x23fd8
movq (%rax), %rdi
movl -0x8(%rbp), %eax
addl $0x10, %eax
movslq %eax, %rcx
leaq 0x8cd2(%rip), %rax      # 0x24130
movsbl (%rax,%rcx), %eax
movzwl %ax, %esi
callq 0x1a360
jmp 0x1b46c
movl -0x8(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x8(%rbp)
jmp 0x1b423
addq $0x10, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/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:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
cmpq $0x0, -0x10(%rbp)
jne 0x1b49c
jmp 0x1b5ca
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rdx
leaq 0x378b(%rip), %rsi      # 0x1ec3a
movb $0x0, %al
callq 0x1130
movq -0x8(%rbp), %rsi
leaq 0x3c9d(%rip), %rdi      # 0x1f15e
callq 0x10f0
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rax
movzwl 0x210(%rax), %esi
callq 0x1a360
movq -0x8(%rbp), %rsi
leaq 0x3ceb(%rip), %rdi      # 0x1f1d0
callq 0x10f0
movq -0x8(%rbp), %rsi
leaq 0x3cdb(%rip), %rdi      # 0x1f1d0
callq 0x10f0
movw $0x2800, -0x14(%rbp)    # imm = 0x2800
movl $0x0, -0x1c(%rbp)
cmpl $0x10, -0x1c(%rbp)
jge 0x1b5c1
movl $0x0, -0x18(%rbp)
cmpl $0x10, -0x18(%rbp)
jge 0x1b5a3
movq -0x10(%rbp), %rax
movl -0x1c(%rbp), %ecx
shll $0x4, %ecx
addl -0x18(%rbp), %ecx
movslq %ecx, %rcx
movw 0x10(%rax,%rcx,2), %ax
movw %ax, -0x12(%rbp)
movzwl -0x12(%rbp), %eax
movzwl -0x14(%rbp), %ecx
cmpl %ecx, %eax
je 0x1b556
movq -0x8(%rbp), %rdi
movzwl -0x12(%rbp), %esi
callq 0x1a2b0
jmp 0x1b566
movq -0x8(%rbp), %rsi
leaq 0x3e86(%rip), %rdi      # 0x1f3e7
callq 0x10f0
movq -0x8(%rbp), %rdi
movzwl -0x14(%rbp), %esi
callq 0x1a2b0
cmpl $0xf, -0x18(%rbp)
je 0x1b589
movq -0x8(%rbp), %rsi
leaq 0x3e63(%rip), %rdi      # 0x1f3e7
callq 0x10f0
movw -0x14(%rbp), %ax
addw $0x1, %ax
movw %ax, -0x14(%rbp)
movl -0x18(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x18(%rbp)
jmp 0x1b518
movq -0x8(%rbp), %rsi
leaq 0x3c22(%rip), %rdi      # 0x1f1d0
callq 0x10f0
movl -0x1c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x1c(%rbp)
jmp 0x1b507
movq -0x8(%rbp), %rdi
callq 0x1170
addq $0x20, %rsp
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O0/MikeGray-APH[P]LibLouisAPH/source/outputs/table-output.c
// Function: process_output
static void process_output(FILE *output, const enum table_process_type process)
{
	fputs("process:  ", output);
	switch(process)
	{
	case PROCESS_GENERIC:     fputs("generic\n", output);     break;
	case PROCESS_NEMETH_UEB:  fputs("nemeth-ueb\n", output);  break;
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movq -0x8(%rbp), %rsi
leaq 0x381c(%rip), %rdi      # 0x1f386
callq 0x10f0
movl -0xc(%rbp), %eax
movl %eax, -0x10(%rbp)
testl %eax, %eax
je 0x1bb85
jmp 0x1bb7b
movl -0x10(%rbp), %eax
subl $0x1, %eax
je 0x1bb97
jmp 0x1bba7
movq -0x8(%rbp), %rsi
leaq 0x3801(%rip), %rdi      # 0x1f391
callq 0x10f0
jmp 0x1bba7
movq -0x8(%rbp), %rsi
leaq 0x37f8(%rip), %rdi      # 0x1f39a
callq 0x10f0
addq $0x10, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/MikeGray-APH[P]LibLouisAPH/source/outputs/table-output.c
// Function: character_output_all
static void character_output_all(FILE *output, const struct table *table)
{
	struct character *character;
	int i;

	for(i = 0; i < TABLE_UNICHAR_HASH_SIZE; i++)
	{
		character = table->character_hash[i];
		while(character)
		{
			character_output(output, character);
			character = character->nxt;
		}
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl $0x0, -0x1c(%rbp)
cmpl $0x10, -0x1c(%rbp)
jge 0x1bc0f
movq -0x10(%rbp), %rax
movslq -0x1c(%rbp), %rcx
movq 0x1f8(%rax,%rcx,8), %rax
movq %rax, -0x18(%rbp)
cmpq $0x0, -0x18(%rbp)
je 0x1bc02
movq -0x8(%rbp), %rdi
movq -0x18(%rbp), %rsi
callq 0x1c780
movq -0x18(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x18(%rbp)
jmp 0x1bbe1
jmp 0x1bc04
movl -0x1c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x1c(%rbp)
jmp 0x1bbc7
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: character_hash_output
static void character_hash_output(FILE *output, const struct table *table)
{
	struct character *character;
	int i, cnt, most;

	most = 0;
	for(i = 0; i < TABLE_UNICHAR_HASH_SIZE; i++)
	if(table->character_hash[i])
	{
		fprintf(output, "[%5d]", i);
		character = table->character_hash[i];
		cnt = 0;
		while(character)
		{
			cnt++;

			fputs(" ", output);
			if(is_space(character->uchar))
				fputs(" ", output);
			else
				utf16_output_char_escape(output, character->uchar);
			character = character->nxt;
		}
		fputs("\n", output);

		if(cnt > most)
			most = cnt;
	}
	fprintf(output, "most = %d\n", most);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl $0x0, -0x24(%rbp)
movl $0x0, -0x1c(%rbp)
cmpl $0x10, -0x1c(%rbp)
jge 0x1bd21
movq -0x10(%rbp), %rax
movslq -0x1c(%rbp), %rcx
cmpq $0x0, 0x1f8(%rax,%rcx,8)
je 0x1bd11
movq -0x8(%rbp), %rdi
movl -0x1c(%rbp), %edx
leaq 0x3749(%rip), %rsi      # 0x1f3b6
movb $0x0, %al
callq 0x1130
movq -0x10(%rbp), %rax
movslq -0x1c(%rbp), %rcx
movq 0x1f8(%rax,%rcx,8), %rax
movq %rax, -0x18(%rbp)
movl $0x0, -0x20(%rbp)
cmpq $0x0, -0x18(%rbp)
je 0x1bcf1
movl -0x20(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x20(%rbp)
movq -0x8(%rbp), %rsi
leaq 0x373d(%rip), %rdi      # 0x1f3e7
callq 0x10f0
movq -0x18(%rbp), %rax
movzwl 0x20(%rax), %edi
callq 0x1c870
cmpl $0x0, %eax
je 0x1bcd3
movq -0x8(%rbp), %rsi
leaq 0x371b(%rip), %rdi      # 0x1f3e7
callq 0x10f0
jmp 0x1bce4
movq -0x8(%rbp), %rdi
movq -0x18(%rbp), %rax
movzwl 0x20(%rax), %esi
callq 0x1a360
movq -0x18(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x18(%rbp)
jmp 0x1bc8f
movq -0x8(%rbp), %rsi
leaq 0x34d4(%rip), %rdi      # 0x1f1d0
callq 0x10f0
movl -0x20(%rbp), %eax
cmpl -0x24(%rbp), %eax
jle 0x1bd0f
movl -0x20(%rbp), %eax
movl %eax, -0x24(%rbp)
jmp 0x1bd11
jmp 0x1bd13
movl -0x1c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x1c(%rbp)
jmp 0x1bc3e
movq -0x8(%rbp), %rdi
movl -0x24(%rbp), %edx
leaq 0x368d(%rip), %rsi      # 0x1f3bc
movb $0x0, %al
callq 0x1130
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/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:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
cmpq $0x0, -0x10(%rbp)
jne 0x1c08c
jmp 0x1c17b
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rax
movq (%rax), %rsi
callq 0x1c070
movq -0x8(%rbp), %rsi
leaq 0x333e(%rip), %rdi      # 0x1f3e5
callq 0x10f0
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rsi
movq -0x10(%rbp), %rax
movl 0x20(%rax), %edx
callq 0x1a220
movq -0x8(%rbp), %rsi
leaq 0x3316(%rip), %rdi      # 0x1f3e5
callq 0x10f0
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rax
movq 0x18(%rax), %rsi
movq -0x10(%rbp), %rax
movl 0x28(%rax), %edx
callq 0x1a220
movl $0x0, -0x14(%rbp)
movl -0x14(%rbp), %eax
movq -0x10(%rbp), %rcx
cmpl 0x28(%rcx), %eax
jge 0x1c16b
movq -0x10(%rbp), %rax
movq 0x18(%rax), %rax
movslq -0x14(%rbp), %rcx
movzwl (%rax,%rcx,2), %eax
cmpl $0x5c, %eax
jne 0x1c11f
movl -0x14(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x14(%rbp)
jmp 0x1c160
movq -0x10(%rbp), %rax
movq 0x18(%rax), %rax
movslq -0x14(%rbp), %rcx
movzwl (%rax,%rcx,2), %eax
cmpl $0x40, %eax
jne 0x1c15e
movq -0x8(%rbp), %rsi
leaq 0x32a6(%rip), %rdi      # 0x1f3e5
callq 0x10f0
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rax
movq 0x10(%rax), %rsi
leaq 0xa129(%rip), %rdx      # 0x26280
callq 0x1b290
jmp 0x1c16b
jmp 0x1c160
movl -0x14(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x14(%rbp)
jmp 0x1c0f3
movq -0x8(%rbp), %rsi
leaq 0x305a(%rip), %rdi      # 0x1f1d0
callq 0x10f0
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: 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:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
cmpq $0x0, -0x10(%rbp)
jne 0x1c1ac
jmp 0x1c29b
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rax
movq (%rax), %rsi
callq 0x1c190
movq -0x8(%rbp), %rsi
leaq 0x321e(%rip), %rdi      # 0x1f3e5
callq 0x10f0
movq -0x10(%rbp), %rax
cmpq $0x0, 0x20(%rax)
je 0x1c1f1
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rax
movq 0x20(%rax), %rsi
movq -0x10(%rbp), %rax
movl 0x28(%rax), %edx
callq 0x1a220
jmp 0x1c201
movq -0x8(%rbp), %rsi
leaq 0x31d9(%rip), %rdi      # 0x1f3d5
callq 0x10f0
movq -0x8(%rbp), %rsi
leaq 0x31d9(%rip), %rdi      # 0x1f3e5
callq 0x10f0
movq -0x10(%rbp), %rax
cmpq $0x0, 0x8(%rax)
je 0x1c236
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rsi
movq -0x10(%rbp), %rax
movl 0x18(%rax), %edx
callq 0x1c8d0
jmp 0x1c246
movq -0x8(%rbp), %rsi
leaq 0x3197(%rip), %rdi      # 0x1f3d8
callq 0x10f0
movq -0x8(%rbp), %rsi
leaq 0x3194(%rip), %rdi      # 0x1f3e5
callq 0x10f0
movq -0x10(%rbp), %rax
cmpq $0x0, 0x10(%rax)
je 0x1c27b
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rax
movq 0x10(%rax), %rsi
leaq 0xa00c(%rip), %rdx      # 0x26280
callq 0x1b290
jmp 0x1c28b
movq -0x8(%rbp), %rsi
leaq 0x3152(%rip), %rdi      # 0x1f3d8
callq 0x10f0
movq -0x8(%rbp), %rsi
leaq 0x2f3a(%rip), %rdi      # 0x1f1d0
callq 0x10f0
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)