LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: Silica[P]PSL/./PSL/pstring.h
// Function: PSL::variable::string::operator%=(unsigned long)
string &operator%=(size_t i)	/* �擪i������������ */
	{
		if (buf)
		{
			size_t c = buf->length();
			if (buf->shared())
			{
				if (i < c)
				{
					SharedBuffer *n = new SharedBuffer(c);
					n->fcopy(buf->buffer()+i, c-i);
					buf->finalize();
					buf = n;
				}
				else
				{
					buf->finalize();
					buf = NULL;
				}
			}
			else
			{
				if (i < c)
					buf->fmove(buf->buffer()+i, c-i);
				else
					buf->setlen(0);
			}
		}
		return *this;
	}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x38(%rbp)
cmpq $0x0, (%rax)
je 0x15783
movq -0x38(%rbp), %rax
movq (%rax), %rdi
callq 0x152c0
movq %rax, %rcx
movq -0x38(%rbp), %rax
movq %rcx, -0x18(%rbp)
movq (%rax), %rdi
callq 0x153a0
testb $0x1, %al
jne 0x1568a
jmp 0x15738
movq -0x10(%rbp), %rax
cmpq -0x18(%rbp), %rax
jae 0x1571f
movl $0x20, %edi
callq 0x13750
movq %rax, %rdi
movq %rdi, %rax
movq %rax, -0x40(%rbp)
movq -0x18(%rbp), %rsi
callq 0x13770
jmp 0x156b7
movq -0x38(%rbp), %rax
movq -0x40(%rbp), %rcx
movq %rcx, -0x20(%rbp)
movq -0x20(%rbp), %rcx
movq %rcx, -0x48(%rbp)
movq (%rax), %rdi
callq 0x13b70
movq -0x48(%rbp), %rdi
movq %rax, %rsi
addq -0x10(%rbp), %rsi
movq -0x18(%rbp), %rdx
subq -0x10(%rbp), %rdx
xorl %eax, %eax
movl %eax, %ecx
callq 0x15350
movq -0x38(%rbp), %rax
movq (%rax), %rdi
callq 0x121d0
movq -0x38(%rbp), %rax
movq -0x20(%rbp), %rcx
movq %rcx, (%rax)
jmp 0x15736
movq -0x40(%rbp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x28(%rbp)
movl %eax, -0x2c(%rbp)
callq 0x12250
jmp 0x1578d
movq -0x38(%rbp), %rax
movq (%rax), %rdi
callq 0x121d0
movq -0x38(%rbp), %rax
movq $0x0, (%rax)
jmp 0x15781
movq -0x10(%rbp), %rax
cmpq -0x18(%rbp), %rax
jae 0x1576f
movq -0x38(%rbp), %rax
movq (%rax), %rcx
movq %rcx, -0x50(%rbp)
movq (%rax), %rdi
callq 0x13b70
movq -0x50(%rbp), %rdi
movq %rax, %rsi
addq -0x10(%rbp), %rsi
movq -0x18(%rbp), %rdx
subq -0x10(%rbp), %rdx
callq 0x157a0
jmp 0x1577f
movq -0x38(%rbp), %rax
movq (%rax), %rdi
xorl %eax, %eax
movl %eax, %esi
callq 0x13b90
jmp 0x15781
jmp 0x15783
movq -0x38(%rbp), %rax
addq $0x50, %rsp
popq %rbp
retq
movq -0x28(%rbp), %rdi
callq 0xc280
nopw %cs:(%rax,%rax)
// File: Silica[P]PSL/./PSL/pstring.h
// Function: PSL::variable::string::operator==(PSL::variable::string const&) const
bool operator==(const string &s) const
	{
		if (buf == s.buf)					return true;
		if (!buf || !s.buf)					return false;
		size_t l = buf->length();
		if (l != s.buf->length())			return false;
		return !std::memcmp(buf->buffer(), s.buf->buffer(), l);
	}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x28(%rbp)
movq (%rax), %rax
movq -0x18(%rbp), %rcx
cmpq (%rcx), %rax
jne 0x1580d
movb $0x1, -0x1(%rbp)
jmp 0x15896
movq -0x28(%rbp), %rax
cmpq $0x0, (%rax)
je 0x15821
movq -0x18(%rbp), %rax
cmpq $0x0, (%rax)
jne 0x15827
movb $0x0, -0x1(%rbp)
jmp 0x15896
movq -0x28(%rbp), %rax
movq (%rax), %rdi
callq 0x152c0
movq %rax, -0x20(%rbp)
movq -0x20(%rbp), %rax
movq %rax, -0x30(%rbp)
movq -0x18(%rbp), %rax
movq (%rax), %rdi
callq 0x152c0
movq %rax, %rcx
movq -0x30(%rbp), %rax
cmpq %rcx, %rax
je 0x1585d
movb $0x0, -0x1(%rbp)
jmp 0x15896
movq -0x28(%rbp), %rax
movq (%rax), %rdi
callq 0x13b70
movq %rax, -0x38(%rbp)
movq -0x18(%rbp), %rax
movq (%rax), %rdi
callq 0x13b70
movq -0x38(%rbp), %rdi
movq %rax, %rsi
movq -0x20(%rbp), %rdx
callq 0xc0d0
cmpl $0x0, %eax
setne %al
xorb $-0x1, %al
andb $0x1, %al
movb %al, -0x1(%rbp)
movb -0x1(%rbp), %al
andb $0x1, %al
addq $0x40, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
nopl (%rax,%rax)
// File: Silica[P]PSL/./PSL/pstring.h
// Function: PSL::variable::string::operator<=(PSL::variable::string const&) const
bool operator<=(const string &s) const
	{
		if (buf == s.buf)	return true;
		if (!buf)			return true;
		if (!s.buf)			return false;
		size_t max = min_s(buf->length(), s.buf->length());
		for (size_t t = 0; t < max; ++t)
		{
			if (buf->at(t) < s.buf->at(t))	return true;
			if (buf->at(t) > s.buf->at(t))	return false;
		}
		if (buf->length() <= s.buf->length())	return true;
		return false;
	}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x30(%rbp)
movq (%rax), %rax
movq -0x18(%rbp), %rcx
cmpq (%rcx), %rax
jne 0x1590d
movb $0x1, -0x1(%rbp)
jmp 0x15a2a
movq -0x30(%rbp), %rax
cmpq $0x0, (%rax)
jne 0x15920
movb $0x1, -0x1(%rbp)
jmp 0x15a2a
movq -0x18(%rbp), %rax
cmpq $0x0, (%rax)
jne 0x15933
movb $0x0, -0x1(%rbp)
jmp 0x15a2a
movq -0x30(%rbp), %rax
movq (%rax), %rdi
callq 0x152c0
movq %rax, -0x38(%rbp)
movq -0x18(%rbp), %rax
movq (%rax), %rdi
callq 0x152c0
movq -0x38(%rbp), %rdi
movq %rax, %rsi
callq 0x15480
movq %rax, -0x20(%rbp)
movq $0x0, -0x28(%rbp)
movq -0x28(%rbp), %rax
cmpq -0x20(%rbp), %rax
jae 0x159f8
movq -0x30(%rbp), %rax
movq (%rax), %rdi
movq -0x28(%rbp), %rsi
callq 0x15a40
movsbl %al, %eax
movl %eax, -0x3c(%rbp)
movq -0x18(%rbp), %rax
movq (%rax), %rdi
movq -0x28(%rbp), %rsi
callq 0x15a40
movb %al, %cl
movl -0x3c(%rbp), %eax
movsbl %cl, %ecx
cmpl %ecx, %eax
jge 0x159ad
movb $0x1, -0x1(%rbp)
jmp 0x15a2a
movq -0x30(%rbp), %rax
movq (%rax), %rdi
movq -0x28(%rbp), %rsi
callq 0x15a40
movsbl %al, %eax
movl %eax, -0x40(%rbp)
movq -0x18(%rbp), %rax
movq (%rax), %rdi
movq -0x28(%rbp), %rsi
callq 0x15a40
movb %al, %cl
movl -0x40(%rbp), %eax
movsbl %cl, %ecx
cmpl %ecx, %eax
jle 0x159e5
movb $0x0, -0x1(%rbp)
jmp 0x15a2a
jmp 0x159e7
movq -0x28(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x28(%rbp)
jmp 0x15967
movq -0x30(%rbp), %rax
movq (%rax), %rdi
callq 0x152c0
movq %rax, -0x48(%rbp)
movq -0x18(%rbp), %rax
movq (%rax), %rdi
callq 0x152c0
movq %rax, %rcx
movq -0x48(%rbp), %rax
cmpq %rcx, %rax
ja 0x15a26
movb $0x1, -0x1(%rbp)
jmp 0x15a2a
movb $0x0, -0x1(%rbp)
movb -0x1(%rbp), %al
andb $0x1, %al
addq $0x50, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
nop
// File: Silica[P]PSL/./PSL/pstring.h
// Function: PSL::variable::string::reverse()
string &reverse()	/* ���]������ */
	{
		if (buf)
		{
			size_t m = buf->length();
			only_and_extend(m);
			size_t e = m/2;
			char *b = buf->buffer();
			for (size_t t = 0; t < e; ++t)
			{
				char temp = b[t];
				b[t] = b[m-t-1];
				b[m-t-1] = temp;
			}
		}
		return *this;
	}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x38(%rbp)
cmpq $0x0, (%rax)
je 0x15cda
movq -0x38(%rbp), %rax
movq (%rax), %rdi
callq 0x152c0
movq -0x38(%rbp), %rdi
movq %rax, -0x10(%rbp)
movq -0x10(%rbp), %rsi
callq 0x152e0
movq -0x38(%rbp), %rax
movq -0x10(%rbp), %rcx
shrq %rcx
movq %rcx, -0x18(%rbp)
movq (%rax), %rdi
callq 0x13b70
movq %rax, -0x20(%rbp)
movq $0x0, -0x28(%rbp)
movq -0x28(%rbp), %rax
cmpq -0x18(%rbp), %rax
jae 0x15cd8
movq -0x20(%rbp), %rax
movq -0x28(%rbp), %rcx
movb (%rax,%rcx), %al
movb %al, -0x29(%rbp)
movq -0x20(%rbp), %rax
movq -0x10(%rbp), %rcx
subq -0x28(%rbp), %rcx
subq $0x1, %rcx
movb (%rax,%rcx), %dl
movq -0x20(%rbp), %rax
movq -0x28(%rbp), %rcx
movb %dl, (%rax,%rcx)
movb -0x29(%rbp), %dl
movq -0x20(%rbp), %rax
movq -0x10(%rbp), %rcx
subq -0x28(%rbp), %rcx
subq $0x1, %rcx
movb %dl, (%rax,%rcx)
movq -0x28(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x28(%rbp)
jmp 0x15c7e
jmp 0x15cda
movq -0x38(%rbp), %rax
addq $0x40, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
nop
// File: Silica[P]PSL/./PSL/pstring.h
// Function: PSL::variable::string::operator int() const
operator int() const
	{
		if (!buf)	return 0;
		char *b = buf->buffer();
		size_t l = buf->length();
		bool minus = false;
		size_t c = 0;
		int r = 0;
		for (; c < l; ++c)
		{
			if (b[c] != SPACE && b[c] != TAB)
				break;
		}
		if (b[c] == MINUS)
		{
			minus = true;
			++c;
		}
		for (; c < l; ++c)
		{
			if (!(b[c] >= ZERO && b[c] <= ZERO+9))
				break;
			r *= 10;
			r += b[c] - ZERO;
		}
		if (minus)
			r = -r;
		return r;
	}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x10(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x40(%rbp)
cmpq $0x0, (%rax)
jne 0x15d56
movl $0x0, -0x4(%rbp)
jmp 0x15e59
movq -0x40(%rbp), %rax
movq (%rax), %rdi
callq 0x13b70
movq %rax, %rcx
movq -0x40(%rbp), %rax
movq %rcx, -0x18(%rbp)
movq (%rax), %rdi
callq 0x152c0
movq %rax, -0x20(%rbp)
movb $0x0, -0x21(%rbp)
movq $0x0, -0x30(%rbp)
movl $0x0, -0x34(%rbp)
movq -0x30(%rbp), %rax
cmpq -0x20(%rbp), %rax
jae 0x15dca
movq -0x18(%rbp), %rax
movq -0x30(%rbp), %rcx
movsbl (%rax,%rcx), %eax
cmpl $0x20, %eax
je 0x15dba
movq -0x18(%rbp), %rax
movq -0x30(%rbp), %rcx
movsbl (%rax,%rcx), %eax
cmpl $0x9, %eax
je 0x15dba
jmp 0x15dca
jmp 0x15dbc
movq -0x30(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x30(%rbp)
jmp 0x15d8c
movq -0x18(%rbp), %rax
movq -0x30(%rbp), %rcx
movsbl (%rax,%rcx), %eax
cmpl $0x2d, %eax
jne 0x15deb
movb $0x1, -0x21(%rbp)
movq -0x30(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x30(%rbp)
jmp 0x15ded
movq -0x30(%rbp), %rax
cmpq -0x20(%rbp), %rax
jae 0x15e45
movq -0x18(%rbp), %rax
movq -0x30(%rbp), %rcx
movsbl (%rax,%rcx), %eax
cmpl $0x30, %eax
jl 0x15e19
movq -0x18(%rbp), %rax
movq -0x30(%rbp), %rcx
movsbl (%rax,%rcx), %eax
cmpl $0x39, %eax
jle 0x15e1b
jmp 0x15e45
imull $0xa, -0x34(%rbp), %eax
movl %eax, -0x34(%rbp)
movq -0x18(%rbp), %rax
movq -0x30(%rbp), %rcx
movsbl (%rax,%rcx), %eax
subl $0x30, %eax
addl -0x34(%rbp), %eax
movl %eax, -0x34(%rbp)
movq -0x30(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x30(%rbp)
jmp 0x15ded
testb $0x1, -0x21(%rbp)
je 0x15e53
xorl %eax, %eax
subl -0x34(%rbp), %eax
movl %eax, -0x34(%rbp)
movl -0x34(%rbp), %eax
movl %eax, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x40, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
nopl (%rax)
// File: Silica[P]PSL/./PSL/variable.h
// Function: PSL::variable::Variable::searchcount(PSL::variable::Variable*, int&)
bool searchcount(Variable *v, int &c)
		{
			if (rc & 0x40000000)
				return true;
			if (static_cast<unsigned>(rc) & 0x80000000)
			{
				if (v == this)
					++c;
				return false;
			}
			rc |= 0x80000000;
			x->searchcount(v, c);
			return false;
		}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x28(%rbp)
movl 0x8(%rax), %eax
andl $0x40000000, %eax       # imm = 0x40000000
cmpl $0x0, %eax
je 0x16e4f
movb $0x1, -0x1(%rbp)
jmp 0x16ea0
movq -0x28(%rbp), %rax
movl 0x8(%rax), %eax
andl $0x80000000, %eax       # imm = 0x80000000
cmpl $0x0, %eax
je 0x16e7b
movq -0x28(%rbp), %rax
cmpq %rax, -0x18(%rbp)
jne 0x16e75
movq -0x20(%rbp), %rax
movl (%rax), %ecx
addl $0x1, %ecx
movl %ecx, (%rax)
movb $0x0, -0x1(%rbp)
jmp 0x16ea0
movq -0x28(%rbp), %rax
movl 0x8(%rax), %ecx
orl $0x80000000, %ecx       # imm = 0x80000000
movl %ecx, 0x8(%rax)
movq (%rax), %rdi
movq -0x18(%rbp), %rsi
movq -0x20(%rbp), %rdx
movq (%rdi), %rax
callq *0x20(%rax)
movb $0x0, -0x1(%rbp)
movb -0x1(%rbp), %al
andb $0x1, %al
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: Silica[P]PSL/./PSL/variable.h
// Function: PSL::variable::Variable::mark()
void mark()
		{
			if (rc & 0x40000000)
				return;
			rc |= 0x40000000;
			x->mark();
		}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x10(%rbp)
movl 0x8(%rax), %eax
andl $0x40000000, %eax       # imm = 0x40000000
cmpl $0x0, %eax
je 0x16ed3
jmp 0x16eec
movq -0x10(%rbp), %rax
movl 0x8(%rax), %ecx
orl $0x40000000, %ecx       # imm = 0x40000000
movl %ecx, 0x8(%rax)
movq (%rax), %rdi
movq (%rdi), %rax
callq *0x28(%rax)
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
nopl (%rax)
// File: Silica[P]PSL/./PSL/environment.h
// Function: PSL::variable::Variable::Environment::clone()
Environment *clone()
	{
		Environment *e = new Environment(*this);
		if (scope)
			e->scope = scope->clone();
		size_t s = stack.size();
		#ifdef PSL_USE_STL_STACK
		if (s)
		{
			rlist l(s);
			for (size_t i = s; i > 0;)
			{
				l[--i] = stack.top();
				stack.pop();
			}
			for (size_t i = 0; i < s; ++i)
			{
				stack.push(l[i]);
				e->stack.push(l[i]);
			}
		}
		#else
		for (size_t i = 0; i < s; ++i)
			e->stack[i] = stack[i];
		#endif
		return e;
	}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x40(%rbp)
movl $0x28, %edi
callq 0x19e40
movq -0x40(%rbp), %rsi
movq %rax, %rdi
movq %rdi, %rax
movq %rax, -0x38(%rbp)
callq 0x19e60
jmp 0x19d83
movq -0x40(%rbp), %rax
movq -0x38(%rbp), %rcx
movq %rcx, -0x10(%rbp)
cmpq $0x0, 0x20(%rax)
je 0x19dc8
movq -0x40(%rbp), %rax
movq 0x20(%rax), %rdi
movq (%rdi), %rax
callq *0x10(%rax)
movq %rax, %rcx
movq -0x10(%rbp), %rax
movq %rcx, 0x20(%rax)
jmp 0x19dc8
movq -0x38(%rbp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x18(%rbp)
movl %eax, -0x1c(%rbp)
callq 0x19be0
jmp 0x19e35
movq -0x40(%rbp), %rdi
addq $0x8, %rdi
callq 0x19150
movq %rax, -0x28(%rbp)
movq $0x0, -0x30(%rbp)
movq -0x30(%rbp), %rax
cmpq -0x28(%rbp), %rax
jae 0x19e2b
movq -0x40(%rbp), %rdi
addq $0x8, %rdi
movq -0x30(%rbp), %rsi
callq 0x19170
movq %rax, -0x48(%rbp)
movq -0x10(%rbp), %rdi
addq $0x8, %rdi
movq -0x30(%rbp), %rsi
callq 0x19170
movq -0x48(%rbp), %rsi
movq %rax, %rdi
callq 0x12310
movq -0x30(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x30(%rbp)
jmp 0x19de1
movq -0x10(%rbp), %rax
addq $0x50, %rsp
popq %rbp
retq
movq -0x18(%rbp), %rdi
callq 0xc280
nop
// File: Silica[P]PSL/./PSL/environment.h
// Function: PSL::variable::Variable::Environment::getVariable(PSL::variable::string const&)
rsv getVariable(const string &name)
	{
		Variable *v;
		v = scope->getVariable(name);		if (v)return v;
		v = global.get()->getifexist(name);	if (v)return v;
		warning(1, name);
		variable x;
		scope->addLocal(name, x);
		return x;
	}

// 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), %rax
movq %rax, -0x40(%rbp)
movq 0x20(%rax), %rdi
movq -0x18(%rbp), %rsi
movq (%rdi), %rax
callq *0x18(%rax)
movq %rax, -0x20(%rbp)
cmpq $0x0, -0x20(%rbp)
je 0x1a052
movq -0x50(%rbp), %rdi
movq -0x20(%rbp), %rsi
callq 0x17710
jmp 0x1a0ec
movq -0x40(%rbp), %rdi
callq 0x12060
movq %rax, %rdi
movq -0x18(%rbp), %rsi
callq 0x1a100
movq %rax, -0x20(%rbp)
cmpq $0x0, -0x20(%rbp)
je 0x1a081
movq -0x50(%rbp), %rdi
movq -0x20(%rbp), %rsi
callq 0x17710
jmp 0x1a0ec
movq -0x40(%rbp), %rdi
movq -0x18(%rbp), %rdx
movl $0x1, %esi
callq 0x11b70
leaq -0x28(%rbp), %rdi
movq %rdi, -0x58(%rbp)
callq 0x1a130
movq -0x40(%rbp), %rax
movq -0x58(%rbp), %rdx
movq 0x20(%rax), %rdi
movq -0x18(%rbp), %rsi
xorl %eax, %eax
movl %eax, %ecx
callq 0x1a190
jmp 0x1a0bb
movq -0x50(%rbp), %rdi
leaq -0x28(%rbp), %rsi
callq 0x11b10
jmp 0x1a0ca
leaq -0x28(%rbp), %rdi
callq 0xcdc0
jmp 0x1a0ec
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x30(%rbp)
movl %eax, -0x34(%rbp)
leaq -0x28(%rbp), %rdi
callq 0xcdc0
jmp 0x1a0f6
movq -0x48(%rbp), %rax
addq $0x60, %rsp
popq %rbp
retq
movq -0x30(%rbp), %rdi
callq 0xc280
nop
// File: Silica[P]PSL/./PSL/environment.h
// Function: PSL::variable::Variable::Code::Run(PSL::variable::Variable::Environment&, unsigned long&)
bool Run(Environment &env, size_t &line)
	{
		size_t size = code.size();
		while (line < size)
		{
			OpCode::RC::RETURNCODE r = code[line++]->Execute(env);
			if (!r)						continue;
			if (r == OpCode::RC::YIELD)	return false;
			return true;
		}
		env.endScope();
		return true;
	}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movq -0x10(%rbp), %rdi
movq %rdi, -0x38(%rbp)
callq 0x1a3c0
movq %rax, -0x28(%rbp)
movq -0x20(%rbp), %rax
movq (%rax), %rax
cmpq -0x28(%rbp), %rax
jae 0x1a3a6
movq -0x38(%rbp), %rdi
movq -0x20(%rbp), %rax
movq (%rax), %rsi
movq %rsi, %rcx
addq $0x1, %rcx
movq %rcx, (%rax)
callq 0x1a3e0
movq (%rax), %rdi
movq -0x18(%rbp), %rsi
movq (%rdi), %rax
callq *0x10(%rax)
movl %eax, -0x2c(%rbp)
cmpl $0x0, -0x2c(%rbp)
jne 0x1a394
jmp 0x1a355
cmpl $0x7, -0x2c(%rbp)
jne 0x1a3a0
movb $0x0, -0x1(%rbp)
jmp 0x1a3b3
movb $0x1, -0x1(%rbp)
jmp 0x1a3b3
movq -0x18(%rbp), %rdi
callq 0x1a400
movb $0x1, -0x1(%rbp)
movb -0x1(%rbp), %al
andb $0x1, %al
addq $0x40, %rsp
popq %rbp
retq
nop
// File: Silica[P]PSL/./PSL/container.h
// Function: PSL::variable::table::~table()
~table()
	{
		size_t max = reserve * 2;
		for (size_t i = 0; i < max; ++i)
			delete d[i];
		delete[] d;
	}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x20(%rbp)
movq 0x8(%rax), %rax
shlq %rax
movq %rax, -0x10(%rbp)
movq $0x0, -0x18(%rbp)
movq -0x18(%rbp), %rax
cmpq -0x10(%rbp), %rax
jae 0x1a54d
movq -0x20(%rbp), %rax
movq 0x10(%rax), %rax
movq -0x18(%rbp), %rcx
movq (%rax,%rcx,8), %rax
movq %rax, -0x28(%rbp)
cmpq $0x0, %rax
je 0x1a53d
movq -0x28(%rbp), %rdi
callq 0x1a6e0
movq -0x28(%rbp), %rdi
callq 0x1a710
jmp 0x1a53f
movq -0x18(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x18(%rbp)
jmp 0x1a507
movq -0x20(%rbp), %rax
movq 0x10(%rax), %rax
movq %rax, -0x30(%rbp)
cmpq $0x0, %rax
je 0x1a568
movq -0x30(%rbp), %rdi
callq 0xc210
addq $0x30, %rsp
popq %rbp
retq
nop
// File: Silica[P]PSL/./PSL/container.h
// Function: PSL::variable::table::operator[](PSL::variable::string const&)
rsv &operator[](const string &s)
	{
		if (len)
		{
			int i = search(s);
			if (i >= 0)
				return d[i]->second;
		}
		if (len >= reserve)
			resize();
		hash h = gethash(s, reserve);
		size_t i = getnextnull(h);
		d[i] = new data(s);
		++len;
		return d[i]->second;
	}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x48(%rbp)
cmpq $0x0, (%rax)
je 0x1a9f3
movq -0x48(%rbp), %rdi
movq -0x18(%rbp), %rsi
callq 0x1aad0
movl %eax, -0x1c(%rbp)
cmpl $0x0, -0x1c(%rbp)
jl 0x1a9f1
movq -0x48(%rbp), %rax
movq 0x10(%rax), %rax
movslq -0x1c(%rbp), %rcx
movq (%rax,%rcx,8), %rax
addq $0x8, %rax
movq %rax, -0x8(%rbp)
jmp 0x1aa99
jmp 0x1a9f3
movq -0x48(%rbp), %rcx
movq (%rcx), %rax
cmpq 0x8(%rcx), %rax
jb 0x1aa09
movq -0x48(%rbp), %rdi
callq 0x1ac40
movq -0x48(%rbp), %rax
movq -0x18(%rbp), %rdi
movq 0x8(%rax), %rsi
callq 0x1ad30
movq -0x48(%rbp), %rdi
movq %rax, -0x28(%rbp)
movq -0x28(%rbp), %rsi
callq 0x1ad60
movq %rax, -0x30(%rbp)
movl $0x10, %edi
callq 0x1ae60
movq %rax, %rdi
movq %rdi, %rax
movq %rax, -0x50(%rbp)
movq -0x18(%rbp), %rsi
callq 0x1ae80
jmp 0x1aa4e
movq -0x48(%rbp), %rax
movq -0x50(%rbp), %rsi
movq 0x10(%rax), %rcx
movq -0x30(%rbp), %rdx
movq %rsi, (%rcx,%rdx,8)
movq (%rax), %rcx
addq $0x1, %rcx
movq %rcx, (%rax)
movq 0x10(%rax), %rax
movq -0x30(%rbp), %rcx
movq (%rax,%rcx,8), %rax
addq $0x8, %rax
movq %rax, -0x8(%rbp)
jmp 0x1aa99
movq -0x50(%rbp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x38(%rbp)
movl %eax, -0x3c(%rbp)
callq 0x1a710
jmp 0x1aaa3
movq -0x8(%rbp), %rax
addq $0x50, %rsp
popq %rbp
retq
movq -0x38(%rbp), %rdi
callq 0xc280
nopl (%rax)
// File: Silica[P]PSL/./PSL/container.h
// Function: PSL::variable::table::search(PSL::variable::string const&) const
int search(const string &s) const
	{
		hash h = gethash(s, reserve);
		if (!d[h])
			return -1;
		else if (d[h]->first == s)
			return static_cast<int>(h);

		size_t max = reserve*2;
		for (size_t i = reserve+h; i < max; ++i)
			if (d[i] && d[i]->first == s)
				return static_cast<int>(i);
		max = reserve + h;
		for (size_t i = reserve; i < max; ++i)
			if (d[i] && d[i]->first == s)
				return static_cast<int>(i);
		return -1;
	}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x40(%rbp)
movq -0x18(%rbp), %rdi
movq 0x8(%rax), %rsi
callq 0x1ad30
movq %rax, %rcx
movq -0x40(%rbp), %rax
movq %rcx, -0x20(%rbp)
movq 0x10(%rax), %rax
movq -0x20(%rbp), %rcx
cmpq $0x0, (%rax,%rcx,8)
jne 0x1ab1b
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
jmp 0x1ac2f
movq -0x40(%rbp), %rax
movq 0x10(%rax), %rax
movq -0x20(%rbp), %rcx
movq (%rax,%rcx,8), %rdi
movq -0x18(%rbp), %rsi
callq 0x157e0
testb $0x1, %al
jne 0x1ab3a
jmp 0x1ab46
movq -0x20(%rbp), %rax
movl %eax, -0x4(%rbp)
jmp 0x1ac2f
jmp 0x1ab48
movq -0x40(%rbp), %rax
movq 0x8(%rax), %rcx
shlq %rcx
movq %rcx, -0x28(%rbp)
movq 0x8(%rax), %rax
addq -0x20(%rbp), %rax
movq %rax, -0x30(%rbp)
movq -0x30(%rbp), %rax
cmpq -0x28(%rbp), %rax
jae 0x1abbb
movq -0x40(%rbp), %rax
movq 0x10(%rax), %rax
movq -0x30(%rbp), %rcx
cmpq $0x0, (%rax,%rcx,8)
je 0x1abab
movq -0x40(%rbp), %rax
movq 0x10(%rax), %rax
movq -0x30(%rbp), %rcx
movq (%rax,%rcx,8), %rdi
movq -0x18(%rbp), %rsi
callq 0x157e0
testb $0x1, %al
jne 0x1ab9f
jmp 0x1abab
movq -0x30(%rbp), %rax
movl %eax, -0x4(%rbp)
jmp 0x1ac2f
jmp 0x1abad
movq -0x30(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x30(%rbp)
jmp 0x1ab63
movq -0x40(%rbp), %rax
movq 0x8(%rax), %rcx
addq -0x20(%rbp), %rcx
movq %rcx, -0x28(%rbp)
movq 0x8(%rax), %rax
movq %rax, -0x38(%rbp)
movq -0x38(%rbp), %rax
cmpq -0x28(%rbp), %rax
jae 0x1ac28
movq -0x40(%rbp), %rax
movq 0x10(%rax), %rax
movq -0x38(%rbp), %rcx
cmpq $0x0, (%rax,%rcx,8)
je 0x1ac18
movq -0x40(%rbp), %rax
movq 0x10(%rax), %rax
movq -0x38(%rbp), %rcx
movq (%rax,%rcx,8), %rdi
movq -0x18(%rbp), %rsi
callq 0x157e0
testb $0x1, %al
jne 0x1ac0f
jmp 0x1ac18
movq -0x38(%rbp), %rax
movl %eax, -0x4(%rbp)
jmp 0x1ac2f
jmp 0x1ac1a
movq -0x38(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x38(%rbp)
jmp 0x1abd3
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
movl -0x4(%rbp), %eax
addq $0x40, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: Silica[P]PSL/./PSL/container.h
// Function: PSL::variable::table::resize()
void resize()
	{
		if (!reserve)
		{
			reserve = 2;
			Reserve();
			return;
		}
		reserve *= 2;
		data **old = Reserve();
		for (size_t i = 0; i < reserve; ++i)
		{
			if (old[i])
			{
				hash h = gethash(old[i]->first, reserve);
				size_t n = getnextnull(h);
				d[n] = old[i];
			}
		}
		delete[] old;
	}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x30(%rbp)
cmpq $0x0, 0x8(%rax)
jne 0x1ac71
movq -0x30(%rbp), %rdi
movq $0x2, 0x8(%rdi)
callq 0x1aee0
jmp 0x1ad22
movq -0x30(%rbp), %rdi
movq 0x8(%rdi), %rax
shlq %rax
movq %rax, 0x8(%rdi)
callq 0x1aee0
movq %rax, -0x10(%rbp)
movq $0x0, -0x18(%rbp)
movq -0x30(%rbp), %rcx
movq -0x18(%rbp), %rax
cmpq 0x8(%rcx), %rax
jae 0x1ad0b
movq -0x10(%rbp), %rax
movq -0x18(%rbp), %rcx
cmpq $0x0, (%rax,%rcx,8)
je 0x1acfb
movq -0x30(%rbp), %rax
movq -0x10(%rbp), %rcx
movq -0x18(%rbp), %rdx
movq (%rcx,%rdx,8), %rdi
movq 0x8(%rax), %rsi
callq 0x1ad30
movq -0x30(%rbp), %rdi
movq %rax, -0x20(%rbp)
movq -0x20(%rbp), %rsi
callq 0x1ad60
movq %rax, %rcx
movq -0x30(%rbp), %rax
movq %rcx, -0x28(%rbp)
movq -0x10(%rbp), %rcx
movq -0x18(%rbp), %rdx
movq (%rcx,%rdx,8), %rdx
movq 0x10(%rax), %rax
movq -0x28(%rbp), %rcx
movq %rdx, (%rax,%rcx,8)
jmp 0x1acfd
movq -0x18(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x18(%rbp)
jmp 0x1ac91
movq -0x10(%rbp), %rax
movq %rax, -0x38(%rbp)
cmpq $0x0, %rax
je 0x1ad22
movq -0x38(%rbp), %rdi
callq 0xc210
addq $0x40, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: Silica[P]PSL/./PSL/container.h
// Function: PSL::variable::table::getnextnull(unsigned long) const
size_t getnextnull(size_t t) const
	{
		if (!d[t])
			return t;
		size_t max = reserve*2;
		for (size_t i = reserve+t; i < max; ++i)
			if (!d[i])
				return i;
		max = reserve + t;
		for (size_t i = reserve; i < max; ++i)
			if (!d[i])
				return i;
		PSL_PRINTF(("table error:\n"));
		return 0;
	}

// 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 0x10(%rax), %rax
movq -0x18(%rbp), %rcx
cmpq $0x0, (%rax,%rcx,8)
jne 0x1ad94
movq -0x18(%rbp), %rax
movq %rax, -0x8(%rbp)
jmp 0x1ae4b
movq -0x38(%rbp), %rax
movq 0x8(%rax), %rcx
shlq %rcx
movq %rcx, -0x20(%rbp)
movq 0x8(%rax), %rax
addq -0x18(%rbp), %rax
movq %rax, -0x28(%rbp)
movq -0x28(%rbp), %rax
cmpq -0x20(%rbp), %rax
jae 0x1ade6
movq -0x38(%rbp), %rax
movq 0x10(%rax), %rax
movq -0x28(%rbp), %rcx
cmpq $0x0, (%rax,%rcx,8)
jne 0x1add6
movq -0x28(%rbp), %rax
movq %rax, -0x8(%rbp)
jmp 0x1ae4b
jmp 0x1add8
movq -0x28(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x28(%rbp)
jmp 0x1adaf
movq -0x38(%rbp), %rax
movq 0x8(%rax), %rcx
addq -0x18(%rbp), %rcx
movq %rcx, -0x20(%rbp)
movq 0x8(%rax), %rax
movq %rax, -0x30(%rbp)
movq -0x30(%rbp), %rax
cmpq -0x20(%rbp), %rax
jae 0x1ae35
movq -0x38(%rbp), %rax
movq 0x10(%rax), %rax
movq -0x30(%rbp), %rcx
cmpq $0x0, (%rax,%rcx,8)
jne 0x1ae25
movq -0x30(%rbp), %rax
movq %rax, -0x8(%rbp)
jmp 0x1ae4b
jmp 0x1ae27
movq -0x30(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x30(%rbp)
jmp 0x1adfe
leaq 0x239c4(%rip), %rdi     # 0x3e800
movb $0x0, %al
callq 0xc050
movq $0x0, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x40, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
nop
// File: Silica[P]PSL/./PSL/container.h
// Function: PSL::variable::table::Reserve()
data **Reserve()
	{
		data **old = d;
		d = new data*[reserve * 2];
		std::memset(d, 0, sizeof(data*) * 2 * reserve);
		return old;
	}

// 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 0x8(%rax), %rax
shlq %rax
movl $0x8, %ecx
mulq %rcx
movq %rax, %rdi
seto %cl
movq $-0x1, %rax
testb $0x1, %cl
cmovneq %rax, %rdi
callq 0xc040
movq %rax, %rcx
movq -0x18(%rbp), %rax
movq %rcx, 0x10(%rax)
movq 0x10(%rax), %rdi
movq 0x8(%rax), %rdx
shlq $0x4, %rdx
xorl %esi, %esi
callq 0xc0e0
movq -0x10(%rbp), %rax
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax)
// File: Silica[P]PSL/./PSL/pstring.h
// Function: PSL::variable::string::hash() const
unsigned long hash() const
	{
		if (!buf)
			return 0;
		unsigned long l = buf->length();
		if (!l)
			return 0;
		unsigned long a = static_cast<unsigned long>(buf->at(0));
		unsigned long b = static_cast<unsigned long>(buf->at(l-1));
		return (b | (a<<8)) ^ (l<<4);
	}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x30(%rbp)
cmpq $0x0, (%rax)
jne 0x1af74
movq $0x0, -0x8(%rbp)
jmp 0x1afe9
movq -0x30(%rbp), %rax
movq (%rax), %rdi
callq 0x152c0
movq %rax, -0x18(%rbp)
cmpq $0x0, -0x18(%rbp)
jne 0x1af95
movq $0x0, -0x8(%rbp)
jmp 0x1afe9
movq -0x30(%rbp), %rax
movq (%rax), %rdi
xorl %eax, %eax
movl %eax, %esi
callq 0x15a40
movb %al, %cl
movq -0x30(%rbp), %rax
movsbq %cl, %rcx
movq %rcx, -0x20(%rbp)
movq (%rax), %rdi
movq -0x18(%rbp), %rsi
subq $0x1, %rsi
callq 0x15a40
movsbq %al, %rax
movq %rax, -0x28(%rbp)
movq -0x28(%rbp), %rax
movq -0x20(%rbp), %rcx
shlq $0x8, %rcx
orq %rcx, %rax
movq -0x18(%rbp), %rcx
shlq $0x4, %rcx
xorq %rcx, %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
nopl (%rax)
// File: Silica[P]PSL/./PSL/container.h
// Function: PSL::variable::table::count(PSL::variable::string const&) const
size_t count(const string &s) const
	{
		if (!reserve)	return 0;
		if (search(s) < 0)
			return 0;
		return 1;
	}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x20(%rbp)
cmpq $0x0, 0x8(%rax)
jne 0x1b039
movq $0x0, -0x8(%rbp)
jmp 0x1b05d
movq -0x20(%rbp), %rdi
movq -0x18(%rbp), %rsi
callq 0x1aad0
cmpl $0x0, %eax
jge 0x1b055
movq $0x0, -0x8(%rbp)
jmp 0x1b05d
movq $0x1, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x20, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: Silica[P]PSL/./PSL/container.h
// Function: PSL::variable::table::erase(PSL::variable::string const&)
void erase(const string &s)
	{
		if (!len)
			return;
		int i = search(s);
		if (i < 0)
			return;
		delete d[i];
		if (i < static_cast<int>(reserve))
			move(static_cast<hash>(i));
		else
			d[i] = NULL;
	}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x20(%rbp)
cmpq $0x0, (%rax)
jne 0x1b100
jmp 0x1b176
movq -0x20(%rbp), %rdi
movq -0x10(%rbp), %rsi
callq 0x1aad0
movl %eax, -0x14(%rbp)
cmpl $0x0, -0x14(%rbp)
jge 0x1b118
jmp 0x1b176
movq -0x20(%rbp), %rax
movq 0x10(%rax), %rax
movslq -0x14(%rbp), %rcx
movq (%rax,%rcx,8), %rax
movq %rax, -0x28(%rbp)
cmpq $0x0, %rax
je 0x1b144
movq -0x28(%rbp), %rdi
callq 0x1a6e0
movq -0x28(%rbp), %rdi
callq 0x1a710
movq -0x20(%rbp), %rcx
movl -0x14(%rbp), %eax
movq 0x8(%rcx), %rcx
cmpl %ecx, %eax
jge 0x1b162
movq -0x20(%rbp), %rdi
movslq -0x14(%rbp), %rsi
callq 0x1b180
jmp 0x1b176
movq -0x20(%rbp), %rax
movq 0x10(%rax), %rax
movslq -0x14(%rbp), %rcx
movq $0x0, (%rax,%rcx,8)
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax)
// File: Silica[P]PSL/./PSL/container.h
// Function: PSL::variable::table::move(unsigned long)
void move(hash h)
	{
		size_t max = reserve*2;
		for (size_t i = reserve; i < max; ++i)
			if (d[i] && h == gethash(d[i]->first, reserve))
			{
				d[h] = d[i];
				d[i] = NULL;
				return;
			}
		d[h] = NULL;
	}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x28(%rbp)
movq 0x8(%rax), %rcx
shlq %rcx
movq %rcx, -0x18(%rbp)
movq 0x8(%rax), %rax
movq %rax, -0x20(%rbp)
movq -0x20(%rbp), %rax
cmpq -0x18(%rbp), %rax
jae 0x1b23a
movq -0x28(%rbp), %rax
movq 0x10(%rax), %rax
movq -0x20(%rbp), %rcx
cmpq $0x0, (%rax,%rcx,8)
je 0x1b227
movq -0x28(%rbp), %rax
movq -0x10(%rbp), %rcx
movq %rcx, -0x30(%rbp)
movq 0x10(%rax), %rcx
movq -0x20(%rbp), %rdx
movq (%rcx,%rdx,8), %rdi
movq 0x8(%rax), %rsi
callq 0x1ad30
movq %rax, %rcx
movq -0x30(%rbp), %rax
cmpq %rcx, %rax
jne 0x1b227
movq -0x28(%rbp), %rax
movq 0x10(%rax), %rcx
movq -0x20(%rbp), %rdx
movq (%rcx,%rdx,8), %rsi
movq 0x10(%rax), %rcx
movq -0x10(%rbp), %rdx
movq %rsi, (%rcx,%rdx,8)
movq 0x10(%rax), %rax
movq -0x20(%rbp), %rcx
movq $0x0, (%rax,%rcx,8)
jmp 0x1b24e
jmp 0x1b229
movq -0x20(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x20(%rbp)
jmp 0x1b1ab
movq -0x28(%rbp), %rax
movq 0x10(%rax), %rax
movq -0x10(%rbp), %rcx
movq $0x0, (%rax,%rcx,8)
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
nop
// File: Silica[P]PSL/./PSL/environment.h
// Function: PSL::variable::Variable::Code::only()
Code *only()
	{
		if (rc == 1)
			return this;
		else
		{
			finalize();
			return new Code(this);
		}
	}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x28(%rbp)
cmpl $0x1, 0x30(%rax)
jne 0x1b4a4
movq -0x28(%rbp), %rax
movq %rax, -0x8(%rbp)
jmp 0x1b4ed
movq -0x28(%rbp), %rdi
callq 0x1a490
movl $0x38, %edi
callq 0x1b7a0
movq -0x28(%rbp), %rsi
movq %rax, %rdi
movq %rdi, %rax
movq %rax, -0x30(%rbp)
callq 0x1b7c0
jmp 0x1b4cc
movq -0x30(%rbp), %rax
movq %rax, -0x8(%rbp)
jmp 0x1b4ed
movq -0x30(%rbp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x18(%rbp)
movl %eax, -0x1c(%rbp)
callq 0x1a600
jmp 0x1b4f7
movq -0x8(%rbp), %rax
addq $0x30, %rsp
popq %rbp
retq
movq -0x18(%rbp), %rdi
callq 0xc280
// File: Silica[P]PSL/./PSL/environment.h
// Function: PSL::variable::Variable::Code::Code(PSL::variable::Variable::Code*)
Code(Code *c)
	{
		rc = 1;
		for (size_t i = 0; i < c->code.size(); ++i)
			code.push_back(c->code[i]->clone());
		for (table::iterator it = c->label.begin(); it != c->label.end(); ++it)
			label[it->first] = it->second;
	}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0xb0, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x60(%rbp)
movq %rdi, %rax
movq %rax, -0x68(%rbp)
callq 0x1baa0
movq -0x60(%rbp), %rdi
addq $0x18, %rdi
movq %rdi, -0x58(%rbp)
callq 0xf290
jmp 0x1b7fa
movq -0x68(%rbp), %rax
movl $0x1, 0x30(%rax)
movq $0x0, -0x28(%rbp)
movq -0x28(%rbp), %rax
movq %rax, -0x70(%rbp)
movq -0x10(%rbp), %rdi
callq 0x1a3c0
movq %rax, %rcx
movq -0x70(%rbp), %rax
cmpq %rcx, %rax
jae 0x1b8a3
movq -0x68(%rbp), %rax
movq %rax, -0x80(%rbp)
movq -0x10(%rbp), %rdi
movq -0x28(%rbp), %rsi
callq 0x1a3e0
movq (%rax), %rdi
movq (%rdi), %rax
movq 0x18(%rax), %rax
callq *%rax
movq %rax, -0x78(%rbp)
jmp 0x1b851
movq -0x80(%rbp), %rdi
movq -0x78(%rbp), %rax
movq %rax, -0x30(%rbp)
leaq -0x30(%rbp), %rsi
callq 0x1bad0
jmp 0x1b868
jmp 0x1b86a
movq -0x28(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x28(%rbp)
jmp 0x1b80d
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x18(%rbp)
movl %eax, -0x1c(%rbp)
jmp 0x1b97e
movq -0x58(%rbp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x18(%rbp)
movl %eax, -0x1c(%rbp)
callq 0x1a4e0
jmp 0x1b97e
movq -0x10(%rbp), %rdi
addq $0x18, %rdi
callq 0x11f70
movl %edx, -0x8c(%rbp)
movq %rax, -0x88(%rbp)
jmp 0x1b8bf
movl -0x8c(%rbp), %eax
movq -0x88(%rbp), %rcx
movq %rcx, -0x50(%rbp)
movl %eax, -0x48(%rbp)
movq -0x50(%rbp), %rax
movq %rax, -0x40(%rbp)
movl -0x48(%rbp), %eax
movl %eax, -0x38(%rbp)
movq -0x10(%rbp), %rdi
addq $0x18, %rdi
callq 0x12030
movl %eax, %esi
leaq -0x40(%rbp), %rdi
callq 0x12010
testb $0x1, %al
jne 0x1b8ff
jmp 0x1b975
leaq -0x40(%rbp), %rdi
movq %rdi, -0xb0(%rbp)
callq 0x12040
movq -0xb0(%rbp), %rdi
movq %rax, %rcx
movq -0x68(%rbp), %rax
addq $0x8, %rcx
movq %rcx, -0xa8(%rbp)
addq $0x18, %rax
movq %rax, -0xa0(%rbp)
callq 0x12040
movq -0xa0(%rbp), %rdi
movq %rax, %rsi
callq 0x1a9a0
movq %rax, -0x98(%rbp)
jmp 0x1b950
movq -0xa8(%rbp), %rsi
movq -0x98(%rbp), %rdi
callq 0x12310
jmp 0x1b965
jmp 0x1b967
leaq -0x40(%rbp), %rdi
callq 0x12120
jmp 0x1b8e1
addq $0xb0, %rsp
popq %rbp
retq
movq -0x60(%rbp), %rdi
callq 0x1a630
movq -0x18(%rbp), %rdi
callq 0xc280
// File: Silica[P]PSL/./PSL/environment.h
// Function: PSL::variable::Variable::Code::push(PSL::variable::Variable::Code*)
void push(Code *c)
	{
		size_t size = c->code.size();
		for (size_t i = 0; i < size; ++i)
			code.push_back(c->code[i]);
		c->code.resize(0);
	}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x28(%rbp)
movq -0x10(%rbp), %rdi
callq 0x1a3c0
movq %rax, -0x18(%rbp)
movq $0x0, -0x20(%rbp)
movq -0x20(%rbp), %rax
cmpq -0x18(%rbp), %rax
jae 0x1bd5e
movq -0x10(%rbp), %rdi
movq -0x20(%rbp), %rsi
callq 0x1a3e0
movq -0x28(%rbp), %rdi
movq %rax, %rsi
callq 0x1bad0
movq -0x20(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x20(%rbp)
jmp 0x1bd2d
movq -0x10(%rbp), %rdi
xorl %eax, %eax
movl %eax, %esi
callq 0x1bc20
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
nopl (%rax,%rax)
// File: Silica[P]PSL/./PSL/container.h
// Function: PSL::variable::table::find(PSL::variable::string const&)
iterator find(const string &s)
	{
		if (len)
		{
			int i = search(s);
			if (i >= 0)
				return iterator(this, i);
		}
		return iterator(this, -1);
	}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x18(%rbp)
movq %rsi, -0x20(%rbp)
movq -0x18(%rbp), %rax
movq %rax, -0x30(%rbp)
cmpq $0x0, (%rax)
je 0x1be88
movq -0x30(%rbp), %rdi
movq -0x20(%rbp), %rsi
callq 0x1aad0
movl %eax, -0x24(%rbp)
cmpl $0x0, -0x24(%rbp)
jl 0x1be86
movq -0x30(%rbp), %rsi
movl -0x24(%rbp), %edx
leaq -0x10(%rbp), %rdi
callq 0x12180
jmp 0x1be9a
jmp 0x1be88
movq -0x30(%rbp), %rsi
leaq -0x10(%rbp), %rdi
movl $0xffffffff, %edx       # imm = 0xFFFFFFFF
callq 0x12180
movq -0x10(%rbp), %rax
movl -0x8(%rbp), %edx
addq $0x30, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: Silica[P]PSL/./PSL/container.h
// Function: PSL::variable::table::set(PSL::variable::string const&, PSL::variable const&)
bool set(const string &s, const variable &v)
	{
		if (len)
		{
			int i = search(s);
			if (i >= 0)
			{
				d[i]->second = v;
				return false;
			}
		}
		if (len >= reserve)
			resize();
		hash h = gethash(s, reserve);
		size_t i = getnextnull(h);
		d[i] = new data(s, v);
		++len;
		return true;
	}

// 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)
cmpq $0x0, (%rax)
je 0x1bf46
movq -0x58(%rbp), %rdi
movq -0x18(%rbp), %rsi
callq 0x1aad0
movl %eax, -0x24(%rbp)
cmpl $0x0, -0x24(%rbp)
jl 0x1bf44
movq -0x20(%rbp), %rsi
leaq -0x30(%rbp), %rdi
movq %rdi, -0x60(%rbp)
callq 0x11b10
movq -0x58(%rbp), %rax
movq -0x60(%rbp), %rsi
movq 0x10(%rax), %rax
movslq -0x24(%rbp), %rcx
movq (%rax,%rcx,8), %rdi
addq $0x8, %rdi
callq 0x12310
jmp 0x1bf18
leaq -0x30(%rbp), %rdi
callq 0xcd90
movb $0x0, -0x1(%rbp)
jmp 0x1bfe0
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x38(%rbp)
movl %eax, -0x3c(%rbp)
leaq -0x30(%rbp), %rdi
callq 0xcd90
jmp 0x1bfeb
jmp 0x1bf46
movq -0x58(%rbp), %rcx
movq (%rcx), %rax
cmpq 0x8(%rcx), %rax
jb 0x1bf5c
movq -0x58(%rbp), %rdi
callq 0x1ac40
movq -0x58(%rbp), %rax
movq -0x18(%rbp), %rdi
movq 0x8(%rax), %rsi
callq 0x1ad30
movq -0x58(%rbp), %rdi
movq %rax, -0x48(%rbp)
movq -0x48(%rbp), %rsi
callq 0x1ad60
movq %rax, -0x50(%rbp)
movl $0x10, %edi
callq 0x1ae60
movq %rax, %rdi
movq %rdi, %rax
movq %rax, -0x68(%rbp)
movq -0x18(%rbp), %rsi
movq -0x20(%rbp), %rdx
callq 0x1c000
jmp 0x1bfa5
movq -0x58(%rbp), %rax
movq -0x68(%rbp), %rsi
movq 0x10(%rax), %rcx
movq -0x50(%rbp), %rdx
movq %rsi, (%rcx,%rdx,8)
movq (%rax), %rcx
addq $0x1, %rcx
movq %rcx, (%rax)
movb $0x1, -0x1(%rbp)
jmp 0x1bfe0
movq -0x68(%rbp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x38(%rbp)
movl %eax, -0x3c(%rbp)
callq 0x1a710
jmp 0x1bfeb
movb -0x1(%rbp), %al
andb $0x1, %al
addq $0x70, %rsp
popq %rbp
retq
movq -0x38(%rbp), %rdi
callq 0xc280
nopw %cs:(%rax,%rax)
nop
// File: Silica[P]PSL/./PSL/scope.h
// Function: PSL::variable::Variable::FunctionScope::Return()
virtual Scope *Return()
	{
		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 0x1c514
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/scope.h
// Function: PSL::variable::Variable::FunctionScope::End(PSL::variable::Variable::Environment&)
virtual Scope *End(Environment &env)
	{
		Scope *s = owner;
		owner = NULL;
		delete this;
		return s;
	}

// 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(%rax), %rcx
movq %rcx, -0x18(%rbp)
movq $0x0, 0x10(%rax)
cmpq $0x0, %rax
je 0x1c5c8
movq -0x20(%rbp), %rdi
movq (%rdi), %rax
callq *0x8(%rax)
movq -0x18(%rbp), %rax
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
nopl (%rax)
// File: Silica[P]PSL/./PSL/scope.h
// Function: PSL::variable::Variable::FunctionScope::addStatic(PSL::variable::string const&, PSL::variable&, PSL::variable::Variable::Environment*)
virtual bool addStatic(const string &name, variable &v, Environment *env)
	{
		if (static_v.get()->exist(name))
		{
			variable x;
			if (env)	env->push(x);
			return false;
		}
		bool r = static_v.get()->set(name, v);
		if (env)	env->push(v);
		return r;
	}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x70, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movq %rcx, -0x28(%rbp)
movq -0x10(%rbp), %rdi
movq %rdi, -0x58(%rbp)
addq $0x28, %rdi
callq 0x12060
movq %rax, %rdi
movq -0x18(%rbp), %rsi
callq 0x172e0
testb $0x1, %al
jne 0x1c61e
jmp 0x1c6a4
leaq -0x30(%rbp), %rdi
callq 0x1a130
cmpq $0x0, -0x28(%rbp)
je 0x1c684
movq -0x28(%rbp), %rax
movq %rax, -0x60(%rbp)
leaq -0x38(%rbp), %rdi
leaq -0x30(%rbp), %rsi
callq 0x11b10
jmp 0x1c645
movq -0x60(%rbp), %rdi
leaq -0x38(%rbp), %rsi
callq 0x11aa0
jmp 0x1c654
leaq -0x38(%rbp), %rdi
callq 0xcd90
jmp 0x1c684
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x40(%rbp)
movl %eax, -0x44(%rbp)
jmp 0x1c696
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x40(%rbp)
movl %eax, -0x44(%rbp)
leaq -0x38(%rbp), %rdi
callq 0xcd90
jmp 0x1c696
movb $0x0, -0x1(%rbp)
leaq -0x30(%rbp), %rdi
callq 0xcdc0
jmp 0x1c71f
leaq -0x30(%rbp), %rdi
callq 0xcdc0
jmp 0x1c72a
movq -0x58(%rbp), %rdi
addq $0x28, %rdi
callq 0x12060
movq %rax, %rdi
movq -0x18(%rbp), %rsi
movq -0x20(%rbp), %rdx
callq 0x17410
andb $0x1, %al
movb %al, -0x45(%rbp)
cmpq $0x0, -0x28(%rbp)
je 0x1c717
movq -0x28(%rbp), %rax
movq %rax, -0x70(%rbp)
movq -0x20(%rbp), %rsi
leaq -0x50(%rbp), %rdi
movq %rdi, -0x68(%rbp)
callq 0x11b10
movq -0x70(%rbp), %rdi
movq -0x68(%rbp), %rsi
callq 0x11aa0
jmp 0x1c6f5
leaq -0x50(%rbp), %rdi
callq 0xcd90
jmp 0x1c717
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x40(%rbp)
movl %eax, -0x44(%rbp)
leaq -0x50(%rbp), %rdi
callq 0xcd90
jmp 0x1c72a
movb -0x45(%rbp), %al
andb $0x1, %al
movb %al, -0x1(%rbp)
movb -0x1(%rbp), %al
andb $0x1, %al
addq $0x70, %rsp
popq %rbp
retq
movq -0x40(%rbp), %rdi
callq 0xc280
nopw %cs:(%rax,%rax)
nopl (%rax)
// File: Silica[P]PSL/./PSL/environment.h
// Function: PSL::variable::Variable::Scope::Goto(PSL::variable::string const&)
virtual Scope *Goto(const string &label)
	{
		if (code->Goto(label, line))
			return this;
		if (!owner)
			return NULL;
		if (Scope *s = owner->Goto(label))
		{
			owner = NULL;
			delete this;
			return s;
		}
		return NULL;
	}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x10(%rbp), %rdx
movq %rdx, -0x28(%rbp)
movq 0x18(%rdx), %rdi
movq -0x18(%rbp), %rsi
addq $0x20, %rdx
callq 0x1d190
testb $0x1, %al
jne 0x1cbef
jmp 0x1cbf9
movq -0x28(%rbp), %rax
movq %rax, -0x8(%rbp)
jmp 0x1cc59
movq -0x28(%rbp), %rax
cmpq $0x0, 0x10(%rax)
jne 0x1cc0e
movq $0x0, -0x8(%rbp)
jmp 0x1cc59
movq -0x28(%rbp), %rax
movq 0x10(%rax), %rdi
movq -0x18(%rbp), %rsi
movq (%rdi), %rax
callq *0x38(%rax)
movq %rax, -0x20(%rbp)
cmpq $0x0, -0x20(%rbp)
je 0x1cc51
movq -0x28(%rbp), %rax
movq $0x0, 0x10(%rax)
cmpq $0x0, %rax
je 0x1cc47
movq -0x28(%rbp), %rdi
movq (%rdi), %rax
callq *0x8(%rax)
movq -0x20(%rbp), %rax
movq %rax, -0x8(%rbp)
jmp 0x1cc59
movq $0x0, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
nopl (%rax)
// File: Silica[P]PSL/./PSL/environment.h
// Function: PSL::variable::Variable::Scope::getLocal()
virtual rsv getLocal()
	{
		if (owner)
		{
			variable v = owner->getLocal();
			variable l = local;
			v = l;
			return v;
		}
		return local;
	}

// 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 -0x10(%rbp), %rax
movq %rax, -0x40(%rbp)
cmpq $0x0, 0x10(%rax)
je 0x1ce69
movq -0x40(%rbp), %rax
movq 0x10(%rax), %rsi
movq (%rsi), %rax
movq 0x58(%rax), %rax
leaq -0x20(%rbp), %rdi
movq %rdi, -0x58(%rbp)
callq *%rax
movq -0x58(%rbp), %rsi
leaq -0x18(%rbp), %rdi
callq 0xcd50
jmp 0x1cdd6
leaq -0x20(%rbp), %rdi
callq 0xcd90
movq -0x40(%rbp), %rsi
addq $0x8, %rsi
leaq -0x38(%rbp), %rdi
callq 0xcd50
jmp 0x1cdf2
leaq -0x18(%rbp), %rdi
leaq -0x38(%rbp), %rsi
callq 0x1d200
jmp 0x1ce01
movq -0x50(%rbp), %rdi
leaq -0x18(%rbp), %rsi
callq 0x11b10
jmp 0x1ce10
leaq -0x38(%rbp), %rdi
callq 0xcdc0
leaq -0x18(%rbp), %rdi
callq 0xcdc0
jmp 0x1ce7a
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x28(%rbp)
movl %eax, -0x2c(%rbp)
leaq -0x20(%rbp), %rdi
callq 0xcd90
jmp 0x1ce84
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x28(%rbp)
movl %eax, -0x2c(%rbp)
jmp 0x1ce5e
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
jmp 0x1ce84
movq -0x50(%rbp), %rdi
movq -0x40(%rbp), %rsi
addq $0x8, %rsi
callq 0xd070
movq -0x48(%rbp), %rax
addq $0x60, %rsp
popq %rbp
retq
movq -0x28(%rbp), %rdi
callq 0xc280
nopl (%rax)
// File: Silica[P]PSL/./PSL/environment.h
// Function: PSL::variable::Variable::Code::Goto(PSL::variable::string const&, unsigned long&)
bool Goto(const string &s, size_t &line)
	{
		if (!label.count(s))
			return false;
		line = static_cast<size_t>(label[s].get()->toInt());
		return true;
	}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movq -0x10(%rbp), %rdi
movq %rdi, -0x28(%rbp)
addq $0x18, %rdi
movq -0x18(%rbp), %rsi
callq 0x1b010
cmpq $0x0, %rax
jne 0x1d1c5
movb $0x0, -0x1(%rbp)
jmp 0x1d1f4
movq -0x28(%rbp), %rdi
addq $0x18, %rdi
movq -0x18(%rbp), %rsi
callq 0x1a9a0
movq %rax, %rdi
callq 0x12060
movq %rax, %rdi
callq 0x12080
movslq %eax, %rcx
movq -0x20(%rbp), %rax
movq %rcx, (%rax)
movb $0x1, -0x1(%rbp)
movb -0x1(%rbp), %al
andb $0x1, %al
addq $0x30, %rsp
popq %rbp
retq
nop
// File: Silica[P]PSL/./PSL/environment.h
// Function: PSL::variable::Variable::Scope::copyto(PSL::variable::Variable::Scope*)
void copyto(Scope *s)
	{
		variable l = local;
		variable c = l;
		s->local = c;
		if (owner)
			s->owner = owner->clone();
		s->line = line;
	}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rsi
movq %rsi, -0x48(%rbp)
addq $0x8, %rsi
leaq -0x18(%rbp), %rdi
movq %rdi, -0x40(%rbp)
callq 0xcd50
movq -0x40(%rbp), %rsi
leaq -0x20(%rbp), %rdi
callq 0x1d4f0
jmp 0x1d418
leaq -0x38(%rbp), %rdi
leaq -0x20(%rbp), %rsi
callq 0x11b10
jmp 0x1d427
movq -0x10(%rbp), %rdi
addq $0x8, %rdi
leaq -0x38(%rbp), %rsi
callq 0x12310
jmp 0x1d43a
leaq -0x38(%rbp), %rdi
callq 0xcd90
movq -0x48(%rbp), %rax
cmpq $0x0, 0x10(%rax)
je 0x1d4a6
movq -0x48(%rbp), %rax
movq 0x10(%rax), %rdi
movq (%rdi), %rax
movq 0x10(%rax), %rax
callq *%rax
movq %rax, -0x50(%rbp)
jmp 0x1d465
movq -0x50(%rbp), %rcx
movq -0x10(%rbp), %rax
movq %rcx, 0x10(%rax)
jmp 0x1d4a6
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x28(%rbp)
movl %eax, -0x2c(%rbp)
jmp 0x1d4d7
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x28(%rbp)
movl %eax, -0x2c(%rbp)
jmp 0x1d4ce
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x28(%rbp)
movl %eax, -0x2c(%rbp)
leaq -0x38(%rbp), %rdi
callq 0xcd90
jmp 0x1d4ce
movq -0x48(%rbp), %rax
movq 0x20(%rax), %rcx
movq -0x10(%rbp), %rax
movq %rcx, 0x20(%rax)
leaq -0x20(%rbp), %rdi
callq 0xcdc0
leaq -0x18(%rbp), %rdi
callq 0xcdc0
addq $0x50, %rsp
popq %rbp
retq
leaq -0x20(%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::MethodScope::getVariable(PSL::variable::string const&)
Variable *getVariable(const string &name)
	{
		Variable *v;
		v = local.get()->getifexist(name);		if (v)return v;
		v = this_v.get()->getifexist(name);		if (v)return v;
		v = static_v.get()->getifexist(name);	if (v)return v;
		return NULL;
	}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x10(%rbp), %rdi
movq %rdi, -0x28(%rbp)
addq $0x8, %rdi
callq 0x12060
movq %rax, %rdi
movq -0x18(%rbp), %rsi
callq 0x1a100
movq %rax, -0x20(%rbp)
cmpq $0x0, -0x20(%rbp)
je 0x1e2d2
movq -0x20(%rbp), %rax
movq %rax, -0x8(%rbp)
jmp 0x1e336
movq -0x28(%rbp), %rdi
addq $0x30, %rdi
callq 0x12060
movq %rax, %rdi
movq -0x18(%rbp), %rsi
callq 0x1a100
movq %rax, -0x20(%rbp)
cmpq $0x0, -0x20(%rbp)
je 0x1e300
movq -0x20(%rbp), %rax
movq %rax, -0x8(%rbp)
jmp 0x1e336
movq -0x28(%rbp), %rdi
addq $0x28, %rdi
callq 0x12060
movq %rax, %rdi
movq -0x18(%rbp), %rsi
callq 0x1a100
movq %rax, -0x20(%rbp)
cmpq $0x0, -0x20(%rbp)
je 0x1e32e
movq -0x20(%rbp), %rax
movq %rax, -0x8(%rbp)
jmp 0x1e336
movq $0x0, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x30, %rsp
popq %rbp
retq
// File: Silica[P]PSL/./PSL/scope.h
// Function: PSL::variable::Variable::ConstructorScope::End(PSL::variable::Variable::Environment&)
Scope *End(Environment &env)
	{
		Scope *s = owner;
		owner = NULL;
		env.top() = this_v;
		delete this;
		return s;
	}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x20(%rbp)
movq 0x10(%rax), %rcx
movq %rcx, -0x18(%rbp)
movq $0x0, 0x10(%rax)
addq $0x30, %rax
movq %rax, -0x28(%rbp)
movq -0x10(%rbp), %rdi
callq 0x1e4a0
movq -0x28(%rbp), %rsi
movq %rax, %rdi
callq 0x12310
movq -0x20(%rbp), %rax
cmpq $0x0, %rax
je 0x1e3e9
movq -0x20(%rbp), %rdi
movq (%rdi), %rax
callq *0x8(%rax)
movq -0x18(%rbp), %rax
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
nopl (%rax)