LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_cpp_makefile_star2_O2/drarwood[P]gags/GA.cpp
// Function: DetermineX2LeastFit(std::vector<int, std::allocator<int>>&, std::vector<double, std::allocator<double>>)
void DetermineX2LeastFit(vector<int>& c, std::vector<double> s) {
    int index;
    vector<double>::iterator it;
    it  = max_element(s.begin(), s.end());    
    it = find(s.begin(), s.end(), *it);
    index = distance(s.begin(), it);
    c.push_back(index);
    s[index] = -1;
    it = max_element(s.begin(), s.end());    
    it = find(s.begin(), s.end(), *it);
    index = distance(s.begin(), it);
    c.push_back(index);
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
subq $0x10, %rsp
movq %rsi, %r14
movq %rdi, %rbx
movq (%rsi), %rdi
movq 0x8(%rsi), %rsi
callq 0x7ca8
movq (%r14), %rdi
movq 0x8(%r14), %rsi
movq %rax, %rdx
callq 0x85e2
subq (%r14), %rax
shrq $0x3, %rax
leaq 0xc(%rsp), %r15
movl %eax, (%r15)
movq %rbx, %rdi
movq %r15, %rsi
callq 0x4a34
movslq (%r15), %rax
movq (%r14), %rdi
movabsq $-0x4010000000000000, %rcx # imm = 0xBFF0000000000000
movq %rcx, (%rdi,%rax,8)
movq 0x8(%r14), %rsi
callq 0x7ca8
movq (%r14), %rdi
movq 0x8(%r14), %rsi
movq %rax, %rdx
callq 0x85e2
subq (%r14), %rax
shrq $0x3, %rax
movl %eax, (%r15)
movq %rbx, %rdi
movq %r15, %rsi
callq 0x4a34
addq $0x10, %rsp
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_cpp_makefile_star2_O2/drarwood[P]gags/InputParser.cpp
// Function: ShowOptions()
void ShowOptions() {
    cout << "Usage:" << endl;
    cout << "      --pheno      -p  [phenotype file]"                    << endl;
    cout << "      --ns         -n  [list of group sizes]"               << endl;
    cout << "      --means      -m  [list of respective means]"          << endl;
    cout << "      --sds        -s  [list of respective SDs]"            << endl;
    cout << "      --seed       -r  [seed - default 10000]"              << endl;
    cout << "      --mrate      -y  [max mutation rate - default 0.01]"  << endl;
    cout << "      --popsize    -z  [initial solutions - default 10]"    << endl;
    cout << "      --exclusions -e  [optional: file of IDs to exclude]" << endl;
    cout << "      --iterations -i  [max iterations - default 50000]"    << endl;
    cout << "      --out        -o  [output file prefix]"                << endl;
    cout << endl;
}

// Assembly:
pushq %rbx
movq 0x686e(%rip), %rbx      # 0xefd8
leaq 0x1d67(%rip), %rsi      # 0xa4d8
movq %rbx, %rdi
callq 0x3250
movq %rax, %rdi
callq 0x3140
leaq 0x1d57(%rip), %rsi      # 0xa4df
movq %rbx, %rdi
callq 0x3250
movq %rax, %rdi
callq 0x3140
leaq 0x1d68(%rip), %rsi      # 0xa507
movq %rbx, %rdi
callq 0x3250
movq %rax, %rdi
callq 0x3140
leaq 0x1d7e(%rip), %rsi      # 0xa534
movq %rbx, %rdi
callq 0x3250
movq %rax, %rdi
callq 0x3140
leaq 0x1d99(%rip), %rsi      # 0xa566
movq %rbx, %rdi
callq 0x3250
movq %rax, %rdi
callq 0x3140
leaq 0x1db2(%rip), %rsi      # 0xa596
movq %rbx, %rdi
callq 0x3250
movq %rax, %rdi
callq 0x3140
leaq 0x1dc9(%rip), %rsi      # 0xa5c4
movq %rbx, %rdi
callq 0x3250
movq %rax, %rdi
callq 0x3140
leaq 0x1dec(%rip), %rsi      # 0xa5fe
movq %rbx, %rdi
callq 0x3250
movq %rax, %rdi
callq 0x3140
leaq 0x1e0d(%rip), %rsi      # 0xa636
movq %rbx, %rdi
callq 0x3250
movq %rax, %rdi
callq 0x3140
leaq 0x1e30(%rip), %rsi      # 0xa670
movq %rbx, %rdi
callq 0x3250
movq %rax, %rdi
callq 0x3140
leaq 0x1e51(%rip), %rsi      # 0xa6a8
movq %rbx, %rdi
callq 0x3250
movq %rax, %rdi
callq 0x3140
movq %rbx, %rdi
popq %rbx
jmp 0x3140
// File: /workspace/github_cpp_makefile_star2_O2/drarwood[P]gags/InputParser.cpp
// Function: SplitDoubleArgs(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>&, std::vector<double, std::allocator<double>>&)
void SplitDoubleArgs(string& s, vector<double>& v) {
    vector<string> vec;
    split(s, ",", vec);
    for (int i = 0; i < vec.size(); ++i) {
        v.push_back(stringToDouble(vec[i]));
    }
}

// Assembly:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x70, %rsp
movq %rsi, %rbx
movq %rdi, %r14
xorps %xmm0, %xmm0
movaps %xmm0, 0x10(%rsp)
andq $0x0, 0x20(%rsp)
leaq 0x1539(%rip), %rsi      # 0xa8ab
leaq 0x30(%rsp), %rdi
leaq 0x8(%rsp), %rdx
callq 0x9656
leaq 0x30(%rsp), %rsi
leaq 0x10(%rsp), %rdx
movq %r14, %rdi
callq 0x9d0a
leaq 0x30(%rsp), %rdi
callq 0x3120
xorl %r12d, %r12d
leaq 0x50(%rsp), %r14
leaq 0x8(%rsp), %r15
xorl %r13d, %r13d
movq 0x10(%rsp), %rsi
movq 0x18(%rsp), %rax
subq %rsi, %rax
sarq $0x5, %rax
cmpq %r13, %rax
jbe 0x93f8
addq %r12, %rsi
movq %r14, %rdi
callq 0x3320
movq %r14, %rdi
callq 0x9b18
movsd %xmm0, 0x8(%rsp)
movq %rbx, %rdi
movq %r15, %rsi
callq 0x7f58
movq %r14, %rdi
callq 0x3120
incq %r13
addq $0x20, %r12
jmp 0x93ad
leaq 0x10(%rsp), %rdi
callq 0x4cec
addq $0x70, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
movq %rax, %rbx
leaq 0x30(%rsp), %rdi
jmp 0x9429
jmp 0x941c
movq %rax, %rbx
jmp 0x942e
movq %rax, %rbx
leaq 0x50(%rsp), %rdi
callq 0x3120
leaq 0x10(%rsp), %rdi
callq 0x4cec
movq %rbx, %rdi
callq 0x3410
// File: /workspace/github_cpp_makefile_star2_O2/drarwood[P]gags/InputParser.cpp
// Function: SplitIntArgs(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>&, std::vector<int, std::allocator<int>>&)
void SplitIntArgs(string& s, vector<int>& v) {
    vector<string> vec;
    split(s, ",", vec);
    for (int i = 0; i < vec.size(); ++i) {
        v.push_back(stringToInt(vec[i]));
    }
}

// Assembly:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x70, %rsp
movq %rsi, %rbx
movq %rdi, %r14
xorps %xmm0, %xmm0
movaps %xmm0, 0x10(%rsp)
andq $0x0, 0x20(%rsp)
leaq 0x1443(%rip), %rsi      # 0xa8ab
leaq 0x30(%rsp), %rdi
leaq 0xc(%rsp), %rdx
callq 0x9656
leaq 0x30(%rsp), %rsi
leaq 0x10(%rsp), %rdx
movq %r14, %rdi
callq 0x9d0a
leaq 0x30(%rsp), %rdi
callq 0x3120
xorl %r12d, %r12d
leaq 0x50(%rsp), %r14
leaq 0xc(%rsp), %r15
xorl %r13d, %r13d
movq 0x10(%rsp), %rsi
movq 0x18(%rsp), %rax
subq %rsi, %rax
sarq $0x5, %rax
cmpq %r13, %rax
jbe 0x94ec
addq %r12, %rsi
movq %r14, %rdi
callq 0x3320
movq %r14, %rdi
callq 0x9b7a
movl %eax, 0xc(%rsp)
movq %rbx, %rdi
movq %r15, %rsi
callq 0x9732
movq %r14, %rdi
callq 0x3120
incq %r13
addq $0x20, %r12
jmp 0x94a3
leaq 0x10(%rsp), %rdi
callq 0x4cec
addq $0x70, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
movq %rax, %rbx
leaq 0x30(%rsp), %rdi
jmp 0x951d
jmp 0x9510
movq %rax, %rbx
jmp 0x9522
movq %rax, %rbx
leaq 0x50(%rsp), %rdi
callq 0x3120
leaq 0x10(%rsp), %rdi
callq 0x4cec
movq %rbx, %rdi
callq 0x3410
// File: /workspace/github_cpp_makefile_star2_O2/drarwood[P]gags/InputParser.cpp
// Function: DetermineDoubleArgsPrecision(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>&, std::vector<int, std::allocator<int>>&)
void DetermineDoubleArgsPrecision(string& s, vector<int>& v) {
    vector<string> vec;
    split(s, ",", vec);
    for (int i = 0; i < vec.size(); ++i) {
        if (vec[i].find(".") != -1) {
            v.push_back(vec[i].size() - (vec[i].find(".")+1));
        }
        else {
            v.push_back(0);
        }
    }
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x48, %rsp
movq %rsi, %rbx
movq %rdi, %r14
xorps %xmm0, %xmm0
movaps %xmm0, 0x10(%rsp)
andq $0x0, 0x20(%rsp)
leaq 0x134e(%rip), %rsi      # 0xa8ab
leaq 0x28(%rsp), %rdi
leaq 0xc(%rsp), %rdx
callq 0x9656
leaq 0x28(%rsp), %rsi
leaq 0x10(%rsp), %rdx
movq %r14, %rdi
callq 0x9d0a
leaq 0x28(%rsp), %rdi
callq 0x3120
xorl %r12d, %r12d
leaq 0xba8(%rip), %r14       # 0xa13a
leaq 0xc(%rsp), %r15
xorl %r13d, %r13d
movq 0x10(%rsp), %rdi
movq 0x18(%rsp), %rax
subq %rdi, %rax
sarq $0x5, %rax
cmpq %r13, %rax
jbe 0x9608
addq %r12, %rdi
movq %r14, %rsi
xorl %edx, %edx
callq 0x3450
cmpq $-0x1, %rax
je 0x95ef
movq 0x10(%rsp), %rdi
movl 0x8(%rdi,%r12), %ebp
addq %r12, %rdi
movq %r14, %rsi
xorl %edx, %edx
callq 0x3450
notl %eax
addl %ebp, %eax
movl %eax, 0xc(%rsp)
movq %rbx, %rdi
movq %r15, %rsi
callq 0x9732
jmp 0x95ff
andl $0x0, 0xc(%rsp)
movq %rbx, %rdi
movq %r15, %rsi
callq 0x9732
incq %r13
addq $0x20, %r12
jmp 0x959a
leaq 0x10(%rsp), %rdi
callq 0x4cec
addq $0x48, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
leaq 0x28(%rsp), %rdi
callq 0x3120
jmp 0x9637
jmp 0x9634
jmp 0x9634
movq %rax, %rbx
leaq 0x10(%rsp), %rdi
callq 0x4cec
movq %rbx, %rdi
callq 0x3410
// File: /workspace/github_cpp_makefile_star2_O2/drarwood[P]gags/StringOperations.cpp
// Function: stringToDouble(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>)
double stringToDouble(string s) {
    double d;
    stringstream ss(s); //turn the string into a stream
    ss >> d; //convert
    return d;
}

// Assembly:
pushq %rbx
subq $0x1a0, %rsp            # imm = 0x1A0
movq %rdi, %rsi
leaq 0x18(%rsp), %rbx
pushq $0x18
popq %rdx
movq %rbx, %rdi
callq 0x33a0
leaq 0x10(%rsp), %rsi
movq %rbx, %rdi
callq 0x3190
movsd 0x10(%rsp), %xmm0
movsd %xmm0, 0x8(%rsp)
leaq 0x18(%rsp), %rdi
callq 0x31e0
movsd 0x8(%rsp), %xmm0
addq $0x1a0, %rsp            # imm = 0x1A0
popq %rbx
retq
movq %rax, %rbx
leaq 0x18(%rsp), %rdi
callq 0x31e0
movq %rbx, %rdi
callq 0x3410
// File: /workspace/github_cpp_makefile_star2_O2/drarwood[P]gags/StringOperations.cpp
// Function: stringToInt(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>)
int stringToInt(string s) {
    int i;
    stringstream ss(s); //turn the string into a stream
    ss >> i; //convert
    return i;
}

// Assembly:
pushq %rbx
subq $0x190, %rsp            # imm = 0x190
movq %rdi, %rsi
leaq 0x8(%rsp), %rbx
pushq $0x18
popq %rdx
movq %rbx, %rdi
callq 0x33a0
leaq 0x4(%rsp), %rsi
movq %rbx, %rdi
callq 0x3180
movl 0x4(%rsp), %ebx
leaq 0x8(%rsp), %rdi
callq 0x31e0
movl %ebx, %eax
addq $0x190, %rsp            # imm = 0x190
popq %rbx
retq
movq %rax, %rbx
leaq 0x8(%rsp), %rdi
callq 0x31e0
movq %rbx, %rdi
callq 0x3410
// File: /workspace/github_cpp_makefile_star2_O2/drarwood[P]gags/StringOperations.cpp
// Function: intToString[abi:cxx11](int)
string intToString(int i) {
    string s;
    ostringstream convert;
    convert << i;
    s = convert.str();
    return s;
}

// Assembly:
pushq %rbp
pushq %r14
pushq %rbx
subq $0x1a0, %rsp            # imm = 0x1A0
movl %esi, %ebp
movq %rdi, %rbx
leaq 0x10(%rdi), %rax
movq %rax, (%rdi)
andq $0x0, 0x8(%rdi)
movb $0x0, 0x10(%rdi)
leaq 0x28(%rsp), %rdi
callq 0x3310
leaq 0x28(%rsp), %rdi
movl %ebp, %esi
callq 0x33f0
leaq 0x30(%rsp), %rsi
leaq 0x8(%rsp), %rdi
callq 0x3390
leaq 0x8(%rsp), %r14
movq %rbx, %rdi
movq %r14, %rsi
callq 0x32d0
movq %r14, %rdi
callq 0x3120
leaq 0x28(%rsp), %rdi
callq 0x3090
movq %rbx, %rax
addq $0x1a0, %rsp            # imm = 0x1A0
popq %rbx
popq %r14
popq %rbp
retq
jmp 0x9c48
movq %rax, %r14
leaq 0x28(%rsp), %rdi
callq 0x3090
jmp 0x9c5a
movq %rax, %r14
movq %rbx, %rdi
callq 0x3120
movq %r14, %rdi
callq 0x3410
// File: /workspace/github_cpp_makefile_star2_O2/drarwood[P]gags/StringOperations.cpp
// Function: doubleToString[abi:cxx11](double)
string doubleToString(double d) {
    string s;
    ostringstream convert;
    convert << d;
    s = convert.str();
    return s;
}

// Assembly:
pushq %r14
pushq %rbx
subq $0x1a8, %rsp            # imm = 0x1A8
movsd %xmm0, 0x8(%rsp)
movq %rdi, %rbx
leaq 0x10(%rdi), %rax
movq %rax, (%rdi)
andq $0x0, 0x8(%rdi)
movb $0x0, 0x10(%rdi)
leaq 0x30(%rsp), %rdi
callq 0x3310
leaq 0x30(%rsp), %rdi
movsd 0x8(%rsp), %xmm0
callq 0x33b0
leaq 0x38(%rsp), %rsi
leaq 0x10(%rsp), %rdi
callq 0x3390
leaq 0x10(%rsp), %r14
movq %rbx, %rdi
movq %r14, %rsi
callq 0x32d0
movq %r14, %rdi
callq 0x3120
leaq 0x30(%rsp), %rdi
callq 0x3090
movq %rbx, %rax
addq $0x1a8, %rsp            # imm = 0x1A8
popq %rbx
popq %r14
retq
jmp 0x9ce8
movq %rax, %r14
leaq 0x30(%rsp), %rdi
callq 0x3090
jmp 0x9cfa
movq %rax, %r14
movq %rbx, %rdi
callq 0x3120
movq %r14, %rdi
callq 0x3410
// File: /workspace/github_cpp_makefile_star2_O2/drarwood[P]gags/StringOperations.cpp
// Function: split(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>&, 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 split(string& s, string sc, vector<string>& v) {

    string::size_type i = 0;
    string::size_type j = s.find(sc);

    while (j != string::npos) {
        v.push_back(s.substr(i,j-i));
        i = ++j;
        j = s.find(sc,j);
        if (j == string::npos) {
            v.push_back(s.substr(i, s.length()));
        }
    }
    if (v.size() == 0) {
        v.push_back(s);
    }
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x28, %rsp
movq %rdx, %rbx
movq %rsi, %r15
movq %rdi, %r14
xorl %ebp, %ebp
xorl %edx, %edx
callq 0x3460
movq %rax, %r13
leaq 0x8(%rsp), %r12
cmpq $-0x1, %r13
je 0x9da3
movq %r13, %rcx
subq %rbp, %rcx
movq %r12, %rdi
movq %r14, %rsi
movq %rbp, %rdx
callq 0x3290
movq %rbx, %rdi
movq %r12, %rsi
callq 0x9dde
movq %r12, %rdi
callq 0x3120
movq %r13, %rbp
incq %rbp
movq %r14, %rdi
movq %r15, %rsi
movq %rbp, %rdx
callq 0x3460
movq %rax, %r13
cmpq $-0x1, %rax
jne 0x9d32
movq 0x8(%r14), %rcx
movq %r12, %rdi
movq %r14, %rsi
movq %rbp, %rdx
callq 0x3290
movq %rbx, %rdi
movq %r12, %rsi
callq 0x9dde
movq %r12, %rdi
callq 0x3120
jmp 0x9d32
movq 0x8(%rbx), %rax
cmpq (%rbx), %rax
jne 0x9db7
movq %rbx, %rdi
movq %r14, %rsi
callq 0x7c16
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
jmp 0x9dc8
movq %rax, %rbx
leaq 0x8(%rsp), %rdi
callq 0x3120
movq %rbx, %rdi
callq 0x3410
nop
// File: /workspace/github_cpp_makefile_star2_O2/SMT-COMP[P]scrambler/scrambler.cpp
// Function: unquote(char const*)
const char *unquote(const char *n)
{
    if (!n[0] || n[0] != '|') {
        return n;
    }

    static std::string buf;
    buf = n;
    assert(!buf.empty());
    if (buf.size() > 1 && buf[0] == '|' && buf[buf.size()-1] == '|') {
        buf = buf.substr(1, buf.size()-2);
    }
    return buf.c_str();
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
cmpb $0x7c, (%rdi)
jne 0x376e
movb 0xfbfc(%rip), %al       # 0x132c8
testb %al, %al
je 0x3779
leaq 0xfbe5(%rip), %rdi      # 0x132c0
movq %rbx, %rsi
callq 0x3300
movq 0xfbd6(%rip), %rbx      # 0x132c0
movq -0x18(%rbx), %rax
cmpq $0x1, %rax
je 0x376e
testq %rax, %rax
je 0x37ca
leaq 0xfbbc(%rip), %rdi      # 0x132c0
callq 0x32d0
movq 0xfbb0(%rip), %rbx      # 0x132c0
cmpb $0x7c, (%rbx)
jne 0x376e
movq -0x18(%rbx), %r14
leaq 0xfba0(%rip), %rdi      # 0x132c0
callq 0x32d0
movq 0xfb94(%rip), %rbx      # 0x132c0
cmpb $0x7c, -0x1(%rbx,%r14)
jne 0x376e
movq -0x18(%rbx), %rcx
addq $-0x2, %rcx
leaq 0xfb7d(%rip), %rbx      # 0x132c0
movq %rsp, %r14
pushq $0x1
popq %rdx
movq %r14, %rdi
movq %rbx, %rsi
callq 0x33b0
movq %rbx, %rdi
movq %r14, %rsi
callq 0x3380
movq %r14, %rdi
callq 0x3438
movq 0xfb52(%rip), %rbx      # 0x132c0
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
leaq 0xfb48(%rip), %rdi      # 0x132c8
callq 0x33d0
testl %eax, %eax
je 0x36d4
movq 0xf804(%rip), %rax      # 0x12f98
addq $0x18, %rax
movq %rax, 0xfb21(%rip)      # 0x132c0
leaq 0xfb1a(%rip), %rsi      # 0x132c0
movq 0xf81b(%rip), %rdi      # 0x12fc8
leaq 0xfa6c(%rip), %rdx      # 0x13220
callq 0x31c0
leaq 0xfb08(%rip), %rdi      # 0x132c8
callq 0x3150
jmp 0x36d4
leaq 0x784f(%rip), %rdi      # 0xb020
leaq 0x7855(%rip), %rsi      # 0xb02d
leaq 0x785c(%rip), %rcx      # 0xb03b
movl $0xad, %edx
callq 0x3160
// File: /workspace/github_cpp_makefile_star2_O2/SMT-COMP[P]scrambler/scrambler.cpp
// Function: scrambler::set_new_name(char const*)
void set_new_name(const char *n)
{
    n = unquote(n);

    if (name_ids.find(n) == name_ids.end()) {
        name_ids[n] = next_name_id;
        ++next_name_id;
    }
}

// Assembly:
pushq %r14
pushq %rbx
subq $0x18, %rsp
callq 0x36b6
movq %rax, %rbx
leaq 0x10(%rsp), %rdi
leaq 0xf(%rsp), %rdx
movq %rax, %rsi
callq 0x3140
leaq 0xfa77(%rip), %rdi      # 0x13288
leaq 0x10(%rsp), %rsi
callq 0x5e2c
movq %rax, %r14
leaq 0x10(%rsp), %rdi
callq 0x3438
testq %r14, %r14
jne 0x386b
movq 0xf9f4(%rip), %r14      # 0x13228
leaq 0x10(%rsp), %rdi
leaq 0xf(%rsp), %rdx
movq %rbx, %rsi
callq 0x3140
leaq 0xfa3b(%rip), %rdi      # 0x13288
leaq 0x10(%rsp), %rsi
callq 0x5f48
movq %r14, (%rax)
leaq 0x10(%rsp), %rdi
callq 0x3438
incq 0xf9bd(%rip)            # 0x13228
addq $0x18, %rsp
popq %rbx
popq %r14
retq
jmp 0x3877
jmp 0x3886
movq %rax, %rbx
leaq 0x10(%rsp), %rdi
callq 0x3438
jmp 0x3889
movq %rax, %rbx
movq %rbx, %rdi
callq 0x33c0
// File: /workspace/github_cpp_makefile_star2_O2/SMT-COMP[P]scrambler/scrambler.cpp
// Function: scrambler::add_node(char const*, scrambler::node*, scrambler::node*, scrambler::node*, scrambler::node*)
void add_node(const char *s, node *n1, node *n2, node *n3, node *n4)
{
    assert(s); // s must be a top-level SMT-LIB command

    node *ret = new node;
    ret->symbol = s;
    ret->is_name = false;
    ret->needs_parens = true;

    if (n1) {
        ret->children.push_back(n1);
    }
    if (n2) {
        ret->children.push_back(n2);
    }
    if (n3) {
        ret->children.push_back(n3);
    }
    if (n4) {
        ret->children.push_back(n4);
    }

    commands.push_back(ret);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x38, %rsp
movq %rsi, 0x30(%rsp)
movq %rdx, 0x28(%rsp)
movq %rcx, 0x20(%rsp)
movq %r8, 0x8(%rsp)
movq %r8, 0x18(%rsp)
testq %rdi, %rdi
je 0x39e9
movq %rcx, %r14
movq %rdx, %r12
movq %rsi, %r13
movq %rdi, %rbp
pushq $0x30
popq %rdi
callq 0x3220
movq %rax, %rbx
movq 0xf649(%rip), %rax      # 0x12f98
addq $0x18, %rax
movq %rax, (%rbx)
leaq 0x10(%rbx), %r15
xorps %xmm0, %xmm0
movups %xmm0, 0x10(%rbx)
andq $0x0, 0x20(%rbx)
movq %rbx, 0x10(%rsp)
movq %rbx, %rdi
movq %rbp, %rsi
callq 0x3300
movb $0x0, 0x8(%rbx)
movb $0x1, 0x28(%rbx)
testq %r13, %r13
je 0x3990
leaq 0x30(%rsp), %rsi
movq %r15, %rdi
callq 0x5ac2
testq %r12, %r12
je 0x39a2
leaq 0x28(%rsp), %rsi
movq %r15, %rdi
callq 0x5ac2
testq %r14, %r14
je 0x39b4
leaq 0x20(%rsp), %rsi
movq %r15, %rdi
callq 0x5ac2
cmpq $0x0, 0x8(%rsp)
je 0x39c9
leaq 0x18(%rsp), %rsi
movq %r15, %rdi
callq 0x5ac2
leaq 0xf900(%rip), %rdi      # 0x132d0
leaq 0x10(%rsp), %rsi
callq 0x5ac2
addq $0x38, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
leaq 0x7737(%rip), %rdi      # 0xb127
leaq 0x7636(%rip), %rsi      # 0xb02d
leaq 0x765f(%rip), %rcx      # 0xb05d
movl $0xe4, %edx
callq 0x3160
// File: /workspace/github_cpp_makefile_star2_O2/SMT-COMP[P]scrambler/scrambler.cpp
// Function: scrambler::make_node(char const*, scrambler::node*, scrambler::node*)
node *make_node(const char *s, node *n1, node *n2)
{
    node *ret = new node;
    ret->needs_parens = true;
    if (s) {
        ret->symbol = s;
    }
    ret->is_name = false;
    if (n1) {
        ret->children.push_back(n1);
    }
    if (n2) {
        ret->children.push_back(n2);
    }
    if (!ret->symbol.empty() && ret->children.empty()) {
        ret->needs_parens = false;
    }
    return ret;
}

// Assembly:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x10, %rsp
movq %rdx, %r14
movq %rsi, %r12
movq %rdi, %r13
movq %rsi, 0x8(%rsp)
movq %rdx, (%rsp)
pushq $0x30
popq %rdi
callq 0x3220
movq %rax, %r15
movq %rax, %rbx
movq 0xf55c(%rip), %rax      # 0x12f98
addq $0x18, %rax
movq %rax, (%r15)
andq $0x0, 0x20(%r15)
xorps %xmm0, %xmm0
movups %xmm0, 0x10(%r15)
movb $0x1, 0x28(%r15)
testq %r13, %r13
je 0x3a65
movq %rbx, %rdi
movq %r13, %rsi
callq 0x3300
addq $0x10, %r15
movb $0x0, 0x8(%rbx)
testq %r12, %r12
je 0x3a7f
leaq 0x8(%rsp), %rsi
movq %r15, %rdi
callq 0x5ac2
testq %r14, %r14
je 0x3a8f
movq %rsp, %rsi
movq %r15, %rdi
callq 0x5ac2
movq (%rbx), %rax
cmpq $0x0, -0x18(%rax)
je 0x3aa7
movq 0x10(%rbx), %rax
cmpq 0x18(%rbx), %rax
jne 0x3aa7
movb $0x0, 0x28(%rbx)
movq %rbx, %rax
addq $0x10, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
// File: /workspace/github_cpp_makefile_star2_O2/SMT-COMP[P]scrambler/scrambler.cpp
// Function: scrambler::make_node(std::vector<scrambler::node*, std::allocator<scrambler::node*>> const*)
node *make_node(const std::vector<node *> *v)
{
    node *ret = new node;
    ret->needs_parens = true;
    ret->symbol = "";
    ret->is_name = false;
    ret->children.assign(v->begin(), v->end());
    return ret;
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rdi, %rbx
pushq $0x30
popq %rdi
callq 0x3220
movq %rax, %r14
movq 0xf4c6(%rip), %rax      # 0x12f98
addq $0x18, %rax
movq %rax, (%r14)
leaq 0x10(%r14), %r15
xorps %xmm0, %xmm0
movups %xmm0, 0x10(%r14)
andq $0x0, 0x20(%r14)
movb $0x1, 0x28(%r14)
leaq 0x7e80(%rip), %rsi      # 0xb976
movq %r14, %rdi
callq 0x3300
movb $0x0, 0x8(%r14)
movq (%rbx), %rsi
movq 0x8(%rbx), %rdx
movq %r15, %rdi
callq 0x656c
movq %r14, %rax
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_cpp_makefile_star2_O2/SMT-COMP[P]scrambler/scrambler.cpp
// Function: scrambler::make_node(scrambler::node*, std::vector<scrambler::node*, std::allocator<scrambler::node*>> const*)
node *make_node(node *n, const std::vector<node *> *v)
{
    node *ret = new node;
    ret->needs_parens = true;
    ret->symbol = "";
    ret->is_name = false;
    ret->children.push_back(n);
    ret->children.insert(ret->children.end(), v->begin(), v->end());
    return ret;
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq %rsp, %r15
movq %rdi, (%r15)
pushq $0x30
popq %rdi
callq 0x3220
movq %rax, %r14
movq 0xf45a(%rip), %rax      # 0x12f98
addq $0x18, %rax
movq %rax, (%r14)
leaq 0x10(%r14), %r12
xorps %xmm0, %xmm0
movups %xmm0, 0x10(%r14)
andq $0x0, 0x20(%r14)
movb $0x1, 0x28(%r14)
leaq 0x7e14(%rip), %rsi      # 0xb976
movq %r14, %rdi
callq 0x3300
movb $0x0, 0x8(%r14)
movq %r12, %rdi
movq %r15, %rsi
callq 0x5ac2
movq 0x18(%r14), %rsi
movq (%rbx), %rdx
movq 0x8(%rbx), %rcx
movq %r12, %rdi
callq 0x5a9c
movq %r14, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
// File: /workspace/github_cpp_makefile_star2_O2/SMT-COMP[P]scrambler/scrambler.cpp
// Function: scrambler::make_name_node(char const*, scrambler::node*)
node *make_name_node(const char* s, node *n1)
{
    node *ret = new node;
    assert(s);
    ret->symbol = s;
    ret->is_name = true;
    ret->needs_parens = false;
    if (n1) {
        ret->children.push_back(n1);
        ret->needs_parens = true;
    }
    return ret;
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
subq $0x10, %rsp
movq %rsi, %r14
movq %rdi, %r15
movq %rsi, 0x8(%rsp)
pushq $0x30
popq %rdi
callq 0x3220
movq %rax, %rbx
movq 0xf3d6(%rip), %rax      # 0x12f98
addq $0x18, %rax
movq %rax, (%rbx)
xorps %xmm0, %xmm0
movups %xmm0, 0x10(%rbx)
andq $0x0, 0x20(%rbx)
testq %r15, %r15
je 0x3c14
movq %rbx, %rdi
movq %r15, %rsi
callq 0x3300
movb $0x1, 0x8(%rbx)
movb $0x0, 0x28(%rbx)
testq %r14, %r14
je 0x3c07
movq %rbx, %rdi
addq $0x10, %rdi
leaq 0x8(%rsp), %rsi
callq 0x5ac2
movb $0x1, 0x28(%rbx)
movq %rbx, %rax
addq $0x10, %rsp
popq %rbx
popq %r14
popq %r15
retq
leaq 0x750c(%rip), %rdi      # 0xb127
leaq 0x740b(%rip), %rsi      # 0xb02d
leaq 0x747b(%rip), %rcx      # 0xb0a4
movl $0x127, %edx            # imm = 0x127
callq 0x3160
// File: /workspace/github_cpp_makefile_star2_O2/SMT-COMP[P]scrambler/scrambler.cpp
// Function: scrambler::shuffle_list(std::vector<scrambler::node*, std::allocator<scrambler::node*>>*, unsigned long, unsigned long)
void shuffle_list(std::vector<scrambler::node *> *v, size_t start, size_t end)
{
    if (!no_scramble) {
        size_t n = end - start;
        for (size_t i = n-1; i > 0; --i) {
            std::swap((*v)[i+start], (*v)[next_rand_int(i+1)+start]);
        }
    }
}

// Assembly:
cmpb $0x0, 0xf603(%rip)      # 0x13280
jne 0x3ce3
pushq %rbx
movq %rdx, %rcx
movq 0xf5ee(%rip), %r8       # 0x13278
movq %rsi, %r9
negq %r9
movabsq $0x5deece66d, %r10      # imm = 0x5DEECE66D
leaq (%r9,%rcx), %r11
cmpq $0x1, %r11
je 0x3ce2
movq (%rdi), %rbx
imulq %r10, %r8
addq $0xb, %r8
btrq $0x31, %r8
movq %r8, 0xf5bd(%rip)       # 0x13278
movq %r8, %rax
shrq $0x10, %rax
xorl %edx, %edx
divq %r11
leaq (%rbx,%rdx,8), %rax
movq -0x8(%rbx,%rcx,8), %rdx
movq (%rax,%rsi,8), %r11
movq %r11, -0x8(%rbx,%rcx,8)
movq %rdx, (%rax,%rsi,8)
decq %rcx
jmp 0x3c9a
popq %rbx
retq
// File: /workspace/github_cpp_makefile_star2_O2/SMT-COMP[P]scrambler/scrambler.cpp
// Function: logic_is_dl()
bool logic_is_dl()  // Difference Logic: IDL, RDL
{
    static int result = -1;
    if (result == -1) {
        if (logic.empty()) {
            std::cerr << "ERROR logic has not been set" << std::endl;
            exit(1);
        }

        if (logic.find("IDL") != std::string::npos || logic.find("RDL") != std::string::npos) {
            result = 1;
        } else {
            result = 0;
        }
    }

    return (result == 1);
}

// Assembly:
pushq %rax
movl 0xf4f2(%rip), %ecx      # 0x13230
cmpl $-0x1, %ecx
jne 0x3d95
movq 0xf59e(%rip), %rax      # 0x132e8
cmpq $0x0, -0x18(%rax)
je 0x3d9d
leaq 0xf590(%rip), %rdi      # 0x132e8
leaq 0x73b3(%rip), %rsi      # 0xb112
xorl %edx, %edx
callq 0x3110
cmpq $-0x1, %rax
je 0x3d71
pushq $0x1
popq %rcx
jmp 0x3d8f
leaq 0xf570(%rip), %rdi      # 0x132e8
leaq 0x7397(%rip), %rsi      # 0xb116
xorl %edx, %edx
callq 0x3110
xorl %ecx, %ecx
cmpq $-0x1, %rax
setne %cl
movl %ecx, 0xf49b(%rip)      # 0x13230
cmpl $0x1, %ecx
sete %al
popq %rcx
retq
movq 0xf24c(%rip), %rdi      # 0x12ff0
leaq 0x734a(%rip), %rsi      # 0xb0f5
callq 0x3210
movq %rax, %rdi
callq 0x30f0
pushq $0x1
popq %rdi
callq 0x3260
// File: /workspace/github_cpp_makefile_star2_O2/SMT-COMP[P]scrambler/scrambler.cpp
// Function: logic_is_arith()
bool logic_is_arith()  // Arithmetic: IA, RA, IRA
{
    static int result = -1;
    if (result == -1) {
        if (logic.empty()) {
            std::cerr << "ERROR logic has not been set" << std::endl;
            exit(1);
        }

        if (logic.find("IA") != std::string::npos || logic.find("RA") != std::string::npos) {
            result = 1;
        } else {
            result = 0;
        }
    }

    return (result == 1);
}

// Assembly:
pushq %rax
movl 0xf46d(%rip), %ecx      # 0x13234
cmpl $-0x1, %ecx
jne 0x3e1e
movq 0xf515(%rip), %rax      # 0x132e8
cmpq $0x0, -0x18(%rax)
je 0x3e26
leaq 0xf507(%rip), %rdi      # 0x132e8
leaq 0x7332(%rip), %rsi      # 0xb11a
xorl %edx, %edx
callq 0x3110
cmpq $-0x1, %rax
je 0x3dfa
pushq $0x1
popq %rcx
jmp 0x3e18
leaq 0xf4e7(%rip), %rdi      # 0x132e8
leaq 0x7315(%rip), %rsi      # 0xb11d
xorl %edx, %edx
callq 0x3110
xorl %ecx, %ecx
cmpq $-0x1, %rax
setne %cl
movl %ecx, 0xf416(%rip)      # 0x13234
cmpl $0x1, %ecx
sete %al
popq %rcx
retq
movq 0xf1c3(%rip), %rdi      # 0x12ff0
leaq 0x72c1(%rip), %rsi      # 0xb0f5
callq 0x3210
movq %rax, %rdi
callq 0x30f0
pushq $0x1
popq %rdi
callq 0x3260
// File: /workspace/github_cpp_makefile_star2_O2/SMT-COMP[P]scrambler/scrambler.cpp
// Function: logic_is_bv()
bool logic_is_bv()  // BitVectors (BV)
{
    static int result = -1;
    if (result == -1) {
        if (logic.empty()) {
            std::cerr << "ERROR logic has not been set" << std::endl;
            exit(1);
        }

        if (logic.find("BV") != std::string::npos) {
            result = 1;
        } else {
            result = 0;
        }
    }

    return result == 1;
}

// Assembly:
pushq %rax
movl 0xf3e8(%rip), %ecx      # 0x13238
cmpl $-0x1, %ecx
jne 0x3e87
movq 0xf48c(%rip), %rax      # 0x132e8
cmpq $0x0, -0x18(%rax)
je 0x3e8f
leaq 0xf47e(%rip), %rdi      # 0x132e8
leaq 0x72af(%rip), %rsi      # 0xb120
xorl %edx, %edx
callq 0x3110
xorl %ecx, %ecx
cmpq $-0x1, %rax
setne %cl
movl %ecx, 0xf3b1(%rip)      # 0x13238
cmpl $0x1, %ecx
sete %al
popq %rcx
retq
movq 0xf15a(%rip), %rdi      # 0x12ff0
leaq 0x7258(%rip), %rsi      # 0xb0f5
callq 0x3210
movq %rax, %rdi
callq 0x30f0
pushq $0x1
popq %rdi
callq 0x3260
// File: /workspace/github_cpp_makefile_star2_O2/SMT-COMP[P]scrambler/scrambler.cpp
// Function: logic_is_fp()
bool logic_is_fp()  // FloatingPoint (FP)
{
    static int result = -1;
    if (result == -1) {
        if (logic.empty()) {
            std::cerr << "ERROR logic has not been set" << std::endl;
            exit(1);
        }

        if (logic.find("FP") != std::string::npos) {
            result = 1;
        } else {
            result = 0;
        }
    }

    return result == 1;
}

// Assembly:
pushq %rax
movl 0xf383(%rip), %ecx      # 0x1323c
cmpl $-0x1, %ecx
jne 0x3ef0
movq 0xf423(%rip), %rax      # 0x132e8
cmpq $0x0, -0x18(%rax)
je 0x3ef8
leaq 0xf415(%rip), %rdi      # 0x132e8
leaq 0x7249(%rip), %rsi      # 0xb123
xorl %edx, %edx
callq 0x3110
xorl %ecx, %ecx
cmpq $-0x1, %rax
setne %cl
movl %ecx, 0xf34c(%rip)      # 0x1323c
cmpl $0x1, %ecx
sete %al
popq %rcx
retq
movq 0xf0f1(%rip), %rdi      # 0x12ff0
leaq 0x71ef(%rip), %rsi      # 0xb0f5
callq 0x3210
movq %rax, %rdi
callq 0x30f0
pushq $0x1
popq %rdi
callq 0x3260
// File: /workspace/github_cpp_makefile_star2_O2/SMT-COMP[P]scrambler/scrambler.cpp
// Function: make_annotation_name()
std::string make_annotation_name()
{
    static uint64_t n = 1;
    std::ostringstream tmp;
    tmp << "smtcomp" << n;
    ++n;
    return tmp.str();
}

// Assembly:
pushq %r14
pushq %rbx
subq $0x168, %rsp            # imm = 0x168
movq %rdi, %rbx
leaq 0x8(%rsp), %r14
movq %r14, %rdi
callq 0x3060
leaq 0x7554(%rip), %rsi      # 0xb9f2
movq %r14, %rdi
callq 0x3210
movq 0xed93(%rip), %rsi      # 0x13240
movq %rax, %rdi
callq 0x3170
incq 0xed84(%rip)            # 0x13240
leaq 0x10(%rsp), %rsi
movq %rbx, %rdi
callq 0x3190
leaq 0x8(%rsp), %rdi
callq 0x3410
movq %rbx, %rax
addq $0x168, %rsp            # imm = 0x168
popq %rbx
popq %r14
retq
movq %rax, %rbx
leaq 0x8(%rsp), %rdi
callq 0x3410
movq %rbx, %rdi
callq 0x33c0
// File: /workspace/github_cpp_makefile_star2_O2/SMT-COMP[P]scrambler/scrambler.cpp
// Function: filter_named(std::unordered_set<std::string, std::hash<std::string>, std::equal_to<std::string>, std::allocator<std::string>> const&)
void filter_named(const StringSet &to_keep)
{
    size_t i, k;
    for (i = k = 0; i < commands.size(); ++i) {
        scrambler::node *cur = commands[i];
        bool keep = true;
        if (cur->symbol == "assert") {
            std::string name = get_named_annot(cur);
            if (!name.empty() && to_keep.find(name) == to_keep.end()) {
                keep = false;
            }
        }
        if (keep) {
            commands[k++] = cur;
        }
    }
    commands.resize(k);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %rdi, 0x10(%rsp)
xorl %ebx, %ebx
leaq 0x8205(%rip), %r15      # 0xd13e
leaq 0x8(%rsp), %r12
xorl %r14d, %r14d
movq 0xe390(%rip), %rcx      # 0x132d8
movq 0xe381(%rip), %rax      # 0x132d0
subq %rax, %rcx
sarq $0x3, %rcx
cmpq %rcx, %r14
jae 0x4fbf
movq (%rax,%r14,8), %r13
movq %r13, %rdi
movq %r15, %rsi
callq 0x5af6
testb %al, %al
je 0x4fac
movq %r12, %rdi
movq %r13, %rsi
callq 0x4d51
movq 0x8(%rsp), %rax
cmpq $0x0, -0x18(%rax)
je 0x4fa4
movq 0x10(%rsp), %rdi
movq %r12, %rsi
callq 0x7768
movq %rax, %rbp
movq %r12, %rdi
callq 0x3438
testq %rbp, %rbp
jne 0x4fac
jmp 0x4fba
movq %r12, %rdi
callq 0x3438
movq 0xe31d(%rip), %rax      # 0x132d0
movq %r13, (%rax,%rbx,8)
incq %rbx
incq %r14
jmp 0x4f41
leaq 0xe30a(%rip), %rdi      # 0x132d0
movq %rbx, %rsi
callq 0x5c18
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
leaq 0x8(%rsp), %rdi
callq 0x3438
movq %rbx, %rdi
callq 0x33c0
// File: /workspace/github_cpp_makefile_star2_O2/SMT-COMP[P]scrambler/scrambler.cpp
// Function: c_strdup(char const*)
char *c_strdup(const char *s)
{
    char *ret = (char *)malloc(strlen(s) + 1);
    if (ret == NULL) {
        exit(1);
    }

    strcpy(ret, s);
    return ret;
}

// Assembly:
pushq %rbx
movq %rdi, %rbx
callq 0x30c0
leaq 0x1(%rax), %rdi
callq 0x32c0
testq %rax, %rax
je 0x5015
movq %rax, %rdi
movq %rbx, %rsi
popq %rbx
jmp 0x31e0
pushq $0x1
popq %rdi
callq 0x3260
// File: /workspace/github_cpp_makefile_star2_O2/SMT-COMP[P]scrambler/parser.cpp
// Function: yy_symbol_print(_IO_FILE*, yysymbol_kind_t, YYSTYPE const*, YYLTYPE const*)
static void
yy_symbol_print (FILE *yyo,
                 yysymbol_kind_t yykind, YYSTYPE const * const yyvaluep, YYLTYPE const * const yylocationp)
{
  YYFPRINTF (yyo, "%s %s (",
             yykind < YYNTOKENS ? "token" : "nterm", yysymbol_name (yykind));

  YYLOCATION_PRINT (yyo, yylocationp);
  YYFPRINTF (yyo, ": ");
  yy_symbol_value_print (yyo, yykind, yyvaluep, yylocationp);
  YYFPRINTF (yyo, ")");
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rdx, %r14
cmpl $0x2e, %esi
leaq 0x4243(%rip), %rax      # 0xcf53
leaq 0x4242(%rip), %rdx      # 0xcf59
cmovlq %rax, %rdx
movq %rdi, %rbx
movslq %esi, %rax
leaq 0x9d38(%rip), %rcx      # 0x12a60
movq (%rcx,%rax,8), %rcx
leaq 0x4218(%rip), %rsi      # 0xcf4b
xorl %r15d, %r15d
xorl %eax, %eax
callq 0x3310
movl (%r14), %edx
movl 0xc(%r14), %ebp
subl $0x1, %ebp
cmovbl %r15d, %ebp
testl %edx, %edx
js 0x8d79
leaq 0x41f2(%rip), %rsi      # 0xcf48
movq %rbx, %rdi
xorl %eax, %eax
callq 0x3310
movl 0x4(%r14), %edx
testl %edx, %edx
js 0x8d79
leaq 0x4644(%rip), %rsi      # 0xd3b3
movq %rbx, %rdi
xorl %eax, %eax
callq 0x3310
movl 0x8(%r14), %edx
testl %edx, %edx
js 0x8dc1
cmpl %edx, (%r14)
jge 0x8da4
leaq 0x462a(%rip), %rsi      # 0xd3b7
movq %rbx, %rdi
xorl %eax, %eax
callq 0x3310
testl %ebp, %ebp
js 0x8dc1
leaq 0x4611(%rip), %rsi      # 0xd3b3
jmp 0x8db5
testl %ebp, %ebp
js 0x8dc1
cmpl %ebp, 0x4(%r14)
jge 0x8dc1
leaq 0x4602(%rip), %rsi      # 0xd3b7
movq %rbx, %rdi
movl %ebp, %edx
xorl %eax, %eax
callq 0x3310
leaq 0x4172(%rip), %rdi      # 0xcf3a
pushq $0x2
popq %rsi
pushq $0x1
popq %rdx
movq %rbx, %rcx
callq 0x3400
pushq $0x29
popq %rdi
movq %rbx, %rsi
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
jmp 0x3270
// File: /workspace/github_cpp_makefile_star2_O2/t0mm4rx[P]piscine_cpp/day05/ex03/Bureaucrat.cpp
// Function: Bureaucrat::setGrade(int)
void Bureaucrat::setGrade(int grade)
{
	if (grade < 1)
		throw GradeTooHighException();
	if (grade > 150)
		throw GradeTooLowException();
	this->grade = grade;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
testl %esi, %esi
jle 0x24b7
cmpl $0x97, %esi
jae 0x24d2
movl %esi, 0x20(%rdi)
popq %rbp
retq
pushq $0x8
popq %rdi
callq 0x2080
leaq 0x467a(%rip), %rcx      # 0x6b40
movq %rcx, (%rax)
leaq 0x46b0(%rip), %rsi      # 0x6b80
jmp 0x24eb
pushq $0x8
popq %rdi
callq 0x2080
leaq 0x4687(%rip), %rcx      # 0x6b68
movq %rcx, (%rax)
leaq 0x46ad(%rip), %rsi      # 0x6b98
movq 0x4aee(%rip), %rdx      # 0x6fe0
movq %rax, %rdi
callq 0x2160
// File: /workspace/github_cpp_makefile_star2_O2/t0mm4rx[P]piscine_cpp/day05/ex03/Bureaucrat.cpp
// Function: Bureaucrat::signForm(Form&)
void Bureaucrat::signForm(Form &form)
{
	try
	{
		form.beSigned(*this);
	}
	catch(std::exception &e)
	{
		std::cout << this->name << " can't sign " << form.getName() << " because " << e.what() << "." << std::endl;
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
subq $0x28, %rsp
movq %rsi, %r14
movq %rdi, %r15
movq %rsi, %rdi
movq %r15, %rsi
callq 0x2a60
addq $0x28, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
cmpl $0x1, %edx
jne 0x2653
movq %rbx, %rdi
callq 0x2040
movq %rax, %rbx
movq 0x4a17(%rip), %rdi      # 0x6fd0
movq %r15, %rsi
callq 0x20c0
leaq 0x1a3c(%rip), %rsi      # 0x4004
movq %rax, %rdi
callq 0x20d0
movq %rax, %r15
leaq -0x38(%rbp), %rdi
movq %r14, %rsi
callq 0x2982
leaq -0x38(%rbp), %rsi
movq %r15, %rdi
callq 0x20c0
leaq 0x1a1f(%rip), %rsi      # 0x4011
movq %rax, %rdi
callq 0x20d0
movq %rax, %r14
movq (%rbx), %rax
movq %rbx, %rdi
callq *0x10(%rax)
movq %r14, %rdi
movq %rax, %rsi
callq 0x20d0
leaq 0x1c27(%rip), %rsi      # 0x423f
movq %rax, %rdi
callq 0x20d0
movq %rax, %rdi
callq 0x2070
leaq -0x38(%rbp), %rdi
callq 0x21d8
callq 0x2150
jmp 0x2590
jmp 0x263d
movq %rax, %rbx
jmp 0x264e
movq %rax, %rbx
leaq -0x38(%rbp), %rdi
callq 0x21d8
callq 0x2150
movq %rbx, %rdi
callq 0x2180
movq %rax, %rdi
callq 0x2811
nop
// File: /workspace/github_cpp_makefile_star2_O2/t0mm4rx[P]piscine_cpp/day05/ex03/Bureaucrat.cpp
// Function: Bureaucrat::executeForm(Form&)
void Bureaucrat::executeForm(Form &form)
{
	try
	{
		form.execute(*this);
	}
	catch(std::exception &e)
	{
		std::cout << this->name << " can't execute " << form.getName() << " because " << e.what() << "." << std::endl;
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
subq $0x28, %rsp
movq %rsi, %r14
movq %rdi, %r15
movq (%rsi), %rax
movq %rsi, %rdi
movq %r15, %rsi
callq *0x10(%rax)
addq $0x28, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
cmpl $0x1, %edx
jne 0x2746
movq %rbx, %rdi
callq 0x2040
movq %rax, %rbx
movq 0x4924(%rip), %rdi      # 0x6fd0
movq %r15, %rsi
callq 0x20c0
leaq 0x1960(%rip), %rsi      # 0x401b
movq %rax, %rdi
callq 0x20d0
movq %rax, %r15
leaq -0x38(%rbp), %rdi
movq %r14, %rsi
callq 0x2982
leaq -0x38(%rbp), %rsi
movq %r15, %rdi
callq 0x20c0
leaq 0x192c(%rip), %rsi      # 0x4011
movq %rax, %rdi
callq 0x20d0
movq %rax, %r14
movq (%rbx), %rax
movq %rbx, %rdi
callq *0x10(%rax)
movq %r14, %rdi
movq %rax, %rsi
callq 0x20d0
leaq 0x1b34(%rip), %rsi      # 0x423f
movq %rax, %rdi
callq 0x20d0
movq %rax, %rdi
callq 0x2070
leaq -0x38(%rbp), %rdi
callq 0x21d8
callq 0x2150
jmp 0x2683
jmp 0x2730
movq %rax, %rbx
jmp 0x2741
movq %rax, %rbx
leaq -0x38(%rbp), %rdi
callq 0x21d8
callq 0x2150
movq %rbx, %rdi
callq 0x2180
movq %rax, %rdi
callq 0x2811
// File: /workspace/github_cpp_makefile_star2_O2/t0mm4rx[P]piscine_cpp/day05/ex03/Form.cpp
// Function: Form::Form(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, int, int)
Form::Form(std::string name, int requiredSignatureGrade, int requiredExecutionGrade) : name(name), requiredSignatureGrade(requiredSignatureGrade), requiredExecutionGrade(requiredExecutionGrade)
{
	if (requiredExecutionGrade < 1 || requiredSignatureGrade < 1)
		throw GradeTooHighException();
	if (requiredExecutionGrade > 150 || requiredSignatureGrade > 150)
		throw GradeTooLowException();
	this->hasBeenSigned = false;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movl %ecx, %r12d
movl %edx, %r13d
movq %rdi, %r15
leaq 0x438a(%rip), %rax      # 0x6c38
movq %rax, (%rdi)
addq $0x8, %rdi
movq %rdi, -0x30(%rbp)
callq 0x2110
movl %r13d, 0x2c(%r15)
movl %r12d, 0x30(%r15)
leaq 0x43b3(%rip), %r14      # 0x6c80
leaq 0x4314(%rip), %rbx      # 0x6be8
testl %r13d, %r13d
jle 0x2912
testl %r12d, %r12d
jle 0x2912
leaq 0x4383(%rip), %r14      # 0x6c68
leaq 0x42d4(%rip), %rbx      # 0x6bc0
cmpl $0x96, %r13d
ja 0x2912
cmpl $0x97, %r12d
jae 0x2912
movb $0x0, 0x28(%r15)
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
pushq $0x8
popq %rdi
callq 0x2080
movq %rbx, (%rax)
movq 0x46bc(%rip), %rdx      # 0x6fe0
movq %rax, %rdi
movq %r14, %rsi
callq 0x2160
movq %rax, %r14
movq -0x30(%rbp), %rdi
callq 0x21d8
movq %r14, %rdi
callq 0x2180
nop
// File: /workspace/github_cpp_makefile_star2_O2/t0mm4rx[P]piscine_cpp/day05/ex03/Form.cpp
// Function: Form::beSigned(Bureaucrat&)
void			Form::beSigned(Bureaucrat &bureaucrat)
{
	if (bureaucrat.getGrade() > this->getSigningGrade())
		throw GradeTooLowException();
	std::cout << bureaucrat.getName() << " signs " << this->getName() << "." << std::endl;
	this->hasBeenSigned = true;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
subq $0x48, %rsp
movq %rsi, %r14
movq %rdi, %rbx
movq %rsi, %rdi
callq 0x2526
cmpl 0x2c(%rbx), %eax
jg 0x2b05
leaq -0x58(%rbp), %r15
movq %r15, %rdi
movq %r14, %rsi
callq 0x253a
movq 0x4536(%rip), %rdi      # 0x6fd0
movq %r15, %rsi
callq 0x20c0
leaq 0x1633(%rip), %rsi      # 0x40dc
movq %rax, %rdi
callq 0x20d0
movq %rax, %r14
leaq 0x8(%rbx), %rsi
leaq -0x38(%rbp), %rdi
callq 0x2110
leaq -0x38(%rbp), %rsi
movq %r14, %rdi
callq 0x20c0
leaq 0x176b(%rip), %rsi      # 0x423f
movq %rax, %rdi
callq 0x20d0
movq %rax, %rdi
callq 0x2070
leaq -0x38(%rbp), %rdi
callq 0x21d8
leaq -0x58(%rbp), %rdi
callq 0x21d8
movb $0x1, 0x28(%rbx)
addq $0x48, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
pushq $0x8
popq %rdi
callq 0x2080
leaq 0x40ac(%rip), %rcx      # 0x6bc0
movq %rcx, (%rax)
leaq 0x414a(%rip), %rsi      # 0x6c68
movq 0x44bb(%rip), %rdx      # 0x6fe0
movq %rax, %rdi
callq 0x2160
jmp 0x2b2f
movq %rax, %rbx
jmp 0x2b40
movq %rax, %rbx
leaq -0x38(%rbp), %rdi
callq 0x21d8
leaq -0x58(%rbp), %rdi
callq 0x21d8
movq %rbx, %rdi
callq 0x2180
nop
// File: /workspace/github_cpp_makefile_star2_O2/t0mm4rx[P]piscine_cpp/day05/ex03/Form.cpp
// Function: Form::execute(Bureaucrat const&) const
void Form::execute(const Bureaucrat &executor) const
{
	if (!this->hasBeenSigned)
		throw NotSignedException();
	if (executor.getGrade() > this->requiredExecutionGrade)
		throw GradeTooLowException();
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %rbx
pushq %rax
cmpb $0x0, 0x28(%rdi)
je 0x2bbd
movq %rdi, %rbx
movq %rsi, %rdi
callq 0x2526
cmpl 0x30(%rbx), %eax
jg 0x2bd8
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
pushq $0x8
popq %rdi
callq 0x2080
leaq 0x4044(%rip), %rcx      # 0x6c10
movq %rcx, (%rax)
leaq 0x407a(%rip), %rsi      # 0x6c50
jmp 0x2bf1
pushq $0x8
popq %rdi
callq 0x2080
leaq 0x3fd9(%rip), %rcx      # 0x6bc0
movq %rcx, (%rax)
leaq 0x4077(%rip), %rsi      # 0x6c68
movq 0x43e8(%rip), %rdx      # 0x6fe0
movq %rax, %rdi
callq 0x2160
// File: /workspace/github_cpp_makefile_star2_O2/t0mm4rx[P]piscine_cpp/day05/ex03/Intern.cpp
// Function: Intern::Intern()
Intern::Intern(void)
{
	this->constructors[0] = ShrubberyCreationForm::constructor;
	this->formNames[0] = "shrubbery";
	this->constructors[1] = RobotomyRequestForm::constructor;
	this->formNames[1] = "robotomy";
	this->constructors[2] = PresidentialPardonForm::constructor;
	this->formNames[2] = "presidential";
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
pushq $0x10
popq %rax
leaq (%rbx,%rax), %rcx
movq %rcx, -0x10(%rbx,%rax)
andq $0x0, -0x8(%rbx,%rax)
movb $0x0, (%rbx,%rax)
addq $0x20, %rax
cmpq $0x70, %rax
jne 0x2c70
leaq 0xb94(%rip), %rax       # 0x3828
movq %rax, 0x60(%rbx)
leaq 0x174f(%rip), %rsi      # 0x43ee
movq %rbx, %rdi
callq 0x21b0
leaq 0x7d8(%rip), %rax       # 0x3486
movq %rax, 0x68(%rbx)
leaq 0x20(%rbx), %rdi
leaq 0x14a0(%rip), %rsi      # 0x415d
callq 0x21b0
leaq 0x3ff(%rip), %rax       # 0x30c8
movq %rax, 0x70(%rbx)
leaq 0x40(%rbx), %rdi
leaq 0x148e(%rip), %rsi      # 0x4166
callq 0x21b0
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %r14
pushq $0x40
popq %r15
leaq (%rbx,%r15), %rdi
callq 0x21d8
addq $-0x20, %r15
cmpq $-0x20, %r15
jne 0x2cef
movq %r14, %rdi
callq 0x2180
// File: /workspace/github_cpp_makefile_star2_O2/t0mm4rx[P]piscine_cpp/day05/ex03/Intern.cpp
// Function: Intern::makeForm(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>)
Form *Intern::makeForm(std::string formName, std::string target)
{
	for (unsigned int i = 0; i < 3; i++)
	{
		if (this->formNames[i] == formName)
		{
			return ((this->constructors[i])(target));
		}
	}
	std::cout << "No form with name " << formName << "." << std::endl;
	return (nullptr);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x28, %rsp
movq %rdx, %r14
movq %rsi, %rbx
movq %rdi, %r15
leaq 0x58(%rdi), %r12
xorl %r13d, %r13d
cmpq $0x60, %r13
je 0x2dce
leaq (%r15,%r13), %rdi
movq %rbx, %rsi
callq 0x2e2b
addq $0x8, %r12
addq $0x20, %r13
testb %al, %al
je 0x2d89
movq (%r12), %r15
leaq -0x48(%rbp), %rbx
movq %rbx, %rdi
movq %r14, %rsi
callq 0x2110
movq %rbx, %rdi
callq *%r15
movq %rax, %rbx
leaq -0x48(%rbp), %rdi
callq 0x21d8
jmp 0x2e05
movq 0x41fb(%rip), %rdi      # 0x6fd0
leaq 0x1397(%rip), %rsi      # 0x4173
callq 0x20d0
movq %rax, %rdi
movq %rbx, %rsi
callq 0x20c0
leaq 0x144c(%rip), %rsi      # 0x423f
movq %rax, %rdi
callq 0x20d0
movq %rax, %rdi
callq 0x2070
xorl %ebx, %ebx
movq %rbx, %rax
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
leaq -0x48(%rbp), %rdi
callq 0x21d8
movq %rbx, %rdi
callq 0x2180
// File: /workspace/github_cpp_makefile_star2_O2/t0mm4rx[P]piscine_cpp/day05/ex03/ShrubberyCreationForm.cpp
// Function: ShrubberyCreationForm::execute(Bureaucrat const&) const
void	ShrubberyCreationForm::execute(const Bureaucrat &bureaucrat) const
{
	std::string		filename = this->target + "_shrubbery";
	std::ofstream	file(filename);

	if (file.fail())
		throw FileErrorException();
	Form::execute(bureaucrat);
	std::cout << "Creating " << filename << "." << std::endl;
	file << this->tree;
	file.close();
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
subq $0x228, %rsp            # imm = 0x228
movq %rsi, %rbx
movq %rdi, %r14
leaq 0x38(%rdi), %rsi
leaq 0xccc(%rip), %rdx       # 0x43ed
leaq -0x38(%rbp), %r15
movq %r15, %rdi
callq 0x3892
leaq -0x238(%rbp), %rdi
pushq $0x10
popq %rdx
movq %r15, %rsi
callq 0x21c0
movq -0x238(%rbp), %rax
movq -0x18(%rax), %rax
testb $0x5, -0x218(%rbp,%rax)
jne 0x37db
movq %r14, %rdi
movq %rbx, %rsi
callq 0x2b9a
movq 0x3866(%rip), %rdi      # 0x6fd0
leaq 0xc87(%rip), %rsi       # 0x43f8
callq 0x20d0
leaq -0x38(%rbp), %rsi
movq %rax, %rdi
callq 0x20c0
leaq 0xab6(%rip), %rsi       # 0x423f
movq %rax, %rdi
callq 0x20d0
movq %rax, %rdi
callq 0x2070
leaq 0x3978(%rip), %rsi      # 0x7118
leaq -0x238(%rbp), %rdi
callq 0x20c0
leaq -0x238(%rbp), %rdi
callq 0x2120
leaq -0x238(%rbp), %rdi
callq 0x2130
leaq -0x38(%rbp), %rdi
callq 0x21d8
addq $0x228, %rsp            # imm = 0x228
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
pushq $0x8
popq %rdi
callq 0x2080
leaq 0x3576(%rip), %rcx      # 0x6d60
movq %rcx, (%rax)
leaq 0x3584(%rip), %rsi      # 0x6d78
movq 0x37e5(%rip), %rdx      # 0x6fe0
movq %rax, %rdi
callq 0x2160
movq %rax, %rbx
jmp 0x3817
movq %rax, %rbx
leaq -0x238(%rbp), %rdi
callq 0x2130
leaq -0x38(%rbp), %rdi
callq 0x21d8
movq %rbx, %rdi
callq 0x2180
// File: /workspace/github_cpp_makefile_star2_O2/vividvilla[P]hackerrank/src/largest-sum-m.cpp
// Function: largestSum(int, std::vector<int, std::allocator<int>>, int)
int largestSum(int k, vector<int> d, int M) {
    int best = 0;
    int N = d.size();
    vector<vector<bool> > s = vector<vector<bool> >(M, vector<bool>(k + 1, false));
    s[0][0] = true;

    for (int j = 0; j < N; j++) {
        for (int l = M - 1; l >= d[j]; l--) {
            for (int i = 1; i <= k; i++) {
                s[l][i] = s[l][i] || s[l - d[j]][i - 1];
                if (i == k && s[l][i] && l > best)
                    best = l;
            }
        }
    }

    return best;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x88, %rsp
movl %edx, %ebp
movq 0x8(%rsi), %r14
movq %rsi, 0x20(%rsp)
subq (%rsi), %r14
movq %rdi, %rbx
leal 0x1(%rdi), %eax
movslq %eax, %rsi
leaq 0xf(%rsp), %rdx
movb $0x0, (%rdx)
leaq 0x60(%rsp), %rdi
leaq 0xe(%rsp), %rcx
callq 0x15fe
movslq %ebp, %rsi
leaq 0x28(%rsp), %rdi
leaq 0x60(%rsp), %rdx
leaq 0xd(%rsp), %rcx
movq %rsi, 0x40(%rsp)
callq 0x1662
leaq 0x60(%rsp), %rdi
callq 0x16b8
movq 0x28(%rsp), %rdi
xorl %r15d, %r15d
xorl %esi, %esi
callq 0x16c8
shrq $0x2, %r14
orq %rdx, (%rax)
movl %ebx, %eax
testl %ebx, %ebx
cmovlel %r15d, %ebx
testl %r14d, %r14d
cmovlel %r15d, %r14d
movq %r14, 0x48(%rsp)
movq %rax, 0x50(%rsp)
decq %rax
movq %rax, 0x58(%rsp)
xorl %ecx, %ecx
cmpq 0x48(%rsp), %rcx
je 0x1408
movq %r15, 0x10(%rsp)
movq 0x40(%rsp), %r13
movq %rcx, 0x18(%rsp)
movq 0x20(%rsp), %rax
movq (%rax), %rax
movslq (%rax,%rcx,4), %rax
cmpq %rax, %r13
jle 0x13fb
decq %r13
imulq $0x28, %r13, %r14
xorl %r15d, %r15d
leaq 0x1(%r15), %rbp
cmpq %r15, %rbx
je 0x13f1
movq 0x28(%rsp), %rdi
addq %r14, %rdi
movq %rbp, %rsi
callq 0x16c8
movb $0x1, %r12b
testq %rdx, (%rax)
jne 0x1397
movq 0x20(%rsp), %rax
movq (%rax), %rax
movq 0x18(%rsp), %rcx
movslq (%rax,%rcx,4), %rax
movq %r13, %rcx
subq %rax, %rcx
imulq $0x28, %rcx, %rdi
addq 0x28(%rsp), %rdi
movq %r15, %rsi
callq 0x16c8
testq %rdx, (%rax)
setne %r12b
movq 0x28(%rsp), %rdi
addq %r14, %rdi
movq %rbp, %rsi
callq 0x16c8
testb %r12b, %r12b
je 0x13b1
orq (%rax), %rdx
jmp 0x13b7
notq %rdx
andq (%rax), %rdx
movq %rdx, (%rax)
cmpq %r15, 0x58(%rsp)
jne 0x13e9
movq 0x28(%rsp), %rdi
addq %r14, %rdi
movq 0x50(%rsp), %rsi
callq 0x16c8
testq %rdx, (%rax)
je 0x13e9
movq 0x10(%rsp), %rax
cmpl %eax, %r13d
cmovgl %r13d, %eax
movq %rax, 0x10(%rsp)
movq %rbp, %r15
jmp 0x1343
movq 0x18(%rsp), %rcx
jmp 0x1324
incq %rcx
movq 0x10(%rsp), %r15
jmp 0x130a
leaq 0x28(%rsp), %rdi
callq 0x16e6
movl %r15d, %eax
addq $0x88, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
jmp 0x1443
movq %rax, %rbx
leaq 0x60(%rsp), %rdi
callq 0x16b8
jmp 0x1450
movq %rax, %rbx
jmp 0x1450
jmp 0x1443
jmp 0x1443
jmp 0x1443
movq %rax, %rbx
leaq 0x28(%rsp), %rdi
callq 0x16e6
movq %rbx, %rdi
callq 0x1130