LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: ashagraev[P]covariation/main.cpp
// Function: TPrinter::Print() const::'lambda'(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>>>> const&)::operator()(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>>>> const&) const
void Print() const {
        auto printRow = [&](const std::vector<std::string>& row){
            const size_t columnWidth = 25;

            std::stringstream rowStream;
            for (const std::string& element : row) {
                PrintNextColumn(rowStream, element, columnWidth);
            }

            printf("%s\n", rowStream.str().c_str());
        };

        printf("%s\n", Title.c_str());
        printRow(Columns);
        for (const std::vector<std::string>& row : Rows) {
            printRow(row);
        }
    }

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x200, %rsp            # imm = 0x200
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x1f8(%rbp)
movq $0x19, -0x18(%rbp)
leaq -0x1a0(%rbp), %rdi
callq 0x2120
movq -0x10(%rbp), %rax
movq %rax, -0x1a8(%rbp)
movq -0x1a8(%rbp), %rdi
callq 0x5ee0
movq %rax, -0x1b0(%rbp)
movq -0x1a8(%rbp), %rdi
callq 0x5f10
movq %rax, -0x1b8(%rbp)
leaq -0x1b0(%rbp), %rdi
leaq -0x1b8(%rbp), %rsi
callq 0x5f40
testb $0x1, %al
jne 0x5d0f
jmp 0x5d67
leaq -0x1b0(%rbp), %rdi
callq 0x5f80
movq -0x1f8(%rbp), %rdi
movq %rax, -0x1c0(%rbp)
movq -0x1c0(%rbp), %rdx
leaq -0x1a0(%rbp), %rsi
movl $0x19, %ecx
callq 0x5fa0
jmp 0x5d43
jmp 0x5d45
leaq -0x1b0(%rbp), %rdi
callq 0x6070
jmp 0x5cf6
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x1c8(%rbp)
movl %eax, -0x1cc(%rbp)
jmp 0x5dda
leaq -0x1f0(%rbp), %rdi
leaq -0x1a0(%rbp), %rsi
callq 0x21b0
jmp 0x5d7c
leaq -0x1f0(%rbp), %rdi
callq 0x20b0
movq %rax, %rsi
leaq 0x233a(%rip), %rdi      # 0x80cc
xorl %eax, %eax
callq 0x2030
jmp 0x5d9b
leaq -0x1f0(%rbp), %rdi
callq 0x20f0
leaq -0x1a0(%rbp), %rdi
callq 0x2140
addq $0x200, %rsp            # imm = 0x200
popq %rbp
retq
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x1c8(%rbp)
movl %eax, -0x1cc(%rbp)
leaq -0x1f0(%rbp), %rdi
callq 0x20f0
leaq -0x1a0(%rbp), %rdi
callq 0x2140
movq -0x1c8(%rbp), %rdi
callq 0x2260
nopw %cs:(%rax,%rax)
nopl (%rax)
// File: ashagraev[P]covariation/main.cpp
// Function: TTypedCovariationCalculator<long double>::Add(double, double)
void Add(const double x, const double y) override {
        ++Count;
        SumX += x;
        SumY += y;
        SumProducts += x * y;
    }

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movsd %xmm0, -0x10(%rbp)
movsd %xmm1, -0x18(%rbp)
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rcx
incq %rcx
movq %rcx, 0x8(%rax)
fldl -0x10(%rbp)
fldt 0x10(%rax)
faddp %st, %st(1)
fstpt 0x10(%rax)
fldl -0x18(%rbp)
fldt 0x20(%rax)
faddp %st, %st(1)
fstpt 0x20(%rax)
movsd -0x10(%rbp), %xmm0
movsd -0x18(%rbp), %xmm1
mulsd %xmm1, %xmm0
movsd %xmm0, -0x20(%rbp)
fldl -0x20(%rbp)
fldt 0x30(%rax)
faddp %st, %st(1)
fstpt 0x30(%rax)
popq %rbp
retq
nopw (%rax,%rax)
// File: ashagraev[P]covariation/main.cpp
// Function: TKahanAccumulator::operator+=(double)
TKahanAccumulator& operator += (const double value) {
        const double y = value - Addition;
        const double t = Sum + y;
        Addition = (t - Sum) - y;
        Sum = t;
        return *this;
    }

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movsd %xmm0, -0x10(%rbp)
movq -0x8(%rbp), %rax
movsd -0x10(%rbp), %xmm0
subsd 0x8(%rax), %xmm0
movsd %xmm0, -0x18(%rbp)
movsd (%rax), %xmm0
addsd -0x18(%rbp), %xmm0
movsd %xmm0, -0x20(%rbp)
movsd -0x20(%rbp), %xmm0
subsd (%rax), %xmm0
subsd -0x18(%rbp), %xmm0
movsd %xmm0, 0x8(%rax)
movsd -0x20(%rbp), %xmm0
movsd %xmm0, (%rax)
popq %rbp
retq
nopl (%rax)
// File: ashagraev[P]covariation/main.cpp
// Function: TWelfordCovariationCalculator::Add(double, double)
void Add(const double x, const double y) override {
        ++Count;
        MeanX += (x - MeanX) / Count;
        SumProducts += (x - MeanX) * (y - MeanY);
        MeanY += (y - MeanY) / Count;
    }

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movsd %xmm0, -0x10(%rbp)
movsd %xmm1, -0x18(%rbp)
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rcx
incq %rcx
movq %rcx, 0x8(%rax)
movsd -0x10(%rbp), %xmm1
movsd 0x10(%rax), %xmm0
subsd %xmm0, %xmm1
movq 0x8(%rax), %xmm4
movaps 0x4045(%rip), %xmm3     # 0x8020
punpckldq %xmm3, %xmm4    # xmm4 = xmm4[0],xmm3[0],xmm4[1],xmm3[1]
movapd 0x4049(%rip), %xmm2     # 0x8030
subpd %xmm2, %xmm4
movaps %xmm4, %xmm5
unpckhpd %xmm4, %xmm4            # xmm4 = xmm4[1,1]
addsd %xmm5, %xmm4
divsd %xmm4, %xmm1
addsd %xmm1, %xmm0
movsd %xmm0, 0x10(%rax)
movsd -0x10(%rbp), %xmm0
movsd 0x10(%rax), %xmm4
movsd 0x18(%rax), %xmm1
subsd %xmm4, %xmm0
movsd -0x18(%rbp), %xmm4
subsd %xmm1, %xmm4
movsd 0x20(%rax), %xmm1
mulsd %xmm4, %xmm0
addsd %xmm1, %xmm0
movsd %xmm0, 0x20(%rax)
movsd -0x18(%rbp), %xmm0
movsd 0x18(%rax), %xmm1
subsd %xmm1, %xmm0
movq 0x8(%rax), %xmm1
punpckldq %xmm3, %xmm1    # xmm1 = xmm1[0],xmm3[0],xmm1[1],xmm3[1]
subpd %xmm2, %xmm1
movaps %xmm1, %xmm2
unpckhpd %xmm1, %xmm1            # xmm1 = xmm1[1,1]
addsd %xmm2, %xmm1
divsd %xmm1, %xmm0
addsd 0x18(%rax), %xmm0
movsd %xmm0, 0x18(%rax)
popq %rbp
retq
nopw (%rax,%rax)
// File: ashagraev[P]covariation/main.cpp
// Function: void TPrinter::PrintNextColumn<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>(std::__cxx11::basic_stringstream<char, std::char_traits<char>, std::allocator<char>>&, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&, unsigned long) const
void PrintNextColumn(std::stringstream& out, const TValue& value, size_t columnWidth) const {
        const size_t startLength = out.str().size();
        out << value;
        const size_t currentLength = out.str().size();
        for (size_t i = currentLength; i < startLength + columnWidth; ++i) {
            out << " ";
        }
    }

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x90, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq %rcx, -0x20(%rbp)
movq -0x10(%rbp), %rsi
leaq -0x48(%rbp), %rdi
callq 0x21b0
leaq -0x48(%rbp), %rdi
callq 0x2110
movq %rax, -0x88(%rbp)
leaq -0x48(%rbp), %rdi
callq 0x20f0
movq -0x88(%rbp), %rax
movq %rax, -0x28(%rbp)
movq -0x10(%rbp), %rdi
addq $0x10, %rdi
movq -0x18(%rbp), %rsi
callq 0x2190
movq -0x10(%rbp), %rsi
leaq -0x70(%rbp), %rdi
callq 0x21b0
leaq -0x70(%rbp), %rdi
callq 0x2110
movq %rax, -0x80(%rbp)
leaq -0x70(%rbp), %rdi
callq 0x20f0
movq -0x80(%rbp), %rax
movq %rax, -0x50(%rbp)
movq -0x50(%rbp), %rax
movq %rax, -0x78(%rbp)
movq -0x78(%rbp), %rax
movq -0x28(%rbp), %rcx
addq -0x20(%rbp), %rcx
cmpq %rcx, %rax
jae 0x6063
movq -0x10(%rbp), %rdi
addq $0x10, %rdi
leaq 0x2019(%rip), %rsi      # 0x8069
callq 0x21c0
movq -0x78(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x78(%rbp)
jmp 0x6030
addq $0x90, %rsp
popq %rbp
retq
nopl (%rax)
// File: drarwood[P]gags/Calculator.cpp
// Function: CalcVariance(std::vector<double, std::allocator<double>>&)
double CalcVariance(vector<double>& v) {
    double s;
    double m;
    int    i;
    s=0;
    for (i=0;i<v.size();++i) {
        s+=v[i];
    }
    m=s/(double) v.size();
    s=0;
    for (i=0;i<v.size();++i) {
        s+=(v[i]-m)*(v[i]-m);
    }
    return (s/(v.size()-1)) ;
}

// Assembly:
subq $0x48, %rsp
movq %rdi, 0x40(%rsp)
xorps %xmm0, %xmm0
movsd %xmm0, 0x38(%rsp)
movl $0x0, 0x2c(%rsp)
movslq 0x2c(%rsp), %rax
movq %rax, 0x20(%rsp)
movq 0x40(%rsp), %rdi
callq 0x5770
movq %rax, %rcx
movq 0x20(%rsp), %rax
cmpq %rcx, %rax
jae 0xdec7
movq 0x40(%rsp), %rdi
movslq 0x2c(%rsp), %rsi
callq 0x5bf0
movsd (%rax), %xmm0
addsd 0x38(%rsp), %xmm0
movsd %xmm0, 0x38(%rsp)
movl 0x2c(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x2c(%rsp)
jmp 0xde7a
movsd 0x38(%rsp), %xmm0
movsd %xmm0, 0x18(%rsp)
movq 0x40(%rsp), %rdi
callq 0x5770
movsd 0x18(%rsp), %xmm0
movq %rax, %xmm1
movaps 0xc3c1(%rip), %xmm2     # 0x1a2b0
punpckldq %xmm2, %xmm1    # xmm1 = xmm1[0],xmm2[0],xmm1[1],xmm2[1]
movapd 0xc3c5(%rip), %xmm2     # 0x1a2c0
subpd %xmm2, %xmm1
movaps %xmm1, %xmm2
unpckhpd %xmm1, %xmm1            # xmm1 = xmm1[1,1]
addsd %xmm2, %xmm1
divsd %xmm1, %xmm0
movsd %xmm0, 0x30(%rsp)
xorps %xmm0, %xmm0
movsd %xmm0, 0x38(%rsp)
movl $0x0, 0x2c(%rsp)
movslq 0x2c(%rsp), %rax
movq %rax, 0x10(%rsp)
movq 0x40(%rsp), %rdi
callq 0x5770
movq %rax, %rcx
movq 0x10(%rsp), %rax
cmpq %rcx, %rax
jae 0xdfa5
movq 0x40(%rsp), %rdi
movslq 0x2c(%rsp), %rsi
callq 0x5bf0
movsd (%rax), %xmm0
subsd 0x30(%rsp), %xmm0
movsd %xmm0, 0x8(%rsp)
movq 0x40(%rsp), %rdi
movslq 0x2c(%rsp), %rsi
callq 0x5bf0
movsd 0x8(%rsp), %xmm0
movsd (%rax), %xmm2
subsd 0x30(%rsp), %xmm2
movsd 0x38(%rsp), %xmm1
mulsd %xmm2, %xmm0
addsd %xmm1, %xmm0
movsd %xmm0, 0x38(%rsp)
movl 0x2c(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x2c(%rsp)
jmp 0xdf25
movsd 0x38(%rsp), %xmm0
movsd %xmm0, (%rsp)
movq 0x40(%rsp), %rdi
callq 0x5770
movsd (%rsp), %xmm0
decq %rax
movq %rax, %xmm1
movaps 0xc2e2(%rip), %xmm2     # 0x1a2b0
punpckldq %xmm2, %xmm1    # xmm1 = xmm1[0],xmm2[0],xmm1[1],xmm2[1]
movapd 0xc2e6(%rip), %xmm2     # 0x1a2c0
subpd %xmm2, %xmm1
movaps %xmm1, %xmm2
unpckhpd %xmm1, %xmm1            # xmm1 = xmm1[1,1]
addsd %xmm2, %xmm1
divsd %xmm1, %xmm0
addq $0x48, %rsp
retq
nopw %cs:(%rax,%rax)
// File: drarwood[P]gags/Calculator.cpp
// Function: CalcMean(std::vector<double, std::allocator<double>>&)
double CalcMean(vector<double>& v) {
    double s;
    s=0;
    for (int i=0;i<v.size();++i) {
        s+=v[i];
    }
    return s/v.size();
}

// Assembly:
subq $0x28, %rsp
movq %rdi, 0x20(%rsp)
xorps %xmm0, %xmm0
movsd %xmm0, 0x18(%rsp)
movl $0x0, 0x14(%rsp)
movslq 0x14(%rsp), %rax
movq %rax, 0x8(%rsp)
movq 0x20(%rsp), %rdi
callq 0x5770
movq %rax, %rcx
movq 0x8(%rsp), %rax
cmpq %rcx, %rax
jae 0xe067
movq 0x20(%rsp), %rdi
movslq 0x14(%rsp), %rsi
callq 0x5bf0
movsd (%rax), %xmm0
addsd 0x18(%rsp), %xmm0
movsd %xmm0, 0x18(%rsp)
movl 0x14(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x14(%rsp)
jmp 0xe01a
movsd 0x18(%rsp), %xmm0
movsd %xmm0, (%rsp)
movq 0x20(%rsp), %rdi
callq 0x5770
movsd (%rsp), %xmm0
movq %rax, %xmm1
movaps 0xc223(%rip), %xmm2     # 0x1a2b0
punpckldq %xmm2, %xmm1    # xmm1 = xmm1[0],xmm2[0],xmm1[1],xmm2[1]
movapd 0xc227(%rip), %xmm2     # 0x1a2c0
subpd %xmm2, %xmm1
movaps %xmm1, %xmm2
unpckhpd %xmm1, %xmm1            # xmm1 = xmm1[1,1]
addsd %xmm2, %xmm1
divsd %xmm1, %xmm0
addq $0x28, %rsp
retq
nopw %cs:(%rax,%rax)
// File: drarwood[P]gags/Calculator.cpp
// Function: CalcSum(std::vector<double, std::allocator<double>>&)
double CalcSum(vector<double>& v) {
    double s;
    s=0;
    for (int i=0;i<v.size();++i) {
        s+=v[i];
    }
    return s;
}

// Assembly:
subq $0x28, %rsp
movq %rdi, 0x20(%rsp)
xorps %xmm0, %xmm0
movsd %xmm0, 0x18(%rsp)
movl $0x0, 0x14(%rsp)
movslq 0x14(%rsp), %rax
movq %rax, 0x8(%rsp)
movq 0x20(%rsp), %rdi
callq 0x5770
movq %rax, %rcx
movq 0x8(%rsp), %rax
cmpq %rcx, %rax
jae 0xe127
movq 0x20(%rsp), %rdi
movslq 0x14(%rsp), %rsi
callq 0x5bf0
movsd (%rax), %xmm0
addsd 0x18(%rsp), %xmm0
movsd %xmm0, 0x18(%rsp)
movl 0x14(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x14(%rsp)
jmp 0xe0da
movsd 0x18(%rsp), %xmm0
addq $0x28, %rsp
retq
nopw %cs:(%rax,%rax)
// File: drarwood[P]gags/Calculator.cpp
// Function: doubleLess(double, double, double, bool)
bool doubleLess(double l, double r, double e, bool orequal) {
    if (fabs(l-r)<e) {
        // within epsilon so considered equal
        return orequal;
    }
    return (l<r);
}

// Assembly:
movb %dil, %al
movsd %xmm0, -0x10(%rsp)
movsd %xmm1, -0x18(%rsp)
movsd %xmm2, -0x20(%rsp)
andb $0x1, %al
movb %al, -0x21(%rsp)
movsd -0x10(%rsp), %xmm1
subsd -0x18(%rsp), %xmm1
movaps 0xc122(%rip), %xmm0     # 0x1a2d0
pand %xmm0, %xmm1
movsd -0x20(%rsp), %xmm0
ucomisd %xmm1, %xmm0
jbe 0xe1ca
movb -0x21(%rsp), %al
andb $0x1, %al
movb %al, -0x1(%rsp)
jmp 0xe1e3
movsd -0x10(%rsp), %xmm1
movsd -0x18(%rsp), %xmm0
ucomisd %xmm1, %xmm0
seta %al
andb $0x1, %al
movb %al, -0x1(%rsp)
movb -0x1(%rsp), %al
andb $0x1, %al
retq
nopw (%rax,%rax)
// File: drarwood[P]gags/ExclusionListProcessor.cpp
// Function: ReadExclusionsFile(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, std::map<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, int, 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, int>>>&)
void ReadExclusionsFile(string f, map<string, int>& m) {
    string line, id;
    ifstream inFile(f.c_str());
    if (inFile.is_open()) {
        while (inFile.good()) {
            getline (inFile, line);
            if (!line.empty()) {
                m[line] = 0;
            }
        }
        inFile.close();
    }
    else {
        cout << "Unable to open " << f << " for reading" << endl;
        exit(EXIT_FAILURE);
    }
}

// Assembly:
subq $0x298, %rsp            # imm = 0x298
movq %rdi, 0x28(%rsp)
movq %rdi, 0x290(%rsp)
movq %rsi, 0x288(%rsp)
leaq 0x268(%rsp), %rdi
callq 0x3410
leaq 0x248(%rsp), %rdi
callq 0x3410
movq 0x28(%rsp), %rdi
callq 0x3120
movq %rax, %rsi
leaq 0x40(%rsp), %rdi
movl $0x8, %edx
callq 0x3540
jmp 0xe2b4
leaq 0x40(%rsp), %rdi
callq 0x3490
movb %al, 0x27(%rsp)
jmp 0xe2c4
movb 0x27(%rsp), %al
testb $0x1, %al
jne 0xe2d1
jmp 0xe38a
jmp 0xe2d3
movq 0x40(%rsp), %rax
movq -0x18(%rax), %rax
leaq 0x40(%rsp,%rax), %rdi
callq 0x34d0
movb %al, 0x26(%rsp)
jmp 0xe2ec
movb 0x26(%rsp), %al
testb $0x1, %al
jne 0xe2f9
jmp 0xe37c
leaq 0x40(%rsp), %rdi
leaq 0x268(%rsp), %rsi
callq 0x3080
jmp 0xe30d
leaq 0x268(%rsp), %rdi
callq 0x34c0
testb $0x1, %al
jne 0xe377
movq 0x288(%rsp), %rdi
leaq 0x268(%rsp), %rsi
callq 0x5fc0
movq %rax, 0x18(%rsp)
jmp 0xe33a
movq 0x18(%rsp), %rax
movl $0x0, (%rax)
jmp 0xe377
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x38(%rsp)
movl %eax, 0x34(%rsp)
jmp 0xe419
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x38(%rsp)
movl %eax, 0x34(%rsp)
leaq 0x40(%rsp), %rdi
callq 0x30c0
jmp 0xe419
jmp 0xe2d3
leaq 0x40(%rsp), %rdi
callq 0x3090
jmp 0xe388
jmp 0xe3ed
movq 0x14c47(%rip), %rdi     # 0x22fd8
leaq 0xbf48(%rip), %rsi      # 0x1a2e0
callq 0x32c0
movq %rax, 0x10(%rsp)
jmp 0xe3a4
movq 0x28(%rsp), %rsi
movq 0x10(%rsp), %rdi
callq 0x32a0
movq %rax, 0x8(%rsp)
jmp 0xe3ba
movq 0x8(%rsp), %rdi
leaq 0xbf2a(%rip), %rsi      # 0x1a2f0
callq 0x32c0
movq %rax, (%rsp)
jmp 0xe3d1
movq (%rsp), %rdi
movq 0x14bec(%rip), %rsi     # 0x22fc8
callq 0x3330
jmp 0xe3e3
movl $0x1, %edi
callq 0x33a0
leaq 0x40(%rsp), %rdi
callq 0x30c0
leaq 0x248(%rsp), %rdi
callq 0x31c0
leaq 0x268(%rsp), %rdi
callq 0x31c0
addq $0x298, %rsp            # imm = 0x298
retq
leaq 0x248(%rsp), %rdi
callq 0x31c0
leaq 0x268(%rsp), %rdi
callq 0x31c0
movq 0x38(%rsp), %rdi
callq 0x3510
nopl (%rax)
// File: drarwood[P]gags/GA.cpp
// Function: DetermineBestSolution(std::vector<double, std::allocator<double>>&, double&, int&)
void DetermineBestSolution(std::vector<double>& v, double& s, int& x) {
    double bestScore = 999999999;
    int    bestScoreIndex;
    for (int i = 0; i < v.size(); ++i) {
        if (v[i] < bestScore) {
            bestScore = v[i];
            bestScoreIndex = i;
        }
    }
    s = bestScore;
    x = bestScoreIndex;
}

// Assembly:
subq $0x38, %rsp
movq %rdi, 0x30(%rsp)
movq %rsi, 0x28(%rsp)
movq %rdx, 0x20(%rsp)
movsd 0xa245(%rip), %xmm0     # 0x1a340
movsd %xmm0, 0x18(%rsp)
movl $0x0, 0x10(%rsp)
movslq 0x10(%rsp), %rax
movq %rax, 0x8(%rsp)
movq 0x30(%rsp), %rdi
callq 0x5770
movq %rax, %rcx
movq 0x8(%rsp), %rax
cmpq %rcx, %rax
jae 0x10179
movq 0x30(%rsp), %rdi
movslq 0x10(%rsp), %rsi
callq 0x5bf0
movsd (%rax), %xmm1
movsd 0x18(%rsp), %xmm0
ucomisd %xmm1, %xmm0
jbe 0x1016a
movq 0x30(%rsp), %rdi
movslq 0x10(%rsp), %rsi
callq 0x5bf0
movsd (%rax), %xmm0
movsd %xmm0, 0x18(%rsp)
movl 0x10(%rsp), %eax
movl %eax, 0x14(%rsp)
jmp 0x1016c
movl 0x10(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x10(%rsp)
jmp 0x10109
movsd 0x18(%rsp), %xmm0
movq 0x28(%rsp), %rax
movsd %xmm0, (%rax)
movl 0x14(%rsp), %ecx
movq 0x20(%rsp), %rax
movl %ecx, (%rax)
addq $0x38, %rsp
retq
nopl (%rax,%rax)
// File: drarwood[P]gags/GA.cpp
// Function: GenerateRouletteWheel(std::vector<double, std::allocator<double>>&, std::vector<double, std::allocator<double>>&)
void GenerateRouletteWheel(vector<double>& r, vector<double>& s) {
    vector<double>s2;
    vector<double>::iterator it = max_element(s.begin(), s.end());
    double worstScore = *it;
    double reqSum = 0;
    double prevProb = 0;    
    for (int i = 0; i < s.size(); ++i) {
        s2.push_back(worstScore-s[i]+1);
        reqSum += (worstScore-s[i]+1);
    }
    for (int i = 0; i < s2.size(); ++i) {
        r.push_back(prevProb + (s2[i] / reqSum));
        prevProb += s2[i] / reqSum;
    }
}

// Assembly:
subq $0xc8, %rsp
movq %rdi, 0xc0(%rsp)
movq %rsi, 0xb8(%rsp)
leaq 0xa0(%rsp), %rdi
callq 0x56f0
movq 0xb8(%rsp), %rdi
callq 0x9be0
movq %rax, 0x90(%rsp)
movq 0xb8(%rsp), %rdi
callq 0x9a50
movq %rax, 0x88(%rsp)
movq 0x90(%rsp), %rdi
movq 0x88(%rsp), %rsi
callq 0x12110
movq %rax, 0x38(%rsp)
jmp 0x105da
movq 0x38(%rsp), %rax
movq %rax, 0x98(%rsp)
leaq 0x98(%rsp), %rdi
callq 0x12160
movsd (%rax), %xmm0
movsd %xmm0, 0x70(%rsp)
xorps %xmm0, %xmm0
movsd %xmm0, 0x68(%rsp)
xorps %xmm0, %xmm0
movsd %xmm0, 0x60(%rsp)
movl $0x0, 0x5c(%rsp)
movslq 0x5c(%rsp), %rax
movq %rax, 0x30(%rsp)
movq 0xb8(%rsp), %rdi
callq 0x5770
movq %rax, %rcx
movq 0x30(%rsp), %rax
cmpq %rcx, %rax
jae 0x10705
movsd 0x70(%rsp), %xmm0
movsd %xmm0, 0x28(%rsp)
movq 0xb8(%rsp), %rdi
movslq 0x5c(%rsp), %rsi
callq 0x5bf0
movsd 0x28(%rsp), %xmm0
movsd (%rax), %xmm1
subsd %xmm1, %xmm0
movsd 0x9cdc(%rip), %xmm1     # 0x1a350
addsd %xmm1, %xmm0
movsd %xmm0, 0x50(%rsp)
leaq 0xa0(%rsp), %rdi
leaq 0x50(%rsp), %rsi
callq 0x12170
jmp 0x10692
movsd 0x70(%rsp), %xmm0
movsd %xmm0, 0x20(%rsp)
movq 0xb8(%rsp), %rdi
movslq 0x5c(%rsp), %rsi
callq 0x5bf0
movsd 0x20(%rsp), %xmm0
subsd (%rax), %xmm0
movsd 0x9c8e(%rip), %xmm1     # 0x1a350
addsd %xmm1, %xmm0
addsd 0x68(%rsp), %xmm0
movsd %xmm0, 0x68(%rsp)
movl 0x5c(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x5c(%rsp)
jmp 0x10618
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x80(%rsp)
movl %eax, 0x7c(%rsp)
leaq 0xa0(%rsp), %rdi
callq 0x61e0
jmp 0x107dc
movl $0x0, 0x4c(%rsp)
movslq 0x4c(%rsp), %rax
movq %rax, 0x18(%rsp)
leaq 0xa0(%rsp), %rdi
callq 0x5770
movq %rax, %rcx
movq 0x18(%rsp), %rax
cmpq %rcx, %rax
jae 0x107c7
movq 0xc0(%rsp), %rax
movq %rax, 0x10(%rsp)
movsd 0x60(%rsp), %xmm0
movsd %xmm0, 0x8(%rsp)
movslq 0x4c(%rsp), %rsi
leaq 0xa0(%rsp), %rdi
callq 0x5bf0
movsd 0x8(%rsp), %xmm0
movq 0x10(%rsp), %rdi
movsd (%rax), %xmm1
movsd 0x68(%rsp), %xmm2
divsd %xmm2, %xmm1
addsd %xmm1, %xmm0
movsd %xmm0, 0x40(%rsp)
leaq 0x40(%rsp), %rsi
callq 0x12170
jmp 0x1078f
movslq 0x4c(%rsp), %rsi
leaq 0xa0(%rsp), %rdi
callq 0x5bf0
movsd (%rax), %xmm0
divsd 0x68(%rsp), %xmm0
addsd 0x60(%rsp), %xmm0
movsd %xmm0, 0x60(%rsp)
movl 0x4c(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x4c(%rsp)
jmp 0x1070d
leaq 0xa0(%rsp), %rdi
callq 0x61e0
addq $0xc8, %rsp
retq
movq 0x80(%rsp), %rdi
callq 0x3510
nopl (%rax)
// File: drarwood[P]gags/GA.cpp
// Function: SpinWheel(std::vector<double, std::allocator<double>>&)
int SpinWheel(vector<double>& r) {
    int i;
    double randomNumber = rand() / (double)RAND_MAX;
    for (i = 0; i < r.size(); ++i) {
        if (randomNumber < r[i]) {
            break;
        }
    }
    return i;
}

// Assembly:
subq $0x28, %rsp
movq %rdi, 0x20(%rsp)
callq 0x30d0
cvtsi2sd %eax, %xmm0
movsd 0x9b4e(%rip), %xmm1     # 0x1a358
divsd %xmm1, %xmm0
movsd %xmm0, 0x10(%rsp)
movl $0x0, 0x1c(%rsp)
movslq 0x1c(%rsp), %rax
movq %rax, 0x8(%rsp)
movq 0x20(%rsp), %rdi
callq 0x5770
movq %rax, %rcx
movq 0x8(%rsp), %rax
cmpq %rcx, %rax
jae 0x10877
movsd 0x10(%rsp), %xmm0
movsd %xmm0, (%rsp)
movq 0x20(%rsp), %rdi
movslq 0x1c(%rsp), %rsi
callq 0x5bf0
movsd (%rsp), %xmm1
movsd (%rax), %xmm0
ucomisd %xmm1, %xmm0
jbe 0x10868
jmp 0x10877
jmp 0x1086a
movl 0x1c(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x1c(%rsp)
jmp 0x1081c
movl 0x1c(%rsp), %eax
addq $0x28, %rsp
retq
// File: drarwood[P]gags/GA.cpp
// Function: DetermineWorstSolution(std::vector<double, std::allocator<double>>&, double&, int&)
void DetermineWorstSolution(vector<double>& v, double& s, int& x) {
    double worstScore = 0;
    int    worstScoreIndex;
    for (int i = 0; i < v.size(); ++i) {
        if (v[i] > worstScore) {
            worstScore = v[i];
            worstScoreIndex = i;
        }
    }
    s = worstScore;
    x = worstScoreIndex;
}

// Assembly:
subq $0x38, %rsp
movq %rdi, 0x30(%rsp)
movq %rsi, 0x28(%rsp)
movq %rdx, 0x20(%rsp)
xorps %xmm0, %xmm0
movsd %xmm0, 0x18(%rsp)
movl $0x0, 0x10(%rsp)
movslq 0x10(%rsp), %rax
movq %rax, 0x8(%rsp)
movq 0x30(%rsp), %rdi
callq 0x5770
movq %rax, %rcx
movq 0x8(%rsp), %rax
cmpq %rcx, %rax
jae 0x10910
movq 0x30(%rsp), %rdi
movslq 0x10(%rsp), %rsi
callq 0x5bf0
movsd (%rax), %xmm0
ucomisd 0x18(%rsp), %xmm0
jbe 0x10901
movq 0x30(%rsp), %rdi
movslq 0x10(%rsp), %rsi
callq 0x5bf0
movsd (%rax), %xmm0
movsd %xmm0, 0x18(%rsp)
movl 0x10(%rsp), %eax
movl %eax, 0x14(%rsp)
jmp 0x10903
movl 0x10(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x10(%rsp)
jmp 0x108a4
movsd 0x18(%rsp), %xmm0
movq 0x28(%rsp), %rax
movsd %xmm0, (%rax)
movl 0x14(%rsp), %ecx
movq 0x20(%rsp), %rax
movl %ecx, (%rax)
addq $0x38, %rsp
retq
nop
// File: 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:
subq $0xa8, %rsp
movq %rsi, (%rsp)
movq %rdi, 0xa0(%rsp)
movq %rsi, 0x98(%rsp)
leaq 0x88(%rsp), %rdi
callq 0x123e0
movq (%rsp), %rdi
callq 0x9be0
movq (%rsp), %rdi
movq %rax, 0x78(%rsp)
callq 0x9a50
movq %rax, 0x70(%rsp)
movq 0x78(%rsp), %rdi
movq 0x70(%rsp), %rsi
callq 0x12110
movq (%rsp), %rdi
movq %rax, 0x80(%rsp)
movq 0x80(%rsp), %rax
movq %rax, 0x88(%rsp)
callq 0x9be0
movq (%rsp), %rdi
movq %rax, 0x60(%rsp)
callq 0x9a50
movq %rax, 0x58(%rsp)
leaq 0x88(%rsp), %rdi
callq 0x12160
movq %rax, %rdx
movq 0x60(%rsp), %rdi
movq 0x58(%rsp), %rsi
callq 0x12400
movq (%rsp), %rdi
movq %rax, 0x68(%rsp)
movq 0x68(%rsp), %rax
movq %rax, 0x88(%rsp)
callq 0x9be0
movq %rax, 0x50(%rsp)
movq 0x88(%rsp), %rax
movq %rax, 0x48(%rsp)
movq 0x50(%rsp), %rdi
movq 0x48(%rsp), %rsi
callq 0x12460
movl %eax, 0x94(%rsp)
movq 0xa0(%rsp), %rdi
leaq 0x94(%rsp), %rsi
callq 0x5c10
movq (%rsp), %rdi
movslq 0x94(%rsp), %rsi
callq 0x5bf0
movq (%rsp), %rdi
movsd 0x8425(%rip), %xmm0     # 0x1a360
movsd %xmm0, (%rax)
callq 0x9be0
movq (%rsp), %rdi
movq %rax, 0x38(%rsp)
callq 0x9a50
movq %rax, 0x30(%rsp)
movq 0x38(%rsp), %rdi
movq 0x30(%rsp), %rsi
callq 0x12110
movq (%rsp), %rdi
movq %rax, 0x40(%rsp)
movq 0x40(%rsp), %rax
movq %rax, 0x88(%rsp)
callq 0x9be0
movq (%rsp), %rdi
movq %rax, 0x20(%rsp)
callq 0x9a50
movq %rax, 0x18(%rsp)
leaq 0x88(%rsp), %rdi
callq 0x12160
movq %rax, %rdx
movq 0x20(%rsp), %rdi
movq 0x18(%rsp), %rsi
callq 0x12400
movq (%rsp), %rdi
movq %rax, 0x28(%rsp)
movq 0x28(%rsp), %rax
movq %rax, 0x88(%rsp)
callq 0x9be0
movq %rax, 0x10(%rsp)
movq 0x88(%rsp), %rax
movq %rax, 0x8(%rsp)
movq 0x10(%rsp), %rdi
movq 0x8(%rsp), %rsi
callq 0x12460
movl %eax, 0x94(%rsp)
movq 0xa0(%rsp), %rdi
leaq 0x94(%rsp), %rsi
callq 0x5c10
addq $0xa8, %rsp
retq
nopw %cs:(%rax,%rax)
nopl (%rax)
// File: drarwood[P]gags/InputParser.cpp
// Function: ShowHeader()
void ShowHeader() {
    cout << endl << "==================== GAGS ===============" << endl;
    cout <<         "    Genetic Algorithm Group Selection  " << endl;
    cout <<         "       Written by Andrew R Wood        " << endl;
    cout <<         "           a.r.wood@exeter.ac.uk       " << endl;
    cout <<         "  University of Exeter Medical School  " << endl;
    cout <<         "          Version 0.1: 20-09-2018      " << endl;
    cout <<         "=======================================" << endl;
    cout << endl;
}

// Assembly:
pushq %rax
movq 0xe3f0(%rip), %rdi      # 0x22fd8
movq 0xe3d9(%rip), %rsi      # 0x22fc8
callq 0x3330
movq %rax, %rdi
leaq 0x57c2(%rip), %rsi      # 0x1a3c0
callq 0x32c0
movq %rax, %rdi
movq 0xe3bb(%rip), %rsi      # 0x22fc8
callq 0x3330
movq 0xe3bf(%rip), %rdi      # 0x22fd8
leaq 0x57ca(%rip), %rsi      # 0x1a3ea
callq 0x32c0
movq %rax, %rdi
movq 0xe399(%rip), %rsi      # 0x22fc8
callq 0x3330
movq 0xe39d(%rip), %rdi      # 0x22fd8
leaq 0x57d0(%rip), %rsi      # 0x1a412
callq 0x32c0
movq %rax, %rdi
movq 0xe377(%rip), %rsi      # 0x22fc8
callq 0x3330
movq 0xe37b(%rip), %rdi      # 0x22fd8
leaq 0x57d6(%rip), %rsi      # 0x1a43a
callq 0x32c0
movq %rax, %rdi
movq 0xe355(%rip), %rsi      # 0x22fc8
callq 0x3330
movq 0xe359(%rip), %rdi      # 0x22fd8
leaq 0x57dc(%rip), %rsi      # 0x1a462
callq 0x32c0
movq %rax, %rdi
movq 0xe333(%rip), %rsi      # 0x22fc8
callq 0x3330
movq 0xe337(%rip), %rdi      # 0x22fd8
leaq 0x57e2(%rip), %rsi      # 0x1a48a
callq 0x32c0
movq %rax, %rdi
movq 0xe311(%rip), %rsi      # 0x22fc8
callq 0x3330
movq 0xe315(%rip), %rdi      # 0x22fd8
leaq 0x57e8(%rip), %rsi      # 0x1a4b2
callq 0x32c0
movq %rax, %rdi
movq 0xe2ef(%rip), %rsi      # 0x22fc8
callq 0x3330
movq 0xe2f3(%rip), %rdi      # 0x22fd8
movq 0xe2dc(%rip), %rsi      # 0x22fc8
callq 0x3330
popq %rax
retq
nopw %cs:(%rax,%rax)
// File: 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 %rax
movq 0xe2d0(%rip), %rdi      # 0x22fd8
leaq 0x57cb(%rip), %rsi      # 0x1a4da
callq 0x32c0
movq %rax, %rdi
movq 0xe2aa(%rip), %rsi      # 0x22fc8
callq 0x3330
movq 0xe2ae(%rip), %rdi      # 0x22fd8
leaq 0x57b0(%rip), %rsi      # 0x1a4e1
callq 0x32c0
movq %rax, %rdi
movq 0xe288(%rip), %rsi      # 0x22fc8
callq 0x3330
movq 0xe28c(%rip), %rdi      # 0x22fd8
leaq 0x57b6(%rip), %rsi      # 0x1a509
callq 0x32c0
movq %rax, %rdi
movq 0xe266(%rip), %rsi      # 0x22fc8
callq 0x3330
movq 0xe26a(%rip), %rdi      # 0x22fd8
leaq 0x57c1(%rip), %rsi      # 0x1a536
callq 0x32c0
movq %rax, %rdi
movq 0xe244(%rip), %rsi      # 0x22fc8
callq 0x3330
movq 0xe248(%rip), %rdi      # 0x22fd8
leaq 0x57d1(%rip), %rsi      # 0x1a568
callq 0x32c0
movq %rax, %rdi
movq 0xe222(%rip), %rsi      # 0x22fc8
callq 0x3330
movq 0xe226(%rip), %rdi      # 0x22fd8
leaq 0x57df(%rip), %rsi      # 0x1a598
callq 0x32c0
movq %rax, %rdi
movq 0xe200(%rip), %rsi      # 0x22fc8
callq 0x3330
movq 0xe204(%rip), %rdi      # 0x22fd8
leaq 0x57eb(%rip), %rsi      # 0x1a5c6
callq 0x32c0
movq %rax, %rdi
movq 0xe1de(%rip), %rsi      # 0x22fc8
callq 0x3330
movq 0xe1e2(%rip), %rdi      # 0x22fd8
leaq 0x5803(%rip), %rsi      # 0x1a600
callq 0x32c0
movq %rax, %rdi
movq 0xe1bc(%rip), %rsi      # 0x22fc8
callq 0x3330
movq 0xe1c0(%rip), %rdi      # 0x22fd8
leaq 0x5819(%rip), %rsi      # 0x1a638
callq 0x32c0
movq %rax, %rdi
movq 0xe19a(%rip), %rsi      # 0x22fc8
callq 0x3330
movq 0xe19e(%rip), %rdi      # 0x22fd8
leaq 0x5831(%rip), %rsi      # 0x1a672
callq 0x32c0
movq %rax, %rdi
movq 0xe178(%rip), %rsi      # 0x22fc8
callq 0x3330
movq 0xe17c(%rip), %rdi      # 0x22fd8
leaq 0x5847(%rip), %rsi      # 0x1a6aa
callq 0x32c0
movq %rax, %rdi
movq 0xe156(%rip), %rsi      # 0x22fc8
callq 0x3330
movq 0xe15a(%rip), %rdi      # 0x22fd8
movq 0xe143(%rip), %rsi      # 0x22fc8
callq 0x3330
popq %rax
retq
nopl (%rax)
// File: 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:
subq $0xb8, %rsp
movq %rdi, 0xb0(%rsp)
movq %rsi, 0xa8(%rsp)
leaq 0x90(%rsp), %rdi
callq 0x5710
movq 0xb0(%rsp), %rax
movq %rax, 0x20(%rsp)
leaq 0x6f(%rsp), %rdi
movq %rdi, 0x28(%rsp)
callq 0x3520
movq 0x28(%rsp), %rdx
leaq 0x27a1(%rip), %rsi      # 0x1a8ad
leaq 0x70(%rsp), %rdi
callq 0x18640
jmp 0x18118
movq 0x20(%rsp), %rdi
leaq 0x70(%rsp), %rsi
leaq 0x90(%rsp), %rdx
callq 0x19440
jmp 0x18131
leaq 0x70(%rsp), %rdi
callq 0x31c0
leaq 0x6f(%rsp), %rdi
callq 0x3350
movl $0x0, 0x58(%rsp)
movslq 0x58(%rsp), %rax
movq %rax, 0x18(%rsp)
leaq 0x90(%rsp), %rdi
callq 0xd220
movq %rax, %rcx
movq 0x18(%rsp), %rax
cmpq %rcx, %rax
jae 0x1824a
movq 0xa8(%rsp), %rax
movq %rax, 0x10(%rsp)
movslq 0x58(%rsp), %rsi
leaq 0x90(%rsp), %rdi
callq 0xeca0
movq %rax, %rsi
leaq 0x30(%rsp), %rdi
callq 0x3140
jmp 0x181a3
leaq 0x30(%rsp), %rdi
callq 0x19130
movsd %xmm0, 0x8(%rsp)
jmp 0x181b5
movq 0x10(%rsp), %rdi
movsd 0x8(%rsp), %xmm0
movsd %xmm0, 0x50(%rsp)
leaq 0x50(%rsp), %rsi
callq 0x12170
jmp 0x181d2
leaq 0x30(%rsp), %rdi
callq 0x31c0
movl 0x58(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x58(%rsp)
jmp 0x1814d
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x60(%rsp)
movl %eax, 0x5c(%rsp)
jmp 0x18214
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x60(%rsp)
movl %eax, 0x5c(%rsp)
leaq 0x70(%rsp), %rdi
callq 0x31c0
leaq 0x6f(%rsp), %rdi
callq 0x3350
jmp 0x1825f
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x60(%rsp)
movl %eax, 0x5c(%rsp)
jmp 0x1825f
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x60(%rsp)
movl %eax, 0x5c(%rsp)
leaq 0x30(%rsp), %rdi
callq 0x31c0
jmp 0x1825f
leaq 0x90(%rsp), %rdi
callq 0x6610
addq $0xb8, %rsp
retq
leaq 0x90(%rsp), %rdi
callq 0x6610
movq 0x60(%rsp), %rdi
callq 0x3510
nopw %cs:(%rax,%rax)
// File: 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:
subq $0xb8, %rsp
movq %rdi, 0xb0(%rsp)
movq %rsi, 0xa8(%rsp)
leaq 0x90(%rsp), %rdi
callq 0x5710
movq 0xb0(%rsp), %rax
movq %rax, 0x20(%rsp)
leaq 0x6f(%rsp), %rdi
movq %rdi, 0x28(%rsp)
callq 0x3520
movq 0x28(%rsp), %rdx
leaq 0x25e1(%rip), %rsi      # 0x1a8ad
leaq 0x70(%rsp), %rdi
callq 0x18640
jmp 0x182d8
movq 0x20(%rsp), %rdi
leaq 0x70(%rsp), %rsi
leaq 0x90(%rsp), %rdx
callq 0x19440
jmp 0x182f1
leaq 0x70(%rsp), %rdi
callq 0x31c0
leaq 0x6f(%rsp), %rdi
callq 0x3350
movl $0x0, 0x58(%rsp)
movslq 0x58(%rsp), %rax
movq %rax, 0x18(%rsp)
leaq 0x90(%rsp), %rdi
callq 0xd220
movq %rax, %rcx
movq 0x18(%rsp), %rax
cmpq %rcx, %rax
jae 0x18404
movq 0xa8(%rsp), %rax
movq %rax, 0x10(%rsp)
movslq 0x58(%rsp), %rsi
leaq 0x90(%rsp), %rdi
callq 0xeca0
movq %rax, %rsi
leaq 0x30(%rsp), %rdi
callq 0x3140
jmp 0x18363
leaq 0x30(%rsp), %rdi
callq 0x191d0
movl %eax, 0xc(%rsp)
jmp 0x18373
movq 0x10(%rsp), %rdi
movl 0xc(%rsp), %eax
movl %eax, 0x54(%rsp)
leaq 0x54(%rsp), %rsi
callq 0x18730
jmp 0x1838c
leaq 0x30(%rsp), %rdi
callq 0x31c0
movl 0x58(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x58(%rsp)
jmp 0x1830d
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x60(%rsp)
movl %eax, 0x5c(%rsp)
jmp 0x183ce
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x60(%rsp)
movl %eax, 0x5c(%rsp)
leaq 0x70(%rsp), %rdi
callq 0x31c0
leaq 0x6f(%rsp), %rdi
callq 0x3350
jmp 0x18419
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x60(%rsp)
movl %eax, 0x5c(%rsp)
jmp 0x18419
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x60(%rsp)
movl %eax, 0x5c(%rsp)
leaq 0x30(%rsp), %rdi
callq 0x31c0
jmp 0x18419
leaq 0x90(%rsp), %rdi
callq 0x6610
addq $0xb8, %rsp
retq
leaq 0x90(%rsp), %rdi
callq 0x6610
movq 0x60(%rsp), %rdi
callq 0x3510
// File: 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:
subq $0x98, %rsp
movq %rdi, 0x90(%rsp)
movq %rsi, 0x88(%rsp)
leaq 0x70(%rsp), %rdi
callq 0x5710
movq 0x90(%rsp), %rax
movq %rax, 0x20(%rsp)
leaq 0x4f(%rsp), %rdi
movq %rdi, 0x28(%rsp)
callq 0x3520
movq 0x28(%rsp), %rdx
leaq 0x2434(%rip), %rsi      # 0x1a8ad
leaq 0x50(%rsp), %rdi
callq 0x18640
jmp 0x18485
movq 0x20(%rsp), %rdi
leaq 0x50(%rsp), %rsi
leaq 0x70(%rsp), %rdx
callq 0x19440
jmp 0x1849b
leaq 0x50(%rsp), %rdi
callq 0x31c0
leaq 0x4f(%rsp), %rdi
callq 0x3350
movl $0x0, 0x38(%rsp)
movslq 0x38(%rsp), %rax
movq %rax, 0x18(%rsp)
leaq 0x70(%rsp), %rdi
callq 0xd220
movq %rax, %rcx
movq 0x18(%rsp), %rax
cmpq %rcx, %rax
jae 0x185ea
movslq 0x38(%rsp), %rsi
leaq 0x70(%rsp), %rdi
callq 0xeca0
movq %rax, %rdi
leaq 0x1c35(%rip), %rsi      # 0x1a12a
xorl %eax, %eax
movl %eax, %edx
callq 0x3570
cmpq $-0x1, %rax
je 0x185ba
movq 0x88(%rsp), %rax
movq %rax, 0x10(%rsp)
movslq 0x38(%rsp), %rsi
leaq 0x70(%rsp), %rdi
movq %rdi, (%rsp)
callq 0xeca0
movq %rax, %rdi
callq 0x31f0
movq (%rsp), %rdi
movq %rax, 0x8(%rsp)
movslq 0x38(%rsp), %rsi
callq 0xeca0
movq %rax, %rdi
leaq 0x1bdd(%rip), %rsi      # 0x1a12a
xorl %eax, %eax
movl %eax, %edx
callq 0x3570
movq 0x8(%rsp), %rcx
movq 0x10(%rsp), %rdi
notl %eax
addl %ecx, %eax
movl %eax, 0x34(%rsp)
leaq 0x34(%rsp), %rsi
callq 0x18730
jmp 0x18574
jmp 0x185d8
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x40(%rsp)
movl %eax, 0x3c(%rsp)
jmp 0x1859e
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x40(%rsp)
movl %eax, 0x3c(%rsp)
leaq 0x50(%rsp), %rdi
callq 0x31c0
leaq 0x4f(%rsp), %rdi
callq 0x3350
jmp 0x185fc
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x40(%rsp)
movl %eax, 0x3c(%rsp)
jmp 0x185fc
movq 0x88(%rsp), %rdi
movl $0x0, 0x30(%rsp)
leaq 0x30(%rsp), %rsi
callq 0x18730
jmp 0x185d6
jmp 0x185d8
jmp 0x185da
movl 0x38(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x38(%rsp)
jmp 0x184b7
leaq 0x70(%rsp), %rdi
callq 0x6610
addq $0x98, %rsp
retq
leaq 0x70(%rsp), %rdi
callq 0x6610
movq 0x40(%rsp), %rdi
callq 0x3510
// File: 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:
subq $0x1c8, %rsp            # imm = 0x1C8
movq %rdi, 0x10(%rsp)
movq %rdi, 0x1c0(%rsp)
movl $0x10, %edi
movl $0x8, %esi
callq 0x19610
movq 0x10(%rsp), %rsi
movl %eax, %edx
leaq 0x30(%rsp), %rdi
movq %rdi, 0x18(%rsp)
callq 0x3480
movq 0x18(%rsp), %rdi
leaq 0x1b8(%rsp), %rsi
callq 0x3270
jmp 0x1917d
movsd 0x1b8(%rsp), %xmm0
movsd %xmm0, 0x8(%rsp)
leaq 0x30(%rsp), %rdi
callq 0x3220
movsd 0x8(%rsp), %xmm0
addq $0x1c8, %rsp            # imm = 0x1C8
retq
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x28(%rsp)
movl %eax, 0x24(%rsp)
leaq 0x30(%rsp), %rdi
callq 0x3220
movq 0x28(%rsp), %rdi
callq 0x3510
nopw %cs:(%rax,%rax)
// File: 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:
subq $0x1c8, %rsp            # imm = 0x1C8
movq %rdi, 0x10(%rsp)
movq %rdi, 0x1c0(%rsp)
movl $0x10, %edi
movl $0x8, %esi
callq 0x19610
movq 0x10(%rsp), %rsi
movl %eax, %edx
leaq 0x30(%rsp), %rdi
movq %rdi, 0x18(%rsp)
callq 0x3480
movq 0x18(%rsp), %rdi
leaq 0x1bc(%rsp), %rsi
callq 0x31b0
jmp 0x1921d
movl 0x1bc(%rsp), %eax
movl %eax, 0xc(%rsp)
leaq 0x30(%rsp), %rdi
callq 0x3220
movl 0xc(%rsp), %eax
addq $0x1c8, %rsp            # imm = 0x1C8
retq
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x28(%rsp)
movl %eax, 0x24(%rsp)
leaq 0x30(%rsp), %rdi
callq 0x3220
movq 0x28(%rsp), %rdi
callq 0x3510
// File: 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:
subq $0x1c8, %rsp            # imm = 0x1C8
movq %rdi, (%rsp)
movq %rdi, %rax
movq %rax, 0x8(%rsp)
movq %rdi, 0x1c0(%rsp)
movl %esi, 0x1bc(%rsp)
movb $0x0, 0x1bb(%rsp)
callq 0x3410
leaq 0x40(%rsp), %rdi
callq 0x33f0
jmp 0x1929b
movl 0x1bc(%rsp), %esi
leaq 0x40(%rsp), %rdi
callq 0x34f0
jmp 0x192ae
leaq 0x10(%rsp), %rdi
leaq 0x40(%rsp), %rsi
callq 0x3300
jmp 0x192bf
movq (%rsp), %rdi
leaq 0x10(%rsp), %rsi
callq 0x33b0
leaq 0x10(%rsp), %rdi
callq 0x31c0
movb $0x1, 0x1bb(%rsp)
leaq 0x40(%rsp), %rdi
callq 0x30b0
testb $0x1, 0x1bb(%rsp)
jne 0x19328
jmp 0x1931f
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x38(%rsp)
movl %eax, 0x34(%rsp)
jmp 0x19335
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x38(%rsp)
movl %eax, 0x34(%rsp)
leaq 0x40(%rsp), %rdi
callq 0x30b0
jmp 0x19335
movq (%rsp), %rdi
callq 0x31c0
movq 0x8(%rsp), %rax
addq $0x1c8, %rsp            # imm = 0x1C8
retq
movq (%rsp), %rdi
callq 0x31c0
movq 0x38(%rsp), %rdi
callq 0x3510
nopl (%rax,%rax)
// File: 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:
subq $0x1d8, %rsp            # imm = 0x1D8
movq %rdi, 0x8(%rsp)
movq %rdi, %rax
movq %rax, 0x10(%rsp)
movq %rdi, 0x1d0(%rsp)
movsd %xmm0, 0x1c8(%rsp)
movb $0x0, 0x1c7(%rsp)
callq 0x3410
leaq 0x48(%rsp), %rdi
callq 0x33f0
jmp 0x1938e
movsd 0x1c8(%rsp), %xmm0
leaq 0x48(%rsp), %rdi
callq 0x3550
jmp 0x193a3
leaq 0x18(%rsp), %rdi
leaq 0x48(%rsp), %rsi
callq 0x3300
jmp 0x193b4
movq 0x8(%rsp), %rdi
leaq 0x18(%rsp), %rsi
callq 0x33b0
leaq 0x18(%rsp), %rdi
callq 0x31c0
movb $0x1, 0x1c7(%rsp)
leaq 0x48(%rsp), %rdi
callq 0x30b0
testb $0x1, 0x1c7(%rsp)
jne 0x1941f
jmp 0x19415
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x40(%rsp)
movl %eax, 0x3c(%rsp)
jmp 0x1942c
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x40(%rsp)
movl %eax, 0x3c(%rsp)
leaq 0x48(%rsp), %rdi
callq 0x30b0
jmp 0x1942c
movq 0x8(%rsp), %rdi
callq 0x31c0
movq 0x10(%rsp), %rax
addq $0x1d8, %rsp            # imm = 0x1D8
retq
movq 0x8(%rsp), %rdi
callq 0x31c0
movq 0x40(%rsp), %rdi
callq 0x3510
// File: 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:
subq $0xb8, %rsp
movq %rsi, 0x38(%rsp)
movq %rdi, 0xb0(%rsp)
movq %rsi, 0xa8(%rsp)
movq %rdx, 0xa0(%rsp)
movq $0x0, 0x98(%rsp)
movq 0xb0(%rsp), %rdi
xorl %eax, %eax
movl %eax, %edx
callq 0x3580
movq %rax, 0x90(%rsp)
cmpq $-0x1, 0x90(%rsp)
je 0x195d5
movq 0xa0(%rsp), %rax
movq %rax, 0x28(%rsp)
movq 0xb0(%rsp), %rsi
movq 0x98(%rsp), %rdx
movq 0x90(%rsp), %rcx
subq %rdx, %rcx
leaq 0x70(%rsp), %rdi
movq %rdi, 0x30(%rsp)
callq 0x3310
movq 0x28(%rsp), %rdi
movq 0x30(%rsp), %rsi
callq 0x19630
jmp 0x194e0
leaq 0x70(%rsp), %rdi
callq 0x31c0
movq 0x38(%rsp), %rsi
movq 0x90(%rsp), %rax
addq $0x1, %rax
movq %rax, 0x90(%rsp)
movq %rax, 0x98(%rsp)
movq 0xb0(%rsp), %rdi
movq 0x90(%rsp), %rdx
callq 0x3580
movq %rax, 0x90(%rsp)
cmpq $-0x1, 0x90(%rsp)
jne 0x195d0
movq 0xa0(%rsp), %rax
movq %rax, 0x18(%rsp)
movq 0xb0(%rsp), %rdi
movq %rdi, 0x8(%rsp)
movq 0x98(%rsp), %rax
movq %rax, 0x10(%rsp)
callq 0x3450
movq 0x8(%rsp), %rsi
movq 0x10(%rsp), %rdx
movq %rax, %rcx
leaq 0x40(%rsp), %rdi
movq %rdi, 0x20(%rsp)
callq 0x3310
movq 0x18(%rsp), %rdi
movq 0x20(%rsp), %rsi
callq 0x19630
jmp 0x19590
leaq 0x40(%rsp), %rdi
callq 0x31c0
jmp 0x195d0
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x68(%rsp)
movl %eax, 0x64(%rsp)
leaq 0x70(%rsp), %rdi
callq 0x31c0
jmp 0x19605
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x68(%rsp)
movl %eax, 0x64(%rsp)
leaq 0x40(%rsp), %rdi
callq 0x31c0
jmp 0x19605
jmp 0x19489
movq 0xa0(%rsp), %rdi
callq 0xd220
cmpq $0x0, %rax
jne 0x195fd
movq 0xa0(%rsp), %rdi
movq 0xb0(%rsp), %rsi
callq 0x12070
addq $0xb8, %rsp
retq
movq 0x68(%rsp), %rdi
callq 0x3510
nop
// File: 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 %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movq -0x10(%rbp), %rax
cmpb $0x0, (%rax)
je 0x3831
movq -0x10(%rbp), %rax
movsbl (%rax), %eax
cmpl $0x7c, %eax
je 0x383e
movq -0x10(%rbp), %rax
movq %rax, -0x8(%rbp)
jmp 0x3975
cmpb $0x0, 0x22af3(%rip)     # 0x26338
jne 0x388a
leaq 0x22aea(%rip), %rdi     # 0x26338
callq 0x3480
cmpl $0x0, %eax
je 0x388a
leaq 0x22ad1(%rip), %rdi     # 0x26330
callq 0x3210
movq 0x2275d(%rip), %rdi     # 0x25fc8
leaq 0x22abe(%rip), %rsi     # 0x26330
leaq 0x22a17(%rip), %rdx     # 0x26290
callq 0x3200
leaq 0x22ab3(%rip), %rdi     # 0x26338
callq 0x3190
movq -0x10(%rbp), %rsi
leaq 0x22a9b(%rip), %rdi     # 0x26330
callq 0x3380
leaq 0x22a8f(%rip), %rdi     # 0x26330
callq 0x34f0
xorb $-0x1, %al
testb $0x1, %al
jne 0x38ae
jmp 0x38b0
jmp 0x38cf
leaq 0x15751(%rip), %rdi     # 0x19008
leaq 0x15757(%rip), %rsi     # 0x19015
movl $0xad, %edx
leaq 0x15759(%rip), %rcx     # 0x19023
callq 0x31a0
leaq 0x22a5a(%rip), %rdi     # 0x26330
callq 0x33c0
cmpq $0x1, %rax
jbe 0x3965
leaq 0x22a44(%rip), %rdi     # 0x26330
xorl %eax, %eax
movl %eax, %esi
callq 0x30e0
movsbl (%rax), %eax
cmpl $0x7c, %eax
jne 0x3965
leaq 0x22a2c(%rip), %rdi     # 0x26330
callq 0x33c0
movq %rax, %rsi
subq $0x1, %rsi
leaq 0x22a19(%rip), %rdi     # 0x26330
callq 0x30e0
movsbl (%rax), %eax
cmpl $0x7c, %eax
jne 0x3965
leaq 0x22a05(%rip), %rdi     # 0x26330
callq 0x33c0
movq %rax, %rcx
subq $0x2, %rcx
leaq -0x18(%rbp), %rdi
leaq 0x229ee(%rip), %rsi     # 0x26330
movl $0x1, %edx
callq 0x3450
leaq 0x229dd(%rip), %rdi     # 0x26330
leaq -0x18(%rbp), %rsi
callq 0x31b0
leaq -0x18(%rbp), %rdi
callq 0x3518
leaq 0x229c4(%rip), %rdi     # 0x26330
callq 0x3340
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x20, %rsp
popq %rbp
retq
nop
// File: 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 %rbp
movq %rsp, %rbp
subq $0x90, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
callq 0x3810
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x58(%rbp)
leaq -0x19(%rbp), %rdi
movq %rdi, -0x50(%rbp)
callq 0x3470
movq -0x58(%rbp), %rsi
movq -0x50(%rbp), %rdx
leaq -0x18(%rbp), %rdi
callq 0x32b0
jmp 0x39c4
leaq 0x2292d(%rip), %rdi     # 0x262f8
leaq -0x18(%rbp), %rsi
callq 0x7080
movq %rax, -0x60(%rbp)
jmp 0x39da
movq -0x60(%rbp), %rax
movq %rax, -0x10(%rbp)
leaq 0x2290f(%rip), %rdi     # 0x262f8
callq 0x70b0
movq %rax, -0x38(%rbp)
leaq -0x10(%rbp), %rdi
leaq -0x38(%rbp), %rsi
callq 0x7050
movb %al, -0x61(%rbp)
leaq -0x18(%rbp), %rdi
callq 0x3518
leaq -0x19(%rbp), %rdi
callq 0x32a0
movb -0x61(%rbp), %al
testb $0x1, %al
jne 0x3a20
jmp 0x3afc
movq 0x22871(%rip), %rax     # 0x26298
movq %rax, -0x80(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x78(%rbp)
leaq -0x41(%rbp), %rdi
movq %rdi, -0x70(%rbp)
callq 0x3470
movq -0x78(%rbp), %rsi
movq -0x70(%rbp), %rdx
leaq -0x40(%rbp), %rdi
callq 0x32b0
jmp 0x3a53
leaq 0x2289e(%rip), %rdi     # 0x262f8
leaq -0x40(%rbp), %rsi
callq 0x70e0
movq %rax, -0x88(%rbp)
jmp 0x3a6c
movq -0x88(%rbp), %rax
movq -0x80(%rbp), %rcx
movq %rcx, (%rax)
leaq -0x40(%rbp), %rdi
callq 0x3518
leaq -0x41(%rbp), %rdi
callq 0x32a0
movq 0x22805(%rip), %rax     # 0x26298
addq $0x1, %rax
movq %rax, 0x227fa(%rip)     # 0x26298
jmp 0x3afc
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x28(%rbp)
movl %eax, -0x2c(%rbp)
jmp 0x3ac3
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x28(%rbp)
movl %eax, -0x2c(%rbp)
leaq -0x18(%rbp), %rdi
callq 0x3518
leaq -0x19(%rbp), %rdi
callq 0x32a0
jmp 0x3b05
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x28(%rbp)
movl %eax, -0x2c(%rbp)
jmp 0x3af1
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x28(%rbp)
movl %eax, -0x2c(%rbp)
leaq -0x40(%rbp), %rdi
callq 0x3518
leaq -0x41(%rbp), %rdi
callq 0x32a0
jmp 0x3b05
addq $0x90, %rsp
popq %rbp
retq
movq -0x28(%rbp), %rdi
callq 0x3460
nop
// File: 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
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq %rcx, -0x20(%rbp)
movq %r8, -0x28(%rbp)
cmpq $0x0, -0x8(%rbp)
je 0x3c75
jmp 0x3c94
leaq 0x15493(%rip), %rdi     # 0x1910f
leaq 0x15392(%rip), %rsi     # 0x19015
movl $0xe4, %edx
leaq 0x153b6(%rip), %rcx     # 0x19045
callq 0x31a0
movl $0x30, %edi
callq 0x3270
movq %rax, %rdi
movq %rdi, -0x38(%rbp)
callq 0x7310
movq -0x38(%rbp), %rax
movq %rax, -0x30(%rbp)
movq -0x8(%rbp), %rsi
movq -0x30(%rbp), %rdi
callq 0x3380
movq -0x30(%rbp), %rax
movb $0x0, 0x8(%rax)
movq -0x30(%rbp), %rax
movb $0x1, 0x28(%rax)
cmpq $0x0, -0x10(%rbp)
je 0x3ce7
movq -0x30(%rbp), %rdi
addq $0x10, %rdi
leaq -0x10(%rbp), %rsi
callq 0x7340
cmpq $0x0, -0x18(%rbp)
je 0x3cff
movq -0x30(%rbp), %rdi
addq $0x10, %rdi
leaq -0x18(%rbp), %rsi
callq 0x7340
cmpq $0x0, -0x20(%rbp)
je 0x3d17
movq -0x30(%rbp), %rdi
addq $0x10, %rdi
leaq -0x20(%rbp), %rsi
callq 0x7340
cmpq $0x0, -0x28(%rbp)
je 0x3d2f
movq -0x30(%rbp), %rdi
addq $0x10, %rdi
leaq -0x28(%rbp), %rsi
callq 0x7340
leaq 0x2260a(%rip), %rdi     # 0x26340
leaq -0x30(%rbp), %rsi
callq 0x7340
addq $0x40, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)