LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_cpp_makefile_star2_O2/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 %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x300, %rsp            # imm = 0x300
movq %rdx, %rbx
movq %rsi, %r14
movq %rdi, %r15
pushq $0x10
popq %rdi
callq 0x6030
movq %rax, %r12
movl $0xc0, %esi
addq 0x10(%r15), %rsi
leaq 0x5770(%rip), %rdx      # 0x115ee
leaq 0xf8(%rsp), %r13
movq %r13, %rdi
callq 0x70c7
leaq 0xb0(%r15), %rdx
leaq 0x8(%rsp), %rdi
movq %r13, %rsi
callq 0x75a1
leaq 0xf8(%rsp), %rdi
callq 0x6150
movq 0x8(%rsp), %r13
movq %r13, (%r12)
andq $0x0, 0x8(%r12)
movq %r15, %rdi
movq %r13, %rsi
callq 0xc8da
leaq 0xf8(%rsp), %rdi
pushq $0x8
popq %rdx
movq %r13, %rsi
callq 0x6590
leaq 0x28(%rsp), %rdi
leaq 0xf8(%rsp), %rsi
callq 0xc95c
movq 0x10(%r15), %rdi
movq %r12, %rsi
callq 0x977a
movq 0x10(%r15), %rdx
leaq 0x70(%rsp), %rdi
leaq 0x28(%rsp), %rsi
xorl %ecx, %ecx
callq 0xf490
leaq 0x70(%rsp), %rdi
movb $0x1, 0x85(%rdi)
callq 0xf504
leaq 0x70(%rsp), %rdi
movq %r14, %rsi
movq %rbx, %rdx
callq 0xf8b8
leaq 0x70(%rsp), %rdi
callq 0xf4ac
leaq 0x28(%rsp), %rdi
callq 0xca02
leaq 0xf8(%rsp), %rdi
callq 0x60c0
leaq 0x8(%rsp), %rdi
callq 0x6150
addq $0x300, %rsp            # imm = 0x300
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
jmp 0xbf6e
movq %rax, %rbx
jmp 0xbf99
movq %rax, %rbx
jmp 0xbfa3
jmp 0xbf7a
movq %rax, %rbx
jmp 0xbfb0
movq %rax, %rbx
leaq 0xf8(%rsp), %rdi
jmp 0xbfb5
movq %rax, %rbx
leaq 0x70(%rsp), %rdi
callq 0xf4ac
leaq 0x28(%rsp), %rdi
callq 0xca02
leaq 0xf8(%rsp), %rdi
callq 0x60c0
leaq 0x8(%rsp), %rdi
callq 0x6150
movq %rbx, %rdi
callq 0x6560
nop
// File: /workspace/github_cpp_makefile_star2_O2/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 %rbx
movq %rdi, %rbx
callq 0x8cfc
leaq 0xd508(%rip), %rax      # 0x19938
movq %rax, (%rbx)
xorps %xmm0, %xmm0
andq $0x0, 0xa8(%rbx)
movups %xmm0, 0x98(%rbx)
orq $-0x1, 0x88(%rbx)
orl $-0x1, 0x90(%rbx)
movb $0x0, 0x85(%rbx)
popq %rbx
retq
nop
// File: /workspace/github_cpp_makefile_star2_O2/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 %r15
pushq %r14
pushq %rbx
movq %rdi, %rbx
leaq 0x48(%rdi), %r14
movl $0xc8, %edi
callq 0x6320
movq %rax, %r15
movq 0x8(%rbx), %rsi
movq 0x10(%rbx), %rdx
movq %rax, %rdi
movq %r14, %rcx
callq 0xec20
movq %rbx, %rdi
movq %r15, %rsi
callq 0x8e02
testb %al, %al
jne 0xc51d
movl $0xd0, %edi
callq 0x6320
movq %rax, %r15
movq 0x8(%rbx), %rsi
movq 0x10(%rbx), %rdx
movq %rax, %rdi
movq %r14, %rcx
callq 0x77c0
movq %rbx, %rdi
movq %r15, %rsi
callq 0x8e02
testb %al, %al
jne 0xc51d
movl $0xd0, %edi
callq 0x6320
movq %rax, %r15
movq 0x8(%rbx), %rsi
movq 0x10(%rbx), %rdx
movq %rax, %rdi
movq %r14, %rcx
callq 0x75c0
movq %rbx, %rdi
movq %r15, %rsi
callq 0x8e02
testb %al, %al
je 0xc545
movq 0x8(%rbx), %rdi
callq 0xd574
testb %al, %al
jne 0xc545
movq 0x8(%rbx), %rdi
callq 0xd09a
testb %al, %al
jne 0xc545
movq 0x8(%rbx), %rdi
callq 0xcc02
jmp 0xc490
popq %rbx
popq %r14
popq %r15
retq
jmp 0xc54d
movq %rax, %rbx
movl $0xd0, %esi
jmp 0xc55f
movq %rax, %rbx
movl $0xc8, %esi
movq %r15, %rdi
callq 0x6330
movq %rbx, %rdi
callq 0x6560
nop
// File: /workspace/github_cpp_makefile_star2_O2/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 %rbx
movq %rdi, %rbx
movl 0x90(%rdi), %edi
testl %edi, %edi
js 0xc583
callq 0x65e0
movl 0x88(%rbx), %eax
movl 0x8c(%rbx), %edi
movl %eax, 0x90(%rbx)
popq %rbx
jmp 0x65e0
nop
// File: /workspace/github_cpp_makefile_star2_O2/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 %rbx
movq %rdi, %rbx
cmpl $0x0, 0x8c(%rdi)
js 0xc5b4
movl 0x88(%rbx), %edi
callq 0x65e0
movl 0x90(%rbx), %edi
testl %edi, %edi
jle 0xc5d0
xorl %esi, %esi
callq 0x62e0
movl 0x90(%rbx), %edi
callq 0x65e0
movl 0x8c(%rbx), %edi
cmpl $0x2, %edi
jl 0xc5ef
pushq $0x1
popq %rsi
callq 0x62e0
movl 0x8c(%rbx), %edi
popq %rbx
jmp 0x65e0
popq %rbx
retq
nop
// File: /workspace/github_cpp_makefile_star2_O2/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
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movq %rdx, %r14
movq %rsi, %r15
movq %rdi, %rbx
movq 0xd97c(%rip), %rdi      # 0x19fc0
callq 0x61f0
movq (%rbx), %rax
movq %rbx, %rdi
callq *0x10(%rax)
callq 0x60d0
testl %eax, %eax
js 0xc672
je 0xc67a
movl %eax, %ebp
movq %rbx, %rdi
callq 0xc570
movl %ebp, %eax
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
pushq $0x4
popq %rdi
callq 0x63a0
movq 0x10(%rbx), %rax
cmpb $0x1, 0xe0(%rax)
jne 0xc6c7
movq 0xd95a(%rip), %rdi      # 0x19fe8
leaq 0x4bde(%rip), %rsi      # 0x11273
callq 0x6310
movq %rax, %r12
callq 0x6480
movq %r12, %rdi
movl %eax, %esi
callq 0x6550
leaq 0x4ed8(%rip), %rsi      # 0x1158b
movq %rax, %rdi
callq 0x6310
movq %rax, %rdi
callq 0x6180
movq 0x10(%rbx), %rax
incl 0x9c(%rax)
movq %rbx, %rdi
callq 0xc59c
movq 0x8(%rbx), %rdi
callq 0xca94
testq %r15, %r15
jne 0xc6f2
testq %r14, %r14
je 0xc6fa
movq %r14, %rdi
callq 0x8c3e
jmp 0xc6fa
movq %r15, %rdi
callq 0x8360
movq (%rbx), %rax
movq %rbx, %rdi
movq %r15, %rsi
movq %r14, %rdx
callq *0x48(%rax)
movq %rbx, %rdi
callq 0xc5f2
nop
// File: /workspace/github_cpp_makefile_star2_O2/ryuichiueda[P]GlueLang/src/Executable.cc
// Function: Executable::makeArgv()
char** Executable::makeArgv(void)
{
	auto argv = new char* [m_nodes.size() + 1 + m_add_args.size()];
	
	argv[0] = (char *)((ArgIntCom *)m_nodes[0])->m_evaled_text.c_str();

	int i = 1;
	for (;i < (int)m_nodes.size();i++){
		argv[i] = (char *)((Arg *)m_nodes[i])->getEvaledString();
	}
	for(auto a : m_add_args){
		argv[i] = new char [a.size()+1];
		strcpy(argv[i],a.c_str());
		argv[i][a.size()] = '\0';
		i++;
	}

	argv[m_nodes.size() + m_add_args.size()] = NULL;
	return argv;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x38, %rsp
movq %rdi, %rbx
movq 0x18(%rdi), %r15
movq 0x20(%rdi), %r12
movq %r12, %rax
subq %r15, %rax
sarq $0x3, %rax
movq 0xa0(%rdi), %rcx
subq 0x98(%rdi), %rcx
sarq $0x5, %rcx
leaq (%rax,%rcx), %rdx
addq %rcx, %rax
incq %rax
shrq $0x3d, %rax
leaq 0x8(,%rdx,8), %rcx
xorl %edi, %edi
negq %rax
sbbq %rdi, %rdi
orq %rcx, %rdi
callq 0x6030
movq (%r15), %rcx
movq 0xa8(%rcx), %rcx
movq %rcx, (%rax)
movq %rax, 0x8(%rsp)
leaq 0x8(%rax), %rbp
pushq $0x1
popq %r14
subq %r15, %r12
shrq $0x3, %r12
movslq %r12d, %rax
cmpq %rax, %r14
jge 0xc7b5
movq (%r15,%r14,8), %rdi
movq (%rdi), %rax
callq *0x40(%rax)
movq %rax, (%rbp)
incq %r14
movq 0x18(%rbx), %r15
movq 0x20(%rbx), %r12
addq $0x8, %rbp
jmp 0xc787
movq 0x98(%rbx), %r15
movq 0xa0(%rbx), %rax
movq %rax, 0x10(%rsp)
leaq 0x18(%rsp), %r14
cmpq 0x10(%rsp), %r15
je 0xc81a
movq %r14, %rdi
movq %r15, %rsi
callq 0x6420
movq 0x20(%rsp), %r12
leaq 0x1(%r12), %rdi
callq 0x6030
movq %rax, %r13
movq %rax, (%rbp)
movq 0x18(%rsp), %rsi
movq %rax, %rdi
callq 0x62f0
movb $0x0, (%r13,%r12)
movq %r14, %rdi
callq 0x6150
addq $0x20, %r15
addq $0x8, %rbp
jmp 0xc7cd
movq 0x20(%rbx), %rsi
movq 0xa0(%rbx), %rcx
subq 0x18(%rbx), %rsi
subq 0x98(%rbx), %rcx
movq 0x8(%rsp), %rax
movq %rax, %rdx
addq %rsi, %rdx
sarq $0x2, %rcx
andq $0x0, (%rcx,%rdx)
addq $0x38, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
leaq 0x18(%rsp), %rdi
callq 0x6150
movq %rbx, %rdi
callq 0x6560
// File: /workspace/github_cpp_makefile_star2_O2/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 %r15
pushq %r14
pushq %rbx
movq %rdi, %rbx
movq 0x18(%rdi), %r14
movq 0x20(%rdi), %r15
cmpq %r15, %r14
je 0xc8ba
movq (%r14), %rdi
movq (%rdi), %rax
callq *0x10(%rax)
addq $0x8, %r14
testb %al, %al
jne 0xc878
leaq 0x60(%rbx), %rdi
leaq 0x4cf9(%rip), %rsi      # 0x11592
callq 0x6400
pushq $0x8
popq %rdi
callq 0x6190
movq %rbx, (%rax)
leaq 0xd0f0(%rip), %rsi      # 0x199a0
movq %rax, %rdi
xorl %edx, %edx
callq 0x6540
movb $0x1, %al
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_cpp_makefile_star2_O2/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:
movq 0x10(%rdi), %rax
cmpb $0x1, 0xe0(%rax)
jne 0xc959
pushq %r15
pushq %r14
pushq %rbx
movq %rsi, %rbx
movq %rdi, %r14
movq 0xd6ef(%rip), %rdi      # 0x19fe8
leaq 0x4973(%rip), %rsi      # 0x11273
callq 0x6310
movq %rax, %r15
callq 0x6480
movq %r15, %rdi
movl %eax, %esi
callq 0x6550
leaq 0x4c8e(%rip), %rsi      # 0x115ac
movq %rax, %rdi
callq 0x6310
movl 0x30(%r14), %esi
movq %rax, %rdi
callq 0x6550
leaq 0x4f16(%rip), %rsi      # 0x1184f
movq %rax, %rdi
callq 0x6310
movq %rax, %rdi
movq %rbx, %rsi
callq 0x6310
movq %rax, %rdi
popq %rbx
popq %r14
popq %r15
jmp 0x6180
retq
nop
// File: /workspace/github_cpp_makefile_star2_O2/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 %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rsi, %r12
movq %rdi, %r15
leaq 0x8(%rdi), %rbx
xorps %xmm0, %xmm0
andq $0x0, 0x18(%rdi)
movups %xmm0, 0x8(%rdi)
leaq 0x28(%rdi), %r14
leaq 0x38(%rdi), %rax
movq %rax, 0x28(%rdi)
andq $0x0, 0x30(%rdi)
movb $0x0, 0x38(%rdi)
movq (%rsi), %rax
movq -0x18(%rax), %rax
testb $0x5, 0x20(%rsi,%rax)
je 0xc9b8
movq 0xd644(%rip), %rdi      # 0x19fe8
leaq 0x4c28(%rip), %rsi      # 0x115d3
callq 0x6310
movq %rax, %rdi
callq 0x6180
movq %r12, (%r15)
andq $0x0, 0x20(%r15)
movq %r15, %rdi
callq 0xc9f0
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
movq %rax, %r15
movq %r14, %rdi
callq 0x6150
movq %rbx, %rdi
callq 0xa256
movq %r15, %rdi
callq 0x6560
nop
// File: /workspace/github_cpp_makefile_star2_O2/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 %r14
pushq %rbx
pushq %rax
movq %rsi, %r14
movq %rdi, %rbx
callq 0xd266
movl %eax, %ecx
movb $0x1, %al
testb %cl, %cl
jne 0xd222
movq %rbx, %rdi
movq %r14, %rsi
callq 0xd36c
addq $0x8, %rsp
popq %rbx
popq %r14
retq
movq %rax, %rdi
callq 0x6120
pushq $0x8
popq %rdi
callq 0x6190
movq %rbx, (%rax)
leaq 0xbfec(%rip), %rsi      # 0x19230
movq %rax, %rdi
xorl %edx, %edx
callq 0x6540
movq %rax, %rbx
callq 0x6500
movq %rbx, %rdi
callq 0x6560
movq %rax, %rdi
callq 0x77b5
// File: /workspace/github_cpp_makefile_star2_O2/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
pushq %r15
pushq %r14
pushq %rbx
subq $0x18, %rsp
movq %rdi, %rbx
movsd 0x20(%rdi), %xmm0
movaps %xmm0, (%rsp)
callq 0xcc02
movq %rbx, %rdi
callq 0xce00
testb %al, %al
jne 0xd58f
movslq 0x20(%rbx), %r15
movq 0x8(%rbx), %r14
movq 0x10(%rbx), %rax
subq %r14, %rax
shrq $0x5, %rax
cmpl %eax, %r15d
jge 0xd604
movq %rbx, %rdi
callq 0xd55e
movb $0x1, %bpl
testb %al, %al
jne 0xd606
shlq $0x5, %r15
movslq 0x24(%rbx), %rsi
cmpl 0x8(%r14,%r15), %esi
jge 0xd5fc
addq %r15, %r14
movq %r14, %rdi
callq 0x65c0
cmpb $0x23, (%rax)
jne 0xd5fc
incl 0x24(%rbx)
movq %rbx, %rdi
xorl %esi, %esi
callq 0xd620
movq %rbx, %rdi
callq 0xce00
testb %al, %al
jne 0xd5ee
jmp 0xd606
movaps (%rsp), %xmm0
movlps %xmm0, 0x20(%rbx)
xorl %ebp, %ebp
movl %ebp, %eax
addq $0x18, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O2/ryuichiueda[P]GlueLang/src/Feeder.cc
// Function: Feeder::printPart(int, int, int, int)
void Feeder::printPart(int from, int from_char, int to, int to_char)
{
	if(from < 0 || from >= (int)m_lines.size())
		return;

	auto *ln = &m_lines.at(from);
	for(int i=0;i<from_char;i++)
		cerr << ' ';
	for(int i=from_char;i < (int)ln->size();i++){
		cerr << ln->at(i);
	}
	cerr << endl;

	if(to > (int)m_lines.size())
		return;

	for(int i=from+1;i<to;i++){
		cerr << m_lines.at(i) << endl;
	}

	if(to == (int)m_lines.size())
		return;

	ln = &m_lines.at(to);
	for(int i=0;i<=to_char;i++){
		if(i < (int)ln->size())
			cerr << ln->at(i);
	}
	cerr << endl;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
testl %esi, %esi
js 0xd88d
movq 0x10(%rdi), %rax
subq 0x8(%rdi), %rax
shrq $0x5, %rax
cmpl %esi, %eax
jle 0xd88d
movl %ecx, %ebp
movl %edx, %ebx
movl %r8d, 0x4(%rsp)
movq %rdi, 0x10(%rsp)
addq $0x8, %rdi
movl %esi, %r12d
movq %rdi, 0x8(%rsp)
movq %r12, %rsi
callq 0x8cba
movq %rax, %r13
xorl %r15d, %r15d
testl %ebx, %ebx
movl %ebx, (%rsp)
cmovgl %ebx, %r15d
movq 0xc80c(%rip), %r14      # 0x19fe8
pushq $0x20
popq %rbx
subl $0x1, %r15d
jb 0xd7f1
movq %r14, %rdi
movl %ebx, %esi
callq 0x6390
jmp 0xd7df
movslq (%rsp), %rbx
movq 0xc7ec(%rip), %r14      # 0x19fe8
movq 0x10(%rsp), %r15
movslq 0x8(%r13), %rax
cmpq %rax, %rbx
jge 0xd825
movq %r13, %rdi
movq %rbx, %rsi
callq 0x65c0
movsbl (%rax), %esi
movq %r14, %rdi
callq 0x6390
incq %rbx
jmp 0xd801
movq 0xc7bc(%rip), %rdi      # 0x19fe8
callq 0x6180
movq 0x10(%r15), %rax
subq 0x8(%r15), %rax
shrq $0x5, %rax
cmpl %ebp, %eax
movl 0x4(%rsp), %r14d
movq 0x8(%rsp), %r13
jl 0xd88d
incq %r12
movq 0xc793(%rip), %rbx      # 0x19fe8
cmpl %ebp, %r12d
jge 0xd87d
movq %r13, %rdi
movq %r12, %rsi
callq 0x8cba
movq %rbx, %rdi
movq %rax, %rsi
callq 0x62b0
movq %rax, %rdi
callq 0x6180
incq %r12
jmp 0xd855
movq 0x10(%r15), %rax
subq 0x8(%r15), %rax
shrq $0x5, %rax
cmpl %ebp, %eax
jne 0xd89c
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movslq %ebp, %rsi
movq %r13, %rdi
callq 0x8cba
movq %rax, %rbx
movslq %r14d, %r12
xorl %r14d, %r14d
movq 0xc731(%rip), %r15      # 0x19fe8
cmpq %r12, %r14
jg 0xd8e0
movslq 0x8(%rbx), %rax
cmpq %rax, %r14
jge 0xd8db
movq %rbx, %rdi
movq %r14, %rsi
callq 0x65c0
movsbl (%rax), %esi
movq %r15, %rdi
callq 0x6390
incq %r14
jmp 0xd8b7
movq 0xc701(%rip), %rdi      # 0x19fe8
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x6180
// File: /workspace/github_cpp_makefile_star2_O2/ryuichiueda[P]GlueLang/src/Feeder.cc
// Function: Feeder::printErrorPart(int, int, int, int)
void Feeder::printErrorPart(int from, int from_char, int to, int to_char)
{
	for(int i=from;i<=to;i++){
		if(i != from && i == to && to_char == 0)
			break;

		string left = "\tline" + to_string(i+1) + ": ";
		cerr << left <<  m_lines[i] << endl;
		if(i == from){
			cerr << "\t";
			for(int j=1-left.size();j<from_char;j++)
				cerr << " ";
			cerr << "^" << endl;
		}
	}
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x88, %rsp
movl %r8d, 0x4(%rsp)
movl %edx, %ebp
movq %rdi, 0x18(%rsp)
movslq %esi, %r13
movslq %ecx, %rax
movq %rax, 0x8(%rsp)
leaq 0x48(%rsp), %r14
movq 0xc6ba(%rip), %rbx      # 0x19fe8
movq %r13, %rax
cmpq 0x8(%rsp), %rax
jg 0xda3f
cmpq %r13, %rax
je 0xd953
cmpl $0x0, 0x4(%rsp)
jne 0xd953
cmpq 0x8(%rsp), %rax
je 0xda3f
movq %r13, %r12
movq %rax, 0x10(%rsp)
leaq 0x1(%rax), %rsi
leaq 0x28(%rsp), %rdi
movq %rsi, 0x20(%rsp)
callq 0x8440
leaq 0x68(%rsp), %r13
movq %r13, %rdi
leaq 0x3cba(%rip), %rsi      # 0x11637
leaq 0x28(%rsp), %rdx
callq 0x909f
movq %r14, %rdi
movq %r13, %rsi
leaq 0x3eba(%rip), %rdx      # 0x1184e
callq 0x7137
movq %r13, %rdi
callq 0x6150
leaq 0x28(%rsp), %rdi
callq 0x6150
movq %rbx, %rdi
movq %r14, %rsi
callq 0x62b0
movq %r12, %r13
leaq 0x3e8f(%rip), %r12      # 0x1184f
movq 0x10(%rsp), %rsi
shlq $0x5, %rsi
movq 0x18(%rsp), %rcx
addq 0x8(%rcx), %rsi
movq %rax, %rdi
callq 0x62b0
movq %rax, %rdi
callq 0x6180
cmpq %r13, 0x10(%rsp)
jne 0xda2d
movq %rbx, %rdi
leaq 0x3e28(%rip), %rsi      # 0x1181b
callq 0x6310
pushq $0x1
popq %r15
subl 0x50(%rsp), %r15d
cmpl %ebp, %r15d
jge 0xda16
movq %rbx, %rdi
movq %r12, %rsi
callq 0x6310
incl %r15d
jmp 0xda01
movq %rbx, %rdi
leaq 0x3c1d(%rip), %rsi      # 0x1163d
callq 0x6310
movq %rax, %rdi
callq 0x6180
movq %r14, %rdi
callq 0x6150
movq 0x20(%rsp), %rax
jmp 0xd931
addq $0x88, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
jmp 0xda63
movq %rax, %rbx
leaq 0x68(%rsp), %rdi
callq 0x6150
leaq 0x28(%rsp), %rdi
jmp 0xda74
jmp 0xda6c
movq %rax, %rbx
leaq 0x48(%rsp), %rdi
callq 0x6150
movq %rbx, %rdi
callq 0x6560
nop
// File: /workspace/github_cpp_makefile_star2_O2/ryuichiueda[P]GlueLang/src/Feeder.cc
// Function: Feeder::countIndent()
int Feeder::countIndent(void)
{
	if(atEnd())
		return 0;

	if(m_cur_char != 0)
		return -1;

	string *p = &m_lines[m_cur_line];
	int i = 0;
	while(i < (int)p->size()){
		if(strchr(" \t",p->at(i)) == NULL)
			break;

		i++;
	}

	return i;
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rdi, %r15
callq 0xd55e
xorl %ebx, %ebx
testb %al, %al
jne 0xda9f
cmpl $0x0, 0x24(%r15)
je 0xdaa7
pushq $-0x1
popq %rbx
movl %ebx, %eax
popq %rbx
popq %r14
popq %r15
retq
movslq 0x20(%r15), %r14
shlq $0x5, %r14
addq 0x8(%r15), %r14
xorl %ebx, %ebx
movabsq $0x100000201, %r15      # imm = 0x100000201
movslq 0x8(%r14), %rax
cmpq %rax, %rbx
jge 0xda9f
movq %r14, %rdi
movq %rbx, %rsi
callq 0x65c0
movzbl (%rax), %eax
cmpq $0x20, %rax
ja 0xda9f
btq %rax, %r15
jae 0xda9f
incq %rbx
jmp 0xdabf
nop
// File: /workspace/github_cpp_makefile_star2_O2/ryuichiueda[P]GlueLang/src/Feeder.cc
// Function: Feeder::block(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>*, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>)
bool Feeder::block(string *ans,string op)
{
	if(!str(op)){
                return false;
	}

        while(blankLine()){
		*ans += '\n';
        }

	int indent = countIndent();
	int idt = INT_MAX;
        while(idt >= indent){//write the script file with removal of the indent
		string tmp;
                lineResidual(&tmp);
                *ans += tmp.substr(indent,tmp.size()-indent);
		*ans += '\n';

                while(blankLine()){
			*ans += '\n';
                }
                idt = countIndent();
        }
	return true;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x68, %rsp
movq %rsi, %rbx
movq %rdi, %r14
leaq 0x28(%rsp), %r15
movq %r15, %rdi
movq %rdx, %rsi
callq 0x6420
movq %r14, %rdi
movq %r15, %rsi
callq 0xd6ae
movl %eax, %ebp
leaq 0x28(%rsp), %rdi
callq 0x6150
movb %bpl, 0x3(%rsp)
testb %bpl, %bpl
je 0xdc64
pushq $0xa
popq %rbp
movq %r14, %rdi
callq 0xce00
testb %al, %al
je 0xdbb0
movq %rbx, %rdi
movl %ebp, %esi
callq 0x6290
jmp 0xdb98
movq %r14, %rdi
callq 0xda82
movl %eax, 0x4(%rsp)
movslq %eax, %r12
movl $0x7fffffff, %r13d      # imm = 0x7FFFFFFF
leaq 0x48(%rsp), %rbp
pushq $0xa
popq %r15
cmpl 0x4(%rsp), %r13d
jl 0xdc64
leaq 0x18(%rsp), %rax
movq %rax, 0x8(%rsp)
andq $0x0, 0x10(%rsp)
movb $0x0, 0x18(%rsp)
movq %r14, %rdi
leaq 0x8(%rsp), %rsi
callq 0xd620
movq 0x10(%rsp), %rcx
subq %r12, %rcx
movq %rbp, %rdi
leaq 0x8(%rsp), %rsi
movq %r12, %rdx
callq 0x6340
movq %rbx, %rdi
movq %rbp, %rsi
callq 0x65d0
movq %rbp, %rdi
callq 0x6150
movq %rbx, %rdi
movl %r15d, %esi
callq 0x6290
movq %r14, %rdi
callq 0xce00
testb %al, %al
je 0xdc4a
movq %rbx, %rdi
movl %r15d, %esi
callq 0x6290
jmp 0xdc31
movq %r14, %rdi
callq 0xda82
movl %eax, %r13d
leaq 0x8(%rsp), %rdi
callq 0x6150
jmp 0xdbce
movb 0x3(%rsp), %al
addq $0x68, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
leaq 0x28(%rsp), %rdi
jmp 0xdc9c
movq %rax, %rbx
leaq 0x48(%rsp), %rdi
callq 0x6150
jmp 0xdc97
jmp 0xdc94
jmp 0xdc94
movq %rax, %rbx
leaq 0x8(%rsp), %rdi
callq 0x6150
movq %rbx, %rdi
callq 0x6560
nop
// File: /workspace/github_cpp_makefile_star2_O2/ryuichiueda[P]GlueLang/src/Import.cc
// Function: Import::parse()
bool Import::parse(void)
{
	m_feeder->getPos(&m_start_line, &m_start_char);

	if(! m_feeder->str(string("import")))
		return false;

	if(! m_feeder->path(&m_path)){
		m_feeder->setPos(m_start_line, m_start_char);
		return false;
	}

	if(m_feeder->str(string("as")))
		return parseAs();

	//import PATH
	if(m_path == "PATH"){
		return parsePATH();
	}
	
	m_feeder->setPos(m_start_line, m_start_char);
	return false;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x48, %rsp
movq %rdi, %rbx
movq 0x8(%rdi), %rdi
leaq 0x30(%rbx), %r14
leaq 0x34(%rbx), %r15
movq %r14, %rsi
movq %r15, %rdx
callq 0xd614
movq 0x8(%rbx), %r12
leaq 0x3811(%rip), %rsi      # 0x11650
leaq 0x28(%rsp), %rdi
leaq 0x7(%rsp), %rdx
callq 0x708c
leaq 0x28(%rsp), %rsi
movq %r12, %rdi
callq 0xd6ae
movl %eax, %ebp
leaq 0x28(%rsp), %rdi
callq 0x6150
testb %bpl, %bpl
je 0xded3
movq 0x8(%rbx), %rdi
leaq 0x88(%rbx), %r12
movq %r12, %rsi
callq 0xcaac
movq 0x8(%rbx), %r13
testb %al, %al
je 0xdec5
leaq 0x37c9(%rip), %rsi      # 0x11657
leaq 0x8(%rsp), %rdi
leaq 0x7(%rsp), %rdx
callq 0x708c
leaq 0x8(%rsp), %rsi
movq %r13, %rdi
callq 0xd6ae
movl %eax, %ebp
leaq 0x8(%rsp), %rdi
callq 0x6150
testb %bpl, %bpl
je 0xdee4
movq %rbx, %rdi
callq 0xdf34
jmp 0xdeff
movl (%r14), %esi
movl (%r15), %edx
movq %r13, %rdi
callq 0xd0a2
xorl %eax, %eax
addq $0x48, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
leaq 0x376f(%rip), %rsi      # 0x1165a
movq %r12, %rdi
callq 0x73cf
testb %al, %al
je 0xdf01
movq %rbx, %rdi
callq 0xe04e
jmp 0xded5
movq 0x8(%rbx), %rdi
movl 0x30(%rbx), %esi
movl 0x34(%rbx), %edx
jmp 0xdece
movq %rax, %rbx
leaq 0x8(%rsp), %rdi
jmp 0xdf21
jmp 0xdf28
movq %rax, %rbx
leaq 0x28(%rsp), %rdi
callq 0x6150
jmp 0xdf2b
movq %rax, %rbx
movq %rbx, %rdi
callq 0x6560
nop
// File: /workspace/github_cpp_makefile_star2_O2/ryuichiueda[P]GlueLang/src/Import.cc
// Function: Import::parseAs()
bool Import::parseAs(void)
{

	if(! m_feeder->fileNameSegment(&m_prefix)){
		m_feeder->setPos(m_start_line, m_start_char);
		return false;
	}

	//evaluate beforehand
	try{
		if(m_path.back() != '/')
			m_path += '/';
		m_env->setImportPath(&m_prefix,&m_path);
	}
	catch(...){
		m_error_msg = "Import error: " + m_env->m_error_msg;
		m_exit_status = 1;
		m_feeder->getPos(&m_end_line, &m_end_char);
		throw this;
	}

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

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
subq $0x28, %rsp
movq %rdi, %rbx
movq 0x8(%rdi), %rdi
leaq 0xa8(%rbx), %r14
movq %r14, %rsi
callq 0xccbe
movl %eax, %ebp
testb %al, %al
je 0xdfa6
leaq 0x88(%rbx), %r15
movq 0x88(%rbx), %rax
movq 0x90(%rbx), %rcx
cmpb $0x2f, -0x1(%rax,%rcx)
je 0xdf81
pushq $0x2f
popq %rsi
movq %r15, %rdi
callq 0x6290
movq 0x10(%rbx), %rdi
movq %r14, %rsi
movq %r15, %rdx
callq 0x9a20
movq 0x8(%rbx), %rdi
leaq 0x38(%rbx), %rsi
addq $0x3c, %rbx
movq %rbx, %rdx
callq 0xd614
jmp 0xdfb5
movq 0x8(%rbx), %rdi
movl 0x30(%rbx), %esi
movl 0x34(%rbx), %edx
callq 0xd0a2
movl %ebp, %eax
addq $0x28, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rdi
callq 0x6120
movl $0xa0, %edx
addq 0x10(%rbx), %rdx
leaq 0x3685(%rip), %rsi      # 0x1165f
leaq 0x8(%rsp), %rdi
callq 0x7156
leaq 0x60(%rbx), %rdi
leaq 0x8(%rsp), %r14
movq %r14, %rsi
callq 0x63d0
movq %r14, %rdi
callq 0x6150
movl $0x1, 0x80(%rbx)
movq 0x8(%rbx), %rdi
leaq 0x38(%rbx), %rsi
leaq 0x3c(%rbx), %rdx
callq 0xd614
pushq $0x8
popq %rdi
callq 0x6190
movq %rbx, (%rax)
leaq 0xb9f6(%rip), %rsi      # 0x19a20
movq %rax, %rdi
xorl %edx, %edx
callq 0x6540
jmp 0xe036
movq %rax, %rbx
callq 0x6500
movq %rbx, %rdi
callq 0x6560
movq %rax, %rdi
callq 0x77b5
// File: /workspace/github_cpp_makefile_star2_O2/ryuichiueda[P]GlueLang/src/Import.cc
// Function: Import::parsePATH()
bool Import::parsePATH(void)
{
	char *str = getenv("PATH");

	if(str == NULL){
		m_feeder->setPos(m_start_line,m_start_char);
		return false;
	}

	string nokey("");

	char *p = strtok(str,":");
	while(p != NULL){
		string path = string(p) + string("/");
		m_env->setImportPath(&nokey,&path);
		p = strtok(NULL,":");
	}

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

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x98, %rsp
movq %rdi, %r14
leaq 0x35f1(%rip), %rdi      # 0x1165a
callq 0x63b0
movq %rax, %rbx
testq %rax, %rax
je 0xe14f
leaq 0x379b(%rip), %rsi      # 0x1181c
leaq 0x18(%rsp), %rdi
leaq 0x78(%rsp), %r12
movq %r12, %rdx
callq 0x708c
leaq 0x33d7(%rip), %rsi      # 0x11471
movq %rbx, 0x10(%rsp)
movq %rbx, %rdi
callq 0x64c0
movq %rax, %r15
leaq 0x58(%rsp), %rbp
leaq 0x38(%rsp), %r13
leaq 0xe(%rsp), %rbx
testq %r15, %r15
je 0xe12a
movq %rbp, %rdi
movq %r15, %rsi
leaq 0xf(%rsp), %rdx
callq 0x708c
movq %r13, %rdi
leaq 0x3516(%rip), %rsi      # 0x115ee
movq %rbx, %rdx
callq 0x708c
movq %r12, %rdi
movq %rbp, %rsi
movq %r13, %rdx
callq 0x7a16
movq %r13, %rdi
callq 0x6150
movq %rbp, %rdi
callq 0x6150
movq 0x10(%r14), %rdi
leaq 0x18(%rsp), %rsi
movq %r12, %rdx
callq 0x9a20
xorl %edi, %edi
leaq 0x3359(%rip), %rsi      # 0x11471
callq 0x64c0
movq %rax, %r15
movq %r12, %rdi
callq 0x6150
jmp 0xe0b9
movq 0x8(%r14), %rdi
leaq 0x38(%r14), %rsi
addq $0x3c, %r14
movq %r14, %rdx
callq 0xd614
leaq 0x18(%rsp), %rdi
callq 0x6150
movq 0x10(%rsp), %rbx
jmp 0xe160
movq 0x8(%r14), %rdi
movl 0x30(%r14), %esi
movl 0x34(%r14), %edx
callq 0xd0a2
testq %rbx, %rbx
setne %al
addq $0x98, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
jmp 0xe17a
movq %rax, %rbx
jmp 0xe1a5
movq %rax, %rbx
jmp 0xe191
movq %rax, %rbx
leaq 0x38(%rsp), %rdi
callq 0x6150
leaq 0x58(%rsp), %rdi
jmp 0xe1a0
movq %rax, %rbx
leaq 0x78(%rsp), %rdi
callq 0x6150
leaq 0x18(%rsp), %rdi
callq 0x6150
movq %rbx, %rdi
callq 0x6560
nop
// File: /workspace/github_cpp_makefile_star2_O2/ryuichiueda[P]GlueLang/src/InternalCommands.cc
// Function: InternalCommands::exec(char const**, Environment*, Feeder*, Executable*)
int InternalCommands::exec(char const** argv,Environment *e,Feeder *f,Executable *p)
{
	int c = 0;
	while(argv[c] != NULL){
		c++;
	}
	if(strncmp(argv[0],"echo",4) == 0){
		exit( echo(c,argv) );
	}else if(strncmp(argv[0],"pid",3) == 0){
		exit( pid(c,e) );
	}else if(strncmp(argv[0],"ppid",4) == 0){
		exit( ppid(c,e) );
	}else if(strncmp(argv[0],"break",5) == 0){
		exit( break_(e) );
	}
	return -1;
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq %rdi, %r15
xorl %r12d, %r12d
cmpq $0x0, (%r15,%r12,8)
leaq 0x1(%r12), %r12
jne 0xe217
movq (%r15), %r14
leaq 0x3452(%rip), %rsi      # 0x1167f
pushq $0x4
popq %rdx
movq %r14, %rdi
callq 0x6170
testl %eax, %eax
je 0xe28b
cmpb $0x70, (%r14)
jne 0xe250
cmpb $0x69, 0x1(%r14)
jne 0xe250
cmpb $0x64, 0x2(%r14)
je 0xe2b5
leaq 0x342d(%rip), %rsi      # 0x11684
pushq $0x4
popq %rdx
movq %r14, %rdi
callq 0x6170
testl %eax, %eax
je 0xe29b
leaq 0x341c(%rip), %rsi      # 0x11689
pushq $0x5
popq %rdx
movq %r14, %rdi
callq 0x6170
testl %eax, %eax
je 0xe2a5
pushq $-0x1
popq %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
decl %r12d
movl %r12d, %edi
movq %r15, %rsi
callq 0xe2c4
jmp 0xe2bd
movq %rbx, %rsi
callq 0xe35e
jmp 0xe2bd
movq %rbx, %rdi
callq 0xe37e
pushq $0x1
popq %rdi
callq 0x63a0
movq %rbx, %rsi
callq 0xe33e
xorl %edi, %edi
callq 0x63a0
// File: /workspace/github_cpp_makefile_star2_O2/ryuichiueda[P]GlueLang/src/InternalCommands.cc
// Function: InternalCommands::echo(int, char const**)
int InternalCommands::echo(int argc, char const** argv)
{
	for(int i = 1; i < argc-1; i++){
		cout << argv[i] << " ";
	}
	if(argc > 1)
		cout << argv[argc-1] << endl;

	return 0;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rsi, %rbx
movl %edi, %r14d
leal -0x1(%r14), %eax
movslq %eax, %r13
pushq $0x1
popq %rbp
movq 0xbcda(%rip), %r15      # 0x19fc0
leaq 0x3562(%rip), %r12      # 0x1184f
cmpq %r13, %rbp
jge 0xe30e
movq (%rbx,%rbp,8), %rsi
movq %r15, %rdi
callq 0x6310
movq %rax, %rdi
movq %r12, %rsi
callq 0x6310
incq %rbp
jmp 0xe2ed
cmpl $0x1, %r14d
jle 0xe32c
movq (%rbx,%r13,8), %rsi
movq 0xbca1(%rip), %rdi      # 0x19fc0
callq 0x6310
movq %rax, %rdi
callq 0x6180
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O2/ryuichiueda[P]GlueLang/src/Job.cc
// Function: Job::Job(Feeder*, Environment*, std::vector<int, std::allocator<int>>*)
Job::Job(Feeder *f, Environment *env,vector<int> *scopes) : Element(f,env,scopes)
{
	m_outfile = NULL;
	m_outstr = NULL;
	m_where = NULL;
	m_is_background = false;

	m_local_env = NULL;
}

// Assembly:
pushq %rbx
movq %rdi, %rbx
callq 0x8cfc
leaq 0xb6ac(%rip), %rax      # 0x19a50
movq %rax, (%rbx)
leaq 0xa8(%rbx), %rax
movq %rax, 0x98(%rbx)
andq $0x0, 0xa0(%rbx)
xorl %eax, %eax
movb %al, 0xa8(%rbx)
movb %al, 0xb8(%rbx)
xorps %xmm0, %xmm0
movups %xmm0, 0x88(%rbx)
movups %xmm0, 0xc0(%rbx)
popq %rbx
retq
// File: /workspace/github_cpp_makefile_star2_O2/ryuichiueda[P]GlueLang/src/Job.cc
// Function: Job::exec(DefFile*, DefStr*)
int Job::exec(DefFile *f,  DefStr *s)
{
	if(m_outfile != NULL)
		f = m_outfile;
	if(m_outstr != NULL)
		s = m_outstr;

	cout << flush;

	eval();

	if(m_where != NULL){
		m_where->exec(f,s);
		m_local_env = m_where->m_local_env;
	}


	if(m_is_background)
		return execBackGround(f,s);

	return execNormal(f,s);
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rdx, %rbx
movq %rsi, %r14
movq %rdi, %r15
movq 0xc0(%rdi), %rax
testq %rax, %rax
cmovneq %rax, %r14
movq 0xc8(%rdi), %rax
testq %rax, %rax
cmovneq %rax, %rbx
movq 0xb631(%rip), %rdi      # 0x19fc0
callq 0x61f0
movq (%r15), %rax
movq %r15, %rdi
callq *0x10(%rax)
movq 0x88(%r15), %rdi
testq %rdi, %rdi
je 0xe9ca
movq (%rdi), %rax
movq %r14, %rsi
movq %rbx, %rdx
callq *0x18(%rax)
movq 0x88(%r15), %rax
movq 0x88(%rax), %rax
movq %rax, 0x90(%r15)
cmpb $0x1, 0xb8(%r15)
jne 0xe9ea
movq %r15, %rdi
movq %r14, %rsi
movq %rbx, %rdx
callq 0xe9fe
xorl %eax, %eax
popq %rbx
popq %r14
popq %r15
retq
movq %r15, %rdi
movq %r14, %rsi
movq %rbx, %rdx
popq %rbx
popq %r14
popq %r15
jmp 0xeb50
nop
// File: /workspace/github_cpp_makefile_star2_O2/ryuichiueda[P]GlueLang/src/Job.cc
// Function: Job::execBackGround(DefFile*, DefStr*)
int Job::execBackGround(DefFile *f,  DefStr *s)
{
	int pid = fork();
	if(pid < 0)
		exit(4);

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

		for(int i=0;i<(int)m_nodes.size();i++){
			auto *p = (Pipeline *)m_nodes[i];
			if(f != NULL && i!=0)
				f->m_data->setAppend();
	
			p->exec(f,s);
		}
		exit(0);
	}

	try{
		DataJob *p = (DataJob *)m_env->getData(&m_scopes,&m_job_name);
		p->m_pid = pid;
	}catch(...){
		m_error_msg = "Bug of backgound process";
		m_exit_status = 2;
		throw this;
	}

	return 0;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rdx, %r14
movq %rsi, %r15
movq %rdi, %rbx
callq 0x60d0
testl %eax, %eax
js 0xea47
movq 0x10(%rbx), %rdi
je 0xea4f
movl %eax, %ebp
leaq 0x48(%rbx), %rsi
leaq 0x98(%rbx), %rdx
callq 0x9d98
movl %ebp, 0x48(%rax)
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
pushq $0x4
popq %rdi
callq 0x63a0
cmpb $0x1, 0xe0(%rdi)
jne 0xeaa3
movq 0xb589(%rip), %rdi      # 0x19fe8
leaq 0x280d(%rip), %rsi      # 0x11273
callq 0x6310
movq 0x10(%rbx), %rcx
movl 0xe4(%rcx), %esi
movq %rax, %rdi
callq 0x6550
leaq 0x2b07(%rip), %rsi      # 0x1158b
movq %rax, %rdi
callq 0x6310
leaq 0x98(%rbx), %rsi
movq %rax, %rdi
callq 0x62b0
movq %rax, %rdi
callq 0x6180
xorl %r13d, %r13d
movq 0x18(%rbx), %rax
movq 0x20(%rbx), %rcx
subq %rax, %rcx
shrq $0x3, %rcx
movslq %ecx, %rcx
cmpq %rcx, %r13
jge 0xeaf2
testq %r15, %r15
sete %cl
movq (%rax,%r13,8), %r12
testq %r13, %r13
sete %al
orb %cl, %al
jne 0xeadd
movq 0x88(%r15), %rdi
callq 0x7c12
movq (%r12), %rax
movq %r12, %rdi
movq %r15, %rsi
movq %r14, %rdx
callq *0x18(%rax)
incq %r13
jmp 0xeaa6
xorl %edi, %edi
callq 0x63a0
movq %rax, %rdi
callq 0x6120
leaq 0x60(%rbx), %rdi
leaq 0x2bc8(%rip), %rsi      # 0x116d4
callq 0x65b0
movl $0x2, 0x80(%rbx)
pushq $0x8
popq %rdi
callq 0x6190
movq %rbx, (%rax)
leaq 0xaf7b(%rip), %rsi      # 0x19aa8
movq %rax, %rdi
xorl %edx, %edx
callq 0x6540
movq %rax, %rbx
callq 0x6500
movq %rbx, %rdi
callq 0x6560
movq %rax, %rdi
callq 0x77b5
nop
// File: /workspace/github_cpp_makefile_star2_O2/ryuichiueda[P]GlueLang/src/Job.cc
// Function: Job::execNormal(DefFile*, DefStr*)
int Job::execNormal(DefFile *f,  DefStr *s)
{
	bool skip = false; // flag to skip the next command
	bool stop_next = false; // stop after then
	for(int i=0;i<(int)m_nodes.size();i++){
		if(skip and not stop_next){
			skip = false;
			continue;
		}

		if(f != NULL && i!=0)
			f->m_data->setAppend();

		auto *p = (Pipeline *)m_nodes[i];
		int es = p->exec(f,s);//Sometimes it does not come back.
		if(stop_next){
			return es;
		}

		stop_next = p->m_has_then and es == 0;
		skip = (p->m_has_then and es != 0)
			or (p->m_has_and and es != 0)
			or (p->m_has_or and es == 0);
	}
	return 0;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rdx, %r14
movq %rsi, %r15
movq %rdi, %r12
xorl %ebp, %ebp
xorl %ebx, %ebx
xorl %ecx, %ecx
movq 0x18(%r12), %rax
movq 0x20(%r12), %rdx
subq %rax, %rdx
shrq $0x3, %rdx
movslq %edx, %rdx
cmpq %rdx, %rbp
jge 0xec0a
testb $0x1, %cl
je 0xeb91
testb $0x1, %bl
je 0xec00
testq %r15, %r15
sete %cl
testq %rbp, %rbp
sete %dl
orb %cl, %dl
jne 0xebb2
movq 0x88(%r15), %rdi
callq 0x7c12
movq 0x18(%r12), %rax
movq (%rax,%rbp,8), %r13
movq (%r13), %rax
movq %r13, %rdi
movq %r15, %rsi
movq %r14, %rdx
callq *0x18(%rax)
testb $0x1, %bl
jne 0xec0e
movb 0x86(%r13), %dl
testl %eax, %eax
sete %bl
setne %sil
andb %dl, %bl
movb $0x1, %cl
testb %dl, %sil
jne 0xec02
testl %eax, %eax
je 0xebf2
cmpb $0x0, 0x85(%r13)
jne 0xec02
testl %eax, %eax
sete %cl
andb 0x87(%r13), %cl
jmp 0xec02
xorl %ecx, %ecx
incq %rbp
jmp 0xeb6a
xorl %eax, %eax
jmp 0xec0e
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_cpp_makefile_star2_O2/ryuichiueda[P]GlueLang/src/Literal.cc
// Function: Literal::parse()
bool Literal::parse(void)
{
	m_feeder->getPos(&m_start_line, &m_start_char);

	try{
		if( m_feeder->literal(&m_text)){
			m_feeder->getPos(&m_end_line, &m_end_char);
			return true;
		}
	}catch(Feeder *e){
		m_feeder->getPos(&m_end_line, &m_end_char);
		m_error_msg = e->m_error_msg;
		m_exit_status = 1;
		throw this;
	}

	return false;
}

// Assembly:
pushq %rbp
pushq %r14
pushq %rbx
movq %rdi, %rbx
movq 0x8(%rdi), %rdi
leaq 0x30(%rbx), %rsi
leaq 0x34(%rbx), %rdx
callq 0xd614
movq 0x8(%rbx), %rdi
leaq 0x88(%rbx), %rsi
callq 0xd200
movl %eax, %ebp
testb %al, %al
je 0xec93
movq 0x8(%rbx), %rdi
leaq 0x38(%rbx), %rsi
leaq 0x3c(%rbx), %rdx
callq 0xd614
movl %ebp, %eax
popq %rbx
popq %r14
popq %rbp
retq
movq %rax, %r14
cmpl $0x1, %edx
jne 0xecfc
movq %r14, %rdi
callq 0x6120
movq %rax, %r14
movq 0x8(%rbx), %rdi
leaq 0x38(%rbx), %rsi
leaq 0x3c(%rbx), %rdx
callq 0xd614
addq $0x28, %r14
leaq 0x60(%rbx), %rdi
movq %r14, %rsi
callq 0x61c0
movl $0x1, 0x80(%rbx)
pushq $0x8
popq %rdi
callq 0x6190
movq %rbx, (%rax)
leaq 0xae4e(%rip), %rsi      # 0x19b38
movq %rax, %rdi
xorl %edx, %edx
callq 0x6540
movq %rax, %r14
callq 0x6500
movq %r14, %rdi
callq 0x6560
// File: /workspace/github_cpp_makefile_star2_O2/ryuichiueda[P]GlueLang/src/Literal.cc
// Function: Literal::eval()
bool Literal::eval(void)
{
	m_evaled_text = m_text;
	//evaled escaped characters 
	auto pos = m_evaled_text.find("\\\'"); // \'
	while(pos != string::npos){
		m_evaled_text.replace(pos, 2, "\'");
		pos = m_evaled_text.find("\\\'", pos + 1);
	}
	return true;
}

// Assembly:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
movq %rdi, %rbx
leaq 0x88(%rdi), %rsi
addq $0xa8, %rbx
movq %rbx, %rdi
callq 0x61c0
xorl %r12d, %r12d
leaq 0x29db(%rip), %r14      # 0x1170b
leaq 0x29d5(%rip), %r15      # 0x1170c
pushq $0x2
popq %r13
movq %rbx, %rdi
movq %r14, %rsi
movq %r12, %rdx
callq 0x6600
cmpq $-0x1, %rax
je 0xed68
movq %rax, %r12
movq %rbx, %rdi
movq %rax, %rsi
movq %r13, %rdx
movq %r15, %rcx
callq 0x61e0
incq %r12
jmp 0xed3b
movb $0x1, %al
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
// File: /workspace/github_cpp_makefile_star2_O2/ryuichiueda[P]GlueLang/src/Pipeline.cc
// Function: Pipeline::exec(DefFile*, DefStr*)
int Pipeline::exec(DefFile *f,  DefStr *s)
{
	// When wait(1) is set in the command line,
	// wait(1) is done in this process.
	// Wait(1) cannot be connected with other commands
	//auto *cl = (Executable *)m_nodes[0];
	if(((Executable *)m_nodes[0])->m_is_wait)
		return execWait();

	int pip[2];
	int prevfd = -1;

	for(auto *n : m_nodes){
		auto *p = (Executable *)n;
		pip[1] = -1;
		if ( p != m_nodes.back() && pipe(pip) < 0) {
			close(prevfd);
			m_error_msg = "Pipe call failed";
			throw this;
		}

		p->setPipe(pip,prevfd);
		//Only the last command is connected to the file/string
		if( n != m_nodes.back() )
			m_pids.push_back( p->exec(NULL,NULL) ); //to pipeline
		else
			m_pids.push_back( p->exec(f,s) ); //to file/string
		prevfd = p->getPrevPipe();
	}

	if(s != NULL)
		s->readFifo();

	for(auto pid : m_pids)
		waitCommands(pid);

	return m_exit_status;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x28, %rsp
movq %rsi, 0x20(%rsp)
movq %rdi, %rbx
movq 0x18(%rdi), %rbp
movq (%rbp), %rax
cmpb $0x1, 0x85(%rax)
jne 0xf02e
movq %rbx, %rdi
callq 0xf146
xorl %eax, %eax
jmp 0xf102
movq %rdx, 0x18(%rsp)
movq 0x20(%rbx), %r13
leaq 0x90(%rbx), %r12
pushq $-0x1
popq %r14
leaq 0x10(%rsp), %rsi
cmpq %r13, %rbp
je 0xf0c9
movq (%rbp), %r15
orl $-0x1, 0x14(%rsp)
movq 0x20(%rbx), %rax
cmpq -0x8(%rax), %r15
je 0xf074
movq %rsi, %rdi
callq 0x6410
leaq 0x10(%rsp), %rsi
testl %eax, %eax
js 0xf111
movq %r15, %rdi
movl %r14d, %edx
callq 0xc8c2
movq 0x20(%rbx), %rax
cmpq -0x8(%rax), %r15
je 0xf095
movq (%r15), %rax
movq %r15, %rdi
xorl %esi, %esi
xorl %edx, %edx
jmp 0xf0a5
movq (%r15), %rax
movq %r15, %rdi
movq 0x20(%rsp), %rsi
movq 0x18(%rsp), %rdx
callq *0x18(%rax)
movl %eax, 0xc(%rsp)
movq %r12, %rdi
leaq 0xc(%rsp), %rsi
callq 0x914e
movl 0x90(%r15), %r14d
addq $0x8, %rbp
jmp 0xf042
movq 0x18(%rsp), %rdi
testq %rdi, %rdi
je 0xf0d8
callq 0x8c4a
movq 0x90(%rbx), %r14
movq 0x98(%rbx), %r15
cmpq %r15, %r14
je 0xf0fc
movl (%r14), %esi
movq %rbx, %rdi
callq 0xf312
addq $0x4, %r14
jmp 0xf0e6
movl 0x80(%rbx), %eax
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movl %r14d, %edi
callq 0x65e0
leaq 0x60(%rbx), %rdi
leaq 0x25ee(%rip), %rsi      # 0x11712
callq 0x6400
pushq $0x8
popq %rdi
callq 0x6190
movq %rbx, (%rax)
leaq 0xaa85(%rip), %rsi      # 0x19bc0
movq %rax, %rdi
xorl %edx, %edx
callq 0x6540
nop
// File: /workspace/github_cpp_makefile_star2_O2/ryuichiueda[P]GlueLang/src/Pipeline.cc
// Function: Pipeline::execWait()
int Pipeline::execWait(void)
{
	auto *c = (Executable *)m_nodes[0];
	c->eval();
	auto argv = c->makeArgv();
	
	int i = 1;
	while(argv[i] != NULL){
		DataJob *p = NULL;
		int pid = 0;
		
		while(pid == 0){ // not forked
			if(p == NULL){
				try{
					string s(argv[i]);
					p = (DataJob *)m_env->getData(&m_scopes,&s);
				}catch(...){
					m_error_msg = "Bug of backgound process";
					m_exit_status = 2;
					throw this;
				}
			}
			pid = p->m_pid;
			//pid = m_env->getBG(argv[i]);
		}
		if(pid < 0){
			m_error_msg = "Unknown background process";
			m_exit_status = 4;
			throw this;
		}
		m_pids.push_back(pid);
		p->m_pid = 0;
		i++;
	}

	for(auto pid : m_pids)
		waitCommands(pid);

	if(m_env->m_v_opt)
		cerr << "+ pid " << m_env->m_pid << " wait done" << endl;

	return 0;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x38, %rsp
movq %rdi, %rbx
movq 0x18(%rdi), %rax
movq (%rax), %r14
movq (%r14), %rax
movq %r14, %rdi
callq *0x10(%rax)
movq %r14, %rdi
callq 0xc712
movq %rax, %r14
leaq 0x48(%rbx), %r15
leaq 0x90(%rbx), %rax
movq %rax, 0x10(%rsp)
pushq $0x1
popq %rbp
leaq 0x18(%rsp), %r13
cmpq $0x0, (%r14,%rbp,8)
je 0xf1f5
xorl %eax, %eax
xorl %r12d, %r12d
movl %eax, 0xc(%rsp)
testl %eax, %eax
jne 0xf1d5
testq %r12, %r12
jne 0xf1ce
movq (%r14,%rbp,8), %rsi
movq %r13, %rdi
leaq 0xb(%rsp), %rdx
callq 0x708c
movq 0x10(%rbx), %rdi
movq %r15, %rsi
movq %r13, %rdx
callq 0x9d98
movq %rax, %r12
movq %r13, %rdi
callq 0x6150
movl 0x48(%r12), %eax
jmp 0xf196
js 0xf273
movq 0x10(%rsp), %rdi
leaq 0xc(%rsp), %rsi
callq 0x90c4
andl $0x0, 0x48(%r12)
incq %rbp
jmp 0xf18a
movq 0x90(%rbx), %r14
movq 0x98(%rbx), %r15
cmpq %r15, %r14
je 0xf219
movl (%r14), %esi
movq %rbx, %rdi
callq 0xf312
addq $0x4, %r14
jmp 0xf203
movq 0x10(%rbx), %rax
cmpb $0x0, 0xe0(%rax)
je 0xf262
movq 0xadbb(%rip), %rdi      # 0x19fe8
leaq 0x203f(%rip), %rsi      # 0x11273
callq 0x6310
movq 0x10(%rbx), %rcx
movl 0xe4(%rcx), %esi
movq %rax, %rdi
callq 0x6550
leaq 0x24ec(%rip), %rsi      # 0x1173e
movq %rax, %rdi
callq 0x6310
movq %rax, %rdi
callq 0x6180
xorl %eax, %eax
addq $0x38, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
leaq 0x60(%rbx), %rdi
leaq 0x24a5(%rip), %rsi      # 0x11723
callq 0x6400
movl $0x4, 0x80(%rbx)
pushq $0x8
popq %rdi
callq 0x6190
movq %rbx, (%rax)
leaq 0xa921(%rip), %rsi      # 0x19bc0
movq %rax, %rdi
xorl %edx, %edx
callq 0x6540
movq %rax, %r14
leaq 0x18(%rsp), %rdi
callq 0x6150
jmp 0xf2bb
movq %rax, %r14
movq %r14, %rdi
callq 0x6120
leaq 0x60(%rbx), %rdi
leaq 0x2406(%rip), %rsi      # 0x116d4
callq 0x65b0
movl $0x2, 0x80(%rbx)
pushq $0x8
popq %rdi
callq 0x6190
movq %rbx, (%rax)
leaq 0xa8d1(%rip), %rsi      # 0x19bc0
movq %rax, %rdi
xorl %edx, %edx
callq 0x6540
movq %rax, %rbx
callq 0x6500
movq %rbx, %rdi
callq 0x6560
movq %rax, %rdi
callq 0x77b5
nop
// File: /workspace/github_cpp_makefile_star2_O2/ryuichiueda[P]GlueLang/src/Pipeline.cc
// Function: Pipeline::waitCommands(int)
void Pipeline::waitCommands(int pid)
{
	int options = 0;
	int status;
	int wpid = waitpid(pid,&status,options);
	if(wpid < 1){
		m_error_msg = "Command wait error";
		m_exit_status = 2;
		throw this;
	}
		
	if(!WIFEXITED(status)){
		if(WIFSIGNALED(status) && WTERMSIG(status) == 13){//ignore sigpipe
			// The exit status of the command that is suffered a sigpipe
			// should be zero because the command itself does not anything bad. 
			m_exit_status = 0;
		}else if(WIFSIGNALED(status) && WTERMSIG(status) == SIGUSR1){
			exit(0);
		}else{
			m_error_msg = "Irregular command termination";
			m_exit_status = 2;
			throw this;
		}
	}else{
		m_exit_status = WEXITSTATUS(status);
	}

	if(m_env->m_v_opt)
		cerr << "+ pid " << pid << " exit " << m_exit_status << endl;

	// judged at the upper level if !> is used
	if(m_has_or || m_exit_status == 0)
		return;

	if((m_has_and or m_has_then) and m_exit_status == 1)
		return;

	if(m_is_then and m_exit_status > 0){
		m_error_msg = "Error at then part";
		m_exit_status = 8;
		throw this;
	}

	m_error_msg = m_nodes.size() > 1 ? "Pipeline error" : "Command error";
	m_command_error = true;
	throw this;
}

// Assembly:
pushq %rbp
pushq %r14
pushq %rbx
subq $0x10, %rsp
movl %esi, %ebp
movq %rdi, %r14
leaq 0xc(%rsp), %rsi
xorl %ebx, %ebx
movl %ebp, %edi
xorl %edx, %edx
callq 0x6260
testl %eax, %eax
jle 0xf3ef
movl 0xc(%rsp), %ecx
movl %ecx, %eax
andl $0x7f, %eax
je 0xf357
cmpl $0xd, %eax
je 0xf35a
cmpl $0xa, %eax
jne 0xf3fc
xorl %edi, %edi
callq 0x63a0
movzbl %ch, %ebx
movl %ebx, 0x80(%r14)
movq 0x10(%r14), %rax
cmpb $0x1, 0xe0(%rax)
jne 0xf3b1
movq 0xac73(%rip), %rdi      # 0x19fe8
leaq 0x1ef7(%rip), %rsi      # 0x11273
callq 0x6310
movq %rax, %rdi
movl %ebp, %esi
callq 0x6550
leaq 0x23d5(%rip), %rsi      # 0x11767
movq %rax, %rdi
callq 0x6310
movl 0x80(%r14), %esi
movq %rax, %rdi
callq 0x6550
movq %rax, %rdi
callq 0x6180
cmpb $0x0, 0x87(%r14)
jne 0xf3e6
movl 0x80(%r14), %eax
testl %eax, %eax
je 0xf3e6
cmpb $0x0, 0x85(%r14)
je 0xf3d7
cmpl $0x1, %eax
je 0xf3e6
jmp 0xf433
cmpl $0x1, %eax
jne 0xf433
cmpb $0x0, 0x86(%r14)
je 0xf433
addq $0x10, %rsp
popq %rbx
popq %r14
popq %rbp
retq
leaq 0x60(%r14), %rdi
leaq 0x210e(%rip), %rsi      # 0x11508
jmp 0xf407
leaq 0x60(%r14), %rdi
leaq 0x2342(%rip), %rsi      # 0x11749
callq 0x6400
movl $0x2, 0x80(%r14)
pushq $0x8
popq %rdi
callq 0x6190
movq %r14, (%rax)
leaq 0xa797(%rip), %rsi      # 0x19bc0
movq %rax, %rdi
xorl %edx, %edx
callq 0x6540
testl %eax, %eax
jle 0xf45e
cmpb $0x0, 0x88(%r14)
je 0xf45e
leaq 0x60(%r14), %rdi
leaq 0x2322(%rip), %rsi      # 0x1176e
callq 0x6400
movl $0x8, 0x80(%r14)
jmp 0xf417
movq 0x20(%r14), %rax
subq 0x18(%r14), %rax
cmpq $0x9, %rax
leaq 0x2310(%rip), %rax      # 0x11781
leaq 0x2105(%rip), %rsi      # 0x1157d
cmovaeq %rax, %rsi
leaq 0x60(%r14), %rdi
callq 0x6400
movb $0x1, 0x84(%r14)
jmp 0xf417
nop
// File: /workspace/github_cpp_makefile_star2_O2/ryuichiueda[P]GlueLang/src/Script.cc
// Function: Script::parse()
bool Script::parse(void)
{
	try{
		return parseScript();
	}
	catch(Element *e){
		printErrorMsg(e,"Parse error");
		m_env->removeFiles();
		end(e->m_exit_status);
	}catch(...){
		cerr << "\nParse error"
		     << "\nunknown error" << endl;
		m_env->removeFiles();
		end(128);
	}
	return true;
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
subq $0x30, %rsp
movq %rdi, %rbx
callq 0xf5f0
movb $0x1, %al
addq $0x30, %rsp
popq %rbx
popq %r14
popq %r15
retq
movq %rdx, %r15
movq %rax, %rdi
callq 0x6120
cmpl $0x2, %r15d
jne 0xf57c
movq %rax, %r14
leaq 0x2274(%rip), %rsi      # 0x117b0
leaq 0x10(%rsp), %rdi
leaq 0xf(%rsp), %rdx
callq 0x708c
leaq 0x10(%rsp), %rdx
movq %r14, %rsi
xorl %ecx, %ecx
callq 0xf7ac
leaq 0x10(%rsp), %rdi
callq 0x6150
movq 0x10(%rbx), %rdi
callq 0x9ec6
movl 0x80(%r14), %esi
movq %rbx, %rdi
callq 0xf75c
movq 0xaa65(%rip), %rdi      # 0x19fe8
leaq 0x2225(%rip), %rsi      # 0x117af
callq 0x6310
leaq 0x2226(%rip), %rsi      # 0x117bc
movq %rax, %rdi
callq 0x6310
movq %rax, %rdi
callq 0x6180
movq 0x10(%rbx), %rdi
callq 0x9ec6
movq %rbx, %rdi
movl $0x80, %esi
callq 0xf75c
jmp 0xf5cd
movq %rax, %rbx
leaq 0x10(%rsp), %rdi
callq 0x6150
jmp 0xf5d0
movq %rax, %rbx
callq 0x6500
jmp 0xf5df
movq %rax, %rbx
callq 0x6500
movq %rbx, %rdi
callq 0x6560
movq %rax, %rdi
callq 0x77b5
nop