LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: ryuichiueda[P]GlueLang/src/Feeder.cc
// Function: Feeder::lineResidual(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>*)
bool Feeder::lineResidual(string *ans)
{
	if(outOfRange())
		return false;

	string *p = &m_lines[m_cur_line];
	if(ans != NULL)
		*ans = string(p->c_str()+m_cur_char,p->size()-m_cur_char);
	m_cur_char = 0;
	m_cur_line++;
	return true;
	
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x80, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x10(%rbp), %rdi
movq %rdi, -0x60(%rbp)
callq 0x163e0
testb $0x1, %al
jne 0x17666
jmp 0x1766f
movb $0x0, -0x1(%rbp)
jmp 0x17736
movq -0x60(%rbp), %rax
movq %rax, %rdi
addq $0x8, %rdi
movslq 0x20(%rax), %rsi
callq 0xb680
movq %rax, -0x20(%rbp)
cmpq $0x0, -0x18(%rbp)
je 0x1771e
movq -0x20(%rbp), %rdi
callq 0x6190
movq -0x60(%rbp), %rcx
movslq 0x24(%rcx), %rcx
addq %rcx, %rax
movq %rax, -0x78(%rbp)
movq -0x20(%rbp), %rdi
callq 0x62c0
movq -0x60(%rbp), %rcx
movslq 0x24(%rcx), %rcx
subq %rcx, %rax
movq %rax, -0x70(%rbp)
leaq -0x41(%rbp), %rdi
movq %rdi, -0x68(%rbp)
callq 0x6710
movq -0x78(%rbp), %rsi
movq -0x70(%rbp), %rdx
movq -0x68(%rbp), %rcx
leaq -0x40(%rbp), %rdi
callq 0x64c0
jmp 0x176e6
movq -0x18(%rbp), %rdi
leaq -0x40(%rbp), %rsi
callq 0x6520
leaq -0x40(%rbp), %rdi
callq 0x6280
leaq -0x41(%rbp), %rdi
callq 0x6480
jmp 0x1771e
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x50(%rbp)
movl %eax, -0x54(%rbp)
leaq -0x41(%rbp), %rdi
callq 0x6480
jmp 0x17744
movq -0x60(%rbp), %rax
movl $0x0, 0x24(%rax)
movl 0x20(%rax), %ecx
addl $0x1, %ecx
movl %ecx, 0x20(%rax)
movb $0x1, -0x1(%rbp)
movb -0x1(%rbp), %al
andb $0x1, %al
addq $0x80, %rsp
popq %rbp
retq
movq -0x50(%rbp), %rdi
callq 0x6700
nopl (%rax)
// File: ryuichiueda[P]GlueLang/src/Feeder.cc
// Function: Feeder::str(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>)
bool Feeder::str(string s)
{
	if(outOfRange())
		return false;

	string *p = &m_lines[m_cur_line];
	if(p->substr(m_cur_char,s.size()) != s)
		return false;

	m_cur_char += s.length();
	blank();
	checkEol(p);
	return true;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x70, %rsp
movq %rsi, -0x50(%rbp)
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x10(%rbp), %rdi
movq %rdi, -0x48(%rbp)
callq 0x163e0
testb $0x1, %al
jne 0x17777
jmp 0x17780
movb $0x0, -0x1(%rbp)
jmp 0x17824
movq -0x48(%rbp), %rax
movq %rax, %rdi
addq $0x8, %rdi
movslq 0x20(%rax), %rsi
callq 0xb680
movq -0x50(%rbp), %rdi
movq %rax, %rcx
movq -0x48(%rbp), %rax
movq %rcx, -0x20(%rbp)
movq -0x20(%rbp), %rcx
movq %rcx, -0x68(%rbp)
movslq 0x24(%rax), %rax
movq %rax, -0x60(%rbp)
callq 0x62c0
movq -0x68(%rbp), %rsi
movq -0x60(%rbp), %rdx
movq %rax, %rcx
leaq -0x40(%rbp), %rdi
callq 0x6440
movq -0x50(%rbp), %rsi
leaq -0x40(%rbp), %rdi
callq 0xfbd0
movb %al, -0x51(%rbp)
leaq -0x40(%rbp), %rdi
callq 0x6280
movb -0x51(%rbp), %al
testb $0x1, %al
jne 0x177ee
jmp 0x177f4
movb $0x0, -0x1(%rbp)
jmp 0x17824
movq -0x50(%rbp), %rdi
callq 0x6620
movq -0x48(%rbp), %rdi
movq %rax, %rcx
movslq 0x24(%rdi), %rax
addq %rcx, %rax
movl %eax, 0x24(%rdi)
callq 0x164a0
movq -0x48(%rbp), %rdi
movq -0x20(%rbp), %rsi
callq 0x165b0
movb $0x1, -0x1(%rbp)
movb -0x1(%rbp), %al
andb $0x1, %al
addq $0x70, %rsp
popq %rbp
retq
nop
// File: ryuichiueda[P]GlueLang/src/Feeder.cc
// Function: Feeder::printErrorPart(int, int, int, int)
void Feeder::printErrorPart(int from, int from_char, int to, int to_char)
{
	for(int i=from;i<=to;i++){
		if(i != from && i == to && to_char == 0)
			break;

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

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0xc0, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movl %edx, -0x10(%rbp)
movl %ecx, -0x14(%rbp)
movl %r8d, -0x18(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x98(%rbp)
movl -0xc(%rbp), %eax
movl %eax, -0x1c(%rbp)
movl -0x1c(%rbp), %eax
cmpl -0x14(%rbp), %eax
jg 0x17c93
movl -0x1c(%rbp), %eax
cmpl -0xc(%rbp), %eax
je 0x17ad4
movl -0x1c(%rbp), %eax
cmpl -0x14(%rbp), %eax
jne 0x17ad4
cmpl $0x0, -0x18(%rbp)
jne 0x17ad4
jmp 0x17c93
movl -0x1c(%rbp), %esi
incl %esi
leaq -0x80(%rbp), %rdi
movq %rdi, -0xa0(%rbp)
callq 0xa480
movq -0xa0(%rbp), %rdx
leaq 0x5b0f(%rip), %rsi      # 0x1d606
leaq -0x60(%rbp), %rdi
callq 0xbf30
jmp 0x17b02
leaq 0x5d14(%rip), %rdx      # 0x1d81d
leaq -0x40(%rbp), %rdi
leaq -0x60(%rbp), %rsi
callq 0x7bd0
jmp 0x17b18
leaq -0x60(%rbp), %rdi
callq 0x6280
leaq -0x80(%rbp), %rdi
callq 0x6280
movq 0x114b7(%rip), %rdi     # 0x28fe8
leaq -0x40(%rbp), %rsi
callq 0x63a0
movq %rax, -0xa8(%rbp)
jmp 0x17b43
movq -0x98(%rbp), %rdi
addq $0x8, %rdi
movslq -0x1c(%rbp), %rsi
callq 0xb680
movq -0xa8(%rbp), %rdi
movq %rax, %rsi
callq 0x63a0
movq %rax, -0xb0(%rbp)
jmp 0x17b6f
movq -0xb0(%rbp), %rdi
movq 0x1142b(%rip), %rsi     # 0x28fa8
callq 0x6460
jmp 0x17b84
movl -0x1c(%rbp), %eax
cmpl -0xc(%rbp), %eax
jne 0x17c7c
movq 0x11451(%rip), %rdi     # 0x28fe8
leaq 0x5c4c(%rip), %rsi      # 0x1d7ea
callq 0x6410
jmp 0x17ba5
leaq -0x40(%rbp), %rdi
callq 0x62c0
movq %rax, %rcx
movl $0x1, %eax
subq %rcx, %rax
movl %eax, -0x90(%rbp)
movl -0x90(%rbp), %eax
cmpl -0x10(%rbp), %eax
jge 0x17c49
movq 0x11417(%rip), %rdi     # 0x28fe8
leaq 0x5c46(%rip), %rsi      # 0x1d81e
callq 0x6410
jmp 0x17bdf
jmp 0x17be1
movl -0x90(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x90(%rbp)
jmp 0x17bbf
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x88(%rbp)
movl %eax, -0x8c(%rbp)
jmp 0x17c21
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x88(%rbp)
movl %eax, -0x8c(%rbp)
leaq -0x60(%rbp), %rdi
callq 0x6280
leaq -0x80(%rbp), %rdi
callq 0x6280
jmp 0x17c9c
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x88(%rbp)
movl %eax, -0x8c(%rbp)
leaq -0x40(%rbp), %rdi
callq 0x6280
jmp 0x17c9c
movq 0x11398(%rip), %rdi     # 0x28fe8
leaq 0x59b5(%rip), %rsi      # 0x1d60c
callq 0x6410
movq %rax, -0xb8(%rbp)
jmp 0x17c65
movq -0xb8(%rbp), %rdi
movq 0x11335(%rip), %rsi     # 0x28fa8
callq 0x6460
jmp 0x17c7a
jmp 0x17c7c
leaq -0x40(%rbp), %rdi
callq 0x6280
movl -0x1c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x1c(%rbp)
jmp 0x17aad
addq $0xc0, %rsp
popq %rbp
retq
movq -0x88(%rbp), %rdi
callq 0x6700
nopl (%rax,%rax)
// File: 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 %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movq -0x10(%rbp), %rdi
movq %rdi, -0x28(%rbp)
callq 0x174c0
testb $0x1, %al
jne 0x17ccf
jmp 0x17cdb
movl $0x0, -0x4(%rbp)
jmp 0x17d5b
movq -0x28(%rbp), %rax
cmpl $0x0, 0x24(%rax)
je 0x17cee
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
jmp 0x17d5b
movq -0x28(%rbp), %rax
movq %rax, %rdi
addq $0x8, %rdi
movslq 0x20(%rax), %rsi
callq 0xb680
movq %rax, -0x18(%rbp)
movl $0x0, -0x1c(%rbp)
movl -0x1c(%rbp), %eax
movl %eax, -0x2c(%rbp)
movq -0x18(%rbp), %rdi
callq 0x62c0
movq %rax, %rcx
movl -0x2c(%rbp), %eax
cmpl %ecx, %eax
jge 0x17d55
movq -0x18(%rbp), %rdi
movslq -0x1c(%rbp), %rsi
callq 0x6770
movsbl (%rax), %esi
leaq 0x587f(%rip), %rdi      # 0x1d5bc
callq 0x6160
cmpq $0x0, %rax
jne 0x17d4a
jmp 0x17d55
movl -0x1c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x1c(%rbp)
jmp 0x17d0d
movl -0x1c(%rbp), %eax
movl %eax, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: 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
movq %rsp, %rbp
subq $0xe0, %rsp
movq %rdx, -0xb8(%rbp)
movq %rsi, %rax
movq -0xb8(%rbp), %rsi
movq %rdi, -0x10(%rbp)
movq %rax, -0x18(%rbp)
movq %rsi, -0x20(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0xb0(%rbp)
leaq -0x40(%rbp), %rdi
movq %rdi, -0xa8(%rbp)
callq 0x61a0
movq -0xb0(%rbp), %rdi
movq -0xa8(%rbp), %rsi
callq 0x17750
movb %al, -0x99(%rbp)
jmp 0x17e7e
movb -0x99(%rbp), %al
xorb $-0x1, %al
movb %al, -0xb9(%rbp)
leaq -0x40(%rbp), %rdi
callq 0x6280
movb -0xb9(%rbp), %al
testb $0x1, %al
jne 0x17ea1
jmp 0x17ec4
movb $0x0, -0x1(%rbp)
jmp 0x18034
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x48(%rbp)
movl %eax, -0x4c(%rbp)
leaq -0x40(%rbp), %rdi
callq 0x6280
jmp 0x18042
jmp 0x17ec6
movq -0xb0(%rbp), %rdi
callq 0x16800
testb $0x1, %al
jne 0x17ed8
jmp 0x17ee8
movq -0x18(%rbp), %rdi
movl $0xa, %esi
callq 0x6290
jmp 0x17ec6
movq -0xb0(%rbp), %rdi
callq 0x17cb0
movl %eax, -0x50(%rbp)
movl $0x7fffffff, -0x54(%rbp) # imm = 0x7FFFFFFF
movl -0x54(%rbp), %eax
cmpl -0x50(%rbp), %eax
jl 0x18030
leaq -0x78(%rbp), %rdi
movq %rdi, -0xc8(%rbp)
callq 0x65a0
movq -0xb0(%rbp), %rdi
movq -0xc8(%rbp), %rsi
callq 0x17640
jmp 0x17f2f
movslq -0x50(%rbp), %rax
movq %rax, -0xd0(%rbp)
leaq -0x78(%rbp), %rdi
movq %rdi, -0xd8(%rbp)
callq 0x62c0
movq -0xd8(%rbp), %rsi
movq -0xd0(%rbp), %rdx
movq %rax, %rcx
movslq -0x50(%rbp), %rax
subq %rax, %rcx
leaq -0x98(%rbp), %rdi
callq 0x6440
jmp 0x17f70
movq -0x18(%rbp), %rdi
leaq -0x98(%rbp), %rsi
callq 0x6560
jmp 0x17f82
leaq -0x98(%rbp), %rdi
callq 0x6280
movq -0x18(%rbp), %rdi
movl $0xa, %esi
callq 0x6290
jmp 0x17f9e
jmp 0x17fa0
movq -0xb0(%rbp), %rdi
callq 0x16800
movb %al, -0xd9(%rbp)
jmp 0x17fb4
movb -0xd9(%rbp), %al
testb $0x1, %al
jne 0x17fc0
jmp 0x17ffa
movq -0x18(%rbp), %rdi
movl $0xa, %esi
callq 0x6290
jmp 0x17fd0
jmp 0x17fa0
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x48(%rbp)
movl %eax, -0x4c(%rbp)
jmp 0x18025
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x48(%rbp)
movl %eax, -0x4c(%rbp)
leaq -0x98(%rbp), %rdi
callq 0x6280
jmp 0x18025
movq -0xb0(%rbp), %rdi
callq 0x17cb0
movl %eax, -0xe0(%rbp)
jmp 0x1800e
movl -0xe0(%rbp), %eax
movl %eax, -0x54(%rbp)
leaq -0x78(%rbp), %rdi
callq 0x6280
jmp 0x17efe
leaq -0x78(%rbp), %rdi
callq 0x6280
jmp 0x18042
movb $0x1, -0x1(%rbp)
movb -0x1(%rbp), %al
andb $0x1, %al
addq $0xe0, %rsp
popq %rbp
retq
movq -0x48(%rbp), %rdi
callq 0x6700
nopl (%rax,%rax)
// File: 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
movq %rsp, %rbp
subq $0xb0, %rsp
movq %rdi, -0x10(%rbp)
movq -0x10(%rbp), %rdx
movq %rdx, -0x88(%rbp)
movq 0x8(%rdx), %rdi
movq %rdx, %rsi
addq $0x30, %rsi
addq $0x34, %rdx
callq 0x17610
movq -0x88(%rbp), %rax
movq 0x8(%rax), %rax
movq %rax, -0x80(%rbp)
leaq -0x31(%rbp), %rdi
movq %rdi, -0x78(%rbp)
callq 0x6710
movq -0x78(%rbp), %rdx
leaq 0x529a(%rip), %rsi      # 0x1d61f
leaq -0x30(%rbp), %rdi
callq 0x7940
jmp 0x18390
movq -0x80(%rbp), %rdi
leaq -0x30(%rbp), %rsi
callq 0x17750
movb %al, -0x89(%rbp)
jmp 0x183a5
movb -0x89(%rbp), %al
xorb $-0x1, %al
movb %al, -0x8a(%rbp)
leaq -0x30(%rbp), %rdi
callq 0x6280
leaq -0x31(%rbp), %rdi
callq 0x6480
movb -0x8a(%rbp), %al
testb $0x1, %al
jne 0x183d1
jmp 0x1840b
movb $0x0, -0x1(%rbp)
jmp 0x18544
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x40(%rbp)
movl %eax, -0x44(%rbp)
jmp 0x183fd
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x40(%rbp)
movl %eax, -0x44(%rbp)
leaq -0x30(%rbp), %rdi
callq 0x6280
leaq -0x31(%rbp), %rdi
callq 0x6480
jmp 0x18552
movq -0x88(%rbp), %rsi
movq 0x8(%rsi), %rdi
addq $0x88, %rsi
callq 0x16220
testb $0x1, %al
jne 0x18445
movq -0x88(%rbp), %rax
movq 0x8(%rax), %rdi
movl 0x30(%rax), %esi
movl 0x34(%rax), %edx
callq 0x16c90
movb $0x0, -0x1(%rbp)
jmp 0x18544
movq -0x88(%rbp), %rax
movq 0x8(%rax), %rax
movq %rax, -0xa0(%rbp)
leaq -0x69(%rbp), %rdi
movq %rdi, -0x98(%rbp)
callq 0x6710
movq -0x98(%rbp), %rdx
leaq 0x51b1(%rip), %rsi      # 0x1d626
leaq -0x68(%rbp), %rdi
callq 0x7940
jmp 0x18480
movq -0xa0(%rbp), %rdi
leaq -0x68(%rbp), %rsi
callq 0x17750
movb %al, -0xa1(%rbp)
jmp 0x18498
leaq -0x68(%rbp), %rdi
callq 0x6280
leaq -0x69(%rbp), %rdi
callq 0x6480
movb -0xa1(%rbp), %al
testb $0x1, %al
jne 0x184b6
jmp 0x184f7
movq -0x88(%rbp), %rdi
callq 0x18560
andb $0x1, %al
movb %al, -0x1(%rbp)
jmp 0x18544
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x40(%rbp)
movl %eax, -0x44(%rbp)
jmp 0x184ec
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x40(%rbp)
movl %eax, -0x44(%rbp)
leaq -0x68(%rbp), %rdi
callq 0x6280
leaq -0x69(%rbp), %rdi
callq 0x6480
jmp 0x18552
movq -0x88(%rbp), %rdi
addq $0x88, %rdi
leaq 0x511d(%rip), %rsi      # 0x1d629
callq 0x8380
testb $0x1, %al
jne 0x18517
jmp 0x1852a
movq -0x88(%rbp), %rdi
callq 0x186f0
andb $0x1, %al
movb %al, -0x1(%rbp)
jmp 0x18544
movq -0x88(%rbp), %rax
movq 0x8(%rax), %rdi
movl 0x30(%rax), %esi
movl 0x34(%rax), %edx
callq 0x16c90
movb $0x0, -0x1(%rbp)
movb -0x1(%rbp), %al
andb $0x1, %al
addq $0xb0, %rsp
popq %rbp
retq
movq -0x40(%rbp), %rdi
callq 0x6700
nopl (%rax,%rax)
// File: 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
movq %rsp, %rbp
subq $0x50, %rsp
movq %rdi, -0x10(%rbp)
movq -0x10(%rbp), %rsi
movq %rsi, -0x48(%rbp)
movq 0x8(%rsi), %rdi
addq $0xa8, %rsi
callq 0x16600
testb $0x1, %al
jne 0x185a4
movq -0x48(%rbp), %rax
movq 0x8(%rax), %rdi
movl 0x30(%rax), %esi
movl 0x34(%rax), %edx
callq 0x16c90
movb $0x0, -0x1(%rbp)
jmp 0x186cd
movq -0x48(%rbp), %rdi
addq $0x88, %rdi
callq 0x62e0
movsbl (%rax), %eax
cmpl $0x2f, %eax
je 0x1867a
movq -0x48(%rbp), %rdi
addq $0x88, %rdi
movl $0x2f, %esi
callq 0x6290
jmp 0x185d7
jmp 0x1867a
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x18(%rbp)
movl %eax, -0x1c(%rbp)
movq -0x18(%rbp), %rdi
callq 0x6180
movq -0x48(%rbp), %rax
movq 0x10(%rax), %rdx
addq $0xa0, %rdx
leaq 0x5027(%rip), %rsi      # 0x1d62e
leaq -0x40(%rbp), %rdi
callq 0x7c20
jmp 0x18612
movq -0x48(%rbp), %rdi
addq $0x60, %rdi
leaq -0x40(%rbp), %rsi
movq %rsi, -0x50(%rbp)
callq 0x6520
movq -0x50(%rbp), %rdi
callq 0x6280
movq -0x48(%rbp), %rdx
movl $0x1, 0x80(%rdx)
movq 0x8(%rdx), %rdi
movq %rdx, %rsi
addq $0x38, %rsi
addq $0x3c, %rdx
callq 0x17610
jmp 0x18654
movl $0x8, %edi
callq 0x6200
movq %rax, %rdi
movq -0x48(%rbp), %rax
movq %rax, (%rdi)
leaq 0x103a1(%rip), %rsi     # 0x28a10
xorl %eax, %eax
movl %eax, %edx
callq 0x66d0
jmp 0x186e9
movq -0x48(%rbp), %rdx
movq 0x10(%rdx), %rdi
movq %rdx, %rsi
addq $0xa8, %rsi
addq $0x88, %rdx
callq 0xe580
jmp 0x1869a
jmp 0x186b1
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x18(%rbp)
movl %eax, -0x1c(%rbp)
callq 0x6690
jmp 0x186af
jmp 0x186d8
movq -0x48(%rbp), %rdx
movq 0x8(%rdx), %rdi
movq %rdx, %rsi
addq $0x38, %rsi
addq $0x3c, %rdx
callq 0x17610
movb $0x1, -0x1(%rbp)
movb -0x1(%rbp), %al
andb $0x1, %al
addq $0x50, %rsp
popq %rbp
retq
movq -0x18(%rbp), %rdi
callq 0x6700
movq %rax, %rdi
callq 0x7f90
nopl (%rax)
// File: ryuichiueda[P]GlueLang/src/Import.cc
// Function: Import::parsePATH()
bool Import::parsePATH(void)
{
	char *str = getenv("PATH");

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

	string nokey("");

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

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

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0xf0, %rsp
movq %rdi, -0x10(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0xd0(%rbp)
leaq 0x4f18(%rip), %rdi      # 0x1d629
callq 0x6500
movq %rax, -0x18(%rbp)
cmpq $0x0, -0x18(%rbp)
jne 0x18740
movq -0xd0(%rbp), %rax
movq 0x8(%rax), %rdi
movl 0x30(%rax), %esi
movl 0x34(%rax), %edx
callq 0x16c90
movb $0x0, -0x1(%rbp)
jmp 0x1894d
leaq -0x39(%rbp), %rdi
movq %rdi, -0xd8(%rbp)
callq 0x6710
movq -0xd8(%rbp), %rdx
leaq 0x508d(%rip), %rsi      # 0x1d7eb
leaq -0x38(%rbp), %rdi
callq 0x7940
jmp 0x18769
leaq -0x39(%rbp), %rdi
callq 0x6480
movq -0x18(%rbp), %rdi
leaq 0x4cda(%rip), %rsi      # 0x1d457
callq 0x6650
movq %rax, -0x58(%rbp)
cmpq $0x0, -0x58(%rbp)
je 0x1890a
movq -0x58(%rbp), %rax
movq %rax, -0xe8(%rbp)
leaq -0x99(%rbp), %rdi
movq %rdi, -0xe0(%rbp)
callq 0x6710
movq -0xe8(%rbp), %rsi
movq -0xe0(%rbp), %rdx
leaq -0x98(%rbp), %rdi
callq 0x7940
jmp 0x187cb
leaq -0xc1(%rbp), %rdi
movq %rdi, -0xf0(%rbp)
callq 0x6710
movq -0xf0(%rbp), %rdx
leaq 0x4dce(%rip), %rsi      # 0x1d5ba
leaq -0xc0(%rbp), %rdi
callq 0x7940
jmp 0x187fa
leaq -0x78(%rbp), %rdi
leaq -0x98(%rbp), %rsi
leaq -0xc0(%rbp), %rdx
callq 0x8f90
jmp 0x18813
leaq -0xc0(%rbp), %rdi
callq 0x6280
leaq -0xc1(%rbp), %rdi
callq 0x6480
leaq -0x98(%rbp), %rdi
callq 0x6280
leaq -0x99(%rbp), %rdi
callq 0x6480
movq -0xd0(%rbp), %rax
movq 0x10(%rax), %rdi
leaq -0x38(%rbp), %rsi
leaq -0x78(%rbp), %rdx
callq 0xe580
jmp 0x1885d
xorl %eax, %eax
movl %eax, %edi
leaq 0x4bef(%rip), %rsi      # 0x1d457
callq 0x6650
movq %rax, -0x58(%rbp)
leaq -0x78(%rbp), %rdi
callq 0x6280
jmp 0x18786
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x48(%rbp)
movl %eax, -0x4c(%rbp)
leaq -0x39(%rbp), %rdi
callq 0x6480
jmp 0x1895b
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x48(%rbp)
movl %eax, -0x4c(%rbp)
jmp 0x188e5
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x48(%rbp)
movl %eax, -0x4c(%rbp)
jmp 0x188cd
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x48(%rbp)
movl %eax, -0x4c(%rbp)
leaq -0xc0(%rbp), %rdi
callq 0x6280
leaq -0xc1(%rbp), %rdi
callq 0x6480
leaq -0x98(%rbp), %rdi
callq 0x6280
leaq -0x99(%rbp), %rdi
callq 0x6480
jmp 0x18942
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x48(%rbp)
movl %eax, -0x4c(%rbp)
leaq -0x78(%rbp), %rdi
callq 0x6280
jmp 0x18942
movq -0xd0(%rbp), %rdx
movq 0x8(%rdx), %rdi
movq %rdx, %rsi
addq $0x38, %rsi
addq $0x3c, %rdx
callq 0x17610
jmp 0x18927
movb $0x1, -0x1(%rbp)
leaq -0x38(%rbp), %rdi
callq 0x6280
jmp 0x1894d
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x48(%rbp)
movl %eax, -0x4c(%rbp)
leaq -0x38(%rbp), %rdi
callq 0x6280
jmp 0x1895b
movb -0x1(%rbp), %al
andb $0x1, %al
addq $0xf0, %rsp
popq %rbp
retq
movq -0x48(%rbp), %rdi
callq 0x6700
nopw %cs:(%rax,%rax)
nop
// File: 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 %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq %rcx, -0x20(%rbp)
movl $0x0, -0x24(%rbp)
movq -0x8(%rbp), %rax
movslq -0x24(%rbp), %rcx
cmpq $0x0, (%rax,%rcx,8)
je 0x18a29
movl -0x24(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x24(%rbp)
jmp 0x18a0f
movq -0x8(%rbp), %rax
movq (%rax), %rdi
leaq 0x4c17(%rip), %rsi      # 0x1d64e
movl $0x4, %edx
callq 0x61f0
cmpl $0x0, %eax
jne 0x18a59
movl -0x24(%rbp), %edi
movq -0x8(%rbp), %rsi
callq 0x18b00
movl %eax, %edi
callq 0x64f0
movq -0x8(%rbp), %rax
movq (%rax), %rdi
leaq 0x4bed(%rip), %rsi      # 0x1d654
movl $0x3, %edx
callq 0x61f0
cmpl $0x0, %eax
jne 0x18a89
movl -0x24(%rbp), %edi
movq -0x10(%rbp), %rsi
callq 0x18b90
movl %eax, %edi
callq 0x64f0
movq -0x8(%rbp), %rax
movq (%rax), %rdi
leaq 0x4bbc(%rip), %rsi      # 0x1d653
movl $0x4, %edx
callq 0x61f0
cmpl $0x0, %eax
jne 0x18ab9
movl -0x24(%rbp), %edi
movq -0x10(%rbp), %rsi
callq 0x18bd0
movl %eax, %edi
callq 0x64f0
movq -0x8(%rbp), %rax
movq (%rax), %rdi
leaq 0x4b91(%rip), %rsi      # 0x1d658
movl $0x5, %edx
callq 0x61f0
cmpl $0x0, %eax
jne 0x18ae6
movq -0x10(%rbp), %rdi
callq 0x18c10
movl %eax, %edi
callq 0x64f0
jmp 0x18ae8
jmp 0x18aea
jmp 0x18aec
movl $0xffffffff, %eax       # imm = 0xFFFFFFFF
addq $0x30, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: 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
movq %rsp, %rbp
subq $0x20, %rsp
movl %edi, -0x4(%rbp)
movq %rsi, -0x10(%rbp)
movl $0x1, -0x14(%rbp)
movl -0x14(%rbp), %eax
movl -0x4(%rbp), %ecx
subl $0x1, %ecx
cmpl %ecx, %eax
jge 0x18b55
movq -0x10(%rbp), %rax
movslq -0x14(%rbp), %rcx
movq (%rax,%rcx,8), %rsi
movq 0x10482(%rip), %rdi     # 0x28fb8
callq 0x6410
movq %rax, %rdi
leaq 0x4cd9(%rip), %rsi      # 0x1d81e
callq 0x6410
movl -0x14(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x14(%rbp)
jmp 0x18b16
cmpl $0x1, -0x4(%rbp)
jle 0x18b87
movq -0x10(%rbp), %rax
movl -0x4(%rbp), %ecx
subl $0x1, %ecx
movslq %ecx, %rcx
movq (%rax,%rcx,8), %rsi
movq 0x10445(%rip), %rdi     # 0x28fb8
callq 0x6410
movq %rax, %rdi
movq 0x10426(%rip), %rsi     # 0x28fa8
callq 0x6460
xorl %eax, %eax
addq $0x20, %rsp
popq %rbp
retq
nop
// File: 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 %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq %rcx, -0x20(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x28(%rbp)
movq -0x10(%rbp), %rsi
movq -0x18(%rbp), %rdx
movq -0x20(%rbp), %rcx
callq 0xb6c0
movq -0x28(%rbp), %rdi
leaq 0xfdb4(%rip), %rax      # 0x28a30
addq $0x10, %rax
movq %rax, (%rdi)
addq $0x98, %rdi
callq 0x65a0
movq -0x28(%rbp), %rax
movq $0x0, 0xc0(%rax)
movq $0x0, 0xc8(%rax)
movq $0x0, 0x88(%rax)
movb $0x0, 0xb8(%rax)
movq $0x0, 0x90(%rax)
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax)
// File: 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 %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x28(%rbp)
cmpq $0x0, 0xc0(%rax)
je 0x19765
movq -0x28(%rbp), %rax
movq 0xc0(%rax), %rax
movq %rax, -0x18(%rbp)
movq -0x28(%rbp), %rax
cmpq $0x0, 0xc8(%rax)
je 0x19782
movq -0x28(%rbp), %rax
movq 0xc8(%rax), %rax
movq %rax, -0x20(%rbp)
movq 0xf82f(%rip), %rdi      # 0x28fb8
movq 0xf830(%rip), %rsi      # 0x28fc0
callq 0x6460
movq -0x28(%rbp), %rdi
movq (%rdi), %rax
callq *0x10(%rax)
movq -0x28(%rbp), %rax
cmpq $0x0, 0x88(%rax)
je 0x197df
movq -0x28(%rbp), %rax
movq 0x88(%rax), %rdi
movq -0x18(%rbp), %rsi
movq -0x20(%rbp), %rdx
movq (%rdi), %rax
callq *0x18(%rax)
movq -0x28(%rbp), %rax
movq 0x88(%rax), %rcx
movq 0x88(%rcx), %rcx
movq %rcx, 0x90(%rax)
movq -0x28(%rbp), %rax
testb $0x1, 0xb8(%rax)
je 0x19802
movq -0x28(%rbp), %rdi
movq -0x18(%rbp), %rsi
movq -0x20(%rbp), %rdx
callq 0x19820
movl %eax, -0x4(%rbp)
jmp 0x19816
movq -0x28(%rbp), %rdi
movq -0x18(%rbp), %rsi
movq -0x20(%rbp), %rdx
callq 0x19a10
movl %eax, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x30, %rsp
popq %rbp
retq
nop
// File: 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
movq %rsp, %rbp
subq $0x60, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x48(%rbp)
callq 0x6110
movl %eax, -0x1c(%rbp)
cmpl $0x0, -0x1c(%rbp)
jge 0x19854
movl $0x4, %edi
callq 0x64f0
cmpl $0x0, -0x1c(%rbp)
jne 0x19946
movq -0x48(%rbp), %rax
movq 0x10(%rax), %rax
testb $0x1, 0xe0(%rax)
je 0x198c9
movq 0xf772(%rip), %rdi      # 0x28fe8
leaq 0x39f6(%rip), %rsi      # 0x1d273
callq 0x6410
movq %rax, %rdi
movq -0x48(%rbp), %rax
movq 0x10(%rax), %rax
movl 0xe4(%rax), %esi
callq 0x66f0
movq %rax, %rdi
leaq 0x3cb2(%rip), %rsi      # 0x1d554
callq 0x6410
movq -0x48(%rbp), %rsi
movq %rax, %rdi
addq $0x98, %rsi
callq 0x63a0
movq %rax, %rdi
movq 0xf6e4(%rip), %rsi      # 0x28fa8
callq 0x6460
movl $0x0, -0x20(%rbp)
movq -0x48(%rbp), %rdi
movl -0x20(%rbp), %eax
movl %eax, -0x4c(%rbp)
addq $0x18, %rdi
callq 0xd900
movq %rax, %rcx
movl -0x4c(%rbp), %eax
cmpl %ecx, %eax
jge 0x1993f
movq -0x48(%rbp), %rdi
addq $0x18, %rdi
movslq -0x20(%rbp), %rsi
callq 0x14640
movq (%rax), %rax
movq %rax, -0x28(%rbp)
cmpq $0x0, -0x10(%rbp)
je 0x19922
cmpl $0x0, -0x20(%rbp)
je 0x19922
movq -0x10(%rbp), %rax
movq 0x88(%rax), %rdi
callq 0x94e0
movq -0x28(%rbp), %rdi
movq -0x10(%rbp), %rsi
movq -0x18(%rbp), %rdx
movq (%rdi), %rax
callq *0x18(%rax)
movl -0x20(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x20(%rbp)
jmp 0x198d0
xorl %edi, %edi
callq 0x64f0
movq -0x48(%rbp), %rdx
movq 0x10(%rdx), %rdi
movq %rdx, %rsi
addq $0x48, %rsi
addq $0x98, %rdx
callq 0xec10
movq %rax, -0x58(%rbp)
jmp 0x19967
movq -0x58(%rbp), %rax
movq %rax, -0x30(%rbp)
movl -0x1c(%rbp), %ecx
movq -0x30(%rbp), %rax
movl %ecx, 0x48(%rax)
jmp 0x199ef
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x38(%rbp)
movl %eax, -0x3c(%rbp)
movq -0x38(%rbp), %rdi
callq 0x6180
movq -0x48(%rbp), %rdi
addq $0x60, %rdi
leaq 0x3d04(%rip), %rsi      # 0x1d6a3
callq 0x6580
jmp 0x199a6
movq -0x48(%rbp), %rax
movl $0x2, 0x80(%rax)
movl $0x8, %edi
callq 0x6200
movq %rax, %rdi
movq -0x48(%rbp), %rax
movq %rax, (%rdi)
leaq 0xf0c9(%rip), %rsi      # 0x28a98
xorl %eax, %eax
movl %eax, %edx
callq 0x66d0
jmp 0x19a08
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x38(%rbp)
movl %eax, -0x3c(%rbp)
callq 0x6690
jmp 0x199ed
jmp 0x199f7
xorl %eax, %eax
addq $0x60, %rsp
popq %rbp
retq
movq -0x38(%rbp), %rdi
callq 0x6700
movq %rax, %rdi
callq 0x7f90
nopl (%rax,%rax)
// File: ryuichiueda[P]GlueLang/src/Job.cc
// Function: Job::execNormal(DefFile*, DefStr*)
int Job::execNormal(DefFile *f,  DefStr *s)
{
	bool skip = false; // flag to skip the next command
	bool stop_next = false; // stop after then
	for(int i=0;i<(int)m_nodes.size();i++){
		if(skip and not stop_next){
			skip = false;
			continue;
		}

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

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

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

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x40(%rbp)
movb $0x0, -0x21(%rbp)
movb $0x0, -0x22(%rbp)
movl $0x0, -0x28(%rbp)
movq -0x40(%rbp), %rdi
movl -0x28(%rbp), %eax
movl %eax, -0x44(%rbp)
addq $0x18, %rdi
callq 0xd900
movq %rax, %rcx
movl -0x44(%rbp), %eax
cmpl %ecx, %eax
jge 0x19b58
testb $0x1, -0x21(%rbp)
je 0x19a71
testb $0x1, -0x22(%rbp)
jne 0x19a71
movb $0x0, -0x21(%rbp)
jmp 0x19b4a
cmpq $0x0, -0x18(%rbp)
je 0x19a8e
cmpl $0x0, -0x28(%rbp)
je 0x19a8e
movq -0x18(%rbp), %rax
movq 0x88(%rax), %rdi
callq 0x94e0
movq -0x40(%rbp), %rdi
addq $0x18, %rdi
movslq -0x28(%rbp), %rsi
callq 0x14640
movq (%rax), %rax
movq %rax, -0x30(%rbp)
movq -0x30(%rbp), %rdi
movq -0x18(%rbp), %rsi
movq -0x20(%rbp), %rdx
movq (%rdi), %rax
callq *0x18(%rax)
movl %eax, -0x34(%rbp)
testb $0x1, -0x22(%rbp)
je 0x19acc
movl -0x34(%rbp), %eax
movl %eax, -0x4(%rbp)
jmp 0x19b5f
movq -0x30(%rbp), %rcx
xorl %eax, %eax
testb $0x1, 0x86(%rcx)
movb %al, -0x45(%rbp)
je 0x19ae8
cmpl $0x0, -0x34(%rbp)
sete %al
movb %al, -0x45(%rbp)
movb -0x45(%rbp), %al
andb $0x1, %al
movb %al, -0x22(%rbp)
movq -0x30(%rbp), %rax
testb $0x1, 0x86(%rax)
je 0x19b08
movb $0x1, %al
cmpl $0x0, -0x34(%rbp)
movb %al, -0x46(%rbp)
jne 0x19b42
movq -0x30(%rbp), %rax
testb $0x1, 0x85(%rax)
je 0x19b20
movb $0x1, %al
cmpl $0x0, -0x34(%rbp)
movb %al, -0x46(%rbp)
jne 0x19b42
movq -0x30(%rbp), %rcx
xorl %eax, %eax
testb $0x1, 0x87(%rcx)
movb %al, -0x47(%rbp)
je 0x19b3c
cmpl $0x0, -0x34(%rbp)
sete %al
movb %al, -0x47(%rbp)
movb -0x47(%rbp), %al
movb %al, -0x46(%rbp)
movb -0x46(%rbp), %al
andb $0x1, %al
movb %al, -0x21(%rbp)
movl -0x28(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x28(%rbp)
jmp 0x19a3b
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x50, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: 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
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x10(%rbp)
movq -0x10(%rbp), %rdx
movq %rdx, -0x38(%rbp)
movq 0x8(%rdx), %rdi
movq %rdx, %rsi
addq $0x30, %rsi
addq $0x34, %rdx
callq 0x17610
movq -0x38(%rbp), %rsi
movq 0x8(%rsi), %rdi
addq $0x88, %rsi
callq 0x16f20
movb %al, -0x29(%rbp)
jmp 0x19d41
movb -0x29(%rbp), %al
testb $0x1, %al
jne 0x19d4d
jmp 0x19dfe
movq -0x38(%rbp), %rdx
movq 0x8(%rdx), %rdi
movq %rdx, %rsi
addq $0x38, %rsi
addq $0x3c, %rdx
callq 0x17610
jmp 0x19d67
movb $0x1, -0x1(%rbp)
jmp 0x19e17
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x18(%rbp)
movl %eax, -0x1c(%rbp)
movl -0x1c(%rbp), %eax
movl $0x1, %ecx
cmpl %ecx, %eax
jne 0x19e22
movq -0x18(%rbp), %rdi
callq 0x6180
movq -0x38(%rbp), %rdx
movq %rax, -0x28(%rbp)
movq 0x8(%rdx), %rdi
movq %rdx, %rsi
addq $0x38, %rsi
addq $0x3c, %rdx
callq 0x17610
jmp 0x19db3
movq -0x38(%rbp), %rdi
movq -0x28(%rbp), %rsi
addq $0x28, %rsi
addq $0x60, %rdi
callq 0x6070
jmp 0x19dca
movq -0x38(%rbp), %rax
movl $0x1, 0x80(%rax)
movl $0x8, %edi
callq 0x6200
movq %rax, %rdi
movq -0x38(%rbp), %rax
movq %rax, (%rdi)
leaq 0xed35(%rip), %rsi      # 0x28b28
xorl %eax, %eax
movl %eax, %edx
callq 0x66d0
jmp 0x19e2b
jmp 0x19e13
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x18(%rbp)
movl %eax, -0x1c(%rbp)
callq 0x6690
jmp 0x19e22
movb $0x0, -0x1(%rbp)
movb -0x1(%rbp), %al
andb $0x1, %al
addq $0x40, %rsp
popq %rbp
retq
movq -0x18(%rbp), %rdi
callq 0x6700
nopl (%rax,%rax)
// File: 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 %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x18(%rbp)
movq %rdi, %rsi
addq $0x88, %rsi
addq $0xa8, %rdi
callq 0x6070
movq -0x18(%rbp), %rdi
addq $0xa8, %rdi
leaq 0x386e(%rip), %rsi      # 0x1d6da
xorl %eax, %eax
movl %eax, %edx
callq 0x67b0
movq %rax, -0x10(%rbp)
cmpq $-0x1, -0x10(%rbp)
je 0x19ec5
movq -0x18(%rbp), %rdi
addq $0xa8, %rdi
movq -0x10(%rbp), %rsi
movl $0x2, %edx
leaq 0x3840(%rip), %rcx      # 0x1d6db
callq 0x6270
movq -0x18(%rbp), %rdi
addq $0xa8, %rdi
movq -0x10(%rbp), %rdx
addq $0x1, %rdx
leaq 0x3820(%rip), %rsi      # 0x1d6da
callq 0x67b0
movq %rax, -0x10(%rbp)
jmp 0x19e79
movb $0x1, %al
andb $0x1, %al
addq $0x20, %rsp
popq %rbp
retq
nop
// File: ryuichiueda[P]GlueLang/src/Pipeline.cc
// Function: Pipeline::Pipeline(Feeder*, Environment*, std::vector<int, std::allocator<int>>*)
Pipeline::Pipeline(Feeder *f, Environment *env,vector<int> *scopes) : Element(f,env,scopes)
{
	m_has_and = false;
	m_has_then = false;
	m_has_or = false;
	m_is_then = false;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq %rcx, -0x20(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x28(%rbp)
movq -0x10(%rbp), %rsi
movq -0x18(%rbp), %rdx
movq -0x20(%rbp), %rcx
callq 0xb6c0
movq -0x28(%rbp), %rdi
leaq 0xec3c(%rip), %rax      # 0x28b48
addq $0x10, %rax
movq %rax, (%rdi)
addq $0x90, %rdi
callq 0xbb60
movq -0x28(%rbp), %rax
movb $0x0, 0x85(%rax)
movb $0x0, 0x86(%rax)
movb $0x0, 0x87(%rax)
movb $0x0, 0x88(%rax)
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: 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 %rbp
movq %rsp, %rbp
subq $0x80, %rsp
movq %rdi, -0x10(%rbp)
movq -0x10(%rbp), %rdi
movq %rdi, -0x58(%rbp)
callq 0x1b070
movb %al, -0x4a(%rbp)
jmp 0x1aed1
movb -0x4a(%rbp), %al
andb $0x1, %al
movb %al, -0x1(%rbp)
jmp 0x1b051
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x18(%rbp)
movl %eax, -0x1c(%rbp)
movl -0x1c(%rbp), %eax
movl $0x2, %ecx
cmpl %ecx, %eax
jne 0x1af8b
movq -0x18(%rbp), %rdi
callq 0x6180
movq %rax, -0x28(%rbp)
movq -0x28(%rbp), %rax
movq %rax, -0x68(%rbp)
leaq -0x49(%rbp), %rdi
movq %rdi, -0x60(%rbp)
callq 0x6710
movq -0x60(%rbp), %rdx
leaq 0x2858(%rip), %rsi      # 0x1d77f
leaq -0x48(%rbp), %rdi
callq 0x7940
jmp 0x1af32
movq -0x68(%rbp), %rsi
movq -0x58(%rbp), %rdi
leaq -0x48(%rbp), %rdx
xorl %ecx, %ecx
callq 0x1b350
jmp 0x1af47
leaq -0x48(%rbp), %rdi
callq 0x6280
leaq -0x49(%rbp), %rdi
callq 0x6480
movq -0x58(%rbp), %rax
movq 0x10(%rax), %rdi
callq 0xee00
jmp 0x1af68
movq -0x58(%rbp), %rdi
movq -0x28(%rbp), %rax
movl 0x80(%rax), %esi
callq 0x1b2d0
jmp 0x1af7d
callq 0x6690
movb $0x1, -0x1(%rbp)
jmp 0x1b051
movq -0x18(%rbp), %rdi
callq 0x6180
movq 0xe04d(%rip), %rdi      # 0x28fe8
leaq 0x27dc(%rip), %rsi      # 0x1d77e
callq 0x6410
movq %rax, -0x70(%rbp)
jmp 0x1afad
movq -0x70(%rbp), %rdi
leaq 0x27d3(%rip), %rsi      # 0x1d78b
callq 0x6410
movq %rax, -0x78(%rbp)
jmp 0x1afc3
movq -0x78(%rbp), %rdi
movq 0xdfda(%rip), %rsi      # 0x28fa8
callq 0x6460
jmp 0x1afd5
movq -0x58(%rbp), %rax
movq 0x10(%rax), %rdi
callq 0xee00
jmp 0x1afe4
movq -0x58(%rbp), %rdi
movl $0x80, %esi
callq 0x1b2d0
jmp 0x1aff4
callq 0x6690
jmp 0x1af82
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x18(%rbp)
movl %eax, -0x1c(%rbp)
callq 0x6690
jmp 0x1b00e
jmp 0x1b05f
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x18(%rbp)
movl %eax, -0x1c(%rbp)
jmp 0x1b033
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x18(%rbp)
movl %eax, -0x1c(%rbp)
leaq -0x48(%rbp), %rdi
callq 0x6280
leaq -0x49(%rbp), %rdi
callq 0x6480
jmp 0x1b04a
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x18(%rbp)
movl %eax, -0x1c(%rbp)
callq 0x6690
jmp 0x1b05f
movb -0x1(%rbp), %al
andb $0x1, %al
addq $0x80, %rsp
popq %rbp
retq
movq -0x18(%rbp), %rdi
callq 0x6700
movq %rax, %rdi
callq 0x7f90
// File: 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 %rbp
movq %rsp, %rbp
subq $0x90, %rsp
movq %rdx, -0x58(%rbp)
movb %cl, %al
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
andb $0x1, %al
movb %al, -0x19(%rbp)
testb $0x1, -0x19(%rbp)
je 0x1b37d
jmp 0x1b491
movq -0x58(%rbp), %rsi
movq 0xdc60(%rip), %rdi      # 0x28fe8
callq 0x63a0
movq %rax, %rdi
leaq 0x244d(%rip), %rsi      # 0x1d7e4
callq 0x6410
movq %rax, -0x70(%rbp)
movq -0x10(%rbp), %rsi
leaq -0x40(%rbp), %rdi
movq %rdi, -0x68(%rbp)
callq 0xb900
movq -0x70(%rbp), %rdi
movq -0x68(%rbp), %rsi
callq 0x63a0
movq %rax, -0x60(%rbp)
jmp 0x1b3c4
movq -0x60(%rbp), %rdi
movq 0xdbd9(%rip), %rsi      # 0x28fa8
callq 0x6460
jmp 0x1b3d6
leaq -0x40(%rbp), %rdi
callq 0x6280
movq -0x10(%rbp), %rdi
callq 0xba50
movq 0xdbf9(%rip), %rdi      # 0x28fe8
leaq 0x23f3(%rip), %rsi      # 0x1d7e9
callq 0x6410
movq %rax, %rdi
movq -0x10(%rbp), %rsi
addq $0x60, %rsi
callq 0x63a0
movq %rax, %rdi
leaq 0x23d7(%rip), %rsi      # 0x1d7ec
callq 0x6410
movq %rax, -0x88(%rbp)
movq -0x10(%rbp), %rdi
callq 0xba80
movq -0x88(%rbp), %rdi
movl %eax, %esi
callq 0x66f0
movq %rax, %rdi
leaq 0x23bb(%rip), %rsi      # 0x1d7fd
callq 0x6410
movq %rax, -0x80(%rbp)
movq -0x10(%rbp), %rdi
callq 0x1b7d0
movq -0x80(%rbp), %rdi
movl %eax, %esi
callq 0x66f0
movq %rax, %rdi
leaq 0x23a3(%rip), %rsi      # 0x1d80c
callq 0x6410
movq %rax, -0x78(%rbp)
callq 0x6600
movq -0x78(%rbp), %rdi
movl %eax, %esi
callq 0x66f0
movq %rax, %rdi
movq 0xdb1c(%rip), %rsi      # 0x28fa8
callq 0x6460
addq $0x90, %rsp
popq %rbp
retq
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x48(%rbp)
movl %eax, -0x4c(%rbp)
leaq -0x40(%rbp), %rdi
callq 0x6280
movq -0x48(%rbp), %rdi
callq 0x6700
nopl (%rax,%rax)
// File: ryuichiueda[P]GlueLang/src/Where.cc
// Function: Where::exec(DefFile*, DefStr*)
int Where::exec(DefFile *f,  DefStr *s)
{
	//m_env->m_local_env[m_job_id] = m_local_env;
	for(auto n : m_nodes)
		n->exec(f,s);

	return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x8(%rbp), %rax
addq $0x18, %rax
movq %rax, -0x20(%rbp)
movq -0x20(%rbp), %rdi
callq 0xc010
movq %rax, -0x28(%rbp)
movq -0x20(%rbp), %rdi
callq 0xc040
movq %rax, -0x30(%rbp)
leaq -0x28(%rbp), %rdi
leaq -0x30(%rbp), %rsi
callq 0xc070
testb $0x1, %al
jne 0x1bbbd
jmp 0x1bbea
leaq -0x28(%rbp), %rdi
callq 0xc0b0
movq (%rax), %rax
movq %rax, -0x38(%rbp)
movq -0x38(%rbp), %rdi
movq -0x10(%rbp), %rsi
movq -0x18(%rbp), %rdx
movq (%rdi), %rax
callq *0x18(%rax)
leaq -0x28(%rbp), %rdi
callq 0xc0d0
jmp 0x1bbaa
xorl %eax, %eax
addq $0x40, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: 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
movq %rsp, %rbp
subq $0xa0, %rsp
movl %edi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x10(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x80(%rbp)
leaq -0x31(%rbp), %rdi
movq %rdi, -0x78(%rbp)
callq 0x6710
movq -0x80(%rbp), %rsi
movq -0x78(%rbp), %rdx
leaq -0x30(%rbp), %rdi
callq 0x7940
jmp 0x1c0ed
leaq -0x31(%rbp), %rdi
callq 0x6480
leaq -0x30(%rbp), %rdi
movq %rdi, -0x90(%rbp)
movl $0x2f, %esi
movq $-0x1, %rdx
movq %rdx, -0x88(%rbp)
callq 0x6760
movq -0x90(%rbp), %rsi
movq -0x88(%rbp), %rcx
movq %rax, %rdx
incq %rdx
leaq -0x68(%rbp), %rdi
callq 0x6440
jmp 0x1c138
leaq 0x12f5(%rip), %rsi      # 0x1d434
leaq -0x68(%rbp), %rdi
callq 0x8350
movb %al, -0x91(%rbp)
jmp 0x1c150
leaq -0x68(%rbp), %rdi
callq 0x6280
movb -0x91(%rbp), %al
andb $0x1, %al
movb %al, -0x45(%rbp)
testb $0x1, -0x45(%rbp)
je 0x1c1b9
movl $0x0, -0x4(%rbp)
movl $0x1, -0x6c(%rbp)
jmp 0x1c1f8
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x40(%rbp)
movl %eax, -0x44(%rbp)
leaq -0x31(%rbp), %rdi
callq 0x6480
jmp 0x1c216
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x40(%rbp)
movl %eax, -0x44(%rbp)
jmp 0x1c20d
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x40(%rbp)
movl %eax, -0x44(%rbp)
leaq -0x68(%rbp), %rdi
callq 0x6280
jmp 0x1c20d
movl $0x1, -0x70(%rbp)
movl -0x70(%rbp), %eax
cmpl -0x8(%rbp), %eax
jge 0x1c1eb
movq -0x10(%rbp), %rax
movslq -0x70(%rbp), %rcx
movq (%rax,%rcx,8), %rax
movsbl (%rax), %eax
cmpl $0x2d, %eax
je 0x1c1de
jmp 0x1c1eb
jmp 0x1c1e0
movl -0x70(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x70(%rbp)
jmp 0x1c1c0
movl -0x70(%rbp), %eax
movl %eax, -0x4(%rbp)
movl $0x1, -0x6c(%rbp)
leaq -0x30(%rbp), %rdi
callq 0x6280
movl -0x4(%rbp), %eax
addq $0xa0, %rsp
popq %rbp
retq
leaq -0x30(%rbp), %rdi
callq 0x6280
movq -0x40(%rbp), %rdi
callq 0x6700
nop
// File: 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
movq %rsp, %rbp
subq $0xd0, %rsp
movl %edi, -0x4(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
leaq -0xc0(%rbp), %rdi
leaq 0xcaac(%rip), %rsi      # 0x28cf0
movl $0xa0, %edx
callq 0x6350
movl $0x0, -0xc4(%rbp)
movl $0x0, -0xc8(%rbp)
movl -0x4(%rbp), %edi
movq -0x10(%rbp), %rsi
leaq -0xc0(%rbp), %rcx
leaq 0x16c8(%rip), %rdx      # 0x1d93f
leaq -0xc8(%rbp), %r8
callq 0x66b0
movl %eax, -0xc4(%rbp)
cmpl $-0x1, %eax
je 0x1c2d2
movl -0xc4(%rbp), %eax
movl %eax, -0xcc(%rbp)
subl $0x68, %eax
je 0x1c2c0
jmp 0x1c2a1
movl -0xcc(%rbp), %eax
subl $0x75, %eax
je 0x1c2bb
jmp 0x1c2ae
movl -0xcc(%rbp), %eax
subl $0x76, %eax
je 0x1c2c5
jmp 0x1c2d0
callq 0x1c020
callq 0x1c2e0
movq -0x18(%rbp), %rax
movb $0x1, 0xe0(%rax)
jmp 0x1c262
movb $0x1, %al
andb $0x1, %al
addq $0xd0, %rsp
popq %rbp
retq
nop
// File: 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 %rbp
movq %rsp, %rbp
movq 0xccfd(%rip), %rdi      # 0x28fe8
leaq 0x1592(%rip), %rsi      # 0x1d884
callq 0x6410
movq %rax, %rdi
leaq 0x159d(%rip), %rsi      # 0x1d89e
callq 0x6410
movq %rax, %rdi
leaq 0x15af(%rip), %rsi      # 0x1d8bf
callq 0x6410
movq %rax, %rdi
leaq 0x15c1(%rip), %rsi      # 0x1d8e0
callq 0x6410
movq %rax, %rdi
movq 0xcc7a(%rip), %rsi      # 0x28fa8
callq 0x6460
movl $0x1, %edi
callq 0x64f0
// File: thierry7100[P]CutOptim/main.cpp
// Function: ConvertPos(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>)
static int ConvertPos(string Pos)
{
int rPos = 0;

    if ( Pos.length() < 2 ) return(TopLeft);
    if ( Pos[0] == 'T' || Pos[0] == 't')
    {
        rPos = 0;
    }
    else if ( Pos[0] == 'C' || Pos[0] == 'c' )
    {
        rPos = 4;
    }
    else if ( Pos[0] == 'B' || Pos[0] == 'b')
    {
        rPos = 8;
    }
    else
    {
        return TopLeft;         //  Top left if unknown
    }
    if ( Pos[1] == 'L' || Pos[1] == 'l')
    {
        rPos += 0;
    }
    else if ( Pos[1] == 'C' || Pos[1] == 'c' )
    {
        rPos += 1;
    }
    else if ( Pos[1] == 'R' || Pos[1] == 'r' )
    {
        rPos += 2;
    }
    else
    {
        return TopLeft;         //  Top left if unknown
    }
    return rPos;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x20(%rbp)
movq %rdi, -0x10(%rbp)
movl $0x0, -0x14(%rbp)
callq 0x9800
cmpq $0x2, %rax
jae 0xf37e
movl $0x0, -0x4(%rbp)
jmp 0xf4df
movq -0x20(%rbp), %rdi
xorl %eax, %eax
movl %eax, %esi
callq 0x9a70
movsbl (%rax), %eax
cmpl $0x54, %eax
je 0xf3a8
movq -0x20(%rbp), %rdi
xorl %eax, %eax
movl %eax, %esi
callq 0x9a70
movsbl (%rax), %eax
cmpl $0x74, %eax
jne 0xf3b1
movl $0x0, -0x14(%rbp)
jmp 0xf427
movq -0x20(%rbp), %rdi
xorl %eax, %eax
movl %eax, %esi
callq 0x9a70
movsbl (%rax), %eax
cmpl $0x43, %eax
je 0xf3db
movq -0x20(%rbp), %rdi
xorl %eax, %eax
movl %eax, %esi
callq 0x9a70
movsbl (%rax), %eax
cmpl $0x63, %eax
jne 0xf3e4
movl $0x4, -0x14(%rbp)
jmp 0xf425
movq -0x20(%rbp), %rdi
xorl %eax, %eax
movl %eax, %esi
callq 0x9a70
movsbl (%rax), %eax
cmpl $0x42, %eax
je 0xf40e
movq -0x20(%rbp), %rdi
xorl %eax, %eax
movl %eax, %esi
callq 0x9a70
movsbl (%rax), %eax
cmpl $0x62, %eax
jne 0xf417
movl $0x8, -0x14(%rbp)
jmp 0xf423
movl $0x0, -0x4(%rbp)
jmp 0xf4df
jmp 0xf425
jmp 0xf427
movq -0x20(%rbp), %rdi
movl $0x1, %esi
callq 0x9a70
movsbl (%rax), %eax
cmpl $0x4c, %eax
je 0xf453
movq -0x20(%rbp), %rdi
movl $0x1, %esi
callq 0x9a70
movsbl (%rax), %eax
cmpl $0x6c, %eax
jne 0xf45e
movl -0x14(%rbp), %eax
addl $0x0, %eax
movl %eax, -0x14(%rbp)
jmp 0xf4d9
movq -0x20(%rbp), %rdi
movl $0x1, %esi
callq 0x9a70
movsbl (%rax), %eax
cmpl $0x43, %eax
je 0xf48a
movq -0x20(%rbp), %rdi
movl $0x1, %esi
callq 0x9a70
movsbl (%rax), %eax
cmpl $0x63, %eax
jne 0xf495
movl -0x14(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x14(%rbp)
jmp 0xf4d7
movq -0x20(%rbp), %rdi
movl $0x1, %esi
callq 0x9a70
movsbl (%rax), %eax
cmpl $0x52, %eax
je 0xf4c1
movq -0x20(%rbp), %rdi
movl $0x1, %esi
callq 0x9a70
movsbl (%rax), %eax
cmpl $0x72, %eax
jne 0xf4cc
movl -0x14(%rbp), %eax
addl $0x2, %eax
movl %eax, -0x14(%rbp)
jmp 0xf4d5
movl $0x0, -0x4(%rbp)
jmp 0xf4df
jmp 0xf4d7
jmp 0xf4d9
movl -0x14(%rbp), %eax
movl %eax, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: 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 %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x10(%rbp), %rdi
movq %rdi, -0x38(%rbp)
callq 0x1c780
movq %rax, %rdi
movq -0x18(%rbp), %rsi
callq 0x23290
movq -0x38(%rbp), %rdi
movq %rax, -0x20(%rbp)
callq 0x1c780
movq %rax, %rdi
callq 0x232f0
movq %rax, -0x28(%rbp)
leaq -0x20(%rbp), %rdi
leaq -0x28(%rbp), %rsi
callq 0x232c0
testb $0x1, %al
jne 0x10ad5
jmp 0x10adf
movq $0x0, -0x8(%rbp)
jmp 0x10b21
movq -0x38(%rbp), %rax
addq $0x68, %rax
movq %rax, -0x40(%rbp)
leaq -0x20(%rbp), %rdi
callq 0x234a0
movq -0x40(%rbp), %rdi
movq %rax, %rsi
addq $0x20, %rsi
callq 0x26b80
movq %rax, -0x30(%rbp)
leaq -0x30(%rbp), %rdi
callq 0x26bb0
movq %rax, %rdi
addq $0x10, %rdi
callq 0x23bb0
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x40, %rsp
popq %rbp
retq
nopl (%rax,%rax)