LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O1/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 0x10dfb1
cmpq $0x0, 0x8(%rbx)
jns 0x10dfac
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 0x171a0(%rip), %rdx     # 0x12510b
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 0x3b366
movq %rbx, %rax
popq %rbx
retq
movq 0x8(%rsi), %rsi
movq 0x140(%rdi), %rcx
movq 0x44af5(%rip), %r8      # 0x152ab8
movq %rbx, %rdx
popq %rbx
jmp 0xfac8
// File: /workspace/github_c_makefile_star2_O1/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 0x3fa8f(%rip), %r14     # 0x14dfd0
movq (%r14), %rdi
movq 0x4fc2d(%rip), %rdx     # 0x15e178
leaq 0x16c7b(%rip), %rsi     # 0x1251cd
xorl %eax, %eax
callq 0x9390
movq (%r14), %rcx
leaq 0x16c87(%rip), %rdi     # 0x1251ea
movl $0x1f, %esi
movl $0x1, %edx
callq 0x9660
movq (%r14), %rcx
leaq 0x16c8e(%rip), %rdi     # 0x12520a
movl $0x1d, %esi
movl $0x1, %edx
callq 0x9660
movq (%r14), %rcx
leaq 0x16c93(%rip), %rdi     # 0x125228
movl $0x24, %esi
movl $0x1, %edx
callq 0x9660
movq (%r14), %rcx
leaq 0x16c9f(%rip), %rdi     # 0x12524d
movl $0x31, %esi
movl $0x1, %edx
callq 0x9660
movq (%r14), %rcx
leaq 0x16cb8(%rip), %rdi     # 0x12527f
movl $0x29, %esi
movl $0x1, %edx
callq 0x9660
movl %ebx, %edi
callq 0x9650
// File: /workspace/github_c_makefile_star2_O1/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, 0x4fb73(%rip)     # 0x15e161
jne 0x10e60b
movq 0x3f9d9(%rip), %rax     # 0x14dfd0
movq (%rax), %rdi
leaq 0x16d5d(%rip), %rsi     # 0x12535e
movq %rbx, %rdx
xorl %eax, %eax
callq 0x9390
movq %r14, %rdi
movq %rbx, %rsi
callq 0x38852
movq %rax, %rcx
xorl %eax, %eax
testq %rcx, %rcx
je 0x10e628
addq $0x8, %rsp
popq %rbx
popq %r14
retq
movq 0x3f9c9(%rip), %rax     # 0x14dff8
movq (%rax), %rdi
leaq 0x16c9b(%rip), %rsi     # 0x1252d4
movq %rbx, %rdx
xorl %eax, %eax
callq 0x9390
movl $0x1, %eax
jmp 0x10e620
// File: /workspace/github_c_makefile_star2_O1/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 0x91a0
movq %rax, %r15
movq %rbx, %rdi
callq 0x91a0
addl %r15d, %eax
addl $0x2, %eax
movslq %eax, %rdi
movl $0x1, %esi
callq 0x9360
movq %rax, %r12
movq %rax, %rdi
movq %r14, %rsi
callq 0x90d0
movslq %r15d, %rax
leaq (%r12,%rax), %rdi
incq %rdi
movb $0x2f, -0x1(%rdi)
movq %rbx, %rsi
callq 0x90d0
movq %r12, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O1/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 0x4fa86(%rip), %rdi     # 0x15e170
testq %rdi, %rdi
je 0x10e6ff
callq 0x9050
movq $0x0, 0x4fa71(%rip) # 0x15e170
movq 0x4fa62(%rip), %rdi     # 0x15e168
testq %rdi, %rdi
je 0x10e71b
callq 0x9050
movq $0x0, 0x4fa4d(%rip) # 0x15e168
popq %rax
retq
// File: /workspace/github_c_makefile_star2_O1/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 0x4bb0(%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 0x266e
leaq 0x19fe(%rip), %rdi      # 0x4056
xorl %r14d, %r14d
xorl %eax, %eax
callq 0x2e20
movl %ebp, %edi
callq 0x2170
jmp 0x2762
addq %r14, %r15
movq 0x10(%r15), %rdi
testq %rdi, %rdi
je 0x2687
callq 0x2040
movq $0x0, 0x10(%r15)
movq 0x18(%r15), %rdi
testq %rdi, %rdi
je 0x269d
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 0x26ca
cmpl $0x2, %esi
jne 0x2715
leaq 0x24(%r15), %rsi
movl $0x2, %edi
jmp 0x26d3
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 0x197c(%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 0x2723
leaq 0x1956(%rip), %rdi      # 0x4072
xorl %eax, %eax
callq 0x2eb3
movl %ebp, (%r15)
movl $0x1, 0x4(%r15)
movb $0x0, 0x8(%r15)
movq 0x10(%r15), %rdx
leaq 0x1947(%rip), %rdi      # 0x4085
leaq 0xe(%rsp), %rcx
movl %ebp, %esi
xorl %eax, %eax
callq 0x2d8d
movl $0x1, %r14d
cmpl %ebx, 0x8a88(%rip)      # 0xb1e0
jg 0x2762
incl %ebx
movl %ebx, 0x8a7e(%rip)      # 0xb1e0
movl %r14d, %eax
addq $0x18, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/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 0x4900
callq 0x142ea
movq %rax, %rbx
movq %rax, %rdi
callq 0x144ec
leaq -0x76(%rip), %rsi       # 0x498e
movq %rbx, %rdi
xorl %edx, %edx
callq 0x54b5
leaq 0x1b664(%rip), %rsi     # 0x20079
movq %rbx, %rdi
callq 0x58eb
leaq 0x1b65f(%rip), %rsi     # 0x20083
movq %rbx, %rdi
xorl %edx, %edx
callq 0x13a5d
testl %eax, %eax
jne 0x4a49
movq %rbx, %rdi
xorl %esi, %esi
movl $0xffffffff, %edx       # imm = 0xFFFFFFFF
xorl %ecx, %ecx
xorl %r8d, %r8d
xorl %r9d, %r9d
callq 0x5dae
leaq 0x1b63c(%rip), %rsi     # 0x2008c
movq %rbx, %rdi
xorl %edx, %edx
callq 0x13a5d
testl %eax, %eax
jne 0x4a75
movq %rbx, %rdi
xorl %esi, %esi
movl $0xffffffff, %edx       # imm = 0xFFFFFFFF
xorl %ecx, %ecx
xorl %r8d, %r8d
xorl %r9d, %r9d
callq 0x5dae
leaq 0x1b61d(%rip), %r14     # 0x20099
movq %rbx, %rdi
movq %r14, %rsi
callq 0x58eb
movq %rbx, %rdi
xorl %esi, %esi
callq 0x4c75
movq %rbx, %rdi
movq %r14, %rsi
callq 0x5584
leaq 0x1b5fe(%rip), %rdx     # 0x200a1
movq %rbx, %rdi
movl $0xffffffff, %esi       # imm = 0xFFFFFFFF
callq 0x569b
movq %rbx, %rdi
xorl %esi, %esi
xorl %edx, %edx
xorl %ecx, %ecx
xorl %r8d, %r8d
callq 0x5d46
movq %rbx, %rdi
movq %r14, %rsi
callq 0x5584
leaq -0x2c(%rbp), %r14
leaq 0x1c01d(%rip), %r15     # 0x20af4
leaq -0x40(%rbp), %r12
movq %r14, %rdi
callq 0x4811
cmpl $0x1b, %eax
je 0x4b44
movl %eax, %r13d
cmpl $0x71, %eax
je 0x4b44
cmpl $0x51, %r13d
je 0x4b44
movq %rbx, %rdi
movl $0xffffffff, %esi       # imm = 0xFFFFFFFF
movq %r15, %rdx
callq 0x569b
movl -0x2c(%rbp), %edx
movq %rbx, %rdi
movl %r13d, %esi
callq 0x4958
movq %rbx, %rdi
movl $0x1, %esi
xorl %edx, %edx
xorl %ecx, %ecx
xorl %r8d, %r8d
callq 0x5d46
movq $0x0, -0x40(%rbp)
movq $0xf42400, -0x38(%rbp)  # imm = 0xF42400
movq %r12, %rdi
xorl %esi, %esi
callq 0x41a0
jmp 0x4adb
callq 0x4935
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O1/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
testl %esi, %esi
jle 0x1323
movl $0xff, %ecx
cmpl %ecx, %esi
cmovll %esi, %ecx
xorl %eax, %eax
movb (%rdi,%rax,2), %dl
movb %dl, (%rsp,%rax)
incq %rax
cmpq %rax, %rcx
jne 0x1313
jmp 0x1325
xorl %eax, %eax
movb $0x0, (%rsp,%rax)
movq %rsp, %rdi
xorl %esi, %esi
xorl %edx, %edx
callq 0x1160
addq $0x108, %rsp            # imm = 0x108
retq
// File: /workspace/github_c_makefile_star2_O1/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 0x134a
movl %esi, %eax
jmp 0x1478
xorl %edx, %edx
leaq 0x11cbd(%rip), %r8      # 0x13010
xorl %r9d, %r9d
movslq %r9d, %rcx
movzwl (%rdi,%rcx,2), %eax
cmpl $0x5c, %eax
je 0x1376
testl %eax, %eax
je 0x146a
incl %r9d
movw %ax, (%rdi,%rdx,2)
jmp 0x145e
leal 0x1(%r9), %r10d
xorl %eax, %eax
cmpl %esi, %r10d
jge 0x1478
movzwl 0x2(%rdi,%rcx,2), %ecx
testw %cx, %cx
je 0x1478
movzwl %cx, %r10d
leal -0x6e(%r10), %r11d
cmpl $0xa, %r11d
ja 0x13b6
movslq (%r8,%r11,4), %r10
addq %r8, %r10
jmpq *%r10
movw $0xa, (%rdi,%rdx,2)
jmp 0x145a
cmpl $0x55, %r10d
je 0x13c2
cmpl $0x58, %r10d
jne 0x143a
leal 0x6(%r9), %ecx
cmpl %esi, %ecx
jg 0x1478
addl $0x2, %r9d
xorl %eax, %eax
movl $0xc, %ecx
xorl %r10d, %r10d
movslq %r9d, %r11
movzwl (%rdi,%r11,2), %r11d
testl %r11d, %r11d
je 0x1478
leal -0x30(%r11), %ebx
cmpw $0x9, %bx
ja 0x1401
incl %r9d
shll %cl, %ebx
addl %ebx, %r10d
jmp 0x142b
leal -0x41(%r11), %ebx
cmpw $0x5, %bx
ja 0x1411
addl $-0x37, %r11d
jmp 0x141f
leal -0x61(%r11), %ebx
cmpw $0x5, %bx
ja 0x142b
addl $-0x57, %r11d
shll %cl, %r11d
incl %r9d
addl %r10d, %r11d
movl %r11d, %r10d
addl $-0x4, %ecx
cmpl $-0x4, %ecx
jne 0x13dc
movw %r10w, (%rdi,%rdx,2)
jmp 0x145e
addl $0x2, %r9d
movw %cx, (%rdi,%rdx,2)
jmp 0x145e
movw $0x20, (%rdi,%rdx,2)
jmp 0x145a
movw $0x9, (%rdi,%rdx,2)
jmp 0x145a
movw $0xd, (%rdi,%rdx,2)
addl $0x2, %r9d
incq %rdx
cmpl %esi, %r9d
jl 0x1356
cmpl %esi, %edx
jg 0x147a
movl %edx, %eax
movw $0x0, (%rdi,%rax,2)
movl %edx, %eax
popq %rbx
retq
callq 0x1060
// File: /workspace/github_c_makefile_star2_O1/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 0x1d71
movq %rdi, %rbx
movq 0x8(%rdi), %rdi
callq 0x1d1a
movq 0x80(%rbx), %rdi
testq %rdi, %rdi
je 0x1d4a
cmpq $0x0, 0x20(%rdi)
jne 0x1d4a
cmpq $0x0, (%rdi)
jne 0x1d73
callq 0x1da7
movq 0x88(%rbx), %rdi
testq %rdi, %rdi
je 0x1d68
cmpq $0x0, 0x20(%rdi)
jne 0x1d68
cmpq $0x0, (%rdi)
jne 0x1d73
callq 0x1da7
movq %rbx, %rdi
popq %rbx
jmp 0x1040
popq %rbx
retq
callq 0x1060
// File: /workspace/github_c_makefile_star2_O1/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 0x1da0
movq %rdi, %rbx
movq (%rdi), %rdi
callq 0x1d78
movq 0x70(%rbx), %rdi
testq %rdi, %rdi
je 0x1da2
callq 0x1040
movq %rbx, %rdi
popq %rbx
jmp 0x1040
popq %rbx
retq
callq 0x1060
// File: /workspace/github_c_makefile_star2_O1/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 0x1deb
pushq %rbx
movq %rdi, %rbx
movq (%rdi), %rdi
callq 0x1da7
movq 0x8(%rbx), %rdi
testq %rdi, %rdi
je 0x1dc6
callq 0x1040
movq 0x10(%rbx), %rdi
testq %rdi, %rdi
je 0x1dd4
callq 0x1040
movq 0x20(%rbx), %rdi
testq %rdi, %rdi
je 0x1de2
callq 0x1040
movq %rbx, %rdi
popq %rbx
jmp 0x1040
retq
// File: /workspace/github_c_makefile_star2_O1/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 %rax
movl $0x320, %edi            # imm = 0x320
callq 0x1180
testq %rax, %rax
je 0x1e0c
movl $0x320, %edx            # imm = 0x320
movq %rax, %rdi
xorl %esi, %esi
popq %rax
jmp 0x1110
leaq 0x113e1(%rip), %rsi     # 0x131f4
leaq 0x113fa(%rip), %rdx     # 0x13214
movl $0x7, %edi
movl $0xeb, %ecx
xorl %eax, %eax
callq 0xa36c
xorl %eax, %eax
popq %rcx
retq
// File: /workspace/github_c_makefile_star2_O1/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 0x1e51
pushq %rbx
movq %rdi, %rbx
movq (%rdi), %rdi
callq 0x1e2f
movq %rbx, %rdi
callq 0x1922
movq %rbx, %rdi
popq %rbx
jmp 0x1040
retq
// File: /workspace/github_c_makefile_star2_O1/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 %rax
movl $0x28, %edi
callq 0x1180
testq %rax, %rax
je 0x1e76
xorps %xmm0, %xmm0
movups %xmm0, 0x10(%rax)
movups %xmm0, (%rax)
movq $0x0, 0x20(%rax)
popq %rcx
retq
leaq 0x11377(%rip), %rsi     # 0x131f4
leaq 0x11390(%rip), %rdx     # 0x13214
movl $0x7, %edi
movl $0x109, %ecx            # imm = 0x109
xorl %eax, %eax
callq 0xa36c
xorl %eax, %eax
popq %rcx
retq
// File: /workspace/github_c_makefile_star2_O1/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 0x1ee6
movq %rax, %r14
movq (%rax), %rax
movzwl 0x20(%r14), %ecx
testq %rax, %rax
je 0x1ef3
cmpw %bx, %cx
jne 0x1ecf
jmp 0x1f07
leaq (%rdi,%rcx,8), %r14
addq $0x1f8, %r14            # imm = 0x1F8
jmp 0x1ef8
cmpw %bx, %cx
je 0x1f07
callq 0x1e52
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_O1/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 %rax
movl $0x80, %edi
callq 0x1180
testq %rax, %rax
je 0x1f46
xorps %xmm0, %xmm0
movups %xmm0, 0x70(%rax)
movups %xmm0, 0x60(%rax)
movups %xmm0, 0x50(%rax)
movups %xmm0, 0x40(%rax)
movups %xmm0, 0x30(%rax)
movups %xmm0, 0x20(%rax)
movups %xmm0, 0x10(%rax)
movups %xmm0, (%rax)
popq %rcx
retq
leaq 0x112a7(%rip), %rsi     # 0x131f4
leaq 0x112c0(%rip), %rdx     # 0x13214
movl $0x7, %edi
movl $0x151, %ecx            # imm = 0x151
xorl %eax, %eax
callq 0xa36c
xorl %eax, %eax
popq %rcx
retq
// File: /workspace/github_c_makefile_star2_O1/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 %rax
movl $0x30, %edi
callq 0x1180
testq %rax, %rax
je 0x1f89
xorps %xmm0, %xmm0
movups %xmm0, 0x20(%rax)
movups %xmm0, 0x10(%rax)
movups %xmm0, (%rax)
popq %rcx
retq
leaq 0x11264(%rip), %rsi     # 0x131f4
leaq 0x1127d(%rip), %rdx     # 0x13214
movl $0x7, %edi
movl $0x169, %ecx            # imm = 0x169
xorl %eax, %eax
callq 0xa36c
xorl %eax, %eax
popq %rcx
retq
// File: /workspace/github_c_makefile_star2_O1/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 %rax
movl $0x90, %edi
callq 0x1180
testq %rax, %rax
je 0x1fcc
movl $0x90, %edx
movq %rax, %rdi
xorl %esi, %esi
popq %rax
jmp 0x1110
leaq 0x11221(%rip), %rsi     # 0x131f4
leaq 0x1123a(%rip), %rdx     # 0x13214
movl $0x7, %edi
movl $0x185, %ecx            # imm = 0x185
xorl %eax, %eax
callq 0xa36c
xorl %eax, %eax
popq %rcx
retq
// File: /workspace/github_c_makefile_star2_O1/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:
pushq %rbx
cmpl $0x2, %edx
jge 0x1ffc
movl %edx, %eax
jmp 0x20ee
xorl %r8d, %r8d
leaq 0x11182(%rip), %r9      # 0x13188
xorl %ecx, %ecx
movslq %r8d, %r11
movzwl (%rsi,%r11,2), %r10d
cmpl $0x5c, %r10d
je 0x2031
testl %r10d, %r10d
je 0x20df
incl %r8d
movslq %ecx, %rax
incl %ecx
movw %r10w, (%rsi,%rax,2)
jmp 0x20d6
leal 0x1(%r8), %ebx
xorl %eax, %eax
cmpl %edx, %ebx
jge 0x20ee
movzwl 0x2(%rsi,%r11,2), %ebx
testw %bx, %bx
je 0x20ee
movzwl %bx, %eax
leal -0x42(%rax), %ebx
cmpl $0xb, %ebx
ja 0x206b
movslq (%r9,%rbx,4), %rax
addq %r9, %rax
jmpq *%rax
movzwl 0x1ea(%rdi), %eax
jmp 0x20c8
cmpl $0x53, %eax
je 0x20c1
cmpl $0x55, %eax
jne 0x207e
movzwl 0x1e8(%rdi), %eax
jmp 0x20c8
incq %r11
movslq %ecx, %rax
movw %r10w, (%rsi,%rax,2)
addl $0x2, %r8d
movzwl (%rsi,%r11,2), %r10d
addl $0x2, %ecx
movw %r10w, 0x2(%rsi,%rax,2)
jmp 0x20d6
movzwl 0x1ec(%rdi), %eax
jmp 0x20c8
movzwl 0x1f0(%rdi), %eax
jmp 0x20c8
movzwl 0x1f4(%rdi), %eax
jmp 0x20c8
movzwl 0x1ee(%rdi), %eax
jmp 0x20c8
movzwl 0x1f2(%rdi), %eax
movslq %ecx, %r10
incl %ecx
movw %ax, (%rsi,%r10,2)
addl $0x2, %r8d
cmpl %edx, %r8d
jl 0x2008
cmpl %edx, %ecx
jg 0x20f0
movslq %ecx, %rax
movw $0x0, (%rsi,%rax,2)
movl %ecx, %eax
popq %rbx
retq
callq 0x1060
// File: /workspace/github_c_makefile_star2_O1/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 0x2b6c
testq %rcx, %rcx
je 0x2b6f
addq $0x10, %rcx
jmp 0x2b76
xorl %eax, %eax
retq
movzbl (%rsi), %eax
leaq (%rdi,%rax,8), %rcx
movq (%rcx), %rax
testq %rax, %rax
je 0x2ba6
movl 0x78(%rax), %ecx
cmpl %edx, %ecx
jle 0x2b8b
movq 0x10(%rax), %rax
jmp 0x2b79
testl %ecx, %ecx
jle 0x2ba6
xorl %edi, %edi
movzwl (%rsi,%rdi,2), %r8d
cmpw 0x46(%rax,%rdi,2), %r8w
jne 0x2b85
incq %rdi
cmpq %rdi, %rcx
jne 0x2b91
retq
// File: /workspace/github_c_makefile_star2_O1/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 $0x218, %edi            # imm = 0x218
callq 0x1180
testq %rax, %rax
je 0x2ccc
movq %rax, %rbx
movl $0x218, %edx            # imm = 0x218
movq %rax, %rdi
xorl %esi, %esi
callq 0x1110
movl $0x8, %eax
leal 0x27f8(%rax), %ecx
movw %cx, (%rbx,%rax,2)
incq %rax
cmpq $0x108, %rax            # imm = 0x108
jne 0x2cb5
jmp 0x2ced
leaq 0x10521(%rip), %rsi     # 0x131f4
leaq 0x10585(%rip), %rdx     # 0x1325f
xorl %ebx, %ebx
movl $0x7, %edi
movl $0x35, %ecx
xorl %eax, %eax
callq 0xa36c
movq %rbx, %rax
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O1/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 0x2d1a
pushq %rbx
movq %rdi, %rbx
movq (%rdi), %rdi
callq 0x2cf2
movq 0x8(%rbx), %rdi
testq %rdi, %rdi
je 0x2d11
callq 0x1040
movq %rbx, %rdi
popq %rbx
jmp 0x1040
retq
// File: /workspace/github_c_makefile_star2_O1/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 0x2d97
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 0x2d67
retq
// File: /workspace/github_c_makefile_star2_O1/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 0x2de1
movl %esi, %eax
xorl %ecx, %ecx
movzwl (%rdi,%rcx,2), %r8d
xorl %esi, %esi
cmpw %r8w, 0x10(%rdx,%rsi,2)
je 0x2dcf
incq %rsi
cmpq $0x100, %rsi            # imm = 0x100
jne 0x2db2
movzwl 0x210(%rdx), %esi
jmp 0x2dd5
addl $0x2800, %esi           # imm = 0x2800
movw %si, (%rdi,%rcx,2)
incq %rcx
cmpq %rax, %rcx
jne 0x2dab
retq
nop
// File: /workspace/github_c_makefile_star2_O1/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 0x34d0
movq %rdi, %rbx
movq (%rdi), %rdi
callq 0x34a8
movq 0x8(%rbx), %rdi
testq %rdi, %rdi
je 0x34d2
callq 0x1040
movq %rbx, %rdi
popq %rbx
jmp 0x1040
popq %rbx
retq
callq 0x1060
// File: /workspace/github_c_makefile_star2_O1/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 0x3565
movq %rdi, %rbx
movq (%rdi), %rdi
callq 0x34d7
cmpl $0x0, 0x28(%rbx)
jne 0x356d
movq 0x8(%rbx), %rdi
testq %rdi, %rdi
je 0x3503
callq 0x1040
movq 0x10(%rbx), %rdi
testq %rdi, %rdi
je 0x3511
callq 0x1040
movq 0x30(%rbx), %rdi
testq %rdi, %rdi
je 0x351f
callq 0x1040
cmpq $0x0, 0x18(%rbx)
je 0x3556
cmpl $0x0, 0x24(%rbx)
jle 0x354d
xorl %r14d, %r14d
movq 0x18(%rbx), %rax
movq (%rax,%r14,8), %rdi
testq %rdi, %rdi
je 0x3541
callq 0x1040
incq %r14
movslq 0x24(%rbx), %rax
cmpq %rax, %r14
jl 0x352f
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_O1/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 0x39da
movabsq $0x100002600, %rax      # imm = 0x100002600
movzwl (%rdi), %ecx
leal -0x2000(%rcx), %edx
cmpl $0xc, %edx
jb 0x39b4
cmpl $0x20, %ecx
ja 0x39bf
movl %ecx, %edx
btq %rdx, %rax
jae 0x39ba
addq $0x2, %rdi
jmp 0x3999
testq %rdx, %rdx
je 0x39d3
cmpl $0xa0, %ecx
je 0x39b4
movq %rdi, 0x16862(%rip)     # 0x1a230
jmp 0x5525
movq %rdi, 0x16856(%rip)     # 0x1a230
xorl %eax, %eax
retq
// File: /workspace/github_c_makefile_star2_O1/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 0x14d03(%rip), %rax     # 0x1a230
testq %rax, %rax
je 0x55ea
cmpw $0x0, (%rax)
je 0x55e6
movq %rax, 0x14ce1(%rip)     # 0x1a228
movl $0x0, 0x14ccf(%rip)     # 0x1a220
movq 0x14cd8(%rip), %rax     # 0x1a230
addq $0x2, %rax
movl $0x1, %edx
movabsq $0x100002600, %rcx      # imm = 0x100002600
movzwl -0x2(%rax), %esi
leal -0x2000(%rsi), %edi
cmpl $0xc, %edi
jb 0x55a9
cmpl $0x20, %esi
ja 0x558c
movl %esi, %edi
btq %rdi, %rcx
jb 0x55a9
testq %rdi, %rdi
je 0x55df
cmpl $0xa0, %esi
je 0x55a9
movl %edx, 0x14c86(%rip)     # 0x1a220
movq %rax, 0x14c8f(%rip)     # 0x1a230
addq $0x2, %rax
incl %edx
jmp 0x556b
movw $0x0, -0x2(%rax)
movzwl (%rax), %edx
leal -0x2000(%rdx), %esi
cmpl $0xc, %esi
jb 0x55d2
cmpl $0x20, %edx
ja 0x55ca
movl %edx, %esi
btq %rsi, %rcx
jb 0x55d2
cmpl $0xa0, %edx
jne 0x55d8
addq $0x2, %rax
jmp 0x55af
movq %rax, 0x14c51(%rip)     # 0x1a230
movl $0x1, %eax
jmp 0x55e8
xorl %eax, %eax
popq %rcx
retq
callq 0x1060
// File: /workspace/github_c_makefile_star2_O1/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 0x5525
testl %eax, %eax
je 0x5ca7
movl 0x1458f(%rip), %eax     # 0x1a220
cmpl $0x1, %eax
jne 0x5cbf
movq 0x1458b(%rip), %rcx     # 0x1a228
cmpw $0x2d, (%rcx)
jne 0x5cb4
xorl %eax, %eax
jmp 0x5cc4
movq $0x0, 0x124e6(%rip) # 0x18198
jmp 0x5cec
cmpl $0x1, %eax
jne 0x5cbf
cmpw $0x3d, (%rcx)
je 0x5ccb
callq 0x7070
movq %rax, 0x124cd(%rip)     # 0x18198
callq 0x5525
testl %eax, %eax
je 0x5cec
movl 0x14546(%rip), %eax     # 0x1a220
cmpl $0x1, %eax
jne 0x5cfb
movq 0x14542(%rip), %rcx     # 0x1a228
cmpw $0x2d, (%rcx)
jne 0x5cf0
xorl %eax, %eax
jmp 0x5d00
cmpl $0x1, %eax
jne 0x5cfb
cmpw $0x3d, (%rcx)
je 0x5d07
callq 0x7070
movq %rax, 0x12489(%rip)     # 0x18190
popq %rax
retq
// File: /workspace/github_c_makefile_star2_O1/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 0x5525
testl %eax, %eax
je 0x5df1
movq 0x12477(%rip), %rbx     # 0x18198
movq 0x12468(%rip), %r14     # 0x18190
movl 0x144f2(%rip), %eax     # 0x1a220
cmpl $0x1, %eax
jne 0x5d58
movq 0x144ee(%rip), %rcx     # 0x1a228
cmpw $0x2d, (%rcx)
jne 0x5d4d
movq $0x0, 0x1244d(%rip) # 0x18198
jmp 0x5d6d
cmpl $0x1, %eax
jne 0x5d58
cmpw $0x3d, (%rcx)
je 0x5d6d
callq 0x7070
movq %rax, 0x12434(%rip)     # 0x18198
testq %rax, %rax
je 0x5df1
callq 0x5525
testl %eax, %eax
je 0x5d9b
movl 0x144a4(%rip), %eax     # 0x1a220
cmpl $0x1, %eax
jne 0x5daf
movq 0x144a0(%rip), %rcx     # 0x1a228
cmpw $0x2d, (%rcx)
jne 0x5da4
movq $0x0, 0x123f7(%rip) # 0x18190
jmp 0x5dc0
movq %rbx, 0x123f6(%rip)     # 0x18198
jmp 0x5df1
cmpl $0x1, %eax
jne 0x5daf
cmpw $0x3d, (%rcx)
je 0x5dc0
callq 0x7070
movq %rax, 0x123d5(%rip)     # 0x18190
testq %rax, %rax
je 0x5df1
callq 0x5525
testl %eax, %eax
je 0x5de3
callq 0x3e97
movq %rbx, 0x123c3(%rip)     # 0x18198
movq %r14, 0x123b4(%rip)     # 0x18190
movl $0x1, %ebx
jmp 0x5e22
movq %rbx, 0x123ae(%rip)     # 0x18198
movq %r14, 0x1239f(%rip)     # 0x18190
movslq 0x123c0(%rip), %rax     # 0x181b8
leaq 0x123e1(%rip), %rcx     # 0x181e0
movq (%rcx,%rax,8), %rdx
leaq 0x123b6(%rip), %rcx     # 0x181c0
movl (%rcx,%rax,4), %ecx
leaq 0xd9ec(%rip), %rsi      # 0x13800
xorl %ebx, %ebx
movl $0x6, %edi
xorl %eax, %eax
callq 0xa36c
movl %ebx, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O1/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 0x13563(%rip), %r8      # 0x1a228
movzwl (%r8), %eax
leal -0x30(%rax), %ecx
cmpl $0xa, %ecx
jae 0x6cee
movl 0x13549(%rip), %esi     # 0x1a220
movq %r8, %rdi
callq 0x12fc
movl %eax, 0x13553(%rip)     # 0x1a238
movl $0x1, %ebx
movl %ebx, %eax
popq %rbx
retq
cmpl $0x24, %eax
je 0x6d72
cmpl $0x62, %eax
jne 0x6d35
movl 0x13522(%rip), %eax     # 0x1a220
cmpl $0x3, %eax
jl 0x6d35
cmpw $0x69, 0x2(%r8)
jne 0x6d35
cmpw $0x74, 0x4(%r8)
jne 0x6d35
movl $0xfffffdf0, %ecx       # imm = 0xFFFFFDF0
movzwl 0x6(%r8), %edx
cmpl $0x4, %eax
jg 0x6df3
addq %rdx, %rcx
addq $0x1e0, %rcx            # imm = 0x1E0
jmp 0x6e03
movslq 0x1147c(%rip), %rax     # 0x181b8
leaq 0x1149d(%rip), %rcx     # 0x181e0
movq (%rcx,%rax,8), %rdx
leaq 0x11472(%rip), %rcx     # 0x181c0
movl (%rcx,%rax,4), %ecx
movl 0x134c8(%rip), %r9d     # 0x1a220
leaq 0xc8c6(%rip), %rsi      # 0x13625
xorl %ebx, %ebx
movl $0x6, %edi
xorl %eax, %eax
callq 0xa36c
jmp 0x6cea
addq $0x2, %r8
movl 0x134a4(%rip), %ecx     # 0x1a220
leal -0x1(%rcx), %r9d
movq 0x11419(%rip), %rax     # 0x181a0
testq %rax, %rax
je 0x6dbe
movl %r9d, %edx
cmpl %r9d, 0x10(%rax)
jne 0x6db6
cmpl $0x2, %ecx
jl 0x6dbe
movq 0x8(%rax), %rsi
xorl %edi, %edi
movzwl (%r8,%rdi,2), %r10d
cmpw (%rsi,%rdi,2), %r10w
jne 0x6db6
incq %rdi
cmpq %rdi, %rdx
jne 0x6da0
jmp 0x6dbe
movq (%rax), %rax
testq %rax, %rax
jne 0x6d8f
testq %rax, %rax
je 0x6dcb
movl 0x14(%rax), %eax
jmp 0x6cdf
movslq 0x113e6(%rip), %rax     # 0x181b8
leaq 0x11407(%rip), %rcx     # 0x181e0
movq (%rcx,%rax,8), %rdx
leaq 0x113dc(%rip), %rcx     # 0x181c0
movl (%rcx,%rax,4), %ecx
leaq 0xc818(%rip), %rsi      # 0x13606
jmp 0x6d5f
leaq (%rdx,%rdx,4), %rax
movzwl 0x8(%r8), %edx
addq %rcx, %rdx
leaq (%rdx,%rax,2), %rcx
movl $0x1, %eax
shlq %cl, %rax
movl %eax, 0x13427(%rip)     # 0x1a238
jmp 0x6ce5
// File: /workspace/github_c_makefile_star2_O1/MikeGray-APH[P]LibLouisAPH/source/compile.c
// Function: convert_to_dots
static int convert_to_dots(unichar *uchars, const int uchars_len)
{
	unichar cell;
	int crs, off;

	cell = 0;
	crs = 0;
	for(off = 0; off < uchars_len; off++)
	{
		if(uchars[off] >= 0x2800 && uchars[off] <= 0x28ff)
		{
			if(cell)
			{
				uchars[crs++] = cell | 0x2800;
				cell = 0;
			}
			uchars[crs++] = uchars[off];
		}
		else if(uchars[off] == u'0')
			cell = 0x2800;
		else if(uchars[off] >= u'1' && uchars[off] <= u'8')
			cell |= (unichar)BIT(uchars[off] - u'1');
		else if(uchars[off] == u'-')
		{
			if(cell)
			{
				uchars[crs++] = cell | 0x2800;
				cell = 0;
			}
		}
		else
			return -1;
	}

	if(cell)
	{
		uchars[crs++] = cell | 0x2800;
		cell = 0;
	}

	return crs;
}

// Assembly:
testl %esi, %esi
jle 0x6eba
movl %esi, %edx
xorl %esi, %esi
xorl %eax, %eax
xorl %r8d, %r8d
movzwl (%rdi,%rsi,2), %ecx
movl %ecx, %r9d
andl $0xff00, %r9d           # imm = 0xFF00
cmpl $0x2800, %r9d           # imm = 0x2800
jne 0x6e68
testw %r8w, %r8w
je 0x6e55
orl $0x2800, %r8d           # imm = 0x2800
movslq %eax, %rcx
incl %eax
movw %r8w, (%rdi,%rcx,2)
movzwl (%rdi,%rsi,2), %ecx
movslq %eax, %r8
incl %eax
movw %cx, (%rdi,%r8,2)
xorl %r9d, %r9d
jmp 0x6e8f
movw $0x2800, %r9w           # imm = 0x2800
cmpl $0x30, %ecx
je 0x6e8f
leal -0x31(%rcx), %r9d
cmpw $0x7, %r9w
ja 0x6e9c
addb $-0x31, %cl
movl $0x1, %r9d
shlq %cl, %r9
orl %r9d, %r8d
movl %r8d, %r9d
incq %rsi
movl %r9d, %r8d
cmpq %rsi, %rdx
jne 0x6e27
jmp 0x6ebf
cmpl $0x2d, %ecx
jne 0x6ed7
testw %r8w, %r8w
je 0x6e63
orl $0x2800, %r8d           # imm = 0x2800
movslq %eax, %rcx
incl %eax
movw %r8w, (%rdi,%rcx,2)
jmp 0x6e63
xorl %r9d, %r9d
xorl %eax, %eax
testw %r9w, %r9w
je 0x6ed6
orl $0x2800, %r9d           # imm = 0x2800
movslq %eax, %rcx
incl %eax
movw %r9w, (%rdi,%rcx,2)
retq
movl $0xffffffff, %eax       # imm = 0xFFFFFFFF
retq
// File: /workspace/github_c_makefile_star2_O1/MikeGray-APH[P]LibLouisAPH/source/compile.c
// Function: token_get_filter
static struct filter* token_get_filter(void)
{
	struct filter *filter;

	filter = filter_find(token_crs, token_len);
	if(!filter)
	{
		log_message(LOG_ERROR, "%s:%d  filter %#S not found", table_file_names[include_depth], table_file_lines[include_depth], token_crs, token_len);
		return NULL;
	}
	return filter;
}

// Assembly:
pushq %rbx
movq 0x131b0(%rip), %r8      # 0x1a228
movl 0x131a1(%rip), %r9d     # 0x1a220
movq 0x110fa(%rip), %rax     # 0x18180
movq 0x20(%rax), %rbx
testq %rbx, %rbx
je 0x70ba
cmpl %r9d, 0x28(%rbx)
jne 0x70b5
testl %r9d, %r9d
jle 0x70ba
movq 0x20(%rbx), %rax
xorl %ecx, %ecx
movzwl (%r8,%rcx,2), %edx
cmpw (%rax,%rcx,2), %dx
jne 0x70b5
incq %rcx
cmpq %rcx, %r9
jne 0x70a0
jmp 0x70ba
movq (%rbx), %rbx
jmp 0x708a
testq %rbx, %rbx
jne 0x70f0
movslq 0x110f2(%rip), %rax     # 0x181b8
leaq 0x11113(%rip), %rcx     # 0x181e0
movq (%rcx,%rax,8), %rdx
leaq 0x110e8(%rip), %rcx     # 0x181c0
movl (%rcx,%rax,4), %ecx
leaq 0xc702(%rip), %rsi      # 0x137e4
xorl %ebx, %ebx
movl $0x6, %edi
xorl %eax, %eax
callq 0xa36c
movq %rbx, %rax
popq %rbx
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O1/MikeGray-APH[P]LibLouisAPH/source/translate.c
// Function: translate_is_marked_name_at
int translate_is_marked_name_at(const struct translate *translate, const unichar mark, const unichar *name, const int name_len, const int at)
{
	int i;

	if(at < 0 || at + name_len + 1 >= translate->input_len)
		return 0;
	if(translate->input[at] != mark)
		return 0;
	if(translate->input[at + name_len + 1] != mark)
		return 0;
	for(i = 0; i < name_len; i++)
	if(translate->input[at + 1 + i] != name[i])
		return 0;

	return 1;
}

// Assembly:
xorl %eax, %eax
testl %r8d, %r8d
js 0x714d
leal (%r8,%rcx), %r9d
incl %r9d
cmpl 0x44(%rdi), %r9d
jge 0x714d
movq 0x38(%rdi), %rdi
movl %r8d, %r8d
cmpw %si, (%rdi,%r8,2)
jne 0x714d
movslq %r9d, %r9
cmpw %si, (%rdi,%r9,2)
jne 0x714d
movl $0x1, %eax
testl %ecx, %ecx
jle 0x714d
movl %ecx, %ecx
leaq (%rdi,%r8,2), %rsi
addq $0x2, %rsi
xorl %edi, %edi
movzwl (%rsi,%rdi,2), %r8d
cmpw (%rdx,%rdi,2), %r8w
jne 0x714e
incq %rdi
cmpq %rdi, %rcx
jne 0x7139
retq
xorl %eax, %eax
retq
// File: /workspace/github_c_makefile_star2_O1/MikeGray-APH[P]LibLouisAPH/source/translate.c
// Function: translate_get_mode_indicator
enum mode_type translate_get_mode_indicator(const struct translate *translate, const struct table *table, const struct mode *mode)
{

	if(translate->input[translate->input_crs] != table->marker_hard && translate->input[translate->input_crs] != table->marker_soft)
		return NONE;

	if(translate_is_equal_at(translate, mode->begin, mode->begin_len, translate->input_crs + 1))
		return BEGIN;
	if(translate_is_equal_at(translate, mode->end, mode->end_len, translate->input_crs + 1))
		return END;
	if(translate_is_equal_at(translate, mode->word, mode->word_len, translate->input_crs + 1))
		return WORD;
	if(translate_is_equal_at(translate, mode->term, mode->term_len, translate->input_crs + 1))
		return TERM;
	if(translate_is_equal_at(translate, mode->symbol, mode->symbol_len, translate->input_crs + 1))
		return SYMBOL;

	return NONE;
}

// Assembly:
movq 0x38(%rdi), %rcx
movslq 0x40(%rdi), %r8
movzwl (%rcx,%r8,2), %r9d
cmpw 0x1f0(%rsi), %r9w
je 0x717b
movl $0x1, %eax
cmpw 0x1f2(%rsi), %r9w
jne 0x72d7
movl 0x54(%rdx), %esi
incq %r8
testq %rsi, %rsi
je 0x7193
leal (%rsi,%r8), %eax
cmpl 0x44(%rdi), %eax
jle 0x721d
movl 0x58(%rdx), %esi
testq %rsi, %rsi
je 0x71a8
leal (%rsi,%r8), %eax
cmpl 0x44(%rdi), %eax
jle 0x724f
movl 0x5c(%rdx), %esi
testq %rsi, %rsi
je 0x71bd
leal (%rsi,%r8), %eax
cmpl 0x44(%rdi), %eax
jle 0x727d
movl 0x60(%rdx), %esi
testq %rsi, %rsi
je 0x71d2
leal (%rsi,%r8), %eax
cmpl 0x44(%rdi), %eax
jle 0x72ab
movl 0x64(%rdx), %esi
movl $0x1, %eax
testq %rsi, %rsi
je 0x72d7
leal (%rsi,%r8), %r9d
cmpl 0x44(%rdi), %r9d
jg 0x72d7
testl %esi, %esi
jle 0x7217
movslq %r8d, %rdi
leaq (%rcx,%rdi,2), %rcx
xorl %edi, %edi
movzwl (%rcx,%rdi,2), %r8d
cmpw 0x44(%rdx,%rdi,2), %r8w
jne 0x72d7
incq %rdi
cmpq %rdi, %rsi
jne 0x71fe
movl $0x6, %eax
retq
movl $0x2, %eax
testl %esi, %esi
jle 0x72d7
leaq (%rcx,%r8,2), %r9
xorl %r10d, %r10d
movzwl (%r9,%r10,2), %r11d
cmpw 0xc(%rdx,%r10,2), %r11w
jne 0x7193
incq %r10
cmpq %r10, %rsi
jne 0x7231
jmp 0x72d7
movl $0x3, %eax
testl %esi, %esi
jle 0x72d7
movslq %r8d, %r9
leaq (%rcx,%r9,2), %r9
xorl %r10d, %r10d
movzwl (%r9,%r10,2), %r11d
cmpw 0x1a(%rdx,%r10,2), %r11w
jne 0x71a8
incq %r10
cmpq %r10, %rsi
jne 0x7262
jmp 0x72d7
movl $0x4, %eax
testl %esi, %esi
jle 0x72d7
movslq %r8d, %r9
leaq (%rcx,%r9,2), %r9
xorl %r10d, %r10d
movzwl (%r9,%r10,2), %r11d
cmpw 0x28(%rdx,%r10,2), %r11w
jne 0x71bd
incq %r10
cmpq %r10, %rsi
jne 0x7290
jmp 0x72d7
movl $0x5, %eax
testl %esi, %esi
jle 0x72d7
movslq %r8d, %r9
leaq (%rcx,%r9,2), %r9
xorl %r10d, %r10d
movzwl (%r9,%r10,2), %r11d
cmpw 0x36(%rdx,%r10,2), %r11w
jne 0x71d2
incq %r10
cmpq %r10, %rsi
jne 0x72be
retq
// File: /workspace/github_c_makefile_star2_O1/MikeGray-APH[P]LibLouisAPH/source/translate.c
// Function: translate_check_output_max
int translate_check_output_max(struct translate *translate, const int increment)
{
	if(translate->output_len + increment < translate->output_max)
		return 1;

	while(translate->output_len + increment >= translate->output_max)
		translate->output_max += translate->output_inc;
	translate->output = REALLOC(translate->output, translate->output_max * sizeof(unichar));
	if(!translate->output)
	{
		LOG_ALLOCATE_FAIL
		return 0;
	}

	translate->output_mask = REALLOC(translate->output_mask, translate->output_max);
	if(!translate->output_mask)
	{
		LOG_ALLOCATE_FAIL
		return 0;
	}

	if(translate->maps_use)
	{
		translate->output_to_input_map = REALLOC(translate->output_to_input_map, translate->output_max * sizeof(int));
		if(!translate->output_to_input_map)
			return 0;
	}

	return 1;
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movl 0x68(%rdi), %eax
leal (%rax,%rsi), %edx
movl $0x1, %ebx
cmpl 0x6c(%rdi), %edx
jl 0x73cb
movq %rdi, %r14
movl 0x6c(%rdi), %ecx
cmpl %ecx, %edx
jl 0x7332
movl 0x70(%r14), %edi
addl %esi, %eax
incl %eax
leal (%rcx,%rdi), %edx
xorl %esi, %esi
cmpl %edx, %eax
cmovlel %edx, %eax
setg %sil
addl %esi, %edx
subl %edx, %eax
cmpl $0x1, %edi
movl %edi, %r8d
adcl $0x0, %r8d
xorl %edx, %edx
divl %r8d
addl %esi, %eax
incl %eax
imull %edi, %eax
addl %ecx, %eax
movl %eax, 0x6c(%r14)
movl %eax, %ecx
movq 0x60(%r14), %rdi
movslq %ecx, %rsi
addq %rsi, %rsi
callq 0x11a0
movq %rax, 0x60(%r14)
testq %rax, %rax
je 0x738e
movq 0x80(%r14), %rdi
movslq 0x6c(%r14), %rsi
callq 0x11a0
movq %rax, 0x80(%r14)
testq %rax, %rax
je 0x73aa
cmpl $0x0, 0x90(%r14)
je 0x73cb
movq 0x78(%r14), %rdi
movslq 0x6c(%r14), %rsi
shlq $0x2, %rsi
callq 0x11a0
movq %rax, 0x78(%r14)
testq %rax, %rax
jne 0x73cb
xorl %ebx, %ebx
jmp 0x73cb
leaq 0xbe5f(%rip), %rsi      # 0x131f4
leaq 0xc636(%rip), %rdx      # 0x139d2
xorl %ebx, %ebx
movl $0x7, %edi
movl $0x64, %ecx
jmp 0x73c4
leaq 0xbe43(%rip), %rsi      # 0x131f4
leaq 0xc61a(%rip), %rdx      # 0x139d2
xorl %ebx, %ebx
movl $0x7, %edi
movl $0x6b, %ecx
xorl %eax, %eax
callq 0xa36c
movl %ebx, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
retq