LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: GAStudyGroup[P]GPX2/src/base/sources/Utils.cpp
// Function: distance(int, int)
int distance(int p1,int p2){
    switch(Config::TYPE){
        case Config::type::EUC_2D:{
            return(EUC_2D(p1,p2));
        }
        case Config::type::GEO:{
            return(GEO(p1,p2));
        }
        case Config::type::ATT:{
            return(ATT(p1,p2));
        }
        default:
            exit(1);
            return -1;
    }
}

// Assembly:
subq $0x18, %rsp
movl %edi, 0x10(%rsp)
movl %esi, 0xc(%rsp)
leaq 0x816c5(%rip), %rax     # 0x9c9a8
movl (%rax), %eax
movl %eax, 0x8(%rsp)
testl %eax, %eax
je 0x1b305
jmp 0x1b2ef
movl 0x8(%rsp), %eax
subl $0x1, %eax
je 0x1b318
jmp 0x1b2fa
movl 0x8(%rsp), %eax
subl $0x2, %eax
je 0x1b32b
jmp 0x1b33e
movl 0x10(%rsp), %edi
movl 0xc(%rsp), %esi
callq 0x1b510
movl %eax, 0x14(%rsp)
jmp 0x1b348
movl 0x10(%rsp), %edi
movl 0xc(%rsp), %esi
callq 0x1b5e0
movl %eax, 0x14(%rsp)
jmp 0x1b348
movl 0x10(%rsp), %edi
movl 0xc(%rsp), %esi
callq 0x1b8d0
movl %eax, 0x14(%rsp)
jmp 0x1b348
movl $0x1, %edi
callq 0x65c0
movl 0x14(%rsp), %eax
addq $0x18, %rsp
retq
nopw %cs:(%rax,%rax)
// File: GAStudyGroup[P]GPX2/src/base/sources/Utils.cpp
// Function: printTour(std::vector<int, std::allocator<int>> const&, std::ostream&)
ostream& printTour(const vector<int> &t, ostream &output){
    for (int cityId : t) {
        output << cityId << " " <<Globals::map.getCityById(cityId).getX()<<" "<<Globals::map.getCityById(cityId).getY()<<"\n";
    }
    output << "\nFitness: " << getFitness(t) << "\n";
    output.flush();
    return (output);
}

// Assembly:
subq $0x78, %rsp
movq %rdi, 0x70(%rsp)
movq %rsi, 0x68(%rsp)
movq 0x70(%rsp), %rax
movq %rax, 0x60(%rsp)
movq 0x60(%rsp), %rdi
callq 0x11350
movq %rax, 0x58(%rsp)
movq 0x60(%rsp), %rdi
callq 0x11380
movq %rax, 0x50(%rsp)
leaq 0x58(%rsp), %rdi
leaq 0x50(%rsp), %rsi
callq 0x1ba70
testb $0x1, %al
jne 0x1b3ae
jmp 0x1b464
leaq 0x58(%rsp), %rdi
callq 0x1bab0
movl (%rax), %eax
movl %eax, 0x4c(%rsp)
movq 0x68(%rsp), %rdi
movl 0x4c(%rsp), %esi
callq 0x6820
movq %rax, %rdi
leaq 0x58f7e(%rip), %rsi     # 0x74354
callq 0x64a0
movq %rax, 0x8(%rsp)
movl 0x4c(%rsp), %edx
leaq 0x30(%rsp), %rdi
leaq 0x829a0(%rip), %rsi     # 0x9dd90
callq 0x19740
leaq 0x30(%rsp), %rdi
callq 0x1bb50
movq 0x8(%rsp), %rdi
callq 0x6900
movq %rax, %rdi
leaq 0x58f41(%rip), %rsi     # 0x74354
callq 0x64a0
movq %rax, 0x10(%rsp)
movl 0x4c(%rsp), %edx
leaq 0x18(%rsp), %rdi
leaq 0x82963(%rip), %rsi     # 0x9dd90
callq 0x19740
leaq 0x18(%rsp), %rdi
callq 0x1bb60
movq 0x10(%rsp), %rdi
callq 0x6900
movq %rax, %rdi
leaq 0x5a3fe(%rip), %rsi     # 0x7584e
callq 0x64a0
leaq 0x58(%rsp), %rdi
callq 0x1bac0
jmp 0x1b396
movq 0x68(%rsp), %rdi
leaq 0x592a0(%rip), %rsi     # 0x74710
callq 0x64a0
movq %rax, (%rsp)
movq 0x70(%rsp), %rdi
callq 0x1b240
movq (%rsp), %rdi
movl %eax, %esi
callq 0x6820
movq %rax, %rdi
leaq 0x5a3b6(%rip), %rsi     # 0x7584e
callq 0x64a0
movq 0x68(%rsp), %rdi
callq 0x6340
movq 0x68(%rsp), %rax
addq $0x78, %rsp
retq
nopw %cs:(%rax,%rax)
// File: GAStudyGroup[P]GPX2/src/base/sources/Utils.cpp
// Function: ATT(int, int)
int ATT(int p1,int p2){
    City c1{Globals::map.getCityById(p1)},c2{Globals::map.getCityById(p2)};
    double dX{c1.getX() - c2.getX()},dY{c1.getY()-c2.getY()},rij,tij;
    rij = sqrt((dX*dX + dY*dY)/10.0);
    tij = round(rij);

    return(tij<rij?(tij+1):tij);
}

// Assembly:
subq $0x78, %rsp
movl %edi, 0x74(%rsp)
movl %esi, 0x70(%rsp)
movl 0x74(%rsp), %edx
leaq 0x58(%rsp), %rdi
leaq 0x824a4(%rip), %rsi     # 0x9dd90
callq 0x19740
movl 0x70(%rsp), %edx
leaq 0x40(%rsp), %rdi
leaq 0x8248f(%rip), %rsi     # 0x9dd90
callq 0x19740
leaq 0x58(%rsp), %rdi
callq 0x1bb50
movsd %xmm0, 0x10(%rsp)
leaq 0x40(%rsp), %rdi
callq 0x1bb50
movaps %xmm0, %xmm1
movsd 0x10(%rsp), %xmm0
subsd %xmm1, %xmm0
movsd %xmm0, 0x38(%rsp)
leaq 0x58(%rsp), %rdi
callq 0x1bb60
movsd %xmm0, 0x18(%rsp)
leaq 0x40(%rsp), %rdi
callq 0x1bb60
movaps %xmm0, %xmm1
movsd 0x18(%rsp), %xmm0
subsd %xmm1, %xmm0
movsd %xmm0, 0x30(%rsp)
movsd 0x38(%rsp), %xmm0
movsd 0x38(%rsp), %xmm2
movsd 0x30(%rsp), %xmm1
mulsd 0x30(%rsp), %xmm1
mulsd %xmm2, %xmm0
addsd %xmm1, %xmm0
movsd 0x58d68(%rip), %xmm1    # 0x746f0
divsd %xmm1, %xmm0
callq 0x63d0
movsd %xmm0, 0x28(%rsp)
movsd 0x28(%rsp), %xmm0
callq 0x61f0
movsd %xmm0, 0x20(%rsp)
movsd 0x20(%rsp), %xmm1
movsd 0x28(%rsp), %xmm0
ucomisd %xmm1, %xmm0
jbe 0x1b9d0
movsd 0x588ee(%rip), %xmm0    # 0x742b0
addsd 0x20(%rsp), %xmm0
movsd %xmm0, 0x8(%rsp)
jmp 0x1b9dc
movsd 0x20(%rsp), %xmm0
movsd %xmm0, 0x8(%rsp)
movsd 0x8(%rsp), %xmm0
cvttsd2si %xmm0, %eax
addq $0x78, %rsp
retq
nopl (%rax,%rax)
// File: GAStudyGroup[P]GPX2/src/base/sources/City.cpp
// Function: City::operator==(City const&) const
bool City::operator==(const City& c) const
{ // Overload para comparação de city==city
    if ((c.getX() == this->x) && (c.getY() == this->y) && (c.getId() == this->id)) {
        return (true);
    } else {
        return (false);
    }
}

// Assembly:
subq $0x28, %rsp
movq %rdi, 0x18(%rsp)
movq %rsi, 0x10(%rsp)
movq 0x18(%rsp), %rax
movq %rax, 0x8(%rsp)
movq 0x10(%rsp), %rdi
callq 0x1bb50
movq 0x8(%rsp), %rax
ucomisd 0x8(%rax), %xmm0
jne 0x1bc42
jp 0x1bc42
movq 0x10(%rsp), %rdi
callq 0x1bb60
movq 0x8(%rsp), %rax
ucomisd 0x10(%rax), %xmm0
jne 0x1bc42
jp 0x1bc42
movq 0x10(%rsp), %rdi
callq 0x1bb70
movq 0x8(%rsp), %rcx
cmpl (%rcx), %eax
jne 0x1bc42
movb $0x1, 0x27(%rsp)
jmp 0x1bc47
movb $0x0, 0x27(%rsp)
movb 0x27(%rsp), %al
andb $0x1, %al
addq $0x28, %rsp
retq
nopw %cs:(%rax,%rax)
// File: GAStudyGroup[P]GPX2/src/base/sources/City.cpp
// Function: City::operator=(City const&)
const City& City::operator=(const City& c)
{ // Overload de atribuição city=city
    this->x = c.getX();
    this->y = c.getY();
    this->id = c.getId();
    return (c);
}

// Assembly:
subq $0x18, %rsp
movq %rdi, 0x10(%rsp)
movq %rsi, 0x8(%rsp)
movq 0x10(%rsp), %rax
movq %rax, (%rsp)
movq 0x8(%rsp), %rdi
callq 0x1bb50
movq (%rsp), %rax
movsd %xmm0, 0x8(%rax)
movq 0x8(%rsp), %rdi
callq 0x1bb60
movq (%rsp), %rax
movsd %xmm0, 0x10(%rax)
movq 0x8(%rsp), %rdi
callq 0x1bb70
movl %eax, %ecx
movq (%rsp), %rax
movl %ecx, (%rax)
movq 0x8(%rsp), %rax
addq $0x18, %rsp
retq
nopl (%rax)
// File: GAStudyGroup[P]GPX2/src/base/sources/ImportData.cpp
// Function: ImportData::findIgnoredWords(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>)
bool ImportData::findIgnoredWords(string input)
{
    regex ignore(":|NAME(.*)|TYPE(.*)|COMMENT(.*)|DIMENSION(.*)|EDGE(.*)|EOF");
    if (regex_match(input, ignore)) {
        return false;
    }
    //  cout << input;
    return true;
}

// Assembly:
subq $0x68, %rsp
movq %rsi, 0x8(%rsp)
movq %rdi, 0x58(%rsp)
movq %rsi, 0x50(%rsp)
leaq 0x58108(%rip), %rsi     # 0x74932
leaq 0x30(%rsp), %rdi
movq %rdi, 0x10(%rsp)
movl $0x10, %edx
callq 0x1df60
movq 0x8(%rsp), %rdi
movq 0x10(%rsp), %rsi
xorl %edx, %edx
callq 0x1e010
movb %al, 0x1f(%rsp)
jmp 0x1c855
movb 0x1f(%rsp), %al
testb $0x1, %al
jne 0x1c85f
jmp 0x1c888
movb $0x0, 0x67(%rsp)
movl $0x1, 0x20(%rsp)
jmp 0x1c895
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x28(%rsp)
movl %eax, 0x24(%rsp)
leaq 0x30(%rsp), %rdi
callq 0x1e090
jmp 0x1c8aa
movb $0x1, 0x67(%rsp)
movl $0x1, 0x20(%rsp)
leaq 0x30(%rsp), %rdi
callq 0x1e090
movb 0x67(%rsp), %al
andb $0x1, %al
addq $0x68, %rsp
retq
movq 0x28(%rsp), %rdi
callq 0x6850
nopw %cs:(%rax,%rax)
// File: GAStudyGroup[P]GPX2/src/base/sources/ImportData.cpp
// Function: ImportData::setEdge_Type(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>)
void ImportData::setEdge_Type(string type){
    if(!type.compare("EUC_2D")){
        Config::TYPE = Config::type::EUC_2D;
    }else if(!type.compare("GEO")){
        Config::TYPE = Config::type::GEO;
    }else if(!type.compare("ATT")){
        Config::TYPE = Config::type::ATT;
    }else{
        cout<<"Unknown edge type."<<endl;
        exit(0);
    }

}

// Assembly:
subq $0x28, %rsp
movq %rsi, 0x8(%rsp)
movq %rdi, %rax
movq 0x8(%rsp), %rdi
movq %rdi, 0x10(%rsp)
movq %rax, 0x20(%rsp)
movq %rdi, 0x18(%rsp)
leaq 0x57daa(%rip), %rsi     # 0x749c1
callq 0x6150
cmpl $0x0, %eax
jne 0x1cc30
leaq 0x7fd80(%rip), %rax     # 0x9c9a8
movl $0x0, (%rax)
jmp 0x1cca7
movq 0x10(%rsp), %rdi
leaq 0x57d8c(%rip), %rsi     # 0x749c8
callq 0x6150
cmpl $0x0, %eax
jne 0x1cc55
leaq 0x7fd5b(%rip), %rax     # 0x9c9a8
movl $0x1, (%rax)
jmp 0x1cca5
movq 0x10(%rsp), %rdi
leaq 0x57d6b(%rip), %rsi     # 0x749cc
callq 0x6150
cmpl $0x0, %eax
jne 0x1cc7a
leaq 0x7fd36(%rip), %rax     # 0x9c9a8
movl $0x2, (%rax)
jmp 0x1cca3
movq 0x7f317(%rip), %rdi     # 0x9bf98
leaq 0x57d48(%rip), %rsi     # 0x749d0
callq 0x64a0
movq %rax, %rdi
movq 0x7f2b9(%rip), %rsi     # 0x9bf50
callq 0x6500
xorl %edi, %edi
callq 0x65c0
jmp 0x1cca5
jmp 0x1cca7
addq $0x28, %rsp
retq
nopl (%rax)
// File: GAStudyGroup[P]GPX2/src/base/sources/ImportData.cpp
// Function: ImportData::getcomment[abi:cxx11]()
string ImportData::getcomment()
{
    if (comment == "") {
        return "N/A";
    } else {
        return comment;
    }
}

// Assembly:
subq $0x48, %rsp
movq %rdi, 0x8(%rsp)
movq %rdi, %rax
movq %rax, 0x10(%rsp)
movq %rdi, 0x40(%rsp)
movq %rsi, 0x38(%rsp)
movq 0x38(%rsp), %rdi
movq %rdi, 0x18(%rsp)
addq $0x40, %rdi
leaq 0x589d4(%rip), %rsi     # 0x759f4
callq 0x1e060
testb $0x1, %al
jne 0x1d02b
jmp 0x1d076
leaq 0x37(%rsp), %rdi
movq %rdi, (%rsp)
callq 0x6860
movq 0x8(%rsp), %rdi
movq (%rsp), %rdx
leaq 0x57843(%rip), %rsi     # 0x7488c
callq 0x92b0
jmp 0x1d050
leaq 0x37(%rsp), %rdi
callq 0x6520
jmp 0x1d089
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x28(%rsp)
movl %eax, 0x24(%rsp)
leaq 0x37(%rsp), %rdi
callq 0x6520
jmp 0x1d093
movq 0x8(%rsp), %rdi
movq 0x18(%rsp), %rsi
addq $0x40, %rsi
callq 0x6200
movq 0x10(%rsp), %rax
addq $0x48, %rsp
retq
movq 0x28(%rsp), %rdi
callq 0x6850
nopl (%rax)
// File: GAStudyGroup[P]GPX2/src/base/sources/ImportData.cpp
// Function: ImportData::explode(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&, char)
std::vector<std::string> ImportData::explode(std::string const & s, char delim)
{
    std::vector<std::string> result;
    std::istringstream iss(s);

    for (std::string token; std::getline(iss, token, delim); )
    {
        result.push_back(std::move(token));
    }

    return result;
}

// Assembly:
subq $0x1f8, %rsp            # imm = 0x1F8
movq %rdi, 0x18(%rsp)
movb %cl, %al
movq %rdi, %rcx
movq %rcx, 0x20(%rsp)
movq %rdi, 0x1f0(%rsp)
movq %rsi, 0x1e8(%rsp)
movq %rdx, 0x1e0(%rsp)
movb %al, 0x1df(%rsp)
movb $0x0, 0x1de(%rsp)
callq 0x1e3e0
movq 0x1e0(%rsp), %rsi
leaq 0x58(%rsp), %rdi
movl $0x8, %edx
callq 0x67d0
jmp 0x1de6b
leaq 0x28(%rsp), %rdi
callq 0x6690
movsbl 0x1df(%rsp), %edx
leaq 0x58(%rsp), %rdi
leaq 0x28(%rsp), %rsi
callq 0x68a0
movq %rax, 0x10(%rsp)
jmp 0x1de93
movq 0x10(%rsp), %rdi
movq (%rdi), %rax
movq -0x18(%rax), %rax
addq %rax, %rdi
callq 0x65f0
movb %al, 0xf(%rsp)
jmp 0x1dead
movb 0xf(%rsp), %al
testb $0x1, %al
jne 0x1def7
jmp 0x1deb7
leaq 0x28(%rsp), %rdi
callq 0x6988
jmp 0x1df0d
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x50(%rsp)
movl %eax, 0x4c(%rsp)
jmp 0x1df40
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x50(%rsp)
movl %eax, 0x4c(%rsp)
leaq 0x28(%rsp), %rdi
callq 0x6988
leaq 0x58(%rsp), %rdi
callq 0x6230
jmp 0x1df40
movq 0x18(%rsp), %rdi
leaq 0x28(%rsp), %rsi
callq 0x1e3f0
jmp 0x1df08
jmp 0x1de75
movb $0x1, 0x1de(%rsp)
leaq 0x58(%rsp), %rdi
callq 0x6230
testb $0x1, 0x1de(%rsp)
jne 0x1df33
movq 0x18(%rsp), %rdi
callq 0xa2c0
movq 0x20(%rsp), %rax
addq $0x1f8, %rsp            # imm = 0x1F8
retq
movq 0x18(%rsp), %rdi
callq 0xa2c0
movq 0x50(%rsp), %rdi
callq 0x6850
nopw %cs:(%rax,%rax)
nop
// File: GAStudyGroup[P]GPX2/src/args/Arg.cpp
// Function: Arg::split(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, char)
vector<string> Arg::split(const string s, char c) {
    vector<string> tokens;
    string token;
    istringstream tokenStream(s);
    while (getline(tokenStream, token, c)) {
        if (!token.empty()) {
            tokens.push_back(token);
        }
    }
    return tokens;
}

// Assembly:
subq $0x1f8, %rsp            # imm = 0x1F8
movq %rdx, 0x20(%rsp)
movq %rdi, 0x10(%rsp)
movb %cl, %al
movq %rdi, %rcx
movq %rcx, 0x18(%rsp)
movq %rdi, 0x1f0(%rsp)
movq %rsi, 0x1e8(%rsp)
movq %rdx, 0x1e0(%rsp)
movb %al, 0x1df(%rsp)
movb $0x0, 0x1de(%rsp)
callq 0x1e3e0
leaq 0x1b8(%rsp), %rdi
callq 0x6690
movq 0x20(%rsp), %rsi
leaq 0x38(%rsp), %rdi
movl $0x8, %edx
callq 0x67d0
jmp 0x47ada
jmp 0x47adc
movsbl 0x1df(%rsp), %edx
leaq 0x38(%rsp), %rdi
leaq 0x1b8(%rsp), %rsi
callq 0x68a0
movq %rax, 0x8(%rsp)
jmp 0x47afd
movq 0x8(%rsp), %rdi
movq (%rdi), %rax
movq -0x18(%rax), %rax
addq %rax, %rdi
callq 0x65f0
movb %al, 0x7(%rsp)
jmp 0x47b17
movb 0x7(%rsp), %al
testb $0x1, %al
jne 0x47b21
jmp 0x47b77
leaq 0x1b8(%rsp), %rdi
callq 0x67b0
testb $0x1, %al
jne 0x47b72
movq 0x10(%rsp), %rdi
leaq 0x1b8(%rsp), %rsi
callq 0x37210
jmp 0x47b46
jmp 0x47b72
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x30(%rsp)
movl %eax, 0x2c(%rsp)
jmp 0x47ba2
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x30(%rsp)
movl %eax, 0x2c(%rsp)
leaq 0x38(%rsp), %rdi
callq 0x6230
jmp 0x47ba2
jmp 0x47adc
movb $0x1, 0x1de(%rsp)
leaq 0x38(%rsp), %rdi
callq 0x6230
leaq 0x1b8(%rsp), %rdi
callq 0x6988
testb $0x1, 0x1de(%rsp)
jne 0x47bc5
jmp 0x47bbb
leaq 0x1b8(%rsp), %rdi
callq 0x6988
movq 0x10(%rsp), %rdi
callq 0xa2c0
jmp 0x47bd2
movq 0x10(%rsp), %rdi
callq 0xa2c0
movq 0x18(%rsp), %rax
addq $0x1f8, %rsp            # imm = 0x1F8
retq
movq 0x30(%rsp), %rdi
callq 0x6850
nopl (%rax)
// File: GAStudyGroup[P]GPX2/src/args/Arg.cpp
// Function: Arg::validateArguments()
void Arg::validateArguments(){
    //programmer error, name or alias repeated
    nameConflict();
    
    processInput();
    if(helpSetted && isSet("help")){
        throw std::runtime_error(help());
    }else{
        processRequired();
    }
}

// Assembly:
subq $0x88, %rsp
movq %rdi, 0x80(%rsp)
movq 0x80(%rsp), %rdi
movq %rdi, 0x18(%rsp)
callq 0x47db0
movq 0x18(%rsp), %rdi
callq 0x482d0
movq 0x18(%rsp), %rax
movb 0x48(%rax), %cl
movb $0x0, 0x5e(%rsp)
movb $0x0, 0x4b(%rsp)
xorl %eax, %eax
testb $0x1, %cl
movb %al, 0x26(%rsp)
je 0x47c78
leaq 0x5f(%rsp), %rdi
movq %rdi, 0x10(%rsp)
callq 0x6860
movq 0x10(%rsp), %rdx
movb $0x1, 0x5e(%rsp)
leaq 0x2dba9(%rip), %rsi     # 0x757f1
leaq 0x60(%rsp), %rdi
callq 0x92b0
jmp 0x47c54
movq 0x18(%rsp), %rdi
movb $0x1, 0x4b(%rsp)
leaq 0x60(%rsp), %rsi
callq 0x489e0
movb %al, 0xf(%rsp)
jmp 0x47c6e
movb 0xf(%rsp), %al
movb %al, 0x26(%rsp)
jmp 0x47c78
movb 0x26(%rsp), %al
movb %al, 0xe(%rsp)
testb $0x1, 0x4b(%rsp)
jne 0x47c89
jmp 0x47c93
leaq 0x60(%rsp), %rdi
callq 0x6988
testb $0x1, 0x5e(%rsp)
jne 0x47c9c
jmp 0x47ca6
leaq 0x5f(%rsp), %rdi
callq 0x6520
movb 0xe(%rsp), %al
testb $0x1, %al
jne 0x47cb3
jmp 0x47d8c
movb $0x1, 0x27(%rsp)
movl $0x10, %edi
callq 0x6240
movq 0x18(%rsp), %rsi
movq %rax, (%rsp)
leaq 0x28(%rsp), %rdi
callq 0x48a80
jmp 0x47cd7
movq (%rsp), %rdi
leaq 0x28(%rsp), %rsi
callq 0x6770
jmp 0x47ce7
movq (%rsp), %rdi
movb $0x0, 0x27(%rsp)
movq 0x542f1(%rip), %rsi     # 0x9bfe8
movq 0x54282(%rip), %rdx     # 0x9bf80
callq 0x67f0
jmp 0x47da8
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x50(%rsp)
movl %eax, 0x4c(%rsp)
jmp 0x47d3b
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x50(%rsp)
movl %eax, 0x4c(%rsp)
testb $0x1, 0x4b(%rsp)
jne 0x47d2f
jmp 0x47d39
leaq 0x60(%rsp), %rdi
callq 0x6988
jmp 0x47d3b
testb $0x1, 0x5e(%rsp)
jne 0x47d44
jmp 0x47d4e
leaq 0x5f(%rsp), %rdi
callq 0x6520
jmp 0x47d9e
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x50(%rsp)
movl %eax, 0x4c(%rsp)
jmp 0x47d78
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x50(%rsp)
movl %eax, 0x4c(%rsp)
leaq 0x28(%rsp), %rdi
callq 0x6988
testb $0x1, 0x27(%rsp)
jne 0x47d81
jmp 0x47d8a
movq (%rsp), %rdi
callq 0x6390
jmp 0x47d9e
movq 0x18(%rsp), %rdi
callq 0x48ca0
addq $0x88, %rsp
retq
movq 0x50(%rsp), %rdi
callq 0x6850
nopl (%rax,%rax)
// File: GAStudyGroup[P]GPX2/src/args/Arg.cpp
// Function: Arg::isSet(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>)
bool Arg::isSet(string arg){
    Argument *a = getArgument(arg);
    if(a!=nullptr){
        return(a->isSet());
    }
    return false;
}

// Assembly:
subq $0x68, %rsp
movq %rdi, 0x58(%rsp)
movq %rsi, 0x50(%rsp)
movq 0x58(%rsp), %rax
movq %rax, (%rsp)
leaq 0x28(%rsp), %rdi
movq %rdi, 0x8(%rsp)
callq 0x6200
movq (%rsp), %rdi
movq 0x8(%rsp), %rsi
callq 0x49080
movq %rax, 0x10(%rsp)
jmp 0x48a1b
leaq 0x28(%rsp), %rdi
callq 0x6988
movq 0x10(%rsp), %rax
movq %rax, 0x48(%rsp)
cmpq $0x0, 0x48(%rsp)
je 0x48a63
movq 0x48(%rsp), %rdi
callq 0x49c30
andb $0x1, %al
movb %al, 0x67(%rsp)
jmp 0x48a68
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x20(%rsp)
movl %eax, 0x1c(%rsp)
leaq 0x28(%rsp), %rdi
callq 0x6988
jmp 0x48a73
movb $0x0, 0x67(%rsp)
movb 0x67(%rsp), %al
andb $0x1, %al
addq $0x68, %rsp
retq
movq 0x20(%rsp), %rdi
callq 0x6850
nopl (%rax)
// File: GAStudyGroup[P]GPX2/src/args/Arg.cpp
// Function: Arg::help[abi:cxx11]()
string Arg::help(){
    string tmp{};

    tmp += programName+"\n\n";
    tmp += "Options:\n";

    for(Argument a : arguments){
        tmp += a.to_string();
        tmp += "\n\n";
    }

    return(tmp);
}

// Assembly:
subq $0xf8, %rsp
movq %rdi, (%rsp)
movq %rdi, %rax
movq %rax, 0x8(%rsp)
movq %rdi, 0xf0(%rsp)
movq %rsi, 0xe8(%rsp)
movq 0xe8(%rsp), %rax
movq %rax, 0x10(%rsp)
movb $0x0, 0xe7(%rsp)
callq 0x6690
movq 0x10(%rsp), %rsi
addq $0x28, %rsi
leaq 0x2cd80(%rip), %rdx     # 0x7584d
leaq 0xc0(%rsp), %rdi
callq 0x18b20
jmp 0x48adc
movq (%rsp), %rdi
leaq 0xc0(%rsp), %rsi
callq 0x6620
jmp 0x48aef
leaq 0xc0(%rsp), %rdi
callq 0x6988
movq (%rsp), %rdi
leaq 0x2cd49(%rip), %rsi     # 0x75850
callq 0x6490
jmp 0x48b0e
movq 0x10(%rsp), %rax
movq %rax, 0xa8(%rsp)
movq 0xa8(%rsp), %rdi
callq 0x49740
movq %rax, 0xa0(%rsp)
movq 0xa8(%rsp), %rdi
callq 0x49770
movq %rax, 0x98(%rsp)
leaq 0xa0(%rsp), %rdi
leaq 0x98(%rsp), %rsi
callq 0x497a0
testb $0x1, %al
jne 0x48b63
jmp 0x48c54
leaq 0xa0(%rsp), %rdi
callq 0x497e0
movq %rax, %rsi
leaq 0x38(%rsp), %rdi
callq 0x497f0
jmp 0x48b7f
leaq 0x18(%rsp), %rdi
leaq 0x38(%rsp), %rsi
callq 0x499a0
jmp 0x48b90
movq (%rsp), %rdi
leaq 0x18(%rsp), %rsi
callq 0x6620
jmp 0x48ba0
leaq 0x18(%rsp), %rdi
callq 0x6988
movq (%rsp), %rdi
leaq 0x2cc98(%rip), %rsi     # 0x7584d
callq 0x6490
jmp 0x48bbc
leaq 0x38(%rsp), %rdi
callq 0xa280
leaq 0xa0(%rsp), %rdi
callq 0x49930
jmp 0x48b45
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0xb8(%rsp)
movl %eax, 0xb4(%rsp)
jmp 0x48c7c
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0xb8(%rsp)
movl %eax, 0xb4(%rsp)
leaq 0xc0(%rsp), %rdi
callq 0x6988
jmp 0x48c7c
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0xb8(%rsp)
movl %eax, 0xb4(%rsp)
jmp 0x48c48
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0xb8(%rsp)
movl %eax, 0xb4(%rsp)
leaq 0x18(%rsp), %rdi
callq 0x6988
leaq 0x38(%rsp), %rdi
callq 0xa280
jmp 0x48c7c
movb $0x1, 0xe7(%rsp)
testb $0x1, 0xe7(%rsp)
jne 0x48c6f
movq (%rsp), %rdi
callq 0x6988
movq 0x8(%rsp), %rax
addq $0xf8, %rsp
retq
movq (%rsp), %rdi
callq 0x6988
movq 0xb8(%rsp), %rdi
callq 0x6850
nopw %cs:(%rax,%rax)
// File: GAStudyGroup[P]GPX2/src/args/Arg.cpp
// Function: Arg::throwException(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>)
void Arg::throwException(string errorMsg){
    if(!errorMsg.empty()){
        if(helpSetted){
            errorMsg += "\nUse -help or -h to display program options.";
        }
        throw std::runtime_error(errorMsg);
    }
}

// Assembly:
subq $0x48, %rsp
movq %rsi, 0x10(%rsp)
movq %rdi, %rax
movq 0x10(%rsp), %rdi
movq %rdi, 0x18(%rsp)
movq %rax, 0x40(%rsp)
movq %rdi, 0x38(%rsp)
movq 0x40(%rsp), %rax
movq %rax, 0x20(%rsp)
callq 0x67b0
testb $0x1, %al
jne 0x49062
movq 0x20(%rsp), %rax
testb $0x1, 0x48(%rax)
je 0x4900f
movq 0x18(%rsp), %rdi
leaq 0x2c816(%rip), %rsi     # 0x75820
callq 0x6490
movl $0x10, %edi
callq 0x6240
movq 0x18(%rsp), %rsi
movq %rax, %rdi
movq %rdi, %rax
movq %rax, 0x8(%rsp)
callq 0x6770
jmp 0x49030
movq 0x8(%rsp), %rdi
movq 0x52fac(%rip), %rsi     # 0x9bfe8
movq 0x52f3d(%rip), %rdx     # 0x9bf80
callq 0x67f0
movq 0x8(%rsp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x30(%rsp)
movl %eax, 0x2c(%rsp)
callq 0x6390
jmp 0x49067
addq $0x48, %rsp
retq
movq 0x30(%rsp), %rdi
callq 0x6850
nopw %cs:(%rax,%rax)
// File: GAStudyGroup[P]GPX2/src/args/Arg.cpp
// Function: Arg::getOption(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>)
string Arg::getOption(string arg){
    Argument *a = getArgument(arg);
    if(a!=nullptr){
        return(a->getOption());
    }
    return {};
}

// Assembly:
subq $0x88, %rsp
movq %rdx, 0x8(%rsp)
movq %rsi, %rax
movq 0x8(%rsp), %rsi
movq %rdi, 0x10(%rsp)
movq %rdi, %rcx
movq %rcx, 0x18(%rsp)
movq %rdi, 0x80(%rsp)
movq %rax, 0x78(%rsp)
movq %rsi, 0x70(%rsp)
movq 0x78(%rsp), %rax
movq %rax, 0x20(%rsp)
leaq 0x48(%rsp), %rdi
movq %rdi, 0x28(%rsp)
callq 0x6200
movq 0x20(%rsp), %rdi
movq 0x28(%rsp), %rsi
callq 0x49080
movq %rax, 0x30(%rsp)
jmp 0x49422
leaq 0x48(%rsp), %rdi
callq 0x6988
movq 0x30(%rsp), %rax
movq %rax, 0x68(%rsp)
cmpq $0x0, 0x68(%rsp)
je 0x49469
movq 0x10(%rsp), %rdi
movq 0x68(%rsp), %rsi
callq 0x498b0
jmp 0x49473
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x40(%rsp)
movl %eax, 0x3c(%rsp)
leaq 0x48(%rsp), %rdi
callq 0x6988
jmp 0x49480
movq 0x10(%rsp), %rdi
callq 0x6690
movq 0x18(%rsp), %rax
addq $0x88, %rsp
retq
movq 0x40(%rsp), %rdi
callq 0x6850
nopw (%rax,%rax)
// File: GAStudyGroup[P]GPX2/src/args/Arg.hpp
// Function: Arg::Argument::to_string[abi:cxx11]()
string to_string(){
                    string tmp{};
                    for(unsigned i=0;i<arg.size();i++){
                        tmp += arg[i];
                        if(i+1 != arg.size()){
                            tmp += "|";
                        }
                    }
                    tmp += ((required)?("\n\tRequired."):(""));
                    tmp += "\n\tDescription: "+((description.empty())?("no description."):(description));
                    return(tmp);
                }

// Assembly:
subq $0xa8, %rsp
movq %rdi, 0x20(%rsp)
movq %rdi, %rax
movq %rax, 0x28(%rsp)
movq %rdi, 0xa0(%rsp)
movq %rsi, 0x98(%rsp)
movq 0x98(%rsp), %rax
movq %rax, 0x30(%rsp)
movb $0x0, 0x97(%rsp)
callq 0x6690
movl $0x0, 0x90(%rsp)
movq 0x30(%rsp), %rdi
movl 0x90(%rsp), %eax
movq %rax, 0x18(%rsp)
callq 0x30bb0
movq %rax, %rcx
movq 0x18(%rsp), %rax
cmpq %rcx, %rax
jae 0x49aa0
movq 0x30(%rsp), %rdi
movl 0x90(%rsp), %eax
movl %eax, %esi
callq 0x49910
movq 0x20(%rsp), %rdi
movq %rax, %rsi
callq 0x6620
jmp 0x49a32
movq 0x30(%rsp), %rdi
movl 0x90(%rsp), %eax
addl $0x1, %eax
movl %eax, %eax
movq %rax, 0x10(%rsp)
callq 0x30bb0
movq %rax, %rcx
movq 0x10(%rsp), %rax
cmpq %rcx, %rax
je 0x49a88
movq 0x20(%rsp), %rdi
leaq 0x2afcb(%rip), %rsi     # 0x74a31
callq 0x6490
jmp 0x49a6d
jmp 0x49a88
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x88(%rsp)
movl %eax, 0x84(%rsp)
jmp 0x49c0b
jmp 0x49a8a
movl 0x90(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x90(%rsp)
jmp 0x499e9
movq 0x20(%rsp), %rdi
movq 0x30(%rsp), %rax
movb 0x38(%rax), %cl
leaq 0x2bdf1(%rip), %rax     # 0x758a5
leaq 0x2bf39(%rip), %rsi     # 0x759f4
testb $0x1, %cl
cmovneq %rax, %rsi
callq 0x6490
jmp 0x49ac9
movq 0x30(%rsp), %rdi
addq $0x18, %rdi
callq 0x67b0
movb $0x0, 0x3e(%rsp)
testb $0x1, %al
jne 0x49ae2
jmp 0x49b10
leaq 0x3f(%rsp), %rdi
movq %rdi, 0x8(%rsp)
callq 0x6860
movq 0x8(%rsp), %rdx
movb $0x1, 0x3e(%rsp)
leaq 0x2bdbf(%rip), %rsi     # 0x758c1
leaq 0x40(%rsp), %rdi
callq 0x92b0
jmp 0x49b0e
jmp 0x49b27
movq 0x30(%rsp), %rsi
addq $0x18, %rsi
leaq 0x40(%rsp), %rdi
callq 0x6200
jmp 0x49b25
jmp 0x49b27
leaq 0x2bd83(%rip), %rsi     # 0x758b1
leaq 0x60(%rsp), %rdi
leaq 0x40(%rsp), %rdx
callq 0x18850
jmp 0x49b3f
movq 0x20(%rsp), %rdi
leaq 0x60(%rsp), %rsi
callq 0x6620
jmp 0x49b50
leaq 0x60(%rsp), %rdi
callq 0x6988
leaq 0x40(%rsp), %rdi
callq 0x6988
testb $0x1, 0x3e(%rsp)
jne 0x49b6d
jmp 0x49b77
leaq 0x3f(%rsp), %rdi
callq 0x6520
movb $0x1, 0x97(%rsp)
testb $0x1, 0x97(%rsp)
jne 0x49bfe
jmp 0x49bf4
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x88(%rsp)
movl %eax, 0x84(%rsp)
jmp 0x49bdf
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x88(%rsp)
movl %eax, 0x84(%rsp)
jmp 0x49bd5
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x88(%rsp)
movl %eax, 0x84(%rsp)
leaq 0x60(%rsp), %rdi
callq 0x6988
leaq 0x40(%rsp), %rdi
callq 0x6988
testb $0x1, 0x3e(%rsp)
jne 0x49be8
jmp 0x49bf2
leaq 0x3f(%rsp), %rdi
callq 0x6520
jmp 0x49c0b
movq 0x20(%rsp), %rdi
callq 0x6988
movq 0x28(%rsp), %rax
addq $0xa8, %rsp
retq
movq 0x20(%rsp), %rdi
callq 0x6988
movq 0x88(%rsp), %rdi
callq 0x6850
nopw %cs:(%rax,%rax)
nopl (%rax)
// File: GAStudyGroup[P]GPX2/src/args/Arg.hpp
// Function: Arg::Argument::setArg(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 setArg(vector<string> arg){
                    if(arg.empty()){
                        throw std::invalid_argument("empty string");
                    }else{
                        this->arg = arg;
                    }
                }

// Assembly:
subq $0x48, %rsp
movq %rsi, 0x10(%rsp)
movq %rdi, %rax
movq 0x10(%rsp), %rdi
movq %rdi, 0x18(%rsp)
movq %rax, 0x40(%rsp)
movq %rdi, 0x38(%rsp)
movq 0x40(%rsp), %rax
movq %rax, 0x20(%rsp)
callq 0x49f70
testb $0x1, %al
jne 0x49ef5
jmp 0x49f4a
movl $0x10, %edi
callq 0x6240
movq %rax, %rdi
movq %rdi, %rax
movq %rax, 0x8(%rsp)
leaq 0x2b987(%rip), %rsi     # 0x75898
callq 0x68f0
jmp 0x49f18
movq 0x8(%rsp), %rdi
movq 0x520a4(%rip), %rsi     # 0x9bfc8
movq 0x52085(%rip), %rdx     # 0x9bfb0
callq 0x67f0
movq 0x8(%rsp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x30(%rsp)
movl %eax, 0x2c(%rsp)
callq 0x6390
jmp 0x49f5e
movq 0x18(%rsp), %rsi
movq 0x20(%rsp), %rdi
callq 0x49fc0
addq $0x48, %rsp
retq
movq 0x30(%rsp), %rdi
callq 0x6850
nopl (%rax,%rax)
// File: GAStudyGroup[P]GPX2/src/opt/Opt.cpp
// Function: Opt::optimize(std::vector<int, std::allocator<int>>&)
vector<int> Opt::optimize(vector<int> &tour){
    Opt obj;

    bool run{false};
    long unsigned int routeSize{tour.size()};
    do{
        run = false;
        for(unsigned i=1;i<routeSize-2;i++){
            edge baseEdge(i-1,i);
            for(unsigned j=i+1;j<routeSize-1;j++){
                edge comparingEdge(j,j+1);
                if(!obj.adjacent(baseEdge,comparingEdge)){
                    if(obj.isBetter(baseEdge,comparingEdge,tour)){
                        reverse(tour.begin()+baseEdge.second,tour.begin()+comparingEdge.first+1);
                        run = true;
                        break;
                    }
                }
            }
            if(run){
                break;
            }
        }
    }while(run);

    return(tour);
}

// Assembly:
subq $0x98, %rsp
movq %rdi, 0x10(%rsp)
movq %rdi, %rax
movq %rax, 0x18(%rsp)
movq %rdi, 0x90(%rsp)
movq %rsi, 0x88(%rsp)
leaq 0x87(%rsp), %rdi
callq 0x4c200
movb $0x0, 0x86(%rsp)
movq 0x88(%rsp), %rdi
callq 0x107e0
movq %rax, 0x78(%rsp)
movb $0x0, 0x86(%rsp)
movl $0x1, 0x74(%rsp)
movl 0x74(%rsp), %eax
movq 0x78(%rsp), %rcx
subq $0x2, %rcx
cmpq %rcx, %rax
jae 0x4c419
movl 0x74(%rsp), %eax
decl %eax
movl %eax, 0x68(%rsp)
leaq 0x6c(%rsp), %rdi
leaq 0x68(%rsp), %rsi
leaq 0x74(%rsp), %rdx
callq 0x4c610
jmp 0x4c2b1
movl 0x74(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x58(%rsp)
movl 0x58(%rsp), %eax
movq 0x78(%rsp), %rcx
subq $0x1, %rcx
cmpq %rcx, %rax
jae 0x4c3fb
movl 0x58(%rsp), %eax
incl %eax
movl %eax, 0x4c(%rsp)
leaq 0x50(%rsp), %rdi
leaq 0x58(%rsp), %rsi
leaq 0x4c(%rsp), %rdx
callq 0x4c640
jmp 0x4c2f2
leaq 0x87(%rsp), %rdi
leaq 0x6c(%rsp), %rsi
leaq 0x50(%rsp), %rdx
callq 0x4c470
movb %al, 0xf(%rsp)
jmp 0x4c30f
movb 0xf(%rsp), %al
testb $0x1, %al
jne 0x4c3e9
jmp 0x4c31d
movq 0x88(%rsp), %rcx
leaq 0x87(%rsp), %rdi
leaq 0x6c(%rsp), %rsi
leaq 0x50(%rsp), %rdx
callq 0x4c4e0
movb %al, 0xe(%rsp)
jmp 0x4c342
movb 0xe(%rsp), %al
testb $0x1, %al
jne 0x4c34f
jmp 0x4c3e7
movq 0x88(%rsp), %rdi
callq 0x10130
movq %rax, 0x38(%rsp)
movslq 0x70(%rsp), %rsi
leaq 0x38(%rsp), %rdi
callq 0x11b40
movq %rax, 0x40(%rsp)
movq 0x88(%rsp), %rdi
callq 0x10130
movq %rax, 0x20(%rsp)
movslq 0x50(%rsp), %rsi
leaq 0x20(%rsp), %rdi
callq 0x11b40
movq %rax, 0x28(%rsp)
leaq 0x28(%rsp), %rdi
movl $0x1, %esi
callq 0x11b40
movq %rax, 0x30(%rsp)
movq 0x40(%rsp), %rdi
movq 0x30(%rsp), %rsi
callq 0x4c670
jmp 0x4c3c0
movb $0x1, 0x86(%rsp)
jmp 0x4c3fb
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x60(%rsp)
movl %eax, 0x5c(%rsp)
leaq 0x87(%rsp), %rdi
callq 0x4c210
jmp 0x4c457
jmp 0x4c3e9
jmp 0x4c3eb
movl 0x58(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x58(%rsp)
jmp 0x4c2bc
testb $0x1, 0x86(%rsp)
je 0x4c407
jmp 0x4c419
jmp 0x4c409
movl 0x74(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x74(%rsp)
jmp 0x4c27b
jmp 0x4c41b
testb $0x1, 0x86(%rsp)
jne 0x4c26b
movq 0x10(%rsp), %rdi
movq 0x88(%rsp), %rsi
callq 0xfcd0
jmp 0x4c43d
leaq 0x87(%rsp), %rdi
callq 0x4c210
movq 0x18(%rsp), %rax
addq $0x98, %rsp
retq
movq 0x60(%rsp), %rdi
callq 0x6850
nopw %cs:(%rax,%rax)
// File: GAStudyGroup[P]GPX2/src/opt/Opt.cpp
// Function: Opt::adjacent(std::pair<int, int>&, std::pair<int, int>&)
bool Opt::adjacent(edge &e1, edge &e2){
    if(e1.first==e2.first || e1.first==e2.second || e1.second==e2.first || e1.second==e2.second){
        return(true);
    }else{
        return(false); 
    }
}

// Assembly:
movq %rdi, -0x10(%rsp)
movq %rsi, -0x18(%rsp)
movq %rdx, -0x20(%rsp)
movq -0x18(%rsp), %rax
movl (%rax), %eax
movq -0x20(%rsp), %rcx
cmpl (%rcx), %eax
je 0x4c4c3
movq -0x18(%rsp), %rax
movl (%rax), %eax
movq -0x20(%rsp), %rcx
cmpl 0x4(%rcx), %eax
je 0x4c4c3
movq -0x18(%rsp), %rax
movl 0x4(%rax), %eax
movq -0x20(%rsp), %rcx
cmpl (%rcx), %eax
je 0x4c4c3
movq -0x18(%rsp), %rax
movl 0x4(%rax), %eax
movq -0x20(%rsp), %rcx
cmpl 0x4(%rcx), %eax
jne 0x4c4ca
movb $0x1, -0x1(%rsp)
jmp 0x4c4cf
movb $0x0, -0x1(%rsp)
movb -0x1(%rsp), %al
andb $0x1, %al
retq
nopw %cs:(%rax,%rax)
// File: GAStudyGroup[P]GPX2/src/opt/Opt.cpp
// Function: Opt::isBetter(std::pair<int, int>&, std::pair<int, int>&, std::vector<int, std::allocator<int>>&)
bool Opt::isBetter(edge &e1, edge &e2, vector<int> &t){
    int oldDistance = distance(t[e1.first],t[e1.second])
        +
        distance(t[e2.first],t[e2.second]);
    
    int newDistance = distance(t[e1.first],t[e2.first])
        +
        distance(t[e1.second],t[e2.second]);

    if(oldDistance>newDistance){
        return(true);
    }else{
        return(false);
    }
}

// Assembly:
subq $0x48, %rsp
movq %rdi, 0x38(%rsp)
movq %rsi, 0x30(%rsp)
movq %rdx, 0x28(%rsp)
movq %rcx, 0x20(%rsp)
movq 0x20(%rsp), %rdi
movq 0x30(%rsp), %rax
movslq (%rax), %rsi
callq 0x10830
movl (%rax), %eax
movl %eax, (%rsp)
movq 0x20(%rsp), %rdi
movq 0x30(%rsp), %rax
movslq 0x4(%rax), %rsi
callq 0x10830
movl (%rsp), %edi
movl (%rax), %esi
callq 0x1b2d0
movl %eax, 0x8(%rsp)
movq 0x20(%rsp), %rdi
movq 0x28(%rsp), %rax
movslq (%rax), %rsi
callq 0x10830
movl (%rax), %eax
movl %eax, 0x4(%rsp)
movq 0x20(%rsp), %rdi
movq 0x28(%rsp), %rax
movslq 0x4(%rax), %rsi
callq 0x10830
movl 0x4(%rsp), %edi
movl (%rax), %esi
callq 0x1b2d0
movl %eax, %ecx
movl 0x8(%rsp), %eax
addl %ecx, %eax
movl %eax, 0x1c(%rsp)
movq 0x20(%rsp), %rdi
movq 0x30(%rsp), %rax
movslq (%rax), %rsi
callq 0x10830
movl (%rax), %eax
movl %eax, 0xc(%rsp)
movq 0x20(%rsp), %rdi
movq 0x28(%rsp), %rax
movslq (%rax), %rsi
callq 0x10830
movl 0xc(%rsp), %edi
movl (%rax), %esi
callq 0x1b2d0
movl %eax, 0x14(%rsp)
movq 0x20(%rsp), %rdi
movq 0x30(%rsp), %rax
movslq 0x4(%rax), %rsi
callq 0x10830
movl (%rax), %eax
movl %eax, 0x10(%rsp)
movq 0x20(%rsp), %rdi
movq 0x28(%rsp), %rax
movslq 0x4(%rax), %rsi
callq 0x10830
movl 0x10(%rsp), %edi
movl (%rax), %esi
callq 0x1b2d0
movl %eax, %ecx
movl 0x14(%rsp), %eax
addl %ecx, %eax
movl %eax, 0x18(%rsp)
movl 0x1c(%rsp), %eax
cmpl 0x18(%rsp), %eax
jle 0x4c5ff
movb $0x1, 0x47(%rsp)
jmp 0x4c604
movb $0x0, 0x47(%rsp)
movb 0x47(%rsp), %al
andb $0x1, %al
addq $0x48, %rsp
retq
nop
// File: 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:
subq $0x58, %rsp
movq %rdi, 0x50(%rsp)
movl $0x1, 0x4c(%rsp)
movl 0x4c(%rsp), %eax
leaq 0x4e79c(%rip), %rcx     # 0x9dda8
cmpl (%rcx), %eax
ja 0x4f798
movl $0x1, 0x48(%rsp)
movl 0x48(%rsp), %eax
leaq 0x4e781(%rip), %rcx     # 0x9dda8
cmpl (%rcx), %eax
ja 0x4f786
movl 0x4c(%rsp), %eax
cmpl 0x48(%rsp), %eax
je 0x4f774
movsd 0x24c6b(%rip), %xmm0    # 0x742b0
subsd 0x4d2cb(%rip), %xmm0    # 0x9c918
movsd %xmm0, 0x18(%rsp)
movl 0x4c(%rsp), %edi
movl 0x48(%rsp), %esi
callq 0x4f580
movaps %xmm0, %xmm1
movsd 0x18(%rsp), %xmm0
mulsd %xmm1, %xmm0
movsd %xmm0, 0x40(%rsp)
movq 0x50(%rsp), %rdi
movl 0x4c(%rsp), %esi
movl 0x48(%rsp), %edx
callq 0x4f7a0
testb $0x1, %al
jne 0x4f68b
jmp 0x4f6b9
movsd 0x4d27d(%rip), %xmm0    # 0x9c910
movsd %xmm0, 0x8(%rsp)
movq 0x50(%rsp), %rdi
callq 0x1b240
movsd 0x8(%rsp), %xmm0
cvtsi2sd %eax, %xmm1
divsd %xmm1, %xmm0
movsd %xmm0, 0x10(%rsp)
jmp 0x4f6c4
xorps %xmm0, %xmm0
movsd %xmm0, 0x10(%rsp)
jmp 0x4f6c4
movsd 0x10(%rsp), %xmm0
movsd %xmm0, 0x38(%rsp)
callq 0x4f840
movsd %xmm0, 0x30(%rsp)
callq 0x4f870
movsd %xmm0, 0x28(%rsp)
movsd 0x40(%rsp), %xmm0
addsd 0x38(%rsp), %xmm0
movsd %xmm0, 0x20(%rsp)
movsd 0x28(%rsp), %xmm0
ucomisd 0x30(%rsp), %xmm0
jbe 0x4f712
movsd 0x30(%rsp), %xmm0
movsd %xmm0, 0x28(%rsp)
movsd 0x20(%rsp), %xmm0
ucomisd 0x30(%rsp), %xmm0
jbe 0x4f72e
movsd 0x30(%rsp), %xmm0
movsd %xmm0, 0x20(%rsp)
jmp 0x4f74e
movsd 0x20(%rsp), %xmm1
movsd 0x28(%rsp), %xmm0
ucomisd %xmm1, %xmm0
jbe 0x4f74c
movsd 0x28(%rsp), %xmm0
movsd %xmm0, 0x20(%rsp)
jmp 0x4f74e
movl 0x4c(%rsp), %edi
movl 0x48(%rsp), %esi
movsd 0x20(%rsp), %xmm0
callq 0x4f5b0
movl 0x48(%rsp), %edi
movl 0x4c(%rsp), %esi
movsd 0x20(%rsp), %xmm0
callq 0x4f5b0
jmp 0x4f776
movl 0x48(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x48(%rsp)
jmp 0x4f61c
jmp 0x4f788
movl 0x4c(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x4c(%rsp)
jmp 0x4f601
addq $0x58, %rsp
retq
nopl (%rax)
// File: 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 %rax
movl $0x1, 0x4(%rsp)
movl 0x4(%rsp), %eax
leaq 0x4e4b4(%rip), %rcx     # 0x9dda8
cmpl (%rcx), %eax
ja 0x4f95f
movl $0x1, (%rsp)
movl (%rsp), %eax
leaq 0x4e49f(%rip), %rcx     # 0x9dda8
cmpl (%rcx), %eax
ja 0x4f93f
movl 0x4(%rsp), %edi
movl (%rsp), %esi
callq 0x4f580
movq 0x4c678(%rip), %rdi     # 0x9bf98
callq 0x6900
movq %rax, %rdi
leaq 0x24a25(%rip), %rsi     # 0x74354
callq 0x64a0
movl (%rsp), %eax
addl $0x1, %eax
movl %eax, (%rsp)
jmp 0x4f8ff
movq 0x4c652(%rip), %rdi     # 0x9bf98
leaq 0x25f01(%rip), %rsi     # 0x7584e
callq 0x64a0
movl 0x4(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x4(%rsp)
jmp 0x4f8e9
movq 0x4c632(%rip), %rdi     # 0x9bf98
movq 0x4c5e3(%rip), %rsi     # 0x9bf50
callq 0x6500
popq %rax
retq
nopw %cs:(%rax,%rax)
// File: 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:
subq $0x58, %rsp
leaq 0x4e41d(%rip), %rax     # 0x9dda8
movl (%rax), %eax
movl $0x8, %ecx
mulq %rcx
movq %rax, %rdi
seto %cl
movq $-0x1, %rax
testb $0x1, %cl
cmovneq %rax, %rdi
callq 0x6040
movq %rax, 0x4e403(%rip)     # 0x9ddb8
movl $0x0, 0x54(%rsp)
movl 0x54(%rsp), %eax
leaq 0x4e3e0(%rip), %rcx     # 0x9dda8
cmpl (%rcx), %eax
jae 0x4fa15
leaq 0x4e3d5(%rip), %rax     # 0x9dda8
movl (%rax), %eax
movl $0x8, %ecx
mulq %rcx
movq %rax, %rdi
seto %cl
movq $-0x1, %rax
testb $0x1, %cl
cmovneq %rax, %rdi
callq 0x6040
movq %rax, %rdx
movq 0x4e3b8(%rip), %rax     # 0x9ddb8
movl 0x54(%rsp), %ecx
movq %rdx, (%rax,%rcx,8)
movl 0x54(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x54(%rsp)
jmp 0x4f9bd
movl $0x1, 0x50(%rsp)
movl 0x50(%rsp), %eax
leaq 0x4e380(%rip), %rcx     # 0x9dda8
cmpl (%rcx), %eax
ja 0x4fae1
movl $0x1, 0x4c(%rsp)
movl 0x4c(%rsp), %eax
leaq 0x4e365(%rip), %rcx     # 0x9dda8
cmpl (%rcx), %eax
ja 0x4facf
movl 0x50(%rsp), %eax
movl %eax, 0x1c(%rsp)
movl 0x4c(%rsp), %eax
movl %eax, 0x20(%rsp)
movl 0x50(%rsp), %eax
cmpl 0x4c(%rsp), %eax
je 0x4faa1
leaq 0x4e33c(%rip), %rax     # 0x9dda8
movl (%rax), %eax
movl %eax, 0xc(%rsp)
movl 0x50(%rsp), %edi
movl 0x4c(%rsp), %esi
callq 0x1b2d0
movl %eax, %ecx
movl 0xc(%rsp), %eax
imull %ecx, %eax
cvtsi2sd %rax, %xmm1
movsd 0x2481b(%rip), %xmm0    # 0x742b0
divsd %xmm1, %xmm0
movsd %xmm0, 0x10(%rsp)
jmp 0x4faac
xorps %xmm0, %xmm0
movsd %xmm0, 0x10(%rsp)
jmp 0x4faac
movl 0x20(%rsp), %esi
movl 0x1c(%rsp), %edi
movsd 0x10(%rsp), %xmm0
callq 0x4f5b0
movl 0x4c(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x4c(%rsp)
jmp 0x4fa38
jmp 0x4fad1
movl 0x50(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x50(%rsp)
jmp 0x4fa1d
leaq 0x4e2a8(%rip), %rsi     # 0x9dd90
leaq 0x30(%rsp), %rdi
movq %rdi, (%rsp)
callq 0x195b0
movq (%rsp), %rsi
leaq 0x4e2c7(%rip), %rdi     # 0x9ddc8
callq 0x4cf70
jmp 0x4fb08
leaq 0x30(%rsp), %rdi
callq 0x9af0
addq $0x58, %rsp
retq
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x28(%rsp)
movl %eax, 0x24(%rsp)
leaq 0x30(%rsp), %rdi
callq 0x9af0
movq 0x28(%rsp), %rdi
callq 0x6850
nopl (%rax)
// File: 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:
subq $0x78, %rsp
movq %rdi, 0x70(%rsp)
movq %rsi, 0x68(%rsp)
movq %rdx, 0x60(%rsp)
movq %rcx, 0x58(%rsp)
movq 0x68(%rsp), %rdi
callq 0x54cc0
movq %rax, 0x50(%rsp)
movq 0x68(%rsp), %rdi
callq 0x54d10
movq %rax, 0x48(%rsp)
leaq 0x50(%rsp), %rdi
leaq 0x48(%rsp), %rsi
callq 0x54cf0
testb $0x1, %al
jne 0x52b4e
jmp 0x52c04
leaq 0x50(%rsp), %rdi
callq 0x54d40
movq 0x8(%rax), %rdi
movq 0x60(%rsp), %rsi
movq 0x58(%rsp), %rdx
callq 0x6aa90
testb $0x1, %al
jne 0x52b71
jmp 0x52bee
movq 0x70(%rsp), %rax
movq %rax, 0x8(%rsp)
leaq 0x50(%rsp), %rdi
callq 0x54d40
movq %rax, (%rsp)
leaq 0x50(%rsp), %rdi
callq 0x54d40
movq (%rsp), %rdi
movq %rax, %rsi
addq $0x8, %rsi
callq 0x54db0
movq 0x8(%rsp), %rdi
movl %eax, 0x38(%rsp)
movq %rdx, 0x40(%rsp)
leaq 0x38(%rsp), %rsi
callq 0x54d60
movq %rax, 0x28(%rsp)
movb %dl, 0x30(%rsp)
movq 0x68(%rsp), %rdi
movq 0x50(%rsp), %rax
movq %rax, 0x18(%rsp)
movq 0x18(%rsp), %rsi
callq 0x54de0
movq %rax, 0x20(%rsp)
movq 0x20(%rsp), %rax
movq %rax, 0x50(%rsp)
jmp 0x52bff
leaq 0x50(%rsp), %rdi
xorl %esi, %esi
callq 0x54e20
movq %rax, 0x10(%rsp)
jmp 0x52b27
addq $0x78, %rsp
retq
nopl (%rax)
// File: 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:
subq $0x68, %rsp
movq %rdi, 0x8(%rsp)
movq %rdi, %rax
movq %rax, 0x10(%rsp)
movq %rdi, 0x60(%rsp)
movl %esi, 0x5c(%rsp)
movq %rdx, 0x50(%rsp)
movb $0x0, 0x4f(%rsp)
callq 0x55830
movq 0x50(%rsp), %rax
movq %rax, 0x40(%rsp)
movq 0x40(%rsp), %rdi
callq 0x552d0
movq %rax, 0x38(%rsp)
movq 0x40(%rsp), %rdi
callq 0x55340
movq %rax, 0x30(%rsp)
leaq 0x38(%rsp), %rdi
leaq 0x30(%rsp), %rsi
callq 0x55300
testb $0x1, %al
jne 0x53b96
jmp 0x53bfb
leaq 0x38(%rsp), %rdi
callq 0x55460
movq %rax, 0x28(%rsp)
movq 0x28(%rsp), %rax
movl (%rax), %eax
cmpl 0x5c(%rsp), %eax
je 0x53bc0
movq 0x28(%rsp), %rax
movl 0x4(%rax), %eax
cmpl 0x5c(%rsp), %eax
jne 0x53bed
movq 0x8(%rsp), %rdi
movq 0x28(%rsp), %rsi
callq 0x55840
jmp 0x53bd1
jmp 0x53bed
movq 0x8(%rsp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x20(%rsp)
movl %eax, 0x1c(%rsp)
callq 0x558d0
jmp 0x53c1b
jmp 0x53bef
leaq 0x38(%rsp), %rdi
callq 0x558b0
jmp 0x53b81
movb $0x1, 0x4f(%rsp)
testb $0x1, 0x4f(%rsp)
jne 0x53c11
movq 0x8(%rsp), %rdi
callq 0x558d0
movq 0x10(%rsp), %rax
addq $0x68, %rsp
retq
movq 0x20(%rsp), %rdi
callq 0x6850
nopw %cs:(%rax,%rax)
// File: 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:
subq $0x58, %rsp
movq %rdi, 0x40(%rsp)
movl $0xffffffff, 0x3c(%rsp) # imm = 0xFFFFFFFF
movl $0xffffffff, 0x38(%rsp) # imm = 0xFFFFFFFF
movq 0x40(%rsp), %rdi
callq 0x67e90
movq %rax, 0x30(%rsp)
movq 0x30(%rsp), %rdi
callq 0x55e20
movq %rax, 0x28(%rsp)
movq 0x30(%rsp), %rdi
callq 0x55e50
movq %rax, 0x20(%rsp)
leaq 0x28(%rsp), %rdi
leaq 0x20(%rsp), %rsi
callq 0x55e80
testb $0x1, %al
jne 0x542db
jmp 0x54315
leaq 0x28(%rsp), %rdi
callq 0x55ec0
movq (%rax), %rax
movq %rax, 0x18(%rsp)
movl 0x1c(%rsp), %eax
cmpl 0x38(%rsp), %eax
jle 0x54307
movl 0x1c(%rsp), %eax
movl %eax, 0x38(%rsp)
movl 0x18(%rsp), %eax
movl %eax, 0x3c(%rsp)
jmp 0x54309
leaq 0x28(%rsp), %rdi
callq 0x55ed0
jmp 0x542c6
movl 0x3c(%rsp), %esi
movl 0x38(%rsp), %ecx
leaq 0x4c(%rsp), %rdi
movl %ecx, %edx
callq 0x55960
movl 0x54(%rsp), %eax
movl %eax, 0x10(%rsp)
movq 0x4c(%rsp), %rax
movq %rax, 0x8(%rsp)
movq 0x8(%rsp), %rax
movl 0x10(%rsp), %edx
addq $0x58, %rsp
retq
nopl (%rax)
// File: GAStudyGroup[P]GPX2/src/cross/gpx/sources/GPX2.cpp
// Function: GPX2::cutCommonEdges()
void GPX2::cutCommonEdges()
{ // executes the process of cutting the common edges between the parents from the union graph
    for (auto &c : unitedGraph) { // goes by all entres from Gu
        vector<Node::node>& vec = c.second->getEdges(); //Loads the vector with the entries contained in the map entry
        for (unsigned i = 0; i < vec.size(); i++) { // goes by the edges' vector
            int commonEdges{ 0 }; //Counts the common edges, in case of two, both are "cutted"
            int last{ -1 }; // position of the first instance of the common edge
            for (unsigned j = 0; j < vec.size(); j++) { // goes by the edges's vector
                if (vec[i].first == vec[j].first) { // Checks the equality
                    commonEdges++;
                    last = j;
                    if (commonEdges > 1) { 
                        // In case of more than one instance of the vertex, it does the "cut"
                        vec[i].second = 0;  //The distance between them is set to 0, to represent the "cut"
                        c.second->deleteEdge(last); // Removes the first vertex instance
                        c.second->setAccess(true); // Changes the vertex acess entry/exit
                    }
                }
            }
        }
    }
}

// Assembly:
subq $0x58, %rsp
movq %rdi, 0x50(%rsp)
movq 0x50(%rsp), %rax
addq $0x90, %rax
movq %rax, 0x48(%rsp)
movq 0x48(%rsp), %rdi
callq 0x60ba0
movq %rax, 0x40(%rsp)
movq 0x48(%rsp), %rdi
callq 0x60bd0
movq %rax, 0x38(%rsp)
leaq 0x40(%rsp), %rdi
leaq 0x38(%rsp), %rsi
callq 0x60c00
testb $0x1, %al
jne 0x5f0cf
jmp 0x5f21d
leaq 0x40(%rsp), %rdi
callq 0x60c20
movq %rax, 0x30(%rsp)
movq 0x30(%rsp), %rax
movq 0x20(%rax), %rdi
callq 0x661c0
movq %rax, 0x28(%rsp)
movl $0x0, 0x24(%rsp)
movl 0x24(%rsp), %eax
movq %rax, 0x10(%rsp)
movq 0x28(%rsp), %rdi
callq 0x610e0
movq %rax, %rcx
movq 0x10(%rsp), %rax
cmpq %rcx, %rax
jae 0x5f20c
movl $0x0, 0x20(%rsp)
movl $0xffffffff, 0x1c(%rsp) # imm = 0xFFFFFFFF
movl $0x0, 0x18(%rsp)
movl 0x18(%rsp), %eax
movq %rax, 0x8(%rsp)
movq 0x28(%rsp), %rdi
callq 0x610e0
movq %rax, %rcx
movq 0x8(%rsp), %rax
cmpq %rcx, %rax
jae 0x5f1fa
movq 0x28(%rsp), %rdi
movl 0x24(%rsp), %eax
movl %eax, %esi
callq 0x60c40
movq %rax, (%rsp)
movq 0x28(%rsp), %rdi
movl 0x18(%rsp), %eax
movl %eax, %esi
callq 0x60c40
movq (%rsp), %rdi
movq %rax, %rsi
callq 0x2f090
testb $0x1, %al
jne 0x5f18f
jmp 0x5f1e8
movl 0x20(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x20(%rsp)
movl 0x18(%rsp), %eax
movl %eax, 0x1c(%rsp)
cmpl $0x1, 0x20(%rsp)
jle 0x5f1e6
movq 0x28(%rsp), %rdi
movl 0x24(%rsp), %eax
movl %eax, %esi
callq 0x60c40
xorps %xmm0, %xmm0
movsd %xmm0, 0x20(%rax)
movq 0x30(%rsp), %rax
movq 0x20(%rax), %rdi
movl 0x1c(%rsp), %esi
callq 0x66280
movq 0x30(%rsp), %rax
movq 0x20(%rax), %rdi
movl $0x1, %esi
callq 0x66230
jmp 0x5f1e8
jmp 0x5f1ea
movl 0x18(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x18(%rsp)
jmp 0x5f135
jmp 0x5f1fc
movl 0x24(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x24(%rsp)
jmp 0x5f0f9
jmp 0x5f20e
leaq 0x40(%rsp), %rdi
callq 0x60d70
jmp 0x5f0b7
addq $0x58, %rsp
retq
nopw %cs:(%rax,%rax)