LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_cpp_makefile_star2_O3/ryuichiueda[P]GlueLang/src/ArgExtCom.cc
// Function: ArgExtCom::parsePrefixedCom()
bool ArgExtCom::parsePrefixedCom(void)
{
	struct stat buf;
	auto paths = m_env->getImportPaths(&m_prefix);
	if(paths == NULL)
		return false;

	for(auto path : *paths){
		m_evaled_text = path + m_text;
		if(stat(m_evaled_text.c_str(), &buf) != 0)
			continue;

		m_feeder->getPos(&m_end_line, &m_end_char);
		return true;
	}
	m_error_msg = "Command " + m_text  + " not exist";
	m_exit_status = 2;
	m_feeder->getPos(&m_end_line, &m_end_char);
	throw this;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0xe8, %rsp
movq %rdi, %rax
movq 0x10(%rdi), %rdi
movq %rax, 0x8(%rsp)
leaq 0xc8(%rax), %rsi
callq 0xb116
testq %rax, %rax
je 0x72cc
movq (%rax), %r14
movq %rax, 0x30(%rsp)
movq 0x8(%rax), %rbx
cmpq %rbx, %r14
je 0x7200
movq 0x8(%rsp), %rax
leaq 0x88(%rax), %r15
leaq 0xa8(%rax), %r12
leaq 0x10(%rsp), %r13
leaq 0x38(%rsp), %rbp
leaq 0x20(%rsp), %rax
movq %rax, 0x10(%rsp)
movq (%r14), %rsi
movq 0x8(%r14), %rdx
addq %rsi, %rdx
movq %r13, %rdi
callq 0x745a
movq %rbp, %rdi
movq %r13, %rsi
movq %r15, %rdx
callq 0x7325
movq %r12, %rdi
movq %rbp, %rsi
callq 0x63f0
movq 0x38(%rsp), %rdi
leaq 0x48(%rsp), %rax
cmpq %rax, %rdi
je 0x71c1
movq 0x48(%rsp), %rsi
incq %rsi
callq 0x6330
movq (%r12), %rdi
leaq 0x58(%rsp), %rsi
callq 0x62b0
testl %eax, %eax
je 0x7295
movq 0x10(%rsp), %rdi
leaq 0x20(%rsp), %rax
cmpq %rax, %rdi
je 0x71f3
movq 0x20(%rsp), %rsi
incq %rsi
callq 0x6330
addq $0x20, %r14
cmpq %rbx, %r14
jne 0x7170
movq 0x8(%rsp), %rax
leaq 0x88(%rax), %rdx
leaq 0xce0b(%rip), %rsi      # 0x1401e
leaq 0x38(%rsp), %r14
movq %r14, %rdi
callq 0x73d2
leaq 0xce00(%rip), %rdx      # 0x14027
leaq 0x10(%rsp), %rdi
movq %r14, %rsi
callq 0x737f
movq 0x8(%rsp), %rbx
leaq 0x60(%rbx), %rdi
leaq 0x10(%rsp), %r14
movq %r14, %rsi
callq 0x63f0
movq %r14, %rdi
callq 0x6150
leaq 0x38(%rsp), %rdi
callq 0x6150
movl $0x2, 0x80(%rbx)
movq 0x8(%rbx), %rdi
leaq 0x38(%rbx), %rsi
leaq 0x3c(%rbx), %rdx
callq 0xfe78
movl $0x8, %edi
callq 0x6190
movq %rbx, (%rax)
leaq 0x13d95(%rip), %rsi     # 0x1b020
movq %rax, %rdi
xorl %edx, %edx
callq 0x6550
movq 0x8(%rsp), %rdx
movq 0x8(%rdx), %rdi
leaq 0x38(%rdx), %rsi
addq $0x3c, %rdx
callq 0xfe78
movq 0x10(%rsp), %rdi
leaq 0x20(%rsp), %rax
cmpq %rax, %rdi
je 0x72c7
movq 0x20(%rsp), %rsi
incq %rsi
callq 0x6330
movq 0x30(%rsp), %rax
testq %rax, %rax
setne %al
addq $0xe8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
jmp 0x72fe
movq %rax, %r14
leaq 0x48(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x731d
movq 0x48(%rsp), %rsi
jmp 0x7315
movq %rax, %r14
movq 0x10(%rsp), %rdi
leaq 0x20(%rsp), %rax
cmpq %rax, %rdi
je 0x731d
movq 0x20(%rsp), %rsi
incq %rsi
callq 0x6330
movq %r14, %rdi
callq 0x6580
// File: /workspace/github_cpp_makefile_star2_O3/ryuichiueda[P]GlueLang/src/ArgIntCom.cc
// Function: ArgIntCom::parse()
bool ArgIntCom::parse(void)
{
	m_feeder->getPos(&m_start_line, &m_start_char);

	m_feeder->str("in.");

	string tmp;
	if(!m_feeder->variable(&m_evaled_text)){
		m_feeder->setPos(m_start_line, m_start_char);
		return false;
	}

	m_text = "in." + m_evaled_text;

	if(m_evaled_text != "wait" && !InternalCommands::exist(&m_evaled_text)){
		m_feeder->setPos(m_start_line, m_start_char);
		return false;
	}


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

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x60, %rsp
movq %rdi, %rbx
movq 0x8(%rdi), %rdi
leaq 0x30(%rbx), %rsi
leaq 0x34(%rbx), %rdx
callq 0xfe78
movq 0x8(%rbx), %r14
leaq 0x10(%rsp), %r12
movq %r12, -0x10(%r12)
leaq 0xca82(%rip), %rsi      # 0x14073
leaq 0xca7e(%rip), %rdx      # 0x14076
movq %rsp, %r15
movq %r15, %rdi
callq 0x74f0
movq %r14, %rdi
movq %r15, %rsi
callq 0xff28
movq (%rsp), %rdi
cmpq %r12, %rdi
je 0x7624
movq 0x10(%rsp), %rsi
incq %rsi
callq 0x6330
leaq 0x30(%rsp), %r12
movq %r12, -0x10(%r12)
movq $0x0, -0x8(%r12)
movb $0x0, (%r12)
movq 0x8(%rbx), %rdi
leaq 0xa8(%rbx), %r14
movq %r14, %rsi
callq 0xf69c
testb %al, %al
je 0x76cd
leaq 0xca19(%rip), %rsi      # 0x14073
leaq 0x40(%rsp), %rdi
movq %r14, %rdx
callq 0x73d2
leaq 0x88(%rbx), %rdi
leaq 0x40(%rsp), %r15
movq %r15, %rsi
callq 0x63f0
movq (%r15), %rdi
leaq 0x50(%rsp), %rax
cmpq %rax, %rdi
je 0x7695
movq 0x50(%rsp), %rsi
incq %rsi
callq 0x6330
leaq 0xcedf(%rip), %rsi      # 0x1457b
movq %r14, %rdi
callq 0x60f0
testl %eax, %eax
je 0x76b4
movq %r14, %rdi
callq 0x11058
testb %al, %al
je 0x76cd
movq 0x8(%rbx), %rdi
leaq 0x38(%rbx), %rsi
addq $0x3c, %rbx
movb $0x1, %bpl
movq %rbx, %rdx
callq 0xfe78
jmp 0x76de
movq 0x8(%rbx), %rdi
movl 0x30(%rbx), %esi
movl 0x34(%rbx), %edx
callq 0xf828
xorl %ebp, %ebp
movq 0x20(%rsp), %rdi
cmpq %r12, %rdi
je 0x76f5
movq 0x30(%rsp), %rsi
incq %rsi
callq 0x6330
movl %ebp, %eax
addq $0x60, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
jmp 0x7719
movq %rax, %rbx
movq (%rsp), %rdi
cmpq %r12, %rdi
je 0x7733
movq 0x10(%rsp), %rsi
jmp 0x772b
movq %rax, %rbx
movq 0x20(%rsp), %rdi
cmpq %r12, %rdi
je 0x7733
movq 0x30(%rsp), %rsi
incq %rsi
callq 0x6330
movq %rbx, %rdi
callq 0x6580
nop
// File: /workspace/github_cpp_makefile_star2_O3/ryuichiueda[P]GlueLang/src/ArgVariable.cc
// Function: ArgVariable::parse()
bool ArgVariable::parse(void)
{
	m_feeder->getPos(&m_start_line, &m_start_char);

	if(m_feeder->str("local.")){
		m_is_local = true;
	}else if(m_feeder->str("this.")){
		m_is_proc = true;
	}

	if(!m_feeder->variable(&m_text))
		return false;

	if(m_is_local)
		m_text = "local." + m_text;
//	else if(m_is_proc)
//	m_text = "this." + m_text;

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

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x60, %rsp
movq %rdi, %rbx
movq 0x8(%rdi), %rdi
leaq 0x30(%rbx), %rsi
leaq 0x34(%rbx), %rdx
callq 0xfe78
movq 0x8(%rbx), %r14
leaq 0x30(%rsp), %r12
movq %r12, -0x10(%r12)
leaq 0xc634(%rip), %rsi      # 0x14091
leaq 0xc633(%rip), %rdx      # 0x14097
leaq 0x20(%rsp), %r15
movq %r15, %rdi
callq 0x74f0
movq %r14, %rdi
movq %r15, %rsi
callq 0xff28
movl %eax, %ebp
movq 0x20(%rsp), %rdi
cmpq %r12, %rdi
je 0x7a95
movq 0x30(%rsp), %rsi
incq %rsi
callq 0x6330
testb %bpl, %bpl
je 0x7aa3
movb $0x1, 0xc8(%rbx)
jmp 0x7af9
movq 0x8(%rbx), %r14
leaq 0x10(%rsp), %r12
movq %r12, -0x10(%r12)
leaq 0xc5ca(%rip), %rsi      # 0x14082
leaq 0xc5c8(%rip), %rdx      # 0x14087
movq %rsp, %r15
movq %r15, %rdi
callq 0x74f0
movq %r14, %rdi
movq %r15, %rsi
callq 0xff28
movl %eax, %ebp
movq (%rsp), %rdi
cmpq %r12, %rdi
je 0x7aed
movq 0x10(%rsp), %rsi
incq %rsi
callq 0x6330
testb %bpl, %bpl
je 0x7af9
movb $0x1, 0xc9(%rbx)
movq 0x8(%rbx), %rdi
leaq 0x88(%rbx), %r14
movq %r14, %rsi
callq 0xf69c
movl %eax, %ebp
testb %al, %al
je 0x7b6b
cmpb $0x1, 0xc8(%rbx)
jne 0x7b57
leaq 0xc56f(%rip), %rsi      # 0x14091
leaq 0x40(%rsp), %r15
movq %r15, %rdi
movq %r14, %rdx
callq 0x73d2
movq %r14, %rdi
movq %r15, %rsi
callq 0x63f0
movq (%r15), %rdi
leaq 0x50(%rsp), %rax
cmpq %rax, %rdi
je 0x7b57
movq 0x50(%rsp), %rsi
incq %rsi
callq 0x6330
movq 0x8(%rbx), %rdi
leaq 0x38(%rbx), %rsi
addq $0x3c, %rbx
movq %rbx, %rdx
callq 0xfe78
movl %ebp, %eax
addq $0x60, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
movq (%rsp), %rdi
jmp 0x7b8b
movq %rax, %rbx
movq 0x20(%rsp), %rdi
cmpq %r12, %rdi
je 0x7b9c
movq (%r12), %rsi
incq %rsi
callq 0x6330
movq %rbx, %rdi
callq 0x6580
// File: /workspace/github_cpp_makefile_star2_O3/ryuichiueda[P]GlueLang/src/ArrayVariable.cc
// Function: ArrayVariable::parse()
bool ArrayVariable::parse(void)
{
	m_feeder->getPos(&m_start_line, &m_start_char);

	try{
		if(!m_feeder->arrayElem(&m_text,&m_array_pos))
			return false;

	}catch(Feeder *e){
		m_feeder->getPos(&m_end_line, &m_end_char);
		m_error_msg = e->m_error_msg;
		m_exit_status = 3;
		throw this;
	}

	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 0xfe78
movq 0x8(%rbx), %rdi
leaq 0x88(%rbx), %rsi
leaq 0xc8(%rbx), %rdx
callq 0xf56a
movl %eax, %ebp
testb %al, %al
je 0x7cb5
movq 0x8(%rbx), %rdi
leaq 0x38(%rbx), %rsi
addq $0x3c, %rbx
movq %rbx, %rdx
callq 0xfe78
movl %ebp, %eax
popq %rbx
popq %r14
popq %rbp
retq
movq %rax, %r14
cmpl $0x1, %edx
jne 0x7d20
movq %r14, %rdi
callq 0x6130
movq %rax, %r14
movq 0x8(%rbx), %rdi
leaq 0x38(%rbx), %rsi
leaq 0x3c(%rbx), %rdx
callq 0xfe78
addq $0x28, %r14
leaq 0x60(%rbx), %rdi
movq %r14, %rsi
callq 0x61c0
movl $0x3, 0x80(%rbx)
movl $0x8, %edi
callq 0x6190
movq %rbx, (%rax)
leaq 0x13542(%rip), %rsi     # 0x1b250
movq %rax, %rdi
xorl %edx, %edx
callq 0x6550
movq %rax, %r14
callq 0x6500
movq %r14, %rdi
callq 0x6580
// File: /workspace/github_cpp_makefile_star2_O3/ryuichiueda[P]GlueLang/src/DataFile.cc
// Function: DataFile::openFile()
void DataFile::openFile(void)
{
	int mode = O_WRONLY | O_CREAT;
	if(m_append_mode)
		mode |= O_APPEND;

	int fd = open( m_value.c_str() , mode, 0600);
	if(fd < 3){
		m_error_msg = "file does not open.";
		throw this;
	}
	if(dup2(fd,1) < 0){
		m_error_msg = "file redirect error";
		throw this;
	}
	if( close(fd) < 0){
		m_error_msg = "file redirect error";
		throw this;
	}
}

// Assembly:
pushq %rbp
pushq %rbx
pushq %rax
movq %rdi, %rbx
movzbl 0x48(%rdi), %esi
shll $0xa, %esi
orl $0x41, %esi
movq 0x28(%rdi), %rdi
movl $0x180, %edx            # imm = 0x180
xorl %eax, %eax
callq 0x6210
cmpl $0x2, %eax
jle 0x8214
movl %eax, %ebp
movl %eax, %edi
movl $0x1, %esi
callq 0x62d0
testl %eax, %eax
js 0x8207
movl %ebp, %edi
callq 0x65e0
testl %eax, %eax
js 0x8207
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
leaq 0x8(%rbx), %rdi
leaq 0xbfe1(%rip), %rsi      # 0x141f3
jmp 0x821f
leaq 0x8(%rbx), %rdi
leaq 0xbfc0(%rip), %rsi      # 0x141df
callq 0x6410
movl $0x8, %edi
callq 0x6190
movq %rbx, (%rax)
leaq 0x130f0(%rip), %rsi     # 0x1b328
movq %rax, %rdi
xorl %edx, %edx
callq 0x6550
// File: /workspace/github_cpp_makefile_star2_O3/ryuichiueda[P]GlueLang/src/DataStr.cc
// Function: DataStr::openFifo()
void DataStr::openFifo(void)
{
	int fd = open( m_filename.c_str() ,O_WRONLY ,0600);
	if(dup2(fd,1) < 0){
		m_error_msg = "str redirect error";
		throw this;
	}
	if( close(fd) < 0){
		m_error_msg = "str redirect error";
		throw this;
	}
}

// Assembly:
pushq %rbp
pushq %rbx
pushq %rax
movq %rdi, %rbx
movq 0x48(%rdi), %rdi
movl $0x1, %esi
movl $0x180, %edx            # imm = 0x180
xorl %eax, %eax
callq 0x6210
movl %eax, %ebp
movl %eax, %edi
movl $0x1, %esi
callq 0x62d0
testl %eax, %eax
js 0x8431
movl %ebp, %edi
callq 0x65e0
testl %eax, %eax
js 0x8431
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
leaq 0x8(%rbx), %rdi
leaq 0xbe0a(%rip), %rsi      # 0x14246
callq 0x6410
movl $0x8, %edi
callq 0x6190
movq %rbx, (%rax)
leaq 0x12fcb(%rip), %rsi     # 0x1b420
movq %rax, %rdi
xorl %edx, %edx
callq 0x6550
nop
// File: /workspace/github_cpp_makefile_star2_O3/ryuichiueda[P]GlueLang/src/DataStr.cc
// Function: DataStr::readFifo()
void DataStr::readFifo(void)
{
	ifstream ifs(m_filename.c_str());
	string tmp;
	string value;
	if(m_is_set){
		value = "\n";
	}

	bool isfirst = true;
	while(ifs && getline(ifs, tmp)){
		if(isfirst){
			value += tmp;
			isfirst = false;
		}else
			value += "\n" + tmp;
	}

	m_is_set = true;
	m_value += value;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x268, %rsp            # imm = 0x268
movq %rdi, %rbx
movq 0x48(%rdi), %rsi
leaq 0x60(%rsp), %rdi
movl $0x8, %edx
callq 0x65b0
leaq 0x30(%rsp), %rcx
movq %rcx, -0x10(%rcx)
xorl %eax, %eax
movq %rax, -0x8(%rcx)
movb %al, (%rcx)
leaq 0x10(%rsp), %rcx
movq %rcx, -0x10(%rcx)
movq %rax, -0x8(%rcx)
movb %al, (%rcx)
cmpb $0x1, 0x68(%rbx)
jne 0x84c6
leaq 0xc49b(%rip), %rcx      # 0x1494f
movq %rsp, %rdi
movl $0x1, %r8d
xorl %esi, %esi
xorl %edx, %edx
callq 0x64c0
movq 0x60(%rsp), %rax
movq -0x18(%rax), %rax
testb $0x5, 0x80(%rsp,%rax)
jne 0x8598
leaq (%rsp,%rax), %rdi
addq $0x60, %rdi
movb $0x1, %r13b
leaq 0x60(%rsp), %r14
leaq 0x20(%rsp), %r15
movq %rsp, %r12
leaq 0x40(%rsp), %rbp
movl $0xa, %esi
callq 0x6300
movsbl %al, %edx
movq %r14, %rdi
movq %r15, %rsi
callq 0x65c0
movq (%rax), %rcx
movq -0x18(%rcx), %rcx
testb $0x5, 0x20(%rax,%rcx)
jne 0x8598
testb $0x1, %r13b
je 0x853a
movq 0x20(%rsp), %rsi
movq 0x28(%rsp), %rdx
movq %r12, %rdi
callq 0x6100
jmp 0x857a
movq %rbp, %rdi
leaq 0xc40b(%rip), %rsi      # 0x1494f
movq %r15, %rdx
callq 0x73d2
movq 0x40(%rsp), %rsi
movq 0x48(%rsp), %rdx
movq %r12, %rdi
callq 0x6100
movq 0x40(%rsp), %rdi
leaq 0x50(%rsp), %rax
cmpq %rax, %rdi
je 0x857a
movq 0x50(%rsp), %rsi
incq %rsi
callq 0x6330
movq 0x60(%rsp), %rax
movq -0x18(%rax), %rax
leaq (%rsp,%rax), %rdi
addq $0x60, %rdi
xorl %r13d, %r13d
testb $0x5, 0x20(%rdi)
je 0x84fa
movb $0x1, 0x68(%rbx)
addq $0x28, %rbx
movq (%rsp), %rsi
movq 0x8(%rsp), %rdx
movq %rbx, %rdi
callq 0x6100
movq (%rsp), %rdi
leaq 0x10(%rsp), %rax
cmpq %rax, %rdi
je 0x85cc
movq 0x10(%rsp), %rsi
incq %rsi
callq 0x6330
movq 0x20(%rsp), %rdi
leaq 0x30(%rsp), %rax
cmpq %rax, %rdi
je 0x85e8
movq 0x30(%rsp), %rsi
incq %rsi
callq 0x6330
leaq 0x60(%rsp), %rdi
callq 0x60b0
addq $0x268, %rsp            # imm = 0x268
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
jmp 0x862b
jmp 0x862b
movq %rax, %rbx
movq 0x40(%rsp), %rdi
leaq 0x50(%rsp), %rax
cmpq %rax, %rdi
je 0x862e
movq 0x50(%rsp), %rsi
incq %rsi
callq 0x6330
jmp 0x862e
jmp 0x862b
movq %rax, %rbx
movq (%rsp), %rdi
leaq 0x10(%rsp), %rax
cmpq %rax, %rdi
je 0x8649
movq 0x10(%rsp), %rsi
incq %rsi
callq 0x6330
movq 0x20(%rsp), %rdi
leaq 0x30(%rsp), %rax
cmpq %rax, %rdi
je 0x8665
movq 0x30(%rsp), %rsi
incq %rsi
callq 0x6330
leaq 0x60(%rsp), %rdi
callq 0x60b0
movq %rbx, %rdi
callq 0x6580
nop
// File: /workspace/github_cpp_makefile_star2_O3/ryuichiueda[P]GlueLang/src/DefFile.cc
// Function: DefFile::connect()
void DefFile::connect(void)
{
	try{
		m_data->openFile();
	}catch(DataFile *e){
		m_error_msg = e->m_error_msg;	
		m_exit_status = 1;
		throw this;
	}

	if(m_env->m_v_opt)
		cerr << "+ pid " << getpid() << " file "
		<< m_data->m_value << " created" << endl;
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
movq 0x88(%rdi), %rdi
callq 0x81be
movq 0x10(%rbx), %rax
cmpb $0x1, 0xe0(%rax)
jne 0x8e0d
movq 0x13279(%rip), %r14     # 0x1bff0
leaq 0xb4f5(%rip), %rsi      # 0x14273
movl $0x6, %edx
movq %r14, %rdi
callq 0x63a0
callq 0x6480
movq %r14, %rdi
movl %eax, %esi
callq 0x6560
movq %rax, %r14
leaq 0xb4d6(%rip), %rsi      # 0x1427a
movl $0x6, %edx
movq %rax, %rdi
callq 0x63a0
movq 0x88(%rbx), %rax
movq 0x28(%rax), %rsi
movq 0x30(%rax), %rdx
movq %r14, %rdi
callq 0x63a0
movq %rax, %rbx
leaq 0xb46b(%rip), %rsi      # 0x1423d
movl $0x8, %edx
movq %rax, %rdi
callq 0x63a0
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
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x61e0
addq $0x8, %rsp
popq %rbx
popq %r14
retq
movq %rax, %r14
cmpl $0x1, %edx
jne 0x8e62
movq %r14, %rdi
callq 0x6130
leaq 0x8(%rax), %rsi
leaq 0x60(%rbx), %rdi
callq 0x61c0
movl $0x1, 0x80(%rbx)
movl $0x8, %edi
callq 0x6190
movq %rbx, (%rax)
leaq 0x12670(%rip), %rsi     # 0x1b4c0
movq %rax, %rdi
xorl %edx, %edx
callq 0x6550
movq %rax, %r14
callq 0x6500
movq %r14, %rdi
callq 0x6580
// File: /workspace/github_cpp_makefile_star2_O3/ryuichiueda[P]GlueLang/src/DefStr.cc
// Function: DefStr::readFifo()
bool DefStr::readFifo(void)
{
	try{
		m_data->readFifo();
	}catch(DataStr *e){
		m_error_msg = e->m_error_msg;
		m_exit_status = 3;
		throw this;
	}

	return true;
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
movq 0xa8(%rdi), %rdi
callq 0x8460
movb $0x1, %al
addq $0x8, %rsp
popq %rbx
popq %r14
retq
movq %rax, %r14
cmpl $0x1, %edx
jne 0x9b40
movq %r14, %rdi
callq 0x6130
leaq 0x8(%rax), %rsi
leaq 0x60(%rbx), %rdi
callq 0x61c0
movl $0x3, 0x80(%rbx)
movl $0x8, %edi
callq 0x6190
movq %rbx, (%rax)
leaq 0x11a72(%rip), %rsi     # 0x1b5a0
movq %rax, %rdi
xorl %edx, %edx
callq 0x6550
movq %rax, %r14
callq 0x6500
movq %r14, %rdi
callq 0x6580
// File: /workspace/github_cpp_makefile_star2_O3/ryuichiueda[P]GlueLang/src/Element.cc
// Function: Element::Element(Feeder*, Environment*, std::vector<int, std::allocator<int>>*)
Element::Element(Feeder *f, Environment *env, vector<int> *scopes)
{
	m_feeder = f;	
	m_env = env;

	m_start_line = m_start_char = -1000;
	m_end_line = m_end_char = -1000;
	m_exit_status = 0;
	m_command_error = false;

	if(scopes == NULL){
		m_job_id = 0;
		m_scopes.push_back(0);
	}else{
		m_scopes = *scopes;
	}
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rdi, %rbx
leaq 0x11a76(%rip), %rax     # 0x1b5d0
movq %rax, (%rdi)
xorps %xmm0, %xmm0
movups %xmm0, 0x18(%rdi)
xorl %eax, %eax
movq %rax, 0x28(%rdi)
leaq 0x48(%rdi), %r14
movups %xmm0, 0x48(%rdi)
movq %rax, 0x58(%rdi)
leaq 0x70(%rdi), %r12
movq %r12, 0x60(%rdi)
movq %rax, 0x68(%rdi)
movb %al, 0x70(%rdi)
movq %rsi, 0x8(%rdi)
movq %rdx, 0x10(%rdi)
movaps 0xa84c(%rip), %xmm0     # 0x143e0
movups %xmm0, 0x30(%rdi)
movl $0x0, 0x80(%rdi)
movb %al, 0x84(%rdi)
testq %rcx, %rcx
je 0x9bba
movq %r14, %rdi
movq %rcx, %rsi
callq 0xa12c
jmp 0x9bce
movl %eax, 0x40(%rbx)
leaq 0x4(%rsp), %rdx
movl %eax, (%rdx)
movq %r14, %rdi
xorl %esi, %esi
callq 0xa214
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
jmp 0x9bdc
movq %rax, %r15
movq 0x60(%rbx), %rdi
cmpq %r12, %rdi
je 0x9bf4
movq (%r12), %rsi
incq %rsi
callq 0x6330
leaq 0x18(%rbx), %r12
movq (%r14), %rdi
testq %rdi, %rdi
je 0x9c0c
movq 0x58(%rbx), %rsi
subq %rdi, %rsi
callq 0x6330
movq (%r12), %rdi
testq %rdi, %rdi
je 0x9c21
movq 0x28(%rbx), %rsi
subq %rdi, %rsi
callq 0x6330
movq %r15, %rdi
callq 0x6580
nop
// File: /workspace/github_cpp_makefile_star2_O3/ryuichiueda[P]GlueLang/src/Element.cc
// Function: Element::add(Element*)
bool Element::add(Element *n)
{
	if( n->parse() ){
		m_nodes.push_back(n);
		return true;
	}
	delete n;
	return false;
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
subq $0x10, %rsp
movq %rsi, %r15
movq %rdi, %r14
movq %rsi, 0x8(%rsp)
movq (%rsi), %rax
movq %rsi, %rdi
callq *0x20(%rax)
movl %eax, %ebx
testb %al, %al
je 0x9ccd
movq 0x20(%r14), %rsi
cmpq 0x28(%r14), %rsi
je 0x9cd8
movq %r15, (%rsi)
addq $0x8, 0x20(%r14)
jmp 0x9ce9
movq (%r15), %rax
movq %r15, %rdi
callq *0x8(%rax)
jmp 0x9ce9
addq $0x18, %r14
leaq 0x8(%rsp), %rdx
movq %r14, %rdi
callq 0xa350
movl %ebx, %eax
addq $0x10, %rsp
popq %rbx
popq %r14
popq %r15
retq
nop
// File: /workspace/github_cpp_makefile_star2_O3/ryuichiueda[P]GlueLang/src/Element.cc
// Function: Element::setJobId(int)
void Element::setJobId(int id)
{
	m_job_id = id;
	m_scopes.push_back(id);
	for(auto &n : m_nodes){
		n->m_job_id = id;
		n->setJobId(id);
	}
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movl %esi, %eax
movq %rdi, %rbx
movl %esi, 0x4(%rsp)
movl %esi, 0x40(%rdi)
movq 0x50(%rdi), %rsi
cmpq 0x58(%rdi), %rsi
je 0xa0f2
movl %eax, (%rsi)
addq $0x4, %rsi
movq %rsi, 0x50(%rbx)
jmp 0xa100
leaq 0x48(%rbx), %rdi
leaq 0x4(%rsp), %rdx
callq 0xa48c
movq 0x18(%rbx), %r14
movq 0x20(%rbx), %rbx
cmpq %rbx, %r14
je 0xa123
movl 0x4(%rsp), %esi
movq (%r14), %rdi
movl %esi, 0x40(%rdi)
movq (%rdi), %rax
callq *0x30(%rax)
addq $0x8, %r14
jmp 0xa108
addq $0x8, %rsp
popq %rbx
popq %r14
retq
nop
// File: /workspace/github_cpp_makefile_star2_O3/ryuichiueda[P]GlueLang/src/Environment.cc
// Function: Environment::initExecProc(char const**)
void Environment::initExecProc(char const* argv[])
{
	m_pid = getpid();
	//set args
	int c = 0;
	m_args.clear();
	while(argv[c] != NULL){
		m_args.push_back(argv[c]);
		c++;
	}
}

// Assembly:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x30, %rsp
movq %rsi, %rbx
movq %rdi, %r14
callq 0x6480
movl %eax, 0xe4(%r14)
movq (%r14), %rsi
movq %r14, %rdi
callq 0xc3a6
movq (%rbx), %rsi
testq %rsi, %rsi
je 0xa94a
leaq 0x20(%rsp), %r13
addq $0x8, %rbx
leaq 0x10(%rsp), %r15
leaq 0xf(%rsp), %r12
movq %r15, %rdi
movq %r12, %rdx
callq 0xbc72
movq %r14, %rdi
movq %r15, %rsi
callq 0xc136
movq 0x10(%rsp), %rdi
cmpq %r13, %rdi
je 0xa93e
movq 0x20(%rsp), %rsi
incq %rsi
callq 0x6330
movq (%rbx), %rsi
addq $0x8, %rbx
testq %rsi, %rsi
jne 0xa911
addq $0x30, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
movq %rax, %rbx
movq 0x10(%rsp), %rdi
cmpq %r13, %rdi
je 0xa972
movq 0x20(%rsp), %rsi
incq %rsi
callq 0x6330
movq %rbx, %rdi
callq 0x6580
// File: /workspace/github_cpp_makefile_star2_O3/ryuichiueda[P]GlueLang/src/Environment.cc
// Function: Environment::setImportPath(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>*, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>*)
string *Environment::getArg(long pos)
{
	if(pos < 0 || pos >= (long)m_args.size()){
		m_error_msg = "Array index out of range (pos: "+
		to_string(pos) + ")";
		throw this;
	}
	return &m_args[pos];
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x68, %rsp
leaq 0x38(%rsp), %r12
movq %r12, -0x10(%r12)
movq $0x0, -0x8(%r12)
movb $0x0, (%r12)
cmpq $0x0, 0x8(%rdx)
je 0xb0c1
movq %rdx, %r15
movq %rsi, %rbx
movq %rdi, %r14
movq (%rdx), %rax
cmpb $0x2f, (%rax)
jne 0xafbc
leaq 0x28(%rsp), %rdi
movq %r15, %rsi
callq 0x61c0
jmp 0xb07f
leaq 0x18(%rsp), %r13
movq %r13, -0x10(%r13)
movq 0x48(%r14), %rsi
movq 0x50(%r14), %rdx
addq %rsi, %rdx
leaq 0x8(%rsp), %rdi
callq 0x745a
leaq 0x964d(%rip), %rsi      # 0x1462e
leaq 0x8(%rsp), %rdi
callq 0x65d0
movq (%r15), %rsi
movq 0x8(%r15), %rdx
leaq 0x8(%rsp), %rdi
callq 0x6100
leaq 0x58(%rsp), %rbp
movq %rbp, -0x10(%rbp)
movq (%rax), %rdx
movq %rax, %rcx
addq $0x10, %rcx
cmpq %rcx, %rdx
je 0xb023
movq %rdx, 0x48(%rsp)
movq (%rcx), %rdx
movq %rdx, 0x58(%rsp)
jmp 0xb02a
movups (%rcx), %xmm0
movups %xmm0, (%rbp)
movq 0x8(%rax), %rdx
leaq 0x48(%rsp), %r15
movq %rdx, 0x8(%r15)
movq %rcx, (%rax)
movq $0x0, 0x8(%rax)
movb $0x0, 0x10(%rax)
leaq 0x28(%rsp), %rdi
movq %r15, %rsi
callq 0x63f0
movq (%r15), %rdi
cmpq %rbp, %rdi
je 0xb068
movq 0x58(%rsp), %rsi
incq %rsi
callq 0x6330
movq 0x8(%rsp), %rdi
cmpq %r13, %rdi
je 0xb07f
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x6330
addq $0x18, %r14
movq %r14, %rdi
movq %rbx, %rsi
callq 0xbd64
leaq 0x28(%rsp), %rsi
movq %rax, %rdi
callq 0xbde0
movq 0x28(%rsp), %rdi
cmpq %r12, %rdi
je 0xb0b2
movq 0x38(%rsp), %rsi
incq %rsi
callq 0x6330
addq $0x68, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
leaq 0x940d(%rip), %rdi      # 0x144d5
xorl %esi, %esi
xorl %edx, %edx
xorl %eax, %eax
callq 0x64a0
jmp 0xb0d5
movq %rax, %rbx
movq 0x8(%rsp), %rdi
cmpq %r13, %rdi
je 0xb0f6
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x6330
jmp 0xb0f6
jmp 0xb0f3
movq %rax, %rbx
movq 0x28(%rsp), %rdi
cmpq %r12, %rdi
je 0xb10d
movq 0x38(%rsp), %rsi
incq %rsi
callq 0x6330
movq %rbx, %rdi
callq 0x6580
nop
// File: /workspace/github_cpp_makefile_star2_O3/ryuichiueda[P]GlueLang/src/Environment.cc
// Function: Environment::getPATH[abi:cxx11]()
string Environment::getPATH(void)
{
	string ans = "PATH=";
	for(auto &path : m_import_paths[""]){
		ans += path + ":";
	}
	ans.pop_back();
	return ans;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x28, %rsp
movq %rsi, %r14
movq %rdi, %rbx
leaq 0x10(%rdi), %rax
movq %rax, 0x20(%rsp)
movq %rax, (%rdi)
leaq 0x92f6(%rip), %rsi      # 0x1446b
leaq 0x92f4(%rip), %rdx      # 0x14470
callq 0x74f0
leaq 0x10(%rsp), %r13
movq %r13, -0x10(%r13)
leaq 0x96cb(%rip), %rdx      # 0x1485c
movq %rsp, %rdi
movq %rdx, %rsi
callq 0x74f0
addq $0x18, %r14
movq %rsp, %rsi
movq %r14, %rdi
callq 0xbe1e
movq %rax, %r14
movq (%rsp), %rdi
cmpq %r13, %rdi
je 0xb1c4
movq 0x10(%rsp), %rsi
incq %rsi
callq 0x6330
movq (%r14), %rbp
movq 0x8(%r14), %r12
cmpq %r12, %rbp
je 0xb22c
movq %rsp, %r14
leaq 0x9297(%rip), %r15      # 0x14471
movq %r13, (%rsp)
movq (%rbp), %rsi
movq 0x8(%rbp), %rdx
addq %rsi, %rdx
movq %r14, %rdi
callq 0x745a
movq %r14, %rdi
movq %r15, %rsi
callq 0x65d0
movq (%rsp), %rsi
movq 0x8(%rsp), %rdx
movq %rbx, %rdi
callq 0x6100
movq (%rsp), %rdi
cmpq %r13, %rdi
je 0xb223
movq 0x10(%rsp), %rsi
incq %rsi
callq 0x6330
addq $0x20, %rbp
cmpq %r12, %rbp
jne 0xb1da
movq %rbx, %rdi
callq 0x63e0
movq %rbx, %rax
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
jmp 0xb251
jmp 0xb24a
movq %rax, %r14
jmp 0xb26a
jmp 0xb251
movq %rax, %r14
movq (%rsp), %rdi
cmpq %r13, %rdi
je 0xb26a
movq 0x10(%rsp), %rsi
incq %rsi
callq 0x6330
movq (%rbx), %rdi
cmpq 0x20(%rsp), %rdi
je 0xb284
movq 0x20(%rsp), %rax
movq (%rax), %rsi
incq %rsi
callq 0x6330
movq %r14, %rdi
callq 0x6580
// File: /workspace/github_cpp_makefile_star2_O3/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 0xb432
leaq 0x68(%rbx), %r15
movq %r15, %rdi
movq %r12, %rsi
callq 0xca72
leaq 0x70(%rbx), %rcx
cmpq %rcx, %rax
je 0xb31b
leaq 0x28(%rsp), %rsi
movq %r15, %rdi
callq 0xbe9a
movq (%rax), %rbx
leaq 0x38(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0xb30c
movq 0x38(%rsp), %rsi
incq %rsi
callq 0x6330
movq %rbx, %rax
addq $0x68, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
leaq 0x9151(%rip), %rsi      # 0x14473
leaq 0x8(%rsp), %rdi
movq %r14, %rdx
callq 0x73d2
leaq 0x9147(%rip), %rsi      # 0x1447d
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 0xb361
movups (%rcx), %xmm0
movups %xmm0, (%r15)
jmp 0xb36e
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 0xb3ae
movq 0x58(%rsp), %rsi
incq %rsi
callq 0x6330
leaq 0x18(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0xb3c9
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x6330
movl $0x8, %edi
callq 0x6190
movq %rbx, (%rax)
leaq 0xfea3(%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 0xb40e
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x6330
jmp 0xb40e
jmp 0xb40b
jmp 0xb40b
movq %rax, %rbx
leaq 0x38(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0xb429
movq 0x38(%rsp), %rsi
incq %rsi
callq 0x6330
movq %rbx, %rdi
callq 0x6580
nop
// File: /workspace/github_cpp_makefile_star2_O3/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 %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x48, %rsp
movq %rdx, %r14
movq %rsi, %r15
movq %rdi, %rbx
movq 0x8(%rsi), %r12
cmpq (%r15), %r12
je 0xb653
movl -0x4(%r12), %esi
addq $-0x4, %r12
movq %rbx, %rdi
movq %r14, %rdx
callq 0xb6e8
testb %al, %al
je 0xb61c
movl (%r12), %esi
movq %rbx, %rdi
movq %r14, %rdx
addq $0x48, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
jmp 0xb2a6
leaq 0x8e19(%rip), %rsi      # 0x14473
leaq 0x8(%rsp), %r15
movq %r15, %rdi
movq %r14, %rdx
callq 0x73d2
leaq 0x8e0c(%rip), %rdx      # 0x1447d
leaq 0x28(%rsp), %rdi
movq %r15, %rsi
callq 0x737f
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 0xfbc8(%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 0xb6e0
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x6330
movq %rbx, %rdi
callq 0x6580
// File: /workspace/github_cpp_makefile_star2_O3/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 0xb432
leaq 0x68(%rbx), %r12
movq %r12, %rdi
movq %r13, %rsi
callq 0xca72
leaq 0x70(%rbx), %rcx
cmpq %rcx, %rax
jne 0xbbd7
movq %rsp, %rsi
movq %r12, %rdi
callq 0xbe9a
movq %r14, (%rax)
leaq 0x10(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0xbbc9
movq 0x10(%rsp), %rsi
incq %rsi
callq 0x6330
addq $0x40, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
leaq 0x88e8(%rip), %rdx      # 0x144c6
leaq 0x20(%rsp), %rdi
movq %r15, %rsi
callq 0xbd0e
leaq 0xa0(%rbx), %rdi
leaq 0x20(%rsp), %r14
movq %r14, %rsi
callq 0x63f0
movq (%r14), %rdi
leaq 0x30(%rsp), %rax
cmpq %rax, %rdi
je 0xbc19
movq 0x30(%rsp), %rsi
incq %rsi
callq 0x6330
movl $0x8, %edi
callq 0x6190
movq %rbx, (%rax)
leaq 0xf653(%rip), %rsi      # 0x1b280
movq %rax, %rdi
xorl %edx, %edx
callq 0x6550
jmp 0xbc3b
jmp 0xbc3b
movq %rax, %rbx
leaq 0x10(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0xbc59
movq 0x10(%rsp), %rsi
incq %rsi
callq 0x6330
movq %rbx, %rdi
callq 0x6580
nop
// File: /workspace/github_cpp_makefile_star2_O3/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 0xfe78
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 0x9c96
movl %eax, %ebp
testb %al, %al
je 0xcecd
movq 0x8(%rbx), %rdi
callq 0xfde0
testb %al, %al
jne 0xceb9
movq 0x8(%rbx), %rdi
callq 0xf820
testb %al, %al
jne 0xceb9
movq 0x8(%rbx), %rdi
callq 0xf326
movq %rbx, %rdi
callq 0xe9b4
movq 0x8(%rbx), %rdi
leaq 0x38(%rbx), %rsi
addq $0x3c, %rbx
movq %rbx, %rdx
callq 0xfe78
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_O3/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 0xec74
movq %rax, %rbx
movq (%rax), %rsi
movq %r15, %rdi
callq 0xeee8
movl $0x10, %edi
callq 0x6030
movq %rax, %r14
movq 0x10(%r15), %rsi
leaq 0x8(%rsp), %r15
movq %r15, %rdi
callq 0xb14e
movq 0x8(%r15), %r15
incq %r15
movq %r15, %rdi
callq 0x6030
movq %rax, %r12
testq %r15, %r15
je 0xcf52
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 0xcf86
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 0xcfb0
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x6330
movq %rbx, %rdi
callq 0x6580
// File: /workspace/github_cpp_makefile_star2_O3/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 0xfe78
movl $0xc8, %edi
callq 0x6320
movq %rax, %r14
movq 0x8(%rbx), %rsi
movq 0x10(%rbx), %rdx
leaq 0x48(%rbx), %rcx
movq %rax, %rdi
callq 0x7588
movq %rbx, %rdi
movq %r14, %rsi
callq 0x9c96
movl %eax, %ebp
testb %al, %al
je 0xd970
movq 0x8(%rbx), %rdi
callq 0xfde0
testb %al, %al
jne 0xd939
movq 0x8(%rbx), %rdi
callq 0xf820
testb %al, %al
jne 0xd939
movq 0x8(%rbx), %rdi
callq 0xf326
movq %rbx, %rdi
callq 0xe9b4
movq 0x18(%rbx), %rax
movl $0x88, %edi
addq (%rax), %rdi
leaq 0x6c2c(%rip), %rsi      # 0x14578
callq 0x60f0
testl %eax, %eax
jne 0xd95c
movb $0x1, 0x85(%rbx)
movq 0x8(%rbx), %rdi
leaq 0x38(%rbx), %rsi
addq $0x3c, %rbx
movq %rbx, %rdx
callq 0xfe78
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_O3/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 0xfe78
movl $0xc8, %edi
callq 0x6320
movq %rax, %r14
movq 0x8(%rbx), %rsi
movq 0x10(%rbx), %rdx
leaq 0x48(%rbx), %rcx
movq %rax, %rdi
callq 0x773c
movq %rbx, %rdi
movq %r14, %rsi
callq 0x9c96
movl %eax, %ebp
testb %al, %al
je 0xda81
movq 0x8(%rbx), %rdi
callq 0xfde0
testb %al, %al
jne 0xda6d
movq 0x8(%rbx), %rdi
callq 0xf820
testb %al, %al
jne 0xda6d
movq 0x8(%rbx), %rdi
callq 0xf326
movq %rbx, %rdi
callq 0xe9b4
movq 0x8(%rbx), %rdi
leaq 0x38(%rbx), %rsi
addq $0x3c, %rbx
movq %rbx, %rdx
callq 0xfe78
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_O3/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 0xec74
movq %rax, %r12
movq (%rax), %rsi
movq %r15, %rdi
callq 0xeee8
movq (%r12), %rsi
leaq 0xd8(%rsp), %r13
movq %r13, %rdi
movl $0x8, %edx
callq 0x65b0
leaq 0x8(%rsp), %rdi
movq %r13, %rsi
callq 0xefcc
movq 0x10(%r15), %rdi
movq %r12, %rsi
callq 0xa8cc
movq 0x10(%r15), %rdx
leaq 0x50(%rsp), %rdi
leaq 0x8(%rsp), %rsi
xorl %ecx, %ecx
callq 0x12680
leaq 0x50(%rsp), %rdi
callq 0x126f4
leaq 0x50(%rsp), %rdi
movq %r14, %rsi
movq %rbx, %rdx
callq 0x12ba2
leaq 0x50(%rsp), %rdi
callq 0x1269c
leaq 0x8(%rsp), %rdi
callq 0xf0ae
leaq 0xd8(%rsp), %rdi
callq 0x60b0
addq $0x2e0, %rsp            # imm = 0x2E0
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
jmp 0xdb61
movq %rax, %rbx
jmp 0xdb78
movq %rax, %rbx
jmp 0xdb82
movq %rax, %rbx
leaq 0x50(%rsp), %rdi
callq 0x1269c
leaq 0x8(%rsp), %rdi
callq 0xf0ae
leaq 0xd8(%rsp), %rdi
callq 0x60b0
movq %rbx, %rdi
callq 0x6580
nop
// File: /workspace/github_cpp_makefile_star2_O3/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 0x745a
leaq 0x65cf(%rip), %rsi      # 0x1462e
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), %rsi
movq %rax, %rcx
addq $0x10, %rcx
cmpq %rcx, %rsi
je 0xe0a8
movq %rsi, (%rsp)
movq (%rcx), %rdx
movq %rdx, 0x10(%rsp)
jmp 0xe0b3
movups (%rcx), %xmm0
movups %xmm0, (%r13)
movq %r13, %rsi
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 0xe0ec
movq 0x100(%rsp), %rsi
incq %rsi
callq 0x6330
movq (%rsp), %rsi
movq %rsi, (%r12)
movq $0x0, 0x8(%r12)
movq %r15, %rdi
callq 0xeee8
movq (%r12), %rsi
leaq 0xf0(%rsp), %rdi
movl $0x8, %edx
callq 0x65b0
leaq 0x20(%rsp), %rdi
leaq 0xf0(%rsp), %rsi
callq 0xefcc
movq 0x10(%r15), %rdi
movq %r12, %rsi
callq 0xa8cc
movq 0x10(%r15), %rdx
leaq 0x68(%rsp), %rdi
leaq 0x20(%rsp), %rsi
xorl %ecx, %ecx
callq 0x12680
leaq 0x68(%rsp), %rdi
movb $0x1, 0x85(%rdi)
callq 0x126f4
leaq 0x68(%rsp), %rdi
movq %r14, %rsi
movq %rbx, %rdx
callq 0x12ba2
leaq 0x68(%rsp), %rdi
callq 0x1269c
leaq 0x20(%rsp), %rdi
callq 0xf0ae
leaq 0xf0(%rsp), %rdi
callq 0x60b0
movq (%rsp), %rdi
cmpq %r13, %rdi
je 0xe1a2
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 0xe1b6
movq %rax, %rbx
jmp 0xe1f0
movq %rax, %rbx
jmp 0xe1fa
jmp 0xe1c2
movq %rax, %rbx
jmp 0xe207
jmp 0xe1c9
movq %rax, %rbx
movq 0xf0(%rsp), %rdi
cmpq %rbp, %rdi
je 0xe21d
movq 0x100(%rsp), %rsi
jmp 0xe215
movq %rax, %rbx
leaq 0x68(%rsp), %rdi
callq 0x1269c
leaq 0x20(%rsp), %rdi
callq 0xf0ae
leaq 0xf0(%rsp), %rdi
callq 0x60b0
movq (%rsp), %rdi
cmpq %r13, %rdi
je 0xe21d
movq 0x10(%rsp), %rsi
incq %rsi
callq 0x6330
movq %rbx, %rdi
callq 0x6580
nopl (%rax)
// File: /workspace/github_cpp_makefile_star2_O3/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 0x9b48
leaq 0xcfe0(%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_O3/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 0x11c98
movq %rbx, %rdi
movq %r15, %rsi
callq 0x9c96
testb %al, %al
jne 0xea4d
movl $0xd0, %edi
callq 0x6320
movq %rax, %r15
movq 0x8(%rbx), %rsi
movq 0x10(%rbx), %rdx
movq %rax, %rdi
movq %r14, %rcx
callq 0x7c38
movq %rbx, %rdi
movq %r15, %rsi
callq 0x9c96
testb %al, %al
jne 0xea4d
movl $0xd0, %edi
callq 0x6320
movq %rax, %r15
movq 0x8(%rbx), %rsi
movq 0x10(%rbx), %rdx
movq %rax, %rdi
movq %r14, %rcx
callq 0x79ec
movq %rbx, %rdi
movq %r15, %rsi
callq 0x9c96
testb %al, %al
je 0xea75
movq 0x8(%rbx), %rdi
callq 0xfde0
testb %al, %al
jne 0xea75
movq 0x8(%rbx), %rdi
callq 0xf820
testb %al, %al
jne 0xea75
movq 0x8(%rbx), %rdi
callq 0xf326
jmp 0xe9c0
popq %rbx
popq %r14
popq %r15
retq
jmp 0xea7d
movq %rax, %rbx
movl $0xd0, %esi
jmp 0xea8f
movq %rax, %rbx
movl $0xc8, %esi
movq %r15, %rdi
callq 0x6330
movq %rbx, %rdi
callq 0x6580
nop
// File: /workspace/github_cpp_makefile_star2_O3/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 0xeab3
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_O3/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 0xeae4
movl 0x88(%rbx), %edi
callq 0x65e0
movl 0x90(%rbx), %edi
testl %edi, %edi
jle 0xeb00
xorl %esi, %esi
callq 0x62d0
movl 0x90(%rbx), %edi
callq 0x65e0
movl 0x8c(%rbx), %edi
cmpl $0x2, %edi
jl 0xeb21
movl $0x1, %esi
callq 0x62d0
movl 0x8c(%rbx), %edi
popq %rbx
jmp 0x65e0
popq %rbx
retq
nop
// File: /workspace/github_cpp_makefile_star2_O3/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 0xd450(%rip), %rdi      # 0x1bfc8
callq 0x61e0
movq (%rbx), %rax
movq %rbx, %rdi
callq *0x10(%rax)
callq 0x60c0
testl %eax, %eax
js 0xeba6
je 0xebb0
movl %eax, %ebp
movq %rbx, %rdi
callq 0xeaa0
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 0xec2a
movq 0xd42c(%rip), %r12      # 0x1bff0
leaq 0x56a8(%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 0x59da(%rip), %rsi      # 0x145cb
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 0xeacc
movq 0x8(%rbx), %rdi
callq 0xf18e
testq %r15, %r15
jne 0xec55
testq %r14, %r14
je 0xec5d
movq %r14, %rdi
callq 0x9aca
jmp 0xec5d
movq %r15, %rdi
callq 0x8d4c
movq (%rbx), %rax
movq %rbx, %rdi
movq %r15, %rsi
movq %r14, %rdx
callq *0x48(%rax)
movq %rbx, %rdi
callq 0xeb24
// File: /workspace/github_cpp_makefile_star2_O3/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, %rbp
movq 0x18(%rdi), %r15
movq 0x20(%rdi), %r12
movq %r12, %r13
subq %r15, %r13
movq %r13, %rax
sarq $0x3, %rax
movq 0xa0(%rdi), %rcx
movq 0x98(%rdi), %r14
movq %rcx, 0x10(%rsp)
subq %r14, %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 %rax, 0x8(%rsp)
movq %rcx, (%rax)
shrq $0x3, %r13
movl $0x1, %ebx
cmpl $0x2, %r13d
jl 0xed3b
movq 0x8(%rsp), %r13
movq (%r15,%rbx,8), %rdi
movq (%rdi), %rax
callq *0x40(%rax)
movq %rax, (%r13,%rbx,8)
incq %rbx
movq 0x18(%rbp), %r15
movq 0x20(%rbp), %r12
movq %r12, %rax
subq %r15, %rax
shrq $0x3, %rax
cltq
cmpq %rax, %rbx
jl 0xed00
movq 0x98(%rbp), %r14
movq 0xa0(%rbp), %rcx
jmp 0xed45
movq 0x8(%rsp), %r13
movq 0x10(%rsp), %rcx
cmpq %rcx, %r14
je 0xee1e
movq %rbp, 0x18(%rsp)
leaq 0x38(%rsp), %r15
leaq (,%rbx,8), %rax
addq %r13, %rax
movq %rax, 0x20(%rsp)
xorl %ebx, %ebx
movq %rcx, 0x10(%rsp)
movq %r15, 0x28(%rsp)
movq (%r14,%rbx,4), %rsi
movq %r14, %rbp
movq 0x8(%r14,%rbx,4), %rdx
addq %rsi, %rdx
leaq 0x28(%rsp), %rdi
callq 0x745a
movq %r15, %r14
movq 0x30(%rsp), %r15
leaq 0x1(%r15), %rdi
callq 0x6030
movq %rax, %r13
movq 0x20(%rsp), %rax
movq %r13, (%rax,%rbx)
movq 0x28(%rsp), %r12
movq %r13, %rdi
movq %r12, %rsi
callq 0x62e0
movb $0x0, (%r13,%r15)
cmpq %r14, %r12
movq %r14, %r15
je 0xedd8
movq 0x38(%rsp), %rsi
incq %rsi
movq %r12, %rdi
callq 0x6330
movq %rbp, %r14
leaq (,%rbx,4), %rax
addq %rbp, %rax
addq $0x8, %rbx
addq $0x20, %rax
movq 0x10(%rsp), %rcx
cmpq %rcx, %rax
jne 0xed6f
movq 0x18(%rsp), %rcx
movq 0x18(%rcx), %r15
movq 0x20(%rcx), %r12
movq 0xa0(%rcx), %rax
movq 0x98(%rcx), %rcx
movq 0x8(%rsp), %r13
jmp 0xee21
movq %rcx, %rax
subq %rcx, %rax
subq %r15, %r12
movq %r13, %rcx
addq %r12, %rcx
sarq $0x2, %rax
movq $0x0, (%rax,%rcx)
movq %r13, %rax
addq $0x48, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
movq 0x28(%rsp), %rdi
cmpq %r14, %rdi
je 0xee65
movq 0x38(%rsp), %rsi
incq %rsi
callq 0x6330
movq %rbx, %rdi
callq 0x6580
nop
// File: /workspace/github_cpp_makefile_star2_O3/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 0xef85
pushq %r15
pushq %r14
pushq %rbx
movq %rsi, %rbx
movq %rdi, %r14
movq 0xd0e5(%rip), %r15      # 0x1bff0
leaq 0x5361(%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 0x56b4(%rip), %rsi      # 0x145ec
movl $0xb, %edx
movq %rax, %rdi
callq 0x63a0
movl 0x30(%r14), %esi
movq %r15, %rdi
callq 0x6560
movq %rax, %r14
leaq 0x5934(%rip), %rsi      # 0x1488f
movl $0x1, %edx
movq %rax, %rdi
callq 0x63a0
testq %rbx, %rbx
je 0xef86
movq %rbx, %rdi
callq 0x6140
movq %r14, %rdi
movq %rbx, %rsi
movq %rax, %rdx
callq 0x63a0
jmp 0xefa0
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