LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: Silica[P]PSL/./PSL/environment.h
// Function: PSL::variable::Variable::Environment::top()
rsv &top()
	{
		#ifdef PSL_CHECKSTACK_POP
		if (stack.empty())
		{
			warning(2);
			stack.push(rsv());
		}
		#endif
		return stack.top();
	}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x30(%rbp)
addq $0x8, %rdi
callq 0x11b50
testb $0x1, %al
jne 0x1e4c6
jmp 0x1e558
leaq 0x20516(%rip), %rsi     # 0x3e9e3
leaq -0x10(%rbp), %rdi
movq %rdi, -0x38(%rbp)
callq 0xc8b0
movq -0x30(%rbp), %rdi
movq -0x38(%rbp), %rdx
movl $0x2, %esi
callq 0x11b70
jmp 0x1e4ee
leaq -0x10(%rbp), %rdi
callq 0xc950
movq -0x30(%rbp), %rax
addq $0x8, %rax
movq %rax, -0x48(%rbp)
leaq -0x28(%rbp), %rdi
movq %rdi, -0x40(%rbp)
callq 0xdf50
movq -0x48(%rbp), %rdi
movq -0x40(%rbp), %rsi
callq 0x12440
jmp 0x1e51f
leaq -0x28(%rbp), %rdi
callq 0xcd90
jmp 0x1e558
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x18(%rbp)
movl %eax, -0x1c(%rbp)
leaq -0x10(%rbp), %rdi
callq 0xc950
jmp 0x1e56b
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x18(%rbp)
movl %eax, -0x1c(%rbp)
leaq -0x28(%rbp), %rdi
callq 0xcd90
jmp 0x1e56b
movq -0x30(%rbp), %rdi
addq $0x8, %rdi
callq 0x1e580
addq $0x50, %rsp
popq %rbp
retq
movq -0x18(%rbp), %rdi
callq 0xc280
nopw %cs:(%rax,%rax)
nop
// File: Silica[P]PSL/./PSL/memory.h
// Function: PSL::variable::VMemoryPool::release(void*)
void release(void *x)
	{
		DATA *c = static_cast<DATA*>(x);
		c->x = 0;
		c->next = current;
		current = c;
	}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq -0x10(%rbp), %rcx
movq %rcx, -0x18(%rbp)
movq -0x18(%rbp), %rcx
movl $0x0, (%rcx)
movq (%rax), %rdx
movq -0x18(%rbp), %rcx
movq %rdx, 0x8(%rcx)
movq -0x18(%rbp), %rcx
movq %rcx, (%rax)
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: Silica[P]PSL/./PSL/variable.h
// Function: PSL::variable::operator=(PSL::variable (*)(PSL::variable&))
variable &operator=(function f)		{
		if (f == NULL)
		{
			variable v = 0;
			x->substitution(v.x);
		}
		else
		{
			variable v = f;
			x->substitution(v.x);
		}
		return *this;
	}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x38(%rbp)
cmpq $0x0, -0x10(%rbp)
jne 0x1fc1e
leaq -0x18(%rbp), %rdi
xorl %esi, %esi
callq 0xcce0
movq -0x38(%rbp), %rax
movq (%rax), %rdi
movq -0x18(%rbp), %rsi
callq 0x12740
jmp 0x1fbfc
leaq -0x18(%rbp), %rdi
callq 0xcdc0
jmp 0x1fc5f
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x20(%rbp)
movl %eax, -0x24(%rbp)
leaq -0x18(%rbp), %rdi
callq 0xcdc0
jmp 0x1fc69
movq -0x10(%rbp), %rsi
leaq -0x30(%rbp), %rdi
callq 0x1ff10
movq -0x38(%rbp), %rax
movq (%rax), %rdi
movq -0x30(%rbp), %rsi
callq 0x12740
jmp 0x1fc3d
leaq -0x30(%rbp), %rdi
callq 0xcdc0
jmp 0x1fc5f
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x20(%rbp)
movl %eax, -0x24(%rbp)
leaq -0x30(%rbp), %rdi
callq 0xcdc0
jmp 0x1fc69
movq -0x38(%rbp), %rax
addq $0x40, %rsp
popq %rbp
retq
movq -0x20(%rbp), %rdi
callq 0xc280
nopw %cs:(%rax,%rax)
nopl (%rax)
// File: Silica[P]PSL/./PSL/PSLlib.h
// Function: PSL::variable::PSLlib::Type(PSL::variable&)
static variable Type(variable &v)
	{
		switch (v.type())
		{
		case NIL:		return "nil";
		case INT:		return "int";
		case HEX:		return "hex";
		case FLOAT:		return "float";
		case STRING:	return "string";
		case POINTER:	return "pointer";
		case RARRAY:	return "tuple";
		case OBJECT:	return "object";
		case METHOD:	return "method";
		case CFUNCTION:	return "Cfunction";
		case CMETHOD:	return "Cmethod";
		case CPOINTER:	return "Cpointer";
		case SPOINTER:	return "SmartPointer";
		case THREAD:	return "thread";
		case BCFUNCTION:return "bind function";
		case CCMETHOD:	return "bind method";
		}
		return "";
	}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x28(%rbp)
movq %rdi, %rax
movq %rax, -0x20(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x10(%rbp), %rdi
callq 0x1fe90
movl %eax, %ecx
movq %rcx, -0x18(%rbp)
subl $0xf, %eax
ja 0x1fe02
movq -0x18(%rbp), %rax
leaq 0x1e416(%rip), %rcx     # 0x3e0d4
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
movq -0x28(%rbp), %rdi
leaq 0x1eb7f(%rip), %rsi     # 0x3e851
callq 0xcee0
jmp 0x1fe12
movq -0x28(%rbp), %rdi
leaq 0x1eb9b(%rip), %rsi     # 0x3e882
callq 0xcee0
jmp 0x1fe12
movq -0x28(%rbp), %rdi
leaq 0x1eb59(%rip), %rsi     # 0x3e855
callq 0xcee0
jmp 0x1fe12
movq -0x28(%rbp), %rdi
leaq 0x1eb28(%rip), %rsi     # 0x3e839
callq 0xcee0
jmp 0x1fe12
movq -0x28(%rbp), %rdi
leaq 0x1eb19(%rip), %rsi     # 0x3e83f
callq 0xcee0
jmp 0x1fe12
movq -0x28(%rbp), %rdi
leaq 0x1ebc8(%rip), %rsi     # 0x3e903
callq 0xcee0
jmp 0x1fe12
movq -0x28(%rbp), %rdi
leaq 0x1eb9a(%rip), %rsi     # 0x3e8ea
callq 0xcee0
jmp 0x1fe12
movq -0x28(%rbp), %rdi
leaq 0x1eb0f(%rip), %rsi     # 0x3e874
callq 0xcee0
jmp 0x1fe12
movq -0x28(%rbp), %rdi
leaq 0x1ebb1(%rip), %rsi     # 0x3e92b
callq 0xcee0
jmp 0x1fe12
movq -0x28(%rbp), %rdi
leaq 0x1eb61(%rip), %rsi     # 0x3e8f0
callq 0xcee0
jmp 0x1fe12
movq -0x28(%rbp), %rdi
leaq 0x1eb59(%rip), %rsi     # 0x3e8fa
callq 0xcee0
jmp 0x1fe12
movq -0x28(%rbp), %rdi
leaq 0x1eb4f(%rip), %rsi     # 0x3e902
callq 0xcee0
jmp 0x1fe12
movq -0x28(%rbp), %rdi
leaq 0x1eb46(%rip), %rsi     # 0x3e90b
callq 0xcee0
jmp 0x1fe12
movq -0x28(%rbp), %rdi
leaq 0x1ea8e(%rip), %rsi     # 0x3e865
callq 0xcee0
jmp 0x1fe12
movq -0x28(%rbp), %rdi
leaq 0x1eb2f(%rip), %rsi     # 0x3e918
callq 0xcee0
jmp 0x1fe12
movq -0x28(%rbp), %rdi
leaq 0x1eb2b(%rip), %rsi     # 0x3e926
callq 0xcee0
jmp 0x1fe12
movq -0x28(%rbp), %rdi
leaq 0x1ebd6(%rip), %rsi     # 0x3e9e3
callq 0xcee0
movq -0x20(%rbp), %rax
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax)
// File: Silica[P]PSL/./PSL/PSLlib.h
// Function: PSL::variable::PSLlib::Map(PSL::variable&)
static variable Map(variable &v)
	{
		variable l = v[0];
		variable f = v[1];
		variable n;
		size_t size = l.length();
		for (size_t i = 0; i < size; ++i)
			n[i] = f(l[i]);
		return n;
	}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x70, %rsp
movq %rdi, -0x68(%rbp)
movq %rdi, %rax
movq %rax, -0x60(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x10(%rbp), %rsi
leaq -0x18(%rbp), %rdi
xorl %edx, %edx
callq 0x22460
movq -0x10(%rbp), %rsi
leaq -0x20(%rbp), %rdi
movl $0x1, %edx
callq 0x22460
jmp 0x20b3e
movq -0x68(%rbp), %rdi
movb $0x0, -0x2d(%rbp)
callq 0x1a130
jmp 0x20b4d
leaq -0x18(%rbp), %rdi
callq 0x1d280
movq %rax, -0x70(%rbp)
jmp 0x20b5c
movq -0x70(%rbp), %rax
movq %rax, -0x38(%rbp)
movq $0x0, -0x40(%rbp)
movq -0x40(%rbp), %rax
cmpq -0x38(%rbp), %rax
jae 0x20c60
movq -0x40(%rbp), %rdx
leaq -0x50(%rbp), %rdi
leaq -0x18(%rbp), %rsi
callq 0x1d2a0
jmp 0x20b8d
leaq -0x48(%rbp), %rdi
leaq -0x20(%rbp), %rsi
leaq -0x50(%rbp), %rdx
callq 0x225b0
jmp 0x20ba0
movq -0x68(%rbp), %rsi
movq -0x40(%rbp), %rdx
leaq -0x58(%rbp), %rdi
callq 0x1d2a0
jmp 0x20bb3
leaq -0x58(%rbp), %rdi
leaq -0x48(%rbp), %rsi
callq 0x1d200
jmp 0x20bc2
leaq -0x58(%rbp), %rdi
callq 0xcdc0
leaq -0x48(%rbp), %rdi
callq 0xcdc0
leaq -0x50(%rbp), %rdi
callq 0xcdc0
movq -0x40(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x40(%rbp)
jmp 0x20b6c
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x28(%rbp)
movl %eax, -0x2c(%rbp)
jmp 0x20ca1
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x28(%rbp)
movl %eax, -0x2c(%rbp)
jmp 0x20c98
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x28(%rbp)
movl %eax, -0x2c(%rbp)
jmp 0x20c8f
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x28(%rbp)
movl %eax, -0x2c(%rbp)
jmp 0x20c55
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x28(%rbp)
movl %eax, -0x2c(%rbp)
jmp 0x20c4c
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x28(%rbp)
movl %eax, -0x2c(%rbp)
leaq -0x58(%rbp), %rdi
callq 0xcdc0
leaq -0x48(%rbp), %rdi
callq 0xcdc0
leaq -0x50(%rbp), %rdi
callq 0xcdc0
jmp 0x20c8f
movb $0x1, -0x2d(%rbp)
testb $0x1, -0x2d(%rbp)
jne 0x20c73
movq -0x68(%rbp), %rdi
callq 0xcdc0
leaq -0x20(%rbp), %rdi
callq 0xcdc0
leaq -0x18(%rbp), %rdi
callq 0xcdc0
movq -0x60(%rbp), %rax
addq $0x70, %rsp
popq %rbp
retq
movq -0x68(%rbp), %rdi
callq 0xcdc0
leaq -0x20(%rbp), %rdi
callq 0xcdc0
leaq -0x18(%rbp), %rdi
callq 0xcdc0
movq -0x28(%rbp), %rdi
callq 0xc280
nopw %cs:(%rax,%rax)
nopl (%rax)
// File: Silica[P]PSL/./PSL/PSLlib.h
// Function: PSL::variable::PSLlib::Filter(PSL::variable&)
static variable Filter(variable &v)
	{
		variable l = v[0];
		variable f = v[1];
		variable n;
		size_t size = l.length();
		for (size_t i = 0; i < size; ++i)
			if (f(l[i]))
				n.push(l[i]);
		return n;
	}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x80, %rsp
movq %rdi, -0x68(%rbp)
movq %rdi, %rax
movq %rax, -0x60(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x10(%rbp), %rsi
leaq -0x18(%rbp), %rdi
xorl %edx, %edx
callq 0x22460
movq -0x10(%rbp), %rsi
leaq -0x20(%rbp), %rdi
movl $0x1, %edx
callq 0x22460
jmp 0x20d01
movq -0x68(%rbp), %rdi
movb $0x0, -0x2d(%rbp)
callq 0x1a130
jmp 0x20d10
leaq -0x18(%rbp), %rdi
callq 0x1d280
movq %rax, -0x70(%rbp)
jmp 0x20d1f
movq -0x70(%rbp), %rax
movq %rax, -0x38(%rbp)
movq $0x0, -0x40(%rbp)
movq -0x40(%rbp), %rax
cmpq -0x38(%rbp), %rax
jae 0x20e47
movq -0x40(%rbp), %rdx
leaq -0x50(%rbp), %rdi
leaq -0x18(%rbp), %rsi
callq 0x1d2a0
jmp 0x20d50
leaq -0x48(%rbp), %rdi
leaq -0x20(%rbp), %rsi
leaq -0x50(%rbp), %rdx
callq 0x225b0
jmp 0x20d63
leaq -0x48(%rbp), %rdi
callq 0x1fef0
movb %al, -0x71(%rbp)
jmp 0x20d71
leaq -0x48(%rbp), %rdi
callq 0xcdc0
leaq -0x50(%rbp), %rdi
callq 0xcdc0
movb -0x71(%rbp), %al
testb $0x1, %al
jne 0x20d8f
jmp 0x20e34
movq -0x40(%rbp), %rdx
leaq -0x58(%rbp), %rdi
leaq -0x18(%rbp), %rsi
callq 0x1d2a0
jmp 0x20da2
movq -0x68(%rbp), %rdi
leaq -0x58(%rbp), %rsi
callq 0x22530
jmp 0x20db1
leaq -0x58(%rbp), %rdi
callq 0xcdc0
jmp 0x20e34
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x28(%rbp)
movl %eax, -0x2c(%rbp)
jmp 0x20e8b
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x28(%rbp)
movl %eax, -0x2c(%rbp)
jmp 0x20e82
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x28(%rbp)
movl %eax, -0x2c(%rbp)
jmp 0x20e79
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x28(%rbp)
movl %eax, -0x2c(%rbp)
jmp 0x20e12
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x28(%rbp)
movl %eax, -0x2c(%rbp)
leaq -0x48(%rbp), %rdi
callq 0xcdc0
leaq -0x50(%rbp), %rdi
callq 0xcdc0
jmp 0x20e79
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x28(%rbp)
movl %eax, -0x2c(%rbp)
leaq -0x58(%rbp), %rdi
callq 0xcdc0
jmp 0x20e79
jmp 0x20e36
movq -0x40(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x40(%rbp)
jmp 0x20d2f
movb $0x1, -0x2d(%rbp)
testb $0x1, -0x2d(%rbp)
jne 0x20e5a
movq -0x68(%rbp), %rdi
callq 0xcdc0
leaq -0x20(%rbp), %rdi
callq 0xcdc0
leaq -0x18(%rbp), %rdi
callq 0xcdc0
movq -0x60(%rbp), %rax
addq $0x80, %rsp
popq %rbp
retq
movq -0x68(%rbp), %rdi
callq 0xcdc0
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/PSLlib.h
// Function: PSL::variable::PSLlib::Reduce(PSL::variable&)
static variable Reduce(variable &v)
	{
		variable l = v[0];
		variable f = v[1];
		size_t size = l.length();
		if (!size)
			return v;
		variable a = l[0];
		for (size_t i = 1; i < size; ++i)
			a = f(a, l[i]);
		return a;
	}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x70, %rsp
movq %rdi, -0x68(%rbp)
movq %rdi, %rax
movq %rax, -0x60(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x10(%rbp), %rsi
leaq -0x18(%rbp), %rdi
xorl %edx, %edx
callq 0x22460
movq -0x10(%rbp), %rsi
leaq -0x20(%rbp), %rdi
movl $0x1, %edx
callq 0x22460
jmp 0x20ede
leaq -0x18(%rbp), %rdi
callq 0x1d280
movq %rax, -0x70(%rbp)
jmp 0x20eed
movq -0x70(%rbp), %rax
movq %rax, -0x38(%rbp)
cmpq $0x0, -0x38(%rbp)
jne 0x20f39
movq -0x68(%rbp), %rdi
movq -0x10(%rbp), %rsi
callq 0x1d4f0
jmp 0x20f0b
movl $0x1, -0x3c(%rbp)
jmp 0x21020
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x28(%rbp)
movl %eax, -0x2c(%rbp)
jmp 0x21045
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x28(%rbp)
movl %eax, -0x2c(%rbp)
jmp 0x2103c
movq -0x68(%rbp), %rdi
movb $0x0, -0x3d(%rbp)
leaq -0x18(%rbp), %rsi
xorl %edx, %edx
callq 0x22460
jmp 0x20f4e
movq $0x1, -0x48(%rbp)
movq -0x48(%rbp), %rax
cmpq -0x38(%rbp), %rax
jae 0x20ff9
movq -0x48(%rbp), %rdx
leaq -0x58(%rbp), %rdi
leaq -0x18(%rbp), %rsi
callq 0x1d2a0
jmp 0x20f77
movq -0x68(%rbp), %rdx
leaq -0x50(%rbp), %rdi
leaq -0x20(%rbp), %rsi
leaq -0x58(%rbp), %rcx
callq 0x22690
jmp 0x20f8e
movq -0x68(%rbp), %rdi
leaq -0x50(%rbp), %rsi
callq 0x1d200
jmp 0x20f9d
leaq -0x50(%rbp), %rdi
callq 0xcdc0
leaq -0x58(%rbp), %rdi
callq 0xcdc0
movq -0x48(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x48(%rbp)
jmp 0x20f56
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x28(%rbp)
movl %eax, -0x2c(%rbp)
jmp 0x21015
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x28(%rbp)
movl %eax, -0x2c(%rbp)
jmp 0x20fee
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x28(%rbp)
movl %eax, -0x2c(%rbp)
leaq -0x50(%rbp), %rdi
callq 0xcdc0
leaq -0x58(%rbp), %rdi
callq 0xcdc0
jmp 0x21015
movb $0x1, -0x3d(%rbp)
movl $0x1, -0x3c(%rbp)
testb $0x1, -0x3d(%rbp)
jne 0x21013
movq -0x68(%rbp), %rdi
callq 0xcdc0
jmp 0x21020
movq -0x68(%rbp), %rdi
callq 0xcdc0
jmp 0x2103c
leaq -0x20(%rbp), %rdi
callq 0xcdc0
leaq -0x18(%rbp), %rdi
callq 0xcdc0
movq -0x60(%rbp), %rax
addq $0x70, %rsp
popq %rbp
retq
leaq -0x20(%rbp), %rdi
callq 0xcdc0
leaq -0x18(%rbp), %rdi
callq 0xcdc0
movq -0x28(%rbp), %rdi
callq 0xc280
nopw (%rax,%rax)
// File: Silica[P]PSL/./PSL/PSLlib.h
// Function: PSL::variable::PSLlib::Eval(PSL::variable&)
static variable Eval(variable &v)
	{
		string s = v;
		variable g;
		s += ";";
		Tokenizer t(s.c_str(), "eval", 0);
		Parser p(&t);
		p.Parse(g);
		if (p.getErrorNum())
			return variable();
		return g;
	}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0xf0, %rsp
movq %rdi, -0xd8(%rbp)
movq %rdi, %rax
movq %rax, -0xd0(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x10(%rbp), %rsi
leaq -0x18(%rbp), %rdi
callq 0x1d2f0
leaq -0x20(%rbp), %rdi
callq 0x1a130
jmp 0x2113c
leaq 0x1d853(%rip), %rsi     # 0x3e996
leaq -0x18(%rbp), %rdi
callq 0xca80
jmp 0x2114e
leaq -0x18(%rbp), %rdi
callq 0xce20
movq %rax, -0xe0(%rbp)
jmp 0x21160
movq -0xe0(%rbp), %rsi
leaq -0xa8(%rbp), %rdi
callq 0xc8b0
jmp 0x21175
leaq 0x1d7da(%rip), %rsi     # 0x3e956
leaq -0xb0(%rbp), %rdi
callq 0xc8b0
jmp 0x2118a
xorl %ecx, %ecx
movl %ecx, %r8d
leaq -0xa0(%rbp), %rdi
leaq -0xa8(%rbp), %rsi
leaq -0xb0(%rbp), %rdx
callq 0x22ce0
jmp 0x211ab
leaq -0xb0(%rbp), %rdi
callq 0xc950
leaq -0xa8(%rbp), %rdi
callq 0xc950
leaq -0xc0(%rbp), %rdi
leaq -0xa0(%rbp), %rsi
callq 0x22de0
jmp 0x211d8
leaq -0xc0(%rbp), %rdi
leaq -0x20(%rbp), %rsi
callq 0x22e00
jmp 0x211ea
leaq -0xc0(%rbp), %rdi
callq 0x22f90
movl %eax, -0xe4(%rbp)
jmp 0x211fe
movl -0xe4(%rbp), %eax
cmpl $0x0, %eax
je 0x2129a
movq -0xd8(%rbp), %rdi
callq 0x1a130
jmp 0x2121b
movl $0x1, -0xc4(%rbp)
jmp 0x212b6
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x28(%rbp)
movl %eax, -0x2c(%rbp)
jmp 0x212ed
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x28(%rbp)
movl %eax, -0x2c(%rbp)
jmp 0x212e4
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x28(%rbp)
movl %eax, -0x2c(%rbp)
jmp 0x21272
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x28(%rbp)
movl %eax, -0x2c(%rbp)
leaq -0xb0(%rbp), %rdi
callq 0xc950
leaq -0xa8(%rbp), %rdi
callq 0xc950
jmp 0x212e4
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x28(%rbp)
movl %eax, -0x2c(%rbp)
leaq -0xa0(%rbp), %rdi
callq 0x22fb0
jmp 0x212e4
movq -0xd8(%rbp), %rdi
leaq -0x20(%rbp), %rsi
callq 0x1d4f0
jmp 0x212ac
movl $0x1, -0xc4(%rbp)
leaq -0xa0(%rbp), %rdi
callq 0x22fb0
leaq -0x20(%rbp), %rdi
callq 0xcdc0
leaq -0x18(%rbp), %rdi
callq 0xc950
movq -0xd0(%rbp), %rax
addq $0xf0, %rsp
popq %rbp
retq
leaq -0x20(%rbp), %rdi
callq 0xcdc0
leaq -0x18(%rbp), %rdi
callq 0xc950
movq -0x28(%rbp), %rdi
callq 0xc280
nop
// File: Silica[P]PSL/./PSL/PSLlib.h
// Function: PSL::variable::PSLlib::Array::set(PSL::variable::rsv const&)
static void set(const rsv &r)
		{
			variable v = r;
			v["length"] = variable(Length);
			v["push"] = variable(Push);
			v["foreach"] = variable(Foreach);
			v["join"] = variable(Join);
		}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x60, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rsi
leaq -0x10(%rbp), %rdi
callq 0xcd50
leaq 0x151d0(%rip), %rsi     # 0x36810
leaq -0x18(%rbp), %rdi
callq 0x36880
jmp 0x2164b
leaq 0x1d6d3(%rip), %rdx     # 0x3ed25
leaq -0x30(%rbp), %rdi
leaq -0x10(%rbp), %rsi
callq 0x1f930
jmp 0x21661
leaq -0x30(%rbp), %rdi
leaq -0x18(%rbp), %rsi
callq 0x1d200
jmp 0x21670
leaq -0x30(%rbp), %rdi
callq 0xcdc0
leaq -0x18(%rbp), %rdi
callq 0xcdc0
leaq 0x15267(%rip), %rsi     # 0x368f0
leaq -0x38(%rbp), %rdi
callq 0x36880
jmp 0x21694
leaq 0x1d6b1(%rip), %rdx     # 0x3ed4c
leaq -0x40(%rbp), %rdi
leaq -0x10(%rbp), %rsi
callq 0x1f930
jmp 0x216aa
leaq -0x40(%rbp), %rdi
leaq -0x38(%rbp), %rsi
callq 0x1d200
jmp 0x216b9
leaq -0x40(%rbp), %rdi
callq 0xcdc0
leaq -0x38(%rbp), %rdi
callq 0xcdc0
leaq 0x1534e(%rip), %rsi     # 0x36a20
leaq -0x48(%rbp), %rdi
callq 0x36880
jmp 0x216dd
leaq 0x1d254(%rip), %rdx     # 0x3e938
leaq -0x50(%rbp), %rdi
leaq -0x10(%rbp), %rsi
callq 0x1f930
jmp 0x216f3
leaq -0x50(%rbp), %rdi
leaq -0x48(%rbp), %rsi
callq 0x1d200
jmp 0x21702
leaq -0x50(%rbp), %rdi
callq 0xcdc0
leaq -0x48(%rbp), %rdi
callq 0xcdc0
leaq 0x15505(%rip), %rsi     # 0x36c20
leaq -0x58(%rbp), %rdi
callq 0x36880
jmp 0x21726
leaq 0x1d624(%rip), %rdx     # 0x3ed51
leaq -0x60(%rbp), %rdi
leaq -0x10(%rbp), %rsi
callq 0x1f930
jmp 0x2173c
leaq -0x60(%rbp), %rdi
leaq -0x58(%rbp), %rsi
callq 0x1d200
jmp 0x2174b
leaq -0x60(%rbp), %rdi
callq 0xcdc0
leaq -0x58(%rbp), %rdi
callq 0xcdc0
leaq -0x10(%rbp), %rdi
callq 0xcdc0
addq $0x60, %rsp
popq %rbp
retq
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x20(%rbp)
movl %eax, -0x24(%rbp)
jmp 0x21836
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x20(%rbp)
movl %eax, -0x24(%rbp)
jmp 0x217a0
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x20(%rbp)
movl %eax, -0x24(%rbp)
leaq -0x30(%rbp), %rdi
callq 0xcdc0
leaq -0x18(%rbp), %rdi
callq 0xcdc0
jmp 0x21836
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x20(%rbp)
movl %eax, -0x24(%rbp)
jmp 0x217d1
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x20(%rbp)
movl %eax, -0x24(%rbp)
leaq -0x40(%rbp), %rdi
callq 0xcdc0
leaq -0x38(%rbp), %rdi
callq 0xcdc0
jmp 0x21836
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x20(%rbp)
movl %eax, -0x24(%rbp)
jmp 0x217ff
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x20(%rbp)
movl %eax, -0x24(%rbp)
leaq -0x50(%rbp), %rdi
callq 0xcdc0
leaq -0x48(%rbp), %rdi
callq 0xcdc0
jmp 0x21836
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x20(%rbp)
movl %eax, -0x24(%rbp)
jmp 0x2182d
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x20(%rbp)
movl %eax, -0x24(%rbp)
leaq -0x60(%rbp), %rdi
callq 0xcdc0
leaq -0x58(%rbp), %rdi
callq 0xcdc0
leaq -0x10(%rbp), %rdi
callq 0xcdc0
movq -0x20(%rbp), %rdi
callq 0xc280
nopl (%rax,%rax)
// File: Silica[P]PSL/./PSL/PSLlib.h
// Function: PSL::variable::PSLlib::File::set(PSL::variable::rsv const&)
static void set(const rsv &r)
		{
			variable v = r;
			variable fc = Close;
			v["open"] = variable(Open);
			v["close"] = fc;
			v["destructor"] = fc;
			v["read"] = variable(Read);
		}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x60, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rsi
leaq -0x10(%rbp), %rdi
callq 0xcd50
leaq 0x167a0(%rip), %rsi     # 0x382c0
leaq -0x18(%rbp), %rdi
callq 0x36880
jmp 0x21b2b
leaq 0x168ce(%rip), %rsi     # 0x38400
leaq -0x30(%rbp), %rdi
callq 0x36880
jmp 0x21b3d
leaq 0x1d22e(%rip), %rdx     # 0x3ed72
leaq -0x38(%rbp), %rdi
leaq -0x10(%rbp), %rsi
callq 0x1f930
jmp 0x21b53
leaq -0x38(%rbp), %rdi
leaq -0x30(%rbp), %rsi
callq 0x1d200
jmp 0x21b62
leaq -0x38(%rbp), %rdi
callq 0xcdc0
leaq -0x30(%rbp), %rdi
callq 0xcdc0
leaq 0x1d1fc(%rip), %rdx     # 0x3ed77
leaq -0x40(%rbp), %rdi
leaq -0x10(%rbp), %rsi
callq 0x1f930
jmp 0x21b8a
leaq -0x40(%rbp), %rdi
leaq -0x18(%rbp), %rsi
callq 0x1d200
jmp 0x21b99
leaq -0x40(%rbp), %rdi
callq 0xcdc0
leaq 0x1cb34(%rip), %rdx     # 0x3e6dd
leaq -0x48(%rbp), %rdi
leaq -0x10(%rbp), %rsi
callq 0x1f930
jmp 0x21bb8
leaq -0x48(%rbp), %rdi
leaq -0x18(%rbp), %rsi
callq 0x1d200
jmp 0x21bc7
leaq -0x48(%rbp), %rdi
callq 0xcdc0
leaq 0x16d19(%rip), %rsi     # 0x388f0
leaq -0x50(%rbp), %rdi
callq 0x36880
jmp 0x21be2
leaq 0x1cc7e(%rip), %rdx     # 0x3e867
leaq -0x58(%rbp), %rdi
leaq -0x10(%rbp), %rsi
callq 0x1f930
jmp 0x21bf8
leaq -0x58(%rbp), %rdi
leaq -0x50(%rbp), %rsi
callq 0x1d200
jmp 0x21c07
leaq -0x58(%rbp), %rdi
callq 0xcdc0
leaq -0x50(%rbp), %rdi
callq 0xcdc0
leaq -0x18(%rbp), %rdi
callq 0xcdc0
leaq -0x10(%rbp), %rdi
callq 0xcdc0
addq $0x60, %rsp
popq %rbp
retq
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x20(%rbp)
movl %eax, -0x24(%rbp)
jmp 0x21ce4
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x20(%rbp)
movl %eax, -0x24(%rbp)
jmp 0x21cdb
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x20(%rbp)
movl %eax, -0x24(%rbp)
jmp 0x21c76
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x20(%rbp)
movl %eax, -0x24(%rbp)
leaq -0x38(%rbp), %rdi
callq 0xcdc0
leaq -0x30(%rbp), %rdi
callq 0xcdc0
jmp 0x21cdb
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x20(%rbp)
movl %eax, -0x24(%rbp)
leaq -0x40(%rbp), %rdi
callq 0xcdc0
jmp 0x21cdb
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x20(%rbp)
movl %eax, -0x24(%rbp)
leaq -0x48(%rbp), %rdi
callq 0xcdc0
jmp 0x21cdb
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x20(%rbp)
movl %eax, -0x24(%rbp)
jmp 0x21cd2
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x20(%rbp)
movl %eax, -0x24(%rbp)
leaq -0x58(%rbp), %rdi
callq 0xcdc0
leaq -0x50(%rbp), %rdi
callq 0xcdc0
leaq -0x18(%rbp), %rdi
callq 0xcdc0
leaq -0x10(%rbp), %rdi
callq 0xcdc0
movq -0x20(%rbp), %rdi
callq 0xc280
nopw %cs:(%rax,%rax)
// File: Silica[P]PSL/./PSL/PSLlib.h
// Function: PSL::variable::PSLlib::Time::set(PSL::variable::rsv const&)
static void set(const rsv &r)
		{
			variable v = r;
			v["time"] = time;
			v["clock"] = Clock;
			v["CLOCKS_PER_SEC"] = CLOCKS_PER_SEC;
		}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rsi
leaq -0x10(%rbp), %rdi
movq %rdi, -0x40(%rbp)
callq 0xcd50
movq -0x40(%rbp), %rsi
leaq 0x1c9f4(%rip), %rdx     # 0x3e98c
leaq -0x18(%rbp), %rdi
callq 0x1f930
jmp 0x21fa3
leaq 0x17c46(%rip), %rsi     # 0x39bf0
leaq -0x18(%rbp), %rdi
callq 0x1fbc0
jmp 0x21fb5
leaq -0x18(%rbp), %rdi
callq 0xcdc0
leaq 0x1cde7(%rip), %rdx     # 0x3edac
leaq -0x30(%rbp), %rdi
leaq -0x10(%rbp), %rsi
callq 0x1f930
jmp 0x21fd4
leaq 0x17c55(%rip), %rsi     # 0x39c30
leaq -0x30(%rbp), %rdi
callq 0x1fbc0
jmp 0x21fe6
leaq -0x30(%rbp), %rdi
callq 0xcdc0
leaq 0x1cdbc(%rip), %rdx     # 0x3edb2
leaq -0x38(%rbp), %rdi
leaq -0x10(%rbp), %rsi
callq 0x1f930
jmp 0x22005
leaq -0x38(%rbp), %rdi
movl $0xf4240, %esi          # imm = 0xF4240
callq 0x39c70
jmp 0x22015
leaq -0x38(%rbp), %rdi
callq 0xcdc0
leaq -0x10(%rbp), %rdi
callq 0xcdc0
addq $0x40, %rsp
popq %rbp
retq
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x20(%rbp)
movl %eax, -0x24(%rbp)
jmp 0x2207e
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x20(%rbp)
movl %eax, -0x24(%rbp)
leaq -0x18(%rbp), %rdi
callq 0xcdc0
jmp 0x2207e
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x20(%rbp)
movl %eax, -0x24(%rbp)
leaq -0x30(%rbp), %rdi
callq 0xcdc0
jmp 0x2207e
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x20(%rbp)
movl %eax, -0x24(%rbp)
leaq -0x38(%rbp), %rdi
callq 0xcdc0
leaq -0x10(%rbp), %rdi
callq 0xcdc0
movq -0x20(%rbp), %rdi
callq 0xc280
// File: Silica[P]PSL/./PSL/parser.h
// Function: PSL::variable::Parser::Parse(PSL::variable&)
void Parse(variable &v)
	{
		string arg = "arg";
		v.pushcode(new Variable::PUSH_NULL);
		v.pushcode(new Variable::LOCAL(arg));
		v.pushcode(new Variable::ARGUMENT);
		while (t->checkNext())
			ParseStatement(v, v);
		if (error)
			PSL_PRINTF(("%d error in compile %s\n", error, t->getFile().c_str()));
//			PSL_PRINTF(("%d error%s in compile %s\n", error, error == 1 ? "" : "s", t->getFile().c_str()));
	}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x80, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x40(%rbp)
leaq 0x1bb76(%rip), %rsi     # 0x3e998
leaq -0x18(%rbp), %rdi
callq 0xc8b0
movq -0x10(%rbp), %rax
movq %rax, -0x38(%rbp)
movl $0x8, %edi
callq 0x1ee10
movq %rax, -0x30(%rbp)
jmp 0x22e43
movq -0x30(%rbp), %rdi
callq 0x23180
movq -0x38(%rbp), %rdi
movq -0x30(%rbp), %rsi
callq 0x23150
jmp 0x22e5b
movq -0x10(%rbp), %rax
movq %rax, -0x50(%rbp)
movl $0x10, %edi
callq 0x231c0
movq %rax, -0x48(%rbp)
jmp 0x22e73
movq -0x48(%rbp), %rdi
leaq -0x18(%rbp), %rsi
callq 0x231e0
jmp 0x22e82
movq -0x48(%rbp), %rsi
movq -0x50(%rbp), %rdi
callq 0x23150
jmp 0x22e91
movq -0x10(%rbp), %rax
movq %rax, -0x60(%rbp)
movl $0x8, %edi
callq 0x1ee10
movq %rax, -0x58(%rbp)
jmp 0x22ea9
movq -0x58(%rbp), %rdi
callq 0x232a0
movq -0x60(%rbp), %rdi
movq -0x58(%rbp), %rsi
callq 0x23150
jmp 0x22ec1
jmp 0x22ec3
movq -0x40(%rbp), %rax
movq (%rax), %rdi
callq 0x232e0
movl %eax, -0x64(%rbp)
jmp 0x22ed4
movl -0x64(%rbp), %eax
cmpl $0x0, %eax
je 0x22f15
movq -0x40(%rbp), %rdi
movq -0x10(%rbp), %rdx
movq %rdx, %rsi
callq 0x23330
jmp 0x22eee
jmp 0x22ec3
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x20(%rbp)
movl %eax, -0x24(%rbp)
jmp 0x22f71
movq -0x48(%rbp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x20(%rbp)
movl %eax, -0x24(%rbp)
callq 0x23270
jmp 0x22f71
movq -0x40(%rbp), %rax
cmpl $0x0, 0x8(%rax)
je 0x22f5f
movq -0x40(%rbp), %rax
movl 0x8(%rax), %ecx
movl %ecx, -0x74(%rbp)
movq (%rax), %rdi
callq 0x23f40
movq %rax, -0x70(%rbp)
jmp 0x22f37
movq -0x70(%rbp), %rdi
callq 0xce20
movq %rax, -0x80(%rbp)
jmp 0x22f46
movq -0x80(%rbp), %rdx
movl -0x74(%rbp), %esi
leaq 0x1ba48(%rip), %rdi     # 0x3e99c
xorl %eax, %eax
callq 0xc050
jmp 0x22f5d
jmp 0x22f5f
leaq -0x18(%rbp), %rdi
callq 0xc950
addq $0x80, %rsp
popq %rbp
retq
leaq -0x18(%rbp), %rdi
callq 0xc950
movq -0x20(%rbp), %rdi
callq 0xc280
nopw %cs:(%rax,%rax)
nopl (%rax)
// File: Silica[P]PSL/./PSL/tokenizer.h
// Function: PSL::variable::Tokenizer::~Tokenizer()
~Tokenizer()
	{
		delete including;
#ifdef PSL_USE_TOKENIZER_DEFINE
		if (dlnew)
			delete definelist;
#endif
	}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x18(%rbp)
movq 0x40(%rax), %rax
movq %rax, -0x10(%rbp)
cmpq $0x0, %rax
je 0x22fe9
movq -0x10(%rbp), %rdi
callq 0x22fb0
movq -0x10(%rbp), %rdi
movl $0x70, %esi
callq 0xc1e0
movq -0x18(%rbp), %rax
testb $0x1, 0x50(%rax)
je 0x2301e
movq -0x18(%rbp), %rax
movq 0x48(%rax), %rax
movq %rax, -0x20(%rbp)
cmpq $0x0, %rax
je 0x2301c
movq -0x20(%rbp), %rdi
callq 0x1a4e0
movq -0x20(%rbp), %rdi
movl $0x18, %esi
callq 0xc1e0
jmp 0x2301e
movq -0x18(%rbp), %rdi
addq $0x68, %rdi
callq 0xc950
movq -0x18(%rbp), %rdi
addq $0x10, %rdi
callq 0xc950
movq -0x18(%rbp), %rdi
callq 0xc950
addq $0x20, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: Silica[P]PSL/./PSL/tokenizer.h
// Function: PSL::variable::Tokenizer::Init(PSL::variable::string const&, int, PSL::variable::table*)
void Init(const string &fn, int l, table *dl)
	{
		prev = i = 0;
		next = UNSET;
		filename = fn;
		line = pline = l;
		including = NULL;
#ifdef PSL_USE_TOKENIZER_DEFINE
		if (dl)
		{
			definelist = dl;
			dlnew = false;
		}
		else
		{
			definelist = new table();
			dlnew = true;
		}
		ifdefcount = ifdefstatus = 0;
#endif
	}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl %edx, -0x14(%rbp)
movq %rcx, -0x20(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x38(%rbp)
movq $0x0, 0x28(%rdi)
movq $0x0, 0x30(%rdi)
movl $0xffffffff, 0x38(%rdi) # imm = 0xFFFFFFFF
movq -0x10(%rbp), %rsi
callq 0x120b0
movq -0x38(%rbp), %rax
movl -0x14(%rbp), %ecx
movl %ecx, 0xc(%rax)
movl %ecx, 0x8(%rax)
movq $0x0, 0x40(%rax)
cmpq $0x0, -0x20(%rbp)
je 0x230dd
movq -0x38(%rbp), %rax
movq -0x20(%rbp), %rcx
movq %rcx, 0x48(%rax)
movb $0x0, 0x50(%rax)
jmp 0x23126
movl $0x18, %edi
callq 0xc1d0
movq %rax, %rdi
movq %rdi, %rax
movq %rax, -0x40(%rbp)
callq 0xf290
jmp 0x230f8
movq -0x38(%rbp), %rax
movq -0x40(%rbp), %rcx
movq %rcx, 0x48(%rax)
movb $0x1, 0x50(%rax)
jmp 0x23126
movq -0x40(%rbp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x28(%rbp)
movl %eax, -0x2c(%rbp)
movl $0x18, %esi
callq 0xc1e0
jmp 0x2313e
movq -0x38(%rbp), %rax
movl $0x0, 0x58(%rax)
movl $0x0, 0x54(%rax)
addq $0x40, %rsp
popq %rbp
retq
movq -0x28(%rbp), %rdi
callq 0xc280
nopw (%rax,%rax)
// File: 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 %rbp
movq %rsp, %rbp
subq $0x60, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x10(%rbp), %rsi
leaq -0x20(%rbp), %rdi
movq %rdi, -0x50(%rbp)
callq 0x11950
movq -0x50(%rbp), %rsi
leaq -0x18(%rbp), %rdi
callq 0xcd50
jmp 0x24390
leaq -0x20(%rbp), %rdi
callq 0xcd90
movq -0x10(%rbp), %rsi
leaq -0x40(%rbp), %rdi
callq 0x11950
jmp 0x243a8
leaq -0x38(%rbp), %rdi
leaq -0x40(%rbp), %rsi
callq 0xcd50
jmp 0x243b7
leaq -0x40(%rbp), %rdi
callq 0xcd90
movq -0x10(%rbp), %rax
movq %rax, -0x60(%rbp)
leaq -0x18(%rbp), %rdi
leaq -0x38(%rbp), %rsi
callq 0x11ad0
movq %rax, -0x58(%rbp)
jmp 0x243db
movq -0x58(%rbp), %rsi
leaq -0x48(%rbp), %rdi
callq 0x11b10
jmp 0x243ea
movq -0x60(%rbp), %rdi
leaq -0x48(%rbp), %rsi
callq 0x11aa0
jmp 0x243f9
leaq -0x48(%rbp), %rdi
callq 0xcd90
leaq -0x38(%rbp), %rdi
callq 0xcdc0
leaq -0x18(%rbp), %rdi
callq 0xcdc0
xorl %eax, %eax
addq $0x60, %rsp
popq %rbp
retq
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x28(%rbp)
movl %eax, -0x2c(%rbp)
leaq -0x20(%rbp), %rdi
callq 0xcd90
jmp 0x2448d
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x28(%rbp)
movl %eax, -0x2c(%rbp)
jmp 0x24484
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x28(%rbp)
movl %eax, -0x2c(%rbp)
leaq -0x40(%rbp), %rdi
callq 0xcd90
jmp 0x24484
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x28(%rbp)
movl %eax, -0x2c(%rbp)
jmp 0x2447b
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x28(%rbp)
movl %eax, -0x2c(%rbp)
leaq -0x48(%rbp), %rdi
callq 0xcd90
leaq -0x38(%rbp), %rdi
callq 0xcdc0
leaq -0x18(%rbp), %rdi
callq 0xcdc0
movq -0x28(%rbp), %rdi
callq 0xc280
nopw %cs:(%rax,%rax)
// File: 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 %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x18(%rbp)
movl 0x8(%rax), %eax
movl %eax, -0xc(%rbp)
movq -0x18(%rbp), %rcx
movq 0x28(%rcx), %rax
movq 0x20(%rcx), %rcx
subq $0x1, %rcx
cmpq %rcx, %rax
jae 0x2538e
movq -0x18(%rbp), %rcx
movq 0x18(%rcx), %rax
movq 0x28(%rcx), %rcx
movsbl (%rax,%rcx), %eax
cmpl $0xa, %eax
jne 0x252e6
movq -0x18(%rbp), %rdi
callq 0x25210
jmp 0x25379
movq -0x18(%rbp), %rcx
movq 0x18(%rcx), %rax
movq 0x28(%rcx), %rcx
movsbl (%rax,%rcx), %eax
cmpl $0xd, %eax
jne 0x2533a
movq -0x18(%rbp), %rdi
callq 0x25210
movq -0x18(%rbp), %rcx
movq 0x28(%rcx), %rax
cmpq 0x20(%rcx), %rax
jae 0x25338
movq -0x18(%rbp), %rcx
movq 0x18(%rcx), %rax
movq 0x28(%rcx), %rcx
movsbl 0x1(%rax,%rcx), %eax
cmpl $0xa, %eax
jne 0x25338
movq -0x18(%rbp), %rax
movq 0x28(%rax), %rcx
addq $0x1, %rcx
movq %rcx, 0x28(%rax)
jmp 0x25379
movq -0x18(%rbp), %rcx
movq 0x18(%rcx), %rax
movq 0x28(%rcx), %rcx
movsbl (%rax,%rcx), %eax
cmpl $0x2a, %eax
jne 0x25377
movq -0x18(%rbp), %rcx
movq 0x18(%rcx), %rax
movq 0x28(%rcx), %rcx
movsbl 0x1(%rax,%rcx), %eax
cmpl $0x2f, %eax
jne 0x25377
movq -0x18(%rbp), %rax
movq 0x28(%rax), %rcx
addq $0x2, %rcx
movq %rcx, 0x28(%rax)
jmp 0x253c2
jmp 0x25379
movq -0x18(%rbp), %rax
movq 0x28(%rax), %rcx
addq $0x1, %rcx
movq %rcx, 0x28(%rax)
jmp 0x252aa
movq -0x18(%rbp), %rdi
callq 0xce20
movq %rax, %rsi
movq -0x18(%rbp), %rax
movl 0x8(%rax), %edx
movl -0xc(%rbp), %ecx
leaq 0x19639(%rip), %rdi     # 0x3e9e4
movb $0x0, %al
callq 0xc050
movq -0x18(%rbp), %rax
movq 0x28(%rax), %rcx
addq $0x1, %rcx
movq %rcx, 0x28(%rax)
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: 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
movq %rsp, %rbp
subq $0x90, %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 -0x18(%rbp), %rdi
callq 0x26840
testb $0x1, %al
jne 0x26329
jmp 0x2633b
movq -0x40(%rbp), %rsi
movq -0x50(%rbp), %rdi
callq 0x15ea0
jmp 0x26480
movq -0x40(%rbp), %rax
cmpq $0x0, (%rax)
jne 0x26390
movl $0x20, %edi
callq 0x13750
movq %rax, %rdi
movq %rdi, %rax
movq %rax, -0x58(%rbp)
movq -0x18(%rbp), %rsi
callq 0x26870
jmp 0x26364
movq -0x58(%rbp), %rsi
movq -0x50(%rbp), %rdi
callq 0x26f80
jmp 0x26480
movq -0x58(%rbp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x20(%rbp)
movl %eax, -0x24(%rbp)
callq 0x12250
jmp 0x2648d
movq -0x18(%rbp), %rdi
callq 0xc0c0
movq %rax, -0x30(%rbp)
movl $0x20, %edi
callq 0x13750
movq %rax, %rcx
movq -0x40(%rbp), %rax
movq %rcx, -0x60(%rbp)
movq %rcx, -0x68(%rbp)
movq (%rax), %rdi
callq 0x152c0
movq -0x60(%rbp), %rdi
movq %rax, %rsi
movq -0x30(%rbp), %rax
addq %rax, %rsi
callq 0x13770
jmp 0x263d3
movq -0x40(%rbp), %rax
movq -0x68(%rbp), %rcx
movq %rcx, -0x38(%rbp)
movq -0x38(%rbp), %rcx
movq %rcx, -0x90(%rbp)
movq (%rax), %rdi
callq 0x13b70
movq %rax, %rcx
movq -0x40(%rbp), %rax
movq %rcx, -0x88(%rbp)
movq (%rax), %rdi
callq 0x152c0
movq -0x90(%rbp), %rdi
movq -0x88(%rbp), %rsi
movq %rax, %rdx
xorl %eax, %eax
movl %eax, %ecx
callq 0x15350
movq -0x40(%rbp), %rax
movq -0x38(%rbp), %rcx
movq %rcx, -0x80(%rbp)
movq -0x18(%rbp), %rcx
movq %rcx, -0x78(%rbp)
movq -0x30(%rbp), %rcx
movq %rcx, -0x70(%rbp)
movq (%rax), %rdi
callq 0x152c0
movq -0x80(%rbp), %rdi
movq -0x78(%rbp), %rsi
movq -0x70(%rbp), %rdx
movq %rax, %rcx
callq 0x15350
movq -0x50(%rbp), %rdi
movq -0x38(%rbp), %rsi
callq 0x26f80
jmp 0x26480
movq -0x68(%rbp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x20(%rbp)
movl %eax, -0x24(%rbp)
callq 0x12250
jmp 0x2648d
movq -0x48(%rbp), %rax
addq $0x90, %rsp
popq %rbp
retq
movq -0x20(%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
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
movq %rsp, %rbp
subq $0x90, %rsp
movq %rdi, -0x48(%rbp)
movq %rdi, %rax
movq %rax, -0x40(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x38(%rbp)
cmpq $0x0, (%rax)
jne 0x264e2
movq -0x48(%rbp), %rdi
movq -0x18(%rbp), %rsi
callq 0x15ea0
jmp 0x265fb
movq -0x18(%rbp), %rax
cmpq $0x0, (%rax)
jne 0x264fe
movq -0x38(%rbp), %rsi
movq -0x48(%rbp), %rdi
callq 0x15ea0
jmp 0x265fb
movl $0x20, %edi
callq 0x13750
movq %rax, %rcx
movq -0x38(%rbp), %rax
movq %rcx, -0x50(%rbp)
movq %rcx, -0x60(%rbp)
movq (%rax), %rdi
callq 0x152c0
movq %rax, -0x58(%rbp)
movq -0x18(%rbp), %rax
movq (%rax), %rdi
callq 0x152c0
movq -0x58(%rbp), %rsi
movq -0x50(%rbp), %rdi
addq %rax, %rsi
callq 0x13770
jmp 0x26541
movq -0x38(%rbp), %rax
movq -0x60(%rbp), %rcx
movq %rcx, -0x20(%rbp)
movq -0x20(%rbp), %rcx
movq %rcx, -0x88(%rbp)
movq (%rax), %rdi
callq 0x13b70
movq %rax, %rcx
movq -0x38(%rbp), %rax
movq %rcx, -0x80(%rbp)
movq (%rax), %rdi
callq 0x152c0
movq -0x88(%rbp), %rdi
movq -0x80(%rbp), %rsi
movq %rax, %rdx
xorl %eax, %eax
movl %eax, %ecx
callq 0x15350
movq -0x20(%rbp), %rax
movq %rax, -0x78(%rbp)
movq -0x18(%rbp), %rax
movq (%rax), %rdi
callq 0x13b70
movq %rax, -0x70(%rbp)
movq -0x18(%rbp), %rax
movq (%rax), %rdi
callq 0x152c0
movq %rax, %rcx
movq -0x38(%rbp), %rax
movq %rcx, -0x68(%rbp)
movq (%rax), %rdi
callq 0x152c0
movq -0x78(%rbp), %rdi
movq -0x70(%rbp), %rsi
movq -0x68(%rbp), %rdx
movq %rax, %rcx
callq 0x15350
movq -0x48(%rbp), %rdi
movq -0x20(%rbp), %rsi
callq 0x26f80
jmp 0x265fb
movq -0x60(%rbp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x28(%rbp)
movl %eax, -0x2c(%rbp)
callq 0x12250
jmp 0x26608
movq -0x40(%rbp), %rax
addq $0x90, %rsp
popq %rbp
retq
movq -0x28(%rbp), %rdi
callq 0xc280
nopw %cs:(%rax,%rax)
nopl (%rax,%rax)
// File: Silica[P]PSL/./PSL/tokenizer.h
// Function: PSL::variable::Tokenizer::getNext()
int getNext()
	{
		if (next > 0)
		{
			int n = next;
			next = UNSET;
			return n;
		}
		if (next < 0)
			return doNext();
		return 0;
	}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x20(%rbp)
cmpl $0x0, 0x38(%rax)
jle 0x26653
movq -0x20(%rbp), %rax
movl 0x38(%rax), %ecx
movl %ecx, -0x14(%rbp)
movl $0xffffffff, 0x38(%rax) # imm = 0xFFFFFFFF
movl -0x14(%rbp), %eax
movl %eax, -0x4(%rbp)
jmp 0x26672
movq -0x20(%rbp), %rax
cmpl $0x0, 0x38(%rax)
jge 0x2666b
movq -0x20(%rbp), %rdi
callq 0x24500
movl %eax, -0x4(%rbp)
jmp 0x26672
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: 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 %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x30(%rbp)
cmpq $0x0, (%rax)
jne 0x266f6
movq -0x10(%rbp), %rdi
callq 0x26840
testb $0x1, %al
jne 0x266f1
movl $0x20, %edi
callq 0x13750
movq %rax, %rdi
movq %rdi, %rax
movq %rax, -0x38(%rbp)
movq -0x10(%rbp), %rsi
callq 0x26870
jmp 0x266ca
movq -0x30(%rbp), %rax
movq -0x38(%rbp), %rcx
movq %rcx, (%rax)
jmp 0x266f1
movq -0x38(%rbp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x18(%rbp)
movl %eax, -0x1c(%rbp)
callq 0x12250
jmp 0x26780
jmp 0x26776
movq -0x10(%rbp), %rdi
callq 0x26840
testb $0x1, %al
jne 0x26705
jmp 0x26742
movq -0x30(%rbp), %rax
movq (%rax), %rdi
callq 0x153a0
testb $0x1, %al
jne 0x26717
jmp 0x26730
movq -0x30(%rbp), %rax
movq (%rax), %rdi
callq 0x121d0
movq -0x30(%rbp), %rax
movq $0x0, (%rax)
jmp 0x26740
movq -0x30(%rbp), %rax
movq (%rax), %rdi
xorl %eax, %eax
movl %eax, %esi
callq 0x13b90
jmp 0x26774
movq -0x10(%rbp), %rdi
callq 0xc0c0
movq -0x30(%rbp), %rdi
movq %rax, -0x28(%rbp)
movq -0x28(%rbp), %rsi
callq 0x152e0
movq -0x30(%rbp), %rax
movq (%rax), %rdi
movq -0x10(%rbp), %rsi
movq -0x28(%rbp), %rdx
xorl %eax, %eax
movl %eax, %ecx
callq 0x15350
jmp 0x26776
movq -0x30(%rbp), %rax
addq $0x40, %rsp
popq %rbp
retq
movq -0x18(%rbp), %rdi
callq 0xc280
nopl (%rax)
// File: Silica[P]PSL/./PSL/pstring.h
// Function: PSL::variable::string::SharedBuffer::copy(char const*)
void copy(const char *s)
		{
			size_t t;
			for (t = 0; t < size; ++t)
			{
				if (!s[t])
					break;
				buf[t] = s[t];
			}
			len = t;
		}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x20(%rbp)
movq $0x0, -0x18(%rbp)
movq -0x20(%rbp), %rcx
movq -0x18(%rbp), %rax
cmpq 0x10(%rcx), %rax
jae 0x26972
movq -0x10(%rbp), %rax
movq -0x18(%rbp), %rcx
cmpb $0x0, (%rax,%rcx)
jne 0x2694a
jmp 0x26972
movq -0x20(%rbp), %rax
movq -0x10(%rbp), %rcx
movq -0x18(%rbp), %rdx
movb (%rcx,%rdx), %dl
movq 0x8(%rax), %rax
movq -0x18(%rbp), %rcx
movb %dl, (%rax,%rcx)
movq -0x18(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x18(%rbp)
jmp 0x2692c
movq -0x20(%rbp), %rax
movq -0x18(%rbp), %rcx
movq %rcx, 0x18(%rax)
popq %rbp
retq
// File: 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:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x10(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rcx
movq 0x28(%rcx), %rax
cmpq 0x20(%rcx), %rax
jae 0x269de
movq -0x18(%rbp), %rcx
movq 0x18(%rcx), %rax
movq 0x28(%rcx), %rcx
movsbl (%rax,%rcx), %eax
cmpl $0x20, %eax
je 0x269c8
movq -0x18(%rbp), %rcx
movq 0x18(%rcx), %rax
movq 0x28(%rcx), %rcx
movsbl (%rax,%rcx), %eax
cmpl $0x9, %eax
jne 0x269ca
jmp 0x269cc
jmp 0x269de
movq -0x18(%rbp), %rax
movq 0x28(%rax), %rcx
addq $0x1, %rcx
movq %rcx, 0x28(%rax)
jmp 0x26990
movq -0x18(%rbp), %rcx
movq 0x28(%rcx), %rax
cmpq 0x20(%rcx), %rax
jne 0x269f2
movb $0x1, -0x1(%rbp)
jmp 0x269f6
movb $0x0, -0x1(%rbp)
movb -0x1(%rbp), %al
andb $0x1, %al
popq %rbp
retq
nopl (%rax)
// File: 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:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x30(%rbp)
cmpq $0x0, (%rax)
jne 0x26a3c
movq -0x18(%rbp), %rax
movsbl (%rax), %eax
cmpl $0x0, %eax
jne 0x26a33
movb $0x1, -0x1(%rbp)
jmp 0x26ac9
movb $0x0, -0x1(%rbp)
jmp 0x26ac9
movq -0x30(%rbp), %rax
movq (%rax), %rdi
callq 0x152c0
movq %rax, -0x20(%rbp)
movq $0x0, -0x28(%rbp)
movq -0x28(%rbp), %rax
cmpq -0x20(%rbp), %rax
jae 0x26aae
movq -0x18(%rbp), %rax
movq -0x28(%rbp), %rcx
movsbl (%rax,%rcx), %eax
cmpl $0x0, %eax
jne 0x26a75
movb $0x0, -0x1(%rbp)
jmp 0x26ac9
movq -0x30(%rbp), %rax
movq (%rax), %rdi
movq -0x28(%rbp), %rsi
callq 0x15a40
movsbl %al, %eax
movq -0x18(%rbp), %rcx
movq -0x28(%rbp), %rdx
movsbl (%rcx,%rdx), %ecx
cmpl %ecx, %eax
je 0x26a9e
movb $0x0, -0x1(%rbp)
jmp 0x26ac9
jmp 0x26aa0
movq -0x28(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x28(%rbp)
jmp 0x26a54
movq -0x18(%rbp), %rax
movq -0x20(%rbp), %rcx
movsbl (%rax,%rcx), %eax
cmpl $0x0, %eax
je 0x26ac5
movb $0x0, -0x1(%rbp)
jmp 0x26ac9
movb $0x1, -0x1(%rbp)
movb -0x1(%rbp), %al
andb $0x1, %al
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
nop
// File: 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 %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x10(%rbp), %rdi
callq 0x23050
movq %rax, %rdi
leaq 0x18242(%rip), %rsi     # 0x3ed45
callq 0xc200
movq %rax, -0x20(%rbp)
cmpq $0x0, -0x20(%rbp)
jne 0x26b1d
movq $0x0, -0x8(%rbp)
jmp 0x26b7b
movl $0x70, %edi
callq 0xc1d0
movq %rax, %rdi
movq %rdi, %rax
movq %rax, -0x40(%rbp)
movq -0x20(%rbp), %rsi
movq -0x10(%rbp), %rdx
movq -0x18(%rbp), %rcx
callq 0x26d30
jmp 0x26b44
movq -0x40(%rbp), %rax
movq %rax, -0x28(%rbp)
movq -0x20(%rbp), %rdi
callq 0xc1c0
movq -0x28(%rbp), %rax
movq %rax, -0x8(%rbp)
jmp 0x26b7b
movq -0x40(%rbp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x30(%rbp)
movl %eax, -0x34(%rbp)
movl $0x70, %esi
callq 0xc1e0
jmp 0x26b85
movq -0x8(%rbp), %rax
addq $0x40, %rsp
popq %rbp
retq
movq -0x30(%rbp), %rdi
callq 0xc280
nop
// File: Silica[P]PSL/./PSL/pstring.h
// Function: PSL::variable::string::rfind(char, int) const
int rfind(char c, int i = -1) const	/* i�ʒu�����t�����Ɍ�������c�̕����𔭌������ʒu���Ԃ� */
	{
		if (buf)
		{
			if (i < 0 || i >= static_cast<int>(buf->length())) i = static_cast<int>(buf->length())-1;
			for (; i >= 0; --i)
			{
				if (buf->at(static_cast<size_t>(i)) == c)
					return i;
			}
		}
		return -1;
	}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movb %sil, %al
movq %rdi, -0x10(%rbp)
movb %al, -0x11(%rbp)
movl %edx, -0x18(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x20(%rbp)
cmpq $0x0, (%rax)
je 0x26c21
cmpl $0x0, -0x18(%rbp)
jl 0x26bd5
movq -0x20(%rbp), %rax
movl -0x18(%rbp), %ecx
movl %ecx, -0x24(%rbp)
movq (%rax), %rdi
callq 0x152c0
movq %rax, %rcx
movl -0x24(%rbp), %eax
cmpl %ecx, %eax
jl 0x26be7
movq -0x20(%rbp), %rax
movq (%rax), %rdi
callq 0x152c0
subl $0x1, %eax
movl %eax, -0x18(%rbp)
jmp 0x26be9
cmpl $0x0, -0x18(%rbp)
jl 0x26c1f
movq -0x20(%rbp), %rax
movq (%rax), %rdi
movslq -0x18(%rbp), %rsi
callq 0x15a40
movsbl %al, %eax
movsbl -0x11(%rbp), %ecx
cmpl %ecx, %eax
jne 0x26c12
movl -0x18(%rbp), %eax
movl %eax, -0x4(%rbp)
jmp 0x26c28
jmp 0x26c14
movl -0x18(%rbp), %eax
addl $-0x1, %eax
movl %eax, -0x18(%rbp)
jmp 0x26be9
jmp 0x26c21
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
movl -0x4(%rbp), %eax
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
nopl (%rax,%rax)
// File: 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 %rbp
movq %rsp, %rbp
subq $0x90, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq %rcx, -0x20(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x58(%rbp)
movq %rdi, %rax
movq %rax, -0x60(%rbp)
callq 0x11f50
movq -0x58(%rbp), %rdi
addq $0x10, %rdi
movq %rdi, -0x50(%rbp)
callq 0x11f50
jmp 0x26d72
movq -0x60(%rbp), %rdi
addq $0x68, %rdi
movq %rdi, -0x68(%rbp)
callq 0x11f50
jmp 0x26d85
movq -0x10(%rbp), %rdi
xorl %eax, %eax
movl %eax, %esi
movl $0x2, %edx
callq 0xc1f0
jmp 0x26d99
movq -0x10(%rbp), %rdi
callq 0xc030
movq %rax, -0x70(%rbp)
jmp 0x26da8
movq -0x70(%rbp), %rax
movq %rax, -0x38(%rbp)
cmpq $0x0, -0x38(%rbp)
jge 0x26dbf
xorl %eax, %eax
movq %rax, -0x78(%rbp)
jmp 0x26dc7
movq -0x38(%rbp), %rax
movq %rax, -0x78(%rbp)
movq -0x60(%rbp), %rax
movq -0x78(%rbp), %rcx
movq %rcx, 0x20(%rax)
movq 0x20(%rax), %rsi
leaq -0x48(%rbp), %rdi
leaq -0x40(%rbp), %rdx
callq 0x26ef0
jmp 0x26de6
movq -0x10(%rbp), %rdi
xorl %edx, %edx
movl %edx, %esi
callq 0xc1f0
jmp 0x26df5
movq -0x60(%rbp), %rax
movq -0x40(%rbp), %rdi
movq 0x20(%rax), %rdx
movq -0x10(%rbp), %rcx
movl $0x1, %esi
callq 0xc230
movq %rax, -0x80(%rbp)
jmp 0x26e15
movq -0x60(%rbp), %rdi
movq -0x80(%rbp), %rax
movq %rax, 0x20(%rdi)
addq $0x10, %rdi
leaq -0x48(%rbp), %rsi
callq 0x120b0
movq %rax, -0x88(%rbp)
jmp 0x26e37
movq -0x88(%rbp), %rdi
callq 0x23050
movq %rax, -0x90(%rbp)
jmp 0x26e4c
movq -0x60(%rbp), %rdi
movq -0x90(%rbp), %rax
movq %rax, 0x18(%rdi)
movq -0x18(%rbp), %rsi
movq -0x20(%rbp), %rcx
movl $0x1, %edx
callq 0x23070
jmp 0x26e6f
leaq -0x48(%rbp), %rdi
callq 0xc950
addq $0x90, %rsp
popq %rbp
retq
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x28(%rbp)
movl %eax, -0x2c(%rbp)
jmp 0x26ed2
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x28(%rbp)
movl %eax, -0x2c(%rbp)
jmp 0x26ec9
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x28(%rbp)
movl %eax, -0x2c(%rbp)
jmp 0x26ec0
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x28(%rbp)
movl %eax, -0x2c(%rbp)
leaq -0x48(%rbp), %rdi
callq 0xc950
movq -0x68(%rbp), %rdi
callq 0xc950
movq -0x50(%rbp), %rdi
callq 0xc950
movq -0x58(%rbp), %rdi
callq 0xc950
movq -0x28(%rbp), %rdi
callq 0xc280
nopw %cs:(%rax,%rax)
nop