LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: devanshdalal[P]cloud-computing-concepts-part-2/MP2Node.cpp
// Function: MP2Node::~MP2Node()
MP2Node::~MP2Node()
{
	delete ht;
	delete secondary;
	delete tertiary;
	delete memberNode;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x18(%rbp)
movq 0x48(%rax), %rax
movq %rax, -0x10(%rbp)
cmpq $0x0, %rax
je 0x1c12c
movq -0x10(%rbp), %rdi
movq (%rdi), %rax
callq *0x8(%rax)
movq -0x18(%rbp), %rax
movq 0x50(%rax), %rax
movq %rax, -0x20(%rbp)
cmpq $0x0, %rax
je 0x1c148
movq -0x20(%rbp), %rdi
movq (%rdi), %rax
callq *0x8(%rax)
movq -0x18(%rbp), %rax
movq 0x58(%rax), %rax
movq %rax, -0x28(%rbp)
cmpq $0x0, %rax
je 0x1c164
movq -0x28(%rbp), %rdi
movq (%rdi), %rax
callq *0x8(%rax)
movq -0x18(%rbp), %rax
movq 0x60(%rax), %rax
movq %rax, -0x30(%rbp)
cmpq $0x0, %rax
je 0x1c180
movq -0x30(%rbp), %rdi
movq (%rdi), %rax
callq *0x8(%rax)
movq -0x18(%rbp), %rdi
addq $0x80, %rdi
callq 0x20ec0
movq -0x18(%rbp), %rdi
addq $0x30, %rdi
callq 0x12c30
movq -0x18(%rbp), %rdi
addq $0x18, %rdi
callq 0x12c30
movq -0x18(%rbp), %rdi
callq 0x12c30
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax)
// File: devanshdalal[P]cloud-computing-concepts-part-2/MP2Node.cpp
// Function: MP2Node::readKey(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>)
string MP2Node::readKey(string key)
{
	/*
	 * Implement this
	 */
	// Read key from local hash table and return value
	if (ht->count(key))
	{
		return ht->read(key);
	}
	if (secondary->count(key))
	{
		return secondary->read(key);
	}
	return tertiary->read(key);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x150, %rsp            # imm = 0x150
movq %rdx, -0x100(%rbp)
movq %rsi, %rax
movq -0x100(%rbp), %rsi
movq %rdi, -0xf8(%rbp)
movq %rdi, %rcx
movq %rcx, -0xf0(%rbp)
movq %rdi, -0x8(%rbp)
movq %rax, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0xe8(%rbp)
movq 0x48(%rax), %rax
movq %rax, -0xe0(%rbp)
leaq -0x38(%rbp), %rdi
movq %rdi, -0xd8(%rbp)
callq 0x4150
movq -0xe0(%rbp), %rdi
movq -0xd8(%rbp), %rsi
callq 0x25f00
movq %rax, -0xd0(%rbp)
jmp 0x1e9eb
leaq -0x38(%rbp), %rdi
callq 0x41e0
movq -0xd0(%rbp), %rax
cmpq $0x0, %rax
je 0x1ea8c
movq -0x100(%rbp), %rsi
movq -0xe8(%rbp), %rax
movq 0x48(%rax), %rax
movq %rax, -0x110(%rbp)
leaq -0x68(%rbp), %rdi
movq %rdi, -0x108(%rbp)
callq 0x4150
movq -0xf8(%rbp), %rdi
movq -0x110(%rbp), %rsi
movq -0x108(%rbp), %rdx
callq 0x25bd0
jmp 0x1ea4a
leaq -0x68(%rbp), %rdi
callq 0x41e0
jmp 0x1ebf4
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x40(%rbp)
movl %eax, -0x44(%rbp)
leaq -0x38(%rbp), %rdi
callq 0x41e0
jmp 0x1ec04
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x40(%rbp)
movl %eax, -0x44(%rbp)
leaq -0x68(%rbp), %rdi
callq 0x41e0
jmp 0x1ec04
movq -0x100(%rbp), %rsi
movq -0xe8(%rbp), %rax
movq 0x50(%rax), %rax
movq %rax, -0x128(%rbp)
leaq -0x88(%rbp), %rdi
movq %rdi, -0x120(%rbp)
callq 0x4150
movq -0x128(%rbp), %rdi
movq -0x120(%rbp), %rsi
callq 0x25f00
movq %rax, -0x118(%rbp)
jmp 0x1ead4
leaq -0x88(%rbp), %rdi
callq 0x41e0
movq -0x118(%rbp), %rax
cmpq $0x0, %rax
je 0x1eb84
movq -0x100(%rbp), %rsi
movq -0xe8(%rbp), %rax
movq 0x50(%rax), %rax
movq %rax, -0x138(%rbp)
leaq -0xa8(%rbp), %rdi
movq %rdi, -0x130(%rbp)
callq 0x4150
movq -0xf8(%rbp), %rdi
movq -0x138(%rbp), %rsi
movq -0x130(%rbp), %rdx
callq 0x25bd0
jmp 0x1eb39
leaq -0xa8(%rbp), %rdi
callq 0x41e0
jmp 0x1ebf4
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x40(%rbp)
movl %eax, -0x44(%rbp)
leaq -0x88(%rbp), %rdi
callq 0x41e0
jmp 0x1ec04
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x40(%rbp)
movl %eax, -0x44(%rbp)
leaq -0xa8(%rbp), %rdi
callq 0x41e0
jmp 0x1ec04
movq -0x100(%rbp), %rsi
movq -0xe8(%rbp), %rax
movq 0x58(%rax), %rax
movq %rax, -0x148(%rbp)
leaq -0xc8(%rbp), %rdi
movq %rdi, -0x140(%rbp)
callq 0x4150
movq -0xf8(%rbp), %rdi
movq -0x148(%rbp), %rsi
movq -0x140(%rbp), %rdx
callq 0x25bd0
jmp 0x1ebcc
leaq -0xc8(%rbp), %rdi
callq 0x41e0
jmp 0x1ebf4
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x40(%rbp)
movl %eax, -0x44(%rbp)
leaq -0xc8(%rbp), %rdi
callq 0x41e0
jmp 0x1ec04
movq -0xf0(%rbp), %rax
addq $0x150, %rsp            # imm = 0x150
popq %rbp
retq
movq -0x40(%rbp), %rdi
callq 0x4570
nopl (%rax)
// File: devanshdalal[P]cloud-computing-concepts-part-2/MP2Node.cpp
// Function: MP2Node::recvLoop()
bool MP2Node::recvLoop()
{
	deleteExpired();
	if (memberNode->bFailed)
	{
		return false;
	}
	else
	{
		return emulNet->ENrecv(&(memberNode->addr), this->enqueueWrapper, NULL, 1, &(memberNode->mp2q));
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movq -0x10(%rbp), %rdi
movq %rdi, -0x18(%rbp)
callq 0x20930
movq -0x18(%rbp), %rax
movq 0x60(%rax), %rax
testb $0x1, 0x10(%rax)
je 0x208dd
movb $0x0, -0x1(%rbp)
jmp 0x20919
movq -0x18(%rbp), %rax
movq 0x70(%rax), %rdi
movq 0x60(%rax), %rsi
addq $0x8, %rsi
movq 0x60(%rax), %r9
addq $0x98, %r9
leaq 0x451(%rip), %rdx       # 0x20d50
xorl %eax, %eax
movl %eax, %ecx
movl $0x1, %r8d
callq 0xcdb0
cmpl $0x0, %eax
setne %al
andb $0x1, %al
movb %al, -0x1(%rbp)
movb -0x1(%rbp), %al
andb $0x1, %al
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: t0mm4rx[P]piscine_cpp/day06/ex00/main.cpp
// Function: main
int		main(int argc, char **argv)
{
	if (argc != 2)
	{
		std::cout << "Wrong usage: ./convert <number>" << std::endl;
		return (1);
	}
	go(argv[1]);
	return (0);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movl $0x0, -0x4(%rbp)
movl %edi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
cmpl $0x2, -0x8(%rbp)
je 0x2b37
movq 0x34c5(%rip), %rdi      # 0x5fd8
leaq 0x15b9(%rip), %rsi      # 0x40d3
callq 0x2100
movq %rax, %rdi
movq 0x3497(%rip), %rsi      # 0x5fc0
callq 0x2110
movl $0x1, -0x4(%rbp)
jmp 0x2b4b
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rdi
callq 0x2360
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
nop
// File: iZhangHui[P]CppPrimer/CH19_SpecializedToolsAndTechniques/examples/dyn_cast.cc
// Function: cast_to_ref(Base const&)
void cast_to_ref(const Base &b)
{
    try {
        const Derived &d = dynamic_cast<const Derived&>(b);
	// use the Derived object to which b referred
    } catch (bad_cast) {
        cout << "called f with an object that is not a Derived" << endl;
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
leaq 0x25d9(%rip), %rsi      # 0x4ba0
leaq 0x25e2(%rip), %rdx      # 0x4bb0
xorl %eax, %eax
movl %eax, %ecx
callq 0x20a0
movq %rax, -0x30(%rbp)
cmpq $0x0, %rax
jne 0x25e8
callq 0x2100
jmp 0x25e8
movq -0x30(%rbp), %rax
movq %rax, -0x10(%rbp)
jmp 0x2665
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 0x2689
movq -0x18(%rbp), %rdi
movq %rdi, -0x40(%rbp)
callq 0x20b0
movq %rax, %rsi
leaq -0x28(%rbp), %rdi
callq 0x2880
movq -0x40(%rbp), %rdi
callq 0x2040
movq 0x29a5(%rip), %rdi      # 0x4fd8
leaq 0xa74(%rip), %rsi       # 0x30ae
callq 0x2060
movq %rax, -0x38(%rbp)
jmp 0x2645
movq -0x38(%rbp), %rdi
movq 0x2968(%rip), %rsi      # 0x4fb8
callq 0x2090
jmp 0x2657
leaq -0x28(%rbp), %rdi
callq 0x20f0
callq 0x20d0
addq $0x40, %rsp
popq %rbp
retq
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x18(%rbp)
movl %eax, -0x1c(%rbp)
leaq -0x28(%rbp), %rdi
callq 0x20f0
callq 0x20d0
jmp 0x2687
jmp 0x2689
movq -0x18(%rbp), %rdi
callq 0x20e0
movq %rax, %rdi
callq 0x28c0
nopw (%rax,%rax)
// File: iZhangHui[P]CppPrimer/CH19_SpecializedToolsAndTechniques/examples/dyn_cast.cc
// Function: main
int main()
{
	Base *bp; 
	bp = new Derived;  // bp actually points to a Derived object
	if (Derived *dp = dynamic_cast<Derived*>(bp)) 
	{
	    // use the Derived object to which dp points
	} else {  // bp points at a Base object
    	// use the Base object to which bp points
	}

	exercises();
	
	cast_to_ref(*bp);
	cast_to_ref(Base());
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movl $0x0, -0x4(%rbp)
movl $0x8, %edi
callq 0x2070
movq %rax, %rdi
movq %rdi, -0x40(%rbp)
callq 0x28d0
movq -0x40(%rbp), %rax
movq %rax, -0x10(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x38(%rbp)
cmpq $0x0, %rax
je 0x26fc
movq -0x38(%rbp), %rdi
leaq 0x24ba(%rip), %rsi      # 0x4ba0
leaq 0x24c3(%rip), %rdx      # 0x4bb0
xorl %eax, %eax
movl %eax, %ecx
callq 0x20a0
movq %rax, -0x48(%rbp)
jmp 0x2704
xorl %eax, %eax
movq %rax, -0x48(%rbp)
jmp 0x2704
movq -0x48(%rbp), %rax
movq %rax, -0x18(%rbp)
cmpq $0x0, -0x18(%rbp)
je 0x2715
jmp 0x2717
jmp 0x2717
callq 0x2250
movq -0x10(%rbp), %rdi
callq 0x25b0
movq $0x0, -0x20(%rbp)
leaq -0x20(%rbp), %rdi
movq %rdi, -0x50(%rbp)
callq 0x2910
movq -0x50(%rbp), %rdi
callq 0x25b0
jmp 0x2745
leaq -0x20(%rbp), %rdi
callq 0x2930
movl -0x4(%rbp), %eax
addq $0x50, %rsp
popq %rbp
retq
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x28(%rbp)
movl %eax, -0x2c(%rbp)
leaq -0x20(%rbp), %rdi
callq 0x2930
movq -0x28(%rbp), %rdi
callq 0x20e0
nopw %cs:(%rax,%rax)
nop
// File: MarkOates[P]file-downloader/ex_file_downloader.cpp
// Function: main
int main(int, char**)
{
   std::string file_url = "https://www.allegro.cc/theme/default/image/logo.png";
   FileDownloader::FileHandle handle = FileDownloader::download_file(file_url, "logo.png");

   if (handle.get_status() == FileDownloader::DOWNLOADED)
      std::cout << "File Downloaded Successfully!" << std::endl;
   else
      std::cout << "Download Error: " << handle.get_error() << std::endl;

   return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x160, %rsp            # imm = 0x160
movl $0x0, -0x4(%rbp)
movl %edi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
leaq -0x31(%rbp), %rdi
movq %rdi, -0x130(%rbp)
callq 0x2260
movq -0x130(%rbp), %rdx
leaq 0x1b1d(%rip), %rsi      # 0x4004
leaq -0x30(%rbp), %rdi
callq 0x2730
jmp 0x24f2
leaq -0x31(%rbp), %rdi
callq 0x2320
leaq -0xe0(%rbp), %rdi
leaq -0x30(%rbp), %rsi
callq 0x2090
jmp 0x250d
leaq -0x101(%rbp), %rdi
movq %rdi, -0x138(%rbp)
callq 0x2260
movq -0x138(%rbp), %rdx
leaq 0x1b01(%rip), %rsi      # 0x402f
leaq -0x100(%rbp), %rdi
callq 0x2730
jmp 0x253c
leaq -0xc0(%rbp), %rdi
leaq -0xe0(%rbp), %rsi
leaq -0x100(%rbp), %rdx
callq 0x2d40
jmp 0x2558
leaq -0x100(%rbp), %rdi
callq 0x21d0
leaq -0x101(%rbp), %rdi
callq 0x2320
leaq -0xe0(%rbp), %rdi
callq 0x21d0
leaq -0xc0(%rbp), %rdi
callq 0x2c50
movl %eax, -0x13c(%rbp)
jmp 0x2590
movl -0x13c(%rbp), %eax
cmpl $0x2, %eax
jne 0x2654
movq 0x3a32(%rip), %rdi      # 0x5fd8
leaq 0x1a8b(%rip), %rsi      # 0x4038
callq 0x2180
movq %rax, -0x148(%rbp)
jmp 0x25bb
movq -0x148(%rbp), %rdi
movq 0x3a1f(%rip), %rsi      # 0x5fe8
callq 0x22a0
jmp 0x25d0
jmp 0x26de
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x40(%rbp)
movl %eax, -0x44(%rbp)
leaq -0x31(%rbp), %rdi
callq 0x2320
jmp 0x271b
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x40(%rbp)
movl %eax, -0x44(%rbp)
jmp 0x2712
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x40(%rbp)
movl %eax, -0x44(%rbp)
jmp 0x2626
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x40(%rbp)
movl %eax, -0x44(%rbp)
leaq -0x100(%rbp), %rdi
callq 0x21d0
leaq -0x101(%rbp), %rdi
callq 0x2320
leaq -0xe0(%rbp), %rdi
callq 0x21d0
jmp 0x2712
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x40(%rbp)
movl %eax, -0x44(%rbp)
jmp 0x2706
movq 0x397d(%rip), %rdi      # 0x5fd8
leaq 0x19f4(%rip), %rsi      # 0x4056
callq 0x2180
movq %rax, -0x150(%rbp)
jmp 0x2670
leaq -0x128(%rbp), %rdi
leaq -0xc0(%rbp), %rsi
callq 0x2ce0
jmp 0x2685
movq -0x150(%rbp), %rdi
leaq -0x128(%rbp), %rsi
callq 0x20f0
movq %rax, -0x158(%rbp)
jmp 0x26a1
movq -0x158(%rbp), %rdi
movq 0x3939(%rip), %rsi      # 0x5fe8
callq 0x22a0
jmp 0x26b6
leaq -0x128(%rbp), %rdi
callq 0x21d0
jmp 0x26de
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x40(%rbp)
movl %eax, -0x44(%rbp)
leaq -0x128(%rbp), %rdi
callq 0x21d0
jmp 0x2706
movl $0x0, -0x4(%rbp)
leaq -0xc0(%rbp), %rdi
callq 0x2b70
leaq -0x30(%rbp), %rdi
callq 0x21d0
movl -0x4(%rbp), %eax
addq $0x160, %rsp            # imm = 0x160
popq %rbp
retq
leaq -0xc0(%rbp), %rdi
callq 0x2b70
leaq -0x30(%rbp), %rdi
callq 0x21d0
movq -0x40(%rbp), %rdi
callq 0x21a0
nopw %cs:(%rax,%rax)
nop
// File: DCTewi[P]Truthtable-Calculator/functions.cpp
// Function: isLegal(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&)
bool isLegal(const std::string &expr)
{
    // Start error
    if (expr[0] != '!' && expr[0] != '(' && !isalpha(expr[0])) return false;
    // Tail error
    if (expr[expr.size() - 1] != ')' && !isalpha(expr[expr.size() - 1])) return false;
    
    for (int i = 1; i < static_cast<int>(expr.size()); i++)
    {
        if (expr[i - 1] == '!' || expr[i] == '!') continue;
        // Consequent operators
        if (operators.count(expr[i]) && operators.count(expr[i - 1])) return false;
        // Consequent variables
        if (isalpha(expr[i]) && isalpha(expr[i - 1])) return false;
    }

    return true;
}

// Assembly:
subq $0x38, %rsp
movq %rdi, 0x28(%rsp)
movq 0x28(%rsp), %rdi
xorl %eax, %eax
movl %eax, %esi
callq 0x2220
movsbl (%rax), %eax
cmpl $0x21, %eax
je 0x294a
movq 0x28(%rsp), %rdi
xorl %eax, %eax
movl %eax, %esi
callq 0x2220
movsbl (%rax), %eax
cmpl $0x28, %eax
je 0x294a
movq 0x28(%rsp), %rdi
xorl %eax, %eax
movl %eax, %esi
callq 0x2220
movsbl (%rax), %edi
callq 0x22b0
cmpl $0x0, %eax
jne 0x294a
movb $0x0, 0x37(%rsp)
jmp 0x2ac3
movq 0x28(%rsp), %rax
movq %rax, 0x18(%rsp)
movq 0x28(%rsp), %rdi
callq 0x2160
movq 0x18(%rsp), %rdi
movq %rax, %rsi
subq $0x1, %rsi
callq 0x2220
movsbl (%rax), %eax
cmpl $0x29, %eax
je 0x29b3
movq 0x28(%rsp), %rax
movq %rax, 0x10(%rsp)
movq 0x28(%rsp), %rdi
callq 0x2160
movq 0x10(%rsp), %rdi
movq %rax, %rsi
subq $0x1, %rsi
callq 0x2220
movsbl (%rax), %edi
callq 0x22b0
cmpl $0x0, %eax
jne 0x29b3
movb $0x0, 0x37(%rsp)
jmp 0x2ac3
movl $0x1, 0x24(%rsp)
movl 0x24(%rsp), %eax
movl %eax, 0xc(%rsp)
movq 0x28(%rsp), %rdi
callq 0x2160
movq %rax, %rcx
movl 0xc(%rsp), %eax
cmpl %ecx, %eax
jge 0x2abe
movq 0x28(%rsp), %rdi
movl 0x24(%rsp), %eax
subl $0x1, %eax
movslq %eax, %rsi
callq 0x2220
movsbl (%rax), %eax
cmpl $0x21, %eax
je 0x2a0f
movq 0x28(%rsp), %rdi
movslq 0x24(%rsp), %rsi
callq 0x2220
movsbl (%rax), %eax
cmpl $0x21, %eax
jne 0x2a14
jmp 0x2aae
movq 0x28(%rsp), %rdi
movslq 0x24(%rsp), %rsi
callq 0x2220
movq %rax, %rsi
leaq 0x107b3(%rip), %rdi     # 0x131e0
callq 0x4a70
cmpq $0x0, %rax
je 0x2a68
movq 0x28(%rsp), %rdi
movl 0x24(%rsp), %eax
subl $0x1, %eax
movslq %eax, %rsi
callq 0x2220
movq %rax, %rsi
leaq 0x1078a(%rip), %rdi     # 0x131e0
callq 0x4a70
cmpq $0x0, %rax
je 0x2a68
movb $0x0, 0x37(%rsp)
jmp 0x2ac3
movq 0x28(%rsp), %rdi
movslq 0x24(%rsp), %rsi
callq 0x2220
movsbl (%rax), %edi
callq 0x22b0
cmpl $0x0, %eax
je 0x2aac
movq 0x28(%rsp), %rdi
movl 0x24(%rsp), %eax
subl $0x1, %eax
movslq %eax, %rsi
callq 0x2220
movsbl (%rax), %edi
callq 0x22b0
cmpl $0x0, %eax
je 0x2aac
movb $0x0, 0x37(%rsp)
jmp 0x2ac3
jmp 0x2aae
movl 0x24(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x24(%rsp)
jmp 0x29bb
movb $0x1, 0x37(%rsp)
movb 0x37(%rsp), %al
andb $0x1, %al
addq $0x38, %rsp
retq
nop
// File: DCTewi[P]Truthtable-Calculator/functions.cpp
// Function: getPriority(char const&)
int getPriority(const char &op)
{
    switch (op)
    {
        case '=': return -3;
        case '-': return -2;
        case '|': return -1;
        case '&': return 0;
        case '!': return 1;
        default: return -10;
    }
}

// Assembly:
movq %rdi, -0x10(%rsp)
movq -0x10(%rsp), %rax
movsbl (%rax), %eax
movl %eax, -0x14(%rsp)
subl $0x21, %eax
je 0x2b3c
jmp 0x2ae8
movl -0x14(%rsp), %eax
subl $0x26, %eax
je 0x2b32
jmp 0x2af3
movl -0x14(%rsp), %eax
subl $0x2d, %eax
je 0x2b1e
jmp 0x2afe
movl -0x14(%rsp), %eax
subl $0x3d, %eax
je 0x2b14
jmp 0x2b09
movl -0x14(%rsp), %eax
subl $0x7c, %eax
je 0x2b28
jmp 0x2b46
movl $0xfffffffd, -0x4(%rsp) # imm = 0xFFFFFFFD
jmp 0x2b4e
movl $0xfffffffe, -0x4(%rsp) # imm = 0xFFFFFFFE
jmp 0x2b4e
movl $0xffffffff, -0x4(%rsp) # imm = 0xFFFFFFFF
jmp 0x2b4e
movl $0x0, -0x4(%rsp)
jmp 0x2b4e
movl $0x1, -0x4(%rsp)
jmp 0x2b4e
movl $0xfffffff6, -0x4(%rsp) # imm = 0xFFFFFFF6
movl -0x4(%rsp), %eax
retq
nopw %cs:(%rax,%rax)
// File: rpetit3[P]fastq-scan/fastq-scan.cpp
// Function: usage()
static int usage()
{
    cout << "Usage: cat FASTQ | fastq-scan [options]" << endl;
    cout << "Version: " << VERSION << endl;
    cout << endl;
    cout << "Optional arguments:" << endl;
    cout << "    -g INT   Genome size for calculating estimated sequencing coverage. (Default 1)" << endl;
    cout << "    -p INT   ASCII offset for input quality scores, can be 33 or 64. (Default 33)" << endl;
    cout << "    -q       Print only the QC stats, do not print read lengths or per-base quality scores" << endl;
    cout << "    -v       Print version information and exit" << endl;
    cout << "    -h       Show this message and exit" << endl;
    cout << endl;
    return 0;
}

// Assembly:
pushq %rax
movq 0xf378(%rip), %rdi      # 0x11fd0
leaq 0xa530(%rip), %rsi      # 0xd18f
callq 0x2180
movq %rax, %rdi
movq 0xf342(%rip), %rsi      # 0x11fb0
callq 0x21b0
movq 0xf356(%rip), %rdi      # 0x11fd0
leaq 0xa536(%rip), %rsi      # 0xd1b7
callq 0x2180
movq %rax, %rdi
leaq 0xf548(%rip), %rsi      # 0x121d8
callq 0x2170
movq %rax, %rdi
movq 0xf311(%rip), %rsi      # 0x11fb0
callq 0x21b0
movq 0xf325(%rip), %rdi      # 0x11fd0
movq 0xf2fe(%rip), %rsi      # 0x11fb0
callq 0x21b0
movq 0xf312(%rip), %rdi      # 0x11fd0
leaq 0xa4fc(%rip), %rsi      # 0xd1c1
callq 0x2180
movq %rax, %rdi
movq 0xf2dc(%rip), %rsi      # 0x11fb0
callq 0x21b0
movq 0xf2f0(%rip), %rdi      # 0x11fd0
leaq 0xa4ee(%rip), %rsi      # 0xd1d5
callq 0x2180
movq %rax, %rdi
movq 0xf2ba(%rip), %rsi      # 0x11fb0
callq 0x21b0
movq 0xf2ce(%rip), %rdi      # 0x11fd0
leaq 0xa520(%rip), %rsi      # 0xd229
callq 0x2180
movq %rax, %rdi
movq 0xf298(%rip), %rsi      # 0x11fb0
callq 0x21b0
movq 0xf2ac(%rip), %rdi      # 0x11fd0
leaq 0xa550(%rip), %rsi      # 0xd27b
callq 0x2180
movq %rax, %rdi
movq 0xf276(%rip), %rsi      # 0x11fb0
callq 0x21b0
movq 0xf28a(%rip), %rdi      # 0x11fd0
leaq 0xa589(%rip), %rsi      # 0xd2d6
callq 0x2180
movq %rax, %rdi
movq 0xf254(%rip), %rsi      # 0x11fb0
callq 0x21b0
movq 0xf268(%rip), %rdi      # 0x11fd0
leaq 0xa597(%rip), %rsi      # 0xd306
callq 0x2180
movq %rax, %rdi
movq 0xf232(%rip), %rsi      # 0x11fb0
callq 0x21b0
movq 0xf246(%rip), %rdi      # 0x11fd0
movq 0xf21f(%rip), %rsi      # 0x11fb0
callq 0x21b0
xorl %eax, %eax
popq %rcx
retq
nopw (%rax,%rax)
// File: rpetit3[P]fastq-scan/fastq-scan.cpp
// Function: Stats::init()
void init(void) {
            read_total = 0;
            total_bp = 0;
            qual_sum = 0;
            read_length_count.resize(MAX_READ_LENGTH,0);
            per_base_qual.resize(MAX_READ_LENGTH,0);
            per_base_count.resize(MAX_READ_LENGTH,0);
            phred = 33;
        }

// Assembly:
subq $0x28, %rsp
movq %rdi, 0x20(%rsp)
movq 0x20(%rsp), %rdi
movq %rdi, (%rsp)
movq $0x0, 0x38(%rdi)
movq $0x0, (%rdi)
xorps %xmm0, %xmm0
movsd %xmm0, 0xc8(%rdi)
addq $0x20, %rdi
movl $0x0, 0x1c(%rsp)
movl $0x2faf080, %esi        # imm = 0x2FAF080
leaq 0x1c(%rsp), %rdx
callq 0x4c00
movq (%rsp), %rdi
addq $0x88, %rdi
movq $0x0, 0x10(%rsp)
movl $0x2faf080, %esi        # imm = 0x2FAF080
leaq 0x10(%rsp), %rdx
callq 0x4cc0
movq (%rsp), %rdi
addq $0xa0, %rdi
movq $0x0, 0x8(%rsp)
movl $0x2faf080, %esi        # imm = 0x2FAF080
leaq 0x8(%rsp), %rdx
callq 0x4cc0
movq (%rsp), %rax
movl $0x21, 0xb8(%rax)
addq $0x28, %rsp
retq
// File: rpetit3[P]fastq-scan/fastq-scan.cpp
// Function: Stats::transform_quality(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>)
int transform_quality(string qual) {
            unsigned int total = 0;
            total_bp += qual.length();
            read_length_count[qual.length()]++;
            for (unsigned int i = 0; i < qual.length(); i++) {
                unsigned int qual_val = (unsigned int)qual[i];
                per_base_qual[i] += qual_val;
                per_base_count[i]++;
                total += qual_val;
            }

            if (qual.length() > 0) {
                double avg_qual = total / qual.length();
                qual_sum += avg_qual;
                per_read_qual.push_back(avg_qual);
                return 0;
            } else {
                return 1;
            }
        }

// Assembly:
subq $0x68, %rsp
movq %rsi, 0x18(%rsp)
movq %rdi, %rax
movq 0x18(%rsp), %rdi
movq %rdi, 0x20(%rsp)
movq %rax, 0x58(%rsp)
movq %rdi, 0x50(%rsp)
movq 0x58(%rsp), %rax
movq %rax, 0x28(%rsp)
movl $0x0, 0x4c(%rsp)
callq 0x2260
movq 0x20(%rsp), %rdi
movq %rax, %rcx
movq 0x28(%rsp), %rax
addq (%rax), %rcx
movq %rcx, (%rax)
addq $0x20, %rax
movq %rax, 0x30(%rsp)
callq 0x2260
movq 0x30(%rsp), %rdi
movq %rax, %rsi
callq 0x7860
movl (%rax), %ecx
addl $0x1, %ecx
movl %ecx, (%rax)
movl $0x0, 0x48(%rsp)
movq 0x20(%rsp), %rdi
movl 0x48(%rsp), %eax
movq %rax, 0x10(%rsp)
callq 0x2260
movq %rax, %rcx
movq 0x10(%rsp), %rax
cmpq %rcx, %rax
jae 0x30a3
movq 0x20(%rsp), %rdi
movl 0x48(%rsp), %eax
movl %eax, %esi
callq 0x2350
movq 0x28(%rsp), %rdi
movsbl (%rax), %eax
movl %eax, 0x44(%rsp)
movl 0x44(%rsp), %eax
movq %rax, 0x8(%rsp)
addq $0x88, %rdi
movl 0x48(%rsp), %eax
movl %eax, %esi
callq 0x7880
movq 0x8(%rsp), %rcx
movq 0x28(%rsp), %rdi
addq (%rax), %rcx
movq %rcx, (%rax)
addq $0xa0, %rdi
movl 0x48(%rsp), %eax
movl %eax, %esi
callq 0x7880
movq (%rax), %rcx
addq $0x1, %rcx
movq %rcx, (%rax)
movl 0x44(%rsp), %eax
addl 0x4c(%rsp), %eax
movl %eax, 0x4c(%rsp)
movl 0x48(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x48(%rsp)
jmp 0x3004
movq 0x20(%rsp), %rdi
callq 0x2260
cmpq $0x0, %rax
jbe 0x310f
movq 0x20(%rsp), %rdi
movl 0x4c(%rsp), %eax
movq %rax, (%rsp)
callq 0x2260
movq 0x28(%rsp), %rdi
movq %rax, %rcx
movq (%rsp), %rax
xorl %edx, %edx
divq %rcx
cvtsi2sd %rax, %xmm0
movsd %xmm0, 0x38(%rsp)
movsd 0x38(%rsp), %xmm0
addsd 0xc8(%rdi), %xmm0
movsd %xmm0, 0xc8(%rdi)
addq $0x70, %rdi
leaq 0x38(%rsp), %rsi
callq 0x78a0
movl $0x0, 0x64(%rsp)
jmp 0x3117
movl $0x1, 0x64(%rsp)
movl 0x64(%rsp), %eax
addq $0x68, %rsp
retq
// File: rpetit3[P]fastq-scan/fastq-scan.cpp
// Function: Stats::get_std(std::vector<unsigned int, std::allocator<unsigned int>>, double)
double get_std(vector<unsigned int> array, double mean) {
            double temp = 0;
            for (unsigned int i = 0; i < read_total; i++) {
                temp += pow((array[i] - mean), 2);
            }
            return sqrt(temp / read_total);
        }

// Assembly:
subq $0x38, %rsp
movq %rsi, (%rsp)
movq %rdi, 0x30(%rsp)
movq %rsi, 0x28(%rsp)
movsd %xmm0, 0x20(%rsp)
movq 0x30(%rsp), %rax
movq %rax, 0x8(%rsp)
xorps %xmm0, %xmm0
movsd %xmm0, 0x18(%rsp)
movl $0x0, 0x14(%rsp)
movq 0x8(%rsp), %rcx
movl 0x14(%rsp), %eax
cmpq 0x38(%rcx), %rax
jae 0x8191
movq (%rsp), %rdi
movl 0x14(%rsp), %eax
movl %eax, %esi
callq 0x7860
movl (%rax), %eax
cvtsi2sd %rax, %xmm0
subsd 0x20(%rsp), %xmm0
movl $0x2, %edi
callq 0x98a0
addsd 0x18(%rsp), %xmm0
movsd %xmm0, 0x18(%rsp)
movl 0x14(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x14(%rsp)
jmp 0x8143
movq 0x8(%rsp), %rax
movsd 0x18(%rsp), %xmm0
movq 0x38(%rax), %xmm1
movaps 0x4eb8(%rip), %xmm2     # 0xd060
punpckldq %xmm2, %xmm1    # xmm1 = xmm1[0],xmm2[0],xmm1[1],xmm2[1]
movapd 0x4ebc(%rip), %xmm2     # 0xd070
subpd %xmm2, %xmm1
movaps %xmm1, %xmm2
unpckhpd %xmm1, %xmm1            # xmm1 = xmm1[1,1]
addsd %xmm2, %xmm1
divsd %xmm1, %xmm0
callq 0x2130
addq $0x38, %rsp
retq
nopw %cs:(%rax,%rax)
nopl (%rax,%rax)
// File: rpetit3[P]fastq-scan/fastq-scan.cpp
// Function: Stats::get_percentile(std::vector<unsigned int, std::allocator<unsigned int>>, unsigned long, float)
double get_percentile(vector<unsigned int> array, size_t size, float percentile) {
            if (size % 2 == 0) {
                int p = int(size * percentile - 1);
                return (array[p] + array[p]) / 2.0;
            } else {
                int p = int(size * percentile);
                return array[p];
            }
        }

// Assembly:
subq $0x58, %rsp
movq %rsi, 0x20(%rsp)
movq %rdi, 0x48(%rsp)
movq %rsi, 0x40(%rsp)
movq %rdx, 0x38(%rsp)
movss %xmm0, 0x34(%rsp)
movq 0x38(%rsp), %rax
andq $0x1, %rax
cmpq $0x0, %rax
jne 0x845b
movq 0x38(%rsp), %rax
movq %rax, %rdx
shrq %rdx
movl %eax, %ecx
andl $0x1, %ecx
orq %rdx, %rcx
cvtsi2ss %rcx, %xmm0
addss %xmm0, %xmm0
cvtsi2ss %rax, %xmm1
movss %xmm1, 0x18(%rsp)
testq %rax, %rax
movss %xmm0, 0x1c(%rsp)
js 0x83ef
movss 0x18(%rsp), %xmm0
movss %xmm0, 0x1c(%rsp)
movq 0x20(%rsp), %rdi
movss 0x1c(%rsp), %xmm0
movss 0x34(%rsp), %xmm1
mulss %xmm1, %xmm0
movss 0x4c08(%rip), %xmm1     # 0xd014
addss %xmm1, %xmm0
cvttss2si %xmm0, %eax
movl %eax, 0x30(%rsp)
movslq 0x30(%rsp), %rsi
callq 0x7860
movq 0x20(%rsp), %rdi
movl (%rax), %eax
movl %eax, 0x14(%rsp)
movslq 0x30(%rsp), %rsi
callq 0x7860
movq %rax, %rcx
movl 0x14(%rsp), %eax
movl (%rcx), %ecx
addl %ecx, %eax
cvtsi2sd %rax, %xmm0
movsd 0x4c31(%rip), %xmm1     # 0xd080
divsd %xmm1, %xmm0
movsd %xmm0, 0x50(%rsp)
jmp 0x84cd
movq 0x38(%rsp), %rax
movq %rax, %rdx
shrq %rdx
movl %eax, %ecx
andl $0x1, %ecx
orq %rdx, %rcx
cvtsi2ss %rcx, %xmm0
addss %xmm0, %xmm0
cvtsi2ss %rax, %xmm1
movss %xmm1, 0xc(%rsp)
testq %rax, %rax
movss %xmm0, 0x10(%rsp)
js 0x8499
movss 0xc(%rsp), %xmm0
movss %xmm0, 0x10(%rsp)
movq 0x20(%rsp), %rdi
movss 0x10(%rsp), %xmm0
movss 0x34(%rsp), %xmm1
mulss %xmm1, %xmm0
cvttss2si %xmm0, %eax
movl %eax, 0x2c(%rsp)
movslq 0x2c(%rsp), %rsi
callq 0x7860
movl (%rax), %eax
cvtsi2sd %rax, %xmm0
movsd %xmm0, 0x50(%rsp)
movsd 0x50(%rsp), %xmm0
addq $0x58, %rsp
retq
nopl (%rax,%rax)
// File: rpetit3[P]fastq-scan/fastq-scan.cpp
// Function: Stats::get_std(std::vector<double, std::allocator<double>>, double)
double get_std(vector<double> array, double mean) {
            double temp = 0;
            for (unsigned int i = 0; i < read_total; i++) {
                temp += pow(((array[i]-phred) - mean), 2);
            }
            return sqrt(temp / read_total);
        }

// Assembly:
subq $0x38, %rsp
movq %rsi, (%rsp)
movq %rdi, 0x30(%rsp)
movq %rsi, 0x28(%rsp)
movsd %xmm0, 0x20(%rsp)
movq 0x30(%rsp), %rax
movq %rax, 0x8(%rsp)
xorps %xmm0, %xmm0
movsd %xmm0, 0x18(%rsp)
movl $0x0, 0x14(%rsp)
movq 0x8(%rsp), %rcx
movl 0x14(%rsp), %eax
cmpq 0x38(%rcx), %rax
jae 0x9f12
movq (%rsp), %rdi
movl 0x14(%rsp), %eax
movl %eax, %esi
callq 0xb730
movq %rax, %rcx
movq 0x8(%rsp), %rax
movsd (%rcx), %xmm0
cvtsi2sdl 0xb8(%rax), %xmm1
subsd %xmm1, %xmm0
subsd 0x20(%rsp), %xmm0
movl $0x2, %edi
callq 0x98a0
addsd 0x18(%rsp), %xmm0
movsd %xmm0, 0x18(%rsp)
movl 0x14(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x14(%rsp)
jmp 0x9eb3
movq 0x8(%rsp), %rax
movsd 0x18(%rsp), %xmm0
movq 0x38(%rax), %xmm1
movaps 0x3137(%rip), %xmm2     # 0xd060
punpckldq %xmm2, %xmm1    # xmm1 = xmm1[0],xmm2[0],xmm1[1],xmm2[1]
movapd 0x313b(%rip), %xmm2     # 0xd070
subpd %xmm2, %xmm1
movaps %xmm1, %xmm2
unpckhpd %xmm1, %xmm1            # xmm1 = xmm1[1,1]
addsd %xmm2, %xmm1
divsd %xmm1, %xmm0
callq 0x2130
addq $0x38, %rsp
retq
nopw %cs:(%rax,%rax)
nopl (%rax)
// File: smuething[P]dune-cxx11/16-shared_from_this.cc
// Function: main
int main()
{
  std::shared_ptr<A> p1(new A());
  std::shared_ptr<A> p2 = p1->shared_from_this();
  assert(p1 == p2);
  return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movl $0x0, -0x4(%rbp)
movl $0x10, %edi
callq 0x1080
movq %rax, %rdi
movq %rdi, -0x48(%rbp)
xorps %xmm0, %xmm0
movaps %xmm0, (%rdi)
callq 0x12b0
movq -0x48(%rbp), %rsi
leaq -0x18(%rbp), %rdi
movq %rdi, -0x40(%rbp)
callq 0x12d0
movq -0x40(%rbp), %rdi
callq 0x1300
movq %rax, %rsi
leaq -0x28(%rbp), %rdi
callq 0x1320
jmp 0x1233
leaq -0x18(%rbp), %rdi
leaq -0x28(%rbp), %rsi
callq 0x1350
testb $0x1, %al
jne 0x1246
jmp 0x1248
jmp 0x127e
leaq 0xdb5(%rip), %rdi       # 0x2004
leaq 0xdb7(%rip), %rsi       # 0x200d
movl $0xc, %edx
leaq 0xdc2(%rip), %rcx       # 0x2024
callq 0x1070
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x30(%rbp)
movl %eax, -0x34(%rbp)
leaq -0x18(%rbp), %rdi
callq 0x1390
jmp 0x12a0
movl $0x0, -0x4(%rbp)
leaq -0x28(%rbp), %rdi
callq 0x1390
leaq -0x18(%rbp), %rdi
callq 0x1390
movl -0x4(%rbp), %eax
addq $0x50, %rsp
popq %rbp
retq
movq -0x30(%rbp), %rdi
callq 0x10d0
nopl (%rax)
// File: matteorr[P]EarleyParser/EarleyParser.cpp
// Function: EarleyParser::~EarleyParser()
EarleyParser::~EarleyParser()
{
	for( unsigned int i = 0; i <= this->inputVector.size(); i++ )
	{
		//int j = 0;
		//cout << i << "  *****************************************************" << endl << "*****************************************************" << endl;
		for( vector<State*>::iterator it = this->earleyParserChart.at(i).begin(); it != this->earleyParserChart.at(i).end(); it++ )
		{
			//j++;
			delete *it;

		}
		//cout << endl << endl << "DELETED STATEs: " << j << endl << endl;

	}

	for( vector<Node*>::iterator it = this->returnVector.begin(); it != this->returnVector.end(); it++ )
	{
		delete *(it);
	}

}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x70, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x48(%rbp)
leaq 0x19685(%rip), %rcx     # 0x1bcf0
addq $0x10, %rcx
movq %rcx, (%rax)
movl $0x0, -0xc(%rbp)
movq -0x48(%rbp), %rdi
movl -0xc(%rbp), %eax
movq %rax, -0x50(%rbp)
addq $0x98, %rdi
callq 0x6c90
movq %rax, %rcx
movq -0x50(%rbp), %rax
cmpq %rcx, %rax
ja 0x2740
movq -0x48(%rbp), %rdi
subq $-0x80, %rdi
movl -0xc(%rbp), %eax
movl %eax, %esi
callq 0x6cb0
movq %rax, -0x58(%rbp)
jmp 0x26b8
movq -0x58(%rbp), %rdi
callq 0x6d00
movq %rax, -0x18(%rbp)
movq -0x48(%rbp), %rdi
subq $-0x80, %rdi
movl -0xc(%rbp), %eax
movl %eax, %esi
callq 0x6cb0
movq %rax, -0x60(%rbp)
jmp 0x26dd
movq -0x60(%rbp), %rdi
callq 0x6d70
movq %rax, -0x20(%rbp)
leaq -0x18(%rbp), %rdi
leaq -0x20(%rbp), %rsi
callq 0x6d30
testb $0x1, %al
jne 0x26fd
jmp 0x2730
leaq -0x18(%rbp), %rdi
callq 0x6da0
movq (%rax), %rax
movq %rax, -0x68(%rbp)
cmpq $0x0, %rax
je 0x271d
movq -0x68(%rbp), %rdi
movq (%rdi), %rax
callq *0x8(%rax)
jmp 0x271f
leaq -0x18(%rbp), %rdi
xorl %esi, %esi
callq 0x6dc0
movq %rax, -0x28(%rbp)
jmp 0x26c5
jmp 0x2732
movl -0xc(%rbp), %eax
addl $0x1, %eax
movl %eax, -0xc(%rbp)
jmp 0x2679
movq -0x48(%rbp), %rdi
addq $0xb0, %rdi
callq 0x6e00
movq %rax, -0x30(%rbp)
movq -0x48(%rbp), %rdi
addq $0xb0, %rdi
callq 0x6e70
movq %rax, -0x38(%rbp)
leaq -0x30(%rbp), %rdi
leaq -0x38(%rbp), %rsi
callq 0x6e30
testb $0x1, %al
jne 0x277b
jmp 0x27ae
leaq -0x30(%rbp), %rdi
callq 0x6ea0
movq (%rax), %rax
movq %rax, -0x70(%rbp)
cmpq $0x0, %rax
je 0x279b
movq -0x70(%rbp), %rdi
movq (%rdi), %rax
callq *0x8(%rax)
jmp 0x279d
leaq -0x30(%rbp), %rdi
xorl %esi, %esi
callq 0x6ec0
movq %rax, -0x40(%rbp)
jmp 0x2754
movq -0x48(%rbp), %rdi
addq $0xb0, %rdi
callq 0x6f00
movq -0x48(%rbp), %rdi
addq $0x98, %rdi
callq 0x6f60
movq -0x48(%rbp), %rdi
addq $0x80, %rdi
callq 0x6fc0
movq -0x48(%rbp), %rdi
addq $0x48, %rdi
callq 0x7020
movq -0x48(%rbp), %rdi
addq $0x10, %rdi
callq 0x7040
addq $0x70, %rsp
popq %rbp
retq
movq %rax, %rdi
callq 0x6cf0
nopw %cs:(%rax,%rax)
// File: matteorr[P]EarleyParser/EarleyParser.cpp
// Function: EarleyParser::splitToVector(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&, std::vector<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, std::allocator<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>>*, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&, bool)
void EarleyParser::splitToVector
	(
		const std::string& inputString,
        std::vector<std::string>* outputVector,
        const std::string& separatorString,
        bool skipNullStrings
    )
{
    unsigned int pos = 0;
    outputVector->clear();

    while( pos < inputString.length() )
    {
        std::string next = inputString.substr( pos );
        unsigned int next_pos = next.find( separatorString );

        if( next_pos == static_cast<unsigned int> (std::string::npos) )
            next_pos = next.length();

        if( !skipNullStrings || next_pos > 0 )
        {
            std::string to_insert = next.substr( 0, next_pos );
            outputVector->push_back( to_insert );
        }

        pos += next_pos + separatorString.size();
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x90, %rsp
movb %r8b, %al
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq %rcx, -0x20(%rbp)
andb $0x1, %al
movb %al, -0x21(%rbp)
movl $0x0, -0x28(%rbp)
movq -0x18(%rbp), %rdi
callq 0x7bf0
movl -0x28(%rbp), %eax
movq %rax, -0x88(%rbp)
movq -0x10(%rbp), %rdi
callq 0x22c0
movq %rax, %rcx
movq -0x88(%rbp), %rax
cmpq %rcx, %rax
jae 0x36fa
movq -0x10(%rbp), %rsi
movl -0x28(%rbp), %eax
movl %eax, %edx
leaq -0x48(%rbp), %rdi
movq $-0x1, %rcx
callq 0x21e0
movq -0x20(%rbp), %rsi
leaq -0x48(%rbp), %rdi
xorl %eax, %eax
movl %eax, %edx
callq 0x2390
movl %eax, -0x4c(%rbp)
cmpl $-0x1, -0x4c(%rbp)
jne 0x3658
leaq -0x48(%rbp), %rdi
callq 0x22c0
movl %eax, -0x4c(%rbp)
testb $0x1, -0x21(%rbp)
je 0x3664
cmpl $0x0, -0x4c(%rbp)
jbe 0x36bb
movl -0x4c(%rbp), %eax
movl %eax, %ecx
xorl %eax, %eax
movl %eax, %edx
leaq -0x70(%rbp), %rdi
leaq -0x48(%rbp), %rsi
callq 0x21e0
jmp 0x367c
movq -0x18(%rbp), %rdi
leaq -0x70(%rbp), %rsi
callq 0x7c10
jmp 0x368b
leaq -0x70(%rbp), %rdi
callq 0x2140
jmp 0x36bb
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x78(%rbp)
movl %eax, -0x7c(%rbp)
jmp 0x36ef
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x78(%rbp)
movl %eax, -0x7c(%rbp)
leaq -0x70(%rbp), %rdi
callq 0x2140
jmp 0x36ef
movl -0x4c(%rbp), %eax
movq %rax, -0x90(%rbp)
movq -0x20(%rbp), %rdi
callq 0x2160
movq -0x90(%rbp), %rcx
addq %rax, %rcx
movl -0x28(%rbp), %eax
addq %rcx, %rax
movl %eax, -0x28(%rbp)
leaq -0x48(%rbp), %rdi
callq 0x2140
jmp 0x35f3
leaq -0x48(%rbp), %rdi
callq 0x2140
jmp 0x3703
addq $0x90, %rsp
popq %rbp
retq
movq -0x78(%rbp), %rdi
callq 0x2340
nopl (%rax)
// File: matteorr[P]EarleyParser/EarleyParser.cpp
// Function: EarleyParser::getProduction(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>)
list<Production>* EarleyParser::getProduction( string nonTerminal )
{
	/*
	 * looks in the hash table of productions
	 * if the non terminal symbol was allready inserted
	 */
	EarleyParser::productionHashTable::iterator got = this->earleyProductions.find( nonTerminal );
	if( got != this->earleyProductions.end() )
	{
		/*
		 * element found in hash table (key nonTerminal contained)
		 */

		//cout << "[DEBUG]: found [" << got->first << "]" << endl;

	}else{
		/*
		 * element not found in hash table (key nonTerminal not contained)
		 */

		//cout << "[DEBUG]: ERROR not found [" << nonTerminal << "] in hash map!" << endl << endl;
		return NULL;
	}

	return & got->second;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x10(%rbp), %rdi
movq %rdi, -0x30(%rbp)
addq $0x10, %rdi
callq 0x70d0
movq -0x30(%rbp), %rdi
movq %rax, -0x20(%rbp)
addq $0x10, %rdi
callq 0x7130
movq %rax, -0x28(%rbp)
leaq -0x20(%rbp), %rdi
leaq -0x28(%rbp), %rsi
callq 0x7100
testb $0x1, %al
jne 0x4729
jmp 0x472b
jmp 0x4735
movq $0x0, -0x8(%rbp)
jmp 0x4746
leaq -0x20(%rbp), %rdi
callq 0x7160
addq $0x20, %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x30, %rsp
popq %rbp
retq
// File: matteorr[P]EarleyParser/Node.cpp
// Function: Node::Node(Node*, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, std::vector<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, std::allocator<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>>, Production*, float)
Node::Node( Node* father, string grammarElement, vector<string> nodeProduction, Production* productionPointer, float productionProbability )
{
	this->father = father;

	this->grammarElement = grammarElement;
	this->production = nodeProduction;
	this->productionProbability = productionProbability;

	this->productionPointer = productionPointer;

}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x70, %rsp
movq %rdx, -0x48(%rbp)
movq %rcx, -0x70(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq %rcx, -0x20(%rbp)
movq %r8, -0x28(%rbp)
movss %xmm0, -0x2c(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x58(%rbp)
leaq 0xd488(%rip), %rax      # 0x1bd30
movq %rax, (%rdi)
addq $0x8, %rdi
movq %rdi, -0x50(%rbp)
callq 0x22a0
movq -0x58(%rbp), %rdi
addq $0x28, %rdi
movq %rdi, -0x68(%rbp)
callq 0x6c50
movq -0x58(%rbp), %rdi
addq $0x48, %rdi
movq %rdi, -0x60(%rbp)
callq 0x6c70
movq -0x58(%rbp), %rax
movq -0x50(%rbp), %rdi
movq -0x48(%rbp), %rsi
movq -0x10(%rbp), %rcx
movq %rcx, 0x40(%rax)
callq 0x2030
jmp 0xe8f5
movq -0x70(%rbp), %rsi
movq -0x58(%rbp), %rdi
addq $0x28, %rdi
callq 0x10270
jmp 0xe908
movq -0x58(%rbp), %rax
movss -0x2c(%rbp), %xmm0
movss %xmm0, 0x60(%rax)
movq -0x28(%rbp), %rcx
movq %rcx, 0x68(%rax)
addq $0x70, %rsp
popq %rbp
retq
movq -0x60(%rbp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x38(%rbp)
movl %eax, -0x3c(%rbp)
callq 0x6f00
movq -0x68(%rbp), %rdi
callq 0x6f60
movq -0x50(%rbp), %rdi
callq 0x2140
movq -0x38(%rbp), %rdi
callq 0x2340
nopw %cs:(%rax,%rax)
// File: matteorr[P]EarleyParser/Node.cpp
// Function: Node::print(bool)
float Node::print( bool printProbabilities )
{
	float prob = -1;

	cout << "Node [" << this->grammarElement << "]{";

	if( printProbabilities == true ){

		if( this->children.size() == 0 )
		{
			/*
			 * we are in a leaf node
			 */
			prob = this->productionProbability;

		}else{

			prob = this->productionProbability;
			for( vector<Node*>::iterator it = this->children.begin(); it != this->children.end(); it++ )
			{
				prob = prob * (*it)->print( printProbabilities );
			}
		}
	}else{

		for( vector<Node*>::iterator it = this->children.begin(); it != this->children.end(); it++ )
		{
			prob = (*it)->print( printProbabilities );
		}
	}
	cout << "prob [" << prob << "]}";

	return prob;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movb %sil, %al
movq %rdi, -0x8(%rbp)
andb $0x1, %al
movb %al, -0x9(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x48(%rbp)
movss 0x2f34(%rip), %xmm0     # 0x13008
movss %xmm0, -0x10(%rbp)
movq 0xbef8(%rip), %rdi      # 0x1bfd8
leaq 0x368a(%rip), %rsi      # 0x13771
callq 0x21c0
movq -0x48(%rbp), %rsi
movq %rax, %rdi
addq $0x8, %rsi
callq 0x21a0
movq %rax, %rdi
leaq 0x3672(%rip), %rsi      # 0x13778
callq 0x21c0
movb -0x9(%rbp), %al
andb $0x1, %al
movzbl %al, %eax
cmpl $0x1, %eax
jne 0x101ca
movq -0x48(%rbp), %rdi
addq $0x48, %rdi
callq 0xde40
cmpq $0x0, %rax
jne 0x10142
movq -0x48(%rbp), %rax
movss 0x60(%rax), %xmm0
movss %xmm0, -0x10(%rbp)
jmp 0x101c8
movq -0x48(%rbp), %rdi
movss 0x60(%rdi), %xmm0
movss %xmm0, -0x10(%rbp)
addq $0x48, %rdi
callq 0x6e00
movq %rax, -0x18(%rbp)
movq -0x48(%rbp), %rdi
addq $0x48, %rdi
callq 0x6e70
movq %rax, -0x20(%rbp)
leaq -0x18(%rbp), %rdi
leaq -0x20(%rbp), %rsi
callq 0x6e30
testb $0x1, %al
jne 0x10181
jmp 0x101c6
movss -0x10(%rbp), %xmm0
movss %xmm0, -0x4c(%rbp)
leaq -0x18(%rbp), %rdi
callq 0x6ea0
movq (%rax), %rdi
movb -0x9(%rbp), %al
andb $0x1, %al
movzbl %al, %esi
callq 0x100b0
movaps %xmm0, %xmm1
movss -0x4c(%rbp), %xmm0
mulss %xmm1, %xmm0
movss %xmm0, -0x10(%rbp)
leaq -0x18(%rbp), %rdi
xorl %esi, %esi
callq 0x6ec0
movq %rax, -0x28(%rbp)
jmp 0x1015d
jmp 0x101c8
jmp 0x10230
movq -0x48(%rbp), %rdi
addq $0x48, %rdi
callq 0x6e00
movq %rax, -0x30(%rbp)
movq -0x48(%rbp), %rdi
addq $0x48, %rdi
callq 0x6e70
movq %rax, -0x38(%rbp)
leaq -0x30(%rbp), %rdi
leaq -0x38(%rbp), %rsi
callq 0x6e30
testb $0x1, %al
jne 0x101ff
jmp 0x1022e
leaq -0x30(%rbp), %rdi
callq 0x6ea0
movq (%rax), %rdi
movb -0x9(%rbp), %al
andb $0x1, %al
movzbl %al, %esi
callq 0x100b0
movss %xmm0, -0x10(%rbp)
leaq -0x30(%rbp), %rdi
xorl %esi, %esi
callq 0x6ec0
movq %rax, -0x40(%rbp)
jmp 0x101db
jmp 0x10230
movq 0xbda1(%rip), %rdi      # 0x1bfd8
leaq 0x353d(%rip), %rsi      # 0x1377b
callq 0x21c0
movq %rax, %rdi
movss -0x10(%rbp), %xmm0
callq 0x2170
movq %rax, %rdi
leaq 0x3528(%rip), %rsi      # 0x13782
callq 0x21c0
movss -0x10(%rbp), %xmm0
addq $0x50, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: matteorr[P]EarleyParser/State.cpp
// Function: State::State(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, Production*, State*, int, int)
State::State( string nonTerminal, Production* productionPointer, State* backtraceState, int inputStringProgress, int productionProgress )
: productionProgress(0), printed(false)
{

	//cout << endl << endl << "!!!!!!!!!!!![DEBUG]: OTHER CONSTRUCTOR CALLED!!!!!!!!!!!!!" << endl << endl << endl;

	this->nonTerminal = nonTerminal;
	this->productionPointer = productionPointer;

	this->backtraceStateVector.push_back( backtraceState );

	this->inputStringProgress = inputStringProgress;
	this->productionProgress = productionProgress;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x60, %rsp
movq %rsi, -0x40(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq %rcx, -0x20(%rbp)
movl %r8d, -0x24(%rbp)
movl %r9d, -0x28(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x50(%rbp)
leaq 0xa83d(%rip), %rax      # 0x1bd90
movq %rax, (%rdi)
addq $0x8, %rdi
movq %rdi, -0x48(%rbp)
callq 0x22a0
movq -0x50(%rbp), %rdi
addq $0x30, %rdi
movq %rdi, -0x58(%rbp)
callq 0xcee0
movq -0x50(%rbp), %rax
movq -0x48(%rbp), %rdi
movq -0x40(%rbp), %rsi
movl $0x0, 0x48(%rax)
movb $0x0, 0x50(%rax)
callq 0x2030
jmp 0x11592
movq -0x50(%rbp), %rdi
movq -0x18(%rbp), %rax
movq %rax, 0x28(%rdi)
addq $0x30, %rdi
leaq -0x20(%rbp), %rsi
callq 0x79b0
jmp 0x115ad
movq -0x50(%rbp), %rax
movl -0x24(%rbp), %ecx
movl %ecx, 0x4c(%rax)
movl -0x28(%rbp), %ecx
movl %ecx, 0x48(%rax)
addq $0x60, %rsp
popq %rbp
retq
movq -0x58(%rbp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x30(%rbp)
movl %eax, -0x34(%rbp)
callq 0x9b90
movq -0x48(%rbp), %rdi
callq 0x2140
movq -0x30(%rbp), %rdi
callq 0x2340
nopw (%rax,%rax)
// File: matteorr[P]EarleyParser/State.cpp
// Function: State::getProductionPointer() const
Production* State::getProductionPointer() const
{
	if( this->productionPointer == NULL ){
		cout << "[ERROR]: production pointer is null" << endl;
		exit(1);
	}

	return this->productionPointer;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x10(%rbp)
cmpq $0x0, 0x28(%rax)
jne 0x11717
movq 0xa8e6(%rip), %rdi      # 0x1bfd8
leaq 0x209f(%rip), %rsi      # 0x13798
callq 0x21c0
movq %rax, %rdi
movq 0xa8c0(%rip), %rsi      # 0x1bfc8
callq 0x21f0
movl $0x1, %edi
callq 0x2220
movq -0x10(%rbp), %rax
movq 0x28(%rax), %rax
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: ronakshah725[P]SLR1Parser_C/parser1.cpp
// Function: printTokens(int)
void printTokens(int ntoken)
{
    //todo
		  switch (ntoken) {
                  
              case LBRACE:
                  printf("lb ");break;
              case RBRACE:
                  printf("rb ");break;
              case IDENTIFIER:
                  printf("x ");
                  break;
              case PRINT:
                  printf("p ");break;
                  break;
              case LOOP:
                  printf("l ");break;
                  break;
              case FUNCTION:
                  printf("f ");
                  break;
              case ASSIGN:
                  printf("= ");
                  break;
              case NUMBER:
                  printf("n ");
                  break;
              default:
                  printf("Syntax error in line %d\n",yylineno);
          }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movl %edi, -0x4(%rbp)
movl -0x4(%rbp), %eax
decl %eax
movl %eax, %ecx
movq %rcx, -0x10(%rbp)
subl $0x7, %eax
ja 0x25b6
movq -0x10(%rbp), %rax
leaq 0x4ada(%rip), %rcx      # 0x7004
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
leaq 0x4aea(%rip), %rdi      # 0x7024
movb $0x0, %al
callq 0x2040
jmp 0x25cd
leaq 0x4adb(%rip), %rdi      # 0x7028
movb $0x0, %al
callq 0x2040
jmp 0x25cd
leaq 0x4acf(%rip), %rdi      # 0x702c
movb $0x0, %al
callq 0x2040
jmp 0x25cd
leaq 0x4ac2(%rip), %rdi      # 0x702f
movb $0x0, %al
callq 0x2040
jmp 0x25cd
leaq 0x4ab5(%rip), %rdi      # 0x7032
movb $0x0, %al
callq 0x2040
jmp 0x25cd
leaq 0x4aa8(%rip), %rdi      # 0x7035
movb $0x0, %al
callq 0x2040
jmp 0x25cd
leaq 0x4a9b(%rip), %rdi      # 0x7038
movb $0x0, %al
callq 0x2040
jmp 0x25cd
leaq 0x4a8e(%rip), %rdi      # 0x703b
movb $0x0, %al
callq 0x2040
jmp 0x25cd
leaq 0x8c33(%rip), %rax      # 0xb1f0
movl (%rax), %esi
leaq 0x4a78(%rip), %rdi      # 0x703e
movb $0x0, %al
callq 0x2040
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: ronakshah725[P]SLR1Parser_C/parser1.cpp
// Function: getAction(int, int, char (*) [16])
int getAction(int state, int token, char x[row][col]){
    
    char* actionString = getVal(state, token, x);
    
    if(isdigit(*actionString))
        return shift;
    else if (isalpha(*actionString))
        return reduce;
    else
        return -100;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movl %edi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movq %rdx, -0x18(%rbp)
movl -0x8(%rbp), %edi
movl -0xc(%rbp), %esi
movq -0x18(%rbp), %rdx
callq 0x2600
movq %rax, -0x20(%rbp)
movq -0x20(%rbp), %rax
movsbl (%rax), %edi
callq 0x2180
cmpl $0x0, %eax
je 0x267f
movl $0x37, -0x4(%rbp)
jmp 0x26a0
movq -0x20(%rbp), %rax
movsbl (%rax), %edi
callq 0x22e0
cmpl $0x0, %eax
je 0x2699
movl $0x4d, -0x4(%rbp)
jmp 0x26a0
movl $0xffffff9c, -0x4(%rbp) # imm = 0xFFFFFF9C
movl -0x4(%rbp), %eax
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax)
// File: ronakshah725[P]SLR1Parser_C/parser1.cpp
// Function: read_table(_IO_FILE*, char (*) [16])
void read_table(FILE* fp, char x[row][col]){
    
    char buf[300];
    
    int i = 0;
    size_t n;
    fgets(buf,sizeof(buf),fp);
    printf("\t\t\t\t\t\t------------TABLE----------\n\n");
    puts(buf);
         printf("\n");
    
    while(fgets(buf,sizeof(buf),fp))
    {
        char *p = strtok(buf,"\t");
        while( p != NULL)
        {
            n = strlen(p);
            if(i>= row && n> col)
                break;
            strcpy(x[i],p);
            i++;
            p = strtok(NULL,"\t");
        }
    }

    
   
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x160, %rsp            # imm = 0x160
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl $0x0, -0x144(%rbp)
leaq -0x140(%rbp), %rdi
movq -0x8(%rbp), %rdx
movl $0x12c, %esi            # imm = 0x12C
callq 0x22d0
leaq 0x496e(%rip), %rdi      # 0x7057
movb $0x0, %al
callq 0x2040
leaq -0x140(%rbp), %rdi
callq 0x22b0
leaq 0x49a6(%rip), %rdi      # 0x70a9
movb $0x0, %al
callq 0x2040
leaq -0x140(%rbp), %rdi
movq -0x8(%rbp), %rdx
movl $0x12c, %esi            # imm = 0x12C
callq 0x22d0
cmpq $0x0, %rax
je 0x27c3
leaq -0x140(%rbp), %rdi
leaq 0x4951(%rip), %rsi      # 0x7088
callq 0x22c0
movq %rax, -0x158(%rbp)
cmpq $0x0, -0x158(%rbp)
je 0x27be
movq -0x158(%rbp), %rdi
callq 0x20f0
movq %rax, -0x150(%rbp)
cmpl $0x1f4, -0x144(%rbp)    # imm = 0x1F4
jl 0x2778
cmpq $0x10, -0x150(%rbp)
jbe 0x2778
jmp 0x27be
movq -0x10(%rbp), %rdi
movslq -0x144(%rbp), %rax
shlq $0x4, %rax
addq %rax, %rdi
movq -0x158(%rbp), %rsi
callq 0x2190
movl -0x144(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x144(%rbp)
xorl %eax, %eax
movl %eax, %edi
leaq 0x48d8(%rip), %rsi      # 0x7088
callq 0x22c0
movq %rax, -0x158(%rbp)
jmp 0x2743
jmp 0x270a
addq $0x160, %rsp            # imm = 0x160
popq %rbp
retq
nopl (%rax)
// File: ronakshah725[P]SLR1Parser_C/parser1.cpp
// Function: getSym(char)
int getSym(char sym){
    for (int i = 0; i<=MAX_SYMBOLS; i++)
        if(tokens[i] == sym)
            return i;
    return -1;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movb %dil, %al
movb %al, -0x5(%rbp)
movl $0x0, -0xc(%rbp)
cmpl $0xe, -0xc(%rbp)
jg 0x2823
movslq -0xc(%rbp), %rcx
leaq 0x89d6(%rip), %rax      # 0xb1d8
movsbl (%rax,%rcx), %eax
movsbl -0x5(%rbp), %ecx
cmpl %ecx, %eax
jne 0x2816
movl -0xc(%rbp), %eax
movl %eax, -0x4(%rbp)
jmp 0x282a
jmp 0x2818
movl -0xc(%rbp), %eax
addl $0x1, %eax
movl %eax, -0xc(%rbp)
jmp 0x27f1
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
movl -0x4(%rbp), %eax
popq %rbp
retq
nop