LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_cpp_makefile_star2_O2/GAStudyGroup[P]GPX2/src/cross/AntColony/Constants.cpp
// Function: AntMap::updatePheromoneMap(std::vector<int, std::allocator<int>> const&)
void AntMap::updatePheromoneMap(const vector<int>& path){
    for(unsigned i=1;i<=Globals::TOUR_SIZE;i++){
        for(unsigned j=1;j<=Globals::TOUR_SIZE;j++){
            if(i!=j){
                double decay{((1-AntConstants::rho)*AntMap::getPheromoneLevel(i,j))},
                    add{(constainsEdge(path,i,j)?(AntConstants::Q/getFitness(path)):(0.0))},
                    max{maxPheromoneLevel()},
                    min{minPheromoneLevel()},
                    newValue{decay+add};
                
                if(min>max){
                    min = max;
                }
                
                if(newValue > max){
                    newValue = max;
                }else if(newValue < min){
                    newValue = min;
                }
                // cout<<"maxPheromoneLevel: "<<max<<" minPheromoneLevel: "<<min<<endl;
                AntMap::setPheromoneLevel(i,j,newValue);
                //because assymetric TSP
                AntMap::setPheromoneLevel(j,i,newValue);
            }
            
        }   
    }
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %rdi, %rbx
leaq 0x221fa(%rip), %rax     # 0x3dc68
movl (%rax), %eax
pushq $0x1
popq %rbp
xorl %r13d, %r13d
cmpl %eax, %ebp
ja 0x1bb97
movslq %ebp, %r12
pushq $0x1
popq %rcx
movl %ecx, %r14d
cmpl %eax, %r14d
ja 0x1bb8d
leal (%r14,%r13), %ecx
cmpl $0x1, %ecx
je 0x1bb85
movsd 0xb843(%rip), %xmm0     # 0x272e8
subsd 0x20d2b(%rip), %xmm0    # 0x3c7d8
movq 0x221c4(%rip), %rax     # 0x3dc78
movq -0x8(%rax,%r12,8), %rax
movslq %r14d, %r15
mulsd -0x8(%rax,%r15,8), %xmm0
movsd %xmm0, 0x10(%rsp)
movq %rbx, %rdi
movl %ebp, %esi
movl %r14d, %edx
callq 0x1bba6
xorpd %xmm0, %xmm0
testb %al, %al
je 0x1bb06
movsd 0x20cea(%rip), %xmm0    # 0x3c7d0
movsd %xmm0, 0x8(%rsp)
movq %rbx, %rdi
callq 0xc060
cvtsi2sd %eax, %xmm0
movsd 0x8(%rsp), %xmm1
divsd %xmm0, %xmm1
movapd %xmm1, %xmm0
movsd 0x10(%rsp), %xmm1
addsd %xmm0, %xmm1
movsd %xmm1, 0x10(%rsp)
cvtsi2sdl 0x22162(%rip), %xmm0 # 0x3dc80
movsd 0x20caa(%rip), %xmm1    # 0x3c7d0
mulsd 0x20caa(%rip), %xmm0    # 0x3c7d8
divsd %xmm0, %xmm1
movsd %xmm1, 0x8(%rsp)
callq 0x1bc08
movsd 0x8(%rsp), %xmm2
movsd 0x10(%rsp), %xmm1
ucomisd %xmm2, %xmm1
leaq 0x22114(%rip), %rax     # 0x3dc68
movl (%rax), %eax
ja 0x1bb62
minsd %xmm0, %xmm2
ucomisd %xmm1, %xmm2
jbe 0x1bb66
movapd %xmm2, %xmm1
movq 0x2210b(%rip), %rcx     # 0x3dc78
movq -0x8(%rcx,%r12,8), %rdx
movsd %xmm1, -0x8(%rdx,%r15,8)
movq -0x8(%rcx,%r15,8), %rcx
movsd %xmm1, -0x8(%rcx,%r12,8)
incl %r14d
jmp 0x1ba87
incl %ebp
decl %r13d
jmp 0x1ba76
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/GAStudyGroup[P]GPX2/src/cross/AntColony/Constants.cpp
// Function: AntMap::constainsEdge(std::vector<int, std::allocator<int>> const&, int, int)
bool AntMap::constainsEdge(const vector<int>& path,int a, int b){
    //find a position in ant`s path
    long int aIndex{find(path.begin(),path.end(),a)-path.begin()};
    //if b is next in position them ant path contains the AB edge
    return path[(aIndex+1)%Globals::TOUR_SIZE]==b;
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movl %edx, %ebx
movq %rdi, %r14
leaq 0x4(%rsp), %rdx
movl %esi, (%rdx)
movq (%rdi), %rdi
movq 0x8(%r14), %rsi
callq 0x1be5d
movq (%r14), %rcx
subq %rcx, %rax
sarq $0x2, %rax
incq %rax
leaq 0x22092(%rip), %rdx     # 0x3dc68
movl (%rdx), %esi
cqto
idivq %rsi
cmpl %ebx, (%rcx,%rdx,4)
sete %al
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_cpp_makefile_star2_O2/GAStudyGroup[P]GPX2/src/cross/AntColony/Constants.cpp
// Function: AntMap::printPheromoneMap()
void AntMap::printPheromoneMap(){
    for(unsigned i=1;i<=Globals::TOUR_SIZE;i++){
        for(unsigned j=1;j<=Globals::TOUR_SIZE;j++){
            cout<<AntMap::getPheromoneLevel(i,j)<<" ";
        }
        cout<<"\n";
    }
    cout<<endl;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
pushq $0x1
popq %r13
leaq 0x21fd4(%rip), %r12     # 0x3dc68
movq 0x20305(%rip), %rbx     # 0x3bfa0
leaq 0xb6c6(%rip), %r15      # 0x27368
movl (%r12), %eax
cmpl %eax, %r13d
ja 0x1bcfc
movslq %r13d, %rbp
pushq $0x1
popq %r14
cmpl %eax, %r14d
ja 0x1bce8
movq 0x21fba(%rip), %rax     # 0x3dc78
movq -0x8(%rax,%rbp,8), %rax
movslq %r14d, %rcx
movsd -0x8(%rax,%rcx,8), %xmm0
movq %rbx, %rdi
callq 0x5560
movq %rax, %rdi
movq %r15, %rsi
callq 0x5370
incl %r14d
movl (%r12), %eax
jmp 0x1bcb2
movq %rbx, %rdi
leaq 0xcae4(%rip), %rsi      # 0x287d6
callq 0x5370
incl %r13d
jmp 0x1bca2
movq 0x2029d(%rip), %rdi     # 0x3bfa0
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x51c0
// File: /workspace/github_cpp_makefile_star2_O2/GAStudyGroup[P]GPX2/src/cross/AntColony/Constants.cpp
// Function: AntMap::initMap()
void AntMap::initMap(){
    //Creating and initializing matrix of pheromones
    AntMap::pheromoneMap = new double*[Globals::TOUR_SIZE];
    for(unsigned i=0;i<Globals::TOUR_SIZE;i++){
        AntMap::pheromoneMap[i] = new double[Globals::TOUR_SIZE];
    }

    //initialized with 1/(numberOfAnts*(distance of i to j))
    for(unsigned i=1;i<=Globals::TOUR_SIZE;i++){
        for(unsigned j=1;j<=Globals::TOUR_SIZE;j++){
            AntMap::setPheromoneLevel(i,j,i!=j?(1.0/(Globals::TOUR_SIZE*distance(i,j))):(0.0));
        }
    }

    AntMap::bestAntYet.setPath(Globals::map.getCityList());
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
leaq 0x21f3d(%rip), %r15     # 0x3dc68
movl (%r15), %r12d
leaq (,%r12,8), %rbx
movq %rbx, %rdi
callq 0x5030
movq %rax, 0x21f33(%rip)     # 0x3dc78
xorl %r14d, %r14d
cmpq %r14, %r12
je 0x1bd65
movq %rbx, %rdi
callq 0x5030
movq 0x21f1c(%rip), %rcx     # 0x3dc78
movq %rax, (%rcx,%r14,8)
incq %r14
jmp 0x1bd48
pushq $0x1
popq %rbx
xorl %r13d, %r13d
cmpl %r12d, %ebx
ja 0x1bdce
movslq %ebx, %rbp
pushq $0x1
popq %rax
movl %eax, %r14d
cmpl %r12d, %r14d
ja 0x1bdc7
leal (%r14,%r13), %eax
xorpd %xmm0, %xmm0
cmpl $0x1, %eax
je 0x1bdad
movl %ebx, %edi
movl %r14d, %esi
callq 0xc0c6
imull %r12d, %eax
cvtsi2sd %rax, %xmm1
movsd 0xb542(%rip), %xmm0     # 0x272e8
divsd %xmm1, %xmm0
movl (%r15), %r12d
movq 0x21ec4(%rip), %rax     # 0x3dc78
movq -0x8(%rax,%rbp,8), %rax
movslq %r14d, %rcx
movsd %xmm0, -0x8(%rax,%rcx,8)
incl %r14d
jmp 0x1bd79
incl %ebx
decl %r13d
jmp 0x1bd6b
leaq 0x21e7b(%rip), %rsi     # 0x3dc50
movq %rsp, %rbx
movq %rbx, %rdi
callq 0xbb16
leaq 0x21ea1(%rip), %rdi     # 0x3dc88
movq %rbx, %rsi
callq 0x1b440
movq %rsp, %rdi
callq 0x6e4c
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
movq %rsp, %rdi
callq 0x6e4c
movq %rbx, %rdi
callq 0x5610
// File: /workspace/github_cpp_makefile_star2_O2/GAStudyGroup[P]GPX2/src/cross/gpx/sources/GPX2Fusion.cpp
// Function: GPX2Fusion::checkUnfeasiblePartitions(std::map<int, Partition*, std::less<int>, std::allocator<std::pair<int const, Partition*>>>&, std::map<int, Partition*, std::less<int>, std::allocator<std::pair<int const, Partition*>>>&, 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*>>>&, 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 GPX2Fusion::checkUnfeasiblePartitions(GPX2Structs::PartitionMap &fpartition, GPX2Structs::PartitionMap &ufpartition, GPX2Structs::NodeMap &red, GPX2Structs::NodeMap &blue)
{ // Função que irá verificar se foi gerada alguma partição feasible durante a fusão
    for (auto it = ufpartition.begin(); it != ufpartition.end();) {
        if (GPX2Support::checkPartition((*it).second,red,blue)) { // Checar se é feasible
            // se for irá ser retirada das partições unfeasible e colocada nas partições feasible
            fpartition.insert(make_pair((*it).first, (*it).second));
            it = ufpartition.erase(it);
        } else {
            it++;
        }
    }
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %rcx, %rbx
movq %rdx, %r14
movq %rsi, %r15
movq %rdi, %r12
movq 0x18(%rsi), %rbp
leaq 0x8(%rsi), %r13
cmpq %r13, %rbp
je 0x1caa8
movq 0x28(%rbp), %rdi
movq %r14, %rsi
movq %rbx, %rdx
callq 0x22d14
testb %al, %al
je 0x1ca9b
movl 0x20(%rbp), %eax
movq 0x28(%rbp), %rcx
movl %eax, 0x8(%rsp)
movq %rcx, 0x10(%rsp)
movq %r12, %rdi
leaq 0x8(%rsp), %rsi
callq 0x1dd6a
movq %r15, %rdi
movq %rbp, %rsi
callq 0x1deaa
movq %rax, %rbp
jmp 0x1ca56
movq %rbp, %rdi
callq 0x52a0
movq %rax, %rbp
jmp 0x1ca56
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/GAStudyGroup[P]GPX2/src/cross/gpx/sources/GPX2Fusion.cpp
// Function: GPX2Fusion::fusionsWithPartition(int, std::vector<GPX2Structs::UnfeasibleConnection, std::allocator<GPX2Structs::UnfeasibleConnection>>&)
vector<GPX2Structs::UnfeasibleConnection> GPX2Fusion::fusionsWithPartition(const int id, vector<GPX2Structs::UnfeasibleConnection>& connections)
{
    vector<GPX2Structs::UnfeasibleConnection> instances;
    for (const auto& con : connections) {
        if (con.partitionId1 == id || con.partitionId2 == id) {
            instances.push_back(con);
        }
    }
    return (instances);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movl %esi, %ebp
movq %rdi, %rbx
andq $0x0, 0x10(%rdi)
xorps %xmm0, %xmm0
movups %xmm0, (%rdi)
movq (%rdx), %r14
movq 0x8(%rdx), %r15
cmpq %r15, %r14
je 0x1d094
cmpl %ebp, (%r14)
je 0x1d083
cmpl %ebp, 0x4(%r14)
jne 0x1d08e
movq %rbx, %rdi
movq %r14, %rsi
callq 0x1d94a
addq $0xc, %r14
jmp 0x1d073
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %r14
movq %rbx, %rdi
callq 0x1ea5c
movq %r14, %rdi
callq 0x5610
// File: /workspace/github_cpp_makefile_star2_O2/GAStudyGroup[P]GPX2/src/cross/gpx/sources/GPX2Fusion.cpp
// Function: GPX2Fusion::whichPartitionToFuseWith(Partition*)
GPX2Structs::UnfeasibleConnection GPX2Fusion::whichPartitionToFuseWith(Partition* partition)
{ // Retorna um par com a partição que contém mais conexões e o total de conexões

    int partitionId{ -1 }, max{ -1 };
    for (auto p : partition->getConnections()) {
        if (p.second > max) {
            max = p.second;
            partitionId = p.first;
        }
    }
    return (GPX2Structs::UnfeasibleConnection(partitionId, max, max));
}

// Assembly:
pushq %rax
callq 0x223b4
movq (%rax), %rcx
movq 0x8(%rax), %rax
pushq $-0x1
popq %rdx
movl %edx, %esi
cmpq %rax, %rcx
je 0x1d2c9
movl 0x4(%rcx), %edi
cmpl %edx, %edi
jle 0x1d2c3
movl (%rcx), %esi
movl %edi, %edx
addq $0x8, %rcx
jmp 0x1d2b3
movq %rdx, %rcx
shlq $0x20, %rcx
movl %esi, %eax
orq %rcx, %rax
popq %rcx
retq
// File: /workspace/github_cpp_makefile_star2_O2/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:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x28, %rsp
movq %rdi, %rbx
leaq 0xd8(%rdi), %r14
leaq 0x108(%rdi), %r15
movq %r14, %rsi
movq %r15, %rdx
callq 0x25449
movq 0x18(%rbx), %rbp
leaq 0x8(%rbx), %r12
leaq 0x60(%rbx), %rax
movq %rax, 0x20(%rsp)
movq %rbx, 0x10(%rsp)
leaq 0x30(%rbx), %rax
movq %rax, 0x18(%rsp)
cmpq %r12, %rbp
je 0x20003
movl 0x20(%rbp), %r13d
movq 0x28(%rbp), %rbx
movq %rbx, %rdi
movq %r14, %rsi
movq %r15, %rdx
callq 0x22d14
testb %al, %al
je 0x1ffe0
movl %r13d, (%rsp)
movq %rbx, 0x8(%rsp)
movq 0x18(%rsp), %rdi
jmp 0x1ffee
movl %r13d, (%rsp)
movq %rbx, 0x8(%rsp)
movq 0x20(%rsp), %rdi
movq %rsp, %rsi
callq 0x1dd6a
movq %rbp, %rdi
callq 0x52a0
movq %rax, %rbp
jmp 0x1ffb1
movq 0x10(%rsp), %rdi
callq 0x1ea2e
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/GAStudyGroup[P]GPX2/src/cross/gpx/sources/GPX2.cpp
// Function: GPX2::fusion()
void GPX2::fusion()
{// Method to execute the GPX2's Fusion, it will check amongst the unfeasibe partitions and try to transform them to feasible ones
    bool atLeastOneConnected{ false };
    //Keps executing while there are still more than one partition to try to fuse them
    while ((unfeasiblePartitions.size() > 1)) {
        //Check how many partitions are connected, the fusion only happens if the partitions are connected by at least one node
        atLeastOneConnected = GPX2Fusion::unfeasiblePartitionsConnected(unfeasiblePartitions, unitedGraph);
        if (!atLeastOneConnected) {
            break;
        }
        // Counts how many times that one partition connects with other unfeasible partition, that is, the nodes that have a path that goes from one partition to another
        GPX2Fusion::countConnectedPartitions(unfeasiblePartitions);

        // Generates the fusion pairs that will be tried, this method already validates them
        GPX2Fusion::generateFusionPairs(fuseWith, unfeasiblePartitions);

        GPX2Fusion::fusePartitions(fuseWith,
                        unfeasiblePartitions,
                        unitedGraph,
                        red,
                        blue);

        for (auto part : unfeasiblePartitions) {
            part.second->getConnectedTo().clear();
            part.second->getConnections().clear();
        }

        //Checks if the generated partition is feasible, in that case it will be put in the feasible partition list
        GPX2Fusion::checkUnfeasiblePartitions(feasiblePartitions,
                                                unfeasiblePartitions,
                                                red,
                                                blue);
    }
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x28, %rsp
movq %rdi, %rbx
leaq 0x60(%rdi), %r14
leaq 0x90(%rdi), %r15
leaq 0xc0(%rdi), %rax
movq %rax, 0x20(%rsp)
leaq 0xd8(%rdi), %rax
movq %rax, 0x10(%rsp)
leaq 0x108(%rdi), %rax
movq %rax, 0x8(%rsp)
leaq 0x68(%rdi), %r13
leaq 0x30(%rdi), %rax
movq %rax, 0x18(%rsp)
cmpq $0x2, 0x88(%rbx)
jb 0x2011c
movq %r14, %rdi
movq %r15, %rsi
callq 0x1d2d7
testb %al, %al
je 0x2011c
movq %r14, %rdi
callq 0x1cb09
movq 0x20(%rsp), %r12
movq %r12, %rdi
movq %r14, %rsi
callq 0x1d0b5
movq %r12, %rdi
movq %r14, %rsi
movq %r15, %rbp
movq %r15, %rdx
movq 0x10(%rsp), %rcx
movq 0x8(%rsp), %r8
callq 0x1cc3f
movq 0x78(%rbx), %r12
cmpq %r13, %r12
je 0x200fd
movq 0x28(%r12), %r15
movq %r15, %rdi
callq 0x223d0
movq %rax, %rdi
callq 0x20a46
movq %r15, %rdi
callq 0x223b4
movq (%rax), %rcx
cmpq %rcx, 0x8(%rax)
je 0x200f0
movq %rcx, 0x8(%rax)
movq %r12, %rdi
callq 0x52a0
movq %rax, %r12
jmp 0x200c1
movq 0x18(%rsp), %rdi
movq %r14, %rsi
movq 0x10(%rsp), %rdx
movq 0x8(%rsp), %rcx
callq 0x1ca34
movq %rbp, %r15
jmp 0x20069
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O2/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:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rdi, %rbx
addq $0xd8, %rdi
movq %rdi, (%rsp)
callq 0x23cbc
leaq 0x108(%rbx), %r12
movq %r12, %rdi
callq 0x23cbc
leaq 0x90(%rbx), %r15
movq %r15, %rdi
callq 0x23cbc
movq %rbx, %rdi
callq 0x23c61
leaq 0x30(%rbx), %r13
movq %r13, %rdi
callq 0x23c61
leaq 0x60(%rbx), %rbp
movq %rbp, %rdi
callq 0x23c61
leaq 0x138(%rbx), %r14
movq 0x138(%rbx), %rax
cmpq %rax, 0x140(%rbx)
je 0x208ac
movq %rax, 0x140(%rbx)
movq %r13, %rdi
callq 0x1ea2e
movq %r14, %rdi
callq 0x21bbe
movq %r12, %rdi
callq 0x20be0
movq (%rsp), %rdi
callq 0x20be0
leaq 0xc0(%rbx), %rdi
callq 0x1ea5c
movq %r15, %rdi
callq 0x20be0
movq %rbp, %rdi
callq 0x1dd56
movq %r13, %rdi
callq 0x1dd56
movq %rbx, %rdi
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x1dd56
movq %rax, %rdi
callq 0x6d35
nop
// File: /workspace/github_cpp_makefile_star2_O2/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:
movl %esi, %ecx
movq 0x20(%rdi), %rsi
movq 0x28(%rdi), %rax
subq %rsi, %rax
pushq $0x28
popq %r8
cqto
idivq %r8
cmpq %rcx, %rax
jb 0x21c57
addq $0x20, %rdi
imulq $0x28, %rcx, %rax
addq %rax, %rsi
jmp 0x21eec
pushq %rax
pushq $0x1
popq %rdi
callq 0x5430
// File: /workspace/github_cpp_makefile_star2_O2/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:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x38, %rsp
movq %rsi, %r13
movq %rdi, %rbx
leaq 0x6ba9(%rip), %rsi      # 0x28874
callq 0x5370
movq %rax, %r14
leaq 0x10(%rsp), %r15
movq %r15, %rdi
movq %r13, %rsi
callq 0x54a0
movq %r14, %rdi
movq %r15, %rsi
callq 0x5330
leaq 0x6ae1(%rip), %rsi      # 0x287d6
movq %rax, %rdi
callq 0x5370
leaq 0x10(%rsp), %r15
movq %r15, %rdi
callq 0x56f8
leaq 0x6b6e(%rip), %rsi      # 0x2887f
movq %rbx, %rdi
callq 0x5370
movq 0x20(%r13), %r12
movq %r13, 0x8(%rsp)
movq 0x28(%r13), %r13
leaq 0x6b60(%rip), %rbp      # 0x2888d
leaq 0x6aa2(%rip), %r14      # 0x287d6
cmpq %r13, %r12
je 0x21d90
movq %r15, %rdi
movq %r12, %rsi
callq 0x209fc
movq %rbx, %rdi
leaq 0x6b3a(%rip), %rsi      # 0x28888
callq 0x5370
movq %rax, %rdi
movq %r15, %rsi
callq 0x5330
movq %rax, %rdi
movq %rbp, %rsi
callq 0x5370
movsd 0x30(%rsp), %xmm0
movq %rax, %rdi
callq 0x5560
movq %rax, %rdi
movq %r14, %rsi
callq 0x5370
movq %r15, %rdi
callq 0x56f8
addq $0x28, %r12
jmp 0x21d34
leaq 0x6b00(%rip), %rsi      # 0x28897
movq %rbx, %rdi
callq 0x5370
movq 0x8(%rsp), %rcx
movzbl 0x38(%rcx), %esi
movq %rax, %rdi
callq 0x55a0
movq %rbx, %rdi
callq 0x5290
movq %rbx, %rax
addq $0x38, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
jmp 0x21dcc
movq %rax, %rbx
leaq 0x10(%rsp), %rdi
callq 0x56f8
movq %rbx, %rdi
callq 0x5610
nop
// File: /workspace/github_cpp_makefile_star2_O2/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:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq %rdi, %r14
xorl %r12d, %r12d
movl %r12d, %r12d
movq 0x8(%rbx), %rax
subq (%rbx), %rax
sarq $0x5, %rax
cmpq %r12, %rax
jbe 0x23409
xorl %ecx, %ecx
movq %r12, %r13
shlq $0x5, %r13
movl %ecx, %r15d
movq (%r14), %rsi
movq 0x8(%r14), %rax
subq %rsi, %rax
sarq $0x5, %rax
cmpq %r15, %rax
jbe 0x23404
movl %r15d, %ebp
movq (%rbx), %rdi
addq %r13, %rdi
shlq $0x5, %r15
addq %r15, %rsi
callq 0x5040
leal 0x1(%rbp), %ecx
testl %eax, %eax
jne 0x233c4
addq (%r14), %r15
movq %r14, %rdi
movq %r15, %rsi
callq 0x1d8b4
incl %r12d
jmp 0x233a8
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/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:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rdi, %rbx
movq 0x18(%rdi), %r14
leaq 0x8(%rdi), %r12
cmpq %r12, %r14
je 0x23ca9
movq 0x28(%r14), %r15
testq %r15, %r15
je 0x23c8a
movq %r15, %rdi
callq 0x1d8da
movl $0x80, %esi
movq %r15, %rdi
callq 0x5390
andq $0x0, 0x28(%r14)
movq %r14, %rdi
callq 0x52a0
movq %rax, %r14
jmp 0x23c74
movq %rbx, %rdi
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
jmp 0x1ea2e
// File: /workspace/github_cpp_makefile_star2_O2/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:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
movq %rdi, %rbx
movq 0x18(%rdi), %r15
leaq 0x8(%rdi), %r13
pushq $0x40
popq %r14
cmpq %r13, %r15
je 0x23d07
movq 0x40(%r15), %r12
testq %r12, %r12
je 0x23cea
movq %r12, %rdi
callq 0x20a4e
movq %r12, %rdi
movq %r14, %rsi
callq 0x5390
andq $0x0, 0x40(%r15)
movq %r15, %rdi
callq 0x52a0
movq %rax, %r15
jmp 0x23cd4
movq %rbx, %rdi
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
jmp 0x20b2e
// File: /workspace/github_cpp_makefile_star2_O2/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:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
movq %rsi, %r14
movq %rdi, %r15
movq 0x18(%rsi), %r12
addq $0x8, %r14
pushq $-0x1
popq %rbx
cmpq %r14, %r12
je 0x23d82
movq 0x28(%r12), %rdi
callq 0x223a8
movq (%rax), %r13
movq 0x28(%r12), %rdi
callq 0x223a8
movq 0x8(%rax), %rsi
movq %r13, %rdi
movq %r15, %rdx
callq 0x1abd1
movq %rax, %r13
movq 0x28(%r12), %rdi
callq 0x223a8
cmpq 0x8(%rax), %r13
jne 0x23d7d
movq %r12, %rdi
callq 0x52a0
movq %rax, %r12
jmp 0x23d32
movl 0x20(%r12), %ebx
movl %ebx, %eax
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
// File: /workspace/github_cpp_makefile_star2_O2/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
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq 0x2e23(%rip), %rbx      # 0x3fe0
movq (%rbx), %rax
movq -0x18(%rax), %rax
andl $0xffffefff, 0x18(%rbx,%rax) # imm = 0xFFFFEFFF
leaq -0x19(%rbp), %r14
movq 0x2df9(%rip), %r15      # 0x3fd0
movq %rbx, %rdi
movq %r14, %rsi
callq 0x1050
movq (%rax), %rcx
movq -0x18(%rcx), %rcx
testb $0x5, 0x20(%rax,%rcx)
jne 0x11fe
movsbl -0x19(%rbp), %esi
movq %r15, %rdi
callq 0x1040
jmp 0x11d7
movq (%rbx), %rax
movq -0x18(%rax), %rax
orl $0x1000, 0x18(%rbx,%rax) # imm = 0x1000
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/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 %rbx
subq $0x40, %rsp
leaq 0x38(%rsp), %rax
movq %rax, -0x30(%rax)
movq $0x1, -0x28(%rax)
xorps %xmm0, %xmm0
movups %xmm0, -0x20(%rax)
movl $0x3f800000, -0x10(%rax) # imm = 0x3F800000
movups %xmm0, -0x8(%rax)
movabsq $0x400d99999999999a, %rbx # imm = 0x400D99999999999A
movq %rsp, %rsi
movq %rbx, (%rsi)
leaq 0x8(%rsp), %rdi
callq 0x134e
movq %rsp, %rsi
movq %rbx, (%rsi)
leaq 0x8(%rsp), %rdi
callq 0x1782
testq %rax, %rax
je 0x1265
leaq 0x8(%rsp), %rdi
callq 0x129a
xorl %eax, %eax
addq $0x40, %rsp
popq %rbx
retq
leaq 0xd98(%rip), %rdi       # 0x2004
leaq 0xda2(%rip), %rsi       # 0x2015
leaq 0xdaf(%rip), %rcx       # 0x2029
pushq $0x8
popq %rdx
callq 0x1080
jmp 0x1284
movq %rax, %rbx
leaq 0x8(%rsp), %rdi
callq 0x129a
movq %rbx, %rdi
callq 0x10f0
nop
// File: /workspace/github_cpp_makefile_star2_O2/WeihuaZhu[P]hpc_prog2/seq_tests.cpp
// Function: SequentialTest_MatrixVectorMult1_Test::TestBody()
TEST(SequentialTest, MatrixVectorMult1) {
    // simple 4 by 4 input matrix
    double A[4*4] = {10., -1., 2., 0.,
                           -1., 11., -1., 3.,
                           2., -1., 10., -1.,
                           0.0, 3., -1., 8.};
    double x[4] =  {6., 25., -11., 15.};
    double y[4];
    double expected_y[4] = {13.,  325., -138.,  206.};
    int n = 4;

    // testing sequential matrix multiplication
    matrix_vector_mult(n, &A[0], &x[0], &y[0]);

    // checking if all values are correct (up to some error value)
    for (int i = 0; i < n; ++i)
    {
        EXPECT_NEAR(expected_y[i], y[i], 1e-10) << " element y[" << i << "] is wrong";
    }
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0xe8, %rsp
leaq 0x1616c(%rip), %rsi     # 0x1d0e0
pushq $0x10
popq %rcx
leaq 0x60(%rsp), %rax
movq %rax, %rdi
rep  movsq (%rsi), %es:(%rdi)
movaps 0x16127(%rip), %xmm0    # 0x1d0b0
leaq 0x40(%rsp), %rdx
movaps %xmm0, 0x10(%rdx)
movaps 0x16107(%rip), %xmm0    # 0x1d0a0
movaps %xmm0, (%rdx)
pushq $0x4
popq %rdi
leaq 0x20(%rsp), %rcx
movq %rax, %rsi
callq 0x1c6d4
leaq 0x160cd(%rip), %r12     # 0x1d080
xorl %r14d, %r14d
leaq 0x16082(%rip), %r13     # 0x1d03f
leaq 0x8(%rsp), %rbp
movq %rsp, %rbx
leaq 0x18(%rsp), %r15
cmpq $0x4, %r14
je 0x70a7
movsd (%r12), %xmm0
movsd 0x20(%rsp,%r14,8), %xmm1
movq %rbp, %rdi
leaq 0x16046(%rip), %rsi     # 0x1d031
leaq 0x16048(%rip), %rdx     # 0x1d03a
movq %r13, %rcx
movsd 0x1600b(%rip), %xmm2    # 0x1d008
callq 0x950b
cmpb $0x0, 0x8(%rsp)
jne 0x7091
movq %rbx, %rdi
callq 0x8f22
movq (%rsp), %rdi
addq $0x10, %rdi
leaq 0x16021(%rip), %rsi     # 0x1d045
callq 0x6410
movq (%rsp), %rdi
addq $0x10, %rdi
movl %r14d, %esi
callq 0x68e0
movq (%rsp), %rdi
addq $0x10, %rdi
leaq 0x16009(%rip), %rsi     # 0x1d051
callq 0x6410
movq 0x10(%rsp), %rax
leaq 0x17a4c(%rip), %r8      # 0x1eaa5
testq %rax, %rax
je 0x7061
movq (%rax), %r8
movq %r15, %rdi
pushq $0x1
popq %rsi
leaq 0x15fee(%rip), %rdx     # 0x1d05c
pushq $0x37
popq %rcx
callq 0x78f2
movq %r15, %rdi
movq %rbx, %rsi
callq 0x7970
movq %r15, %rdi
callq 0x7952
movq %rbx, %rdi
callq 0x731c
leaq 0x10(%rsp), %rdi
callq 0x7362
incq %r14
addq $0x8, %r12
jmp 0x6fca
addq $0xe8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
jmp 0x70da
jmp 0x70cf
movq %rax, %rbx
leaq 0x18(%rsp), %rdi
callq 0x7952
jmp 0x70d2
movq %rax, %rbx
movq %rsp, %rdi
callq 0x731c
leaq 0x10(%rsp), %rdi
callq 0x7362
movq %rbx, %rdi
callq 0x6900
// File: /workspace/github_cpp_makefile_star2_O2/WeihuaZhu[P]hpc_prog2/seq_tests.cpp
// Function: SequentialTest_Jacobi1_Test::TestBody()
TEST(SequentialTest, Jacobi1) {
    // simple 4 by 4 input matrix
    double A[4*4] = {10., -1., 2., 0.,
                           -1., 11., -1., 3.,
                           2., -1., 10., -1.,
                           0.0, 3., -1., 8.};
    double b[4] =  {6., 25., -11., 15.};
    double x[4];
    double expected_x[4] = {1.0,  2.0, -1.0, 1.0};
    int n = 4;

    // testing sequential matrix multiplication
    jacobi(n, A, b, x);

    // checking if all values are correct (up to some error value)
    for (int i = 0; i < n; ++i)
    {
        EXPECT_NEAR(expected_x[i], x[i], 1e-10) << " element y[" << i << "] is wrong";
    }
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0xe8, %rsp
leaq 0x15fdc(%rip), %rsi     # 0x1d0e0
pushq $0x10
popq %rcx
leaq 0x60(%rsp), %rax
movq %rax, %rdi
rep  movsq (%rsi), %es:(%rdi)
movaps 0x15f97(%rip), %xmm0    # 0x1d0b0
leaq 0x40(%rsp), %rdx
movaps %xmm0, 0x10(%rdx)
movaps 0x15f77(%rip), %xmm0    # 0x1d0a0
movaps %xmm0, (%rdx)
pushq $0x4
popq %rdi
leaq 0x20(%rsp), %rcx
pushq $0x64
popq %r8
movsd 0x15ec8(%rip), %xmm0    # 0x1d008
movq %rax, %rsi
callq 0x1c779
leaq 0x15f71(%rip), %r12     # 0x1d0c0
xorl %r14d, %r14d
leaq 0x15ee6(%rip), %r13     # 0x1d03f
leaq 0x8(%rsp), %rbp
movq %rsp, %rbx
leaq 0x18(%rsp), %r15
cmpq $0x4, %r14
je 0x7243
movsd (%r12), %xmm0
movsd 0x20(%rsp,%r14,8), %xmm1
movq %rbp, %rdi
leaq 0x15eeb(%rip), %rsi     # 0x1d072
leaq 0x15eed(%rip), %rdx     # 0x1d07b
movq %r13, %rcx
movsd 0x15e6f(%rip), %xmm2    # 0x1d008
callq 0x950b
cmpb $0x0, 0x8(%rsp)
jne 0x722d
movq %rbx, %rdi
callq 0x8f22
movq (%rsp), %rdi
addq $0x10, %rdi
leaq 0x15e85(%rip), %rsi     # 0x1d045
callq 0x6410
movq (%rsp), %rdi
addq $0x10, %rdi
movl %r14d, %esi
callq 0x68e0
movq (%rsp), %rdi
addq $0x10, %rdi
leaq 0x15e6d(%rip), %rsi     # 0x1d051
callq 0x6410
movq 0x10(%rsp), %rax
leaq 0x178b0(%rip), %r8      # 0x1eaa5
testq %rax, %rax
je 0x71fd
movq (%rax), %r8
movq %r15, %rdi
pushq $0x1
popq %rsi
leaq 0x15e52(%rip), %rdx     # 0x1d05c
pushq $0x4d
popq %rcx
callq 0x78f2
movq %r15, %rdi
movq %rbx, %rsi
callq 0x7970
movq %r15, %rdi
callq 0x7952
movq %rbx, %rdi
callq 0x731c
leaq 0x10(%rsp), %rdi
callq 0x7362
incq %r14
addq $0x8, %r12
jmp 0x7166
addq $0xe8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
jmp 0x7276
jmp 0x726b
movq %rax, %rbx
leaq 0x18(%rsp), %rdi
callq 0x7952
jmp 0x726e
movq %rax, %rbx
movq %rsp, %rdi
callq 0x731c
leaq 0x10(%rsp), %rdi
callq 0x7362
movq %rbx, %rdi
callq 0x6900
// File: /workspace/github_cpp_makefile_star2_O2/WeihuaZhu[P]hpc_prog2/./gtest/gtest.h
// Function: testing::internal::scoped_ptr<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>::reset(std::__cxx11::basic_string<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:
cmpq %rsi, (%rdi)
je 0x73b3
pushq %r15
pushq %r14
pushq %rbx
movq %rsi, %rbx
movq %rdi, %r14
pushq $0x1
popq %rdi
callq 0x78ee
testb %al, %al
je 0x73ab
movq (%r14), %r15
testq %r15, %r15
je 0x73a0
movq %r15, %rdi
callq 0x6a28
pushq $0x20
popq %rsi
movq %r15, %rdi
callq 0x6460
movq %rbx, (%r14)
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_cpp_makefile_star2_O2/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:
pushq %r14
pushq %rbx
subq $0x18, %rsp
leaq 0xc(%rsp), %rbx
movl %edi, (%rbx)
leaq 0x10(%rsp), %r14
movq %rsi, (%r14)
movq %rbx, %rdi
callq 0x10f02
movq %rbx, %rdi
movq %r14, %rsi
callq 0x6740
movq 0x26b64(%rip), %rbx     # 0x2dfa0
leaq 0x4(%rsp), %rsi
movq %rbx, %rdi
callq 0x6570
leaq 0x8(%rsp), %r14
movq %rbx, %rdi
movq %r14, %rsi
callq 0x6730
cmpl $0x0, (%r14)
jne 0x7495
movq 0x26b52(%rip), %rdi     # 0x2dfb8
leaq 0x15df0(%rip), %rsi     # 0x1d25d
callq 0x6410
movl 0x4(%rsp), %esi
movq %rax, %rdi
callq 0x68e0
leaq 0x15df5(%rip), %rsi     # 0x1d27a
movq %rax, %rdi
callq 0x6410
movq %rax, %rdi
callq 0x61f0
callq 0x7a12
movq %rax, %rdi
callq 0xc23c
movq %rax, %rbx
movq 0x8(%rax), %rsi
movq %rax, %rdi
callq 0xf886
movq %rax, %r14
pushq $0x18
popq %rdi
callq 0x6430
movl 0x8(%rsp), %ecx
leaq 0x25f39(%rip), %rdx     # 0x2d400
movq %rdx, (%rax)
movl %ecx, 0x8(%rax)
movq %r14, 0x10(%rax)
movq %rbx, %rdi
movq %rax, %rsi
callq 0xf87e
callq 0x74f0
callq 0x6330
xorl %eax, %eax
addq $0x18, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_cpp_makefile_star2_O2/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:
pushq %r14
pushq %rbx
subq $0x28, %rsp
movl %esi, %ebx
movq %rdi, %rsi
leaq 0x8(%rsp), %r14
movq %r14, %rdi
callq 0x1448d
movq (%r14), %rdi
callq 0x65e0
testq %rax, %rax
je 0x7644
movb $0x1, %bl
cmpb $0x30, (%rax)
jne 0x7644
cmpb $0x0, 0x1(%rax)
setne %bl
leaq 0x8(%rsp), %rdi
callq 0x6a28
movl %ebx, %eax
addq $0x28, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_cpp_makefile_star2_O2/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:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
subq $0x58, %rsp
movl %esi, %ebx
movq %rdi, %rsi
leaq 0x38(%rsp), %r14
movq %r14, %rdi
callq 0x1448d
movq (%r14), %rdi
callq 0x65e0
testq %rax, %rax
je 0x7783
movq %rax, %r14
movl %ebx, 0xc(%rsp)
leaq 0x18(%rsp), %rdi
callq 0x8f22
movq 0x18(%rsp), %r15
addq $0x10, %r15
leaq 0x17db1(%rip), %rsi     # 0x1f498
movq %r15, %rdi
callq 0x6410
leaq 0x38(%rsp), %rsi
movq %r15, %rdi
callq 0x63c0
leaq 0x18(%rsp), %rdi
leaq 0xc(%rsp), %rdx
movq %r14, %rsi
callq 0x10a55
movl %eax, %ebp
leaq 0x18(%rsp), %rdi
callq 0x731c
testb %bpl, %bpl
je 0x7725
movl 0xc(%rsp), %ebx
jmp 0x7783
leaq 0x10(%rsp), %rdi
callq 0x8f22
movq 0x10(%rsp), %r14
leaq 0x10(%r14), %rdi
movl %ebx, %esi
callq 0x68e0
leaq 0x18(%rsp), %rdi
movq %r14, %rsi
callq 0x90f7
leaq 0x18(%rsp), %r14
movq (%r14), %rsi
leaq 0x17d53(%rip), %rdi     # 0x1f4ae
xorl %eax, %eax
callq 0x6070
movq %r14, %rdi
callq 0x6a28
leaq 0x10(%rsp), %rdi
callq 0x731c
movq 0x2680d(%rip), %rax     # 0x2df88
movq (%rax), %rdi
callq 0x6580
leaq 0x38(%rsp), %rdi
callq 0x6a28
movl %ebx, %eax
addq $0x58, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
jmp 0x77a6
movq %rax, %rbx
leaq 0x10(%rsp), %rdi
jmp 0x77b3
movq %rax, %rbx
jmp 0x77b8
movq %rax, %rbx
leaq 0x18(%rsp), %rdi
callq 0x731c
leaq 0x38(%rsp), %rdi
callq 0x6a28
movq %rbx, %rdi
callq 0x6900
// File: /workspace/github_cpp_makefile_star2_O2/WeihuaZhu[P]hpc_prog2/./gtest/gtest-all.cc
// Function: testing::internal::Random::Generate(unsigned int)
UInt32 Random::Generate(UInt32 range) {
  // These constants are the same as are used in glibc's rand(3).
  state_ = (1103515245U*state_ + 12345U) % kMaxRange;

  GTEST_CHECK_(range > 0)
      << "Cannot generate a number in the range [0, 0).";
  GTEST_CHECK_(range <= kMaxRange)
      << "Generation of a number in [0, " << range << ") was requested, "
      << "but this can only generate numbers in [0, " << kMaxRange << ").";

  // Converting via modulus introduces a bit of downward bias, but
  // it's simple, and a linear congruential generator isn't too good
  // to begin with.
  return state_ % range;
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movl %esi, %ebx
movq %rdi, %r14
imull $0x41c64e6d, (%rdi), %eax # imm = 0x41C64E6D
addl $0x3039, %eax           # imm = 0x3039
andl $0x7fffffff, %eax       # imm = 0x7FFFFFFF
movl %eax, (%rdi)
testl %esi, %esi
je 0x787b
cmpl $0x80000001, %ebx       # imm = 0x80000001
jb 0x78c0
leaq 0x16a61(%rip), %rdx     # 0x1e261
movq %rsp, %rdi
pushq $0x3
popq %rsi
movl $0x6f5, %ecx            # imm = 0x6F5
callq 0x1418e
movq 0x267d1(%rip), %rdi     # 0x2dfe8
leaq 0x16aa3(%rip), %rsi     # 0x1e2c1
callq 0x6410
leaq 0x16abd(%rip), %rsi     # 0x1e2e7
movq %rax, %rdi
callq 0x6410
movl %ebx, %esi
movq %rax, %rdi
callq 0x62a0
leaq 0x16ac3(%rip), %rsi     # 0x1e306
movq %rax, %rdi
callq 0x6410
leaq 0x16ac6(%rip), %rsi     # 0x1e318
movq %rax, %rdi
callq 0x6410
movl $0x80000000, %esi       # imm = 0x80000000
movq %rax, %rdi
callq 0x62a0
leaq 0x16a50(%rip), %rsi     # 0x1e2be
movq %rax, %rdi
callq 0x6410
movq %rsp, %rdi
jmp 0x78bb
leaq 0x169df(%rip), %rdx     # 0x1e261
leaq 0x4(%rsp), %rdi
pushq $0x3
popq %rsi
movl $0x6f3, %ecx            # imm = 0x6F3
callq 0x1418e
movq 0x2674d(%rip), %rdi     # 0x2dfe8
leaq 0x169d4(%rip), %rsi     # 0x1e276
callq 0x6410
leaq 0x169e5(%rip), %rsi     # 0x1e293
movq %rax, %rdi
callq 0x6410
leaq 0x4(%rsp), %rdi
callq 0x14252
movl (%r14), %eax
xorl %edx, %edx
divl %ebx
movl %edx, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
movq %rax, %rbx
leaq 0x4(%rsp), %rdi
jmp 0x78e1
movq %rax, %rbx
movq %rsp, %rdi
callq 0x14252
movq %rbx, %rdi
callq 0x6900
// File: /workspace/github_cpp_makefile_star2_O2/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:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
subq $0x48, %rsp
movq %rsi, %r15
movq %rdi, %rbx
callq 0x7a12
movq (%rbx), %rsi
movl (%rsi), %ebx
movq 0x8(%rsi), %r14
movl 0x10(%rsi), %ebp
addq $0x18, %rsi
leaq 0x28(%rsp), %rdi
movq %r15, %rdx
callq 0x7d6b
callq 0x7a12
leaq 0x8(%rsp), %rdi
callq 0x7e04
leaq 0x26cc8(%rip), %rdi     # 0x2e680
leaq 0x28(%rsp), %r8
leaq 0x8(%rsp), %r9
movl %ebx, %esi
movq %r14, %rdx
movl %ebp, %ecx
callq 0x7a82
leaq 0x8(%rsp), %rdi
callq 0x6a28
leaq 0x28(%rsp), %rdi
callq 0x6a28
addq $0x48, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
leaq 0x8(%rsp), %rdi
callq 0x6a28
jmp 0x79ff
movq %rax, %rbx
leaq 0x28(%rsp), %rdi
callq 0x6a28
movq %rbx, %rdi
callq 0x6900
nop
// File: /workspace/github_cpp_makefile_star2_O2/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:
pushq %rbx
movb 0x26caf(%rip), %al      # 0x2e6c8
testb %al, %al
je 0x7a26
leaq 0x26c5c(%rip), %rax     # 0x2e680
popq %rbx
retq
leaq 0x26c9b(%rip), %rdi     # 0x2e6c8
callq 0x6950
testl %eax, %eax
je 0x7a1d
leaq 0x26c43(%rip), %rdi     # 0x2e680
callq 0xfe08
leaq 0x8425(%rip), %rdi      # 0xfe6e
leaq 0x26c30(%rip), %rsi     # 0x2e680
leaq 0x26ac1(%rip), %rdx     # 0x2e518
callq 0x63b0
leaq 0x26c65(%rip), %rdi     # 0x2e6c8
callq 0x6290
jmp 0x7a1d
movq %rax, %rbx
leaq 0x26c54(%rip), %rdi     # 0x2e6c8
callq 0x6280
movq %rbx, %rdi
callq 0x6900
nop
// File: /workspace/github_cpp_makefile_star2_O2/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:
pushq %r15
pushq %r14
pushq %rbx
subq $0x40, %rsp
movq %rsi, %r14
movq %rdi, %rbx
leaq 0x20(%rsp), %r15
movq %r15, %rdi
movq %rdx, %rsi
callq 0x90e6
cmpq $0x0, 0x8(%r15)
je 0x7dbd
leaq 0x16d0c(%rip), %rdx     # 0x1eaa4
movq %rsp, %rdi
movq %r14, %rsi
callq 0x154f6
movq %rsp, %rsi
leaq 0x20(%rsp), %rdx
movq %rbx, %rdi
callq 0x162a3
movq %rsp, %rdi
callq 0x6a28
jmp 0x7dc8
movq %rbx, %rdi
movq %r14, %rsi
callq 0x66e0
leaq 0x20(%rsp), %rdi
callq 0x6a28
movq %rbx, %rax
addq $0x40, %rsp
popq %rbx
popq %r14
popq %r15
retq
jmp 0x7dee
movq %rax, %rbx
movq %rsp, %rdi
callq 0x6a28
jmp 0x7df1
movq %rax, %rbx
leaq 0x20(%rsp), %rdi
callq 0x6a28
movq %rbx, %rdi
callq 0x6900
nop
// File: /workspace/github_cpp_makefile_star2_O2/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:
pushq %rbx
subq $0x40, %rsp
movq %rdi, %rbx
movq %rsp, %rdi
callq 0x15494
leaq 0x2680b(%rip), %rsi     # 0x2e648
leaq 0x20(%rsp), %rdi
callq 0x154a8
movq %rsp, %rdi
leaq 0x20(%rsp), %rsi
callq 0x6230
leaq 0x20(%rsp), %rdi
callq 0x6a28
movq %rsp, %rsi
movq %rbx, %rdi
callq 0x7e9e
movq %rsp, %rdi
callq 0x6a28
movq %rbx, %rax
addq $0x40, %rsp
popq %rbx
retq
jmp 0x7e8b
movq %rax, %rbx
leaq 0x20(%rsp), %rdi
callq 0x6a28
jmp 0x7e8e
movq %rax, %rbx
movq %rsp, %rdi
callq 0x6a28
movq %rbx, %rdi
callq 0x6900
// File: /workspace/github_cpp_makefile_star2_O2/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:
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
movq 0x26690(%rip), %r14     # 0x2e5b0
testq %r14, %r14
je 0x7f4c
pushq $0x3a
popq %rsi
movq %r14, %rdi
callq 0x6190
testq %rax, %rax
je 0x7f5d
leaq 0x10(%rbx), %rcx
movq %rcx, (%rbx)
movq %rbx, %rdi
movq %r14, %rsi
movq %rax, %rdx
callq 0x1a50a
jmp 0x7f6d
leaq 0x16b52(%rip), %rsi     # 0x1eaa5
leaq 0x7(%rsp), %rdx
movq %rbx, %rdi
jmp 0x7f68
leaq 0x6(%rsp), %rdx
movq %rbx, %rdi
movq %r14, %rsi
callq 0x1543a
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_cpp_makefile_star2_O2/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:
pushq %r15
pushq %r14
pushq %rbx
subq $0x60, %rsp
movq %rdx, %r14
movq %rdi, %rbx
cmpq $0x0, 0x8(%rsi)
je 0x8354
leaq 0x40(%rsp), %r15
movq %r15, %rdi
callq 0x13dea
movq %rsp, %rdi
pushq $0x2f
popq %rdx
movq %r15, %rsi
callq 0x1848d
leaq 0x20(%rsp), %rdi
movq %rsp, %rsi
movq %r14, %rdx
callq 0x162a3
leaq 0x20(%rsp), %rsi
movq %rbx, %rdi
callq 0x154a8
leaq 0x20(%rsp), %rdi
callq 0x6a28
movq %rsp, %rdi
callq 0x6a28
leaq 0x40(%rsp), %rdi
callq 0x6a28
jmp 0x835f
movq %rbx, %rdi
movq %r14, %rsi
callq 0x66e0
movq %rbx, %rax
addq $0x60, %rsp
popq %rbx
popq %r14
popq %r15
retq
movq %rax, %rbx
leaq 0x20(%rsp), %rdi
callq 0x6a28
jmp 0x837e
movq %rax, %rbx
movq %rsp, %rdi
callq 0x6a28
jmp 0x838b
movq %rax, %rbx
leaq 0x40(%rsp), %rdi
callq 0x6a28
movq %rbx, %rdi
callq 0x6900
nop
// File: /workspace/github_cpp_makefile_star2_O2/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:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x28, %rsp
movq %rcx, %r14
movq %rdx, %r15
movq %rsi, %r12
movq %rdi, %rbx
callq 0x15494
xorl %ebp, %ebp
leaq 0x8(%rsp), %r13
movq %r13, %rdi
movq %r12, %rsi
movq %r15, %rdx
movl %ebp, %ecx
movq %r14, %r8
callq 0x13c06
movq %rbx, %rdi
movq %r13, %rsi
callq 0x6230
movq %r13, %rdi
callq 0x6a28
movq %rbx, %rdi
callq 0x13e58
incl %ebp
testb %al, %al
jne 0x83f0
movq %rbx, %rax
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %r14
jmp 0x8448
movq %rax, %r14
leaq 0x8(%rsp), %rdi
callq 0x6a28
movq %rbx, %rdi
callq 0x6a28
movq %r14, %rdi
callq 0x6900