LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_cpp_makefile_star2_O1/ryuichiueda[P]GlueLang/src/Environment.cc
// Function: Environment::getData(int, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>*)
Data *Environment::getData(int scope_id,string *key)
{
	string k = genKey(scope_id,key);
	//cerr << "get: " << k << endl;
	if(m_data.find(k) == m_data.end()){
		m_error_msg = "Variable " + *key + " not found";
		throw this;
	}

	return m_data[k];
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x68, %rsp
movq %rdx, %r14
movl %esi, %edx
movq %rdi, %rbx
leaq 0x28(%rsp), %r12
movq %r12, %rdi
movq %r14, %rcx
callq 0xb454
leaq 0x68(%rbx), %r15
movq %r15, %rdi
movq %r12, %rsi
callq 0xcac0
leaq 0x70(%rbx), %rcx
cmpq %rcx, %rax
je 0xb33d
leaq 0x28(%rsp), %rsi
movq %r15, %rdi
callq 0xbeb8
movq (%rax), %rbx
leaq 0x38(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0xb32e
movq 0x38(%rsp), %rsi
incq %rsi
callq 0x6330
movq %rbx, %rax
addq $0x68, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
leaq 0x9115(%rip), %rsi      # 0x14459
leaq 0x8(%rsp), %rdi
movq %r14, %rdx
callq 0x73ce
leaq 0x910b(%rip), %rsi      # 0x14463
leaq 0x8(%rsp), %rdi
callq 0x65d0
leaq 0x58(%rsp), %r15
movq %r15, -0x10(%r15)
movq (%rax), %rdx
movq %rax, %rcx
addq $0x10, %rcx
cmpq %rcx, %rdx
jne 0xb383
movups (%rcx), %xmm0
movups %xmm0, (%r15)
jmp 0xb390
movq %rdx, 0x48(%rsp)
movq (%rcx), %rdx
movq %rdx, 0x58(%rsp)
movq 0x8(%rax), %rdx
leaq 0x48(%rsp), %r14
movq %rdx, 0x8(%r14)
movq %rcx, (%rax)
movq $0x0, 0x8(%rax)
movb $0x0, 0x10(%rax)
leaq 0xa0(%rbx), %rdi
movq %r14, %rsi
callq 0x63f0
movq (%r14), %rdi
cmpq %r15, %rdi
je 0xb3d0
movq 0x58(%rsp), %rsi
incq %rsi
callq 0x6330
leaq 0x18(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0xb3eb
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x6330
movl $0x8, %edi
callq 0x6190
movq %rbx, (%rax)
leaq 0xfe81(%rip), %rsi      # 0x1b280
movq %rax, %rdi
xorl %edx, %edx
callq 0x6550
movq %rax, %rbx
leaq 0x18(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0xb430
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x6330
jmp 0xb430
jmp 0xb42d
jmp 0xb42d
movq %rax, %rbx
leaq 0x38(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0xb44b
movq 0x38(%rsp), %rsi
incq %rsi
callq 0x6330
movq %rbx, %rdi
callq 0x6580
nop
// File: /workspace/github_cpp_makefile_star2_O1/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
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x48, %rsp
movq %rdx, %r14
movq %rsi, %r15
movq %rdi, %rbx
movq 0x8(%rsi), %rbp
movq %rbp, %r12
movq (%r15), %r13
cmpq %r13, %rbp
je 0xb673
leaq -0x4(%r12), %rbp
movl -0x4(%r12), %esi
movq %rbx, %rdi
movq %r14, %rdx
callq 0xb71c
testb %al, %al
je 0xb641
movl (%rbp), %esi
movq %rbx, %rdi
movq %r14, %rdx
callq 0xb2c8
cmpq %r13, %r12
je 0xb687
addq $0x48, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
leaq 0x8dcb(%rip), %rsi      # 0x14459
leaq 0x8(%rsp), %r15
movq %r15, %rdi
movq %r14, %rdx
callq 0x73ce
leaq 0x8dbe(%rip), %rdx      # 0x14463
leaq 0x28(%rsp), %rdi
movq %r15, %rsi
callq 0x737b
leaq 0xa0(%rbx), %rdi
leaq 0x28(%rsp), %r14
movq %r14, %rsi
callq 0x63f0
movq %r14, %rdi
callq 0x6150
leaq 0x8(%rsp), %rdi
callq 0x6150
movl $0x8, %edi
callq 0x6190
movq %rbx, (%rax)
leaq 0xfb94(%rip), %rsi      # 0x1b280
movq %rax, %rdi
xorl %edx, %edx
callq 0x6550
movq %rax, %rbx
leaq 0x18(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0xb714
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x6330
movq %rbx, %rdi
callq 0x6580
// File: /workspace/github_cpp_makefile_star2_O1/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 %r14
pushq %rbx
subq $0x68, %rsp
movq %rdi, %rbx
testq %rsi, %rsi
js 0xbab7
movq (%rbx), %rax
movq 0x8(%rbx), %rcx
subq %rax, %rcx
sarq $0x5, %rcx
cmpq %rsi, %rcx
jle 0xbab7
shlq $0x5, %rsi
addq %rsi, %rax
addq $0x68, %rsp
popq %rbx
popq %r14
retq
leaq 0x28(%rsp), %r14
movq %r14, %rdi
callq 0xbfa4
leaq 0x89c1(%rip), %rsi      # 0x1448c
leaq 0x8(%rsp), %rdi
movq %r14, %rdx
callq 0xbf34
leaq 0x8c05(%rip), %rdx      # 0x146e4
leaq 0x48(%rsp), %rdi
leaq 0x8(%rsp), %rsi
callq 0x737b
leaq 0xa0(%rbx), %rdi
leaq 0x48(%rsp), %r14
movq %r14, %rsi
callq 0x63f0
movq %r14, %rdi
callq 0x6150
leaq 0x8(%rsp), %rdi
callq 0x6150
leaq 0x28(%rsp), %rdi
callq 0x6150
movl $0x8, %edi
callq 0x6190
movq %rbx, (%rax)
leaq 0xf74e(%rip), %rsi      # 0x1b280
movq %rax, %rdi
xorl %edx, %edx
callq 0x6550
movq %rax, %rbx
leaq 0x18(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0xbb5f
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x6330
jmp 0xbb5f
movq %rax, %rbx
leaq 0x38(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0xbb7a
movq 0x38(%rsp), %rsi
incq %rsi
callq 0x6330
movq %rbx, %rdi
callq 0x6580
// File: /workspace/github_cpp_makefile_star2_O1/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 %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x40, %rsp
movq %rcx, %r14
movq %rdx, %r15
movl %esi, %edx
movq %rdi, %rbx
movq %rsp, %r13
movq %r13, %rdi
movq %r15, %rcx
callq 0xb454
leaq 0x68(%rbx), %r12
movq %r12, %rdi
movq %r13, %rsi
callq 0xcac0
leaq 0x70(%rbx), %rcx
cmpq %rcx, %rax
jne 0xbbf7
movq %rsp, %rsi
movq %r12, %rdi
callq 0xbeb8
movq %r14, (%rax)
leaq 0x10(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0xbbe9
movq 0x10(%rsp), %rsi
incq %rsi
callq 0x6330
addq $0x40, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
leaq 0x88ae(%rip), %rdx      # 0x144ac
leaq 0x20(%rsp), %rdi
movq %r15, %rsi
callq 0xbd2b
leaq 0xa0(%rbx), %rdi
leaq 0x20(%rsp), %r14
movq %r14, %rsi
callq 0x63f0
movq (%r14), %rdi
leaq 0x30(%rsp), %rax
cmpq %rax, %rdi
je 0xbc39
movq 0x30(%rsp), %rsi
incq %rsi
callq 0x6330
movl $0x8, %edi
callq 0x6190
movq %rbx, (%rax)
leaq 0xf633(%rip), %rsi      # 0x1b280
movq %rax, %rdi
xorl %edx, %edx
callq 0x6550
jmp 0xbc5b
jmp 0xbc5b
movq %rax, %rbx
leaq 0x10(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0xbc79
movq 0x10(%rsp), %rsi
incq %rsi
callq 0x6330
movq %rbx, %rdi
callq 0x6580
nop
// File: /workspace/github_cpp_makefile_star2_O1/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
pushq %r14
pushq %rbx
movq %rdi, %rbx
movq 0x8(%rdi), %rdi
leaq 0x30(%rbx), %rsi
leaq 0x34(%rbx), %rdx
callq 0x1003e
movl $0xe8, %edi
callq 0x6320
movq %rax, %r14
movq 0x8(%rbx), %rsi
movq 0x10(%rbx), %rdx
leaq 0x48(%rbx), %rcx
movq %rax, %rdi
callq 0x6d08
movq %rbx, %rdi
movq %r14, %rsi
callq 0x9cc2
movl %eax, %ebp
testb %al, %al
je 0xcf19
movq 0x8(%rbx), %rdi
callq 0xffa2
testb %al, %al
jne 0xcf05
movq 0x8(%rbx), %rdi
callq 0xf950
testb %al, %al
jne 0xcf05
movq 0x8(%rbx), %rdi
callq 0xf358
movq %rbx, %rdi
callq 0xe9f0
movq 0x8(%rbx), %rdi
leaq 0x38(%rbx), %rsi
addq $0x3c, %rbx
movq %rbx, %rdx
callq 0x1003e
movl %ebp, %eax
popq %rbx
popq %r14
popq %rbp
retq
movq %rax, %rbx
movl $0xe8, %esi
movq %r14, %rdi
callq 0x6330
movq %rbx, %rdi
callq 0x6580
// File: /workspace/github_cpp_makefile_star2_O1/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 %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x28, %rsp
movq %rdi, %r15
callq 0xecb0
movq %rax, %rbx
movq (%rax), %rsi
movq %r15, %rdi
callq 0xeeee
movl $0x10, %edi
callq 0x6030
movq %rax, %r14
movq 0x10(%r15), %rsi
leaq 0x8(%rsp), %r15
movq %r15, %rdi
callq 0xb170
movq 0x8(%r15), %r15
incq %r15
movq %r15, %rdi
callq 0x6030
movq %rax, %r12
testq %r15, %r15
je 0xcf9e
movq 0x8(%rsp), %rsi
movq %r12, %rdi
movq %r15, %rdx
callq 0x6260
movq %r12, (%r14)
movq $0x0, 0x8(%r14)
movq (%rbx), %rdi
movq %rbx, %rsi
movq %r14, %rdx
callq 0x6540
leaq 0x18(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0xcfd2
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x6330
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
movq %rax, %rbx
leaq 0x18(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0xcffc
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x6330
movq %rbx, %rdi
callq 0x6580
// File: /workspace/github_cpp_makefile_star2_O1/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
pushq %r14
pushq %rbx
movq %rdi, %rbx
movq 0x8(%rdi), %rdi
leaq 0x30(%rbx), %rsi
leaq 0x34(%rbx), %rdx
callq 0x1003e
movl $0xc8, %edi
callq 0x6320
movq %rax, %r14
movq 0x8(%rbx), %rsi
movq 0x10(%rbx), %rdx
leaq 0x48(%rbx), %rcx
movq %rax, %rdi
callq 0x7578
movq %rbx, %rdi
movq %r14, %rsi
callq 0x9cc2
movl %eax, %ebp
testb %al, %al
je 0xd9b4
movq 0x8(%rbx), %rdi
callq 0xffa2
testb %al, %al
jne 0xd97d
movq 0x8(%rbx), %rdi
callq 0xf950
testb %al, %al
jne 0xd97d
movq 0x8(%rbx), %rdi
callq 0xf358
movq %rbx, %rdi
callq 0xe9f0
movq 0x18(%rbx), %rax
movl $0x88, %edi
addq (%rax), %rdi
leaq 0x6bc8(%rip), %rsi      # 0x14558
callq 0x60f0
testl %eax, %eax
jne 0xd9a0
movb $0x1, 0x85(%rbx)
movq 0x8(%rbx), %rdi
leaq 0x38(%rbx), %rsi
addq $0x3c, %rbx
movq %rbx, %rdx
callq 0x1003e
movl %ebp, %eax
popq %rbx
popq %r14
popq %rbp
retq
movq %rax, %rbx
movl $0xc8, %esi
movq %r14, %rdi
callq 0x6330
movq %rbx, %rdi
callq 0x6580
nop
// File: /workspace/github_cpp_makefile_star2_O1/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
pushq %r14
pushq %rbx
movq %rdi, %rbx
movq 0x8(%rdi), %rdi
leaq 0x30(%rbx), %rsi
leaq 0x34(%rbx), %rdx
callq 0x1003e
movl $0xc8, %edi
callq 0x6320
movq %rax, %r14
movq 0x8(%rbx), %rsi
movq 0x10(%rbx), %rdx
leaq 0x48(%rbx), %rcx
movq %rax, %rdi
callq 0x772c
movq %rbx, %rdi
movq %r14, %rsi
callq 0x9cc2
movl %eax, %ebp
testb %al, %al
je 0xdac5
movq 0x8(%rbx), %rdi
callq 0xffa2
testb %al, %al
jne 0xdab1
movq 0x8(%rbx), %rdi
callq 0xf950
testb %al, %al
jne 0xdab1
movq 0x8(%rbx), %rdi
callq 0xf358
movq %rbx, %rdi
callq 0xe9f0
movq 0x8(%rbx), %rdi
leaq 0x38(%rbx), %rsi
addq $0x3c, %rbx
movq %rbx, %rdx
callq 0x1003e
movl %ebp, %eax
popq %rbx
popq %r14
popq %rbp
retq
movq %rax, %rbx
movl $0xc8, %esi
movq %r14, %rdi
callq 0x6330
movq %rbx, %rdi
callq 0x6580
// File: /workspace/github_cpp_makefile_star2_O1/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 %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x2e0, %rsp            # imm = 0x2E0
movq %rdx, %rbx
movq %rsi, %r14
movq %rdi, %r15
callq 0xecb0
movq %rax, %r12
movq (%rax), %rsi
movq %r15, %rdi
callq 0xeeee
movq (%r12), %rsi
leaq 0xd8(%rsp), %r13
movq %r13, %rdi
movl $0x8, %edx
callq 0x65b0
leaq 0x8(%rsp), %rdi
movq %r13, %rsi
callq 0xefd4
movq 0x10(%r15), %rdi
movq %r12, %rsi
callq 0xa8e8
movq 0x10(%r15), %rdx
leaq 0x50(%rsp), %rdi
leaq 0x8(%rsp), %rsi
xorl %ecx, %ecx
callq 0x128ac
leaq 0x50(%rsp), %rdi
callq 0x12920
leaq 0x50(%rsp), %rdi
movq %r14, %rsi
movq %rbx, %rdx
callq 0x12dce
leaq 0x50(%rsp), %rdi
callq 0x128c8
leaq 0x8(%rsp), %rdi
callq 0xf0b6
leaq 0xd8(%rsp), %rdi
callq 0x60b0
addq $0x2e0, %rsp            # imm = 0x2E0
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
jmp 0xdba5
movq %rax, %rbx
jmp 0xdbbc
movq %rax, %rbx
jmp 0xdbc6
movq %rax, %rbx
leaq 0x50(%rsp), %rdi
callq 0x128c8
leaq 0x8(%rsp), %rdi
callq 0xf0b6
leaq 0xd8(%rsp), %rdi
callq 0x60b0
movq %rbx, %rdi
callq 0x6580
nop
// File: /workspace/github_cpp_makefile_star2_O1/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
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x2f8, %rsp            # imm = 0x2F8
movq %rdx, %rbx
movq %rsi, %r14
movq %rdi, %r15
movl $0x10, %edi
callq 0x6030
movq %rax, %r12
movq 0x10(%r15), %rax
leaq 0x100(%rsp), %rbp
movq %rbp, -0x10(%rbp)
movq 0xc0(%rax), %rsi
movq 0xc8(%rax), %rdx
addq %rsi, %rdx
leaq 0xf0(%rsp), %r13
movq %r13, %rdi
callq 0x7456
leaq 0x6570(%rip), %rsi      # 0x14611
movq %r13, %rdi
callq 0x65d0
movq 0xb0(%r15), %rsi
movq 0xb8(%r15), %rdx
leaq 0xf0(%rsp), %rdi
callq 0x6100
leaq 0x10(%rsp), %r13
movq %r13, -0x10(%r13)
movq (%rax), %rdx
movq %rax, %rcx
addq $0x10, %rcx
cmpq %rcx, %rdx
je 0xe0ea
movq %rdx, (%rsp)
movq (%rcx), %rdx
movq %rdx, 0x10(%rsp)
jmp 0xe0f2
movups (%rcx), %xmm0
movups %xmm0, (%r13)
movq 0x8(%rax), %rdx
movq %rdx, 0x8(%rsp)
movq %rcx, (%rax)
movq $0x0, 0x8(%rax)
movb $0x0, 0x10(%rax)
movq 0xf0(%rsp), %rdi
cmpq %rbp, %rdi
je 0xe127
movq 0x100(%rsp), %rsi
incq %rsi
callq 0x6330
movq (%rsp), %rsi
movq %rsi, (%r12)
movq $0x0, 0x8(%r12)
movq %r15, %rdi
callq 0xeeee
movq (%r12), %rsi
leaq 0xf0(%rsp), %rdi
movl $0x8, %edx
callq 0x65b0
leaq 0x20(%rsp), %rdi
leaq 0xf0(%rsp), %rsi
callq 0xefd4
movq 0x10(%r15), %rdi
movq %r12, %rsi
callq 0xa8e8
movq 0x10(%r15), %rdx
leaq 0x68(%rsp), %rdi
leaq 0x20(%rsp), %rsi
xorl %ecx, %ecx
callq 0x128ac
leaq 0x68(%rsp), %rdi
movb $0x1, 0x85(%rdi)
callq 0x12920
leaq 0x68(%rsp), %rdi
movq %r14, %rsi
movq %rbx, %rdx
callq 0x12dce
leaq 0x68(%rsp), %rdi
callq 0x128c8
leaq 0x20(%rsp), %rdi
callq 0xf0b6
leaq 0xf0(%rsp), %rdi
callq 0x60b0
movq (%rsp), %rdi
cmpq %r13, %rdi
je 0xe1e1
movq 0x10(%rsp), %rsi
incq %rsi
callq 0x6330
addq $0x2f8, %rsp            # imm = 0x2F8
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
jmp 0xe1f5
movq %rax, %rbx
jmp 0xe22f
movq %rax, %rbx
jmp 0xe239
jmp 0xe201
movq %rax, %rbx
jmp 0xe246
jmp 0xe208
movq %rax, %rbx
movq 0xf0(%rsp), %rdi
cmpq %rbp, %rdi
je 0xe25c
movq 0x100(%rsp), %rsi
jmp 0xe254
movq %rax, %rbx
leaq 0x68(%rsp), %rdi
callq 0x128c8
leaq 0x20(%rsp), %rdi
callq 0xf0b6
leaq 0xf0(%rsp), %rdi
callq 0x60b0
movq (%rsp), %rdi
cmpq %r13, %rdi
je 0xe25c
movq 0x10(%rsp), %rsi
incq %rsi
callq 0x6330
movq %rbx, %rdi
callq 0x6580
// File: /workspace/github_cpp_makefile_star2_O1/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 0x9b54
leaq 0xcfa4(%rip), %rax      # 0x1b938
movq %rax, (%rbx)
xorps %xmm0, %xmm0
movups %xmm0, 0x98(%rbx)
movq $0x0, 0xa8(%rbx)
movq $-0x1, 0x88(%rbx)
movl $0xffffffff, 0x90(%rbx) # imm = 0xFFFFFFFF
movb $0x0, 0x85(%rbx)
popq %rbx
retq
// File: /workspace/github_cpp_makefile_star2_O1/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 0x11eb0
movq %rbx, %rdi
movq %r15, %rsi
callq 0x9cc2
testb %al, %al
jne 0xea89
movl $0xd0, %edi
callq 0x6320
movq %rax, %r15
movq 0x8(%rbx), %rsi
movq 0x10(%rbx), %rdx
movq %rax, %rdi
movq %r14, %rcx
callq 0x7c28
movq %rbx, %rdi
movq %r15, %rsi
callq 0x9cc2
testb %al, %al
jne 0xea89
movl $0xd0, %edi
callq 0x6320
movq %rax, %r15
movq 0x8(%rbx), %rsi
movq 0x10(%rbx), %rdx
movq %rax, %rdi
movq %r14, %rcx
callq 0x79dc
movq %rbx, %rdi
movq %r15, %rsi
callq 0x9cc2
testb %al, %al
je 0xeab1
movq 0x8(%rbx), %rdi
callq 0xffa2
testb %al, %al
jne 0xeab1
movq 0x8(%rbx), %rdi
callq 0xf950
testb %al, %al
jne 0xeab1
movq 0x8(%rbx), %rdi
callq 0xf358
jmp 0xe9fc
popq %rbx
popq %r14
popq %r15
retq
jmp 0xeab9
movq %rax, %rbx
movl $0xd0, %esi
jmp 0xeacb
movq %rax, %rbx
movl $0xc8, %esi
movq %r15, %rdi
callq 0x6330
movq %rbx, %rdi
callq 0x6580
nop
// File: /workspace/github_cpp_makefile_star2_O1/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 0xeaef
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_O1/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 0xeb20
movl 0x88(%rbx), %edi
callq 0x65e0
movl 0x90(%rbx), %edi
testl %edi, %edi
jle 0xeb3c
xorl %esi, %esi
callq 0x62d0
movl 0x90(%rbx), %edi
callq 0x65e0
movl 0x8c(%rbx), %edi
cmpl $0x2, %edi
jl 0xeb5d
movl $0x1, %esi
callq 0x62d0
movl 0x8c(%rbx), %edi
popq %rbx
jmp 0x65e0
popq %rbx
retq
nop
// File: /workspace/github_cpp_makefile_star2_O1/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 0xd414(%rip), %rdi      # 0x1bfc8
callq 0x61e0
movq (%rbx), %rax
movq %rbx, %rdi
callq *0x10(%rax)
callq 0x60c0
testl %eax, %eax
js 0xebe2
je 0xebec
movl %eax, %ebp
movq %rbx, %rdi
callq 0xeadc
movl %ebp, %eax
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
movl $0x4, %edi
callq 0x63c0
movq 0x10(%rbx), %rax
cmpb $0x1, 0xe0(%rax)
jne 0xec62
movq 0xd3f0(%rip), %r12      # 0x1bff0
leaq 0x566c(%rip), %rsi      # 0x14273
movl $0x6, %edx
movq %r12, %rdi
callq 0x63a0
callq 0x6480
movq %r12, %rdi
movl %eax, %esi
callq 0x6560
movq %rax, %r12
leaq 0x597e(%rip), %rsi      # 0x145ab
movl $0x6, %edx
movq %rax, %rdi
callq 0x63a0
movq (%r12), %rax
movq -0x18(%rax), %rdi
addq %r12, %rdi
movl $0xa, %esi
callq 0x6300
movsbl %al, %esi
movq %r12, %rdi
callq 0x6040
movq %rax, %rdi
callq 0x61e0
movq 0x10(%rbx), %rax
incl 0x9c(%rax)
movq %rbx, %rdi
callq 0xeb08
movq 0x8(%rbx), %rdi
callq 0xf196
testq %r15, %r15
jne 0xec91
testq %r14, %r14
je 0xec99
movq %r14, %rdi
callq 0x9ad4
jmp 0xec99
movq %r15, %rdi
callq 0x8d3e
movq (%rbx), %rax
movq %rbx, %rdi
movq %r15, %rsi
movq %r14, %rdx
callq *0x48(%rax)
movq %rbx, %rdi
callq 0xeb60
// File: /workspace/github_cpp_makefile_star2_O1/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 $0x48, %rsp
movq %rdi, %rbx
movq 0x18(%rdi), %r14
movq 0x20(%rdi), %rax
subq %r14, %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 %rax, %r15
movq (%r14), %rax
movq 0xa8(%rax), %rax
movq %rax, (%r15)
movq 0x18(%rbx), %rax
movq 0x20(%rbx), %rcx
subq %rax, %rcx
shrq $0x3, %rcx
movl $0x1, %r14d
cmpl $0x2, %ecx
jl 0xed5a
movq (%rax,%r14,8), %rdi
movq (%rdi), %rax
callq *0x40(%rax)
movq %rax, (%r15,%r14,8)
incq %r14
movq 0x18(%rbx), %rax
movq 0x20(%rbx), %rcx
subq %rax, %rcx
shrq $0x3, %rcx
movslq %ecx, %rcx
cmpq %rcx, %r14
jl 0xed32
movq %r15, 0x8(%rsp)
movq 0x98(%rbx), %rbp
movq %rbx, 0x10(%rsp)
movq 0xa0(%rbx), %rax
movq %rax, 0x20(%rsp)
cmpq %rax, %rbp
je 0xee11
leaq 0x38(%rsp), %rbx
movq 0x8(%rsp), %rax
leaq (%rax,%r14,8), %rax
movq %rax, 0x18(%rsp)
xorl %r14d, %r14d
movq %rbx, 0x28(%rsp)
movq (%rbp,%r14,4), %rsi
movq 0x8(%rbp,%r14,4), %rdx
addq %rsi, %rdx
leaq 0x28(%rsp), %rdi
callq 0x7456
movq 0x30(%rsp), %r15
leaq 0x1(%r15), %rdi
callq 0x6030
movq %rax, %r13
movq 0x18(%rsp), %rax
movq %r13, (%rax,%r14)
movq 0x28(%rsp), %r12
movq %r13, %rdi
movq %r12, %rsi
callq 0x62e0
movb $0x0, (%r13,%r15)
cmpq %rbx, %r12
je 0xedf7
movq 0x38(%rsp), %rsi
incq %rsi
movq %r12, %rdi
callq 0x6330
leaq (,%r14,4), %rax
addq %rbp, %rax
addq $0x8, %r14
addq $0x20, %rax
cmpq 0x20(%rsp), %rax
jne 0xed96
movq 0x10(%rsp), %rax
movq 0x20(%rax), %rsi
subq 0x18(%rax), %rsi
movq 0xa0(%rax), %rcx
subq 0x98(%rax), %rcx
movq 0x8(%rsp), %rax
movq %rax, %rdx
addq %rsi, %rdx
sarq $0x2, %rcx
movq $0x0, (%rcx,%rdx)
addq $0x48, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %r14
movq 0x28(%rsp), %rdi
cmpq %rbx, %rdi
je 0xee6c
movq 0x38(%rsp), %rsi
incq %rsi
callq 0x6330
movq %r14, %rdi
callq 0x6580
// File: /workspace/github_cpp_makefile_star2_O1/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 0xef8b
pushq %r15
pushq %r14
pushq %rbx
movq %rsi, %rbx
movq %rdi, %r14
movq 0xd0df(%rip), %r15      # 0x1bff0
leaq 0x535b(%rip), %rsi      # 0x14273
movl $0x6, %edx
movq %r15, %rdi
callq 0x63a0
callq 0x6480
movq %r15, %rdi
movl %eax, %esi
callq 0x6560
movq %rax, %r15
leaq 0x568e(%rip), %rsi      # 0x145cc
movl $0xb, %edx
movq %rax, %rdi
callq 0x63a0
movl 0x30(%r14), %esi
movq %r15, %rdi
callq 0x6560
movq %rax, %r14
leaq 0x5914(%rip), %rsi      # 0x14875
movl $0x1, %edx
movq %rax, %rdi
callq 0x63a0
testq %rbx, %rbx
je 0xef8c
movq %rbx, %rdi
callq 0x6140
movq %r14, %rdi
movq %rbx, %rsi
movq %rax, %rdx
callq 0x63a0
jmp 0xefa6
retq
movq (%r14), %rax
movq -0x18(%rax), %rax
movq %r14, %rdi
addq %rax, %rdi
movl 0x20(%r14,%rax), %esi
orl $0x1, %esi
callq 0x6530
movq (%r14), %rax
movq -0x18(%rax), %rdi
addq %r14, %rdi
movl $0xa, %esi
callq 0x6300
movsbl %al, %esi
movq %r14, %rdi
callq 0x6040
movq %rax, %rdi
popq %rbx
popq %r14
popq %r15
jmp 0x61e0
nop
// File: /workspace/github_cpp_makefile_star2_O1/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, %r14
movq %rdi, %rbx
xorps %xmm0, %xmm0
movups %xmm0, 0x8(%rdi)
xorl %eax, %eax
movq %rax, 0x18(%rdi)
leaq 0x38(%rdi), %r12
movq %r12, 0x28(%rdi)
movq %rax, 0x30(%rdi)
movb $0x0, 0x38(%rdi)
movq (%rsi), %rax
movq -0x18(%rax), %rax
testb $0x5, 0x20(%rsi,%rax)
je 0xf053
movq 0xcfdc(%rip), %r15      # 0x1bff0
leaq 0x55d8(%rip), %rsi      # 0x145f3
movl $0x17, %edx
movq %r15, %rdi
callq 0x63a0
movq (%r15), %rax
addq -0x18(%rax), %r15
movq %r15, %rdi
movl $0xa, %esi
callq 0x6300
movsbl %al, %esi
movq 0xcfaa(%rip), %rdi      # 0x1bff0
callq 0x6040
movq %rax, %rdi
callq 0x61e0
movq %r14, (%rbx)
movq $0x0, 0x20(%rbx)
movq %rbx, %rdi
callq 0xf0e0
testb %al, %al
jne 0xf05e
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
jmp 0xf078
movq %rax, %r14
movq 0x28(%rbx), %rdi
addq $0x8, %rbx
cmpq %r12, %rdi
je 0xf094
movq (%r12), %rsi
incq %rsi
callq 0x6330
movq %rbx, %rdi
callq 0xbcd0
movq %r14, %rdi
callq 0x6580
// File: /workspace/github_cpp_makefile_star2_O1/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
pushq %r15
pushq %r14
pushq %rbx
subq $0x28, %rsp
movq %rdi, %rbx
leaq 0x18(%rsp), %r15
movq %r15, -0x10(%r15)
movq $0x0, -0x8(%r15)
movb $0x0, (%r15)
movq (%rdi), %r14
movq (%r14), %rax
movq -0x18(%rax), %rdi
addq %r14, %rdi
movl $0xa, %esi
callq 0x6300
movsbl %al, %edx
leaq 0x8(%rsp), %rsi
movq %r14, %rdi
callq 0x65c0
movq (%rax), %rcx
movq -0x18(%rcx), %rcx
movl 0x20(%rax,%rcx), %ebp
testb $0x5, %bpl
jne 0xf14b
addq $0x8, %rbx
leaq 0x8(%rsp), %rsi
movq %rbx, %rdi
callq 0xbdfe
movq 0x8(%rsp), %rdi
cmpq %r15, %rdi
je 0xf162
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x6330
testb $0x5, %bpl
sete %al
addq $0x28, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
movq 0x8(%rsp), %rdi
cmpq %r15, %rdi
je 0xf18e
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x6330
movq %rbx, %rdi
callq 0x6580
// File: /workspace/github_cpp_makefile_star2_O1/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 0xfb88
movl %eax, %ecx
movb $0x1, %al
testb %cl, %cl
jne 0xfb42
movq %rbx, %rdi
movq %r14, %rsi
callq 0xfcfa
addq $0x8, %rsp
popq %rbx
popq %r14
retq
movq %rax, %rdi
callq 0x6130
movl $0x8, %edi
callq 0x6190
movq %rbx, (%rax)
leaq 0xb6ca(%rip), %rsi      # 0x1b230
movq %rax, %rdi
xorl %edx, %edx
callq 0x6550
movq %rax, %rbx
callq 0x6500
movq %rbx, %rdi
callq 0x6580
movq %rax, %rdi
callq 0x7c1d
// File: /workspace/github_cpp_makefile_star2_O1/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 %r14
pushq %rbx
movq %rdi, %rbx
movl 0x20(%rdi), %ebp
movl 0x24(%rdi), %r14d
callq 0xf358
movq %rbx, %rdi
callq 0xf5bc
testb %al, %al
jne 0xffb5
movslq 0x20(%rbx), %rax
movq 0x8(%rbx), %rdi
movq 0x10(%rbx), %rcx
subq %rdi, %rcx
shrq $0x5, %rcx
cmpl %ecx, %eax
jge 0x10029
movslq 0x24(%rbx), %rsi
movq %rax, %r8
shlq $0x5, %r8
movq 0x8(%rdi,%r8), %rdx
cmpl %edx, %esi
jge 0x10022
cmpq %rsi, %rdx
jbe 0x10030
addq %r8, %rdi
movq (%rdi), %rdx
cmpb $0x23, (%rdx,%rsi)
jne 0x10022
incl %esi
movl %esi, 0x24(%rbx)
cmpl %ecx, %eax
jge 0x10012
movl $0x0, 0x24(%rbx)
incl %eax
movl %eax, 0x20(%rbx)
movq %rbx, %rdi
callq 0xf5bc
testb %al, %al
jne 0x10012
movb $0x1, %al
jmp 0x1002b
movl %ebp, 0x20(%rbx)
movl %r14d, 0x24(%rbx)
xorl %eax, %eax
popq %rbx
popq %r14
popq %rbp
retq
leaq 0x4484(%rip), %rdi      # 0x144bb
xorl %eax, %eax
callq 0x64a0
// File: /workspace/github_cpp_makefile_star2_O1/ryuichiueda[P]GlueLang/src/Feeder.cc
// Function: Feeder::doBlock(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>*)
bool Feeder::doBlock(string *ans)
{
	return block(ans,"do");
	/*
	if(!str("do")){
                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 %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x28, %rsp
movq %rsi, %rbx
movq %rdi, %r14
leaq 0x18(%rsp), %r12
movq %r12, -0x10(%r12)
leaq 0x3d65(%rip), %rsi      # 0x14665
leaq 0x3d60(%rip), %rdx      # 0x14667
leaq 0x8(%rsp), %r15
movq %r15, %rdi
callq 0x74e6
movq %r14, %rdi
movq %rbx, %rsi
movq %r15, %rdx
callq 0x1096c
movl %eax, %ebx
movq 0x8(%rsp), %rdi
cmpq %r12, %rdi
je 0x1093b
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x6330
movl %ebx, %eax
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
movq %rax, %rbx
movq 0x8(%rsp), %rdi
cmpq %r12, %rdi
je 0x10963
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x6330
movq %rbx, %rdi
callq 0x6580
nop
// File: /workspace/github_cpp_makefile_star2_O1/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 0x58(%rsp), %r12
movq %r12, -0x10(%r12)
movq (%rdx), %rsi
movq 0x8(%rdx), %rdx
addq %rsi, %rdx
leaq 0x48(%rsp), %r15
movq %r15, %rdi
callq 0x7456
movq %r14, %rdi
movq %r15, %rsi
callq 0x100e8
movl %eax, %ebp
movq 0x48(%rsp), %rdi
cmpq %r12, %rdi
je 0x109c5
movq 0x58(%rsp), %rsi
incq %rsi
callq 0x6330
movb %bpl, 0x7(%rsp)
testb %bpl, %bpl
je 0x10ac1
movq %r14, %rdi
callq 0xf5bc
testb %al, %al
je 0x109ee
movq %rbx, %rdi
movl $0xa, %esi
callq 0x6290
jmp 0x109d3
movq %r14, %rdi
callq 0x10830
movl %eax, %r15d
movslq %eax, %r12
leaq 0x8(%rsp), %r13
leaq 0x18(%rsp), %rax
movq %rax, 0x8(%rsp)
movq $0x0, 0x10(%rsp)
movb $0x0, 0x18(%rsp)
movq %r14, %rdi
movq %r13, %rsi
callq 0x1004a
movq 0x10(%rsp), %rcx
subq %r12, %rcx
leaq 0x28(%rsp), %rdi
movq %r13, %rsi
movq %r12, %rdx
callq 0x6350
movq 0x28(%rsp), %rsi
movq 0x30(%rsp), %rdx
movq %rbx, %rdi
callq 0x6100
movq 0x28(%rsp), %rdi
leaq 0x38(%rsp), %rax
cmpq %rax, %rdi
je 0x10a6a
movq 0x38(%rsp), %rsi
incq %rsi
callq 0x6330
movq %rbx, %rdi
movl $0xa, %esi
callq 0x6290
movq %r14, %rdi
callq 0xf5bc
testb %al, %al
je 0x10a92
movq %rbx, %rdi
movl $0xa, %esi
callq 0x6290
jmp 0x10a77
movq %r14, %rdi
callq 0x10830
movl %eax, %ebp
movq 0x8(%rsp), %rdi
leaq 0x18(%rsp), %rax
cmpq %rax, %rdi
je 0x10ab8
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x6330
cmpl %r15d, %ebp
jge 0x10a01
movb 0x7(%rsp), %al
addq $0x68, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
movq 0x48(%rsp), %rdi
cmpq %r12, %rdi
je 0x10b2c
movq 0x58(%rsp), %rsi
jmp 0x10b24
jmp 0x10b0d
movq %rax, %rbx
movq 0x28(%rsp), %rdi
leaq 0x38(%rsp), %rax
cmpq %rax, %rdi
je 0x10b10
movq 0x38(%rsp), %rsi
incq %rsi
callq 0x6330
jmp 0x10b10
jmp 0x10b0d
movq %rax, %rbx
movq 0x8(%rsp), %rdi
leaq 0x18(%rsp), %rax
cmpq %rax, %rdi
je 0x10b2c
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x6330
movq %rbx, %rdi
callq 0x6580
// File: /workspace/github_cpp_makefile_star2_O1/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), %rsi
leaq 0x34(%rbx), %r15
movq %rsi, (%rsp)
movq %r15, %rdx
callq 0x1003e
movq 0x8(%rbx), %r12
leaq 0x38(%rsp), %r14
movq %r14, -0x10(%r14)
leaq 0x392f(%rip), %rsi      # 0x14676
leaq 0x392e(%rip), %rdx      # 0x1467c
leaq 0x28(%rsp), %r13
movq %r13, %rdi
callq 0x74e6
movq %r12, %rdi
movq %r13, %rsi
callq 0x100e8
movl %eax, %ebp
movq 0x28(%rsp), %rdi
cmpq %r14, %rdi
je 0x10d7f
movq 0x38(%rsp), %rsi
incq %rsi
callq 0x6330
testb %bpl, %bpl
je 0x10e2a
movq 0x8(%rbx), %rdi
leaq 0x88(%rbx), %r12
movq %r12, %rsi
callq 0xf1b0
movq 0x8(%rbx), %r13
testb %al, %al
je 0x10dfa
leaq 0x18(%rsp), %r14
movq %r14, -0x10(%r14)
leaq 0x38ca(%rip), %rsi      # 0x1467d
leaq 0x38c5(%rip), %rdx      # 0x1467f
leaq 0x8(%rsp), %r15
movq %r15, %rdi
callq 0x74e6
movq %r13, %rdi
movq %r15, %rsi
callq 0x100e8
movl %eax, %ebp
movq 0x8(%rsp), %rdi
cmpq %r14, %rdi
je 0x10deb
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x6330
testb %bpl, %bpl
je 0x10e08
movq %rbx, %rdi
callq 0x10e70
jmp 0x10e43
movq (%rsp), %rax
movl (%rax), %esi
movl (%r15), %edx
movq %r13, %rdi
jmp 0x10e25
leaq 0x3871(%rip), %rsi      # 0x14680
movq %r12, %rdi
callq 0x60f0
testl %eax, %eax
je 0x10e3b
movq 0x8(%rbx), %rdi
movl 0x30(%rbx), %esi
movl 0x34(%rbx), %edx
callq 0xf958
xorl %eax, %eax
addq $0x48, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rbx, %rdi
callq 0x10f82
jmp 0x10e2c
movq %rax, %rbx
movq 0x8(%rsp), %rdi
jmp 0x10e57
movq %rax, %rbx
movq 0x28(%rsp), %rdi
cmpq %r14, %rdi
je 0x10e67
movq (%r14), %rsi
incq %rsi
callq 0x6330
movq %rbx, %rdi
callq 0x6580
nop
// File: /workspace/github_cpp_makefile_star2_O1/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 0xf49c
movl %eax, %ebp
testb %al, %al
je 0x10ee4
leaq 0x88(%rbx), %r15
movq 0x88(%rbx), %rax
movq 0x90(%rbx), %rcx
cmpb $0x2f, -0x1(%rax,%rcx)
je 0x10ebf
movq %r15, %rdi
movl $0x2f, %esi
callq 0x6290
movq 0x10(%rbx), %rdi
movq %r14, %rsi
movq %r15, %rdx
callq 0xaf8a
movq 0x8(%rbx), %rdi
leaq 0x38(%rbx), %rsi
addq $0x3c, %rbx
movq %rbx, %rdx
callq 0x1003e
jmp 0x10ef3
movq 0x8(%rbx), %rdi
movl 0x30(%rbx), %esi
movl 0x34(%rbx), %edx
callq 0xf958
movl %ebp, %eax
addq $0x28, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rdi
callq 0x6130
movl $0xa0, %edx
addq 0x10(%rbx), %rdx
leaq 0x376d(%rip), %rsi      # 0x14685
leaq 0x8(%rsp), %rdi
callq 0x73ce
leaq 0x8(%rsp), %rsi
movq %rbx, %rdi
callq 0x66e0
movl $0x1, 0x80(%rbx)
movq 0x8(%rbx), %rdi
leaq 0x38(%rbx), %rsi
leaq 0x3c(%rbx), %rdx
callq 0x1003e
movl $0x8, %edi
callq 0x6190
movq %rbx, (%rax)
leaq 0xaac2(%rip), %rsi      # 0x1ba20
movq %rax, %rdi
xorl %edx, %edx
callq 0x6550
jmp 0x10f6a
movq %rax, %rbx
callq 0x6500
movq %rbx, %rdi
callq 0x6580
movq %rax, %rdi
callq 0x7c1d
// File: /workspace/github_cpp_makefile_star2_O1/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 0x1128f
movq (%r15), %r14
leaq 0x3400(%rip), %rsi      # 0x146a5
movl $0x4, %edx
movq %r14, %rdi
callq 0x6170
testl %eax, %eax
je 0x1130f
leaq 0x33ee(%rip), %rsi      # 0x146ab
movl $0x3, %edx
movq %r14, %rdi
callq 0x6170
testl %eax, %eax
je 0x1131f
leaq 0x33d5(%rip), %rsi      # 0x146aa
movl $0x4, %edx
movq %r14, %rdi
callq 0x6170
testl %eax, %eax
je 0x11329
leaq 0x33c2(%rip), %rsi      # 0x146af
movl $0x5, %edx
movq %r14, %rdi
callq 0x6170
testl %eax, %eax
je 0x11338
movl $0xffffffff, %eax       # imm = 0xFFFFFFFF
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
decl %r12d
movl %r12d, %edi
movq %r15, %rsi
callq 0x1134a
jmp 0x11331
movq %rbx, %rsi
callq 0x11464
jmp 0x11331
movq %rbx, %rsi
callq 0x114a6
xorl %edi, %edi
callq 0x63c0
movq %rbx, %rdi
callq 0x114e8
movl $0x1, %edi
callq 0x63c0
// File: /workspace/github_cpp_makefile_star2_O1/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
subq $0x18, %rsp
movq %rsi, %rbx
leal -0x1(%rdi), %eax
movl %eax, 0xc(%rsp)
movq %rdi, 0x10(%rsp)
cmpl $0x3, %edi
jl 0x113d5
movl 0xc(%rsp), %ebp
movl $0x1, %r14d
movq 0xac4b(%rip), %r15      # 0x1bfc8
leaq 0x34f1(%rip), %r12      # 0x14875
movq (%rbx,%r14,8), %r13
testq %r13, %r13
je 0x113a5
movq %r13, %rdi
callq 0x6140
movq %r15, %rdi
movq %r13, %rsi
movq %rax, %rdx
callq 0x63a0
jmp 0x113bd
movq (%r15), %rax
movq -0x18(%rax), %rax
leaq (%r15,%rax), %rdi
movl 0x20(%r15,%rax), %esi
orl $0x1, %esi
callq 0x6530
movl $0x1, %edx
movq %r15, %rdi
movq %r12, %rsi
callq 0x63a0
incq %r14
cmpq %r14, %rbp
jne 0x11384
cmpl $0x1, 0x10(%rsp)
jle 0x11452
movslq 0xc(%rsp), %rax
movq (%rbx,%rax,8), %rbx
testq %rbx, %rbx
je 0x11406
movq %rbx, %rdi
callq 0x6140
movq 0xabcf(%rip), %rdi      # 0x1bfc8
movq %rbx, %rsi
movq %rax, %rdx
callq 0x63a0
jmp 0x11424
movq 0xabbb(%rip), %rax      # 0x1bfc8
movq (%rax), %rcx
movq -0x18(%rcx), %rcx
leaq (%rax,%rcx), %rdi
movl 0x20(%rax,%rcx), %esi
orl $0x1, %esi
callq 0x6530
movq 0xab9d(%rip), %rbx      # 0x1bfc8
movq (%rbx), %rax
movq -0x18(%rax), %rdi
addq %rbx, %rdi
movl $0xa, %esi
callq 0x6300
movsbl %al, %esi
movq %rbx, %rdi
callq 0x6040
movq %rax, %rdi
callq 0x61e0
xorl %eax, %eax
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O1/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 0x9b54
leaq 0xa540(%rip), %rax      # 0x1ba50
movq %rax, (%rbx)
leaq 0xa8(%rbx), %rax
movq %rax, 0x98(%rbx)
movq $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
nop
// File: /workspace/github_cpp_makefile_star2_O1/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 0xa405(%rip), %rdi      # 0x1bfc8
callq 0x61e0
movq (%r15), %rax
movq %r15, %rdi
callq *0x10(%rax)
movq 0x88(%r15), %rdi
testq %rdi, %rdi
je 0x11bfe
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 0x11c1e
movq %r15, %rdi
movq %r14, %rsi
movq %rbx, %rdx
callq 0x11c32
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 0x11db0
nop
// File: /workspace/github_cpp_makefile_star2_O1/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 0x60c0
testl %eax, %eax
js 0x11c7b
movq 0x10(%rbx), %rdi
je 0x11c85
movl %eax, %ebp
leaq 0x48(%rbx), %rsi
leaq 0x98(%rbx), %rdx
callq 0xb626
movl %ebp, 0x48(%rax)
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movl $0x4, %edi
callq 0x63c0
cmpb $0x1, 0xe0(%rdi)
jne 0x11cf0
movq 0xa35b(%rip), %r12      # 0x1bff0
leaq 0x25d7(%rip), %rsi      # 0x14273
movl $0x6, %edx
movq %r12, %rdi
callq 0x63a0
movq 0x10(%rbx), %rax
movl 0xe4(%rax), %esi
movq %r12, %rdi
callq 0x6560
movq %rax, %r12
leaq 0x28e6(%rip), %rsi      # 0x145ab
movl $0x6, %edx
movq %rax, %rdi
callq 0x63a0
movq 0x98(%rbx), %rsi
movq 0xa0(%rbx), %rdx
movq %r12, %rdi
callq 0x63a0
movq %rax, %rdi
callq 0x6180
movq 0x18(%rbx), %rax
movq 0x20(%rbx), %rcx
subq %rax, %rcx
shrq $0x3, %rcx
testl %ecx, %ecx
jle 0x11d50
xorl %r13d, %r13d
testq %r15, %r15
sete %cl
movq (%rax,%r13,8), %r12
testq %r13, %r13
sete %al
orb %cl, %al
jne 0x11d26
movq 0x88(%r15), %rdi
callq 0x81a8
movq (%r12), %rax
movq %r12, %rdi
movq %r15, %rsi
movq %r14, %rdx
callq *0x18(%rax)
incq %r13
movq 0x18(%rbx), %rax
movq 0x20(%rbx), %rcx
subq %rax, %rcx
shrq $0x3, %rcx
movslq %ecx, %rcx
cmpq %rcx, %r13
jl 0x11d06
xorl %edi, %edi
callq 0x63c0
movq %rax, %rdi
callq 0x6130
leaq 0x60(%rbx), %rdi
leaq 0x2990(%rip), %rsi      # 0x146fa
callq 0x6410
movl $0x2, 0x80(%rbx)
movl $0x8, %edi
callq 0x6190
movq %rbx, (%rax)
leaq 0x9d1b(%rip), %rsi      # 0x1baa8
movq %rax, %rdi
xorl %edx, %edx
callq 0x6550
movq %rax, %rbx
callq 0x6500
movq %rbx, %rdi
callq 0x6580
movq %rax, %rdi
callq 0x7c1d
nop
// File: /workspace/github_cpp_makefile_star2_O1/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
subq $0x18, %rsp
movq %rdx, 0x10(%rsp)
movq 0x20(%rdi), %rax
subq 0x18(%rdi), %rax
shrq $0x3, %rax
testl %eax, %eax
jle 0x11e9c
movq %rdi, %r15
xorl %r13d, %r13d
xorl %ebx, %ebx
xorl %ebp, %ebp
movq %rsi, 0x8(%rsp)
testb $0x1, %bl
je 0x11df5
testb $0x1, %bpl
je 0x11e80
testq %rsi, %rsi
sete %al
testq %r13, %r13
sete %cl
orb %al, %cl
jne 0x11e16
movq 0x88(%rsi), %rdi
callq 0x81a8
movq 0x8(%rsp), %rsi
movq 0x18(%r15), %rax
movq (%rax,%r13,8), %r12
movq (%r12), %rax
movq %r12, %rdi
movq 0x10(%rsp), %rdx
callq *0x18(%rax)
movl %ebp, %ecx
testb $0x1, %bpl
jne 0x11e6e
movb 0x86(%r12), %dl
testl %eax, %eax
sete %cl
setne %sil
andb %dl, %cl
movb $0x1, %bl
testb %dl, %sil
jne 0x11e6b
testl %eax, %eax
je 0x11e5e
cmpb $0x0, 0x85(%r12)
jne 0x11e6b
testl %eax, %eax
sete %bl
andb 0x87(%r12), %bl
movl %r14d, %eax
movl %eax, %r14d
testb $0x1, %bpl
movl %ecx, %ebp
movq 0x8(%rsp), %rsi
je 0x11e82
jmp 0x11e9e
xorl %ebx, %ebx
movq 0x20(%r15), %rax
subq 0x18(%r15), %rax
incq %r13
shrq $0x3, %rax
cltq
cmpq %rax, %r13
jl 0x11de6
xorl %eax, %eax
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
nopl (%rax)