LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O0/BernardTatin[P]s7sh/repl.c
// Function: load_scm
static int load_scm(s7_scheme *sc, const char *file_name) {
    int ret_value = SUCCESS;

    if (!is_quiet) {
        fprintf(stdout, "loading %s...\n", file_name);
    }
    if (!s7_load(sc, file_name)) {
        fprintf(stderr, "Cannot load %s\n", file_name);
        ret_value = FAILURE;
    }
    return ret_value;
}

// Assembly:
subq $0x18, %rsp
movq %rdi, 0x10(%rsp)
movq %rsi, 0x8(%rsp)
movl $0x0, 0x4(%rsp)
testb $0x1, 0x49894(%rip)     # 0x225411
jne 0x1dbb9c
movq 0x3944a(%rip), %rax     # 0x214fd0
movq (%rax), %rdi
movq 0x8(%rsp), %rdx
leaq 0x188c4(%rip), %rsi     # 0x1f4459
movb $0x0, %al
callq 0x9390
movq 0x10(%rsp), %rdi
movq 0x8(%rsp), %rsi
callq 0x29f70
cmpq $0x0, %rax
jne 0x1dbbd6
movq 0x39440(%rip), %rax     # 0x214ff8
movq (%rax), %rdi
movq 0x8(%rsp), %rdx
leaq 0x18808(%rip), %rsi     # 0x1f43cf
movb $0x0, %al
callq 0x9390
movl $0x1, 0x4(%rsp)
movl 0x4(%rsp), %eax
addq $0x18, %rsp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/BernardTatin[P]s7sh/repl.c
// Function: concat
static char *concat(char *s1, char *s2) {
    int len1 = strlen(s1);
    int len2 = strlen(s2);
    char *ret_str = (char *)calloc(len1 + len2 + 2, 1);
    char *ptr = ret_str;

    strcpy(ptr, s1);
    ptr += len1;
    *(ptr++) = '/';
    strcpy(ptr, s2);
    return ret_str;
}

// Assembly:
subq $0x28, %rsp
movq %rdi, 0x20(%rsp)
movq %rsi, 0x18(%rsp)
movq 0x20(%rsp), %rdi
callq 0x91a0
movl %eax, 0x14(%rsp)
movq 0x18(%rsp), %rdi
callq 0x91a0
movl %eax, 0x10(%rsp)
movl 0x14(%rsp), %eax
addl 0x10(%rsp), %eax
addl $0x2, %eax
movslq %eax, %rdi
movl $0x1, %esi
callq 0x9360
movq %rax, 0x8(%rsp)
movq 0x8(%rsp), %rax
movq %rax, (%rsp)
movq (%rsp), %rdi
movq 0x20(%rsp), %rsi
callq 0x90d0
movl 0x14(%rsp), %ecx
movq (%rsp), %rax
movslq %ecx, %rcx
addq %rcx, %rax
movq %rax, (%rsp)
movq (%rsp), %rax
movq %rax, %rcx
addq $0x1, %rcx
movq %rcx, (%rsp)
movb $0x2f, (%rax)
movq (%rsp), %rdi
movq 0x18(%rsp), %rsi
callq 0x90d0
movq 0x8(%rsp), %rax
addq $0x28, %rsp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/BernardTatin[P]s7sh/repl.c
// Function: set_scm_environment
static void set_scm_environment(s7_scheme *sc) {
    set_scm_env_var(sc, "*home*", "HOME");
    set_scm_env_var(sc, "*base-path*", "PATH");
    set_scm_env_var(sc, "*editor*", "EDITOR");
    set_scm_env_var(sc, "*user*", "USER");
}

// Assembly:
pushq %rax
movq %rdi, (%rsp)
movq (%rsp), %rdi
leaq 0x18737(%rip), %rsi     # 0x1f4407
leaq 0x12623(%rip), %rdx     # 0x1ee2fa
callq 0x1dbf90
movq (%rsp), %rdi
leaq 0x18727(%rip), %rsi     # 0x1f440e
leaq 0x1872c(%rip), %rdx     # 0x1f441a
callq 0x1dbf90
movq (%rsp), %rdi
leaq 0x18721(%rip), %rsi     # 0x1f441f
leaq 0x18723(%rip), %rdx     # 0x1f4428
callq 0x1dbf90
movq (%rsp), %rdi
leaq 0x1871a(%rip), %rsi     # 0x1f442f
leaq 0x1871a(%rip), %rdx     # 0x1f4436
callq 0x1dbf90
popq %rax
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/BernardTatin[P]s7sh/repl.c
// Function: ensure_user_conf_exists
static int ensure_user_conf_exists(void) {
    int ret_value = SUCCESS;

    sprintf(s7_user_conf_name, "%s/%s", getenv("HOME"), S7_USER_CONFIG);
    // TODO: remove this bad hack !!!!
    ui_scm_lib[0] = s7_user_conf_name;
    FILE *s7_config_file = fopen(s7_user_conf_name, "r");
    if (s7_config_file == NULL) {
        s7_config_file = fopen(s7_user_conf_name, "w");
        if (s7_config_file != NULL) {
            fprintf(s7_config_file, ";; %s - created on %s - %s\n\n",
                    s7_user_conf_name, __DATE__, __TIME__);
            fprintf(s7_config_file, "(format #t \"%s loaded !!!~%% \")",
                    S7_USER_CONFIG);
        } else {
            ret_value = FAILURE;
        }
    }
    if (s7_config_file != NULL) {
        fclose(s7_config_file);
    }
    return ret_value;
}

// Assembly:
subq $0x18, %rsp
movl $0x0, 0x14(%rsp)
leaq 0x12597(%rip), %rdi     # 0x1ee2fa
callq 0x9030
movq %rax, %rdx
leaq 0x4949e(%rip), %rdi     # 0x225210
leaq 0x18714(%rip), %rsi     # 0x1f448d
leaq 0x18713(%rip), %rcx     # 0x1f4493
movb $0x0, %al
callq 0x9640
leaq 0x49482(%rip), %rax     # 0x225210
movq %rax, 0x3a4cb(%rip)     # 0x216260
leaq 0x49474(%rip), %rdi     # 0x225210
leaq 0x166ca(%rip), %rsi     # 0x1f246d
callq 0x95b0
movq %rax, 0x8(%rsp)
cmpq $0x0, 0x8(%rsp)
jne 0x1dbe23
leaq 0x49454(%rip), %rdi     # 0x225210
leaq 0x18012(%rip), %rsi     # 0x1f3dd5
callq 0x95b0
movq %rax, 0x8(%rsp)
cmpq $0x0, 0x8(%rsp)
je 0x1dbe19
movq 0x8(%rsp), %rdi
leaq 0x186bc(%rip), %rsi     # 0x1f449d
leaq 0x49428(%rip), %rdx     # 0x225210
leaq 0x186cb(%rip), %rcx     # 0x1f44ba
leaq 0x186d0(%rip), %r8      # 0x1f44c6
movb $0x0, %al
callq 0x9390
movq 0x8(%rsp), %rdi
leaq 0x186c6(%rip), %rsi     # 0x1f44cf
leaq 0x18683(%rip), %rdx     # 0x1f4493
movb $0x0, %al
callq 0x9390
jmp 0x1dbe21
movl $0x1, 0x14(%rsp)
jmp 0x1dbe23
cmpq $0x0, 0x8(%rsp)
je 0x1dbe35
movq 0x8(%rsp), %rdi
callq 0x9180
movl 0x14(%rsp), %eax
addq $0x18, %rsp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/BernardTatin[P]s7sh/repl.c
// Function: clean_on_exit
static void clean_on_exit(void ) {
    if (s7_libs != NULL) {
        free(s7_libs);
        s7_libs = NULL;
    }
    if (s7_home != NULL) {
        free(s7_home);
        s7_home = NULL;
    }
}

// Assembly:
pushq %rax
cmpq $0x0, 0x49577(%rip)     # 0x225420
je 0x1dbec2
movq 0x4956e(%rip), %rdi     # 0x225420
callq 0x9050
movq $0x0, 0x4955e(%rip) # 0x225420
cmpq $0x0, 0x4954e(%rip)     # 0x225418
je 0x1dbee3
movq 0x49545(%rip), %rdi     # 0x225418
callq 0x9050
movq $0x0, 0x49535(%rip) # 0x225418
popq %rax
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/BernardTatin[P]s7sh/repl.c
// Function: Cbool_to_Sbool
static inline char *Cbool_to_Sbool(const bool b) {
    if (b) {
        return strue;
    } else {
        return sfalse;
    }
}

// Assembly:
movb %dil, %al
andb $0x1, %al
movb %al, -0x9(%rsp)
testb $0x1, -0x9(%rsp)
je 0x1dbf7e
movq 0x3a2a9(%rip), %rax     # 0x216220
movq %rax, -0x8(%rsp)
jmp 0x1dbf8a
movq 0x3a2a3(%rip), %rax     # 0x216228
movq %rax, -0x8(%rsp)
movq -0x8(%rsp), %rax
retq
// File: /workspace/github_c_makefile_star2_O0/BernardTatin[P]s7sh/repl.c
// Function: autoload_scm_files
static int autoload_scm_files(s7_scheme *sc, char *scm_files[]) {
    int ret_value = SUCCESS;

    for (int k=0; ret_value == SUCCESS && scm_files[k] != NULL; k++) {
        ret_value = autoload_scm(sc, scm_files[k]);
    }
    return ret_value;
}

// Assembly:
subq $0x28, %rsp
movq %rdi, 0x20(%rsp)
movq %rsi, 0x18(%rsp)
movl $0x0, 0x14(%rsp)
movl $0x0, 0x10(%rsp)
xorl %eax, %eax
cmpl $0x0, 0x14(%rsp)
movb %al, 0xf(%rsp)
jne 0x1dc031
movq 0x18(%rsp), %rax
movslq 0x10(%rsp), %rcx
cmpq $0x0, (%rax,%rcx,8)
setne %al
movb %al, 0xf(%rsp)
movb 0xf(%rsp), %al
testb $0x1, %al
jne 0x1dc03b
jmp 0x1dc064
movq 0x20(%rsp), %rdi
movq 0x18(%rsp), %rax
movslq 0x10(%rsp), %rcx
movq (%rax,%rcx,8), %rsi
callq 0x1dc070
movl %eax, 0x14(%rsp)
movl 0x10(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x10(%rsp)
jmp 0x1dc00e
movl 0x14(%rsp), %eax
addq $0x28, %rsp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/BernardTatin[P]s7sh/repl.c
// Function: autoload_scm
static int autoload_scm(s7_scheme *sc, char *file_name) {
    // TODO: verify memory leaks
    // function basename is not clear
    char *file_name_2 = strdup(file_name);
    char *symbol = basename(file_name_2);
    int ret_value = SUCCESS;

    if (!is_quiet) {
        fprintf(stdout, "autoloading %s...\n", file_name);
    }
    sprintf(scm_code_buffer, "(autoload '%s \"%s\")", symbol, file_name);
    s7_eval_c_string(sc, scm_code_buffer);
    free(file_name_2);
    return ret_value;
}

// Assembly:
subq $0x28, %rsp
movq %rdi, 0x20(%rsp)
movq %rsi, 0x18(%rsp)
movq 0x18(%rsp), %rdi
callq 0x96a0
movq %rax, 0x10(%rsp)
movq 0x10(%rsp), %rdi
callq 0x9400
movq %rax, 0x8(%rsp)
movl $0x0, 0x4(%rsp)
testb $0x1, 0x49366(%rip)     # 0x225411
jne 0x1dc0ca
movq 0x38f1c(%rip), %rax     # 0x214fd0
movq (%rax), %rdi
movq 0x18(%rsp), %rdx
leaq 0x18392(%rip), %rsi     # 0x1f4455
movb $0x0, %al
callq 0x9390
movq 0x8(%rsp), %rdx
movq 0x18(%rsp), %rcx
leaq 0x49355(%rip), %rdi     # 0x225430
leaq 0x18386(%rip), %rsi     # 0x1f4468
movb $0x0, %al
callq 0x9640
movq 0x20(%rsp), %rdi
leaq 0x4933b(%rip), %rsi     # 0x225430
callq 0x2b910
movq 0x10(%rsp), %rdi
callq 0x9050
movl 0x4(%rsp), %eax
addq $0x28, %rsp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/BernardTatin[P]s7sh/repl.c
// Function: load_scm_files
static int load_scm_files(s7_scheme *sc, char *scm_files[]) {
    int ret_value = SUCCESS;

    for (int k=0; ret_value == SUCCESS && scm_files[k] != NULL; k++) {
        ret_value = load_scm(sc, scm_files[k]);
    }
    return ret_value;
}

// Assembly:
subq $0x28, %rsp
movq %rdi, 0x20(%rsp)
movq %rsi, 0x18(%rsp)
movl $0x0, 0x14(%rsp)
movl $0x0, 0x10(%rsp)
xorl %eax, %eax
cmpl $0x0, 0x14(%rsp)
movb %al, 0xf(%rsp)
jne 0x1dc151
movq 0x18(%rsp), %rax
movslq 0x10(%rsp), %rcx
cmpq $0x0, (%rax,%rcx,8)
setne %al
movb %al, 0xf(%rsp)
movb 0xf(%rsp), %al
testb $0x1, %al
jne 0x1dc15b
jmp 0x1dc184
movq 0x20(%rsp), %rdi
movq 0x18(%rsp), %rax
movslq 0x10(%rsp), %rcx
movq (%rax,%rcx,8), %rsi
callq 0x1dbb60
movl %eax, 0x14(%rsp)
movl 0x10(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x10(%rsp)
jmp 0x1dc12e
movl 0x14(%rsp), %eax
addq $0x28, %rsp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/MikeGray-APH[P]LibLouisAPH/source/utf-convert.c
// Function: utf16_convert_to_int
int utf16_convert_to_int(unichar *uchars, const int uchars_len)
{
	char cchars[0x100];
	int len, i;

	len = uchars_len;
	if(uchars_len >= 0xff)
		len = 0xff;

	/*   simple conversion   */
	for(i = 0; i < len; i++)
		cchars[i] = (char)uchars[i];
	cchars[i] = 0;

	return strtol(cchars, NULL, 0);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x120, %rsp            # imm = 0x120
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movl -0xc(%rbp), %eax
movl %eax, -0x114(%rbp)
cmpl $0xff, -0xc(%rbp)
jl 0x12ce
movl $0xff, -0x114(%rbp)
movl $0x0, -0x118(%rbp)
movl -0x118(%rbp), %eax
cmpl -0x114(%rbp), %eax
jge 0x1316
movq -0x8(%rbp), %rax
movslq -0x118(%rbp), %rcx
movw (%rax,%rcx,2), %ax
movb %al, %cl
movslq -0x118(%rbp), %rax
movb %cl, -0x110(%rbp,%rax)
movl -0x118(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x118(%rbp)
jmp 0x12d8
movslq -0x118(%rbp), %rax
movb $0x0, -0x110(%rbp,%rax)
leaq -0x110(%rbp), %rdi
xorl %eax, %eax
movl %eax, %esi
xorl %edx, %edx
callq 0x1140
addq $0x120, %rsp            # imm = 0x120
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O0/MikeGray-APH[P]LibLouisAPH/source/table.c
// Function: character_free
void character_free(struct character *character)
{
	if(!character)
		return;

	character_free(character->nxt);
	FREE(character);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
cmpq $0x0, -0x8(%rbp)
jne 0x25a5
jmp 0x25ba
movq -0x8(%rbp), %rax
movq (%rax), %rdi
callq 0x2590
movq -0x8(%rbp), %rdi
callq 0x1040
addq $0x10, %rsp
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O0/MikeGray-APH[P]LibLouisAPH/source/table.c
// Function: rule_free_backward
void rule_free_backward(struct rule *rule)
{
	struct rule *nxt;

	if(!rule)
		return;

	while(rule->dots_nxt)
	{
		if(rule->dots_nxt->direction != BACKWARD)
			break;

		nxt = rule->dots_nxt;
		rule->dots_nxt = nxt->dots_nxt;
		nxt->chars_nxt = NULL;
		rule_free(nxt);
	}

	rule_free_backward(rule->dots_nxt);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
cmpq $0x0, -0x8(%rbp)
jne 0x25d5
jmp 0x2632
jmp 0x25d7
movq -0x8(%rbp), %rax
cmpq $0x0, 0x10(%rax)
je 0x2625
movq -0x8(%rbp), %rax
movq 0x10(%rax), %rax
cmpl $-0x1, 0x4(%rax)
je 0x25f2
jmp 0x2625
movq -0x8(%rbp), %rax
movq 0x10(%rax), %rax
movq %rax, -0x10(%rbp)
movq -0x10(%rbp), %rax
movq 0x10(%rax), %rcx
movq -0x8(%rbp), %rax
movq %rcx, 0x10(%rax)
movq -0x10(%rbp), %rax
movq $0x0, 0x8(%rax)
movq -0x10(%rbp), %rdi
callq 0x2640
jmp 0x25d7
movq -0x8(%rbp), %rax
movq 0x10(%rax), %rdi
callq 0x25c0
addq $0x10, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/MikeGray-APH[P]LibLouisAPH/source/table.c
// Function: rule_free
void rule_free(struct rule *rule)
{
	if(!rule)
		return;

	rule_free(rule->chars_nxt);

	if(rule->filter_forward)
	if(!rule->filter_forward->name)
	{
		ASSERT(!rule->filter_forward->nxt)
		filter_free(rule->filter_forward);
	}
	if(rule->filter_backward)
	if(!rule->filter_backward->name)
	{
		ASSERT(!rule->filter_backward->nxt)
		filter_free(rule->filter_backward);
	}

	FREE(rule);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
cmpq $0x0, -0x8(%rbp)
jne 0x2658
jmp 0x26fe
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rdi
callq 0x2640
movq -0x8(%rbp), %rax
cmpq $0x0, 0x80(%rax)
je 0x26ad
movq -0x8(%rbp), %rax
movq 0x80(%rax), %rax
cmpq $0x0, 0x20(%rax)
jne 0x26ab
movq -0x8(%rbp), %rax
movq 0x80(%rax), %rax
cmpq $0x0, (%rax)
je 0x269b
callq 0x1050
movq -0x8(%rbp), %rax
movq 0x80(%rax), %rdi
callq 0x2760
jmp 0x26ad
movq -0x8(%rbp), %rax
cmpq $0x0, 0x88(%rax)
je 0x26f5
movq -0x8(%rbp), %rax
movq 0x88(%rax), %rax
cmpq $0x0, 0x20(%rax)
jne 0x26f3
movq -0x8(%rbp), %rax
movq 0x88(%rax), %rax
cmpq $0x0, (%rax)
je 0x26e3
callq 0x1050
movq -0x8(%rbp), %rax
movq 0x88(%rax), %rdi
callq 0x2760
jmp 0x26f5
movq -0x8(%rbp), %rdi
callq 0x1040
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/MikeGray-APH[P]LibLouisAPH/source/table.c
// Function: mode_free
void mode_free(struct mode *mode)
{
	if(!mode)
		return;

	mode_free(mode->nxt);
	ASSERT(mode->name)
	FREE(mode->name);
	FREE(mode);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
cmpq $0x0, -0x8(%rbp)
jne 0x2725
jmp 0x2757
movq -0x8(%rbp), %rax
movq (%rax), %rdi
callq 0x2710
movq -0x8(%rbp), %rax
cmpq $0x0, 0x70(%rax)
jne 0x2741
callq 0x1050
movq -0x8(%rbp), %rax
movq 0x70(%rax), %rdi
callq 0x1040
movq -0x8(%rbp), %rdi
callq 0x1040
addq $0x10, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/MikeGray-APH[P]LibLouisAPH/source/table.c
// Function: filter_free
void filter_free(struct filter *filter)
{
	if(!filter)
		return;

	filter_free(filter->nxt);
	if(filter->before)
		FREE(filter->before);
	if(filter->after)
		FREE(filter->after);
	if(filter->name)
		FREE(filter->name);
	FREE(filter);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
cmpq $0x0, -0x8(%rbp)
jne 0x2775
jmp 0x27d2
movq -0x8(%rbp), %rax
movq (%rax), %rdi
callq 0x2760
movq -0x8(%rbp), %rax
cmpq $0x0, 0x8(%rax)
je 0x2799
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rdi
callq 0x1040
movq -0x8(%rbp), %rax
cmpq $0x0, 0x10(%rax)
je 0x27b1
movq -0x8(%rbp), %rax
movq 0x10(%rax), %rdi
callq 0x1040
movq -0x8(%rbp), %rax
cmpq $0x0, 0x20(%rax)
je 0x27c9
movq -0x8(%rbp), %rax
movq 0x20(%rax), %rdi
callq 0x1040
movq -0x8(%rbp), %rdi
callq 0x1040
addq $0x10, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/MikeGray-APH[P]LibLouisAPH/source/table.c
// Function: table_allocate
table* table_allocate(void)
{
	struct table *table;

	table = MALLOC(sizeof(struct table));
	LOG_ALLOCATE_FAIL_RETURN_NULL(table)
	table_init(table);
	return table;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movl $0x320, %edi            # imm = 0x320
callq 0x1160
movq %rax, -0x10(%rbp)
cmpq $0x0, -0x10(%rbp)
jne 0x2826
movl $0x7, %edi
leaq 0x1ba6f(%rip), %rsi     # 0x1e278
leaq 0x1ba88(%rip), %rdx     # 0x1e298
movl $0xeb, %ecx
movb $0x0, %al
callq 0xf610
movq $0x0, -0x8(%rbp)
jmp 0x2837
movq -0x10(%rbp), %rdi
callq 0x1ef0
movq -0x10(%rbp), %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/MikeGray-APH[P]LibLouisAPH/source/table.c
// Function: table_free
void table_free(struct table *table)
{
	if(!table)
		return;

	table_free(table->nxt);
	table_fini(table);
	FREE(table);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
cmpq $0x0, -0x8(%rbp)
jne 0x2865
jmp 0x2883
movq -0x8(%rbp), %rax
movq (%rax), %rdi
callq 0x2850
movq -0x8(%rbp), %rdi
callq 0x1f30
movq -0x8(%rbp), %rdi
callq 0x1040
addq $0x10, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/MikeGray-APH[P]LibLouisAPH/source/table.c
// Function: character_allocate
character* character_allocate(void)
{
	struct character *character;

	character = MALLOC(sizeof(struct character));
	LOG_ALLOCATE_FAIL_RETURN_NULL(character)
	memset(character, 0, sizeof(struct character));
	return character;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movl $0x28, %edi
callq 0x1160
movq %rax, -0x10(%rbp)
cmpq $0x0, -0x10(%rbp)
jne 0x28d6
movl $0x7, %edi
leaq 0x1b9bf(%rip), %rsi     # 0x1e278
leaq 0x1b9d8(%rip), %rdx     # 0x1e298
movl $0x109, %ecx            # imm = 0x109
movb $0x0, %al
callq 0xf610
movq $0x0, -0x8(%rbp)
jmp 0x28ee
movq -0x10(%rbp), %rdi
xorl %esi, %esi
movl $0x28, %edx
callq 0x1100
movq -0x10(%rbp), %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x10, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/MikeGray-APH[P]LibLouisAPH/source/table.c
// Function: table_find_character
struct character* table_find_character(const struct table *table, const unichar uchar)
{
	struct character *character;
	int hash;

	hash = uchar_get_hash(uchar, TABLE_UNICHAR_HASH_SIZE);
	character = table->character_hash[hash];

	while(character)
	if(character->uchar == uchar)
		break;
	else
		character = character->nxt;

	return character;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movw %si, %ax
movq %rdi, -0x8(%rbp)
movw %ax, -0xa(%rbp)
movl $0x10, %esi
movzwl -0xa(%rbp), %edi
callq 0x2970
movl %eax, -0x1c(%rbp)
movq -0x8(%rbp), %rax
movslq -0x1c(%rbp), %rcx
movq 0x1f8(%rax,%rcx,8), %rax
movq %rax, -0x18(%rbp)
cmpq $0x0, -0x18(%rbp)
je 0x295e
movq -0x18(%rbp), %rax
movzwl 0x20(%rax), %eax
movzwl -0xa(%rbp), %ecx
cmpl %ecx, %eax
jne 0x2951
jmp 0x295e
movq -0x18(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x18(%rbp)
jmp 0x2938
movq -0x18(%rbp), %rax
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/MikeGray-APH[P]LibLouisAPH/source/table.c
// Function: table_find_or_add_character
struct character* table_find_or_add_character(struct table *table, const unichar uchar)
{
	struct character *character;
	int hash;

	hash = uchar_get_hash(uchar, TABLE_UNICHAR_HASH_SIZE);
	if(!table->character_hash[hash])
		table->character_hash[hash] =
		character = character_allocate();
	else
	{
		character = table->character_hash[hash];

		/*   find end of list, checking for match
		     along the way   */
		while(character->nxt)
		if(character->uchar == uchar)
			return character;
		else
			character = character->nxt;
		if(character->uchar == uchar)
			return character;

		character->nxt = character_allocate();
		character = character->nxt;
	}

	character->uchar = uchar;
	return character;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movw %si, %ax
movq %rdi, -0x10(%rbp)
movw %ax, -0x12(%rbp)
movl $0x10, %esi
movzwl -0x12(%rbp), %edi
callq 0x2970
movl %eax, -0x24(%rbp)
movq -0x10(%rbp), %rax
movslq -0x24(%rbp), %rcx
cmpq $0x0, 0x1f8(%rax,%rcx,8)
jne 0x29e5
callq 0x2890
movq %rax, %rdx
movq %rdx, -0x20(%rbp)
movq -0x10(%rbp), %rax
movslq -0x24(%rbp), %rcx
movq %rdx, 0x1f8(%rax,%rcx,8)
jmp 0x2a5e
movq -0x10(%rbp), %rax
movslq -0x24(%rbp), %rcx
movq 0x1f8(%rax,%rcx,8), %rax
movq %rax, -0x20(%rbp)
movq -0x20(%rbp), %rax
cmpq $0x0, (%rax)
je 0x2a2a
movq -0x20(%rbp), %rax
movzwl 0x20(%rax), %eax
movzwl -0x12(%rbp), %ecx
cmpl %ecx, %eax
jne 0x2a1d
movq -0x20(%rbp), %rax
movq %rax, -0x8(%rbp)
jmp 0x2a72
movq -0x20(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x20(%rbp)
jmp 0x29f9
movq -0x20(%rbp), %rax
movzwl 0x20(%rax), %eax
movzwl -0x12(%rbp), %ecx
cmpl %ecx, %eax
jne 0x2a44
movq -0x20(%rbp), %rax
movq %rax, -0x8(%rbp)
jmp 0x2a72
callq 0x2890
movq %rax, %rcx
movq -0x20(%rbp), %rax
movq %rcx, (%rax)
movq -0x20(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x20(%rbp)
movw -0x12(%rbp), %cx
movq -0x20(%rbp), %rax
movw %cx, 0x20(%rax)
movq -0x20(%rbp), %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/MikeGray-APH[P]LibLouisAPH/source/table.c
// Function: mode_allocate
mode* mode_allocate(void)
{
	struct mode *mode;

	mode = MALLOC(sizeof(struct mode));
	LOG_ALLOCATE_FAIL_RETURN_NULL(mode)
	memset(mode, 0, sizeof(struct mode));
	return mode;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movl $0x80, %edi
callq 0x1160
movq %rax, -0x10(%rbp)
cmpq $0x0, -0x10(%rbp)
jne 0x2ac6
movl $0x7, %edi
leaq 0x1b7cf(%rip), %rsi     # 0x1e278
leaq 0x1b7e8(%rip), %rdx     # 0x1e298
movl $0x151, %ecx            # imm = 0x151
movb $0x0, %al
callq 0xf610
movq $0x0, -0x8(%rbp)
jmp 0x2ade
movq -0x10(%rbp), %rdi
xorl %esi, %esi
movl $0x80, %edx
callq 0x1100
movq -0x10(%rbp), %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x10, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/MikeGray-APH[P]LibLouisAPH/source/table.c
// Function: filter_allocate
filter* filter_allocate(void)
{
	struct filter *filter;

	filter = MALLOC(sizeof(struct filter));
	LOG_ALLOCATE_FAIL_RETURN_NULL(filter)
	memset(filter, 0, sizeof(struct filter));
	return filter;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movl $0x30, %edi
callq 0x1160
movq %rax, -0x10(%rbp)
cmpq $0x0, -0x10(%rbp)
jne 0x2b36
movl $0x7, %edi
leaq 0x1b75f(%rip), %rsi     # 0x1e278
leaq 0x1b778(%rip), %rdx     # 0x1e298
movl $0x169, %ecx            # imm = 0x169
movb $0x0, %al
callq 0xf610
movq $0x0, -0x8(%rbp)
jmp 0x2b4e
movq -0x10(%rbp), %rdi
xorl %esi, %esi
movl $0x30, %edx
callq 0x1100
movq -0x10(%rbp), %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x10, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/MikeGray-APH[P]LibLouisAPH/source/table.c
// Function: rule_allocate
rule* rule_allocate(void)
{
	struct rule *rule;

	rule = MALLOC(sizeof(struct rule));
	LOG_ALLOCATE_FAIL_RETURN_NULL(rule)
	memset(rule, 0, sizeof(struct rule));
	return rule;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movl $0x90, %edi
callq 0x1160
movq %rax, -0x10(%rbp)
cmpq $0x0, -0x10(%rbp)
jne 0x2ba6
movl $0x7, %edi
leaq 0x1b6ef(%rip), %rsi     # 0x1e278
leaq 0x1b708(%rip), %rdx     # 0x1e298
movl $0x185, %ecx            # imm = 0x185
movb $0x0, %al
callq 0xf610
movq $0x0, -0x8(%rbp)
jmp 0x2bbe
movq -0x10(%rbp), %rdi
xorl %esi, %esi
movl $0x90, %edx
callq 0x1100
movq -0x10(%rbp), %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x10, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/MikeGray-APH[P]LibLouisAPH/source/table.c
// Function: rule_match_forward
static const struct rule* rule_match_forward(
	const struct rule *const*rule_hash,
	const unsigned int hash_size,
	const unichar *chars,
	const int chars_len,
	const struct rule *at)
{
	const struct rule *rule;
	int hash;

	if(!rule_hash)
		return NULL;

	if(at)
		rule = at->chars_nxt;
	else
	{
		hash = uchar_get_hash(chars[0], hash_size);
		rule = rule_hash[hash];
	}

	while(rule)
	{
		if(rule_chars_is_match(rule, chars, chars_len))
			break;
		else
			rule = rule->chars_nxt;
	}

	return rule;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x10(%rbp)
movl %esi, -0x14(%rbp)
movq %rdx, -0x20(%rbp)
movl %ecx, -0x24(%rbp)
movq %r8, -0x30(%rbp)
cmpq $0x0, -0x10(%rbp)
jne 0x412b
movq $0x0, -0x8(%rbp)
jmp 0x419b
cmpq $0x0, -0x30(%rbp)
je 0x4140
movq -0x30(%rbp), %rax
movq 0x8(%rax), %rax
movq %rax, -0x38(%rbp)
jmp 0x4165
movq -0x20(%rbp), %rax
movw (%rax), %ax
movl -0x14(%rbp), %esi
movzwl %ax, %edi
callq 0x2970
movl %eax, -0x3c(%rbp)
movq -0x10(%rbp), %rax
movslq -0x3c(%rbp), %rcx
movq (%rax,%rcx,8), %rax
movq %rax, -0x38(%rbp)
jmp 0x4167
cmpq $0x0, -0x38(%rbp)
je 0x4193
movq -0x38(%rbp), %rdi
movq -0x20(%rbp), %rsi
movl -0x24(%rbp), %edx
callq 0x44c0
cmpl $0x0, %eax
je 0x4185
jmp 0x4193
movq -0x38(%rbp), %rax
movq 0x8(%rax), %rax
movq %rax, -0x38(%rbp)
jmp 0x4167
movq -0x38(%rbp), %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x40, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/MikeGray-APH[P]LibLouisAPH/source/table.c
// Function: rule_match_backward
static const struct rule* rule_match_backward(
	const struct rule * const *rule_hash,
	const unsigned int hash_size,
	const unichar *chars,
	const int chars_len,
	const struct rule *at)
{
	const struct rule *rule;
	int hash;

	if(!rule_hash)
		return NULL;

	if(at)
		rule = at->dots_nxt;
	else
	{
		hash = uchar_get_hash(chars[0], hash_size);
		rule = rule_hash[hash];
	}

	while(rule)
	if(rule_dots_is_match(rule, chars, chars_len))
		break;
	else
		rule = rule->dots_nxt;

	return rule;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x10(%rbp)
movl %esi, -0x14(%rbp)
movq %rdx, -0x20(%rbp)
movl %ecx, -0x24(%rbp)
movq %r8, -0x30(%rbp)
cmpq $0x0, -0x10(%rbp)
jne 0x41db
movq $0x0, -0x8(%rbp)
jmp 0x424b
cmpq $0x0, -0x30(%rbp)
je 0x41f0
movq -0x30(%rbp), %rax
movq 0x10(%rax), %rax
movq %rax, -0x38(%rbp)
jmp 0x4215
movq -0x20(%rbp), %rax
movw (%rax), %ax
movl -0x14(%rbp), %esi
movzwl %ax, %edi
callq 0x2970
movl %eax, -0x3c(%rbp)
movq -0x10(%rbp), %rax
movslq -0x3c(%rbp), %rcx
movq (%rax,%rcx,8), %rax
movq %rax, -0x38(%rbp)
jmp 0x4217
cmpq $0x0, -0x38(%rbp)
je 0x4243
movq -0x38(%rbp), %rdi
movq -0x20(%rbp), %rsi
movl -0x24(%rbp), %edx
callq 0x4540
cmpl $0x0, %eax
je 0x4235
jmp 0x4243
movq -0x38(%rbp), %rax
movq 0x10(%rax), %rax
movq %rax, -0x38(%rbp)
jmp 0x4217
movq -0x38(%rbp), %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x40, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/MikeGray-APH[P]LibLouisAPH/source/table.c
// Function: rule_chars_compare
static int rule_chars_compare(const struct rule *const rule0, const struct rule *const rule1, const int forward_only)
{
	if(rule0->chars_len > rule1->chars_len)
		return -1;
	else if(rule0->chars_len == rule1->chars_len)
	{
		if(rule0->filter_forward)
		{
			if(rule1->filter_forward)
			{
				if(forward_only)
					return 0;
				else if(rule0->dots_len > rule1->dots_len)
					return -1;
				else if(rule0->dots_len == rule1->dots_len)
					return 0;
				else
					return 1;
			}
			else
				return -1;
		}
		else
		{
			if(rule1->filter_forward)
				return 1;
			else
			{
				if(forward_only)
					return 0;
				else if(rule0->dots_len > rule1->dots_len)
					return -1;
				else if(rule0->dots_len == rule1->dots_len)
					return 0;
				else
					return 1;
			}
		}
	}
	else
		return 1;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movl %edx, -0x1c(%rbp)
movq -0x10(%rbp), %rax
movl 0x74(%rax), %eax
movq -0x18(%rbp), %rcx
cmpl 0x74(%rcx), %eax
jle 0x428b
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
jmp 0x437c
movq -0x10(%rbp), %rax
movl 0x74(%rax), %eax
movq -0x18(%rbp), %rcx
cmpl 0x74(%rcx), %eax
jne 0x4375
movq -0x10(%rbp), %rax
cmpq $0x0, 0x80(%rax)
je 0x4314
movq -0x18(%rbp), %rax
cmpq $0x0, 0x80(%rax)
je 0x430b
cmpl $0x0, -0x1c(%rbp)
je 0x42cd
movl $0x0, -0x4(%rbp)
jmp 0x437c
movq -0x10(%rbp), %rax
movl 0x78(%rax), %eax
movq -0x18(%rbp), %rcx
cmpl 0x78(%rcx), %eax
jle 0x42e9
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
jmp 0x437c
movq -0x10(%rbp), %rax
movl 0x78(%rax), %eax
movq -0x18(%rbp), %rcx
cmpl 0x78(%rcx), %eax
jne 0x4302
movl $0x0, -0x4(%rbp)
jmp 0x437c
movl $0x1, -0x4(%rbp)
jmp 0x437c
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
jmp 0x437c
movq -0x18(%rbp), %rax
cmpq $0x0, 0x80(%rax)
je 0x432b
movl $0x1, -0x4(%rbp)
jmp 0x437c
cmpl $0x0, -0x1c(%rbp)
je 0x433a
movl $0x0, -0x4(%rbp)
jmp 0x437c
movq -0x10(%rbp), %rax
movl 0x78(%rax), %eax
movq -0x18(%rbp), %rcx
cmpl 0x78(%rcx), %eax
jle 0x4353
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
jmp 0x437c
movq -0x10(%rbp), %rax
movl 0x78(%rax), %eax
movq -0x18(%rbp), %rcx
cmpl 0x78(%rcx), %eax
jne 0x436c
movl $0x0, -0x4(%rbp)
jmp 0x437c
movl $0x1, -0x4(%rbp)
jmp 0x437c
movl $0x1, -0x4(%rbp)
movl -0x4(%rbp), %eax
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/MikeGray-APH[P]LibLouisAPH/source/table.c
// Function: rule_dots_compare
static int rule_dots_compare(const struct rule *const rule0, const struct rule *const rule1, const int backward_only)
{
	if(rule0->dots_len > rule1->dots_len)
		return -1;
	else if(rule0->dots_len == rule1->dots_len)
	{
		if(rule0->filter_backward)
		{
			if(rule1->filter_backward)
			{
				if(backward_only)
					return 0;
				else if(rule0->chars_len > rule1->chars_len)
					return -1;
				else if(rule0->chars_len == rule1->chars_len)
					return 0;
				else
					return 1;
			}
			else
				return -1;
		}
		else
		{
			if(rule1->filter_backward)
				return 1;
			else
			{
				if(backward_only)
					return 0;
				else if(rule0->chars_len > rule1->chars_len)
					return -1;
				else if(rule0->chars_len == rule1->chars_len)
					return 0;
				else
					return 1;
			}
		}
	}
	else
		return 1;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movl %edx, -0x1c(%rbp)
movq -0x10(%rbp), %rax
movl 0x78(%rax), %eax
movq -0x18(%rbp), %rcx
cmpl 0x78(%rcx), %eax
jle 0x43bb
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
jmp 0x44ac
movq -0x10(%rbp), %rax
movl 0x78(%rax), %eax
movq -0x18(%rbp), %rcx
cmpl 0x78(%rcx), %eax
jne 0x44a5
movq -0x10(%rbp), %rax
cmpq $0x0, 0x88(%rax)
je 0x4444
movq -0x18(%rbp), %rax
cmpq $0x0, 0x88(%rax)
je 0x443b
cmpl $0x0, -0x1c(%rbp)
je 0x43fd
movl $0x0, -0x4(%rbp)
jmp 0x44ac
movq -0x10(%rbp), %rax
movl 0x74(%rax), %eax
movq -0x18(%rbp), %rcx
cmpl 0x74(%rcx), %eax
jle 0x4419
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
jmp 0x44ac
movq -0x10(%rbp), %rax
movl 0x74(%rax), %eax
movq -0x18(%rbp), %rcx
cmpl 0x74(%rcx), %eax
jne 0x4432
movl $0x0, -0x4(%rbp)
jmp 0x44ac
movl $0x1, -0x4(%rbp)
jmp 0x44ac
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
jmp 0x44ac
movq -0x18(%rbp), %rax
cmpq $0x0, 0x88(%rax)
je 0x445b
movl $0x1, -0x4(%rbp)
jmp 0x44ac
cmpl $0x0, -0x1c(%rbp)
je 0x446a
movl $0x0, -0x4(%rbp)
jmp 0x44ac
movq -0x10(%rbp), %rax
movl 0x74(%rax), %eax
movq -0x18(%rbp), %rcx
cmpl 0x74(%rcx), %eax
jle 0x4483
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
jmp 0x44ac
movq -0x10(%rbp), %rax
movl 0x74(%rax), %eax
movq -0x18(%rbp), %rcx
cmpl 0x74(%rcx), %eax
jne 0x449c
movl $0x0, -0x4(%rbp)
jmp 0x44ac
movl $0x1, -0x4(%rbp)
jmp 0x44ac
movl $0x1, -0x4(%rbp)
movl -0x4(%rbp), %eax
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/MikeGray-APH[P]LibLouisAPH/source/table.c
// Function: rule_chars_is_match
static int rule_chars_is_match(const struct rule *rule, const unichar *uchars, const int uchars_len)
{
	int i;

	if(rule->chars_len > uchars_len)
		return 0;

	for(i = 0; i < rule->chars_len; i++)
	if(uchars[i] != rule->chars[i])
		return 0;

	return 1;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movl %edx, -0x1c(%rbp)
movq -0x10(%rbp), %rax
movl 0x74(%rax), %eax
cmpl -0x1c(%rbp), %eax
jle 0x44e4
movl $0x0, -0x4(%rbp)
jmp 0x4531
movl $0x0, -0x20(%rbp)
movl -0x20(%rbp), %eax
movq -0x10(%rbp), %rcx
cmpl 0x74(%rcx), %eax
jge 0x452a
movq -0x18(%rbp), %rax
movslq -0x20(%rbp), %rcx
movzwl (%rax,%rcx,2), %eax
movq -0x10(%rbp), %rcx
movslq -0x20(%rbp), %rdx
movzwl 0x18(%rcx,%rdx,2), %ecx
cmpl %ecx, %eax
je 0x451d
movl $0x0, -0x4(%rbp)
jmp 0x4531
jmp 0x451f
movl -0x20(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x20(%rbp)
jmp 0x44eb
movl $0x1, -0x4(%rbp)
movl -0x4(%rbp), %eax
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/MikeGray-APH[P]LibLouisAPH/source/table.c
// Function: rule_dots_is_match
static int rule_dots_is_match(const struct rule *rule, const unichar *uchars, const int uchars_len)
{
	int i;

	if(rule->dots_len > uchars_len)
		return 0;

	for(i = 0; i < rule->dots_len; i++)
	if(uchars[i] != rule->dots[i])
		return 0;

	return 1;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movl %edx, -0x1c(%rbp)
movq -0x10(%rbp), %rax
movl 0x78(%rax), %eax
cmpl -0x1c(%rbp), %eax
jle 0x4564
movl $0x0, -0x4(%rbp)
jmp 0x45b1
movl $0x0, -0x20(%rbp)
movl -0x20(%rbp), %eax
movq -0x10(%rbp), %rcx
cmpl 0x78(%rcx), %eax
jge 0x45aa
movq -0x18(%rbp), %rax
movslq -0x20(%rbp), %rcx
movzwl (%rax,%rcx,2), %eax
movq -0x10(%rbp), %rcx
movslq -0x20(%rbp), %rdx
movzwl 0x46(%rcx,%rdx,2), %ecx
cmpl %ecx, %eax
je 0x459d
movl $0x0, -0x4(%rbp)
jmp 0x45b1
jmp 0x459f
movl -0x20(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x20(%rbp)
jmp 0x456b
movl $0x1, -0x4(%rbp)
movl -0x4(%rbp), %eax
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/MikeGray-APH[P]LibLouisAPH/source/conversion.c
// Function: conversion_init
void conversion_init(struct conversion *conversion)
{
	int i;

	memset(conversion, 0, sizeof(struct conversion));

	/*   fill with default cells   */
	for(i = 0; i < 256; i++)
		conversion->converts[i] = 0x2800 + i;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
xorl %esi, %esi
movl $0x218, %edx            # imm = 0x218
callq 0x1100
movl $0x0, -0xc(%rbp)
cmpl $0x100, -0xc(%rbp)      # imm = 0x100
jge 0x460f
movl -0xc(%rbp), %eax
addl $0x2800, %eax           # imm = 0x2800
movw %ax, %dx
movq -0x8(%rbp), %rax
movslq -0xc(%rbp), %rcx
movw %dx, 0x10(%rax,%rcx,2)
movl -0xc(%rbp), %eax
addl $0x1, %eax
movl %eax, -0xc(%rbp)
jmp 0x45e3
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/MikeGray-APH[P]LibLouisAPH/source/conversion.c
// Function: conversion_fini
void conversion_fini(struct conversion *conversion)
{
	if(!conversion)
		return;

	if(conversion->file_name)
		FREE(conversion->file_name);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
cmpq $0x0, -0x8(%rbp)
jne 0x4635
jmp 0x464d
movq -0x8(%rbp), %rax
cmpq $0x0, 0x8(%rax)
je 0x464d
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rdi
callq 0x1040
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/MikeGray-APH[P]LibLouisAPH/source/conversion.c
// Function: conversion_allocate
conversion* conversion_allocate(void)
{
	struct conversion *conversion;

	conversion = MALLOC(sizeof(struct conversion));
	LOG_ALLOCATE_FAIL_RETURN_NULL(conversion)
	conversion_init(conversion);

	return conversion;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movl $0x218, %edi            # imm = 0x218
callq 0x1160
movq %rax, -0x10(%rbp)
cmpq $0x0, -0x10(%rbp)
jne 0x46a6
movl $0x7, %edi
leaq 0x19bef(%rip), %rsi     # 0x1e278
leaq 0x19c53(%rip), %rdx     # 0x1e2e3
movl $0x35, %ecx
movb $0x0, %al
callq 0xf610
movq $0x0, -0x8(%rbp)
jmp 0x46b7
movq -0x10(%rbp), %rdi
callq 0x45c0
movq -0x10(%rbp), %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/MikeGray-APH[P]LibLouisAPH/source/conversion.c
// Function: conversion_free
void conversion_free(struct conversion *conversion)
{
	if(!conversion)
		return;

	conversion_free(conversion->nxt);
	conversion_fini(conversion);
	FREE(conversion);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
cmpq $0x0, -0x8(%rbp)
jne 0x46e5
jmp 0x4703
movq -0x8(%rbp), %rax
movq (%rax), %rdi
callq 0x46d0
movq -0x8(%rbp), %rdi
callq 0x4620
movq -0x8(%rbp), %rdi
callq 0x1040
addq $0x10, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/MikeGray-APH[P]LibLouisAPH/source/conversion.c
// Function: conversion_set_cell
int conversion_set_cell(struct conversion *conversion, const unichar cell, const unichar uchar)
{
	if(cell >= 0x2800 && cell <= 0x28ff)
		conversion->converts[cell & 0xff] = uchar;
	else
		return 0;

	return 1;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movw %dx, %ax
movw %si, %cx
movq %rdi, -0x10(%rbp)
movw %cx, -0x12(%rbp)
movw %ax, -0x14(%rbp)
movzwl -0x12(%rbp), %eax
cmpl $0x2800, %eax           # imm = 0x2800
jl 0x4758
movzwl -0x12(%rbp), %eax
cmpl $0x28ff, %eax           # imm = 0x28FF
jg 0x4758
movw -0x14(%rbp), %dx
movq -0x10(%rbp), %rax
movzwl -0x12(%rbp), %ecx
andl $0xff, %ecx
movslq %ecx, %rcx
movw %dx, 0x10(%rax,%rcx,2)
jmp 0x4761
movl $0x0, -0x4(%rbp)
jmp 0x4768
movl $0x1, -0x4(%rbp)
movl -0x4(%rbp), %eax
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/MikeGray-APH[P]LibLouisAPH/source/conversion.c
// Function: conversion_convert_to
void conversion_convert_to(unichar *dots, const int dots_len, const struct conversion *conversion)
{
	int i;

	if(!conversion)
		return;

	for(i = 0; i < dots_len; i++)
	if(dots[i] >= 0x2800 && dots[i] <= 0x28ff)
		dots[i] = conversion->converts[dots[i] & 0xff];
	else
		dots[i] = conversion->unknown;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movq %rdx, -0x18(%rbp)
cmpq $0x0, -0x18(%rbp)
jne 0x47bb
jmp 0x4840
movl $0x0, -0x1c(%rbp)
movl -0x1c(%rbp), %eax
cmpl -0xc(%rbp), %eax
jge 0x4840
movq -0x8(%rbp), %rax
movslq -0x1c(%rbp), %rcx
movzwl (%rax,%rcx,2), %eax
cmpl $0x2800, %eax           # imm = 0x2800
jl 0x481c
movq -0x8(%rbp), %rax
movslq -0x1c(%rbp), %rcx
movzwl (%rax,%rcx,2), %eax
cmpl $0x28ff, %eax           # imm = 0x28FF
jg 0x481c
movq -0x18(%rbp), %rax
movq -0x8(%rbp), %rcx
movslq -0x1c(%rbp), %rdx
movzwl (%rcx,%rdx,2), %ecx
andl $0xff, %ecx
movslq %ecx, %rcx
movw 0x10(%rax,%rcx,2), %dx
movq -0x8(%rbp), %rax
movslq -0x1c(%rbp), %rcx
movw %dx, (%rax,%rcx,2)
jmp 0x4833
movq -0x18(%rbp), %rax
movw 0x210(%rax), %dx
movq -0x8(%rbp), %rax
movslq -0x1c(%rbp), %rcx
movw %dx, (%rax,%rcx,2)
jmp 0x4835
movl -0x1c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x1c(%rbp)
jmp 0x47c2
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/MikeGray-APH[P]LibLouisAPH/source/conversion.c
// Function: conversion_convert_from
void conversion_convert_from(unichar *uchars, const int uchars_len, const struct conversion *conversion)
{
	int i;

	if(!conversion)
		return;

	for(i = 0; i < uchars_len; i++)
		uchars[i] = convert_uchar_from(conversion, uchars[i]);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movq %rdx, -0x18(%rbp)
cmpq $0x0, -0x18(%rbp)
jne 0x486c
jmp 0x48aa
movl $0x0, -0x1c(%rbp)
movl -0x1c(%rbp), %eax
cmpl -0xc(%rbp), %eax
jge 0x48aa
movq -0x18(%rbp), %rdi
movq -0x8(%rbp), %rax
movslq -0x1c(%rbp), %rcx
movzwl (%rax,%rcx,2), %esi
callq 0x48b0
movw %ax, %dx
movq -0x8(%rbp), %rax
movslq -0x1c(%rbp), %rcx
movw %dx, (%rax,%rcx,2)
movl -0x1c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x1c(%rbp)
jmp 0x4873
addq $0x20, %rsp
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O0/MikeGray-APH[P]LibLouisAPH/source/conversion.c
// Function: convert_uchar_from
static unichar convert_uchar_from(const struct conversion *conversion, const unichar uchar)
{
	int i;

	for(i = 0; i < 0x100; i++)
	if(uchar == conversion->converts[i])
		return i + 0x2800;

	return conversion->unknown;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movw %si, %ax
movq %rdi, -0x10(%rbp)
movw %ax, -0x12(%rbp)
movl $0x0, -0x18(%rbp)
cmpl $0x100, -0x18(%rbp)     # imm = 0x100
jge 0x48ff
movzwl -0x12(%rbp), %eax
movq -0x10(%rbp), %rcx
movslq -0x18(%rbp), %rdx
movzwl 0x10(%rcx,%rdx,2), %ecx
cmpl %ecx, %eax
jne 0x48f2
movl -0x18(%rbp), %eax
addl $0x2800, %eax           # imm = 0x2800
movw %ax, -0x2(%rbp)
jmp 0x490e
jmp 0x48f4
movl -0x18(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x18(%rbp)
jmp 0x48c6
movq -0x10(%rbp), %rax
movw 0x210(%rax), %ax
movw %ax, -0x2(%rbp)
movw -0x2(%rbp), %ax
popq %rbp
retq
nopw %cs:(%rax,%rax)
nop
// File: /workspace/github_c_makefile_star2_O0/MikeGray-APH[P]LibLouisAPH/source/compile.c
// Function: variable_free
static void variable_free(struct variable *var)
{
	if(!var)
		return;

	variable_free(var->nxt);
	ASSERT(var->uchars)
	FREE(var->uchars);
	FREE(var);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
cmpq $0x0, -0x8(%rbp)
jne 0x5325
jmp 0x5357
movq -0x8(%rbp), %rax
movq (%rax), %rdi
callq 0x5310
movq -0x8(%rbp), %rax
cmpq $0x0, 0x8(%rax)
jne 0x5341
callq 0x1050
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rdi
callq 0x1040
movq -0x8(%rbp), %rdi
callq 0x1040
addq $0x10, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/MikeGray-APH[P]LibLouisAPH/source/compile.c
// Function: macro_free
static void macro_free(struct macro *macro)
{
	if(!macro)
		return;

	macro_free(macro->nxt);

	macro_fini(macro);
	FREE(macro);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
cmpq $0x0, -0x8(%rbp)
jne 0x5375
jmp 0x5393
movq -0x8(%rbp), %rax
movq (%rax), %rdi
callq 0x5360
movq -0x8(%rbp), %rdi
callq 0xa460
movq -0x8(%rbp), %rdi
callq 0x1040
addq $0x10, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/MikeGray-APH[P]LibLouisAPH/source/compile.c
// Function: token_init
static int token_init(unichar *uchars)
{
	if(!uchars)
		return 0;

	for(token_nxt = uchars; is_space(*token_nxt); token_nxt++);
	if(!(*token_nxt))
		return 0;

	return token_parse();
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x10(%rbp)
cmpq $0x0, -0x10(%rbp)
jne 0x578c
movl $0x0, -0x4(%rbp)
jmp 0x57df
movq -0x10(%rbp), %rax
movq %rax, 0x20a79(%rip)     # 0x26210
movq 0x20a72(%rip), %rax     # 0x26210
movzwl (%rax), %edi
callq 0x5950
cmpl $0x0, %eax
je 0x57c1
jmp 0x57ad
movq 0x20a5c(%rip), %rax     # 0x26210
addq $0x2, %rax
movq %rax, 0x20a51(%rip)     # 0x26210
jmp 0x5797
movq 0x20a48(%rip), %rax     # 0x26210
cmpw $0x0, (%rax)
jne 0x57d7
movl $0x0, -0x4(%rbp)
jmp 0x57df
callq 0x6190
movl %eax, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x10, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/MikeGray-APH[P]LibLouisAPH/source/compile.c
// Function: compile_convert
static int compile_convert(struct conversion *conversion)
{
	unichar cell, uchar;

	if(!token_parse())
		goto return_fail;
	if(token_convert_to_dots() < 0)
		goto return_fail;
	if(token_len != 1)
		goto return_fail;

	cell = *token_crs;

	if(!token_parse())
		goto return_fail;

	token_convert_escapes();
	if(token_len != 1)
		goto return_fail;

	uchar = *token_crs;

	return conversion_set_cell(conversion, cell, uchar);

	return_fail:
	log_message(LOG_ERROR, "%s:%d  invalid convert", conversion->file_name, table_file_lines[0]);
	return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
callq 0x6190
cmpl $0x0, %eax
jne 0x5838
jmp 0x58a0
callq 0x9ed0
cmpl $0x0, %eax
jge 0x5844
jmp 0x58a0
cmpl $0x1, 0x209b5(%rip)     # 0x26200
je 0x584f
jmp 0x58a0
movq 0x209b2(%rip), %rax     # 0x26208
movw (%rax), %ax
movw %ax, -0x12(%rbp)
callq 0x6190
cmpl $0x0, %eax
jne 0x5869
jmp 0x58a0
callq 0x9670
cmpl $0x1, 0x2098b(%rip)     # 0x26200
je 0x5879
jmp 0x58a0
movq 0x20988(%rip), %rax     # 0x26208
movw (%rax), %ax
movw %ax, -0x14(%rbp)
movq -0x10(%rbp), %rdi
movw -0x12(%rbp), %ax
movzwl %ax, %esi
movzwl -0x14(%rbp), %edx
callq 0x4710
movl %eax, -0x4(%rbp)
jmp 0x58c8
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rdx
movl 0x1e8f2(%rip), %ecx     # 0x241a0
movl $0x6, %edi
leaq 0x19116(%rip), %rsi     # 0x1e9d0
movb $0x0, %al
callq 0xf610
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/MikeGray-APH[P]LibLouisAPH/source/compile.c
// Function: compile_unknown
static int compile_unknown(struct conversion *conversion)
{
	if(!token_parse())
		goto return_fail;
	if(token_len != 1)
		goto return_fail;

	return conversion_set_unknown(conversion, *token_crs);

	return_fail:
	log_message(LOG_ERROR, "%s:%d  invalid unknown", conversion->file_name, table_file_lines[0]);
	return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x10(%rbp)
callq 0x6190
cmpl $0x0, %eax
jne 0x58f8
jmp 0x591b
cmpl $0x1, 0x20901(%rip)     # 0x26200
je 0x5903
jmp 0x591b
movq -0x10(%rbp), %rdi
movq 0x208fa(%rip), %rax     # 0x26208
movzwl (%rax), %esi
callq 0x4770
movl %eax, -0x4(%rbp)
jmp 0x5943
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rdx
movl 0x1e877(%rip), %ecx     # 0x241a0
movl $0x6, %edi
leaq 0x190b2(%rip), %rsi     # 0x1e9e7
movb $0x0, %al
callq 0xf610
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x10, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/MikeGray-APH[P]LibLouisAPH/source/utf.h
// Function: is_space
static inline int is_space(const unichar uchar)
{
	switch(uchar)
	{
	case u' ':
	case u'\t':
	case u'\n':
	case u'\r':
	case u'\u00a0':
	case u'\u2000':
	case u'\u2001':
	case u'\u2002':
	case u'\u2003':
	case u'\u2004':
	case u'\u2005':
	case u'\u2006':
	case u'\u2007':
	case u'\u2008':
	case u'\u2009':
	case u'\u200a':
	case u'\u200b':

		return 1;
	}

	return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movw %di, %ax
movw %ax, -0x6(%rbp)
movzwl -0x6(%rbp), %eax
movl %eax, -0xc(%rbp)
addl $-0x9, %eax
subl $0x2, %eax
jb 0x599b
jmp 0x596c
movl -0xc(%rbp), %eax
subl $0xd, %eax
je 0x599b
jmp 0x5976
movl -0xc(%rbp), %eax
subl $0x20, %eax
je 0x599b
jmp 0x5980
movl -0xc(%rbp), %eax
subl $0xa0, %eax
je 0x599b
jmp 0x598c
movl -0xc(%rbp), %eax
addl $0xffffe000, %eax       # imm = 0xFFFFE000
subl $0xb, %eax
ja 0x59a4
jmp 0x599b
movl $0x1, -0x4(%rbp)
jmp 0x59ab
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O0/MikeGray-APH[P]LibLouisAPH/source/compile.c
// Function: token_parse
static int token_parse(void)
{
	ASSERT(token_nxt)
	if(!(*token_nxt))
		return 0;

	token_crs = token_nxt;
	for(token_len = 0; !is_space(*token_nxt); token_nxt++)
	if(!(*token_nxt))
		return 1;
	else
		token_len++;
	*token_nxt = 0;

	for(token_nxt++; is_space(*token_nxt); token_nxt++);

	return 1;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
cmpq $0x0, 0x20070(%rip)     # 0x26210
jne 0x61a7
callq 0x1050
movq 0x20062(%rip), %rax     # 0x26210
cmpw $0x0, (%rax)
jne 0x61c0
movl $0x0, -0x4(%rbp)
jmp 0x627f
movq 0x20049(%rip), %rax     # 0x26210
movq %rax, 0x2003a(%rip)     # 0x26208
movl $0x0, 0x20028(%rip)     # 0x26200
movq 0x20031(%rip), %rax     # 0x26210
movzwl (%rax), %edi
callq 0x5950
cmpl $0x0, %eax
setne %al
xorb $-0x1, %al
testb $0x1, %al
jne 0x61f5
jmp 0x6230
movq 0x20014(%rip), %rax     # 0x26210
cmpw $0x0, (%rax)
jne 0x620b
movl $0x1, -0x4(%rbp)
jmp 0x627f
movl 0x1ffef(%rip), %eax     # 0x26200
addl $0x1, %eax
movl %eax, 0x1ffe6(%rip)     # 0x26200
jmp 0x621c
movq 0x1ffed(%rip), %rax     # 0x26210
addq $0x2, %rax
movq %rax, 0x1ffe2(%rip)     # 0x26210
jmp 0x61d8
movq 0x1ffd9(%rip), %rax     # 0x26210
movw $0x0, (%rax)
movq 0x1ffcd(%rip), %rax     # 0x26210
addq $0x2, %rax
movq %rax, 0x1ffc2(%rip)     # 0x26210
movq 0x1ffbb(%rip), %rax     # 0x26210
movzwl (%rax), %edi
callq 0x5950
cmpl $0x0, %eax
je 0x6278
jmp 0x6264
movq 0x1ffa5(%rip), %rax     # 0x26210
addq $0x2, %rax
movq %rax, 0x1ff9a(%rip)     # 0x26210
jmp 0x624e
movl $0x1, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x10, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/MikeGray-APH[P]LibLouisAPH/source/utf.h
// Function: utf16_copy
static inline void utf16_copy(unichar *dst, const unichar *src, const int len)
{
	int i;

	for(i = 0; i < len; i++)
		dst[i] = src[i];
	dst[len - 1] = 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
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 0x62d1
movq -0x10(%rbp), %rax
movslq -0x18(%rbp), %rcx
movw (%rax,%rcx,2), %dx
movq -0x8(%rbp), %rax
movslq -0x18(%rbp), %rcx
movw %dx, (%rax,%rcx,2)
movl -0x18(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x18(%rbp)
jmp 0x62a6
movq -0x8(%rbp), %rax
movl -0x14(%rbp), %ecx
subl $0x1, %ecx
movslq %ecx, %rcx
movw $0x0, (%rax,%rcx,2)
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/MikeGray-APH[P]LibLouisAPH/source/compile.c
// Function: macro_allocate
macro* macro_allocate(void)
{
	struct macro *macro;

	macro = MALLOC(sizeof(struct macro));
	LOG_ALLOCATE_FAIL_RETURN_NULL(macro)
	macro_init(macro);
	return macro;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movl $0x40, %edi
callq 0x1160
movq %rax, -0x10(%rbp)
cmpq $0x0, -0x10(%rbp)
jne 0x6336
movl $0x7, %edi
leaq 0x17f5f(%rip), %rsi     # 0x1e278
leaq 0x18001(%rip), %rdx     # 0x1e321
movl $0x673, %ecx            # imm = 0x673
movb $0x0, %al
callq 0xf610
movq $0x0, -0x8(%rbp)
jmp 0x6347
movq -0x10(%rbp), %rdi
callq 0x6360
movq -0x10(%rbp), %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)