LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_cpp_makefile_star2_O1/Davidc2525[P]Leaf/parser/Scanner.cpp
// Function: coco_string_hash(wchar_t const*)
int coco_string_hash(const wchar_t *data) {
	int h = 0;
	if (!data) { return 0; }
	while (*data != 0) {
		h = (h * 7) ^ *data;
		++data;
	}
	if (h < 0) { h = -h; }
	return h;
}

// Assembly:
testq %rdi, %rdi
je 0x94a2
movl (%rdi), %eax
testl %eax, %eax
je 0x94a5
addq $0x4, %rdi
xorl %edx, %edx
leal (,%rdx,8), %ecx
subl %edx, %ecx
xorl %eax, %ecx
movl (%rdi), %eax
addq $0x4, %rdi
movl %ecx, %edx
testl %eax, %eax
jne 0x9489
jmp 0x94a7
xorl %eax, %eax
retq
xorl %ecx, %ecx
movl %ecx, %eax
negl %eax
cmovsl %ecx, %eax
retq
// File: /workspace/github_cpp_makefile_star2_O1/Davidc2525[P]Leaf/parser/Scanner.cpp
// Function: coco_string_create(char const*)
wchar_t* coco_string_create(const char* value) {
	int len = 0;
	if (value) { len = strlen(value); }
	wchar_t* data = new wchar_t[len + 1];
	for (int i = 0; i < len; ++i) { data[i] = (wchar_t) value[i]; }
	data[len] = 0;
	return data;
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rdi, %rbx
testq %rdi, %rdi
je 0x94c9
movq %rbx, %rdi
callq 0x5120
movq %rax, %r14
jmp 0x94cc
xorl %r14d, %r14d
movslq %r14d, %r15
leaq 0x4(,%r15,4), %rax
cmpl $-0x1, %r15d
movq $-0x1, %rdi
cmovgeq %rax, %rdi
callq 0x5040
testl %r15d, %r15d
jle 0x9504
movl %r14d, %ecx
xorl %edx, %edx
movsbl (%rbx,%rdx), %esi
movl %esi, (%rax,%rdx,4)
incq %rdx
cmpq %rdx, %rcx
jne 0x94f5
movl $0x0, (%rax,%r15,4)
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_cpp_makefile_star2_O1/Davidc2525[P]Leaf/parser/Scanner.cpp
// Function: coco_string_create_char(wchar_t const*)
char* coco_string_create_char(const wchar_t *value) {
	int len = coco_string_length(value);
	char *res = new char[len + 1];
	for (int i = 0; i < len; ++i) { res[i] = (char) value[i]; }
	res[len] = 0;
	return res;
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
testq %rdi, %rdi
je 0x952b
movq %rbx, %rdi
callq 0x5200
movq %rax, %r14
jmp 0x952e
xorl %r14d, %r14d
leal 0x1(%r14), %eax
movslq %eax, %rdi
callq 0x5040
testl %r14d, %r14d
jle 0x9554
movl %r14d, %ecx
xorl %edx, %edx
movb (%rbx,%rdx,4), %sil
movb %sil, (%rax,%rdx)
incq %rdx
cmpq %rdx, %rcx
jne 0x9544
movslq %r14d, %rcx
movb $0x0, (%rax,%rcx)
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_cpp_makefile_star2_O1/Davidc2525[P]Leaf/parser/Scanner.cpp
// Function: Token::Token()
Token::Token() {
	kind = 0;
	pos  = 0;
	col  = 0;
	line = 0;
	val  = NULL;
	next = NULL;
}

// Assembly:
xorl %eax, %eax
movq %rax, (%rdi)
movq %rax, 0xc(%rdi)
xorps %xmm0, %xmm0
movups %xmm0, 0x18(%rdi)
retq
nop
// File: /workspace/github_cpp_makefile_star2_O1/Davidc2525[P]Leaf/parser/Scanner.cpp
// Function: Buffer::Buffer(_IO_FILE*, bool)
Buffer::Buffer(FILE* s, bool isUserStream) {
// ensure binary read on windows
#if _MSC_VER >= 1300
	_setmode(_fileno(s), _O_BINARY);
#endif
	stream = s; this->isUserStream = isUserStream;
	if (CanSeek()) {
		fseek(s, 0, SEEK_END);
		fileLen = ftell(s);
		fseek(s, 0, SEEK_SET);
		bufLen = (fileLen < COCO_MAX_BUFFER_LENGTH) ? fileLen : COCO_MAX_BUFFER_LENGTH;
		bufStart = INT_MAX; // nothing in the buffer so far
	} else {
		fileLen = bufLen = bufStart = 0;
	}
	bufCapacity = (bufLen>0) ? bufLen : COCO_MIN_BUFFER_LENGTH;
	buf = new unsigned char[bufCapacity];	
	if (fileLen > 0) SetPos(0);          // setup  buffer to position 0 (start)
	else bufPos = 0; // index 0 is already after the file, thus Pos = 0 is invalid
	if (bufLen == fileLen && CanSeek()) Close();
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
leaq 0x1bd56(%rip), %rax     # 0x25310
movq %rax, (%rdi)
movq %rsi, 0x28(%rdi)
movb %dl, 0x30(%rdi)
testq %rsi, %rsi
je 0x9619
movq %rsi, %r14
movq %rsi, %rdi
callq 0x5030
cmpq $-0x1, %rax
je 0x9619
movq %r14, %rdi
xorl %esi, %esi
movl $0x2, %edx
callq 0x52f0
movq %r14, %rdi
callq 0x5030
movl %eax, 0x1c(%rbx)
movq %r14, %rdi
xorl %esi, %esi
xorl %edx, %edx
callq 0x52f0
movl 0x1c(%rbx), %ecx
movl $0x10000, %eax          # imm = 0x10000
cmpl %eax, %ecx
cmovll %ecx, %eax
movl $0x7fffffff, %edx       # imm = 0x7FFFFFFF
movl $0x14, %ecx
jmp 0x9629
movl $0x0, 0x14(%rbx)
movl $0x1c, %ecx
xorl %eax, %eax
xorl %edx, %edx
movl %eax, 0x18(%rbx)
movl %edx, (%rbx,%rcx)
movl 0x18(%rbx), %eax
testl %eax, %eax
movl $0x400, %edi            # imm = 0x400
cmovgl %eax, %edi
movl %edi, 0x10(%rbx)
callq 0x5040
movq %rax, 0x8(%rbx)
cmpl $0x0, 0x1c(%rbx)
jle 0x965b
movq (%rbx), %rax
movq %rbx, %rdi
xorl %esi, %esi
callq *0x38(%rax)
jmp 0x9662
movl $0x0, 0x20(%rbx)
movl 0x18(%rbx), %eax
cmpl 0x1c(%rbx), %eax
jne 0x968e
movq 0x28(%rbx), %rdi
testq %rdi, %rdi
je 0x968e
callq 0x5030
cmpq $-0x1, %rax
je 0x968e
movq (%rbx), %rax
movq %rbx, %rdi
addq $0x8, %rsp
popq %rbx
popq %r14
jmpq *0x10(%rax)
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_cpp_makefile_star2_O1/Davidc2525[P]Leaf/parser/Scanner.cpp
// Function: Buffer::Buffer(Buffer*)
Buffer::Buffer(Buffer *b) {
	buf = b->buf;
	bufCapacity = b->bufCapacity;
	b->buf = NULL;
	bufStart = b->bufStart;
	bufLen = b->bufLen;
	fileLen = b->fileLen;
	bufPos = b->bufPos;
	stream = b->stream;
	b->stream = NULL;
	isUserStream = b->isUserStream;
}

// Assembly:
leaq 0x1bc55(%rip), %rax     # 0x25310
movq %rax, (%rdi)
movq 0x8(%rsi), %rax
movq %rax, 0x8(%rdi)
movl 0x10(%rsi), %eax
movl %eax, 0x10(%rdi)
xorl %eax, %eax
movq %rax, 0x8(%rsi)
movl 0x14(%rsi), %ecx
movl %ecx, 0x14(%rdi)
movl 0x18(%rsi), %ecx
movl %ecx, 0x18(%rdi)
movl 0x1c(%rsi), %ecx
movl %ecx, 0x1c(%rdi)
movl 0x20(%rsi), %ecx
movl %ecx, 0x20(%rdi)
movq 0x28(%rsi), %rcx
movq %rcx, 0x28(%rdi)
movq %rax, 0x28(%rsi)
movb 0x30(%rsi), %al
movb %al, 0x30(%rdi)
retq
nop
// File: /workspace/github_cpp_makefile_star2_O1/Davidc2525[P]Leaf/parser/Scanner.cpp
// Function: Buffer::Buffer(unsigned char const*, int)
Buffer::Buffer(const unsigned char* buf, int len) {
	this->buf = new unsigned char[len];
	memcpy(this->buf, buf, len*sizeof(unsigned char));
	bufStart = 0;
	bufCapacity = bufLen = len;
	fileLen = len;
	bufPos = 0;
	stream = NULL;
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rsi, %rbx
movq %rdi, %r14
leaq 0x1bc00(%rip), %rax     # 0x25310
movq %rax, (%rdi)
movslq %edx, %r15
movq %r15, %rdi
callq 0x5040
movq %rax, 0x8(%r14)
movq %rax, %rdi
movq %rbx, %rsi
movq %r15, %rdx
callq 0x51e0
xorl %eax, %eax
movl %eax, 0x14(%r14)
movl %r15d, 0x18(%r14)
movl %r15d, 0x10(%r14)
movl %r15d, 0x1c(%r14)
movl %eax, 0x20(%r14)
movq $0x0, 0x28(%r14)
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_cpp_makefile_star2_O1/Davidc2525[P]Leaf/parser/Scanner.cpp
// Function: Buffer::Read()
int Buffer::Read() {
	if (bufPos < bufLen) {
		return buf[bufPos++];
	} else if (GetPos() < fileLen) {
		SetPos(GetPos()); // shift buffer start to Pos
		return buf[bufPos++];
	} else if ((stream != NULL) && !CanSeek() && (ReadNextStreamChunk() > 0)) {
		return buf[bufPos++];
	} else {
		return EoF;
	}
}

// Assembly:
pushq %rbp
pushq %rbx
pushq %rax
movq %rdi, %rbx
movl 0x20(%rdi), %eax
cmpl 0x18(%rdi), %eax
jl 0x97c1
movq (%rbx), %rax
movq %rbx, %rdi
callq *0x30(%rax)
cmpl 0x1c(%rbx), %eax
jge 0x97da
movq (%rbx), %rax
movq %rbx, %rdi
callq *0x30(%rax)
movq (%rbx), %rcx
movq %rbx, %rdi
movl %eax, %esi
callq *0x38(%rcx)
movl 0x20(%rbx), %eax
movq 0x8(%rbx), %rcx
leal 0x1(%rax), %edx
movl %edx, 0x20(%rbx)
cltq
movzbl (%rcx,%rax), %ebp
movl %ebp, %eax
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
movq 0x28(%rbx), %rdi
movl $0x10000, %ebp          # imm = 0x10000
testq %rdi, %rdi
je 0x97d1
callq 0x5030
cmpq $-0x1, %rax
jne 0x97d1
movq %rbx, %rdi
callq 0x9802
testl %eax, %eax
jne 0x97be
jmp 0x97d1
nop
// File: /workspace/github_cpp_makefile_star2_O1/Davidc2525[P]Leaf/parser/Scanner.cpp
// Function: Buffer::ReadNextStreamChunk()
int Buffer::ReadNextStreamChunk() {
	int free = bufCapacity - bufLen;
	if (free == 0) {
		// in the case of a growing input stream
		// we can neither seek in the stream, nor can we
		// foresee the maximum length, thus we must adapt
		// the buffer size on demand.
		bufCapacity = bufLen * 2;
		unsigned char *newBuf = new unsigned char[bufCapacity];
		memcpy(newBuf, buf, bufLen*sizeof(unsigned char));
		delete [] buf;
		buf = newBuf;
		free = bufLen;
	}
	int read = fread(buf + bufLen, sizeof(unsigned char), free, stream);
	if (read > 0) {
		fileLen = bufLen = (bufLen + read);
		return read;
	}
	// end of stream reached
	return 0;
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rdi, %rbx
movl 0x10(%rdi), %eax
movslq 0x18(%rdi), %r14
subl %r14d, %eax
jne 0x984e
leaq (%r14,%r14), %rdi
movl %edi, 0x10(%rbx)
callq 0x5040
movq %rax, %r15
movq 0x8(%rbx), %r12
movq %rax, %rdi
movq %r12, %rsi
movq %r14, %rdx
callq 0x51e0
testq %r12, %r12
je 0x9847
movq %r12, %rdi
callq 0x5360
movq %r15, 0x8(%rbx)
movl 0x18(%rbx), %eax
movslq 0x18(%rbx), %rdi
addq 0x8(%rbx), %rdi
movslq %eax, %rdx
movq 0x28(%rbx), %rcx
movl $0x1, %esi
callq 0x53e0
testl %eax, %eax
jle 0x9878
movl 0x18(%rbx), %ecx
addl %eax, %ecx
movl %ecx, 0x18(%rbx)
movl %ecx, 0x1c(%rbx)
jmp 0x987a
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
// File: /workspace/github_cpp_makefile_star2_O1/Davidc2525[P]Leaf/parser/Scanner.cpp
// Function: Buffer::Peek()
int Buffer::Peek() {
	int curPos = GetPos();
	int ch = Read();
	SetPos(curPos);
	return ch;
}

// Assembly:
pushq %rbp
pushq %r14
pushq %rbx
movq %rdi, %rbx
movq (%rdi), %rax
callq *0x30(%rax)
movl %eax, %ebp
movq (%rbx), %rax
movq %rbx, %rdi
callq *0x18(%rax)
movl %eax, %r14d
movq (%rbx), %rax
movq %rbx, %rdi
movl %ebp, %esi
callq *0x38(%rax)
movl %r14d, %eax
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O1/Davidc2525[P]Leaf/parser/Scanner.cpp
// Function: Buffer::GetString(int, int)
wchar_t* Buffer::GetString(int beg, int end) {
	int len = 0;
	wchar_t *buf = new wchar_t[end - beg];
	int oldPos = GetPos();
	SetPos(beg);
	while (GetPos() < end) buf[len++] = (wchar_t) Read();
	SetPos(oldPos);
	wchar_t *res = coco_string_create(buf, 0, len);
	coco_string_delete(buf);
	return res;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movl %edx, %ebp
movl %esi, %r12d
movq %rdi, %rbx
movl %edx, %eax
subl %esi, %eax
cltq
leaq (,%rax,4), %rcx
testl %eax, %eax
movq $-0x1, %rdi
cmovnsq %rcx, %rdi
callq 0x5040
movq %rax, %r14
movq (%rbx), %rax
movq %rbx, %rdi
callq *0x30(%rax)
movl %eax, %r15d
movq (%rbx), %rax
movq %rbx, %rdi
movl %r12d, %esi
callq *0x38(%rax)
movq (%rbx), %rax
movq %rbx, %rdi
callq *0x30(%rax)
xorl %r12d, %r12d
cmpl %ebp, %eax
jge 0x992f
xorl %r12d, %r12d
movq (%rbx), %rax
movq %rbx, %rdi
callq *0x18(%rax)
movl %eax, (%r14,%r12,4)
incq %r12
movq (%rbx), %rax
movq %rbx, %rdi
callq *0x30(%rax)
cmpl %ebp, %eax
jl 0x9912
movq (%rbx), %rax
movq %rbx, %rdi
movl %r15d, %esi
callq *0x38(%rax)
movq %r14, %rdi
xorl %esi, %esi
movl %r12d, %edx
callq 0x910f
movq %rax, %rbx
movq %r14, %rdi
callq 0x5360
movq %rbx, %rax
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O1/Davidc2525[P]Leaf/parser/Scanner.cpp
// Function: Buffer::SetPos(int)
void Buffer::SetPos(int value) {
	if ((value >= fileLen) && (stream != NULL) && !CanSeek()) {
		// Wanted position is after buffer and the stream
		// is not seek-able e.g. network or console,
		// thus we have to read the stream manually till
		// the wanted position is in sight.
		while ((value >= fileLen) && (ReadNextStreamChunk() > 0));
	}

	if ((value < 0) || (value > fileLen)) {
		printf("--- buffer out of bounds access, position: %d\n", value);
		exit(1);
	}

	if ((value >= bufStart) && (value < (bufStart + bufLen))) { // already in buffer
		bufPos = value - bufStart;
	} else if (stream != NULL) { // must be swapped in
		fseek(stream, value, SEEK_SET);
		bufLen = fread(buf, sizeof(unsigned char), bufCapacity, stream);
		bufStart = value; bufPos = 0;
	} else {
		bufPos = fileLen - bufStart; // make Pos return fileLen
	}
}

// Assembly:
pushq %rbp
pushq %r14
pushq %rbx
movl %esi, %ebp
movq %rdi, %rbx
cmpl %esi, 0x1c(%rdi)
setg %al
movq 0x28(%rdi), %rdi
testq %rdi, %rdi
sete %cl
orb %al, %cl
jne 0x99a1
callq 0x5030
cmpq $-0x1, %rax
jne 0x99a1
cmpl %ebp, 0x1c(%rbx)
jg 0x99a1
movq %rbx, %rdi
callq 0x9802
testl %eax, %eax
jne 0x9990
testl %ebp, %ebp
js 0x9a01
movl 0x1c(%rbx), %eax
cmpl %ebp, %eax
jl 0x9a01
movl 0x14(%rbx), %ecx
movl %ebp, %r14d
subl %ecx, %r14d
jl 0x99c0
movl 0x18(%rbx), %edx
addl %ecx, %edx
cmpl %ebp, %edx
jg 0x99f8
movq 0x28(%rbx), %rdi
testq %rdi, %rdi
je 0x99f3
movl %ebp, %esi
xorl %r14d, %r14d
xorl %edx, %edx
callq 0x52f0
movslq 0x10(%rbx), %rdx
movq 0x8(%rbx), %rdi
movq 0x28(%rbx), %rcx
movl $0x1, %esi
callq 0x53e0
movl %eax, 0x18(%rbx)
movl %ebp, 0x14(%rbx)
jmp 0x99f8
subl %ecx, %eax
movl %eax, %r14d
movl %r14d, 0x20(%rbx)
popq %rbx
popq %r14
popq %rbp
retq
leaq 0xfbad(%rip), %rdi      # 0x195b5
movl %ebp, %esi
xorl %eax, %eax
callq 0x5070
movl $0x1, %edi
callq 0x5340
nop
// File: /workspace/github_cpp_makefile_star2_O1/Davidc2525[P]Leaf/parser/Scanner.cpp
// Function: UTF8Buffer::Read()
int UTF8Buffer::Read() {
	int ch;
	do {
		ch = Buffer::Read();
		// until we find a utf8 start (0xxxxxxx or 11xxxxxx)
	} while ((ch >= 128) && ((ch & 0xC0) != 0xC0) && (ch != EoF));
	if (ch < 128 || ch == EoF) {
		// nothing to do, first 127 chars are the same in ascii and utf8
		// 0xxxxxxx or end of file character
	} else if ((ch & 0xF0) == 0xF0) {
		// 11110xxx 10xxxxxx 10xxxxxx 10xxxxxx
		int c1 = ch & 0x07; ch = Buffer::Read();
		int c2 = ch & 0x3F; ch = Buffer::Read();
		int c3 = ch & 0x3F; ch = Buffer::Read();
		int c4 = ch & 0x3F;
		ch = (((((c1 << 6) | c2) << 6) | c3) << 6) | c4;
	} else if ((ch & 0xE0) == 0xE0) {
		// 1110xxxx 10xxxxxx 10xxxxxx
		int c1 = ch & 0x0F; ch = Buffer::Read();
		int c2 = ch & 0x3F; ch = Buffer::Read();
		int c3 = ch & 0x3F;
		ch = (((c1 << 6) | c2) << 6) | c3;
	} else if ((ch & 0xC0) == 0xC0) {
		// 110xxxxx 10xxxxxx
		int c1 = ch & 0x1F; ch = Buffer::Read();
		int c2 = ch & 0x3F;
		ch = (c1 << 6) | c2;
	}
	return ch;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %r14
movq %r14, %rdi
callq 0x978e
movl %eax, %ebx
cmpl $0x80, %eax
jb 0x9a4d
cmpl $0x10000, %ebx          # imm = 0x10000
je 0x9a4d
movl %ebx, %eax
andl $0xc0, %eax
cmpl $0xc0, %eax
jne 0x9a26
cmpl $0x80, %ebx
setb %al
cmpl $0x10000, %ebx          # imm = 0x10000
sete %cl
orb %al, %cl
jne 0x9aed
movl %ebx, %eax
notl %eax
testb $-0x10, %al
jne 0x9ab0
movq %r14, %rdi
callq 0x978e
movl %eax, %ebp
andl $0x3f, %ebp
movq %r14, %rdi
callq 0x978e
movl %eax, %r15d
movq %r14, %rdi
callq 0x978e
andl $0x3f, %eax
andl $0x7, %ebx
shll $0x6, %ebx
orl %ebp, %ebx
shll $0xc, %ebx
andl $0x3f, %r15d
shll $0x6, %r15d
orl %ebx, %r15d
orl %eax, %r15d
movl %r15d, %ebx
jmp 0x9aed
testb $-0x20, %al
jne 0x9ad6
movq %r14, %rdi
callq 0x978e
movl %eax, %ebp
andl $0x3f, %ebp
movq %r14, %rdi
callq 0x978e
andl $0x3f, %eax
andl $0xf, %ebx
shll $0x6, %ebx
orl %ebp, %ebx
jmp 0x9ae8
testb $-0x40, %al
jne 0x9aed
movq %r14, %rdi
callq 0x978e
andl $0x3f, %eax
andl $0x1f, %ebx
shll $0x6, %ebx
orl %eax, %ebx
movl %ebx, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O1/Davidc2525[P]Leaf/parser/Scanner.cpp
// Function: Scanner::Scanner(wchar_t const*)
Scanner::Scanner(const wchar_t* fileName) {
	FILE* stream;
	char *chFileName = coco_string_create_char(fileName);
	if ((stream = fopen(chFileName, "rb")) == NULL) {
		printf("--- Cannot open file %ls\n", fileName);
		exit(1);
	}
	coco_string_delete(chFileName);
	buffer = new Buffer(stream, false);
	Init();
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rsi, %r14
movq %rdi, %rbx
leaq 0x1ae71(%rip), %rax     # 0x253d8
movq %rax, 0x38(%rdi)
movl $0x400, %edi            # imm = 0x400
callq 0x5040
movq %rax, 0x40(%rbx)
movl $0x400, %edx            # imm = 0x400
movq %rax, %rdi
xorl %esi, %esi
callq 0x5170
leaq 0x1ae79(%rip), %rax     # 0x25408
movq %rax, 0x48(%rbx)
movl $0x400, %edi            # imm = 0x400
callq 0x5040
movq %rax, 0x50(%rbx)
movl $0x400, %edx            # imm = 0x400
movq %rax, %rdi
xorl %esi, %esi
callq 0x5170
movq %r14, %rdi
callq 0x9512
movq %rax, %r15
leaq 0xf022(%rip), %rsi      # 0x195e4
movq %rax, %rdi
callq 0x5320
testq %rax, %rax
je 0xa60f
movq %rax, %r12
movq %r15, %rdi
callq 0x5360
movl $0x38, %edi
callq 0x5290
movq %rax, %r15
movq %rax, %rdi
movq %r12, %rsi
xorl %edx, %edx
callq 0x95ac
movq %r15, 0x98(%rbx)
movq %rbx, %rdi
callq 0x9bfc
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
leaq 0xefd1(%rip), %rdi      # 0x195e7
movq %r14, %rsi
xorl %eax, %eax
callq 0x5070
movl $0x1, %edi
callq 0x5340
movq %rax, %r14
movl $0x38, %esi
movq %r15, %rdi
callq 0x52a0
jmp 0xa644
movq %rax, %r14
jmp 0xa64d
movq %rax, %r14
leaq 0x48(%rbx), %rdi
callq 0xb7cc
addq $0x38, %rbx
movq %rbx, %rdi
callq 0xb826
movq %r14, %rdi
callq 0x5470
nop
// File: /workspace/github_cpp_makefile_star2_O1/Davidc2525[P]Leaf/parser/Scanner.cpp
// Function: Scanner::~Scanner()
Scanner::~Scanner() {
	char* cur = (char*) firstHeap;

	while(cur != NULL) {
		cur = *(char**) (cur + COCO_HEAP_BLOCK_SIZE);
		free(firstHeap);
		firstHeap = cur;
	}
	delete [] tval;
	delete buffer;
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
movq (%rdi), %r14
testq %r14, %r14
je 0xa749
movq 0x4000000(%r14), %r14
movq (%rbx), %rdi
callq 0x5330
movq %r14, (%rbx)
jmp 0xa730
movq 0x60(%rbx), %rdi
testq %rdi, %rdi
je 0xa757
callq 0x5360
movq 0x98(%rbx), %rdi
testq %rdi, %rdi
je 0xa769
movq (%rdi), %rax
callq *0x8(%rax)
leaq 0x48(%rbx), %rdi
callq 0xb7cc
addq $0x38, %rbx
movq %rbx, %rdi
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0xb826
nop
// File: /workspace/github_cpp_makefile_star2_O1/Davidc2525[P]Leaf/parser/Scanner.cpp
// Function: Scanner::NextCh()
void Scanner::NextCh() {
	if (oldEols > 0) { ch = EOL; oldEols--; }
	else {
		pos = buffer->GetPos();
		// buffer reads unicode chars, if UTF8 has been detected
		ch = buffer->Read(); col++; charPos++;
		// replace isolated '\r' by '\n' in order to make
		// eol handling uniform across Windows, Unix and Mac
		if (ch == L'\r' && buffer->Peek() != L'\n') ch = EOL;
		if (ch == EOL) { line++; col = 0; }
	}

}

// Assembly:
pushq %rbx
movq %rdi, %rbx
movl 0x94(%rdi), %eax
testl %eax, %eax
jle 0xa7a8
movzbl 0x20(%rbx), %ecx
movl %ecx, 0x80(%rbx)
decl %eax
movl %eax, 0x94(%rbx)
jmp 0xa817
movq 0x98(%rbx), %rdi
movq (%rdi), %rax
callq *0x30(%rax)
movl %eax, 0x84(%rbx)
movq 0x98(%rbx), %rdi
movq (%rdi), %rax
callq *0x18(%rax)
movl %eax, 0x80(%rbx)
incl 0x90(%rbx)
incl 0x88(%rbx)
cmpl $0xd, %eax
jne 0xa7fb
movq 0x98(%rbx), %rdi
movq (%rdi), %rax
callq *0x20(%rax)
cmpl $0xa, %eax
je 0xa7fb
movzbl 0x20(%rbx), %eax
movl %eax, 0x80(%rbx)
movzbl 0x20(%rbx), %eax
cmpl %eax, 0x80(%rbx)
jne 0xa817
incl 0x8c(%rbx)
movl $0x0, 0x90(%rbx)
popq %rbx
retq
nop
// File: /workspace/github_cpp_makefile_star2_O1/Davidc2525[P]Leaf/parser/Scanner.cpp
// Function: Scanner::CreateToken()
Token* Scanner::CreateToken() {
	Token *t;
	if (((char*) heapTop + (int) sizeof(Token)) >= (char*) heapEnd) {
		CreateHeapBlock();
	}
	t = (Token*) heapTop;
	heapTop = (void*) ((char*) heapTop + sizeof(Token));
	t->val = NULL;
	t->next = NULL;
	return t;
}

// Assembly:
pushq %rbx
movq %rdi, %rbx
movq 0x10(%rdi), %rax
addq $0x28, %rax
cmpq 0x18(%rdi), %rax
jb 0xa834
movq %rbx, %rdi
callq 0xab3a
movq 0x10(%rbx), %rax
leaq 0x28(%rax), %rcx
movq %rcx, 0x10(%rbx)
xorps %xmm0, %xmm0
movups %xmm0, 0x18(%rax)
popq %rbx
retq
nop
// File: /workspace/github_cpp_makefile_star2_O1/Davidc2525[P]Leaf/parser/Scanner.cpp
// Function: Scanner::AddCh()
void Scanner::AddCh() {
	if (tlen >= tvalLength) {
		tvalLength *= 2;
		wchar_t *newBuf = new wchar_t[tvalLength];
		memcpy(newBuf, tval, tlen*sizeof(wchar_t));
		delete [] tval;
		tval = newBuf;
	}
	if (ch != Buffer::EoF) {
		tval[tlen++] = ch;
		NextCh();
	}
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rdi, %rbx
movslq 0x6c(%rdi), %r14
movslq 0x68(%rdi), %rax
cmpl %eax, %r14d
jl 0xa8ab
leal (%rax,%rax), %ecx
movl %ecx, 0x68(%rbx)
movq %rax, %rcx
shlq $0x3, %rcx
testl %eax, %eax
movq $-0x1, %rdi
cmovnsq %rcx, %rdi
callq 0x5040
movq %rax, %r15
movq 0x60(%rbx), %r12
shlq $0x2, %r14
movq %rax, %rdi
movq %r12, %rsi
movq %r14, %rdx
callq 0x51e0
testq %r12, %r12
je 0xa8a7
movq %r12, %rdi
callq 0x5360
movq %r15, 0x60(%rbx)
movl 0x80(%rbx), %eax
cmpl $0x10000, %eax          # imm = 0x10000
jne 0xa8c4
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
movq 0x60(%rbx), %rcx
movslq 0x6c(%rbx), %rdx
leal 0x1(%rdx), %esi
movl %esi, 0x6c(%rbx)
movl %eax, (%rcx,%rdx,4)
movq %rbx, %rdi
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
jmp 0xa786
// File: /workspace/github_cpp_makefile_star2_O1/Davidc2525[P]Leaf/parser/Scanner.cpp
// Function: Scanner::Comment0()
bool Scanner::Comment0() {
	int level = 1, pos0 = pos, line0 = line, col0 = col, charPos0 = charPos;
	NextCh();
	if (ch == L'/') {
		NextCh();
		for(;;) {
			if (ch == 10) {
				level--;
				if (level == 0) { oldEols = line - line0; NextCh(); return true; }
				NextCh();
			} else if (ch == buffer->EoF) return false;
			else NextCh();
		}
	} else {
		buffer->SetPos(pos0); NextCh(); line = line0; col = col0; charPos = charPos0;
	}
	return false;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movq %rdi, %rbx
movl 0x84(%rdi), %ebp
movl 0x88(%rdi), %r15d
movl 0x8c(%rdi), %r14d
movl 0x90(%rdi), %r12d
callq 0xa786
cmpl $0x2f, 0x80(%rbx)
jne 0xa951
movq %rbx, %rdi
callq 0xa786
movl 0x80(%rbx), %eax
cmpl $0x10000, %eax          # imm = 0x10000
je 0xa97d
cmpl $0xa, %eax
jne 0xa91c
movl 0x8c(%rbx), %eax
subl %r14d, %eax
movl %eax, 0x94(%rbx)
movq %rbx, %rdi
callq 0xa786
movb $0x1, %al
jmp 0xa97f
movq 0x98(%rbx), %rdi
movq (%rdi), %rax
movl %ebp, %esi
callq *0x38(%rax)
movq %rbx, %rdi
callq 0xa786
movl %r14d, 0x8c(%rbx)
movl %r12d, 0x90(%rbx)
movl %r15d, 0x88(%rbx)
xorl %eax, %eax
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O1/Davidc2525[P]Leaf/parser/Scanner.cpp
// Function: Scanner::Comment1()
bool Scanner::Comment1() {
	int level = 1, pos0 = pos, line0 = line, col0 = col, charPos0 = charPos;
	NextCh();
	if (ch == L'*') {
		NextCh();
		for(;;) {
			if (ch == L'*') {
				NextCh();
				if (ch == L')') {
					level--;
					if (level == 0) { oldEols = line - line0; NextCh(); return true; }
					NextCh();
				}
			} else if (ch == L'(') {
				NextCh();
				if (ch == L'*') {
					level++; NextCh();
				}
			} else if (ch == buffer->EoF) return false;
			else NextCh();
		}
	} else {
		buffer->SetPos(pos0); NextCh(); line = line0; col = col0; charPos = charPos0;
	}
	return false;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movq %rdi, %rbx
movl 0x84(%rdi), %ebp
movl 0x88(%rdi), %r15d
movl 0x8c(%rdi), %r14d
movl 0x90(%rdi), %r12d
callq 0xa786
cmpl $0x2a, 0x80(%rbx)
jne 0xaa29
movl $0x1, %ebp
movq %rbx, %rdi
callq 0xa786
movl 0x80(%rbx), %eax
cmpl $0x28, %eax
je 0xa9ec
cmpl $0x2a, %eax
jne 0xaa01
movq %rbx, %rdi
callq 0xa786
cmpl $0x29, 0x80(%rbx)
jne 0xa9c9
jmp 0xaa0a
movq %rbx, %rdi
callq 0xa786
cmpl $0x2a, 0x80(%rbx)
jne 0xa9c9
incl %ebp
jmp 0xa9c1
cmpl $0x10000, %eax          # imm = 0x10000
jne 0xa9c1
jmp 0xaa55
decl %ebp
jne 0xa9c1
movl 0x8c(%rbx), %eax
subl %r14d, %eax
movl %eax, 0x94(%rbx)
movq %rbx, %rdi
callq 0xa786
movb $0x1, %al
jmp 0xaa57
movq 0x98(%rbx), %rdi
movq (%rdi), %rax
movl %ebp, %esi
callq *0x38(%rax)
movq %rbx, %rdi
callq 0xa786
movl %r14d, 0x8c(%rbx)
movl %r12d, 0x90(%rbx)
movl %r15d, 0x88(%rbx)
xorl %eax, %eax
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O1/Davidc2525[P]Leaf/parser/Scanner.cpp
// Function: Scanner::CreateHeapBlock()
void Scanner::CreateHeapBlock() {
	void* newHeap;
	char* cur = (char*) firstHeap;

	while(((char*) tokens < cur) || ((char*) tokens > (cur + COCO_HEAP_BLOCK_SIZE))) {
		cur = *((char**) (cur + COCO_HEAP_BLOCK_SIZE));
		free(firstHeap);
		firstHeap = cur;
	}

	// COCO_HEAP_BLOCK_SIZE byte heap + pointer to next heap block
	newHeap = malloc(COCO_HEAP_BLOCK_SIZE + sizeof(void*));
	*heapEnd = newHeap;
	heapEnd = (void**) (((char*) newHeap) + COCO_HEAP_BLOCK_SIZE);
	*heapEnd = 0;
	heap = newHeap;
	heapTop = heap;
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
movq (%rdi), %r14
movq 0x70(%rdi), %rax
cmpq %r14, %rax
setb %cl
addq $0x4000000, %r14        # imm = 0x4000000
cmpq %r14, %rax
seta %al
orb %cl, %al
cmpb $0x1, %al
jne 0xab8a
movq (%r14), %r14
movq (%rbx), %rdi
callq 0x5330
movq %r14, (%rbx)
movq 0x70(%rbx), %rax
cmpq %r14, %rax
setb %cl
addq $0x4000000, %r14        # imm = 0x4000000
cmpq %r14, %rax
seta %al
orb %cl, %al
jne 0xab61
movl $0x4000008, %edi        # imm = 0x4000008
callq 0x5370
movq 0x18(%rbx), %rcx
movq %rax, (%rcx)
leaq 0x4000000(%rax), %rcx
movq %rcx, 0x18(%rbx)
movq $0x0, 0x4000000(%rax)
movq %rax, 0x8(%rbx)
movq %rax, 0x10(%rbx)
addq $0x8, %rsp
popq %rbx
popq %r14
retq
nop
// File: /workspace/github_cpp_makefile_star2_O1/Davidc2525[P]Leaf/parser/Scanner.cpp
// Function: Scanner::AppendVal(Token*)
void Scanner::AppendVal(Token *t) {
	int reqMem = (tlen + 1) * sizeof(wchar_t);
	if (((char*) heapTop + reqMem) >= (char*) heapEnd) {
		if (reqMem > COCO_HEAP_BLOCK_SIZE) {
			printf("--- Too long token value\n");
			exit(1);
		}
		CreateHeapBlock();
	}
	t->val = (wchar_t*) heapTop;
	heapTop = (void*) ((char*) heapTop + reqMem);

	wcsncpy(t->val, tval, tlen);
	t->val[tlen] = L'\0';
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rsi, %r14
movq %rdi, %rbx
movl 0x6c(%rdi), %eax
leal 0x4(,%rax,4), %eax
movslq %eax, %r15
movq 0x10(%rdi), %rcx
addq %r15, %rcx
cmpq 0x18(%rdi), %rcx
jb 0xabf6
cmpl $0x4000001, %eax        # imm = 0x4000001
jge 0xac27
movq %rbx, %rdi
callq 0xab3a
movq 0x10(%rbx), %rdi
movq %rdi, 0x18(%r14)
addq %rdi, %r15
movq %r15, 0x10(%rbx)
movq 0x60(%rbx), %rsi
movslq 0x6c(%rbx), %rdx
callq 0x50a0
movq 0x18(%r14), %rax
movslq 0x6c(%rbx), %rcx
movl $0x0, (%rax,%rcx,4)
popq %rbx
popq %r14
popq %r15
retq
leaq 0xe9fc(%rip), %rdi      # 0x1962a
callq 0x5400
movl $0x1, %edi
callq 0x5340
nop
// File: /workspace/github_cpp_makefile_star2_O1/Davidc2525[P]Leaf/parser/Scanner.cpp
// Function: Scanner::SetScannerBehindT()
void Scanner::SetScannerBehindT() {
	buffer->SetPos(t->pos);
	NextCh();
	line = t->line; col = t->col; charPos = t->charPos;
	for (int i = 0; i < tlen; i++) NextCh();
}

// Assembly:
pushq %rbp
pushq %rbx
pushq %rax
movq %rdi, %rbx
movq 0x58(%rdi), %rax
movq 0x98(%rdi), %rdi
movl 0x4(%rax), %esi
movq (%rdi), %rax
callq *0x38(%rax)
movq %rbx, %rdi
callq 0xa786
movq 0x58(%rbx), %rax
movl 0x10(%rax), %ecx
movl %ecx, 0x8c(%rbx)
movl 0xc(%rax), %ecx
movl %ecx, 0x90(%rbx)
movl 0x8(%rax), %eax
movl %eax, 0x88(%rbx)
cmpl $0x0, 0x6c(%rbx)
jle 0xb720
xorl %ebp, %ebp
movq %rbx, %rdi
callq 0xa786
incl %ebp
cmpl 0x6c(%rbx), %ebp
jl 0xb711
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O1/Davidc2525[P]Leaf/parser/Scanner.cpp
// Function: Scanner::Peek()
Token* Scanner::Peek() {
	do {
		if (pt->next == NULL) {
			pt->next = NextToken();
		}
		pt = pt->next;
	} while (pt->kind > maxT); // skip pragmas

	return pt;
}

// Assembly:
pushq %rbx
movq %rdi, %rbx
movq 0x78(%rbx), %rax
cmpq $0x0, 0x20(%rax)
jne 0xb76b
movq %rbx, %rdi
callq 0xac3e
movq 0x78(%rbx), %rcx
movq %rax, 0x20(%rcx)
movq 0x78(%rbx), %rax
movq 0x20(%rax), %rax
movq %rax, 0x78(%rbx)
movl (%rax), %ecx
cmpl 0x2c(%rbx), %ecx
jg 0xb750
popq %rbx
retq
// File: /workspace/github_cpp_makefile_star2_O1/Davidc2525[P]Leaf/parser/Scanner.cpp
// Function: Buffer::~Buffer()
Buffer::~Buffer() {
	Close(); 
	if (buf != NULL) {
		delete [] buf;
		buf = NULL;
	}
}

// Assembly:
pushq %rbx
movq %rdi, %rbx
leaq 0x19b7b(%rip), %rax     # 0x25310
movq %rax, (%rdi)
cmpb $0x0, 0x30(%rdi)
jne 0xb7b4
movq 0x28(%rbx), %rdi
testq %rdi, %rdi
je 0xb7b4
callq 0x5280
movq $0x0, 0x28(%rbx)
movq 0x8(%rbx), %rdi
testq %rdi, %rdi
je 0xb7ca
callq 0x5360
movq $0x0, 0x8(%rbx)
popq %rbx
retq
// File: /workspace/github_cpp_makefile_star2_O1/Davidc2525[P]Leaf/parser/Scanner.h
// Function: KeywordMap::~KeywordMap()
virtual ~KeywordMap() {
		for (int i = 0; i < 128; ++i) {
			Elem *e = tab[i];
			while (e != NULL) {
				Elem *next = e->next;
				delete e;
				e = next;
			}
		}
		delete [] tab;
	}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rdi, %rbx
leaq 0x19c2d(%rip), %rax     # 0x25408
movq %rax, (%rdi)
xorl %r14d, %r14d
movq 0x8(%rbx), %rax
movq (%rax,%r14,8), %rdi
testq %rdi, %rdi
je 0xb800
movq (%rdi), %rax
movq 0x18(%rdi), %r15
callq *0x8(%rax)
movq %r15, %rdi
testq %r15, %r15
jne 0xb7ee
incq %r14
cmpq $0x80, %r14
jne 0xb7e1
movq 0x8(%rbx), %rdi
testq %rdi, %rdi
je 0xb81f
popq %rbx
popq %r14
popq %r15
jmp 0x5360
popq %rbx
popq %r14
popq %r15
retq
nop
// File: /workspace/github_cpp_makefile_star2_O1/Davidc2525[P]Leaf/parser/Parser.cpp
// Function: Parser::Get()
void Parser::Get() {
	for (;;) {
		t = la;
		la = scanner->Scan();
		if (la->kind <= maxT) { ++errDist; break; }

		if (dummyToken != t) {
			dummyToken->kind = t->kind;
			dummyToken->pos = t->pos;
			dummyToken->col = t->col;
			dummyToken->line = t->line;
			dummyToken->next = NULL;
			coco_string_delete(dummyToken->val);
			dummyToken->val = coco_string_create(t->val);
			t = dummyToken;
		}
		la = t;
	}
}

// Assembly:
pushq %rbx
movq %rdi, %rbx
movq 0x18(%rdi), %rdi
movq 0x30(%rbx), %rax
movq %rax, 0x28(%rbx)
callq 0xb728
movq %rax, 0x30(%rbx)
movl (%rax), %eax
cmpl (%rbx), %eax
jle 0xbe62
movq 0x8(%rbx), %rdi
movq 0x28(%rbx), %rax
cmpq %rax, %rdi
je 0xbe54
movl (%rax), %ecx
movl %ecx, (%rdi)
movl 0x4(%rax), %ecx
movl %ecx, 0x4(%rdi)
movl 0xc(%rax), %ecx
movl %ecx, 0xc(%rdi)
movl 0x10(%rax), %eax
movl %eax, 0x10(%rdi)
movq $0x0, 0x20(%rdi)
addq $0x18, %rdi
callq 0x9394
movq 0x28(%rbx), %rax
movq 0x18(%rax), %rdi
callq 0x90d8
movq 0x8(%rbx), %rcx
movq %rax, 0x18(%rcx)
movq %rcx, 0x28(%rbx)
movq 0x18(%rbx), %rdi
movq 0x28(%rbx), %rax
movq %rax, 0x30(%rbx)
jmp 0xbdf8
incl 0x10(%rbx)
popq %rbx
retq
nop
// File: /workspace/github_cpp_makefile_star2_O1/Davidc2525[P]Leaf/parser/Parser.cpp
// Function: Parser::ExpectWeak(int, int)
void Parser::ExpectWeak(int n, int follow) {
	if (la->kind == n) Get();
	else {
		SynErr(n);
		while (!StartOf(follow)) Get();
	}
}

// Assembly:
pushq %rbp
pushq %r14
pushq %rbx
movq %rdi, %rbx
movq 0x30(%rdi), %rax
cmpl %esi, (%rax)
jne 0xbe95
movq %rbx, %rdi
popq %rbx
popq %r14
popq %rbp
jmp 0xbde8
movl %edx, %ebp
movq %rbx, %rdi
callq 0xba44
movslq %ebp, %rax
movq 0x30(%rbx), %rcx
movslq (%rcx), %rcx
imulq $0x34, %rax, %rax
leaq 0xdaac(%rip), %r14      # 0x19960
addq %rax, %r14
cmpb $0x0, (%rcx,%r14)
jne 0xbed4
movq %rbx, %rdi
callq 0xbde8
movq 0x30(%rbx), %rax
movslq (%rax), %rax
cmpb $0x1, (%rax,%r14)
jne 0xbebe
popq %rbx
popq %r14
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O1/Davidc2525[P]Leaf/parser/Parser.cpp
// Function: Parser::WeakSeparator(int, int, int)
bool Parser::WeakSeparator(int n, int syFol, int repFol) {
	if (la->kind == n) {Get(); return true;}
	else if (StartOf(repFol)) {return false;}
	else {
		SynErr(n);
		while (!(StartOf(syFol) || StartOf(repFol) || StartOf(0))) {
			Get();
		}
		return StartOf(syFol);
	}
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movq %rdi, %rbx
movq 0x30(%rdi), %rax
movslq (%rax), %rax
cmpl %esi, %eax
jne 0xbf18
movq %rbx, %rdi
callq 0xbde8
movb $0x1, %al
jmp 0xbf57
movslq %ecx, %rcx
imulq $0x34, %rcx, %r14
leaq 0xda3a(%rip), %r15      # 0x19960
addq %r15, %r14
cmpb $0x0, (%rax,%r14)
je 0xbf34
xorl %eax, %eax
jmp 0xbf57
movl %edx, %ebp
movq %rbx, %rdi
callq 0xba44
movslq %ebp, %rax
movq 0x30(%rbx), %rcx
movslq (%rcx), %rcx
imulq $0x34, %rax, %r12
addq %r15, %r12
movb (%rcx,%r12), %al
testb %al, %al
je 0xbf62
andb $0x1, %al
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
cmpb $0x0, (%rcx,%r14)
jne 0xbf57
cmpb $0x0, (%rcx,%r15)
jne 0xbf57
movq %rbx, %rdi
callq 0xbde8
movq 0x30(%rbx), %rax
movslq (%rax), %rcx
movb (%rcx,%r12), %al
cmpb $0x1, %al
jne 0xbf62
jmp 0xbf57
nop
// File: /workspace/github_cpp_makefile_star2_O1/Davidc2525[P]Leaf/parser/Parser.cpp
// Function: Parser::SourceCode(LEAF::AST::NODEU*&)
bool Parser::StartOf(int s) {
	const bool T = true;
	const bool x = false;

	static bool set[11][52] = {
		{T,x,x,x, x,x,x,x, x,x,x,x, x,x,x,x, x,x,x,x, x,x,x,x, x,x,x,x, x,x,x,x, x,x,x,x, x,x,x,x, x,x,x,x, x,x,x,x, x,x,x,x},
		{x,T,x,x, T,x,x,x, x,T,x,T, x,T,T,T, x,T,T,T, x,T,T,x, T,T,T,x, T,T,x,x, x,x,x,x, x,x,x,x, x,x,x,x, x,x,x,x, x,x,x,x},
		{x,T,T,T, T,x,T,T, x,x,x,x, x,x,x,T, x,x,x,x, x,x,x,x, x,x,x,x, T,T,x,x, T,x,x,x, x,x,x,x, x,x,x,x, x,x,x,T, T,x,x,x},
		{T,T,T,x, T,x,x,x, x,T,T,T, T,T,T,T, T,T,T,T, x,T,T,x, T,T,T,T, T,T,T,T, x,T,T,T, T,T,T,T, T,T,T,T, T,T,T,x, x,T,x,x},
		{x,T,x,x, T,x,x,x, x,x,x,x, x,x,x,T, x,x,x,x, x,x,x,x, T,T,T,x, x,x,x,x, x,x,x,x, x,x,x,x, x,x,x,x, x,x,x,x, x,x,x,x},
		{x,T,x,x, T,x,x,x, x,x,x,x, x,x,x,T, x,x,x,x, x,x,x,x, T,x,T,x, x,x,x,x, x,x,x,x, x,x,x,x, x,x,x,x, x,x,x,x, x,x,x,x},
		{x,x,x,x, T,x,x,x, x,x,x,x, x,x,x,T, T,x,x,x, x,x,x,x, T,T,T,x, x,x,x,x, x,x,x,x, x,x,x,x, x,x,x,x, x,x,x,x, x,x,x,x},
		{x,x,x,x, x,x,x,x, x,x,x,x, x,x,x,T, T,x,x,x, x,x,x,x, T,T,T,x, x,x,x,x, x,x,x,x, x,x,x,x, x,x,x,x, x,x,x,x, x,x,x,x},
		{x,x,x,x, T,x,x,x, x,x,x,x, x,x,x,T, T,x,x,x, x,x,x,x, T,x,T,x, x,x,x,x, x,x,x,x, x,x,x,x, x,x,x,x, x,x,x,x, x,x,x,x},
		{x,x,x,x, x,x,x,x, x,x,x,x, x,x,x,T, T,x,x,x, x,x,x,x, T,x,T,x, x,x,x,x, x,x,x,x, x,x,x,x, x,x,x,x, x,x,x,x, x,x,x,x},
		{x,x,x,x, x,x,x,x, x,x,x,x, x,x,x,x, x,x,x,x, x,x,x,x, x,x,x,x, x,x,x,x, x,x,x,x, x,T,T,T, T,T,T,x, x,x,x,x, x,x,x,x}
	};



	return set[s][la->kind];
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq 0x30(%rdi), %rax
movslq (%rax), %rax
leaq 0xd98c(%rip), %r12      # 0x19960
cmpb $0x1, 0x34(%rax,%r12)
jne 0xc00b
movq %rsi, %rbx
movq %rdi, %r14
movq %rsp, %r15
movq %r14, %rdi
movq %r15, %rsi
callq 0xc018
movq (%rbx), %rdi
movq (%rsp), %rsi
callq 0x8d2c
movq 0x30(%r14), %rax
movslq (%rax), %rax
cmpb $0x0, 0x34(%rax,%r12)
jne 0xbfe5
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
nop
// File: /workspace/github_cpp_makefile_star2_O1/Davidc2525[P]Leaf/parser/Parser.cpp
// Function: Parser::ActParams(LEAF::AST::NODEU*&, bool)
void Parser::ActParams(ASTU&f_node,bool ifc) {
		Obj * obj = get_obj(f_node);  int n = 0; f_node = func_call(f_node,ifc);
		Expect(15 /* "(" */);
		if (StartOf(2)) {
			ASTU s_2;
			Expr(s_2);
			n++; block_add(f_node,s_2); 
			while (la->kind == 25 /* "," */) {
				Get();
				ASTU s_2;
				Expr(s_2);
				n++; block_add(f_node,s_2); 
			}
		}
		Expect(16 /* ")" */);
		if(n!=obj->nPars){
		cout<<";la funcion recibe n parametros: "<<obj->nPars<<" actual: "<<n<<  endl;
		exit(1);
		}
		
		unwrap_call_function(get_obj(f_node));
		
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x10, %rsp
movl %edx, %ebp
movq %rsi, %r15
movq %rdi, %rbx
movq (%rsi), %rdi
callq 0x8d76
movq %rax, %r14
movq (%r15), %rdi
movl %ebp, %esi
callq 0x8d75
movq %rax, (%r15)
movq %rbx, %rdi
movl $0xf, %esi
callq 0xbe68
movq 0x30(%rbx), %rax
movslq (%rax), %rax
leaq 0xcd37(%rip), %rcx      # 0x19960
xorl %ebp, %ebp
cmpb $0x1, 0x68(%rax,%rcx)
jne 0xcc89
leaq 0x8(%rsp), %r12
movq %rbx, %rdi
movq %r12, %rsi
callq 0xe1e2
movq (%r15), %rdi
movq (%r12), %rsi
callq 0x8d2c
movq 0x30(%rbx), %rax
movl $0x1, %ebp
cmpl $0x19, (%rax)
jne 0xcc89
movq %rsp, %r12
movq %rbx, %rdi
callq 0xbde8
movq %rbx, %rdi
movq %r12, %rsi
callq 0xe1e2
incl %ebp
movq (%r15), %rdi
movq (%rsp), %rsi
callq 0x8d2c
movq 0x30(%rbx), %rax
cmpl $0x19, (%rax)
je 0xcc5f
movq %rbx, %rdi
movl $0x10, %esi
callq 0xbe68
cmpl 0x38(%r14), %ebp
jne 0xccbb
movq (%r15), %rdi
callq 0x8d76
movq %rbx, %rdi
movq %rax, %rsi
addq $0x10, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
jmp 0xed42
movq 0x19316(%rip), %rdi     # 0x25fd8
leaq 0xcf74(%rip), %rsi      # 0x19c3d
callq 0x5270
movl 0x38(%r14), %esi
movq %rax, %rdi
callq 0x5460
leaq 0xcf7e(%rip), %rsi      # 0x19c5f
movq %rax, %rdi
callq 0x5270
movq %rax, %rdi
movl %ebp, %esi
callq 0x5460
movq %rax, %rdi
callq 0x5130
movl $0x1, %edi
callq 0x5340
nop
// File: /workspace/github_cpp_makefile_star2_O1/Davidc2525[P]Leaf/parser/Parser.cpp
// Function: Parser::StatementBLock(LEAF::AST::NODEU*&)
void Parser::StatementBLock(ASTU&b_node) {
		
		Expect(9 /* "{" */);
		while (StartOf(1)) {
			ASTU stat;
			Statement(stat);
			block_add(b_node,stat); 
		}
		Expect(10 /* "}" */);
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rsi, %r14
movq %rdi, %rbx
movl $0x9, %esi
callq 0xbe68
movq 0x30(%rbx), %rax
movslq (%rax), %rax
leaq 0xc69e(%rip), %r12      # 0x19960
cmpb $0x1, 0x34(%rax,%r12)
jne 0xd2f3
movq %rsp, %r15
movq %rbx, %rdi
movq %r15, %rsi
callq 0xc018
movq (%r14), %rdi
movq (%rsp), %rsi
callq 0x8d2c
movq 0x30(%rbx), %rax
movslq (%rax), %rax
cmpb $0x0, 0x34(%rax,%r12)
jne 0xd2cd
movq %rbx, %rdi
movl $0xa, %esi
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
jmp 0xbe68
nop
// File: /workspace/github_cpp_makefile_star2_O1/Davidc2525[P]Leaf/parser/Parser.cpp
// Function: Parser::TryCatchStatement(LEAF::AST::NODEU*&)
void Parser::TryCatchStatement(ASTU&stat) {
		stat = block_try();
		Expect(22 /* "try" */);
		StatementBLock(stat);
		PartCatchStatement(stat);
		while (la->kind == 23 /* "catch" */) {
			PartCatchStatement(stat);
		}
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq %rdi, %r14
callq 0x8fb3
movq %rax, (%rbx)
movq %r14, %rdi
movl $0x16, %esi
callq 0xbe68
movq %r14, %rdi
movq %rbx, %rsi
callq 0xd29c
movq %r14, %rdi
movq %rbx, %rsi
callq 0xda10
movq 0x30(%r14), %rax
cmpl $0x17, (%rax)
je 0xd336
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_cpp_makefile_star2_O1/Davidc2525[P]Leaf/parser/Parser.cpp
// Function: Parser::VarDcl(Parser::MetaData*)
void Parser::VarDcl(MetaData * md) {
		if (la->kind == _t_pointer) {
			Get();
			VarDcl(md);
			cout << " puntero a";
			puntero(last(md->type));
			
		} else if (StartOf(6)) {
			VarDirectDcl(md);
		} else SynErr(58);
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %r14
movq %rdi, %rbx
movq 0x30(%rdi), %rax
movslq (%rax), %rax
cmpq $0x1, %rax
jne 0xd3b2
movq %rbx, %rdi
callq 0xbde8
movq %rbx, %rdi
movq %r14, %rsi
callq 0xd352
movq 0x18c55(%rip), %rdi     # 0x25fd8
leaq 0xc937(%rip), %rsi      # 0x19cc1
movl $0xa, %edx
callq 0x5300
movq 0x8(%r14), %rsi
movq %rbx, %rdi
callq 0xec82
movq %rbx, %rdi
movq %rax, %rsi
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0xee70
leaq 0xc5a7(%rip), %rcx      # 0x19960
cmpb $0x1, 0x138(%rax,%rcx)
jne 0xd3d5
movq %rbx, %rdi
movq %r14, %rsi
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0xdc52
movq %rbx, %rdi
movl $0x3a, %esi
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0xba44
nop
// File: /workspace/github_cpp_makefile_star2_O1/Davidc2525[P]Leaf/parser/Parser.cpp
// Function: Parser::FuncDcl(Parser::MetaData*)
void Parser::FuncDcl(MetaData * fd) {
		if (la->kind == _t_pointer) {
			Get();
			FuncDcl(fd);
			cout << "; puntero a"; 
			puntero(last(fd->type));
		} else if (StartOf(8)) {
			FuncDirectDcl(fd);
		} else SynErr(61);
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %r14
movq %rdi, %rbx
movq 0x30(%rdi), %rax
movslq (%rax), %rax
cmpq $0x1, %rax
jne 0xd9d8
movq %rbx, %rdi
callq 0xbde8
movq %rbx, %rdi
movq %r14, %rsi
callq 0xd978
movq 0x1862f(%rip), %rdi     # 0x25fd8
leaq 0xc310(%rip), %rsi      # 0x19cc0
movl $0xb, %edx
callq 0x5300
movq 0x8(%r14), %rsi
movq %rbx, %rdi
callq 0xec82
movq %rbx, %rdi
movq %rax, %rsi
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0xee70
leaq 0xbf81(%rip), %rcx      # 0x19960
cmpb $0x1, 0x1a0(%rax,%rcx)
jne 0xd9fb
movq %rbx, %rdi
movq %r14, %rsi
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0xdf88
movq %rbx, %rdi
movl $0x3d, %esi
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0xba44
nop
// File: /workspace/github_cpp_makefile_star2_O1/Davidc2525[P]Leaf/parser/Parser.cpp
// Function: Parser::PartCatchStatement(LEAF::AST::NODEU*&)
void Parser::PartCatchStatement(ASTU&_try_) {
		ASTU catch_ast; ASTU ex_var; 
		Expect(23 /* "catch" */);
		catch_ast = block_catch(); 
		VarDeclDefCatch(ex_var);
		catch_set_ex_var(catch_ast,ex_var); 
		StatementBLock(catch_ast);
		try_add_catch(_try_,catch_ast); 
}

// Assembly:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x10, %rsp
movq %rsi, %rbx
movq %rdi, %r14
movl $0x17, %esi
callq 0xbe68
callq 0x9016
movq %rax, %r15
leaq 0x8(%rsp), %r12
movq %rax, (%r12)
movq %rsp, %r13
movq %r14, %rdi
movq %r13, %rsi
callq 0xda7c
movq (%r13), %rsi
movq %r15, %rdi
callq 0x905b
movq %r14, %rdi
movq %r12, %rsi
callq 0xd29c
movq (%rbx), %rdi
movq %r15, %rsi
addq $0x10, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
jmp 0x8ff4
nop
// File: /workspace/github_cpp_makefile_star2_O1/Davidc2525[P]Leaf/parser/Parser.cpp
// Function: Parser::VarDeclDefCatch(LEAF::AST::NODEU*&)
void Parser::VarDeclDefCatch(ASTU&s) {
		int c_declaraciones = 0;
		//MetaData ** declaraciones = (MetaData**)malloc(sizeof(MetaData*)*100);
		string * Tipe = new string(""); 
		MetaData * md = new MetaData();
		VarDcl(md);
		Expect(24 /* ":" */);
		Expect(_name);
		Tipe = new string(""); LexString(Tipe);
		
		cout << " " << *Tipe <<" type kind: "<<symbol_table::find(Tipe)->type->kind<<endl<<endl; 
		
		Struct * tmp = last(md->type);
		*tmp = *symbol_table::find(Tipe)->type;	
		
		Obj * o = symbol_table::insert(Obj::Var,md->tmpName,md->type);
		
		ASTU tmp_ident = ident(md->tmpName);
		set_obj(tmp_ident,o);
		s = tmp_ident;
		dump(md->type,0);				
		
}

// Assembly:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
movq %rsi, %r14
movq %rdi, %rbx
movl $0x20, %edi
callq 0x5290
leaq 0x10(%rax), %rcx
movq %rcx, (%rax)
movq $0x0, 0x8(%rax)
movb $0x0, 0x10(%rax)
movl $0x20, %edi
callq 0x5290
movq %rax, %r15
movq %rax, %rdi
callq 0xeb92
movq %rbx, %rdi
movq %r15, %rsi
callq 0xd352
movq %rbx, %rdi
movl $0x18, %esi
callq 0xbe68
movq %rbx, %rdi
movl $0x4, %esi
callq 0xbe68
movl $0x20, %edi
callq 0x5290
movq %rax, %r12
addq $0x10, %rax
movq %rax, (%r12)
movq $0x0, 0x8(%r12)
movb $0x0, 0x10(%r12)
movq %rbx, %rdi
movq %r12, %rsi
callq 0xec0a
movq 0x184c0(%rip), %r13     # 0x25fd8
leaq 0xc0d2(%rip), %rsi      # 0x19bf1
movl $0x1, %edx
movq %r13, %rdi
callq 0x5300
movq (%r12), %rsi
movq 0x8(%r12), %rdx
movq %r13, %rdi
callq 0x5300
movq %rax, %r13
leaq 0xc0ac(%rip), %rsi      # 0x19bf3
movl $0xc, %edx
movq %rax, %rdi
callq 0x5300
movq %r12, %rdi
callq 0x110a0
movq 0x18(%rax), %rax
movl 0x10(%rax), %esi
movq %r13, %rdi
callq 0x5460
movq %rax, %r13
movq (%rax), %rax
movq -0x18(%rax), %rdi
addq %r13, %rdi
movl $0xa, %esi
callq 0x5260
movsbl %al, %esi
movq %r13, %rdi
callq 0x5050
movq %rax, %rdi
callq 0x51a0
movq %rax, %r13
movq (%rax), %rax
movq -0x18(%rax), %rdi
addq %r13, %rdi
movl $0xa, %esi
callq 0x5260
movsbl %al, %esi
movq %r13, %rdi
callq 0x5050
movq %rax, %rdi
callq 0x51a0
movq 0x8(%r15), %rsi
movq %rbx, %rdi
callq 0xec82
movq %rax, %r13
movq %r12, %rdi
callq 0x110a0
movq 0x18(%rax), %rax
movups (%rax), %xmm0
movups 0x10(%rax), %xmm1
movups 0x20(%rax), %xmm2
movups %xmm0, (%r13)
movups %xmm1, 0x10(%r13)
movups %xmm2, 0x20(%r13)
movq 0x8(%r15), %rdx
movq 0x10(%r15), %rsi
movl $0x1, %edi
callq 0x10fda
movq %rax, %r12
movq 0x10(%r15), %rdi
callq 0x8e19
movq %rax, %r13
movq %rax, %rdi
movq %r12, %rsi
callq 0x8d7b
movq %r13, (%r14)
movq 0x8(%r15), %rsi
movq %rbx, %rdi
xorl %edx, %edx
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
jmp 0xeaf0
movq %rax, %rbx
movl $0x20, %esi
movq %r15, %rdi
callq 0x52a0
movq %rbx, %rdi
callq 0x5470
// File: /workspace/github_cpp_makefile_star2_O1/Davidc2525[P]Leaf/parser/Parser.cpp
// Function: Parser::VarDirectDcl(Parser::MetaData*)
void Parser::VarDirectDcl(MetaData * md) {
		string * Name = new string("");; 
		if (la->kind == _name) {
			Get();
			LexString(Name);
			cout <<endl<< "; " << *Name << " es"; 
			md->tmpName=Name;
			
		} else if (la->kind == 15 /* "(" */) {
			Get();
			VarDcl(md);
			Expect(16 /* ")" */);
		} else if (StartOf(7)) {
			cout <<endl<< "; noname " << " es";  
		} else SynErr(59);
		while (la->kind == 15 /* "(" */ || la->kind == 26 /* "[" */) {
			VarSuffix(md);
		}
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq %rdi, %r14
movl $0x20, %edi
callq 0x5290
movq %rax, %r15
addq $0x10, %rax
movq %rax, (%r15)
movq $0x0, 0x8(%r15)
movb $0x0, 0x10(%r15)
movq 0x30(%r14), %rax
movslq (%rax), %rax
cmpq $0xf, %rax
je 0xdd20
cmpl $0x4, %eax
jne 0xdd45
movq %r14, %rdi
callq 0xbde8
movq %r14, %rdi
movq %r15, %rsi
callq 0xec0a
movq 0x18323(%rip), %r12     # 0x25fd8
movq (%r12), %rax
movq -0x18(%rax), %rdi
addq %r12, %rdi
movl $0xa, %esi
callq 0x5260
movsbl %al, %esi
movq %r12, %rdi
callq 0x5050
movq %rax, %rdi
callq 0x51a0
movq %rax, %r12
leaq 0xbfa5(%rip), %rsi      # 0x19c8c
movl $0x2, %edx
movq %rax, %rdi
callq 0x5300
movq (%r15), %rsi
movq 0x8(%r15), %rdx
movq %r12, %rdi
callq 0x5300
leaq 0xbf85(%rip), %rsi      # 0x19c8f
movl $0x3, %edx
movq %rax, %rdi
callq 0x5300
movq %r15, 0x10(%rbx)
jmp 0xddcb
movq %r14, %rdi
callq 0xbde8
movq %r14, %rdi
movq %rbx, %rsi
callq 0xd352
movq %r14, %rdi
movl $0x10, %esi
callq 0xbe68
jmp 0xddcb
leaq 0xbc14(%rip), %rcx      # 0x19960
cmpb $0x1, 0x16c(%rax,%rcx)
jne 0xddb1
movq 0x1827b(%rip), %r15     # 0x25fd8
movq (%r15), %rax
movq -0x18(%rax), %rdi
addq %r15, %rdi
movl $0xa, %esi
callq 0x5260
movsbl %al, %esi
movq %r15, %rdi
callq 0x5050
movq %rax, %rdi
callq 0x51a0
movq %rax, %r15
leaq 0xbf05(%rip), %rsi      # 0x19c93
movl $0x9, %edx
movq %rax, %rdi
callq 0x5300
leaq 0xbeed(%rip), %rsi      # 0x19c8f
movl $0x3, %edx
movq %r15, %rdi
callq 0x5300
jmp 0xddcb
movq %r14, %rdi
movl $0x3b, %esi
callq 0xba44
jmp 0xddcb
movq %r14, %rdi
movq %rbx, %rsi
callq 0xdde8
movq 0x30(%r14), %rax
movl (%rax), %eax
cmpl $0x1a, %eax
je 0xddc0
cmpl $0xf, %eax
je 0xddc0
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
nop
// File: /workspace/github_cpp_makefile_star2_O1/Davidc2525[P]Leaf/parser/Parser.cpp
// Function: Parser::VarSuffix(Parser::MetaData*)
void Parser::VarSuffix(MetaData * md) {
		if (la->kind == 26 /* "[" */) {
			string * buff = new string(""); 
			Get();
			cout << " array ["; 
			if (la->kind == _number) {
				Get();
				LexString(buff);
				cout << atoi(buff->c_str()); 
			}
			Expect(27 /* "]" */);
			_array(last(md->type)); cout << "] de"; 
		} else if (la->kind == 15 /* "(" */) {
			Get();
			if (StartOf(4)) {
				VarDecl();
				while (la->kind == 25 /* "," */) {
					Get();
					VarDecl();
				}
			}
			Expect(16 /* ")" */);
			funcion(last(md->type)); md->isF = true; ;cout << " ;function q retorna"; 
		} else SynErr(60);
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
subq $0x10, %rsp
movq %rsi, %r14
movq %rdi, %rbx
movq 0x30(%rdi), %rax
movl (%rax), %eax
cmpl $0xf, %eax
je 0xdec0
cmpl $0x1a, %eax
jne 0xdf72
movl $0x20, %edi
callq 0x5290
movq %rax, %r15
addq $0x10, %rax
movq %rax, (%r15)
movq $0x0, 0x8(%r15)
movb $0x0, 0x10(%r15)
movq %rbx, %rdi
callq 0xbde8
movq 0x18199(%rip), %rdi     # 0x25fd8
leaq 0xbe57(%rip), %rsi      # 0x19c9d
movl $0x8, %edx
callq 0x5300
movq 0x30(%rbx), %rax
cmpl $0x3, (%rax)
jne 0xde82
movq %rbx, %rdi
callq 0xbde8
movq %rbx, %rdi
movq %r15, %rsi
callq 0xec0a
movq (%r15), %rdi
callq 0x5410
movq 0x1815d(%rip), %rdi     # 0x25fd8
movl %eax, %esi
callq 0x5460
movq %rbx, %rdi
movl $0x1b, %esi
callq 0xbe68
movq 0x8(%r14), %rsi
movq %rbx, %rdi
callq 0xec82
movq %rbx, %rdi
movq %rax, %rsi
xorl %edx, %edx
callq 0xefc8
movq 0x18129(%rip), %rdi     # 0x25fd8
leaq 0xbdf0(%rip), %rsi      # 0x19ca6
movl $0x4, %edx
jmp 0xdf64
movq %rbx, %rdi
callq 0xbde8
movq 0x30(%rbx), %rax
movslq (%rax), %rax
leaq 0xba8a(%rip), %rcx      # 0x19960
cmpb $0x1, 0xd0(%rax,%rcx)
jne 0xdf29
callq 0x8ccc
leaq 0x8(%rsp), %rsi
movq %rax, (%rsi)
movq %rbx, %rdi
callq 0xc4aa
movq 0x30(%rbx), %rax
cmpl $0x19, (%rax)
jne 0xdf29
leaq 0x8(%rsp), %r15
movq %rbx, %rdi
callq 0xbde8
callq 0x8ccc
movq %rax, 0x8(%rsp)
movq %rbx, %rdi
movq %r15, %rsi
callq 0xc4aa
movq 0x30(%rbx), %rax
cmpl $0x19, (%rax)
je 0xdf03
movq %rbx, %rdi
movl $0x10, %esi
callq 0xbe68
movq 0x8(%r14), %rsi
movq %rbx, %rdi
callq 0xec82
movq %rbx, %rdi
movq %rax, %rsi
callq 0xede6
movb $0x1, (%r14)
movq 0x18080(%rip), %rdi     # 0x25fd8
leaq 0xbd4c(%rip), %rsi      # 0x19cab
movl $0x14, %edx
addq $0x10, %rsp
popq %rbx
popq %r14
popq %r15
jmp 0x5300
movq %rbx, %rdi
movl $0x3c, %esi
addq $0x10, %rsp
popq %rbx
popq %r14
popq %r15
jmp 0xba44