LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: GAStudyGroup[P]GPX2/src/cross/gpx/sources/GPX2.cpp
// Function: GPX2::checkAllPartitions()
void GPX2::checkAllPartitions()
{
    GPX2Support::setAllEntryAndExits(candidatePartitions,red,blue);

    for(auto cpart : candidatePartitions){
        if(GPX2Support::checkPartition(cpart.second,red,blue)){
            feasiblePartitions.insert(make_pair(cpart.first,cpart.second));
        }else{
            unfeasiblePartitions.insert(make_pair(cpart.first,cpart.second));
        }
    }
    candidatePartitions.clear();
}

// Assembly:
subq $0x88, %rsp
movq %rdi, 0x80(%rsp)
movq 0x80(%rsp), %rdi
movq %rdi, 0x10(%rsp)
movq %rdi, %rsi
addq $0xd8, %rsi
movq %rdi, %rdx
addq $0x108, %rdx            # imm = 0x108
callq 0x6f580
movq 0x10(%rsp), %rax
movq %rax, 0x78(%rsp)
movq 0x78(%rsp), %rdi
callq 0x54cc0
movq %rax, 0x70(%rsp)
movq 0x78(%rsp), %rdi
callq 0x54d10
movq %rax, 0x68(%rsp)
leaq 0x70(%rsp), %rdi
leaq 0x68(%rsp), %rsi
callq 0x54cf0
testb $0x1, %al
jne 0x5fa55
jmp 0x5fb2b
leaq 0x70(%rsp), %rdi
callq 0x54d40
movq 0x10(%rsp), %rdx
movq (%rax), %rcx
movq %rcx, 0x58(%rsp)
movq 0x8(%rax), %rax
movq %rax, 0x60(%rsp)
movq 0x60(%rsp), %rdi
movq %rdx, %rsi
addq $0xd8, %rsi
addq $0x108, %rdx            # imm = 0x108
callq 0x6aa90
testb $0x1, %al
jne 0x5fa96
jmp 0x5fada
movq 0x10(%rsp), %rax
addq $0x30, %rax
movq %rax, 0x8(%rsp)
leaq 0x58(%rsp), %rdi
leaq 0x58(%rsp), %rsi
addq $0x8, %rsi
callq 0x54db0
movq 0x8(%rsp), %rdi
movl %eax, 0x48(%rsp)
movq %rdx, 0x50(%rsp)
leaq 0x48(%rsp), %rsi
callq 0x54d60
movq %rax, 0x38(%rsp)
movb %dl, 0x40(%rsp)
jmp 0x5fb1a
movq 0x10(%rsp), %rax
addq $0x60, %rax
movq %rax, (%rsp)
leaq 0x58(%rsp), %rdi
leaq 0x58(%rsp), %rsi
addq $0x8, %rsi
callq 0x54db0
movq (%rsp), %rdi
movl %eax, 0x28(%rsp)
movq %rdx, 0x30(%rsp)
leaq 0x28(%rsp), %rsi
callq 0x54d60
movq %rax, 0x18(%rsp)
movb %dl, 0x20(%rsp)
jmp 0x5fb1c
leaq 0x70(%rsp), %rdi
callq 0x552a0
jmp 0x5fa3d
movq 0x10(%rsp), %rdi
callq 0x61410
addq $0x88, %rsp
retq
nopl (%rax)
// File: GAStudyGroup[P]GPX2/src/cross/gpx/sources/GPX2.cpp
// Function: GPX2::convertChoosenChild()
vector<int> GPX2::convertChoosenChild(){
    if (offspringChoosen == GPX2Structs::Parent::RED) {
        GPX2Support::removeGhosts(red);
        return(GPX2Support::mapToTour(red));
    } else {
        GPX2Support::removeGhosts(blue);
        return(GPX2Support::mapToTour(blue));
    }
}

// Assembly:
subq $0x28, %rsp
movq %rdi, (%rsp)
movq %rdi, %rax
movq %rax, 0x8(%rsp)
movq %rdi, 0x20(%rsp)
movq %rsi, 0x18(%rsp)
movq 0x18(%rsp), %rax
movq %rax, 0x10(%rsp)
cmpl $0x0, 0x150(%rax)
jne 0x60965
movq 0x10(%rsp), %rdi
addq $0xd8, %rdi
callq 0x6ee20
movq 0x10(%rsp), %rsi
movq (%rsp), %rdi
addq $0xd8, %rsi
callq 0x6d9f0
jmp 0x6098b
movq 0x10(%rsp), %rdi
addq $0x108, %rdi            # imm = 0x108
callq 0x6ee20
movq 0x10(%rsp), %rsi
movq (%rsp), %rdi
addq $0x108, %rsi            # imm = 0x108
callq 0x6d9f0
movq 0x8(%rsp), %rax
addq $0x28, %rsp
retq
nopw %cs:(%rax,%rax)
// File: GAStudyGroup[P]GPX2/src/cross/gpx/sources/GPX2.cpp
// Function: GPX2::~GPX2()
GPX2::~GPX2()
{
    GPX2Support::deleteNodeMap(red);
    GPX2Support::deleteNodeMap(blue);
    GPX2Support::deleteNodeMap(unitedGraph);
    GPX2Support::deletePartitionMap(candidatePartitions);
    GPX2Support::deletePartitionMap(feasiblePartitions);
    GPX2Support::deletePartitionMap(unfeasiblePartitions);
    partitionsChoosen.clear();
    feasiblePartitions.clear();
}

// Assembly:
subq $0x18, %rsp
movq %rdi, 0x10(%rsp)
movq 0x10(%rsp), %rdi
movq %rdi, 0x8(%rsp)
addq $0xd8, %rdi
callq 0x6c740
jmp 0x60a51
movq 0x8(%rsp), %rdi
addq $0x108, %rdi            # imm = 0x108
callq 0x6c740
jmp 0x60a64
movq 0x8(%rsp), %rdi
addq $0x90, %rdi
callq 0x6c740
jmp 0x60a77
movq 0x8(%rsp), %rdi
callq 0x6c690
jmp 0x60a83
movq 0x8(%rsp), %rdi
addq $0x30, %rdi
callq 0x6c690
jmp 0x60a93
movq 0x8(%rsp), %rdi
addq $0x60, %rdi
callq 0x6c690
jmp 0x60aa3
movq 0x8(%rsp), %rdi
addq $0x138, %rdi            # imm = 0x138
callq 0x61770
movq 0x8(%rsp), %rdi
addq $0x30, %rdi
callq 0x61410
movq 0x8(%rsp), %rdi
addq $0x138, %rdi            # imm = 0x138
callq 0x61790
movq 0x8(%rsp), %rdi
addq $0x108, %rdi            # imm = 0x108
callq 0x60b90
movq 0x8(%rsp), %rdi
addq $0xd8, %rdi
callq 0x60b90
movq 0x8(%rsp), %rdi
addq $0xc0, %rdi
callq 0x558d0
movq 0x8(%rsp), %rdi
addq $0x90, %rdi
callq 0x60b90
movq 0x8(%rsp), %rdi
addq $0x60, %rdi
callq 0x55c90
movq 0x8(%rsp), %rdi
addq $0x30, %rdi
callq 0x55c90
movq 0x8(%rsp), %rdi
callq 0x55c90
addq $0x18, %rsp
retq
movq %rax, %rdi
callq 0x9450
nopw (%rax,%rax)
// File: GAStudyGroup[P]GPX2/src/cross/gpx/sources/Node.cpp
// Function: Node::deleteEdge(unsigned int)
void Node::deleteEdge(unsigned i)
{
    if (i <= edges.size()) {
        edges.erase(edges.begin() + i);
    } else {
        exit(EXIT_FAILURE);
    }
}

// Assembly:
subq $0x48, %rsp
movq %rdi, 0x40(%rsp)
movl %esi, 0x3c(%rsp)
movq 0x40(%rsp), %rdi
movq %rdi, 0x8(%rsp)
movl 0x3c(%rsp), %eax
movq %rax, 0x10(%rsp)
addq $0x20, %rdi
callq 0x610e0
movq %rax, %rcx
movq 0x10(%rsp), %rax
cmpq %rcx, %rax
ja 0x6630d
movq 0x8(%rsp), %rdi
movq %rdi, %rax
addq $0x20, %rax
movq %rax, (%rsp)
addq $0x20, %rdi
callq 0x60f80
movq %rax, 0x20(%rsp)
movl 0x3c(%rsp), %eax
movl %eax, %esi
leaq 0x20(%rsp), %rdi
callq 0x66990
movq %rax, 0x28(%rsp)
leaq 0x30(%rsp), %rdi
leaq 0x28(%rsp), %rsi
callq 0x669d0
movq (%rsp), %rdi
movq 0x30(%rsp), %rsi
callq 0x66920
movq %rax, 0x18(%rsp)
jmp 0x66317
movl $0x1, %edi
callq 0x65c0
addq $0x48, %rsp
retq
nopl (%rax)
// File: GAStudyGroup[P]GPX2/src/cross/gpx/sources/Node.cpp
// Function: operator<<(std::ostream&, Node&)
ostream& operator<<(ostream &output, Node &cn){
    output<<"=====\nID: "<<cn.getId()<<"\n";
    output<<"edges: \n";
    for(Node::node n : cn.getEdges()){
        output<<"\tid "<<n.first<<" | dist: "<<n.second<<"\n";
    }
    output<<"is access: "<<cn.getAccess();
    output.flush();
    return(output);
}

// Assembly:
subq $0xc8, %rsp
movq %rdi, 0xc0(%rsp)
movq %rsi, 0xb8(%rsp)
movq 0xc0(%rsp), %rdi
leaq 0xf539(%rip), %rsi      # 0x7590f
callq 0x64a0
movq %rax, 0x30(%rsp)
movq 0xb8(%rsp), %rsi
leaq 0x98(%rsp), %rdi
movq %rdi, 0x38(%rsp)
callq 0x66190
movq 0x30(%rsp), %rdi
movq 0x38(%rsp), %rsi
callq 0x6440
movq %rax, 0x40(%rsp)
jmp 0x66410
movq 0x40(%rsp), %rdi
leaq 0xf432(%rip), %rsi      # 0x7584e
callq 0x64a0
jmp 0x66423
leaq 0x98(%rsp), %rdi
callq 0x6988
movq 0xc0(%rsp), %rdi
leaq 0xf4db(%rip), %rsi      # 0x7591a
callq 0x64a0
movq 0xb8(%rsp), %rdi
callq 0x661c0
movq %rax, 0x80(%rsp)
movq 0x80(%rsp), %rdi
callq 0x60f80
movq %rax, 0x78(%rsp)
movq 0x80(%rsp), %rdi
callq 0x60fb0
movq %rax, 0x70(%rsp)
leaq 0x78(%rsp), %rdi
leaq 0x70(%rsp), %rsi
callq 0x60fe0
testb $0x1, %al
jne 0x66495
jmp 0x6657b
leaq 0x78(%rsp), %rdi
callq 0x61020
movq %rax, %rsi
leaq 0x48(%rsp), %rdi
callq 0x61030
movq 0xc0(%rsp), %rdi
leaq 0xf468(%rip), %rsi      # 0x75923
callq 0x64a0
movq %rax, 0x28(%rsp)
jmp 0x664c7
movq 0x28(%rsp), %rdi
leaq 0x48(%rsp), %rsi
callq 0x6440
movq %rax, 0x20(%rsp)
jmp 0x664dd
movq 0x20(%rsp), %rdi
leaq 0xf43f(%rip), %rsi      # 0x75928
callq 0x64a0
movq %rax, 0x18(%rsp)
jmp 0x664f5
movq 0x18(%rsp), %rdi
movsd 0x68(%rsp), %xmm0
callq 0x6900
movq %rax, 0x10(%rsp)
jmp 0x6650c
movq 0x10(%rsp), %rdi
leaq 0xf336(%rip), %rsi      # 0x7584e
callq 0x64a0
jmp 0x6651f
leaq 0x48(%rsp), %rdi
callq 0x610b0
leaq 0x78(%rsp), %rdi
callq 0x610c0
jmp 0x6647d
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x90(%rsp)
movl %eax, 0x8c(%rsp)
leaq 0x98(%rsp), %rdi
callq 0x6988
jmp 0x665ce
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x90(%rsp)
movl %eax, 0x8c(%rsp)
leaq 0x48(%rsp), %rdi
callq 0x610b0
jmp 0x665ce
movq 0xc0(%rsp), %rdi
leaq 0xf3a8(%rip), %rsi      # 0x75932
callq 0x64a0
movq %rax, 0x8(%rsp)
movq 0xb8(%rsp), %rdi
callq 0x661d0
movq 0x8(%rsp), %rdi
movzbl %al, %esi
andl $0x1, %esi
callq 0x6870
movq 0xc0(%rsp), %rdi
callq 0x6340
movq 0xc0(%rsp), %rax
addq $0xc8, %rsp
retq
movq 0x90(%rsp), %rdi
callq 0x6850
nopl (%rax,%rax)
// File: GAStudyGroup[P]GPX2/src/cross/gpx/sources/GPX2Support.cpp
// Function: GPX2Support::eraseSubVector(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::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>>>>&)
void GPX2Support::eraseSubVector(vector<string>& vec, vector<string>& subvec)
{
    for (unsigned i = 0; i < subvec.size(); i++) {
        for (unsigned j = 0; j < vec.size(); j++) {
            if (subvec[i].compare(vec[j]) == 0) {
                vec.erase(vec.begin() + j);
                break;
            }
        }
    }
}

// Assembly:
subq $0x58, %rsp
movq %rdi, 0x50(%rsp)
movq %rsi, 0x48(%rsp)
movl $0x0, 0x44(%rsp)
movl 0x44(%rsp), %eax
movq %rax, 0x18(%rsp)
movq 0x48(%rsp), %rdi
callq 0x30bb0
movq %rax, %rcx
movq 0x18(%rsp), %rax
cmpq %rcx, %rax
jae 0x6b6c2
movl $0x0, 0x40(%rsp)
movl 0x40(%rsp), %eax
movq %rax, 0x10(%rsp)
movq 0x50(%rsp), %rdi
callq 0x30bb0
movq %rax, %rcx
movq 0x10(%rsp), %rax
cmpq %rcx, %rax
jae 0x6b6b0
movq 0x48(%rsp), %rdi
movl 0x44(%rsp), %eax
movl %eax, %esi
callq 0x49910
movq %rax, 0x8(%rsp)
movq 0x50(%rsp), %rdi
movl 0x40(%rsp), %eax
movl %eax, %esi
callq 0x49910
movq 0x8(%rsp), %rdi
movq %rax, %rsi
callq 0x6060
cmpl $0x0, %eax
jne 0x6b69e
movq 0x50(%rsp), %rax
movq %rax, (%rsp)
movq 0x50(%rsp), %rdi
callq 0x1e310
movq %rax, 0x28(%rsp)
movl 0x40(%rsp), %eax
movl %eax, %esi
leaq 0x28(%rsp), %rdi
callq 0x4a710
movq %rax, 0x30(%rsp)
leaq 0x38(%rsp), %rdi
leaq 0x30(%rsp), %rsi
callq 0x555d0
movq (%rsp), %rdi
movq 0x38(%rsp), %rsi
callq 0x55560
movq %rax, 0x20(%rsp)
jmp 0x6b6b0
jmp 0x6b6a0
movl 0x40(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x40(%rsp)
jmp 0x6b5f2
jmp 0x6b6b2
movl 0x44(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x44(%rsp)
jmp 0x6b5c6
addq $0x58, %rsp
retq
nopw (%rax,%rax)
// File: GAStudyGroup[P]GPX2/src/cross/gpx/sources/GPX2Support.cpp
// Function: GPX2Support::deletePartitionMap(std::map<int, Partition*, std::less<int>, std::allocator<std::pair<int const, Partition*>>>&)
void GPX2Support::deletePartitionMap(GPX2Structs::PartitionMap& m)
{
    // deallocate the pointers and set them to null, then clear the map

    for (auto& it : m) {
        delete it.second;
        it.second = nullptr;
    }
    m.clear();
}

// Assembly:
subq $0x38, %rsp
movq %rdi, 0x30(%rsp)
movq 0x30(%rsp), %rax
movq %rax, 0x28(%rsp)
movq 0x28(%rsp), %rdi
callq 0x54cc0
movq %rax, 0x20(%rsp)
movq 0x28(%rsp), %rdi
callq 0x54d10
movq %rax, 0x18(%rsp)
leaq 0x20(%rsp), %rdi
leaq 0x18(%rsp), %rsi
callq 0x54cf0
testb $0x1, %al
jne 0x6c6d6
jmp 0x6c72b
leaq 0x20(%rsp), %rdi
callq 0x54d40
movq %rax, 0x10(%rsp)
movq 0x10(%rsp), %rax
movq 0x8(%rax), %rax
movq %rax, 0x8(%rsp)
cmpq $0x0, %rax
je 0x6c712
movq 0x8(%rsp), %rdi
callq 0x556f0
movq 0x8(%rsp), %rdi
movl $0x80, %esi
callq 0x64c0
movq 0x10(%rsp), %rax
movq $0x0, 0x8(%rax)
leaq 0x20(%rsp), %rdi
callq 0x552a0
jmp 0x6c6c1
movq 0x30(%rsp), %rdi
callq 0x61410
addq $0x38, %rsp
retq
nopw (%rax,%rax)
// File: GAStudyGroup[P]GPX2/src/cross/gpx/sources/GPX2Support.cpp
// Function: GPX2Support::deleteNodeMap(std::map<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, Node*, std::less<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>, std::allocator<std::pair<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const, Node*>>>&)
void GPX2Support::deleteNodeMap(GPX2Structs::NodeMap& m)
{ // deletar o mapa completamente,
    // desalocando os ponteiros tb
    for (auto& it : m) {
        delete it.second;
        it.second = nullptr;
    }
    m.clear();
}

// Assembly:
subq $0x38, %rsp
movq %rdi, 0x30(%rsp)
movq 0x30(%rsp), %rax
movq %rax, 0x28(%rsp)
movq 0x28(%rsp), %rdi
callq 0x60ba0
movq %rax, 0x20(%rsp)
movq 0x28(%rsp), %rdi
callq 0x60bd0
movq %rax, 0x18(%rsp)
leaq 0x20(%rsp), %rdi
leaq 0x18(%rsp), %rsi
callq 0x60c00
testb $0x1, %al
jne 0x6c786
jmp 0x6c7db
leaq 0x20(%rsp), %rdi
callq 0x60c20
movq %rax, 0x10(%rsp)
movq 0x10(%rsp), %rax
movq 0x20(%rax), %rax
movq %rax, 0x8(%rsp)
cmpq $0x0, %rax
je 0x6c7c2
movq 0x8(%rsp), %rdi
callq 0x61540
movq 0x8(%rsp), %rdi
movl $0x40, %esi
callq 0x64c0
movq 0x10(%rsp), %rax
movq $0x0, 0x20(%rax)
leaq 0x20(%rsp), %rdi
callq 0x60d70
jmp 0x6c771
movq 0x30(%rsp), %rdi
callq 0x70680
addq $0x38, %rsp
retq
nopw (%rax,%rax)
// File: GAStudyGroup[P]GPX2/src/cross/gpx/sources/GPX2Support.cpp
// Function: GPX2Support::whichPartition(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, std::map<int, Partition*, std::less<int>, std::allocator<std::pair<int const, Partition*>>>)
int GPX2Support::whichPartition(const string id, GPX2Structs::PartitionMap partitions)
{ // Procura em qual partição está a cidade procurada, retorna o ID da partição
    for (auto& p : partitions) {
        if (find(p.second->getNodes().begin(), p.second->getNodes().end(), id) != p.second->getNodes().end()) {
            return (p.first);
        }
    }
    return (-1);
}

// Assembly:
subq $0x68, %rsp
movq %rdi, 0x8(%rsp)
movq %rdi, 0x58(%rsp)
movq %rsi, 0x50(%rsp)
movq %rsi, 0x48(%rsp)
movq 0x48(%rsp), %rdi
callq 0x54cc0
movq %rax, 0x40(%rsp)
movq 0x48(%rsp), %rdi
callq 0x54d10
movq %rax, 0x38(%rsp)
leaq 0x40(%rsp), %rdi
leaq 0x38(%rsp), %rsi
callq 0x54cf0
testb $0x1, %al
jne 0x6c83e
jmp 0x6c8ea
leaq 0x40(%rsp), %rdi
callq 0x54d40
movq %rax, 0x30(%rsp)
movq 0x30(%rsp), %rax
movq 0x8(%rax), %rdi
callq 0x67e70
movq %rax, %rdi
callq 0x1e310
movq %rax, 0x20(%rsp)
movq 0x30(%rsp), %rax
movq 0x8(%rax), %rdi
callq 0x67e70
movq %rax, %rdi
callq 0x1e340
movq 0x8(%rsp), %rdx
movq %rax, 0x18(%rsp)
movq 0x20(%rsp), %rdi
movq 0x18(%rsp), %rsi
callq 0x49c90
movq %rax, 0x28(%rsp)
movq 0x30(%rsp), %rax
movq 0x8(%rax), %rdi
callq 0x67e70
movq %rax, %rdi
callq 0x1e340
movq %rax, 0x10(%rsp)
leaq 0x28(%rsp), %rdi
leaq 0x10(%rsp), %rsi
callq 0x1e370
testb $0x1, %al
jne 0x6c8cc
jmp 0x6c8d9
movq 0x30(%rsp), %rax
movl (%rax), %eax
movl %eax, 0x64(%rsp)
jmp 0x6c8f2
jmp 0x6c8db
leaq 0x40(%rsp), %rdi
callq 0x552a0
jmp 0x6c826
movl $0xffffffff, 0x64(%rsp) # imm = 0xFFFFFFFF
movl 0x64(%rsp), %eax
addq $0x68, %rsp
retq
nopl (%rax,%rax)
// File: iZhangHui[P]CppPrimer/CH17_SpecializedLibraryFacilities/examples/no-skipws.cc
// Function: main
int main()
{
	char ch;
	cin >> noskipws;  // set cin so that it reads whitespace
	while (cin >> ch)
		cout << ch;
	cin >> skipws;    // reset cin to the default state 
	                  // so that it ignores whitespace

	return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movl $0x0, -0x4(%rbp)
movq 0x2dfa(%rip), %rdi      # 0x3fe0
leaq 0x63(%rip), %rsi        # 0x1250
callq 0x1080
movq 0x2de7(%rip), %rdi      # 0x3fe0
leaq -0x5(%rbp), %rsi
callq 0x1060
movq %rax, %rdi
movq (%rdi), %rax
addq -0x18(%rax), %rdi
callq 0x1050
testb $0x1, %al
jne 0x1217
jmp 0x1229
movq 0x2db2(%rip), %rdi      # 0x3fd0
movsbl -0x5(%rbp), %esi
callq 0x1040
jmp 0x11f2
movq 0x2db0(%rip), %rdi      # 0x3fe0
leaq 0x49(%rip), %rsi        # 0x1280
callq 0x1080
xorl %eax, %eax
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
nop
// File: smuething[P]dune-cxx11/25-unordered_set.cc
// Function: main
int main()
{
  std::unordered_set<double> s;
  s.insert(3.7);
  assert(s.count(3.7) > 0);
  return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x90, %rsp
movl $0x0, -0x4(%rbp)
leaq -0x40(%rbp), %rdi
movq %rdi, -0x88(%rbp)
callq 0x12f0
movq -0x88(%rbp), %rdi
movabsq $0x400d99999999999a, %rax # imm = 0x400D99999999999A
movq %rax, -0x48(%rbp)
leaq -0x48(%rbp), %rsi
callq 0x1310
movb %dl, -0x79(%rbp)
movq %rax, -0x78(%rbp)
jmp 0x1249
movb -0x79(%rbp), %al
movq -0x78(%rbp), %rcx
movq %rcx, -0x68(%rbp)
movb %al, -0x60(%rbp)
movabsq $0x400d99999999999a, %rax # imm = 0x400D99999999999A
movq %rax, -0x70(%rbp)
leaq -0x40(%rbp), %rdi
leaq -0x70(%rbp), %rsi
callq 0x1350
movq %rax, -0x90(%rbp)
jmp 0x127b
movq -0x90(%rbp), %rax
cmpq $0x0, %rax
jbe 0x128a
jmp 0x12c0
leaq 0x1d77(%rip), %rdi      # 0x3008
leaq 0x1d81(%rip), %rsi      # 0x3019
movl $0x8, %edx
leaq 0x1d89(%rip), %rcx      # 0x302d
callq 0x1080
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x50(%rbp)
movl %eax, -0x54(%rbp)
leaq -0x40(%rbp), %rdi
callq 0x1380
jmp 0x12dc
movl $0x0, -0x4(%rbp)
leaq -0x40(%rbp), %rdi
callq 0x1380
movl -0x4(%rbp), %eax
addq $0x90, %rsp
popq %rbp
retq
movq -0x50(%rbp), %rdi
callq 0x10f0
nopw %cs:(%rax,%rax)
nop
// File: WeihuaZhu[P]hpc_prog2/./gtest/gtest.h
// Function: testing::internal::scoped_ptr<std::__cxx11::basic_stringstream<char, std::char_traits<char>, std::allocator<char>>>::reset(std::__cxx11::basic_stringstream<char, std::char_traits<char>, std::allocator<char>>*)
void reset(T* p = NULL) {
    if (p != ptr_) {
      if (IsTrue(sizeof(T) > 0)) {  // Makes sure T is a complete type.
        delete ptr_;
      }
      ptr_ = p;
    }
  }

// Assembly:
subq $0x28, %rsp
movq %rdi, 0x20(%rsp)
movq %rsi, 0x18(%rsp)
movq 0x20(%rsp), %rcx
movq %rcx, 0x10(%rsp)
movq 0x18(%rsp), %rax
cmpq (%rcx), %rax
je 0x108cf
movl $0x1, %edi
callq 0x16400
testb $0x1, %al
jne 0x108a2
jmp 0x108c2
movq 0x10(%rsp), %rax
movq (%rax), %rax
movq %rax, 0x8(%rsp)
cmpq $0x0, %rax
je 0x108c0
movq 0x8(%rsp), %rdi
movq (%rdi), %rax
callq *0x8(%rax)
jmp 0x108c2
movq 0x10(%rsp), %rax
movq 0x18(%rsp), %rcx
movq %rcx, (%rax)
addq $0x28, %rsp
retq
nopw %cs:(%rax,%rax)
nop
// File: WeihuaZhu[P]hpc_prog2/mpi_gtest.cpp
// Function: main
int main(int argc, char* argv[]) {
    int result = 0;

    ::testing::InitGoogleTest(&argc, argv);
    MPI_Init(&argc, &argv);

    // get processor rank
    int rank, p;
    MPI_Comm_size(MPI_COMM_WORLD, &p);
    MPI_Comm_rank(MPI_COMM_WORLD, &rank);

    if (rank == 0)
      std::cout << "Running GTEST with MPI with " << p << " processes." << std::endl;

    // set up wrapped test listener
    ::testing::TestEventListeners& listeners =
      ::testing::UnitTest::GetInstance()->listeners();
    ::testing::TestEventListener* default_listener =  listeners.Release(listeners.default_result_printer());
    listeners.Append(new mpi_gtest::MpiTestEventListener(rank, default_listener));

    // running tests
    result = RUN_ALL_TESTS();

    // clean up MPI
    MPI_Finalize();

    // return good status no matter what
    return 0;
}

// Assembly:
subq $0x58, %rsp
movl $0x0, 0x54(%rsp)
movl %edi, 0x50(%rsp)
movq %rsi, 0x48(%rsp)
movl $0x0, 0x44(%rsp)
movq 0x48(%rsp), %rsi
leaq 0x50(%rsp), %rdi
callq 0x29220
leaq 0x50(%rsp), %rdi
leaq 0x48(%rsp), %rsi
callq 0xf030
movq 0x544e6(%rip), %rdi     # 0x64f98
leaq 0x3c(%rsp), %rsi
callq 0xecb0
movq 0x544d5(%rip), %rdi     # 0x64f98
leaq 0x40(%rsp), %rsi
callq 0xf020
cmpl $0x0, 0x40(%rsp)
jne 0x10b11
movq 0x544dd(%rip), %rdi     # 0x64fb8
leaq 0x3a805(%rip), %rsi     # 0x4b2e7
callq 0xea00
movq %rax, %rdi
movl 0x3c(%rsp), %esi
callq 0xf3d0
movq %rax, %rdi
leaq 0x3a807(%rip), %rsi     # 0x4b304
callq 0xea00
movq %rax, %rdi
movq 0x54484(%rip), %rsi     # 0x64f90
callq 0xeaa0
callq 0x16600
movq %rax, %rdi
callq 0x1f360
movq %rax, 0x30(%rsp)
movq 0x30(%rsp), %rdi
movq %rdi, (%rsp)
callq 0x112b0
movq (%rsp), %rdi
movq %rax, %rsi
callq 0x26560
movq %rax, 0x28(%rsp)
movq 0x30(%rsp), %rax
movq %rax, 0x8(%rsp)
movl $0x18, %edi
callq 0xea20
movq %rax, %rdi
movq %rdi, %rax
movq %rax, 0x10(%rsp)
movl 0x40(%rsp), %esi
movq 0x28(%rsp), %rdx
callq 0x112c0
jmp 0x10b71
movq 0x10(%rsp), %rsi
movq 0x8(%rsp), %rdi
callq 0x26530
callq 0x11310
movl %eax, 0x44(%rsp)
callq 0xe770
xorl %eax, %eax
addq $0x58, %rsp
retq
movq 0x10(%rsp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x20(%rsp)
movl %eax, 0x1c(%rsp)
movl $0x18, %esi
callq 0xea60
movq 0x20(%rsp), %rdi
callq 0xf410
nopl (%rax)
// File: WeihuaZhu[P]hpc_prog2/./gtest/gtest-all.cc
// Function: testing::internal::BoolFromGTestEnv(char const*, bool)
bool BoolFromGTestEnv(const char* flag, bool default_value) {
  const std::string env_var = FlagToEnvVar(flag);
  const char* const string_value = posix::GetEnv(env_var.c_str());
  return string_value == NULL ?
      default_value : strcmp(string_value, "0") != 0;
}

// Assembly:
subq $0x68, %rsp
movb %sil, %al
movq %rdi, 0x60(%rsp)
andb $0x1, %al
movb %al, 0x5f(%rsp)
movq 0x60(%rsp), %rsi
leaq 0x38(%rsp), %rdi
movq %rdi, 0x10(%rsp)
callq 0x30330
movq 0x10(%rsp), %rdi
callq 0xe370
movq %rax, %rdi
callq 0x36880
movq %rax, 0x18(%rsp)
jmp 0x15e6f
movq 0x18(%rsp), %rax
movq %rax, 0x30(%rsp)
cmpq $0x0, 0x30(%rsp)
jne 0x15e8b
movb 0x5f(%rsp), %al
movb %al, 0xf(%rsp)
jmp 0x15ea6
movq 0x30(%rsp), %rdi
leaq 0x384c1(%rip), %rsi     # 0x4e358
callq 0xefe0
cmpl $0x0, %eax
setne %al
movb %al, 0xf(%rsp)
movb 0xf(%rsp), %al
movb %al, 0xe(%rsp)
leaq 0x38(%rsp), %rdi
callq 0xf698
movb 0xe(%rsp), %al
andb $0x1, %al
addq $0x68, %rsp
retq
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x28(%rsp)
movl %eax, 0x24(%rsp)
leaq 0x38(%rsp), %rdi
callq 0xf698
movq 0x28(%rsp), %rdi
callq 0xf410
nopw %cs:(%rax,%rax)
// File: WeihuaZhu[P]hpc_prog2/./gtest/gtest-all.cc
// Function: testing::internal::Int32FromGTestEnv(char const*, int)
Int32 Int32FromGTestEnv(const char* flag, Int32 default_value) {
  const std::string env_var = FlagToEnvVar(flag);
  const char* const string_value = posix::GetEnv(env_var.c_str());
  if (string_value == NULL) {
    // The environment variable is not set.
    return default_value;
  }

  Int32 result = default_value;
  if (!ParseInt32(Message() << "Environment variable " << env_var,
                  string_value, &result)) {
    printf("The default value %s is used.\n",
           (Message() << default_value).GetString().c_str());
    fflush(stdout);
    return default_value;
  }

  return result;
}

// Assembly:
subq $0xb8, %rsp
movq %rdi, 0xa8(%rsp)
movl %esi, 0xa4(%rsp)
movq 0xa8(%rsp), %rsi
leaq 0x80(%rsp), %rdi
movq %rdi, 0x20(%rsp)
callq 0x30330
movq 0x20(%rsp), %rdi
callq 0xe370
movq %rax, %rdi
callq 0x36880
movq %rax, 0x28(%rsp)
jmp 0x15ff9
movq 0x28(%rsp), %rax
movq %rax, 0x78(%rsp)
cmpq $0x0, 0x78(%rsp)
jne 0x16039
movl 0xa4(%rsp), %eax
movl %eax, 0xb4(%rsp)
movl $0x1, 0x68(%rsp)
jmp 0x161ab
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x70(%rsp)
movl %eax, 0x6c(%rsp)
jmp 0x161c7
movl 0xa4(%rsp), %eax
movl %eax, 0x64(%rsp)
leaq 0x58(%rsp), %rdi
callq 0x192e0
jmp 0x16050
leaq 0x37bc5(%rip), %rsi     # 0x4dc1c
leaq 0x58(%rsp), %rdi
callq 0x3acb0
movq %rax, 0x18(%rsp)
jmp 0x16068
movq 0x18(%rsp), %rdi
leaq 0x80(%rsp), %rsi
callq 0x32e10
movq %rax, 0x10(%rsp)
jmp 0x16081
movq 0x10(%rsp), %rdi
movq 0x78(%rsp), %rsi
leaq 0x64(%rsp), %rdx
callq 0x28830
movb %al, 0xf(%rsp)
jmp 0x1609b
movb 0xf(%rsp), %al
xorb $-0x1, %al
movb %al, 0xe(%rsp)
leaq 0x58(%rsp), %rdi
callq 0x105d0
movb 0xe(%rsp), %al
testb $0x1, %al
jne 0x160bc
jmp 0x16198
leaq 0x30(%rsp), %rdi
callq 0x192e0
jmp 0x160c8
leaq 0x30(%rsp), %rdi
leaq 0xa4(%rsp), %rsi
callq 0x10540
movq %rax, (%rsp)
jmp 0x160e0
movq (%rsp), %rsi
leaq 0x38(%rsp), %rdi
callq 0x196c0
jmp 0x160f0
leaq 0x38(%rsp), %rdi
callq 0xe370
movq %rax, %rsi
leaq 0x37b2e(%rip), %rdi     # 0x4dc32
xorl %eax, %eax
callq 0xe090
jmp 0x1610d
leaq 0x38(%rsp), %rdi
callq 0xf698
leaq 0x30(%rsp), %rdi
callq 0x105d0
movq 0x4ee58(%rip), %rax     # 0x64f80
movq (%rax), %rdi
callq 0xecc0
jmp 0x16132
movl 0xa4(%rsp), %eax
movl %eax, 0xb4(%rsp)
movl $0x1, 0x68(%rsp)
jmp 0x161ab
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x70(%rsp)
movl %eax, 0x6c(%rsp)
leaq 0x58(%rsp), %rdi
callq 0x105d0
jmp 0x161c7
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x70(%rsp)
movl %eax, 0x6c(%rsp)
jmp 0x1618c
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x70(%rsp)
movl %eax, 0x6c(%rsp)
leaq 0x38(%rsp), %rdi
callq 0xf698
leaq 0x30(%rsp), %rdi
callq 0x105d0
jmp 0x161c7
movl 0x64(%rsp), %eax
movl %eax, 0xb4(%rsp)
movl $0x1, 0x68(%rsp)
leaq 0x80(%rsp), %rdi
callq 0xf698
movl 0xb4(%rsp), %eax
addq $0xb8, %rsp
retq
leaq 0x80(%rsp), %rdi
callq 0xf698
movq 0x70(%rsp), %rdi
callq 0xf410
nop
// File: WeihuaZhu[P]hpc_prog2/./gtest/gtest-all.cc
// Function: testing::internal::AssertHelper::operator=(testing::Message const&) const
void AssertHelper::operator=(const Message& message) const {
  UnitTest::GetInstance()->
    AddTestPartResult(data_->type, data_->file, data_->line,
                      AppendUserMessage(data_->message, message),
                      UnitTest::GetInstance()->impl()
                      ->CurrentOsStackTraceExceptTop(1)
                      // Skips the stack frame for this function itself.
                      );  // NOLINT
}

// Assembly:
subq $0x98, %rsp
movq %rdi, 0x90(%rsp)
movq %rsi, 0x88(%rsp)
movq 0x90(%rsp), %rax
movq %rax, 0x8(%rsp)
callq 0x16600
movq %rax, %rcx
movq 0x8(%rsp), %rax
movq %rcx, 0x10(%rsp)
movq (%rax), %rsi
movl (%rsi), %eax
movl %eax, 0x1c(%rsp)
movq 0x8(%rsi), %rax
movq %rax, 0x20(%rsp)
movl 0x10(%rsi), %eax
movl %eax, 0x2c(%rsp)
addq $0x18, %rsi
movq 0x88(%rsp), %rdx
leaq 0x68(%rsp), %rdi
callq 0x16b20
callq 0x16600
movq %rax, 0x30(%rsp)
jmp 0x16551
movq 0x30(%rsp), %rdi
callq 0x32b10
movq %rax, (%rsp)
jmp 0x16561
movq (%rsp), %rsi
leaq 0x48(%rsp), %rdi
movl $0x1, %edx
callq 0x16c10
jmp 0x16576
movl 0x2c(%rsp), %ecx
movq 0x20(%rsp), %rdx
movl 0x1c(%rsp), %esi
movq 0x10(%rsp), %rdi
leaq 0x68(%rsp), %r8
leaq 0x48(%rsp), %r9
callq 0x16690
jmp 0x16599
leaq 0x48(%rsp), %rdi
callq 0xf698
leaq 0x68(%rsp), %rdi
callq 0xf698
addq $0x98, %rsp
retq
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x40(%rsp)
movl %eax, 0x3c(%rsp)
jmp 0x165dd
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x40(%rsp)
movl %eax, 0x3c(%rsp)
leaq 0x48(%rsp), %rdi
callq 0xf698
leaq 0x68(%rsp), %rdi
callq 0xf698
movq 0x40(%rsp), %rdi
callq 0xf410
nopw %cs:(%rax,%rax)
// File: WeihuaZhu[P]hpc_prog2/./gtest/gtest-all.cc
// Function: testing::UnitTest::GetInstance()
UnitTest* UnitTest::GetInstance() {
  // When compiled with MSVC 7.1 in optimized mode, destroying the
  // UnitTest object upon exiting the program messes up the exit code,
  // causing successful tests to appear failed.  We have to use a
  // different implementation in this case to bypass the compiler bug.
  // This implementation makes the compiler happy, at the cost of
  // leaking the UnitTest object.

  // CodeGear C++Builder insists on a public destructor for the
  // default implementation.  Use this implementation to keep good OO
  // design with private destructor.

#if (_MSC_VER == 1310 && !defined(_DEBUG)) || defined(__BORLANDC__)
  static UnitTest* const instance = new UnitTest;
  return instance;
#else
  static UnitTest instance;
  return &instance;
#endif  // (_MSC_VER == 1310 && !defined(_DEBUG)) || defined(__BORLANDC__)
}

// Assembly:
subq $0x18, %rsp
cmpb $0x0, 0x4f6f5(%rip)     # 0x65d00
jne 0x16652
leaq 0x4f6ec(%rip), %rdi     # 0x65d00
callq 0xf4a0
cmpl $0x0, %eax
je 0x16652
leaq 0x4f693(%rip), %rdi     # 0x65cb8
callq 0x26f40
jmp 0x1662c
leaq 0x109bd(%rip), %rdi     # 0x26ff0
leaq 0x4f67e(%rip), %rsi     # 0x65cb8
leaq 0x4f50f(%rip), %rdx     # 0x65b50
callq 0xe8e0
leaq 0x4f6b3(%rip), %rdi     # 0x65d00
callq 0xe610
leaq 0x4f65f(%rip), %rax     # 0x65cb8
addq $0x18, %rsp
retq
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x10(%rsp)
movl %eax, 0xc(%rsp)
leaq 0x4f68d(%rip), %rdi     # 0x65d00
callq 0xe5f0
movq 0x10(%rsp), %rdi
callq 0xf410
nopw %cs:(%rax,%rax)
// File: WeihuaZhu[P]hpc_prog2/./gtest/gtest-all.cc
// Function: testing::internal::AppendUserMessage(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&, testing::Message const&)
std::string AppendUserMessage(const std::string& gtest_msg,
                              const Message& user_msg) {
  // Appends the user message if it's non-empty.
  const std::string user_msg_string = user_msg.GetString();
  if (user_msg_string.empty()) {
    return gtest_msg;
  }

  return gtest_msg + "\n" + user_msg_string;
}

// Assembly:
subq $0x78, %rsp
movq %rdi, (%rsp)
movq %rdi, %rax
movq %rax, 0x8(%rsp)
movq %rdi, 0x70(%rsp)
movq %rsi, 0x68(%rsp)
movq %rdx, 0x60(%rsp)
movq 0x60(%rsp), %rsi
leaq 0x40(%rsp), %rdi
callq 0x196c0
leaq 0x40(%rsp), %rdi
callq 0xf2f0
testb $0x1, %al
jne 0x16b5e
jmp 0x16b88
movq (%rsp), %rdi
movq 0x68(%rsp), %rsi
callq 0xe3a0
jmp 0x16b6e
movl $0x1, 0x30(%rsp)
jmp 0x16be3
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x38(%rsp)
movl %eax, 0x34(%rsp)
jmp 0x16bf7
movq 0x68(%rsp), %rsi
leaq 0x365e1(%rip), %rdx     # 0x4d175
leaq 0x10(%rsp), %rdi
callq 0x32cc0
jmp 0x16ba0
movq (%rsp), %rdi
leaq 0x10(%rsp), %rsi
leaq 0x40(%rsp), %rdx
callq 0x347c0
jmp 0x16bb5
leaq 0x10(%rsp), %rdi
callq 0xf698
movl $0x1, 0x30(%rsp)
jmp 0x16be3
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x38(%rsp)
movl %eax, 0x34(%rsp)
leaq 0x10(%rsp), %rdi
callq 0xf698
jmp 0x16bf7
leaq 0x40(%rsp), %rdi
callq 0xf698
movq 0x8(%rsp), %rax
addq $0x78, %rsp
retq
leaq 0x40(%rsp), %rdi
callq 0xf698
movq 0x38(%rsp), %rdi
callq 0xf410
nopl (%rax,%rax)
// File: WeihuaZhu[P]hpc_prog2/./gtest/gtest-all.cc
// Function: testing::internal::GetCurrentExecutableName()
FilePath GetCurrentExecutableName() {
  FilePath result;

#if GTEST_OS_WINDOWS
  result.Set(FilePath(g_executable_path).RemoveExtension("exe"));
#else
  result.Set(FilePath(g_executable_path));
#endif  // GTEST_OS_WINDOWS

  return result.RemoveDirectoryName();
}

// Assembly:
subq $0x68, %rsp
movq %rdi, (%rsp)
movq %rdi, %rax
movq %rax, 0x8(%rsp)
movq %rdi, 0x60(%rsp)
leaq 0x40(%rsp), %rdi
callq 0x32b20
leaq 0x4efca(%rip), %rsi     # 0x65c80
leaq 0x20(%rsp), %rdi
callq 0x32bc0
jmp 0x16cc2
leaq 0x40(%rsp), %rdi
leaq 0x20(%rsp), %rsi
callq 0x32b90
jmp 0x16cd3
leaq 0x20(%rsp), %rdi
callq 0x32c20
movq (%rsp), %rdi
leaq 0x40(%rsp), %rsi
callq 0x16d40
jmp 0x16ced
leaq 0x40(%rsp), %rdi
callq 0x32c20
movq 0x8(%rsp), %rax
addq $0x68, %rsp
retq
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x18(%rsp)
movl %eax, 0x14(%rsp)
jmp 0x16d29
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x18(%rsp)
movl %eax, 0x14(%rsp)
leaq 0x20(%rsp), %rdi
callq 0x32c20
leaq 0x40(%rsp), %rdi
callq 0x32c20
movq 0x18(%rsp), %rdi
callq 0xf410
nopl (%rax)
// File: WeihuaZhu[P]hpc_prog2/./gtest/gtest-all.cc
// Function: testing::internal::UnitTestOptions::GetOutputFormat[abi:cxx11]()
std::string UnitTestOptions::GetOutputFormat() {
  const char* const gtest_output_flag = GTEST_FLAG(output).c_str();
  if (gtest_output_flag == NULL) return std::string("");

  const char* const colon = strchr(gtest_output_flag, ':');
  return (colon == NULL) ?
      std::string(gtest_output_flag) :
      std::string(gtest_output_flag, colon - gtest_output_flag);
}

// Assembly:
subq $0x78, %rsp
movq %rdi, 0x30(%rsp)
movq %rdi, %rax
movq %rax, 0x38(%rsp)
movq %rdi, 0x70(%rsp)
leaq 0x4ed5b(%rip), %rdi     # 0x65be8
callq 0xe370
movq %rax, 0x68(%rsp)
cmpq $0x0, 0x68(%rsp)
jne 0x16ef2
leaq 0x67(%rsp), %rdi
movq %rdi, 0x28(%rsp)
callq 0xf420
movq 0x30(%rsp), %rdi
movq 0x28(%rsp), %rdx
leaq 0x362b7(%rip), %rsi     # 0x4d176
callq 0x32980
jmp 0x16ec6
leaq 0x67(%rsp), %rdi
callq 0xeb40
jmp 0x17007
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x58(%rsp)
movl %eax, 0x54(%rsp)
leaq 0x67(%rsp), %rdi
callq 0xeb40
jmp 0x17011
movq 0x68(%rsp), %rdi
movl $0x3a, %esi
callq 0xe340
movq %rax, 0x48(%rsp)
movq 0x48(%rsp), %rax
movb $0x0, 0x46(%rsp)
movb $0x0, 0x44(%rsp)
cmpq $0x0, %rax
jne 0x16f51
movq 0x68(%rsp), %rax
movq %rax, 0x18(%rsp)
leaq 0x47(%rsp), %rdi
movq %rdi, 0x20(%rsp)
callq 0xf420
movq 0x30(%rsp), %rdi
movq 0x18(%rsp), %rsi
movq 0x20(%rsp), %rdx
movb $0x1, 0x46(%rsp)
callq 0x32980
jmp 0x16f4f
jmp 0x16f97
movq 0x68(%rsp), %rcx
movq %rcx, (%rsp)
movq 0x48(%rsp), %rax
subq %rcx, %rax
movq %rax, 0x8(%rsp)
leaq 0x45(%rsp), %rdi
movq %rdi, 0x10(%rsp)
callq 0xf420
movq 0x30(%rsp), %rdi
movq (%rsp), %rsi
movq 0x8(%rsp), %rdx
movq 0x10(%rsp), %rcx
movb $0x1, 0x44(%rsp)
callq 0xec30
jmp 0x16f95
jmp 0x16f97
testb $0x1, 0x44(%rsp)
jne 0x16fa0
jmp 0x16faa
leaq 0x45(%rsp), %rdi
callq 0xeb40
testb $0x1, 0x46(%rsp)
jne 0x16fb3
jmp 0x16fbd
leaq 0x47(%rsp), %rdi
callq 0xeb40
jmp 0x17007
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x58(%rsp)
movl %eax, 0x54(%rsp)
jmp 0x16ff2
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x58(%rsp)
movl %eax, 0x54(%rsp)
testb $0x1, 0x44(%rsp)
jne 0x16fe6
jmp 0x16ff0
leaq 0x45(%rsp), %rdi
callq 0xeb40
jmp 0x16ff2
testb $0x1, 0x46(%rsp)
jne 0x16ffb
jmp 0x17005
leaq 0x47(%rsp), %rdi
callq 0xeb40
jmp 0x17011
movq 0x38(%rsp), %rax
addq $0x78, %rsp
retq
movq 0x58(%rsp), %rdi
callq 0xf410
nopl (%rax,%rax)
// File: WeihuaZhu[P]hpc_prog2/./gtest/gtest-all.cc
// Function: testing::internal::FilePath::ConcatPaths(testing::internal::FilePath const&, testing::internal::FilePath const&)
FilePath FilePath::ConcatPaths(const FilePath& directory,
                               const FilePath& relative_path) {
  if (directory.IsEmpty())
    return relative_path;
  const FilePath dir(directory.RemoveTrailingPathSeparator());
  return FilePath(dir.string() + kPathSeparator + relative_path.string());
}

// Assembly:
subq $0xb8, %rsp
movq %rdi, 0x20(%rsp)
movq %rdi, %rax
movq %rax, 0x28(%rsp)
movq %rdi, 0xb0(%rsp)
movq %rsi, 0xa8(%rsp)
movq %rdx, 0xa0(%rsp)
movq 0xa8(%rsp), %rdi
callq 0x3a8b0
testb $0x1, %al
jne 0x1781f
jmp 0x17836
movq 0x20(%rsp), %rdi
movq 0xa0(%rsp), %rsi
callq 0x3a880
jmp 0x17926
movq 0xa8(%rsp), %rsi
leaq 0x80(%rsp), %rdi
movq %rdi, 0x10(%rsp)
callq 0x2f5e0
movq 0x10(%rsp), %rdi
callq 0x32c30
movq %rax, 0x18(%rsp)
jmp 0x17861
movq 0x18(%rsp), %rsi
leaq 0x40(%rsp), %rdi
movl $0x2f, %edx
callq 0x3a8d0
jmp 0x17877
movq 0xa0(%rsp), %rdi
callq 0x32c30
movq %rax, 0x8(%rsp)
jmp 0x1788b
movq 0x8(%rsp), %rdx
leaq 0x60(%rsp), %rdi
leaq 0x40(%rsp), %rsi
callq 0x347c0
jmp 0x178a1
movq 0x20(%rsp), %rdi
leaq 0x60(%rsp), %rsi
callq 0x32bc0
jmp 0x178b2
leaq 0x60(%rsp), %rdi
callq 0xf698
leaq 0x40(%rsp), %rdi
callq 0xf698
leaq 0x80(%rsp), %rdi
callq 0x32c20
jmp 0x17926
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x38(%rsp)
movl %eax, 0x34(%rsp)
jmp 0x17917
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x38(%rsp)
movl %eax, 0x34(%rsp)
jmp 0x1790d
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x38(%rsp)
movl %eax, 0x34(%rsp)
leaq 0x60(%rsp), %rdi
callq 0xf698
leaq 0x40(%rsp), %rdi
callq 0xf698
leaq 0x80(%rsp), %rdi
callq 0x32c20
jmp 0x17933
movq 0x28(%rsp), %rax
addq $0xb8, %rsp
retq
movq 0x38(%rsp), %rdi
callq 0xf410
nopl (%rax)
// File: WeihuaZhu[P]hpc_prog2/./gtest/gtest-all.cc
// Function: testing::internal::FilePath::GenerateUniqueFileName(testing::internal::FilePath const&, testing::internal::FilePath const&, char const*)
FilePath FilePath::GenerateUniqueFileName(const FilePath& directory,
                                          const FilePath& base_name,
                                          const char* extension) {
  FilePath full_pathname;
  int number = 0;
  do {
    full_pathname.Set(MakeFileName(directory, base_name, number++, extension));
  } while (full_pathname.FileOrDirectoryExists());
  return full_pathname;
}

// Assembly:
subq $0x78, %rsp
movq %rdi, 0x10(%rsp)
movq %rdi, %rax
movq %rax, 0x18(%rsp)
movq %rdi, 0x70(%rsp)
movq %rsi, 0x68(%rsp)
movq %rdx, 0x60(%rsp)
movq %rcx, 0x58(%rsp)
movb $0x0, 0x57(%rsp)
callq 0x32b20
movl $0x0, 0x50(%rsp)
movq 0x68(%rsp), %rsi
movq 0x60(%rsp), %rdx
movl 0x50(%rsp), %ecx
movl %ecx, %eax
incl %eax
movl %eax, 0x50(%rsp)
movq 0x58(%rsp), %r8
leaq 0x30(%rsp), %rdi
callq 0x2f2c0
jmp 0x17a5e
movq 0x10(%rsp), %rdi
leaq 0x30(%rsp), %rsi
callq 0x32b90
jmp 0x17a6f
leaq 0x30(%rsp), %rdi
callq 0x32c20
movq 0x10(%rsp), %rdi
callq 0x2f6b0
movb %al, 0xf(%rsp)
jmp 0x17a89
movb 0xf(%rsp), %al
testb $0x1, %al
jne 0x17a37
jmp 0x17a93
movb $0x1, 0x57(%rsp)
testb $0x1, 0x57(%rsp)
jne 0x17ad5
jmp 0x17acb
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x28(%rsp)
movl %eax, 0x24(%rsp)
jmp 0x17adf
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x28(%rsp)
movl %eax, 0x24(%rsp)
leaq 0x30(%rsp), %rdi
callq 0x32c20
jmp 0x17adf
movq 0x10(%rsp), %rdi
callq 0x32c20
movq 0x18(%rsp), %rax
addq $0x78, %rsp
retq
movq 0x10(%rsp), %rdi
callq 0x32c20
movq 0x28(%rsp), %rdi
callq 0xf410
nopw %cs:(%rax,%rax)
// File: WeihuaZhu[P]hpc_prog2/./gtest/gtest-all.cc
// Function: testing::internal::UnitTestOptions::PatternMatchesString(char const*, char const*)
bool UnitTestOptions::PatternMatchesString(const char *pattern,
                                           const char *str) {
  switch (*pattern) {
    case '\0':
    case ':':  // Either ':' or '\0' marks the end of the pattern.
      return *str == '\0';
    case '?':  // Matches any single character.
      return *str != '\0' && PatternMatchesString(pattern + 1, str + 1);
    case '*':  // Matches any string (possibly empty) of characters.
      return (*str != '\0' && PatternMatchesString(pattern, str + 1)) ||
          PatternMatchesString(pattern + 1, str);
    default:  // Non-special character.  Matches itself.
      return *pattern == *str &&
          PatternMatchesString(pattern + 1, str + 1);
  }
}

// Assembly:
subq $0x28, %rsp
movq %rdi, 0x18(%rsp)
movq %rsi, 0x10(%rsp)
movq 0x18(%rsp), %rax
movsbl (%rax), %eax
movl %eax, 0xc(%rsp)
testl %eax, %eax
je 0x17b44
jmp 0x17b20
movl 0xc(%rsp), %eax
subl $0x2a, %eax
je 0x17b9a
jmp 0x17b2b
movl 0xc(%rsp), %eax
subl $0x3a, %eax
je 0x17b44
jmp 0x17b36
movl 0xc(%rsp), %eax
subl $0x3f, %eax
je 0x17b5d
jmp 0x17bea
movq 0x10(%rsp), %rax
movsbl (%rax), %eax
cmpl $0x0, %eax
sete %al
andb $0x1, %al
movb %al, 0x27(%rsp)
jmp 0x17c29
movq 0x10(%rsp), %rax
movsbl (%rax), %ecx
xorl %eax, %eax
cmpl $0x0, %ecx
movb %al, 0xb(%rsp)
je 0x17b8b
movq 0x18(%rsp), %rdi
addq $0x1, %rdi
movq 0x10(%rsp), %rsi
addq $0x1, %rsi
callq 0x17b00
movb %al, 0xb(%rsp)
movb 0xb(%rsp), %al
andb $0x1, %al
movb %al, 0x27(%rsp)
jmp 0x17c29
movq 0x10(%rsp), %rax
movsbl (%rax), %eax
cmpl $0x0, %eax
je 0x17bc7
movq 0x18(%rsp), %rdi
movq 0x10(%rsp), %rsi
addq $0x1, %rsi
callq 0x17b00
movb %al, %cl
movb $0x1, %al
testb $0x1, %cl
movb %al, 0xa(%rsp)
jne 0x17bde
movq 0x18(%rsp), %rdi
addq $0x1, %rdi
movq 0x10(%rsp), %rsi
callq 0x17b00
movb %al, 0xa(%rsp)
movb 0xa(%rsp), %al
andb $0x1, %al
movb %al, 0x27(%rsp)
jmp 0x17c29
movq 0x18(%rsp), %rax
movsbl (%rax), %ecx
movq 0x10(%rsp), %rax
movsbl (%rax), %edx
xorl %eax, %eax
cmpl %edx, %ecx
movb %al, 0x9(%rsp)
jne 0x17c1f
movq 0x18(%rsp), %rdi
addq $0x1, %rdi
movq 0x10(%rsp), %rsi
addq $0x1, %rsi
callq 0x17b00
movb %al, 0x9(%rsp)
movb 0x9(%rsp), %al
andb $0x1, %al
movb %al, 0x27(%rsp)
movb 0x27(%rsp), %al
andb $0x1, %al
addq $0x28, %rsp
retq
nopw %cs:(%rax,%rax)
// File: WeihuaZhu[P]hpc_prog2/./gtest/gtest-all.cc
// Function: testing::internal::UnitTestOptions::MatchesFilter(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&, char const*)
bool UnitTestOptions::MatchesFilter(
    const std::string& name, const char* filter) {
  const char *cur_pattern = filter;
  for (;;) {
    if (PatternMatchesString(cur_pattern, name.c_str())) {
      return true;
    }

    // Finds the next pattern in the filter.
    cur_pattern = strchr(cur_pattern, ':');

    // Returns if no more pattern can be found.
    if (cur_pattern == NULL) {
      return false;
    }

    // Skips the pattern separater (the ':' character).
    cur_pattern++;
  }
}

// Assembly:
subq $0x28, %rsp
movq %rdi, 0x18(%rsp)
movq %rsi, 0x10(%rsp)
movq 0x10(%rsp), %rax
movq %rax, 0x8(%rsp)
movq 0x8(%rsp), %rax
movq %rax, (%rsp)
movq 0x18(%rsp), %rdi
callq 0xe370
movq (%rsp), %rdi
movq %rax, %rsi
callq 0x17b00
testb $0x1, %al
jne 0x17c7d
jmp 0x17c84
movb $0x1, 0x27(%rsp)
jmp 0x17cb7
movq 0x8(%rsp), %rdi
movl $0x3a, %esi
callq 0xe340
movq %rax, 0x8(%rsp)
cmpq $0x0, 0x8(%rsp)
jne 0x17ca7
movb $0x0, 0x27(%rsp)
jmp 0x17cb7
movq 0x8(%rsp), %rax
addq $0x1, %rax
movq %rax, 0x8(%rsp)
jmp 0x17c58
movb 0x27(%rsp), %al
andb $0x1, %al
addq $0x28, %rsp
retq
nopw %cs:(%rax,%rax)
// File: WeihuaZhu[P]hpc_prog2/./gtest/gtest-all.cc
// Function: testing::ScopedFakeTestPartResultReporter::Init()
void ScopedFakeTestPartResultReporter::Init() {
  internal::UnitTestImpl* const impl = internal::GetUnitTestImpl();
  if (intercept_mode_ == INTERCEPT_ALL_THREADS) {
    old_reporter_ = impl->GetGlobalTestPartResultReporter();
    impl->SetGlobalTestPartResultReporter(this);
  } else {
    old_reporter_ = impl->GetTestPartResultReporterForCurrentThread();
    impl->SetTestPartResultReporterForCurrentThread(this);
  }
}

// Assembly:
subq $0x18, %rsp
movq %rdi, 0x10(%rsp)
movq 0x10(%rsp), %rax
movq %rax, (%rsp)
callq 0x32df0
movq %rax, %rcx
movq (%rsp), %rax
movq %rcx, 0x8(%rsp)
cmpl $0x1, 0x8(%rax)
jne 0x18107
movq 0x8(%rsp), %rdi
callq 0x181a0
movq (%rsp), %rsi
movq %rax, 0x10(%rsi)
movq 0x8(%rsp), %rdi
callq 0x181f0
jmp 0x18123
movq 0x8(%rsp), %rdi
callq 0x18240
movq (%rsp), %rsi
movq %rax, 0x10(%rsi)
movq 0x8(%rsp), %rdi
callq 0x18260
addq $0x18, %rsp
retq
nopl (%rax,%rax)
// File: WeihuaZhu[P]hpc_prog2/./gtest/gtest-all.cc
// Function: testing::ScopedFakeTestPartResultReporter::~ScopedFakeTestPartResultReporter()
ScopedFakeTestPartResultReporter::~ScopedFakeTestPartResultReporter() {
  internal::UnitTestImpl* const impl = internal::GetUnitTestImpl();
  if (intercept_mode_ == INTERCEPT_ALL_THREADS) {
    impl->SetGlobalTestPartResultReporter(old_reporter_);
  } else {
    impl->SetTestPartResultReporterForCurrentThread(old_reporter_);
  }
}

// Assembly:
subq $0x28, %rsp
movq %rdi, 0x20(%rsp)
movq 0x20(%rsp), %rax
movq %rax, 0x8(%rsp)
leaq 0x4c0a6(%rip), %rcx     # 0x64350
movq %rcx, (%rax)
callq 0x32df0
movq %rax, 0x10(%rsp)
jmp 0x182b9
movq 0x8(%rsp), %rax
movq 0x10(%rsp), %rcx
movq %rcx, 0x18(%rsp)
cmpl $0x1, 0x8(%rax)
jne 0x182e5
movq 0x8(%rsp), %rax
movq 0x18(%rsp), %rdi
movq 0x10(%rax), %rsi
callq 0x181f0
jmp 0x182e3
jmp 0x182fc
movq 0x8(%rsp), %rax
movq 0x18(%rsp), %rdi
movq 0x10(%rax), %rsi
callq 0x18260
jmp 0x182fa
jmp 0x182fc
movq 0x8(%rsp), %rdi
callq 0x3ba00
addq $0x28, %rsp
retq
movq %rax, %rdi
callq 0x108e0
nopw %cs:(%rax,%rax)
// File: WeihuaZhu[P]hpc_prog2/./gtest/gtest-all.cc
// Function: testing::TestPartResultArray::GetTestPartResult(int) const
const TestPartResult& TestPartResultArray::GetTestPartResult(int index) const {
  if (index < 0 || index >= size()) {
    printf("\nInvalid index (%d) into TestPartResultArray.\n", index);
    internal::posix::Abort();
  }

  return array_[index];
}

// Assembly:
subq $0x28, %rsp
movq %rdi, 0x20(%rsp)
movl %esi, 0x1c(%rsp)
movq 0x20(%rsp), %rax
movq %rax, 0x10(%rsp)
cmpl $0x0, 0x1c(%rsp)
jl 0x18a3a
movq 0x10(%rsp), %rdi
movl 0x1c(%rsp), %eax
movl %eax, 0xc(%rsp)
callq 0x189f0
movl %eax, %ecx
movl 0xc(%rsp), %eax
cmpl %ecx, %eax
jl 0x18a51
movl 0x1c(%rsp), %esi
leaq 0x35247(%rip), %rdi     # 0x4dc8c
movb $0x0, %al
callq 0xe090
callq 0x34a70
movq 0x10(%rsp), %rdi
movslq 0x1c(%rsp), %rsi
callq 0x3b050
addq $0x28, %rsp
retq
nopw %cs:(%rax,%rax)
// File: WeihuaZhu[P]hpc_prog2/./gtest/gtest-all.cc
// Function: testing::internal::SumOverTestCaseList(std::vector<testing::TestCase*, std::allocator<testing::TestCase*>> const&, int (testing::TestCase::*)() const)
static int SumOverTestCaseList(const std::vector<TestCase*>& case_list,
                               int (TestCase::*method)() const) {
  int sum = 0;
  for (size_t i = 0; i < case_list.size(); i++) {
    sum += (case_list[i]->*method)();
  }
  return sum;
}

// Assembly:
subq $0x58, %rsp
movq %rsi, 0x48(%rsp)
movq %rdx, 0x50(%rsp)
movq 0x48(%rsp), %rax
movq 0x50(%rsp), %rcx
movq %rdi, 0x40(%rsp)
movq %rcx, 0x38(%rsp)
movq %rax, 0x30(%rsp)
movl $0x0, 0x2c(%rsp)
movq $0x0, 0x20(%rsp)
movq 0x20(%rsp), %rax
movq %rax, 0x18(%rsp)
movq 0x40(%rsp), %rdi
callq 0x33480
movq %rax, %rcx
movq 0x18(%rsp), %rax
cmpq %rcx, %rax
jae 0x18fd6
movq 0x40(%rsp), %rdi
movq 0x20(%rsp), %rsi
callq 0x3bc10
movq (%rax), %rcx
movq 0x30(%rsp), %rax
movq %rax, 0x8(%rsp)
movq 0x38(%rsp), %rdx
addq %rdx, %rcx
movq %rcx, 0x10(%rsp)
andq $0x1, %rax
cmpq $0x0, %rax
je 0x18fa7
movq 0x8(%rsp), %rcx
movq 0x10(%rsp), %rax
movq (%rax), %rax
subq $0x1, %rcx
movq (%rax,%rcx), %rax
movq %rax, (%rsp)
jmp 0x18fb0
movq 0x8(%rsp), %rax
movq %rax, (%rsp)
movq 0x10(%rsp), %rdi
movq (%rsp), %rax
callq *%rax
addl 0x2c(%rsp), %eax
movl %eax, 0x2c(%rsp)
movq 0x20(%rsp), %rax
addq $0x1, %rax
movq %rax, 0x20(%rsp)
jmp 0x18f38
movl 0x2c(%rsp), %eax
addq $0x58, %rsp
retq
nop
// File: WeihuaZhu[P]hpc_prog2/./gtest/gtest-all.cc
// Function: testing::internal::StreamWideCharsToMessage(wchar_t const*, unsigned long, testing::Message*)
static void StreamWideCharsToMessage(const wchar_t* wstr, size_t length,
                                     Message* msg) {
  for (size_t i = 0; i != length; ) {  // NOLINT
    if (wstr[i] != L'\0') {
      *msg << WideStringToUtf8(wstr + i, static_cast<int>(length - i));
      while (i != length && wstr[i] != L'\0')
        i++;
    } else {
      *msg << '\0';
      i++;
    }
  }
}

// Assembly:
subq $0x68, %rsp
movq %rdi, 0x60(%rsp)
movq %rsi, 0x58(%rsp)
movq %rdx, 0x50(%rsp)
movq $0x0, 0x48(%rsp)
movq 0x48(%rsp), %rax
cmpq 0x58(%rsp), %rax
je 0x196ac
movq 0x60(%rsp), %rax
movq 0x48(%rsp), %rcx
cmpl $0x0, (%rax,%rcx,4)
je 0x19685
movq 0x50(%rsp), %rax
movq %rax, 0x8(%rsp)
movq 0x60(%rsp), %rcx
movq 0x48(%rsp), %rax
leaq (%rcx,%rax,4), %rsi
movl 0x58(%rsp), %edx
subl %eax, %edx
leaq 0x28(%rsp), %rdi
movq %rdi, 0x10(%rsp)
callq 0x1c4e0
movq 0x8(%rsp), %rdi
movq 0x10(%rsp), %rsi
callq 0x32e10
jmp 0x1961e
leaq 0x28(%rsp), %rdi
callq 0xf698
movq 0x48(%rsp), %rcx
xorl %eax, %eax
cmpq 0x58(%rsp), %rcx
movb %al, 0x7(%rsp)
je 0x1964f
movq 0x60(%rsp), %rax
movq 0x48(%rsp), %rcx
cmpl $0x0, (%rax,%rcx,4)
setne %al
movb %al, 0x7(%rsp)
movb 0x7(%rsp), %al
testb $0x1, %al
jne 0x19659
jmp 0x19683
movq 0x48(%rsp), %rax
addq $0x1, %rax
movq %rax, 0x48(%rsp)
jmp 0x19628
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x20(%rsp)
movl %eax, 0x1c(%rsp)
leaq 0x28(%rsp), %rdi
callq 0xf698
jmp 0x196b1
jmp 0x196a7
movq 0x50(%rsp), %rdi
movb $0x0, 0x1b(%rsp)
leaq 0x1b(%rsp), %rsi
callq 0x36e50
movq 0x48(%rsp), %rax
addq $0x1, %rax
movq %rax, 0x48(%rsp)
jmp 0x195bc
addq $0x68, %rsp
retq
movq 0x20(%rsp), %rdi
callq 0xf410
nopl (%rax,%rax)
// File: WeihuaZhu[P]hpc_prog2/./gtest/gtest-all.cc
// Function: testing::internal::StringStreamToString(std::__cxx11::basic_stringstream<char, std::char_traits<char>, std::allocator<char>>*)
std::string StringStreamToString(::std::stringstream* ss) {
  const ::std::string& str = ss->str();
  const char* const start = str.c_str();
  const char* const end = start + str.length();

  std::string result;
  result.reserve(2 * (end - start));
  for (const char* ch = start; ch != end; ++ch) {
    if (*ch == '\0') {
      result += "\\0";  // Replaces NUL with "\\0";
    } else {
      result += *ch;
    }
  }

  return result;
}

// Assembly:
subq $0x88, %rsp
movq %rdi, 0x18(%rsp)
movq %rdi, %rax
movq %rax, (%rsp)
movq %rdi, 0x80(%rsp)
movq %rsi, 0x78(%rsp)
movq 0x78(%rsp), %rsi
leaq 0x50(%rsp), %rdi
movq %rdi, 0x8(%rsp)
callq 0xe9f0
movq 0x8(%rsp), %rax
movq %rax, 0x70(%rsp)
movq 0x70(%rsp), %rdi
callq 0xe370
movq %rax, 0x48(%rsp)
movq 0x48(%rsp), %rax
movq %rax, 0x10(%rsp)
movq 0x70(%rsp), %rdi
callq 0xf110
movq 0x18(%rsp), %rdi
movq %rax, %rcx
movq 0x10(%rsp), %rax
addq %rcx, %rax
movq %rax, 0x40(%rsp)
movb $0x0, 0x3f(%rsp)
callq 0xefa0
movq 0x18(%rsp), %rdi
movq 0x40(%rsp), %rsi
movq 0x48(%rsp), %rax
subq %rax, %rsi
addq %rsi, %rsi
callq 0xf1b0
jmp 0x1979c
movq 0x48(%rsp), %rax
movq %rax, 0x20(%rsp)
movq 0x20(%rsp), %rax
cmpq 0x40(%rsp), %rax
je 0x19820
movq 0x20(%rsp), %rax
movsbl (%rax), %eax
cmpl $0x0, %eax
jne 0x197f8
movq 0x18(%rsp), %rdi
leaq 0x33388(%rip), %rsi     # 0x4cb53
callq 0xe9d0
jmp 0x197d2
jmp 0x1980e
movq 0x18(%rsp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x30(%rsp)
movl %eax, 0x2c(%rsp)
callq 0xf698
leaq 0x50(%rsp), %rdi
callq 0xf698
jmp 0x1984c
movq 0x18(%rsp), %rdi
movq 0x20(%rsp), %rax
movsbl (%rax), %esi
callq 0xe5e0
jmp 0x1980c
jmp 0x1980e
jmp 0x19810
movq 0x20(%rsp), %rax
addq $0x1, %rax
movq %rax, 0x20(%rsp)
jmp 0x197a6
movb $0x1, 0x3f(%rsp)
testb $0x1, 0x3f(%rsp)
jne 0x19836
movq 0x18(%rsp), %rdi
callq 0xf698
leaq 0x50(%rsp), %rdi
callq 0xf698
movq (%rsp), %rax
addq $0x88, %rsp
retq
movq 0x30(%rsp), %rdi
callq 0xf410
nopw %cs:(%rax,%rax)