LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O2/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 %r15
pushq %r14
pushq %rbx
movl %edi, %ebx
movq 0x43c1f(%rip), %r15     # 0x114fd0
movq (%r15), %rdi
movq 0x53dbd(%rip), %rdx     # 0x125178
leaq 0x16ebb(%rip), %rsi     # 0xe827d
xorl %eax, %eax
callq 0x8390
movq (%r15), %rcx
leaq 0x16ec7(%rip), %rdi     # 0xe829a
pushq $0x1f
popq %rsi
pushq $0x1
popq %r14
movq %r14, %rdx
callq 0x8660
movq (%r15), %rcx
leaq 0x16ece(%rip), %rdi     # 0xe82ba
pushq $0x1d
popq %rsi
movq %r14, %rdx
callq 0x8660
movq (%r15), %rcx
leaq 0x16ed7(%rip), %rdi     # 0xe82d8
pushq $0x24
popq %rsi
movq %r14, %rdx
callq 0x8660
movq (%r15), %rcx
leaq 0x16ee7(%rip), %rdi     # 0xe82fd
pushq $0x31
popq %rsi
movq %r14, %rdx
callq 0x8660
movq (%r15), %rcx
leaq 0x16f04(%rip), %rdi     # 0xe832f
pushq $0x29
popq %rsi
movq %r14, %rdx
callq 0x8660
movl %ebx, %edi
callq 0x8650
// File: /workspace/github_c_makefile_star2_O2/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, 0x53cdf(%rip)     # 0x125161
jne 0xd149f
movq 0x43b45(%rip), %rax     # 0x114fd0
movq (%rax), %rdi
leaq 0x16f79(%rip), %rsi     # 0xe840e
movq %rbx, %rdx
xorl %eax, %eax
callq 0x8390
movq %r14, %rdi
movq %rbx, %rsi
callq 0x2a33b
movq %rax, %rcx
xorl %eax, %eax
testq %rcx, %rcx
je 0xd14bc
addq $0x8, %rsp
popq %rbx
popq %r14
retq
movq 0x43b35(%rip), %rax     # 0x114ff8
movq (%rax), %rdi
leaq 0x16eb7(%rip), %rsi     # 0xe8384
movq %rbx, %rdx
xorl %eax, %eax
callq 0x8390
pushq $0x1
popq %rax
jmp 0xd14b4
// File: /workspace/github_c_makefile_star2_O2/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
pushq $0x1
popq %rsi
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_O2/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 0x53bf6(%rip), %rdi     # 0x125170
testq %rdi, %rdi
je 0xd158c
callq 0x8050
andq $0x0, 0x53be4(%rip)     # 0x125170
movq 0x53bd5(%rip), %rdi     # 0x125168
testq %rdi, %rdi
je 0xd15a5
callq 0x8050
andq $0x0, 0x53bc3(%rip)     # 0x125168
popq %rax
retq
// File: /workspace/github_c_makefile_star2_O2/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 0x4bee(%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 0x2630
leaq 0x1a3c(%rip), %rdi      # 0x4056
xorl %r14d, %r14d
xorl %eax, %eax
callq 0x2d51
movl %ebp, %edi
callq 0x2170
jmp 0x270f
addq %r14, %r15
movq 0x10(%r15), %rdi
testq %rdi, %rdi
je 0x2646
callq 0x2040
andq $0x0, 0x10(%r15)
movq 0x18(%r15), %rdi
testq %rdi, %rdi
je 0x2659
callq 0x2040
andq $0x0, 0x18(%r15)
pushq $0x30
popq %rdi
pushq $0x1
popq %rsi
callq 0x2190
movq %rax, 0x10(%r15)
movzwl 0x20(%r15), %esi
cmpl $0xa, %esi
je 0x267f
cmpl $0x2, %esi
jne 0x26c4
leaq 0x24(%r15), %rsi
pushq $0x2
jmp 0x2685
leaq 0x28(%r15), %rsi
pushq $0xa
popq %rdi
pushq $0x2f
popq %rcx
movq %rax, %rdx
callq 0x2030
movzwl 0x22(%r15), %eax
rolw $0x8, %ax
movzwl %ax, %ecx
leaq 0x19cb(%rip), %rdx      # 0x406f
leaq 0xe(%rsp), %r14
pushq $0xa
popq %rsi
movq %r14, %rdi
xorl %eax, %eax
callq 0x2100
movq %r14, %rdi
callq 0x22d0
movq %rax, 0x18(%r15)
jmp 0x26d2
leaq 0x19a7(%rip), %rdi      # 0x4072
xorl %eax, %eax
callq 0x2de2
movl %ebp, (%r15)
movl $0x1, 0x4(%r15)
movb $0x0, 0x8(%r15)
movq 0x10(%r15), %rdx
leaq 0x1998(%rip), %rdi      # 0x4085
leaq 0xe(%rsp), %rcx
movl %ebp, %esi
xorl %eax, %eax
callq 0x2cc0
pushq $0x1
popq %r14
cmpl %ebx, 0x8adb(%rip)      # 0xb1e0
jg 0x270f
incl %ebx
movl %ebx, 0x8ad1(%rip)      # 0xb1e0
movl %r14d, %eax
addq $0x18, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/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
pushq %rax
callq 0x4742
callq 0x12e2e
movq %rax, %rbx
movq %rax, %rdi
callq 0x13054
leaq -0x4a(%rip), %rsi       # 0x47d0
movq %rbx, %rdi
xorl %edx, %edx
callq 0x524e
leaq 0x19856(%rip), %rsi     # 0x1e081
movq %rbx, %rdi
callq 0x568d
leaq 0x19851(%rip), %rsi     # 0x1e08b
movq %rbx, %rdi
xorl %edx, %edx
callq 0x125ff
testl %eax, %eax
jne 0x485d
pushq $-0x1
popq %rdx
movq %rbx, %rdi
xorl %esi, %esi
xorl %ecx, %ecx
xorl %r8d, %r8d
xorl %r9d, %r9d
callq 0x5b5c
leaq 0x19830(%rip), %rsi     # 0x1e094
movq %rbx, %rdi
xorl %edx, %edx
callq 0x125ff
testl %eax, %eax
jne 0x4887
pushq $-0x1
popq %rdx
movq %rbx, %rdi
xorl %esi, %esi
xorl %ecx, %ecx
xorl %r8d, %r8d
xorl %r9d, %r9d
callq 0x5b5c
leaq 0x19813(%rip), %r15     # 0x1e0a1
movq %rbx, %rdi
movq %r15, %rsi
callq 0x568d
movq %rbx, %rdi
xorl %esi, %esi
callq 0x4a75
movq %rbx, %rdi
movq %r15, %rsi
callq 0x531c
leaq 0x197f4(%rip), %rdx     # 0x1e0a9
pushq $-0x1
popq %rsi
movq %rbx, %rdi
callq 0x5438
movq %rbx, %rdi
xorl %esi, %esi
xorl %edx, %edx
xorl %ecx, %ecx
xorl %r8d, %r8d
callq 0x5af4
movq %rbx, %rdi
movq %r15, %rsi
callq 0x531c
leaq -0x2c(%rbp), %r15
leaq 0x1a294(%rip), %r12     # 0x1eb7b
pushq $0x1
popq %r13
movq %r15, %rdi
callq 0x4661
cmpl $0x1b, %eax
je 0x4943
movl %eax, %r14d
cmpl $0x71, %eax
je 0x4943
cmpl $0x51, %r14d
je 0x4943
movq %rbx, %rdi
pushq $-0x1
popq %rsi
movq %r12, %rdx
callq 0x5438
movl -0x2c(%rbp), %edx
movq %rbx, %rdi
movl %r14d, %esi
callq 0x479a
movq %rbx, %rdi
movl %r13d, %esi
xorl %edx, %edx
xorl %ecx, %ecx
xorl %r8d, %r8d
callq 0x5af4
movsd 0x196dc(%rip), %xmm0    # 0x1e018
callq 0x46ed
jmp 0x48eb
callq 0x4777
// File: /workspace/github_c_makefile_star2_O2/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
xorl %ecx, %ecx
testl %eax, %eax
cmovlel %ecx, %eax
cmpq %rcx, %rax
je 0x1314
movb (%rdi,%rcx,2), %dl
movb %dl, (%rsp,%rcx)
incq %rcx
jmp 0x1304
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_O2/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 0x1339
movl %esi, %eax
jmp 0x1463
xorl %edx, %edx
pushq $0xc
popq %r8
leaq 0xfcca(%rip), %r9       # 0x11010
xorl %r10d, %r10d
cmpl %esi, %r10d
jge 0x1456
movslq %r10d, %rcx
movzwl (%rdi,%rcx,2), %eax
cmpl $0x5c, %eax
je 0x1372
testl %eax, %eax
je 0x1456
incl %r10d
movw %ax, (%rdi,%rdx,2)
jmp 0x144a
leal 0x1(%r10), %r11d
xorl %eax, %eax
cmpl %esi, %r11d
jge 0x1463
movzwl 0x2(%rdi,%rcx,2), %ecx
testw %cx, %cx
je 0x1463
movzwl %cx, %r11d
leal -0x6e(%r11), %ebx
cmpl $0xa, %ebx
ja 0x13b1
movslq (%r9,%rbx,4), %r11
addq %r9, %r11
jmpq *%r11
movw $0xa, (%rdi,%rdx,2)
jmp 0x1446
cmpl $0x55, %r11d
je 0x13bd
cmpl $0x58, %r11d
jne 0x1426
leal 0x6(%r10), %ecx
cmpl %esi, %ecx
jg 0x1463
addl $0x2, %r10d
xorl %eax, %eax
movl %r8d, %ecx
cmpl $-0x4, %ecx
je 0x1369
movslq %r10d, %r11
movzwl (%rdi,%r11,2), %r11d
testl %r11d, %r11d
je 0x1452
leal -0x30(%r11), %ebx
cmpw $0x9, %bx
ja 0x13f7
incl %r10d
shll %cl, %ebx
addl %ebx, %eax
jmp 0x1421
leal -0x41(%r11), %ebx
cmpw $0x5, %bx
ja 0x1407
addl $-0x37, %r11d
jmp 0x1415
leal -0x61(%r11), %ebx
cmpw $0x5, %bx
ja 0x1421
addl $-0x57, %r11d
shll %cl, %r11d
incl %r10d
addl %eax, %r11d
movl %r11d, %eax
addl $-0x4, %ecx
jmp 0x13d2
addl $0x2, %r10d
movw %cx, (%rdi,%rdx,2)
jmp 0x144a
movw $0x20, (%rdi,%rdx,2)
jmp 0x1446
movw $0x9, (%rdi,%rdx,2)
jmp 0x1446
movw $0xd, (%rdi,%rdx,2)
addl $0x2, %r10d
incq %rdx
jmp 0x1349
xorl %eax, %eax
jmp 0x1463
cmpl %esi, %edx
jg 0x1465
movl %edx, %eax
andw $0x0, (%rdi,%rax,2)
movl %edx, %eax
popq %rbx
retq
callq 0x1060
// File: /workspace/github_c_makefile_star2_O2/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 0x1d4b
movq %rdi, %rbx
movq 0x8(%rdi), %rdi
callq 0x1cf4
movq 0x80(%rbx), %rdi
testq %rdi, %rdi
je 0x1d24
cmpq $0x0, 0x20(%rdi)
jne 0x1d24
cmpq $0x0, (%rdi)
jne 0x1d4d
callq 0x1d81
movq 0x88(%rbx), %rdi
testq %rdi, %rdi
je 0x1d42
cmpq $0x0, 0x20(%rdi)
jne 0x1d42
cmpq $0x0, (%rdi)
jne 0x1d4d
callq 0x1d81
movq %rbx, %rdi
popq %rbx
jmp 0x1040
popq %rbx
retq
callq 0x1060
// File: /workspace/github_c_makefile_star2_O2/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 0x1d7a
movq %rdi, %rbx
movq (%rdi), %rdi
callq 0x1d52
movq 0x70(%rbx), %rdi
testq %rdi, %rdi
je 0x1d7c
callq 0x1040
movq %rbx, %rdi
popq %rbx
jmp 0x1040
popq %rbx
retq
callq 0x1060
// File: /workspace/github_c_makefile_star2_O2/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 0x1db6
pushq %rbx
movq %rdi, %rbx
movq (%rdi), %rdi
callq 0x1d81
movq 0x8(%rbx), %rdi
callq 0x1040
movq 0x10(%rbx), %rdi
callq 0x1040
movq 0x20(%rbx), %rdi
callq 0x1040
movq %rbx, %rdi
popq %rbx
jmp 0x1040
retq
// File: /workspace/github_c_makefile_star2_O2/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 0x1e11
pushq %rbx
movq %rdi, %rbx
movq (%rdi), %rdi
callq 0x1def
movq %rbx, %rdi
callq 0x1948
movq %rbx, %rdi
popq %rbx
jmp 0x1040
retq
// File: /workspace/github_c_makefile_star2_O2/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 0x1e95
movq %rax, %r14
movq (%rax), %rax
movzwl 0x20(%r14), %ecx
testq %rax, %rax
je 0x1ea2
cmpw %bx, %cx
jne 0x1e7e
jmp 0x1eb6
leaq (%rdi,%rcx,8), %r14
addq $0x1f8, %r14            # imm = 0x1F8
jmp 0x1ea7
cmpw %bx, %cx
je 0x1eb6
callq 0x1e12
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_O2/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 0x1f6f
movl %edx, %eax
retq
pxor %xmm3, %xmm3
movq 0xf235(%rip), %xmm0     # 0x111b0
movdqa 0xf23d(%rip), %xmm1     # 0x111c0
leaq 0xf246(%rip), %rcx      # 0x111d0
pcmpeqd %xmm2, %xmm2
movd %xmm3, %r9d
pshufd $0x55, %xmm3, %xmm4     # xmm4 = xmm3[1,1,1,1]
cmpl %edx, %r9d
jge 0x2086
movslq %r9d, %r8
movzwl (%rsi,%r8,2), %eax
cmpl $0x5c, %eax
je 0x1fc9
testl %eax, %eax
je 0x2086
psubd %xmm2, %xmm3
movd %xmm4, %r8d
movslq %r8d, %r8
movw %ax, (%rsi,%r8,2)
jmp 0x1f8e
incl %r9d
xorl %eax, %eax
cmpl %edx, %r9d
jge 0x2096
movzwl 0x2(%rsi,%r8,2), %r9d
testw %r9w, %r9w
je 0x2096
movzwl %r9w, %eax
leal -0x42(%rax), %r9d
movdqa %xmm3, %xmm5
paddd %xmm0, %xmm5
cmpl $0xb, %r9d
ja 0x200f
movslq (%rcx,%r9,4), %rax
addq %rcx, %rax
jmpq *%rax
movzwl 0x1ea(%rdi), %eax
jmp 0x2070
cmpl $0x53, %eax
je 0x2069
cmpl $0x55, %eax
jne 0x2022
movzwl 0x1e8(%rdi), %eax
jmp 0x2070
incq %r8
movd %xmm4, %eax
cltq
movw $0x5c, (%rsi,%rax,2)
movzwl (%rsi,%r8,2), %r8d
paddd %xmm1, %xmm3
movw %r8w, 0x2(%rsi,%rax,2)
jmp 0x1f8e
movzwl 0x1ec(%rdi), %eax
jmp 0x2070
movzwl 0x1f0(%rdi), %eax
jmp 0x2070
movzwl 0x1f4(%rdi), %eax
jmp 0x2070
movzwl 0x1ee(%rdi), %eax
jmp 0x2070
movzwl 0x1f2(%rdi), %eax
movd %xmm4, %r8d
movslq %r8d, %r8
movw %ax, (%rsi,%r8,2)
movdqa %xmm5, %xmm3
jmp 0x1f8e
movd %xmm4, %eax
cmpl %edx, %eax
jg 0x2097
movslq %eax, %rcx
andw $0x0, (%rsi,%rcx,2)
retq
pushq %rax
callq 0x1060
// File: /workspace/github_c_makefile_star2_O2/MikeGray-APH[P]LibLouisAPH/source/table.c
// Function: rule_match_forward
static const struct rule* rule_match_forward(
	const struct rule *const*rule_hash,
	const unsigned int hash_size,
	const unichar *chars,
	const int chars_len,
	const struct rule *at)
{
	const struct rule *rule;
	int hash;

	if(!rule_hash)
		return NULL;

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

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

	return rule;
}

// Assembly:
testq %rdi, %rdi
je 0x29b3
movq %rcx, %rax
testq %rcx, %rcx
je 0x2974
addq $0x8, %rax
jmp 0x297b
movzbl (%rsi), %eax
leaq (%rdi,%rax,8), %rax
xorl %ecx, %ecx
movq (%rax), %rax
testq %rax, %rax
je 0x29b3
movl 0x74(%rax), %edi
cmpl %edx, %edi
jg 0x29ad
testl %edi, %edi
cmovlel %ecx, %edi
xorl %r8d, %r8d
cmpq %r8, %rdi
je 0x29b5
movzwl (%rsi,%r8,2), %r9d
leaq 0x1(%r8), %r10
cmpw 0x18(%rax,%r8,2), %r9w
movq %r10, %r8
je 0x2994
addq $0x8, %rax
jmp 0x297d
xorl %eax, %eax
retq
// File: /workspace/github_c_makefile_star2_O2/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 0x2a08
movq %rcx, %rax
testq %rcx, %rcx
je 0x29c9
addq $0x10, %rax
jmp 0x29d0
movzbl (%rsi), %eax
leaq (%rdi,%rax,8), %rax
xorl %ecx, %ecx
movq (%rax), %rax
testq %rax, %rax
je 0x2a08
movl 0x78(%rax), %edi
cmpl %edx, %edi
jg 0x2a02
testl %edi, %edi
cmovlel %ecx, %edi
xorl %r8d, %r8d
cmpq %r8, %rdi
je 0x2a0a
movzwl (%rsi,%r8,2), %r9d
leaq 0x1(%r8), %r10
cmpw 0x46(%rax,%r8,2), %r9w
movq %r10, %r8
je 0x29e9
addq $0x10, %rax
jmp 0x29d2
xorl %eax, %eax
retq
// File: /workspace/github_c_makefile_star2_O2/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
cmpq $0x100, %r14            # imm = 0x100
je 0x2ad1
leal 0x2800(%r14), %eax
movw %ax, 0x10(%rbx,%r14,2)
incq %r14
jmp 0x2ab6
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O2/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 0x1190
movq %rax, %rbx
testq %rax, %rax
je 0x2b05
movq %rbx, %rdi
callq 0x2aa0
jmp 0x2b20
leaq 0xe730(%rip), %rsi      # 0x1123c
leaq 0xe794(%rip), %rdx      # 0x112a7
pushq $0x7
popq %rdi
pushq $0x35
popq %rcx
xorl %eax, %eax
callq 0x9174
movq %rbx, %rax
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O2/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 0x2b47
pushq %rbx
movq %rdi, %rbx
movq (%rdi), %rdi
callq 0x2b25
movq %rbx, %rdi
callq 0x2ad9
movq %rbx, %rdi
popq %rbx
jmp 0x1040
retq
// File: /workspace/github_c_makefile_star2_O2/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
je 0x2bb9
leaq 0x210(%rdx), %rax
addq $0x10, %rdx
xorl %ecx, %ecx
testl %esi, %esi
cmovlel %ecx, %esi
cmpq %rcx, %rsi
je 0x2bb9
movzwl (%rdi,%rcx,2), %r8d
movzbl %r8b, %r9d
andl $0xff00, %r8d           # imm = 0xFF00
cmpw $0x2800, %r8w           # imm = 0x2800
leaq (%rdx,%r9,2), %r8
cmovneq %rax, %r8
movzwl (%r8), %r8d
movw %r8w, (%rdi,%rcx,2)
incq %rcx
jmp 0x2b88
retq
// File: /workspace/github_c_makefile_star2_O2/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
je 0x2c00
xorl %eax, %eax
testl %esi, %esi
cmovlel %eax, %esi
cmpq %rsi, %rax
je 0x2c00
movzwl (%rdi,%rax,2), %r8d
xorl %ecx, %ecx
cmpq $0x100, %rcx            # imm = 0x100
je 0x2be8
cmpw %r8w, 0x10(%rdx,%rcx,2)
je 0x2bf1
incq %rcx
jmp 0x2bd2
movzwl 0x210(%rdx), %ecx
jmp 0x2bf7
addl $0x2800, %ecx           # imm = 0x2800
movw %cx, (%rdi,%rax,2)
incq %rax
jmp 0x2bc6
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O2/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 0x3268
movq %rdi, %rbx
movq (%rdi), %rdi
callq 0x3240
movq 0x8(%rbx), %rdi
testq %rdi, %rdi
je 0x326a
callq 0x1040
movq %rbx, %rdi
popq %rbx
jmp 0x1040
popq %rbx
retq
callq 0x1060
// File: /workspace/github_c_makefile_star2_O2/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 0x32df
movq %rdi, %rbx
movq (%rdi), %rdi
callq 0x326f
cmpl $0x0, 0x28(%rbx)
jne 0x32e7
movq 0x8(%rbx), %rdi
callq 0x1040
movq 0x10(%rbx), %rdi
callq 0x1040
movq 0x30(%rbx), %rdi
callq 0x1040
movq 0x18(%rbx), %rdi
testq %rdi, %rdi
je 0x32d0
xorl %r14d, %r14d
movslq 0x24(%rbx), %rax
cmpq %rax, %r14
jge 0x32cb
movq (%rdi,%r14,8), %rdi
callq 0x1040
incq %r14
movq 0x18(%rbx), %rdi
jmp 0x32b0
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_O2/MikeGray-APH[P]LibLouisAPH/source/compile.c
// Function: token_parse
static int token_parse(void)
{
	ASSERT(token_nxt)
	if(!(*token_nxt))
		return 0;

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

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

	return 1;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq 0x14058(%rip), %r14     # 0x19240
testq %r14, %r14
je 0x5272
movzwl (%r14), %ebp
testw %bp, %bp
je 0x523e
andl $0x0, 0x1402f(%rip)     # 0x19230
movq %r14, 0x14030(%rip)     # 0x19238
addq $0x2, %r14
pushq $0x1
popq %rbx
movl %ebx, %r15d
movzwl %bp, %edi
callq 0x36b8
testl %eax, %eax
jne 0x5242
testw %bp, %bp
je 0x5265
movl %r15d, 0x14006(%rip)    # 0x19230
movq %r14, 0x1400f(%rip)     # 0x19240
movzwl (%r14), %ebp
incl %r15d
addq $0x2, %r14
jmp 0x5212
xorl %ebx, %ebx
jmp 0x5265
andw $0x0, -0x2(%r14)
addq $-0x2, %r14
movzwl 0x2(%r14), %edi
addq $0x2, %r14
callq 0x36b8
testl %eax, %eax
jne 0x524c
movq %r14, 0x13fdb(%rip)     # 0x19240
movl %ebx, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
callq 0x1060
// File: /workspace/github_c_makefile_star2_O2/MikeGray-APH[P]LibLouisAPH/source/utf.h
// Function: utf16_copy
static inline void utf16_copy(unichar *dst, const unichar *src, const int len)
{
	int i;

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

// Assembly:
xorl %eax, %eax
testl %edx, %edx
movl $0x0, %ecx
cmovgl %edx, %ecx
cmpq %rax, %rcx
je 0x5297
movzwl (%rsi,%rax,2), %r8d
movw %r8w, (%rdi,%rax,2)
incq %rax
jmp 0x5283
movslq %edx, %rax
andw $0x0, -0x2(%rdi,%rax,2)
retq
// File: /workspace/github_c_makefile_star2_O2/MikeGray-APH[P]LibLouisAPH/source/utf.h
// Function: utf16_are_equal
static inline int utf16_are_equal(const unichar *uchars0, const int uchars0_len, const unichar *uchars1, const int uchars1_len)
{
	int i;

	if(uchars0_len != uchars1_len)
		return 0;
	for(i = 0; i < uchars0_len; i++)
	if(uchars0[i] != uchars1[i])
		return 0;
	return 1;
}

// Assembly:
cmpl %ecx, %esi
jne 0x621d
xorl %ecx, %ecx
testl %esi, %esi
cmovlel %ecx, %esi
pushq $0x1
popq %rax
cmpq %rcx, %rsi
je 0x621f
movzwl (%rdi,%rcx,2), %r8d
leaq 0x1(%rcx), %r9
cmpw (%rdx,%rcx,2), %r8w
movq %r9, %rcx
je 0x6205
xorl %eax, %eax
retq
// File: /workspace/github_c_makefile_star2_O2/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 %rbp
pushq %r14
pushq %rbx
movq 0x12fd7(%rip), %rbx     # 0x19238
movzwl (%rbx), %eax
leal -0x30(%rax), %ecx
cmpl $0xa, %ecx
jae 0x628c
movl 0x12fbe(%rip), %esi     # 0x19230
movq %rbx, %rdi
callq 0x12ec
movl %eax, 0x12fc8(%rip)     # 0x19248
pushq $0x1
popq %r14
movl %r14d, %eax
popq %rbx
popq %r14
popq %rbp
retq
cmpl $0x24, %eax
je 0x62d3
cmpl $0x62, %eax
jne 0x630d
movl 0x12f93(%rip), %r9d     # 0x19230
cmpl $0x3, %r9d
jl 0x6314
cmpw $0x69, 0x2(%rbx)
jne 0x6314
cmpw $0x74, 0x4(%rbx)
jne 0x6314
movl $0xfffffdf0, %eax       # imm = 0xFFFFFDF0
movzwl 0x6(%rbx), %ecx
cmpl $0x4, %r9d
ja 0x637d
addq %rax, %rcx
addq $0x1e0, %rcx            # imm = 0x1E0
jmp 0x638b
addq $0x2, %rbx
movl 0x12f53(%rip), %ebp     # 0x19230
decl %ebp
leaq 0x10eca(%rip), %r14     # 0x171b0
movq (%r14), %r14
testq %r14, %r14
je 0x6342
movq 0x8(%r14), %rdx
movl 0x10(%r14), %ecx
movq %rbx, %rdi
movl %ebp, %esi
callq 0x61f7
testl %eax, %eax
je 0x62e6
movl 0x14(%r14), %eax
jmp 0x627a
movl 0x12f1c(%rip), %r9d     # 0x19230
movslq 0x10ead(%rip), %rax     # 0x171c8
leaq 0x10ece(%rip), %rcx     # 0x171f0
movq (%rcx,%rax,8), %rdx
leaq 0x10ea3(%rip), %rcx     # 0x171d0
movl (%rcx,%rax,4), %ecx
leaq 0xb32a(%rip), %rsi      # 0x11661
xorl %r14d, %r14d
pushq $0x6
popq %rdi
movq %rbx, %r8
jmp 0x6371
movslq 0x10e7f(%rip), %rax     # 0x171c8
leaq 0x10ea0(%rip), %rcx     # 0x171f0
movq (%rcx,%rax,8), %rdx
leaq 0x10e75(%rip), %rcx     # 0x171d0
movl (%rcx,%rax,4), %ecx
leaq 0xb2dd(%rip), %rsi      # 0x11642
xorl %r14d, %r14d
pushq $0x6
popq %rdi
movq %rbx, %r8
movl %ebp, %r9d
xorl %eax, %eax
callq 0x9174
jmp 0x6284
imulq $0xa, %rcx, %rdx
movzwl 0x8(%rbx), %ecx
addq %rax, %rcx
addq %rdx, %rcx
pushq $0x1
popq %rax
shlq %cl, %rax
movl %eax, 0x12eb1(%rip)     # 0x19248
jmp 0x6280
// File: /workspace/github_c_makefile_star2_O2/MikeGray-APH[P]LibLouisAPH/source/utf.h
// Function: utf16_is_equal_cchars
static inline int utf16_is_equal_cchars(const unichar *uchars, const int uchars_len, const char *cchars, const int cchars_len)
{
	int i;

	if(uchars_len != cchars_len)
		return 0;
	for(i = 0; i < cchars_len; i++)
	if(uchars[i] != (unichar)cchars[i])
		return 0;
	return 1;
}

// Assembly:
cmpl %ecx, %esi
jne 0x63c2
xorl %ecx, %ecx
testl %esi, %esi
cmovlel %ecx, %esi
pushq $0x1
popq %rax
cmpq %rcx, %rsi
je 0x63c4
movsbl (%rdx,%rcx), %r8d
leaq 0x1(%rcx), %r9
cmpw %r8w, (%rdi,%rcx,2)
movq %r9, %rcx
je 0x63aa
xorl %eax, %eax
retq
// File: /workspace/github_c_makefile_star2_O2/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:
pushq %rbx
xorl %edx, %edx
testl %esi, %esi
cmovlel %edx, %esi
movabsq $0x1, %r9
movl $0xffffffff, %r8d       # imm = 0xFFFFFFFF
xorl %r10d, %r10d
xorl %eax, %eax
movslq %eax, %rcx
cmpq %rdx, %rsi
je 0x6494
movzwl (%rdi,%rdx,2), %r11d
movl %r11d, %ebx
andl $0xff00, %ebx           # imm = 0xFF00
cmpw $0x2800, %bx            # imm = 0x2800
jne 0x6446
testw %r10w, %r10w
je 0x6438
orl $0x2800, %r10d          # imm = 0x2800
leal 0x1(%rcx), %eax
movw %r10w, (%rdi,%rcx,2)
movzwl (%rdi,%rdx,2), %r11d
movslq %eax, %rcx
incl %eax
movw %r11w, (%rdi,%rcx,2)
xorl %ebx, %ebx
jmp 0x646e
movw $0x2800, %bx            # imm = 0x2800
cmpw $0x30, %r11w
je 0x646e
leal -0x31(%r11), %ebx
cmpw $0x7, %bx
ja 0x6476
movzwl %r11w, %ecx
addb $-0x31, %cl
movq %r9, %r11
shlq %cl, %r11
orl %r11d, %r10d
movl %r10d, %ebx
incq %rdx
movl %ebx, %r10d
jmp 0x63fd
cmpw $0x2d, %r11w
jne 0x64ab
testw %r10w, %r10w
je 0x6442
orl $0x2800, %r10d          # imm = 0x2800
leal 0x1(%rcx), %eax
movw %r10w, (%rdi,%rcx,2)
jmp 0x6442
testw %r10w, %r10w
je 0x64a9
orl $0x2800, %r10d          # imm = 0x2800
leal 0x1(%rcx), %eax
movw %r10w, (%rdi,%rcx,2)
popq %rbx
retq
movl %r8d, %eax
jmp 0x64a9
// File: /workspace/github_c_makefile_star2_O2/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 %rbp
pushq %r14
pushq %rbx
movq 0x12c46(%rip), %r14     # 0x19238
movl 0x12c38(%rip), %ebp     # 0x19230
movq 0x10b91(%rip), %rbx     # 0x17190
addq $0x20, %rbx
movq (%rbx), %rbx
testq %rbx, %rbx
je 0x6622
movq 0x20(%rbx), %rdx
movl 0x28(%rbx), %ecx
movq %r14, %rdi
movl %ebp, %esi
callq 0x61f7
testl %eax, %eax
je 0x6603
jmp 0x6655
movslq 0x10b9f(%rip), %rax     # 0x171c8
leaq 0x10bc0(%rip), %rcx     # 0x171f0
movq (%rcx,%rax,8), %rdx
leaq 0x10b95(%rip), %rcx     # 0x171d0
movl (%rcx,%rax,4), %ecx
leaq 0xb1dd(%rip), %rsi      # 0x11822
pushq $0x6
popq %rdi
movq %r14, %r8
movl %ebp, %r9d
xorl %eax, %eax
callq 0x9174
movq %rbx, %rax
popq %rbx
popq %r14
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O2/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 0x66ba
leal (%r8,%rcx), %r9d
incl %r9d
cmpl 0x44(%rdi), %r9d
jge 0x66ba
movq 0x38(%rdi), %rdi
movl %r8d, %r10d
cmpw %si, (%rdi,%r10,2)
jne 0x66ba
movslq %r9d, %r9
cmpw %si, (%rdi,%r9,2)
jne 0x66ba
incl %r8d
movl %r8d, %eax
xorl %esi, %esi
testl %ecx, %ecx
cmovlel %esi, %ecx
leaq (%rdi,%rax,2), %rdi
pushq $0x1
popq %rax
cmpq %rsi, %rcx
je 0x66ba
movzwl (%rdi,%rsi,2), %r8d
leaq 0x1(%rsi), %r9
cmpw (%rdx,%rsi,2), %r8w
movq %r9, %rsi
je 0x66a0
xorl %eax, %eax
retq
// File: /workspace/github_c_makefile_star2_O2/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:
pushq %r15
pushq %r14
pushq %rbx
movq %rdx, %rbx
movq %rdi, %r15
movq 0x38(%rdi), %rax
movslq 0x40(%rdi), %r14
movzwl (%rax,%r14,2), %eax
cmpw 0x1f0(%rsi), %ax
je 0x66e5
cmpw 0x1f2(%rsi), %ax
jne 0x671c
leaq 0xc(%rbx), %rsi
movl 0x54(%rbx), %edx
incl %r14d
movq %r15, %rdi
movl %r14d, %ecx
callq 0x677c
testl %eax, %eax
je 0x6702
pushq $0x2
jmp 0x6752
leaq 0x1a(%rbx), %rsi
movl 0x58(%rbx), %edx
movq %r15, %rdi
movl %r14d, %ecx
callq 0x677c
testl %eax, %eax
je 0x6720
pushq $0x3
jmp 0x6752
pushq $0x1
jmp 0x6752
leaq 0x28(%rbx), %rsi
movl 0x5c(%rbx), %edx
movq %r15, %rdi
movl %r14d, %ecx
callq 0x677c
testl %eax, %eax
je 0x673a
pushq $0x4
jmp 0x6752
leaq 0x36(%rbx), %rsi
movl 0x60(%rbx), %edx
movq %r15, %rdi
movl %r14d, %ecx
callq 0x677c
testl %eax, %eax
je 0x6759
pushq $0x5
popq %rax
popq %rbx
popq %r14
popq %r15
retq
movl 0x64(%rbx), %edx
addq $0x44, %rbx
movq %r15, %rdi
movq %rbx, %rsi
movl %r14d, %ecx
callq 0x677c
xorl %ecx, %ecx
testl %eax, %eax
setne %cl
leal (%rcx,%rcx,4), %eax
incl %eax
jmp 0x6753
// File: /workspace/github_c_makefile_star2_O2/MikeGray-APH[P]LibLouisAPH/source/translate.h
// Function: translate_is_equal_at
static inline int translate_is_equal_at(const struct translate *translate, const unichar *uchars, const int uchars_len, const int at)
{
	int i;

	if(!uchars_len)
		return 0;

	if(at + uchars_len > translate->input_len)
		return 0;

	for(i = 0; i < uchars_len; i++)
	if(translate->input[at + i] != uchars[i])
		return 0;

	return uchars_len;
}

// Assembly:
xorl %eax, %eax
testl %edx, %edx
je 0x67c1
leal (%rcx,%rdx), %r8d
cmpl 0x44(%rdi), %r8d
jg 0x67c1
movslq %ecx, %rax
xorl %ecx, %ecx
testl %edx, %edx
movl $0x0, %r8d
cmovgl %edx, %r8d
addq %rax, %rax
cmpq %rcx, %r8
je 0x67c2
movq 0x38(%rdi), %r9
addq %rax, %r9
movzwl (%r9,%rcx,2), %r9d
leaq 0x1(%rcx), %r10
cmpw (%rsi,%rcx,2), %r9w
movq %r10, %rcx
je 0x67a0
xorl %eax, %eax
retq
movl %edx, %eax
retq
// File: /workspace/github_c_makefile_star2_O2/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
addl 0x68(%rdi), %esi
movl 0x6c(%rdi), %eax
pushq $0x1
popq %rbx
cmpl %eax, %esi
jl 0x687b
movq %rdi, %r14
cmpl %eax, %esi
jl 0x67eb
addl 0x70(%r14), %eax
movl %eax, 0x6c(%r14)
jmp 0x67dd
movq 0x60(%r14), %rdi
movslq %eax, %rsi
addq %rsi, %rsi
callq 0x11c0
movq %rax, 0x60(%r14)
testq %rax, %rax
je 0x6847
movq 0x80(%r14), %rdi
movslq 0x6c(%r14), %rsi
callq 0x11c0
movq %rax, 0x80(%r14)
testq %rax, %rax
je 0x685e
cmpl $0x0, 0x90(%r14)
je 0x687b
movq 0x78(%r14), %rdi
movslq 0x6c(%r14), %rsi
shlq $0x2, %rsi
callq 0x11c0
movq %rax, 0x78(%r14)
testq %rax, %rax
jne 0x687b
xorl %ebx, %ebx
jmp 0x687b
leaq 0xa9ee(%rip), %rsi      # 0x1123c
leaq 0xb1bb(%rip), %rdx      # 0x11a10
xorl %ebx, %ebx
pushq $0x7
popq %rdi
pushq $0x64
jmp 0x6873
leaq 0xa9d7(%rip), %rsi      # 0x1123c
leaq 0xb1a4(%rip), %rdx      # 0x11a10
xorl %ebx, %ebx
pushq $0x7
popq %rdi
pushq $0x6b
popq %rcx
xorl %eax, %eax
callq 0x9174
movl %ebx, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O2/MikeGray-APH[P]LibLouisAPH/source/translate.c
// Function: translate_skip
int translate_skip(struct translate *translate, const int chars_cnt, const int clear_map)
{
	int cnt, i;

	/*   ensure chars_cnt is still within range   */
	if(translate->input_crs + chars_cnt > translate->input_len)
		cnt = translate->input_len - translate->input_crs;
	else
		cnt = chars_cnt;

	if(clear_map)
	if(translate->maps_use)
	for(i = 0; i < cnt; i++)
	if(translate->input_map[translate->input_crs + i] >= 0)
	{
		ASSERT(translate->input_crs + i < translate->input_len)
		translate->input_to_output_map[translate->input_map[translate->input_crs + i]] = -1;
	}

	translate_increment(translate, cnt, 0);

	return 1;
}

// Assembly:
pushq %rax
movl %esi, %eax
movl 0x40(%rdi), %ecx
movl 0x44(%rdi), %r8d
movl %r8d, %esi
subl %ecx, %esi
addl %eax, %ecx
cmpl %r8d, %ecx
cmovlel %eax, %esi
testl %edx, %edx
je 0x68e8
cmpl $0x0, 0x90(%rdi)
je 0x68e8
xorl %eax, %eax
testl %esi, %esi
movl $0x0, %ecx
cmovgl %esi, %ecx
cmpl %eax, %ecx
je 0x68e8
movq 0x50(%rdi), %rdx
movslq 0x40(%rdi), %r8
leaq (%rax,%r8), %r9
movslq (%rdx,%r9,4), %rdx
testq %rdx, %rdx
js 0x68e3
movl %r8d, %r8d
addq %rax, %r8
cmpl 0x44(%rdi), %r8d
jge 0x68f4
movq 0x48(%rdi), %r8
orl $-0x1, (%r8,%rdx,4)
incq %rax
jmp 0x68b5
xorl %edx, %edx
callq 0x68f9
pushq $0x1
popq %rax
popq %rcx
retq
callq 0x1060
// File: /workspace/github_c_makefile_star2_O2/MikeGray-APH[P]LibLouisAPH/source/translate.h
// Function: translate_increment
static inline void translate_increment(struct translate *translate, const int chars_cnt, const int dots_cnt)
{
	if(chars_cnt)
	if(!translate->cursor_set)
	if(translate->cursor_pos >= translate->input_crs && translate->cursor_pos < translate->input_crs + chars_cnt)
	{
		translate->cursor_set = 1;
		translate->cursor_pos = translate->output_len;
	}
	translate->input_crs += chars_cnt;
	translate->output_len += dots_cnt;
}

// Assembly:
testl %esi, %esi
je 0x6936
cmpl $0x0, 0x8c(%rdi)
jne 0x6936
movl 0x40(%rdi), %eax
movl 0x88(%rdi), %ecx
cmpl %eax, %ecx
setge %r8b
addl %esi, %eax
cmpl %eax, %ecx
setl %al
andb %r8b, %al
cmpb $0x1, %al
jne 0x6936
movl $0x1, 0x8c(%rdi)
movl 0x68(%rdi), %eax
movl %eax, 0x88(%rdi)
addl %esi, 0x40(%rdi)
addl %edx, 0x68(%rdi)
retq
// File: /workspace/github_c_makefile_star2_O2/MikeGray-APH[P]LibLouisAPH/source/translate.c
// Function: translate_insert_dots
int translate_insert_dots(struct translate *translate, const unichar *dots, const int dots_len)
{
	int i;

	if(!translate_check_output_max(translate, dots_len))
		return 0;

	for(i = 0; i < dots_len; i++)
	{
		ASSERT(translate->output_len + i < translate->output_max)
		translate->output[translate->output_len + i] = dots[i];
		translate->output_mask[translate->output_len + i] = 0;

		if(translate->maps_use)
			translate->output_to_input_map[translate->output_len + i] = -1;
	}

	translate->output_len += dots_len;

	return 1;
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movl %edx, %ebx
movq %rsi, %r15
movq %rdi, %r14
movl %edx, %esi
callq 0x67c5
testl %eax, %eax
je 0x69b7
xorl %eax, %eax
testl %ebx, %ebx
movl $0x0, %ecx
cmovgl %ebx, %ecx
movl 0x68(%r14), %edx
cmpq %rax, %rcx
je 0x69ac
addq %rax, %rdx
cmpl 0x6c(%r14), %edx
jge 0x69bf
movzwl (%r15,%rax,2), %esi
movq 0x60(%r14), %rdi
movslq %edx, %rdx
movw %si, (%rdi,%rdx,2)
movq 0x80(%r14), %rsi
movb $0x0, (%rsi,%rdx)
cmpl $0x0, 0x90(%r14)
je 0x69a7
movq 0x78(%r14), %rdx
movslq 0x68(%r14), %rsi
addq %rax, %rsi
orl $-0x1, (%rdx,%rsi,4)
incq %rax
jmp 0x6961
addl %ebx, %edx
movl %edx, 0x68(%r14)
pushq $0x1
popq %rax
jmp 0x69b9
xorl %eax, %eax
popq %rbx
popq %r14
popq %r15
retq
callq 0x1060
// File: /workspace/github_c_makefile_star2_O2/MikeGray-APH[P]LibLouisAPH/source/translate.c
// Function: translate_insert_dots_for_chars
int translate_insert_dots_for_chars(struct translate *translate, const unichar *dots, const int dots_len, const int chars_cnt)
{
	int i;

	if(!translate_check_output_max(translate, dots_len))
		return 0;

	for(i = 0; i < dots_len; i++)
	{
		ASSERT(translate->output_len + i < translate->output_max)
		translate->output[translate->output_len + i] = dots[i];
		translate->output_mask[translate->output_len + i] = 0;

		if(translate->maps_use)
			translate->output_to_input_map[translate->output_len + i] = translate->input_map[translate->input_crs];
	}
	if(translate->maps_use)
	for(i = 0; i < chars_cnt; i++)
		translate_remap_input(translate, i, 0);

	translate_increment(translate, chars_cnt, dots_len);

	return 1;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movl %ecx, %ebp
movl %edx, %ebx
movq %rsi, %r15
movq %rdi, %r14
movl %edx, %esi
callq 0x67c5
testl %eax, %eax
je 0x6a8d
xorl %eax, %eax
testl %ebx, %ebx
movl $0x0, %ecx
cmovgl %ebx, %ecx
cmpq %rax, %rcx
je 0x6a4c
movslq 0x68(%r14), %rdx
leal (%rax,%rdx), %esi
cmpl 0x6c(%r14), %esi
jge 0x6a98
movzwl (%r15,%rax,2), %esi
movq 0x60(%r14), %rdi
leaq (%rax,%rdx), %r8
movw %si, (%rdi,%r8,2)
addq 0x80(%r14), %rdx
movb $0x0, (%rax,%rdx)
cmpl $0x0, 0x90(%r14)
je 0x6a47
movslq 0x40(%r14), %rdx
movq 0x50(%r14), %rsi
movq 0x78(%r14), %rdi
movl (%rsi,%rdx,4), %edx
movslq 0x68(%r14), %rsi
addq %rax, %rsi
movl %edx, (%rdi,%rsi,4)
incq %rax
jmp 0x69f1
cmpl $0x0, 0x90(%r14)
je 0x6a7c
xorl %r15d, %r15d
testl %ebp, %ebp
movl $0x0, %r12d
cmovgl %ebp, %r12d
cmpl %r15d, %r12d
je 0x6a7c
movq %r14, %rdi
movl %r15d, %esi
xorl %edx, %edx
callq 0x6a9d
incl %r15d
jmp 0x6a65
movq %r14, %rdi
movl %ebp, %esi
movl %ebx, %edx
callq 0x68f9
pushq $0x1
popq %rax
jmp 0x6a8f
xorl %eax, %eax
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
callq 0x1060