LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_cpp_makefile_star2_O2/alfanick[P]rest-cpp/src/rest/server.cpp
// Function: REST::Server::run()
void Server::run() {
  int status;

  router()->print();

  status = listen(handle, SOMAXCONN);
  if (status == -1)
    throw ServerError();

  while (is_running) {
    Request::client client;
    socklen_t addr_size = sizeof(client.address);
    client.handle = accept(handle, (struct sockaddr *)&(client.address), &addr_size);

    try {
      if (client.handle == -1)
        throw ServerError();

      dispatcher->next(client);
    } catch (Exception &e) {
      if (is_running)
        std::cerr << "!!! " << e.what() << std::endl;
      close(client.handle);
    }
  }
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0xa8, %rsp
movq %rdi, %rbx
callq 0x30930
movq %rax, %rdi
callq 0x31540
movl 0x48(%rbx), %edi
movl $0x1000, %esi           # imm = 0x1000
callq 0x320e0
cmpl $-0x1, %eax
je 0x490ac
movq 0x13cba(%rip), %rbp     # 0x5cc70
movq 0x14023(%rip), %r12     # 0x5cfe0
leaq 0x20(%rsp), %r14
leaq 0x14(%rsp), %r15
leaq 0x4039(%rip), %r13      # 0x4d007
addq $0x10, %rbp
cmpb $0x1, 0x8(%rbx)
jne 0x4909a
movl $0x80, 0x14(%rsp)
movq %r14, %rsi
movq %r15, %rdx
movl 0x48(%rbx), %edi
callq 0x307b0
movl %eax, 0xa0(%rsp)
cmpl $-0x1, %eax
je 0x4900b
movq (%rbx), %rdi
movq %r14, %rsi
callq 0x336c0
jmp 0x48fd2
pushq $0x8
popq %rdi
callq 0x30c90
movq %rbp, (%rax)
movq 0x13c3b(%rip), %rsi     # 0x5cc58
movq 0x13f8c(%rip), %rdx     # 0x5cfb0
movq %rax, %rdi
callq 0x333b0
jmp 0x490d8
movq %rax, 0x8(%rsp)
cmpl $0x1, %edx
jne 0x490e2
movq 0x8(%rsp), %rdi
callq 0x30a60
cmpb $0x1, 0x8(%rbx)
movq %rax, 0x8(%rsp)
jne 0x49084
movq %r12, %rdi
movq %r13, %rsi
callq 0x31d30
movq %rax, 0x18(%rsp)
movq 0x8(%rsp), %rdi
movq (%rdi), %rax
callq *0x10(%rax)
movq 0x18(%rsp), %rdi
movq %rax, %rsi
callq 0x31d30
movq %rax, %rdi
callq 0x30c80
movl 0xa0(%rsp), %edi
callq 0x33a20
callq 0x33100
jmp 0x48fd2
addq $0xa8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
pushq $0x8
popq %rdi
callq 0x30c90
movq 0x13bb5(%rip), %rcx     # 0x5cc70
movq 0x13b96(%rip), %rsi     # 0x5cc58
movq 0x13ee7(%rip), %rdx     # 0x5cfb0
movq %rax, %rdi
addq $0x10, %rcx
movq %rcx, (%rax)
callq 0x333b0
movq %rax, 0x8(%rsp)
callq 0x33100
movq 0x8(%rsp), %rdi
callq 0x33510
movq %rax, %rdi
callq 0x34aa2
// File: /workspace/github_cpp_makefile_star2_O2/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, %r14
movq 0x10(%rdi), %rdi
leaq 0xc8(%r14), %rsi
callq 0x9af8
testq %rax, %rax
je 0x6fc8
movq (%rax), %r12
movq %rax, 0x10(%rsp)
movq 0x8(%rax), %rbx
leaq 0x88(%r14), %r15
movq %r14, 0x8(%rsp)
leaq 0xa8(%r14), %r13
leaq 0x18(%rsp), %rbp
leaq 0x38(%rsp), %r14
cmpq %rbx, %r12
je 0x6fe0
movq %rbp, %rdi
movq %r12, %rsi
callq 0x6420
movq %r14, %rdi
movq %rbp, %rsi
movq %r15, %rdx
callq 0x70ff
movq %r13, %rdi
movq %r14, %rsi
callq 0x63d0
movq %r14, %rdi
callq 0x6150
movq (%r13), %rdi
leaq 0x58(%rsp), %rsi
callq 0x62c0
testl %eax, %eax
je 0x6fa3
movq %rbp, %rdi
callq 0x6150
addq $0x20, %r12
jmp 0x6f4e
movq 0x8(%rsp), %rdx
movq 0x8(%rdx), %rdi
leaq 0x38(%rdx), %rsi
addq $0x3c, %rdx
callq 0xd614
leaq 0x18(%rsp), %rdi
callq 0x6150
movq 0x10(%rsp), %rax
testq %rax, %rax
setne %al
addq $0xe8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
leaq 0xa037(%rip), %rsi      # 0x1101e
leaq 0x38(%rsp), %rbx
movq %rbx, %rdi
movq %r15, %rdx
callq 0x7156
leaq 0xa029(%rip), %rdx      # 0x11027
leaq 0x18(%rsp), %rdi
movq %rbx, %rsi
callq 0x7137
movq 0x8(%rsp), %r14
leaq 0x60(%r14), %rdi
leaq 0x18(%rsp), %rbx
movq %rbx, %rsi
callq 0x63d0
movq %rbx, %rdi
callq 0x6150
leaq 0x38(%rsp), %rdi
callq 0x6150
movl $0x2, 0x80(%r14)
movq 0x8(%r14), %rdi
leaq 0x38(%r14), %rsi
leaq 0x3c(%r14), %rdx
callq 0xd614
pushq $0x8
popq %rdi
callq 0x6190
movq %r14, (%rax)
leaq 0x11fbf(%rip), %rsi     # 0x19020
movq %rax, %rdi
xorl %edx, %edx
callq 0x6540
jmp 0x7077
movq %rax, %rbx
leaq 0x38(%rsp), %rdi
jmp 0x707f
movq %rax, %rbx
leaq 0x18(%rsp), %rdi
callq 0x6150
movq %rbx, %rdi
callq 0x6560
// File: /workspace/github_cpp_makefile_star2_O2/ryuichiueda[P]GlueLang/src/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 %rbx
subq $0x68, %rsp
movq %rdi, %rbx
movq 0x8(%rdi), %rdi
leaq 0x30(%rbx), %rsi
leaq 0x34(%rbx), %rdx
callq 0xd614
movq 0x8(%rbx), %r14
leaq 0x9db2(%rip), %rsi      # 0x11073
leaq 0x28(%rsp), %rdi
leaq 0x8(%rsp), %rdx
callq 0x708c
leaq 0x28(%rsp), %rsi
movq %r14, %rdi
callq 0xd6ae
leaq 0x28(%rsp), %rdi
callq 0x6150
leaq 0x18(%rsp), %rax
movq %rax, -0x10(%rax)
andq $0x0, -0x8(%rax)
movb $0x0, (%rax)
movq 0x8(%rbx), %rdi
leaq 0xa8(%rbx), %r14
movq %r14, %rsi
callq 0xcf68
testb %al, %al
je 0x7377
leaq 0x9d5d(%rip), %rsi      # 0x11073
leaq 0x48(%rsp), %rdi
movq %r14, %rdx
callq 0x7156
leaq 0x88(%rbx), %rdi
leaq 0x48(%rsp), %r15
movq %r15, %rsi
callq 0x63d0
movq %r15, %rdi
callq 0x6150
leaq 0xa1f5(%rip), %rsi      # 0x1153b
movq %r14, %rdi
callq 0x73c5
testb %al, %al
je 0x735e
movq %r14, %rdi
callq 0xe1b8
testb %al, %al
je 0x7377
movq 0x8(%rbx), %rdi
leaq 0x38(%rbx), %rsi
addq $0x3c, %rbx
movb $0x1, %bpl
movq %rbx, %rdx
callq 0xd614
jmp 0x7388
movq 0x8(%rbx), %rdi
movl 0x30(%rbx), %esi
movl 0x34(%rbx), %edx
callq 0xd0a2
xorl %ebp, %ebp
leaq 0x8(%rsp), %rdi
callq 0x6150
movl %ebp, %eax
addq $0x68, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
jmp 0x73b0
movq %rax, %rbx
leaq 0x28(%rsp), %rdi
jmp 0x73b8
movq %rax, %rbx
jmp 0x73bd
movq %rax, %rbx
leaq 0x8(%rsp), %rdi
callq 0x6150
movq %rbx, %rdi
callq 0x6560
// File: /workspace/github_cpp_makefile_star2_O2/ryuichiueda[P]GlueLang/src/ArgProc.cc
// Function: ArgProc::parse()
bool ArgProc::parse(void)
{
	m_feeder->getPos(&m_start_line, &m_start_char);

	m_feeder->str("this.");

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

	m_text = "this." + m_evaled_text;
	m_evaled_text = m_env->m_tmpdir + "/" + m_evaled_text;
	m_feeder->getPos(&m_end_line, &m_end_char);
	return true;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
subq $0x88, %rsp
movq %rdi, %rbx
movq 0x8(%rdi), %rdi
leaq 0x30(%rbx), %rsi
leaq 0x34(%rbx), %rdx
callq 0xd614
movq 0x8(%rbx), %r14
leaq 0x9c46(%rip), %rsi      # 0x11082
leaq 0x68(%rsp), %rdi
leaq 0x48(%rsp), %rdx
callq 0x708c
leaq 0x68(%rsp), %rsi
movq %r14, %rdi
callq 0xd6ae
leaq 0x68(%rsp), %rdi
callq 0x6150
leaq 0x58(%rsp), %rax
movq %rax, -0x10(%rax)
andq $0x0, -0x8(%rax)
movb $0x0, (%rax)
movq 0x8(%rbx), %rdi
leaq 0xa8(%rbx), %r14
movq %r14, %rsi
callq 0xcf68
testb %al, %al
je 0x753b
movq 0x10(%rbx), %rdi
xorl %esi, %esi
movq %r14, %rdx
callq 0x9e6a
testb %al, %al
je 0x753b
leaq 0x9bd7(%rip), %rsi      # 0x11082
leaq 0x28(%rsp), %rdi
movq %r14, %rdx
callq 0x7156
leaq 0x88(%rbx), %rdi
leaq 0x28(%rsp), %r15
movq %r15, %rsi
callq 0x63d0
movq %r15, %rdi
callq 0x6150
movl $0xc0, %esi
addq 0x10(%rbx), %rsi
leaq 0xa10a(%rip), %rdx      # 0x115ee
leaq 0x8(%rsp), %rdi
callq 0x70c7
leaq 0x28(%rsp), %rdi
leaq 0x8(%rsp), %rsi
movq %r14, %rdx
callq 0x75a1
leaq 0x28(%rsp), %r15
movq %r14, %rdi
movq %r15, %rsi
callq 0x63d0
movq %r15, %rdi
callq 0x6150
leaq 0x8(%rsp), %rdi
callq 0x6150
movq 0x8(%rbx), %rdi
leaq 0x38(%rbx), %rsi
addq $0x3c, %rbx
movb $0x1, %bpl
movq %rbx, %rdx
callq 0xd614
jmp 0x754c
movq 0x8(%rbx), %rdi
movl 0x30(%rbx), %esi
movl 0x34(%rbx), %edx
callq 0xd0a2
xorl %ebp, %ebp
leaq 0x48(%rsp), %rdi
callq 0x6150
movl %ebp, %eax
addq $0x88, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
leaq 0x8(%rsp), %rdi
callq 0x6150
jmp 0x758b
jmp 0x7588
jmp 0x7588
movq %rax, %rbx
leaq 0x68(%rsp), %rdi
jmp 0x7590
movq %rax, %rbx
jmp 0x7595
movq %rax, %rbx
leaq 0x48(%rsp), %rdi
callq 0x6150
movq %rbx, %rdi
callq 0x6560
nop
// File: /workspace/github_cpp_makefile_star2_O2/ryuichiueda[P]GlueLang/src/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 %rbx
subq $0x68, %rsp
movq %rdi, %rbx
movq 0x8(%rdi), %rdi
leaq 0x30(%rbx), %rsi
leaq 0x34(%rbx), %rdx
callq 0xd614
movq 0x8(%rbx), %r14
leaq 0x9a6c(%rip), %rsi      # 0x11091
leaq 0x28(%rsp), %rdi
leaq 0x48(%rsp), %rdx
callq 0x708c
leaq 0x28(%rsp), %rsi
movq %r14, %rdi
callq 0xd6ae
movl %eax, %ebp
leaq 0x28(%rsp), %rdi
callq 0x6150
testb %bpl, %bpl
je 0x765b
movb $0x1, 0xc8(%rbx)
jmp 0x769a
movq 0x8(%rbx), %r14
leaq 0x9a1c(%rip), %rsi      # 0x11082
leaq 0x8(%rsp), %rdi
leaq 0x48(%rsp), %rdx
callq 0x708c
leaq 0x8(%rsp), %rsi
movq %r14, %rdi
callq 0xd6ae
movl %eax, %ebp
leaq 0x8(%rsp), %rdi
callq 0x6150
testb %bpl, %bpl
je 0x769a
movb $0x1, 0xc9(%rbx)
movq 0x8(%rbx), %rdi
leaq 0x88(%rbx), %r14
movq %r14, %rsi
callq 0xcf68
movl %eax, %ebp
testb %al, %al
je 0x76fa
cmpb $0x1, 0xc8(%rbx)
jne 0x76e6
leaq 0x99ce(%rip), %rsi      # 0x11091
leaq 0x48(%rsp), %r15
movq %r15, %rdi
movq %r14, %rdx
callq 0x7156
movq %r14, %rdi
movq %r15, %rsi
callq 0x63d0
movq %r15, %rdi
callq 0x6150
movq 0x8(%rbx), %rdi
leaq 0x38(%rbx), %rsi
addq $0x3c, %rbx
movq %rbx, %rdx
callq 0xd614
movl %ebp, %eax
addq $0x68, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
leaq 0x8(%rsp), %rdi
jmp 0x771b
jmp 0x7722
movq %rax, %rbx
leaq 0x28(%rsp), %rdi
callq 0x6150
jmp 0x7725
movq %rax, %rbx
movq %rbx, %rdi
callq 0x6560
nop
// File: /workspace/github_cpp_makefile_star2_O2/ryuichiueda[P]GlueLang/src/ArgVariable.cc
// Function: ArgVariable::eval()
bool ArgVariable::eval(void)
{
	try{
		Data *p;
		//if(m_is_local){
		//	p = m_env->m_local_env[m_job_id]->getData(&m_text);
		//}else{
			p = m_env->getData(&m_scopes,&m_text);
		//}
		m_evaled_text = p->m_value;
	}catch(...){
		m_error_msg = m_env->m_error_msg;
		m_exit_status = 3;
		throw this;
	}
	return true;
}

// Assembly:
pushq %rbx
movq %rdi, %rbx
movq 0x10(%rdi), %rdi
leaq 0x48(%rbx), %rsi
leaq 0x88(%rbx), %rdx
callq 0x9d98
addq $0x28, %rax
leaq 0xa8(%rbx), %rdi
movq %rax, %rsi
callq 0x61c0
movb $0x1, %al
popq %rbx
retq
movq %rax, %rdi
callq 0x6120
movl $0xa0, %esi
addq 0x10(%rbx), %rsi
leaq 0x60(%rbx), %rdi
callq 0x61c0
movl $0x3, 0x80(%rbx)
pushq $0x8
popq %rdi
callq 0x6190
movq %rbx, (%rax)
leaq 0x119fd(%rip), %rsi     # 0x19190
movq %rax, %rdi
xorl %edx, %edx
callq 0x6540
movq %rax, %rbx
callq 0x6500
movq %rbx, %rdi
callq 0x6560
movq %rax, %rdi
callq 0x77b5
// File: /workspace/github_cpp_makefile_star2_O2/ryuichiueda[P]GlueLang/src/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 0xd614
movq 0x8(%rbx), %rdi
leaq 0x88(%rbx), %rsi
leaq 0xc8(%rbx), %rdx
callq 0xce64
movl %eax, %ebp
testb %al, %al
je 0x783d
movq 0x8(%rbx), %rdi
leaq 0x38(%rbx), %rsi
addq $0x3c, %rbx
movq %rbx, %rdx
callq 0xd614
movl %ebp, %eax
popq %rbx
popq %r14
popq %rbp
retq
movq %rax, %r14
cmpl $0x1, %edx
jne 0x78a6
movq %r14, %rdi
callq 0x6120
movq %rax, %r14
movq 0x8(%rbx), %rdi
leaq 0x38(%rbx), %rsi
leaq 0x3c(%rbx), %rdx
callq 0xd614
addq $0x28, %r14
leaq 0x60(%rbx), %rdi
movq %r14, %rsi
callq 0x61c0
movl $0x3, 0x80(%rbx)
pushq $0x8
popq %rdi
callq 0x6190
movq %rbx, (%rax)
leaq 0x119bc(%rip), %rsi     # 0x19250
movq %rax, %rdi
xorl %edx, %edx
callq 0x6540
movq %rax, %r14
callq 0x6500
movq %r14, %rdi
callq 0x6560
// File: /workspace/github_cpp_makefile_star2_O2/ryuichiueda[P]GlueLang/src/ArrayVariable.cc
// Function: ArrayVariable::eval()
bool ArrayVariable::eval(void)
{
	if(m_text != "argv"){
		// treat as a literal until array can be declared in scripts.
		m_evaled_text = m_text + "[" + to_string(m_array_pos) + "]";
		return true;
	}

	try{
		m_evaled_text = *m_env->getArg(m_array_pos);
	}catch(Environment *e){
		m_error_msg = e->m_error_msg;
		m_exit_status = 3;
		throw this;
	}
	return true;
}

// Assembly:
pushq %r14
pushq %rbx
subq $0x88, %rsp
movq %rdi, %rbx
leaq 0x88(%rdi), %r14
leaq 0x981e(%rip), %rsi      # 0x110e7
movq %r14, %rdi
callq 0x73c5
testb %al, %al
je 0x7967
leaq 0x9d25(%rip), %rdx      # 0x11605
leaq 0x28(%rsp), %rdi
movq %r14, %rsi
callq 0x70c7
movq 0xc8(%rbx), %rsi
leaq 0x8(%rsp), %rdi
callq 0x7a7d
leaq 0x48(%rsp), %rdi
leaq 0x28(%rsp), %rsi
leaq 0x8(%rsp), %rdx
callq 0x7a16
leaq 0xa03a(%rip), %rdx      # 0x11953
leaq 0x68(%rsp), %rdi
leaq 0x48(%rsp), %rsi
callq 0x7137
addq $0xa8, %rbx
leaq 0x68(%rsp), %r14
movq %rbx, %rdi
movq %r14, %rsi
callq 0x63d0
movq %r14, %rdi
callq 0x6150
leaq 0x48(%rsp), %rdi
callq 0x6150
leaq 0x8(%rsp), %rdi
callq 0x6150
leaq 0x28(%rsp), %rdi
callq 0x6150
jmp 0x7986
movq 0x10(%rbx), %rdi
movq 0xc8(%rbx), %rsi
callq 0xa0a8
leaq 0xa8(%rbx), %rdi
movq %rax, %rsi
callq 0x61c0
movb $0x1, %al
addq $0x88, %rsp
popq %rbx
popq %r14
retq
movq %rax, %r14
leaq 0x48(%rsp), %rdi
callq 0x6150
jmp 0x79a5
movq %rax, %r14
leaq 0x8(%rsp), %rdi
callq 0x6150
jmp 0x79b4
movq %rax, %r14
leaq 0x28(%rsp), %rdi
callq 0x6150
jmp 0x7a0e
movq %rax, %r14
cmpl $0x1, %edx
jne 0x7a0e
movq %r14, %rdi
callq 0x6120
leaq 0xa0(%rax), %rsi
leaq 0x60(%rbx), %rdi
callq 0x61c0
movl $0x3, 0x80(%rbx)
pushq $0x8
popq %rdi
callq 0x6190
movq %rbx, (%rax)
leaq 0x11854(%rip), %rsi     # 0x19250
movq %rax, %rdi
xorl %edx, %edx
callq 0x6540
movq %rax, %r14
callq 0x6500
movq %r14, %rdi
callq 0x6560
// File: /workspace/github_cpp_makefile_star2_O2/ryuichiueda[P]GlueLang/src/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 0x6220
cmpl $0x2, %eax
jle 0x7c6c
movl %eax, %ebp
pushq $0x1
popq %rsi
movl %eax, %edi
callq 0x62e0
testl %eax, %eax
js 0x7c5f
movl %ebp, %edi
callq 0x65e0
testl %eax, %eax
js 0x7c5f
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
leaq 0x8(%rbx), %rdi
leaq 0x9589(%rip), %rsi      # 0x111f3
jmp 0x7c77
leaq 0x8(%rbx), %rdi
leaq 0x9568(%rip), %rsi      # 0x111df
callq 0x6400
pushq $0x8
popq %rdi
callq 0x6190
movq %rbx, (%rax)
leaq 0x1169a(%rip), %rsi     # 0x19328
movq %rax, %rdi
xorl %edx, %edx
callq 0x6540
// File: /workspace/github_cpp_makefile_star2_O2/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 %r14
pushq %rbx
movq %rdi, %rbx
movq 0x48(%rdi), %rdi
pushq $0x1
popq %r14
movl %r14d, %esi
movl $0x180, %edx            # imm = 0x180
xorl %eax, %eax
callq 0x6220
movl %eax, %ebp
movl %eax, %edi
movl %r14d, %esi
callq 0x62e0
testl %eax, %eax
js 0x7e54
movl %ebp, %edi
callq 0x65e0
testl %eax, %eax
js 0x7e54
popq %rbx
popq %r14
popq %rbp
retq
leaq 0x8(%rbx), %rdi
leaq 0x93e7(%rip), %rsi      # 0x11246
callq 0x6400
pushq $0x8
popq %rdi
callq 0x6190
movq %rbx, (%rax)
leaq 0x115aa(%rip), %rsi     # 0x19420
movq %rax, %rdi
xorl %edx, %edx
callq 0x6540
// File: /workspace/github_cpp_makefile_star2_O2/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
pushq $0x8
popq %rdx
callq 0x6590
leaq 0x30(%rsp), %rax
movq %rax, -0x10(%rax)
andq $0x0, -0x8(%rax)
xorl %ecx, %ecx
leaq 0x10(%rsp), %rdx
movq %rdx, -0x10(%rdx)
andq $0x0, -0x8(%rdx)
movb %cl, (%rax)
movb %cl, (%rdx)
cmpb $0x1, 0x68(%rbx)
jne 0x7edc
leaq 0x9a3b(%rip), %rsi      # 0x1190f
movq %rsp, %rdi
callq 0x65b0
movb $0x1, %r13b
leaq 0x60(%rsp), %r14
leaq 0x20(%rsp), %r15
movq %rsp, %r12
leaq 0x40(%rsp), %rbp
movq 0x60(%rsp), %rax
movq -0x18(%rax), %rax
testb $0x5, 0x80(%rsp,%rax)
jne 0x7f5d
movq %r14, %rdi
movq %r15, %rsi
callq 0x6090
movq (%rax), %rcx
movq -0x18(%rcx), %rcx
testb $0x5, 0x20(%rax,%rcx)
jne 0x7f5d
testb $0x1, %r13b
je 0x7f33
xorl %r13d, %r13d
movq %r12, %rdi
movq %r15, %rsi
callq 0x65d0
jmp 0x7ef1
movq %rbp, %rdi
leaq 0x99d2(%rip), %rsi      # 0x1190f
movq %r15, %rdx
callq 0x7156
movq %r12, %rdi
movq %rbp, %rsi
callq 0x65d0
movq %rbp, %rdi
callq 0x6150
xorl %r13d, %r13d
jmp 0x7ef1
movb $0x1, 0x68(%rbx)
addq $0x28, %rbx
movq %rsp, %rsi
movq %rbx, %rdi
callq 0x65d0
movq %rsp, %rdi
callq 0x6150
leaq 0x20(%rsp), %rdi
callq 0x6150
leaq 0x60(%rsp), %rdi
callq 0x60c0
addq $0x268, %rsp            # imm = 0x268
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
jmp 0x7fb3
jmp 0x7fb3
movq %rax, %rbx
leaq 0x40(%rsp), %rdi
callq 0x6150
jmp 0x7fb6
jmp 0x7fb3
movq %rax, %rbx
movq %rsp, %rdi
callq 0x6150
leaq 0x20(%rsp), %rdi
callq 0x6150
leaq 0x60(%rsp), %rdi
callq 0x60c0
movq %rbx, %rdi
callq 0x6560
// File: /workspace/github_cpp_makefile_star2_O2/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 0x7c18
movq 0x10(%rbx), %rax
cmpb $0x1, 0xe0(%rax)
jne 0x83e5
movq 0x11c61(%rip), %rdi     # 0x19fe8
leaq 0x8ee5(%rip), %rsi      # 0x11273
callq 0x6310
movq %rax, %r14
callq 0x6480
movq %r14, %rdi
movl %eax, %esi
callq 0x6550
leaq 0x8ece(%rip), %rsi      # 0x1127a
movq %rax, %rdi
callq 0x6310
movq 0x88(%rbx), %rsi
addq $0x28, %rsi
movq %rax, %rdi
callq 0x62b0
leaq 0x8e6f(%rip), %rsi      # 0x1123d
movq %rax, %rdi
callq 0x6310
movq %rax, %rdi
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x6180
addq $0x8, %rsp
popq %rbx
popq %r14
retq
movq %rax, %r14
cmpl $0x1, %edx
jne 0x8438
movq %r14, %rdi
callq 0x6120
leaq 0x8(%rax), %rsi
leaq 0x60(%rbx), %rdi
callq 0x61c0
movl $0x1, 0x80(%rbx)
pushq $0x8
popq %rdi
callq 0x6190
movq %rbx, (%rax)
leaq 0x1109a(%rip), %rsi     # 0x194c0
movq %rax, %rdi
xorl %edx, %edx
callq 0x6540
movq %rax, %r14
callq 0x6500
movq %r14, %rdi
callq 0x6560
// File: /workspace/github_cpp_makefile_star2_O2/ryuichiueda[P]GlueLang/src/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 0x7e80
movb $0x1, %al
addq $0x8, %rsp
popq %rbx
popq %r14
retq
movq %rax, %r14
cmpl $0x1, %edx
jne 0x8cb2
movq %r14, %rdi
callq 0x6120
leaq 0x8(%rax), %rsi
leaq 0x60(%rbx), %rdi
callq 0x61c0
movl $0x3, 0x80(%rbx)
pushq $0x8
popq %rdi
callq 0x6190
movq %rbx, (%rax)
leaq 0x10900(%rip), %rsi     # 0x195a0
movq %rax, %rdi
xorl %edx, %edx
callq 0x6540
movq %rax, %r14
callq 0x6500
movq %r14, %rdi
callq 0x6560
// File: /workspace/github_cpp_makefile_star2_O2/ryuichiueda[P]GlueLang/src/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 0x108c2(%rip), %rax     # 0x195d0
movq %rax, (%rdi)
xorps %xmm0, %xmm0
andq $0x0, 0x28(%rdi)
movups %xmm0, 0x18(%rdi)
andq $0x0, 0x58(%rdi)
movups %xmm0, 0x48(%rdi)
leaq 0x70(%rdi), %rax
movq %rax, 0x60(%rdi)
andq $0x0, 0x68(%rdi)
xorl %eax, %eax
movb %al, 0x70(%rdi)
movq %rsi, 0x8(%rdi)
movq %rdx, 0x10(%rdi)
movaps 0x8699(%rip), %xmm0     # 0x113e0
movups %xmm0, 0x30(%rdi)
andl $0x0, 0x80(%rdi)
leaq 0x48(%rdi), %r14
movb %al, 0x84(%rdi)
testq %rcx, %rcx
je 0x8d6e
movq %r14, %rdi
movq %rcx, %rsi
callq 0x8fb8
jmp 0x8d82
andl $0x0, 0x40(%rbx)
leaq 0x4(%rsp), %rsi
andl $0x0, (%rsi)
movq %r14, %rdi
callq 0x914e
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
jmp 0x8d90
movq %rax, %r15
leaq 0x18(%rbx), %r12
addq $0x60, %rbx
movq %rbx, %rdi
callq 0x6150
movq %r14, %rdi
callq 0x911a
movq %r12, %rdi
callq 0x90e6
movq %r15, %rdi
callq 0x6560
nop
// File: /workspace/github_cpp_makefile_star2_O2/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 0x8e38
addq $0x18, %r14
leaq 0x8(%rsp), %rsi
movq %r14, %rdi
callq 0x9082
jmp 0x8e41
movq (%r15), %rax
movq %r15, %rdi
callq *0x8(%rax)
movl %ebx, %eax
addq $0x10, %rsp
popq %rbx
popq %r14
popq %r15
retq
nop
// File: /workspace/github_cpp_makefile_star2_O2/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
movq %rdi, %rbx
leaq 0x4(%rsp), %rax
movl %esi, (%rax)
movl %esi, 0x40(%rdi)
addq $0x48, %rdi
movq %rax, %rsi
callq 0x90c4
movq 0x18(%rbx), %r14
movq 0x20(%rbx), %rbx
cmpq %rbx, %r14
je 0x8fb0
movl 0x4(%rsp), %esi
movq (%r14), %rdi
movl %esi, 0x40(%rdi)
movq (%rdi), %rax
callq *0x30(%rax)
addq $0x8, %r14
jmp 0x8f95
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_cpp_makefile_star2_O2/ryuichiueda[P]GlueLang/src/Environment.cc
// Function: Environment::Environment(int, char const**, int)
Environment::Environment(int argc, char const* argv[],int script_pos)
{
	// set cwd (this directory is never changed)
	char tmp[MAXPATHLEN];
	if (getcwd(tmp,sizeof(tmp)) == NULL){
		cerr << "Initizalization error" << endl;
		perror ("getcwd");
		exit(5);
	}

	m_dir = tmp;	
	m_pid = getpid();
	m_ppid = getppid();

	//set arguments 
	for(int i=script_pos;i<argc;i++)
		m_args.push_back(argv[i]);

	m_v_opt = false;
	m_level = 0;
	//m_job_counter = 0;
	//m_is_local = false;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x1038, %rsp           # imm = 0x1038
movq %rdi, %rbx
xorps %xmm0, %xmm0
movups %xmm0, (%rdi)
andq $0x0, 0x10(%rdi)
leaq 0x20(%rdi), %rax
andl $0x0, 0x20(%rdi)
andq $0x0, 0x28(%rdi)
movq %rax, 0x30(%rdi)
movq %rax, 0x38(%rdi)
andq $0x0, 0x40(%rdi)
movl %ecx, %ebp
leaq 0x58(%rdi), %rax
movq %rax, 0x48(%rdi)
andq $0x0, 0x50(%rdi)
xorl %eax, %eax
movb %al, 0x58(%rdi)
andl $0x0, 0x70(%rdi)
movq %rdx, %r15
andq $0x0, 0x78(%rdi)
movl %esi, %r12d
leaq 0x70(%rdi), %rcx
movq %rcx, 0x80(%rdi)
movq %rcx, 0x88(%rdi)
andq $0x0, 0x90(%rdi)
leaq 0xb0(%rdi), %rcx
movq %rcx, 0xa0(%rdi)
andq $0x0, 0xa8(%rdi)
leaq 0x48(%rdi), %r14
movb %al, 0xb0(%rdi)
leaq 0xd0(%rdi), %rcx
movq %rcx, 0xc0(%rdi)
andq $0x0, 0xc8(%rdi)
movb %al, 0xd0(%rdi)
leaq 0x30(%rsp), %rdi
movl $0x1000, %esi           # imm = 0x1000
callq 0x61a0
testq %rax, %rax
movq %r14, 0x8(%rsp)
je 0x9646
leaq 0x30(%rsp), %rsi
movq %r14, %rdi
callq 0x65b0
callq 0x6480
movl %eax, 0xe4(%rbx)
callq 0x6430
movl %eax, 0xe8(%rbx)
movslq %ebp, %rbp
movslq %r12d, %r14
leaq 0x10(%rsp), %r12
leaq 0x7(%rsp), %r13
cmpq %r14, %rbp
jge 0x9626
movq (%r15,%rbp,8), %rsi
movq %r12, %rdi
movq %r13, %rdx
callq 0x708c
movq %rbx, %rdi
movq %r12, %rsi
callq 0xa540
movq %r12, %rdi
callq 0x6150
incq %rbp
jmp 0x95fa
movb $0x0, 0xe0(%rbx)
andl $0x0, 0x9c(%rbx)
addq $0x1038, %rsp           # imm = 0x1038
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq 0x1099b(%rip), %rdi     # 0x19fe8
leaq 0x7dc7(%rip), %rsi      # 0x1141b
callq 0x6310
movq %rax, %rdi
callq 0x6180
leaq 0x7dc9(%rip), %rdi      # 0x11431
callq 0x6280
pushq $0x5
popq %rdi
callq 0x63a0
jmp 0x9686
movq %rax, %r15
leaq 0x10(%rsp), %rdi
callq 0x6150
jmp 0x9689
movq %rax, %r15
leaq 0xa0(%rbx), %r12
leaq 0xc0(%rbx), %rdi
leaq 0x68(%rbx), %r13
leaq 0x18(%rbx), %rbp
callq 0x6150
movq %r12, %rdi
callq 0x6150
movq %r13, %rdi
callq 0xa408
movq 0x8(%rsp), %rdi
callq 0x6150
movq %rbp, %rdi
callq 0xa46c
movq %rbx, %rdi
callq 0xa256
movq %r15, %rdi
callq 0x6560
// File: /workspace/github_cpp_makefile_star2_O2/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 %r12
pushq %rbx
subq $0x28, %rsp
movq %rsi, %rbx
movq %rdi, %r14
callq 0x6480
movl %eax, 0xe4(%r14)
movq %r14, %rdi
callq 0xa298
leaq 0x8(%rsp), %r15
leaq 0x7(%rsp), %r12
movq (%rbx), %rsi
testq %rsi, %rsi
je 0x97d5
movq %r15, %rdi
movq %r12, %rdx
callq 0x708c
movq %r14, %rdi
movq %r15, %rsi
callq 0xa540
movq %r15, %rdi
callq 0x6150
addq $0x8, %rbx
jmp 0x97a9
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
movq %rax, %rbx
leaq 0x8(%rsp), %rdi
callq 0x6150
movq %rbx, %rdi
callq 0x6560
// File: /workspace/github_cpp_makefile_star2_O2/ryuichiueda[P]GlueLang/src/Environment.cc
// Function: Environment::initTmpdir()
void Environment::initTmpdir(void)
{
	auto *p = getImportPaths("tmpdir");
	if(p == NULL || p->size() < 1){
		cerr << "unable to find tmpdir" << endl;
		throw this;
	}

	srand(time(NULL));

	m_tmpdir = p->at(0) + "glue" + to_string(m_pid) + "-" + to_string(rand());
	while(mkdir(m_tmpdir.c_str(),0700) != 0){
		cerr << "unable to create tmpdir" << endl;
		throw this;
	}
}

// Assembly:
pushq %r14
pushq %rbx
subq $0xc8, %rsp
movq %rdi, %rbx
leaq 0x7c3d(%rip), %rsi      # 0x11447
callq 0x99cc
testq %rax, %rax
je 0x9930
movq %rax, %r14
movq 0x8(%rax), %rax
cmpq (%r14), %rax
je 0x9930
xorl %edi, %edi
callq 0x62d0
movl %eax, %edi
callq 0x6300
movq %r14, %rdi
xorl %esi, %esi
callq 0x8cba
leaq 0x7c07(%rip), %rdx      # 0x1144e
leaq 0x48(%rsp), %rdi
movq %rax, %rsi
callq 0x70c7
movl 0xe4(%rbx), %esi
leaq 0x28(%rsp), %rdi
callq 0x8440
leaq 0x68(%rsp), %rdi
leaq 0x48(%rsp), %rsi
leaq 0x28(%rsp), %rdx
callq 0x7a16
leaq 0x79f2(%rip), %rdx      # 0x11271
leaq 0x88(%rsp), %rdi
leaq 0x68(%rsp), %rsi
callq 0x7137
callq 0x60e0
leaq 0x8(%rsp), %rdi
movl %eax, %esi
callq 0x8440
leaq 0xa8(%rsp), %rdi
leaq 0x88(%rsp), %rsi
leaq 0x8(%rsp), %rdx
callq 0x7a16
leaq 0xc0(%rbx), %rdi
leaq 0xa8(%rsp), %r14
movq %r14, %rsi
callq 0x63d0
movq %r14, %rdi
callq 0x6150
leaq 0x8(%rsp), %rdi
callq 0x6150
leaq 0x88(%rsp), %rdi
callq 0x6150
leaq 0x68(%rsp), %rdi
callq 0x6150
leaq 0x28(%rsp), %rdi
callq 0x6150
leaq 0x48(%rsp), %rdi
callq 0x6150
movq 0xc0(%rbx), %rdi
movl $0x1c0, %esi            # imm = 0x1C0
callq 0x6160
testl %eax, %eax
jne 0x9940
addq $0xc8, %rsp
popq %rbx
popq %r14
retq
movq 0x106b1(%rip), %rdi     # 0x19fe8
leaq 0x7afa(%rip), %rsi      # 0x11438
jmp 0x994e
movq 0x106a1(%rip), %rdi     # 0x19fe8
leaq 0x7b05(%rip), %rsi      # 0x11453
callq 0x6310
movq %rax, %rdi
callq 0x6180
pushq $0x8
popq %rdi
callq 0x6190
movq %rbx, (%rax)
leaq 0xf913(%rip), %rsi      # 0x19280
movq %rax, %rdi
xorl %edx, %edx
callq 0x6540
movq %rax, %rbx
leaq 0x8(%rsp), %rdi
callq 0x6150
jmp 0x9989
movq %rax, %rbx
leaq 0x88(%rsp), %rdi
callq 0x6150
jmp 0x999b
movq %rax, %rbx
leaq 0x68(%rsp), %rdi
callq 0x6150
jmp 0x99aa
movq %rax, %rbx
leaq 0x28(%rsp), %rdi
callq 0x6150
jmp 0x99b9
movq %rax, %rbx
leaq 0x48(%rsp), %rdi
callq 0x6150
movq %rbx, %rdi
callq 0x6560
nop
// File: /workspace/github_cpp_makefile_star2_O2/ryuichiueda[P]GlueLang/src/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>>*)
void Environment::setImportPath(string *key, string *value)
{
	string path;
	if(value->at(0) == '/'){
		path = *value;
	}else{
		path = m_dir + "/" + *value; //resolve relative path (too lazy)
	}
	m_import_paths[*key].push_back(path);
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
subq $0x60, %rsp
movq %rdx, %r15
movq %rsi, %rbx
movq %rdi, %r14
leaq 0x10(%rsp), %rax
movq %rax, -0x10(%rax)
andq $0x0, -0x8(%rax)
movb $0x0, (%rax)
movq %rdx, %rdi
xorl %esi, %esi
callq 0x65c0
cmpb $0x2f, (%rax)
jne 0x9a5f
movq %rsp, %rdi
movq %r15, %rsi
callq 0x61c0
jmp 0x9aa8
leaq 0x48(%r14), %rsi
leaq 0x7b84(%rip), %rdx      # 0x115ee
leaq 0x20(%rsp), %rdi
callq 0x70c7
leaq 0x40(%rsp), %rdi
leaq 0x20(%rsp), %rsi
movq %r15, %rdx
callq 0x75a1
movq %rsp, %rdi
leaq 0x40(%rsp), %r15
movq %r15, %rsi
callq 0x63d0
movq %r15, %rdi
callq 0x6150
leaq 0x20(%rsp), %rdi
callq 0x6150
addq $0x18, %r14
movq %r14, %rdi
movq %rbx, %rsi
callq 0xa2a0
movq %rsp, %rsi
movq %rax, %rdi
callq 0xa306
movq %rsp, %rdi
callq 0x6150
addq $0x60, %rsp
popq %rbx
popq %r14
popq %r15
retq
movq %rax, %rbx
leaq 0x20(%rsp), %rdi
callq 0x6150
jmp 0x9ae8
jmp 0x9ae5
movq %rax, %rbx
movq %rsp, %rdi
callq 0x6150
movq %rbx, %rdi
callq 0x6560
// File: /workspace/github_cpp_makefile_star2_O2/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 %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x30, %rsp
movq %rsi, %r14
movq %rdi, %rbx
leaq 0x7921(%rip), %rsi      # 0x1146b
leaq 0x10(%rsp), %rdx
callq 0x708c
leaq 0x7cc1(%rip), %rsi      # 0x1181c
leaq 0x10(%rsp), %rdi
leaq 0xf(%rsp), %rdx
callq 0x708c
addq $0x18, %r14
leaq 0x10(%rsp), %rsi
movq %r14, %rdi
callq 0xa332
movq %rax, %r12
leaq 0x10(%rsp), %r14
movq %r14, %rdi
callq 0x6150
movq (%r12), %r15
movq 0x8(%r12), %r13
leaq 0x78d6(%rip), %r12      # 0x11471
cmpq %r13, %r15
je 0x9bc7
movq %r14, %rdi
movq %r15, %rsi
movq %r12, %rdx
callq 0x70c7
movq %rbx, %rdi
movq %r14, %rsi
callq 0x65d0
movq %r14, %rdi
callq 0x6150
addq $0x20, %r15
jmp 0x9b9b
movq %rbx, %rdi
callq 0x63c0
movq %rbx, %rax
addq $0x30, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
jmp 0x9be9
jmp 0x9be4
movq %rax, %r14
jmp 0x9bf6
movq %rax, %r14
leaq 0x10(%rsp), %rdi
callq 0x6150
movq %rbx, %rdi
callq 0x6150
movq %r14, %rdi
callq 0x6560
// File: /workspace/github_cpp_makefile_star2_O2/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 0x9d18
leaq 0x68(%rbx), %r15
movq %r15, %rdi
movq %r12, %rsi
callq 0xad8c
leaq 0x70(%rbx), %rcx
cmpq %rcx, %rax
je 0x9c84
leaq 0x28(%rsp), %rsi
movq %r15, %rdi
callq 0xa398
movq (%rax), %rbx
leaq 0x28(%rsp), %rdi
callq 0x6150
movq %rbx, %rax
addq $0x68, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
leaq 0x77e8(%rip), %rsi      # 0x11473
leaq 0x8(%rsp), %rdi
movq %r14, %rdx
callq 0x7156
leaq 0x77de(%rip), %rdx      # 0x1147d
leaq 0x48(%rsp), %rdi
leaq 0x8(%rsp), %rsi
callq 0x7137
leaq 0xa0(%rbx), %rdi
leaq 0x48(%rsp), %r14
movq %r14, %rsi
callq 0x63d0
movq %r14, %rdi
callq 0x6150
leaq 0x8(%rsp), %rdi
callq 0x6150
pushq $0x8
popq %rdi
callq 0x6190
movq %rbx, (%rax)
leaq 0xf59a(%rip), %rsi      # 0x19280
movq %rax, %rdi
xorl %edx, %edx
callq 0x6540
movq %rax, %rbx
leaq 0x8(%rsp), %rdi
callq 0x6150
jmp 0x9d06
jmp 0x9d03
jmp 0x9d03
movq %rax, %rbx
leaq 0x28(%rsp), %rdi
callq 0x6150
movq %rbx, %rdi
callq 0x6560
// File: /workspace/github_cpp_makefile_star2_O2/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 0x9de7
movl -0x4(%r12), %esi
addq $-0x4, %r12
movq %rbx, %rdi
movq %r14, %rdx
callq 0x9e6a
testb %al, %al
je 0x9db0
movl (%r12), %esi
movq %rbx, %rdi
movq %r14, %rdx
addq $0x48, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
jmp 0x9c20
leaq 0x7685(%rip), %rsi      # 0x11473
leaq 0x8(%rsp), %r15
movq %r15, %rdi
movq %r14, %rdx
callq 0x7156
leaq 0x7678(%rip), %rdx      # 0x1147d
leaq 0x28(%rsp), %rdi
movq %r15, %rsi
callq 0x7137
leaq 0xa0(%rbx), %rdi
leaq 0x28(%rsp), %r14
movq %r14, %rsi
callq 0x63d0
movq %r14, %rdi
callq 0x6150
leaq 0x8(%rsp), %rdi
callq 0x6150
pushq $0x8
popq %rdi
callq 0x6190
movq %rbx, (%rax)
leaq 0xf436(%rip), %rsi      # 0x19280
movq %rax, %rdi
xorl %edx, %edx
callq 0x6540
movq %rax, %rbx
leaq 0x8(%rsp), %rdi
callq 0x6150
movq %rbx, %rdi
callq 0x6560
nop
// File: /workspace/github_cpp_makefile_star2_O2/ryuichiueda[P]GlueLang/src/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 0xa0d9
movq (%rbx), %rax
movq 0x8(%rbx), %rcx
subq %rax, %rcx
sarq $0x5, %rcx
cmpq %rsi, %rcx
jle 0xa0d9
shlq $0x5, %rsi
addq %rsi, %rax
addq $0x68, %rsp
popq %rbx
popq %r14
retq
leaq 0x28(%rsp), %r14
movq %r14, %rdi
callq 0x7a7d
leaq 0x73b9(%rip), %rsi      # 0x114a6
leaq 0x8(%rsp), %rdi
movq %r14, %rdx
callq 0x909f
leaq 0x75bd(%rip), %rdx      # 0x116be
leaq 0x48(%rsp), %rdi
leaq 0x8(%rsp), %rsi
callq 0x7137
leaq 0xa0(%rbx), %rdi
leaq 0x48(%rsp), %r14
movq %r14, %rsi
callq 0x63d0
movq %r14, %rdi
callq 0x6150
leaq 0x8(%rsp), %rdi
callq 0x6150
leaq 0x28(%rsp), %rdi
callq 0x6150
pushq $0x8
popq %rdi
callq 0x6190
movq %rbx, (%rax)
leaq 0xf12e(%rip), %rsi      # 0x19280
movq %rax, %rdi
xorl %edx, %edx
callq 0x6540
movq %rax, %rbx
leaq 0x8(%rsp), %rdi
callq 0x6150
jmp 0xa16e
movq %rax, %rbx
leaq 0x28(%rsp), %rdi
callq 0x6150
movq %rbx, %rdi
callq 0x6560
// File: /workspace/github_cpp_makefile_star2_O2/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 0x9d18
leaq 0x68(%rbx), %r12
movq %r12, %rdi
movq %r13, %rsi
callq 0xad8c
leaq 0x70(%rbx), %rcx
cmpq %rcx, %rax
jne 0xa1e2
movq %rsp, %rsi
movq %r12, %rdi
callq 0xa398
movq %r14, (%rax)
movq %rsp, %rdi
callq 0x6150
addq $0x40, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
leaq 0x72dd(%rip), %rdx      # 0x114c6
leaq 0x20(%rsp), %rdi
movq %r15, %rsi
callq 0x70c7
leaq 0xa0(%rbx), %rdi
leaq 0x20(%rsp), %r14
movq %r14, %rsi
callq 0x63d0
movq %r14, %rdi
callq 0x6150
pushq $0x8
popq %rdi
callq 0x6190
movq %rbx, (%rax)
leaq 0xf05c(%rip), %rsi      # 0x19280
movq %rax, %rdi
xorl %edx, %edx
callq 0x6540
jmp 0xa232
jmp 0xa232
movq %rax, %rbx
movq %rsp, %rdi
callq 0x6150
movq %rbx, %rdi
callq 0x6560
nop
// File: /workspace/github_cpp_makefile_star2_O2/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 0xd614
movl $0xe8, %edi
callq 0x6320
movq %rax, %r14
movq 0x8(%rbx), %rsi
movq 0x10(%rbx), %rdx
leaq 0x48(%rbx), %rcx
movq %rax, %rdi
callq 0x6bf8
movq %rbx, %rdi
movq %r14, %rsi
callq 0x8e02
movl %eax, %ebp
testb %al, %al
je 0xb259
movq 0x8(%rbx), %rdi
callq 0xd574
testb %al, %al
jne 0xb245
movq 0x8(%rbx), %rdi
callq 0xd09a
testb %al, %al
jne 0xb245
movq 0x8(%rbx), %rdi
callq 0xcc02
movq %rbx, %rdi
callq 0xc484
movq 0x8(%rbx), %rdi
leaq 0x38(%rbx), %rsi
addq $0x3c, %rbx
movq %rbx, %rdx
callq 0xd614
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 0x6560
// File: /workspace/github_cpp_makefile_star2_O2/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 0xc712
movq %rax, %rbx
movq (%rax), %rsi
movq %r15, %rdi
callq 0xc8da
pushq $0x10
popq %rdi
callq 0x6030
movq %rax, %r14
movq 0x10(%r15), %rsi
leaq 0x8(%rsp), %r15
movq %r15, %rdi
callq 0x9b30
movq 0x8(%r15), %r15
incq %r15
movq %r15, %rdi
callq 0x6030
movq %rax, %r12
testq %r15, %r15
je 0xb2dc
movq 0x8(%rsp), %rsi
movq %r12, %rdi
movq %r15, %rdx
callq 0x6270
movq %r12, (%r14)
andq $0x0, 0x8(%r14)
movq (%rbx), %rdi
movq %rbx, %rsi
movq %r14, %rdx
callq 0x6530
leaq 0x8(%rsp), %rdi
callq 0x6150
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
movq %rax, %rbx
leaq 0x8(%rsp), %rdi
callq 0x6150
movq %rbx, %rdi
callq 0x6560
nop
// File: /workspace/github_cpp_makefile_star2_O2/ryuichiueda[P]GlueLang/src/ExecForEach.cc
// Function: ExecForEach::parse()
bool ExecForEach::parse(void)
{
	m_feeder->getPos(&m_start_line, &m_start_char);

	string scr;
	bool scr_exist = m_feeder->forEachBlock(&scr);
	if(!scr_exist){
		m_feeder->setPos(m_start_line, m_start_char);
		return false;
	}

	m_name = "unnamed" + to_string(m_start_line);

	//create a file
	string tmpdir = m_env->m_tmpdir + "/" + m_name;
	ofstream ofs(tmpdir.c_str());
	ofs << scr;

	auto *p = new DataProc();
	p->setFileName(&tmpdir);
	m_env->setData(m_scopes.back(),&m_name,p);
	return true;
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x248, %rsp            # imm = 0x248
movq %rdi, %r14
movq 0x8(%rdi), %rdi
leaq 0x30(%r14), %r15
leaq 0x34(%r14), %rdx
movq %r15, %rsi
callq 0xd614
leaq 0x38(%rsp), %rax
movq %rax, -0x10(%rax)
andq $0x0, -0x8(%rax)
movb $0x0, (%rax)
movq 0x8(%r14), %rdi
leaq 0x28(%rsp), %rsi
callq 0xdd0e
movl %eax, %ebx
testb %al, %al
je 0xb50d
movl (%r15), %esi
leaq 0x8(%rsp), %rdi
callq 0x8440
leaq 0x60ce(%rip), %rsi      # 0x11500
leaq 0x48(%rsp), %rdi
leaq 0x8(%rsp), %rdx
callq 0x909f
leaq 0xb0(%r14), %r15
leaq 0x48(%rsp), %r12
movq %r15, %rdi
movq %r12, %rsi
callq 0x63d0
movq %r12, %rdi
callq 0x6150
leaq 0x8(%rsp), %rdi
callq 0x6150
movl $0xc0, %esi
addq 0x10(%r14), %rsi
leaq 0x6174(%rip), %rdx      # 0x115ee
leaq 0x48(%rsp), %rdi
callq 0x70c7
leaq 0x8(%rsp), %rdi
leaq 0x48(%rsp), %rsi
movq %r15, %rdx
callq 0x75a1
leaq 0x48(%rsp), %rdi
callq 0x6150
movq 0x8(%rsp), %rsi
leaq 0x48(%rsp), %rdi
pushq $0x10
popq %rdx
callq 0x6360
leaq 0x48(%rsp), %rdi
leaq 0x28(%rsp), %rsi
callq 0x62b0
pushq $0x68
popq %rdi
callq 0x6320
movq %rax, %r12
movq %rax, %rdi
callq 0x7cdc
leaq 0x8(%rsp), %rsi
movq %r12, %rdi
callq 0x7d3e
movq 0x10(%r14), %rdi
movq 0x50(%r14), %rax
movl -0x4(%rax), %esi
movq %r15, %rdx
movq %r12, %rcx
callq 0xa180
leaq 0x48(%rsp), %rdi
callq 0x6490
leaq 0x8(%rsp), %rdi
callq 0x6150
jmp 0xb51e
movq 0x8(%r14), %rdi
movl 0x30(%r14), %esi
movl 0x34(%r14), %edx
callq 0xd0a2
leaq 0x28(%rsp), %rdi
callq 0x6150
movl %ebx, %eax
addq $0x248, %rsp            # imm = 0x248
popq %rbx
popq %r12
popq %r14
popq %r15
retq
movq %rax, %rbx
pushq $0x68
popq %rsi
movq %r12, %rdi
callq 0x6330
jmp 0xb563
jmp 0xb560
jmp 0xb559
movq %rax, %rbx
leaq 0x48(%rsp), %rdi
jmp 0xb572
jmp 0xb579
movq %rax, %rbx
jmp 0xb56d
jmp 0xb579
movq %rax, %rbx
leaq 0x48(%rsp), %rdi
callq 0x6490
leaq 0x8(%rsp), %rdi
callq 0x6150
jmp 0xb57c
movq %rax, %rbx
leaq 0x28(%rsp), %rdi
callq 0x6150
movq %rbx, %rdi
callq 0x6560
// File: /workspace/github_cpp_makefile_star2_O2/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 0xd614
movl $0xc8, %edi
callq 0x6320
movq %rax, %r14
movq 0x8(%rbx), %rsi
movq 0x10(%rbx), %rdx
leaq 0x48(%rbx), %rcx
movq %rax, %rdi
callq 0x7264
movq %rbx, %rdi
movq %r14, %rsi
callq 0x8e02
movl %eax, %ebp
testb %al, %al
je 0xb9cc
movq 0x8(%rbx), %rdi
callq 0xd574
testb %al, %al
jne 0xb995
movq 0x8(%rbx), %rdi
callq 0xd09a
testb %al, %al
jne 0xb995
movq 0x8(%rbx), %rdi
callq 0xcc02
movq %rbx, %rdi
callq 0xc484
movq 0x18(%rbx), %rax
movl $0x88, %edi
addq (%rax), %rdi
leaq 0x5b90(%rip), %rsi      # 0x11538
callq 0x73cf
testb %al, %al
je 0xb9b8
movb $0x1, 0x85(%rbx)
movq 0x8(%rbx), %rdi
leaq 0x38(%rbx), %rsi
addq $0x3c, %rbx
movq %rbx, %rdx
callq 0xd614
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 0x6560
nop
// File: /workspace/github_cpp_makefile_star2_O2/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 0xd614
movl $0xc8, %edi
callq 0x6320
movq %rax, %r14
movq 0x8(%rbx), %rsi
movq 0x10(%rbx), %rdx
leaq 0x48(%rbx), %rcx
movq %rax, %rdi
callq 0x73dc
movq %rbx, %rdi
movq %r14, %rsi
callq 0x8e02
movl %eax, %ebp
testb %al, %al
je 0xbadd
movq 0x8(%rbx), %rdi
callq 0xd574
testb %al, %al
jne 0xbac9
movq 0x8(%rbx), %rdi
callq 0xd09a
testb %al, %al
jne 0xbac9
movq 0x8(%rbx), %rdi
callq 0xcc02
movq %rbx, %rdi
callq 0xc484
movq 0x8(%rbx), %rdi
leaq 0x38(%rbx), %rsi
addq $0x3c, %rbx
movq %rbx, %rdx
callq 0xd614
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 0x6560
// File: /workspace/github_cpp_makefile_star2_O2/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 0xc712
movq %rax, %r12
movq (%rax), %rsi
movq %r15, %rdi
callq 0xc8da
movq (%r12), %rsi
leaq 0xd8(%rsp), %r13
pushq $0x8
popq %rdx
movq %r13, %rdi
callq 0x6590
leaq 0x8(%rsp), %rdi
movq %r13, %rsi
callq 0xc95c
movq 0x10(%r15), %rdi
movq %r12, %rsi
callq 0x977a
movq 0x10(%r15), %rdx
leaq 0x50(%rsp), %rdi
leaq 0x8(%rsp), %rsi
xorl %ecx, %ecx
callq 0xf490
leaq 0x50(%rsp), %rdi
callq 0xf504
leaq 0x50(%rsp), %rdi
movq %r14, %rsi
movq %rbx, %rdx
callq 0xf8b8
leaq 0x50(%rsp), %rdi
callq 0xf4ac
leaq 0x8(%rsp), %rdi
callq 0xca02
leaq 0xd8(%rsp), %rdi
callq 0x60c0
addq $0x2e0, %rsp            # imm = 0x2E0
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
jmp 0xbbbb
movq %rax, %rbx
jmp 0xbbd2
movq %rax, %rbx
jmp 0xbbdc
movq %rax, %rbx
leaq 0x50(%rsp), %rdi
callq 0xf4ac
leaq 0x8(%rsp), %rdi
callq 0xca02
leaq 0xd8(%rsp), %rdi
callq 0x60c0
movq %rbx, %rdi
callq 0x6560
nopl (%rax)