LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_cpp_makefile_star2_O1/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
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x1b0, %rsp            # imm = 0x1B0
movq %rsi, %r15
movq (%rdi), %rbx
leaq -0x1c8(%rbp), %rdi
callq 0x20a0
movq (%r15), %r14
movq 0x8(%r15), %r12
cmpq %r12, %r14
je 0x382d
leaq -0x1c8(%rbp), %r15
movl $0x19, %ecx
movq %rbx, %rdi
movq %r15, %rsi
movq %r14, %rdx
callq 0x38b4
addq $0x20, %r14
cmpq %r12, %r14
jne 0x3811
leaq -0x1b0(%rbp), %rsi
leaq -0x40(%rbp), %rdi
callq 0x2170
leaq -0x30(%rbp), %rbx
movq -0x10(%rbx), %rdi
callq 0x2160
movq -0x10(%rbx), %rdi
cmpq %rbx, %rdi
je 0x3858
callq 0x2100
movq 0x4759(%rip), %rsi      # 0x7fb8
leaq -0x1c8(%rbp), %rdi
callq 0x20c0
leaq -0x148(%rbp), %rdi
callq 0x2040
addq $0x1b0, %rsp            # imm = 0x1B0
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
jmp 0x3889
movq %rax, %rbx
movq 0x4725(%rip), %rsi      # 0x7fb8
leaq -0x1c8(%rbp), %rdi
callq 0x20c0
leaq -0x148(%rbp), %rdi
callq 0x2040
movq %rbx, %rdi
callq 0x21a0
nop
// File: /workspace/github_cpp_makefile_star2_O1/ashagraev[P]covariation/main.cpp
// Function: TTypedCovariationCalculator<TKahanAccumulator>::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
incq 0x8(%rdi)
movapd %xmm0, %xmm2
subsd 0x18(%rdi), %xmm2
movsd 0x10(%rdi), %xmm3
movsd 0x20(%rdi), %xmm4
movapd %xmm3, %xmm5
addsd %xmm2, %xmm5
movapd %xmm5, %xmm6
subsd %xmm3, %xmm6
subsd %xmm2, %xmm6
movsd %xmm6, 0x18(%rdi)
movsd %xmm5, 0x10(%rdi)
mulsd %xmm1, %xmm0
subsd 0x28(%rdi), %xmm1
movapd %xmm4, %xmm2
addsd %xmm1, %xmm2
movapd %xmm2, %xmm3
subsd %xmm4, %xmm3
subsd %xmm1, %xmm3
movsd %xmm3, 0x28(%rdi)
movsd %xmm2, 0x20(%rdi)
subsd 0x38(%rdi), %xmm0
movsd 0x30(%rdi), %xmm1
movapd %xmm1, %xmm2
addsd %xmm0, %xmm2
movapd %xmm2, %xmm3
subsd %xmm1, %xmm3
subsd %xmm0, %xmm3
movsd %xmm3, 0x38(%rdi)
movsd %xmm2, 0x30(%rdi)
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O1/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 0x8(%rdi), %rax
incq %rax
movq %rax, 0x8(%rdi)
movsd 0x10(%rdi), %xmm2
movapd %xmm0, %xmm3
subsd %xmm2, %xmm3
movq %rax, %xmm4
punpckldq 0x1f5d(%rip), %xmm4 # xmm4 = xmm4[0],mem[0],xmm4[1],mem[1]
subpd 0x1f65(%rip), %xmm4     # 0x5050
movapd %xmm4, %xmm5
unpckhpd %xmm4, %xmm5            # xmm5 = xmm5[1],xmm4[1]
addsd %xmm4, %xmm5
divsd %xmm5, %xmm3
addsd %xmm2, %xmm3
movsd %xmm3, 0x10(%rdi)
subsd %xmm3, %xmm0
movsd 0x18(%rdi), %xmm2
subsd %xmm2, %xmm1
mulsd %xmm1, %xmm0
addsd 0x20(%rdi), %xmm0
movsd %xmm0, 0x20(%rdi)
divsd %xmm5, %xmm1
addsd %xmm2, %xmm1
movsd %xmm1, 0x18(%rdi)
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O1/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
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x28, %rsp
movq %rcx, -0x30(%rbp)
movq %rdx, %r12
movq %rsi, %rbx
leaq 0x18(%rsi), %r15
leaq -0x50(%rbp), %r13
movq %r13, %rdi
movq %r15, %rsi
callq 0x2170
movq (%r13), %rdi
movq 0x8(%r13), %r13
leaq -0x40(%rbp), %r14
cmpq %r14, %rdi
je 0x38f8
callq 0x2100
addq $0x10, %rbx
movq (%r12), %rsi
movq 0x8(%r12), %rdx
movq %rbx, %rdi
callq 0x2130
leaq -0x50(%rbp), %r12
movq %r12, %rdi
movq %r15, %rsi
callq 0x2170
movq (%r12), %rdi
movq 0x8(%r12), %r15
cmpq %r14, %rdi
je 0x392f
callq 0x2100
addq -0x30(%rbp), %r13
cmpq %r13, %r15
jae 0x3957
leaq 0x175a(%rip), %r14      # 0x5099
movl $0x1, %edx
movq %rbx, %rdi
movq %r14, %rsi
callq 0x2130
incq %r15
cmpq %r13, %r15
jb 0x393f
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O1/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:
movq (%rdi), %rcx
movq 0x8(%rdi), %rdx
movq %rdx, %rax
subq %rcx, %rax
sarq $0x3, %rax
xorpd %xmm0, %xmm0
xorpd %xmm1, %xmm1
cmpq %rcx, %rdx
je 0x6a1c
cmpq $0x1, %rax
movq %rax, %rsi
adcq $0x0, %rsi
xorl %edi, %edi
addsd (%rcx,%rdi,8), %xmm1
incq %rdi
cmpq %rdi, %rsi
jne 0x6a0f
cmpq %rcx, %rdx
je 0x6a70
movq %rax, %xmm0
punpckldq 0x68c2(%rip), %xmm0 # xmm0 = xmm0[0],mem[0],xmm0[1],mem[1]
subpd 0x68ca(%rip), %xmm0     # 0xd300
movapd %xmm0, %xmm2
unpckhpd %xmm0, %xmm2            # xmm2 = xmm2[1],xmm0[1]
addsd %xmm0, %xmm2
divsd %xmm2, %xmm1
cmpq $0x1, %rax
movq %rax, %rdx
adcq $0x0, %rdx
xorpd %xmm0, %xmm0
xorl %esi, %esi
movsd (%rcx,%rsi,8), %xmm2
subsd %xmm1, %xmm2
mulsd %xmm2, %xmm2
addsd %xmm2, %xmm0
incq %rsi
cmpq %rsi, %rdx
jne 0x6a57
decq %rax
movq %rax, %xmm1
punpckldq 0x6870(%rip), %xmm1 # xmm1 = xmm1[0],mem[0],xmm1[1],mem[1]
subpd 0x6878(%rip), %xmm1     # 0xd300
movapd %xmm1, %xmm2
unpckhpd %xmm1, %xmm2            # xmm2 = xmm2[1],xmm1[1]
addsd %xmm1, %xmm2
divsd %xmm2, %xmm0
retq
// File: /workspace/github_cpp_makefile_star2_O1/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:
movq (%rdi), %rcx
movq 0x8(%rdi), %rdx
movq %rdx, %rax
subq %rcx, %rax
sarq $0x3, %rax
cmpq %rcx, %rdx
je 0x6acf
cmpq $0x1, %rax
movq %rax, %rdx
adcq $0x0, %rdx
xorpd %xmm0, %xmm0
xorl %esi, %esi
addsd (%rcx,%rsi,8), %xmm0
incq %rsi
cmpq %rsi, %rdx
jne 0x6ac0
jmp 0x6ad3
xorpd %xmm0, %xmm0
movq %rax, %xmm1
punpckldq 0x6810(%rip), %xmm1 # xmm1 = xmm1[0],mem[0],xmm1[1],mem[1]
subpd 0x6818(%rip), %xmm1     # 0xd300
movapd %xmm1, %xmm2
unpckhpd %xmm1, %xmm2            # xmm2 = xmm2[1],xmm1[1]
addsd %xmm1, %xmm2
divsd %xmm2, %xmm0
retq
// File: /workspace/github_cpp_makefile_star2_O1/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:
movq (%rdi), %rax
movq 0x8(%rdi), %rcx
subq %rax, %rcx
je 0x6b25
sarq $0x3, %rcx
cmpq $0x1, %rcx
adcq $0x0, %rcx
xorpd %xmm0, %xmm0
xorl %edx, %edx
addsd (%rax,%rdx,8), %xmm0
incq %rdx
cmpq %rdx, %rcx
jne 0x6b17
retq
xorps %xmm0, %xmm0
retq
// File: /workspace/github_cpp_makefile_star2_O1/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:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x250, %rsp            # imm = 0x250
movq %rsi, %rbx
movq %rdi, %r14
leaq 0x18(%rsp), %r12
movq %r12, -0x10(%r12)
xorl %eax, %eax
movq %rax, -0x8(%r12)
movb %al, (%r12)
leaq 0x38(%rsp), %r13
movq %r13, -0x10(%r13)
movq %rax, -0x8(%r13)
movb %al, (%r13)
movq (%rdi), %rsi
leaq 0x48(%rsp), %rdi
movl $0x8, %edx
callq 0x3470
leaq 0xc0(%rsp), %rdi
callq 0x3080
testb %al, %al
je 0x6c98
movq 0x48(%rsp), %rax
movq -0x18(%rax), %rax
cmpl $0x0, 0x68(%rsp,%rax)
jne 0x6c45
leaq (%rsp,%rax), %rdi
addq $0x48, %rdi
leaq 0x48(%rsp), %r14
leaq 0x8(%rsp), %r15
movl $0xa, %esi
callq 0x3260
movsbl %al, %edx
movq %r14, %rdi
movq %r15, %rsi
callq 0x3480
cmpq $0x0, 0x10(%rsp)
je 0x6c2e
movq %rbx, %rdi
movq %r15, %rsi
callq 0x57be
movl $0x0, (%rax)
movq 0x48(%rsp), %rax
movq -0x18(%rax), %rax
leaq (%rsp,%rax), %rdi
addq $0x48, %rdi
cmpl $0x0, 0x20(%rdi)
je 0x6bfd
leaq 0x48(%rsp), %rdi
callq 0x3070
leaq 0x48(%rsp), %rdi
callq 0x3090
movq 0x28(%rsp), %rdi
cmpq %r13, %rdi
je 0x6c70
movq 0x38(%rsp), %rsi
incq %rsi
callq 0x3280
movq 0x8(%rsp), %rdi
cmpq %r12, %rdi
je 0x6c87
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x3280
addq $0x250, %rsp            # imm = 0x250
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
movq 0xb339(%rip), %rdi      # 0x11fd8
leaq 0x667a(%rip), %rsi      # 0xd320
movl $0xf, %edx
callq 0x32c0
movq (%r14), %rsi
movq 0x8(%r14), %rdx
movq 0xb31a(%rip), %rdi      # 0x11fd8
callq 0x32c0
movq %rax, %rbx
leaq 0x6663(%rip), %rsi      # 0xd330
movl $0xc, %edx
movq %rax, %rdi
callq 0x32c0
movq %rbx, %rdi
callq 0x3120
movl $0x1, %edi
callq 0x32e0
movq %rax, %rbx
jmp 0x6d00
jmp 0x6cf3
movq %rax, %rbx
leaq 0x48(%rsp), %rdi
callq 0x3090
movq 0x28(%rsp), %rdi
cmpq %r13, %rdi
je 0x6d17
movq 0x38(%rsp), %rsi
incq %rsi
callq 0x3280
movq 0x8(%rsp), %rdi
cmpq %r12, %rdi
je 0x6d2e
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x3280
movq %rbx, %rdi
callq 0x3450
nop
// File: /workspace/github_cpp_makefile_star2_O1/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:
movq (%rdi), %rax
movq 0x8(%rdi), %rcx
subq %rax, %rcx
je 0x7a78
sarq $0x3, %rcx
cmpq $0x1, %rcx
adcq $0x0, %rcx
movsd 0x5933(%rip), %xmm1     # 0xd388
xorl %r8d, %r8d
movsd (%rax,%r8,8), %xmm0
ucomisd %xmm0, %xmm1
cmoval %r8d, %edi
minsd %xmm1, %xmm0
incq %r8
movapd %xmm0, %xmm1
cmpq %r8, %rcx
jne 0x7a58
jmp 0x7a80
movsd 0x5908(%rip), %xmm0     # 0xd388
movsd %xmm0, (%rsi)
movl %edi, (%rdx)
retq
// File: /workspace/github_cpp_makefile_star2_O1/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:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x30, %rsp
movq %rsi, %r14
movq %rdi, %rbx
xorpd %xmm0, %xmm0
movapd %xmm0, (%rsp)
movq $0x0, 0x10(%rsp)
movq (%rsi), %rdx
movq 0x8(%rsi), %rax
cmpq %rax, %rdx
sete %sil
movq %rdx, %rcx
addq $0x8, %rcx
cmpq %rax, %rcx
sete %dil
orb %sil, %dil
je 0x7d6e
movq %rdx, %rsi
jmp 0x7d8a
movsd (%rcx), %xmm0
ucomisd (%rdx), %xmm0
movq %rcx, %rsi
ja 0x7d7e
movq %rdx, %rsi
addq $0x8, %rcx
movq %rsi, %rdx
cmpq %rax, %rcx
jne 0x7d6e
movq (%r14), %rax
cmpq %rax, 0x8(%r14)
je 0x7e3a
movsd (%rsi), %xmm2
xorpd %xmm0, %xmm0
xorl %r13d, %r13d
movsd 0x55f6(%rip), %xmm3     # 0xd3a0
movq %rsp, %r15
leaq 0x28(%rsp), %r12
movsd %xmm2, 0x18(%rsp)
movsd %xmm0, 0x20(%rsp)
movapd %xmm2, %xmm0
subsd (%rax,%r13,8), %xmm0
addsd %xmm3, %xmm0
movsd %xmm0, 0x28(%rsp)
movq 0x8(%rsp), %rsi
cmpq 0x10(%rsp), %rsi
je 0x7ded
movsd %xmm0, (%rsi)
addq $0x8, %rsi
movq %rsi, 0x8(%rsp)
jmp 0x7df8
movq %r15, %rdi
movq %r12, %rdx
callq 0x8f10
movq (%r14), %rax
movq 0x8(%r14), %rcx
movsd 0x18(%rsp), %xmm2
movapd %xmm2, %xmm0
subsd (%rax,%r13,8), %xmm0
movsd 0x5589(%rip), %xmm3     # 0xd3a0
addsd %xmm3, %xmm0
movsd 0x20(%rsp), %xmm1
addsd %xmm0, %xmm1
movapd %xmm1, %xmm0
incq %r13
subq %rax, %rcx
sarq $0x3, %rcx
cmpq %r13, %rcx
ja 0x7db8
jmp 0x7e3e
xorpd %xmm0, %xmm0
movq (%rsp), %rdi
cmpq %rdi, 0x8(%rsp)
je 0x7ed2
xorpd %xmm2, %xmm2
xorl %r15d, %r15d
leaq 0x28(%rsp), %r14
movapd %xmm0, %xmm1
movsd %xmm0, 0x20(%rsp)
movsd (%rdi,%r15,8), %xmm0
divsd %xmm1, %xmm0
movsd %xmm2, 0x18(%rsp)
addsd %xmm2, %xmm0
movsd %xmm0, 0x28(%rsp)
movq 0x8(%rbx), %rsi
cmpq 0x10(%rbx), %rsi
je 0x7e95
movsd %xmm0, (%rsi)
addq $0x8, %rsi
movq %rsi, 0x8(%rbx)
jmp 0x7ea0
movq %rbx, %rdi
movq %r14, %rdx
callq 0x8f10
movq (%rsp), %rdi
movq 0x8(%rsp), %rax
movsd (%rdi,%r15,8), %xmm0
movsd 0x20(%rsp), %xmm1
divsd %xmm1, %xmm0
movsd 0x18(%rsp), %xmm2
addsd %xmm0, %xmm2
incq %r15
subq %rdi, %rax
sarq $0x3, %rax
cmpq %r15, %rax
ja 0x7e63
testq %rdi, %rdi
je 0x7ee4
movq 0x10(%rsp), %rsi
subq %rdi, %rsi
callq 0x3280
addq $0x30, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
jmp 0x7ef4
movq %rax, %rbx
movq (%rsp), %rdi
testq %rdi, %rdi
je 0x7f0d
movq 0x10(%rsp), %rsi
subq %rdi, %rsi
callq 0x3280
movq %rbx, %rdi
callq 0x3450
// File: /workspace/github_cpp_makefile_star2_O1/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:
pushq %rbx
movq %rdi, %rbx
callq 0x30a0
movq (%rbx), %rdx
movq 0x8(%rbx), %rcx
subq %rdx, %rcx
je 0x7f5c
cvtsi2sd %eax, %xmm0
divsd 0x5472(%rip), %xmm0     # 0xd3a8
sarq $0x3, %rcx
cmpq $0x1, %rcx
adcq $0x0, %rcx
xorl %eax, %eax
movsd (%rdx,%rax,8), %xmm1
ucomisd %xmm0, %xmm1
ja 0x7f5e
incq %rax
cmpq %rax, %rcx
jne 0x7f44
movq %rcx, %rax
jmp 0x7f5e
xorl %eax, %eax
popq %rbx
retq
// File: /workspace/github_cpp_makefile_star2_O1/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:
movq (%rdi), %rax
movq 0x8(%rdi), %rcx
subq %rax, %rcx
je 0x7f9f
sarq $0x3, %rcx
cmpq $0x1, %rcx
adcq $0x0, %rcx
xorpd %xmm1, %xmm1
xorl %r8d, %r8d
movsd (%rax,%r8,8), %xmm0
ucomisd %xmm1, %xmm0
cmoval %r8d, %edi
maxsd %xmm1, %xmm0
incq %r8
movapd %xmm0, %xmm1
cmpq %r8, %rcx
jne 0x7f7f
jmp 0x7fa3
xorpd %xmm0, %xmm0
movsd %xmm0, (%rsi)
movl %edi, (%rdx)
retq
// File: /workspace/github_cpp_makefile_star2_O1/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 %r14
pushq %rbx
pushq %rax
movq %rsi, %r14
movq %rdi, %rbx
movq (%rsi), %rdi
movq 0x8(%rsi), %rsi
cmpq %rsi, %rdi
sete %cl
movq %rdi, %rax
addq $0x8, %rax
cmpq %rsi, %rax
sete %dl
orb %cl, %dl
movq %rdi, %rdx
jne 0x8a66
movq %rdi, %rcx
movsd (%rax), %xmm0
ucomisd (%rcx), %xmm0
movq %rax, %rdx
ja 0x8a5a
movq %rcx, %rdx
addq $0x8, %rax
movq %rdx, %rcx
cmpq %rsi, %rax
jne 0x8a4a
callq 0x9517
subq (%r14), %rax
shrq $0x3, %rax
movl %eax, 0x4(%rsp)
movq 0x8(%rbx), %rsi
cmpq 0x10(%rbx), %rsi
je 0x8a8c
movl %eax, (%rsi)
addq $0x4, %rsi
movq %rsi, 0x8(%rbx)
jmp 0x8a99
leaq 0x4(%rsp), %rdx
movq %rbx, %rdi
callq 0x619a
movslq 0x4(%rsp), %rax
movq (%r14), %rdi
movabsq $-0x4010000000000000, %rcx # imm = 0xBFF0000000000000
movq %rcx, (%rdi,%rax,8)
movq 0x8(%r14), %rsi
cmpq %rsi, %rdi
sete %cl
movq %rdi, %rax
addq $0x8, %rax
cmpq %rsi, %rax
sete %dl
orb %cl, %dl
movq %rdi, %rdx
jne 0x8aec
movq %rdi, %rcx
movsd (%rax), %xmm0
ucomisd (%rcx), %xmm0
movq %rax, %rdx
ja 0x8ae0
movq %rcx, %rdx
addq $0x8, %rax
movq %rdx, %rcx
cmpq %rsi, %rax
jne 0x8ad0
callq 0x9517
subq (%r14), %rax
shrq $0x3, %rax
movl %eax, 0x4(%rsp)
movq 0x8(%rbx), %rsi
cmpq 0x10(%rbx), %rsi
je 0x8b12
movl %eax, (%rsi)
addq $0x4, %rsi
movq %rsi, 0x8(%rbx)
jmp 0x8b1f
leaq 0x4(%rsp), %rdx
movq %rbx, %rdi
callq 0x619a
addq $0x8, %rsp
popq %rbx
popq %r14
retq
nop
// File: /workspace/github_cpp_makefile_star2_O1/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 %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x68, %rsp
movq %rsi, %rbx
movq %rdi, %r14
xorps %xmm0, %xmm0
movaps %xmm0, (%rsp)
movq $0x0, 0x10(%rsp)
leaq 0x58(%rsp), %r15
movq %r15, -0x10(%r15)
leaq 0x287c(%rip), %rsi      # 0xd8db
leaq 0x2876(%rip), %rdx      # 0xd8dc
leaq 0x48(%rsp), %rdi
callq 0xb4c8
leaq 0x48(%rsp), %rsi
movq %rsp, %rdx
movq %r14, %rdi
callq 0xbdac
movq 0x48(%rsp), %rdi
cmpq %r15, %rdi
je 0xb097
movq 0x58(%rsp), %rsi
incq %rsi
callq 0x3280
movq (%rsp), %rax
cmpq %rax, 0x8(%rsp)
je 0xb13a
movl $0x8, %r13d
leaq 0x38(%rsp), %r12
xorl %ebp, %ebp
leaq 0x28(%rsp), %r14
leaq 0x20(%rsp), %r15
movq %r12, 0x28(%rsp)
movq -0x8(%rax,%r13), %rsi
movq (%rax,%r13), %rdx
addq %rsi, %rdx
movq %r14, %rdi
callq 0x5c1c
movq %r14, %rdi
callq 0xbad4
movsd %xmm0, 0x20(%rsp)
movq 0x8(%rbx), %rsi
cmpq 0x10(%rbx), %rsi
je 0xb0fc
movsd %xmm0, (%rsi)
addq $0x8, %rsi
movq %rsi, 0x8(%rbx)
jmp 0xb107
movq %rbx, %rdi
movq %r15, %rdx
callq 0x8f10
movq 0x28(%rsp), %rdi
cmpq %r12, %rdi
je 0xb11e
movq 0x38(%rsp), %rsi
incq %rsi
callq 0x3280
incq %rbp
movq (%rsp), %rax
movq 0x8(%rsp), %rcx
subq %rax, %rcx
sarq $0x5, %rcx
addq $0x20, %r13
cmpq %rbp, %rcx
ja 0xb0bd
movq %rsp, %rdi
callq 0x5a76
addq $0x68, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
movq 0x48(%rsp), %rdi
cmpq %r15, %rdi
je 0xb186
movq 0x58(%rsp), %rsi
jmp 0xb17e
jmp 0xb167
movq %rax, %rbx
jmp 0xb186
movq %rax, %rbx
movq 0x28(%rsp), %rdi
cmpq %r12, %rdi
je 0xb186
movq 0x38(%rsp), %rsi
incq %rsi
callq 0x3280
movq %rsp, %rdi
callq 0x5a76
movq %rbx, %rdi
callq 0x3450
// File: /workspace/github_cpp_makefile_star2_O1/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 %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x68, %rsp
movq %rsi, %rbx
movq %rdi, %r14
xorps %xmm0, %xmm0
movaps %xmm0, 0x10(%rsp)
movq $0x0, 0x20(%rsp)
leaq 0x58(%rsp), %r15
movq %r15, -0x10(%r15)
leaq 0x2710(%rip), %rsi      # 0xd8db
leaq 0x270a(%rip), %rdx      # 0xd8dc
leaq 0x48(%rsp), %rdi
callq 0xb4c8
leaq 0x48(%rsp), %rsi
leaq 0x10(%rsp), %rdx
movq %r14, %rdi
callq 0xbdac
movq 0x48(%rsp), %rdi
cmpq %r15, %rdi
je 0xb205
movq 0x58(%rsp), %rsi
incq %rsi
callq 0x3280
movq 0x10(%rsp), %rax
cmpq %rax, 0x18(%rsp)
je 0xb2a6
movl $0x8, %r13d
leaq 0x38(%rsp), %r12
xorl %ebp, %ebp
leaq 0x28(%rsp), %r14
leaq 0xc(%rsp), %r15
movq %r12, 0x28(%rsp)
movq -0x8(%rax,%r13), %rsi
movq (%rax,%r13), %rdx
addq %rsi, %rdx
movq %r14, %rdi
callq 0x5c1c
movq %r14, %rdi
callq 0xbb60
movl %eax, 0xc(%rsp)
movq 0x8(%rbx), %rsi
cmpq 0x10(%rbx), %rsi
je 0xb267
movl %eax, (%rsi)
addq $0x4, %rsi
movq %rsi, 0x8(%rbx)
jmp 0xb272
movq %rbx, %rdi
movq %r15, %rdx
callq 0xb558
movq 0x28(%rsp), %rdi
cmpq %r12, %rdi
je 0xb289
movq 0x38(%rsp), %rsi
incq %rsi
callq 0x3280
incq %rbp
movq 0x10(%rsp), %rax
movq 0x18(%rsp), %rcx
subq %rax, %rcx
sarq $0x5, %rcx
addq $0x20, %r13
cmpq %rbp, %rcx
ja 0xb22c
leaq 0x10(%rsp), %rdi
callq 0x5a76
addq $0x68, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
movq 0x48(%rsp), %rdi
cmpq %r15, %rdi
je 0xb2f4
movq 0x58(%rsp), %rsi
jmp 0xb2ec
jmp 0xb2d5
movq %rax, %rbx
jmp 0xb2f4
movq %rax, %rbx
movq 0x28(%rsp), %rdi
cmpq %r12, %rdi
je 0xb2f4
movq 0x38(%rsp), %rsi
incq %rsi
callq 0x3280
leaq 0x10(%rsp), %rdi
callq 0x5a76
movq %rbx, %rdi
callq 0x3450
// File: /workspace/github_cpp_makefile_star2_O1/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)
movq $0x0, 0x20(%rsp)
leaq 0x38(%rsp), %r15
movq %r15, -0x10(%r15)
leaq 0x25a0(%rip), %rsi      # 0xd8db
leaq 0x259a(%rip), %rdx      # 0xd8dc
leaq 0x28(%rsp), %rdi
callq 0xb4c8
leaq 0x28(%rsp), %rsi
leaq 0x10(%rsp), %rdx
movq %r14, %rdi
callq 0xbdac
movq 0x28(%rsp), %rdi
cmpq %r15, %rdi
je 0xb375
movq 0x38(%rsp), %rsi
incq %rsi
callq 0x3280
movq 0x10(%rsp), %rdi
cmpq %rdi, 0x18(%rsp)
je 0xb43c
xorl %r12d, %r12d
leaq 0x1dab(%rip), %r14      # 0xd13a
leaq 0xc(%rsp), %r15
xorl %r13d, %r13d
addq %r12, %rdi
movl $0x1, %ecx
movq %r14, %rsi
xorl %edx, %edx
callq 0x3430
cmpq $-0x1, %rax
je 0xb3e1
movq 0x10(%rsp), %rdi
movl 0x8(%rdi,%r12), %ebp
addq %r12, %rdi
movl $0x1, %ecx
movq %r14, %rsi
xorl %edx, %edx
callq 0x3430
notl %eax
addl %ebp, %eax
movl %eax, 0xc(%rsp)
movq 0x8(%rbx), %rsi
cmpq 0x10(%rbx), %rsi
je 0xb403
movl %eax, (%rsi)
jmp 0xb3f9
movl $0x0, 0xc(%rsp)
movq 0x8(%rbx), %rsi
cmpq 0x10(%rbx), %rsi
je 0xb410
movl $0x0, (%rsi)
addq $0x4, %rsi
movq %rsi, 0x8(%rbx)
jmp 0xb41b
movq %rbx, %rdi
movq %r15, %rdx
callq 0xb558
jmp 0xb41b
movq %rbx, %rdi
movq %r15, %rdx
callq 0xb558
incq %r13
movq 0x10(%rsp), %rdi
movq 0x18(%rsp), %rax
subq %rdi, %rax
sarq $0x5, %rax
addq $0x20, %r12
cmpq %r13, %rax
ja 0xb397
leaq 0x10(%rsp), %rdi
callq 0x5a76
addq $0x48, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
movq 0x28(%rsp), %rdi
cmpq %r15, %rdi
je 0xb478
movq 0x38(%rsp), %rsi
incq %rsi
callq 0x3280
jmp 0xb478
jmp 0xb475
jmp 0xb475
movq %rax, %rbx
leaq 0x10(%rsp), %rdi
callq 0x5a76
movq %rbx, %rdi
callq 0x3450
// File: /workspace/github_cpp_makefile_star2_O1/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
movq %rbx, %rdi
movl $0x18, %edx
callq 0x33d0
leaq 0x10(%rsp), %rsi
movq %rbx, %rdi
callq 0x3190
movsd 0x10(%rsp), %xmm0
movsd %xmm0, 0x8(%rsp)
movq 0x6497(%rip), %rsi      # 0x11fa8
leaq 0x18(%rsp), %rdi
callq 0x31f0
leaq 0x98(%rsp), %rdi
callq 0x30d0
movsd 0x8(%rsp), %xmm0
addq $0x1a0, %rsp            # imm = 0x1A0
popq %rbx
retq
movq %rax, %rbx
movq 0x6467(%rip), %rsi      # 0x11fa8
leaq 0x18(%rsp), %rdi
callq 0x31f0
leaq 0x98(%rsp), %rdi
callq 0x30d0
movq %rbx, %rdi
callq 0x3450
// File: /workspace/github_cpp_makefile_star2_O1/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
movq %rbx, %rdi
movl $0x18, %edx
callq 0x33d0
leaq 0x4(%rsp), %rsi
movq %rbx, %rdi
callq 0x3180
movl 0x4(%rsp), %ebx
movq 0x6413(%rip), %rsi      # 0x11fa8
leaq 0x8(%rsp), %rdi
callq 0x31f0
leaq 0x88(%rsp), %rdi
callq 0x30d0
movl %ebx, %eax
addq $0x190, %rsp            # imm = 0x190
popq %rbx
retq
movq %rax, %rbx
movq 0x63e7(%rip), %rsi      # 0x11fa8
leaq 0x8(%rsp), %rdi
callq 0x31f0
leaq 0x88(%rsp), %rdi
callq 0x30d0
movq %rbx, %rdi
callq 0x3450
// File: /workspace/github_cpp_makefile_star2_O1/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 %r15
pushq %r14
pushq %rbx
subq $0x198, %rsp            # imm = 0x198
movl %esi, %ebp
movq %rdi, %rbx
leaq 0x10(%rdi), %r15
movq %r15, (%rdi)
movq $0x0, 0x8(%rdi)
movb $0x0, 0x10(%rdi)
leaq 0x20(%rsp), %rdi
callq 0x3320
leaq 0x20(%rsp), %rdi
movl %ebp, %esi
callq 0x3420
leaq 0x28(%rsp), %rsi
movq %rsp, %rdi
callq 0x33c0
movq %rsp, %r14
movq %rbx, %rdi
movq %r14, %rsi
callq 0x32f0
movq (%r14), %rdi
leaq 0x10(%rsp), %rax
cmpq %rax, %rdi
je 0xbc50
movq 0x10(%rsp), %rsi
incq %rsi
callq 0x3280
movq 0x6379(%rip), %rsi      # 0x11fd0
leaq 0x20(%rsp), %rdi
callq 0x3140
leaq 0x90(%rsp), %rdi
callq 0x30d0
movq %rbx, %rax
addq $0x198, %rsp            # imm = 0x198
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
jmp 0xbc81
movq %rax, %r14
movq 0x6345(%rip), %rsi      # 0x11fd0
leaq 0x20(%rsp), %rdi
callq 0x3140
leaq 0x90(%rsp), %rdi
callq 0x30d0
jmp 0xbca7
movq %rax, %r14
movq (%rbx), %rdi
cmpq %r15, %rdi
je 0xbcba
movq (%r15), %rsi
incq %rsi
callq 0x3280
movq %r14, %rdi
callq 0x3450
// File: /workspace/github_cpp_makefile_star2_O1/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 %r15
pushq %r14
pushq %rbx
subq $0x1a0, %rsp            # imm = 0x1A0
movsd %xmm0, (%rsp)
movq %rdi, %rbx
leaq 0x10(%rdi), %r15
movq %r15, (%rdi)
movq $0x0, 0x8(%rdi)
movb $0x0, 0x10(%rdi)
leaq 0x28(%rsp), %rdi
callq 0x3320
leaq 0x28(%rsp), %rdi
movsd (%rsp), %xmm0
callq 0x33e0
leaq 0x30(%rsp), %rsi
leaq 0x8(%rsp), %rdi
callq 0x33c0
leaq 0x8(%rsp), %r14
movq %rbx, %rdi
movq %r14, %rsi
callq 0x32f0
movq (%r14), %rdi
leaq 0x18(%rsp), %rax
cmpq %rax, %rdi
je 0xbd3b
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x3280
movq 0x628e(%rip), %rsi      # 0x11fd0
leaq 0x28(%rsp), %rdi
callq 0x3140
leaq 0x98(%rsp), %rdi
callq 0x30d0
movq %rbx, %rax
addq $0x1a0, %rsp            # imm = 0x1A0
popq %rbx
popq %r14
popq %r15
retq
jmp 0xbd6b
movq %rax, %r14
movq 0x625b(%rip), %rsi      # 0x11fd0
leaq 0x28(%rsp), %rdi
callq 0x3140
leaq 0x98(%rsp), %rdi
callq 0x30d0
jmp 0xbd91
movq %rax, %r14
movq (%rbx), %rdi
cmpq %r15, %rdi
je 0xbda4
movq (%r15), %rsi
incq %rsi
callq 0x3280
movq %r14, %rdi
callq 0x3450
// File: /workspace/github_cpp_makefile_star2_O1/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
movq (%rsi), %rsi
movq 0x8(%r15), %rcx
xorl %edx, %edx
callq 0x3430
cmpq $-0x1, %rax
je 0xbe7f
movq %rax, %r13
xorl %ebp, %ebp
leaq 0x8(%rsp), %r12
movq %r13, %rcx
subq %rbp, %rcx
movq %r12, %rdi
movq %r14, %rsi
movq %rbp, %rdx
callq 0x32a0
movq %rbx, %rdi
movq %r12, %rsi
callq 0xbecc
movq 0x8(%rsp), %rdi
leaq 0x18(%rsp), %rax
cmpq %rax, %rdi
je 0xbe20
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x3280
movq %r13, %rbp
incq %rbp
movq (%r15), %rsi
movq 0x8(%r15), %rcx
movq %r14, %rdi
movq %rbp, %rdx
callq 0x3430
movq %rax, %r13
cmpq $-0x1, %rax
jne 0xbde5
movq 0x8(%r14), %rcx
leaq 0x8(%rsp), %r15
movq %r15, %rdi
movq %r14, %rsi
movq %rbp, %rdx
callq 0x32a0
movq %rbx, %rdi
movq %r15, %rsi
callq 0xbecc
movq 0x8(%rsp), %rdi
leaq 0x18(%rsp), %rax
cmpq %rax, %rdi
je 0xbe7f
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x3280
movq 0x8(%rbx), %rax
cmpq (%rbx), %rax
jne 0xbe93
movq %rbx, %rdi
movq %r14, %rsi
callq 0x8b28
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
jmp 0xbea4
movq %rax, %rbx
movq 0x8(%rsp), %rdi
leaq 0x18(%rsp), %rax
cmpq %rax, %rdi
je 0xbec3
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x3280
movq %rbx, %rdi
callq 0x3450
nop
// File: /workspace/github_cpp_makefile_star2_O1/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
subq $0x18, %rsp
movq %rdi, %rbx
cmpb $0x7c, (%rdi)
jne 0x3b2a
movb 0xf891(%rip), %al       # 0x132f0
testb %al, %al
je 0x3b35
movq %rbx, %rdi
callq 0x3100
leaq 0xf872(%rip), %rdi      # 0x132e8
movq %rbx, %rsi
movq %rax, %rdx
callq 0x32a0
movq 0xf860(%rip), %rax      # 0x132e8
movq -0x18(%rax), %rcx
cmpq $0x1, %rcx
je 0x3b23
testq %rcx, %rcx
je 0x3b3f
movl -0x8(%rax), %eax
testl %eax, %eax
js 0x3ab2
leaq 0xf83b(%rip), %rdi      # 0x132e8
callq 0x3070
movq 0xf82f(%rip), %rax      # 0x132e8
cmpb $0x7c, (%rax)
jne 0x3b23
movq -0x18(%rax), %rbx
movl -0x8(%rax), %eax
testl %eax, %eax
js 0x3ad5
leaq 0xf818(%rip), %rdi      # 0x132e8
callq 0x3070
movq 0xf80c(%rip), %rax      # 0x132e8
cmpb $0x7c, -0x1(%rax,%rbx)
jne 0x3b23
movq -0x18(%rax), %rcx
addq $-0x2, %rcx
leaq 0xf7f6(%rip), %rbx      # 0x132e8
leaq 0x10(%rsp), %r14
movl $0x1, %edx
movq %r14, %rdi
movq %rbx, %rsi
callq 0x33f0
movq %rbx, %rdi
movq %r14, %rsi
callq 0x33c0
movq (%r14), %rdi
addq $-0x18, %rdi
leaq 0xf(%rsp), %rsi
callq 0x3170
movq 0xf7be(%rip), %rbx      # 0x132e8
movq %rbx, %rax
addq $0x18, %rsp
popq %rbx
popq %r14
retq
callq 0x3490
jmp 0x3a67
leaq 0x84da(%rip), %rdi      # 0xc020
leaq 0x84e0(%rip), %rsi      # 0xc02d
leaq 0x84e7(%rip), %rcx      # 0xc03b
movl $0xad, %edx
callq 0x3190
// File: /workspace/github_cpp_makefile_star2_O1/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 0x3a46
movq %rax, %rbx
testq %rax, %rax
je 0x3b82
movq %rbx, %rdi
callq 0x3100
movq %rax, %rsi
addq %rbx, %rsi
jmp 0x3b89
movq $-0x1, %rsi
leaq 0xf(%rsp), %rdx
movq %rbx, %rdi
callq 0x6876
leaq 0x10(%rsp), %rsi
movq %rax, (%rsi)
leaq 0xf70b(%rip), %rdi      # 0x132b0
callq 0x6912
movq %rax, %r14
movq 0x10(%rsp), %rdi
addq $-0x18, %rdi
leaq 0xe(%rsp), %rsi
callq 0x3170
testq %r14, %r14
jne 0x3c26
movq 0xf684(%rip), %r14      # 0x13250
testq %rbx, %rbx
je 0x3be1
movq %rbx, %rdi
callq 0x3100
movq %rbx, %rsi
addq %rax, %rsi
jmp 0x3be8
movq $-0x1, %rsi
leaq 0xf(%rsp), %rdx
movq %rbx, %rdi
callq 0x6876
leaq 0x10(%rsp), %rsi
movq %rax, (%rsi)
leaq 0xf6ac(%rip), %rdi      # 0x132b0
callq 0x6a28
movq %r14, (%rax)
movq 0x10(%rsp), %rdi
addq $-0x18, %rdi
leaq 0xe(%rsp), %rsi
callq 0x3170
incq 0xf62a(%rip)            # 0x13250
addq $0x18, %rsp
popq %rbx
popq %r14
retq
jmp 0x3c32
jmp 0x3c4a
movq %rax, %rbx
movq 0x10(%rsp), %rdi
addq $-0x18, %rdi
leaq 0xe(%rsp), %rsi
callq 0x3170
jmp 0x3c4d
movq %rax, %rbx
movq %rbx, %rdi
callq 0x3400
// File: /workspace/github_cpp_makefile_star2_O1/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 %r14
pushq %rbx
subq $0x28, %rsp
movq %rsi, 0x20(%rsp)
movq %rdx, 0x18(%rsp)
movq %rcx, 0x10(%rsp)
movq %r8, 0x8(%rsp)
testq %rdi, %rdi
je 0x3e5f
movq %rdi, %rbx
movl $0x30, %edi
callq 0x3260
movq %rax, %r14
movq 0xf25a(%rip), %rax      # 0x12f88
addq $0x18, %rax
movq %rax, (%r14)
xorps %xmm0, %xmm0
movups %xmm0, 0x10(%r14)
movq $0x0, 0x20(%r14)
movq %r14, (%rsp)
movq %rbx, %rdi
callq 0x3100
movq %r14, %rdi
movq %rbx, %rsi
movq %rax, %rdx
callq 0x32a0
movq (%rsp), %rdi
movb $0x0, 0x8(%rdi)
movb $0x1, 0x28(%rdi)
movq 0x20(%rsp), %rax
testq %rax, %rax
je 0x3d97
movq 0x18(%rdi), %rsi
cmpq 0x20(%rdi), %rsi
je 0x3d89
movq %rax, (%rsi)
addq $0x8, 0x18(%rdi)
jmp 0x3d97
addq $0x10, %rdi
leaq 0x20(%rsp), %rdx
callq 0x6f62
movq 0x18(%rsp), %rax
testq %rax, %rax
je 0x3dc7
movq (%rsp), %rdi
movq 0x18(%rdi), %rsi
cmpq 0x20(%rdi), %rsi
je 0x3db9
movq %rax, (%rsi)
addq $0x8, 0x18(%rdi)
jmp 0x3dc7
addq $0x10, %rdi
leaq 0x18(%rsp), %rdx
callq 0x6f62
movq 0x10(%rsp), %rax
testq %rax, %rax
je 0x3df7
movq (%rsp), %rdi
movq 0x18(%rdi), %rsi
cmpq 0x20(%rdi), %rsi
je 0x3de9
movq %rax, (%rsi)
addq $0x8, 0x18(%rdi)
jmp 0x3df7
addq $0x10, %rdi
leaq 0x10(%rsp), %rdx
callq 0x6f62
movq 0x8(%rsp), %rax
testq %rax, %rax
je 0x3e27
movq (%rsp), %rdi
movq 0x18(%rdi), %rsi
cmpq 0x20(%rdi), %rsi
je 0x3e19
movq %rax, (%rsi)
addq $0x8, 0x18(%rdi)
jmp 0x3e27
addq $0x10, %rdi
leaq 0x8(%rsp), %rdx
callq 0x6f62
movq 0xf4d2(%rip), %rsi      # 0x13300
cmpq 0xf4d3(%rip), %rsi      # 0x13308
je 0x3e48
movq (%rsp), %rax
movq %rax, (%rsi)
addq $0x8, 0xf4ba(%rip)      # 0x13300
jmp 0x3e57
leaq 0xf4a9(%rip), %rdi      # 0x132f8
movq %rsp, %rdx
callq 0x6f62
addq $0x28, %rsp
popq %rbx
popq %r14
retq
leaq 0x82c1(%rip), %rdi      # 0xc127
leaq 0x81c0(%rip), %rsi      # 0xc02d
leaq 0x81e9(%rip), %rcx      # 0xc05d
movl $0xe4, %edx
callq 0x3190
// File: /workspace/github_cpp_makefile_star2_O1/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 %rbx
subq $0x10, %rsp
movq %rdi, %r15
movq %rsi, 0x8(%rsp)
movq %rdx, (%rsp)
movl $0x30, %edi
callq 0x3260
movq %rax, %r14
movq %rax, %rbx
movq 0xf0de(%rip), %rax      # 0x12f88
addq $0x18, %rax
movq %rax, (%r14)
xorps %xmm0, %xmm0
movups %xmm0, 0x10(%r14)
movq $0x0, 0x20(%r14)
movb $0x1, 0x28(%r14)
testq %r15, %r15
je 0x3ee1
movq %r15, %rdi
callq 0x3100
movq %rbx, %rdi
movq %r15, %rsi
movq %rax, %rdx
callq 0x32a0
addq $0x10, %r14
movb $0x0, 0x8(%rbx)
movq 0x8(%rsp), %rax
testq %rax, %rax
je 0x3f14
movq 0x18(%rbx), %rsi
cmpq 0x20(%rbx), %rsi
je 0x3f07
movq %rax, (%rsi)
addq $0x8, 0x18(%rbx)
jmp 0x3f14
leaq 0x8(%rsp), %rdx
movq %r14, %rdi
callq 0x6f62
movq (%rsp), %rax
testq %rax, %rax
je 0x3f3c
movq 0x18(%rbx), %rsi
cmpq 0x20(%rbx), %rsi
je 0x3f31
movq %rax, (%rsi)
addq $0x8, 0x18(%rbx)
jmp 0x3f3c
movq %rsp, %rdx
movq %r14, %rdi
callq 0x6f62
movq (%rbx), %rax
cmpq $0x0, -0x18(%rax)
je 0x3f54
movq 0x10(%rbx), %rax
cmpq 0x18(%rbx), %rax
jne 0x3f54
movb $0x0, 0x28(%rbx)
movq %rbx, %rax
addq $0x10, %rsp
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_cpp_makefile_star2_O1/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
movl $0x30, %edi
callq 0x3260
movq %rax, %r14
movq 0xf00b(%rip), %rax      # 0x12f88
addq $0x18, %rax
movq %rax, (%r14)
leaq 0x10(%r14), %r15
xorps %xmm0, %xmm0
movups %xmm0, 0x10(%r14)
movq $0x0, 0x20(%r14)
movb $0x1, 0x28(%r14)
leaq 0x89d2(%rip), %rsi      # 0xc976
movq %r14, %rdi
xorl %edx, %edx
callq 0x32a0
movb $0x0, 0x8(%r14)
movq (%rbx), %rsi
movq 0x8(%rbx), %rdx
movq %r15, %rdi
callq 0x7038
movq %r14, %rax
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_cpp_makefile_star2_O1/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 %rbx
subq $0x10, %rsp
movq %rsi, %r14
movq %rdi, 0x8(%rsp)
movl $0x30, %edi
callq 0x3260
movq %rax, %rbx
movq 0xef98(%rip), %rax      # 0x12f88
addq $0x18, %rax
movq %rax, (%rbx)
leaq 0x10(%rbx), %r15
xorps %xmm0, %xmm0
movups %xmm0, 0x10(%rbx)
movq $0x0, 0x20(%rbx)
movb $0x1, 0x28(%rbx)
leaq 0x8961(%rip), %rsi      # 0xc976
movq %rbx, %rdi
xorl %edx, %edx
callq 0x32a0
movb $0x0, 0x8(%rbx)
movq 0x18(%rbx), %rsi
cmpq 0x20(%rbx), %rsi
je 0x403c
movq 0x8(%rsp), %rax
movq %rax, (%rsi)
addq $0x8, 0x18(%rbx)
jmp 0x4049
leaq 0x8(%rsp), %rdx
movq %r15, %rdi
callq 0x6f62
movq 0x18(%rbx), %rsi
movq (%r14), %rdx
movq 0x8(%r14), %rcx
movq %r15, %rdi
callq 0x6d16
movq %rbx, %rax
addq $0x10, %rsp
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_cpp_makefile_star2_O1/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 %r14
pushq %rbx
pushq %rax
movq %rdi, %r14
movq %rsi, (%rsp)
movl $0x30, %edi
callq 0x3260
movq %rax, %rbx
movq 0xef00(%rip), %rax      # 0x12f88
addq $0x18, %rax
movq %rax, (%rbx)
xorps %xmm0, %xmm0
movups %xmm0, 0x10(%rbx)
movq $0x0, 0x20(%rbx)
testq %r14, %r14
je 0x40fc
movq %r14, %rdi
callq 0x3100
movq %rbx, %rdi
movq %r14, %rsi
movq %rax, %rdx
callq 0x32a0
movb $0x1, 0x8(%rbx)
movb $0x0, 0x28(%rbx)
movq (%rsp), %rax
testq %rax, %rax
je 0x40f1
movq 0x18(%rbx), %rsi
cmpq 0x20(%rbx), %rsi
je 0x40de
movq %rax, (%rsi)
addq $0x8, 0x18(%rbx)
jmp 0x40ed
movq %rbx, %rdi
addq $0x10, %rdi
movq %rsp, %rdx
callq 0x6f62
movb $0x1, 0x28(%rbx)
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
leaq 0x8024(%rip), %rdi      # 0xc127
leaq 0x7f23(%rip), %rsi      # 0xc02d
leaq 0x7f93(%rip), %rcx      # 0xc0a4
movl $0x127, %edx            # imm = 0x127
callq 0x3190
// File: /workspace/github_cpp_makefile_star2_O1/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, 0xf122(%rip)      # 0x132a8
jne 0x41fc
movq %rdx, %rcx
movq %rsi, %rax
notq %rax
addq %rdx, %rax
je 0x41fc
pushq %rbx
movq 0xf102(%rip), %r8       # 0x132a0
movq %rsi, %r9
negq %r9
movabsq $0x5deece66d, %r10      # imm = 0x5DEECE66D
imulq %r10, %r8
movq (%rdi), %r11
leaq (%r9,%rcx), %rbx
addq $0xb, %r8
btrq $0x31, %r8
movq %r8, %rax
shrq $0x10, %rax
xorl %edx, %edx
divq %rbx
leaq (%r11,%rdx,8), %rax
movq -0x8(%r11,%rcx,8), %rdx
movq (%rax,%rsi,8), %rbx
movq %rbx, -0x8(%r11,%rcx,8)
movq %rdx, (%rax,%rsi,8)
leaq (%r9,%rcx), %rax
decq %rax
decq %rcx
cmpq $0x1, %rax
jne 0x41ae
movq %r8, 0xf0a5(%rip)       # 0x132a0
popq %rbx
retq
// File: /workspace/github_cpp_makefile_star2_O1/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
cmpl $-0x1, 0xeffe(%rip)     # 0x13258
jne 0x42b8
movq 0xf0ad(%rip), %rax      # 0x13310
cmpq $0x0, -0x18(%rax)
je 0x42c4
leaq 0xf09f(%rip), %rdi      # 0x13310
leaq 0x7e9a(%rip), %rsi      # 0xc112
movl $0x3, %ecx
xorl %edx, %edx
callq 0x3090
movl $0x1, %ecx
cmpq $-0x1, %rax
jne 0x42b2
leaq 0xf07a(%rip), %rdi      # 0x13310
leaq 0x7e79(%rip), %rsi      # 0xc116
movl $0x3, %ecx
xorl %edx, %edx
callq 0x3090
xorl %ecx, %ecx
cmpq $-0x1, %rax
setne %cl
movl %ecx, 0xefa0(%rip)      # 0x13258
cmpl $0x1, 0xef99(%rip)      # 0x13258
sete %al
popq %rcx
retq
movq 0xed25(%rip), %rdi      # 0x12ff0
leaq 0x7e23(%rip), %rsi      # 0xc0f5
callq 0x3250
movq %rax, %rdi
callq 0x3120
movl $0x1, %edi
callq 0x32c0
// File: /workspace/github_cpp_makefile_star2_O1/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
cmpl $-0x1, 0xef6b(%rip)     # 0x1325c
jne 0x434f
movq 0xf016(%rip), %rax      # 0x13310
cmpq $0x0, -0x18(%rax)
je 0x435b
leaq 0xf008(%rip), %rdi      # 0x13310
leaq 0x7e0b(%rip), %rsi      # 0xc11a
movl $0x2, %ecx
xorl %edx, %edx
callq 0x3090
movl $0x1, %ecx
cmpq $-0x1, %rax
jne 0x4349
leaq 0xefe3(%rip), %rdi      # 0x13310
leaq 0x7de9(%rip), %rsi      # 0xc11d
movl $0x2, %ecx
xorl %edx, %edx
callq 0x3090
xorl %ecx, %ecx
cmpq $-0x1, %rax
setne %cl
movl %ecx, 0xef0d(%rip)      # 0x1325c
cmpl $0x1, 0xef06(%rip)      # 0x1325c
sete %al
popq %rcx
retq
movq 0xec8e(%rip), %rdi      # 0x12ff0
leaq 0x7d8c(%rip), %rsi      # 0xc0f5
callq 0x3250
movq %rax, %rdi
callq 0x3120
movl $0x1, %edi
callq 0x32c0
// File: /workspace/github_cpp_makefile_star2_O1/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
cmpl $-0x1, 0xeed8(%rip)     # 0x13260
jne 0x43c1
movq 0xef7f(%rip), %rax      # 0x13310
cmpq $0x0, -0x18(%rax)
je 0x43cd
leaq 0xef71(%rip), %rdi      # 0x13310
leaq 0x7d7a(%rip), %rsi      # 0xc120
movl $0x2, %ecx
xorl %edx, %edx
callq 0x3090
xorl %ecx, %ecx
cmpq $-0x1, %rax
setne %cl
movl %ecx, 0xee9f(%rip)      # 0x13260
cmpl $0x1, 0xee98(%rip)      # 0x13260
sete %al
popq %rcx
retq
movq 0xec1c(%rip), %rdi      # 0x12ff0
leaq 0x7d1a(%rip), %rsi      # 0xc0f5
callq 0x3250
movq %rax, %rdi
callq 0x3120
movl $0x1, %edi
callq 0x32c0
// File: /workspace/github_cpp_makefile_star2_O1/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
cmpl $-0x1, 0xee6a(%rip)     # 0x13264
jne 0x4433
movq 0xef0d(%rip), %rax      # 0x13310
cmpq $0x0, -0x18(%rax)
je 0x443f
leaq 0xeeff(%rip), %rdi      # 0x13310
leaq 0x7d0b(%rip), %rsi      # 0xc123
movl $0x2, %ecx
xorl %edx, %edx
callq 0x3090
xorl %ecx, %ecx
cmpq $-0x1, %rax
setne %cl
movl %ecx, 0xee31(%rip)      # 0x13264
cmpl $0x1, 0xee2a(%rip)      # 0x13264
sete %al
popq %rcx
retq
movq 0xebaa(%rip), %rdi      # 0x12ff0
leaq 0x7ca8(%rip), %rsi      # 0xc0f5
callq 0x3250
movq %rax, %rdi
callq 0x3120
movl $0x1, %edi
callq 0x32c0