LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: ryuichiueda[P]GlueLang/src/Environment.cc
// Function: Environment::getData(std::vector<int, std::allocator<int>>*, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>*)
Data *Environment::getData(vector<int> *scopes,string *key)
{
	for(auto rit = scopes->rbegin(); rit != scopes->rend(); ++rit){
		if(isData(*rit,key))
			return getData(*rit,key);
	}
	m_error_msg = "Variable " + *key + " not found";
	throw this;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x90, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x80(%rbp)
movq -0x10(%rbp), %rsi
leaq -0x20(%rbp), %rdi
callq 0xfaa0
movq -0x10(%rbp), %rsi
leaq -0x28(%rbp), %rdi
callq 0xfb20
leaq -0x20(%rbp), %rdi
leaq -0x28(%rbp), %rsi
callq 0xfaf0
testb $0x1, %al
jne 0xec5c
jmp 0xeca8
leaq -0x20(%rbp), %rdi
callq 0xfb70
movq -0x80(%rbp), %rdi
movl (%rax), %esi
movq -0x18(%rbp), %rdx
callq 0xed50
testb $0x1, %al
jne 0xec7a
jmp 0xec9b
leaq -0x20(%rbp), %rdi
callq 0xfb70
movq -0x80(%rbp), %rdi
movl (%rax), %esi
movq -0x18(%rbp), %rdx
callq 0xe9a0
addq $0x90, %rsp
popq %rbp
retq
jmp 0xec9d
leaq -0x20(%rbp), %rdi
callq 0xfba0
jmp 0xec3c
movq -0x18(%rbp), %rdx
leaq 0xe7a6(%rip), %rsi      # 0x1d459
leaq -0x68(%rbp), %rdi
movq %rdi, -0x88(%rbp)
callq 0x7c20
movq -0x88(%rbp), %rsi
leaq 0xe792(%rip), %rdx      # 0x1d463
leaq -0x48(%rbp), %rdi
callq 0x7bd0
jmp 0xecdc
movq -0x80(%rbp), %rdi
addq $0xa0, %rdi
leaq -0x48(%rbp), %rsi
callq 0x6520
leaq -0x48(%rbp), %rdi
callq 0x6280
leaq -0x68(%rbp), %rdi
callq 0x6280
movl $0x8, %edi
callq 0x6200
movq %rax, %rdi
movq -0x80(%rbp), %rax
movq %rax, (%rdi)
leaq 0x19553(%rip), %rsi     # 0x28270
xorl %eax, %eax
movl %eax, %edx
callq 0x66d0
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x70(%rbp)
movl %eax, -0x74(%rbp)
leaq -0x68(%rbp), %rdi
callq 0x6280
movq -0x70(%rbp), %rdi
callq 0x6700
nopw %cs:(%rax,%rax)
// File: ryuichiueda[P]GlueLang/src/Environment.cc
// Function: Environment::getArg[abi:cxx11](long)
string *Environment::getArg(long pos)
{
	if(pos < 0 || pos >= (long)m_args.size()){
		m_error_msg = "Array index out of range (pos: "+
		to_string(pos) + ")";
		throw this;
	}
	return &m_args[pos];
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0xa0, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x88(%rbp)
cmpq $0x0, -0x10(%rbp)
jl 0xf15f
movq -0x88(%rbp), %rdi
movq -0x10(%rbp), %rax
movq %rax, -0x90(%rbp)
callq 0xb6a0
movq %rax, %rcx
movq -0x90(%rbp), %rax
cmpq %rcx, %rax
jl 0xf229
movq -0x10(%rbp), %rsi
leaq -0x70(%rbp), %rdi
movq %rdi, -0x98(%rbp)
callq 0x9060
movq -0x98(%rbp), %rdx
leaq 0xe30b(%rip), %rsi      # 0x1d48c
leaq -0x50(%rbp), %rdi
callq 0xbf30
jmp 0xf18c
leaq 0xe4fa(%rip), %rdx      # 0x1d68d
leaq -0x30(%rbp), %rdi
leaq -0x50(%rbp), %rsi
callq 0x7bd0
jmp 0xf1a2
movq -0x88(%rbp), %rdi
addq $0xa0, %rdi
leaq -0x30(%rbp), %rsi
callq 0x6520
leaq -0x30(%rbp), %rdi
callq 0x6280
leaq -0x50(%rbp), %rdi
callq 0x6280
leaq -0x70(%rbp), %rdi
callq 0x6280
movl $0x8, %edi
callq 0x6200
movq %rax, %rdi
movq -0x88(%rbp), %rax
movq %rax, (%rdi)
leaq 0x1907e(%rip), %rsi     # 0x28270
xorl %eax, %eax
movl %eax, %edx
callq 0x66d0
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x78(%rbp)
movl %eax, -0x7c(%rbp)
jmp 0xf21e
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x78(%rbp)
movl %eax, -0x7c(%rbp)
leaq -0x50(%rbp), %rdi
callq 0x6280
leaq -0x70(%rbp), %rdi
callq 0x6280
jmp 0xf242
movq -0x88(%rbp), %rdi
movq -0x10(%rbp), %rsi
callq 0xb680
addq $0xa0, %rsp
popq %rbp
retq
movq -0x78(%rbp), %rdi
callq 0x6700
nopl (%rax,%rax)
// File: ryuichiueda[P]GlueLang/src/Environment.cc
// Function: Environment::setData(int, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>*, Data*)
void Environment::setData(int scope_id,string *key, Data *value)
{
	string k = genKey(scope_id,key);
//	cerr << "set: " << k << endl;
	if(m_data.find(k) != m_data.end()){
		m_error_msg = *key + " already exist";
		throw this;
	}
	m_data[k] = value;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0xb0, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movq %rdx, -0x18(%rbp)
movq %rcx, -0x20(%rbp)
movq -0x8(%rbp), %rsi
movq %rsi, -0x98(%rbp)
movl -0xc(%rbp), %edx
movq -0x18(%rbp), %rcx
leaq -0x40(%rbp), %rdi
movq %rdi, -0x90(%rbp)
callq 0xeb50
movq -0x98(%rbp), %rdi
movq -0x90(%rbp), %rsi
addq $0x68, %rdi
callq 0xf990
movq %rax, -0x88(%rbp)
jmp 0xf2ac
movq -0x98(%rbp), %rdi
movq -0x88(%rbp), %rax
movq %rax, -0x48(%rbp)
addq $0x68, %rdi
callq 0xf540
movq %rax, -0x60(%rbp)
leaq -0x48(%rbp), %rdi
leaq -0x60(%rbp), %rsi
callq 0xf570
testb $0x1, %al
jne 0xf2e1
jmp 0xf361
movq -0x18(%rbp), %rsi
leaq 0xe1c0(%rip), %rdx      # 0x1d4ac
leaq -0x80(%rbp), %rdi
callq 0x79f0
jmp 0xf2f7
movq -0x98(%rbp), %rdi
addq $0xa0, %rdi
leaq -0x80(%rbp), %rsi
movq %rsi, -0xa0(%rbp)
callq 0x6520
movq -0xa0(%rbp), %rdi
callq 0x6280
movl $0x8, %edi
callq 0x6200
movq %rax, %rdi
movq -0x98(%rbp), %rax
movq %rax, (%rdi)
leaq 0x18f31(%rip), %rsi     # 0x28270
xorl %eax, %eax
movl %eax, %edx
callq 0x66d0
jmp 0xf3b5
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x50(%rbp)
movl %eax, -0x54(%rbp)
leaq -0x40(%rbp), %rdi
callq 0x6280
jmp 0xf3ac
movq -0x98(%rbp), %rdi
movq -0x20(%rbp), %rax
movq %rax, -0xb0(%rbp)
addq $0x68, %rdi
leaq -0x40(%rbp), %rsi
callq 0xf9c0
movq %rax, -0xa8(%rbp)
jmp 0xf389
movq -0xa8(%rbp), %rax
movq -0xb0(%rbp), %rcx
movq %rcx, (%rax)
leaq -0x40(%rbp), %rdi
callq 0x6280
addq $0xb0, %rsp
popq %rbp
retq
movq -0x50(%rbp), %rdi
callq 0x6700
nopw %cs:(%rax,%rax)
// File: ryuichiueda[P]GlueLang/src/ExecExtCom.cc
// Function: ExecExtCom::parse()
bool ExecExtCom::parse(void)
{
	m_feeder->getPos(&m_start_line, &m_start_char);

	if(!add(new ArgExtCom(m_feeder,m_env,&m_scopes)))
		return false;

	if(!m_feeder->comment() && !m_feeder->atNewLine()){
		m_feeder->blank();
		parseArgs();
	}

	m_feeder->getPos(&m_end_line, &m_end_char);
	return true;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movq -0x10(%rbp), %rdx
movq %rdx, -0x30(%rbp)
movq 0x8(%rdx), %rdi
movq %rdx, %rsi
addq $0x30, %rsi
addq $0x34, %rdx
callq 0x17610
movl $0xe8, %edi
callq 0x6420
movq -0x30(%rbp), %rcx
movq %rax, %rdi
movq %rdi, %rax
movq %rax, -0x28(%rbp)
movq 0x8(%rcx), %rsi
movq 0x10(%rcx), %rdx
addq $0x48, %rcx
callq 0x7130
jmp 0x13743
movq -0x28(%rbp), %rsi
movq -0x30(%rbp), %rdi
callq 0xb860
testb $0x1, %al
jne 0x13776
movb $0x0, -0x1(%rbp)
jmp 0x137ca
movq -0x28(%rbp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x18(%rbp)
movl %eax, -0x1c(%rbp)
movl $0xe8, %esi
callq 0x6430
jmp 0x137d5
movq -0x30(%rbp), %rax
movq 0x8(%rax), %rdi
callq 0x17510
testb $0x1, %al
jne 0x137ae
movq -0x30(%rbp), %rax
movq 0x8(%rax), %rdi
callq 0x16c70
testb $0x1, %al
jne 0x137ae
movq -0x30(%rbp), %rax
movq 0x8(%rax), %rdi
callq 0x164a0
movq -0x30(%rbp), %rdi
callq 0x157b0
movq -0x30(%rbp), %rdx
movq 0x8(%rdx), %rdi
movq %rdx, %rsi
addq $0x38, %rsi
addq $0x3c, %rdx
callq 0x17610
movb $0x1, -0x1(%rbp)
movb -0x1(%rbp), %al
andb $0x1, %al
addq $0x30, %rsp
popq %rbp
retq
movq -0x18(%rbp), %rdi
callq 0x6700
nop
// File: ryuichiueda[P]GlueLang/src/ExecExtCom.cc
// Function: ExecExtCom::execChild(DefFile*, DefStr*)
void ExecExtCom::execChild(DefFile *f,  DefStr *s)
{
	auto argv = makeArgv();
	vOptProc(argv[0]);
	auto env = new const char* [2];
	string path = m_env->getPATH();
	char *tmp = new char[path.size() + 1];
	char_traits<char>::copy(tmp, path.c_str(), path.size() + 1);
	env[0] = (const char *)tmp;
	env[1] = NULL;
	execve(argv[0],(char **)argv,(char **)env);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x90, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x78(%rbp)
callq 0x15be0
movq -0x78(%rbp), %rdi
movq %rax, -0x20(%rbp)
movq -0x20(%rbp), %rax
movq (%rax), %rsi
callq 0x15f40
movl $0x10, %edi
callq 0x6040
movq %rax, %rcx
movq -0x78(%rbp), %rax
movq %rcx, -0x28(%rbp)
movq 0x10(%rax), %rsi
leaq -0x48(%rbp), %rdi
movq %rdi, -0x70(%rbp)
callq 0xe730
movq -0x70(%rbp), %rdi
callq 0x62c0
movq %rax, %rdi
incq %rdi
callq 0x6040
movq %rax, -0x68(%rbp)
jmp 0x13858
movq -0x68(%rbp), %rax
movq %rax, -0x50(%rbp)
movq -0x50(%rbp), %rax
movq %rax, -0x88(%rbp)
leaq -0x48(%rbp), %rdi
movq %rdi, -0x90(%rbp)
callq 0x6190
movq -0x90(%rbp), %rdi
movq %rax, -0x80(%rbp)
callq 0x62c0
movq -0x88(%rbp), %rdi
movq -0x80(%rbp), %rsi
movq %rax, %rdx
incq %rdx
callq 0x13900
jmp 0x138a3
movq -0x50(%rbp), %rcx
movq -0x28(%rbp), %rax
movq %rcx, (%rax)
movq -0x28(%rbp), %rax
movq $0x0, 0x8(%rax)
movq -0x20(%rbp), %rax
movq (%rax), %rdi
movq -0x20(%rbp), %rsi
movq -0x28(%rbp), %rdx
callq 0x66c0
leaq -0x48(%rbp), %rdi
callq 0x6280
addq $0x90, %rsp
popq %rbp
retq
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x58(%rbp)
movl %eax, -0x5c(%rbp)
leaq -0x48(%rbp), %rdi
callq 0x6280
movq -0x58(%rbp), %rdi
callq 0x6700
nop
// File: ryuichiueda[P]GlueLang/src/ExecIntCom.cc
// Function: ExecIntCom::parse()
bool ExecIntCom::parse(void)
{
	m_feeder->getPos(&m_start_line, &m_start_char);

	if(!add(new ArgIntCom(m_feeder,m_env,&m_scopes)))
		return false;

	if(!m_feeder->comment() && !m_feeder->atNewLine()){
		m_feeder->blank();
		parseArgs();
	}

	auto *c = (ArgIntCom *)m_nodes[0];
	if(c->m_text == "in.wait"){
		m_is_wait = true;
	}

	m_feeder->getPos(&m_end_line, &m_end_char);
	return true;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x10(%rbp)
movq -0x10(%rbp), %rdx
movq %rdx, -0x38(%rbp)
movq 0x8(%rdx), %rdi
movq %rdx, %rsi
addq $0x30, %rsi
addq $0x34, %rdx
callq 0x17610
movl $0xc8, %edi
callq 0x6420
movq -0x38(%rbp), %rcx
movq %rax, %rdi
movq %rdi, %rax
movq %rax, -0x30(%rbp)
movq 0x8(%rcx), %rsi
movq 0x10(%rcx), %rdx
addq $0x48, %rcx
callq 0x8060
jmp 0x14503
movq -0x30(%rbp), %rsi
movq -0x38(%rbp), %rdi
callq 0xb860
testb $0x1, %al
jne 0x1453c
movb $0x0, -0x1(%rbp)
jmp 0x145d0
movq -0x30(%rbp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x18(%rbp)
movl %eax, -0x1c(%rbp)
movl $0xc8, %esi
callq 0x6430
jmp 0x145db
movq -0x38(%rbp), %rax
movq 0x8(%rax), %rdi
callq 0x17510
testb $0x1, %al
jne 0x14574
movq -0x38(%rbp), %rax
movq 0x8(%rax), %rdi
callq 0x16c70
testb $0x1, %al
jne 0x14574
movq -0x38(%rbp), %rax
movq 0x8(%rax), %rdi
callq 0x164a0
movq -0x38(%rbp), %rdi
callq 0x157b0
movq -0x38(%rbp), %rdi
addq $0x18, %rdi
xorl %eax, %eax
movl %eax, %esi
callq 0x14640
movq (%rax), %rax
movq %rax, -0x28(%rbp)
movq -0x28(%rbp), %rdi
addq $0x88, %rdi
leaq 0x8f63(%rip), %rsi      # 0x1d501
callq 0x8380
testb $0x1, %al
jne 0x145a9
jmp 0x145b4
movq -0x38(%rbp), %rax
movb $0x1, 0x85(%rax)
movq -0x38(%rbp), %rdx
movq 0x8(%rdx), %rdi
movq %rdx, %rsi
addq $0x38, %rsi
addq $0x3c, %rdx
callq 0x17610
movb $0x1, -0x1(%rbp)
movb -0x1(%rbp), %al
andb $0x1, %al
addq $0x40, %rsp
popq %rbp
retq
movq -0x18(%rbp), %rdi
callq 0x6700
nopw %cs:(%rax,%rax)
// File: ryuichiueda[P]GlueLang/src/ExecProc.cc
// Function: ExecProc::parse()
bool ExecProc::parse(void)
{
	m_feeder->getPos(&m_start_line, &m_start_char);

	if(!add(new ArgProc(m_feeder,m_env,&m_scopes)))
		return false;

	if(!m_feeder->comment() && !m_feeder->atNewLine()){
		m_feeder->blank();
		parseArgs();
	}

	m_feeder->getPos(&m_end_line, &m_end_char);
	return true;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movq -0x10(%rbp), %rdx
movq %rdx, -0x30(%rbp)
movq 0x8(%rdx), %rdi
movq %rdx, %rsi
addq $0x30, %rsi
addq $0x34, %rdx
callq 0x17610
movl $0xc8, %edi
callq 0x6420
movq -0x30(%rbp), %rcx
movq %rax, %rdi
movq %rdi, %rax
movq %rax, -0x28(%rbp)
movq 0x8(%rcx), %rsi
movq 0x10(%rcx), %rdx
addq $0x48, %rcx
callq 0x83b0
jmp 0x14753
movq -0x28(%rbp), %rsi
movq -0x30(%rbp), %rdi
callq 0xb860
testb $0x1, %al
jne 0x14786
movb $0x0, -0x1(%rbp)
jmp 0x147da
movq -0x28(%rbp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x18(%rbp)
movl %eax, -0x1c(%rbp)
movl $0xc8, %esi
callq 0x6430
jmp 0x147e5
movq -0x30(%rbp), %rax
movq 0x8(%rax), %rdi
callq 0x17510
testb $0x1, %al
jne 0x147be
movq -0x30(%rbp), %rax
movq 0x8(%rax), %rdi
callq 0x16c70
testb $0x1, %al
jne 0x147be
movq -0x30(%rbp), %rax
movq 0x8(%rax), %rdi
callq 0x164a0
movq -0x30(%rbp), %rdi
callq 0x157b0
movq -0x30(%rbp), %rdx
movq 0x8(%rdx), %rdi
movq %rdx, %rsi
addq $0x38, %rsi
addq $0x3c, %rdx
callq 0x17610
movb $0x1, -0x1(%rbp)
movb -0x1(%rbp), %al
andb $0x1, %al
addq $0x30, %rsp
popq %rbp
retq
movq -0x18(%rbp), %rdi
callq 0x6700
nop
// File: ryuichiueda[P]GlueLang/src/ExecProc.cc
// Function: ExecProc::execChild(DefFile*, DefStr*)
void ExecProc::execChild(DefFile *f,  DefStr *s)
{
	auto argv = makeArgv();
	// argv[0]: script file
	// argv[1,2,...]: args
	
	vOptProc(argv[0]);
	ifstream ifs(argv[0]);
	Feeder feeder(&ifs);

	m_env->initExecProc((const char**)argv);
	Script scr(&feeder,m_env,NULL);

	scr.parse();
	scr.exec(f,s); // exit in the exec function
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x320, %rsp            # imm = 0x320
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x318(%rbp)
callq 0x15be0
movq -0x318(%rbp), %rdi
movq %rax, -0x20(%rbp)
movq -0x20(%rbp), %rax
movq (%rax), %rsi
callq 0x15f40
movq -0x20(%rbp), %rax
movq (%rax), %rsi
leaq -0x228(%rbp), %rdi
movq %rdi, -0x310(%rbp)
movl $0x8, %edx
callq 0x6740
movq -0x310(%rbp), %rsi
leaq -0x270(%rbp), %rdi
callq 0x15fe0
jmp 0x14862
movq -0x318(%rbp), %rax
movq 0x10(%rax), %rdi
movq -0x20(%rbp), %rsi
callq 0xe120
jmp 0x14878
movq -0x318(%rbp), %rax
movq 0x10(%rax), %rdx
xorl %eax, %eax
movl %eax, %ecx
leaq -0x308(%rbp), %rdi
leaq -0x270(%rbp), %rsi
callq 0x1ad80
jmp 0x1489c
leaq -0x308(%rbp), %rdi
callq 0x1aeb0
jmp 0x148aa
movq -0x10(%rbp), %rsi
movq -0x18(%rbp), %rdx
leaq -0x308(%rbp), %rdi
callq 0x1b4c0
jmp 0x148c0
leaq -0x308(%rbp), %rdi
callq 0x1add0
leaq -0x270(%rbp), %rdi
callq 0x160f0
leaq -0x228(%rbp), %rdi
callq 0x6100
addq $0x320, %rsp            # imm = 0x320
popq %rbp
retq
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x278(%rbp)
movl %eax, -0x27c(%rbp)
jmp 0x1493f
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x278(%rbp)
movl %eax, -0x27c(%rbp)
jmp 0x14933
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x278(%rbp)
movl %eax, -0x27c(%rbp)
leaq -0x308(%rbp), %rdi
callq 0x1add0
leaq -0x270(%rbp), %rdi
callq 0x160f0
leaq -0x228(%rbp), %rdi
callq 0x6100
movq -0x278(%rbp), %rdi
callq 0x6700
nopw (%rax,%rax)
// File: ryuichiueda[P]GlueLang/src/ExecSubShell.cc
// Function: ExecSubShell::execChild(DefFile*, DefStr*)
void ExecSubShell::execChild(DefFile *f,  DefStr *s)
{
	auto argv = new char* [2];
	string tmpdir = m_env->m_tmpdir + "/" + m_name;
	argv[0] = (char *)tmpdir.c_str();
	argv[1] = NULL;

	vOptProc(argv[0]);
	ifstream ifs(argv[0]);
	Feeder feeder(&ifs);

	m_env->initExecProc((const char**)argv);
	Script scr(&feeder,m_env,NULL);

	scr.setSilent();
	scr.parse();
	scr.exec(f,s); // exit in the exec function
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x360, %rsp            # imm = 0x360
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x358(%rbp)
movl $0x10, %edi
callq 0x6040
movq %rax, %rcx
movq -0x358(%rbp), %rax
movq %rcx, -0x20(%rbp)
movq 0x10(%rax), %rsi
addq $0xc0, %rsi
leaq 0x881e(%rip), %rdx      # 0x1d5ba
leaq -0x60(%rbp), %rdi
movq %rdi, -0x350(%rbp)
callq 0x79f0
movq -0x358(%rbp), %rdx
movq -0x350(%rbp), %rsi
addq $0xb0, %rdx
leaq -0x40(%rbp), %rdi
callq 0x8720
jmp 0x14dcc
leaq -0x60(%rbp), %rdi
callq 0x6280
leaq -0x40(%rbp), %rdi
callq 0x6190
movq -0x358(%rbp), %rdi
movq %rax, %rcx
movq -0x20(%rbp), %rax
movq %rcx, (%rax)
movq -0x20(%rbp), %rax
movq $0x0, 0x8(%rax)
movq -0x20(%rbp), %rax
movq (%rax), %rsi
callq 0x15f40
jmp 0x14e09
movq -0x20(%rbp), %rax
movq (%rax), %rsi
leaq -0x278(%rbp), %rdi
movl $0x8, %edx
callq 0x6740
jmp 0x14e23
leaq -0x2c0(%rbp), %rdi
leaq -0x278(%rbp), %rsi
callq 0x15fe0
jmp 0x14e38
movq -0x358(%rbp), %rax
movq 0x10(%rax), %rdi
movq -0x20(%rbp), %rsi
callq 0xe120
jmp 0x14e4e
movq -0x358(%rbp), %rax
movq 0x10(%rax), %rdx
xorl %eax, %eax
movl %eax, %ecx
leaq -0x348(%rbp), %rdi
leaq -0x2c0(%rbp), %rsi
callq 0x1ad80
jmp 0x14e72
leaq -0x348(%rbp), %rdi
callq 0x143f0
jmp 0x14e80
leaq -0x348(%rbp), %rdi
callq 0x1aeb0
jmp 0x14e8e
movq -0x10(%rbp), %rsi
movq -0x18(%rbp), %rdx
leaq -0x348(%rbp), %rdi
callq 0x1b4c0
jmp 0x14ea4
leaq -0x348(%rbp), %rdi
callq 0x1add0
leaq -0x2c0(%rbp), %rdi
callq 0x160f0
leaq -0x278(%rbp), %rdi
callq 0x6100
leaq -0x40(%rbp), %rdi
callq 0x6280
addq $0x360, %rsp            # imm = 0x360
popq %rbp
retq
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x68(%rbp)
movl %eax, -0x6c(%rbp)
leaq -0x60(%rbp), %rdi
callq 0x6280
jmp 0x14f54
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x68(%rbp)
movl %eax, -0x6c(%rbp)
jmp 0x14f4b
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x68(%rbp)
movl %eax, -0x6c(%rbp)
jmp 0x14f3f
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x68(%rbp)
movl %eax, -0x6c(%rbp)
jmp 0x14f33
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x68(%rbp)
movl %eax, -0x6c(%rbp)
leaq -0x348(%rbp), %rdi
callq 0x1add0
leaq -0x2c0(%rbp), %rdi
callq 0x160f0
leaq -0x278(%rbp), %rdi
callq 0x6100
leaq -0x40(%rbp), %rdi
callq 0x6280
movq -0x68(%rbp), %rdi
callq 0x6700
nopl (%rax)
// File: ryuichiueda[P]GlueLang/src/Executable.cc
// Function: Executable::Executable(Feeder*, Environment*, std::vector<int, std::allocator<int>>*)
Executable::Executable(Feeder *f, Environment *env, vector<int> *scopes) : Element(f,env,scopes)
{
	m_pipe[0] = -1;
	m_pipe[1] = -1;
	m_pipe_prev = -1;
	m_is_wait = false;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq %rcx, -0x20(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x28(%rbp)
movq -0x10(%rbp), %rsi
movq -0x18(%rbp), %rdx
movq -0x20(%rbp), %rcx
callq 0xb6c0
movq -0x28(%rbp), %rdi
leaq 0x131fc(%rip), %rax     # 0x28918
addq $0x10, %rax
movq %rax, (%rdi)
addq $0x98, %rdi
callq 0xf3e0
movq -0x28(%rbp), %rax
movl $0xffffffff, 0x88(%rax) # imm = 0xFFFFFFFF
movl $0xffffffff, 0x8c(%rax) # imm = 0xFFFFFFFF
movl $0xffffffff, 0x90(%rax) # imm = 0xFFFFFFFF
movb $0x0, 0x85(%rax)
addq $0x30, %rsp
popq %rbp
retq
nop
// File: ryuichiueda[P]GlueLang/src/Executable.cc
// Function: Executable::parseArgs()
void Executable::parseArgs(void)
{
	bool flg = true;
	while(1){
		flg = add(new Literal(m_feeder,m_env,&m_scopes))
			|| add(new ArrayVariable(m_feeder,m_env,&m_scopes))
			|| add(new ArgVariable(m_feeder,m_env,&m_scopes));

		if(flg == false)
			return;

		if(m_feeder->comment() || m_feeder->atNewLine())
			return;

		m_feeder->blank();
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x70, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x48(%rbp)
movb $0x1, -0x9(%rbp)
movl $0xc8, %edi
callq 0x6420
movq -0x48(%rbp), %rcx
movq %rax, %rdi
movq %rdi, %rax
movq %rax, -0x50(%rbp)
movq 0x8(%rcx), %rsi
movq 0x10(%rcx), %rdx
addq $0x48, %rcx
movb $0x0, -0x29(%rbp)
movb $0x0, -0x39(%rbp)
callq 0x19c60
jmp 0x157fb
movq -0x50(%rbp), %rsi
movq -0x48(%rbp), %rdi
callq 0xb860
movb %al, %cl
movb $0x1, %al
testb $0x1, %cl
movb %al, -0x51(%rbp)
jne 0x158a7
movl $0xd0, %edi
callq 0x6420
movq -0x48(%rbp), %rcx
movq %rax, %rdi
movq %rdi, %rax
movq %rax, -0x60(%rbp)
movq %rdi, -0x28(%rbp)
movb $0x1, -0x29(%rbp)
movq 0x8(%rcx), %rsi
movq 0x10(%rcx), %rdx
addq $0x48, %rcx
callq 0x8b60
jmp 0x1584b
movq -0x60(%rbp), %rsi
movq -0x48(%rbp), %rdi
callq 0xb860
movb %al, %cl
movb $0x1, %al
testb $0x1, %cl
movb %al, -0x51(%rbp)
jne 0x158a7
movl $0xd0, %edi
callq 0x6420
movq -0x48(%rbp), %rcx
movq %rax, %rdi
movq %rdi, %rax
movq %rax, -0x68(%rbp)
movq %rdi, -0x38(%rbp)
movb $0x1, -0x39(%rbp)
movq 0x8(%rcx), %rsi
movq 0x10(%rcx), %rdx
addq $0x48, %rcx
callq 0x8770
jmp 0x15897
movq -0x68(%rbp), %rsi
movq -0x48(%rbp), %rdi
callq 0xb860
movb %al, -0x51(%rbp)
movb -0x51(%rbp), %al
andb $0x1, %al
movb %al, -0x9(%rbp)
movb -0x9(%rbp), %al
andb $0x1, %al
movzbl %al, %eax
cmpl $0x0, %eax
jne 0x15928
jmp 0x15960
movq -0x50(%rbp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x18(%rbp)
movl %eax, -0x1c(%rbp)
movl $0xc8, %esi
callq 0x6430
jmp 0x15966
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x18(%rbp)
movl %eax, -0x1c(%rbp)
testb $0x1, -0x29(%rbp)
jne 0x158f4
jmp 0x15902
movq -0x28(%rbp), %rdi
movl $0xd0, %esi
callq 0x6430
jmp 0x15966
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x18(%rbp)
movl %eax, -0x1c(%rbp)
testb $0x1, -0x39(%rbp)
jne 0x15918
jmp 0x15926
movq -0x38(%rbp), %rdi
movl $0xd0, %esi
callq 0x6430
jmp 0x15966
movq -0x48(%rbp), %rax
movq 0x8(%rax), %rdi
callq 0x17510
testb $0x1, %al
jne 0x1594c
movq -0x48(%rbp), %rax
movq 0x8(%rax), %rdi
callq 0x16c70
testb $0x1, %al
jne 0x1594c
jmp 0x1594e
jmp 0x15960
movq -0x48(%rbp), %rax
movq 0x8(%rax), %rdi
callq 0x164a0
jmp 0x157c8
addq $0x70, %rsp
popq %rbp
retq
movq -0x18(%rbp), %rdi
callq 0x6700
nop
// File: ryuichiueda[P]GlueLang/src/Executable.cc
// Function: Executable::parentPipeProc()
void Executable::parentPipeProc(void)
{
	if(m_pipe_prev >= 0)
		close(m_pipe_prev);

	m_pipe_prev = m_pipe[0];
	close(m_pipe[1]);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x10(%rbp)
cmpl $0x0, 0x90(%rax)
jl 0x1599c
movq -0x10(%rbp), %rax
movl 0x90(%rax), %edi
callq 0x6790
movq -0x10(%rbp), %rax
movl 0x88(%rax), %ecx
movl %ecx, 0x90(%rax)
movl 0x8c(%rax), %edi
callq 0x6790
addq $0x10, %rsp
popq %rbp
retq
nopl (%rax)
// File: ryuichiueda[P]GlueLang/src/Executable.cc
// Function: Executable::childPipeProc()
void Executable::childPipeProc(void)
{
	if(m_pipe[1] >= 0)
		close(m_pipe[0]);

	if(m_pipe_prev > 0) {
		dup2(m_pipe_prev, 0);
		close(m_pipe_prev);
	}
	if(m_pipe[1] > 1){
		dup2(m_pipe[1], 1);
		close(m_pipe[1]);
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x10(%rbp)
cmpl $0x0, 0x8c(%rax)
jl 0x159ec
movq -0x10(%rbp), %rax
movl 0x88(%rax), %edi
callq 0x6790
movq -0x10(%rbp), %rax
cmpl $0x0, 0x90(%rax)
jle 0x15a19
movq -0x10(%rbp), %rax
movl 0x90(%rax), %edi
xorl %esi, %esi
callq 0x63d0
movq -0x10(%rbp), %rax
movl 0x90(%rax), %edi
callq 0x6790
movq -0x10(%rbp), %rax
cmpl $0x1, 0x8c(%rax)
jle 0x15a49
movq -0x10(%rbp), %rax
movl 0x8c(%rax), %edi
movl $0x1, %esi
callq 0x63d0
movq -0x10(%rbp), %rax
movl 0x8c(%rax), %edi
callq 0x6790
addq $0x10, %rsp
popq %rbp
retq
nop
// File: ryuichiueda[P]GlueLang/src/Executable.cc
// Function: Executable::exec(DefFile*, DefStr*)
int Executable::exec(DefFile *f, DefStr *s)
{
	cout << flush;

	eval();

	int pid = fork();
	if(pid < 0)
		exit(4);

	if (pid == 0){//child
		if(m_env->m_v_opt)
			cerr << "+ pid " << getpid() << " fork " << endl;

		m_env->m_level++;
		childPipeProc();

		//The child process should not access to the source code.
		m_feeder->close();

		//open a file or a string variable
		if(f != NULL)
			f->connect();
		else if(s != NULL)
			s->connect();

		execChild(f,s);
		execErrorExit();
	}

	/*parent*/
	parentPipeProc();
	return pid;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x28(%rbp)
movq 0x134e5(%rip), %rdi     # 0x28fb8
movq 0x134e6(%rip), %rsi     # 0x28fc0
callq 0x6460
movq -0x28(%rbp), %rdi
movq (%rdi), %rax
callq *0x10(%rax)
callq 0x6110
movl %eax, -0x1c(%rbp)
cmpl $0x0, -0x1c(%rbp)
jge 0x15b01
movl $0x4, %edi
callq 0x64f0
cmpl $0x0, -0x1c(%rbp)
jne 0x15bc9
movq -0x28(%rbp), %rax
movq 0x10(%rax), %rax
testb $0x1, 0xe0(%rax)
je 0x15b61
movq 0x134c5(%rip), %rdi     # 0x28fe8
leaq 0x7749(%rip), %rsi      # 0x1d273
callq 0x6410
movq %rax, -0x30(%rbp)
callq 0x6600
movq -0x30(%rbp), %rdi
movl %eax, %esi
callq 0x66f0
movq %rax, %rdi
leaq 0x7a07(%rip), %rsi      # 0x1d554
callq 0x6410
movq %rax, %rdi
movq 0x1344c(%rip), %rsi     # 0x28fa8
callq 0x6460
movq -0x28(%rbp), %rdi
movq 0x10(%rdi), %rax
movl 0x9c(%rax), %ecx
addl $0x1, %ecx
movl %ecx, 0x9c(%rax)
callq 0x159c0
movq -0x28(%rbp), %rax
movq 0x8(%rax), %rdi
callq 0x161e0
cmpq $0x0, -0x10(%rbp)
je 0x15b9c
movq -0x10(%rbp), %rdi
callq 0xa340
jmp 0x15bae
cmpq $0x0, -0x18(%rbp)
je 0x15bac
movq -0x18(%rbp), %rdi
callq 0xb4f0
jmp 0x15bae
movq -0x28(%rbp), %rdi
movq -0x10(%rbp), %rsi
movq -0x18(%rbp), %rdx
movq (%rdi), %rax
callq *0x48(%rax)
movq -0x28(%rbp), %rdi
callq 0x15a50
movq -0x28(%rbp), %rdi
callq 0x15970
movl -0x1c(%rbp), %eax
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: ryuichiueda[P]GlueLang/src/Executable.cc
// Function: Executable::eval()
bool Executable::eval(void)
{
	for(auto &s : m_nodes){
		if(s->eval())
			continue;

		m_error_msg = "evaluation of args failed";
		throw this;
	}
	return true;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x30(%rbp)
addq $0x18, %rax
movq %rax, -0x10(%rbp)
movq -0x10(%rbp), %rdi
callq 0xc010
movq %rax, -0x18(%rbp)
movq -0x10(%rbp), %rdi
callq 0xc040
movq %rax, -0x20(%rbp)
leaq -0x18(%rbp), %rdi
leaq -0x20(%rbp), %rsi
callq 0xc070
testb $0x1, %al
jne 0x15e89
jmp 0x15eee
leaq -0x18(%rbp), %rdi
callq 0xc0b0
movq %rax, -0x28(%rbp)
movq -0x28(%rbp), %rax
movq (%rax), %rdi
movq (%rdi), %rax
callq *0x10(%rax)
testb $0x1, %al
jne 0x15ea9
jmp 0x15eab
jmp 0x15ee3
movq -0x30(%rbp), %rdi
addq $0x60, %rdi
leaq 0x76a1(%rip), %rsi      # 0x1d55b
callq 0x6580
movl $0x8, %edi
callq 0x6200
movq %rax, %rdi
movq -0x30(%rbp), %rax
movq %rax, (%rdi)
leaq 0x12ab6(%rip), %rsi     # 0x28990
xorl %eax, %eax
movl %eax, %edx
callq 0x66d0
leaq -0x18(%rbp), %rdi
callq 0xc0d0
jmp 0x15e76
movb $0x1, %al
andb $0x1, %al
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: ryuichiueda[P]GlueLang/src/Executable.cc
// Function: Executable::vOptProc(char const*)
void Executable::vOptProc(char const* arg)
{
	if(!m_env->m_v_opt)
		return;

	cerr << "+ pid " << getpid() << " exec line " 
		<< m_start_line << " " << arg << endl;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x18(%rbp)
movq 0x10(%rax), %rax
testb $0x1, 0xe0(%rax)
jne 0x15f67
jmp 0x15fd6
movq 0x1307a(%rip), %rdi     # 0x28fe8
leaq 0x72fe(%rip), %rsi      # 0x1d273
callq 0x6410
movq %rax, -0x20(%rbp)
callq 0x6600
movq -0x20(%rbp), %rdi
movl %eax, %esi
callq 0x66f0
movq %rax, %rdi
leaq 0x75dd(%rip), %rsi      # 0x1d575
callq 0x6410
movq %rax, %rdi
movq -0x18(%rbp), %rax
movl 0x30(%rax), %esi
callq 0x66f0
movq %rax, %rdi
leaq 0x7868(%rip), %rsi      # 0x1d81e
callq 0x6410
movq %rax, %rdi
movq -0x10(%rbp), %rsi
callq 0x6410
movq %rax, %rdi
movq 0x12fd7(%rip), %rsi     # 0x28fa8
callq 0x6460
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax)
// File: ryuichiueda[P]GlueLang/src/Feeder.cc
// Function: Feeder::Feeder(std::basic_ifstream<char, std::char_traits<char>>*)
Feeder::Feeder(ifstream *ifs){
	if (ifs->fail()){
		cerr << "glue: script read error" << endl;
//		return EXIT_FAILURE;
	}
	m_ifs = ifs;
	m_cur_line = 0;
	m_cur_char = 0;

	readAll();
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x30(%rbp)
addq $0x8, %rdi
movq %rdi, -0x38(%rbp)
callq 0xf3e0
movq -0x30(%rbp), %rdi
addq $0x28, %rdi
movq %rdi, -0x28(%rbp)
callq 0x65a0
movq -0x10(%rbp), %rdi
movq (%rdi), %rax
movq -0x18(%rax), %rax
addq %rax, %rdi
callq 0x6030
movb %al, -0x1d(%rbp)
jmp 0x1602e
movb -0x1d(%rbp), %al
testb $0x1, %al
jne 0x16037
jmp 0x16084
movq 0x12faa(%rip), %rdi     # 0x28fe8
leaq 0x7557(%rip), %rsi      # 0x1d59c
callq 0x6410
movq %rax, -0x40(%rbp)
jmp 0x16050
movq -0x40(%rbp), %rdi
movq 0x12f4d(%rip), %rsi     # 0x28fa8
callq 0x6460
jmp 0x16062
jmp 0x16084
movq -0x28(%rbp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x18(%rbp)
movl %eax, -0x1c(%rbp)
callq 0x6280
movq -0x38(%rbp), %rdi
callq 0xf4b0
jmp 0x160aa
movq -0x30(%rbp), %rdi
movq -0x10(%rbp), %rax
movq %rax, (%rdi)
movl $0x0, 0x20(%rdi)
movl $0x0, 0x24(%rdi)
callq 0x160c0
jmp 0x160a4
addq $0x40, %rsp
popq %rbp
retq
movq -0x18(%rbp), %rdi
callq 0x6700
nopw %cs:(%rax,%rax)
// File: ryuichiueda[P]GlueLang/src/Feeder.cc
// Function: Feeder::readLine()
bool Feeder::readLine(void)
{
	string str;
	if(!getline(*m_ifs, str))
		return false;
	m_lines.push_back(str);
	return true;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x60, %rsp
movq %rdi, -0x10(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x58(%rbp)
leaq -0x30(%rbp), %rdi
movq %rdi, -0x50(%rbp)
callq 0x65a0
movq -0x58(%rbp), %rax
movq -0x50(%rbp), %rsi
movq (%rax), %rdi
callq 0x60d0
movq %rax, -0x48(%rbp)
jmp 0x16157
movq -0x48(%rbp), %rdi
movq (%rdi), %rax
movq -0x18(%rax), %rax
addq %rax, %rdi
callq 0x61d0
movb %al, -0x59(%rbp)
jmp 0x1616f
movb -0x59(%rbp), %al
testb $0x1, %al
jne 0x16178
jmp 0x1619c
movb $0x0, -0x1(%rbp)
movl $0x1, -0x40(%rbp)
jmp 0x161ba
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x38(%rbp)
movl %eax, -0x3c(%rbp)
leaq -0x30(%rbp), %rdi
callq 0x6280
jmp 0x161ce
movq -0x58(%rbp), %rdi
addq $0x8, %rdi
leaq -0x30(%rbp), %rsi
callq 0xf750
jmp 0x161af
movb $0x1, -0x1(%rbp)
movl $0x1, -0x40(%rbp)
leaq -0x30(%rbp), %rdi
callq 0x6280
movb -0x1(%rbp), %al
andb $0x1, %al
addq $0x60, %rsp
popq %rbp
retq
movq -0x38(%rbp), %rdi
callq 0x6700
nopw (%rax,%rax)
// File: ryuichiueda[P]GlueLang/src/Feeder.cc
// Function: Feeder::close()
void Feeder::close(void)
{
	if(m_ifs == NULL)
		return;

	m_ifs->close();
	m_ifs = NULL;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x10(%rbp)
cmpq $0x0, (%rax)
jne 0x161fc
jmp 0x16213
movq -0x10(%rbp), %rax
movq (%rax), %rdi
callq 0x60e0
movq -0x10(%rbp), %rax
movq $0x0, (%rax)
addq $0x10, %rsp
popq %rbp
retq
nopl (%rax)
// File: ryuichiueda[P]GlueLang/src/Feeder.cc
// Function: Feeder::path(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>*)
bool Feeder::path(string *ans)
{
	if(outOfRange())
		return false;

	string *p = &m_lines[m_cur_line];
	int i = m_cur_char;
	for(;i < (int)p->length();i++){
		char c = p->at(i);
		if(strchr(" #",c) != NULL)
			break;

		if(! isAlphabet(c) && ! isNum(c) && strchr("._-/",c) == NULL)
			return false;
	}
	if(i == m_cur_char)
		return false;

	*ans = string(p->c_str()+m_cur_char,i-m_cur_char);
	m_cur_char = i;
	blank();
	checkEol(p);
	return true;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x90, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x10(%rbp), %rdi
movq %rdi, -0x68(%rbp)
callq 0x163e0
testb $0x1, %al
jne 0x16246
jmp 0x1624f
movb $0x0, -0x1(%rbp)
jmp 0x163c4
movq -0x68(%rbp), %rax
movq %rax, %rdi
addq $0x8, %rdi
movslq 0x20(%rax), %rsi
callq 0xb680
movq %rax, %rcx
movq -0x68(%rbp), %rax
movq %rcx, -0x20(%rbp)
movl 0x24(%rax), %eax
movl %eax, -0x24(%rbp)
movl -0x24(%rbp), %eax
movl %eax, -0x6c(%rbp)
movq -0x20(%rbp), %rdi
callq 0x6620
movq %rax, %rcx
movl -0x6c(%rbp), %eax
cmpl %ecx, %eax
jge 0x16308
movq -0x20(%rbp), %rdi
movslq -0x24(%rbp), %rsi
callq 0x6770
movb (%rax), %al
movb %al, -0x25(%rbp)
movsbl -0x25(%rbp), %esi
leaq 0x730a(%rip), %rdi      # 0x1d5b4
callq 0x6160
cmpq $0x0, %rax
je 0x162b7
jmp 0x16308
movq -0x68(%rbp), %rdi
movsbl -0x25(%rbp), %esi
callq 0x16420
testb $0x1, %al
jne 0x162f8
movq -0x68(%rbp), %rdi
movsbl -0x25(%rbp), %esi
callq 0x16470
testb $0x1, %al
jne 0x162f8
movsbl -0x25(%rbp), %esi
leaq 0x72d3(%rip), %rdi      # 0x1d5b7
callq 0x6160
cmpq $0x0, %rax
jne 0x162f8
movb $0x0, -0x1(%rbp)
jmp 0x163c4
jmp 0x162fa
movl -0x24(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x24(%rbp)
jmp 0x16274
movq -0x68(%rbp), %rcx
movl -0x24(%rbp), %eax
cmpl 0x24(%rcx), %eax
jne 0x1631d
movb $0x0, -0x1(%rbp)
jmp 0x163c4
movq -0x20(%rbp), %rdi
callq 0x6190
movq -0x68(%rbp), %rcx
movslq 0x24(%rcx), %rdx
movl %edx, %ecx
addq %rdx, %rax
movq %rax, -0x88(%rbp)
movl -0x24(%rbp), %eax
subl %ecx, %eax
cltq
movq %rax, -0x80(%rbp)
leaq -0x49(%rbp), %rdi
movq %rdi, -0x78(%rbp)
callq 0x6710
movq -0x88(%rbp), %rsi
movq -0x80(%rbp), %rdx
movq -0x78(%rbp), %rcx
leaq -0x48(%rbp), %rdi
callq 0x64c0
jmp 0x1636c
movq -0x18(%rbp), %rdi
leaq -0x48(%rbp), %rsi
callq 0x6520
leaq -0x48(%rbp), %rdi
callq 0x6280
leaq -0x49(%rbp), %rdi
callq 0x6480
movq -0x68(%rbp), %rdi
movl -0x24(%rbp), %eax
movl %eax, 0x24(%rdi)
callq 0x164a0
movq -0x68(%rbp), %rdi
movq -0x20(%rbp), %rsi
callq 0x165b0
movb $0x1, -0x1(%rbp)
jmp 0x163c4
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x58(%rbp)
movl %eax, -0x5c(%rbp)
leaq -0x49(%rbp), %rdi
callq 0x6480
jmp 0x163d2
movb -0x1(%rbp), %al
andb $0x1, %al
addq $0x90, %rsp
popq %rbp
retq
movq -0x58(%rbp), %rdi
callq 0x6700
nopl (%rax,%rax)
// File: ryuichiueda[P]GlueLang/src/Feeder.cc
// Function: Feeder::isAlphabet(char)
bool Feeder::isAlphabet(char c)
{
	if(c >= 'a' && c <= 'z')
		return true;
	if(c >= 'A' && c <= 'Z')
		return true;

	return false;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movb %sil, %al
movq %rdi, -0x10(%rbp)
movb %al, -0x11(%rbp)
movsbl -0x11(%rbp), %eax
cmpl $0x61, %eax
jl 0x16446
movsbl -0x11(%rbp), %eax
cmpl $0x7a, %eax
jg 0x16446
movb $0x1, -0x1(%rbp)
jmp 0x16462
movsbl -0x11(%rbp), %eax
cmpl $0x41, %eax
jl 0x1645e
movsbl -0x11(%rbp), %eax
cmpl $0x5a, %eax
jg 0x1645e
movb $0x1, -0x1(%rbp)
jmp 0x16462
movb $0x0, -0x1(%rbp)
movb -0x1(%rbp), %al
andb $0x1, %al
popq %rbp
retq
nopl (%rax)
// File: ryuichiueda[P]GlueLang/src/Feeder.cc
// Function: Feeder::blank()
bool Feeder::blank(void)
{
	if(outOfRange())
		return false;

	string *p = &m_lines[m_cur_line];

	if(p->size() - m_cur_char < 1)
		return false;

	int i = m_cur_char;
	if(strchr(" \t",p->at(i)) == NULL)
		return false;

	for(;i < (int)p->length();i++){
		if(strchr(" \t",p->at(i)) == NULL)
			break;
	}

	m_cur_char = i;
	checkEol(p);
	return true;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movq -0x10(%rbp), %rdi
movq %rdi, -0x28(%rbp)
callq 0x163e0
testb $0x1, %al
jne 0x164bf
jmp 0x164c8
movb $0x0, -0x1(%rbp)
jmp 0x16598
movq -0x28(%rbp), %rax
movq %rax, %rdi
addq $0x8, %rdi
movslq 0x20(%rax), %rsi
callq 0xb680
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rdi
callq 0x62c0
movq -0x28(%rbp), %rcx
movslq 0x24(%rcx), %rcx
subq %rcx, %rax
cmpq $0x1, %rax
jae 0x16503
movb $0x0, -0x1(%rbp)
jmp 0x16598
movq -0x28(%rbp), %rax
movl 0x24(%rax), %eax
movl %eax, -0x1c(%rbp)
movq -0x18(%rbp), %rdi
movslq -0x1c(%rbp), %rsi
callq 0x6770
movsbl (%rax), %esi
leaq 0x7098(%rip), %rdi      # 0x1d5bc
callq 0x6160
cmpq $0x0, %rax
jne 0x16535
movb $0x0, -0x1(%rbp)
jmp 0x16598
jmp 0x16537
movl -0x1c(%rbp), %eax
movl %eax, -0x2c(%rbp)
movq -0x18(%rbp), %rdi
callq 0x6620
movq %rax, %rcx
movl -0x2c(%rbp), %eax
cmpl %ecx, %eax
jge 0x16581
movq -0x18(%rbp), %rdi
movslq -0x1c(%rbp), %rsi
callq 0x6770
movsbl (%rax), %esi
leaq 0x7055(%rip), %rdi      # 0x1d5bc
callq 0x6160
cmpq $0x0, %rax
jne 0x16574
jmp 0x16581
jmp 0x16576
movl -0x1c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x1c(%rbp)
jmp 0x16537
movq -0x28(%rbp), %rdi
movl -0x1c(%rbp), %eax
movl %eax, 0x24(%rdi)
movq -0x18(%rbp), %rsi
callq 0x165b0
movb $0x1, -0x1(%rbp)
movb -0x1(%rbp), %al
andb $0x1, %al
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: ryuichiueda[P]GlueLang/src/Feeder.cc
// Function: Feeder::checkEol(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>*)
void Feeder::checkEol(string *p)
{
	if(m_cur_char < (int)p->length())
		return;

	m_cur_char = 0;
	m_cur_line++;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x20(%rbp)
movl 0x24(%rax), %eax
movl %eax, -0x14(%rbp)
movq -0x10(%rbp), %rdi
callq 0x6620
movq %rax, %rcx
movl -0x14(%rbp), %eax
cmpl %ecx, %eax
jge 0x165e3
jmp 0x165f7
movq -0x20(%rbp), %rax
movl $0x0, 0x24(%rax)
movl 0x20(%rax), %ecx
addl $0x1, %ecx
movl %ecx, 0x20(%rax)
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax)
// File: ryuichiueda[P]GlueLang/src/Feeder.cc
// Function: Feeder::blankLine()
bool Feeder::blankLine(void)
{
	if(outOfRange() || m_cur_char != 0)
		return false;
	
	string *p = &m_lines[m_cur_line];
	for(auto c : *p){
		if(strchr(" \t",c) == NULL)
			return false;
	}

	m_cur_char = p->size();
	checkEol(p);
	return true;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x10(%rbp)
movq -0x10(%rbp), %rdi
movq %rdi, -0x40(%rbp)
callq 0x163e0
testb $0x1, %al
jne 0x16827
movq -0x40(%rbp), %rax
cmpl $0x0, 0x24(%rax)
je 0x16830
movb $0x0, -0x1(%rbp)
jmp 0x168d1
movq -0x40(%rbp), %rax
movq %rax, %rdi
addq $0x8, %rdi
movslq 0x20(%rax), %rsi
callq 0xb680
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rax
movq %rax, -0x20(%rbp)
movq -0x20(%rbp), %rdi
callq 0x6380
movq %rax, -0x28(%rbp)
movq -0x20(%rbp), %rdi
callq 0x6250
movq %rax, -0x30(%rbp)
leaq -0x28(%rbp), %rdi
leaq -0x30(%rbp), %rsi
callq 0x181b0
testb $0x1, %al
jne 0x1687d
jmp 0x168b4
leaq -0x28(%rbp), %rdi
callq 0x181f0
movb (%rax), %al
movb %al, -0x31(%rbp)
movsbl -0x31(%rbp), %esi
leaq 0x6d26(%rip), %rdi      # 0x1d5bc
callq 0x6160
cmpq $0x0, %rax
jne 0x168a7
movb $0x0, -0x1(%rbp)
jmp 0x168d1
jmp 0x168a9
leaq -0x28(%rbp), %rdi
callq 0x18210
jmp 0x1686a
movq -0x18(%rbp), %rdi
callq 0x62c0
movq -0x40(%rbp), %rdi
movl %eax, 0x24(%rdi)
movq -0x18(%rbp), %rsi
callq 0x165b0
movb $0x1, -0x1(%rbp)
movb -0x1(%rbp), %al
andb $0x1, %al
addq $0x40, %rsp
popq %rbp
retq
nopl (%rax)
// File: ryuichiueda[P]GlueLang/src/Feeder.cc
// Function: Feeder::arrayElem(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>*, long*)
bool Feeder::arrayElem(string *name,long *pos)
{
	if(outOfRange())
		return false;

	int bl = m_cur_line;
	int bc = m_cur_char;

	if(!variable(name))
		return false;

	if(atNewLine()){
		setPos(bl,bc);
		return false;
	}

	string *p = &m_lines[m_cur_line];
	int i = m_cur_char;
	if(p->at(i) != '['){
		setPos(bl,bc);
		return false;
	}

	m_cur_char++;
	checkEol(p);

	blank();

	if(!positiveInt(pos)){
		// It must be a positive integer after '['
		// in this stage. (A variable should be permitted
		// in future)
		m_error_msg = "Invalid array pos";
		throw this;
	}

	blank();

	p = &m_lines[m_cur_line];
	if(p->at(m_cur_char) != ']'){
		setPos(bl,bc);
		return false;
	}

	m_cur_char++;
	checkEol(p);
	return true;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movq -0x10(%rbp), %rdi
movq %rdi, -0x40(%rbp)
callq 0x163e0
testb $0x1, %al
jne 0x16907
jmp 0x16910
movb $0x0, -0x1(%rbp)
jmp 0x16a83
movq -0x40(%rbp), %rdi
movl 0x20(%rdi), %eax
movl %eax, -0x24(%rbp)
movl 0x24(%rdi), %eax
movl %eax, -0x28(%rbp)
movq -0x18(%rbp), %rsi
callq 0x16a90
testb $0x1, %al
jne 0x16936
movb $0x0, -0x1(%rbp)
jmp 0x16a83
movq -0x40(%rbp), %rdi
callq 0x16c70
testb $0x1, %al
jne 0x16945
jmp 0x1695d
movq -0x40(%rbp), %rdi
movl -0x24(%rbp), %esi
movl -0x28(%rbp), %edx
callq 0x16c90
movb $0x0, -0x1(%rbp)
jmp 0x16a83
movq -0x40(%rbp), %rax
movq %rax, %rdi
addq $0x8, %rdi
movslq 0x20(%rax), %rsi
callq 0xb680
movq %rax, %rcx
movq -0x40(%rbp), %rax
movq %rcx, -0x30(%rbp)
movl 0x24(%rax), %eax
movl %eax, -0x34(%rbp)
movq -0x30(%rbp), %rdi
movslq -0x34(%rbp), %rsi
callq 0x6770
movsbl (%rax), %eax
cmpl $0x5b, %eax
je 0x169af
movq -0x40(%rbp), %rdi
movl -0x24(%rbp), %esi
movl -0x28(%rbp), %edx
callq 0x16c90
movb $0x0, -0x1(%rbp)
jmp 0x16a83
movq -0x40(%rbp), %rdi
movl 0x24(%rdi), %eax
addl $0x1, %eax
movl %eax, 0x24(%rdi)
movq -0x30(%rbp), %rsi
callq 0x165b0
movq -0x40(%rbp), %rdi
callq 0x164a0
movq -0x40(%rbp), %rdi
movq -0x20(%rbp), %rsi
callq 0x16cb0
testb $0x1, %al
jne 0x16a17
movq -0x40(%rbp), %rdi
addq $0x28, %rdi
leaq 0x6bd1(%rip), %rsi      # 0x1d5bf
callq 0x6580
movl $0x8, %edi
callq 0x6200
movq %rax, %rdi
movq -0x40(%rbp), %rax
movq %rax, (%rdi)
leaq 0x11812(%rip), %rsi     # 0x28220
xorl %eax, %eax
movl %eax, %edx
callq 0x66d0
movq -0x40(%rbp), %rdi
callq 0x164a0
movq -0x40(%rbp), %rax
movq %rax, %rdi
addq $0x8, %rdi
movslq 0x20(%rax), %rsi
callq 0xb680
movq %rax, %rcx
movq -0x40(%rbp), %rax
movq %rcx, -0x30(%rbp)
movq -0x30(%rbp), %rdi
movslq 0x24(%rax), %rsi
callq 0x6770
movsbl (%rax), %eax
cmpl $0x5d, %eax
je 0x16a69
movq -0x40(%rbp), %rdi
movl -0x24(%rbp), %esi
movl -0x28(%rbp), %edx
callq 0x16c90
movb $0x0, -0x1(%rbp)
jmp 0x16a83
movq -0x40(%rbp), %rdi
movl 0x24(%rdi), %eax
addl $0x1, %eax
movl %eax, 0x24(%rdi)
movq -0x30(%rbp), %rsi
callq 0x165b0
movb $0x1, -0x1(%rbp)
movb -0x1(%rbp), %al
andb $0x1, %al
addq $0x40, %rsp
popq %rbp
retq
nop
// File: ryuichiueda[P]GlueLang/src/Feeder.cc
// Function: Feeder::variable(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>*)
bool Feeder::variable(string *ans)
{
	if(outOfRange())
		return false;

	string *p = &m_lines[m_cur_line];
	int i = m_cur_char;
	if(p->at(i) == '>' || p->at(i) == '&')
		return false;

	for(;i < (int)p->length();i++){
		char c = p->at(i);
		if(strchr("> #[",c))
			break;

		if(! isAlphabet(c) && ! isNum(c) && c != '_' && c != '-')
			return false;
	}

	*ans = string(p->c_str()+m_cur_char,i-m_cur_char);
	m_cur_char = i;
	blank();
	checkEol(p);
	return true;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x90, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x10(%rbp), %rdi
movq %rdi, -0x68(%rbp)
callq 0x163e0
testb $0x1, %al
jne 0x16ab6
jmp 0x16abf
movb $0x0, -0x1(%rbp)
jmp 0x16c50
movq -0x68(%rbp), %rax
movq %rax, %rdi
addq $0x8, %rdi
movslq 0x20(%rax), %rsi
callq 0xb680
movq %rax, %rcx
movq -0x68(%rbp), %rax
movq %rcx, -0x20(%rbp)
movl 0x24(%rax), %eax
movl %eax, -0x24(%rbp)
movq -0x20(%rbp), %rdi
movslq -0x24(%rbp), %rsi
callq 0x6770
movsbl (%rax), %eax
cmpl $0x3e, %eax
je 0x16b0e
movq -0x20(%rbp), %rdi
movslq -0x24(%rbp), %rsi
callq 0x6770
movsbl (%rax), %eax
cmpl $0x26, %eax
jne 0x16b17
movb $0x0, -0x1(%rbp)
jmp 0x16c50
jmp 0x16b19
movl -0x24(%rbp), %eax
movl %eax, -0x6c(%rbp)
movq -0x20(%rbp), %rdi
callq 0x6620
movq %rax, %rcx
movl -0x6c(%rbp), %eax
cmpl %ecx, %eax
jge 0x16ba9
movq -0x20(%rbp), %rdi
movslq -0x24(%rbp), %rsi
callq 0x6770
movb (%rax), %al
movb %al, -0x25(%rbp)
movsbl -0x25(%rbp), %esi
leaq 0x6a82(%rip), %rdi      # 0x1d5d1
callq 0x6160
cmpq $0x0, %rax
je 0x16b5c
jmp 0x16ba9
movq -0x68(%rbp), %rdi
movsbl -0x25(%rbp), %esi
callq 0x16420
testb $0x1, %al
jne 0x16b99
movq -0x68(%rbp), %rdi
movsbl -0x25(%rbp), %esi
callq 0x16470
testb $0x1, %al
jne 0x16b99
movsbl -0x25(%rbp), %eax
cmpl $0x5f, %eax
je 0x16b99
movsbl -0x25(%rbp), %eax
cmpl $0x2d, %eax
je 0x16b99
movb $0x0, -0x1(%rbp)
jmp 0x16c50
jmp 0x16b9b
movl -0x24(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x24(%rbp)
jmp 0x16b19
movq -0x20(%rbp), %rdi
callq 0x6190
movq -0x68(%rbp), %rcx
movslq 0x24(%rcx), %rdx
movl %edx, %ecx
addq %rdx, %rax
movq %rax, -0x88(%rbp)
movl -0x24(%rbp), %eax
subl %ecx, %eax
cltq
movq %rax, -0x80(%rbp)
leaq -0x49(%rbp), %rdi
movq %rdi, -0x78(%rbp)
callq 0x6710
movq -0x88(%rbp), %rsi
movq -0x80(%rbp), %rdx
movq -0x78(%rbp), %rcx
leaq -0x48(%rbp), %rdi
callq 0x64c0
jmp 0x16bf8
movq -0x18(%rbp), %rdi
leaq -0x48(%rbp), %rsi
callq 0x6520
leaq -0x48(%rbp), %rdi
callq 0x6280
leaq -0x49(%rbp), %rdi
callq 0x6480
movq -0x68(%rbp), %rdi
movl -0x24(%rbp), %eax
movl %eax, 0x24(%rdi)
callq 0x164a0
movq -0x68(%rbp), %rdi
movq -0x20(%rbp), %rsi
callq 0x165b0
movb $0x1, -0x1(%rbp)
jmp 0x16c50
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x58(%rbp)
movl %eax, -0x5c(%rbp)
leaq -0x49(%rbp), %rdi
callq 0x6480
jmp 0x16c5e
movb -0x1(%rbp), %al
andb $0x1, %al
addq $0x90, %rsp
popq %rbp
retq
movq -0x58(%rbp), %rdi
callq 0x6700
nopw (%rax,%rax)
// File: ryuichiueda[P]GlueLang/src/Feeder.cc
// Function: Feeder::literal(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>*)
bool Feeder::literal(string *ans)
{
	try{
		return literalNoEsc(ans) || literalEsc(ans);
	}catch(...){
		throw this;
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x28(%rbp)
movq -0x10(%rbp), %rsi
callq 0x16fe0
movb %al, -0x1d(%rbp)
jmp 0x16f46
movb -0x1d(%rbp), %cl
movb $0x1, %al
testb $0x1, %cl
movb %al, -0x29(%rbp)
jne 0x16f6f
jmp 0x16f55
movq -0x28(%rbp), %rdi
movq -0x10(%rbp), %rsi
callq 0x17180
movb %al, -0x2a(%rbp)
jmp 0x16f67
movb -0x2a(%rbp), %al
movb %al, -0x29(%rbp)
jmp 0x16f6f
movb -0x29(%rbp), %al
andb $0x1, %al
addq $0x30, %rsp
popq %rbp
retq
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x18(%rbp)
movl %eax, -0x1c(%rbp)
movq -0x18(%rbp), %rdi
callq 0x6180
movl $0x8, %edi
callq 0x6200
movq %rax, %rdi
movq -0x28(%rbp), %rax
movq %rax, (%rdi)
leaq 0x11276(%rip), %rsi     # 0x28220
xorl %eax, %eax
movl %eax, %edx
callq 0x66d0
jmp 0x16fdb
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x18(%rbp)
movl %eax, -0x1c(%rbp)
callq 0x6690
jmp 0x16fc8
jmp 0x16fca
movq -0x18(%rbp), %rdi
callq 0x6700
movq %rax, %rdi
callq 0x7f90
nopl (%rax,%rax)
// File: ryuichiueda[P]GlueLang/src/Feeder.cc
// Function: Feeder::literalNoEsc(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>*)
bool Feeder::literalNoEsc(string *ans)
{
	if(outOfRange())
		return false;

	string *p = &m_lines[m_cur_line];
	int i = m_cur_char;

	if(p->at(i) != '-' && ! isNum(p->at(i)))
		return false;

	i++;

	for(;i < (int)p->length();i++){
		if(strchr(" \t",p->at(i)))
			break;
	}

	*ans = string(p->c_str()+m_cur_char,i-m_cur_char);
	m_cur_char = i;
	blank();
	checkEol(p);
	return true;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x90, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x10(%rbp), %rdi
movq %rdi, -0x68(%rbp)
callq 0x163e0
testb $0x1, %al
jne 0x17006
jmp 0x1700f
movb $0x0, -0x1(%rbp)
jmp 0x17169
movq -0x68(%rbp), %rax
movq %rax, %rdi
addq $0x8, %rdi
movslq 0x20(%rax), %rsi
callq 0xb680
movq %rax, %rcx
movq -0x68(%rbp), %rax
movq %rcx, -0x20(%rbp)
movl 0x24(%rax), %eax
movl %eax, -0x24(%rbp)
movq -0x20(%rbp), %rdi
movslq -0x24(%rbp), %rsi
callq 0x6770
movsbl (%rax), %eax
cmpl $0x2d, %eax
je 0x1706f
movq -0x20(%rbp), %rdi
movslq -0x24(%rbp), %rsi
callq 0x6770
movq -0x68(%rbp), %rdi
movsbl (%rax), %esi
callq 0x16470
testb $0x1, %al
jne 0x1706f
movb $0x0, -0x1(%rbp)
jmp 0x17169
movl -0x24(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x24(%rbp)
movl -0x24(%rbp), %eax
movl %eax, -0x6c(%rbp)
movq -0x20(%rbp), %rdi
callq 0x6620
movq %rax, %rcx
movl -0x6c(%rbp), %eax
cmpl %ecx, %eax
jge 0x170c2
movq -0x20(%rbp), %rdi
movslq -0x24(%rbp), %rsi
callq 0x6770
movsbl (%rax), %esi
leaq 0x6514(%rip), %rdi      # 0x1d5bc
callq 0x6160
cmpq $0x0, %rax
je 0x170b5
jmp 0x170c2
jmp 0x170b7
movl -0x24(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x24(%rbp)
jmp 0x17078
movq -0x20(%rbp), %rdi
callq 0x6190
movq -0x68(%rbp), %rcx
movslq 0x24(%rcx), %rdx
movl %edx, %ecx
addq %rdx, %rax
movq %rax, -0x88(%rbp)
movl -0x24(%rbp), %eax
subl %ecx, %eax
cltq
movq %rax, -0x80(%rbp)
leaq -0x49(%rbp), %rdi
movq %rdi, -0x78(%rbp)
callq 0x6710
movq -0x88(%rbp), %rsi
movq -0x80(%rbp), %rdx
movq -0x78(%rbp), %rcx
leaq -0x48(%rbp), %rdi
callq 0x64c0
jmp 0x17111
movq -0x18(%rbp), %rdi
leaq -0x48(%rbp), %rsi
callq 0x6520
leaq -0x48(%rbp), %rdi
callq 0x6280
leaq -0x49(%rbp), %rdi
callq 0x6480
movq -0x68(%rbp), %rdi
movl -0x24(%rbp), %eax
movl %eax, 0x24(%rdi)
callq 0x164a0
movq -0x68(%rbp), %rdi
movq -0x20(%rbp), %rsi
callq 0x165b0
movb $0x1, -0x1(%rbp)
jmp 0x17169
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x58(%rbp)
movl %eax, -0x5c(%rbp)
leaq -0x49(%rbp), %rdi
callq 0x6480
jmp 0x17177
movb -0x1(%rbp), %al
andb $0x1, %al
addq $0x90, %rsp
popq %rbp
retq
movq -0x58(%rbp), %rdi
callq 0x6700
// File: ryuichiueda[P]GlueLang/src/Feeder.cc
// Function: Feeder::comment()
bool Feeder::comment(void)
{
	int ln,ch;
	getPos(&ln,&ch);

	blank();
	while(blankLine()){ };
	if(outOfRange())
		return false;

	if(atEnd())
		return true;

	string *p = &m_lines[m_cur_line];
	if((int)p->size() <= m_cur_char || p->at(m_cur_char) != '#'){
		setPos(ln,ch);
		return false;
	}

	m_cur_char++;

	lineResidual(NULL);
	while(blankLine()){ };
	return true;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movq -0x10(%rbp), %rdi
movq %rdi, -0x28(%rbp)
leaq -0x14(%rbp), %rsi
leaq -0x18(%rbp), %rdx
callq 0x17610
movq -0x28(%rbp), %rdi
callq 0x164a0
movq -0x28(%rbp), %rdi
callq 0x16800
testb $0x1, %al
jne 0x17549
jmp 0x1754b
jmp 0x1753a
movq -0x28(%rbp), %rdi
callq 0x163e0
testb $0x1, %al
jne 0x1755a
jmp 0x17563
movb $0x0, -0x1(%rbp)
jmp 0x175fe
movq -0x28(%rbp), %rdi
callq 0x174c0
testb $0x1, %al
jne 0x17572
jmp 0x1757b
movb $0x1, -0x1(%rbp)
jmp 0x175fe
movq -0x28(%rbp), %rax
movq %rax, %rdi
addq $0x8, %rdi
movslq 0x20(%rax), %rsi
callq 0xb680
movq %rax, -0x20(%rbp)
movq -0x20(%rbp), %rdi
callq 0x62c0
movq -0x28(%rbp), %rcx
cmpl 0x24(%rcx), %eax
jle 0x175be
movq -0x28(%rbp), %rax
movq -0x20(%rbp), %rdi
movslq 0x24(%rax), %rsi
callq 0x6770
movsbl (%rax), %eax
cmpl $0x23, %eax
je 0x175d3
movq -0x28(%rbp), %rdi
movl -0x14(%rbp), %esi
movl -0x18(%rbp), %edx
callq 0x16c90
movb $0x0, -0x1(%rbp)
jmp 0x175fe
movq -0x28(%rbp), %rdi
movl 0x24(%rdi), %eax
addl $0x1, %eax
movl %eax, 0x24(%rdi)
xorl %eax, %eax
movl %eax, %esi
callq 0x17640
movq -0x28(%rbp), %rdi
callq 0x16800
testb $0x1, %al
jne 0x175f8
jmp 0x175fa
jmp 0x175e9
movb $0x1, -0x1(%rbp)
movb -0x1(%rbp), %al
andb $0x1, %al
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax)