LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_cpp_makefile_star2_O1/Silica[P]PSL/./PSL/code.h
// Function: PSL::variable::Variable::CALL::Execute(PSL::variable::Variable::Environment&)
CLONE(CALL)
	EXEC
	{
		variable r = env.pop();
		variable v = env.pop();
		env.push(r);
		#ifdef PSL_OPTIMIZE_TAILCALL
		MNEMONIC::mnemonic n = env.getNext();
		if (isMethod(v.x))
		{
			rsv z = v[1];
/*		���\�b�h��this�𑩔����Ȃ��ׁA���\�b�h�Ăяo���Ŗ����œK������������
		�X�R�[�v�Ɋ����t�����ꂽ���[�J���I�u�W�F�N�g(this)���j�������Ȃ��烁�\�b�h���Ăяo�����Ă��܂�
		���\�b�h�X�R�[�v��this�𑩔������̂Ŏ��̃X�R�[�v�������Ă��܂��Ζ����Ȃ�
		���ׂ̈����ňꎞ�I��this���ێ����Ă��� */
			if (n == MNEMONIC::RETURN)	env.Return();
			else if (n == MNEMONIC::END)env.endScope();
			v.prepare(env);
		}
		else
		#endif
		{
			#ifdef PSL_OPTIMIZE_TAILCALL
			if (n == MNEMONIC::RETURN)	env.Return();
			else if (n == MNEMONIC::END)env.endScope();
			#endif
			v.prepare(env);
		}
		return RC::CALL;
	}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x10, %rsp
movq %rsi, %r15
leaq 0x8(%rsp), %rbx
movq %rbx, %rdi
callq 0xf800
movq (%rbx), %rbx
incl 0x8(%rbx)
movq %rbx, %rdi
callq 0xfc04
leaq 0x8(%rsp), %rdi
movq %r15, %rsi
callq 0xf800
movq 0x8(%rsp), %r14
incl 0x8(%r14)
movq %r14, %rdi
callq 0xfc04
incl 0x8(%rbx)
leaq 0x8(%rsp), %rsi
movq %rbx, (%rsi)
leaq 0x8(%r15), %rdi
callq 0xfc38
movq 0x8(%rsp), %rdi
callq 0xfc04
movq 0x20(%r15), %rcx
movq 0x18(%rcx), %rax
movq 0x20(%rcx), %rcx
movl $0xff, %ebp
cmpq %rcx, 0x10(%rax)
jbe 0x225d2
movq (%rax), %rax
movq (%rax,%rcx,8), %rdi
movq (%rdi), %rax
callq *0x28(%rax)
movl %eax, %ebp
movq (%r14), %rdi
movq (%rdi), %rax
callq *0x10(%rax)
addl $-0xa, %eax
cmpl $0x2, %eax
ja 0x22625
movq (%r14), %rdi
movq (%rdi), %rax
movl $0x1, %esi
callq *0x120(%rax)
movq %rax, %r12
testq %rax, %rax
cmoveq %r14, %r12
addl $0x2, 0x8(%r12)
movq %r12, %rdi
callq 0xfc04
cmpl $0xff, %ebp
je 0x22663
cmpl $0x16, %ebp
jne 0x22674
movq 0x20(%r15), %rdi
movq (%rdi), %rax
callq *0x20(%rax)
jmp 0x22670
cmpl $0xff, %ebp
je 0x2263e
cmpl $0x16, %ebp
jne 0x2264f
movq 0x20(%r15), %rdi
movq (%rdi), %rax
callq *0x20(%rax)
jmp 0x2264b
movq 0x20(%r15), %rdi
movq (%rdi), %rax
movq %r15, %rsi
callq *0x40(%rax)
movq %rax, 0x20(%r15)
movq (%r14), %rdi
movq (%rdi), %rax
movq %r15, %rsi
movq %r14, %rdx
callq *0x160(%rax)
jmp 0x2268e
movq 0x20(%r15), %rdi
movq (%rdi), %rax
movq %r15, %rsi
callq *0x40(%rax)
movq %rax, 0x20(%r15)
movq (%r14), %rdi
movq (%rdi), %rax
movq %r15, %rsi
movq %r14, %rdx
callq *0x160(%rax)
movq %r12, %rdi
callq 0xfc04
movq %r14, %rdi
callq 0xfc04
movq %rbx, %rdi
callq 0xfc04
movl $0x1, %eax
addq $0x10, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
jmp 0x22702
jmp 0x22702
jmp 0x226e5
movq %rax, %r15
movq %r12, %rdi
callq 0xfc04
jmp 0x226e8
jmp 0x22702
jmp 0x22702
jmp 0x22702
jmp 0x22702
movq %rax, %r15
movq 0x8(%rsp), %rdi
callq 0xfc04
jmp 0x226e8
jmp 0x22702
jmp 0x22702
movq %rax, %r15
jmp 0x226f0
jmp 0x22702
movq %rax, %r15
movq %r14, %rdi
callq 0xfc04
movq %rbx, %rdi
callq 0xfc04
movq %r15, %rdi
callq 0xc290
jmp 0x22702
movq %rax, %rdi
callq 0xde83
// File: /workspace/github_cpp_makefile_star2_O1/Silica[P]PSL/./PSL/code.h
// Function: PSL::variable::Variable::INC::Execute(PSL::variable::Variable::Environment&)
CLONE(INC)
	EXEC
	{
		variable v = env.pop();
		env.push(v.clone());
		v += 1;
		return RC::NONE;
	}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
subq $0x10, %rsp
movq %rsi, %r14
leaq 0x8(%rsp), %rbx
movq %rbx, %rdi
callq 0xf800
movq (%rbx), %rbx
incl 0x8(%rbx)
movq %rbx, %rdi
callq 0xfc04
movq %rbx, %rdi
callq 0xf88a
movq %rax, %r15
incl 0x8(%rax)
leaq 0x8(%rsp), %rsi
movq %rax, (%rsi)
addq $0x8, %r14
movq %r14, %rdi
callq 0xfc38
movq 0x8(%rsp), %rdi
callq 0xfc04
movq %r15, %rdi
callq 0xfc04
leaq 0x8(%rsp), %rdi
movl $0x1, %esi
callq 0xca22
movq 0x8(%rsp), %rsi
movq (%rbx), %rdi
movq (%rdi), %rax
callq *0x48(%rax)
movq (%rbx), %rdi
movq (%rdi), %rax
movq %rbx, %rsi
callq *0x158(%rax)
movq 0x8(%rsp), %rdi
callq 0xfc04
movq %rbx, %rdi
callq 0xfc04
xorl %eax, %eax
addq $0x10, %rsp
popq %rbx
popq %r14
popq %r15
retq
jmp 0x2284a
jmp 0x2284a
jmp 0x22824
jmp 0x2284a
jmp 0x2284a
movq %rax, %r14
movq 0x8(%rsp), %rdi
callq 0xfc04
movq %r15, %rdi
callq 0xfc04
jmp 0x22838
jmp 0x2284a
jmp 0x2284a
movq %rax, %r14
jmp 0x22838
jmp 0x2284a
movq %rax, %r14
movq 0x8(%rsp), %rdi
callq 0xfc04
movq %rbx, %rdi
callq 0xfc04
movq %r14, %rdi
callq 0xc290
jmp 0x2284a
movq %rax, %rdi
callq 0xde83
// File: /workspace/github_cpp_makefile_star2_O1/Silica[P]PSL/./PSL/code.h
// Function: PSL::variable::Variable::INDEX::Execute(PSL::variable::Variable::Environment&)
CLONE(INDEX)
	EXEC
	{
		variable i = env.pop();
		variable v = env.pop();
		env.push(v[i]);
		return RC::NONE;
	}

// Assembly:
pushq %r14
pushq %rbx
subq $0x28, %rsp
movq %rsi, %rbx
leaq 0x10(%rsp), %r14
movq %r14, %rdi
callq 0xf800
movq (%r14), %rdi
incl 0x8(%rdi)
movq %rdi, 0x20(%rsp)
callq 0xfc04
leaq 0x8(%rsp), %rdi
movq %rbx, %rsi
callq 0xf800
movq 0x8(%rsp), %rdi
incl 0x8(%rdi)
movq %rdi, 0x10(%rsp)
callq 0xfc04
leaq 0x18(%rsp), %rdi
leaq 0x10(%rsp), %rsi
leaq 0x20(%rsp), %rdx
callq 0x185b6
movq 0x18(%rsp), %rax
incl 0x8(%rax)
leaq 0x8(%rsp), %rsi
movq %rax, (%rsi)
addq $0x8, %rbx
movq %rbx, %rdi
callq 0xfc38
movq 0x8(%rsp), %rdi
callq 0xfc04
movq 0x18(%rsp), %rdi
callq 0xfc04
movq 0x10(%rsp), %rdi
callq 0xfc04
movq 0x20(%rsp), %rdi
callq 0xfc04
xorl %eax, %eax
addq $0x28, %rsp
popq %rbx
popq %r14
retq
jmp 0x22a97
jmp 0x22a97
jmp 0x22a97
jmp 0x22a97
movq %rax, %rbx
movq 0x8(%rsp), %rdi
callq 0xfc04
movq 0x18(%rsp), %rdi
callq 0xfc04
jmp 0x22a70
jmp 0x22a97
jmp 0x22a97
movq %rax, %rbx
movq 0x10(%rsp), %rdi
callq 0xfc04
jmp 0x22a83
jmp 0x22a97
jmp 0x22a97
movq %rax, %rbx
movq 0x20(%rsp), %rdi
callq 0xfc04
movq %rbx, %rdi
callq 0xc290
jmp 0x22a97
movq %rax, %rdi
callq 0xde83
nop
// File: /workspace/github_cpp_makefile_star2_O1/Silica[P]PSL/./PSL/code.h
// Function: PSL::variable::Variable::MEMBER::Execute(PSL::variable::Variable::Environment&)
CLONE(MEMBER(name))
	EXEC
	{
		variable v = env.pop();
		#ifdef PSL_MEMBER_REGISTER
		env.reg = v;
		#endif
		#ifdef PSL_WARNING_UNDEFINED_MEMBER
		if (!v.exist(name))
			env.warning(4, name);
		#endif
		env.push(v[name]);
		return RC::NONE;
	}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
subq $0x10, %rsp
movq %rsi, %r15
movq %rdi, %r14
leaq 0x8(%rsp), %rbx
movq %rbx, %rdi
callq 0xf800
movq (%rbx), %rbx
incl 0x8(%rbx)
movq %rbx, %rdi
callq 0xfc04
addq $0x8, %r14
movq (%rbx), %rdi
movq (%rdi), %rax
movq %r14, %rsi
callq *0x128(%rax)
movq %rax, %r14
testq %rax, %rax
cmoveq %rbx, %r14
addl $0x2, 0x8(%r14)
leaq 0x8(%rsp), %rsi
movq %r14, (%rsi)
addq $0x8, %r15
movq %r15, %rdi
callq 0xfc38
movq 0x8(%rsp), %rdi
callq 0xfc04
movq %r14, %rdi
callq 0xfc04
movq %rbx, %rdi
callq 0xfc04
xorl %eax, %eax
addq $0x10, %rsp
popq %rbx
popq %r14
popq %r15
retq
jmp 0x22bc0
jmp 0x22bc0
jmp 0x22bc0
movq %rax, %r15
movq 0x8(%rsp), %rdi
callq 0xfc04
movq %r14, %rdi
callq 0xfc04
jmp 0x22bae
jmp 0x22bc0
jmp 0x22bc0
movq %rax, %r15
movq %rbx, %rdi
callq 0xfc04
movq %r15, %rdi
callq 0xc290
jmp 0x22bc0
movq %rax, %rdi
callq 0xde83
// File: /workspace/github_cpp_makefile_star2_O1/Silica[P]PSL/./PSL/memory.h
// Function: PSL::variable::VMemoryPool::GarbageCollection()
void GarbageCollection()
	{
		#ifdef PSL_SHARED_GLOBAL
		StaticObject::global().get()->mark();
		#endif
		Mark();
		#ifdef PSL_USE_DESTRUCTOR
		Destructor();
		#endif
		Delete();
		UnMark();
		ReleaseEmpty();
	}

// Assembly:
pushq %rbx
movq %rdi, %rbx
callq 0xd8a6
movq (%rax), %rax
movl 0x8(%rax), %ecx
btl $0x1e, %ecx
jb 0x22eb1
orl $0x40000000, %ecx       # imm = 0x40000000
movl %ecx, 0x8(%rax)
movq (%rax), %rdi
movq (%rdi), %rax
callq *0x28(%rax)
movq %rbx, %rdi
callq 0x22efc
movq %rbx, %rdi
callq 0x22fe0
movq %rbx, %rdi
callq 0x23028
leaq 0x8(%rbx), %rax
xorl %ecx, %ecx
cmpl $0x0, (%rax,%rcx)
je 0x22eda
andb $0x3f, 0xb(%rax,%rcx)
addq $0x10, %rcx
cmpq $0x1000, %rcx           # imm = 0x1000
jne 0x22ecf
movq 0x1000(%rax), %rax
testq %rax, %rax
jne 0x22ecd
movq %rbx, %rdi
popq %rbx
jmp 0x23070
// File: /workspace/github_cpp_makefile_star2_O1/Silica[P]PSL/./PSL/memory.h
// Function: PSL::variable::VMemoryPool::ReleaseEmpty()
void ReleaseEmpty()
	{
		for (pool **pl = &p.next; *pl != NULL;)
		{
			if ((*pl)->empty())
			{
				pool *n = (*pl)->next;
				(*pl)->next = NULL;
				delete *pl;
				*pl = n;
				continue;
			}
			pl = &(*pl)->next;
		}
		DATA **ptr = &current;
		POOLOOP;else{
			*ptr = pl->ptr+i;
			ptr = &pl->ptr[i].next;
		}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rdi, %rbx
movq 0x1008(%rdi), %rcx
testq %rcx, %rcx
je 0x23117
leaq 0x1008(%rbx), %r15
movq %rcx, %rax
cmpl $0x0, (%rax)
jne 0x230fe
leaq 0x10(%rax), %rcx
xorl %esi, %esi
movq %rsi, %rdx
cmpq $0xff, %rsi
je 0x230b9
cmpl $0x0, (%rcx)
leaq 0x10(%rcx), %rcx
leaq 0x1(%rdx), %rsi
je 0x230a0
cmpq $0xff, %rdx
jb 0x230fe
movq 0x1000(%rax), %r12
movq $0x0, 0x1000(%rax)
movq (%r15), %r14
testq %r14, %r14
je 0x230f1
movq %r14, %rdi
callq 0xdf96
movl $0x1008, %esi           # imm = 0x1008
movq %r14, %rdi
callq 0xc1d0
movq %r12, (%r15)
movq %r12, %rax
testq %r12, %r12
jne 0x23095
jmp 0x23117
movq 0x1000(%rax), %rcx
addq $0x1000, %rax           # imm = 0x1000
movq %rax, %r15
testq %rcx, %rcx
jne 0x23092
leaq 0x8(%rbx), %rax
movl $0x100, %ecx            # imm = 0x100
movq %rax, %rdx
cmpl $0x0, (%rdx)
jne 0x2312f
movq %rdx, (%rbx)
leaq 0x8(%rdx), %rbx
addq $0x10, %rdx
decq %rcx
jne 0x23123
movq 0x1000(%rax), %rax
testq %rax, %rax
jne 0x2311b
movq $0x0, (%rbx)
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
nop
// File: /workspace/github_cpp_makefile_star2_O1/Silica[P]PSL/./PSL/memory.h
// Function: PSL::variable::VMemoryPool::searchcount(PSL::variable::Variable*, int&)
void searchcount(Variable *v, int &c)
	{
		POOLOOP
		{
			Variable *x = (Variable*)(pl->ptr+i);
			if (v == x)
				continue;
			x->searchcount(v, c);
		}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rdx, %rbx
movq %rsi, %r14
movq %rdi, %r15
addq $0x8, %r15
xorl %r12d, %r12d
cmpl $0x0, (%r15,%r12)
je 0x2318b
leaq (%r15,%r12), %rdi
cmpq %r14, %rdi
je 0x2318b
movq %r14, %rsi
movq %rbx, %rdx
callq 0x11c90
addq $0x10, %r12
cmpq $0x1000, %r12           # imm = 0x1000
jne 0x23170
movq 0x1000(%r15), %r15
testq %r15, %r15
jne 0x2316d
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
// File: /workspace/github_cpp_makefile_star2_O1/Silica[P]PSL/./PSL/PSLlib.h
// Function: PSL::variable::PSLlib::Strlib::Char(PSL::variable&)
static variable Char(variable &v)
		{
			char c = v;
			string s = c;
			variable ch = s;
			return ch;
		}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
movq (%rsi), %rax
movq (%rax), %rdi
movq (%rdi), %rax
callq *0xe8(%rax)
movsbl %al, %esi
movq %rsp, %r14
movq %r14, %rdi
callq 0x23c82
movq %rbx, %rdi
movq %r14, %rsi
callq 0x1b226
movq (%rsp), %rdi
testq %rdi, %rdi
je 0x2326f
callq 0xfbc0
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
movq %rax, %rbx
movq (%rsp), %rdi
testq %rdi, %rdi
je 0x2328b
callq 0xfbc0
movq %rbx, %rdi
callq 0xc290
nop
// File: /workspace/github_cpp_makefile_star2_O1/Silica[P]PSL/./PSL/PSLlib.h
// Function: PSL::variable::PSLlib::Strlib::getChar(PSL::variable&)
static variable getChar(variable &v)
		{
			string s;
			using namespace std;
			int c = getchar();
			s = static_cast<char>(c);
			variable ch = s;
			return ch;
		}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
movq %rsp, %r14
movq $0x0, (%r14)
callq 0xc220
movsbl %al, %esi
movq %r14, %rdi
callq 0x23d82
movq %rsp, %rsi
movq %rbx, %rdi
callq 0x1b226
movq (%rsp), %rdi
testq %rdi, %rdi
je 0x23be0
callq 0xfbc0
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
movq %rax, %rbx
movq (%rsp), %rdi
testq %rdi, %rdi
je 0x23bfc
callq 0xfbc0
movq %rbx, %rdi
callq 0xc290
// File: /workspace/github_cpp_makefile_star2_O1/Silica[P]PSL/./PSL/PSLlib.h
// Function: PSL::variable::PSLlib::Strlib::Gets(PSL::variable&)
static variable Gets(variable &v)
		{
			string s;
			int c;
			using namespace std;
			while ((c = getc(stdin)) != EOF)
			{
				s += static_cast<char>(c);
				if (c == '\n')
					break;
			}
			return s;
		}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
movq %rsp, %r14
movq $0x0, (%r14)
movq 0x1b3c1(%rip), %r15     # 0x3efe0
movq (%r15), %rdi
callq 0xc0a0
cmpl $-0x1, %eax
je 0x23c3f
movl %eax, %ebp
movsbl %bpl, %esi
movq %r14, %rdi
callq 0xc7dc
cmpl $0xa, %ebp
jne 0x23c1f
movq %rsp, %rsi
movq %rbx, %rdi
callq 0x1b226
movq (%rsp), %rdi
testq %rdi, %rdi
je 0x23c58
callq 0xfbc0
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
jmp 0x23c68
movq %rax, %rbx
movq (%rsp), %rdi
testq %rdi, %rdi
je 0x23c79
callq 0xfbc0
movq %rbx, %rdi
callq 0xc290
nop
// File: /workspace/github_cpp_makefile_star2_O1/Silica[P]PSL/./PSL/pstring.h
// Function: PSL::variable::string::substr(unsigned long, unsigned long) const
string substr(size_t i = 0, size_t l = 0) const	/* i����l�������؂��o���������� */
	{
		if (!buf)	return string();
		size_t m = buf->length();
		if (i >= m)	return string();
		if (!l || (i + l > m))	l = m - i;
		SharedBuffer *n = new SharedBuffer(l);
		n->fcopy(buf->buffer()+i, l);
		return n;
	}

// Assembly:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
movq %rdi, %rbx
movq (%rsi), %rax
testq %rax, %rax
je 0x23d5c
movq %rdx, %r14
movq 0x18(%rax), %rdx
movq %rdx, %rax
subq %r14, %rax
jbe 0x23d5c
movq %rsi, %r12
leaq (%rcx,%r14), %rsi
cmpq %rdx, %rsi
movq %rcx, %r13
cmovaq %rax, %r13
testq %rcx, %rcx
cmoveq %rax, %r13
callq 0x1055a
movq %rax, %r15
movl $0x1, (%rax)
leaq 0x1(%r13), %rdi
callq 0xc040
movq %rax, 0x8(%r15)
movq %r13, 0x10(%r15)
movq $0x0, 0x18(%r15)
movq (%r12), %rcx
addq 0x8(%rcx), %r14
movq %rax, %rdi
movq %r14, %rsi
movq %r13, %rdx
callq 0xc150
movq %r13, 0x18(%r15)
jmp 0x23d5f
xorl %r15d, %r15d
movq %r15, (%rbx)
movq %rbx, %rax
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
movq %rax, %rbx
movq %r15, %rdi
callq 0xfbe0
movq %rbx, %rdi
callq 0xc290
// File: /workspace/github_cpp_makefile_star2_O1/Silica[P]PSL/./PSL/pstring.h
// Function: PSL::variable::string::operator=(char)
string &operator=(char c)
	{
		if (!buf)	buf = new SharedBuffer(SPARE);
		else if (buf->shared())
		{
			buf->finalize();
			buf = new SharedBuffer(SPARE);
		}
		buf->buffer()[0] = c;
		buf->setlen(1);
		return *this;
	}

// Assembly:
pushq %rbp
pushq %r14
pushq %rbx
movl %esi, %ebp
movq %rdi, %rbx
movq (%rdi), %rdi
testq %rdi, %rdi
je 0x23db7
cmpl $0x1, (%rdi)
je 0x23de6
callq 0xfbc0
callq 0x1055a
movq %rax, %r14
movl $0x1, (%rax)
movl $0xc, %edi
callq 0xc040
jmp 0x23dcf
callq 0x1055a
movq %rax, %r14
movl $0x1, (%rax)
movl $0xc, %edi
callq 0xc040
movq %rax, 0x8(%r14)
movq $0xb, 0x10(%r14)
movq $0x0, 0x18(%r14)
movq %r14, (%rbx)
movq (%rbx), %rax
movq 0x8(%rax), %rax
movb %bpl, (%rax)
movq (%rbx), %rax
movq $0x1, 0x18(%rax)
movq %rbx, %rax
popq %rbx
popq %r14
popq %rbp
retq
jmp 0x23e05
movq %rax, %rbx
movq %r14, %rdi
callq 0xfbe0
movq %rbx, %rdi
callq 0xc290
// File: /workspace/github_cpp_makefile_star2_O1/Silica[P]PSL/./PSL/PSLlib.h
// Function: PSL::variable::PSLlib::Array::Push(PSL::variable&, PSL::variable&)
static variable Push(variable &this_v, variable &v)
		{
			if (!this_v)
			{
				v[0].push(v[1]);
				return v[0].length();
			}
			else
			{
				this_v.push(v);
				return this_v.length();
			}
		}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rdx, %r14
movq %rsi, %r15
movq %rdi, %rbx
movq (%rsi), %rax
movq (%rax), %rdi
movq (%rdi), %rax
callq *0xe0(%rax)
testb %al, %al
je 0x23f07
movq (%r15), %rax
movq (%r14), %rsi
movq (%rax), %rdi
movq (%rdi), %rax
callq *0x130(%rax)
movq (%r15), %rax
movq (%rax), %rdi
movq (%rdi), %rax
callq *0x108(%rax)
movq %rbx, %rdi
movq %rax, %rsi
callq 0x15d32
jmp 0x23fa5
movq (%r14), %r12
movq (%r12), %rdi
movq (%rdi), %rax
xorl %esi, %esi
callq *0x120(%rax)
movq %rax, %r15
testq %rax, %rax
cmoveq %r12, %r15
incl 0x8(%r15)
movq (%r14), %r12
movq (%r12), %rdi
movq (%rdi), %rax
movl $0x1, %esi
callq *0x120(%rax)
testq %rax, %rax
cmovneq %rax, %r12
incl 0x8(%r12)
movq (%r15), %rdi
movq (%rdi), %rax
movq %r12, %rsi
callq *0x130(%rax)
movq %r12, %rdi
callq 0xfc04
movq %r15, %rdi
callq 0xfc04
movq (%r14), %r15
movq (%r15), %rdi
movq (%rdi), %rax
xorl %esi, %esi
callq *0x120(%rax)
movq %rax, %r14
testq %rax, %rax
cmoveq %r15, %r14
incl 0x8(%r14)
movq (%r14), %rdi
movq (%rdi), %rax
callq *0x108(%rax)
movq %rbx, %rdi
movq %rax, %rsi
callq 0x15d32
movq %r14, %rdi
callq 0xfc04
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
jmp 0x23feb
jmp 0x23feb
jmp 0x23feb
movq %rax, %rbx
movq %r12, %rdi
callq 0xfc04
jmp 0x23fcc
jmp 0x23feb
movq %rax, %rbx
movq %r15, %rdi
callq 0xfc04
jmp 0x23fe3
jmp 0x23feb
movq %rax, %rbx
movq %r14, %rdi
callq 0xfc04
movq %rbx, %rdi
callq 0xc290
movq %rax, %rdi
callq 0xde83
nop
// File: /workspace/github_cpp_makefile_star2_O1/Silica[P]PSL/./PSL/PSLlib.h
// Function: PSL::variable::PSLlib::Array::Foreach(PSL::variable&, PSL::variable&)
static variable Foreach(variable &this_v, variable &v)
		{
			size_t size;
			if (!this_v)
			{
				variable array = v[0];
				size = array.length();
				for (size_t i = 0; i < size; ++i)
					v[1](array[i]);
			}
			else
			{
				size = this_v.length();
				for (size_t i = 0; i < size; ++i)
					v(this_v[i]);
			}
			return size;
		}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x28, %rsp
movq %rdx, %r14
movq %rsi, %rbx
movq %rdi, %r12
movq (%rsi), %rax
movq (%rax), %rdi
movq (%rdi), %rax
callq *0xe0(%rax)
testb %al, %al
je 0x2409a
movq (%rbx), %rax
movq (%rax), %rdi
movq (%rdi), %rax
callq *0x108(%rax)
movq %rax, %r15
testq %rax, %rax
je 0x24168
movq %r12, 0x8(%rsp)
xorl %r12d, %r12d
movq %rsp, %rbp
movq (%rbx), %r13
movq (%r13), %rdi
movq (%rdi), %rax
movq %r12, %rsi
callq *0x120(%rax)
testq %rax, %rax
cmoveq %r13, %rax
incl 0x8(%rax)
movq %rax, (%rsp)
leaq 0x18(%rsp), %rdi
movq %r14, %rsi
movq %rbp, %rdx
callq 0x1844a
movq 0x18(%rsp), %rdi
callq 0xfc04
movq (%rsp), %rdi
callq 0xfc04
incq %r12
cmpq %r12, %r15
jne 0x24044
movq 0x8(%rsp), %r12
jmp 0x24168
movq %r12, 0x8(%rsp)
movq (%r14), %rbx
movq (%rbx), %rdi
movq (%rdi), %rax
xorl %esi, %esi
callq *0x120(%rax)
movq %rax, %r12
testq %rax, %rax
cmoveq %rbx, %r12
incl 0x8(%r12)
movq (%r12), %rdi
movq (%rdi), %rax
callq *0x108(%rax)
movq %rax, %r15
testq %rax, %rax
je 0x2415b
xorl %r13d, %r13d
leaq 0x10(%rsp), %rbp
movq (%r14), %rbx
movq (%rbx), %rdi
movq (%rdi), %rax
movl $0x1, %esi
callq *0x120(%rax)
testq %rax, %rax
je 0x240fc
movq %rax, %rbx
incl 0x8(%rbx)
movq %rbx, (%rsp)
movq (%r12), %rdi
movq (%rdi), %rax
movq %r13, %rsi
callq *0x120(%rax)
movq %r12, %rcx
testq %rax, %rax
je 0x2411e
movq %rax, %rcx
incl 0x8(%rcx)
movq %rcx, 0x10(%rsp)
leaq 0x20(%rsp), %rdi
movq %rsp, %rsi
movq %rbp, %rdx
callq 0x1844a
movq 0x20(%rsp), %rdi
callq 0xfc04
movq 0x10(%rsp), %rdi
callq 0xfc04
movq (%rsp), %rdi
callq 0xfc04
incq %r13
cmpq %r13, %r15
jne 0x240e0
movq %r12, %rdi
callq 0xfc04
movq 0x8(%rsp), %r12
movq %r12, %rdi
movq %r15, %rsi
callq 0x15d32
movq %r12, %rax
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
jmp 0x241d7
jmp 0x24189
movq %rax, %rbx
jmp 0x241a9
movq %rax, %rbx
jmp 0x241a0
movq %rax, %rbx
movq 0x10(%rsp), %rdi
callq 0xfc04
movq (%rsp), %rdi
callq 0xfc04
movq %r12, %rdi
callq 0xfc04
jmp 0x241cb
jmp 0x241d7
jmp 0x241d7
jmp 0x241d7
jmp 0x241d7
jmp 0x241d7
jmp 0x241d7
movq %rax, %rbx
movq (%rsp), %rdi
callq 0xfc04
movq %rbx, %rdi
callq 0xc290
jmp 0x241d7
jmp 0x241d7
movq %rax, %rdi
callq 0xde83
nop
// File: /workspace/github_cpp_makefile_star2_O1/Silica[P]PSL/./PSL/PSLlib.h
// Function: PSL::variable::PSLlib::File::Close(PSL::variable&, PSL::variable&)
static variable Close(variable &this_v, variable &v)
		{
			using namespace std;
			FILE *fp = this_v["$$__FILE*fp__$$"];
			if (fp)
				fclose(fp);
			this_v["$$__FILE*fp__$$"] = 0;
			this_v["name"] = "";
			return v;
		}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rdx, %r14
movq %rsi, %r15
movq %rdi, %rbx
leaq 0x379d(%rip), %rdx      # 0x28a27
movq %rsp, %r12
movq %r12, %rdi
callq 0x15f8c
movq (%r12), %rax
movq (%rax), %rdi
movq (%rdi), %rax
callq *0x100(%rax)
movq %rax, %r12
movq (%rsp), %rdi
callq 0xfc04
testq %r12, %r12
je 0x252be
movq %r12, %rdi
callq 0xc1b0
leaq 0x3762(%rip), %rdx      # 0x28a27
movq %rsp, %r12
movq %r12, %rdi
movq %r15, %rsi
callq 0x15f8c
movq %r12, %rdi
xorl %esi, %esi
callq 0x183da
movq (%rsp), %rdi
callq 0xfc04
leaq 0x374a(%rip), %rdx      # 0x28a37
movq %rsp, %r12
movq %r12, %rdi
movq %r15, %rsi
callq 0x15f8c
leaq 0x33f0(%rip), %rsi      # 0x286f2
movq %r12, %rdi
callq 0x258a2
movq (%rsp), %rdi
callq 0xfc04
movq (%r14), %rdi
callq 0xf88a
movq %rax, (%rbx)
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
jmp 0x25367
movq %rax, %rbx
movq (%rsp), %rdi
callq 0xfc04
jmp 0x2535f
jmp 0x25367
jmp 0x25367
movq %rax, %rbx
movq (%rsp), %rdi
callq 0xfc04
jmp 0x2535f
jmp 0x25367
jmp 0x25367
movq %rax, %rbx
movq (%rsp), %rdi
callq 0xfc04
movq %rbx, %rdi
callq 0xc290
movq %rax, %rdi
callq 0xde83
nop
// File: /workspace/github_cpp_makefile_star2_O1/Silica[P]PSL/./PSL/PSLlib.h
// Function: PSL::variable::PSLlib::File::Read(PSL::variable&, PSL::variable&)
static variable Read(variable &this_v, variable &v)
		{
			std::FILE *fp = this_v["$$__FILE*fp__$$"];
			size_t size = v;
			if (!fp || !size)
				return "";
			buffer vbuf(size+1);
			char *buf = reinterpret_cast<char*>(vbuf.get());
			vbuf.resize(std::fread(buf, 1, size, fp));
			vbuf.push(0);
			string s = buf;
			return s;
		}

// Assembly:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x20, %rsp
movq %rdx, %r15
movq %rdi, %rbx
leaq 0x32bb(%rip), %rdx      # 0x28a27
leaq 0x8(%rsp), %r14
movq %r14, %rdi
callq 0x15f8c
movq (%r14), %rax
movq (%rax), %rdi
movq (%rdi), %rax
callq *0x100(%rax)
movq %rax, %r14
movq 0x8(%rsp), %rdi
callq 0xfc04
movq (%r15), %rax
movq (%rax), %rdi
movq (%rdi), %rax
callq *0xe8(%rax)
testq %r14, %r14
setne %cl
testl %eax, %eax
setne %dl
testb %dl, %cl
je 0x2583a
movslq %eax, %r12
leaq 0x1(%r12), %rsi
leaq 0x8(%rsp), %r13
movq %r13, %rdi
callq 0x25b92
movq (%r13), %r15
movl $0x1, %esi
movq %r15, %rdi
movq %r12, %rdx
movq %r14, %rcx
callq 0xc230
movq %rax, %r14
movq %r13, %rdi
movq %rax, %rsi
callq 0x15ba0
leaq 0x8(%rsp), %rdi
movq %r14, 0x10(%rdi)
movq %rsp, %rsi
movb $0x0, (%rsi)
callq 0x15b5e
movq %rsp, %rdi
movq %r15, %rsi
callq 0xc75c
movq %rsp, %rsi
movq %rbx, %rdi
callq 0x1b226
movq (%rsp), %rdi
testq %rdi, %rdi
je 0x25829
callq 0xfbc0
movq 0x8(%rsp), %rdi
testq %rdi, %rdi
je 0x25849
callq 0xc210
jmp 0x25849
leaq 0x2eb1(%rip), %rsi      # 0x286f2
movq %rbx, %rdi
callq 0xcaf2
movq %rbx, %rax
addq $0x20, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
movq %rax, %rbx
movq (%rsp), %rdi
testq %rdi, %rdi
je 0x25872
callq 0xfbc0
jmp 0x25872
jmp 0x2586f
movq %rax, %rbx
movq 0x8(%rsp), %rdi
testq %rdi, %rdi
je 0x25892
callq 0xc210
jmp 0x25892
jmp 0x2589a
movq %rax, %rbx
movq 0x8(%rsp), %rdi
callq 0xfc04
movq %rbx, %rdi
callq 0xc290
movq %rax, %rdi
callq 0xde83
// File: /workspace/github_cpp_makefile_star2_O1/Silica[P]PSL/./PSL/PSLlib.h
// Function: PSL::variable::PSLlib::Binary::Read(PSL::variable&, PSL::variable&)
static variable Read(variable &this_v, variable &v)
		{
			using namespace std;
			FILE *fp = this_v["$$__FILE*fp__$$"];
			int size = v;
			variable r;
			if (!fp || !size)
				return r;
			for (int i = 0; i < size; ++i)
			{
				int c = fgetc(fp);
				if (c == EOF)
				{
					size = i;
					break;
				}
				r.push(static_cast<hex>(c));
			}
			r["length"] = size;
			return r;
		}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rdx, %r15
movq %rdi, %rbx
leaq 0x294f(%rip), %rdx      # 0x28a27
movq %rsp, %r14
movq %r14, %rdi
callq 0x15f8c
movq (%r14), %rax
movq (%rax), %rdi
movq (%rdi), %rax
callq *0x100(%rax)
movq %rax, %r14
movq (%rsp), %rdi
callq 0xfc04
movq (%r15), %rax
movq (%rax), %rdi
movq (%rdi), %rax
callq *0xe8(%rax)
movl %eax, %ebp
movq %rbx, %rdi
callq 0x1303e
testq %r14, %r14
sete %al
testl %ebp, %ebp
sete %cl
orb %al, %cl
jne 0x261ab
testl %ebp, %ebp
jle 0x26186
movl $0x1, %r13d
movq %rsp, %r15
movq %r14, %rdi
callq 0xc250
movl %eax, %r12d
cmpl $-0x1, %eax
je 0x26170
movslq %r12d, %rsi
movq %r15, %rdi
callq 0x15d32
movq (%rbx), %rax
movq (%rsp), %rsi
movq (%rax), %rdi
movq (%rdi), %rax
callq *0x130(%rax)
movq (%rsp), %rdi
callq 0xfc04
jmp 0x26174
leal -0x1(%r13), %ebp
cmpl $-0x1, %r12d
je 0x26186
leal 0x1(%r13), %eax
cmpl %ebp, %r13d
movl %eax, %r13d
jl 0x26137
leaq 0x2842(%rip), %rdx      # 0x289cf
movq %rsp, %rdi
movq %rbx, %rsi
callq 0x15f8c
movq %rsp, %rdi
movl %ebp, %esi
callq 0x183da
movq (%rsp), %rdi
callq 0xfc04
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
jmp 0x26206
movq %rax, %r14
movq (%rsp), %rdi
callq 0xfc04
jmp 0x261f6
jmp 0x26206
jmp 0x261e5
jmp 0x26206
movq %rax, %r14
movq (%rsp), %rdi
callq 0xfc04
jmp 0x261fe
jmp 0x26206
jmp 0x26206
movq %rax, %r14
jmp 0x261f6
movq %rax, %r14
movq (%rsp), %rdi
callq 0xfc04
movq %rbx, %rdi
callq 0xca7e
movq %r14, %rdi
callq 0xc290
movq %rax, %rdi
callq 0xde83
// File: /workspace/github_cpp_makefile_star2_O1/Silica[P]PSL/./PSL/PSLlib.h
// Function: PSL::variable::PSLlib::Binary::ReadDW(PSL::variable&, PSL::variable&)
static variable ReadDW(variable &this_v, variable &v)
		{
			using namespace std;
			FILE *fp = this_v["$$__FILE*fp__$$"];
			int size = v;
			variable r;
			if (!fp || !size)
				return r;
			for (int i = 0; i < size; ++i)
			{
				hex h;
				if (!fread(&h, sizeof(hex), 1, fp))
				{
					size = i;
					break;
				}
				r.push(h);
			}
			r["length"] = size;
			return r;
		}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %rdx, %r15
movq %rdi, %rbx
leaq 0x27fe(%rip), %rdx      # 0x28a27
leaq 0x8(%rsp), %r14
movq %r14, %rdi
callq 0x15f8c
movq (%r14), %rax
movq (%rax), %rdi
movq (%rdi), %rax
callq *0x100(%rax)
movq %rax, %r14
movq 0x8(%rsp), %rdi
callq 0xfc04
movq (%r15), %rax
movq (%rax), %rdi
movq (%rdi), %rax
callq *0xe8(%rax)
movl %eax, %ebp
movq %rbx, %rdi
callq 0x1303e
testq %r14, %r14
sete %al
testl %ebp, %ebp
sete %cl
orb %al, %cl
jne 0x2631a
testl %ebp, %ebp
jle 0x262f0
movl $0x1, %r12d
leaq 0x8(%rsp), %r15
movl $0x8, %esi
movl $0x1, %edx
movq %r15, %rdi
movq %r14, %rcx
callq 0xc230
movq %rax, %r13
testq %rax, %rax
je 0x262d9
movq 0x8(%rsp), %rsi
leaq 0x10(%rsp), %rdi
callq 0x15d32
movq (%rbx), %rax
movq 0x10(%rsp), %rsi
movq (%rax), %rdi
movq (%rdi), %rax
callq *0x130(%rax)
movq 0x10(%rsp), %rdi
callq 0xfc04
jmp 0x262de
leal -0x1(%r12), %ebp
testq %r13, %r13
je 0x262f0
leal 0x1(%r12), %eax
cmpl %ebp, %r12d
movl %eax, %r12d
jl 0x2628d
leaq 0x26d8(%rip), %rdx      # 0x289cf
leaq 0x8(%rsp), %rdi
movq %rbx, %rsi
callq 0x15f8c
leaq 0x8(%rsp), %rdi
movl %ebp, %esi
callq 0x183da
movq 0x8(%rsp), %rdi
callq 0xfc04
movq %rbx, %rax
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
jmp 0x26378
movq %rax, %r14
movq 0x8(%rsp), %rdi
callq 0xfc04
jmp 0x26368
jmp 0x26378
jmp 0x26356
jmp 0x26378
movq %rax, %r14
movq 0x8(%rsp), %rdi
callq 0xfc04
jmp 0x26370
jmp 0x26378
jmp 0x26378
movq %rax, %r14
jmp 0x26368
movq %rax, %r14
movq 0x10(%rsp), %rdi
callq 0xfc04
movq %rbx, %rdi
callq 0xca7e
movq %r14, %rdi
callq 0xc290
movq %rax, %rdi
callq 0xde83
// File: /workspace/github_cpp_makefile_star2_O1/Silica[P]PSL/./PSL/PSL.h
// Function: PSL::PSLVM::loadCompiledCode(PSL::variable::string const&)
error loadCompiledCode(const string &filename)
	{
		using namespace std;
		FILE *fp = fopen(filename, "rb");
		if (!fp)
			return FOPEN_ERROR;
		fseek(fp, 0, SEEK_END);
		long size = ftell(fp);
		if (size < 0)
			size = 0;
		fseek(fp, 0, SEEK_SET);
		error e = loadCompiledCode(fp, static_cast<unsigned long>(size));
		fclose(fp);
		return e;
	}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rdi, %rbx
movq (%rsi), %rax
testq %rax, %rax
je 0x267c1
movq 0x8(%rax), %rcx
movq 0x18(%rax), %rdx
movb $0x0, (%rcx,%rdx)
movq 0x8(%rax), %rdi
jmp 0x267c8
leaq 0x1f2a(%rip), %rdi      # 0x286f2
leaq 0x2284(%rip), %rsi      # 0x28a53
callq 0xc200
testq %rax, %rax
je 0x26828
movq %rax, %r14
xorl %r12d, %r12d
movq %rax, %rdi
xorl %esi, %esi
movl $0x2, %edx
callq 0xc1f0
movq %r14, %rdi
callq 0xc030
movq %rax, %r15
testq %rax, %rax
cmovleq %r12, %r15
movq %r14, %rdi
xorl %esi, %esi
xorl %edx, %edx
callq 0xc1f0
movq %rbx, %rdi
movq %r14, %rsi
movq %r15, %rdx
callq 0x268ee
movl %eax, %ebx
movq %r14, %rdi
callq 0xc1b0
movl %ebx, %eax
jmp 0x2682d
movl $0x1, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
nop
// File: /workspace/github_cpp_makefile_star2_O1/Silica[P]PSL/./PSL/PSL.h
// Function: PSL::PSLVM::parse(PSL::variable::Tokenizer*)
bool parse(variable::Tokenizer *t)
	{
		variable::Parser p(t);

		variable g;
		p.Parse(g);
		if (p.getErrorNum())
			return true;

		variable gl = env.global;
		gl.gset(g);
		gl.prepare(env);
		return false;
	}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
subq $0x18, %rsp
movq %rdi, %rbx
leaq 0x8(%rsp), %r14
movq %rsi, (%r14)
movl $0x0, 0x8(%r14)
movq %rsp, %r15
movq %r15, %rdi
callq 0x1303e
movq %r14, %rdi
movq %r15, %rsi
callq 0x189ca
movl 0x10(%rsp), %ebp
testl %ebp, %ebp
jne 0x268a6
movq (%rbx), %r14
incl 0x8(%r14)
movq (%rsp), %rsi
movq (%r14), %rdi
movq (%rdi), %rax
callq *0x40(%rax)
movq %rax, (%r14)
movq (%rax), %rcx
movq %rax, %rdi
movq %rbx, %rsi
movq %r14, %rdx
callq *0x160(%rcx)
movq %r14, %rdi
callq 0xfc04
movq (%rsp), %rdi
callq 0xfc04
testl %ebp, %ebp
setne %al
addq $0x18, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
jmp 0x268e6
movq %rax, %rbx
movq %r14, %rdi
callq 0xfc04
jmp 0x268d5
jmp 0x268e6
jmp 0x268e6
movq %rax, %rbx
movq (%rsp), %rdi
callq 0xfc04
movq %rbx, %rdi
callq 0xc290
movq %rax, %rdi
callq 0xde83
// File: /workspace/github_cpp_makefile_star2_O1/Silica[P]PSL/./PSL/PSL.h
// Function: PSL::PSLVM::loadCompiledCode(_IO_FILE*, unsigned long)
error loadCompiledCode(std::FILE *fp, unsigned long size)
	{
		unsigned long l;
		fread(&l, 1, sizeof(l), fp);
		if (l != 0xBCDEF01A)
			return NOT_COMPILED_CODE;
		size -= sizeof(l);
		variable::Variable::bytecode b(size);
		fread(b.get(), 1, size, fp);
		return loadCompiledCode(b);
	}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x20, %rsp
movq %rdx, %r15
movq %rsi, %r14
movq %rdi, %rbx
leaq 0x18(%rsp), %r12
movl $0x1, %esi
movl $0x8, %edx
movq %r12, %rdi
movq %r14, %rcx
callq 0xc230
movl $0x3, %ebp
movl $0xbcdef01a, %eax       # imm = 0xBCDEF01A
cmpq %rax, (%r12)
jne 0x2696e
addq $-0x8, %r15
movq %rsp, %r12
movq %r12, %rdi
movq %r15, %rsi
callq 0x25b92
movq (%r12), %rdi
movl $0x1, %esi
movq %r15, %rdx
movq %r14, %rcx
callq 0xc230
movq %rbx, %rdi
movq %r12, %rsi
callq 0x26996
movl %eax, %ebp
movq (%rsp), %rdi
testq %rdi, %rdi
je 0x2696e
callq 0xc210
movl %ebp, %eax
addq $0x20, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
movq (%rsp), %rdi
testq %rdi, %rdi
je 0x2698e
callq 0xc210
movq %rbx, %rdi
callq 0xc290
// File: /workspace/github_cpp_makefile_star2_O1/Silica[P]PSL/./PSL/PSL.h
// Function: PSL::PSLVM::loadCompiledCode(PSL::variable::Variable::bytecode&)
error loadCompiledCode(variable::buffer &buf)
	{
		variable c;
		variable::Variable::bcreader::read(buf, c);
		variable g = env.global;
		g.gset(c);
		g.prepare(env);
		return NONE;
	}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
subq $0x10, %rsp
movq %rsi, %r14
movq %rdi, %rbx
leaq 0x8(%rsp), %r15
movq %r15, %rdi
callq 0x1303e
movq %r14, %rdi
movq %r15, %rsi
callq 0x26a36
movq (%rbx), %r14
incl 0x8(%r14)
movq 0x8(%rsp), %rsi
movq (%r14), %rdi
movq (%rdi), %rax
callq *0x40(%rax)
movq %rax, (%r14)
movq (%rax), %rcx
movq %rax, %rdi
movq %rbx, %rsi
movq %r14, %rdx
callq *0x160(%rcx)
movq %r14, %rdi
callq 0xfc04
movq 0x8(%rsp), %rdi
callq 0xfc04
xorl %eax, %eax
addq $0x10, %rsp
popq %rbx
popq %r14
popq %r15
retq
jmp 0x26a2d
jmp 0x26a2d
movq %rax, %rbx
jmp 0x26a19
movq %rax, %rbx
movq %r14, %rdi
callq 0xfc04
movq 0x8(%rsp), %rdi
callq 0xfc04
movq %rbx, %rdi
callq 0xc290
jmp 0x26a2d
movq %rax, %rdi
callq 0xde83
nop
// File: /workspace/github_cpp_makefile_star2_O1/Silica[P]PSL/./PSL/code.h
// Function: PSL::variable::Variable::BAND::Execute(PSL::variable::Variable::Environment&)
CLONE(BAND)
	EXEC
	{
		variable r = env.pop();
		variable l = env.pop();
		variable v(static_cast<bool>(l) && static_cast<bool>(r));
		env.push(v);
		return RC::NONE;
	}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
subq $0x10, %rsp
movq %rsi, %r15
movq %rsp, %rbx
movq %rbx, %rdi
callq 0xf800
movq (%rbx), %rbx
incl 0x8(%rbx)
movq %rbx, %rdi
callq 0xfc04
movq %rsp, %rdi
movq %r15, %rsi
callq 0xf800
movq (%rsp), %r14
incl 0x8(%r14)
movq %r14, %rdi
callq 0xfc04
movq (%r14), %rdi
movq (%rdi), %rax
callq *0xe0(%rax)
testb %al, %al
je 0x27b4a
movq (%rbx), %rdi
movq (%rdi), %rax
callq *0xe0(%rax)
jmp 0x27b4c
xorl %eax, %eax
movzbl %al, %esi
movq %rsp, %rdi
callq 0x1eaa8
movq (%rsp), %rax
incl 0x8(%rax)
leaq 0x8(%rsp), %rsi
movq %rax, (%rsi)
addq $0x8, %r15
movq %r15, %rdi
callq 0xfc38
movq 0x8(%rsp), %rdi
callq 0xfc04
movq (%rsp), %rdi
callq 0xfc04
movq %r14, %rdi
callq 0xfc04
movq %rbx, %rdi
callq 0xfc04
xorl %eax, %eax
addq $0x10, %rsp
popq %rbx
popq %r14
popq %r15
retq
jmp 0x27beb
jmp 0x27beb
jmp 0x27beb
jmp 0x27beb
movq %rax, %r15
movq 0x8(%rsp), %rdi
callq 0xfc04
movq (%rsp), %rdi
callq 0xfc04
jmp 0x27bd1
jmp 0x27beb
jmp 0x27beb
jmp 0x27beb
movq %rax, %r15
jmp 0x27bd9
jmp 0x27beb
movq %rax, %r15
movq %r14, %rdi
callq 0xfc04
movq %rbx, %rdi
callq 0xfc04
movq %r15, %rdi
callq 0xc290
jmp 0x27beb
movq %rax, %rdi
callq 0xde83
nop
// File: /workspace/github_cpp_makefile_star2_O1/Silica[P]PSL/./PSL/PSL.h
// Function: PSL::PSLVM::writeCompiledCode(_IO_FILE*)
error writeCompiledCode(std::FILE *fp)
	{
		variable::Variable::bytecode b;
		env.global.get()->write("", b);
		unsigned long l = 0xBCDEF01A;
		fwrite(&l, 1, sizeof(l), fp);
		fwrite(b.get(), 1, b.size(), fp);
		return NONE;
	}

// Assembly:
pushq %r14
pushq %rbx
subq $0x28, %rsp
movq %rsi, %rbx
xorps %xmm0, %xmm0
movaps %xmm0, 0x10(%rsp)
movq $0x0, 0x20(%rsp)
movq (%rdi), %r14
leaq 0x971(%rip), %rsi       # 0x286f2
leaq 0x8(%rsp), %rdi
callq 0xc75c
movq (%r14), %rdi
movq (%rdi), %rax
leaq 0x8(%rsp), %rsi
leaq 0x10(%rsp), %rdx
callq *0x1a0(%rax)
movq 0x8(%rsp), %rdi
testq %rdi, %rdi
je 0x27db0
callq 0xfbc0
movl $0xbcdef01a, %eax       # imm = 0xBCDEF01A
leaq 0x8(%rsp), %rdi
movq %rax, (%rdi)
movl $0x1, %esi
movl $0x8, %edx
movq %rbx, %rcx
callq 0xc2c0
movq 0x10(%rsp), %rdi
movq 0x20(%rsp), %rdx
movl $0x1, %esi
movq %rbx, %rcx
callq 0xc2c0
movq 0x10(%rsp), %rdi
testq %rdi, %rdi
je 0x27df5
callq 0xc210
xorl %eax, %eax
addq $0x28, %rsp
popq %rbx
popq %r14
retq
movq %rax, %rbx
movq 0x8(%rsp), %rdi
testq %rdi, %rdi
je 0x27e16
callq 0xfbc0
jmp 0x27e16
movq %rax, %rbx
movq 0x10(%rsp), %rdi
testq %rdi, %rdi
je 0x27e25
callq 0xc210
movq %rbx, %rdi
callq 0xc290
// File: /workspace/github_cpp_makefile_star2_O1/razor[P]rds-tmc-decoder/tmcdec.c
// Function: load_eventcode
void load_eventcode()
{
    int i;
    for (i=0; i<TMC_EVENT_LIST_LINES; i++) {
        int code = strtol(tmc_events[i][2], NULL, 10);
        if (code != 0) {
            eventmsg[code] = 
            tmc_events[i][1];
//            printf("%d=>%s\n", code, eventmsg[code]);
        } else {
            eventmsg[code] = 0;
        }
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movl $0x10, %ebx
leaq 0xfece(%rip), %r14      # 0x36050
leaq 0x1ffa7(%rip), %r15     # 0x46130
movq (%rbx,%r14), %rdi
xorl %esi, %esi
movl $0xa, %edx
callq 0x26060
testl %eax, %eax
je 0x261aa
movq -0x8(%rbx,%r14), %rcx
cltq
movq %rcx, (%r15,%rax,8)
jmp 0x261b5
movq $0x0, 0x1ff7b(%rip) # 0x46130
addq $0x20, %rbx
cmpq $0xc6f0, %rbx           # imm = 0xC6F0
jne 0x26189
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O1/razor[P]rds-tmc-decoder/tmcdec.c
// Function: parsemsg
void parsemsg(const char *msg)
{
    char *endptr = NULL;
    tmcmsg.block1 = strtol(msg, &endptr, 16);
    tmcmsg.block2 = strtol(endptr, &endptr, 16);
    tmcmsg.block3 = strtol(endptr, &endptr, 16);
    tmcmsg.block4 = strtol(endptr, &endptr, 16);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %rbx
pushq %rax
leaq -0x10(%rbp), %rbx
movq $0x0, (%rbx)
movq %rbx, %rsi
movl $0x10, %edx
callq 0x26060
movl %eax, 0x23f3f(%rip)     # 0x4a130
movq (%rbx), %rdi
movq %rbx, %rsi
movl $0x10, %edx
callq 0x26060
movl %eax, 0x23f2d(%rip)     # 0x4a134
movq (%rbx), %rdi
movq %rbx, %rsi
movl $0x10, %edx
callq 0x26060
movl %eax, 0x23f1b(%rip)     # 0x4a138
movq (%rbx), %rdi
movq %rbx, %rsi
movl $0x10, %edx
callq 0x26060
movl %eax, 0x23f09(%rip)     # 0x4a13c
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O1/razor[P]rds-tmc-decoder/tmcdec.c
// Function: main
int main()
{
    char buf[32];
    load_eventcode();
    while (fgets(buf, 32, stdin) != NULL) {
        int s = strlen(buf);
        *(buf+s-1) = 0;
        parsemsg(buf);
        if ((tmcmsg.block2 & 0xF800) == GROUP_8A && 
            (tmcmsg.block2 & 0x1F) == 0x8) printf("%s\t%s\n", buf, getevent());
        else printf("%s\t-\n", buf);
    }
    return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x28, %rsp
callq 0x2616c
movq 0xfd6d(%rip), %r12      # 0x35fe0
movq (%r12), %rdx
leaq -0x50(%rbp), %rdi
movl $0x20, %esi
callq 0x26050
testq %rax, %rax
je 0x26317
leaq -0x50(%rbp), %rbx
movl $0xf81f, %r13d          # imm = 0xF81F
leaq 0xda89(%rip), %r14      # 0x33d28
leaq 0xda89(%rip), %r15      # 0x33d2f
movq %rbx, %rdi
callq 0x26030
cltq
movb $0x0, -0x51(%rbp,%rax)
movq %rbx, %rdi
callq 0x261cd
movl 0x23e71(%rip), %eax     # 0x4a134
andl %r13d, %eax
cmpl $0x8008, %eax           # imm = 0x8008
jne 0x262f4
movl 0x23e65(%rip), %eax     # 0x4a138
movl $0x7ff, %ecx            # imm = 0x7FF
andl %ecx, %eax
leaq 0x1fe4f(%rip), %rcx     # 0x46130
movq (%rcx,%rax,8), %rdx
movq %r14, %rdi
movq %rbx, %rsi
xorl %eax, %eax
callq 0x26040
jmp 0x26301
movq %r15, %rdi
movq %rbx, %rsi
xorl %eax, %eax
callq 0x26040
movq (%r12), %rdx
movq %rbx, %rdi
movl $0x20, %esi
callq 0x26050
testq %rax, %rax
jne 0x262a6
xorl %eax, %eax
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O1/CK7[P]abawaca/src/abawaca.cpp
// Function: init_cluster(ScafDpData const&)
Cluster* init_cluster(const ScafDpData& scaf_db)
{
	Cluster* cluster = new Cluster(scaf_db);
	for(size_t i=1; i<=scaf_db.ndps(); i++)
		*cluster += i;
	for(size_t i=1; i<=scaf_db.nscafs(); i++)
		cluster->add_assigned_scaf(i);

	return cluster;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rdi, %rbx
movl $0xa0, %edi
callq 0x53a0
movq %rax, %r14
movq %rbx, (%rax)
addq $0x10, %rax
xorl %ecx, %ecx
movl %ecx, 0x10(%r14)
movq %rcx, 0x18(%r14)
movq %rax, 0x20(%r14)
movq %rax, 0x28(%r14)
movq %rcx, 0x30(%r14)
leaq 0x68(%r14), %rax
movq %rax, 0x38(%r14)
movq $0x1, 0x40(%r14)
xorps %xmm0, %xmm0
movups %xmm0, 0x48(%r14)
movl $0x3f800000, 0x58(%r14) # imm = 0x3F800000
movups %xmm0, 0x60(%r14)
leaq 0x78(%r14), %rax
movl %ecx, 0x78(%r14)
movq %rcx, 0x80(%r14)
movq %rax, 0x88(%r14)
movq %rax, 0x90(%r14)
movq %rcx, 0x98(%r14)
movq 0x68(%rbx), %rax
subq 0x60(%rbx), %rax
cmpq $0x30, %rax
je 0x8ea3
movl $0x1, %r15d
movabsq $-0x5555555555555555, %r12 # imm = 0xAAAAAAAAAAAAAAAB
movq %r14, %rdi
movq %r15, %rsi
callq 0x12330
incq %r15
movq 0x68(%rbx), %rax
subq 0x60(%rbx), %rax
sarq $0x4, %rax
imulq %r12, %rax
decq %rax
cmpq %rax, %r15
jbe 0x8e7d
movq 0x80(%rbx), %rax
subq 0x78(%rbx), %rax
cmpq $0x48, %rax
je 0x8ef9
movq %r14, %r15
addq $0x70, %r15
movl $0x1, %r13d
movabsq $-0x71c71c71c71c71c7, %r12 # imm = 0x8E38E38E38E38E39
movq %r13, -0x30(%rbp)
movq %r15, %rdi
leaq -0x30(%rbp), %rsi
callq 0xb14e
incq %r13
movq 0x80(%rbx), %rax
subq 0x78(%rbx), %rax
sarq $0x3, %rax
imulq %r12, %rax
decq %rax
cmpq %rax, %r13
jbe 0x8ecb
movq %r14, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O1/CK7[P]abawaca/src/abawaca.cpp
// Function: get_fasta(std::set<unsigned long, std::less<unsigned long>, std::allocator<unsigned long>> const&, ScafDpData const&, char const*)
size_t get_fasta(const set<size_t>& scafs, const ScafDpData& scaf_db, const char* fasta_out)
{
	size_t total_bps = 0;
	Bio::SeqIOWrite_fasta<Bio::DNASequence>  writer(fasta_out);


	for(auto sit=scafs.begin(); sit!=scafs.end(); sit++) {
		const Bio::DNASequence* seq_obj = scaf_db.get_scaf(*sit)->get_seq_obj();
		if(seq_obj == NULL) {
			cerr << "Warning: could not find scaffold " << scaf_db.scaf_id2name(*sit) << " (" << *sit << ") in fasta file" << endl;
			continue;
		}
		writer.write_seq(*seq_obj);
		total_bps += seq_obj->seq().size();
	}

	return total_bps;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x288, %rsp            # imm = 0x288
movq %rsi, %rbx
movq %rdi, %r14
leaq -0x68(%rbp), %rdi
leaq -0x48(%rbp), %rax
movq %rdx, %rsi
movq %rax, %rdx
callq 0x5160
leaq -0x2a8(%rbp), %rdi
leaq -0x68(%rbp), %rsi
callq 0x9444
leaq -0x58(%rbp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x8f5a
callq 0x5340
movq 0x18(%r14), %r15
addq $0x8, %r14
xorl %r12d, %r12d
cmpq %r14, %r15
je 0x908b
movq 0x20(%r15), %rax
movq 0x78(%rbx), %rcx
movq 0x80(%rbx), %rdx
subq %rcx, %rdx
sarq $0x3, %rdx
movabsq $-0x71c71c71c71c71c7, %rsi # imm = 0x8E38E38E38E38E39
imulq %rsi, %rdx
cmpq %rax, %rdx
leaq (%rax,%rax,8), %rax
leaq (%rcx,%rax,8), %rax
movl $0x0, %ecx
cmovbeq %rcx, %rax
movq 0x38(%rax), %r13
testq %r13, %r13
je 0x8fc7
leaq -0x2a8(%rbp), %rdi
movq %r13, %rsi
callq 0x94c8
addq 0x50(%r13), %r12
jmp 0x9077
movl $0x21, %edx
movq 0x1a015(%rip), %rdi     # 0x22fe8
leaq 0x111ea(%rip), %rsi     # 0x1a1c4
callq 0x5420
movq 0x20(%r15), %rdx
leaq -0x48(%rbp), %rdi
movq %rbx, %rsi
callq 0xce74
movq -0x48(%rbp), %rsi
movq -0x40(%rbp), %rdx
movq 0x19fea(%rip), %rdi     # 0x22fe8
callq 0x5420
movq %rax, %r13
movl $0x2, %edx
movq %rax, %rdi
leaq 0x11f28(%rip), %rsi     # 0x1af3d
callq 0x5420
movq 0x20(%r15), %rsi
movq %r13, %rdi
callq 0x5240
movq %rax, %r13
movl $0xf, %edx
movq %rax, %rdi
leaq 0x111ae(%rip), %rsi     # 0x1a1e6
callq 0x5420
movq (%r13), %rax
movq -0x18(%rax), %rdi
addq %r13, %rdi
movl $0xa, %esi
callq 0x5360
movsbl %al, %esi
movq %r13, %rdi
callq 0x5040
movq %rax, %rdi
callq 0x5250
movq -0x48(%rbp), %rdi
leaq -0x38(%rbp), %rax
cmpq %rax, %rdi
je 0x9077
callq 0x5340
movq %r15, %rdi
callq 0x5430
movq %rax, %r15
cmpq %r14, %rax
jne 0x8f6e
leaq -0x2a8(%rbp), %rdi
callq 0x9f06
movq %r12, %rax
addq $0x288, %rsp            # imm = 0x288
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
leaq -0x58(%rbp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x90f0
callq 0x5340
jmp 0x90f0
movq %rax, %rbx
jmp 0x90f0
jmp 0x90ca
movq %rax, %rbx
jmp 0x90e4
movq %rax, %rbx
movq -0x48(%rbp), %rdi
leaq -0x38(%rbp), %rax
cmpq %rax, %rdi
je 0x90e4
callq 0x5340
leaq -0x2a8(%rbp), %rdi
callq 0x9f06
movq %rbx, %rdi
callq 0x56a0
// File: /workspace/github_cpp_makefile_star2_O1/CK7[P]abawaca/src/SeqIOWrite_fasta.h
// Function: Bio::SeqIOWrite_fasta<Bio::Sequence<Bio::DNAString>>::write_seq(Bio::Sequence<Bio::DNAString> const&)
void SeqIOWrite_fasta<S>::write_seq(const S& seq)
{
	this->m_fp << '>' <<  seq.display_id() << ' ' <<  seq.desc() << endl;
	// A conversion from seq.seq() to string is assumed to exist!
	string	str = string(seq.seq());
	this->m_line_num++;
	for(size_t i=0; i<=str.size(); i+=_line_length) {
		this->m_fp << str.substr(i, (i+_line_length<=str.size())? _line_length : str.size()-i+1) << endl;
		this->m_line_num++;
	}
	this->m_seq_num++;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x48, %rsp
movq %rsi, %r12
movq %rdi, %rbx
leaq 0x38(%rdi), %r14
leaq -0x48(%rbp), %r15
movb $0x3e, (%r15)
movl $0x1, %edx
movq %r14, %rdi
movq %r15, %rsi
callq 0x5420
movq 0x8(%r12), %rsi
movq 0x10(%r12), %rdx
movq %rax, %rdi
callq 0x5420
movb $0x20, (%r15)
leaq -0x48(%rbp), %rsi
movl $0x1, %edx
movq %rax, %rdi
callq 0x5420
movq 0x28(%r12), %rsi
movq 0x30(%r12), %rdx
movq %rax, %rdi
callq 0x5420
movq %rax, %r15
movq (%rax), %rax
movq -0x18(%rax), %rdi
addq %r15, %rdi
movl $0xa, %esi
callq 0x5360
movsbl %al, %esi
movq %r15, %rdi
callq 0x5040
movq %rax, %rdi
callq 0x5250
leaq -0x38(%rbp), %rax
movq %rax, -0x10(%rax)
movq 0x48(%r12), %rsi
movq 0x50(%r12), %rdx
addq %rsi, %rdx
leaq -0x48(%rbp), %r15
movq %r15, %rdi
callq 0xb27a
incq 0x28(%rbx)
movq 0x8(%r15), %rax
xorl %r12d, %r12d
leaq -0x68(%rbp), %r13
movq 0x238(%rbx), %rdx
leaq (%rdx,%r12), %rsi
movq %rax, %rcx
subq %r12, %rcx
incq %rcx
cmpq %rax, %rsi
cmovbeq %rdx, %rcx
movq %r13, %rdi
leaq -0x48(%rbp), %rsi
movq %r12, %rdx
callq 0x53c0
movq -0x68(%rbp), %rsi
movq -0x60(%rbp), %rdx
movq %r14, %rdi
callq 0x5420
movq %rax, %r15
movq (%rax), %rax
movq -0x18(%rax), %rdi
addq %r15, %rdi
movl $0xa, %esi
callq 0x5360
movsbl %al, %esi
movq %r15, %rdi
callq 0x5040
movq %rax, %rdi
callq 0x5250
movq -0x68(%rbp), %rdi
leaq -0x58(%rbp), %rax
cmpq %rax, %rdi
je 0x9604
callq 0x5340
incq 0x28(%rbx)
addq 0x238(%rbx), %r12
movq -0x40(%rbp), %rax
cmpq %rax, %r12
jbe 0x958e
incq 0x30(%rbx)
movq -0x48(%rbp), %rdi
leaq -0x38(%rbp), %rax
cmpq %rax, %rdi
je 0x9632
callq 0x5340
addq $0x48, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
jmp 0x965b
movq %rax, %rbx
movq -0x68(%rbp), %rdi
leaq -0x58(%rbp), %rax
cmpq %rax, %rdi
je 0x965b
callq 0x5340
leaq -0x38(%rbp), %rax
movq -0x48(%rbp), %rdi
cmpq %rax, %rdi
je 0x966d
callq 0x5340
movq %rbx, %rdi
callq 0x56a0
nop
// File: /workspace/github_cpp_makefile_star2_O1/CK7[P]abawaca/src/SeqIOWrite.h
// Function: Bio::SeqIOWrite<Bio::Sequence<Bio::DNAString>>::open(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>)
void SeqIOWrite<S>::open(string file)
{
	this->close();
	this->SeqIO::open(file);
	m_fp.open(file.c_str());

	if(m_fp.fail())
		throw Bad_file(file, "Failed to open file", __PRETTY_FUNCTION__);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x68, %rsp
movq %rsi, %r14
movq %rdi, %rbx
movq (%rdi), %rax
callq *0x10(%rax)
leaq -0x38(%rbp), %r15
movq %r15, -0x10(%r15)
movq (%r14), %rsi
movq 0x8(%r14), %rdx
addq %rsi, %rdx
leaq -0x48(%rbp), %rdi
callq 0xb27a
movq (%rbx), %rax
movq %rbx, %rdi
callq *0x10(%rax)
leaq 0x8(%rbx), %rdi
leaq -0x48(%rbp), %rsi
callq 0x51e0
movq -0x48(%rbp), %rdi
cmpq %r15, %rdi
je 0xa024
callq 0x5340
leaq 0x38(%rbx), %rdi
movq (%r14), %rsi
movl $0x10, %edx
callq 0x5060
movq 0x38(%rbx), %rax
movq -0x18(%rax), %rax
testb $0x5, 0x58(%rbx,%rax)
jne 0xa053
addq $0x68, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movl $0x28, %edi
callq 0x51b0
movq %rax, %rbx
leaq -0x78(%rbp), %r15
movq %r15, -0x10(%r15)
movq (%r14), %rsi
movq 0x8(%r14), %rdx
addq %rsi, %rdx
leaq -0x88(%rbp), %rdi
callq 0xb27a
leaq -0x58(%rbp), %r13
movq %r13, -0x10(%r13)
leaq 0x103fd(%rip), %rsi     # 0x1a48a
leaq 0x10409(%rip), %rdx     # 0x1a49d
leaq -0x68(%rbp), %rdi
callq 0xb314
movb $0x1, %r12b
leaq 0x103f7(%rip), %rcx     # 0x1a49e
leaq -0x88(%rbp), %rsi
leaq -0x68(%rbp), %rdx
movq %rbx, %rdi
xorl %r8d, %r8d
callq 0xa392
xorl %r12d, %r12d
leaq 0x18889(%rip), %rsi     # 0x22950
leaq 0xde0(%rip), %rdx       # 0xaeae
movq %rbx, %rdi
callq 0x5660
movq %rax, %r14
movq -0x68(%rbp), %rdi
cmpq %r13, %rdi
je 0xa0ef
callq 0x5340
jmp 0xa0ef
movq %rax, %r14
movb $0x1, %r12b
movq -0x88(%rbp), %rdi
cmpq %r15, %rdi
je 0xa108
callq 0x5340
jmp 0xa108
movq %rax, %r14
movb $0x1, %r12b
testb %r12b, %r12b
je 0xa128
movq %rbx, %rdi
callq 0x5280
jmp 0xa128
movq %rax, %r14
movq -0x48(%rbp), %rdi
cmpq %r15, %rdi
je 0xa128
callq 0x5340
movq %r14, %rdi
callq 0x56a0