LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_cpp_makefile_star2_O3/ryuichiueda[P]GlueLang/src/Feeder.cc
// Function: Feeder::Feeder(std::basic_ifstream<char, std::char_traits<char>>*)
Feeder::Feeder(ifstream *ifs){
	if (ifs->fail()){
		cerr << "glue: script read error" << endl;
//		return EXIT_FAILURE;
	}
	m_ifs = ifs;
	m_cur_line = 0;
	m_cur_char = 0;

	readAll();
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rsi, %r14
movq %rdi, %rbx
xorps %xmm0, %xmm0
movups %xmm0, 0x8(%rdi)
xorl %eax, %eax
movq %rax, 0x18(%rdi)
leaq 0x38(%rdi), %r12
movq %r12, 0x28(%rdi)
movq %rax, 0x30(%rdi)
movb $0x0, 0x38(%rdi)
movq (%rsi), %rax
movq -0x18(%rax), %rax
testb $0x5, 0x20(%rsi,%rax)
je 0xf04b
movq 0xcfe4(%rip), %r15      # 0x1bff0
leaq 0x5600(%rip), %rsi      # 0x14613
movl $0x17, %edx
movq %r15, %rdi
callq 0x63a0
movq (%r15), %rax
addq -0x18(%rax), %r15
movq %r15, %rdi
movl $0xa, %esi
callq 0x6300
movsbl %al, %esi
movq 0xcfb2(%rip), %rdi      # 0x1bff0
callq 0x6040
movq %rax, %rdi
callq 0x61e0
movq %r14, (%rbx)
movq $0x0, 0x20(%rbx)
movq %rbx, %rdi
callq 0xf0d8
testb %al, %al
jne 0xf056
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
jmp 0xf070
movq %rax, %r14
movq 0x28(%rbx), %rdi
addq $0x8, %rbx
cmpq %r12, %rdi
je 0xf08c
movq (%r12), %rsi
incq %rsi
callq 0x6330
movq %rbx, %rdi
callq 0xbcb0
movq %r14, %rdi
callq 0x6580
// File: /workspace/github_cpp_makefile_star2_O3/ryuichiueda[P]GlueLang/src/Feeder.cc
// Function: Feeder::readLine()
bool Feeder::readLine(void)
{
	string str;
	if(!getline(*m_ifs, str))
		return false;
	m_lines.push_back(str);
	return true;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
subq $0x28, %rsp
movq %rdi, %rbx
leaq 0x18(%rsp), %r15
movq %r15, -0x10(%r15)
movq $0x0, -0x8(%r15)
movb $0x0, (%r15)
movq (%rdi), %r14
movq (%r14), %rax
movq -0x18(%rax), %rdi
addq %r14, %rdi
movl $0xa, %esi
callq 0x6300
movsbl %al, %edx
leaq 0x8(%rsp), %rsi
movq %r14, %rdi
callq 0x65c0
movq (%rax), %rcx
movq -0x18(%rcx), %rcx
movl 0x20(%rax,%rcx), %ebp
testb $0x5, %bpl
jne 0xf143
addq $0x8, %rbx
leaq 0x8(%rsp), %rsi
movq %rbx, %rdi
callq 0xbde0
movq 0x8(%rsp), %rdi
cmpq %r15, %rdi
je 0xf15a
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x6330
testb $0x5, %bpl
sete %al
addq $0x28, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
movq 0x8(%rsp), %rdi
cmpq %r15, %rdi
je 0xf186
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x6330
movq %rbx, %rdi
callq 0x6580
// File: /workspace/github_cpp_makefile_star2_O3/ryuichiueda[P]GlueLang/src/Feeder.cc
// Function: Feeder::blank()
bool Feeder::blank(void)
{
	if(outOfRange())
		return false;

	string *p = &m_lines[m_cur_line];

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

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

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

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

// Assembly:
pushq %rax
movslq 0x20(%rdi), %rcx
movq 0x8(%rdi), %rax
movq 0x10(%rdi), %rdx
subq %rax, %rdx
shrq $0x5, %rdx
cmpl %edx, %ecx
jge 0xf357
movq %rcx, %rdx
shlq $0x5, %rdx
leaq (%rax,%rdx), %r8
movq 0x8(%rax,%rdx), %rdx
movslq 0x24(%rdi), %rsi
cmpq %rsi, %rdx
jne 0xf35b
xorl %eax, %eax
popq %rcx
retq
jbe 0xf3c4
movq (%r8), %r8
movzbl (%r8,%rsi), %r10d
xorl %eax, %eax
cmpq $0x20, %r10
ja 0xf359
movabsq $0x100000201, %r9       # imm = 0x100000201
btq %r10, %r9
jae 0xf359
cmpl %edx, %esi
jge 0xf39e
cmpq %rsi, %rdx
jbe 0xf3b3
movzbl (%r8,%rsi), %eax
cmpq $0x20, %rax
ja 0xf3ae
btq %rax, %r9
jae 0xf3ae
incq %rsi
cmpl %esi, %edx
jne 0xf381
movl $0x0, 0x24(%rdi)
incl %ecx
movl %ecx, 0x20(%rdi)
movb $0x1, %al
jmp 0xf359
movl %esi, 0x24(%rdi)
jmp 0xf3aa
leaq 0x511b(%rip), %rdi      # 0x144d5
movq %rdx, %rsi
xorl %eax, %eax
callq 0x64a0
leaq 0x510a(%rip), %rdi      # 0x144d5
jmp 0xf3bd
nop
// File: /workspace/github_cpp_makefile_star2_O3/ryuichiueda[P]GlueLang/src/Feeder.cc
// Function: Feeder::literal(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>*)
bool Feeder::literal(string *ans)
{
	try{
		return literalNoEsc(ans) || literalEsc(ans);
	}catch(...){
		throw this;
	}
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %r14
movq %rdi, %rbx
callq 0xfa34
movl %eax, %ecx
movb $0x1, %al
testb %cl, %cl
jne 0xf9ee
movq %rbx, %rdi
movq %r14, %rsi
callq 0xfb66
addq $0x8, %rsp
popq %rbx
popq %r14
retq
movq %rax, %rdi
callq 0x6130
movl $0x8, %edi
callq 0x6190
movq %rbx, (%rax)
leaq 0xb81e(%rip), %rsi      # 0x1b230
movq %rax, %rdi
xorl %edx, %edx
callq 0x6550
movq %rax, %rbx
callq 0x6500
movq %rbx, %rdi
callq 0x6580
movq %rax, %rdi
callq 0x7c2d
// File: /workspace/github_cpp_makefile_star2_O3/ryuichiueda[P]GlueLang/src/Feeder.cc
// Function: Feeder::comment()
bool Feeder::comment(void)
{
	int ln,ch;
	getPos(&ln,&ch);

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

	if(atEnd())
		return true;

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

	m_cur_char++;

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

// Assembly:
pushq %rbx
subq $0x10, %rsp
movq %rdi, %rbx
movsd 0x20(%rdi), %xmm0
movaps %xmm0, (%rsp)
callq 0xf326
movq %rbx, %rdi
callq 0xf500
testb %al, %al
jne 0xfdf6
movslq 0x20(%rbx), %rax
movq 0x8(%rbx), %rcx
movq 0x10(%rbx), %rdx
subq %rcx, %rdx
shrq $0x5, %rdx
cmpl %edx, %eax
jge 0xfe62
movslq 0x24(%rbx), %rsi
movq %rax, %rdi
shlq $0x5, %rdi
movq 0x8(%rcx,%rdi), %rdx
cmpl %edx, %esi
jge 0xfe5a
cmpq %rsi, %rdx
jbe 0xfe6a
addq %rdi, %rcx
movq (%rcx), %rcx
cmpb $0x23, (%rcx,%rsi)
jne 0xfe5a
movl $0x0, 0x24(%rbx)
incl %eax
movl %eax, 0x20(%rbx)
movq %rbx, %rdi
callq 0xf500
testb %al, %al
jne 0xfe4a
movb $0x1, %al
jmp 0xfe64
movaps (%rsp), %xmm0
movlps %xmm0, 0x20(%rbx)
xorl %eax, %eax
addq $0x10, %rsp
popq %rbx
retq
leaq 0x4664(%rip), %rdi      # 0x144d5
xorl %eax, %eax
callq 0x64a0
// File: /workspace/github_cpp_makefile_star2_O3/ryuichiueda[P]GlueLang/src/Feeder.cc
// Function: Feeder::countIndent()
int Feeder::countIndent(void)
{
	if(atEnd())
		return 0;

	if(m_cur_char != 0)
		return -1;

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

		i++;
	}

	return i;
}

// Assembly:
pushq %rax
movslq 0x20(%rdi), %rdx
movq 0x8(%rdi), %rcx
movq 0x10(%rdi), %rax
subq %rcx, %rax
shrq $0x5, %rax
cmpl %eax, %edx
sete %al
cmpl $0x0, 0x24(%rdi)
setne %dil
sete %sil
orb %al, %dil
je 0x106b6
andb %sil, %al
movzbl %al, %eax
decl %eax
jmp 0x10703
shlq $0x5, %rdx
movq 0x8(%rcx,%rdx), %rax
testl %eax, %eax
jle 0x106fd
addq %rdx, %rcx
movl %eax, %edx
andl $0x7fffffff, %edx       # imm = 0x7FFFFFFF
xorl %esi, %esi
movabsq $0x100000201, %rdi      # imm = 0x100000201
cmpq %rsi, %rax
je 0x10705
movq (%rcx), %r8
movzbl (%r8,%rsi), %r8d
cmpq $0x20, %r8
ja 0x10701
btq %r8, %rdi
jae 0x10701
incq %rsi
cmpq %rsi, %rdx
jne 0x106da
jmp 0x10703
xorl %eax, %eax
jmp 0x10703
movl %esi, %eax
popq %rcx
retq
leaq 0x3dc9(%rip), %rdi      # 0x144d5
movq %rax, %rsi
movq %rax, %rdx
xorl %eax, %eax
callq 0x64a0
nop
// File: /workspace/github_cpp_makefile_star2_O3/ryuichiueda[P]GlueLang/src/Feeder.cc
// Function: Feeder::doBlock(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>*)
bool Feeder::doBlock(string *ans)
{
	return block(ans,"do");
	/*
	if(!str("do")){
                return false;
	}

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

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

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

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x28, %rsp
movq %rsi, %rbx
movq %rdi, %r14
leaq 0x18(%rsp), %r12
movq %r12, -0x10(%r12)
leaq 0x3f43(%rip), %rsi      # 0x1467f
leaq 0x3f3e(%rip), %rdx      # 0x14681
leaq 0x8(%rsp), %r15
movq %r15, %rdi
callq 0x74f0
movq %r14, %rdi
movq %rbx, %rsi
movq %r15, %rdx
callq 0x107a8
movl %eax, %ebx
movq 0x8(%rsp), %rdi
cmpq %r12, %rdi
je 0x10777
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x6330
movl %ebx, %eax
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
movq %rax, %rbx
movq 0x8(%rsp), %rdi
cmpq %r12, %rdi
je 0x1079f
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x6330
movq %rbx, %rdi
callq 0x6580
nop
// File: /workspace/github_cpp_makefile_star2_O3/ryuichiueda[P]GlueLang/src/Feeder.cc
// Function: Feeder::block(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>*, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>)
bool Feeder::block(string *ans,string op)
{
	if(!str(op)){
                return false;
	}

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

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

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

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x68, %rsp
movq %rsi, %rbx
movq %rdi, %r14
leaq 0x58(%rsp), %r12
movq %r12, -0x10(%r12)
movq (%rdx), %rsi
movq 0x8(%rdx), %rdx
addq %rsi, %rdx
leaq 0x48(%rsp), %r15
movq %r15, %rdi
callq 0x745a
movq %r14, %rdi
movq %r15, %rsi
callq 0xff28
movl %eax, %ebp
movq 0x48(%rsp), %rdi
cmpq %r12, %rdi
je 0x10801
movq 0x58(%rsp), %rsi
incq %rsi
callq 0x6330
movb %bpl, 0x7(%rsp)
testb %bpl, %bpl
je 0x108fd
movq %r14, %rdi
callq 0xf500
testb %al, %al
je 0x1082a
movq %rbx, %rdi
movl $0xa, %esi
callq 0x6290
jmp 0x1080f
movq %r14, %rdi
callq 0x10682
movl %eax, %r15d
movslq %eax, %r12
leaq 0x8(%rsp), %r13
leaq 0x18(%rsp), %rax
movq %rax, 0x8(%rsp)
movq $0x0, 0x10(%rsp)
movb $0x0, 0x18(%rsp)
movq %r14, %rdi
movq %r13, %rsi
callq 0xfe84
movq 0x10(%rsp), %rcx
subq %r12, %rcx
leaq 0x28(%rsp), %rdi
movq %r13, %rsi
movq %r12, %rdx
callq 0x6350
movq 0x28(%rsp), %rsi
movq 0x30(%rsp), %rdx
movq %rbx, %rdi
callq 0x6100
movq 0x28(%rsp), %rdi
leaq 0x38(%rsp), %rax
cmpq %rax, %rdi
je 0x108a6
movq 0x38(%rsp), %rsi
incq %rsi
callq 0x6330
movq %rbx, %rdi
movl $0xa, %esi
callq 0x6290
movq %r14, %rdi
callq 0xf500
testb %al, %al
je 0x108ce
movq %rbx, %rdi
movl $0xa, %esi
callq 0x6290
jmp 0x108b3
movq %r14, %rdi
callq 0x10682
movl %eax, %ebp
movq 0x8(%rsp), %rdi
leaq 0x18(%rsp), %rax
cmpq %rax, %rdi
je 0x108f4
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x6330
cmpl %r15d, %ebp
jge 0x1083d
movb 0x7(%rsp), %al
addq $0x68, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
movq 0x48(%rsp), %rdi
cmpq %r12, %rdi
je 0x10968
movq 0x58(%rsp), %rsi
jmp 0x10960
jmp 0x10949
movq %rax, %rbx
movq 0x28(%rsp), %rdi
leaq 0x38(%rsp), %rax
cmpq %rax, %rdi
je 0x1094c
movq 0x38(%rsp), %rsi
incq %rsi
callq 0x6330
jmp 0x1094c
jmp 0x10949
movq %rax, %rbx
movq 0x8(%rsp), %rdi
leaq 0x18(%rsp), %rax
cmpq %rax, %rdi
je 0x10968
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x6330
movq %rbx, %rdi
callq 0x6580
// File: /workspace/github_cpp_makefile_star2_O3/ryuichiueda[P]GlueLang/src/Import.cc
// Function: Import::parse()
bool Import::parse(void)
{
	m_feeder->getPos(&m_start_line, &m_start_char);

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

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

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

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

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x48, %rsp
movq %rdi, %rbx
movq 0x8(%rdi), %rdi
leaq 0x30(%rbx), %rsi
leaq 0x34(%rbx), %r15
movq %rsi, (%rsp)
movq %r15, %rdx
callq 0xfe78
movq 0x8(%rbx), %r12
leaq 0x38(%rsp), %r14
movq %r14, -0x10(%r14)
leaq 0x3b0d(%rip), %rsi      # 0x14690
leaq 0x3b0c(%rip), %rdx      # 0x14696
leaq 0x28(%rsp), %r13
movq %r13, %rdi
callq 0x74f0
movq %r12, %rdi
movq %r13, %rsi
callq 0xff28
movl %eax, %ebp
movq 0x28(%rsp), %rdi
cmpq %r14, %rdi
je 0x10bbb
movq 0x38(%rsp), %rsi
incq %rsi
callq 0x6330
testb %bpl, %bpl
je 0x10c66
movq 0x8(%rbx), %rdi
leaq 0x88(%rbx), %r12
movq %r12, %rsi
callq 0xf1a8
movq 0x8(%rbx), %r13
testb %al, %al
je 0x10c36
leaq 0x18(%rsp), %r14
movq %r14, -0x10(%r14)
leaq 0x3aa8(%rip), %rsi      # 0x14697
leaq 0x3aa3(%rip), %rdx      # 0x14699
leaq 0x8(%rsp), %r15
movq %r15, %rdi
callq 0x74f0
movq %r13, %rdi
movq %r15, %rsi
callq 0xff28
movl %eax, %ebp
movq 0x8(%rsp), %rdi
cmpq %r14, %rdi
je 0x10c27
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x6330
testb %bpl, %bpl
je 0x10c44
movq %rbx, %rdi
callq 0x10cac
jmp 0x10c7f
movq (%rsp), %rax
movl (%rax), %esi
movl (%r15), %edx
movq %r13, %rdi
jmp 0x10c61
leaq 0x3a4f(%rip), %rsi      # 0x1469a
movq %r12, %rdi
callq 0x60f0
testl %eax, %eax
je 0x10c77
movq 0x8(%rbx), %rdi
movl 0x30(%rbx), %esi
movl 0x34(%rbx), %edx
callq 0xf828
xorl %eax, %eax
addq $0x48, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rbx, %rdi
callq 0x10dbe
jmp 0x10c68
movq %rax, %rbx
movq 0x8(%rsp), %rdi
jmp 0x10c93
movq %rax, %rbx
movq 0x28(%rsp), %rdi
cmpq %r14, %rdi
je 0x10ca3
movq (%r14), %rsi
incq %rsi
callq 0x6330
movq %rbx, %rdi
callq 0x6580
nop
// File: /workspace/github_cpp_makefile_star2_O3/ryuichiueda[P]GlueLang/src/Import.cc
// Function: Import::parseAs()
bool Import::parseAs(void)
{

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

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

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

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
subq $0x28, %rsp
movq %rdi, %rbx
movq 0x8(%rdi), %rdi
leaq 0xa8(%rbx), %r14
movq %r14, %rsi
callq 0xf3e2
movl %eax, %ebp
testb %al, %al
je 0x10d20
leaq 0x88(%rbx), %r15
movq 0x88(%rbx), %rax
movq 0x90(%rbx), %rcx
cmpb $0x2f, -0x1(%rax,%rcx)
je 0x10cfb
movq %r15, %rdi
movl $0x2f, %esi
callq 0x6290
movq 0x10(%rbx), %rdi
movq %r14, %rsi
movq %r15, %rdx
callq 0xaf68
movq 0x8(%rbx), %rdi
leaq 0x38(%rbx), %rsi
addq $0x3c, %rbx
movq %rbx, %rdx
callq 0xfe78
jmp 0x10d2f
movq 0x8(%rbx), %rdi
movl 0x30(%rbx), %esi
movl 0x34(%rbx), %edx
callq 0xf828
movl %ebp, %eax
addq $0x28, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rdi
callq 0x6130
movl $0xa0, %edx
addq 0x10(%rbx), %rdx
leaq 0x394b(%rip), %rsi      # 0x1469f
leaq 0x8(%rsp), %rdi
callq 0x73d2
leaq 0x8(%rsp), %rsi
movq %rbx, %rdi
callq 0x66e0
movl $0x1, 0x80(%rbx)
movq 0x8(%rbx), %rdi
leaq 0x38(%rbx), %rsi
leaq 0x3c(%rbx), %rdx
callq 0xfe78
movl $0x8, %edi
callq 0x6190
movq %rbx, (%rax)
leaq 0xac86(%rip), %rsi      # 0x1ba20
movq %rax, %rdi
xorl %edx, %edx
callq 0x6550
jmp 0x10da6
movq %rax, %rbx
callq 0x6500
movq %rbx, %rdi
callq 0x6580
movq %rax, %rdi
callq 0x7c2d
// File: /workspace/github_cpp_makefile_star2_O3/ryuichiueda[P]GlueLang/src/InternalCommands.cc
// Function: InternalCommands::exec(char const**, Environment*, Feeder*, Executable*)
int InternalCommands::exec(char const** argv,Environment *e,Feeder *f,Executable *p)
{
	int c = 0;
	while(argv[c] != NULL){
		c++;
	}
	if(strncmp(argv[0],"echo",4) == 0){
		exit( echo(c,argv) );
	}else if(strncmp(argv[0],"pid",3) == 0){
		exit( pid(c,e) );
	}else if(strncmp(argv[0],"ppid",4) == 0){
		exit( ppid(c,e) );
	}else if(strncmp(argv[0],"break",5) == 0){
		exit( break_(e) );
	}
	return -1;
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq %rdi, %r15
xorl %r12d, %r12d
cmpq $0x0, (%r15,%r12,8)
leaq 0x1(%r12), %r12
jne 0x110c7
movq (%r15), %r14
leaq 0x35e2(%rip), %rsi      # 0x146bf
movl $0x4, %edx
movq %r14, %rdi
callq 0x6170
testl %eax, %eax
je 0x11143
cmpb $0x70, (%r14)
jne 0x11102
cmpb $0x69, 0x1(%r14)
jne 0x11102
cmpb $0x64, 0x2(%r14)
je 0x1116f
leaq 0x35bb(%rip), %rsi      # 0x146c4
movl $0x4, %edx
movq %r14, %rdi
callq 0x6170
testl %eax, %eax
je 0x11153
leaq 0x35a8(%rip), %rsi      # 0x146c9
movl $0x5, %edx
movq %r14, %rdi
callq 0x6170
testl %eax, %eax
je 0x1115d
movl $0xffffffff, %eax       # imm = 0xFFFFFFFF
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
decl %r12d
movl %r12d, %edi
movq %r15, %rsi
callq 0x1117e
jmp 0x11177
movq %rbx, %rsi
callq 0x112ca
jmp 0x11177
movq %rbx, %rdi
callq 0x1130c
movl $0x1, %edi
callq 0x63c0
movq %rbx, %rsi
callq 0x11288
xorl %edi, %edi
callq 0x63c0
// File: /workspace/github_cpp_makefile_star2_O3/ryuichiueda[P]GlueLang/src/InternalCommands.cc
// Function: InternalCommands::echo(int, char const**)
int InternalCommands::echo(int argc, char const** argv)
{
	for(int i = 1; i < argc-1; i++){
		cout << argv[i] << " ";
	}
	if(argc > 1)
		cout << argv[argc-1] << endl;

	return 0;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rsi, %rbx
leal -0x1(%rdi), %eax
movl %eax, %ebp
movq %rdi, (%rsp)
cmpl $0x3, %edi
jl 0x111ff
movl $0x1, %r14d
movq 0xae21(%rip), %r15      # 0x1bfc8
leaq 0x36e1(%rip), %r12      # 0x1488f
movq (%rbx,%r14,8), %r13
testq %r13, %r13
je 0x111cf
movq %r13, %rdi
callq 0x6140
movq %r15, %rdi
movq %r13, %rsi
movq %rax, %rdx
callq 0x63a0
jmp 0x111e7
movq (%r15), %rax
movq -0x18(%rax), %rax
leaq (%r15,%rax), %rdi
movl 0x20(%r15,%rax), %esi
orl $0x1, %esi
callq 0x6530
movl $0x1, %edx
movq %r15, %rdi
movq %r12, %rsi
callq 0x63a0
incq %r14
cmpq %r14, %rbp
jne 0x111ae
cmpl $0x1, (%rsp)
jle 0x11276
movq (%rbx,%rbp,8), %rbx
testq %rbx, %rbx
je 0x1122a
movq %rbx, %rdi
callq 0x6140
movq 0xadab(%rip), %rdi      # 0x1bfc8
movq %rbx, %rsi
movq %rax, %rdx
callq 0x63a0
jmp 0x11248
movq 0xad97(%rip), %rax      # 0x1bfc8
movq (%rax), %rcx
movq -0x18(%rcx), %rcx
leaq (%rax,%rcx), %rdi
movl 0x20(%rax,%rcx), %esi
orl $0x1, %esi
callq 0x6530
movq 0xad79(%rip), %rbx      # 0x1bfc8
movq (%rbx), %rax
movq -0x18(%rax), %rdi
addq %rbx, %rdi
movl $0xa, %esi
callq 0x6300
movsbl %al, %esi
movq %rbx, %rdi
callq 0x6040
movq %rax, %rdi
callq 0x61e0
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O3/ryuichiueda[P]GlueLang/src/Job.cc
// Function: Job::Job(Feeder*, Environment*, std::vector<int, std::allocator<int>>*)
Job::Job(Feeder *f, Environment *env,vector<int> *scopes) : Element(f,env,scopes)
{
	m_outfile = NULL;
	m_outstr = NULL;
	m_where = NULL;
	m_is_background = false;

	m_local_env = NULL;
}

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

	cout << flush;

	eval();

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


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

	return execNormal(f,s);
}

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

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

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

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

	return 0;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rdx, %r14
movq %rsi, %r15
movq %rdi, %rbx
callq 0x60c0
testl %eax, %eax
js 0x11a7b
movq 0x10(%rbx), %rdi
je 0x11a85
movl %eax, %ebp
leaq 0x48(%rbx), %rsi
leaq 0x98(%rbx), %rdx
callq 0xb604
movl %ebp, 0x48(%rax)
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movl $0x4, %edi
callq 0x63c0
cmpb $0x1, 0xe0(%rdi)
jne 0x11af0
movq 0xa55b(%rip), %r12      # 0x1bff0
leaq 0x27d7(%rip), %rsi      # 0x14273
movl $0x6, %edx
movq %r12, %rdi
callq 0x63a0
movq 0x10(%rbx), %rax
movl 0xe4(%rax), %esi
movq %r12, %rdi
callq 0x6560
movq %rax, %r12
leaq 0x2b06(%rip), %rsi      # 0x145cb
movl $0x6, %edx
movq %rax, %rdi
callq 0x63a0
movq 0x98(%rbx), %rsi
movq 0xa0(%rbx), %rdx
movq %r12, %rdi
callq 0x63a0
movq %rax, %rdi
callq 0x6180
movq 0x18(%rbx), %rax
movq 0x20(%rbx), %rcx
subq %rax, %rcx
shrq $0x3, %rcx
testl %ecx, %ecx
jle 0x11b50
xorl %r13d, %r13d
testq %r15, %r15
sete %cl
movq (%rax,%r13,8), %r12
testq %r13, %r13
sete %al
orb %cl, %al
jne 0x11b26
movq 0x88(%r15), %rdi
callq 0x81b8
movq (%r12), %rax
movq %r12, %rdi
movq %r15, %rsi
movq %r14, %rdx
callq *0x18(%rax)
incq %r13
movq 0x18(%rbx), %rax
movq 0x20(%rbx), %rcx
subq %rax, %rcx
shrq $0x3, %rcx
movslq %ecx, %rcx
cmpq %rcx, %r13
jl 0x11b06
xorl %edi, %edi
callq 0x63c0
movq %rax, %rdi
callq 0x6130
leaq 0x60(%rbx), %rdi
leaq 0x2baa(%rip), %rsi      # 0x14714
callq 0x6410
movl $0x2, 0x80(%rbx)
movl $0x8, %edi
callq 0x6190
movq %rbx, (%rax)
leaq 0x9f1b(%rip), %rsi      # 0x1baa8
movq %rax, %rdi
xorl %edx, %edx
callq 0x6550
movq %rax, %rbx
callq 0x6500
movq %rbx, %rdi
callq 0x6580
movq %rax, %rdi
callq 0x7c2d
nop
// File: /workspace/github_cpp_makefile_star2_O3/ryuichiueda[P]GlueLang/src/Literal.cc
// Function: Literal::parse()
bool Literal::parse(void)
{
	m_feeder->getPos(&m_start_line, &m_start_char);

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

	return false;
}

// Assembly:
pushq %rbp
pushq %r14
pushq %rbx
movq %rdi, %rbx
movq 0x8(%rdi), %rdi
leaq 0x30(%rbx), %rsi
leaq 0x34(%rbx), %rdx
callq 0xfe78
movq 0x8(%rbx), %rdi
leaq 0x88(%rbx), %rsi
callq 0xf9cc
movl %eax, %ebp
testb %al, %al
je 0x11d0b
movq 0x8(%rbx), %rdi
leaq 0x38(%rbx), %rsi
leaq 0x3c(%rbx), %rdx
callq 0xfe78
movl %ebp, %eax
popq %rbx
popq %r14
popq %rbp
retq
movq %rax, %r14
cmpl $0x1, %edx
jne 0x11d76
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 $0x1, 0x80(%rbx)
movl $0x8, %edi
callq 0x6190
movq %rbx, (%rax)
leaq 0x9dd4(%rip), %rsi      # 0x1bb38
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/Literal.cc
// Function: Literal::eval()
bool Literal::eval(void)
{
	m_evaled_text = m_text;
	//evaled escaped characters 
	auto pos = m_evaled_text.find("\\\'"); // \'
	while(pos != string::npos){
		m_evaled_text.replace(pos, 2, "\'");
		pos = m_evaled_text.find("\\\'", pos + 1);
	}
	return true;
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rdi, %rbx
leaq 0x88(%rdi), %rsi
addq $0xa8, %rbx
movq %rbx, %rdi
callq 0x61c0
leaq 0x29a5(%rip), %rsi      # 0x1474b
movl $0x2, %ecx
movq %rbx, %rdi
xorl %edx, %edx
callq 0x6570
cmpq $-0x1, %rax
je 0x11e04
movq %rax, %r14
leaq 0x2987(%rip), %r15      # 0x1474c
leaq 0x297f(%rip), %r12      # 0x1474b
movl $0x2, %edx
movl $0x1, %r8d
movq %rbx, %rdi
movq %r14, %rsi
movq %r15, %rcx
callq 0x6390
incq %r14
movl $0x2, %ecx
movq %rbx, %rdi
movq %r12, %rsi
movq %r14, %rdx
callq 0x6570
movq %rax, %r14
cmpq $-0x1, %rax
jne 0x11dcc
movb $0x1, %al
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
nop
// File: /workspace/github_cpp_makefile_star2_O3/ryuichiueda[P]GlueLang/src/Pipeline.cc
// Function: Pipeline::exec(DefFile*, DefStr*)
int Pipeline::exec(DefFile *f,  DefStr *s)
{
	// When wait(1) is set in the command line,
	// wait(1) is done in this process.
	// Wait(1) cannot be connected with other commands
	//auto *cl = (Executable *)m_nodes[0];
	if(((Executable *)m_nodes[0])->m_is_wait)
		return execWait();

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

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

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

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

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

	return m_exit_status;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x28, %rsp
movq %rsi, 0x18(%rsp)
movq %rdi, %rbx
movq 0x18(%rdi), %r15
movq (%r15), %rax
cmpb $0x1, 0x85(%rax)
jne 0x12101
movq %rbx, %rdi
callq 0x1224c
xorl %eax, %eax
jmp 0x12207
movq %rdx, 0x10(%rsp)
movq 0x20(%rbx), %r14
cmpq %r14, %r15
je 0x121ce
leaq 0x90(%rbx), %rax
movq %rax, 0x8(%rsp)
movl $0xffffffff, %r12d      # imm = 0xFFFFFFFF
leaq 0x20(%rsp), %r13
movq (%r15), %rbp
movl $0xffffffff, 0x24(%rsp) # imm = 0xFFFFFFFF
movq 0x20(%rbx), %rax
cmpq -0x8(%rax), %rbp
je 0x1214f
movq %r13, %rdi
callq 0x6420
testl %eax, %eax
js 0x12216
movq %rbp, %rdi
movq %r13, %rsi
movl %r12d, %edx
callq 0xeed0
movq 0x20(%rbx), %rax
cmpq -0x8(%rax), %rbp
je 0x12174
movq (%rbp), %rax
movq %rbp, %rdi
xorl %esi, %esi
xorl %edx, %edx
jmp 0x12185
movq (%rbp), %rax
movq %rbp, %rdi
movq 0x18(%rsp), %rsi
movq 0x10(%rsp), %rdx
callq *0x18(%rax)
movl %eax, 0x4(%rsp)
movq 0x98(%rbx), %rsi
cmpq 0xa0(%rbx), %rsi
je 0x121ab
movl %eax, (%rsi)
addq $0x4, %rsi
movq %rsi, 0x98(%rbx)
jmp 0x121ba
movq 0x8(%rsp), %rdi
leaq 0x4(%rsp), %rdx
callq 0xa214
movl 0x90(%rbp), %r12d
addq $0x8, %r15
cmpq %r14, %r15
jne 0x1212a
movq 0x10(%rsp), %rdi
testq %rdi, %rdi
je 0x121dd
callq 0x9ad6
movq 0x90(%rbx), %r14
movq 0x98(%rbx), %r15
cmpq %r15, %r14
je 0x12201
movl (%r14), %esi
movq %rbx, %rdi
callq 0x124cc
addq $0x4, %r14
jmp 0x121eb
movl 0x80(%rbx), %eax
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movl %r12d, %edi
callq 0x65e0
leaq 0x60(%rbx), %rdi
leaq 0x2529(%rip), %rsi      # 0x14752
callq 0x6410
movl $0x8, %edi
callq 0x6190
movq %rbx, (%rax)
leaq 0x997e(%rip), %rsi      # 0x1bbc0
movq %rax, %rdi
xorl %edx, %edx
callq 0x6550
// File: /workspace/github_cpp_makefile_star2_O3/ryuichiueda[P]GlueLang/src/Script.cc
// Function: Script::parse()
bool Script::parse(void)
{
	try{
		return parseScript();
	}
	catch(Element *e){
		printErrorMsg(e,"Parse error");
		m_env->removeFiles();
		end(e->m_exit_status);
	}catch(...){
		cerr << "\nParse error"
		     << "\nunknown error" << endl;
		m_env->removeFiles();
		end(128);
	}
	return true;
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
subq $0x20, %rsp
movq %rdi, %rbx
callq 0x12810
movb $0x1, %al
addq $0x20, %rsp
popq %rbx
popq %r14
popq %r15
retq
movq %rdx, %r15
movq %rax, %rdi
callq 0x6130
cmpl $0x2, %r15d
jne 0x1277f
movq %rax, %r14
leaq 0x10(%rsp), %r15
movq %r15, -0x10(%r15)
leaq 0x20bb(%rip), %rsi      # 0x147f0
leaq 0x20bf(%rip), %rdx      # 0x147fb
movq %rsp, %rdi
callq 0x74f0
movq %rsp, %rdx
movq %r14, %rsi
xorl %ecx, %ecx
callq 0x12a00
movq (%rsp), %rdi
cmpq %r15, %rdi
je 0x12767
movq 0x10(%rsp), %rsi
incq %rsi
callq 0x6330
movq 0x10(%rbx), %rdi
callq 0xb76c
movl 0x80(%r14), %esi
movq %rbx, %rdi
callq 0x1297e
movq 0x986a(%rip), %rdi      # 0x1bff0
leaq 0x2062(%rip), %rsi      # 0x147ef
movl $0xc, %edx
callq 0x63a0
movq 0x9852(%rip), %rdi      # 0x1bff0
leaq 0x2057(%rip), %rsi      # 0x147fc
movl $0xe, %edx
callq 0x63a0
movq 0x983a(%rip), %rdi      # 0x1bff0
callq 0x6180
movq 0x10(%rbx), %rdi
callq 0xb76c
movq %rbx, %rdi
movl $0x80, %esi
callq 0x1297e
jmp 0x127ee
movq %rax, %rbx
movq (%rsp), %rdi
cmpq %r15, %rdi
je 0x127f1
movq 0x10(%rsp), %rsi
incq %rsi
callq 0x6330
jmp 0x127f1
movq %rax, %rbx
callq 0x6500
jmp 0x12800
movq %rax, %rbx
callq 0x6500
movq %rbx, %rdi
callq 0x6580
movq %rax, %rdi
callq 0x7c2d
// File: /workspace/github_cpp_makefile_star2_O3/ryuichiueda[P]GlueLang/src/Script.cc
// Function: Script::parseScript()
bool Script::parseScript(void)
{
	m_feeder->getPos(&m_start_line, &m_start_char);

	// mainly for shebang
	while(m_feeder->comment());
	// import
	while(add(new Import(m_feeder,m_env,&m_scopes))){
		while(m_feeder->blankLine());
	}

	m_env->initTmpdir();

	while(1){
		// comments -> proc or job -> proc or job -> ...

		while(m_feeder->comment());

		bool res = add(new DefProc(m_feeder,m_env,&m_scopes))
			|| add(new Job(m_feeder,m_env,&m_scopes));

		if(!res)
			break;
	
		while(m_feeder->blankLine());
	}
	m_feeder->getPos(&m_end_line, &m_end_char);

	if(!m_feeder->atEnd()){
		m_error_msg = "Unknown token";
		m_exit_status = 7;
		throw this;
	}

	return true;
}

// Assembly:
pushq %r15
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
callq 0xfde0
testb %al, %al
jne 0x12829
leaq 0x48(%rbx), %r14
movl $0xc8, %edi
callq 0x6320
movq %rax, %r15
movq 0x8(%rbx), %rsi
movq 0x10(%rbx), %rdx
movq %rax, %rdi
movq %r14, %rcx
callq 0x10a8c
movq %rbx, %rdi
movq %r15, %rsi
callq 0x9c96
testb %al, %al
je 0x12878
movq 0x8(%rbx), %rdi
callq 0xf500
testb %al, %al
jne 0x12869
jmp 0x1283a
movq 0x10(%rbx), %rdi
callq 0xa97a
movq 0x8(%rbx), %rdi
callq 0xfde0
testb %al, %al
jne 0x12881
movl $0xc8, %edi
callq 0x6320
movq %rax, %r15
movq 0x8(%rbx), %rsi
movq 0x10(%rbx), %rdx
movq %rax, %rdi
movq %r14, %rcx
callq 0x8ed8
movq %rbx, %rdi
movq %r15, %rsi
callq 0x9c96
testb %al, %al
jne 0x128ec
movl $0xd0, %edi
callq 0x6320
movq %rax, %r15
movq 0x8(%rbx), %rsi
movq 0x10(%rbx), %rdx
movq %rax, %rdi
movq %r14, %rcx
callq 0x11324
movq %rbx, %rdi
movq %r15, %rsi
callq 0x9c96
testb %al, %al
je 0x128fb
movq 0x8(%rbx), %rdi
callq 0xf500
testb %al, %al
jne 0x128ec
jmp 0x12881
movq 0x8(%rbx), %rdi
leaq 0x38(%rbx), %rsi
leaq 0x3c(%rbx), %rdx
callq 0xfe78
movq 0x8(%rbx), %rdi
callq 0xfdca
testb %al, %al
je 0x12921
movb $0x1, %al
popq %rbx
popq %r14
popq %r15
retq
leaq 0x60(%rbx), %rdi
leaq 0x1edf(%rip), %rsi      # 0x1480b
callq 0x6410
movl $0x7, 0x80(%rbx)
movl $0x8, %edi
callq 0x6190
movq %rbx, (%rax)
leaq 0x9311(%rip), %rsi      # 0x1bc60
movq %rax, %rdi
xorl %edx, %edx
callq 0x6550
movq %rax, %rbx
movl $0xd0, %esi
jmp 0x1296d
jmp 0x12965
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/Script.cc
// Function: Script::printErrorMsg(Element*, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, bool)
void Script::printErrorMsg(Element *e,string error_type, bool silent)
{
	if(silent)
		return;

	cerr << error_type << " at " << e->pos() << endl;
	e->printErrorPart();
	cerr << "\n\t" << e->m_error_msg
	     << "\n\tprocess_level " << e->getLevel()
	     << "\n\texit_status " << e->getExitStatus()
	     << "\n\tpid " << getpid() << endl;
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
subq $0x20, %rsp
testl %ecx, %ecx
jne 0x12b71
movq %rsi, %rbx
movq (%rdx), %rsi
movq 0x8(%rdx), %rdx
movq 0x95ce(%rip), %rdi      # 0x1bff0
callq 0x63a0
movq %rax, %r14
leaq 0x1e24(%rip), %rsi      # 0x14855
movl $0x4, %edx
movq %rax, %rdi
callq 0x63a0
movq %rsp, %r15
movq %r15, %rdi
movq %rbx, %rsi
callq 0x9d10
movq (%r15), %rsi
movq 0x8(%r15), %rdx
movq %r14, %rdi
callq 0x63a0
movq %rax, %r14
movq (%rax), %rax
movq -0x18(%rax), %rdi
addq %r14, %rdi
movl $0xa, %esi
callq 0x6300
movsbl %al, %esi
movq %r14, %rdi
callq 0x6040
movq %rax, %rdi
callq 0x61e0
leaq 0x10(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x12aa0
movq 0x10(%rsp), %rsi
incq %rsi
callq 0x6330
movq %rbx, %rdi
callq 0xa0a6
movq 0x9541(%rip), %r14      # 0x1bff0
leaq 0x1da4(%rip), %rsi      # 0x1485a
movl $0x2, %edx
movq %r14, %rdi
callq 0x63a0
movq 0x60(%rbx), %rsi
movq 0x68(%rbx), %rdx
movq %r14, %rdi
callq 0x63a0
movq %rax, %r14
leaq 0x1d80(%rip), %rsi      # 0x1485d
movl $0x10, %edx
movq %rax, %rdi
callq 0x63a0
movq %rbx, %rdi
callq 0xa0c0
movq %r14, %rdi
movl %eax, %esi
callq 0x6560
movq %rax, %r14
leaq 0x1d68(%rip), %rsi      # 0x1486e
movl $0xe, %edx
movq %rax, %rdi
callq 0x63a0
movl 0x80(%rbx), %esi
movq %r14, %rdi
callq 0x6560
movq %rax, %rbx
leaq 0x1d52(%rip), %rsi      # 0x1487d
movl $0x6, %edx
movq %rax, %rdi
callq 0x63a0
callq 0x6480
movq %rbx, %rdi
movl %eax, %esi
callq 0x6560
movq %rax, %rbx
movq (%rax), %rax
movq -0x18(%rax), %rdi
addq %rbx, %rdi
movl $0xa, %esi
callq 0x6300
movsbl %al, %esi
movq %rbx, %rdi
callq 0x6040
movq %rax, %rdi
callq 0x61e0
addq $0x20, %rsp
popq %rbx
popq %r14
popq %r15
retq
movq %rax, %rbx
leaq 0x10(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x12b99
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/Script.cc
// Function: Script::exec(DefFile*, DefStr*)
int Script::exec(DefFile *f,  DefStr *s)
{
	int exit_status = 0;
	try{
		for(auto &c : m_nodes){
			exit_status = c->exec(NULL,NULL);
		}
		m_env->removeFiles();
		if(exit_status == 0)
			end(0);
	}catch(Element *e){
		printErrorMsg(e,"Execution error",m_silent);
		m_env->removeFiles();
		if(e->m_command_error)
			end(1);
		else
			end(e->getExitStatus());
	}catch(...){
		cerr << "\nExecution error\n"
		     << "unknown error" << endl;
		m_env->removeFiles();
		end(3);
	}
	cerr << "unknown error (uncatched)" << endl;
	m_env->removeFiles();
	end(3);
	return 0;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
subq $0x28, %rsp
movq %rdi, %rbx
movq 0x18(%rdi), %r14
movq 0x20(%rdi), %r15
movb $0x1, %bpl
cmpq %r15, %r14
je 0x12bdb
movq (%r14), %rdi
movq (%rdi), %rax
xorl %esi, %esi
xorl %edx, %edx
callq *0x18(%rax)
addq $0x8, %r14
cmpq %r15, %r14
jne 0x12bbf
testl %eax, %eax
sete %bpl
movq 0x10(%rbx), %rdi
callq 0xb76c
testb %bpl, %bpl
je 0x12bf0
xorl %edi, %edi
callq 0x63c0
movq 0x93f9(%rip), %r14      # 0x1bff0
leaq 0x1c3d(%rip), %rsi      # 0x1483b
movl $0x19, %edx
movq %r14, %rdi
callq 0x63a0
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
callq 0x61e0
movq 0x10(%rbx), %rdi
callq 0xb76c
movq %rbx, %rdi
movl $0x3, %esi
callq 0x1297e
jmp 0x12c4a
movq %rdx, %r15
movq %rax, %rdi
callq 0x6130
cmpl $0x2, %r15d
jne 0x12cd1
movq %rax, %r14
leaq 0x18(%rsp), %r15
movq %r15, -0x10(%r15)
leaq 0x1bbd(%rip), %rsi      # 0x1482b
leaq 0x1bc5(%rip), %rdx      # 0x1483a
leaq 0x8(%rsp), %rdi
callq 0x74f0
movzbl 0x85(%rbx), %ecx
leaq 0x8(%rsp), %rdx
movq %r14, %rsi
callq 0x12a00
movq 0x8(%rsp), %rdi
cmpq %r15, %rdi
je 0x12caa
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x6330
movq 0x10(%rbx), %rdi
callq 0xb76c
movl $0x1, %esi
cmpb $0x0, 0x84(%r14)
jne 0x12cc9
movl 0x80(%r14), %esi
movq %rbx, %rdi
callq 0x1297e
movq 0x9318(%rip), %rdi      # 0x1bff0
leaq 0x1b3a(%rip), %rsi      # 0x14819
movl $0x11, %edx
callq 0x63a0
movq 0x9300(%rip), %rdi      # 0x1bff0
leaq 0x1b06(%rip), %rsi      # 0x147fd
movl $0xd, %edx
callq 0x63a0
movq 0x92e8(%rip), %rdi      # 0x1bff0
callq 0x6180
movq 0x10(%rbx), %rdi
callq 0xb76c
movq %rbx, %rdi
movl $0x3, %esi
callq 0x1297e
jmp 0x12d41
movq %rax, %rbx
movq 0x8(%rsp), %rdi
cmpq %r15, %rdi
je 0x12d44
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x6330
jmp 0x12d44
movq %rax, %rbx
callq 0x6500
jmp 0x12d53
movq %rax, %rbx
callq 0x6500
movq %rbx, %rdi
callq 0x6580
movq %rax, %rdi
callq 0x7c2d
nop
// File: /workspace/github_cpp_makefile_star2_O3/ryuichiueda[P]GlueLang/src/Where.cc
// Function: Where::parse()
bool Where::parse(void)
{
	m_feeder->getPos(&m_start_line, &m_start_char);
	int base_indent = m_feeder->countIndent();
	if(base_indent <= 0)
		return false;

	m_feeder->blank();
	if(!m_feeder->str("where")){
		m_feeder->setPos(m_start_line, m_start_char);
		return false;
	}

	int indent = base_indent;
	while(indent >= base_indent){
		m_feeder->blank();
		if(add(new Job(m_feeder,m_env,&m_scopes))){
		}else{
			m_error_msg = "Invalid where sentences";	
			m_exit_status = 1;
			throw this;
		}

		if(!m_feeder->atNewLine()){
			m_error_msg = "Invalid pipeline or andline";	
			m_exit_status = 1;
			throw this;
		}
		
		indent = m_feeder->countIndent();
	}

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

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x20, %rsp
movq %rdi, %rbx
movq 0x8(%rdi), %rdi
leaq 0x30(%rbx), %rsi
leaq 0x34(%rbx), %rdx
callq 0xfe78
movq 0x8(%rbx), %rdi
callq 0x10682
testl %eax, %eax
jle 0x12eeb
movl %eax, %ebp
movq 0x8(%rbx), %rdi
callq 0xf326
movq 0x8(%rbx), %r14
leaq 0x10(%rsp), %r12
movq %r12, -0x10(%r12)
leaq 0x1a73(%rip), %rsi      # 0x148a6
leaq 0x1a71(%rip), %rdx      # 0x148ab
movq %rsp, %r15
movq %r15, %rdi
callq 0x74f0
movq %r14, %rdi
movq %r15, %rsi
callq 0xff28
movl %eax, %r14d
movq (%rsp), %rdi
cmpq %r12, %rdi
je 0x12e69
movq 0x10(%rsp), %rsi
incq %rsi
callq 0x6330
testb %r14b, %r14b
je 0x12edc
leaq 0x48(%rbx), %r14
movq 0x8(%rbx), %rdi
callq 0xf326
movl $0xd0, %edi
callq 0x6320
movq %rax, %r15
movq 0x8(%rbx), %rsi
movq 0x10(%rbx), %rdx
movq %rax, %rdi
movq %r14, %rcx
callq 0x11324
movq %rbx, %rdi
movq %r15, %rsi
callq 0x9c96
testb %al, %al
je 0x12f07
movq 0x8(%rbx), %rdi
callq 0xf820
testb %al, %al
je 0x12efa
movq 0x8(%rbx), %rdi
callq 0x10682
cmpl %ebp, %eax
jge 0x12e72
movq 0x8(%rbx), %rdi
leaq 0x38(%rbx), %rsi
addq $0x3c, %rbx
movq %rbx, %rdx
callq 0xfe78
movb $0x1, %al
jmp 0x12eed
movq 0x8(%rbx), %rdi
movl 0x30(%rbx), %esi
movl 0x34(%rbx), %edx
callq 0xf828
xorl %eax, %eax
addq $0x20, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
leaq 0x60(%rbx), %rdi
leaq 0x19bf(%rip), %rsi      # 0x148c4
jmp 0x12f12
leaq 0x60(%rbx), %rdi
leaq 0x199a(%rip), %rsi      # 0x148ac
callq 0x6410
movl $0x1, 0x80(%rbx)
movl $0x8, %edi
callq 0x6190
movq %rbx, (%rax)
leaq 0x8dab(%rip), %rsi      # 0x1bce0
movq %rax, %rdi
xorl %edx, %edx
callq 0x6550
movq %rax, %rbx
movq (%rsp), %rdi
cmpq %r12, %rdi
je 0x12f65
movq 0x10(%rsp), %rsi
incq %rsi
jmp 0x12f60
movq %rax, %rbx
movl $0xd0, %esi
movq %r15, %rdi
callq 0x6330
movq %rbx, %rdi
callq 0x6580
nop
// File: /workspace/github_cpp_makefile_star2_O3/ryuichiueda[P]GlueLang/src/main.cc
// Function: scriptPos(int, char const**)
int scriptPos(int argc, char const* argv[])
{
	string com = string(argv[0]);
	bool shebang = com.substr(com.find_last_of('/') + 1) != "glue";

	if(shebang)
		return 0;

	int i=1;
	for(;i<argc;i++){
		if(argv[i][0] != '-')
			break;
	}
	return i;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
subq $0x48, %rsp
movq %rsi, %rbx
movl %edi, %ebp
movq (%rsi), %rsi
leaq 0x28(%rsp), %r14
leaq 0x8(%rsp), %rdx
movq %r14, %rdi
callq 0xbc72
movq %r14, %rdi
movl $0x2f, %esi
movq $-0x1, %rdx
callq 0x65f0
leaq 0x1(%rax), %rdx
leaq 0x8(%rsp), %rdi
movq %r14, %rsi
movq $-0x1, %rcx
callq 0x6350
leaq 0x114c(%rip), %rsi      # 0x1444e
leaq 0x8(%rsp), %r14
movq %r14, %rdi
callq 0x60f0
movl %eax, %r15d
movq (%r14), %rdi
leaq 0x18(%rsp), %rax
cmpq %rax, %rdi
je 0x1332c
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x6330
xorl %r14d, %r14d
testl %r15d, %r15d
jne 0x1335b
movl $0x1, %r14d
cmpl $0x2, %ebp
jl 0x1335b
movl %ebp, %eax
movl $0x1, %r14d
movq (%rbx,%r14,8), %rcx
cmpb $0x2d, (%rcx)
jne 0x1335b
incq %r14
cmpq %r14, %rax
jne 0x13347
movl %eax, %r14d
leaq 0x38(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x13376
movq 0x38(%rsp), %rsi
incq %rsi
callq 0x6330
movl %r14d, %eax
addq $0x48, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
leaq 0x38(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x133a2
movq 0x38(%rsp), %rsi
incq %rsi
callq 0x6330
movq %rbx, %rdi
callq 0x6580
// File: /workspace/github_cpp_makefile_star2_O3/ryuichiueda[P]GlueLang/src/main.cc
// Function: setFlags(int, char const**, Environment*)
bool setFlags(int argc, char const* argv[],Environment *e)
{
	struct option long_opts[] = {
		{"help",0,NULL,'h'},
		{"usage",0,NULL,'u'},
		{"version",0,NULL,'h'},
		{"verbose",0,NULL,'v'},
		{0,0,0,0}
	};

	int opt = 0;
	int idx = 0;
	while((opt = getopt_long(argc,(char *const *)argv,"uhv",long_opts,&idx)) != -1){
		switch (opt){
		case 'u':
			usage();
		case 'h':
			version();
		case 'v':
			e->m_v_opt = true;
			break;
		}
	}
	return true;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0xb8, %rsp
movq %rdx, %rbx
movq %rsi, %r14
movl %edi, %ebp
leaq 0x8936(%rip), %rsi      # 0x1bd00
leaq 0x10(%rsp), %r15
movl $0xa0, %edx
movq %r15, %rdi
callq 0x6260
leaq 0xc(%rsp), %r12
movl $0x0, (%r12)
leaq 0x15c0(%rip), %r13      # 0x149b0
movl %ebp, %edi
movq %r14, %rsi
movq %r13, %rdx
movq %r15, %rcx
movq %r12, %r8
callq 0x6520
cmpl $0x75, %eax
jle 0x13416
cmpl $0x76, %eax
jne 0x133f0
movb $0x1, 0xe0(%rbx)
jmp 0x133f0
cmpl $-0x1, %eax
je 0x1342a
cmpl $0x68, %eax
je 0x1343e
cmpl $0x75, %eax
jne 0x133f0
callq 0x13267
movb $0x1, %al
addq $0xb8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
callq 0x13443
// File: /workspace/github_cpp_makefile_star2_O3/ryuichiueda[P]GlueLang/src/main.cc
// Function: version()
void version(void)
{
	cerr << "GlueLang v0.3.2 🌸🍺\n"
	     << "Copyright (C) 2021 Ryuichi Ueda\n"
	     << "Released under the MIT License.\n"
	     << "https://github.com/ryuichiueda/GlueLang" << endl;
	exit(1);
}

// Assembly:
pushq %rax
movq 0x8ba5(%rip), %rdi      # 0x1bff0
leaq 0x14a3(%rip), %rsi      # 0x148f5
callq 0x6310
leaq 0x14b1(%rip), %rsi      # 0x1490f
movq %rax, %rdi
callq 0x6310
leaq 0x14c3(%rip), %rsi      # 0x14930
movq %rax, %rdi
callq 0x6310
leaq 0x14d5(%rip), %rsi      # 0x14951
movq %rax, %rdi
callq 0x6310
movq %rax, %rdi
callq 0x6180
movl $0x1, %edi
callq 0x63c0
// File: /workspace/github_cpp_makefile_star2_O3/thierry7100[P]CutOptim/include/cxxopts.hpp
// Function: cxxopts::ParseResult::count(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&) const
size_t
    count(const std::string& o) const
    {
      auto iter = m_options->find(o);
      if (iter == m_options->end())
      {
        return 0;
      }

      auto riter = m_results.find(iter->second);

      return riter->second.count();
    }

// Assembly:
pushq %rbx
movq %rdi, %rbx
movq (%rdi), %rdi
callq 0x1342a
testq %rax, %rax
je 0xcb26
addq $0x68, %rbx
addq $0x28, %rax
movq %rbx, %rdi
movq %rax, %rsi
callq 0x140fa
movq 0x28(%rax), %rax
jmp 0xcb28
xorl %eax, %eax
popq %rbx
retq
// File: /workspace/github_cpp_makefile_star2_O3/thierry7100[P]CutOptim/include/cxxopts.hpp
// Function: cxxopts::ParseResult::operator[](std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&) const
const OptionValue&
    operator[](const std::string& option) const
    {
      auto iter = m_options->find(option);

      if (iter == m_options->end())
      {
        throw option_not_present_exception(option);
      }

      auto riter = m_results.find(iter->second);

      return riter->second;
    }

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq %rdi, %r14
movq (%rdi), %rdi
callq 0x1342a
testq %rax, %rax
je 0xcffc
addq $0x68, %r14
addq $0x28, %rax
movq %r14, %rdi
movq %rax, %rsi
callq 0x140fa
addq $0x18, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
movl $0x28, %edi
callq 0x7210
movq %rax, %r14
movq %rax, %rdi
movq %rbx, %rsi
callq 0x15c68
leaq 0x4317d(%rip), %rsi     # 0x50198
leaq 0x151dc(%rip), %rdx     # 0x221fe
movq %r14, %rdi
callq 0x7710
movq %rax, %rbx
movq %r14, %rdi
callq 0x7340
movq %rbx, %rdi
callq 0x7740
nop
// File: /workspace/github_cpp_makefile_star2_O3/thierry7100[P]CutOptim/include/cxxopts.hpp
// Function: cxxopts::values::abstract_value<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>::abstract_value(cxxopts::values::abstract_value<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>> const&)
abstract_value(const abstract_value& rhs)
      {
        if (rhs.m_result)
        {
          m_result = std::make_shared<T>();
          m_store = m_result.get();
        }
        else
        {
          m_store = rhs.m_store;
        }

        m_default = rhs.m_default;
        m_implicit = rhs.m_implicit;
        m_default_value = rhs.m_default_value;
        m_implicit_value = rhs.m_implicit_value;
      }

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rsi, %r12
movq %rdi, %rbx
xorps %xmm0, %xmm0
movups %xmm0, 0x8(%rdi)
leaq 0x2f4d5(%rip), %rax     # 0x50468
movq %rax, (%rdi)
movups %xmm0, 0x18(%rdi)
movw $0x0, 0x30(%rdi)
leaq 0x38(%rdi), %r14
leaq 0x48(%rdi), %r13
movq %r13, 0x38(%rdi)
xorl %eax, %eax
movq %rax, 0x40(%rdi)
movb %al, 0x48(%rdi)
leaq 0x58(%rdi), %r15
leaq 0x68(%rdi), %rbp
movq %rbp, 0x58(%rdi)
movq %rax, 0x60(%rdi)
movb %al, 0x68(%rdi)
cmpq %rax, 0x18(%rsi)
je 0x21045
movl $0x30, %edi
callq 0x7440
movabsq $0x100000001, %rcx      # imm = 0x100000001
movq %rcx, 0x8(%rax)
leaq 0x2f4f3(%rip), %rcx     # 0x504e0
movq %rcx, (%rax)
leaq 0x10(%rax), %rcx
movq %rax, %rdx
addq $0x20, %rdx
movq %rdx, 0x10(%rax)
movq $0x0, 0x18(%rax)
movb $0x0, 0x20(%rax)
movq %rcx, 0x18(%rbx)
movq 0x20(%rbx), %rdi
movq %rax, 0x20(%rbx)
testq %rdi, %rdi
je 0x2104a
movq %r15, (%rsp)
movq %rbp, %r15
movq %r14, %rbp
movq %r13, %r14
leaq 0x18(%rbx), %r13
callq 0xd388
movq (%r13), %rcx
movq %r14, %r13
movq %rbp, %r14
movq %r15, %rbp
movq (%rsp), %r15
jmp 0x2104a
movq 0x28(%r12), %rcx
movq %rcx, 0x28(%rbx)
movb 0x30(%r12), %al
movb %al, 0x30(%rbx)
movb 0x31(%r12), %al
movb %al, 0x31(%rbx)
leaq 0x38(%r12), %rsi
movq %r14, %rdi
callq 0x7260
addq $0x58, %r12
movq %r15, %rdi
movq %r12, %rsi
callq 0x7260
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
jmp 0x2108b
movq %rax, %r12
movq (%r15), %rdi
cmpq %rbp, %rdi
je 0x210a2
movq (%rbp), %rsi
incq %rsi
callq 0x7450
movq (%r14), %rdi
cmpq %r13, %rdi
je 0x210b6
movq (%r13), %rsi
incq %rsi
callq 0x7450
movq 0x20(%rbx), %rdi
testq %rdi, %rdi
je 0x210c4
callq 0xd388
movq %rbx, %rdi
callq 0x20df6
movq %r12, %rdi
callq 0x7740
// File: /workspace/github_cpp_makefile_star2_O3/thierry7100[P]CutOptim/include/cxxopts.hpp
// Function: cxxopts::values::standard_value<bool>::set_default_and_implicit()
void
      set_default_and_implicit()
      {
        m_default = true;
        m_default_value = "false";
        m_implicit = true;
        m_implicit_value = "true";
      }

// Assembly:
pushq %rbp
pushq %rbx
pushq %rax
movq %rdi, %rbx
movb $0x1, %bpl
movb %bpl, 0x30(%rdi)
addq $0x38, %rdi
movq 0x40(%rbx), %rdx
leaq 0x1aa2c(%rip), %rcx     # 0x3c47a
movl $0x5, %r8d
xorl %esi, %esi
callq 0x7650
movb %bpl, 0x31(%rbx)
movq 0x60(%rbx), %rdx
addq $0x58, %rbx
leaq 0x1a9b8(%rip), %rcx     # 0x3c426
movl $0x4, %r8d
movq %rbx, %rdi
xorl %esi, %esi
addq $0x8, %rsp
popq %rbx
popq %rbp
jmp 0x7650