LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_cpp_makefile_star2_O1/Silica[P]PSL/./PSL/code.h
// Function: PSL::variable::Variable::ARGUMENT::Execute(PSL::variable::Variable::Environment&)
CLONE(ARGUMENT)
	EXEC
	{
		variable l = env.pop();
		variable r = env.pop();
		env.push(l.substitution(r));
		return RC::NONE;
	}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
subq $0x10, %rsp
movq %rsi, %r15
leaq 0x8(%rsp), %rbx
movq %rbx, %rdi
callq 0xf800
movq (%rbx), %rbx
incl 0x8(%rbx)
movq %rbx, %rdi
callq 0xfc04
leaq 0x8(%rsp), %rdi
movq %r15, %rsi
callq 0xf800
movq 0x8(%rsp), %r14
incl 0x8(%r14)
movq %r14, %rdi
callq 0xfc04
movq (%rbx), %rdi
movq (%rdi), %rax
movq %r14, %rsi
callq *0x38(%rax)
movq %rax, (%rbx)
movq (%rax), %rcx
movq %rax, %rdi
movq %rbx, %rsi
callq *0x158(%rcx)
incl 0x8(%rbx)
leaq 0x8(%rsp), %rsi
movq %rbx, (%rsi)
addq $0x8, %r15
movq %r15, %rdi
callq 0xfc38
movq 0x8(%rsp), %rdi
callq 0xfc04
movq %r14, %rdi
callq 0xfc04
movq %rbx, %rdi
callq 0xfc04
xorl %eax, %eax
addq $0x10, %rsp
popq %rbx
popq %r14
popq %r15
retq
jmp 0x1998d
jmp 0x1998d
jmp 0x1998d
movq %rax, %r15
movq 0x8(%rsp), %rdi
callq 0xfc04
jmp 0x19973
jmp 0x1998d
jmp 0x1998d
movq %rax, %r15
jmp 0x1997b
jmp 0x1998d
movq %rax, %r15
movq %r14, %rdi
callq 0xfc04
movq %rbx, %rdi
callq 0xfc04
movq %r15, %rdi
callq 0xc290
jmp 0x1998d
movq %rax, %rdi
callq 0xde83
nop
// File: /workspace/github_cpp_makefile_star2_O1/Silica[P]PSL/./PSL/tokenizer.h
// Function: PSL::variable::Tokenizer::mcomment()
void mcomment()
	{
		int l = line;
		for (; i < len-1; ++i)
		{
			if (s[i] == '\n')
			{
				incline();
				continue;
			}
			if (s[i] == '\r')
			{
				incline();
				if (i < len && s[i+1] == '\n')
					++i;
				continue;
			}
			if (s[i] == '*' && s[i+1] == '/')
			{
				i += 2;
				return;
			}
		}
		PSL_PRINTF(("error %s %d: comment not closed from %d\n", filename.c_str(), line, l));
		++i;
	}

// Assembly:
pushq %rbx
movq %rdi, %rbx
movl 0x8(%rdi), %ecx
movq 0x20(%rdi), %rdx
leaq -0x1(%rdx), %rsi
movq 0x28(%rdi), %rax
cmpq %rsi, %rax
jae 0x1a2ac
movl 0x8(%rbx), %edi
movq 0x18(%rbx), %r8
movzbl (%r8,%rax), %r9d
cmpl $0x2a, %r9d
je 0x1a298
cmpl $0xd, %r9d
je 0x1a279
cmpl $0xa, %r9d
jne 0x1a2a0
incl %edi
movl %edi, 0x8(%rbx)
movq %rax, 0x30(%rbx)
jmp 0x1a2a0
incl %edi
movl %edi, 0x8(%rbx)
movq %rax, 0x30(%rbx)
cmpq %rdx, %rax
jae 0x1a2a0
cmpb $0xa, 0x1(%r8,%rax)
jne 0x1a2a0
incq %rax
movq %rax, 0x28(%rbx)
jmp 0x1a2a0
cmpb $0x2f, 0x1(%r8,%rax)
je 0x1a2eb
incq %rax
movq %rax, 0x28(%rbx)
cmpq %rsi, %rax
jb 0x1a257
movq (%rbx), %rax
testq %rax, %rax
je 0x1a2c6
movq 0x8(%rax), %rdx
movq 0x18(%rax), %rsi
movb $0x0, (%rdx,%rsi)
movq 0x8(%rax), %rsi
jmp 0x1a2cd
leaq 0xe425(%rip), %rsi      # 0x286f2
movl 0x8(%rbx), %edx
leaq 0xe41c(%rip), %rdi      # 0x286f3
xorl %eax, %eax
callq 0xc050
movq 0x28(%rbx), %rax
incq %rax
movq %rax, 0x28(%rbx)
popq %rbx
retq
addq $0x2, %rax
jmp 0x1a2e5
nop
// File: /workspace/github_cpp_makefile_star2_O1/Silica[P]PSL/./PSL/tokenizer.h
// Function: PSL::variable::Tokenizer::string_literal(char, bool)
void string_literal(char end = '"', bool escape = true)
	{
		size_t h = i;
		nstr = "";
		for (; i < len; ++i)
		{
			if (s[i] == end)
			{
				nstr += string(s+h, i-h);
				++i;
				return;
			}
			if (escape && s[i] == '\\')
			{
				nstr += string(s+h, i-h);
				h = i;
				size_t j = i+1;
				if (s[j] == 'n')		nstr += '\n';
				else if (s[j] == '"')	nstr += '"';
				else if (s[j] == 't')	nstr += '\t';
/*				else if (s[j] == 'r')	nstr += '\r';
				else if (s[j] == 'a')	nstr += '\a';
				else if (s[j] == 'f')	nstr += '\f';
				else if (s[j] == 'v')	nstr += '\v';*/
/*				else if (s[j] == 'x')
				{
					char c = 0;
					nstr += c;
				}*/
				else					continue;
				h = j+1;
				i = j;
				continue;
			}
		}
	}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movl %edx, %ebp
movl %esi, %r15d
movq %rdi, %rbx
movq 0x28(%rdi), %r13
leaq 0x68(%rdi), %r14
leaq 0xe3de(%rip), %rsi      # 0x286f2
movq %r14, %rdi
callq 0x1af2a
movq 0x28(%rbx), %rdx
cmpq 0x20(%rbx), %rdx
jae 0x1a3f5
xorb $0x1, %bpl
movq 0x18(%rbx), %rsi
movb (%rsi,%rdx), %al
cmpb %r15b, %al
je 0x1a3c7
cmpb $0x5c, %al
setne %al
orb %bpl, %al
jne 0x1a3b0
addq %r13, %rsi
subq %r13, %rdx
movq %rsp, %r12
movq %r12, %rdi
callq 0x1b00a
movq %r14, %rdi
movq %r12, %rsi
callq 0x110be
movq (%rsp), %rdi
testq %rdi, %rdi
je 0x1a372
callq 0xfbc0
movq 0x18(%rbx), %rax
movq 0x28(%rbx), %r13
movzbl 0x1(%rax,%r13), %eax
cmpl $0x22, %eax
je 0x1a397
cmpl $0x6e, %eax
je 0x1a393
cmpl $0x74, %eax
jne 0x1a3b0
movb $0x9, %al
jmp 0x1a399
movb $0xa, %al
jmp 0x1a399
movb $0x22, %al
leaq 0x1(%r13), %r12
movzbl %al, %esi
movq %r14, %rdi
callq 0xc7dc
addq $0x2, %r13
movq %r12, 0x28(%rbx)
movq 0x28(%rbx), %rdx
incq %rdx
movq %rdx, 0x28(%rbx)
cmpq 0x20(%rbx), %rdx
jb 0x1a32e
jmp 0x1a3f5
addq %r13, %rsi
subq %r13, %rdx
movq %rsp, %r15
movq %r15, %rdi
callq 0x1b00a
movq %r14, %rdi
movq %r15, %rsi
callq 0x110be
movq (%rsp), %rdi
testq %rdi, %rdi
je 0x1a3f1
callq 0xfbc0
incq 0x28(%rbx)
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
jmp 0x1a406
movq %rax, %rbx
movq (%rsp), %rdi
testq %rdi, %rdi
je 0x1a417
callq 0xfbc0
movq %rbx, %rdi
callq 0xc290
nop
// File: /workspace/github_cpp_makefile_star2_O1/Silica[P]PSL/./PSL/tokenizer.h
// Function: PSL::variable::Tokenizer::getIdentifier()
bool getIdentifier()
	{
		if (!((s[i] >= 'a' && s[i] <= 'z') || (s[i] >= 'A' && s[i] <= 'Z') || s[i] == '_' || (s[i]&0x80)))
			return false;
		size_t h = i;
		for (++i; i < len; ++i)
		{
			if ((s[i] >= 'a' && s[i] <= 'z') || (s[i] >= 'A' && s[i] <= 'Z') || s[i] == '_' || (s[i] >= '0' && s[i] <= '9') || (s[i]&0x80))
				continue;
			break;
		}
		nstr = string(s+h, i-h);
		return true;
	}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
movq 0x18(%rdi), %rcx
movq 0x28(%rdi), %rax
movb (%rcx,%rax), %dl
movl %edx, %esi
andb $-0x21, %sil
addb $-0x41, %sil
cmpb $0x1a, %sil
jb 0x1ac74
cmpb $0x5f, %dl
setne %sil
testb %dl, %dl
setns %dl
testb %dl, %sil
je 0x1ac74
xorl %eax, %eax
jmp 0x1ad17
leaq (%rcx,%rax), %rsi
movq 0x20(%rbx), %rdi
leaq 0x1(%rax), %rdx
movq %rdx, 0x28(%rbx)
cmpq %rdi, %rdx
jae 0x1acd7
movb (%rcx,%rdx), %r8b
leal -0x61(%r8), %r9d
cmpb $0x1a, %r9b
jb 0x1acc8
leal -0x41(%r8), %r9d
cmpb $0x1a, %r9b
setb %r9b
cmpb $0x5f, %r8b
sete %r10b
orb %r9b, %r10b
jne 0x1acc8
leal -0x3a(%r8), %r9d
cmpb $-0xa, %r9b
setb %r9b
testb %r8b, %r8b
setns %r8b
testb %r9b, %r8b
jne 0x1acd7
incq %rdx
movq %rdx, 0x28(%rbx)
cmpq %rdx, %rdi
jne 0x1ac89
movq %rdi, %rdx
subq %rax, %rdx
movq %rsp, %r14
movq %r14, %rdi
callq 0x1b00a
movq (%r14), %r14
testq %r14, %r14
je 0x1acf2
incl (%r14)
jmp 0x1acf5
xorl %r14d, %r14d
movq 0x68(%rbx), %rdi
testq %rdi, %rdi
je 0x1ad03
callq 0xfbc0
movq %r14, 0x68(%rbx)
movq (%rsp), %rdi
testq %rdi, %rdi
je 0x1ad15
callq 0xfbc0
movb $0x1, %al
addq $0x8, %rsp
popq %rbx
popq %r14
retq
nop
// File: /workspace/github_cpp_makefile_star2_O1/Silica[P]PSL/./PSL/pstring.h
// Function: PSL::variable::string::operator+(char const*) const
string operator+(const char *s) const
	{
		if (empty_s(s))	return *this;
		if (!buf)		return new SharedBuffer(s);
		size_t l = std::strlen(s);
		SharedBuffer *n = new SharedBuffer(buf->length() + l);
		n->fcopy(buf->buffer(), buf->length());
		n->fcopy(s, l, buf->length());
		return n;
	}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rsi, %r13
movq %rdi, %rbx
testq %rdx, %rdx
je 0x1adc7
movq %rdx, %r15
cmpb $0x0, (%rdx)
je 0x1adc7
cmpq $0x0, (%r13)
je 0x1adda
movq %r15, %rdi
callq 0xc0c0
movq %rax, %r12
callq 0x1055a
movq %rax, %r14
movq (%r13), %rbp
movq 0x18(%rbp), %r13
movl $0x1, (%rax)
leaq (%r12,%r13), %rdi
incq %rdi
callq 0xc040
addq %r12, %r13
movq %rax, 0x8(%r14)
movq %r13, 0x10(%r14)
movq $0x0, 0x18(%r14)
movq 0x8(%rbp), %rsi
movq 0x18(%rbp), %r13
movq %rax, %rdi
movq %r13, %rdx
callq 0xc150
movq %r13, 0x18(%r14)
movq 0x18(%rbp), %r13
movq 0x8(%r14), %rdi
addq %r13, %rdi
movq %r15, %rsi
movq %r12, %rdx
callq 0xc150
addq %r12, %r13
movq %r13, 0x18(%r14)
jmp 0x1ae1b
movq (%r13), %r14
testq %r14, %r14
je 0x1add5
incl (%r14)
jmp 0x1ae1b
xorl %r14d, %r14d
jmp 0x1ae1b
callq 0x1055a
movq %rax, %r14
movq %r15, %rdi
callq 0xc0c0
movq %rax, %r12
movl $0x1, (%r14)
leaq 0x1(%rax), %rdi
callq 0xc040
movq %rax, 0x8(%r14)
movq %r12, 0x10(%r14)
movq %r12, 0x18(%r14)
movq %rax, %rdi
movq %r15, %rsi
movq %r12, %rdx
callq 0xc150
movq %r12, 0x18(%r14)
movq %r14, (%rbx)
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
jmp 0x1ae32
movq %rax, %rbx
movq %r14, %rdi
callq 0xfbe0
movq %rbx, %rdi
callq 0xc290
nop
// File: /workspace/github_cpp_makefile_star2_O1/Silica[P]PSL/./PSL/pstring.h
// Function: PSL::variable::string::operator+(PSL::variable::string const&) const
string operator+(const string &s) const
	{
/*		string n = *this; // ���ۂ̂Ƃ��o�b�t�@���L�V�X�e�������邩�炱���ł������ȂɃ��X�������킯�����Ȃ��Ǝv������
		n += s;
		return n;*/
		if (!buf)	return s;
		if (!s.buf)	return *this;
		SharedBuffer *n = new SharedBuffer(buf->length() + s.buf->length());
		n->fcopy(buf->buffer(), buf->length());
		n->fcopy(s.buf->buffer(), s.buf->length(), buf->length());
		return n;
	}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rdi, %rbx
movq (%rsi), %rax
movq (%rdx), %r14
testq %rax, %rax
je 0x1aeed
testq %r14, %r14
je 0x1aef7
movq %rdx, %r15
movq %rsi, %r12
callq 0x1055a
movq %rax, %r14
movq (%r12), %r12
movq 0x18(%r12), %rbp
movq (%r15), %r13
movq 0x18(%r13), %r15
movl $0x1, (%rax)
leaq (%r15,%rbp), %rdi
incq %rdi
callq 0xc040
addq %rbp, %r15
movq %rax, 0x8(%r14)
movq %r15, 0x10(%r14)
movq $0x0, 0x18(%r14)
movq 0x8(%r12), %rsi
movq 0x18(%r12), %r15
movq %rax, %rdi
movq %r15, %rdx
callq 0xc150
movq %r15, 0x18(%r14)
movq 0x8(%r13), %rsi
movq 0x18(%r13), %r15
movq 0x18(%r12), %r12
movq 0x8(%r14), %rdi
addq %r12, %rdi
movq %r15, %rdx
callq 0xc150
addq %r15, %r12
movq %r12, 0x18(%r14)
jmp 0x1af01
testq %r14, %r14
je 0x1aefe
incl (%r14)
jmp 0x1af01
incl (%rax)
movq %rax, %r14
jmp 0x1af01
xorl %r14d, %r14d
movq %r14, (%rbx)
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
movq %r14, %rdi
callq 0xfbe0
movq %rbx, %rdi
callq 0xc290
nop
// File: /workspace/github_cpp_makefile_star2_O1/Silica[P]PSL/./PSL/pstring.h
// Function: PSL::variable::string::operator=(char const*)
string &operator=(const char *s)
	{
		if (!buf)
		{
			if (!empty_s(s))
				buf = new SharedBuffer(s);
		}
		else
		{
			if (empty_s(s))
			{
				if (buf->shared())
				{
					buf->finalize();
					buf = NULL;
				}
				else
				{
					buf->setlen(0);
				}
			}
			else
			{
				size_t l = std::strlen(s);
				only_and_extend(l);
				buf->fcopy(s, l);
			}
		}
		return *this;
	}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rsi, %r14
movq %rdi, %rbx
movq (%rdi), %rdi
testq %rdi, %rdi
je 0x1af8a
testq %r14, %r14
je 0x1af7b
cmpb $0x0, (%r14)
je 0x1af7b
movq %r14, %rdi
callq 0xc0c0
movq %rax, %r15
movq %rbx, %rdi
movq %rax, %rsi
callq 0x1112c
movq (%rbx), %r12
movq 0x8(%r12), %rdi
movq %r14, %rsi
movq %r15, %rdx
callq 0xc150
movq %r15, 0x18(%r12)
jmp 0x1afe7
cmpl $0x1, (%rdi)
jne 0x1afdb
movq $0x0, 0x18(%rdi)
jmp 0x1afe7
testq %r14, %r14
je 0x1afe7
cmpb $0x0, (%r14)
je 0x1afe7
callq 0x1055a
movq %rax, %r15
movq %r14, %rdi
callq 0xc0c0
movq %rax, %r12
movl $0x1, (%r15)
leaq 0x1(%rax), %rdi
callq 0xc040
movq %rax, 0x8(%r15)
movq %r12, 0x10(%r15)
movq %r12, 0x18(%r15)
movq %rax, %rdi
movq %r14, %rsi
movq %r12, %rdx
callq 0xc150
movq %r12, 0x18(%r15)
movq %r15, (%rbx)
jmp 0x1afe7
callq 0xfbc0
movq $0x0, (%rbx)
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
movq %rax, %rbx
movq %r15, %rdi
callq 0xfbe0
movq %rbx, %rdi
callq 0xc290
nop
// File: /workspace/github_cpp_makefile_star2_O1/Silica[P]PSL/./PSL/tokenizer.h
// Function: PSL::variable::Tokenizer::whitespace()
bool whitespace()
	{
		for (; i < len; ++i)
		{
			if (s[i] == ' ' || s[i] == '\t')
				continue;
			break;
		}
		if (i == len)
			return true;
		return false;
	}

// Assembly:
movq 0x20(%rdi), %rax
movq 0x28(%rdi), %rcx
cmpq %rax, %rcx
jae 0x1b0f0
movq 0x18(%rdi), %rdx
movzbl (%rdx,%rcx), %esi
cmpl $0x20, %esi
je 0x1b0e1
cmpl $0x9, %esi
jne 0x1b0f0
incq %rcx
movq %rcx, 0x28(%rdi)
cmpq %rcx, %rax
jne 0x1b0d3
movq %rax, %rcx
cmpq %rax, %rcx
sete %al
retq
nop
// File: /workspace/github_cpp_makefile_star2_O1/Silica[P]PSL/./PSL/pstring.h
// Function: PSL::variable::string::operator==(char const*) const
bool operator==(const char *s) const
	{
		if (!buf)
		{
			if (s[0] == 0)	return true;
			else			return false;
		}
		size_t l = buf->length();
		for (size_t t = 0; t < l; ++t)
		{
			if (s[t] == 0)			return false;
			if (buf->at(t) != s[t])	return false;
		}
		if (s[l] != 0)				return false;
		return true;
	}

// Assembly:
movq (%rdi), %rax
testq %rax, %rax
je 0x1b129
movq 0x18(%rax), %rcx
testq %rcx, %rcx
je 0x1b126
xorl %edx, %edx
movb (%rsi,%rdx), %dil
testb %dil, %dil
je 0x1b130
movq 0x8(%rax), %r8
cmpb %dil, (%r8,%rdx)
jne 0x1b130
incq %rdx
cmpq %rdx, %rcx
jne 0x1b10b
addq %rcx, %rsi
cmpb $0x0, (%rsi)
sete %al
retq
xorl %eax, %eax
retq
nop
// File: /workspace/github_cpp_makefile_star2_O1/Silica[P]PSL/./PSL/tokenizer.h
// Function: PSL::variable::Tokenizer::New(PSL::variable::string const&, PSL::variable::table*)
static Tokenizer *New(const string &fn, table *dl = NULL)
	{
		using namespace std;
		FILE *fp = fopen(fn, "r");
		if (!fp)
			return NULL;
		Tokenizer *t = new Tokenizer(fp, fn, dl);
		fclose(fp);
		return t;
	}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq %rdi, %r14
movq (%rdi), %rax
testq %rax, %rax
je 0x1b15c
movq 0x8(%rax), %rcx
movq 0x18(%rax), %rdx
movb $0x0, (%rcx,%rdx)
movq 0x8(%rax), %rdi
jmp 0x1b163
leaq 0xd58f(%rip), %rdi      # 0x286f2
leaq 0xd885(%rip), %rsi      # 0x289ef
callq 0xc200
testq %rax, %rax
je 0x1b19f
movq %rax, %r12
movl $0x70, %edi
callq 0xc1c0
movq %rax, %r15
movq %rax, %rdi
movq %r12, %rsi
movq %r14, %rdx
movq %rbx, %rcx
callq 0x1b288
movq %r12, %rdi
callq 0xc1b0
jmp 0x1b1a2
xorl %r15d, %r15d
movq %r15, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
movq %rax, %rbx
movl $0x70, %esi
movq %r15, %rdi
callq 0xc1d0
movq %rbx, %rdi
callq 0xc290
nop
// File: /workspace/github_cpp_makefile_star2_O1/Silica[P]PSL/./PSL/tokenizer.h
// Function: PSL::variable::Tokenizer::Tokenizer(_IO_FILE*, PSL::variable::string const&, PSL::variable::table*)
Tokenizer(std::FILE *fp, const string &fn, table *dl = NULL)
	{
		using namespace std;
		fseek(fp, 0, SEEK_END);
		long r = ftell(fp);
		len = r < 0 ? 0 : static_cast<size_t>(r);
		char *p;
		string buf(len, p);
		fseek(fp, 0, SEEK_SET);
		len = fread(p, 1, len, fp);
		s = str = buf;
		Init(fn, 1, dl);
	}

// Assembly:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x10, %rsp
movq %rcx, %r14
movq %rdx, %r15
movq %rsi, %r12
movq %rdi, %rbx
xorl %r13d, %r13d
movq %r13, (%rdi)
movq %r13, 0x10(%rdi)
movq %r13, 0x68(%rdi)
movq %rsi, %rdi
xorl %esi, %esi
movl $0x2, %edx
callq 0xc1f0
movq %r12, %rdi
callq 0xc030
testq %rax, %rax
cmovgq %rax, %r13
movq %r13, 0x20(%rbx)
movq %rsp, %rdi
leaq 0x8(%rsp), %rdx
movq %r13, %rsi
callq 0x1b3c2
xorl %r13d, %r13d
movq %r12, %rdi
xorl %esi, %esi
xorl %edx, %edx
callq 0xc1f0
movq 0x8(%rsp), %rdi
movq 0x20(%rbx), %rdx
movl $0x1, %esi
movq %r12, %rcx
callq 0xc230
movq %rax, 0x20(%rbx)
movq (%rsp), %rax
testq %rax, %rax
je 0x1b318
incl (%rax)
movq %rax, %r13
movq 0x10(%rbx), %rdi
testq %rdi, %rdi
je 0x1b326
callq 0xfbc0
movq %r13, 0x10(%rbx)
testq %r13, %r13
je 0x1b341
movq 0x8(%r13), %rax
movq 0x18(%r13), %rcx
movb $0x0, (%rax,%rcx)
movq 0x8(%r13), %rax
jmp 0x1b348
leaq 0xd3aa(%rip), %rax      # 0x286f2
movq %rax, 0x18(%rbx)
movq %rbx, %rdi
movq %r15, %rsi
movl $0x1, %edx
movq %r14, %rcx
callq 0x18b82
movq (%rsp), %rdi
testq %rdi, %rdi
je 0x1b36d
callq 0xfbc0
addq $0x10, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
movq %rax, %r14
movq (%rsp), %rdi
testq %rdi, %rdi
je 0x1b391
callq 0xfbc0
jmp 0x1b391
movq %rax, %r14
movq 0x68(%rbx), %rdi
testq %rdi, %rdi
je 0x1b39f
callq 0xfbc0
movq 0x10(%rbx), %rdi
testq %rdi, %rdi
je 0x1b3ad
callq 0xfbc0
movq (%rbx), %rdi
testq %rdi, %rdi
je 0x1b3ba
callq 0xfbc0
movq %r14, %rdi
callq 0xc290
// File: /workspace/github_cpp_makefile_star2_O1/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
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movq %rdx, %r14
movq %rsi, %r15
movq %rdi, %rbx
movq (%rdi), %rdi
callq 0x1bf6c
movl %eax, %ebp
movq (%rbx), %r12
movl 0x38(%r12), %eax
testl %eax, %eax
jns 0x1b458
movq %r12, %rdi
callq 0x199bc
movl %eax, 0x38(%r12)
testl %eax, %eax
je 0x1b479
cmpl $0x7d, %eax
jne 0x1b481
movq (%rbx), %rdi
cmpl $0x0, 0x38(%rdi)
jle 0x1b499
movl $0xffffffff, 0x38(%rdi) # imm = 0xFFFFFFFF
movl $0x1, %r12d
jmp 0x1b492
movl $0x3, %r12d
jmp 0x1b492
movq %rbx, %rdi
movq %r15, %rsi
movq %r14, %rdx
callq 0x18c32
xorl %r12d, %r12d
testl %r12d, %r12d
je 0x1b43f
jmp 0x1b4a8
movl $0x1, %r12d
jns 0x1b492
callq 0x199bc
jmp 0x1b492
cmpl $0x3, %r12d
jne 0x1b4d2
leaq 0xd23d(%rip), %rcx      # 0x286f2
movq %rbx, %rdi
movl $0xc, %esi
movl %ebp, %edx
movl $0xffffffff, %r8d       # imm = 0xFFFFFFFF
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
jmp 0x1bdbc
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O1/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 %r15
pushq %r14
pushq %rbx
movl %edx, %ebx
movq %rdi, %r14
movl %ecx, %edx
callq 0x1c49a
movq (%r14), %r15
movl 0x38(%r15), %eax
testl %eax, %eax
jns 0x1b528
movq %r15, %rdi
callq 0x199bc
movl %eax, 0x38(%r15)
cmpl %ebx, %eax
jne 0x1b53a
movl $0xffffffff, 0x38(%r15) # imm = 0xFFFFFFFF
popq %rbx
popq %r14
popq %r15
retq
cmpb $0x3b, %bl
jne 0x1b55b
movq (%r14), %r15
movl 0x38(%r15), %eax
testl %eax, %eax
jns 0x1b556
movq %r15, %rdi
callq 0x199bc
movl %eax, 0x38(%r15)
cmpl $0x7d, %eax
je 0x1b534
movq (%r14), %rdi
callq 0x1c86c
leaq 0xd188(%rip), %rcx      # 0x286f2
movq %r14, %rdi
movl $0x9, %esi
movl %ebx, %edx
movl %eax, %r8d
popq %rbx
popq %r14
popq %r15
jmp 0x1bdbc
nop
// File: /workspace/github_cpp_makefile_star2_O1/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 %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
movq 0x10(%rdi), %rdi
movq (%rdi), %rax
callq *0x20(%rax)
movq %rax, %r14
movq $0x0, 0x10(%rbx)
movq (%rbx), %rax
movq %rbx, %rdi
callq *0x8(%rax)
movq %r14, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_cpp_makefile_star2_O1/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 %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
movq 0x10(%rdi), %rdi
movq (%rdi), %rax
callq *0x30(%rax)
movq %rax, %r14
movq $0x0, 0x10(%rbx)
movq (%rbx), %rax
movq %rbx, %rdi
callq *0x8(%rax)
movq %r14, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_cpp_makefile_star2_O1/Silica[P]PSL/./PSL/code.h
// Function: PSL::variable::Variable::POP::Execute(PSL::variable::Variable::Environment&)
CLONE(POP)
	EXEC
	{
		#ifdef PSL_MEMBER_REGISTER
		env.reg = env.pop();
		#else
		env.pop();
		#endif
		return RC::NONE;
	}

// Assembly:
pushq %rbx
subq $0x10, %rsp
leaq 0x8(%rsp), %rbx
movq %rbx, %rdi
callq 0xf800
movq (%rbx), %rdi
callq 0xfc04
xorl %eax, %eax
addq $0x10, %rsp
popq %rbx
retq
movq %rax, %rdi
callq 0xde83
// File: /workspace/github_cpp_makefile_star2_O1/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 %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
movq %rsi, %rbx
movq %rdi, %r14
callq 0x1c964
leaq 0x214c9(%rip), %r12     # 0x3dd60
movabsq $0x10000000040001, %r13 # imm = 0x10000000040001
movq (%r14), %r15
movl 0x38(%r15), %eax
testl %eax, %eax
jns 0x1c8b8
movq %r15, %rdi
callq 0x199bc
movl %eax, 0x38(%r15)
cmpl $0x2c, %eax
jne 0x1c927
movq (%r14), %rdi
cmpl $0x0, 0x38(%rdi)
jle 0x1c8cf
movl $0xffffffff, 0x38(%rdi) # imm = 0xFFFFFFFF
jmp 0x1c8d6
jns 0x1c8d6
callq 0x199bc
movq (%r14), %r15
movl 0x38(%r15), %eax
testl %eax, %eax
jns 0x1c8ed
movq %r15, %rdi
callq 0x199bc
movl %eax, 0x38(%r15)
addl $-0x29, %eax
cmpl $0x34, %eax
ja 0x1c8fb
btq %rax, %r13
jb 0x1c927
movq %r14, %rdi
movq %rbx, %rsi
xorl %edx, %edx
callq 0x1c964
callq 0xf762
movq %r12, (%rax)
movq (%rbx), %rcx
movq (%rcx), %rdi
movq (%rdi), %rcx
movq %rax, %rsi
callq *0x190(%rcx)
jmp 0x1c8a1
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
nop
// File: /workspace/github_cpp_makefile_star2_O1/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
pushq %r14
pushq %rbx
movq %rcx, %r14
movl %edx, %ebp
movq %rsi, %rbx
callq 0x10058
cmpl $0x3, %ebp
je 0x1cf32
cmpl $0x2, %ebp
je 0x1cf29
cmpl $0x1, %ebp
jne 0x1cf3b
leaq 0x1fe61(%rip), %rcx     # 0x3cd88
jmp 0x1cf42
leaq 0x1fec0(%rip), %rcx     # 0x3cdf0
jmp 0x1cf42
leaq 0x1fbb7(%rip), %rcx     # 0x3caf0
jmp 0x1cf42
leaq 0x2193e(%rip), %rcx     # 0x3e880
movq %rcx, (%rax)
movq $0x0, 0x8(%rax)
movq (%r14), %rcx
testq %rcx, %rcx
je 0x1cf59
incl (%rcx)
jmp 0x1cf5b
xorl %ecx, %ecx
movq %rcx, 0x8(%rax)
movq (%rbx), %rcx
movq (%rcx), %rdi
movq (%rdi), %rcx
movq 0x190(%rcx), %rcx
movq %rax, %rsi
popq %rbx
popq %r14
popq %rbp
jmpq *%rcx
// File: /workspace/github_cpp_makefile_star2_O1/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
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq %rdi, %r14
callq 0x1f338
leaq 0x204b5(%rip), %r13     # 0x3dbc0
movq (%r14), %r15
movl 0x38(%r15), %ebp
testl %ebp, %ebp
jns 0x1d724
movq %r15, %rdi
callq 0x199bc
movl %eax, %ebp
movl %eax, 0x38(%r15)
cmpl $0x1a, %ebp
jne 0x1d7af
movq (%r14), %rdi
cmpl $0x0, 0x38(%rdi)
jle 0x1d73f
movl $0xffffffff, 0x38(%rdi) # imm = 0xFFFFFFFF
jmp 0x1d746
jns 0x1d746
callq 0x199bc
callq 0x10058
movq %rax, %r15
movl $0x0, 0x8(%rax)
movq %r13, (%rax)
movq (%rbx), %rax
movq (%rax), %rdi
movq (%rdi), %rax
movq %r15, %rsi
callq *0x190(%rax)
movq (%rbx), %rax
movq (%rax), %rdi
movq (%rdi), %rax
callq *0x180(%rax)
movq %rax, %r12
movq %r14, %rdi
movq %rbx, %rsi
xorl %edx, %edx
callq 0x1f338
movq (%rbx), %rax
movq (%rax), %rdi
movq (%rdi), %rax
callq *0x180(%rax)
subl %r12d, %eax
movq (%r15), %rcx
movq %r15, %rdi
movl %eax, %esi
callq *0x20(%rcx)
cmpl $0x1a, %ebp
je 0x1d70b
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O1/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 %r14
pushq %rbx
subq $0x18, %rsp
movq %rsi, %r14
leaq 0x8(%rsp), %rbx
movq %rbx, %rdi
callq 0xf800
movq (%rbx), %rbx
incl 0x8(%rbx)
movq %rbx, %rdi
callq 0xfc04
leaq 0x8(%rsp), %rdi
movl $0x6, %esi
callq 0xfdc8
movq 0x8(%rsp), %rax
movq (%rax), %rdi
movq (%rdi), %rax
movq %rbx, %rsi
callq *0x130(%rax)
movq 0x8(%rsp), %rax
incl 0x8(%rax)
leaq 0x10(%rsp), %rsi
movq %rax, (%rsi)
addq $0x8, %r14
movq %r14, %rdi
callq 0xfc38
movq 0x10(%rsp), %rdi
callq 0xfc04
movq 0x8(%rsp), %rdi
callq 0xfc04
movq %rbx, %rdi
callq 0xfc04
xorl %eax, %eax
addq $0x18, %rsp
popq %rbx
popq %r14
retq
jmp 0x1e35f
jmp 0x1e35f
jmp 0x1e35f
movq %rax, %r14
movq 0x10(%rsp), %rdi
callq 0xfc04
jmp 0x1e33c
jmp 0x1e35f
movq %rax, %r14
movq 0x8(%rsp), %rdi
callq 0xfc04
jmp 0x1e34d
jmp 0x1e35f
movq %rax, %r14
movq %rbx, %rdi
callq 0xfc04
movq %r14, %rdi
callq 0xc290
jmp 0x1e35f
movq %rax, %rdi
callq 0xde83
nop
// File: /workspace/github_cpp_makefile_star2_O1/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 %r15
pushq %r14
pushq %rbx
subq $0x10, %rsp
movq %rsi, %r14
movq %rdi, %rbx
leaq 0x8(%rsp), %r15
movq %r15, %rdi
callq 0xf800
movq (%r15), %rdi
incl 0x8(%rdi)
movq %rdi, (%rsp)
callq 0xfc04
movq %r14, %rdi
callq 0x15518
movq (%rax), %r14
incl 0x8(%r14)
addq $0x8, %rbx
movq (%r14), %rdi
movq (%rdi), %rax
movq %rsp, %rdx
movq %rbx, %rsi
callq *0x148(%rax)
movq %r14, %rdi
callq 0xfc04
movq (%rsp), %rdi
callq 0xfc04
xorl %eax, %eax
addq $0x10, %rsp
popq %rbx
popq %r14
popq %r15
retq
jmp 0x1e4b0
jmp 0x1e4b0
movq %rax, %rbx
movq %r14, %rdi
callq 0xfc04
jmp 0x1e49d
jmp 0x1e4b0
movq %rax, %rbx
movq (%rsp), %rdi
callq 0xfc04
movq %rbx, %rdi
callq 0xc290
jmp 0x1e4b0
movq %rax, %rdi
callq 0xde83
// File: /workspace/github_cpp_makefile_star2_O1/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 %r15
pushq %r14
pushq %rbx
subq $0x10, %rsp
movq %rsi, %r14
leaq 0x8(%rsp), %rbx
movq %rbx, %rdi
callq 0xf800
movq (%rbx), %rbx
incl 0x8(%rbx)
movq %rbx, %rdi
callq 0xfc04
movq %r14, %rdi
callq 0x15518
movq (%rax), %r15
incl 0x8(%r15)
movq (%r15), %rdi
movq (%rdi), %rax
movq %rbx, %rsi
callq *0x130(%rax)
movq %r15, %rdi
callq 0xfc04
movq %rbx, %rdi
callq 0xfc04
xorl %eax, %eax
addq $0x10, %rsp
popq %rbx
popq %r14
popq %r15
retq
jmp 0x1e60b
jmp 0x1e60b
movq %rax, %r14
movq %r15, %rdi
callq 0xfc04
jmp 0x1e5f9
jmp 0x1e60b
movq %rax, %r14
movq %rbx, %rdi
callq 0xfc04
movq %r14, %rdi
callq 0xc290
jmp 0x1e60b
movq %rax, %rdi
callq 0xde83
nop
// File: /workspace/github_cpp_makefile_star2_O1/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 %r15
pushq %r14
pushq %rbx
subq $0x10, %rsp
movq %rsi, %r15
movq %rdi, %r14
leaq 0x8(%rsp), %rbx
movq %rbx, %rdi
callq 0xf800
movq (%rbx), %rbx
incl 0x8(%rbx)
movq %rbx, %rdi
callq 0xfc04
movq %r15, %rdi
callq 0x15518
movq (%rax), %rax
incl 0x8(%rax)
leaq 0x8(%rsp), %rsi
movq %rax, (%rsi)
movl 0x8(%r14), %edx
movq %rsp, %rdi
callq 0x18392
movq (%rsp), %r14
movq (%r14), %rdi
movq (%rdi), %rax
movq %rbx, %rsi
callq *0x38(%rax)
movq %rax, (%r14)
movq (%rax), %rcx
movq %rax, %rdi
movq %r14, %rsi
callq *0x158(%rcx)
movq (%rsp), %rdi
callq 0xfc04
movq 0x8(%rsp), %rdi
callq 0xfc04
movq %rbx, %rdi
callq 0xfc04
xorl %eax, %eax
addq $0x10, %rsp
popq %rbx
popq %r14
popq %r15
retq
jmp 0x1e711
jmp 0x1e711
jmp 0x1e711
movq %rax, %r14
jmp 0x1e6f3
movq %rax, %r14
jmp 0x1e6fd
jmp 0x1e711
movq %rax, %r14
movq (%rsp), %rdi
callq 0xfc04
movq 0x8(%rsp), %rdi
callq 0xfc04
movq %rbx, %rdi
callq 0xfc04
movq %r14, %rdi
callq 0xc290
jmp 0x1e711
jmp 0x1e711
movq %rax, %rdi
callq 0xde83
nop
// File: /workspace/github_cpp_makefile_star2_O1/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 %r14
pushq %rbx
subq $0x18, %rsp
movq %rsi, %r14
movq %rsi, %rdi
callq 0x15518
movq (%rax), %rbx
movl 0x8(%rbx), %eax
leal 0x1(%rax), %ecx
movl %ecx, 0x8(%rbx)
addl $0x2, %eax
movl %eax, 0x8(%rbx)
leaq 0x8(%rsp), %rdx
movq %rbx, (%rdx)
movq 0x20(%r14), %rsi
movq (%rsi), %rax
leaq 0x10(%rsp), %rdi
callq *0x60(%rax)
movq 0x10(%rsp), %rdi
callq 0xfc04
movq 0x8(%rsp), %rdi
callq 0xfc04
movq %rbx, %rdi
callq 0xfc04
xorl %eax, %eax
addq $0x18, %rsp
popq %rbx
popq %r14
retq
jmp 0x1ee52
jmp 0x1ee52
jmp 0x1ee52
movq %rax, %r14
movq 0x8(%rsp), %rdi
callq 0xfc04
movq %rbx, %rdi
callq 0xfc04
movq %r14, %rdi
callq 0xc290
jmp 0x1ee52
movq %rax, %rdi
callq 0xde83
// File: /workspace/github_cpp_makefile_star2_O1/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
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq %rdi, %r14
callq 0x1f452
leaq 0x1d733(%rip), %r13     # 0x3ca88
movq (%r14), %r15
movl 0x38(%r15), %ebp
testl %ebp, %ebp
jns 0x1f36e
movq %r15, %rdi
callq 0x199bc
movl %eax, %ebp
movl %eax, 0x38(%r15)
cmpl $0x19, %ebp
jne 0x1f442
movq (%r14), %rdi
cmpl $0x0, 0x38(%rdi)
jle 0x1f389
movl $0xffffffff, 0x38(%rdi) # imm = 0xFFFFFFFF
jmp 0x1f390
jns 0x1f390
callq 0x199bc
callq 0x10058
movq %rax, %r15
movl $0x0, 0x8(%rax)
leaq 0x1e8ea(%rip), %rax     # 0x3dc90
movq %rax, (%r15)
movq (%rbx), %rax
movq (%rax), %rdi
movq (%rdi), %rax
movq %r15, %rsi
callq *0x190(%rax)
movq (%rbx), %rax
movq (%rax), %rdi
movq (%rdi), %rax
callq *0x180(%rax)
movq %rax, %r12
movq %r14, %rdi
movq %rbx, %rsi
xorl %edx, %edx
callq 0x1f452
callq 0x10058
movl $0x1, 0x8(%rax)
leaq 0x1e90b(%rip), %rcx     # 0x3dcf8
movq %rcx, (%rax)
movq (%rbx), %rcx
movq (%rcx), %rdi
movq (%rdi), %rcx
movq %rax, %rsi
callq *0x190(%rcx)
movq (%rbx), %rax
movq (%rax), %rdi
movq (%rdi), %rax
callq *0x180(%rax)
subl %r12d, %eax
movq (%r15), %rcx
movq %r15, %rdi
movl %eax, %esi
callq *0x20(%rcx)
callq 0xf762
movq %r13, (%rax)
movq (%rbx), %rcx
movq (%rcx), %rdi
movq (%rdi), %rcx
movq %rax, %rsi
callq *0x190(%rcx)
cmpl $0x19, %ebp
je 0x1f355
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O1/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 %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
movq %rsi, %rbx
movq %rdi, %r14
callq 0x1f50e
leaq 0x1e6eb(%rip), %r12     # 0x3db58
leaq 0x1e67c(%rip), %r13     # 0x3daf0
movq (%r14), %r15
movl 0x38(%r15), %eax
testl %eax, %eax
jns 0x1f48b
movq %r15, %rdi
callq 0x199bc
movl %eax, 0x38(%r15)
cmpl $0xa, %eax
je 0x1f4aa
cmpl $0x9, %eax
jne 0x1f503
movq (%r14), %rdi
cmpl $0x0, 0x38(%rdi)
jle 0x1f4cb
movl $0xffffffff, 0x38(%rdi) # imm = 0xFFFFFFFF
movq %r13, %r15
jmp 0x1f4d0
movq (%r14), %rdi
cmpl $0x0, 0x38(%rdi)
jle 0x1f4bf
movl $0xffffffff, 0x38(%rdi) # imm = 0xFFFFFFFF
movq %r12, %r15
jmp 0x1f4d0
movq %r12, %r15
jns 0x1f4d0
callq 0x199bc
jmp 0x1f4ba
movq %r13, %r15
js 0x1f4fc
movq %r14, %rdi
movq %rbx, %rsi
xorl %edx, %edx
callq 0x1f50e
callq 0xf762
movq %r15, (%rax)
movq (%rbx), %rcx
movq (%rcx), %rdi
movq (%rdi), %rcx
movq %rax, %rsi
callq *0x190(%rcx)
jmp 0x1f474
callq 0x199bc
jmp 0x1f4a5
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
nop
// File: /workspace/github_cpp_makefile_star2_O1/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
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq %rdi, %r14
callq 0x1f63c
leaq 0x1e55d(%rip), %r13     # 0x3da88
leaq 0x1e4ee(%rip), %rbp     # 0x3da20
leaq 0x1e417(%rip), %r12     # 0x3d950
movq (%r14), %r15
movl 0x38(%r15), %eax
testl %eax, %eax
jns 0x1f550
movq %r15, %rdi
callq 0x199bc
movl %eax, 0x38(%r15)
cmpl $0x3b, %eax
jg 0x1f578
cmpl $0xb, %eax
je 0x1f59b
cmpl $0xc, %eax
jne 0x1f62c
movq (%r14), %rdi
cmpl $0x0, 0x38(%rdi)
jle 0x1f5e5
movl $0xffffffff, 0x38(%rdi) # imm = 0xFFFFFFFF
movq %r13, %r15
jmp 0x1f5f6
cmpl $0x3e, %eax
je 0x1f5b4
cmpl $0x3c, %eax
jne 0x1f62c
movq (%r14), %rdi
cmpl $0x0, 0x38(%rdi)
jle 0x1f5f1
movl $0xffffffff, 0x38(%rdi) # imm = 0xFFFFFFFF
movq %r12, %r15
jmp 0x1f5f6
movq (%r14), %rdi
cmpl $0x0, 0x38(%rdi)
jle 0x1f5c9
movl $0xffffffff, 0x38(%rdi) # imm = 0xFFFFFFFF
leaq 0x1e406(%rip), %r15     # 0x3d9b8
jmp 0x1f5f6
movq (%r14), %rdi
cmpl $0x0, 0x38(%rdi)
jle 0x1f5d9
movl $0xffffffff, 0x38(%rdi) # imm = 0xFFFFFFFF
movq %rbp, %r15
jmp 0x1f5f6
leaq 0x1e3e8(%rip), %r15     # 0x3d9b8
jns 0x1f5f6
callq 0x199bc
jmp 0x1f5ab
movq %rbp, %r15
jns 0x1f5f6
callq 0x199bc
jmp 0x1f5c4
movq %r13, %r15
jns 0x1f5f6
callq 0x199bc
jmp 0x1f573
movq %r12, %r15
js 0x1f622
movq %r14, %rdi
movq %rbx, %rsi
xorl %edx, %edx
callq 0x1f63c
callq 0xf762
movq %r15, (%rax)
movq (%rbx), %rcx
movq (%rcx), %rdi
movq (%rdi), %rcx
movq %rax, %rsi
callq *0x190(%rcx)
jmp 0x1f539
callq 0x199bc
jmp 0x1f596
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O1/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
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movq %rsi, %rbx
movq %rdi, %r14
callq 0x1f6c2
leaq 0x1e292(%rip), %r12     # 0x3d8e8
movq (%r14), %r15
movl 0x38(%r15), %ebp
testl %ebp, %ebp
jns 0x1f66f
movq %r15, %rdi
callq 0x199bc
movl %eax, %ebp
movl %eax, 0x38(%r15)
cmpl $0x7c, %ebp
jne 0x1f6b9
movq (%r14), %rdi
cmpl $0x0, 0x38(%rdi)
jle 0x1f686
movl $0xffffffff, 0x38(%rdi) # imm = 0xFFFFFFFF
jmp 0x1f68d
jns 0x1f68d
callq 0x199bc
movq %r14, %rdi
movq %rbx, %rsi
xorl %edx, %edx
callq 0x1f6c2
callq 0xf762
movq %r12, (%rax)
movq (%rbx), %rcx
movq (%rcx), %rdi
movq (%rdi), %rcx
movq %rax, %rsi
callq *0x190(%rcx)
cmpl $0x7c, %ebp
je 0x1f656
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O1/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
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movq %rsi, %rbx
movq %rdi, %r14
callq 0x1f748
leaq 0x1e1a4(%rip), %r12     # 0x3d880
movq (%r14), %r15
movl 0x38(%r15), %ebp
testl %ebp, %ebp
jns 0x1f6f5
movq %r15, %rdi
callq 0x199bc
movl %eax, %ebp
movl %eax, 0x38(%r15)
cmpl $0x5e, %ebp
jne 0x1f73f
movq (%r14), %rdi
cmpl $0x0, 0x38(%rdi)
jle 0x1f70c
movl $0xffffffff, 0x38(%rdi) # imm = 0xFFFFFFFF
jmp 0x1f713
jns 0x1f713
callq 0x199bc
movq %r14, %rdi
movq %rbx, %rsi
xorl %edx, %edx
callq 0x1f748
callq 0xf762
movq %r12, (%rax)
movq (%rbx), %rcx
movq (%rcx), %rdi
movq (%rdi), %rcx
movq %rax, %rsi
callq *0x190(%rcx)
cmpl $0x5e, %ebp
je 0x1f6dc
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O1/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
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movq %rsi, %rbx
movq %rdi, %r14
callq 0x1f7ce
leaq 0x1e0b6(%rip), %r12     # 0x3d818
movq (%r14), %r15
movl 0x38(%r15), %ebp
testl %ebp, %ebp
jns 0x1f77b
movq %r15, %rdi
callq 0x199bc
movl %eax, %ebp
movl %eax, 0x38(%r15)
cmpl $0x26, %ebp
jne 0x1f7c5
movq (%r14), %rdi
cmpl $0x0, 0x38(%rdi)
jle 0x1f792
movl $0xffffffff, 0x38(%rdi) # imm = 0xFFFFFFFF
jmp 0x1f799
jns 0x1f799
callq 0x199bc
movq %r14, %rdi
movq %rbx, %rsi
xorl %edx, %edx
callq 0x1f7ce
callq 0xf762
movq %r12, (%rax)
movq (%rbx), %rcx
movq (%rcx), %rdi
movq (%rdi), %rcx
movq %rax, %rsi
callq *0x190(%rcx)
cmpl $0x26, %ebp
je 0x1f762
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O1/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 %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
movq %rsi, %rbx
movq %rdi, %r14
callq 0x1f88a
leaq 0x1dfc7(%rip), %r12     # 0x3d7b0
leaq 0x1df58(%rip), %r13     # 0x3d748
movq (%r14), %r15
movl 0x38(%r15), %eax
testl %eax, %eax
jns 0x1f807
movq %r15, %rdi
callq 0x199bc
movl %eax, 0x38(%r15)
cmpl $0x16, %eax
je 0x1f826
cmpl $0x15, %eax
jne 0x1f87f
movq (%r14), %rdi
cmpl $0x0, 0x38(%rdi)
jle 0x1f847
movl $0xffffffff, 0x38(%rdi) # imm = 0xFFFFFFFF
movq %r13, %r15
jmp 0x1f84c
movq (%r14), %rdi
cmpl $0x0, 0x38(%rdi)
jle 0x1f83b
movl $0xffffffff, 0x38(%rdi) # imm = 0xFFFFFFFF
movq %r12, %r15
jmp 0x1f84c
movq %r12, %r15
jns 0x1f84c
callq 0x199bc
jmp 0x1f836
movq %r13, %r15
js 0x1f878
movq %r14, %rdi
movq %rbx, %rsi
xorl %edx, %edx
callq 0x1f88a
callq 0xf762
movq %r15, (%rax)
movq (%rbx), %rcx
movq (%rcx), %rdi
movq (%rdi), %rcx
movq %rax, %rsi
callq *0x190(%rcx)
jmp 0x1f7f0
callq 0x199bc
jmp 0x1f821
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
nop
// File: /workspace/github_cpp_makefile_star2_O1/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 %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
movq %rsi, %rbx
movq %rdi, %r14
callq 0x1f946
leaq 0x1de3b(%rip), %r12     # 0x3d6e0
leaq 0x1ddcc(%rip), %r13     # 0x3d678
movq (%r14), %r15
movl 0x38(%r15), %eax
testl %eax, %eax
jns 0x1f8c3
movq %r15, %rdi
callq 0x199bc
movl %eax, 0x38(%r15)
cmpl $0x2d, %eax
je 0x1f8e2
cmpl $0x2b, %eax
jne 0x1f93b
movq (%r14), %rdi
cmpl $0x0, 0x38(%rdi)
jle 0x1f903
movl $0xffffffff, 0x38(%rdi) # imm = 0xFFFFFFFF
movq %r13, %r15
jmp 0x1f908
movq (%r14), %rdi
cmpl $0x0, 0x38(%rdi)
jle 0x1f8f7
movl $0xffffffff, 0x38(%rdi) # imm = 0xFFFFFFFF
movq %r12, %r15
jmp 0x1f908
movq %r12, %r15
jns 0x1f908
callq 0x199bc
jmp 0x1f8f2
movq %r13, %r15
js 0x1f934
movq %r14, %rdi
movq %rbx, %rsi
xorl %edx, %edx
callq 0x1f946
callq 0xf762
movq %r15, (%rax)
movq (%rbx), %rcx
movq (%rcx), %rdi
movq (%rdi), %rcx
movq %rax, %rsi
callq *0x190(%rcx)
jmp 0x1f8ac
callq 0x199bc
jmp 0x1f8dd
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
nop
// File: /workspace/github_cpp_makefile_star2_O1/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
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq %rdi, %r14
testl %edx, %edx
jne 0x1f966
movq %r14, %rdi
movq %rbx, %rsi
callq 0x1cf78
leaq 0x1dca3(%rip), %r12     # 0x3d610
leaq 0x1dc34(%rip), %r13     # 0x3d5a8
leaq 0x1dbc5(%rip), %rbp     # 0x3d540
movq (%r14), %r15
movl 0x38(%r15), %eax
testl %eax, %eax
jns 0x1f992
movq %r15, %rdi
callq 0x199bc
movl %eax, 0x38(%r15)
cmpl $0x25, %eax
je 0x1f9cf
cmpl $0x2f, %eax
je 0x1f9ba
cmpl $0x2a, %eax
jne 0x1fa32
movq (%r14), %rdi
cmpl $0x0, 0x38(%rdi)
jle 0x1f9f0
movl $0xffffffff, 0x38(%rdi) # imm = 0xFFFFFFFF
movq %rbp, %r15
jmp 0x1fa01
movq (%r14), %rdi
cmpl $0x0, 0x38(%rdi)
jle 0x1f9e4
movl $0xffffffff, 0x38(%rdi) # imm = 0xFFFFFFFF
movq %r13, %r15
jmp 0x1fa01
movq (%r14), %rdi
cmpl $0x0, 0x38(%rdi)
jle 0x1f9fc
movl $0xffffffff, 0x38(%rdi) # imm = 0xFFFFFFFF
movq %r12, %r15
jmp 0x1fa01
movq %r13, %r15
jns 0x1fa01
callq 0x199bc
jmp 0x1f9ca
movq %rbp, %r15
jns 0x1fa01
callq 0x199bc
jmp 0x1f9b5
movq %r12, %r15
js 0x1fa2b
movq %r14, %rdi
movq %rbx, %rsi
callq 0x1cf78
callq 0xf762
movq %r15, (%rax)
movq (%rbx), %rcx
movq (%rcx), %rdi
movq (%rdi), %rcx
movq %rax, %rsi
callq *0x190(%rcx)
jmp 0x1f97b
callq 0x199bc
jmp 0x1f9df
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O1/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 %r14
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq %rdi, %r14
movq %rsi, %rdi
callq 0x15518
movq (%rax), %rax
movq (%rax), %rdi
movq (%rdi), %rax
callq *0xe0(%rax)
testb %al, %al
je 0x20ffc
movslq 0x8(%r14), %rax
movq 0x20(%rbx), %rcx
movslq 0x20(%rcx), %rdx
addq %rax, %rdx
movq %rdx, 0x20(%rcx)
jmp 0x21012
movq %rsp, %r14
movq %r14, %rdi
movq %rbx, %rsi
callq 0xf800
movq (%r14), %rdi
callq 0xfc04
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
movq %rax, %rdi
callq 0xde83
// File: /workspace/github_cpp_makefile_star2_O1/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 %r14
pushq %rbx
subq $0x28, %rsp
movq %rsi, %rbx
leaq 0x10(%rsp), %r14
movq %r14, %rdi
callq 0xf800
movq (%r14), %rdi
incl 0x8(%rdi)
movq %rdi, 0x18(%rsp)
callq 0xfc04
leaq 0x8(%rsp), %rdi
movq %rbx, %rsi
callq 0xf800
movq 0x8(%rsp), %rdi
incl 0x8(%rdi)
movq %rdi, 0x10(%rsp)
callq 0xfc04
movq 0x10(%rsp), %rax
movq (%rax), %rdi
movq (%rdi), %rax
callq *0x10(%rax)
cmpl $0x6, %eax
jne 0x21321
movq 0x10(%rsp), %rax
movq 0x18(%rsp), %rsi
movq (%rax), %rdi
movq (%rdi), %rax
callq *0x130(%rax)
movq 0x10(%rsp), %rax
incl 0x8(%rax)
leaq 0x8(%rsp), %rsi
movq %rax, (%rsi)
addq $0x8, %rbx
movq %rbx, %rdi
callq 0xfc38
movq 0x8(%rsp), %rdi
callq 0xfc04
jmp 0x21365
leaq 0x20(%rsp), %rdi
leaq 0x10(%rsp), %rsi
leaq 0x18(%rsp), %rdx
callq 0x2141c
movq 0x20(%rsp), %rax
incl 0x8(%rax)
leaq 0x8(%rsp), %rsi
movq %rax, (%rsi)
addq $0x8, %rbx
movq %rbx, %rdi
callq 0xfc38
movq 0x8(%rsp), %rdi
callq 0xfc04
movq 0x20(%rsp), %rdi
callq 0xfc04
movq 0x10(%rsp), %rdi
callq 0xfc04
movq 0x18(%rsp), %rdi
callq 0xfc04
xorl %eax, %eax
addq $0x28, %rsp
popq %rbx
popq %r14
retq
jmp 0x213e7
jmp 0x213e7
jmp 0x213e7
movq %rax, %rbx
movq 0x8(%rsp), %rdi
callq 0xfc04
movq 0x20(%rsp), %rdi
callq 0xfc04
jmp 0x213c9
jmp 0x213e7
jmp 0x213e7
movq %rax, %rbx
movq 0x8(%rsp), %rdi
callq 0xfc04
jmp 0x213c9
jmp 0x213e7
jmp 0x213c6
jmp 0x213e7
jmp 0x213e7
jmp 0x213e7
movq %rax, %rbx
jmp 0x213d3
jmp 0x213e7
movq %rax, %rbx
movq 0x10(%rsp), %rdi
callq 0xfc04
movq 0x18(%rsp), %rdi
callq 0xfc04
movq %rbx, %rdi
callq 0xc290
jmp 0x213e7
movq %rax, %rdi
callq 0xde83
nop
// File: /workspace/github_cpp_makefile_star2_O1/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 %r15
pushq %r14
pushq %rbx
subq $0x10, %rsp
movq %rsi, %r14
leaq 0x8(%rsp), %rbx
movq %rbx, %rdi
callq 0xf800
movq (%rbx), %rbx
incl 0x8(%rbx)
movq %rbx, %rdi
callq 0xfc04
movq %r14, %rdi
callq 0x15518
movq (%rax), %r14
incl 0x8(%r14)
movq (%r14), %rdi
movq (%rdi), %rax
movq %rbx, %rsi
callq *0x38(%rax)
movq %rax, (%r14)
movq (%rax), %rcx
movq %rax, %rdi
movq %r14, %rsi
callq *0x158(%rcx)
movq %r14, %rdi
callq 0xfc04
movq %rbx, %rdi
callq 0xfc04
xorl %eax, %eax
addq $0x10, %rsp
popq %rbx
popq %r14
popq %r15
retq
jmp 0x21578
jmp 0x21578
movq %rax, %r15
jmp 0x21566
jmp 0x21578
movq %rax, %r15
movq %r14, %rdi
callq 0xfc04
movq %rbx, %rdi
callq 0xfc04
movq %r15, %rdi
callq 0xc290
jmp 0x21578
movq %rax, %rdi
callq 0xde83
// File: /workspace/github_cpp_makefile_star2_O1/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 %r15
pushq %r14
pushq %rbx
subq $0x10, %rsp
movq %rsi, %r14
leaq 0x8(%rsp), %rbx
movq %rbx, %rdi
callq 0xf800
movq (%rbx), %rbx
incl 0x8(%rbx)
movq %rbx, %rdi
callq 0xfc04
movq %r14, %rdi
callq 0x15518
movq (%rax), %r14
incl 0x8(%r14)
movq (%r14), %rdi
movq (%rdi), %rax
movq %rbx, %rsi
callq *0x40(%rax)
movq %rax, (%r14)
movq (%rax), %rcx
movq %rax, %rdi
movq %r14, %rsi
callq *0x158(%rcx)
movq %r14, %rdi
callq 0xfc04
movq %rbx, %rdi
callq 0xfc04
xorl %eax, %eax
addq $0x10, %rsp
popq %rbx
popq %r14
popq %r15
retq
jmp 0x2164a
jmp 0x2164a
movq %rax, %r15
jmp 0x21638
jmp 0x2164a
movq %rax, %r15
movq %r14, %rdi
callq 0xfc04
movq %rbx, %rdi
callq 0xfc04
movq %r15, %rdi
callq 0xc290
jmp 0x2164a
movq %rax, %rdi
callq 0xde83
// File: /workspace/github_cpp_makefile_star2_O1/Silica[P]PSL/./PSL/parser.h
// Function: PSL::variable::Parser::ParseDangling(PSL::variable&, PSL::variable&)
void ParseDangling(variable &g, variable &c)
	{
		if (t->getNextIf('{'/*'}'*/))
			ParseBlock(g, c);
		else
			ParseStatement(g, c);
	}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rdx, %rbx
movq %rsi, %r14
movq %rdi, %r15
movq (%rdi), %r12
movl 0x38(%r12), %eax
testl %eax, %eax
jns 0x21e44
movq %r12, %rdi
callq 0x199bc
movl %eax, 0x38(%r12)
cmpl $0x7b, %eax
jne 0x21e6b
movl $0xffffffff, 0x38(%r12) # imm = 0xFFFFFFFF
movq %r15, %rdi
movq %r14, %rsi
movq %rbx, %rdx
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
jmp 0x1b424
movq %r15, %rdi
movq %r14, %rsi
movq %rbx, %rdx
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
jmp 0x18c32