LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: Silica[P]PSL/./PSL/parser.h
// Function: PSL::variable::Parser::ParseBlock(PSL::variable&, PSL::variable&)
void ParseBlock(variable &g, variable &c)
	{
		int line = t->getLine();
		while (int n = t->checkNext())
		{
			if (n == /*'{'*/'}')
			{
				t->getNext();
				return;
			}
			ParseStatement(g, c);
		}
		Error(BINC, line);
	}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x28(%rbp)
movq (%rax), %rdi
callq 0x280c0
movl %eax, -0x1c(%rbp)
movq -0x28(%rbp), %rax
movq (%rax), %rdi
callq 0x232e0
movl %eax, -0x20(%rbp)
cmpl $0x0, -0x20(%rbp)
je 0x27003
cmpl $0x7d, -0x20(%rbp)
jne 0x26ff0
movq -0x28(%rbp), %rax
movq (%rax), %rdi
callq 0x26620
jmp 0x27021
movq -0x28(%rbp), %rdi
movq -0x10(%rbp), %rsi
movq -0x18(%rbp), %rdx
callq 0x23330
jmp 0x26fc7
movq -0x28(%rbp), %rdi
movl -0x1c(%rbp), %edx
movl $0xc, %esi
leaq 0x179cd(%rip), %rcx     # 0x3e9e3
movl $0xffffffff, %r8d       # imm = 0xFFFFFFFF
callq 0x27d80
addq $0x30, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: Silica[P]PSL/./PSL/parser.h
// Function: PSL::variable::Parser::ParseExpression(PSL::variable&, char, bool)
void ParseExpression(variable &c, char e, bool l = false)
	{
		getexp13(c, l);
		if (!t->getNextIf(e))
			if (e != ';' || t->checkNext() != /*'{'*/'}')
				Error(TINAE, e, "", t->getPrevLine());
	}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movb %cl, %al
movb %dl, %cl
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movb %cl, -0x11(%rbp)
andb $0x1, %al
movb %al, -0x12(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x20(%rbp)
movq -0x10(%rbp), %rsi
movb -0x12(%rbp), %al
andb $0x1, %al
movzbl %al, %edx
callq 0x28b00
movq -0x20(%rbp), %rax
movq (%rax), %rdi
movsbl -0x11(%rbp), %esi
callq 0x27d30
testb $0x1, %al
jne 0x271e3
movsbl -0x11(%rbp), %eax
cmpl $0x3b, %eax
jne 0x271b3
movq -0x20(%rbp), %rax
movq (%rax), %rdi
callq 0x232e0
cmpl $0x7d, %eax
je 0x271e1
movq -0x20(%rbp), %rax
movsbl -0x11(%rbp), %ecx
movl %ecx, -0x24(%rbp)
movq (%rax), %rdi
callq 0x29070
movq -0x20(%rbp), %rdi
movl -0x24(%rbp), %edx
movl %eax, %r8d
movl $0x9, %esi
leaq 0x17807(%rip), %rcx     # 0x3e9e3
callq 0x27d80
jmp 0x271e3
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax)
// File: Silica[P]PSL/./PSL/tokenizer.h
// Function: PSL::variable::Tokenizer::getNextIf(int)
bool getNextIf(int t)
	{
		if (checkNext() == t)
		{
			next = UNSET;
			return true;
		}
		return false;
	}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movl %esi, -0x14(%rbp)
movq -0x10(%rbp), %rdi
movq %rdi, -0x20(%rbp)
callq 0x232e0
cmpl -0x14(%rbp), %eax
jne 0x27d62
movq -0x20(%rbp), %rax
movl $0xffffffff, 0x38(%rax) # imm = 0xFFFFFFFF
movb $0x1, -0x1(%rbp)
jmp 0x27d66
movb $0x0, -0x1(%rbp)
movb -0x1(%rbp), %al
andb $0x1, %al
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
nopl (%rax,%rax)
// File: Silica[P]PSL/./PSL/scope.h
// Function: PSL::variable::Variable::AnonymousScope::Return()
virtual Scope *Return()
	{
		Scope *s = owner->Return();
		owner = NULL;
		delete this;
		return s;
	}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x18(%rbp)
movq 0x10(%rax), %rdi
movq (%rdi), %rax
callq *0x20(%rax)
movq %rax, %rcx
movq -0x18(%rbp), %rax
movq %rcx, -0x10(%rbp)
movq $0x0, 0x10(%rax)
cmpq $0x0, %rax
je 0x28961
movq -0x18(%rbp), %rdi
movq (%rdi), %rax
callq *0x8(%rax)
movq -0x10(%rbp), %rax
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: Silica[P]PSL/./PSL/scope.h
// Function: PSL::variable::Variable::AnonymousScope::Break()
virtual Scope *Break()
	{
		Scope *s = owner->Break();
		owner = NULL;
		delete this;
		return s;
	}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x18(%rbp)
movq 0x10(%rax), %rdi
movq (%rdi), %rax
callq *0x28(%rax)
movq %rax, %rcx
movq -0x18(%rbp), %rax
movq %rcx, -0x10(%rbp)
movq $0x0, 0x10(%rax)
cmpq $0x0, %rax
je 0x289b1
movq -0x18(%rbp), %rdi
movq (%rdi), %rax
callq *0x8(%rax)
movq -0x10(%rbp), %rax
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: Silica[P]PSL/./PSL/scope.h
// Function: PSL::variable::Variable::AnonymousScope::Continue()
virtual Scope *Continue()
	{
		Scope *s = owner->Continue();
		owner = NULL;
		delete this;
		return s;
	}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x18(%rbp)
movq 0x10(%rax), %rdi
movq (%rdi), %rax
callq *0x30(%rax)
movq %rax, %rcx
movq -0x18(%rbp), %rax
movq %rcx, -0x10(%rbp)
movq $0x0, 0x10(%rax)
cmpq $0x0, %rax
je 0x28a01
movq -0x18(%rbp), %rdi
movq (%rdi), %rax
callq *0x8(%rax)
movq -0x10(%rbp), %rax
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: Silica[P]PSL/./PSL/parser.h
// Function: PSL::variable::Parser::getexp12(PSL::variable&, bool)
void getexp12(variable &c, bool l = false)
	{
		getexp11(c, l);
		while (int n = t->checkNext())
		{
			if (n == ',')
			{
				t->getNext();
				n = t->checkNext();
				if (n == /*'('*/')' || n == ';' || n == ']')
					break;
				else
				{
					getexp11(c);
					c.pushcode(new Variable::LIST);
				}
			}
			else break;
		}
	}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movb %dl, %al
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
andb $0x1, %al
movb %al, -0x11(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x20(%rbp)
movq -0x10(%rbp), %rsi
movb -0x11(%rbp), %al
andb $0x1, %al
movzbl %al, %edx
callq 0x29590
movq -0x20(%rbp), %rax
movq (%rax), %rdi
callq 0x232e0
movl %eax, -0x18(%rbp)
cmpl $0x0, -0x18(%rbp)
je 0x291ad
cmpl $0x2c, -0x18(%rbp)
jne 0x291a6
movq -0x20(%rbp), %rax
movq (%rax), %rdi
callq 0x26620
movq -0x20(%rbp), %rax
movq (%rax), %rdi
callq 0x232e0
movl %eax, -0x18(%rbp)
cmpl $0x29, -0x18(%rbp)
je 0x29168
cmpl $0x3b, -0x18(%rbp)
je 0x29168
cmpl $0x5d, -0x18(%rbp)
jne 0x2916a
jmp 0x291ad
movq -0x20(%rbp), %rdi
movq -0x10(%rbp), %rsi
xorl %edx, %edx
callq 0x29590
movq -0x10(%rbp), %rax
movq %rax, -0x30(%rbp)
movl $0x8, %edi
callq 0x1ee10
movq %rax, %rdi
movq %rdi, -0x28(%rbp)
callq 0x29c80
movq -0x30(%rbp), %rdi
movq -0x28(%rbp), %rsi
callq 0x23150
jmp 0x291a8
jmp 0x291ad
jmp 0x29120
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
nopl (%rax)
// File: Silica[P]PSL/./PSL/parser.h
// Function: PSL::variable::Parser::Declaration(PSL::variable&, PSL::variable::Parser::Declare, PSL::variable::string&)
void Declaration(variable &c, Declare d, string &name)
	{
		if (d == DECLARE_GLOBAL)		c.pushcode(new Variable::GLOBAL(name));
		else if (d == DECLARE_STATIC)	c.pushcode(new Variable::STATIC(name));
		else if (d == DECLARE_LOCAL)	c.pushcode(new Variable::LOCAL(name));
		else							c.pushcode(new Variable::DECLARATION(name));
	}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x70, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl %edx, -0x14(%rbp)
movq %rcx, -0x20(%rbp)
cmpl $0x1, -0x14(%rbp)
jne 0x29d30
movq -0x10(%rbp), %rax
movq %rax, -0x40(%rbp)
movl $0x10, %edi
callq 0x2aa20
movq %rax, %rdi
movq %rdi, %rax
movq %rax, -0x38(%rbp)
movq -0x20(%rbp), %rsi
callq 0x2aa40
jmp 0x29d04
movq -0x38(%rbp), %rsi
movq -0x40(%rbp), %rdi
callq 0x23150
jmp 0x29e2d
movq -0x38(%rbp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x28(%rbp)
movl %eax, -0x2c(%rbp)
callq 0x2aad0
jmp 0x29e33
cmpl $0x2, -0x14(%rbp)
jne 0x29d89
movq -0x10(%rbp), %rax
movq %rax, -0x50(%rbp)
movl $0x10, %edi
callq 0x2ab00
movq %rax, %rdi
movq %rdi, %rax
movq %rax, -0x48(%rbp)
movq -0x20(%rbp), %rsi
callq 0x2ab20
jmp 0x29d5d
movq -0x48(%rbp), %rsi
movq -0x50(%rbp), %rdi
callq 0x23150
jmp 0x29e2b
movq -0x48(%rbp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x28(%rbp)
movl %eax, -0x2c(%rbp)
callq 0x2abb0
jmp 0x29e33
cmpl $0x3, -0x14(%rbp)
jne 0x29ddc
movq -0x10(%rbp), %rax
movq %rax, -0x60(%rbp)
movl $0x10, %edi
callq 0x231c0
movq %rax, %rdi
movq %rdi, %rax
movq %rax, -0x58(%rbp)
movq -0x20(%rbp), %rsi
callq 0x231e0
jmp 0x29db6
movq -0x58(%rbp), %rsi
movq -0x60(%rbp), %rdi
callq 0x23150
jmp 0x29e29
movq -0x58(%rbp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x28(%rbp)
movl %eax, -0x2c(%rbp)
callq 0x23270
jmp 0x29e33
movq -0x10(%rbp), %rax
movq %rax, -0x70(%rbp)
movl $0x10, %edi
callq 0x285a0
movq %rax, %rdi
movq %rdi, %rax
movq %rax, -0x68(%rbp)
movq -0x20(%rbp), %rsi
callq 0x285c0
jmp 0x29e03
movq -0x68(%rbp), %rsi
movq -0x70(%rbp), %rdi
callq 0x23150
jmp 0x29e29
movq -0x68(%rbp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x28(%rbp)
movl %eax, -0x2c(%rbp)
callq 0x28650
jmp 0x29e33
jmp 0x29e2b
jmp 0x29e2d
addq $0x70, %rsp
popq %rbp
retq
movq -0x28(%rbp), %rdi
callq 0xc280
nopl (%rax)
// File: Silica[P]PSL/./PSL/parser.h
// Function: PSL::variable::Parser::getexp10(PSL::variable&, bool)
void getexp10(variable &c, bool l = false)
	{
		getexp9(c, l);
		while (int n = t->checkNext())
		{
			#if defined(PSL_OPTIMIZE_BOOL_AND) && defined(PSL_OPTIMIZE_IN_COMPILE)
			if (n==Tokenizer::BOR)
			{
				t->getNext();
				Variable::OpCode *oc = new Variable::JRT(0);
				c.pushcode(oc);
				size_t b = c.codelength();
				getexp9(c);
				oc->set(static_cast<int>(c.codelength() - b));
			}
			#else
			EXP(Tokenizer::BOR, 9, BOR)
			#endif
			else break;
		}
	}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movb %dl, %al
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
andb $0x1, %al
movb %al, -0x11(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x40(%rbp)
movq -0x10(%rbp), %rsi
movb -0x11(%rbp), %al
andb $0x1, %al
movzbl %al, %edx
callq 0x2dd50
movq -0x40(%rbp), %rax
movq (%rax), %rdi
callq 0x232e0
movl %eax, -0x18(%rbp)
cmpl $0x0, -0x18(%rbp)
je 0x2a93e
cmpl $0x1a, -0x18(%rbp)
jne 0x2a937
movq -0x40(%rbp), %rax
movq (%rax), %rdi
callq 0x26620
movl $0x10, %edi
callq 0x2a950
movq %rax, %rdi
movq %rdi, %rax
movq %rax, -0x48(%rbp)
xorl %esi, %esi
callq 0x2ded0
jmp 0x2a8cc
movq -0x48(%rbp), %rax
movq %rax, -0x20(%rbp)
movq -0x10(%rbp), %rdi
movq -0x20(%rbp), %rsi
callq 0x23150
movq -0x10(%rbp), %rdi
callq 0x27030
movq -0x40(%rbp), %rdi
movq %rax, -0x38(%rbp)
movq -0x10(%rbp), %rsi
xorl %edx, %edx
callq 0x2dd50
movq -0x20(%rbp), %rax
movq %rax, -0x50(%rbp)
movq -0x10(%rbp), %rdi
callq 0x27030
movq -0x50(%rbp), %rdi
subq -0x38(%rbp), %rax
movl %eax, %esi
movq (%rdi), %rax
callq *0x20(%rax)
jmp 0x2a939
movq -0x48(%rbp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x28(%rbp)
movl %eax, -0x2c(%rbp)
callq 0x2a9b0
jmp 0x2a944
jmp 0x2a93e
jmp 0x2a880
addq $0x50, %rsp
popq %rbp
retq
movq -0x28(%rbp), %rdi
callq 0xc280
nopl (%rax)
// File: Silica[P]PSL/./PSL/code.h
// Function: PSL::variable::Variable::PARENTHESES::Execute(PSL::variable::Variable::Environment&)
CLONE(PARENTHESES)
	EXEC
	{
		variable v = env.pop();
		variable r(variable::RARRAY);
		r.push(v);
		env.push(r);
		return RC::NONE;
	}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x10(%rbp), %rsi
leaq -0x20(%rbp), %rdi
movq %rdi, -0x48(%rbp)
callq 0x11950
movq -0x48(%rbp), %rsi
leaq -0x18(%rbp), %rdi
callq 0xcd50
jmp 0x2bf00
leaq -0x20(%rbp), %rdi
callq 0xcd90
leaq -0x38(%rbp), %rdi
movl $0x6, %esi
callq 0x127a0
jmp 0x2bf19
leaq -0x38(%rbp), %rdi
leaq -0x18(%rbp), %rsi
callq 0x22530
jmp 0x2bf28
movq -0x10(%rbp), %rax
movq %rax, -0x50(%rbp)
leaq -0x40(%rbp), %rdi
leaq -0x38(%rbp), %rsi
callq 0x11b10
jmp 0x2bf3f
movq -0x50(%rbp), %rdi
leaq -0x40(%rbp), %rsi
callq 0x11aa0
jmp 0x2bf4e
leaq -0x40(%rbp), %rdi
callq 0xcd90
leaq -0x38(%rbp), %rdi
callq 0xcdc0
leaq -0x18(%rbp), %rdi
callq 0xcdc0
xorl %eax, %eax
addq $0x50, %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 0x2bfcb
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x28(%rbp)
movl %eax, -0x2c(%rbp)
jmp 0x2bfc2
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x28(%rbp)
movl %eax, -0x2c(%rbp)
jmp 0x2bfb9
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x28(%rbp)
movl %eax, -0x2c(%rbp)
leaq -0x40(%rbp), %rdi
callq 0xcd90
leaq -0x38(%rbp), %rdi
callq 0xcdc0
leaq -0x18(%rbp), %rdi
callq 0xcdc0
movq -0x28(%rbp), %rdi
callq 0xc280
nopw %cs:(%rax,%rax)
nop
// File: Silica[P]PSL/./PSL/code.h
// Function: PSL::variable::Variable::SET_MEMBER::Execute(PSL::variable::Variable::Environment&)
CLONE(SET_MEMBER(name))
	EXEC
	{
		variable v = env.pop();
		variable x = env.top();
		x.set(name, v);
		return RC::NONE;
	}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x48(%rbp)
movq -0x10(%rbp), %rsi
leaq -0x20(%rbp), %rdi
movq %rdi, -0x40(%rbp)
callq 0x11950
movq -0x40(%rbp), %rsi
leaq -0x18(%rbp), %rdi
callq 0xcd50
jmp 0x2c2a8
leaq -0x20(%rbp), %rdi
callq 0xcd90
movq -0x10(%rbp), %rdi
callq 0x1e4a0
movq %rax, -0x50(%rbp)
jmp 0x2c2c0
movq -0x50(%rbp), %rsi
leaq -0x38(%rbp), %rdi
callq 0xcd50
jmp 0x2c2cf
movq -0x48(%rbp), %rsi
addq $0x8, %rsi
leaq -0x38(%rbp), %rdi
leaq -0x18(%rbp), %rdx
callq 0x1d370
jmp 0x2c2e6
leaq -0x38(%rbp), %rdi
callq 0xcdc0
leaq -0x18(%rbp), %rdi
callq 0xcdc0
xorl %eax, %eax
addq $0x50, %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 0x2c343
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x28(%rbp)
movl %eax, -0x2c(%rbp)
jmp 0x2c33a
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x28(%rbp)
movl %eax, -0x2c(%rbp)
leaq -0x38(%rbp), %rdi
callq 0xcdc0
leaq -0x18(%rbp), %rdi
callq 0xcdc0
movq -0x28(%rbp), %rdi
callq 0xc280
nopl (%rax)
// File: Silica[P]PSL/./PSL/code.h
// Function: PSL::variable::Variable::ARRAY_PUSH::Execute(PSL::variable::Variable::Environment&)
CLONE(ARRAY_PUSH)
	EXEC
	{
		variable v = env.pop();
		variable x = env.top();
		x.push(v);
		return RC::NONE;
	}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x10(%rbp), %rsi
leaq -0x20(%rbp), %rdi
movq %rdi, -0x40(%rbp)
callq 0x11950
movq -0x40(%rbp), %rsi
leaq -0x18(%rbp), %rdi
callq 0xcd50
jmp 0x2c4a0
leaq -0x20(%rbp), %rdi
callq 0xcd90
movq -0x10(%rbp), %rdi
callq 0x1e4a0
movq %rax, -0x48(%rbp)
jmp 0x2c4b8
movq -0x48(%rbp), %rsi
leaq -0x38(%rbp), %rdi
callq 0xcd50
jmp 0x2c4c7
leaq -0x38(%rbp), %rdi
leaq -0x18(%rbp), %rsi
callq 0x22530
jmp 0x2c4d6
leaq -0x38(%rbp), %rdi
callq 0xcdc0
leaq -0x18(%rbp), %rdi
callq 0xcdc0
xorl %eax, %eax
addq $0x50, %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 0x2c533
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x28(%rbp)
movl %eax, -0x2c(%rbp)
jmp 0x2c52a
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x28(%rbp)
movl %eax, -0x2c(%rbp)
leaq -0x38(%rbp), %rdi
callq 0xcdc0
leaq -0x18(%rbp), %rdi
callq 0xcdc0
movq -0x28(%rbp), %rdi
callq 0xc280
nopl (%rax)
// File: Silica[P]PSL/./PSL/code.h
// Function: PSL::variable::Variable::SET_INDEX::Execute(PSL::variable::Variable::Environment&)
CLONE(SET_INDEX(x))
	EXEC
	{
		variable v = env.pop();
		variable w = env.top();
		w[x] = v;
		return RC::NONE;
	}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x60, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x50(%rbp)
movq -0x10(%rbp), %rsi
leaq -0x20(%rbp), %rdi
movq %rdi, -0x48(%rbp)
callq 0x11950
movq -0x48(%rbp), %rsi
leaq -0x18(%rbp), %rdi
callq 0xcd50
jmp 0x2c628
leaq -0x20(%rbp), %rdi
callq 0xcd90
movq -0x10(%rbp), %rdi
callq 0x1e4a0
movq %rax, -0x58(%rbp)
jmp 0x2c640
movq -0x58(%rbp), %rsi
leaq -0x38(%rbp), %rdi
callq 0xcd50
jmp 0x2c64f
movq -0x50(%rbp), %rax
movl 0x8(%rax), %edx
leaq -0x40(%rbp), %rdi
leaq -0x38(%rbp), %rsi
callq 0x22460
jmp 0x2c665
leaq -0x40(%rbp), %rdi
leaq -0x18(%rbp), %rsi
callq 0x1d200
jmp 0x2c674
leaq -0x40(%rbp), %rdi
callq 0xcdc0
leaq -0x38(%rbp), %rdi
callq 0xcdc0
leaq -0x18(%rbp), %rdi
callq 0xcdc0
xorl %eax, %eax
addq $0x60, %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 0x2c6f1
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x28(%rbp)
movl %eax, -0x2c(%rbp)
jmp 0x2c6e8
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x28(%rbp)
movl %eax, -0x2c(%rbp)
jmp 0x2c6df
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x28(%rbp)
movl %eax, -0x2c(%rbp)
leaq -0x40(%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/code.h
// Function: PSL::variable::Variable::CLOSURE::Execute(PSL::variable::Variable::Environment&)
CLONE(CLOSURE)
	EXEC
	{
		variable v = env.top();
		#ifdef PSL_CLOSURE_REFERENCE
		env.setLocal(v);
		#else
		v = env.getLocal();
		#endif
		return RC::NONE;
	}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x10(%rbp), %rdi
callq 0x1e4a0
movq %rax, %rsi
leaq -0x18(%rbp), %rdi
movq %rdi, -0x48(%rbp)
callq 0xcd50
movq -0x48(%rbp), %rsi
movq -0x10(%rbp), %rax
movq %rax, -0x40(%rbp)
leaq -0x28(%rbp), %rdi
callq 0x11b10
jmp 0x2d580
movq -0x40(%rbp), %rsi
leaq -0x20(%rbp), %rdi
leaq -0x28(%rbp), %rdx
callq 0x2d650
jmp 0x2d593
leaq -0x20(%rbp), %rdi
callq 0xcd90
leaq -0x28(%rbp), %rdi
callq 0xcd90
leaq -0x18(%rbp), %rdi
callq 0xcdc0
xorl %eax, %eax
addq $0x50, %rsp
popq %rbp
retq
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x30(%rbp)
movl %eax, -0x34(%rbp)
jmp 0x2d5d9
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x30(%rbp)
movl %eax, -0x34(%rbp)
leaq -0x28(%rbp), %rdi
callq 0xcd90
leaq -0x18(%rbp), %rdi
callq 0xcdc0
movq -0x30(%rbp), %rdi
callq 0xc280
nopl (%rax,%rax)
// File: Silica[P]PSL/./PSL/parser.h
// Function: PSL::variable::Parser::getexp9(PSL::variable&, bool)
void getexp9(variable &c, bool l = false)
	{
		getexp8(c, l);
		while (int n = t->checkNext())
		{
			#if defined(PSL_OPTIMIZE_BOOL_AND) && defined(PSL_OPTIMIZE_IN_COMPILE)
			if (n==Tokenizer::BAND)
			{
				t->getNext();
				Variable::OpCode *oc = new Variable::JRF(0);
				c.pushcode(oc);
				size_t b = c.codelength();
				getexp8(c);
				c.pushcode(new Variable::JR(1));
				oc->set(static_cast<int>(c.codelength() - b));
				c.pushcode(new Variable::PUSH_NULL);
			}
			#else
			EXP(Tokenizer::BAND, 8, BAND)
			#endif
			else break;
		}
	}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x70, %rsp
movb %dl, %al
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
andb $0x1, %al
movb %al, -0x11(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x40(%rbp)
movq -0x10(%rbp), %rsi
movb -0x11(%rbp), %al
andb $0x1, %al
movzbl %al, %edx
callq 0x2df10
movq -0x40(%rbp), %rax
movq (%rax), %rdi
callq 0x232e0
movl %eax, -0x18(%rbp)
cmpl $0x0, -0x18(%rbp)
je 0x2deb5
cmpl $0x19, -0x18(%rbp)
jne 0x2deae
movq -0x40(%rbp), %rax
movq (%rax), %rdi
callq 0x26620
movl $0x10, %edi
callq 0x2a950
movq %rax, %rdi
movq %rdi, %rax
movq %rax, -0x48(%rbp)
xorl %esi, %esi
callq 0x2a970
jmp 0x2ddcc
movq -0x48(%rbp), %rax
movq %rax, -0x20(%rbp)
movq -0x10(%rbp), %rdi
movq -0x20(%rbp), %rsi
callq 0x23150
movq -0x10(%rbp), %rdi
callq 0x27030
movq -0x40(%rbp), %rdi
movq %rax, -0x38(%rbp)
movq -0x10(%rbp), %rsi
xorl %edx, %edx
callq 0x2df10
movq -0x10(%rbp), %rax
movq %rax, -0x58(%rbp)
movl $0x10, %edi
callq 0x2a950
movq %rax, %rdi
movq %rdi, %rax
movq %rax, -0x50(%rbp)
movl $0x1, %esi
callq 0x2a9e0
jmp 0x2de25
movq -0x50(%rbp), %rsi
movq -0x58(%rbp), %rdi
callq 0x23150
movq -0x20(%rbp), %rax
movq %rax, -0x70(%rbp)
movq -0x10(%rbp), %rdi
callq 0x27030
movq -0x70(%rbp), %rdi
subq -0x38(%rbp), %rax
movl %eax, %esi
movq (%rdi), %rax
callq *0x20(%rax)
movq -0x10(%rbp), %rax
movq %rax, -0x68(%rbp)
movl $0x8, %edi
callq 0x1ee10
movq %rax, %rdi
movq %rdi, -0x60(%rbp)
callq 0x23180
movq -0x68(%rbp), %rdi
movq -0x60(%rbp), %rsi
callq 0x23150
jmp 0x2deb0
movq -0x48(%rbp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x28(%rbp)
movl %eax, -0x2c(%rbp)
callq 0x2a9b0
jmp 0x2debb
movq -0x50(%rbp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x28(%rbp)
movl %eax, -0x2c(%rbp)
callq 0x2a9b0
jmp 0x2debb
jmp 0x2deb5
jmp 0x2dd80
addq $0x70, %rsp
popq %rbp
retq
movq -0x28(%rbp), %rdi
callq 0xc280
nopw %cs:(%rax,%rax)
nop
// File: Silica[P]PSL/./PSL/parser.h
// Function: PSL::variable::Parser::getexp8(PSL::variable&, bool)
void getexp8(variable &c, bool l = false)
	{
		getexp7(c, l);
		while (int n = t->checkNext())
		{
			EXP(Tokenizer::EQ, 7, EQ)
			else EXP(Tokenizer::NE, 7, NEQ)
			else break;
		}
	}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movb %dl, %al
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
andb $0x1, %al
movb %al, -0x11(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x20(%rbp)
movq -0x10(%rbp), %rsi
movb -0x11(%rbp), %al
andb $0x1, %al
movzbl %al, %edx
callq 0x2e010
movq -0x20(%rbp), %rax
movq (%rax), %rdi
callq 0x232e0
movl %eax, -0x18(%rbp)
cmpl $0x0, -0x18(%rbp)
je 0x2dffe
cmpl $0x9, -0x18(%rbp)
jne 0x2dfa7
movq -0x20(%rbp), %rax
movq (%rax), %rdi
callq 0x26620
movq -0x20(%rbp), %rdi
movq -0x10(%rbp), %rsi
xorl %edx, %edx
callq 0x2e010
movq -0x10(%rbp), %rax
movq %rax, -0x30(%rbp)
movl $0x8, %edi
callq 0x1ee10
movq %rax, %rdi
movq %rdi, -0x28(%rbp)
callq 0x2e1b0
movq -0x30(%rbp), %rdi
movq -0x28(%rbp), %rsi
callq 0x23150
jmp 0x2dff9
cmpl $0xa, -0x18(%rbp)
jne 0x2dff5
movq -0x20(%rbp), %rax
movq (%rax), %rdi
callq 0x26620
movq -0x20(%rbp), %rdi
movq -0x10(%rbp), %rsi
xorl %edx, %edx
callq 0x2e010
movq -0x10(%rbp), %rax
movq %rax, -0x40(%rbp)
movl $0x8, %edi
callq 0x1ee10
movq %rax, %rdi
movq %rdi, -0x38(%rbp)
callq 0x2e1f0
movq -0x40(%rbp), %rdi
movq -0x38(%rbp), %rsi
callq 0x23150
jmp 0x2dff7
jmp 0x2dffe
jmp 0x2dff9
jmp 0x2df40
addq $0x40, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
nop
// File: Silica[P]PSL/./PSL/parser.h
// Function: PSL::variable::Parser::getexp7(PSL::variable&, bool)
void getexp7(variable &c, bool l = false)
	{
		getexp6(c, l);
		while (int n = t->checkNext())
		{
			EXP('<', 6, LT)
			else EXP(Tokenizer::LE, 6, LE)
			else EXP('>', 6, GT)
			else EXP(Tokenizer::GE, 6, GE)
			else break;
		}
	}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x60, %rsp
movb %dl, %al
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
andb $0x1, %al
movb %al, -0x11(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x20(%rbp)
movq -0x10(%rbp), %rsi
movb -0x11(%rbp), %al
andb $0x1, %al
movzbl %al, %edx
callq 0x2e230
movq -0x20(%rbp), %rax
movq (%rax), %rdi
callq 0x232e0
movl %eax, -0x18(%rbp)
cmpl $0x0, -0x18(%rbp)
je 0x2e1a4
cmpl $0x3c, -0x18(%rbp)
jne 0x2e0aa
movq -0x20(%rbp), %rax
movq (%rax), %rdi
callq 0x26620
movq -0x20(%rbp), %rdi
movq -0x10(%rbp), %rsi
xorl %edx, %edx
callq 0x2e230
movq -0x10(%rbp), %rax
movq %rax, -0x30(%rbp)
movl $0x8, %edi
callq 0x1ee10
movq %rax, %rdi
movq %rdi, -0x28(%rbp)
callq 0x2e2d0
movq -0x30(%rbp), %rdi
movq -0x28(%rbp), %rsi
callq 0x23150
jmp 0x2e19f
cmpl $0xb, -0x18(%rbp)
jne 0x2e0fb
movq -0x20(%rbp), %rax
movq (%rax), %rdi
callq 0x26620
movq -0x20(%rbp), %rdi
movq -0x10(%rbp), %rsi
xorl %edx, %edx
callq 0x2e230
movq -0x10(%rbp), %rax
movq %rax, -0x40(%rbp)
movl $0x8, %edi
callq 0x1ee10
movq %rax, %rdi
movq %rdi, -0x38(%rbp)
callq 0x2e310
movq -0x40(%rbp), %rdi
movq -0x38(%rbp), %rsi
callq 0x23150
jmp 0x2e19d
cmpl $0x3e, -0x18(%rbp)
jne 0x2e149
movq -0x20(%rbp), %rax
movq (%rax), %rdi
callq 0x26620
movq -0x20(%rbp), %rdi
movq -0x10(%rbp), %rsi
xorl %edx, %edx
callq 0x2e230
movq -0x10(%rbp), %rax
movq %rax, -0x50(%rbp)
movl $0x8, %edi
callq 0x1ee10
movq %rax, %rdi
movq %rdi, -0x48(%rbp)
callq 0x2e350
movq -0x50(%rbp), %rdi
movq -0x48(%rbp), %rsi
callq 0x23150
jmp 0x2e19b
cmpl $0xc, -0x18(%rbp)
jne 0x2e197
movq -0x20(%rbp), %rax
movq (%rax), %rdi
callq 0x26620
movq -0x20(%rbp), %rdi
movq -0x10(%rbp), %rsi
xorl %edx, %edx
callq 0x2e230
movq -0x10(%rbp), %rax
movq %rax, -0x60(%rbp)
movl $0x8, %edi
callq 0x1ee10
movq %rax, %rdi
movq %rdi, -0x58(%rbp)
callq 0x2e390
movq -0x60(%rbp), %rdi
movq -0x58(%rbp), %rsi
callq 0x23150
jmp 0x2e199
jmp 0x2e1a4
jmp 0x2e19b
jmp 0x2e19d
jmp 0x2e19f
jmp 0x2e040
addq $0x60, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: Silica[P]PSL/./PSL/parser.h
// Function: PSL::variable::Parser::getexp6(PSL::variable&, bool)
void getexp6(variable &c, bool l = false)
	{
		getexp5(c, l);
		while (int n = t->checkNext())
		{
			EXP('|', 5, OR)
			else break;
		}
	}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movb %dl, %al
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
andb $0x1, %al
movb %al, -0x11(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x20(%rbp)
movq -0x10(%rbp), %rsi
movb -0x11(%rbp), %al
andb $0x1, %al
movzbl %al, %edx
callq 0x2e3d0
movq -0x20(%rbp), %rax
movq (%rax), %rdi
callq 0x232e0
movl %eax, -0x18(%rbp)
cmpl $0x0, -0x18(%rbp)
je 0x2e2c7
cmpl $0x7c, -0x18(%rbp)
jne 0x2e2c3
movq -0x20(%rbp), %rax
movq (%rax), %rdi
callq 0x26620
movq -0x20(%rbp), %rdi
movq -0x10(%rbp), %rsi
xorl %edx, %edx
callq 0x2e3d0
movq -0x10(%rbp), %rax
movq %rax, -0x30(%rbp)
movl $0x8, %edi
callq 0x1ee10
movq %rax, %rdi
movq %rdi, -0x28(%rbp)
callq 0x2e470
movq -0x30(%rbp), %rdi
movq -0x28(%rbp), %rsi
callq 0x23150
jmp 0x2e2c5
jmp 0x2e2c7
jmp 0x2e260
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax)
// File: Silica[P]PSL/./PSL/parser.h
// Function: PSL::variable::Parser::getexp5(PSL::variable&, bool)
void getexp5(variable &c, bool l = false)
	{
		getexp4(c, l);
		while (int n = t->checkNext())
		{
			EXP('^', 4, XOR)
			else break;
		}
	}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movb %dl, %al
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
andb $0x1, %al
movb %al, -0x11(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x20(%rbp)
movq -0x10(%rbp), %rsi
movb -0x11(%rbp), %al
andb $0x1, %al
movzbl %al, %edx
callq 0x2e4b0
movq -0x20(%rbp), %rax
movq (%rax), %rdi
callq 0x232e0
movl %eax, -0x18(%rbp)
cmpl $0x0, -0x18(%rbp)
je 0x2e467
cmpl $0x5e, -0x18(%rbp)
jne 0x2e463
movq -0x20(%rbp), %rax
movq (%rax), %rdi
callq 0x26620
movq -0x20(%rbp), %rdi
movq -0x10(%rbp), %rsi
xorl %edx, %edx
callq 0x2e4b0
movq -0x10(%rbp), %rax
movq %rax, -0x30(%rbp)
movl $0x8, %edi
callq 0x1ee10
movq %rax, %rdi
movq %rdi, -0x28(%rbp)
callq 0x2e550
movq -0x30(%rbp), %rdi
movq -0x28(%rbp), %rsi
callq 0x23150
jmp 0x2e465
jmp 0x2e467
jmp 0x2e400
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax)
// File: Silica[P]PSL/./PSL/parser.h
// Function: PSL::variable::Parser::getexp4(PSL::variable&, bool)
void getexp4(variable &c, bool l = false)
	{
		getexp3(c, l);
		while (int n = t->checkNext())
		{
			EXP('&', 3, AND)
			else break;
		}
	}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movb %dl, %al
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
andb $0x1, %al
movb %al, -0x11(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x20(%rbp)
movq -0x10(%rbp), %rsi
movb -0x11(%rbp), %al
andb $0x1, %al
movzbl %al, %edx
callq 0x2e590
movq -0x20(%rbp), %rax
movq (%rax), %rdi
callq 0x232e0
movl %eax, -0x18(%rbp)
cmpl $0x0, -0x18(%rbp)
je 0x2e547
cmpl $0x26, -0x18(%rbp)
jne 0x2e543
movq -0x20(%rbp), %rax
movq (%rax), %rdi
callq 0x26620
movq -0x20(%rbp), %rdi
movq -0x10(%rbp), %rsi
xorl %edx, %edx
callq 0x2e590
movq -0x10(%rbp), %rax
movq %rax, -0x30(%rbp)
movl $0x8, %edi
callq 0x1ee10
movq %rax, %rdi
movq %rdi, -0x28(%rbp)
callq 0x2e690
movq -0x30(%rbp), %rdi
movq -0x28(%rbp), %rsi
callq 0x23150
jmp 0x2e545
jmp 0x2e547
jmp 0x2e4e0
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax)
// File: Silica[P]PSL/./PSL/parser.h
// Function: PSL::variable::Parser::getexp3(PSL::variable&, bool)
void getexp3(variable &c, bool l = false)
	{
		getexp2(c, l);
		while (int n = t->checkNext())
		{
			EXP(Tokenizer::SHL, 2, SHL)
			else EXP(Tokenizer::SHR, 2, SHR)
			else break;
		}
	}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movb %dl, %al
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
andb $0x1, %al
movb %al, -0x11(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x20(%rbp)
movq -0x10(%rbp), %rsi
movb -0x11(%rbp), %al
andb $0x1, %al
movzbl %al, %edx
callq 0x2e6d0
movq -0x20(%rbp), %rax
movq (%rax), %rdi
callq 0x232e0
movl %eax, -0x18(%rbp)
cmpl $0x0, -0x18(%rbp)
je 0x2e67e
cmpl $0x15, -0x18(%rbp)
jne 0x2e627
movq -0x20(%rbp), %rax
movq (%rax), %rdi
callq 0x26620
movq -0x20(%rbp), %rdi
movq -0x10(%rbp), %rsi
xorl %edx, %edx
callq 0x2e6d0
movq -0x10(%rbp), %rax
movq %rax, -0x30(%rbp)
movl $0x8, %edi
callq 0x1ee10
movq %rax, %rdi
movq %rdi, -0x28(%rbp)
callq 0x2e7d0
movq -0x30(%rbp), %rdi
movq -0x28(%rbp), %rsi
callq 0x23150
jmp 0x2e679
cmpl $0x16, -0x18(%rbp)
jne 0x2e675
movq -0x20(%rbp), %rax
movq (%rax), %rdi
callq 0x26620
movq -0x20(%rbp), %rdi
movq -0x10(%rbp), %rsi
xorl %edx, %edx
callq 0x2e6d0
movq -0x10(%rbp), %rax
movq %rax, -0x40(%rbp)
movl $0x8, %edi
callq 0x1ee10
movq %rax, %rdi
movq %rdi, -0x38(%rbp)
callq 0x2e810
movq -0x40(%rbp), %rdi
movq -0x38(%rbp), %rsi
callq 0x23150
jmp 0x2e677
jmp 0x2e67e
jmp 0x2e679
jmp 0x2e5c0
addq $0x40, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
nop
// File: Silica[P]PSL/./PSL/parser.h
// Function: PSL::variable::Parser::getexp2(PSL::variable&, bool)
void getexp2(variable &c, bool l = false)
	{
		getexp1(c, l);
		while (int n = t->checkNext())
		{
			EXP('+', 1, ADD)
			else EXP('-', 1, SUB)
			else break;
		}
	}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movb %dl, %al
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
andb $0x1, %al
movb %al, -0x11(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x20(%rbp)
movq -0x10(%rbp), %rsi
movb -0x11(%rbp), %al
andb $0x1, %al
movzbl %al, %edx
callq 0x2e850
movq -0x20(%rbp), %rax
movq (%rax), %rdi
callq 0x232e0
movl %eax, -0x18(%rbp)
cmpl $0x0, -0x18(%rbp)
je 0x2e7be
cmpl $0x2b, -0x18(%rbp)
jne 0x2e767
movq -0x20(%rbp), %rax
movq (%rax), %rdi
callq 0x26620
movq -0x20(%rbp), %rdi
movq -0x10(%rbp), %rsi
xorl %edx, %edx
callq 0x2e850
movq -0x10(%rbp), %rax
movq %rax, -0x30(%rbp)
movl $0x8, %edi
callq 0x1ee10
movq %rax, %rdi
movq %rdi, -0x28(%rbp)
callq 0x2e9a0
movq -0x30(%rbp), %rdi
movq -0x28(%rbp), %rsi
callq 0x23150
jmp 0x2e7b9
cmpl $0x2d, -0x18(%rbp)
jne 0x2e7b5
movq -0x20(%rbp), %rax
movq (%rax), %rdi
callq 0x26620
movq -0x20(%rbp), %rdi
movq -0x10(%rbp), %rsi
xorl %edx, %edx
callq 0x2e850
movq -0x10(%rbp), %rax
movq %rax, -0x40(%rbp)
movl $0x8, %edi
callq 0x1ee10
movq %rax, %rdi
movq %rdi, -0x38(%rbp)
callq 0x2e9e0
movq -0x40(%rbp), %rdi
movq -0x38(%rbp), %rsi
callq 0x23150
jmp 0x2e7b7
jmp 0x2e7be
jmp 0x2e7b9
jmp 0x2e700
addq $0x40, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
nop
// File: Silica[P]PSL/./PSL/parser.h
// Function: PSL::variable::Parser::getexp1(PSL::variable&, bool)
void getexp1(variable &c, bool l = false)
	{
		if (!l)
			getTerm(c);
		while (int n = t->checkNext())
		{
			EXP0('*', Term, MUL)
			else EXP0('/', Term, DIV)
			else EXP0('%', Term, MOD)
			else break;
		}
	}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movb %dl, %al
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
andb $0x1, %al
movb %al, -0x11(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x20(%rbp)
testb $0x1, -0x11(%rbp)
jne 0x2e882
movq -0x20(%rbp), %rdi
movq -0x10(%rbp), %rsi
callq 0x29e40
jmp 0x2e884
movq -0x20(%rbp), %rax
movq (%rax), %rdi
callq 0x232e0
movl %eax, -0x18(%rbp)
cmpl $0x0, -0x18(%rbp)
je 0x2e98f
cmpl $0x2a, -0x18(%rbp)
jne 0x2e8ec
movq -0x20(%rbp), %rax
movq (%rax), %rdi
callq 0x26620
movq -0x20(%rbp), %rdi
movq -0x10(%rbp), %rsi
callq 0x29e40
movq -0x10(%rbp), %rax
movq %rax, -0x30(%rbp)
movl $0x8, %edi
callq 0x1ee10
movq %rax, %rdi
movq %rdi, -0x28(%rbp)
callq 0x2ea20
movq -0x30(%rbp), %rdi
movq -0x28(%rbp), %rsi
callq 0x23150
jmp 0x2e98a
cmpl $0x2f, -0x18(%rbp)
jne 0x2e938
movq -0x20(%rbp), %rax
movq (%rax), %rdi
callq 0x26620
movq -0x20(%rbp), %rdi
movq -0x10(%rbp), %rsi
callq 0x29e40
movq -0x10(%rbp), %rax
movq %rax, -0x40(%rbp)
movl $0x8, %edi
callq 0x1ee10
movq %rax, %rdi
movq %rdi, -0x38(%rbp)
callq 0x2ea60
movq -0x40(%rbp), %rdi
movq -0x38(%rbp), %rsi
callq 0x23150
jmp 0x2e988
cmpl $0x25, -0x18(%rbp)
jne 0x2e984
movq -0x20(%rbp), %rax
movq (%rax), %rdi
callq 0x26620
movq -0x20(%rbp), %rdi
movq -0x10(%rbp), %rsi
callq 0x29e40
movq -0x10(%rbp), %rax
movq %rax, -0x50(%rbp)
movl $0x8, %edi
callq 0x1ee10
movq %rax, %rdi
movq %rdi, -0x48(%rbp)
callq 0x2eaa0
movq -0x50(%rbp), %rdi
movq -0x48(%rbp), %rsi
callq 0x23150
jmp 0x2e986
jmp 0x2e98f
jmp 0x2e988
jmp 0x2e98a
jmp 0x2e884
addq $0x50, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
nop
// File: Silica[P]PSL/./PSL/code.h
// Function: PSL::variable::Variable::JRT::Execute(PSL::variable::Variable::Environment&)
CLONE(JRT(j))
	EXEC
	{
		if (env.top().get()->toBool())
			env.RJump(j);
		else
			env.pop();
		return RC::NONE;
	}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x20(%rbp)
movq -0x10(%rbp), %rdi
callq 0x1e4a0
movq %rax, %rdi
callq 0x12060
movq %rax, %rdi
callq 0x16f20
testb $0x1, %al
jne 0x313e7
jmp 0x313f9
movq -0x20(%rbp), %rax
movq -0x10(%rbp), %rdi
movl 0x8(%rax), %esi
callq 0x316b0
jmp 0x3140f
movq -0x10(%rbp), %rsi
leaq -0x18(%rbp), %rdi
callq 0x11950
leaq -0x18(%rbp), %rdi
callq 0xcd90
xorl %eax, %eax
addq $0x20, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: Silica[P]PSL/./PSL/code.h
// Function: PSL::variable::Variable::LIST::Execute(PSL::variable::Variable::Environment&)
CLONE(LIST)
	EXEC
	{
		variable r = env.pop();
		variable l = env.pop();
		if (l.type(variable::RARRAY))
		{
			l.push(r);
			env.push(l);
		}
		else
		{
			env.push(variable(l, r));
		}
		return RC::NONE;
	}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x80, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x10(%rbp), %rsi
leaq -0x20(%rbp), %rdi
movq %rdi, -0x60(%rbp)
callq 0x11950
movq -0x60(%rbp), %rsi
leaq -0x18(%rbp), %rdi
callq 0xcd50
jmp 0x31a63
leaq -0x20(%rbp), %rdi
callq 0xcd90
movq -0x10(%rbp), %rsi
leaq -0x40(%rbp), %rdi
callq 0x11950
jmp 0x31a7b
leaq -0x38(%rbp), %rdi
leaq -0x40(%rbp), %rsi
callq 0xcd50
jmp 0x31a8a
leaq -0x40(%rbp), %rdi
callq 0xcd90
leaq -0x38(%rbp), %rdi
movl $0x6, %esi
callq 0x31c90
movb %al, -0x61(%rbp)
jmp 0x31aa6
movb -0x61(%rbp), %al
testb $0x1, %al
jne 0x31ab2
jmp 0x31b65
leaq -0x38(%rbp), %rdi
leaq -0x18(%rbp), %rsi
callq 0x22530
jmp 0x31ac1
movq -0x10(%rbp), %rax
movq %rax, -0x70(%rbp)
leaq -0x48(%rbp), %rdi
leaq -0x38(%rbp), %rsi
callq 0x11b10
jmp 0x31ad8
movq -0x70(%rbp), %rdi
leaq -0x48(%rbp), %rsi
callq 0x11aa0
jmp 0x31ae7
leaq -0x48(%rbp), %rdi
callq 0xcd90
jmp 0x31be0
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x28(%rbp)
movl %eax, -0x2c(%rbp)
leaq -0x20(%rbp), %rdi
callq 0xcd90
jmp 0x31c0f
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x28(%rbp)
movl %eax, -0x2c(%rbp)
jmp 0x31c06
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x28(%rbp)
movl %eax, -0x2c(%rbp)
leaq -0x40(%rbp), %rdi
callq 0xcd90
jmp 0x31c06
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x28(%rbp)
movl %eax, -0x2c(%rbp)
jmp 0x31bfd
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x28(%rbp)
movl %eax, -0x2c(%rbp)
leaq -0x48(%rbp), %rdi
callq 0xcd90
jmp 0x31bfd
movq -0x10(%rbp), %rax
movq %rax, -0x78(%rbp)
leaq -0x58(%rbp), %rdi
leaq -0x38(%rbp), %rsi
leaq -0x18(%rbp), %rdx
callq 0x31cc0
jmp 0x31b80
leaq -0x50(%rbp), %rdi
leaq -0x58(%rbp), %rsi
callq 0x11b10
jmp 0x31b8f
movq -0x78(%rbp), %rdi
leaq -0x50(%rbp), %rsi
callq 0x11aa0
jmp 0x31b9e
leaq -0x50(%rbp), %rdi
callq 0xcd90
leaq -0x58(%rbp), %rdi
callq 0xcdc0
jmp 0x31be0
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x28(%rbp)
movl %eax, -0x2c(%rbp)
jmp 0x31bd5
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x28(%rbp)
movl %eax, -0x2c(%rbp)
leaq -0x50(%rbp), %rdi
callq 0xcd90
leaq -0x58(%rbp), %rdi
callq 0xcdc0
jmp 0x31bfd
leaq -0x38(%rbp), %rdi
callq 0xcdc0
leaq -0x18(%rbp), %rdi
callq 0xcdc0
xorl %eax, %eax
addq $0x80, %rsp
popq %rbp
retq
leaq -0x38(%rbp), %rdi
callq 0xcdc0
leaq -0x18(%rbp), %rdi
callq 0xcdc0
movq -0x28(%rbp), %rdi
callq 0xc280
nopl (%rax,%rax)
// File: Silica[P]PSL/./PSL/code.h
// Function: PSL::variable::Variable::SUBSTITUTION::Execute(PSL::variable::Variable::Environment&)
CLONE(SUBSTITUTION)
	EXEC
	{
		variable r = env.pop();
		variable l = env.top();
		l.substitution(r);
		return RC::NONE;
	}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x10(%rbp), %rsi
leaq -0x20(%rbp), %rdi
movq %rdi, -0x40(%rbp)
callq 0x11950
movq -0x40(%rbp), %rsi
leaq -0x18(%rbp), %rdi
callq 0xcd50
jmp 0x31eb0
leaq -0x20(%rbp), %rdi
callq 0xcd90
movq -0x10(%rbp), %rdi
callq 0x1e4a0
movq %rax, -0x48(%rbp)
jmp 0x31ec8
movq -0x48(%rbp), %rsi
leaq -0x38(%rbp), %rdi
callq 0xcd50
jmp 0x31ed7
leaq -0x38(%rbp), %rdi
leaq -0x18(%rbp), %rsi
callq 0x11ad0
jmp 0x31ee6
leaq -0x38(%rbp), %rdi
callq 0xcdc0
leaq -0x18(%rbp), %rdi
callq 0xcdc0
xorl %eax, %eax
addq $0x50, %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 0x31f43
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x28(%rbp)
movl %eax, -0x2c(%rbp)
jmp 0x31f3a
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x28(%rbp)
movl %eax, -0x2c(%rbp)
leaq -0x38(%rbp), %rdi
callq 0xcdc0
leaq -0x18(%rbp), %rdi
callq 0xcdc0
movq -0x28(%rbp), %rdi
callq 0xc280
nopl (%rax)
// File: Silica[P]PSL/./PSL/code.h
// Function: PSL::variable::Variable::ASSIGNMENT::Execute(PSL::variable::Variable::Environment&)
CLONE(ASSIGNMENT)
	EXEC
	{
		variable r = env.pop();
		variable l = env.top();
		l.assignment(r);
		return RC::NONE;
	}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x10(%rbp), %rsi
leaq -0x20(%rbp), %rdi
movq %rdi, -0x40(%rbp)
callq 0x11950
movq -0x40(%rbp), %rsi
leaq -0x18(%rbp), %rdi
callq 0xcd50
jmp 0x32040
leaq -0x20(%rbp), %rdi
callq 0xcd90
movq -0x10(%rbp), %rdi
callq 0x1e4a0
movq %rax, -0x48(%rbp)
jmp 0x32058
movq -0x48(%rbp), %rsi
leaq -0x38(%rbp), %rdi
callq 0xcd50
jmp 0x32067
leaq -0x38(%rbp), %rdi
leaq -0x18(%rbp), %rsi
callq 0x32150
jmp 0x32076
leaq -0x38(%rbp), %rdi
callq 0xcdc0
leaq -0x18(%rbp), %rdi
callq 0xcdc0
xorl %eax, %eax
addq $0x50, %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 0x320d3
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x28(%rbp)
movl %eax, -0x2c(%rbp)
jmp 0x320ca
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x28(%rbp)
movl %eax, -0x2c(%rbp)
leaq -0x38(%rbp), %rdi
callq 0xcdc0
leaq -0x18(%rbp), %rdi
callq 0xcdc0
movq -0x28(%rbp), %rdi
callq 0xc280
nopl (%rax)
// File: Silica[P]PSL/./PSL/scope.h
// Function: PSL::variable::Variable::LoopScope::Break()
virtual Scope *Break()
	{
		Scope *s = owner;
		owner = NULL;
		delete this;
		return s;
	}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x18(%rbp)
movq 0x10(%rax), %rcx
movq %rcx, -0x10(%rbp)
movq $0x0, 0x10(%rax)
cmpq $0x0, %rax
je 0x33984
movq -0x18(%rbp), %rdi
movq (%rdi), %rax
callq *0x8(%rax)
movq -0x10(%rbp), %rax
addq $0x20, %rsp
popq %rbp
retq
nop
// File: 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 %rbp
movq %rsp, %rbp
subq $0x60, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x10(%rbp), %rsi
leaq -0x20(%rbp), %rdi
movq %rdi, -0x50(%rbp)
callq 0x11950
movq -0x50(%rbp), %rsi
leaq -0x18(%rbp), %rdi
callq 0xcd50
jmp 0x346d0
leaq -0x20(%rbp), %rdi
callq 0xcd90
movq -0x10(%rbp), %rax
movq %rax, -0x58(%rbp)
leaq -0x40(%rbp), %rdi
leaq -0x18(%rbp), %rsi
callq 0x2be50
jmp 0x346f0
leaq -0x38(%rbp), %rdi
leaq -0x40(%rbp), %rsi
callq 0x11b10
jmp 0x346ff
movq -0x58(%rbp), %rdi
leaq -0x38(%rbp), %rsi
callq 0x11aa0
jmp 0x3470e
leaq -0x38(%rbp), %rdi
callq 0xcd90
leaq -0x40(%rbp), %rdi
callq 0xcdc0
leaq -0x48(%rbp), %rdi
movl $0x1, %esi
callq 0xcce0
jmp 0x34730
leaq -0x18(%rbp), %rdi
leaq -0x48(%rbp), %rsi
callq 0x1f0c0
jmp 0x3473f
leaq -0x48(%rbp), %rdi
callq 0xcdc0
leaq -0x18(%rbp), %rdi
callq 0xcdc0
xorl %eax, %eax
addq $0x60, %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 0x347ca
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x28(%rbp)
movl %eax, -0x2c(%rbp)
jmp 0x347c1
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x28(%rbp)
movl %eax, -0x2c(%rbp)
jmp 0x347a1
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x28(%rbp)
movl %eax, -0x2c(%rbp)
leaq -0x38(%rbp), %rdi
callq 0xcd90
leaq -0x40(%rbp), %rdi
callq 0xcdc0
jmp 0x347c1
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x28(%rbp)
movl %eax, -0x2c(%rbp)
leaq -0x48(%rbp), %rdi
callq 0xcdc0
leaq -0x18(%rbp), %rdi
callq 0xcdc0
movq -0x28(%rbp), %rdi
callq 0xc280
nopw %cs:(%rax,%rax)
nopl (%rax)
// File: 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 %rbp
movq %rsp, %rbp
subq $0x60, %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 0x34ad0
leaq -0x20(%rbp), %rdi
callq 0xcd90
movq -0x10(%rbp), %rsi
leaq -0x40(%rbp), %rdi
callq 0x11950
jmp 0x34ae8
leaq -0x38(%rbp), %rdi
leaq -0x40(%rbp), %rsi
callq 0xcd50
jmp 0x34af7
leaq -0x40(%rbp), %rdi
callq 0xcd90
movq -0x10(%rbp), %rax
movq %rax, -0x60(%rbp)
leaq -0x50(%rbp), %rdi
leaq -0x38(%rbp), %rsi
leaq -0x18(%rbp), %rdx
callq 0x22770
jmp 0x34b1b
leaq -0x48(%rbp), %rdi
leaq -0x50(%rbp), %rsi
callq 0x11b10
jmp 0x34b2a
movq -0x60(%rbp), %rdi
leaq -0x48(%rbp), %rsi
callq 0x11aa0
jmp 0x34b39
leaq -0x48(%rbp), %rdi
callq 0xcd90
leaq -0x50(%rbp), %rdi
callq 0xcdc0
leaq -0x38(%rbp), %rdi
callq 0xcdc0
leaq -0x18(%rbp), %rdi
callq 0xcdc0
xorl %eax, %eax
addq $0x60, %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 0x34bed
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x28(%rbp)
movl %eax, -0x2c(%rbp)
jmp 0x34be4
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x28(%rbp)
movl %eax, -0x2c(%rbp)
leaq -0x40(%rbp), %rdi
callq 0xcd90
jmp 0x34be4
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x28(%rbp)
movl %eax, -0x2c(%rbp)
jmp 0x34bdb
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x28(%rbp)
movl %eax, -0x2c(%rbp)
jmp 0x34bd2
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x28(%rbp)
movl %eax, -0x2c(%rbp)
leaq -0x48(%rbp), %rdi
callq 0xcd90
leaq -0x50(%rbp), %rdi
callq 0xcdc0
leaq -0x38(%rbp), %rdi
callq 0xcdc0
leaq -0x18(%rbp), %rdi
callq 0xcdc0
movq -0x28(%rbp), %rdi
callq 0xc280
nopw %cs:(%rax,%rax)
// File: 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 %rbp
movq %rsp, %rbp
subq $0x60, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x50(%rbp)
movq -0x10(%rbp), %rsi
leaq -0x20(%rbp), %rdi
movq %rdi, -0x48(%rbp)
callq 0x11950
movq -0x48(%rbp), %rsi
leaq -0x18(%rbp), %rdi
callq 0xcd50
jmp 0x34d08
leaq -0x20(%rbp), %rdi
callq 0xcd90
movq -0x50(%rbp), %rdx
movq -0x10(%rbp), %rax
movq %rax, -0x58(%rbp)
addq $0x8, %rdx
leaq -0x40(%rbp), %rdi
leaq -0x18(%rbp), %rsi
callq 0x1d320
jmp 0x34d30
leaq -0x38(%rbp), %rdi
leaq -0x40(%rbp), %rsi
callq 0x11b10
jmp 0x34d3f
movq -0x58(%rbp), %rdi
leaq -0x38(%rbp), %rsi
callq 0x11aa0
jmp 0x34d4e
leaq -0x38(%rbp), %rdi
callq 0xcd90
leaq -0x40(%rbp), %rdi
callq 0xcdc0
leaq -0x18(%rbp), %rdi
callq 0xcdc0
xorl %eax, %eax
addq $0x60, %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 0x34dcb
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x28(%rbp)
movl %eax, -0x2c(%rbp)
jmp 0x34dc2
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x28(%rbp)
movl %eax, -0x2c(%rbp)
jmp 0x34db9
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x28(%rbp)
movl %eax, -0x2c(%rbp)
leaq -0x38(%rbp), %rdi
callq 0xcd90
leaq -0x40(%rbp), %rdi
callq 0xcdc0
leaq -0x18(%rbp), %rdi
callq 0xcdc0
movq -0x28(%rbp), %rdi
callq 0xc280
nopw %cs:(%rax,%rax)
nop
// File: 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 %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x10(%rbp)
callq 0xd060
movq %rax, %rdi
callq 0x12060
movq %rax, %rdi
callq 0x16eb0
movq -0x10(%rbp), %rdi
callq 0x35260
movq -0x10(%rbp), %rdi
callq 0x35330
movq -0x10(%rbp), %rdi
callq 0x353b0
movq -0x10(%rbp), %rdi
callq 0x35430
movq -0x10(%rbp), %rdi
callq 0x354c0
addq $0x10, %rsp
popq %rbp
retq
nopl (%rax)
// File: 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 %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x38(%rbp)
addq $0x8, %rax
addq $0x1000, %rax           # imm = 0x1000
movq %rax, -0x10(%rbp)
movq -0x10(%rbp), %rax
cmpq $0x0, (%rax)
je 0x35571
movq -0x10(%rbp), %rax
movq (%rax), %rdi
callq 0x35910
testb $0x1, %al
jne 0x35502
jmp 0x3555b
movq -0x10(%rbp), %rax
movq (%rax), %rax
movq 0x1000(%rax), %rax
movq %rax, -0x18(%rbp)
movq -0x10(%rbp), %rax
movq (%rax), %rax
movq $0x0, 0x1000(%rax)
movq -0x10(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x40(%rbp)
cmpq $0x0, %rax
je 0x3554e
movq -0x40(%rbp), %rdi
callq 0xef70
movq -0x40(%rbp), %rdi
movl $0x1008, %esi           # imm = 0x1008
callq 0xc1e0
movq -0x18(%rbp), %rcx
movq -0x10(%rbp), %rax
movq %rcx, (%rax)
jmp 0x354e2
movq -0x10(%rbp), %rax
movq (%rax), %rax
addq $0x1000, %rax           # imm = 0x1000
movq %rax, -0x10(%rbp)
jmp 0x354e2
movq -0x38(%rbp), %rax
movq %rax, -0x20(%rbp)
addq $0x8, %rax
movq %rax, -0x28(%rbp)
cmpq $0x0, -0x28(%rbp)
je 0x355fb
movl $0x0, -0x2c(%rbp)
cmpl $0x100, -0x2c(%rbp)     # imm = 0x100
jge 0x355e8
movq -0x28(%rbp), %rax
movslq -0x2c(%rbp), %rcx
shlq $0x4, %rcx
addq %rcx, %rax
cmpl $0x0, (%rax)
je 0x355ae
jmp 0x355db
movq -0x28(%rbp), %rcx
movslq -0x2c(%rbp), %rax
shlq $0x4, %rax
addq %rax, %rcx
movq -0x20(%rbp), %rax
movq %rcx, (%rax)
movq -0x28(%rbp), %rax
movslq -0x2c(%rbp), %rcx
shlq $0x4, %rcx
addq %rcx, %rax
addq $0x8, %rax
movq %rax, -0x20(%rbp)
jmp 0x355dd
movl -0x2c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x2c(%rbp)
jmp 0x3558f
jmp 0x355ea
movq -0x28(%rbp), %rax
movq 0x1000(%rax), %rax
movq %rax, -0x28(%rbp)
jmp 0x35581
movq -0x20(%rbp), %rax
movq $0x0, (%rax)
addq $0x40, %rsp
popq %rbp
retq
nopl (%rax)
// File: 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 %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x8(%rbp), %rax
addq $0x8, %rax
movq %rax, -0x20(%rbp)
cmpq $0x0, -0x20(%rbp)
je 0x356ab
movl $0x0, -0x24(%rbp)
cmpl $0x100, -0x24(%rbp)     # imm = 0x100
jge 0x35698
movq -0x20(%rbp), %rax
movslq -0x24(%rbp), %rcx
shlq $0x4, %rcx
addq %rcx, %rax
cmpl $0x0, (%rax)
je 0x3568b
movq -0x20(%rbp), %rax
movslq -0x24(%rbp), %rcx
shlq $0x4, %rcx
addq %rcx, %rax
movq %rax, -0x30(%rbp)
movq -0x10(%rbp), %rax
cmpq -0x30(%rbp), %rax
jne 0x3567a
jmp 0x3568d
movq -0x30(%rbp), %rdi
movq -0x10(%rbp), %rsi
movq -0x18(%rbp), %rdx
callq 0x16e20
jmp 0x3568d
movl -0x24(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x24(%rbp)
jmp 0x3563e
jmp 0x3569a
movq -0x20(%rbp), %rax
movq 0x1000(%rax), %rax
movq %rax, -0x20(%rbp)
jmp 0x35630
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
nopl (%rax,%rax)