LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O3/vdedios[P]minishell/libft/ft_putendl_fd.c
// Function: ft_putendl_fd
void	ft_putendl_fd(char *s, int fd)
{
	char endl;

	if (s)
	{
		endl = '\n';
		write(fd, s, ft_strlen(s));
		write(fd, &endl, 1);
	}
}

// Assembly:
testq %rdi, %rdi
je 0x508e
pushq %r15
pushq %r14
pushq %rbx
subq $0x10, %rsp
movl %esi, %ebx
movq %rdi, %r14
leaq 0xf(%rsp), %r15
movb $0xa, (%r15)
callq 0x5408
movl %ebx, %edi
movq %r14, %rsi
movq %rax, %rdx
callq 0x1040
movl $0x1, %edx
movl %ebx, %edi
movq %r15, %rsi
callq 0x1040
addq $0x10, %rsp
popq %rbx
popq %r14
popq %r15
retq
nop
// File: /workspace/github_c_makefile_star2_O3/vdedios[P]minishell/libft/ft_split.c
// Function: ft_split
char			**ft_split(char const *s, char c)
{
	char	**matrix;
	size_t	i;
	size_t	matrix_size;;

	i = 0;
	if (!s)
		return (0);
	matrix_size = ft_count_words(s, c);
	if (!(matrix = (char **)malloc((matrix_size + 1) * sizeof(char*))))
		return (NULL);
	while (i < matrix_size)
	{
		while (*s == c)
			s++;		
		if (!(matrix[i] = ft_get_word(s, c)))
			return (ft_free_all(matrix, i));
		s += ft_strlen(matrix[i]);
		i++;
	}
	matrix[i] = 0;
	return (matrix);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
testq %rdi, %rdi
je 0x51c5
movl %esi, %ebx
movq %rdi, %r14
movb (%rdi), %al
xorl %ebp, %ebp
testb %al, %al
je 0x5116
cmpb %bl, %al
setne %bpl
movq %r14, %rdi
callq 0x5408
cmpq $0x1, %rax
je 0x5116
xorl %r15d, %r15d
cmpb %bl, (%r14,%r15)
jne 0x5103
xorl %eax, %eax
cmpb %bl, 0x1(%r14,%r15)
setne %al
addq %rax, %rbp
incq %r15
movq %r14, %rdi
callq 0x5408
decq %rax
cmpq %rax, %r15
jb 0x50f0
leaq 0x8(,%rbp,8), %rdi
callq 0x1160
testq %rax, %rax
je 0x51c5
movq %rax, %r12
testq %rbp, %rbp
je 0x5194
xorl %r15d, %r15d
movq %r12, (%rsp)
decq %r14
movq %r14, %rax
incq %r14
cmpb %bl, 0x1(%rax)
je 0x513e
xorl %r12d, %r12d
movb (%r14,%r12), %al
incq %r12
cmpb %bl, %al
je 0x515b
testb %al, %al
jne 0x514c
movq %r12, %rdi
callq 0x1160
testq %rax, %rax
je 0x519e
movq %rax, %r13
movq %rax, %rdi
movq %r14, %rsi
movq %r12, %rdx
callq 0x53b0
movq (%rsp), %r12
movq %r13, (%r12,%r15,8)
movq %r13, %rdi
callq 0x5408
addq %rax, %r14
incq %r15
cmpq %rbp, %r15
jne 0x513b
movq $0x0, (%r12,%rbp,8)
jmp 0x51c8
movq (%rsp), %rbx
movq $0x0, (%rbx,%r15,8)
testq %r15, %r15
je 0x51bd
movq (%rbx,%r15,8), %rdi
callq 0x1030
decq %r15
jne 0x51af
movq %rbx, %rdi
callq 0x1030
xorl %r12d, %r12d
movq %r12, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O3/vdedios[P]minishell/libft/ft_strjoin.c
// Function: ft_strjoin
char	*ft_strjoin(char const *s1, char const *s2)
{
	char	*joint;
	size_t	l;
	size_t	i;
	size_t	j;
	
	if (!s1 || !s2)
		return (0);
	l = ft_strlen(s1) + ft_strlen(s2) + 1;
	if (!(joint = malloc(l * sizeof(char))))
		return (NULL);
	l = 0;
	i = 0;
	j = 0;
	while (l < (ft_strlen(s1) + ft_strlen(s2)))
	{
		if (l < ft_strlen(s1))
			joint[l++] = s1[i++];
		else
			joint[l++] = s2[j++];
	}
	joint[l] = '\0';
	return (joint);
}

// Assembly:
testq %rdi, %rdi
sete %al
testq %rsi, %rsi
sete %cl
orb %al, %cl
jne 0x52a2
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %rsi, %rbx
movq %rdi, %r14
callq 0x5408
movq %rax, %r15
movq %rbx, %rdi
callq 0x5408
leaq (%r15,%rax), %rdi
incq %rdi
callq 0x1160
testq %rax, %rax
je 0x52a5
movq %rax, (%rsp)
movq %r14, %rdi
callq 0x5408
movq %rax, %r12
movq %rbx, %rdi
callq 0x5408
addq %r12, %rax
jne 0x52a9
xorl %r13d, %r13d
jmp 0x531c
xorl %eax, %eax
retq
xorl %eax, %eax
jmp 0x5325
xorl %r12d, %r12d
xorl %ebp, %ebp
movq %r14, 0x10(%rsp)
xorl %r13d, %r13d
movq %rbx, 0x8(%rsp)
xorl %ebx, %ebx
xorl %r15d, %r15d
movq 0x10(%rsp), %r14
movq %r14, %rdi
callq 0x5408
cmpq %rax, %r13
adcq $0x0, %rbx
cmpq %rax, %r13
sbbq $-0x1, %r15
addq %r14, %rbp
addq 0x8(%rsp), %r12
cmpq %rax, %r13
cmovbq %rbp, %r12
movb (%r12), %al
movq (%rsp), %rcx
movb %al, (%rcx,%r13)
incq %r13
movq %r14, %rdi
callq 0x5408
movq %rax, %r12
movq 0x8(%rsp), %rdi
callq 0x5408
addq %r12, %rax
movq %r15, %r12
movq %rbx, %rbp
cmpq %rax, %r13
jb 0x52c5
movq (%rsp), %rax
movb $0x0, (%rax,%r13)
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/vdedios[P]minishell/libft/ft_strlcat.c
// Function: ft_strlcat
size_t	ft_strlcat(char *dst, const char *src, size_t dstsize)
{
	size_t i;
	size_t j;
	size_t l_dst;

	l_dst = ft_strlen(dst);
	j = 0;
	if (dstsize < l_dst)
		return (dstsize + ft_strlen(src));
	else
	{
		i = l_dst;
		while (src[j] != '\0' && i < dstsize - 1)
		{
			dst[i] = src[j];
			i++;
			j++;
		}
		dst[i] = '\0';
		return (l_dst + ft_strlen(src));
	}
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rdx, %r15
movq %rsi, %rbx
movq %rdi, %r12
callq 0x5408
cmpq %r15, %rax
jbe 0x535c
movq %rbx, %rdi
callq 0x5408
addq %r15, %rax
jmp 0x53a4
movq %rax, %r14
decq %r15
movb (%rbx), %al
testb %al, %al
sete %cl
cmpq %r15, %r14
setae %dl
orb %cl, %dl
jne 0x5391
leaq 0x1(%rbx), %rdx
movq %r14, %rcx
movb %al, (%r12,%rcx)
incq %rcx
movb (%rdx), %al
testb %al, %al
je 0x5394
incq %rdx
cmpq %r15, %rcx
jb 0x537a
jmp 0x5394
movq %r14, %rcx
movb $0x0, (%r12,%rcx)
movq %rbx, %rdi
callq 0x5408
addq %r14, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O3/vdedios[P]minishell/libft/ft_strlcpy.c
// Function: ft_strlcpy
size_t	ft_strlcpy(char *dest, const char *src, size_t size)
{
	size_t	i;
	size_t	j;

	i = 0;
	j = 0;
	if (!src || !dest)
		return (0);
	i = ft_strlen(src);
	if (size == 0)
		return (i);
	while (j < size - 1 && src[j])
	{ 
		dest[j] = src[j];
		j++;
	}
	dest[j] = '\0';
	return (i);
}

// Assembly:
testq %rsi, %rsi
sete %al
testq %rdi, %rdi
sete %cl
orb %al, %cl
jne 0x5402
pushq %r15
pushq %r14
pushq %rbx
movq %rdx, %r14
movq %rsi, %r15
movq %rdi, %rbx
movq %rsi, %rdi
callq 0x5408
testq %r14, %r14
je 0x53fc
xorl %ecx, %ecx
decq %r14
je 0x53f8
movb (%r15,%rcx), %dl
testb %dl, %dl
je 0x53f8
movb %dl, (%rbx,%rcx)
incq %rcx
cmpq %rcx, %r14
jne 0x53e2
movq %r14, %rcx
movb $0x0, (%rbx,%rcx)
popq %rbx
popq %r14
popq %r15
retq
xorl %eax, %eax
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O3/vdedios[P]minishell/libft/ft_strncmp.c
// Function: ft_strncmp
int	ft_strncmp(const char *s1, const char *s2, size_t n)
{
	size_t	i;
	size_t	aux;

	aux = 1;
	i = 0;
	while (i < n && aux == 1)
	{
		if (s1[i] != s2[i])
			return ((unsigned char)s1[i] - (unsigned char)s2[i]);
		else if (s1[i] == '\0' || s2[i] == '\0')
			aux = 0;
		i++;
	}
	return (0);
}

// Assembly:
xorl %eax, %eax
testq %rdx, %rdx
je 0x5456
movl $0x1, %ecx
movzbl -0x1(%rdi,%rcx), %r8d
movzbl -0x1(%rsi,%rcx), %r9d
cmpb %r9b, %r8b
jne 0x5457
cmpq %rdx, %rcx
jae 0x5456
incq %rcx
testb %r8b, %r8b
jne 0x5438
retq
subl %r9d, %r8d
movl %r8d, %eax
retq
nop
// File: /workspace/github_c_makefile_star2_O3/vdedios[P]minishell/libft/ft_strcmp.c
// Function: ft_strcmp
size_t	ft_strcmp(char *s1, char *s2)
{
	while (*s2)
	{
		if (*s1 != *s2)
			return (0);
		s1++;
		s2++;
	}
	if (*s1 != *s2)
		return (0);
	return (1);
}

// Assembly:
movb (%rsi), %cl
testb %cl, %cl
je 0x547b
incq %rsi
xorl %eax, %eax
cmpb %cl, (%rdi)
jne 0x5483
incq %rdi
movb (%rsi), %cl
incq %rsi
testb %cl, %cl
jne 0x546b
xorl %eax, %eax
cmpb $0x0, (%rdi)
sete %al
retq
// File: /workspace/github_c_makefile_star2_O3/vdedios[P]minishell/libft/ft_strnstr.c
// Function: ft_strnstr
char	*ft_strnstr(const char *haystack, const char *needle, size_t len)
{
	int i;
	int j;

	i = 0;
	while (haystack[i] != '\0' && i < (int)len)
	{
		j = 0;
		while (needle[j] && haystack[i + j] == needle[j] && (i + j) < (int)len)
			j++;
		if (!needle[j])
			return ((char *)&haystack[i]);
		j = 0;
		i++;
	}
	if (!needle[0])
		return ((char *)haystack);
	return (NULL);
}

// Assembly:
movq %rdi, %rax
movb (%rsi), %cl
testl %edx, %edx
jle 0x54d8
cmpb $0x0, (%rax)
je 0x54d8
andl $0x7fffffff, %edx       # imm = 0x7FFFFFFF
incq %rsi
xorl %edi, %edi
movq %rsi, %r8
movq %rdi, %r9
movl %ecx, %r10d
testb %cl, %cl
je 0x54e4
cmpq %rdx, %r9
jae 0x54c5
cmpb %r10b, (%rax,%r9)
jne 0x54c5
movb (%r8), %r10b
incq %r9
incq %r8
testb %r10b, %r10b
jne 0x54aa
jmp 0x54e1
leaq 0x1(%rdi), %r8
cmpq %rdx, %r8
jae 0x54d8
cmpb $0x0, 0x1(%rax,%rdi)
movq %r8, %rdi
jne 0x549d
xorl %edx, %edx
testb %cl, %cl
cmovneq %rdx, %rax
retq
addq %rdi, %rax
retq
// File: /workspace/github_c_makefile_star2_O3/lucvoo[P]sparse-dev/test-linearize.c
// Function: main
int main(int argc, char **argv)
{
	struct string_list *filelist = NULL;
	char *file;

	clean_up_symbols(sparse_initialize(argc, argv, &filelist));
	FOR_EACH_PTR(filelist, file) {
		clean_up_symbols(sparse(file));
	} END_FOR_EACH_PTR(file);

	report_stats();
	return 0;
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
subq $0x10, %rsp
leaq 0x8(%rsp), %rbx
movq $0x0, (%rbx)
movq %rbx, %rdx
callq 0x12a46
movq %rax, %rdi
callq 0xf696
movq (%rbx), %rbx
testq %rbx, %rbx
je 0xf685
movq %rbx, %r14
movzwl (%r14), %eax
testb %al, %al
jle 0xf67c
xorl %r15d, %r15d
movq 0x18(%r14,%r15,8), %rdi
movzwl %ax, %ecx
cmpl $0x100, %ecx            # imm = 0x100
jb 0xf65c
testq %rdi, %rdi
je 0xf66d
callq 0x12d7e
movq %rax, %rdi
callq 0xf696
movzwl (%r14), %eax
incq %r15
movzwl %ax, %ecx
movsbq %cl, %rcx
cmpq %rcx, %r15
jl 0xf647
movq 0x10(%r14), %r14
cmpq %rbx, %r14
jne 0xf63c
callq 0x2bc2c
xorl %eax, %eax
addq $0x10, %rsp
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O3/lucvoo[P]sparse-dev/test-linearize.c
// Function: clean_up_symbols
static void clean_up_symbols(struct symbol_list *list)
{
	struct symbol *sym;

	FOR_EACH_PTR(list, sym) {
		struct entrypoint *ep;

		expand_symbol(sym);
		ep = linearize_symbol(sym);
		if (!(fdump_ir & PASS_FINAL))
			continue;
		if (ep)
			show_entry(ep);
	} END_FOR_EACH_PTR(sym);
}

// Assembly:
testq %rdi, %rdi
je 0xf717
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
movq %rdi, %rbx
leaq 0x5886a(%rip), %r15     # 0x67f18
movq %rdi, %r12
movzwl (%r12), %eax
testb %al, %al
jle 0xf704
xorl %r13d, %r13d
movq 0x18(%r12,%r13,8), %r14
movzwl %ax, %eax
cmpl $0x100, %eax            # imm = 0x100
jb 0xf6d1
testq %r14, %r14
je 0xf6f4
movq %r14, %rdi
callq 0xf9b0
movq %r14, %rdi
callq 0x14732
testb $0x10, (%r15)
je 0xf6f4
testq %rax, %rax
je 0xf6f4
movq %rax, %rdi
callq 0x13f0c
incq %r13
movl (%r12), %eax
movsbq %al, %rcx
cmpq %rcx, %r13
jl 0xf6bd
movq 0x10(%r12), %r12
cmpq %rbx, %r12
jne 0xf6b1
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O3/mrkite[P]regs/docmaker/parser.cc
// Function: Parser::error(File*, char const*, ...)
void Parser::error(File *f, const char *format, ...) {
  va_list args;
  va_start(args, format);

  fprintf(stderr, "Error: %s:%d: ", f->name.c_str(), f->curLine);
  vfprintf(stderr, format, args);

  va_end(args);
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
subq $0xd0, %rsp
movq %rdx, %rbx
leaq 0x20(%rsp), %rdx
movq %rcx, 0x18(%rdx)
movq %r8, 0x20(%rdx)
movq %r9, 0x28(%rdx)
testb %al, %al
je 0x348b
movaps %xmm0, 0x50(%rsp)
movaps %xmm1, 0x60(%rsp)
movaps %xmm2, 0x70(%rsp)
movaps %xmm3, 0x80(%rsp)
movaps %xmm4, 0x90(%rsp)
movaps %xmm5, 0xa0(%rsp)
movaps %xmm6, 0xb0(%rsp)
movaps %xmm7, 0xc0(%rsp)
movq %rsp, %r14
movq %rdx, 0x10(%r14)
leaq 0xf0(%rsp), %rax
movq %rax, 0x8(%r14)
movabsq $0x3000000018, %rax     # imm = 0x3000000018
movq %rax, (%r14)
movq 0xab1e(%rip), %r15      # 0xdfd0
movq (%r15), %rdi
movq 0x18(%rsi), %rdx
movl 0x38(%rsi), %ecx
leaq 0x6cae(%rip), %rsi      # 0xa171
xorl %eax, %eax
callq 0x32e0
movq (%r15), %rdi
movq %rbx, %rsi
movq %r14, %rdx
callq 0x32a0
addq $0xd0, %rsp
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O3/mrkite[P]regs/docmaker/compiler.cc
// Function: Compiler::refErr(Symbol*, char const*, ...)
bool Compiler::refErr(Symbol *symbol, const char *format, ...) {
  va_list args;
  va_start(args, format);

  fprintf(stderr, "Error: %s:%d: ", symbol->referencedFile.c_str(),
          symbol->referencedLine);
  vfprintf(stderr, format, args);

  va_end(args);

  numErrors++;
  return numErrors < 10;
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0xd8, %rsp
movq %rdx, %r14
movq %rdi, %rbx
leaq 0x20(%rsp), %rdx
movq %rcx, 0x18(%rdx)
movq %r8, 0x20(%rdx)
movq %r9, 0x28(%rdx)
testb %al, %al
je 0x358a
movaps %xmm0, 0x50(%rsp)
movaps %xmm1, 0x60(%rsp)
movaps %xmm2, 0x70(%rsp)
movaps %xmm3, 0x80(%rsp)
movaps %xmm4, 0x90(%rsp)
movaps %xmm5, 0xa0(%rsp)
movaps %xmm6, 0xb0(%rsp)
movaps %xmm7, 0xc0(%rsp)
movq %rsp, %r15
movq %rdx, 0x10(%r15)
leaq 0x100(%rsp), %rax
movq %rax, 0x8(%r15)
movabsq $0x3000000018, %rax     # imm = 0x3000000018
movq %rax, (%r15)
movq 0xaa1f(%rip), %r12      # 0xdfd0
movq (%r12), %rdi
movq 0x30(%rsi), %rdx
movl 0x2c(%rsi), %ecx
leaq 0x6bae(%rip), %rsi      # 0xa171
xorl %eax, %eax
callq 0x32e0
movq (%r12), %rdi
movq %r14, %rsi
movq %r15, %rdx
callq 0x32a0
movl (%rbx), %eax
leal 0x1(%rax), %ecx
movl %ecx, (%rbx)
cmpl $0x9, %eax
setl %al
addq $0xd8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
nop
// File: /workspace/github_c_makefile_star2_O3/mrkite[P]regs/docmaker/compiler.cc
// Function: Compiler::defErr(Symbol*, char const*, ...)
bool Compiler::defErr(Symbol *symbol, const char *format, ...) {
  va_list args;
  va_start(args, format);

  fprintf(stderr, "Error: %s:%d: ", symbol->definedFile.c_str(),
          symbol->definedLine);
  vfprintf(stderr, format, args);

  va_end(args);

  numErrors++;
  return numErrors < 10;
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0xd8, %rsp
movq %rdx, %r14
movq %rdi, %rbx
leaq 0x20(%rsp), %rdx
movq %rcx, 0x18(%rdx)
movq %r8, 0x20(%rdx)
movq %r9, 0x28(%rdx)
testb %al, %al
je 0x3656
movaps %xmm0, 0x50(%rsp)
movaps %xmm1, 0x60(%rsp)
movaps %xmm2, 0x70(%rsp)
movaps %xmm3, 0x80(%rsp)
movaps %xmm4, 0x90(%rsp)
movaps %xmm5, 0xa0(%rsp)
movaps %xmm6, 0xb0(%rsp)
movaps %xmm7, 0xc0(%rsp)
movq %rsp, %r15
movq %rdx, 0x10(%r15)
leaq 0x100(%rsp), %rax
movq %rax, 0x8(%r15)
movabsq $0x3000000018, %rax     # imm = 0x3000000018
movq %rax, (%r15)
movq 0xa953(%rip), %r12      # 0xdfd0
movq (%r12), %rdi
movq 0x58(%rsi), %rdx
movl 0x50(%rsi), %ecx
leaq 0x6ae2(%rip), %rsi      # 0xa171
xorl %eax, %eax
callq 0x32e0
movq (%r12), %rdi
movq %r14, %rsi
movq %r15, %rdx
callq 0x32a0
movl (%rbx), %eax
leal 0x1(%rax), %ecx
movl %ecx, (%rbx)
cmpl $0x9, %eax
setl %al
addq $0xd8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O3/mrkite[P]regs/docmaker/parser.cc
// Function: Parser::add(char const*, Intrinsic)
void Parser::add(const char *token, Intrinsic value) {
  Token t;
  t.asStr = token;
  t.filename = "(intrinsic)";
  t.curLine = 0;
  Symbol *symbol = find(t);
  symbol->isKnown = true;
  symbol->definedLine = symbol->referencedLine;
  symbol->definedFile = symbol->referencedFile;
  symbol->kind = isIntrinsic;
  symbol->asIntrinsic = value;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x58, %rsp
movl %edx, %ebx
movq %rsi, %r15
movq %rdi, %r14
leaq 0x8(%rsp), %r12
leaq 0x18(%rsp), %r13
movq %r13, -0x10(%r13)
xorl %eax, %eax
movq %rax, -0x8(%r13)
movb %al, (%r13)
movb %al, 0x10(%r13)
movl $0x0, 0x14(%r13)
leaq 0x40(%rsp), %rbp
movq %rbp, -0x10(%rbp)
movq %rax, -0x8(%rbp)
movb %al, (%rbp)
movq %rsi, %rdi
callq 0x3110
movq %r12, %rdi
xorl %esi, %esi
xorl %edx, %edx
movq %r15, %rcx
movq %rax, %r8
callq 0x3350
leaq 0x30(%rsp), %rdi
movq 0x8(%rdi), %rdx
leaq 0x6180(%rip), %rcx      # 0xa074
movl $0xb, %r8d
xorl %esi, %esi
callq 0x3350
movq %rsp, %rsi
movl $0x0, 0x50(%rsi)
movq %r14, %rdi
callq 0x3f92
movq %rax, %r14
movb $0x1, 0x28(%rax)
movl 0x2c(%rax), %eax
movl %eax, 0x50(%r14)
leaq 0x30(%r14), %rsi
movq %r14, %rdi
addq $0x58, %rdi
callq 0x3140
movl $0x0, 0x78(%r14)
movl %ebx, 0x80(%r14)
movq 0x30(%rsp), %rdi
cmpq %rbp, %rdi
je 0x3f57
movq 0x40(%rsp), %rsi
incq %rsi
callq 0x3200
movq 0x8(%rsp), %rdi
cmpq %r13, %rdi
je 0x3f6e
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x3200
addq $0x58, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
jmp 0x3f7f
movq %rax, %rbx
movq %rsp, %rdi
callq 0x6014
movq %rbx, %rdi
callq 0x33d0
// File: /workspace/github_c_makefile_star2_O3/mrkite[P]regs/docmaker/parser.cc
// Function: Parser::find(Token const&)
Symbol *Parser::find(const Token &t) {
  std::string key = t.asStr;
  if (symbols.count(key) == 0) {
    Symbol s;
    s.name = key;
    s.referencedLine = t.curLine;
    s.referencedFile = t.filename;
    symbols.insert(std::pair<std::string, Symbol>(key, s));
  }
  return &symbols[key];
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x158, %rsp            # imm = 0x158
movq %rsi, %r14
movq %rdi, %rbx
leaq 0x18(%rsp), %r12
movq %r12, -0x10(%r12)
movq 0x8(%rsi), %rsi
movq 0x10(%r14), %rdx
addq %rsi, %rdx
leaq 0x8(%rsp), %r15
movq %r15, %rdi
callq 0x6342
movq %rbx, %rdi
movq %r15, %rsi
callq 0x63d8
leaq 0x8(%rbx), %rcx
cmpq %rcx, %rax
jne 0x414d
leaq 0x38(%rsp), %r15
movq %r15, -0x10(%r15)
xorl %eax, %eax
movq %rax, -0x8(%r15)
movb %al, (%r15)
movw $0x0, 0x10(%r15)
movl %eax, 0x14(%r15)
movb %al, 0x18(%r15)
movl %eax, 0x1c(%r15)
leaq 0x68(%rsp), %r13
movq %r13, -0x10(%r13)
movq %rax, -0x8(%r13)
movb %al, (%r13)
movl %eax, 0x10(%r13)
leaq 0x90(%rsp), %rbp
movq %rbp, -0x10(%rbp)
movq %rax, -0x8(%rbp)
movb %al, (%rbp)
leaq 0x28(%rsp), %rdi
leaq 0x8(%rsp), %rsi
callq 0x3140
leaq 0x58(%rsp), %rdi
movl 0x50(%r14), %eax
movl %eax, -0x4(%rdi)
addq $0x30, %r14
movq %r14, %rsi
callq 0x3140
leaq 0xb0(%rsp), %rdi
leaq 0x8(%rsp), %rsi
leaq 0x28(%rsp), %rdx
callq 0x604c
leaq 0xb0(%rsp), %rsi
movq %rbx, %rdi
callq 0x6462
leaq 0x138(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x409f
movq 0x138(%rsp), %rsi
incq %rsi
callq 0x3200
leaq 0x110(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x40c0
movq 0x110(%rsp), %rsi
incq %rsi
callq 0x3200
leaq 0xe0(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x40e1
movq 0xe0(%rsp), %rsi
incq %rsi
callq 0x3200
leaq 0xc0(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x4102
movq 0xc0(%rsp), %rsi
incq %rsi
callq 0x3200
movq 0x80(%rsp), %rdi
cmpq %rbp, %rdi
je 0x411f
movq 0x90(%rsp), %rsi
incq %rsi
callq 0x3200
movq 0x58(%rsp), %rdi
cmpq %r13, %rdi
je 0x4136
movq 0x68(%rsp), %rsi
incq %rsi
callq 0x3200
movq 0x28(%rsp), %rdi
cmpq %r15, %rdi
je 0x414d
movq 0x38(%rsp), %rsi
incq %rsi
callq 0x3200
leaq 0x8(%rsp), %rsi
movq %rbx, %rdi
callq 0x6210
movq %rax, %rbx
movq 0x8(%rsp), %rdi
cmpq %r12, %rdi
je 0x4174
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x3200
movq %rbx, %rax
addq $0x158, %rsp            # imm = 0x158
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
leaq 0xb0(%rsp), %rdi
callq 0x6158
jmp 0x41a0
jmp 0x419d
movq %rax, %rbx
leaq 0x28(%rsp), %rdi
callq 0x61c2
jmp 0x41af
movq %rax, %rbx
movq 0x8(%rsp), %rdi
cmpq %r12, %rdi
je 0x41c6
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x3200
movq %rbx, %rdi
callq 0x33d0
// File: /workspace/github_c_makefile_star2_O3/mrkite[P]regs/docmaker/parser.cc
// Function: Parser::load(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>)
bool Parser::load(std::string filename) {
  std::ifstream f(filename, std::ios::in | std::ios::binary | std::ios::ate);
  if (!f.is_open()) {
    return false;
  }
  std::streamoff len = f.tellg();
  char *data = new char[len + 1];
  f.seekg(0, std::ios::beg);
  f.read(data, len);
  f.close();

  data[len] = 0;

  File file;
  file.p = data;
  file.end = data + len;
  file.name = filename;
  file.curLine = 1;

  bool okay = parse(&file);
  delete [] data;
  return okay;
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x248, %rsp            # imm = 0x248
movq %rsi, %r14
movq %rdi, %rbx
leaq 0x40(%rsp), %rdi
movl $0xe, %edx
callq 0x3380
leaq 0xb8(%rsp), %rdi
callq 0x3090
testb %al, %al
je 0x4520
leaq 0x40(%rsp), %rdi
callq 0x33c0
movq %rax, %r12
leaq 0x1(%rax), %rdi
callq 0x3030
movq %rax, %r15
leaq 0x40(%rsp), %rdi
xorl %esi, %esi
xorl %edx, %edx
callq 0x32b0
leaq 0x40(%rsp), %rdi
movq %r15, %rsi
movq %r12, %rdx
callq 0x3270
leaq 0x40(%rsp), %rdi
callq 0x3080
movq %r15, %rax
addq %r12, %rax
xorl %ecx, %ecx
movb %cl, (%r15,%r12)
leaq 0x18(%rsp), %rdi
leaq 0x28(%rsp), %r12
movq %r12, -0x10(%r12)
movq $0x0, -0x8(%r12)
movb %cl, (%r12)
movq %r15, -0x28(%r12)
movq %rax, -0x18(%r12)
movq %r14, %rsi
callq 0x3140
movq %rsp, %rsi
movl $0x1, 0x38(%rsi)
movq %rbx, %rdi
callq 0x4572
movl %eax, %ebx
movq %r15, %rdi
callq 0x3280
movq 0x18(%rsp), %rdi
cmpq %r12, %rdi
je 0x4522
movq 0x28(%rsp), %rsi
incq %rsi
callq 0x3200
jmp 0x4522
xorl %ebx, %ebx
leaq 0x40(%rsp), %rdi
callq 0x30b0
movl %ebx, %eax
addq $0x248, %rsp            # imm = 0x248
popq %rbx
popq %r12
popq %r14
popq %r15
retq
jmp 0x453f
movq %rax, %rbx
movq 0x18(%rsp), %rdi
cmpq %r12, %rdi
je 0x4560
movq 0x28(%rsp), %rsi
incq %rsi
callq 0x3200
jmp 0x4560
jmp 0x455d
movq %rax, %rbx
leaq 0x40(%rsp), %rdi
callq 0x30b0
movq %rbx, %rdi
callq 0x33d0
// File: /workspace/github_c_makefile_star2_O3/mrkite[P]regs/docmaker/parser.cc
// Function: Parser::parse(File*)
bool Parser::parse(File *file) {
  Token token;
  while ((token = file->token()).type != END) {
    switch (token.type) {
      case VAR:
        if (!addDefinition(token, file)) {
          return false;
        }
        break;
      default:
        error(file, "Expected a definition\n");
        return false;
    }
  }
  return true;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0xb8, %rsp
movq %rsi, %rbx
movq %rdi, %r14
leaq 0x20(%rsp), %rcx
movq %rcx, -0x10(%rcx)
xorl %eax, %eax
movq %rax, -0x8(%rcx)
movb %al, (%rcx)
movb %al, 0x10(%rcx)
movl $0x0, 0x14(%rcx)
leaq 0x48(%rsp), %rcx
movq %rcx, -0x10(%rcx)
movq %rax, -0x8(%rcx)
movb %al, (%rcx)
leaq 0x78(%rsp), %rbp
leaq 0x60(%rsp), %r15
leaq 0x8(%rsp), %r12
movq %r15, %rdi
movq %rbx, %rsi
callq 0x7862
movl 0x60(%rsp), %eax
movl %eax, 0x8(%rsp)
leaq 0x10(%rsp), %rdi
leaq 0x68(%rsp), %rsi
callq 0x3260
movq 0x88(%rsp), %rax
movq %rax, 0x30(%rsp)
leaq 0x38(%rsp), %rdi
leaq 0x90(%rsp), %rsi
callq 0x3260
movl 0xb0(%rsp), %eax
movl %eax, 0x58(%rsp)
movl 0x8(%rsp), %r13d
movq 0x90(%rsp), %rdi
leaq 0xa0(%rsp), %rax
cmpq %rax, %rdi
je 0x4638
movq 0xa0(%rsp), %rsi
incq %rsi
callq 0x3200
movq 0x68(%rsp), %rdi
cmpq %rbp, %rdi
je 0x464f
movq 0x78(%rsp), %rsi
incq %rsi
callq 0x3200
testl %r13d, %r13d
je 0x4671
cmpl $0x7, 0x8(%rsp)
jne 0x46c1
movq %r14, %rdi
movq %r12, %rsi
movq %rbx, %rdx
callq 0x46ec
testb %al, %al
jne 0x45c2
movq 0x38(%rsp), %rdi
leaq 0x48(%rsp), %rax
cmpq %rax, %rdi
je 0x468d
movq 0x48(%rsp), %rsi
incq %rsi
callq 0x3200
movq 0x10(%rsp), %rdi
leaq 0x20(%rsp), %rax
cmpq %rax, %rdi
je 0x46a9
movq 0x20(%rsp), %rsi
incq %rsi
callq 0x3200
testl %r13d, %r13d
sete %al
addq $0xb8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
leaq 0x59d4(%rip), %rdx      # 0xa09c
movq %rbx, %rsi
xorl %eax, %eax
callq 0x3430
jmp 0x4671
jmp 0x46d6
movq %rax, %rbx
leaq 0x8(%rsp), %rdi
callq 0x6014
movq %rbx, %rdi
callq 0x33d0
nop
// File: /workspace/github_c_makefile_star2_O3/mrkite[P]regs/docmaker/parser.cc
// Function: Parser::addDefinition(Token const&, File*)
bool Parser::addDefinition(const Token &def, File *file) {
  Symbol *s = find(def);
  if (s->isKnown) {
    error(file, "Duplicate definition: '%s'\nDefined in '%s' on line %d\n",
          s->name.c_str(), s->definedFile.c_str(), s->definedLine);
    return false;
  }
  s->definedLine = def.curLine;
  s->definedFile = def.filename;
  s->isKnown = true;
  Token token = file->token();
  switch (token.type) {
    case ENUM:
      return parseEnum(s, file);
    case SYMBOL:
      switch (token.asSym) {
        case '(':
          return parseFunc(s, file);
        case '=':
          return parseAlias(s, file);
        default:
          error(file, "Expected '=' or '(', found '%c'\n", token.asSym);
          return false;
      }
    case STRUCT:
      s->kind = isStruct;
      s->asStruct = new Struct();
      return parseStruct(s->asStruct, file);
    case UNION:
      s->kind = isUnion;
      s->asStruct = new Struct();
      return parseStruct(s->asStruct, file);
    default:
      error(file, "Parser error.\n");
      return false;
  }
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x60, %rsp
movq %rdx, %rbx
movq %rsi, %r12
movq %rdi, %r14
callq 0x3f92
movq %rax, %r15
cmpb $0x1, 0x28(%rax)
je 0x4826
movl 0x50(%r12), %eax
movl %eax, 0x50(%r15)
addq $0x30, %r12
movq %r15, %rdi
addq $0x58, %rdi
movq %r12, %rsi
callq 0x3140
movb $0x1, 0x28(%r15)
leaq 0x8(%rsp), %r12
movq %r12, %rdi
movq %rbx, %rsi
callq 0x7862
movl (%r12), %eax
decl %eax
cmpl $0x5, %eax
ja 0x4846
leaq 0x5902(%rip), %rcx      # 0xa05c
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
movq %r14, %rdi
movq %r15, %rsi
movq %rbx, %rdx
callq 0x488e
jmp 0x47b0
movl $0x3, %eax
jmp 0x477f
movl $0x4, %eax
movl %eax, 0x78(%r15)
movl $0x18, %edi
callq 0x31f0
xorps %xmm0, %xmm0
movups %xmm0, (%rax)
movq $0x0, 0x10(%rax)
movq %rax, 0x80(%r15)
movq %r14, %rdi
movq %rax, %rsi
movq %rbx, %rdx
callq 0x558a
movl %eax, %ebp
leaq 0x48(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x47cd
movq 0x48(%rsp), %rsi
incq %rsi
callq 0x3200
leaq 0x20(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x47e8
movq 0x20(%rsp), %rsi
incq %rsi
callq 0x3200
movl %ebp, %eax
addq $0x60, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
movzbl 0x30(%rsp), %eax
cmpl $0x3d, %eax
je 0x4816
cmpl $0x28, %eax
jne 0x485e
movq %r14, %rdi
movq %r15, %rsi
movq %rbx, %rdx
callq 0x4e1a
jmp 0x47b0
movq %r14, %rdi
movq %r15, %rsi
movq %rbx, %rdx
callq 0x54b2
jmp 0x47b0
movq (%r15), %rcx
movq 0x58(%r15), %r8
movl 0x50(%r15), %r9d
leaq 0x587b(%rip), %rdx      # 0xa0b3
xorl %ebp, %ebp
movq %rbx, %rsi
xorl %eax, %eax
callq 0x3430
jmp 0x47e8
leaq 0x58be(%rip), %rdx      # 0xa10b
xorl %ebp, %ebp
movq %rbx, %rsi
xorl %eax, %eax
callq 0x3430
jmp 0x47b2
movsbl %al, %ecx
leaq 0x5882(%rip), %rdx      # 0xa0ea
xorl %ebp, %ebp
movq %rbx, %rsi
xorl %eax, %eax
callq 0x3430
jmp 0x47b2
movq %rax, %rbx
leaq 0x8(%rsp), %rdi
callq 0x6014
movq %rbx, %rdi
callq 0x33d0
// File: /workspace/github_c_makefile_star2_O3/mrkite[P]regs/docmaker/parser.cc
// Function: Parser::parseAlias(Symbol*, File*)
bool Parser::parseAlias(Symbol *s, File *f) {
  Ref *ref = new Ref();
  s->asAlias = ref;
  s->kind = isAlias;
  if (!parseRef(ref, f)) {
    return false;
  }
  return f->token().expect(';');
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
subq $0x60, %rsp
movq %rdx, %rbx
movq %rsi, %r14
movq %rdi, %r15
movl $0x30, %edi
callq 0x31f0
xorps %xmm0, %xmm0
movups %xmm0, (%rax)
movups %xmm0, 0x10(%rax)
movups %xmm0, 0x20(%rax)
leaq 0x20(%rax), %rcx
movl $0xffffffff, 0xc(%rax)  # imm = 0xFFFFFFFF
movq %rcx, 0x10(%rax)
movb $0x0, 0x20(%rax)
movq %rax, 0x80(%r14)
movl $0x2, 0x78(%r14)
movq %r15, %rdi
movq %rax, %rsi
movq %rbx, %rdx
callq 0x59ac
testb %al, %al
je 0x5567
leaq 0x8(%rsp), %r14
movq %r14, %rdi
movq %rbx, %rsi
callq 0x7862
movq %r14, %rdi
movl $0x3b, %esi
callq 0x7afc
movl %eax, %ebx
leaq 0x48(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x554a
movq 0x48(%rsp), %rsi
incq %rsi
callq 0x3200
leaq 0x20(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x5569
movq 0x20(%rsp), %rsi
incq %rsi
callq 0x3200
jmp 0x5569
xorl %ebx, %ebx
movl %ebx, %eax
addq $0x60, %rsp
popq %rbx
popq %r14
popq %r15
retq
movq %rax, %rbx
leaq 0x8(%rsp), %rdi
callq 0x6014
movq %rbx, %rdi
callq 0x33d0
// File: /workspace/github_c_makefile_star2_O3/mrkite[P]regs/docmaker/parser.cc
// Function: Parser::parseArgument(Argument*, Token const&, File*)
bool Parser::parseArgument(Argument *arg, const Token &def, File *f) {
  arg->key = def.asStr;
  if (!f->token().expect(':')) {
    return false;
  }
  return parseRef(&arg->ref, f);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x60, %rsp
movq %rcx, %rbx
movq %rsi, %r14
movq %rdi, %r15
leaq 0x8(%rdx), %rsi
movq %r14, %rdi
callq 0x3140
leaq 0x8(%rsp), %r12
movq %r12, %rdi
movq %rbx, %rsi
callq 0x7862
movq %r12, %rdi
movl $0x3a, %esi
callq 0x7afc
movl %eax, %ebp
leaq 0x48(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x5953
movq 0x48(%rsp), %rsi
incq %rsi
callq 0x3200
leaq 0x20(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x596e
movq 0x20(%rsp), %rsi
incq %rsi
callq 0x3200
testb %bpl, %bpl
je 0x5987
addq $0x20, %r14
movq %r15, %rdi
movq %r14, %rsi
movq %rbx, %rdx
callq 0x59ac
jmp 0x5989
xorl %eax, %eax
addq $0x60, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
leaq 0x8(%rsp), %rdi
callq 0x6014
movq %rbx, %rdi
callq 0x33d0
nop
// File: /workspace/github_c_makefile_star2_O3/mrkite[P]regs/docmaker/parser.cc
// Function: Parser::parseField(Field*, Token const&, File*)
bool Parser::parseField(Field *field, const Token &def, File *f) {
  if (def.type == STRUCT) {
    field->kind = isStruct;
    field->theStruct = new Struct();
    return parseStruct(field->theStruct, f);
  } else if (def.type == UNION) {
    field->kind = isUnion;
    field->theStruct = new Struct();
    return parseStruct(field->theStruct, f);
  } else {
    field->kind = isRef;
    field->key = def.asStr;
    if (!f->token().expect(':')) {
      return false;
    }
    field->ref = new Ref();
    return parseRef(field->ref, f);
  }
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x60, %rsp
movq %rcx, %rbx
movq %rsi, %r15
movq %rdi, %r14
movl (%rdx), %eax
cmpl $0x6, %eax
je 0x5f01
cmpl $0x5, %eax
jne 0x5f3f
movl $0x3, 0x20(%r15)
jmp 0x5f09
movl $0x4, 0x20(%r15)
movl $0x18, %edi
callq 0x31f0
xorps %xmm0, %xmm0
movups %xmm0, (%rax)
movq $0x0, 0x10(%rax)
movq %rax, 0x28(%r15)
movq %r14, %rdi
movq %rax, %rsi
movq %rbx, %rdx
addq $0x60, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
jmp 0x558a
movl $0x5, 0x20(%r15)
addq $0x8, %rdx
movq %r15, %rdi
movq %rdx, %rsi
callq 0x3140
leaq 0x8(%rsp), %r12
movq %r12, %rdi
movq %rbx, %rsi
callq 0x7862
movq %r12, %rdi
movl $0x3a, %esi
callq 0x7afc
movl %eax, %ebp
leaq 0x48(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x5f90
movq 0x48(%rsp), %rsi
incq %rsi
callq 0x3200
leaq 0x20(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x5fab
movq 0x20(%rsp), %rsi
incq %rsi
callq 0x3200
testb %bpl, %bpl
je 0x5fef
movl $0x30, %edi
callq 0x31f0
xorps %xmm0, %xmm0
movups %xmm0, (%rax)
movups %xmm0, 0x10(%rax)
movups %xmm0, 0x20(%rax)
leaq 0x20(%rax), %rcx
movl $0xffffffff, 0xc(%rax)  # imm = 0xFFFFFFFF
movq %rcx, 0x10(%rax)
movb $0x0, 0x20(%rax)
movq %rax, 0x28(%r15)
movq %r14, %rdi
movq %rax, %rsi
movq %rbx, %rdx
callq 0x59ac
jmp 0x5ff1
xorl %eax, %eax
addq $0x60, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
leaq 0x8(%rsp), %rdi
callq 0x6014
movq %rbx, %rdi
callq 0x33d0
nop
// File: /workspace/github_c_makefile_star2_O3/mrkite[P]regs/docmaker/compiler.cc
// Function: Compiler::calculateSizes(Symbol*)
bool Compiler::calculateSizes(Symbol *s) {
  s->isSizing = true;
  switch (s->kind) {
    case isFunction:
      s->size = 4;
      break;
    case isAlias:
    case isRef:
      s->size = calcRefSize(s->asAlias, s);
      break;
    case isStruct:
      s->size = calcStructSize(s->asStruct, s);
      if (s->size < 0) {
        return false;
      }
      break;
    case isUnion:
      s->size = calcUnionSize(s->asStruct, s);
      if (s->size < 0) {
        return false;
      }
      break;
    case isEnum:
      if (!s->asEnum->type->isKnown) {
        refErr(s->asEnum->type, "Unknown type: '%s'\n",
               s->asEnum->type->name.c_str());
        return false;
      }
      if (!s->asEnum->type->isSized) {
        if (s->asEnum->type->isSizing) {
          defErr(s, "Recurisve type found: '%s'\n", s->name.c_str());
          return false;
        }
        if (!calculateSizes(s->asEnum->type)) {
          return false;
        }
      }
      s->size = s->asEnum->type->size;
      break;
    case isIntrinsic:
      switch (s->asIntrinsic) {
        case U8:
        case S8:
          s->size = 1;
          break;
        case U16:
        case S16:
          s->size = 2;
          break;
        case U32:
        case S32:
          s->size = 4;
          break;
        default:
          defErr(s, "Unknown intrinsic\n");
          return false;
      }
      break;
    default:
      defErr(s, "Uknown symbol type\n");
      return false;
  }
  s->isSized = true;
  s->isSizing = false;
  return true;
}

// Assembly:
pushq %rbp
pushq %rbx
pushq %rax
movq %rsi, %rbx
movb $0x1, 0x20(%rsi)
movl 0x78(%rsi), %eax
cmpq $0x6, %rax
ja 0x758d
leaq 0x2cc8(%rip), %rcx      # 0xa19c
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
movq 0x80(%rbx), %rsi
movq %rbx, %rdx
callq 0x75d8
jmp 0x755c
movl 0x80(%rbx), %eax
cmpq $0x6, %rax
jae 0x7596
leaq 0x2cb3(%rip), %rcx      # 0xa1b8
movl (%rcx,%rax,4), %eax
jmp 0x755c
movq 0x80(%rbx), %rax
movq (%rax), %rsi
cmpb $0x0, 0x28(%rsi)
je 0x75ab
cmpb $0x0, 0x21(%rsi)
jne 0x7541
cmpb $0x1, 0x20(%rsi)
je 0x75c0
callq 0x74b6
testb %al, %al
je 0x7589
movq 0x80(%rbx), %rax
movq (%rax), %rsi
movl 0x24(%rsi), %eax
jmp 0x755c
movq 0x80(%rbx), %rsi
movq %rbx, %rdx
callq 0x76fc
jmp 0x7570
movl $0x4, %eax
movl %eax, 0x24(%rbx)
jmp 0x7577
movq 0x80(%rbx), %rsi
movq %rbx, %rdx
callq 0x7654
movl %eax, 0x24(%rbx)
testl %eax, %eax
js 0x7589
movw $0x100, 0x20(%rbx)      # imm = 0x100
movb $0x1, %bpl
movl %ebp, %eax
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
xorl %ebp, %ebp
jmp 0x7580
leaq 0x2cd6(%rip), %rdx      # 0xa26a
jmp 0x759d
leaq 0x2cba(%rip), %rdx      # 0xa257
xorl %ebp, %ebp
movq %rbx, %rsi
xorl %eax, %eax
callq 0x35f6
jmp 0x7580
movq (%rsi), %rcx
leaq 0x2c1b(%rip), %rdx      # 0xa1d0
xorl %ebp, %ebp
xorl %eax, %eax
callq 0x352a
jmp 0x7580
movq (%rbx), %rcx
leaq 0x2c71(%rip), %rdx      # 0xa23b
xorl %ebp, %ebp
movq %rbx, %rsi
xorl %eax, %eax
callq 0x35f6
jmp 0x7580
// File: /workspace/github_c_makefile_star2_O3/mrkite[P]regs/docmaker/compiler.cc
// Function: Compiler::calcRefSize(Ref*, Symbol*)
int32_t Compiler::calcRefSize(Ref *ref, Symbol *parent) {
  if (!ref->symbol->isKnown) {
    refErr(ref->symbol, "Unknown type: %s'\n", ref->symbol->name.c_str());
    return -1;
  }
  // prevent recursion errors
  if (ref->pointer > 0) {
    return 4;
  }
  if (!ref->symbol->isSized) {
    if (ref->symbol->isSizing) {
      defErr(parent, "Recursive type found: '%s'\n", parent->name.c_str());
      return -1;
    }
    if (!calculateSizes(ref->symbol)) {
      return -1;
    }
  }
  int32_t size = ref->symbol->size;
  if (ref->array >= 0) {
    size *= ref->array;
  }
  return size;
}

// Assembly:
pushq %rbx
movq %rsi, %rbx
movq (%rsi), %rsi
cmpb $0x0, 0x28(%rsi)
je 0x7622
movl $0x4, %eax
cmpl $0x0, 0x8(%rbx)
jg 0x7638
cmpb $0x0, 0x21(%rsi)
jne 0x760f
cmpb $0x1, 0x20(%rsi)
je 0x763a
callq 0x74b6
movl %eax, %ecx
movl $0xffffffff, %eax       # imm = 0xFFFFFFFF
testb %cl, %cl
je 0x7638
movq (%rbx), %rsi
movl 0xc(%rbx), %ecx
testl %ecx, %ecx
movl $0x1, %eax
cmovnsl %ecx, %eax
imull 0x24(%rsi), %eax
jmp 0x7638
movq (%rsi), %rcx
leaq 0x2c52(%rip), %rdx      # 0xa27e
xorl %eax, %eax
callq 0x352a
movl $0xffffffff, %eax       # imm = 0xFFFFFFFF
popq %rbx
retq
movq (%rdx), %rcx
leaq 0x2c4d(%rip), %rax      # 0xa291
movq %rdx, %rsi
movq %rax, %rdx
xorl %eax, %eax
callq 0x35f6
jmp 0x7633
nop
// File: /workspace/github_c_makefile_star2_O3/mrkite[P]regs/docmaker/file.cc
// Function: File::skipWhitespace()
void File::skipWhitespace() {
  while (p < end && isspace(*p)) {
    if (*p == '\n') {
      curLine++;
    }
    p++;
  }
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movq (%rdi), %r14
movq 0x10(%rdi), %r15
cmpq %r15, %r14
jae 0x7858
movq %rdi, %rbx
movl 0x38(%rdi), %ebp
movb (%r14), %r12b
movsbl %r12b, %edi
callq 0x3060
testl %eax, %eax
je 0x7858
cmpb $0xa, %r12b
jne 0x784d
incl %ebp
movl %ebp, 0x38(%rbx)
incq %r14
movq %r14, (%rbx)
cmpq %r15, %r14
jne 0x7832
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O3/mrkite[P]regs/docmaker/file.cc
// Function: File::checkKeywords(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>)
TokenType File::checkKeywords(std::string keyword) {
  if (keyword == "enum") {
    return ENUM;
  } else if (keyword == "struct") {
    return STRUCT;
  } else if (keyword == "union") {
    return UNION;
  }
  return VAR;
}

// Assembly:
pushq %rbx
movq %rsi, %rbx
leaq 0x281c(%rip), %rsi      # 0xa2c7
movq %rbx, %rdi
callq 0x30d0
testl %eax, %eax
je 0x7ae6
leaq 0x280e(%rip), %rsi      # 0xa2cc
movq %rbx, %rdi
callq 0x30d0
testl %eax, %eax
je 0x7aed
leaq 0x2802(%rip), %rsi      # 0xa2d3
movq %rbx, %rdi
callq 0x30d0
cmpl $0x1, %eax
movl $0x7, %eax
sbbl $0x0, %eax
jmp 0x7af2
movl $0x1, %eax
jmp 0x7af2
movl $0x5, %eax
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O3/mrkite[P]regs/docmaker/file.cc
// Function: Token::expect(char)
bool Token::expect(char ch) {
  if (type != SYMBOL) {
    fprintf(stderr, "Error: %s:%d: ", filename.c_str(), curLine);
    fprintf(stderr, "'%c' expected\n", ch);
    return false;
  }
  if (asSym != ch) {
    fprintf(stderr, "Error: %s:%d: ", filename.c_str(), curLine);
    fprintf(stderr, "'%c' expected, found '%c' instead.\n", ch, asSym);
    return false;
  }
  return true;
}

// Assembly:
pushq %rax
movq %rdi, %rcx
cmpl $0x3, (%rdi)
jne 0x7b0f
movb $0x1, %al
cmpb %sil, 0x28(%rcx)
jne 0x7b1d
popq %rcx
retq
movzbl %sil, %esi
movq %rcx, %rdi
callq 0x36c1
jmp 0x7b2d
leaq 0x28(%rcx), %rdx
movzbl %sil, %edi
movq %rcx, %rsi
callq 0x3704
xorl %eax, %eax
jmp 0x7b0d
nop
// File: /workspace/github_c_makefile_star2_O3/mrkite[P]regs/docmaker/file.cc
// Function: Token::expect(char const*)
bool Token::expect(const char *str) {
  if (type == SYMBOL) {
    for (const char *s = str; *s; s++) {
      if (*s == asSym) {
        return true;
      }
    }
  }
  fprintf(stderr, "Error: %s:%d: ", filename.c_str(), curLine);
  bool comma = false;
  for (const char *s = str; *s; s++) {
    fprintf(stderr, "%s'%c'", comma ? " or " : "", *s);
    comma = true;
  }
  if (type == SYMBOL) {
    fprintf(stderr, " expected, found '%c' instead\n", asSym);
  } else {
    fprintf(stderr, " expected\n");
  }
  return false;
}

// Assembly:
pushq %rbx
subq $0x10, %rsp
cmpl $0x3, (%rdi)
jne 0x7b56
movb (%rsi), %al
testb %al, %al
je 0x7b56
movb 0x28(%rdi), %cl
leaq 0x1(%rsi), %rdx
cmpb %cl, %al
je 0x7b67
movb (%rdx), %al
incq %rdx
testb %al, %al
jne 0x7b49
leaq 0xf(%rsp), %rbx
movq %rbx, %rdx
callq 0x3748
movb (%rbx), %al
jmp 0x7b69
movb $0x1, %al
andb $0x1, %al
addq $0x10, %rsp
popq %rbx
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O3/mrkite[P]regs/docmaker/avl.cc
// Function: rotateRight(std::shared_ptr<AVLNode_>)
static AVLNode rotateRight(AVLNode y) {
  auto x = y->left;
  auto t = x->right;
  x->right = y;
  y->left = t;
  y->height = max(Height(y->left), Height(y->right)) + 1;
  x->height = max(Height(x->left), Height(x->right)) + 1;
  return x;
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %rsi, %r14
movq %rdi, %rbx
movq (%rsi), %rax
movq 0x8(%rax), %rdi
movq %rdi, (%rbx)
movq 0x10(%rax), %rax
movq %rax, 0x8(%rbx)
testq %rax, %rax
je 0x811e
movq 0x5ebb(%rip), %rcx      # 0xdfc8
cmpb $0x0, (%rcx)
je 0x8117
incl 0x8(%rax)
jmp 0x811e
lock
incl 0x8(%rax)
movq (%rbx), %rdi
movq 0x18(%rdi), %r12
leaq 0x10(%rsp), %r15
movq %r12, -0x8(%r15)
movq 0x20(%rdi), %rax
movq %rax, (%r15)
testq %rax, %rax
je 0x8154
movq 0x5e8a(%rip), %rcx      # 0xdfc8
cmpb $0x0, (%rcx)
je 0x8148
incl 0x8(%rax)
jmp 0x8154
lock
incl 0x8(%rax)
movq (%rbx), %rdi
movq 0x8(%rsp), %r12
movq (%r14), %rax
movq %rax, 0x18(%rdi)
addq $0x20, %rdi
leaq 0x8(%r14), %rsi
callq 0x867a
movq (%r14), %rdi
movq %r12, 0x8(%rdi)
addq $0x10, %rdi
movq %r15, %rsi
callq 0x867a
movq (%r14), %rcx
movq 0x8(%rcx), %rax
movq 0x10(%rcx), %r15
testq %r15, %r15
je 0x81a2
movq 0x5e36(%rip), %rcx      # 0xdfc8
cmpb $0x0, (%rcx)
je 0x819d
incl 0x8(%r15)
jmp 0x81a2
lock
incl 0x8(%r15)
testq %rax, %rax
je 0x81ac
movl 0x38(%rax), %eax
jmp 0x81ae
xorl %eax, %eax
movq (%r14), %rdx
movq 0x18(%rdx), %rcx
movq 0x20(%rdx), %rdi
testq %rdi, %rdi
je 0x81d3
movq 0x5e03(%rip), %rdx      # 0xdfc8
cmpb $0x0, (%rdx)
je 0x81cf
incl 0x8(%rdi)
jmp 0x81d3
lock
incl 0x8(%rdi)
testq %rcx, %rcx
je 0x81dd
movl 0x38(%rcx), %ecx
jmp 0x81df
xorl %ecx, %ecx
cmpl %ecx, %eax
cmovgl %eax, %ecx
incl %ecx
movq (%r14), %rax
movl %ecx, 0x38(%rax)
testq %rdi, %rdi
je 0x81f6
callq 0x77a6
testq %r15, %r15
je 0x8203
movq %r15, %rdi
callq 0x77a6
movq (%rbx), %rcx
movq 0x8(%rcx), %rax
movq 0x10(%rcx), %r14
testq %r14, %r14
je 0x822a
movq 0x5dae(%rip), %rcx      # 0xdfc8
cmpb $0x0, (%rcx)
je 0x8225
incl 0x8(%r14)
jmp 0x822a
lock
incl 0x8(%r14)
testq %rax, %rax
je 0x8234
movl 0x38(%rax), %eax
jmp 0x8236
xorl %eax, %eax
movq (%rbx), %rdx
movq 0x18(%rdx), %rcx
movq 0x20(%rdx), %rdi
testq %rdi, %rdi
je 0x825b
movq 0x5d7b(%rip), %rdx      # 0xdfc8
cmpb $0x0, (%rdx)
je 0x8257
incl 0x8(%rdi)
jmp 0x825b
lock
incl 0x8(%rdi)
testq %rcx, %rcx
je 0x8265
movl 0x38(%rcx), %ecx
jmp 0x8267
xorl %ecx, %ecx
cmpl %ecx, %eax
cmovgl %eax, %ecx
incl %ecx
movq (%rbx), %rax
movl %ecx, 0x38(%rax)
testq %rdi, %rdi
je 0x827e
callq 0x77a6
testq %r14, %r14
je 0x828b
movq %r14, %rdi
callq 0x77a6
movq 0x10(%rsp), %rdi
testq %rdi, %rdi
je 0x829a
callq 0x77a6
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O3/mrkite[P]regs/docmaker/avl.cc
// Function: rotateLeft(std::shared_ptr<AVLNode_>)
static AVLNode rotateLeft(AVLNode x) {
  auto y = x->right;
  auto t = y->left;
  y->left = x;
  x->right = t;
  x->height = max(Height(x->left), Height(x->right)) + 1;
  y->height = max(Height(y->left), Height(y->right)) + 1;
  return y;
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %rsi, %r14
movq %rdi, %rbx
movq (%rsi), %rax
movq 0x18(%rax), %rdi
movq %rdi, (%rbx)
movq 0x20(%rax), %rax
movq %rax, 0x8(%rbx)
testq %rax, %rax
je 0x82e6
movq 0x5cf3(%rip), %rcx      # 0xdfc8
cmpb $0x0, (%rcx)
je 0x82df
incl 0x8(%rax)
jmp 0x82e6
lock
incl 0x8(%rax)
movq (%rbx), %rdi
movq 0x8(%rdi), %r12
leaq 0x10(%rsp), %r15
movq %r12, -0x8(%r15)
movq 0x10(%rdi), %rax
movq %rax, (%r15)
testq %rax, %rax
je 0x831c
movq 0x5cc2(%rip), %rcx      # 0xdfc8
cmpb $0x0, (%rcx)
je 0x8310
incl 0x8(%rax)
jmp 0x831c
lock
incl 0x8(%rax)
movq (%rbx), %rdi
movq 0x8(%rsp), %r12
movq (%r14), %rax
movq %rax, 0x8(%rdi)
addq $0x10, %rdi
leaq 0x8(%r14), %rsi
callq 0x867a
movq (%r14), %rdi
movq %r12, 0x18(%rdi)
addq $0x20, %rdi
movq %r15, %rsi
callq 0x867a
movq (%r14), %rcx
movq 0x8(%rcx), %rax
movq 0x10(%rcx), %r15
testq %r15, %r15
je 0x836a
movq 0x5c6e(%rip), %rcx      # 0xdfc8
cmpb $0x0, (%rcx)
je 0x8365
incl 0x8(%r15)
jmp 0x836a
lock
incl 0x8(%r15)
testq %rax, %rax
je 0x8374
movl 0x38(%rax), %eax
jmp 0x8376
xorl %eax, %eax
movq (%r14), %rdx
movq 0x18(%rdx), %rcx
movq 0x20(%rdx), %rdi
testq %rdi, %rdi
je 0x839b
movq 0x5c3b(%rip), %rdx      # 0xdfc8
cmpb $0x0, (%rdx)
je 0x8397
incl 0x8(%rdi)
jmp 0x839b
lock
incl 0x8(%rdi)
testq %rcx, %rcx
je 0x83a5
movl 0x38(%rcx), %ecx
jmp 0x83a7
xorl %ecx, %ecx
cmpl %ecx, %eax
cmovgl %eax, %ecx
incl %ecx
movq (%r14), %rax
movl %ecx, 0x38(%rax)
testq %rdi, %rdi
je 0x83be
callq 0x77a6
testq %r15, %r15
je 0x83cb
movq %r15, %rdi
callq 0x77a6
movq (%rbx), %rcx
movq 0x8(%rcx), %rax
movq 0x10(%rcx), %r14
testq %r14, %r14
je 0x83f2
movq 0x5be6(%rip), %rcx      # 0xdfc8
cmpb $0x0, (%rcx)
je 0x83ed
incl 0x8(%r14)
jmp 0x83f2
lock
incl 0x8(%r14)
testq %rax, %rax
je 0x83fc
movl 0x38(%rax), %eax
jmp 0x83fe
xorl %eax, %eax
movq (%rbx), %rdx
movq 0x18(%rdx), %rcx
movq 0x20(%rdx), %rdi
testq %rdi, %rdi
je 0x8423
movq 0x5bb3(%rip), %rdx      # 0xdfc8
cmpb $0x0, (%rdx)
je 0x841f
incl 0x8(%rdi)
jmp 0x8423
lock
incl 0x8(%rdi)
testq %rcx, %rcx
je 0x842d
movl 0x38(%rcx), %ecx
jmp 0x842f
xorl %ecx, %ecx
cmpl %ecx, %eax
cmovgl %eax, %ecx
incl %ecx
movq (%rbx), %rax
movl %ecx, 0x38(%rax)
testq %rdi, %rdi
je 0x8446
callq 0x77a6
testq %r14, %r14
je 0x8453
movq %r14, %rdi
callq 0x77a6
movq 0x10(%rsp), %rdi
testq %rdi, %rdi
je 0x8462
callq 0x77a6
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O3/mrkite[P]regs/docmaker/avl.cc
// Function: AVL::walk(std::shared_ptr<AVLNode_>, unsigned int) const
AVLNode AVL::walk(AVLNode root, uint32_t key) const {
  AVLNode node = root;
  if (node == nullptr) {
    node = this->root;
  }
  while (node != nullptr && node->key != key) {
    if (key < node->key) {
      node = node->left;
    } else {
      node = node->right;
    }
  }
  return node;
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movl %ecx, %ebx
movq %rdi, %r14
movq (%rdx), %rax
movq %rax, (%rdi)
movq 0x8(%rdx), %rcx
movq %rcx, 0x8(%rdi)
testq %rcx, %rcx
je 0x84a3
movq 0x5b36(%rip), %rdx      # 0xdfc8
cmpb $0x0, (%rdx)
je 0x849c
incl 0x8(%rcx)
jmp 0x84a3
lock
incl 0x8(%rcx)
movq (%r14), %rax
leaq 0x8(%r14), %r15
testq %rax, %rax
jne 0x84c6
movq (%rsi), %rax
movq %rax, (%r14)
addq $0x8, %rsi
movq %r15, %rdi
callq 0x867a
movq (%r14), %rax
testq %rax, %rax
je 0x84e4
cmpl %ebx, (%rax)
je 0x84e4
setbe %cl
movzbl %cl, %ecx
shll $0x4, %ecx
leaq (%rcx,%rax), %rsi
addq $0x10, %rsi
movq -0x8(%rsi), %rax
movq %rax, (%r14)
jmp 0x84b6
movq %r14, %rax
popq %rbx
popq %r14
popq %r15
retq
nop
// File: /workspace/github_c_makefile_star2_O3/mrkite[P]regs/docmaker/output.cc
// Function: Output::ws(std::ostream*, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&)
void Output::ws(std::ostream *f, const std::string &val) {
  uint8_t len = val.length() > 255 ? 255 : val.length();
  char v = len;
  f->write(&v, 1);
  f->write(val.c_str(), len);
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
subq $0x10, %rsp
movq %rdx, %rbx
movq %rsi, %r14
movq 0x8(%rdx), %rax
movl $0xff, %r15d
cmpq %r15, %rax
cmovbq %rax, %r15
leaq 0xf(%rsp), %rsi
movb %r15b, (%rsi)
movl $0x1, %edx
movq %r14, %rdi
callq 0x3290
movq (%rbx), %rsi
movq %r14, %rdi
movq %r15, %rdx
callq 0x3290
addq $0x10, %rsp
popq %rbx
popq %r14
popq %r15
retq
nop
// File: /workspace/github_c_makefile_star2_O3/mrkite[P]regs/docmaker/output.cc
// Function: Output::setEnum(std::ostream*, Enum const*)
void Output::setEnum(std::ostream *f, const Enum *e) {
  w32(f, lookup(e->type->name));
  w32(f, e->entries.size());
  for (auto it = e->entries.begin(); it != e->entries.end(); it++) {
    w32(f, it->second);
    ws(f, it->first);
  }
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %rdx, %rbx
movq %rsi, %r14
movq (%rdx), %rsi
callq 0x90bc
movl (%rax), %eax
leaq 0x10(%rsp), %rsi
movl %eax, (%rsi)
movl $0x4, %edx
movq %r14, %rdi
callq 0x3290
movl 0x30(%rbx), %eax
leaq 0x14(%rsp), %rsi
movl %eax, (%rsi)
movl $0x4, %edx
movq %r14, %rdi
callq 0x3290
movq 0x20(%rbx), %r15
addq $0x10, %rbx
cmpq %rbx, %r15
je 0x8ce4
movl $0xff, %r12d
leaq 0xb(%rsp), %r13
movl 0x40(%r15), %eax
movl %eax, 0xc(%rsp)
movl $0x4, %edx
movq %r14, %rdi
leaq 0xc(%rsp), %rsi
callq 0x3290
movq 0x28(%r15), %rbp
cmpq %r12, %rbp
cmovaeq %r12, %rbp
movb %bpl, 0xb(%rsp)
movl $0x1, %edx
movq %r14, %rdi
movq %r13, %rsi
callq 0x3290
movq 0x20(%r15), %rsi
movq %r14, %rdi
movq %rbp, %rdx
callq 0x3290
movq %r15, %rdi
callq 0x3240
movq %rax, %r15
cmpq %rbx, %rax
jne 0x8c8b
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O3/mrkite[P]regs/docmaker/output.cc
// Function: Output::setRef(std::ostream*, Ref const*)
void Output::setRef(std::ostream *f, const Ref *r) {
  if (r->symbol == nullptr) {
    w32(f, 0);
  } else {
    w32(f, lookup(r->symbol->name));
    w32(f, r->pointer);
    w32(f, r->array);
    ws(f, r->reg);
  }
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq (%rdx), %rsi
testq %rsi, %rsi
je 0x8d97
movq %rdx, %r14
callq 0x90bc
movl (%rax), %eax
leaq 0x4(%rsp), %r15
movl %eax, (%r15)
movl $0x4, %edx
movq %rbx, %rdi
movq %r15, %rsi
callq 0x3290
movl 0x8(%r14), %eax
movl %eax, (%r15)
leaq 0x4(%rsp), %r15
movl $0x4, %edx
movq %rbx, %rdi
movq %r15, %rsi
callq 0x3290
movl 0xc(%r14), %eax
movl %eax, (%r15)
leaq 0x4(%rsp), %r15
movl $0x4, %edx
movq %rbx, %rdi
movq %r15, %rsi
callq 0x3290
movq 0x18(%r14), %rax
movl $0xff, %r12d
cmpq %r12, %rax
cmovbq %rax, %r12
movb %r12b, (%r15)
leaq 0x4(%rsp), %rsi
movl $0x1, %edx
movq %rbx, %rdi
callq 0x3290
movq 0x10(%r14), %rsi
movq %rbx, %rdi
movq %r12, %rdx
jmp 0x8daa
leaq 0x4(%rsp), %rsi
movl $0x0, (%rsi)
movl $0x4, %edx
movq %rbx, %rdi
callq 0x3290
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
nop