LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: Silica[P]PSL/./PSL/memory.h
// Function: PSL::variable::VMemoryPool::pool::empty()
bool empty()
		{
			for (int i = 0; i < poolsize; ++i)
				if (ptr[i].x)
					return false;
			return true;
		}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x10(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x20(%rbp)
movl $0x0, -0x14(%rbp)
cmpl $0x100, -0x14(%rbp)     # imm = 0x100
jge 0x35957
movq -0x20(%rbp), %rax
movslq -0x14(%rbp), %rcx
shlq $0x4, %rcx
addq %rcx, %rax
cmpl $0x0, (%rax)
je 0x3594a
movb $0x0, -0x1(%rbp)
jmp 0x3595b
jmp 0x3594c
movl -0x14(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x14(%rbp)
jmp 0x35927
movb $0x1, -0x1(%rbp)
movb -0x1(%rbp), %al
andb $0x1, %al
popq %rbp
retq
nopw %cs:(%rax,%rax)
nopl (%rax)
// File: 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 %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movq %rdi, -0x48(%rbp)
movq %rdi, %rax
movq %rax, -0x50(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x10(%rbp), %rdi
callq 0x36470
movb %al, -0x11(%rbp)
movsbl -0x11(%rbp), %esi
leaq -0x20(%rbp), %rdi
movq %rdi, -0x40(%rbp)
callq 0x36490
movq -0x48(%rbp), %rdi
movq -0x40(%rbp), %rsi
movb $0x0, -0x21(%rbp)
callq 0x26cc0
jmp 0x359bb
movb $0x1, -0x21(%rbp)
testb $0x1, -0x21(%rbp)
jne 0x359e7
jmp 0x359de
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x30(%rbp)
movl %eax, -0x34(%rbp)
leaq -0x20(%rbp), %rdi
callq 0xc950
jmp 0x359fa
movq -0x48(%rbp), %rdi
callq 0xcdc0
leaq -0x20(%rbp), %rdi
callq 0xc950
movq -0x50(%rbp), %rax
addq $0x50, %rsp
popq %rbp
retq
movq -0x30(%rbp), %rdi
callq 0xc280
nopw %cs:(%rax,%rax)
nopl (%rax)
// File: 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 %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movq %rdi, -0x48(%rbp)
movq %rdi, %rax
movq %rax, -0x40(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
leaq -0x18(%rbp), %rdi
callq 0x11f50
callq 0xc220
movl %eax, -0x34(%rbp)
jmp 0x3635e
movl -0x34(%rbp), %eax
movl %eax, -0x1c(%rbp)
movsbl -0x1c(%rbp), %esi
leaq -0x18(%rbp), %rdi
callq 0x36700
jmp 0x36373
movq -0x48(%rbp), %rdi
movb $0x0, -0x2d(%rbp)
leaq -0x18(%rbp), %rsi
callq 0x26cc0
jmp 0x36386
movb $0x1, -0x2d(%rbp)
testb $0x1, -0x2d(%rbp)
jne 0x363b2
jmp 0x363a9
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x28(%rbp)
movl %eax, -0x2c(%rbp)
leaq -0x18(%rbp), %rdi
callq 0xc950
jmp 0x363c5
movq -0x48(%rbp), %rdi
callq 0xcdc0
leaq -0x18(%rbp), %rdi
callq 0xc950
movq -0x40(%rbp), %rax
addq $0x50, %rsp
popq %rbp
retq
movq -0x28(%rbp), %rdi
callq 0xc280
nop
// File: 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
movq %rsp, %rbp
subq $0x50, %rsp
movq %rdi, -0x40(%rbp)
movq %rdi, %rax
movq %rax, -0x38(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
leaq -0x18(%rbp), %rdi
callq 0x11f50
movq 0x22be5(%rip), %rax     # 0x58fe0
movq (%rax), %rdi
callq 0xc0a0
movl %eax, -0x44(%rbp)
jmp 0x36408
movl -0x44(%rbp), %eax
movl %eax, -0x1c(%rbp)
cmpl $-0x1, %eax
je 0x36443
movsbl -0x1c(%rbp), %esi
leaq -0x18(%rbp), %rdi
callq 0xc980
jmp 0x36422
cmpl $0xa, -0x1c(%rbp)
jne 0x36441
jmp 0x36443
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x28(%rbp)
movl %eax, -0x2c(%rbp)
leaq -0x18(%rbp), %rdi
callq 0xc950
jmp 0x36465
jmp 0x363f4
movq -0x40(%rbp), %rdi
leaq -0x18(%rbp), %rsi
callq 0x26cc0
jmp 0x36452
leaq -0x18(%rbp), %rdi
callq 0xc950
movq -0x38(%rbp), %rax
addq $0x50, %rsp
popq %rbp
retq
movq -0x28(%rbp), %rdi
callq 0xc280
nop
// File: 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 %rbp
movq %rsp, %rbp
subq $0x70, %rsp
movq %rdi, -0x58(%rbp)
movq %rdi, %rax
movq %rax, -0x50(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq %rcx, -0x20(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x48(%rbp)
cmpq $0x0, (%rax)
jne 0x3655f
movq -0x58(%rbp), %rdi
callq 0x11f50
jmp 0x36621
movq -0x48(%rbp), %rax
movq (%rax), %rdi
callq 0x152c0
movq %rax, -0x28(%rbp)
movq -0x18(%rbp), %rax
cmpq -0x28(%rbp), %rax
jb 0x36587
movq -0x58(%rbp), %rdi
callq 0x11f50
jmp 0x36621
cmpq $0x0, -0x20(%rbp)
je 0x3659c
movq -0x18(%rbp), %rax
addq -0x20(%rbp), %rax
cmpq -0x28(%rbp), %rax
jbe 0x365a8
movq -0x28(%rbp), %rax
subq -0x18(%rbp), %rax
movq %rax, -0x20(%rbp)
movl $0x20, %edi
callq 0x13750
movq %rax, %rdi
movq %rdi, %rax
movq %rax, -0x60(%rbp)
movq -0x20(%rbp), %rsi
callq 0x13770
jmp 0x365c7
movq -0x48(%rbp), %rax
movq -0x60(%rbp), %rcx
movq %rcx, -0x30(%rbp)
movq -0x30(%rbp), %rcx
movq %rcx, -0x68(%rbp)
movq (%rax), %rdi
callq 0x13b70
movq -0x68(%rbp), %rdi
movq %rax, %rsi
addq -0x18(%rbp), %rsi
movq -0x20(%rbp), %rdx
xorl %eax, %eax
movl %eax, %ecx
callq 0x15350
movq -0x58(%rbp), %rdi
movq -0x30(%rbp), %rsi
callq 0x26f80
jmp 0x36621
movq -0x60(%rbp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x38(%rbp)
movl %eax, -0x3c(%rbp)
callq 0x12250
jmp 0x3662b
movq -0x50(%rbp), %rax
addq $0x70, %rsp
popq %rbp
retq
movq -0x38(%rbp), %rdi
callq 0xc280
nopw %cs:(%rax,%rax)
nop
// File: Silica[P]PSL/./PSL/pstring.h
// Function: PSL::variable::string::find(char, int) const
int find(char c, int i = 0) const	/* i�ʒu���猟������c�̕����𔭌������ʒu���Ԃ� */
	{
		if (i >= 0 && buf)
		{
			for (size_t t = static_cast<size_t>(i); t < buf->length(); ++t)
			{
				if (buf->at(t) == c)
					return static_cast<int>(t);
			}
		}
		return -1;
	}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movb %sil, %al
movq %rdi, -0x10(%rbp)
movb %al, -0x11(%rbp)
movl %edx, -0x18(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x28(%rbp)
cmpl $0x0, -0x18(%rbp)
jl 0x366eb
movq -0x28(%rbp), %rax
cmpq $0x0, (%rax)
je 0x366eb
movslq -0x18(%rbp), %rax
movq %rax, -0x20(%rbp)
movq -0x28(%rbp), %rax
movq -0x20(%rbp), %rcx
movq %rcx, -0x30(%rbp)
movq (%rax), %rdi
callq 0x152c0
movq %rax, %rcx
movq -0x30(%rbp), %rax
cmpq %rcx, %rax
jae 0x366e9
movq -0x28(%rbp), %rax
movq (%rax), %rdi
movq -0x20(%rbp), %rsi
callq 0x15a40
movsbl %al, %eax
movsbl -0x11(%rbp), %ecx
cmpl %ecx, %eax
jne 0x366d9
movq -0x20(%rbp), %rax
movl %eax, -0x4(%rbp)
jmp 0x366f2
jmp 0x366db
movq -0x20(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x20(%rbp)
jmp 0x36695
jmp 0x366eb
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
movl -0x4(%rbp), %eax
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: 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
movq %rsp, %rbp
subq $0x40, %rsp
movb %sil, %al
movq %rdi, -0x8(%rbp)
movb %al, -0x9(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x28(%rbp)
cmpq $0x0, (%rax)
jne 0x36767
movl $0x20, %edi
callq 0x13750
movq %rax, %rdi
movq %rdi, %rax
movq %rax, -0x30(%rbp)
movl $0xb, %esi
callq 0x13770
jmp 0x36740
movq -0x28(%rbp), %rax
movq -0x30(%rbp), %rcx
movq %rcx, (%rax)
jmp 0x367cb
movq -0x30(%rbp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x18(%rbp)
movl %eax, -0x1c(%rbp)
callq 0x12250
jmp 0x36800
movq -0x28(%rbp), %rax
movq (%rax), %rdi
callq 0x153a0
testb $0x1, %al
jne 0x36779
jmp 0x367c9
movq -0x28(%rbp), %rax
movq (%rax), %rdi
callq 0x121d0
movl $0x20, %edi
callq 0x13750
movq %rax, %rdi
movq %rdi, %rax
movq %rax, -0x38(%rbp)
movl $0xb, %esi
callq 0x13770
jmp 0x367a5
movq -0x28(%rbp), %rax
movq -0x38(%rbp), %rcx
movq %rcx, (%rax)
jmp 0x367c9
movq -0x38(%rbp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x18(%rbp)
movl %eax, -0x1c(%rbp)
callq 0x12250
jmp 0x36800
jmp 0x367cb
movq -0x28(%rbp), %rax
movb -0x9(%rbp), %cl
movb %cl, -0x39(%rbp)
movq (%rax), %rdi
callq 0x13b70
movb -0x39(%rbp), %dl
movq %rax, %rcx
movq -0x28(%rbp), %rax
movb %dl, (%rcx)
movq (%rax), %rdi
movl $0x1, %esi
callq 0x13b90
movq -0x28(%rbp), %rax
addq $0x40, %rsp
popq %rbp
retq
movq -0x18(%rbp), %rdi
callq 0xc280
nopl (%rax)
// File: 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 %rbp
movq %rsp, %rbp
subq $0x60, %rsp
movq %rdi, -0x50(%rbp)
movq %rdi, %rax
movq %rax, -0x48(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x10(%rbp), %rdi
callq 0x371a0
testb $0x1, %al
jne 0x36921
jmp 0x369e6
movq -0x18(%rbp), %rsi
leaq -0x20(%rbp), %rdi
xorl %edx, %edx
callq 0x22460
movq -0x18(%rbp), %rsi
leaq -0x28(%rbp), %rdi
movl $0x1, %edx
callq 0x22460
jmp 0x36944
leaq -0x20(%rbp), %rdi
leaq -0x28(%rbp), %rsi
callq 0x22530
jmp 0x36953
leaq -0x28(%rbp), %rdi
callq 0xcdc0
leaq -0x20(%rbp), %rdi
callq 0xcdc0
movq -0x18(%rbp), %rsi
leaq -0x40(%rbp), %rdi
movq %rdi, -0x60(%rbp)
xorl %edx, %edx
callq 0x22460
movq -0x60(%rbp), %rdi
callq 0x1d280
movq %rax, -0x58(%rbp)
jmp 0x36987
movq -0x58(%rbp), %rsi
movq -0x50(%rbp), %rdi
callq 0x1f4c0
jmp 0x36996
leaq -0x40(%rbp), %rdi
callq 0xcdc0
jmp 0x36a08
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x30(%rbp)
movl %eax, -0x34(%rbp)
jmp 0x369c4
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x30(%rbp)
movl %eax, -0x34(%rbp)
leaq -0x28(%rbp), %rdi
callq 0xcdc0
leaq -0x20(%rbp), %rdi
callq 0xcdc0
jmp 0x36a12
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x30(%rbp)
movl %eax, -0x34(%rbp)
leaq -0x40(%rbp), %rdi
callq 0xcdc0
jmp 0x36a12
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rsi
callq 0x22530
movq -0x10(%rbp), %rdi
callq 0x1d280
movq -0x50(%rbp), %rdi
movq %rax, %rsi
callq 0x1f4c0
movq -0x48(%rbp), %rax
addq $0x60, %rsp
popq %rbp
retq
movq -0x30(%rbp), %rdi
callq 0xc280
nopl (%rax,%rax)
// File: 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
movq %rsp, %rbp
subq $0xa0, %rsp
movq %rdi, -0x80(%rbp)
movq %rdi, %rax
movq %rax, -0x78(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x10(%rbp), %rdi
callq 0x371a0
testb $0x1, %al
jne 0x36a54
jmp 0x36b5b
movq -0x18(%rbp), %rsi
leaq -0x28(%rbp), %rdi
movq %rdi, -0x90(%rbp)
xorl %edx, %edx
callq 0x22460
movq -0x90(%rbp), %rdi
callq 0x1d280
movq %rax, -0x88(%rbp)
jmp 0x36a7f
movq -0x88(%rbp), %rax
movq %rax, -0x20(%rbp)
movq $0x0, -0x40(%rbp)
movq -0x40(%rbp), %rax
cmpq -0x20(%rbp), %rax
jae 0x36b3f
movq -0x18(%rbp), %rsi
leaq -0x50(%rbp), %rdi
movl $0x1, %edx
callq 0x22460
jmp 0x36ab4
movq -0x40(%rbp), %rdx
leaq -0x58(%rbp), %rdi
leaq -0x28(%rbp), %rsi
callq 0x1d2a0
jmp 0x36ac7
leaq -0x48(%rbp), %rdi
leaq -0x50(%rbp), %rsi
leaq -0x58(%rbp), %rdx
callq 0x225b0
jmp 0x36ada
leaq -0x48(%rbp), %rdi
callq 0xcdc0
leaq -0x58(%rbp), %rdi
callq 0xcdc0
leaq -0x50(%rbp), %rdi
callq 0xcdc0
movq -0x40(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x40(%rbp)
jmp 0x36a92
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x30(%rbp)
movl %eax, -0x34(%rbp)
jmp 0x36b4d
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x30(%rbp)
movl %eax, -0x34(%rbp)
jmp 0x36b34
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x30(%rbp)
movl %eax, -0x34(%rbp)
leaq -0x58(%rbp), %rdi
callq 0xcdc0
leaq -0x50(%rbp), %rdi
callq 0xcdc0
jmp 0x36b4d
leaq -0x28(%rbp), %rdi
callq 0xcdc0
jmp 0x36bef
leaq -0x28(%rbp), %rdi
callq 0xcdc0
jmp 0x36c09
movq -0x10(%rbp), %rdi
callq 0x1d280
movq %rax, -0x20(%rbp)
movq $0x0, -0x60(%rbp)
movq -0x60(%rbp), %rax
cmpq -0x20(%rbp), %rax
jae 0x36bed
movq -0x18(%rbp), %rax
movq %rax, -0xa0(%rbp)
movq -0x10(%rbp), %rsi
movq -0x60(%rbp), %rdx
leaq -0x70(%rbp), %rdi
movq %rdi, -0x98(%rbp)
callq 0x1d2a0
movq -0xa0(%rbp), %rsi
movq -0x98(%rbp), %rdx
leaq -0x68(%rbp), %rdi
callq 0x225b0
jmp 0x36bb6
leaq -0x68(%rbp), %rdi
callq 0xcdc0
leaq -0x70(%rbp), %rdi
callq 0xcdc0
movq -0x60(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x60(%rbp)
jmp 0x36b70
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x30(%rbp)
movl %eax, -0x34(%rbp)
leaq -0x70(%rbp), %rdi
callq 0xcdc0
jmp 0x36c09
jmp 0x36bef
movq -0x80(%rbp), %rdi
movq -0x20(%rbp), %rsi
callq 0x1f4c0
movq -0x78(%rbp), %rax
addq $0xa0, %rsp
popq %rbp
retq
movq -0x30(%rbp), %rdi
callq 0xc280
nopw %cs:(%rax,%rax)
nopl (%rax)
// File: 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 %rbp
movq %rsp, %rbp
subq $0x80, %rsp
movq %rdi, -0x68(%rbp)
movq %rdi, %rax
movq %rax, -0x60(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x10(%rbp), %rsi
leaq 0x6a90(%rip), %rdx      # 0x3ed7d
leaq -0x28(%rbp), %rdi
movq %rdi, -0x58(%rbp)
callq 0x1f930
movq -0x58(%rbp), %rdi
callq 0x38a90
movq %rax, -0x50(%rbp)
jmp 0x38309
leaq -0x28(%rbp), %rdi
callq 0xcdc0
movq -0x50(%rbp), %rax
movq %rax, -0x20(%rbp)
cmpq $0x0, -0x20(%rbp)
je 0x38346
movq -0x20(%rbp), %rdi
callq 0xc1c0
jmp 0x38346
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x30(%rbp)
movl %eax, -0x34(%rbp)
leaq -0x28(%rbp), %rdi
callq 0xcdc0
jmp 0x383ed
movq -0x10(%rbp), %rsi
leaq 0x6a2c(%rip), %rdx      # 0x3ed7d
leaq -0x40(%rbp), %rdi
movq %rdi, -0x70(%rbp)
callq 0x1f930
movq -0x70(%rbp), %rdi
xorl %esi, %esi
callq 0x224c0
jmp 0x3836b
leaq -0x40(%rbp), %rdi
callq 0xcdc0
movq -0x10(%rbp), %rsi
leaq 0x6a0e(%rip), %rdx      # 0x3ed8d
leaq -0x48(%rbp), %rdi
movq %rdi, -0x78(%rbp)
callq 0x1f930
movq -0x78(%rbp), %rdi
leaq 0x664c(%rip), %rsi      # 0x3e9e3
callq 0x38ab0
jmp 0x3839e
leaq -0x48(%rbp), %rdi
callq 0xcdc0
movq -0x68(%rbp), %rdi
movq -0x18(%rbp), %rsi
callq 0x1d4f0
movq -0x60(%rbp), %rax
addq $0x80, %rsp
popq %rbp
retq
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x30(%rbp)
movl %eax, -0x34(%rbp)
leaq -0x40(%rbp), %rdi
callq 0xcdc0
jmp 0x383ed
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x30(%rbp)
movl %eax, -0x34(%rbp)
leaq -0x48(%rbp), %rdi
callq 0xcdc0
movq -0x30(%rbp), %rdi
callq 0xc280
nopw %cs:(%rax,%rax)
// File: 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 %rbp
movq %rsp, %rbp
subq $0xa0, %rsp
movq %rdi, -0x88(%rbp)
movq %rdi, %rax
movq %rax, -0x80(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x10(%rbp), %rsi
leaq 0x645d(%rip), %rdx      # 0x3ed7d
leaq -0x28(%rbp), %rdi
movq %rdi, -0x78(%rbp)
callq 0x1f930
movq -0x78(%rbp), %rdi
callq 0x38a90
movq %rax, -0x70(%rbp)
jmp 0x3893c
leaq -0x28(%rbp), %rdi
callq 0xcdc0
movq -0x70(%rbp), %rax
movq %rax, -0x20(%rbp)
movq -0x18(%rbp), %rdi
callq 0x36640
movq %rax, -0x40(%rbp)
cmpq $0x0, -0x20(%rbp)
je 0x38968
cmpq $0x0, -0x40(%rbp)
jne 0x3899a
movq -0x88(%rbp), %rdi
leaq 0x606d(%rip), %rsi      # 0x3e9e3
callq 0xcee0
jmp 0x38a72
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x30(%rbp)
movl %eax, -0x34(%rbp)
leaq -0x28(%rbp), %rdi
callq 0xcdc0
jmp 0x38a7f
movq -0x40(%rbp), %rsi
incq %rsi
leaq -0x58(%rbp), %rdi
movq %rdi, -0x98(%rbp)
callq 0x390d0
movq -0x98(%rbp), %rdi
callq 0x39130
movq %rax, -0x90(%rbp)
jmp 0x389c6
movq -0x90(%rbp), %rax
movq %rax, -0x60(%rbp)
movq -0x60(%rbp), %rdi
movq -0x40(%rbp), %rdx
movq -0x20(%rbp), %rcx
movl $0x1, %esi
callq 0xc230
movq %rax, -0xa0(%rbp)
jmp 0x389f0
movq -0xa0(%rbp), %rsi
leaq -0x58(%rbp), %rdi
callq 0x39150
jmp 0x38a02
leaq -0x58(%rbp), %rdi
xorl %esi, %esi
callq 0x1f100
jmp 0x38a0f
movq -0x60(%rbp), %rsi
leaq -0x68(%rbp), %rdi
callq 0xc8b0
jmp 0x38a1e
movq -0x88(%rbp), %rdi
leaq -0x68(%rbp), %rsi
callq 0x26cc0
jmp 0x38a30
leaq -0x68(%rbp), %rdi
callq 0xc950
leaq -0x58(%rbp), %rdi
callq 0x39180
jmp 0x38a72
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x30(%rbp)
movl %eax, -0x34(%rbp)
jmp 0x38a67
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x30(%rbp)
movl %eax, -0x34(%rbp)
leaq -0x68(%rbp), %rdi
callq 0xc950
leaq -0x58(%rbp), %rdi
callq 0x39180
jmp 0x38a7f
movq -0x80(%rbp), %rax
addq $0xa0, %rsp
popq %rbp
retq
movq -0x30(%rbp), %rdi
callq 0xc280
nopl (%rax,%rax)
// File: 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
movq %rsp, %rbp
subq $0x80, %rsp
movq %rdi, -0x78(%rbp)
movq %rdi, %rax
movq %rax, -0x70(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x10(%rbp), %rsi
leaq 0x5500(%rip), %rdx      # 0x3ed7d
leaq -0x28(%rbp), %rdi
movq %rdi, -0x68(%rbp)
callq 0x1f930
movq -0x68(%rbp), %rdi
callq 0x38a90
movq %rax, -0x60(%rbp)
jmp 0x39899
leaq -0x28(%rbp), %rdi
callq 0xcdc0
movq -0x60(%rbp), %rax
movq %rax, -0x20(%rbp)
movq -0x18(%rbp), %rdi
callq 0x1feb0
movq -0x78(%rbp), %rdi
movl %eax, -0x38(%rbp)
movb $0x0, -0x39(%rbp)
callq 0x1a130
cmpq $0x0, -0x20(%rbp)
je 0x398d0
cmpl $0x0, -0x38(%rbp)
jne 0x398fa
movb $0x1, -0x39(%rbp)
movl $0x1, -0x40(%rbp)
jmp 0x399dc
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x30(%rbp)
movl %eax, -0x34(%rbp)
leaq -0x28(%rbp), %rdi
callq 0xcdc0
jmp 0x39a01
movl $0x0, -0x44(%rbp)
movl -0x44(%rbp), %eax
cmpl -0x38(%rbp), %eax
jge 0x39985
movq -0x20(%rbp), %rdi
callq 0xc240
movl %eax, -0x7c(%rbp)
jmp 0x39917
movl -0x7c(%rbp), %eax
movl %eax, -0x48(%rbp)
cmpl $-0x1, -0x48(%rbp)
jne 0x3993c
movl -0x44(%rbp), %eax
movl %eax, -0x38(%rbp)
jmp 0x39985
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x30(%rbp)
movl %eax, -0x34(%rbp)
jmp 0x399f8
movslq -0x48(%rbp), %rsi
leaq -0x50(%rbp), %rdi
callq 0x1f4c0
jmp 0x3994b
movq -0x78(%rbp), %rdi
leaq -0x50(%rbp), %rsi
callq 0x22530
jmp 0x3995a
leaq -0x50(%rbp), %rdi
callq 0xcdc0
movl -0x44(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x44(%rbp)
jmp 0x39901
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x30(%rbp)
movl %eax, -0x34(%rbp)
leaq -0x50(%rbp), %rdi
callq 0xcdc0
jmp 0x399f8
movq -0x78(%rbp), %rsi
movl -0x38(%rbp), %eax
movl %eax, -0x80(%rbp)
leaq 0x538f(%rip), %rdx      # 0x3ed25
leaq -0x58(%rbp), %rdi
callq 0x1f930
jmp 0x399a1
movl -0x80(%rbp), %esi
leaq -0x58(%rbp), %rdi
callq 0x224c0
jmp 0x399af
leaq -0x58(%rbp), %rdi
callq 0xcdc0
movb $0x1, -0x39(%rbp)
movl $0x1, -0x40(%rbp)
jmp 0x399dc
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x30(%rbp)
movl %eax, -0x34(%rbp)
leaq -0x58(%rbp), %rdi
callq 0xcdc0
jmp 0x399f8
testb $0x1, -0x39(%rbp)
jne 0x399eb
movq -0x78(%rbp), %rdi
callq 0xcdc0
movq -0x70(%rbp), %rax
addq $0x80, %rsp
popq %rbp
retq
movq -0x78(%rbp), %rdi
callq 0xcdc0
movq -0x30(%rbp), %rdi
callq 0xc280
nopw (%rax,%rax)
// File: 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
movq %rsp, %rbp
subq $0x90, %rsp
movq %rdi, -0x80(%rbp)
movq %rdi, %rax
movq %rax, -0x78(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x10(%rbp), %rsi
leaq 0x5340(%rip), %rdx      # 0x3ed7d
leaq -0x28(%rbp), %rdi
movq %rdi, -0x70(%rbp)
callq 0x1f930
movq -0x70(%rbp), %rdi
callq 0x38a90
movq %rax, -0x68(%rbp)
jmp 0x39a59
leaq -0x28(%rbp), %rdi
callq 0xcdc0
movq -0x68(%rbp), %rax
movq %rax, -0x20(%rbp)
movq -0x18(%rbp), %rdi
callq 0x1feb0
movq -0x80(%rbp), %rdi
movl %eax, -0x38(%rbp)
movb $0x0, -0x39(%rbp)
callq 0x1a130
cmpq $0x0, -0x20(%rbp)
je 0x39a90
cmpl $0x0, -0x38(%rbp)
jne 0x39aba
movb $0x1, -0x39(%rbp)
movl $0x1, -0x40(%rbp)
jmp 0x39bbc
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x30(%rbp)
movl %eax, -0x34(%rbp)
leaq -0x28(%rbp), %rdi
callq 0xcdc0
jmp 0x39be1
movl $0x0, -0x44(%rbp)
movl -0x44(%rbp), %eax
cmpl -0x38(%rbp), %eax
jge 0x39b5f
movq -0x20(%rbp), %rcx
leaq -0x50(%rbp), %rdi
movl $0x8, %esi
movl $0x1, %edx
callq 0xc230
movq %rax, -0x88(%rbp)
jmp 0x39aed
movq -0x88(%rbp), %rax
cmpq $0x0, %rax
jne 0x39b13
movl -0x44(%rbp), %eax
movl %eax, -0x38(%rbp)
jmp 0x39b5f
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x30(%rbp)
movl %eax, -0x34(%rbp)
jmp 0x39bd8
movq -0x50(%rbp), %rsi
leaq -0x58(%rbp), %rdi
callq 0x1f4c0
jmp 0x39b22
movq -0x80(%rbp), %rdi
leaq -0x58(%rbp), %rsi
callq 0x22530
jmp 0x39b31
leaq -0x58(%rbp), %rdi
callq 0xcdc0
movl -0x44(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x44(%rbp)
jmp 0x39ac1
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x30(%rbp)
movl %eax, -0x34(%rbp)
leaq -0x58(%rbp), %rdi
callq 0xcdc0
jmp 0x39bd8
movq -0x80(%rbp), %rsi
movl -0x38(%rbp), %eax
movl %eax, -0x8c(%rbp)
leaq 0x51b2(%rip), %rdx      # 0x3ed25
leaq -0x60(%rbp), %rdi
callq 0x1f930
jmp 0x39b7e
movl -0x8c(%rbp), %esi
leaq -0x60(%rbp), %rdi
callq 0x224c0
jmp 0x39b8f
leaq -0x60(%rbp), %rdi
callq 0xcdc0
movb $0x1, -0x39(%rbp)
movl $0x1, -0x40(%rbp)
jmp 0x39bbc
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x30(%rbp)
movl %eax, -0x34(%rbp)
leaq -0x60(%rbp), %rdi
callq 0xcdc0
jmp 0x39bd8
testb $0x1, -0x39(%rbp)
jne 0x39bcb
movq -0x80(%rbp), %rdi
callq 0xcdc0
movq -0x78(%rbp), %rax
addq $0x90, %rsp
popq %rbp
retq
movq -0x80(%rbp), %rdi
callq 0xcdc0
movq -0x30(%rbp), %rdi
callq 0xc280
nopw (%rax,%rax)
// File: 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 %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x38(%rbp)
movq -0x18(%rbp), %rdi
callq 0x23050
movq %rax, %rdi
leaq 0x4bfe(%rip), %rsi      # 0x3eda9
callq 0xc200
movq %rax, -0x20(%rbp)
cmpq $0x0, -0x20(%rbp)
jne 0x3a1c4
movl $0x1, -0x4(%rbp)
jmp 0x3a224
movq -0x20(%rbp), %rdi
xorl %eax, %eax
movl %eax, %esi
movl $0x2, %edx
callq 0xc1f0
movq -0x20(%rbp), %rdi
callq 0xc030
movq %rax, -0x28(%rbp)
cmpq $0x0, -0x28(%rbp)
jge 0x3a1f2
movq $0x0, -0x28(%rbp)
movq -0x20(%rbp), %rdi
xorl %eax, %eax
movl %eax, %esi
xorl %edx, %edx
callq 0xc1f0
movq -0x38(%rbp), %rdi
movq -0x20(%rbp), %rsi
movq -0x28(%rbp), %rdx
callq 0x3a320
movl %eax, -0x2c(%rbp)
movq -0x20(%rbp), %rdi
callq 0xc1c0
movl -0x2c(%rbp), %eax
movl %eax, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x40, %rsp
popq %rbp
retq
nopl (%rax)
// File: 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
movq %rsp, %rbp
subq $0x60, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x60(%rbp)
movq -0x18(%rbp), %rsi
leaq -0x28(%rbp), %rdi
movq %rdi, -0x58(%rbp)
callq 0x22de0
leaq -0x30(%rbp), %rdi
movq %rdi, -0x50(%rbp)
callq 0x1a130
movq -0x58(%rbp), %rdi
movq -0x50(%rbp), %rsi
callq 0x22e00
jmp 0x3a275
leaq -0x28(%rbp), %rdi
callq 0x22f90
cmpl $0x0, %eax
je 0x3a29e
movb $0x1, -0x1(%rbp)
movl $0x1, -0x40(%rbp)
jmp 0x3a2f8
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x38(%rbp)
movl %eax, -0x3c(%rbp)
jmp 0x3a30c
movq -0x60(%rbp), %rsi
leaq -0x48(%rbp), %rdi
callq 0xcd50
jmp 0x3a2ad
leaq -0x48(%rbp), %rdi
leaq -0x30(%rbp), %rsi
callq 0x3a530
jmp 0x3a2bc
movq -0x60(%rbp), %rsi
leaq -0x48(%rbp), %rdi
callq 0x343f0
jmp 0x3a2cb
movb $0x0, -0x1(%rbp)
movl $0x1, -0x40(%rbp)
leaq -0x48(%rbp), %rdi
callq 0xcdc0
jmp 0x3a2f8
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x38(%rbp)
movl %eax, -0x3c(%rbp)
leaq -0x48(%rbp), %rdi
callq 0xcdc0
jmp 0x3a30c
leaq -0x30(%rbp), %rdi
callq 0xcdc0
movb -0x1(%rbp), %al
andb $0x1, %al
addq $0x60, %rsp
popq %rbp
retq
leaq -0x30(%rbp), %rdi
callq 0xcdc0
movq -0x38(%rbp), %rdi
callq 0xc280
nop
// File: 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
movq %rsp, %rbp
subq $0x70, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x58(%rbp)
movq -0x18(%rbp), %rcx
leaq -0x28(%rbp), %rdi
movl $0x1, %esi
movl $0x8, %edx
callq 0xc230
movl $0xbcdef01a, %eax       # imm = 0xBCDEF01A
cmpq %rax, -0x28(%rbp)
je 0x3a367
movl $0x3, -0x4(%rbp)
jmp 0x3a3de
movq -0x20(%rbp), %rax
addq $-0x8, %rax
movq %rax, -0x20(%rbp)
movq -0x20(%rbp), %rsi
leaq -0x40(%rbp), %rdi
movq %rdi, -0x60(%rbp)
callq 0x390d0
movq -0x60(%rbp), %rdi
callq 0x39130
movq %rax, %rdi
movq -0x20(%rbp), %rdx
movq -0x18(%rbp), %rcx
movl $0x1, %esi
callq 0xc230
jmp 0x3a3a4
movq -0x58(%rbp), %rdi
leaq -0x40(%rbp), %rsi
callq 0x3a3f0
movl %eax, -0x64(%rbp)
jmp 0x3a3b6
movl -0x64(%rbp), %eax
movl %eax, -0x4(%rbp)
leaq -0x40(%rbp), %rdi
callq 0x39180
jmp 0x3a3de
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x48(%rbp)
movl %eax, -0x4c(%rbp)
leaq -0x40(%rbp), %rdi
callq 0x39180
jmp 0x3a3e7
movl -0x4(%rbp), %eax
addq $0x70, %rsp
popq %rbp
retq
movq -0x48(%rbp), %rdi
callq 0xc280
// File: 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 %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x40(%rbp)
leaq -0x18(%rbp), %rdi
movq %rdi, -0x38(%rbp)
callq 0x1a130
movq -0x38(%rbp), %rsi
movq -0x10(%rbp), %rdi
callq 0x3a4a0
jmp 0x3a424
movq -0x40(%rbp), %rsi
leaq -0x30(%rbp), %rdi
callq 0xcd50
jmp 0x3a433
leaq -0x30(%rbp), %rdi
leaq -0x18(%rbp), %rsi
callq 0x3a530
jmp 0x3a442
movq -0x40(%rbp), %rsi
leaq -0x30(%rbp), %rdi
callq 0x343f0
jmp 0x3a451
leaq -0x30(%rbp), %rdi
callq 0xcdc0
leaq -0x18(%rbp), %rdi
callq 0xcdc0
xorl %eax, %eax
addq $0x40, %rsp
popq %rbp
retq
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x20(%rbp)
movl %eax, -0x24(%rbp)
jmp 0x3a48e
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x20(%rbp)
movl %eax, -0x24(%rbp)
leaq -0x30(%rbp), %rdi
callq 0xcdc0
leaq -0x18(%rbp), %rdi
callq 0xcdc0
movq -0x20(%rbp), %rdi
callq 0xc280
// File: Silica[P]PSL/./PSL/bytecode.h
// Function: PSL::variable::Variable::bcreader::read(PSL::variable::Variable::bytecode&, PSL::variable&)
static void read(bytecode &b, variable &v)
	{
		bytecode::byte *byte = b.get();
		bytecode::byte *end = byte + b.size();
		if (b.size() < 2 || byte[0] != OpCode::MNEMONIC::BEGIN || byte[1] != 0)
			return;
		byte += 2;
		readcode(byte, end, v);
	}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rdi
callq 0x39130
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rax
movq %rax, -0x28(%rbp)
movq -0x8(%rbp), %rdi
callq 0x3a560
movq %rax, %rcx
movq -0x28(%rbp), %rax
addq %rcx, %rax
movq %rax, -0x20(%rbp)
movq -0x8(%rbp), %rdi
callq 0x3a560
cmpq $0x2, %rax
jb 0x3a506
movq -0x18(%rbp), %rax
movzbl (%rax), %eax
cmpl $0xf1, %eax
jne 0x3a506
movq -0x18(%rbp), %rax
movzbl 0x1(%rax), %eax
cmpl $0x0, %eax
je 0x3a508
jmp 0x3a525
movq -0x18(%rbp), %rax
addq $0x2, %rax
movq %rax, -0x18(%rbp)
movq -0x20(%rbp), %rsi
movq -0x10(%rbp), %rdx
leaq -0x18(%rbp), %rdi
callq 0x3a580
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: 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 %rbp
movq %rsp, %rbp
subq $0x70, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x10(%rbp), %rsi
leaq -0x20(%rbp), %rdi
movq %rdi, -0x58(%rbp)
callq 0x11950
movq -0x58(%rbp), %rsi
leaq -0x18(%rbp), %rdi
callq 0xcd50
jmp 0x3cae0
leaq -0x20(%rbp), %rdi
callq 0xcd90
movq -0x10(%rbp), %rsi
leaq -0x40(%rbp), %rdi
callq 0x11950
jmp 0x3caf8
leaq -0x38(%rbp), %rdi
leaq -0x40(%rbp), %rsi
callq 0xcd50
jmp 0x3cb07
leaq -0x40(%rbp), %rdi
callq 0xcd90
leaq -0x38(%rbp), %rdi
callq 0x1fef0
movb %al, -0x59(%rbp)
jmp 0x3cb1e
movb -0x59(%rbp), %cl
xorl %eax, %eax
testb $0x1, %cl
movb %al, -0x5a(%rbp)
jne 0x3cb2d
jmp 0x3cb43
leaq -0x18(%rbp), %rdi
callq 0x1fef0
movb %al, -0x5b(%rbp)
jmp 0x3cb3b
movb -0x5b(%rbp), %al
movb %al, -0x5a(%rbp)
jmp 0x3cb43
movb -0x5a(%rbp), %al
movzbl %al, %esi
andl $0x1, %esi
leaq -0x48(%rbp), %rdi
callq 0x2ce70
jmp 0x3cb57
movq -0x10(%rbp), %rax
movq %rax, -0x68(%rbp)
leaq -0x50(%rbp), %rdi
leaq -0x48(%rbp), %rsi
callq 0x11b10
jmp 0x3cb6e
movq -0x68(%rbp), %rdi
leaq -0x50(%rbp), %rsi
callq 0x11aa0
jmp 0x3cb7d
leaq -0x50(%rbp), %rdi
callq 0xcd90
leaq -0x48(%rbp), %rdi
callq 0xcdc0
leaq -0x38(%rbp), %rdi
callq 0xcdc0
leaq -0x18(%rbp), %rdi
callq 0xcdc0
xorl %eax, %eax
addq $0x70, %rsp
popq %rbp
retq
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x28(%rbp)
movl %eax, -0x2c(%rbp)
leaq -0x20(%rbp), %rdi
callq 0xcd90
jmp 0x3cc31
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x28(%rbp)
movl %eax, -0x2c(%rbp)
jmp 0x3cc28
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x28(%rbp)
movl %eax, -0x2c(%rbp)
leaq -0x40(%rbp), %rdi
callq 0xcd90
jmp 0x3cc28
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x28(%rbp)
movl %eax, -0x2c(%rbp)
jmp 0x3cc1f
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x28(%rbp)
movl %eax, -0x2c(%rbp)
jmp 0x3cc16
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x28(%rbp)
movl %eax, -0x2c(%rbp)
leaq -0x50(%rbp), %rdi
callq 0xcd90
leaq -0x48(%rbp), %rdi
callq 0xcdc0
leaq -0x38(%rbp), %rdi
callq 0xcdc0
leaq -0x18(%rbp), %rdi
callq 0xcdc0
movq -0x28(%rbp), %rdi
callq 0xc280
nopw (%rax,%rax)
// File: 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 %rbp
movq %rsp, %rbp
subq $0x70, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x58(%rbp)
leaq -0x28(%rbp), %rdi
callq 0x3d060
movq -0x58(%rbp), %rdi
callq 0x12060
movq %rax, -0x50(%rbp)
leaq 0x1a4e(%rip), %rsi      # 0x3e9e3
leaq -0x30(%rbp), %rdi
callq 0xc8b0
jmp 0x3cfa0
movq -0x50(%rbp), %rdi
leaq -0x30(%rbp), %rsi
leaq -0x28(%rbp), %rdx
callq 0x17810
jmp 0x3cfb3
leaq -0x30(%rbp), %rdi
callq 0xc950
movl $0xbcdef01a, %eax       # imm = 0xBCDEF01A
movq %rax, -0x48(%rbp)
movq -0x10(%rbp), %rcx
leaq -0x48(%rbp), %rdi
movl $0x1, %esi
movl $0x8, %edx
callq 0xc2b0
jmp 0x3cfde
leaq -0x28(%rbp), %rdi
movq %rdi, -0x68(%rbp)
callq 0x39130
movq -0x68(%rbp), %rdi
movq %rax, -0x60(%rbp)
callq 0x3a560
movq -0x60(%rbp), %rdi
movq %rax, %rdx
movq -0x10(%rbp), %rcx
movl $0x1, %esi
callq 0xc2b0
jmp 0x3d00f
leaq -0x28(%rbp), %rdi
callq 0x39180
xorl %eax, %eax
addq $0x70, %rsp
popq %rbp
retq
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x38(%rbp)
movl %eax, -0x3c(%rbp)
jmp 0x3d043
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x38(%rbp)
movl %eax, -0x3c(%rbp)
leaq -0x30(%rbp), %rdi
callq 0xc950
leaq -0x28(%rbp), %rdi
callq 0x39180
movq -0x38(%rbp), %rdi
callq 0xc280
nopw %cs:(%rax,%rax)
nop
// File: 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
subq $0x10, %rsp
movl $0x0, -0x4(%rbp)
cmpl $0x637, -0x4(%rbp)      # imm = 0x637
jge 0x261fc
movslq -0x4(%rbp), %rcx
leaq 0xfebd(%rip), %rax      # 0x36050
shlq $0x5, %rcx
addq %rcx, %rax
movq 0x10(%rax), %rdi
xorl %eax, %eax
movl %eax, %esi
movl $0xa, %edx
callq 0x26060
movl %eax, -0x8(%rbp)
cmpl $0x0, -0x8(%rbp)
je 0x261dc
movslq -0x4(%rbp), %rcx
leaq 0xfe90(%rip), %rax      # 0x36050
shlq $0x5, %rcx
addq %rcx, %rax
movq 0x8(%rax), %rdx
movslq -0x8(%rbp), %rcx
leaq 0x1ff5a(%rip), %rax     # 0x46130
movq %rdx, (%rax,%rcx,8)
jmp 0x261ef
movslq -0x8(%rbp), %rcx
leaq 0x1ff49(%rip), %rax     # 0x46130
movq $0x0, (%rax,%rcx,8)
jmp 0x261f1
movl -0x4(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x4(%rbp)
jmp 0x2617f
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: 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
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq $0x0, -0x10(%rbp)
movq -0x8(%rbp), %rdi
leaq -0x10(%rbp), %rsi
movl $0x10, %edx
callq 0x26060
movl %eax, 0x23ef4(%rip)     # 0x4a130
movq -0x10(%rbp), %rdi
leaq -0x10(%rbp), %rsi
movl $0x10, %edx
callq 0x26060
movl %eax, 0x23ee0(%rip)     # 0x4a134
movq -0x10(%rbp), %rdi
leaq -0x10(%rbp), %rsi
movl $0x10, %edx
callq 0x26060
movl %eax, 0x23ecc(%rip)     # 0x4a138
movq -0x10(%rbp), %rdi
leaq -0x10(%rbp), %rsi
movl $0x10, %edx
callq 0x26060
movl %eax, 0x23eb8(%rip)     # 0x4a13c
addq $0x10, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: 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
subq $0x40, %rsp
movl $0x0, -0x4(%rbp)
callq 0x26170
leaq -0x30(%rbp), %rdi
movq 0xfd01(%rip), %rax      # 0x35fe0
movq (%rax), %rdx
movl $0x20, %esi
callq 0x26050
cmpq $0x0, %rax
je 0x2636b
leaq -0x30(%rbp), %rdi
callq 0x26030
movl %eax, -0x34(%rbp)
movslq -0x34(%rbp), %rax
movb $0x0, -0x31(%rbp,%rax)
leaq -0x30(%rbp), %rdi
callq 0x26210
movl 0x23e1e(%rip), %eax     # 0x4a134
andl $0xf800, %eax           # imm = 0xF800
cmpl $0x8000, %eax           # imm = 0x8000
jne 0x26354
movl 0x23e0c(%rip), %eax     # 0x4a134
andl $0x1f, %eax
cmpl $0x8, %eax
jne 0x26354
leaq -0x30(%rbp), %rax
movq %rax, -0x40(%rbp)
callq 0x26290
movq -0x40(%rbp), %rsi
movq %rax, %rdx
leaq 0xd9dd(%rip), %rdi      # 0x33d28
movb $0x0, %al
callq 0x26040
jmp 0x26366
leaq -0x30(%rbp), %rsi
leaq 0xd9d0(%rip), %rdi      # 0x33d2f
movb $0x0, %al
callq 0x26040
jmp 0x262d4
xorl %eax, %eax
addq $0x40, %rsp
popq %rbp
retq
// File: 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
subq $0x50, %rsp
movq %rdi, -0x8(%rbp)
movl $0xa0, %edi
callq 0x5410
movq %rax, %rdi
movq %rdi, %rax
movq %rax, -0x38(%rbp)
movq -0x8(%rbp), %rsi
callq 0xac40
jmp 0x98eb
movq -0x38(%rbp), %rax
movq %rax, -0x10(%rbp)
movq $0x1, -0x28(%rbp)
movq -0x28(%rbp), %rax
movq %rax, -0x40(%rbp)
movq -0x8(%rbp), %rdi
callq 0xa680
movq %rax, %rcx
movq -0x40(%rbp), %rax
cmpq %rcx, %rax
ja 0x994a
movq -0x28(%rbp), %rsi
movq -0x10(%rbp), %rdi
callq 0x24800
movq -0x28(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x28(%rbp)
jmp 0x98fb
movq -0x38(%rbp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x18(%rbp)
movl %eax, -0x1c(%rbp)
callq 0x53a0
jmp 0x9994
movq $0x1, -0x30(%rbp)
movq -0x30(%rbp), %rax
movq %rax, -0x48(%rbp)
movq -0x8(%rbp), %rdi
callq 0xa740
movq %rax, %rcx
movq -0x48(%rbp), %rax
cmpq %rcx, %rax
ja 0x998a
movq -0x10(%rbp), %rdi
movq -0x30(%rbp), %rsi
callq 0xac90
movq -0x30(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x30(%rbp)
jmp 0x9952
movq -0x10(%rbp), %rax
addq $0x50, %rsp
popq %rbp
retq
movq -0x18(%rbp), %rdi
callq 0x5750
nopl (%rax)
// File: 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
subq $0xb0, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x70(%rbp)
addq $0x38, %rdi
movl $0x3e, %esi
callq 0x54a0
movq %rax, -0x80(%rbp)
movq -0x10(%rbp), %rdi
callq 0x11ce0
movq -0x80(%rbp), %rdi
movq %rax, %rsi
callq 0x5360
movq %rax, %rdi
movl $0x20, %esi
callq 0x54a0
movq %rax, -0x78(%rbp)
movq -0x10(%rbp), %rdi
callq 0x11d00
movq -0x78(%rbp), %rdi
movq %rax, %rsi
callq 0x5360
movq %rax, %rdi
movq 0x4255e(%rip), %rsi     # 0x4cf90
callq 0x5440
movq -0x10(%rbp), %rdi
callq 0xabe0
movq %rax, %rsi
leaq -0x30(%rbp), %rdi
callq 0x11d20
movq -0x70(%rbp), %rax
movq 0x28(%rax), %rcx
addq $0x1, %rcx
movq %rcx, 0x28(%rax)
movq $0x0, -0x38(%rbp)
movq -0x38(%rbp), %rax
movq %rax, -0x88(%rbp)
leaq -0x30(%rbp), %rdi
callq 0x52c0
movq %rax, %rcx
movq -0x88(%rbp), %rax
cmpq %rcx, %rax
ja 0xab9f
movq -0x70(%rbp), %rcx
movq %rcx, %rax
addq $0x38, %rax
movq %rax, -0xa0(%rbp)
movq -0x38(%rbp), %rax
movq %rax, -0x98(%rbp)
movq -0x38(%rbp), %rax
addq 0x238(%rcx), %rax
movq %rax, -0x90(%rbp)
leaq -0x30(%rbp), %rdi
callq 0x52c0
movq %rax, %rcx
movq -0x90(%rbp), %rax
cmpq %rcx, %rax
ja 0xaae6
movq -0x70(%rbp), %rax
movq 0x238(%rax), %rax
movq %rax, -0xa8(%rbp)
jmp 0xaafe
leaq -0x30(%rbp), %rdi
callq 0x52c0
subq -0x38(%rbp), %rax
addq $0x1, %rax
movq %rax, -0xa8(%rbp)
movq -0x98(%rbp), %rdx
movq -0xa8(%rbp), %rcx
leaq -0x58(%rbp), %rdi
leaq -0x30(%rbp), %rsi
callq 0x5420
jmp 0xab1b
movq -0xa0(%rbp), %rdi
leaq -0x58(%rbp), %rsi
callq 0x5360
movq %rax, -0xb0(%rbp)
jmp 0xab34
movq -0xb0(%rbp), %rdi
movq 0x4244e(%rip), %rsi     # 0x4cf90
callq 0x5440
jmp 0xab49
leaq -0x58(%rbp), %rdi
callq 0x5250
movq -0x70(%rbp), %rax
movq 0x28(%rax), %rcx
addq $0x1, %rcx
movq %rcx, 0x28(%rax)
movq -0x70(%rbp), %rax
movq 0x238(%rax), %rax
addq -0x38(%rbp), %rax
movq %rax, -0x38(%rbp)
jmp 0xaa64
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x60(%rbp)
movl %eax, -0x64(%rbp)
jmp 0xabc1
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x60(%rbp)
movl %eax, -0x64(%rbp)
leaq -0x58(%rbp), %rdi
callq 0x5250
jmp 0xabc1
movq -0x70(%rbp), %rax
movq 0x30(%rax), %rcx
addq $0x1, %rcx
movq %rcx, 0x30(%rax)
leaq -0x30(%rbp), %rdi
callq 0x5250
addq $0xb0, %rsp
popq %rbp
retq
leaq -0x30(%rbp), %rdi
callq 0x5250
movq -0x60(%rbp), %rdi
callq 0x5750
nopw %cs:(%rax,%rax)
nopl (%rax)
// File: 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
subq $0xc0, %rsp
movq %rsi, -0xa0(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x98(%rbp)
movq (%rdi), %rax
movq 0x10(%rax), %rax
callq *%rax
movq -0xa0(%rbp), %rsi
leaq -0x30(%rbp), %rdi
movq %rdi, -0x90(%rbp)
callq 0x51a0
movq -0x98(%rbp), %rdi
movq -0x90(%rbp), %rsi
callq 0xe2b0
jmp 0xde6a
leaq -0x30(%rbp), %rdi
callq 0x5250
movq -0xa0(%rbp), %rdi
movq -0x98(%rbp), %rax
addq $0x38, %rax
movq %rax, -0xa8(%rbp)
callq 0x5190
movq -0xa8(%rbp), %rdi
movq %rax, %rsi
movl $0x10, %edx
callq 0x5080
movq -0x98(%rbp), %rax
movq %rax, %rdi
addq $0x38, %rdi
movq 0x38(%rax), %rax
addq -0x18(%rax), %rdi
callq 0x5030
testb $0x1, %al
jne 0xdec9
jmp 0xdfdd
movb $0x1, -0x82(%rbp)
movl $0x28, %edi
callq 0x51e0
movq -0xa0(%rbp), %rsi
movq %rax, -0xb0(%rbp)
leaq -0x60(%rbp), %rdi
callq 0x51a0
jmp 0xdef3
leaq -0x81(%rbp), %rdi
movq %rdi, -0xb8(%rbp)
callq 0x5760
movq -0xb8(%rbp), %rdx
leaq 0x275c4(%rip), %rsi     # 0x354d8
leaq -0x80(%rbp), %rdi
callq 0x55b0
jmp 0xdf1f
movq -0xb0(%rbp), %rdi
leaq 0x275bf(%rip), %rcx     # 0x354ec
xorl %eax, %eax
movl %eax, %r8d
leaq -0x60(%rbp), %rsi
leaq -0x80(%rbp), %rdx
callq 0xe310
jmp 0xdf41
movq -0xb0(%rbp), %rdi
movb $0x0, -0x82(%rbp)
leaq 0x3e9f2(%rip), %rsi     # 0x4c948
leaq 0xb93(%rip), %rdx       # 0xeaf0
callq 0x5700
jmp 0xdfef
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x38(%rbp)
movl %eax, -0x3c(%rbp)
leaq -0x30(%rbp), %rdi
callq 0x5250
jmp 0xdfe6
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x38(%rbp)
movl %eax, -0x3c(%rbp)
jmp 0xdfc4
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x38(%rbp)
movl %eax, -0x3c(%rbp)
jmp 0xdfaf
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x38(%rbp)
movl %eax, -0x3c(%rbp)
leaq -0x80(%rbp), %rdi
callq 0x5250
leaq -0x81(%rbp), %rdi
callq 0x5460
leaq -0x60(%rbp), %rdi
callq 0x5250
testb $0x1, -0x82(%rbp)
jne 0xdfcf
jmp 0xdfdb
movq -0xb0(%rbp), %rdi
callq 0x52d0
jmp 0xdfe6
addq $0xc0, %rsp
popq %rbp
retq
movq -0x38(%rbp), %rdi
callq 0x5750
nop
// File: CK7[P]abawaca/src/SeqIOWrite.h
// Function: Bio::SeqIOWrite<Bio::Sequence<Bio::DNAString>>::restart()
void SeqIOWrite<S>::restart()
{
	SeqIO::restart();

	m_fp.close();
	m_fp.open(this->file_name().c_str());

	if(m_fp.fail())
		throw Bio::Bad_file(this->file_name(), "Failed to re-open file", __PRETTY_FUNCTION__);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0xb0, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x98(%rbp)
callq 0xe2f0
movq -0x98(%rbp), %rdi
addq $0x38, %rdi
movq %rdi, -0x88(%rbp)
callq 0x5600
movq -0x98(%rbp), %rsi
leaq -0x28(%rbp), %rdi
movq %rdi, -0x90(%rbp)
callq 0xef70
movq -0x90(%rbp), %rdi
callq 0x5190
movq -0x88(%rbp), %rdi
movq %rax, %rsi
movl $0x10, %edx
callq 0x5080
jmp 0xe05f
leaq -0x28(%rbp), %rdi
callq 0x5250
movq -0x98(%rbp), %rax
movq %rax, %rdi
addq $0x38, %rdi
movq 0x38(%rax), %rax
addq -0x18(%rax), %rdi
callq 0x5030
testb $0x1, %al
jne 0xe08c
jmp 0xe191
movb $0x1, -0x7a(%rbp)
movl $0x28, %edi
callq 0x51e0
movq -0x98(%rbp), %rsi
movq %rax, -0xa0(%rbp)
leaq -0x58(%rbp), %rdi
callq 0xef70
jmp 0xe0b3
leaq -0x79(%rbp), %rdi
movq %rdi, -0xa8(%rbp)
callq 0x5760
movq -0xa8(%rbp), %rdx
leaq 0x274ec(%rip), %rsi     # 0x355bd
leaq -0x78(%rbp), %rdi
callq 0x55b0
jmp 0xe0dc
movq -0xa0(%rbp), %rdi
leaq 0x274ea(%rip), %rcx     # 0x355d4
xorl %eax, %eax
movl %eax, %r8d
leaq -0x58(%rbp), %rsi
leaq -0x78(%rbp), %rdx
callq 0xe310
jmp 0xe0fe
movq -0xa0(%rbp), %rdi
movb $0x0, -0x7a(%rbp)
leaq 0x3e838(%rip), %rsi     # 0x4c948
leaq 0x9d9(%rip), %rdx       # 0xeaf0
callq 0x5700
jmp 0xe1a3
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x30(%rbp)
movl %eax, -0x34(%rbp)
leaq -0x28(%rbp), %rdi
callq 0x5250
jmp 0xe19a
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x30(%rbp)
movl %eax, -0x34(%rbp)
jmp 0xe17b
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x30(%rbp)
movl %eax, -0x34(%rbp)
jmp 0xe169
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x30(%rbp)
movl %eax, -0x34(%rbp)
leaq -0x78(%rbp), %rdi
callq 0x5250
leaq -0x79(%rbp), %rdi
callq 0x5460
leaq -0x58(%rbp), %rdi
callq 0x5250
testb $0x1, -0x7a(%rbp)
jne 0xe183
jmp 0xe18f
movq -0xa0(%rbp), %rdi
callq 0x52d0
jmp 0xe19a
addq $0xb0, %rsp
popq %rbp
retq
movq -0x30(%rbp), %rdi
callq 0x5750
nopw %cs:(%rax,%rax)
nopl (%rax)
// File: CK7[P]abawaca/src/TinyMT-src-1.0.1/tinymt/tinymt32.c
// Function: tinymt32_init(TINYMT32_T*, unsigned int)
void tinymt32_init(tinymt32_t * random, uint32_t seed) {
    random->status[0] = seed;
    random->status[1] = random->mat1;
    random->status[2] = random->mat2;
    random->status[3] = random->tmat;
    for (int i = 1; i < MIN_LOOP; i++) {
	random->status[i & 3] ^= i + UINT32_C(1812433253)
	    * (random->status[(i - 1) & 3]
	       ^ (random->status[(i - 1) & 3] >> 30));
    }
    period_certification(random);
    for (int i = 0; i < PRE_LOOP; i++) {
	tinymt32_next_state(random);
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movl -0xc(%rbp), %ecx
movq -0x8(%rbp), %rax
movl %ecx, (%rax)
movq -0x8(%rbp), %rax
movl 0x10(%rax), %ecx
movq -0x8(%rbp), %rax
movl %ecx, 0x4(%rax)
movq -0x8(%rbp), %rax
movl 0x14(%rax), %ecx
movq -0x8(%rbp), %rax
movl %ecx, 0x8(%rax)
movq -0x8(%rbp), %rax
movl 0x18(%rax), %ecx
movq -0x8(%rbp), %rax
movl %ecx, 0xc(%rax)
movl $0x1, -0x10(%rbp)
cmpl $0x8, -0x10(%rbp)
jge 0x11df3
movl -0x10(%rbp), %edx
movq -0x8(%rbp), %rax
movl -0x10(%rbp), %ecx
subl $0x1, %ecx
andl $0x3, %ecx
movslq %ecx, %rcx
movl (%rax,%rcx,4), %eax
movq -0x8(%rbp), %rcx
movl -0x10(%rbp), %esi
subl $0x1, %esi
andl $0x3, %esi
movslq %esi, %rsi
movl (%rcx,%rsi,4), %ecx
shrl $0x1e, %ecx
xorl %ecx, %eax
imull $0x6c078965, %eax, %eax # imm = 0x6C078965
addl %eax, %edx
movq -0x8(%rbp), %rax
movl -0x10(%rbp), %ecx
andl $0x3, %ecx
movslq %ecx, %rcx
xorl (%rax,%rcx,4), %edx
movl %edx, (%rax,%rcx,4)
movl -0x10(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x10(%rbp)
jmp 0x11d99
movq -0x8(%rbp), %rdi
callq 0x11e30
movl $0x0, -0x14(%rbp)
cmpl $0x8, -0x14(%rbp)
jge 0x11e1d
movq -0x8(%rbp), %rdi
callq 0x11ea0
movl -0x14(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x14(%rbp)
jmp 0x11e03
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)