LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O0/lucvoo[P]sparse-dev/tokenize.c
// Function: hash_name
static unsigned long hash_name(const char *name, int len)
{
	unsigned long hash;
	const unsigned char *p = (const unsigned char *)name;

	hash = ident_hash_init(*p++);
	while (--len) {
		unsigned int i = *p++;
		hash = ident_hash_add(hash, i);
	}
	return ident_hash_end(hash);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x20(%rbp)
movq -0x20(%rbp), %rax
movq %rax, %rcx
addq $0x1, %rcx
movq %rcx, -0x20(%rbp)
movzbl (%rax), %eax
movq %rax, -0x18(%rbp)
movl -0xc(%rbp), %eax
addl $-0x1, %eax
movl %eax, -0xc(%rbp)
cmpl $0x0, %eax
je 0x44eed
movq -0x20(%rbp), %rax
movq %rax, %rcx
addq $0x1, %rcx
movq %rcx, -0x20(%rbp)
movzbl (%rax), %eax
movl %eax, -0x24(%rbp)
imulq $0xb, -0x18(%rbp), %rax
movl -0x24(%rbp), %ecx
addq %rcx, %rax
movq %rax, -0x18(%rbp)
jmp 0x44eb9
movq -0x18(%rbp), %rax
shrq $0xd, %rax
addq -0x18(%rbp), %rax
andq $0x1fff, %rax           # imm = 0x1FFF
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/lucvoo[P]sparse-dev/tokenize.c
// Function: create_hashed_ident
static struct ident *create_hashed_ident(const char *name, int len, unsigned long hash)
{
	struct ident *ident;
	struct ident **p;

	p = &hash_table[hash];
	while ((ident = *p) != NULL) {
		if (ident->len == (unsigned char) len) {
			if (strncmp(name, ident->name, len) != 0)
				goto next;

			ident_hit++;
			return ident;
		}
next:
		//misses++;
		p = &ident->next;
	}
	ident = alloc_ident(name, len);
	*p = ident;
	ident->next = NULL;
	ident_miss++;
	idents++;
	return ident;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movl %esi, -0x14(%rbp)
movq %rdx, -0x20(%rbp)
movq -0x20(%rbp), %rcx
leaq 0x57a42(%rip), %rax     # 0x9c9c0
shlq $0x3, %rcx
addq %rcx, %rax
movq %rax, -0x30(%rbp)
movq -0x30(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x28(%rbp)
cmpq $0x0, %rax
je 0x44fed
movq -0x28(%rbp), %rax
movzbl 0x10(%rax), %eax
movl -0x14(%rbp), %ecx
movzbl %cl, %ecx
cmpl %ecx, %eax
jne 0x44fe1
movq -0x10(%rbp), %rdi
movq -0x28(%rbp), %rsi
addq $0x12, %rsi
movslq -0x14(%rbp), %rdx
callq 0x11080
cmpl $0x0, %eax
je 0x44fc8
jmp 0x44fe3
movl 0x579e6(%rip), %eax     # 0x9c9b4
addl $0x1, %eax
movl %eax, 0x579dd(%rip)     # 0x9c9b4
movq -0x28(%rbp), %rax
movq %rax, -0x8(%rbp)
jmp 0x45039
jmp 0x44fe3
movq -0x28(%rbp), %rax
movq %rax, -0x30(%rbp)
jmp 0x44f89
movq -0x10(%rbp), %rdi
movl -0x14(%rbp), %esi
callq 0x45310
movq %rax, -0x28(%rbp)
movq -0x28(%rbp), %rcx
movq -0x30(%rbp), %rax
movq %rcx, (%rax)
movq -0x28(%rbp), %rax
movq $0x0, (%rax)
movl 0x5799f(%rip), %eax     # 0x9c9b8
addl $0x1, %eax
movl %eax, 0x57996(%rip)     # 0x9c9b8
movl 0x6d9cc(%rip), %eax     # 0xb29f4
addl $0x1, %eax
movl %eax, 0x6d9c3(%rip)     # 0xb29f4
movq -0x28(%rbp), %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/lucvoo[P]sparse-dev/tokenize.c
// Function: built_in_token
struct token *built_in_token(int stream, struct ident *ident)
{
	struct token *token;

	token = __alloc_token(0);
	token->pos.stream = stream;
	token_type(token) = TOKEN_IDENT;
	token->ident = ident;
	return token;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movl %edi, -0x4(%rbp)
movq %rsi, -0x10(%rbp)
xorl %edi, %edi
callq 0x46980
movq %rax, -0x18(%rbp)
movl -0x4(%rbp), %ecx
movq -0x18(%rbp), %rax
movl %ecx, %ecx
movl %ecx, %edx
movq (%rax), %rcx
andq $0x3fff, %rdx           # imm = 0x3FFF
shlq $0x6, %rdx
andq $-0xfffc1, %rcx         # imm = 0xFFF0003F
orq %rdx, %rcx
movq %rcx, (%rax)
movq -0x18(%rbp), %rax
movq (%rax), %rcx
andq $-0x40, %rcx
orq $0x3, %rcx
movq %rcx, (%rax)
movq -0x10(%rbp), %rcx
movq -0x18(%rbp), %rax
movq %rcx, 0x10(%rax)
movq -0x18(%rbp), %rax
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/lucvoo[P]sparse-dev/tokenize.c
// Function: setup_stream
static struct token *setup_stream(stream_t *stream, int idx, int fd,
	unsigned char *buf, unsigned int buf_size)
{
	struct token *begin;

	stream->nr = idx;
	stream->line = 1;
	stream->newline = 1;
	stream->whitespace = 0;
	stream->pos = 0;

	stream->token = NULL;
	stream->fd = fd;
	stream->offset = 0;
	stream->size = buf_size;
	stream->buffer = buf;

	begin = alloc_token(stream);
	token_type(begin) = TOKEN_STREAMBEGIN;
	stream->tokenlist = &begin->next;
	return begin;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movl %edx, -0x10(%rbp)
movq %rcx, -0x18(%rbp)
movl %r8d, -0x1c(%rbp)
movl -0xc(%rbp), %ecx
movq -0x8(%rbp), %rax
movl %ecx, 0x14(%rax)
movq -0x8(%rbp), %rax
movl $0x1, 0x10(%rax)
movq -0x8(%rbp), %rax
movl $0x1, 0x18(%rax)
movq -0x8(%rbp), %rax
movl $0x0, 0x1c(%rax)
movq -0x8(%rbp), %rax
movl $0x0, 0xc(%rax)
movq -0x8(%rbp), %rax
movq $0x0, 0x28(%rax)
movl -0x10(%rbp), %ecx
movq -0x8(%rbp), %rax
movl %ecx, (%rax)
movq -0x8(%rbp), %rax
movl $0x0, 0x4(%rax)
movl -0x1c(%rbp), %ecx
movq -0x8(%rbp), %rax
movl %ecx, 0x8(%rax)
movq -0x18(%rbp), %rcx
movq -0x8(%rbp), %rax
movq %rcx, 0x30(%rax)
movq -0x8(%rbp), %rdi
callq 0x45380
movq %rax, -0x28(%rbp)
movq -0x28(%rbp), %rax
movq (%rax), %rcx
andq $-0x40, %rcx
orq $0x13, %rcx
movq %rcx, (%rax)
movq -0x28(%rbp), %rcx
addq $0x8, %rcx
movq -0x8(%rbp), %rax
movq %rcx, 0x20(%rax)
movq -0x28(%rbp), %rax
addq $0x30, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/lucvoo[P]sparse-dev/tokenize.c
// Function: tokenize_stream
static struct token *tokenize_stream(stream_t *stream)
{
	int c = nextchar(stream);
	while (c != EOF) {
		if (!isspace(c)) {
			struct token *token = alloc_token(stream);
			stream->token = token;
			stream->newline = 0;
			stream->whitespace = 0;
			c = get_one_token(c, stream);
			continue;
		}
		stream->whitespace = 1;
		c = nextchar(stream);
	}
	return mark_eof(stream);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
callq 0x454d0
movl %eax, -0xc(%rbp)
cmpl $-0x1, -0xc(%rbp)
je 0x45261
callq 0x112f0
movq (%rax), %rax
movslq -0xc(%rbp), %rcx
movzwl (%rax,%rcx,2), %eax
andl $0x2000, %eax           # imm = 0x2000
cmpl $0x0, %eax
jne 0x45248
movq -0x8(%rbp), %rdi
callq 0x45380
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rcx
movq -0x8(%rbp), %rax
movq %rcx, 0x28(%rax)
movq -0x8(%rbp), %rax
movl $0x0, 0x18(%rax)
movq -0x8(%rbp), %rax
movl $0x0, 0x1c(%rax)
movl -0xc(%rbp), %edi
movq -0x8(%rbp), %rsi
callq 0x45560
movl %eax, -0xc(%rbp)
jmp 0x451e8
movq -0x8(%rbp), %rax
movl $0x1, 0x1c(%rax)
movq -0x8(%rbp), %rdi
callq 0x454d0
movl %eax, -0xc(%rbp)
jmp 0x451e8
movq -0x8(%rbp), %rdi
callq 0x455f0
addq $0x20, %rsp
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O0/lucvoo[P]sparse-dev/tokenize.c
// Function: tokenize
struct token * tokenize(const struct position *pos, const char *name, int fd, struct token *endtoken, const char **next_path)
{
	struct token *begin, *end;
	stream_t stream;
	unsigned char buffer[BUFSIZE];
	int idx;

	idx = init_stream(pos, name, fd, next_path);
	if (idx < 0) {
		// info(endtoken->pos, "File %s is const", name);
		return endtoken;
	}

	begin = setup_stream(&stream, idx, fd, buffer, 0);
	end = tokenize_stream(&stream);
	if (endtoken)
		end->next = endtoken;
	return begin;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x2090, %rsp           # imm = 0x2090
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movl %edx, -0x1c(%rbp)
movq %rcx, -0x28(%rbp)
movq %r8, -0x30(%rbp)
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rsi
movl -0x1c(%rbp), %edx
movq -0x30(%rbp), %rcx
callq 0x44b60
movl %eax, -0x2084(%rbp)
cmpl $0x0, -0x2084(%rbp)
jge 0x452bb
movq -0x28(%rbp), %rax
movq %rax, -0x8(%rbp)
jmp 0x45303
movl -0x2084(%rbp), %esi
movl -0x1c(%rbp), %edx
leaq -0x2080(%rbp), %rcx
leaq -0x78(%rbp), %rdi
xorl %r8d, %r8d
callq 0x45110
movq %rax, -0x38(%rbp)
leaq -0x78(%rbp), %rdi
callq 0x451d0
movq %rax, -0x40(%rbp)
cmpq $0x0, -0x28(%rbp)
je 0x452fb
movq -0x28(%rbp), %rcx
movq -0x40(%rbp), %rax
movq %rcx, 0x8(%rax)
movq -0x38(%rbp), %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x2090, %rsp           # imm = 0x2090
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O0/lucvoo[P]sparse-dev/tokenize.c
// Function: alloc_ident
static struct ident *alloc_ident(const char *name, int len)
{
	struct ident *ident = __alloc_ident(len);
	ident->symbols = NULL;
	ident->len = len;
	ident->tainted = 0;
	memcpy(ident->name, name, len);
	return ident;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movl -0xc(%rbp), %edi
callq 0x46890
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rax
movq $0x0, 0x8(%rax)
movl -0xc(%rbp), %eax
movb %al, %cl
movq -0x18(%rbp), %rax
movb %cl, 0x10(%rax)
movq -0x18(%rbp), %rax
movb 0x11(%rax), %cl
andb $-0x2, %cl
orb $0x0, %cl
movb %cl, 0x11(%rax)
movq -0x18(%rbp), %rdi
addq $0x12, %rdi
movq -0x8(%rbp), %rsi
movslq -0xc(%rbp), %rdx
callq 0x111d0
movq -0x18(%rbp), %rax
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/lucvoo[P]sparse-dev/tokenize.c
// Function: stream_pos
static struct position stream_pos(stream_t *stream)
{
	struct position pos;
	pos.type = 0;
	pos.stream = stream->nr;
	pos.newline = stream->newline;
	pos.whitespace = stream->whitespace;
	pos.pos = stream->pos;
	pos.line = stream->line;
	pos.noexpand = 0;
	return pos;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x10(%rbp)
movq -0x8(%rbp), %rax
andq $-0x40, %rax
orq $0x0, %rax
movq %rax, -0x8(%rbp)
movq -0x10(%rbp), %rax
movl 0x14(%rax), %eax
movl %eax, %ecx
movq -0x8(%rbp), %rax
andq $0x3fff, %rcx           # imm = 0x3FFF
shlq $0x6, %rcx
andq $-0xfffc1, %rax         # imm = 0xFFF0003F
orq %rcx, %rax
movq %rax, -0x8(%rbp)
movq -0x10(%rbp), %rax
movl 0x18(%rax), %eax
movl %eax, %ecx
movq -0x8(%rbp), %rax
andq $0x1, %rcx
shlq $0x14, %rcx
andq $-0x100001, %rax        # imm = 0xFFEFFFFF
orq %rcx, %rax
movq %rax, -0x8(%rbp)
movq -0x10(%rbp), %rax
movl 0x1c(%rax), %eax
movl %eax, %ecx
movq -0x8(%rbp), %rax
andq $0x1, %rcx
shlq $0x15, %rcx
andq $-0x200001, %rax        # imm = 0xFFDFFFFF
orq %rcx, %rax
movq %rax, -0x8(%rbp)
movq -0x10(%rbp), %rax
movl 0xc(%rax), %eax
movl %eax, %ecx
movq -0x8(%rbp), %rax
andq $0x3ff, %rcx            # imm = 0x3FF
shlq $0x16, %rcx
movabsq $-0xffc00001, %rdx      # imm = 0xFFFFFFFF003FFFFF
andq %rdx, %rax
orq %rcx, %rax
movq %rax, -0x8(%rbp)
movq -0x10(%rbp), %rax
movl 0x10(%rax), %eax
movl %eax, %ecx
movq -0x8(%rbp), %rax
andq $0x7fffffff, %rcx       # imm = 0x7FFFFFFF
shlq $0x20, %rcx
movabsq $-0x7fffffff00000001, %rdx # imm = 0x80000000FFFFFFFF
andq %rdx, %rax
orq %rcx, %rax
movq %rax, -0x8(%rbp)
movabsq $0x7fffffffffffffff, %rax # imm = 0x7FFFFFFFFFFFFFFF
andq -0x8(%rbp), %rax
orq $0x0, %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/lucvoo[P]sparse-dev/tokenize.c
// Function: nextchar
static inline int nextchar(stream_t *stream)
{
	int offset = stream->offset;

	if (offset < stream->size) {
		int c = stream->buffer[offset++];
		static const char special[256] = {
			['\t'] = 1, ['\r'] = 1, ['\n'] = 1, ['\\'] = 1
		};
		if (!special[c]) {
			stream->offset = offset;
			stream->pos++;
			return c;
		}
	}
	return nextchar_slow(stream);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movq -0x10(%rbp), %rax
movl 0x4(%rax), %eax
movl %eax, -0x14(%rbp)
movl -0x14(%rbp), %eax
movq -0x10(%rbp), %rcx
cmpl 0x8(%rcx), %eax
jge 0x45541
movq -0x10(%rbp), %rax
movq 0x30(%rax), %rax
movl -0x14(%rbp), %ecx
movl %ecx, %edx
addl $0x1, %edx
movl %edx, -0x14(%rbp)
movslq %ecx, %rcx
movzbl (%rax,%rcx), %eax
movl %eax, -0x18(%rbp)
movslq -0x18(%rbp), %rcx
leaq 0x24996(%rip), %rax     # 0x69eb0
cmpb $0x0, (%rax,%rcx)
jne 0x4553f
movl -0x14(%rbp), %ecx
movq -0x10(%rbp), %rax
movl %ecx, 0x4(%rax)
movq -0x10(%rbp), %rax
movl 0xc(%rax), %ecx
addl $0x1, %ecx
movl %ecx, 0xc(%rax)
movl -0x18(%rbp), %eax
movl %eax, -0x4(%rbp)
jmp 0x4554d
jmp 0x45541
movq -0x10(%rbp), %rdi
callq 0x456a0
movl %eax, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/lucvoo[P]sparse-dev/tokenize.c
// Function: get_one_token
static int get_one_token(int c, stream_t *stream)
{
	long class = cclass[c + 1];
	if (class & Digit)
		return get_one_number(c, nextchar(stream), stream);
	if (class & Letter)
		return get_one_identifier(c, stream);
	return get_one_special(c, stream);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movl %edi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl -0x8(%rbp), %eax
addl $0x1, %eax
movslq %eax, %rcx
leaq 0x24a31(%rip), %rax     # 0x69fb0
movsbq (%rax,%rcx), %rax
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rax
andq $0x2, %rax
cmpq $0x0, %rax
je 0x455b8
movl -0x8(%rbp), %eax
movl %eax, -0x1c(%rbp)
movq -0x10(%rbp), %rdi
callq 0x454d0
movl -0x1c(%rbp), %edi
movl %eax, %esi
movq -0x10(%rbp), %rdx
callq 0x458f0
movl %eax, -0x4(%rbp)
jmp 0x455e6
movq -0x18(%rbp), %rax
andq $0x1, %rax
cmpq $0x0, %rax
je 0x455d7
movl -0x8(%rbp), %edi
movq -0x10(%rbp), %rsi
callq 0x45a90
movl %eax, -0x4(%rbp)
jmp 0x455e6
movl -0x8(%rbp), %edi
movq -0x10(%rbp), %rsi
callq 0x45c30
movl %eax, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x20, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/lucvoo[P]sparse-dev/tokenize.c
// Function: mark_eof
static struct token *mark_eof(stream_t *stream)
{
	struct token *end;

	end = alloc_token(stream);
	eof_token_entry.pos = end->pos;
	token_type(end) = TOKEN_STREAMEND;
	end->pos.newline = 1;

	eof_token_entry.next = &eof_token_entry;
	eof_token_entry.pos.newline = 1;

	end->next =  &eof_token_entry;
	*stream->tokenlist = end;
	stream->tokenlist = NULL;
	return end;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
callq 0x45380
movq %rax, -0x10(%rbp)
movq -0x10(%rbp), %rax
movq (%rax), %rax
movq %rax, 0x673a9(%rip)     # 0xac9c0
movq -0x10(%rbp), %rax
movq (%rax), %rcx
andq $-0x40, %rcx
orq $0x14, %rcx
movq %rcx, (%rax)
movq -0x10(%rbp), %rax
movq (%rax), %rcx
andq $-0x100001, %rcx        # imm = 0xFFEFFFFF
orq $0x100000, %rcx         # imm = 0x100000
movq %rcx, (%rax)
leaq 0x67378(%rip), %rax     # 0xac9c0
movq %rax, 0x67379(%rip)     # 0xac9c8
movq 0x6736a(%rip), %rax     # 0xac9c0
andq $-0x100001, %rax        # imm = 0xFFEFFFFF
orq $0x100000, %rax         # imm = 0x100000
movq %rax, 0x67357(%rip)     # 0xac9c0
movq -0x10(%rbp), %rax
leaq 0x6734c(%rip), %rcx     # 0xac9c0
movq %rcx, 0x8(%rax)
movq -0x10(%rbp), %rcx
movq -0x8(%rbp), %rax
movq 0x20(%rax), %rax
movq %rcx, (%rax)
movq -0x8(%rbp), %rax
movq $0x0, 0x20(%rax)
movq -0x10(%rbp), %rax
addq $0x10, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/lucvoo[P]sparse-dev/tokenize.c
// Function: get_one_identifier
static int get_one_identifier(int c, stream_t *stream)
{
	struct token *token;
	struct ident *ident;
	unsigned long hash;
	char buf[256];
	int len = 1;
	int next;

	hash = ident_hash_init(c);
	buf[0] = c;
	for (;;) {
		next = nextchar(stream);
		if (!(cclass[next + 1] & (Letter | Digit)))
			break;
		if (len >= sizeof(buf))
			break;
		hash = ident_hash_add(hash, next);
		buf[len] = next;
		len++;
	};
	if (cclass[next + 1] & Quote) {
		if (len == 1 && buf[0] == 'L') {
			if (next == '\'')
				return eat_string(nextchar(stream), stream,
							TOKEN_WIDE_CHAR);
			else
				return eat_string(nextchar(stream), stream,
							TOKEN_WIDE_STRING);
		}
	}
	hash = ident_hash_end(hash);
	ident = create_hashed_ident(buf, len, hash);

	/* Pass it on.. */
	token = stream->token;
	token_type(token) = TOKEN_IDENT;
	token->ident = ident;
	add_token(stream);
	return next;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x140, %rsp            # imm = 0x140
movl %edi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl $0x1, -0x134(%rbp)
movslq -0x8(%rbp), %rax
movq %rax, -0x28(%rbp)
movl -0x8(%rbp), %eax
movb %al, -0x130(%rbp)
movq -0x10(%rbp), %rdi
callq 0x454d0
movl %eax, -0x138(%rbp)
movl -0x138(%rbp), %eax
addl $0x1, %eax
movslq %eax, %rcx
leaq 0x244d1(%rip), %rax     # 0x69fb0
movsbl (%rax,%rcx), %eax
andl $0x3, %eax
cmpl $0x0, %eax
jne 0x45aed
jmp 0x45b38
movslq -0x134(%rbp), %rax
cmpq $0x100, %rax            # imm = 0x100
jb 0x45afe
jmp 0x45b38
imulq $0xb, -0x28(%rbp), %rax
movslq -0x138(%rbp), %rcx
addq %rcx, %rax
movq %rax, -0x28(%rbp)
movl -0x138(%rbp), %eax
movb %al, %cl
movslq -0x134(%rbp), %rax
movb %cl, -0x130(%rbp,%rax)
movl -0x134(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x134(%rbp)
jmp 0x45abd
movl -0x138(%rbp), %eax
addl $0x1, %eax
movslq %eax, %rcx
leaq 0x24465(%rip), %rax     # 0x69fb0
movsbl (%rax,%rcx), %eax
andl $0x40, %eax
cmpl $0x0, %eax
je 0x45bb6
cmpl $0x1, -0x134(%rbp)
jne 0x45bb4
movsbl -0x130(%rbp), %eax
cmpl $0x4c, %eax
jne 0x45bb4
cmpl $0x27, -0x138(%rbp)
jne 0x45b96
movq -0x10(%rbp), %rdi
callq 0x454d0
movl %eax, %edi
movq -0x10(%rbp), %rsi
movl $0xb, %edx
callq 0x45e60
movl %eax, -0x4(%rbp)
jmp 0x45c22
movq -0x10(%rbp), %rdi
callq 0x454d0
movl %eax, %edi
movq -0x10(%rbp), %rsi
movl $0x11, %edx
callq 0x45e60
movl %eax, -0x4(%rbp)
jmp 0x45c22
jmp 0x45bb6
movq -0x28(%rbp), %rax
shrq $0xd, %rax
addq -0x28(%rbp), %rax
andq $0x1fff, %rax           # imm = 0x1FFF
movq %rax, -0x28(%rbp)
leaq -0x130(%rbp), %rdi
movl -0x134(%rbp), %esi
movq -0x28(%rbp), %rdx
callq 0x44f60
movq %rax, -0x20(%rbp)
movq -0x10(%rbp), %rax
movq 0x28(%rax), %rax
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rax
movq (%rax), %rcx
andq $-0x40, %rcx
orq $0x3, %rcx
movq %rcx, (%rax)
movq -0x20(%rbp), %rcx
movq -0x18(%rbp), %rax
movq %rcx, 0x10(%rax)
movq -0x10(%rbp), %rdi
callq 0x45e10
movl -0x138(%rbp), %eax
movl %eax, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x140, %rsp            # imm = 0x140
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/lucvoo[P]sparse-dev/tokenize.c
// Function: add_token
static void add_token(stream_t *stream)
{
	struct token *token = stream->token;

	stream->token = NULL;
	token->next = NULL;
	*stream->tokenlist = token;
	stream->tokenlist = &token->next;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq 0x28(%rax), %rax
movq %rax, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq $0x0, 0x28(%rax)
movq -0x10(%rbp), %rax
movq $0x0, 0x8(%rax)
movq -0x10(%rbp), %rcx
movq -0x8(%rbp), %rax
movq 0x20(%rax), %rax
movq %rcx, (%rax)
movq -0x10(%rbp), %rcx
addq $0x8, %rcx
movq -0x8(%rbp), %rax
movq %rcx, 0x20(%rax)
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/lucvoo[P]sparse-dev/tokenize.c
// Function: drop_stream_eoln
static int drop_stream_eoln(stream_t *stream)
{
	drop_token(stream);
	for (;;) {
		switch (nextchar(stream)) {
		case EOF:
			return EOF;
		case '\n':
			return nextchar(stream);
		}
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movq -0x10(%rbp), %rdi
callq 0x46240
movq -0x10(%rbp), %rdi
callq 0x454d0
movl %eax, %ecx
movl %ecx, -0x14(%rbp)
subl $-0x1, %eax
je 0x46174
jmp 0x4616a
movl -0x14(%rbp), %eax
subl $0xa, %eax
je 0x4617d
jmp 0x4618b
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
jmp 0x4618d
movq -0x10(%rbp), %rdi
callq 0x454d0
movl %eax, -0x4(%rbp)
jmp 0x4618d
jmp 0x46155
movl -0x4(%rbp), %eax
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/lucvoo[P]sparse-dev/tokenize.c
// Function: drop_stream_comment
static int drop_stream_comment(stream_t *stream)
{
	int newline;
	int next;
	drop_token(stream);
	newline = stream->newline;

	next = nextchar(stream);
	for (;;) {
		int curr = next;
		if (curr == EOF) {
			warning(stream_pos(stream), "End of file in the middle of a comment");
			return curr;
		}
		next = nextchar(stream);
		if (curr == '*' && next == '/')
			break;
	}
	stream->newline = newline;
	return nextchar(stream);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movq -0x10(%rbp), %rdi
callq 0x46240
movq -0x10(%rbp), %rax
movl 0x18(%rax), %eax
movl %eax, -0x14(%rbp)
movq -0x10(%rbp), %rdi
callq 0x454d0
movl %eax, -0x18(%rbp)
movl -0x18(%rbp), %eax
movl %eax, -0x1c(%rbp)
cmpl $-0x1, -0x1c(%rbp)
jne 0x461fe
movq -0x10(%rbp), %rdi
callq 0x453d0
movq %rax, -0x24(%rbp)
movq -0x24(%rbp), %rdi
leaq 0x240ad(%rip), %rsi     # 0x6a29c
movb $0x0, %al
callq 0x16d80
movl -0x1c(%rbp), %eax
movl %eax, -0x4(%rbp)
jmp 0x46230
movq -0x10(%rbp), %rdi
callq 0x454d0
movl %eax, -0x18(%rbp)
cmpl $0x2a, -0x1c(%rbp)
jne 0x46218
cmpl $0x2f, -0x18(%rbp)
jne 0x46218
jmp 0x4621a
jmp 0x461cb
movl -0x14(%rbp), %ecx
movq -0x10(%rbp), %rax
movl %ecx, 0x18(%rax)
movq -0x10(%rbp), %rdi
callq 0x454d0
movl %eax, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/lucvoo[P]sparse-dev/utils.c
// Function: hexval
unsigned int hexval(unsigned int c)
{
	int retval = 256;
	switch (c) {
	case '0'...'9':
		retval = c - '0';
		break;
	case 'a'...'f':
		retval = c - 'a' + 10;
		break;
	case 'A'...'F':
		retval = c - 'A' + 10;
		break;
	}
	return retval;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movl %edi, -0x4(%rbp)
movl $0x100, -0x8(%rbp)      # imm = 0x100
movl -0x4(%rbp), %eax
movl %eax, -0xc(%rbp)
addl $-0x30, %eax
subl $0xa, %eax
jb 0x462d8
jmp 0x462be
movl -0xc(%rbp), %eax
addl $-0x41, %eax
subl $0x6, %eax
jb 0x462f1
jmp 0x462cb
movl -0xc(%rbp), %eax
addl $-0x61, %eax
subl $0x6, %eax
jb 0x462e3
jmp 0x462fd
movl -0x4(%rbp), %eax
subl $0x30, %eax
movl %eax, -0x8(%rbp)
jmp 0x462fd
movl -0x4(%rbp), %eax
subl $0x61, %eax
addl $0xa, %eax
movl %eax, -0x8(%rbp)
jmp 0x462fd
movl -0x4(%rbp), %eax
subl $0x41, %eax
addl $0xa, %eax
movl %eax, -0x8(%rbp)
movl -0x8(%rbp), %eax
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/lucvoo[P]sparse-dev/utils.c
// Function: xvasprintf
char *xvasprintf(const char *fmt, va_list ap)
{
	va_list ap2;
	char *str;
	int n;

	va_copy(ap2, ap);
	n = vsnprintf(NULL, 0, fmt, ap2) + 1;
	va_end(ap2);

	str = __alloc_bytes(n);
	vsnprintf(str, n, fmt, ap);

	return str;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
leaq -0x30(%rbp), %rax
movq -0x10(%rbp), %rcx
movq 0x10(%rcx), %rdx
movq %rdx, 0x10(%rax)
movups (%rcx), %xmm0
movups %xmm0, (%rax)
movq -0x8(%rbp), %rdx
leaq -0x30(%rbp), %rcx
xorl %eax, %eax
movl %eax, %esi
movq %rsi, %rdi
callq 0x110b0
addl $0x1, %eax
movl %eax, -0x3c(%rbp)
leaq -0x30(%rbp), %rax
movl -0x3c(%rbp), %edi
callq 0x47100
movq %rax, -0x38(%rbp)
movq -0x38(%rbp), %rdi
movslq -0x3c(%rbp), %rsi
movq -0x8(%rbp), %rdx
movq -0x10(%rbp), %rcx
callq 0x110b0
movq -0x38(%rbp), %rax
addq $0x40, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/lucvoo[P]sparse-dev/allocate.c
// Function: drop_all_allocations
void drop_all_allocations(struct allocator_struct *desc)
{
	struct allocation_blob *blob = desc->blobs;

	desc->blobs = NULL;
	desc->allocations = 0;
	desc->total_bytes = 0;
	desc->useful_bytes = 0;
	desc->freelist = NULL;
	while (blob) {
		struct allocation_blob *next = blob->next;
		blob_free(blob, desc->chunking);
		blob = next;
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rax
movq %rax, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq $0x0, 0x8(%rax)
movq -0x8(%rbp), %rax
movl $0x0, 0x20(%rax)
movq -0x8(%rbp), %rax
movq $0x0, 0x28(%rax)
movq -0x8(%rbp), %rax
movq $0x0, 0x30(%rax)
movq -0x8(%rbp), %rax
movq $0x0, 0x18(%rax)
cmpq $0x0, -0x10(%rbp)
je 0x46571
movq -0x10(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x18(%rbp)
movq -0x10(%rbp), %rdi
movq -0x8(%rbp), %rax
movl 0x14(%rax), %eax
movl %eax, %esi
callq 0x49430
movq -0x18(%rbp), %rax
movq %rax, -0x10(%rbp)
jmp 0x46543
addq $0x20, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/lucvoo[P]sparse-dev/allocate.c
// Function: show_allocations
void show_allocations(struct allocator_struct *x)
{
	fprintf(stderr, "%s: %d allocations, %lu bytes (%lu total bytes, "
			"%6.2f%% usage, %6.2f average size)\n",
		x->name, x->allocations, x->useful_bytes, x->total_bytes,
		100 * (double) x->useful_bytes / x->total_bytes,
		(double) x->useful_bytes / x->allocations);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq 0x3d83d(%rip), %rax     # 0x83ff0
movq (%rax), %rdi
movq -0x8(%rbp), %rsi
movq (%rsi), %rdx
movl 0x20(%rsi), %eax
movl %eax, %ecx
movq 0x30(%rsi), %r8
movq 0x28(%rsi), %r9
movq %r8, %xmm1
movaps 0x23b0a(%rip), %xmm4    # 0x6a2e0
punpckldq %xmm4, %xmm1    # xmm1 = xmm1[0],xmm4[0],xmm1[1],xmm4[1]
movapd 0x23b0e(%rip), %xmm3    # 0x6a2f0
subpd %xmm3, %xmm1
movaps %xmm1, %xmm0
unpckhpd %xmm1, %xmm1            # xmm1 = xmm1[1,1]
addsd %xmm0, %xmm1
movsd 0x23b07(%rip), %xmm2    # 0x6a300
movaps %xmm1, %xmm0
mulsd %xmm2, %xmm0
movq %r9, %xmm2
punpckldq %xmm4, %xmm2    # xmm2 = xmm2[0],xmm4[0],xmm2[1],xmm4[1]
subpd %xmm3, %xmm2
movaps %xmm2, %xmm3
unpckhpd %xmm2, %xmm2            # xmm2 = xmm2[1,1]
addsd %xmm3, %xmm2
divsd %xmm2, %xmm0
cvtsi2sd %rax, %xmm2
divsd %xmm2, %xmm1
leaq 0x23af8(%rip), %rsi     # 0x6a324
movb $0x2, %al
callq 0x111c0
addq $0x10, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/lucvoo[P]sparse-dev/allocate.c
// Function: get_allocator_stats
void get_allocator_stats(struct allocator_struct *x, struct allocator_stats *s)
{
	s->name = x->name;
	s->allocations = x->allocations;
	s->useful_bytes = x->useful_bytes;
	s->total_bytes = x->total_bytes;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq (%rax), %rcx
movq -0x10(%rbp), %rax
movq %rcx, (%rax)
movq -0x8(%rbp), %rax
movl 0x20(%rax), %ecx
movq -0x10(%rbp), %rax
movl %ecx, 0x8(%rax)
movq -0x8(%rbp), %rax
movq 0x30(%rax), %rcx
movq -0x10(%rbp), %rax
movq %rcx, 0x18(%rax)
movq -0x8(%rbp), %rax
movq 0x28(%rax), %rcx
movq -0x10(%rbp), %rax
movq %rcx, 0x10(%rax)
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/lucvoo[P]sparse-dev/builtin.c
// Function: declare_builtins
void declare_builtins(int stream, const struct builtin_fn tbl[])
{
	if (!tbl)
		return;

	while (tbl->name)
		declare_builtin(stream, tbl++);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movl %edi, -0x4(%rbp)
movq %rsi, -0x10(%rbp)
cmpq $0x0, -0x10(%rbp)
jne 0x47a48
jmp 0x47a6d
jmp 0x47a4a
movq -0x10(%rbp), %rax
cmpq $0x0, (%rax)
je 0x47a6d
movl -0x4(%rbp), %edi
movq -0x10(%rbp), %rsi
movq %rsi, %rax
addq $0x58, %rax
movq %rax, -0x10(%rbp)
callq 0x47a80
jmp 0x47a4a
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/lucvoo[P]sparse-dev/builtin.c
// Function: declare_builtin
static void declare_builtin(int stream, const struct builtin_fn *entry)
{
	struct symbol *sym = create_symbol(stream, entry->name, SYM_NODE, NS_SYMBOL);
	struct symbol *fun = alloc_symbol(sym->pos, SYM_FN);
	struct symbol *arg;
	int i;

	sym->ctype.base_type = fun;
	sym->ctype.modifiers = MOD_TOPLEVEL;
	sym->builtin = 1;
	sym->op = entry->op;

	fun->ctype.base_type = get_ctype(entry->ret_type);
	fun->variadic = entry->variadic;

	for (i = 0; (arg = entry->args[i]); i++) {
		struct symbol *anode = alloc_symbol(sym->pos, SYM_NODE);
		anode->ctype.base_type = get_ctype(arg);
		add_symbol(&fun->arguments, anode);
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movl %edi, -0x4(%rbp)
movq %rsi, -0x10(%rbp)
movl -0x4(%rbp), %edi
movq -0x10(%rbp), %rax
movq (%rax), %rsi
movl $0x3, %edx
movl $0x10, %ecx
callq 0x40ab0
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rax
movq 0x4(%rax), %rdi
movl $0x5, %esi
callq 0x3f4d0
movq %rax, -0x20(%rbp)
movq -0x20(%rbp), %rcx
movq -0x18(%rbp), %rax
movq %rcx, 0x60(%rax)
movq -0x18(%rbp), %rax
movq $0x10, 0x68(%rax)
movq -0x18(%rbp), %rax
movl 0x54(%rax), %ecx
andl $0xfff7ffff, %ecx       # imm = 0xFFF7FFFF
orl $0x80000, %ecx          # imm = 0x80000
movl %ecx, 0x54(%rax)
movq -0x10(%rbp), %rax
movq 0x50(%rax), %rcx
movq -0x18(%rbp), %rax
movq %rcx, 0x40(%rax)
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rdi
callq 0x47db0
movq %rax, %rcx
movq -0x20(%rbp), %rax
movq %rcx, 0x60(%rax)
movq -0x10(%rbp), %rax
movb 0x10(%rax), %al
andb $0x1, %al
movzbl %al, %edx
movq -0x20(%rbp), %rax
movl 0x54(%rax), %ecx
andl $0x1, %edx
shll $0x9, %edx
andl $0xfffffdff, %ecx       # imm = 0xFFFFFDFF
orl %edx, %ecx
movl %ecx, 0x54(%rax)
movl $0x0, -0x2c(%rbp)
movq -0x10(%rbp), %rax
movslq -0x2c(%rbp), %rcx
movq 0x18(%rax,%rcx,8), %rax
movq %rax, -0x28(%rbp)
cmpq $0x0, %rax
je 0x47ba4
movq -0x18(%rbp), %rax
movq 0x4(%rax), %rdi
movl $0x3, %esi
callq 0x3f4d0
movq %rax, -0x38(%rbp)
movq -0x28(%rbp), %rdi
callq 0x47db0
movq %rax, %rcx
movq -0x38(%rbp), %rax
movq %rcx, 0x60(%rax)
movq -0x20(%rbp), %rdi
addq $0x48, %rdi
addq $0x40, %rdi
movq -0x38(%rbp), %rsi
callq 0x476a0
movl -0x2c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x2c(%rbp)
jmp 0x47b43
addq $0x40, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/lucvoo[P]sparse-dev/builtin.c
// Function: eval_args
static int eval_args(struct expression *expr, int n)
{
	struct expression *arg;
	struct symbol *sym;
	const char *msg;
	int rc = 1;

	FOR_EACH_PTR(expr->args, arg) {
		if (n-- == 0) {
			msg = "too many arguments";
			goto error;
		}
		if (!evaluate_expression(arg))
			rc = 0;
	} END_FOR_EACH_PTR(arg);
	if (n > 0) {
		msg = "not enough arguments";
		goto error;
	}
	return rc;

error:
	sym = expr->fn->ctype;
	expression_error(expr, "%s for %s", msg, show_ident(sym->ident));
	return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x70, %rsp
movq %rdi, -0x10(%rbp)
movl %esi, -0x14(%rbp)
movl $0x1, -0x34(%rbp)
movq -0x10(%rbp), %rax
movq 0x28(%rax), %rax
movq %rax, -0x40(%rbp)
movq -0x40(%rbp), %rax
movq %rax, -0x48(%rbp)
movq -0x40(%rbp), %rax
movq %rax, -0x50(%rbp)
cmpq $0x0, -0x40(%rbp)
jne 0x47c8e
jmp 0x47d36
jmp 0x47c90
movl $0x0, -0x54(%rbp)
movl -0x54(%rbp), %eax
movq -0x48(%rbp), %rcx
movw (%rcx), %cx
shlw $0x8, %cx
sarw $0x8, %cx
movswl %cx, %ecx
cmpl %ecx, %eax
jge 0x47d1e
movq -0x48(%rbp), %rax
movslq -0x54(%rbp), %rcx
movq 0x18(%rax,%rcx,8), %rax
movq %rax, -0x20(%rbp)
movq -0x48(%rbp), %rax
movw (%rax), %ax
sarw $0x8, %ax
cwtl
cmpl $0x0, %eax
je 0x47cdb
cmpq $0x0, -0x20(%rbp)
jne 0x47cdb
jmp 0x47d10
movl -0x14(%rbp), %eax
movl %eax, %ecx
addl $-0x1, %ecx
movl %ecx, -0x14(%rbp)
cmpl $0x0, %eax
jne 0x47cf8
leaq 0x22777(%rip), %rax     # 0x6a469
movq %rax, -0x30(%rbp)
jmp 0x47d51
movq -0x20(%rbp), %rdi
callq 0x4bb70
cmpq $0x0, %rax
jne 0x47d0e
movl $0x0, -0x34(%rbp)
jmp 0x47d10
movl -0x54(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x54(%rbp)
jmp 0x47c97
jmp 0x47d20
movq -0x48(%rbp), %rax
movq 0x10(%rax), %rax
movq %rax, -0x48(%rbp)
cmpq -0x40(%rbp), %rax
jne 0x47c90
cmpl $0x0, -0x14(%rbp)
jle 0x47d49
leaq 0x22739(%rip), %rax     # 0x6a47c
movq %rax, -0x30(%rbp)
jmp 0x47d51
movl -0x34(%rbp), %eax
movl %eax, -0x4(%rbp)
jmp 0x47d9e
movq -0x10(%rbp), %rax
movq 0x20(%rax), %rax
movq 0x10(%rax), %rax
movq %rax, -0x28(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x68(%rbp)
movq -0x30(%rbp), %rax
movq %rax, -0x60(%rbp)
movq -0x28(%rbp), %rax
movq 0x18(%rax), %rdi
callq 0x44150
movq -0x68(%rbp), %rdi
movq -0x60(%rbp), %rdx
movq %rax, %rcx
leaq 0x22701(%rip), %rsi     # 0x6a491
movb $0x0, %al
callq 0x17030
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x70, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/lucvoo[P]sparse-dev/builtin.c
// Function: evaluate_choose
static int evaluate_choose(struct expression *expr)
{
	struct expression_list *list = expr->args;
	struct expression *arg, *args[3];
	int n = 0;

	/* there will be exactly 3; we'd already verified that */
	FOR_EACH_PTR(list, arg) {
		args[n++] = arg;
	} END_FOR_EACH_PTR(arg);

	*expr = get_expression_value(args[0]) ? *args[1] : *args[2];

	return 1;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x60, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq 0x28(%rax), %rax
movq %rax, -0x10(%rbp)
movl $0x0, -0x34(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x40(%rbp)
movq -0x40(%rbp), %rax
movq %rax, -0x48(%rbp)
movq -0x40(%rbp), %rax
movq %rax, -0x50(%rbp)
cmpq $0x0, -0x40(%rbp)
jne 0x48203
jmp 0x48285
jmp 0x48205
movl $0x0, -0x54(%rbp)
movl -0x54(%rbp), %eax
movq -0x48(%rbp), %rcx
movw (%rcx), %cx
shlw $0x8, %cx
sarw $0x8, %cx
movswl %cx, %ecx
cmpl %ecx, %eax
jge 0x48271
movq -0x48(%rbp), %rax
movslq -0x54(%rbp), %rcx
movq 0x18(%rax,%rcx,8), %rax
movq %rax, -0x18(%rbp)
movq -0x48(%rbp), %rax
movw (%rax), %ax
sarw $0x8, %ax
cwtl
cmpl $0x0, %eax
je 0x48250
cmpq $0x0, -0x18(%rbp)
jne 0x48250
jmp 0x48266
movq -0x18(%rbp), %rcx
movl -0x34(%rbp), %eax
movl %eax, %edx
addl $0x1, %edx
movl %edx, -0x34(%rbp)
cltq
movq %rcx, -0x30(%rbp,%rax,8)
movl -0x54(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x54(%rbp)
jmp 0x4820c
jmp 0x48273
movq -0x48(%rbp), %rax
movq 0x10(%rax), %rax
movq %rax, -0x48(%rbp)
cmpq -0x40(%rbp), %rax
jne 0x48205
movq -0x8(%rbp), %rax
movq %rax, -0x60(%rbp)
movq -0x30(%rbp), %rdi
callq 0x11ff0
cmpq $0x0, %rax
je 0x482b0
movq -0x60(%rbp), %rdi
movq -0x28(%rbp), %rsi
movl $0x40, %edx
callq 0x111d0
jmp 0x482c2
movq -0x60(%rbp), %rdi
movq -0x20(%rbp), %rsi
movl $0x40, %edx
callq 0x111d0
movl $0x1, %eax
addq $0x60, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/lucvoo[P]sparse-dev/builtin.c
// Function: expand_constant_p
static int expand_constant_p(struct expression *expr, int cost)
{
	expr->type = EXPR_VALUE;
	expr->value = !cost;
	expr->taint = 0;
	return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movq -0x8(%rbp), %rax
movl (%rax), %ecx
andl $0xffffff00, %ecx       # imm = 0xFFFFFF00
orl $0x1, %ecx
movl %ecx, (%rax)
cmpl $0x0, -0xc(%rbp)
setne %al
xorb $-0x1, %al
andb $0x1, %al
movzbl %al, %eax
movslq %eax, %rcx
movq -0x8(%rbp), %rax
movq %rcx, 0x20(%rax)
movq -0x8(%rbp), %rax
movl $0x0, 0x28(%rax)
xorl %eax, %eax
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/lucvoo[P]sparse-dev/builtin.c
// Function: expand_expect
static int expand_expect(struct expression *expr, int cost)
{
	struct expression *arg = first_ptr_list((struct ptr_list *) expr->args);

	if (arg)
		*expr = *arg;
	return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movq -0x8(%rbp), %rax
movq 0x28(%rax), %rdi
callq 0x30f30
movq %rax, -0x18(%rbp)
cmpq $0x0, -0x18(%rbp)
je 0x483c9
movq -0x8(%rbp), %rdi
movq -0x18(%rbp), %rsi
movl $0x40, %edx
callq 0x111d0
xorl %eax, %eax
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/lucvoo[P]sparse-dev/builtin.c
// Function: evaluate_pure_unop
static int evaluate_pure_unop(struct expression *expr)
{
	struct expression *arg = first_expression(expr->args);
	int flags = arg->flags;

	/*
	 * Allow such functions with a constant integer expression
	 * argument to be treated as a *constant* integer.
	 * This allow us to use them in switch() { case ...:
	 */
	flags |= (flags & CEF_ICE) ? CEF_SET_INT : 0;
	expr->flags = flags;
	return 1;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq 0x28(%rax), %rdi
callq 0x48980
movq %rax, -0x10(%rbp)
movq -0x10(%rbp), %rax
movl (%rax), %eax
shrl $0x8, %eax
andl $0xff, %eax
movl %eax, -0x14(%rbp)
movl -0x14(%rbp), %edx
andl $0x10, %edx
xorl %eax, %eax
movl $0x31, %ecx
cmpl $0x0, %edx
cmovnel %ecx, %eax
orl -0x14(%rbp), %eax
movl %eax, -0x14(%rbp)
movl -0x14(%rbp), %edx
movq -0x8(%rbp), %rax
movl (%rax), %ecx
andl $0xff, %edx
shll $0x8, %edx
andl $0xffff00ff, %ecx       # imm = 0xFFFF00FF
orl %edx, %ecx
movl %ecx, (%rax)
movl $0x1, %eax
addq $0x20, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/lucvoo[P]sparse-dev/builtin.c
// Function: expand_bswap
static int expand_bswap(struct expression *expr, int cost)
{
	struct expression *arg;
	long long val;

	if (cost)
		return cost;

	/* the arguments number & type have already been checked */
	arg = first_expression(expr->args);
	val = get_expression_value_silent(arg);
	switch (expr->ctype->bit_size) {
	case 16: expr->value = bswap16(val); break;
	case 32: expr->value = bswap32(val); break;
	case 64: expr->value = bswap64(val); break;
	default: /* impossible error */
		return SIDE_EFFECTS;
	}

	expr->type = EXPR_VALUE;
	expr->taint = 0;
	return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movl %esi, -0x14(%rbp)
cmpl $0x0, -0x14(%rbp)
je 0x488c0
movl -0x14(%rbp), %eax
movl %eax, -0x4(%rbp)
jmp 0x4896f
movq -0x10(%rbp), %rax
movq 0x28(%rax), %rdi
callq 0x48980
movq %rax, -0x20(%rbp)
movq -0x20(%rbp), %rdi
callq 0x12190
movq %rax, -0x28(%rbp)
movq -0x10(%rbp), %rax
movq 0x10(%rax), %rax
movl 0x50(%rax), %eax
movl %eax, -0x2c(%rbp)
subl $0x10, %eax
je 0x48907
jmp 0x488f3
movl -0x2c(%rbp), %eax
subl $0x20, %eax
je 0x4891e
jmp 0x488fd
movl -0x2c(%rbp), %eax
subl $0x40, %eax
je 0x48932
jmp 0x48943
movq -0x28(%rbp), %rax
rolw $0x8, %ax
movzwl %ax, %eax
movl %eax, %ecx
movq -0x10(%rbp), %rax
movq %rcx, 0x20(%rax)
jmp 0x4894c
movq -0x28(%rbp), %rax
bswapl %eax
movl %eax, %eax
movl %eax, %ecx
movq -0x10(%rbp), %rax
movq %rcx, 0x20(%rax)
jmp 0x4894c
movq -0x28(%rbp), %rcx
bswapq %rcx
movq -0x10(%rbp), %rax
movq %rcx, 0x20(%rax)
jmp 0x4894c
movl $0x2710, -0x4(%rbp)     # imm = 0x2710
jmp 0x4896f
movq -0x10(%rbp), %rax
movl (%rax), %ecx
andl $0xffffff00, %ecx       # imm = 0xFFFFFF00
orl $0x1, %ecx
movl %ecx, (%rax)
movq -0x10(%rbp), %rax
movl $0x0, 0x28(%rax)
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/lucvoo[P]sparse-dev/builtin.c
// Function: expand_isdigit
static int expand_isdigit(struct expression *expr, int cost)
{
	struct expression *arg = first_expression(expr->args);
	long long val = get_expression_value_silent(arg);

	if (cost)
		return cost;

	expr->value = (val >= '0') && (val <= '9');
	expr->type = EXPR_VALUE;
	expr->taint = 0;
	return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movl %esi, -0x14(%rbp)
movq -0x10(%rbp), %rax
movq 0x28(%rax), %rdi
callq 0x48980
movq %rax, -0x20(%rbp)
movq -0x20(%rbp), %rdi
callq 0x12190
movq %rax, -0x28(%rbp)
cmpl $0x0, -0x14(%rbp)
je 0x48d4b
movl -0x14(%rbp), %eax
movl %eax, -0x4(%rbp)
jmp 0x48d98
xorl %eax, %eax
cmpq $0x30, -0x28(%rbp)
movb %al, -0x29(%rbp)
jl 0x48d62
cmpq $0x39, -0x28(%rbp)
setle %al
movb %al, -0x29(%rbp)
movb -0x29(%rbp), %al
andb $0x1, %al
movzbl %al, %eax
movslq %eax, %rcx
movq -0x10(%rbp), %rax
movq %rcx, 0x20(%rax)
movq -0x10(%rbp), %rax
movl (%rax), %ecx
andl $0xffffff00, %ecx       # imm = 0xFFFFFF00
orl $0x1, %ecx
movl %ecx, (%rax)
movq -0x10(%rbp), %rax
movl $0x0, 0x28(%rax)
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/lucvoo[P]sparse-dev/builtin.c
// Function: evaluate_fp_unop
static int evaluate_fp_unop(struct expression *expr)
{
	struct expression *arg;

	if (!eval_args(expr, 1))
		return 0;

	arg = first_expression(expr->args);
	if (!is_float_type(arg->ctype)) {
		expression_error(expr, "non-floating-point argument in call to %s()",
			show_ident(expr->fn->ctype->ident));
		return 0;
	}
	return 1;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movq -0x10(%rbp), %rdi
movl $0x1, %esi
callq 0x47c50
cmpl $0x0, %eax
jne 0x48dd8
movl $0x0, -0x4(%rbp)
jmp 0x48e3d
movq -0x10(%rbp), %rax
movq 0x28(%rax), %rdi
callq 0x48980
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rax
movq 0x10(%rax), %rdi
callq 0x48e50
cmpl $0x0, %eax
jne 0x48e36
movq -0x10(%rbp), %rax
movq %rax, -0x20(%rbp)
movq -0x10(%rbp), %rax
movq 0x20(%rax), %rax
movq 0x10(%rax), %rax
movq 0x18(%rax), %rdi
callq 0x44150
movq -0x20(%rbp), %rdi
movq %rax, %rdx
leaq 0x224d8(%rip), %rsi     # 0x6b2fe
movb $0x0, %al
callq 0x17030
movl $0x0, -0x4(%rbp)
jmp 0x48e3d
movl $0x1, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/lucvoo[P]sparse-dev/./compat/mmap-blob.c
// Function: blob_alloc
void *blob_alloc(unsigned long size)
{
	void *ptr;

	if (size & ~CHUNK)
		die("internal error: bad allocation size (%lu bytes)", size);
	ptr = mmap(NULL, size, PROT_READ | PROT_WRITE, MAP_PRIVATE | MAP_ANONYMOUS, -1, 0);
	if (ptr == MAP_FAILED)
		ptr = NULL;
	return ptr;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
andq $-0x8001, %rax          # imm = 0xFFFF7FFF
cmpq $0x0, %rax
je 0x493de
movq -0x8(%rbp), %rsi
leaq 0x21f53(%rip), %rdi     # 0x6b32a
movb $0x0, %al
callq 0x17190
movq -0x8(%rbp), %rsi
xorl %eax, %eax
movl %eax, %r9d
movl $0x3, %edx
movl $0x22, %ecx
movl $0xffffffff, %r8d       # imm = 0xFFFFFFFF
movq %r9, %rdi
callq 0x110d0
movq %rax, -0x10(%rbp)
movq $-0x1, %rax
cmpq %rax, -0x10(%rbp)
jne 0x49418
movq $0x0, -0x10(%rbp)
movq -0x10(%rbp), %rax
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/lucvoo[P]sparse-dev/cse.c
// Function: cse_eliminate
void cse_eliminate(struct entrypoint *ep)
{
	int i;

	for (i = 0; i < INSN_HASH_SIZE; i++) {
		struct instruction_list **list = insn_hash_table + i;
		if (*list) {
			if (instruction_list_size(*list) > 1) {
				struct instruction *insn, *last;

				sort_instruction_list(list);

				last = NULL;
				FOR_EACH_PTR(*list, insn) {
					if (!insn->bb)
						continue;
					if (last) {
						if (!insn_compare(last, insn))
							insn = try_to_cse(ep, last, insn);
					}
					last = insn;
				} END_FOR_EACH_PTR(insn);
			}
			free_ptr_list(list);
		}
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movq %rdi, -0x8(%rbp)
movl $0x0, -0xc(%rbp)
cmpl $0x100, -0xc(%rbp)      # imm = 0x100
jge 0x49938
movslq -0xc(%rbp), %rcx
leaq 0x6c2e5(%rip), %rax     # 0xb5ae0
shlq $0x3, %rcx
addq %rcx, %rax
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rax
cmpq $0x0, (%rax)
je 0x49928
movq -0x18(%rbp), %rax
movq (%rax), %rdi
callq 0x49940
cmpl $0x1, %eax
jle 0x4991b
movq -0x18(%rbp), %rdi
callq 0x49960
movq $0x0, -0x28(%rbp)
movq -0x18(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x30(%rbp)
movq -0x30(%rbp), %rax
movq %rax, -0x38(%rbp)
movq -0x30(%rbp), %rax
movq %rax, -0x40(%rbp)
cmpq $0x0, -0x30(%rbp)
jne 0x49861
jmp 0x49919
jmp 0x49863
movl $0x0, -0x44(%rbp)
movl -0x44(%rbp), %eax
movq -0x38(%rbp), %rcx
movw (%rcx), %cx
shlw $0x8, %cx
sarw $0x8, %cx
movswl %cx, %ecx
cmpl %ecx, %eax
jge 0x49901
movq -0x38(%rbp), %rax
movslq -0x44(%rbp), %rcx
movq 0x18(%rax,%rcx,8), %rax
movq %rax, -0x20(%rbp)
movq -0x38(%rbp), %rax
movw (%rax), %ax
sarw $0x8, %ax
cwtl
cmpl $0x0, %eax
je 0x498ae
cmpq $0x0, -0x20(%rbp)
jne 0x498ae
jmp 0x498f3
movq -0x20(%rbp), %rax
cmpq $0x0, 0x8(%rax)
jne 0x498bb
jmp 0x498f3
cmpq $0x0, -0x28(%rbp)
je 0x498eb
movq -0x28(%rbp), %rdi
movq -0x20(%rbp), %rsi
callq 0x49990
cmpl $0x0, %eax
jne 0x498e9
movq -0x8(%rbp), %rdi
movq -0x28(%rbp), %rsi
movq -0x20(%rbp), %rdx
callq 0x49cc0
movq %rax, -0x20(%rbp)
jmp 0x498eb
movq -0x20(%rbp), %rax
movq %rax, -0x28(%rbp)
movl -0x44(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x44(%rbp)
jmp 0x4986a
jmp 0x49903
movq -0x38(%rbp), %rax
movq 0x10(%rax), %rax
movq %rax, -0x38(%rbp)
cmpq -0x30(%rbp), %rax
jne 0x49863
jmp 0x4991b
jmp 0x4991d
movq -0x18(%rbp), %rdi
callq 0x31cd0
jmp 0x49928
jmp 0x4992a
movl -0xc(%rbp), %eax
addl $0x1, %eax
movl %eax, -0xc(%rbp)
jmp 0x497e3
addq $0x50, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/lucvoo[P]sparse-dev/cse.c
// Function: phi_compare
static int phi_compare(pseudo_t phi1, pseudo_t phi2)
{
	const struct instruction *def1 = phi1->def;
	const struct instruction *def2 = phi2->def;

	if (def1->src1 != def2->src1)
		return def1->src1 < def2->src1 ? -1 : 1;
	if (def1->bb != def2->bb)
		return def1->bb < def2->bb ? -1 : 1;
	return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x10(%rbp), %rax
movq 0x18(%rax), %rax
movq %rax, -0x20(%rbp)
movq -0x18(%rbp), %rax
movq 0x18(%rax), %rax
movq %rax, -0x28(%rbp)
movq -0x20(%rbp), %rax
movq 0x30(%rax), %rax
movq -0x28(%rbp), %rcx
cmpq 0x30(%rcx), %rax
je 0x4a2cb
movq -0x20(%rbp), %rax
movq 0x30(%rax), %rdx
movq -0x28(%rbp), %rax
movq 0x30(%rax), %rsi
movl $0x1, %eax
movl $0xffffffff, %ecx       # imm = 0xFFFFFFFF
cmpq %rsi, %rdx
cmovbl %ecx, %eax
movl %eax, -0x4(%rbp)
jmp 0x4a309
movq -0x20(%rbp), %rax
movq 0x8(%rax), %rax
movq -0x28(%rbp), %rcx
cmpq 0x8(%rcx), %rax
je 0x4a302
movq -0x20(%rbp), %rax
movq 0x8(%rax), %rdx
movq -0x28(%rbp), %rax
movq 0x8(%rax), %rsi
movl $0x1, %eax
movl $0xffffffff, %ecx       # imm = 0xFFFFFFFF
cmpq %rsi, %rdx
cmovbl %ecx, %eax
movl %eax, -0x4(%rbp)
jmp 0x4a309
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/lucvoo[P]sparse-dev/cse.c
// Function: cse_one_instruction
static struct instruction * cse_one_instruction(struct instruction *insn, struct instruction *def)
{
	convert_instruction_target(insn, def->target);

	kill_instruction(insn);
	repeat_phase |= REPEAT_CSE;
	return def;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rax
movq 0x20(%rax), %rsi
callq 0x58e80
movq -0x8(%rbp), %rdi
callq 0x4a480
leaq 0x42e13(%rip), %rax     # 0x8d154
movl (%rax), %ecx
orl $0x1, %ecx
leaq 0x42e07(%rip), %rax     # 0x8d154
movl %ecx, (%rax)
movq -0x10(%rbp), %rax
addq $0x10, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/lucvoo[P]sparse-dev/cse.c
// Function: trivial_common_parent
static struct basic_block *trivial_common_parent(struct basic_block *bb1, struct basic_block *bb2)
{
	struct basic_block *parent;

	if (bb_list_size(bb1->parents) != 1)
		return NULL;
	parent = first_basic_block(bb1->parents);
	if (bb_list_size(bb2->parents) != 1)
		return NULL;
	if (first_basic_block(bb2->parents) != parent)
		return NULL;
	return parent;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x10(%rbp), %rax
movq 0x18(%rax), %rdi
callq 0x4a4a0
cmpl $0x1, %eax
je 0x4a38c
movq $0x0, -0x8(%rbp)
jmp 0x4a3de
movq -0x10(%rbp), %rax
movq 0x18(%rax), %rdi
callq 0x4a4c0
movq %rax, -0x20(%rbp)
movq -0x18(%rbp), %rax
movq 0x18(%rax), %rdi
callq 0x4a4a0
cmpl $0x1, %eax
je 0x4a3b9
movq $0x0, -0x8(%rbp)
jmp 0x4a3de
movq -0x18(%rbp), %rax
movq 0x18(%rax), %rdi
callq 0x4a4c0
cmpq -0x20(%rbp), %rax
je 0x4a3d6
movq $0x0, -0x8(%rbp)
jmp 0x4a3de
movq -0x20(%rbp), %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/lucvoo[P]sparse-dev/dominate.c
// Function: bank_get
static struct basic_block *bank_get(struct piggy *bank)
{
	int level = bank->max;
	do {
		struct basic_block *bb = pop_bb(&bank->lists[level]);
		if (bb)
			return bb;
		if (!level)
			return NULL;
		bank->max = --level;
	} while (1);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movq -0x10(%rbp), %rax
movl (%rax), %eax
movl %eax, -0x14(%rbp)
movq -0x10(%rbp), %rdi
addq $0x8, %rdi
movslq -0x14(%rbp), %rax
shlq $0x3, %rax
addq %rax, %rdi
callq 0x4ad20
movq %rax, -0x20(%rbp)
cmpq $0x0, -0x20(%rbp)
je 0x4a862
movq -0x20(%rbp), %rax
movq %rax, -0x8(%rbp)
jmp 0x4a889
cmpl $0x0, -0x14(%rbp)
jne 0x4a872
movq $0x0, -0x8(%rbp)
jmp 0x4a889
movl -0x14(%rbp), %ecx
addl $-0x1, %ecx
movl %ecx, -0x14(%rbp)
movq -0x10(%rbp), %rax
movl %ecx, (%rax)
movb $0x1, %al
testb $0x1, %al
jne 0x4a835
jmp 0x4a889
movq -0x8(%rbp), %rax
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)