LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O3/BernardTatin[P]s7sh/s7.c
// Function: chooser_check_arg_types
static s7_pointer chooser_check_arg_types(s7_scheme *sc, s7_pointer arg1, s7_pointer arg2, s7_pointer fallback,
                        s7_pointer f_2_ff, s7_pointer f_2_ii, s7_pointer f_2_if, s7_pointer f_2_fi,
                        s7_pointer f_2_xi, s7_pointer f_2_ix, s7_pointer f_2_fx, s7_pointer f_2_xf)
                {
                    s7_pointer arg1_type, arg2_type;

                    arg1_type = argument_type(sc, arg1);
                    arg2_type = argument_type(sc, arg2);

                    if ((arg1_type) || (arg2_type))
                    {
                        if (arg1_type == sc->is_float_symbol)
                        {
                            if (arg2_type == sc->is_float_symbol)
                                return(f_2_ff);
                            if (arg2_type == sc->is_integer_symbol)
                                return(f_2_fi);
                            return(f_2_fx);
                        }
                        if (arg1_type == sc->is_integer_symbol)
                        {
                            if (arg2_type == sc->is_float_symbol)
                                return(f_2_if);
                            if (arg2_type == sc->is_integer_symbol)
                                return(f_2_ii);
                            return(f_2_ix);
                        }
                        if (arg2_type == sc->is_float_symbol)
                            return(f_2_xf);
                        if (arg2_type == sc->is_integer_symbol)
                            return(f_2_xi);
                    }
                    return(fallback);
                }

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %r9, %r14
movq %r8, %rbx
movq %rcx, %r15
movq %rdx, %rbp
movq %rdi, %r12
callq 0x103f3e
movq %rax, %r13
movq %r12, %rdi
movq %rbp, %rsi
callq 0x103f3e
movq %r13, %rcx
orq %rax, %rcx
je 0x103ee7
movq 0x11e0(%r12), %rcx
cmpq %rcx, %r13
je 0x103efc
movq 0x10d0(%r12), %rdx
cmpq %rdx, %r13
je 0x103f16
cmpq %rcx, %rax
je 0x103f29
cmpq %rdx, %rax
je 0x103f30
movq %r15, %rbx
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
cmpq %r13, %rax
je 0x103eea
cmpq 0x10d0(%r12), %rax
movq 0x48(%rsp), %rbx
cmovneq 0x60(%rsp), %rbx
jmp 0x103eea
cmpq %rcx, %rax
je 0x103f37
cmpq %r13, %rax
cmovneq 0x58(%rsp), %r14
movq %r14, %rbx
jmp 0x103eea
movq 0x68(%rsp), %rbx
jmp 0x103eea
movq 0x50(%rsp), %rbx
jmp 0x103eea
movq 0x40(%rsp), %rbx
jmp 0x103eea
// File: /workspace/github_c_makefile_star2_O3/BernardTatin[P]s7sh/s7.c
// Function: argument_type
static s7_pointer argument_type(s7_scheme *sc, s7_pointer arg1)
                {
                    if (is_pair(arg1))
                    {
                        if (car(arg1) == sc->quote_symbol)
                            return(s7_type_of(sc, cadr(arg1)));

                        if ((is_h_optimized(arg1)) &&
                                (is_safe_c_op(optimize_op(arg1))) &&
                                (is_c_function(opt1_cfunc(arg1))))
                        {
                            s7_pointer sig;
                            sig = c_function_signature(opt1_cfunc(arg1));
                            if ((sig) &&
                                    (is_pair(sig)) &&
                                    (is_symbol(car(sig))))
                                return(car(sig));
                        }
                    }
                    else
                    {
                        if (!is_symbol(arg1))
                            return(s7_type_of(sc, arg1));
                    }
                    return(NULL);
                }

// Assembly:
movzbl (%rsi), %eax
cmpl $0xa, %eax
je 0x103f9f
cmpl $0x1, %eax
jne 0x103fad
movq 0x8(%rsi), %rax
cmpq 0x17b0(%rdi), %rax
je 0x103fa2
cmpw $0x801, (%rsi)          # imm = 0x801
jne 0x103f9f
movzwl 0x4(%rsi), %eax
testb $0x1, %al
sete %cl
addl $-0x2, %eax
movzwl %ax, %eax
cmpl $0x9c, %eax
setae %al
orb %cl, %al
jne 0x103f9f
movq 0x18(%rsi), %rax
cmpb $0x30, (%rax)
jb 0x103f9f
movq 0x8(%rax), %rax
movq 0x38(%rax), %rax
testq %rax, %rax
je 0x103f9f
cmpb $0x1, (%rax)
jne 0x103f9f
movq 0x8(%rax), %rax
cmpb $0xa, (%rax)
jne 0x103f9f
retq
xorl %eax, %eax
retq
movq 0x10(%rsi), %rax
movq 0x8(%rax), %rax
movzbl (%rax), %eax
movq 0x8e8(%rdi,%rax,8), %rax
retq
// File: /workspace/github_c_makefile_star2_O3/BernardTatin[P]s7sh/s7.c
// Function: lt_out_y
static bool lt_out_y(s7_scheme *sc, s7_pointer x, s7_pointer y)
    {
        if (has_active_methods(sc, y))
            return(find_and_apply_method(sc, find_let(sc, y), sc->lt_symbol, list_2(sc, x, y)) != sc->F);
        wrong_type_argument(sc, sc->lt_symbol, 2, y, T_REAL);
        return(false);
    }

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rdx, %r14
movq %rdi, %rbx
testb $0x40, 0x3(%rdx)
je 0x10469f
cmpb $0x1, 0x24c(%rbx)
jne 0x10469f
movq %rsi, %r15
movq %rbx, %rdi
movq %r14, %rsi
callq 0x8a63
movq %rax, %r12
movq 0x12c0(%rbx), %r13
movq 0x90(%rbx), %rax
movq 0x110(%rbx), %rbp
cmpq 0x98(%rbx), %rax
ja 0x104645
movq %rbx, %rdi
callq 0xa550
movq 0x90(%rbx), %rax
leaq -0x8(%rax), %rcx
movq %rcx, 0x90(%rbx)
movq -0x8(%rax), %rax
movl $0x200001, %edx         # imm = 0x200001
movq %rdx, (%rax)
movq %r14, 0x8(%rax)
movq %rbp, 0x10(%rax)
movq 0x90(%rbx), %rcx
leaq -0x8(%rcx), %rsi
movq %rsi, 0x90(%rbx)
movq -0x8(%rcx), %rcx
movq %rdx, (%rcx)
movq %r15, 0x8(%rcx)
movq %rax, 0x10(%rcx)
movq %rbx, %rdi
movq %r12, %rsi
movq %r13, %rdx
callq 0x9058e
cmpq 0x120(%rbx), %rax
setne %al
jmp 0x1046cc
movq 0x12c0(%rbx), %rax
movq 0x8(%rax), %rsi
movq 0x422af(%rip), %rdx     # 0x146960
movq 0x140(%rbx), %r8
movq 0x46409(%rip), %r9      # 0x14aac8
movq %rbx, %rdi
movq %r14, %rcx
callq 0xa4e4
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/BernardTatin[P]s7sh/s7.c
// Function: geq_out_y
static bool geq_out_y(s7_scheme *sc, s7_pointer x, s7_pointer y)
    {
        if (has_active_methods(sc, y))
            return(find_and_apply_method(sc, find_let(sc, y), sc->geq_symbol, list_2(sc, x, y)) != sc->F);
        wrong_type_argument(sc, sc->geq_symbol, 2, y, T_REAL);
        return(false);
    }

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rdx, %r14
movq %rdi, %rbx
testb $0x40, 0x3(%rdx)
je 0x10479b
cmpb $0x1, 0x24c(%rbx)
jne 0x10479b
movq %rsi, %r15
movq %rbx, %rdi
movq %r14, %rsi
callq 0x8a63
movq %rax, %r12
movq 0xf48(%rbx), %r13
movq 0x90(%rbx), %rax
movq 0x110(%rbx), %rbp
cmpq 0x98(%rbx), %rax
ja 0x104741
movq %rbx, %rdi
callq 0xa550
movq 0x90(%rbx), %rax
leaq -0x8(%rax), %rcx
movq %rcx, 0x90(%rbx)
movq -0x8(%rax), %rax
movl $0x200001, %edx         # imm = 0x200001
movq %rdx, (%rax)
movq %r14, 0x8(%rax)
movq %rbp, 0x10(%rax)
movq 0x90(%rbx), %rcx
leaq -0x8(%rcx), %rsi
movq %rsi, 0x90(%rbx)
movq -0x8(%rcx), %rcx
movq %rdx, (%rcx)
movq %r15, 0x8(%rcx)
movq %rax, 0x10(%rcx)
movq %rbx, %rdi
movq %r12, %rsi
movq %r13, %rdx
callq 0x9058e
cmpq 0x120(%rbx), %rax
setne %al
jmp 0x1047c8
movq 0xf48(%rbx), %rax
movq 0x8(%rax), %rsi
movq 0x421b3(%rip), %rdx     # 0x146960
movq 0x140(%rbx), %r8
movq 0x4630d(%rip), %r9      # 0x14aac8
movq %rbx, %rdi
movq %r14, %rcx
callq 0xa4e4
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/BernardTatin[P]s7sh/s7.c
// Function: sl_integer_gt_0
static s7_pointer sl_integer_gt_0(s7_scheme *sc, s7_pointer sym, s7_pointer val)
                {
                    if (!s7_is_integer(val))
                        return(simple_wrong_type_argument(sc, sym, val, T_INTEGER));
                    if (s7_integer(val) <= 0)
                        return(simple_out_of_range(sc, sym, val, wrap_string(sc, "should be positive", 18)));
                    return(val);
                }

// Assembly:
pushq %rbx
movq %rdx, %rbx
cmpb $0xb, (%rdx)
jne 0x104855
cmpq $0x0, 0x8(%rbx)
jg 0x104850
movq 0x8(%rsi), %rax
movq 0x820(%rdi), %rcx
movslq 0x7dc(%rdi), %rdx
movq (%rcx,%rdx,8), %rcx
incl %edx
andl $0x7, %edx
movl %edx, 0x7dc(%rdi)
leaq 0x179e4(%rip), %rdx     # 0x11c1f3
movq %rdx, 0x10(%rcx)
movq $0x12, 0x8(%rcx)
movq 0x1ef8(%rdi), %rdx
movq 0x10(%rdx), %rdx
movq %rax, 0x8(%rdx)
movq 0x10(%rdx), %rax
movq %rbx, 0x8(%rax)
movq 0x10(%rax), %rax
movq %rcx, 0x8(%rax)
movq 0x1948(%rdi), %rbx
movq 0x1ef8(%rdi), %rdx
movq %rbx, %rsi
callq 0x38dfa
movq %rbx, %rax
popq %rbx
retq
movq 0x8(%rsi), %rsi
movq 0x140(%rdi), %rcx
movq 0x46251(%rip), %r8      # 0x14aab8
movq %rbx, %rdx
popq %rbx
jmp 0xed2a
// File: /workspace/github_c_makefile_star2_O3/BernardTatin[P]s7sh/s7.c
// Function: sl_real_geq_0
static s7_pointer sl_real_geq_0(s7_scheme *sc, s7_pointer sym, s7_pointer val)
                {
                    if (!s7_is_real(val))
                        return(simple_wrong_type_argument(sc, sym, val, T_REAL));
                    if (s7_real(val) < 0.0)
                        return(simple_out_of_range(sc, sym, val, wrap_string(sc, "should be positive", 18)));
                    return(val);
                }

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rdx, %rbx
movq %rsi, %r15
movq %rdi, %r14
movzbl (%rdx), %eax
leaq 0x460c8(%rip), %rcx     # 0x14a9b0
cmpb $0x0, (%rax,%rcx)
je 0x1048f9
cmpb $0xd, %al
jne 0x10491b
movsd 0x8(%rbx), %xmm0
jmp 0x104931
movq 0x8(%r15), %rsi
movq 0x140(%r14), %rcx
movq 0x461bd(%rip), %r8      # 0x14aac8
movq %r14, %rdi
movq %rbx, %rdx
popq %rbx
popq %r14
popq %r15
jmp 0xed2a
movq 0x4610e(%rip), %rdi     # 0x14aa30
leaq 0x574f(%rip), %rdx      # 0x10a078
movq %rbx, %rsi
callq 0xd498
xorpd %xmm1, %xmm1
ucomisd %xmm0, %xmm1
jbe 0x1049a8
movq 0x8(%r15), %rax
movq 0x820(%r14), %rcx
movslq 0x7dc(%r14), %rdx
movq (%rcx,%rdx,8), %rcx
incl %edx
andl $0x7, %edx
movl %edx, 0x7dc(%r14)
leaq 0x1788f(%rip), %rdx     # 0x11c1f3
movq %rdx, 0x10(%rcx)
movq $0x12, 0x8(%rcx)
movq 0x1ef8(%r14), %rdx
movq 0x10(%rdx), %rdx
movq %rax, 0x8(%rdx)
movq 0x10(%rdx), %rax
movq %rbx, 0x8(%rax)
movq 0x10(%rax), %rax
movq %rcx, 0x8(%rax)
movq 0x1948(%r14), %rbx
movq 0x1ef8(%r14), %rdx
movq %r14, %rdi
movq %rbx, %rsi
callq 0x38dfa
movq %rbx, %rax
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O3/BernardTatin[P]s7sh/s7.c
// Function: sl_integer_geq_0
static s7_pointer sl_integer_geq_0(s7_scheme *sc, s7_pointer sym, s7_pointer val)
                {
                    if (!s7_is_integer(val))
                        return(simple_wrong_type_argument(sc, sym, val, T_INTEGER));
                    if (s7_integer(val) < 0)
                        return(simple_out_of_range(sc, sym, val, wrap_string(sc, "should be non-negative", 18)));
                    return(val);
                }

// Assembly:
pushq %rbx
movq %rdx, %rbx
cmpb $0xb, (%rdx)
jne 0x104a2f
cmpq $0x0, 0x8(%rbx)
jns 0x104a2a
movq 0x8(%rsi), %rax
movq 0x820(%rdi), %rcx
movslq 0x7dc(%rdi), %rdx
movq (%rcx,%rdx,8), %rcx
incl %edx
andl $0x7, %edx
movl %edx, 0x7dc(%rdi)
leaq 0x17832(%rip), %rdx     # 0x11c21b
movq %rdx, 0x10(%rcx)
movq $0x12, 0x8(%rcx)
movq 0x1ef8(%rdi), %rdx
movq 0x10(%rdx), %rdx
movq %rax, 0x8(%rdx)
movq 0x10(%rdx), %rax
movq %rbx, 0x8(%rax)
movq 0x10(%rax), %rax
movq %rcx, 0x8(%rax)
movq 0x1948(%rdi), %rbx
movq 0x1ef8(%rdi), %rdx
movq %rbx, %rsi
callq 0x38dfa
movq %rbx, %rax
popq %rbx
retq
movq 0x8(%rsi), %rsi
movq 0x140(%rdi), %rcx
movq 0x46077(%rip), %r8      # 0x14aab8
movq %rbx, %rdx
popq %rbx
jmp 0xed2a
nop
// File: /workspace/github_c_makefile_star2_O3/BernardTatin[P]s7sh/repl.c
// Function: dohelp
static void dohelp(const int exit_code) {
    fprintf(stdout, "%s [-h|-v|-qb] [-L dir-lib]\n", progname);
    fprintf(stdout, "  -h: show this text and exits\n");
    fprintf(stdout, "  -v: show VERSION and exits\n");
    fprintf(stdout, "  -q: quiet, suppress some messages\n");
    fprintf(stdout, "  -b: batch, executes files and quit, implies -q\n");
    fprintf(stdout, "  -L dir-lib: add dir-lib to *load-path*\n");
    exit (exit_code);
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movl %edi, %ebx
movq 0x4101f(%rip), %r14     # 0x145fd0
movq (%r14), %rdi
movq 0x511bd(%rip), %rdx     # 0x156178
leaq 0x1731b(%rip), %rsi     # 0x11c2dd
xorl %eax, %eax
callq 0x8390
movq (%r14), %rcx
leaq 0x17327(%rip), %rdi     # 0x11c2fa
movl $0x1f, %esi
movl $0x1, %edx
callq 0x8660
movq (%r14), %rcx
leaq 0x1732e(%rip), %rdi     # 0x11c31a
movl $0x1d, %esi
movl $0x1, %edx
callq 0x8660
movq (%r14), %rcx
leaq 0x17333(%rip), %rdi     # 0x11c338
movl $0x24, %esi
movl $0x1, %edx
callq 0x8660
movq (%r14), %rcx
leaq 0x1733f(%rip), %rdi     # 0x11c35d
movl $0x31, %esi
movl $0x1, %edx
callq 0x8660
movq (%r14), %rcx
leaq 0x17358(%rip), %rdi     # 0x11c38f
movl $0x29, %esi
movl $0x1, %edx
callq 0x8660
movl %ebx, %edi
callq 0x8650
// File: /workspace/github_c_makefile_star2_O3/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:
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq %rdi, %r14
cmpb $0x0, 0x51103(%rip)     # 0x156161
jne 0x10507b
movq 0x40f69(%rip), %rax     # 0x145fd0
movq (%rax), %rdi
leaq 0x173fd(%rip), %rsi     # 0x11c46e
movq %rbx, %rdx
xorl %eax, %eax
callq 0x8390
movq %r14, %rdi
movq %rbx, %rsi
callq 0x36446
movq %rax, %rcx
xorl %eax, %eax
testq %rcx, %rcx
je 0x105098
addq $0x8, %rsp
popq %rbx
popq %r14
retq
movq 0x40f59(%rip), %rax     # 0x145ff8
movq (%rax), %rdi
leaq 0x1733b(%rip), %rsi     # 0x11c3e4
movq %rbx, %rdx
xorl %eax, %eax
callq 0x8390
movl $0x1, %eax
jmp 0x105090
// File: /workspace/github_c_makefile_star2_O3/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:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq %rdi, %r14
callq 0x81a0
movq %rax, %r15
movq %rbx, %rdi
callq 0x81a0
addl %r15d, %eax
addl $0x2, %eax
movslq %eax, %rdi
movl $0x1, %esi
callq 0x8360
movq %rax, %r12
movq %rax, %rdi
movq %r14, %rsi
callq 0x80d0
movslq %r15d, %rax
leaq (%r12,%rax), %rdi
incq %rdi
movb $0x2f, -0x1(%rdi)
movq %rbx, %rsi
callq 0x80d0
movq %r12, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O3/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
movq 0x51016(%rip), %rdi     # 0x156170
testq %rdi, %rdi
je 0x10516f
callq 0x8050
movq $0x0, 0x51001(%rip) # 0x156170
movq 0x50ff2(%rip), %rdi     # 0x156168
testq %rdi, %rdi
je 0x10518b
callq 0x8050
movq $0x0, 0x50fdd(%rip) # 0x156168
popq %rax
retq
// File: /workspace/github_c_makefile_star2_O3/canboat[P]canboat/ip/iptee.c
// Function: storeNewClient
int storeNewClient(int i, int sockfd)
{
  char portstr[10];

  client[i].socklen = sizeof(client[i].sockaddr);
  if (getpeername(sockfd, &client[i].sockaddr.any, &client[i].socklen))
  {
    logError("Unknown incoming client\n");
    close(sockfd);
    return 0;
  }

  if (client[i].host)
  {
    free(client[i].host);
    client[i].host = 0;
  }
  if (client[i].port)
  {
    free(client[i].port);
    client[i].port = 0;
  }

  client[i].host = calloc(INET6_ADDRSTRLEN + 2, 1);
  if (client[i].sockaddr.any.sa_family == AF_INET)
  {
    inet_ntop(client[i].sockaddr.any.sa_family, &client[i].sockaddr.in.sin_addr, client[i].host, INET6_ADDRSTRLEN + 1);
    snprintf(portstr, sizeof(portstr), "%u", ntohs(client[i].sockaddr.in.sin_port));
    client[i].port = strdup(portstr);
  }
  else if (client[i].sockaddr.any.sa_family == AF_INET6)
  {
    inet_ntop(client[i].sockaddr.any.sa_family, &client[i].sockaddr.in6.sin6_addr, client[i].host, INET6_ADDRSTRLEN + 1);
    snprintf(portstr, sizeof(portstr), "%u", ntohs(client[i].sockaddr.in6.sin6_port));
    client[i].port = strdup(portstr);
  }
  else
  {
    logAbort("Unknown family %d\n", client[i].sockaddr.any.sa_family);
  }

  client[i].fd        = sockfd;
  client[i].ct        = ClientTCP;
  client[i].reconnect = false;

  logDebug("New TCP client socket %d addr %s port %s\n", sockfd, client[i].host, portstr);

  if (i >= clients)
  {
    clients = i + 1;
  }
  return 1;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
subq $0x18, %rsp
movl %esi, %ebp
movl %edi, %ebx
movslq %edi, %r14
shlq $0x6, %r14
leaq 0x4bad(%rip), %r15      # 0x71e0
leaq (%r14,%r15), %rdx
addq $0x3c, %rdx
movl $0x1c, (%rdx)
leaq (%r14,%r15), %rsi
addq $0x20, %rsi
movl %ebp, %edi
callq 0x20c0
testl %eax, %eax
je 0x2671
leaq 0x19fb(%rip), %rdi      # 0x4056
xorl %r14d, %r14d
xorl %eax, %eax
callq 0x2e30
movl %ebp, %edi
callq 0x2170
jmp 0x2765
addq %r14, %r15
movq 0x10(%r15), %rdi
testq %rdi, %rdi
je 0x268a
callq 0x2040
movq $0x0, 0x10(%r15)
movq 0x18(%r15), %rdi
testq %rdi, %rdi
je 0x26a0
callq 0x2040
movq $0x0, 0x18(%r15)
movl $0x30, %edi
movl $0x1, %esi
callq 0x2190
movq %rax, 0x10(%r15)
movzwl 0x20(%r15), %esi
cmpl $0xa, %esi
je 0x26cd
cmpl $0x2, %esi
jne 0x2718
leaq 0x24(%r15), %rsi
movl $0x2, %edi
jmp 0x26d6
leaq 0x28(%r15), %rsi
movl $0xa, %edi
movq %rax, %rdx
movl $0x2f, %ecx
callq 0x2030
movzwl 0x22(%r15), %eax
rolw $0x8, %ax
movzwl %ax, %ecx
leaq 0x1979(%rip), %rdx      # 0x406f
leaq 0xe(%rsp), %r14
movl $0xa, %esi
movq %r14, %rdi
xorl %eax, %eax
callq 0x2100
movq %r14, %rdi
callq 0x22d0
movq %rax, 0x18(%r15)
jmp 0x2726
leaq 0x1953(%rip), %rdi      # 0x4072
xorl %eax, %eax
callq 0x2ec3
movl %ebp, (%r15)
movl $0x1, 0x4(%r15)
movb $0x0, 0x8(%r15)
movq 0x10(%r15), %rdx
leaq 0x1944(%rip), %rdi      # 0x4085
leaq 0xe(%rsp), %rcx
movl %ebp, %esi
xorl %eax, %eax
callq 0x2d9d
movl $0x1, %r14d
cmpl %ebx, 0x8a85(%rip)      # 0xb1e0
jg 0x2765
incl %ebx
movl %ebx, 0x8a7b(%rip)      # 0xb1e0
movl %r14d, %eax
addq $0x18, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/tylerneylon[P]APIsWithLua/ch3/eatyguy4.c
// Function: main
int main() {

  start();

  // Create a Lua state and load the module.
  lua_State *L = luaL_newstate();
  luaL_openlibs(L);

  // Set up API functions written in C.
  lua_register(L, "timestamp", timestamp);

  // Set up API functions written in Lua.
  luaL_dofile(L, "util.lua");

  // Load eatyguy4 and run the init() function.
  luaL_dofile(L, "eatyguy4.lua");
  lua_setglobal(L, "eatyguy");
  lua_settop(L, 0);

  lua_getglobal(L, "eatyguy");
  lua_getfield(L, -1, "init");  // -1 means stack top.
  lua_call(L, 0, 0);            // 0, 0 = #args, #retvals

  lua_getglobal(L, "eatyguy");
  while (1) {
    int is_end_of_seq;
    int key = getkey(&is_end_of_seq);
    if (key == ESC_KEY || key == 'q' || key == 'Q') done();

    // Call eatyguy.loop(<key>).
    lua_getfield(L, -1, "loop");
    push_keypress(L, key, is_end_of_seq);
    lua_call(L, 1, 0);

    sleephires(0.016);  // Sleep for 16ms.
  }

  return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
callq 0x48f0
callq 0x14dd5
movq %rax, %rbx
movq %rax, %rdi
callq 0x14fd8
leaq -0x76(%rip), %rsi       # 0x497e
movq %rbx, %rdi
xorl %edx, %edx
callq 0x55cc
leaq 0x1c674(%rip), %rsi     # 0x21079
movq %rbx, %rdi
callq 0x5a10
leaq 0x1c66f(%rip), %rsi     # 0x21083
movq %rbx, %rdi
xorl %edx, %edx
callq 0x1452e
testl %eax, %eax
jne 0x4a39
movq %rbx, %rdi
xorl %esi, %esi
movl $0xffffffff, %edx       # imm = 0xFFFFFFFF
xorl %ecx, %ecx
xorl %r8d, %r8d
xorl %r9d, %r9d
callq 0x5ef3
leaq 0x1c64c(%rip), %rsi     # 0x2108c
movq %rbx, %rdi
xorl %edx, %edx
callq 0x1452e
testl %eax, %eax
jne 0x4a65
movq %rbx, %rdi
xorl %esi, %esi
movl $0xffffffff, %edx       # imm = 0xFFFFFFFF
xorl %ecx, %ecx
xorl %r8d, %r8d
xorl %r9d, %r9d
callq 0x5ef3
leaq 0x1c62d(%rip), %r14     # 0x21099
movq %rbx, %rdi
movq %r14, %rsi
callq 0x5a10
movq %rbx, %rdi
xorl %esi, %esi
callq 0x4c71
movq %rbx, %rdi
movq %r14, %rsi
callq 0x569b
leaq 0x1c60e(%rip), %rdx     # 0x210a1
movq %rbx, %rdi
movl $0xffffffff, %esi       # imm = 0xFFFFFFFF
callq 0x57b9
movq %rbx, %rdi
xorl %esi, %esi
xorl %edx, %edx
xorl %ecx, %ecx
xorl %r8d, %r8d
callq 0x5e8b
movq %rbx, %rdi
movq %r14, %rsi
callq 0x569b
leaq -0x2c(%rbp), %r14
leaq 0x1d09d(%rip), %r15     # 0x21b64
leaq -0x40(%rbp), %r12
movq %r14, %rdi
callq 0x4801
cmpl $0x1b, %eax
je 0x4b34
movl %eax, %r13d
cmpl $0x71, %eax
je 0x4b34
cmpl $0x51, %r13d
je 0x4b34
movq %rbx, %rdi
movl $0xffffffff, %esi       # imm = 0xFFFFFFFF
movq %r15, %rdx
callq 0x57b9
movl -0x2c(%rbp), %edx
movq %rbx, %rdi
movl %r13d, %esi
callq 0x4948
movq %rbx, %rdi
movl $0x1, %esi
xorl %edx, %edx
xorl %ecx, %ecx
xorl %r8d, %r8d
callq 0x5e8b
movq $0x0, -0x40(%rbp)
movq $0xf42400, -0x38(%rbp)  # imm = 0xF42400
movq %r12, %rdi
xorl %esi, %esi
callq 0x4190
jmp 0x4acb
callq 0x4925
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O3/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:
subq $0x108, %rsp            # imm = 0x108
movl $0xff, %eax
cmpl %eax, %esi
cmovll %esi, %eax
testl %esi, %esi
jle 0x1335
movl %eax, %eax
xorl %ecx, %ecx
movb (%rdi,%rcx,2), %dl
movb %dl, (%rsp,%rcx)
incq %rcx
cmpq %rcx, %rax
jne 0x1325
jmp 0x1337
xorl %eax, %eax
movb $0x0, (%rsp,%rax)
movq %rsp, %rdi
xorl %esi, %esi
xorl %edx, %edx
callq 0x1170
addq $0x108, %rsp            # imm = 0x108
retq
// File: /workspace/github_c_makefile_star2_O3/MikeGray-APH[P]LibLouisAPH/source/utf-convert.c
// Function: utf16_convert_escapes
int utf16_convert_escapes(unichar *uchars, const int uchars_len)
{
	int crs, off, hex, i;

	if(uchars_len < 2)
		return uchars_len;

	crs =
	off = 0;
	while(off < uchars_len)
	{
		if(!uchars[off])
			break;
		else if(uchars[off] == u'\\')
		{
			off++;
			if(!uchars[off])
				return 0;
			else if(off >= uchars_len)
				return 0;
			switch(uchars[off])
			{
			default:    uchars[crs++] = uchars[off++];  break;
			case u'n':  uchars[crs++] = u'\n';  off++;  break;
			case u'r':  uchars[crs++] = u'\r';  off++;  break;
			case u't':  uchars[crs++] = u'\t';  off++;  break;
			case u's':  uchars[crs++] = u' ';   off++;  break;

			case u'x':  case u'X':  case u'u':  case u'U':

				if(off + 5 > uchars_len)
					return 0;
				hex = 0;
				off++;
				for(i = 0; i < 4; i++)
				{
					if(!uchars[off])
						return 0;
					else if(uchars[off] >= u'0' && uchars[off] <= u'9')
						hex += ((uchars[off++] - u'0')) << ((3 - i) * 4);
					else if(uchars[off] >= u'A' && uchars[off] <= u'F')
						hex += ((uchars[off++] - u'A') + 10) << ((3 - i) * 4);
					else if(uchars[off] >= u'a' && uchars[off] <= u'f')
						hex += ((uchars[off++] - u'a') + 10) << ((3 - i) * 4);
				}
				uchars[crs++] = hex;
				break;
			}
		}
		else
			uchars[crs++] = uchars[off++];
	}

	if(crs <= uchars_len)
		uchars[crs] = 0;
#ifdef DEBUG
	else
		ASSERT(0)
#endif
	return crs;
}

// Assembly:
pushq %rbx
cmpl $0x2, %esi
jge 0x135c
movl %esi, %eax
jmp 0x148a
xorl %edx, %edx
leaq 0x11cab(%rip), %r8      # 0x13010
xorl %r9d, %r9d
movslq %r9d, %rcx
movzwl (%rdi,%rcx,2), %eax
cmpl $0x5c, %eax
je 0x1388
testl %eax, %eax
je 0x147c
incl %r9d
movw %ax, (%rdi,%rdx,2)
jmp 0x1470
leal 0x1(%r9), %r10d
xorl %eax, %eax
cmpl %esi, %r10d
jge 0x148a
movzwl 0x2(%rdi,%rcx,2), %ecx
testw %cx, %cx
je 0x148a
movzwl %cx, %r10d
leal -0x6e(%r10), %r11d
cmpl $0xa, %r11d
ja 0x13c8
movslq (%r8,%r11,4), %r10
addq %r8, %r10
jmpq *%r10
movw $0xa, (%rdi,%rdx,2)
jmp 0x146c
cmpl $0x55, %r10d
je 0x13d4
cmpl $0x58, %r10d
jne 0x144c
leal 0x6(%r9), %ecx
cmpl %esi, %ecx
jg 0x148a
addl $0x2, %r9d
xorl %eax, %eax
movl $0xc, %ecx
xorl %r10d, %r10d
movslq %r9d, %r11
movzwl (%rdi,%r11,2), %r11d
testl %r11d, %r11d
je 0x148a
leal -0x30(%r11), %ebx
cmpw $0x9, %bx
ja 0x1413
incl %r9d
shll %cl, %ebx
addl %ebx, %r10d
jmp 0x143d
leal -0x41(%r11), %ebx
cmpw $0x5, %bx
ja 0x1423
addl $-0x37, %r11d
jmp 0x1431
leal -0x61(%r11), %ebx
cmpw $0x5, %bx
ja 0x143d
addl $-0x57, %r11d
shll %cl, %r11d
incl %r9d
addl %r10d, %r11d
movl %r11d, %r10d
addl $-0x4, %ecx
cmpl $-0x4, %ecx
jne 0x13ee
movw %r10w, (%rdi,%rdx,2)
jmp 0x1470
addl $0x2, %r9d
movw %cx, (%rdi,%rdx,2)
jmp 0x1470
movw $0x20, (%rdi,%rdx,2)
jmp 0x146c
movw $0x9, (%rdi,%rdx,2)
jmp 0x146c
movw $0xd, (%rdi,%rdx,2)
addl $0x2, %r9d
incq %rdx
cmpl %esi, %r9d
jl 0x1368
cmpl %esi, %edx
jg 0x148c
movl %edx, %eax
movw $0x0, (%rdi,%rax,2)
movl %edx, %eax
popq %rbx
retq
callq 0x1060
// File: /workspace/github_c_makefile_star2_O3/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:
testq %rdi, %rdi
je 0x1d87
pushq %rbx
movq %rdi, %rbx
movq 0x10(%rdi), %rax
testq %rax, %rax
je 0x1d86
addq $0x10, %rbx
movq %rax, %rdi
cmpl $-0x1, 0x4(%rdi)
movq 0x10(%rdi), %rax
jne 0x1d7a
movq %rax, (%rbx)
movq $0x0, 0x8(%rdi)
callq 0x1d88
movq (%rbx), %rdi
testq %rdi, %rdi
jne 0x1d56
jmp 0x1d86
addq $0x10, %rdi
movq %rdi, %rbx
testq %rax, %rax
jne 0x1d53
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O3/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 %rbx
testq %rdi, %rdi
je 0x1ddf
movq %rdi, %rbx
movq 0x8(%rdi), %rdi
callq 0x1d88
movq 0x80(%rbx), %rdi
testq %rdi, %rdi
je 0x1db8
cmpq $0x0, 0x20(%rdi)
jne 0x1db8
cmpq $0x0, (%rdi)
jne 0x1de1
callq 0x1e15
movq 0x88(%rbx), %rdi
testq %rdi, %rdi
je 0x1dd6
cmpq $0x0, 0x20(%rdi)
jne 0x1dd6
cmpq $0x0, (%rdi)
jne 0x1de1
callq 0x1e15
movq %rbx, %rdi
popq %rbx
jmp 0x1040
popq %rbx
retq
callq 0x1060
// File: /workspace/github_c_makefile_star2_O3/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 %rbx
testq %rdi, %rdi
je 0x1e0e
movq %rdi, %rbx
movq (%rdi), %rdi
callq 0x1de6
movq 0x70(%rbx), %rdi
testq %rdi, %rdi
je 0x1e10
callq 0x1040
movq %rbx, %rdi
popq %rbx
jmp 0x1040
popq %rbx
retq
callq 0x1060
// File: /workspace/github_c_makefile_star2_O3/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:
testq %rdi, %rdi
je 0x1e59
pushq %rbx
movq %rdi, %rbx
movq (%rdi), %rdi
callq 0x1e15
movq 0x8(%rbx), %rdi
testq %rdi, %rdi
je 0x1e34
callq 0x1040
movq 0x10(%rbx), %rdi
testq %rdi, %rdi
je 0x1e42
callq 0x1040
movq 0x20(%rbx), %rdi
testq %rdi, %rdi
je 0x1e50
callq 0x1040
movq %rbx, %rdi
popq %rbx
jmp 0x1040
retq
// File: /workspace/github_c_makefile_star2_O3/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:
testq %rdi, %rdi
je 0x1eb8
pushq %rbx
movq %rdi, %rbx
movq (%rdi), %rdi
callq 0x1e96
movq %rbx, %rdi
callq 0x1976
movq %rbx, %rdi
popq %rbx
jmp 0x1040
retq
// File: /workspace/github_c_makefile_star2_O3/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 %r14
pushq %rbx
pushq %rax
movl %esi, %ebx
movl %esi, %ecx
andl $0xf, %ecx
movq 0x1f8(%rdi,%rcx,8), %rax
testq %rax, %rax
je 0x1f42
movq %rax, %r14
movq (%rax), %rax
movzwl 0x20(%r14), %ecx
testq %rax, %rax
je 0x1f4f
cmpw %bx, %cx
jne 0x1f2b
jmp 0x1f63
leaq (%rdi,%rcx,8), %r14
addq $0x1f8, %r14            # imm = 0x1F8
jmp 0x1f54
cmpw %bx, %cx
je 0x1f63
callq 0x1eb9
movq %rax, (%r14)
movw %bx, 0x20(%rax)
movq %rax, %r14
movq %r14, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O3/MikeGray-APH[P]LibLouisAPH/source/table.c
// Function: table_convert_escape_markers
int table_convert_escape_markers(const struct table *table, unichar *uchars, const int uchars_len)
{
	int crs, off;

	if(uchars_len < 2)
		return uchars_len;

	crs =
	off = 0;
	while(off < uchars_len)
	{
		if(!uchars[off])
			break;
		else if(uchars[off] == u'\\')
		{
			off++;
			if(!uchars[off])
				return 0;
			else if(off >= uchars_len)
				return 0;
			switch(uchars[off])
			{
			case u'U':  uchars[crs++] = table->marker_user;      off++;  break;
			case u'B':  uchars[crs++] = table->marker_begin;     off++;  break;
			case u'E':  uchars[crs++] = table->marker_end;       off++;  break;
			case u'M':  uchars[crs++] = table->marker_modifier;  off++;  break;
			case u'H':  uchars[crs++] = table->marker_hard;      off++;  break;
			case u'S':  uchars[crs++] = table->marker_soft;      off++;  break;
			case u'I':  uchars[crs++] = table->marker_internal;  off++;  break;

			default:

				uchars[crs++] = uchars[off - 1];
				uchars[crs++] = uchars[off++];
				break;
			}
		}
		else
			uchars[crs++] = uchars[off++];
	}

	if(crs <= uchars_len)
		uchars[crs] = 0;
#ifdef DEBUG
	else
		ASSERT(0)
#endif
	return crs;
}

// Assembly:
cmpl $0x2, %edx
jge 0x202a
movl %edx, %eax
retq
pxor %xmm0, %xmm0
movq 0x1117a(%rip), %xmm1    # 0x131b0
movdqa 0x11182(%rip), %xmm2    # 0x131c0
leaq 0x1118b(%rip), %rcx     # 0x131d0
pcmpeqd %xmm3, %xmm3
movd %xmm0, %r10d
movslq %r10d, %r9
movzwl (%rsi,%r9,2), %eax
pshufd $0x55, %xmm0, %xmm4     # xmm4 = xmm0[1,1,1,1]
movd %xmm4, %r8d
cmpl $0x5c, %eax
je 0x207e
testl %eax, %eax
je 0x2139
psubd %xmm3, %xmm0
movslq %r8d, %r8
movw %ax, (%rsi,%r8,2)
jmp 0x2123
incl %r10d
xorl %eax, %eax
cmpl %edx, %r10d
jge 0x214a
movzwl 0x2(%rsi,%r9,2), %r10d
testw %r10w, %r10w
je 0x214a
movzwl %r10w, %eax
leal -0x42(%rax), %r10d
cmpl $0xb, %r10d
ja 0x20bc
movslq (%rcx,%r10,4), %rax
addq %rcx, %rax
jmpq *%rax
movzwl 0x1ea(%rdi), %eax
jmp 0x2117
cmpl $0x53, %eax
je 0x2110
cmpl $0x55, %eax
jne 0x20cf
movzwl 0x1e8(%rdi), %eax
jmp 0x2117
incq %r9
movslq %r8d, %rax
movw $0x5c, (%rsi,%rax,2)
movzwl (%rsi,%r9,2), %r8d
paddd %xmm2, %xmm0
movw %r8w, 0x2(%rsi,%rax,2)
jmp 0x2123
movzwl 0x1ec(%rdi), %eax
jmp 0x2117
movzwl 0x1f0(%rdi), %eax
jmp 0x2117
movzwl 0x1f4(%rdi), %eax
jmp 0x2117
movzwl 0x1ee(%rdi), %eax
jmp 0x2117
movzwl 0x1f2(%rdi), %eax
movslq %r8d, %r8
movw %ax, (%rsi,%r8,2)
paddd %xmm1, %xmm0
movd %xmm0, %eax
cmpl %edx, %eax
jl 0x2049
pshufd $0x55, %xmm0, %xmm0     # xmm0 = xmm0[1,1,1,1]
movd %xmm0, %r8d
cmpl %edx, %r8d
jg 0x214b
movslq %r8d, %rax
movw $0x0, (%rsi,%rax,2)
movl %r8d, %eax
retq
pushq %rax
callq 0x1060
// File: /workspace/github_c_makefile_star2_O3/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:
testq %rdi, %rdi
je 0x2ad3
testq %rcx, %rcx
je 0x2a9b
addq $0x10, %rcx
jmp 0x2aa2
movzbl (%rsi), %eax
leaq (%rdi,%rax,8), %rcx
movq (%rcx), %rax
testq %rax, %rax
je 0x2ad3
movl 0x78(%rax), %ecx
cmpl %edx, %ecx
jle 0x2ab7
movq 0x10(%rax), %rax
jmp 0x2aa5
testl %ecx, %ecx
jle 0x2ad2
xorl %edi, %edi
movzwl (%rsi,%rdi,2), %r8d
cmpw 0x46(%rax,%rdi,2), %r8w
jne 0x2ab1
incq %rdi
cmpq %rdi, %rcx
jne 0x2abd
retq
xorl %eax, %eax
retq
// File: /workspace/github_c_makefile_star2_O3/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 %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
xorl %r14d, %r14d
movl $0x218, %edx            # imm = 0x218
xorl %esi, %esi
callq 0x1110
movdqa 0x1071e(%rip), %xmm0    # 0x132b0
movdqa 0x10726(%rip), %xmm1    # 0x132c0
movdqa 0x1072e(%rip), %xmm2    # 0x132d0
movdqa %xmm0, %xmm3
por %xmm1, %xmm3
movdqu %xmm3, 0x10(%rbx,%r14,2)
addq $0x8, %r14
paddw %xmm2, %xmm0
cmpq $0x100, %r14            # imm = 0x100
jne 0x2ba2
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O3/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 %rbx
movl $0x1, %edi
movl $0x218, %esi            # imm = 0x218
callq 0x1150
movq %rax, %rbx
testq %rax, %rax
je 0x2c2f
movdqa 0x106b3(%rip), %xmm0    # 0x132b0
xorl %eax, %eax
movdqa 0x106b9(%rip), %xmm1    # 0x132c0
movdqa 0x106c1(%rip), %xmm2    # 0x132d0
movdqa %xmm0, %xmm3
por %xmm1, %xmm3
movdqu %xmm3, 0x10(%rbx,%rax,2)
addq $0x8, %rax
paddw %xmm2, %xmm0
cmpq $0x100, %rax            # imm = 0x100
jne 0x2c0f
jmp 0x2c4e
leaq 0x10606(%rip), %rsi     # 0x1323c
leaq 0x106a3(%rip), %rdx     # 0x132e0
movl $0x7, %edi
movl $0x35, %ecx
xorl %eax, %eax
callq 0xa278
movq %rbx, %rax
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O3/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:
testq %rdi, %rdi
je 0x2c7b
pushq %rbx
movq %rdi, %rbx
movq (%rdi), %rdi
callq 0x2c53
movq 0x8(%rbx), %rdi
testq %rdi, %rdi
je 0x2c72
callq 0x1040
movq %rbx, %rdi
popq %rbx
jmp 0x1040
retq
// File: /workspace/github_c_makefile_star2_O3/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:
testq %rdx, %rdx
sete %al
testl %esi, %esi
setle %cl
orb %al, %cl
jne 0x2cf8
leaq 0x210(%rdx), %rax
addq $0x10, %rdx
movl %esi, %ecx
xorl %esi, %esi
movzwl (%rdi,%rsi,2), %r8d
movzbl %r8b, %r9d
andl $0xff00, %r8d           # imm = 0xFF00
cmpl $0x2800, %r8d           # imm = 0x2800
leaq (%rdx,%r9,2), %r8
cmovneq %rax, %r8
movzwl (%r8), %r8d
movw %r8w, (%rdi,%rsi,2)
incq %rsi
cmpq %rsi, %rcx
jne 0x2cc8
retq
// File: /workspace/github_c_makefile_star2_O3/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:
testq %rdx, %rdx
sete %al
testl %esi, %esi
setle %cl
orb %al, %cl
jne 0x2d42
movl %esi, %eax
xorl %ecx, %ecx
movzwl (%rdi,%rcx,2), %r8d
xorl %esi, %esi
cmpw %r8w, 0x10(%rdx,%rsi,2)
je 0x2d30
incq %rsi
cmpq $0x100, %rsi            # imm = 0x100
jne 0x2d13
movzwl 0x210(%rdx), %esi
jmp 0x2d36
addl $0x2800, %esi           # imm = 0x2800
movw %si, (%rdi,%rcx,2)
incq %rcx
cmpq %rax, %rcx
jne 0x2d0c
retq
nop
// File: /workspace/github_c_makefile_star2_O3/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 %rbx
testq %rdi, %rdi
je 0x345e
movq %rdi, %rbx
movq (%rdi), %rdi
callq 0x3436
movq 0x8(%rbx), %rdi
testq %rdi, %rdi
je 0x3460
callq 0x1040
movq %rbx, %rdi
popq %rbx
jmp 0x1040
popq %rbx
retq
callq 0x1060
// File: /workspace/github_c_makefile_star2_O3/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 %r14
pushq %rbx
pushq %rax
testq %rdi, %rdi
je 0x34f8
movq %rdi, %rbx
movq (%rdi), %rdi
callq 0x3465
cmpl $0x0, 0x28(%rbx)
jne 0x3500
movq 0x8(%rbx), %rdi
testq %rdi, %rdi
je 0x3491
callq 0x1040
movq 0x10(%rbx), %rdi
testq %rdi, %rdi
je 0x349f
callq 0x1040
movq 0x30(%rbx), %rdi
testq %rdi, %rdi
je 0x34ad
callq 0x1040
movq 0x18(%rbx), %rdi
testq %rdi, %rdi
je 0x34e9
movl 0x24(%rbx), %eax
testl %eax, %eax
jle 0x34e4
xorl %r14d, %r14d
movq 0x18(%rbx), %rcx
movq (%rcx,%r14,8), %rdi
testq %rdi, %rdi
je 0x34d5
callq 0x1040
movl 0x24(%rbx), %eax
incq %r14
movslq %eax, %rcx
cmpq %rcx, %r14
jl 0x34c0
movq 0x18(%rbx), %rdi
callq 0x1040
movq %rbx, %rdi
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x1040
addq $0x8, %rsp
popq %rbx
popq %r14
retq
callq 0x1060
// File: /workspace/github_c_makefile_star2_O3/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:
testq %rdi, %rdi
je 0x396a
movabsq $0x100002600, %rax      # imm = 0x100002600
movzwl (%rdi), %ecx
leal -0x2000(%rcx), %edx
cmpl $0xc, %edx
jb 0x3944
cmpl $0x20, %ecx
ja 0x394f
movl %ecx, %edx
btq %rdx, %rax
jae 0x394a
addq $0x2, %rdi
jmp 0x3929
testq %rdx, %rdx
je 0x3963
cmpl $0xa0, %ecx
je 0x3944
movq %rdi, 0x168d2(%rip)     # 0x1a230
jmp 0x53ae
movq %rdi, 0x168c6(%rip)     # 0x1a230
xorl %eax, %eax
retq
// File: /workspace/github_c_makefile_star2_O3/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 %rax
movq 0x14e7a(%rip), %rax     # 0x1a230
testq %rax, %rax
je 0x5470
movzwl (%rax), %esi
testw %si, %si
je 0x546c
movq %rax, 0x14e56(%rip)     # 0x1a228
movl $0x0, 0x14e44(%rip)     # 0x1a220
addq $0x2, %rax
movl $0x1, %edx
movabsq $0x100002600, %rcx      # imm = 0x100002600
movzwl %si, %esi
leal -0x2000(%rsi), %edi
cmpl $0xc, %edi
jb 0x542f
cmpl $0x20, %esi
ja 0x540f
movl %esi, %edi
btq %rdi, %rcx
jb 0x542f
testq %rdi, %rdi
je 0x5465
cmpl $0xa0, %esi
je 0x542f
movl %edx, 0x14e03(%rip)     # 0x1a220
movq %rax, 0x14e0c(%rip)     # 0x1a230
movzwl (%rax), %esi
addq $0x2, %rax
incl %edx
jmp 0x53ef
movw $0x0, -0x2(%rax)
movzwl (%rax), %edx
leal -0x2000(%rdx), %esi
cmpl $0xc, %esi
jb 0x5458
cmpl $0x20, %edx
ja 0x5450
movl %edx, %esi
btq %rsi, %rcx
jb 0x5458
cmpl $0xa0, %edx
jne 0x545e
addq $0x2, %rax
jmp 0x5435
movq %rax, 0x14dcb(%rip)     # 0x1a230
movl $0x1, %eax
jmp 0x546e
xorl %eax, %eax
popq %rcx
retq
callq 0x1060
// File: /workspace/github_c_makefile_star2_O3/MikeGray-APH[P]LibLouisAPH/source/compile.c
// Function: compile_use
static int compile_use(void)
{
	if(!token_parse())
	{
		rule_filter_forward = NULL;
		rule_filter_backward = NULL;
		return 1;
	}

	if(token_is_equal("-", 1))
		rule_filter_forward = NULL;
	else if(!token_is_equal("=", 1))
		rule_filter_forward = token_get_filter();

	if(!token_parse())
	{
		rule_filter_backward = NULL;
		return 1;
	}

	if(token_is_equal("-", 1))
		rule_filter_backward = NULL;
	else if(!token_is_equal("=", 1))
		rule_filter_backward = token_get_filter();

	return 1;
}

// Assembly:
pushq %rax
callq 0x53ae
testl %eax, %eax
je 0x5b35
cmpl $0x1, 0x1473a(%rip)     # 0x1a220
jne 0x5afc
movq 0x14739(%rip), %rax     # 0x1a228
movzwl (%rax), %eax
cmpl $0x2d, %eax
je 0x5b4b
cmpl $0x3d, %eax
je 0x5b08
callq 0x6e6d
movq %rax, 0x12690(%rip)     # 0x18198
callq 0x53ae
testl %eax, %eax
je 0x5b40
cmpl $0x1, 0x14708(%rip)     # 0x1a220
jne 0x5b2e
movq 0x14707(%rip), %rax     # 0x1a228
movzwl (%rax), %eax
cmpl $0x2d, %eax
je 0x5b40
cmpl $0x3d, %eax
je 0x5b49
callq 0x6e6d
jmp 0x5b42
movq $0x0, 0x12658(%rip) # 0x18198
xorl %eax, %eax
movq %rax, 0x12647(%rip)     # 0x18190
popq %rax
retq
xorl %eax, %eax
jmp 0x5b01
// File: /workspace/github_c_makefile_star2_O3/MikeGray-APH[P]LibLouisAPH/source/compile.c
// Function: compile_uses
static int compile_uses(void)
{
	struct filter *forward, *backward;
	int status;

	if(!token_parse())
		goto return_fail;

	forward = rule_filter_forward;
	backward = rule_filter_backward;

	if(token_is_equal("-", 1))
		rule_filter_forward = NULL;
	else if(!token_is_equal("=", 1))
	{
		rule_filter_forward = token_get_filter();
		if(!rule_filter_forward)
			goto return_fail;
	}

	if(!token_parse())
	{
		rule_filter_forward = forward;
		goto return_fail;
	}

	if(token_is_equal("-", 1))
		rule_filter_backward = NULL;
	else if(!token_is_equal("=", 1))
	{
		rule_filter_backward = token_get_filter();
		if(!rule_filter_backward)
			goto return_fail;
	}

	if(!token_parse())
	{
		rule_filter_forward = forward;
		rule_filter_backward = backward;
		goto return_fail;
	}

	status = token_compile();

	rule_filter_forward = forward;
	rule_filter_backward = backward;
	return status;

	return_fail:
	log_message(LOG_ERROR, "%s:%d  invalid uses", table_file_names[include_depth], table_file_lines[include_depth]);
	return 0;
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
callq 0x53ae
testl %eax, %eax
je 0x5c27
movq 0x12631(%rip), %rbx     # 0x18198
movq 0x12622(%rip), %r14     # 0x18190
cmpl $0x1, 0x146ab(%rip)     # 0x1a220
jne 0x5b98
movq 0x146aa(%rip), %rax     # 0x1a228
movzwl (%rax), %eax
cmpl $0x3d, %eax
je 0x5ba9
cmpl $0x2d, %eax
jne 0x5b98
movq $0x0, 0x12602(%rip) # 0x18198
jmp 0x5ba9
callq 0x6e6d
movq %rax, 0x125f4(%rip)     # 0x18198
testq %rax, %rax
je 0x5c27
callq 0x53ae
testl %eax, %eax
je 0x5c10
cmpl $0x1, 0x14667(%rip)     # 0x1a220
jne 0x5bdc
movq 0x14666(%rip), %rax     # 0x1a228
movzwl (%rax), %eax
cmpl $0x3d, %eax
je 0x5bed
cmpl $0x2d, %eax
jne 0x5bdc
movq $0x0, 0x125b6(%rip) # 0x18190
jmp 0x5bed
callq 0x6e6d
movq %rax, 0x125a8(%rip)     # 0x18190
testq %rax, %rax
je 0x5c27
callq 0x53ae
testl %eax, %eax
je 0x5c19
callq 0x3da3
movq %rbx, 0x12596(%rip)     # 0x18198
movq %r14, 0x12587(%rip)     # 0x18190
movl $0x1, %ebx
jmp 0x5c58
movq %rbx, 0x12581(%rip)     # 0x18198
jmp 0x5c27
movq %rbx, 0x12578(%rip)     # 0x18198
movq %r14, 0x12569(%rip)     # 0x18190
movslq 0x1258a(%rip), %rax     # 0x181b8
leaq 0x125ab(%rip), %rcx     # 0x181e0
movq (%rcx,%rax,8), %rdx
leaq 0x12580(%rip), %rcx     # 0x181c0
movl (%rcx,%rax,4), %ecx
leaq 0xdc52(%rip), %rsi      # 0x1389c
xorl %ebx, %ebx
movl $0x6, %edi
xorl %eax, %eax
callq 0xa278
movl %ebx, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O3/MikeGray-APH[P]LibLouisAPH/source/compile.c
// Function: token_convert_to_int
static int token_convert_to_int(void)
{
	struct variable *var;

	switch(token_crs[0])
	{
	case u'0':  case u'1':  case u'2':  case u'3':  case u'4':
	case u'5':  case u'6':  case u'7':  case u'8':  case u'9':

		token_int = utf16_convert_to_int(token_crs, token_len);
		return 1;

	case u'$':

		var = variable_find(&token_crs[1], token_len - 1);
		if(!var)
		{
			log_message(LOG_ERROR, "%s:%d  variable $%#S not found", table_file_names[include_depth], table_file_lines[include_depth], &token_crs[1], token_len - 1);
			return 0;
		}
		token_int = var->value;
		return 1;

	case u'b':

		if(token_len < 3)
			break;
		if(token_crs[1] != u'i' || token_crs[2] != u't')
			break;
		if(token_len < 5)
			token_int = BIT(token_crs[3] - u'0');
		else
			token_int = BIT(((token_crs[3] - u'0') * 10) + (token_crs[4] - u'0'));
		return 1;
	}

	log_message(LOG_ERROR, "%s:%d  invalid value %#S", table_file_names[include_depth], table_file_lines[include_depth], token_crs, token_len);
	return 0;
}

// Assembly:
pushq %rbx
movq 0x13764(%rip), %r8      # 0x1a228
movzwl (%r8), %eax
leal -0x30(%rax), %ecx
cmpl $0xa, %ecx
jae 0x6aed
movl 0x1374a(%rip), %esi     # 0x1a220
movq %r8, %rdi
callq 0x130c
movl %eax, 0x13754(%rip)     # 0x1a238
movl $0x1, %ebx
movl %ebx, %eax
popq %rbx
retq
cmpl $0x24, %eax
je 0x6b47
cmpl $0x62, %eax
jne 0x6bbc
movl 0x1371e(%rip), %r9d     # 0x1a220
cmpl $0x3, %r9d
jl 0x6bc3
cmpw $0x69, 0x2(%r8)
jne 0x6bc3
cmpw $0x74, 0x4(%r8)
jne 0x6bc3
movl $0xfffffdf0, %eax       # imm = 0xFFFFFDF0
movzwl 0x6(%r8), %ecx
cmpl $0x4, %r9d
ja 0x6c01
addq %rax, %rcx
addq $0x1e0, %rcx            # imm = 0x1E0
jmp 0x6c11
addq $0x2, %r8
movl 0x136cf(%rip), %eax     # 0x1a220
leal -0x1(%rax), %r9d
movq 0x11644(%rip), %rcx     # 0x181a0
testq %rcx, %rcx
je 0x6b97
movl %r9d, %edx
cmpl %r9d, 0x10(%rcx)
jne 0x6b8f
cmpl $0x2, %eax
jl 0x6bf9
movq 0x8(%rcx), %rsi
xorl %edi, %edi
movzwl (%r8,%rdi,2), %r10d
cmpw (%rsi,%rdi,2), %r10w
jne 0x6b8f
incq %rdi
cmpq %rdi, %rdx
jne 0x6b79
jmp 0x6bf9
movq (%rcx), %rcx
testq %rcx, %rcx
jne 0x6b64
movslq 0x1161a(%rip), %rax     # 0x181b8
leaq 0x1163b(%rip), %rcx     # 0x181e0
movq (%rcx,%rax,8), %rdx
leaq 0x11610(%rip), %rcx     # 0x181c0
movl (%rcx,%rax,4), %ecx
leaq 0xcae8(%rip), %rsi      # 0x136a2
jmp 0x6be6
movl 0x1365d(%rip), %r9d     # 0x1a220
movslq 0x115ee(%rip), %rax     # 0x181b8
leaq 0x1160f(%rip), %rcx     # 0x181e0
movq (%rcx,%rax,8), %rdx
leaq 0x115e4(%rip), %rcx     # 0x181c0
movl (%rcx,%rax,4), %ecx
leaq 0xcadb(%rip), %rsi      # 0x136c1
xorl %ebx, %ebx
movl $0x6, %edi
xorl %eax, %eax
callq 0xa278
jmp 0x6ae9
movl 0x14(%rcx), %eax
jmp 0x6ade
leaq (%rcx,%rcx,4), %rcx
movzwl 0x8(%r8), %edx
addq %rax, %rdx
leaq (%rdx,%rcx,2), %rcx
movl $0x1, %eax
shlq %cl, %rax
movl %eax, 0x13619(%rip)     # 0x1a238
jmp 0x6ae4