LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_cpp_makefile_star2_O3/fanyazhi[P]Spline-Fitting/src/CRSmatrix.cpp
// Function: CRSmatrix::productAx(std::vector<double, std::allocator<double>>)
std::vector<double> CRSmatrix::productAx(std::vector<double> x) {
    std::vector<double> product(x.size());
    for (int i = 0; i < rowNum; i++) {
        for (int j = 0; j < colNum; j++) {
            product[i] += x[j] * retrieveElement(i, j);
        }
    }
    return product;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x48, %rsp
movq %rsi, %rbx
movq 0x8(%rdx), %rsi
movq %rdx, 0x28(%rsp)
subq (%rdx), %rsi
sarq $0x3, %rsi
leaq 0xf(%rsp), %rdx
movq %rdi, 0x10(%rsp)
callq 0x3d90
movq %rbx, 0x18(%rsp)
movslq (%rbx), %rax
movq %rax, 0x30(%rsp)
testq %rax, %rax
jle 0x2e31
movq 0x18(%rsp), %rax
movl 0x4(%rax), %ecx
movq 0x20(%rax), %rax
movq %rax, 0x20(%rsp)
movq 0x10(%rsp), %rax
movq (%rax), %rsi
xorl %edi, %edi
testl %ecx, %ecx
jle 0x2e20
movq 0x28(%rsp), %rax
movq (%rax), %r9
movq 0x20(%rsp), %rax
movslq (%rax,%rdi,4), %r14
leaq 0x1(%rdi), %rdx
movq %rdx, 0x38(%rsp)
movslq 0x4(%rax,%rdi,4), %r11
movq 0x18(%rsp), %rax
movq 0x8(%rax), %rdx
movq %rdx, 0x40(%rsp)
movsd (%rsi,%rdi,8), %xmm0
movq %r11, %r13
subq %r14, %r13
movl %r14d, %ebp
movq %r14, %r10
shlq $0x2, %r10
addq 0x38(%rax), %r10
xorl %ebx, %ebx
xorpd %xmm1, %xmm1
cmpl %r11d, %r14d
jge 0x2dff
xorl %r15d, %r15d
xorl %edx, %edx
movl %r14d, %eax
movl (%r10,%r15,4), %r8d
leal (%r15,%rbp), %r12d
cmpq %r8, %rbx
cmovel %r12d, %eax
sete %r8b
orb %r8b, %dl
incq %r15
cmpq %r15, %r13
jne 0x2dd0
testb $0x1, %dl
je 0x2dff
cltq
movq 0x40(%rsp), %rdx
movsd (%rdx,%rax,8), %xmm1
mulsd (%r9,%rbx,8), %xmm1
addsd %xmm1, %xmm0
movsd %xmm0, (%rsi,%rdi,8)
incq %rbx
cmpq %rcx, %rbx
jne 0x2dbf
movq 0x38(%rsp), %rax
movq %rax, %rdi
jmp 0x2e26
incq %rdi
movq %rdi, %rax
cmpq 0x30(%rsp), %rax
jne 0x2d6f
movq 0x10(%rsp), %rax
addq $0x48, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O3/fanyazhi[P]Spline-Fitting/src/CRSmatrix.cpp
// Function: CRSmatrix::deleteValue(unsigned int, unsigned int)
void CRSmatrix::deleteValue(unsigned int i, unsigned int j) {
    for (int n = rowPtr[i]; n < rowPtr[i] + (rowPtr[i + 1] - rowPtr[i]); n++) {
        if (colInd[n] == j) {
            value.erase(value.begin() + n);
            colInd.erase(colInd.begin() + n);
            for (unsigned int m = i + 1; m < rowPtr.size(); m++) rowPtr[m]--;
        }
    }
}

// Assembly:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
movl %esi, %r14d
movl %esi, %ecx
movq 0x20(%rdi), %rax
movslq (%rax,%rcx,4), %r12
leal 0x1(%r14), %r13d
cmpl (%rax,%r13,4), %r12d
jge 0x2f11
movl %edx, %ebx
movq %rdi, %r15
addl $0x2, %r14d
movq 0x38(%r15), %rcx
cmpl %ebx, (%rcx,%r12,4)
jne 0x2f01
movq 0x8(%r15), %rax
movq 0x10(%r15), %rdx
leaq (%rax,%r12,8), %rsi
addq $0x8, %rsi
cmpq %rdx, %rsi
je 0x2eaa
leaq (%rax,%r12,8), %rdi
subq %rsi, %rdx
callq 0x2260
movq 0x10(%r15), %rdx
movq 0x38(%r15), %rcx
addq $-0x8, %rdx
movq %rdx, 0x10(%r15)
leaq (%rcx,%r12,4), %rsi
addq $0x4, %rsi
movq 0x40(%r15), %rdx
cmpq %rdx, %rsi
je 0x2ed3
leaq (%rcx,%r12,4), %rdi
subq %rsi, %rdx
callq 0x2260
movq 0x40(%r15), %rdx
addq $-0x4, %rdx
movq %rdx, 0x40(%r15)
movq 0x20(%r15), %rax
movq 0x28(%r15), %rcx
subq %rax, %rcx
sarq $0x2, %rcx
cmpq %r13, %rcx
jbe 0x2f01
movl %r14d, %edx
movq %r13, %rsi
decl (%rax,%rsi,4)
movl %edx, %esi
incl %edx
cmpq %rsi, %rcx
ja 0x2ef5
incq %r12
movslq (%rax,%r13,4), %rcx
cmpq %rcx, %r12
jl 0x2e73
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
nop
// File: /workspace/github_cpp_makefile_star2_O3/fanyazhi[P]Spline-Fitting/src/CRSmatrix.cpp
// Function: CRSmatrix::printA()
void CRSmatrix::printA() {
    for (int valI = 0; valI < rowNum; valI++) {
        for (int valJ = 0; valJ < colNum; valJ++) {
            std::cout << " " << retrieveElement(valI, valJ);
        }
        std::cout << std::endl;
    }
}

// Assembly:
cmpl $0x0, (%rdi)
jle 0x3006
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rdi, %rbx
xorl %r13d, %r13d
movq 0x609b(%rip), %r14      # 0x8fd8
leaq 0x326c(%rip), %r15      # 0x61b0
leaq 0x1(%r13), %r12
cmpl $0x0, 0x4(%rbx)
jle 0x2fc2
xorl %ebp, %ebp
movl $0x1, %edx
movq %r14, %rdi
movq %r15, %rsi
callq 0x21c0
movq 0x20(%rbx), %rcx
movl (%rcx,%r13,4), %eax
movslq (%rcx,%r12,4), %rcx
xorps %xmm0, %xmm0
cmpl %ecx, %eax
jge 0x2fb3
movslq %eax, %rdx
subq %rdx, %rcx
shlq $0x2, %rdx
addq 0x38(%rbx), %rdx
xorl %esi, %esi
movl %eax, %edi
xorl %r8d, %r8d
leal (%rdi,%rsi), %r9d
cmpl %ebp, (%rdx,%rsi,4)
cmovel %r9d, %eax
sete %r9b
orb %r9b, %r8b
incq %rsi
cmpq %rsi, %rcx
jne 0x2f88
testb $0x1, %r8b
je 0x2fb3
cltq
movq 0x8(%rbx), %rcx
movsd (%rcx,%rax,8), %xmm0
movq %r14, %rdi
callq 0x2250
incl %ebp
cmpl 0x4(%rbx), %ebp
jl 0x2f50
movq (%r14), %rax
movq -0x18(%rax), %rdi
addq %r14, %rdi
movl $0xa, %esi
callq 0x2170
movsbl %al, %esi
movq %r14, %rdi
callq 0x2030
movq %rax, %rdi
callq 0x20e0
movslq (%rbx), %rax
movq %r12, %r13
cmpq %rax, %r12
jl 0x2f44
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O3/fanyazhi[P]Spline-Fitting/src/CRSmatrix.cpp
// Function: vectorNorm(std::vector<double, std::allocator<double>>)
double vectorNorm(std::vector<double> x) {
    double sum = 0.0;
    for (unsigned int i = 0; i < x.size(); i++) {
        sum += pow(x[i], 2);
    }
    return sqrt(sum);
}

// Assembly:
movq (%rdi), %rax
movq 0x8(%rdi), %rcx
xorpd %xmm1, %xmm1
xorpd %xmm0, %xmm0
subq %rax, %rcx
je 0x3038
sarq $0x3, %rcx
xorl %edx, %edx
movsd (%rax,%rdx,8), %xmm2
mulsd %xmm2, %xmm2
addsd %xmm2, %xmm0
incq %rdx
movl %edx, %esi
cmpq %rsi, %rcx
ja 0x3021
ucomisd %xmm1, %xmm0
jb 0x2120
sqrtsd %xmm0, %xmm0
retq
// File: /workspace/github_cpp_makefile_star2_O3/fanyazhi[P]Spline-Fitting/src/cubicSpline.cpp
// Function: constructVariables(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>)
vector<double> constructVariables(string address) {
    //initiate vector x to store all elements in file
    vector<double> x;

    ifstream inValue;
    inValue.open(address);

    //check if file is open, if not exit code
    if (!inValue.is_open()) {
        cout << "error: file did not open" << endl;
        exit(1);
    }

    // Declare a variable to load the contents from the file
    string line = "";

    // Loading the value vector
    while (inValue >> line) {
        double value = stod(line);
        x.push_back(value);
    }

    return x;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x238, %rsp            # imm = 0x238
movq %rsi, %r14
movq %rdi, %rbx
xorps %xmm0, %xmm0
movups %xmm0, (%rdi)
movq $0x0, 0x10(%rdi)
leaq 0x30(%rsp), %r15
movq %r15, %rdi
callq 0x21b0
movq %r15, %rdi
movq %r14, %rsi
movl $0x8, %edx
callq 0x2150
leaq 0xa8(%rsp), %rdi
callq 0x2050
testb %al, %al
je 0x534c
leaq 0x10(%rsp), %rax
movq %rax, -0x10(%rax)
leaq 0x1058(%rip), %rdx      # 0x62bb
movq %rsp, %rdi
movq %rdx, %rsi
callq 0x3f9c
leaq 0x30(%rsp), %r14
movq %rsp, %r15
movq %r14, %rdi
movq %r15, %rsi
callq 0x21f0
movq (%rax), %rcx
movq -0x18(%rcx), %rcx
testb $0x5, 0x20(%rax,%rcx)
jne 0x52fa
movq (%rsp), %r13
callq 0x2040
movq %rax, %rbp
movl (%rax), %r12d
movl $0x0, (%rax)
movq %r13, %rdi
leaq 0x28(%rsp), %rsi
callq 0x2100
cmpq %r13, 0x28(%rsp)
je 0x5334
movl (%rbp), %eax
testl %eax, %eax
je 0x52c6
cmpl $0x22, %eax
jne 0x52ca
jmp 0x5340
movl %r12d, (%rbp)
movsd %xmm0, 0x20(%rsp)
movq 0x8(%rbx), %rsi
cmpq 0x10(%rbx), %rsi
je 0x52e8
movsd %xmm0, (%rsi)
addq $0x8, %rsi
movq %rsi, 0x8(%rbx)
jmp 0x5276
movq %rbx, %rdi
leaq 0x20(%rsp), %rdx
callq 0x4032
jmp 0x5276
movq (%rsp), %rdi
leaq 0x10(%rsp), %rax
cmpq %rax, %rdi
je 0x5315
movq 0x10(%rsp), %rsi
incq %rsi
callq 0x2190
leaq 0x30(%rsp), %rdi
callq 0x2060
movq %rbx, %rax
addq $0x238, %rsp            # imm = 0x238
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
leaq 0xe3e(%rip), %rdi       # 0x6179
callq 0x20d0
leaq 0xe32(%rip), %rdi       # 0x6179
callq 0x2220
movq 0x3c85(%rip), %rdi      # 0x8fd8
leaq 0xe06(%rip), %rsi       # 0x6160
movl $0x18, %edx
callq 0x21c0
movq 0x3c6d(%rip), %rdi      # 0x8fd8
callq 0x20a0
movl $0x1, %edi
callq 0x21d0
jmp 0x537c
movq %rax, %r14
jmp 0x53b0
jmp 0x5383
movq %rax, %r14
jmp 0x5395
movq %rax, %r14
cmpl $0x0, (%rbp)
jne 0x5395
movl %r12d, (%rbp)
movq (%rsp), %rdi
leaq 0x10(%rsp), %rax
cmpq %rax, %rdi
je 0x53b0
movq 0x10(%rsp), %rsi
incq %rsi
callq 0x2190
leaq 0x30(%rsp), %rdi
callq 0x2060
movq (%rbx), %rdi
testq %rdi, %rdi
je 0x53ce
movq 0x10(%rbx), %rsi
subq %rdi, %rsi
callq 0x2190
movq %r14, %rdi
callq 0x2270
nop
// File: /workspace/github_cpp_makefile_star2_O3/oknenavin[P]cxon/test/src/json/json.node-main.cxx
// Function: void test::kind::time<void (*)(test::test&)>(std::vector<test::test, std::allocator<test::test>>&, void (*)(test::test&))
void time(cases& cases, TIME_CXON time_cxon) {
            struct {
                std::vector<std::string> name;
                std::vector<void(*)(test&)> func;
            }   cnts;
                cnts.name.push_back(time_cxon == &time_cxon_node ? "# cxon/node" : "# cxon/native");
                cnts.func.push_back(time_cxon);
#           ifdef CXON_TIME_BOOST_JSON
                cnts.name.push_back("Boost/JSON");
                cnts.func.push_back(&time_boostjson);
#           endif
#           ifdef CXON_TIME_RAPIDJSON
                cnts.name.push_back("RapidJSON");
                cnts.func.push_back(&time_rapidjson);
#           endif
#           ifdef CXON_TIME_NLOHMANN
                cnts.name.push_back("nlohmann/JSON");
                cnts.func.push_back(&time_nlohmannjson);
#           endif
            {   // time
                auto time_node = cases;
                for (auto& test: time_node)
                    for (auto& func: cnts.func)
                        func(test);
                time_print(cnts.name, time_node);
            }
        }

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x68, %rsp
movq %rdi, %rbx
movq %rsi, 0x8(%rsp)
xorps %xmm0, %xmm0
movaps %xmm0, 0x50(%rsp)
movaps %xmm0, 0x40(%rsp)
movaps %xmm0, 0x30(%rsp)
xorl %eax, %eax
cmpq 0xd8b74(%rip), %rsi     # 0x11ffd0
leaq 0x8bfd0(%rip), %rcx     # 0xd3433
leaq 0x8bfd5(%rip), %rsi     # 0xd343f
cmoveq %rcx, %rsi
setne %al
leaq 0x20(%rsp), %r14
movq %r14, -0x10(%r14)
leaq (%rsi,%rax,2), %rdx
addq $0xb, %rdx
leaq 0x10(%rsp), %rdi
callq 0x18f42
leaq 0x30(%rsp), %rdi
leaq 0x10(%rsp), %rsi
callq 0x4e412
movq 0x10(%rsp), %rdi
cmpq %r14, %rdi
je 0x474aa
callq 0xe240
movq 0x50(%rsp), %rsi
cmpq 0x58(%rsp), %rsi
je 0x474c6
movq 0x8(%rsp), %rax
movq %rax, (%rsi)
addq $0x8, 0x50(%rsp)
jmp 0x474d5
leaq 0x48(%rsp), %rdi
leaq 0x8(%rsp), %rdx
callq 0x4b316
leaq 0x10(%rsp), %rdi
movq %rbx, %rsi
callq 0x4b276
movq 0x10(%rsp), %rbx
movq 0x18(%rsp), %r14
cmpq %r14, %rbx
je 0x47512
movq 0x48(%rsp), %r15
movq 0x50(%rsp), %r12
cmpq %r12, %r15
je 0x4750c
movq %rbx, %rdi
callq *(%r15)
addq $0x8, %r15
jmp 0x474fb
subq $-0x80, %rbx
jmp 0x474ec
leaq 0x30(%rsp), %rdi
leaq 0x10(%rsp), %rsi
callq 0x46102
leaq 0x10(%rsp), %rdi
callq 0x47d18
movq 0x48(%rsp), %rdi
testq %rdi, %rdi
je 0x4753a
callq 0xe240
leaq 0x30(%rsp), %rdi
callq 0x1d9d0
addq $0x68, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
jmp 0x4756a
jmp 0x4756f
jmp 0x4756a
movq %rax, %rbx
movq 0x10(%rsp), %rdi
cmpq %r14, %rdi
je 0x4757c
callq 0xe240
jmp 0x4757c
movq %rax, %rbx
jmp 0x4757c
movq %rax, %rbx
leaq 0x10(%rsp), %rdi
callq 0x47d18
leaq 0x30(%rsp), %rdi
callq 0x4b2fa
movq %rbx, %rdi
callq 0xe3c0
// File: /workspace/github_cpp_makefile_star2_O3/oknenavin[P]cxon/test/../src/cxon/lib/node.json.hxx
// Function: bool cxon::imp::write_number_key_<cxon::JSON<cxon::json::format_traits>, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, double, cxon::context<cxon::JSON<cxon::json::format_traits>, cxon::napa::imp::var<cxon::node::recursion_guard, unsigned int>>>(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>&, double const&, cxon::context<cxon::JSON<cxon::json::format_traits>, cxon::napa::imp::var<cxon::node::recursion_guard, unsigned int>>&)
static bool write_number_key_(O& o, const T& t, Cx& cx) {
                if (std::isinf(t))
                    return std::signbit(t) ?
                            write_value<X>(o, "-inf", cx) : write_value<X>(o, "inf", cx)
                    ;
                if (std::isnan(t))
                    return  write_value<X>(o, "nan", cx);
                return cio::key::write_key<X>(o, t, cx);
            }

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rdx, %r14
movq %rdi, %rbx
movq (%rsi), %xmm0
movq %xmm0, %rax
movq %rax, %rcx
btrq $0x3f, %rcx
movabsq $0x7ff0000000000000, %rdx # imm = 0x7FF0000000000000
cmpq %rdx, %rcx
jne 0x668cf
testq %rax, %rax
js 0x66912
leaq 0x6bce9(%rip), %rsi     # 0xd25a8
movq %rbx, %rdi
movq %r14, %rdx
popq %rbx
popq %r14
popq %r15
jmp 0x4dd36
ucomisd %xmm0, %xmm0
jp 0x66929
movq %rsi, %r15
movq %rbx, %rdi
movl $0x22, %esi
callq 0xe220
movsd (%r15), %xmm0
movq %rbx, %rdi
movq %r14, %rsi
callq 0x4d728
testb %al, %al
je 0x6690a
movq %rbx, %rdi
movl $0x22, %esi
callq 0xe220
movb $0x1, %al
jmp 0x6690c
xorl %eax, %eax
popq %rbx
popq %r14
popq %r15
retq
leaq 0x6bc8e(%rip), %rsi     # 0xd25a7
movq %rbx, %rdi
movq %r14, %rdx
popq %rbx
popq %r14
popq %r15
jmp 0x4da86
leaq 0x6bc7d(%rip), %rsi     # 0xd25ad
jmp 0x668bf
// File: /workspace/github_cpp_makefile_star2_O3/oknenavin[P]cxon/test/../src/cxon/lang/json/node/node.hxx
// Function: cxon::json::basic_node<cxon::json::node_traits<std::allocator<char>>>::basic_node(cxon::json::basic_node<cxon::json::node_traits<std::allocator<char>>> const&, std::allocator<cxon::json::basic_node<cxon::json::node_traits<std::allocator<char>>>> const&)
basic_node(const basic_node& o, const allocator_type& al)
                noexcept(value::is_nothrow_copy_constructible<basic_node>::value)
            :   kind_(o.kind_), alloc_(al)
            {
                switch (o.kind_) {
#                   define CXON_JSON_TYPE_DEF(T)    case node_kind::T: value::copy_construct<T>(*this, o); break
                        CXON_JSON_TYPE_DEF(object);
                        CXON_JSON_TYPE_DEF(array);
                        CXON_JSON_TYPE_DEF(string);
                        CXON_JSON_TYPE_DEF(real);
                        CXON_JSON_TYPE_DEF(sint);
                        CXON_JSON_TYPE_DEF(uint);
                        CXON_JSON_TYPE_DEF(boolean);
                        CXON_JSON_TYPE_DEF(null);
#                   undef CXON_JSON_TYPE_DEF
                }
            }

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movl 0x20(%rsi), %eax
movl %eax, 0x20(%rdi)
cmpq $0x7, %rax
ja 0x67cd5
movq %rdi, %rbx
leaq 0x6c1ba(%rip), %rcx     # 0xd3e00
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
movq (%rsi), %rax
movq %rax, (%rbx)
jmp 0x67cd5
leaq 0x10(%rbx), %rax
movq %rax, (%rbx)
movq (%rsi), %rax
movq 0x8(%rsi), %rdx
addq %rax, %rdx
movq %rbx, %rdi
movq %rax, %rsi
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x6e392
movq $0x0, (%rbx)
jmp 0x67cd5
movsd (%rsi), %xmm0
movsd %xmm0, (%rbx)
jmp 0x67cd5
movq (%rsi), %r14
movl $0x30, %edi
callq 0xe250
movq %rax, (%rbx)
leaq 0x6(%rsp), %rdx
movq %rax, %rdi
movq %r14, %rsi
callq 0x7bbfc
jmp 0x67cd5
movq (%rsi), %r14
movl $0x18, %edi
callq 0xe250
movq %rax, (%rbx)
leaq 0x7(%rsp), %rdx
movq %rax, %rdi
movq %r14, %rsi
callq 0x7be36
jmp 0x67cd5
movb (%rsi), %al
movb %al, (%rbx)
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_cpp_makefile_star2_O3/oknenavin[P]cxon/test/src/json/json.node-time.native.cxx
// Function: test::kind::time_cxon_native(test::test&)
void time_cxon_native(test& t) {
        auto i = native::executors_.find(t.source.substr(t.source.rfind('/') + 1));
        i != native::executors_.end() ?
            i->second(t) :
            (time_cxon_node(t), t.flag = true, void())
        ;
    }

// Assembly:
pushq %r14
pushq %rbx
subq $0x28, %rsp
movq %rdi, %rbx
movl $0x2f, %esi
movq $-0x1, %rdx
callq 0xe440
leaq 0x1(%rax), %rdx
leaq 0x8(%rsp), %r14
movq %r14, %rdi
movq %rbx, %rsi
movq $-0x1, %rcx
callq 0xe270
leaq 0x6f081(%rip), %rdi     # 0x1206a0
movq %r14, %rsi
callq 0xcfd48
movq %rax, %r14
leaq 0x18(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0xb163d
callq 0xe240
leaq 0x6f064(%rip), %rax     # 0x1206a8
cmpq %rax, %r14
je 0xb1652
movq %rbx, %rdi
callq *0x40(%r14)
jmp 0xb165e
movq %rbx, %rdi
callq 0xcfdac
movb $0x1, 0x78(%rbx)
addq $0x28, %rsp
popq %rbx
popq %r14
retq
movq %rax, %rbx
leaq 0x18(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0xb167c
callq 0xe240
movq %rbx, %rdi
callq 0xe3c0
// File: /workspace/github_cpp_makefile_star2_O3/cpottamus[P]btree_lab/readdisk.cc
// Function: main
int main(int argc, char *argv[])
{
  if (argc<4) { 
    usage();
    exit(-1);
  }
  SIZE_T blocknum=atoi(argv[2]);
  SIZE_T numblocks=atoi(argv[3]);
  double reqtime;

  DiskSystem disk(argv[1]);

  vector<Block> b;

  ERROR_T rc= disk.Read(blocknum, numblocks, b, reqtime);

  if (rc!=ERROR_NOERROR) { 
    cerr << "Error "<< rc << " occured.\n";
    return -1;
  } else {
    cerr << "Read took "<<reqtime<<" milliseconds\n";
    for (vector<Block>::const_iterator i=b.begin();i!=b.end();++i) {
      // cerr << (*i);
      for (SIZE_T j=0;j<(*i).length;j++) { 
	cout << (*i).data[j];
      }
    }
  }
  return 0;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0xc0, %rsp
cmpl $0x3, %edi
jle 0x26a3
movq %rsi, %r14
movq 0x10(%rsi), %rdi
callq 0x2290
movl %eax, %ebx
movq 0x18(%r14), %rdi
callq 0x2290
movl %eax, %ebp
movq 0x8(%r14), %rsi
leaq 0x10(%rsp), %rdi
leaq 0xf(%rsp), %rdx
callq 0x26f8
subq $0x8, %rsp
xorl %eax, %eax
leaq 0x48(%rsp), %rdi
leaq 0x18(%rsp), %rsi
xorps %xmm0, %xmm0
xorps %xmm1, %xmm1
xorps %xmm2, %xmm2
xorl %edx, %edx
xorl %ecx, %ecx
xorl %r8d, %r8d
xorl %r9d, %r9d
pushq %rax
pushq %rax
pushq %rax
callq 0x2814
addq $0x20, %rsp
leaq 0x20(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x2572
movq 0x20(%rsp), %rsi
incq %rsi
callq 0x2190
xorps %xmm0, %xmm0
leaq 0x10(%rsp), %rcx
movaps %xmm0, (%rcx)
movq $0x0, 0x10(%rcx)
leaq 0x40(%rsp), %rdi
leaq 0x38(%rsp), %r8
movl %ebx, %esi
movl %ebp, %edx
callq 0x35a2
movl %eax, %ebx
testl %eax, %eax
je 0x25e2
movq 0x5a4b(%rip), %rdi      # 0x7ff0
leaq 0x2a8c(%rip), %rsi      # 0x5038
movl $0x6, %edx
callq 0x21d0
movq 0x5a33(%rip), %rdi      # 0x7ff0
movl %ebx, %esi
callq 0x22f0
movl $0xffffffff, %ebx       # imm = 0xFFFFFFFF
leaq 0x2a6f(%rip), %rsi      # 0x503f
movl $0xa, %edx
movq %rax, %rdi
callq 0x21d0
jmp 0x267d
movq 0x5a07(%rip), %rdi      # 0x7ff0
leaq 0x2a5a(%rip), %rsi      # 0x504a
movl $0xa, %edx
callq 0x21d0
movsd 0x38(%rsp), %xmm0
movq 0x59e9(%rip), %rdi      # 0x7ff0
callq 0x22b0
leaq 0x2a42(%rip), %rsi      # 0x5055
movl $0xe, %edx
movq %rax, %rdi
callq 0x21d0
movq 0x10(%rsp), %r15
movq 0x18(%rsp), %rax
cmpq %rax, %r15
je 0x267b
movq 0x599a(%rip), %rbx      # 0x7fd0
leaq 0xf(%rsp), %r14
cmpl $0x0, 0x10(%r15)
je 0x2672
xorl %r12d, %r12d
movq 0x8(%r15), %rax
movb (%rax,%r12), %al
movb %al, 0xf(%rsp)
movl $0x1, %edx
movq %rbx, %rdi
movq %r14, %rsi
callq 0x21d0
incq %r12
movl 0x10(%r15), %eax
cmpq %rax, %r12
jb 0x2645
movq 0x18(%rsp), %rax
addq $0x28, %r15
cmpq %rax, %r15
jne 0x263b
xorl %ebx, %ebx
leaq 0x10(%rsp), %rdi
callq 0x2736
leaq 0x40(%rsp), %rdi
callq 0x2db4
movl %ebx, %eax
addq $0xc0, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
callq 0x24cc
movl $0xffffffff, %edi       # imm = 0xFFFFFFFF
callq 0x2200
movq %rax, %rbx
leaq 0x20(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x26f0
movq 0x20(%rsp), %rsi
incq %rsi
callq 0x2190
jmp 0x26f0
movq %rax, %rbx
jmp 0x26f0
jmp 0x26d9
movq %rax, %rbx
leaq 0x10(%rsp), %rdi
callq 0x2736
leaq 0x40(%rsp), %rdi
callq 0x2db4
movq %rbx, %rdi
callq 0x2300
// File: /workspace/github_cpp_makefile_star2_O3/lemire[P]runningmaxmin/./runningmaxmin.h
// Function: slowmaxmin::slowmaxmin(std::vector<double, std::allocator<double>>&, int)
slowmaxmin(std::vector<floattype> & array, int width)
        : maxvalues(array.size() - width + 1),
          minvalues(array.size() - width + 1) {
        floattype maxvalue, minvalue;
        for (uint s = 0; s < array.size() - width + 1; ++s) {
            maxvalue = array[s];
            minvalue = array[s];
            // could be done with iterators
            for (uint k = s + 1; k < s + width; ++k) {
                if (maxvalue < array[k])
                    maxvalue = array[k];
                if (minvalue > array[k])
                    minvalue = array[k];
            }
            maxvalues[s] = maxvalue;
            minvalues[s] = minvalue;
        }
    }

// Assembly:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x10, %rsp
movl %edx, %ebx
movq %rsi, %r12
movq %rdi, %r14
leaq 0x7646(%rip), %rax      # 0xab68
addq $0x10, %rax
movq %rax, (%rdi)
leaq 0x8(%rdi), %r15
movq 0x8(%rsi), %rsi
subq (%r12), %rsi
sarq $0x3, %rsi
movslq %edx, %r13
subq %r13, %rsi
incq %rsi
leaq 0xf(%rsp), %rdx
movq %r15, %rdi
callq 0x56be
movq 0x8(%r12), %rsi
subq (%r12), %rsi
addq $0x20, %r14
sarq $0x3, %rsi
subq %r13, %rsi
incq %rsi
leaq 0xe(%rsp), %rdx
movq %r14, %rdi
callq 0x56be
movq (%r12), %rax
movq 0x8(%r12), %rcx
subq %rax, %rcx
sarq $0x3, %rcx
subq %r13, %rcx
incq %rcx
je 0x35f4
movq (%r15), %rdx
movq (%r14), %rsi
leal -0x1(%rbx), %edi
movl $0x1, %r8d
xorl %r9d, %r9d
vmovsd (%rax,%r9,8), %xmm0
leaq 0x1(%r9), %r10
leal (%r9,%rbx), %r11d
cmpl %r10d, %r11d
jbe 0x35d6
movl %r8d, %r11d
leaq (%rax,%r11,8), %r11
xorl %r14d, %r14d
vmovapd %xmm0, %xmm1
vmovsd (%r11,%r14,8), %xmm2
vmaxsd %xmm1, %xmm2, %xmm1
vminsd %xmm0, %xmm2, %xmm0
incq %r14
cmpl %r14d, %edi
jne 0x35be
jmp 0x35da
vmovapd %xmm0, %xmm1
vmovsd %xmm1, (%rdx,%r9,8)
vmovsd %xmm0, (%rsi,%r9,8)
movl %r10d, %r11d
incl %r8d
movq %r10, %r9
cmpq %r11, %rcx
ja 0x359d
addq $0x10, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
movq %rax, %rbx
movq (%r15), %rdi
testq %rdi, %rdi
je 0x3612
callq 0x20e0
movq %rbx, %rdi
callq 0x2190
// File: /workspace/github_cpp_makefile_star2_O3/lemire[P]runningmaxmin/./runningmaxmin.h
// Function: lemiremaxminwrap::lemiremaxminwrap(std::vector<double, std::allocator<double>>&, unsigned int)
lemiremaxminwrap(std::vector<floattype> & array, uint width)
        : maxvalues(array.size() - width + 1),
          minvalues(array.size() - width + 1) {
        lemiremaxmintruestreaming lts(width);
        for (uint i = 0; i < width - 1; ++i) {
            lts.update(array[i]);
        }
        for (uint i = width - 1; i < array.size(); ++i) {
            lts.update(array[i]);
            maxvalues[i - width + 1] = lts.max();
            minvalues[i - width + 1] = lts.min();
        }
    }

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x48, %rsp
movl %edx, %r15d
movq %rsi, %r12
movq %rdi, %r14
leaq 0x6dbe(%rip), %rax      # 0xac08
addq $0x10, %rax
movq %rax, (%rdi)
addq $0x8, %rdi
movq 0x8(%rsi), %rsi
subq (%r12), %rsi
sarq $0x3, %rsi
movl %edx, %ebx
subq %rbx, %rsi
incq %rsi
leaq 0x10(%rsp), %rdx
movq %rdi, 0x8(%rsp)
callq 0x56be
movq 0x8(%r12), %rsi
subq (%r12), %rsi
addq $0x20, %r14
sarq $0x3, %rsi
subq %rbx, %rsi
incq %rsi
leaq 0x10(%rsp), %rdx
movq %r14, %rdi
callq 0x56be
leaq 0x10(%rsp), %rdi
movl %r15d, %esi
callq 0x5c10
movl %r15d, %eax
decl %eax
je 0x3ed4
movl %eax, %ebp
xorl %ebx, %ebx
leaq 0x10(%rsp), %r13
movq (%r12), %rax
vmovsd (%rax,%rbx,8), %xmm0
movq %r13, %rdi
callq 0x5c96
incq %rbx
cmpq %rbx, %rbp
jne 0x3eb9
jmp 0x3ed6
xorl %ebp, %ebp
movq (%r12), %rax
movq 0x8(%r12), %rcx
subq %rax, %rcx
sarq $0x3, %rcx
cmpq %rbp, %rcx
jbe 0x3f59
xorl %ebx, %ebx
leaq 0x10(%rsp), %r13
vmovsd (%rax,%rbp,8), %xmm0
movq %r13, %rdi
callq 0x5c96
movq 0x10(%rsp), %rdi
movl 0x18(%rsp), %eax
shlq $0x4, %rax
vmovsd 0x8(%rdi,%rax), %xmm0
movl %ebx, %eax
movq 0x8(%rsp), %rcx
movq (%rcx), %rcx
vmovsd %xmm0, (%rcx,%rax,8)
movq 0x28(%rsp), %rcx
movl 0x30(%rsp), %edx
shlq $0x4, %rdx
vmovsd 0x8(%rcx,%rdx), %xmm0
movq (%r14), %rcx
vmovsd %xmm0, (%rcx,%rax,8)
leal (%r15,%rbx), %ebp
movq (%r12), %rax
movq 0x8(%r12), %rcx
subq %rax, %rcx
sarq $0x3, %rcx
incl %ebx
cmpq %rbp, %rcx
ja 0x3ef2
jmp 0x3f5e
movq 0x10(%rsp), %rdi
callq 0x2120
movq 0x28(%rsp), %rdi
callq 0x2120
addq $0x48, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %r15
jmp 0x3f9f
movq %rax, %r15
jmp 0x3fac
jmp 0x3f88
movq %rax, %r15
movq 0x10(%rsp), %rdi
callq 0x2120
movq 0x28(%rsp), %rdi
callq 0x2120
movq (%r14), %rdi
testq %rdi, %rdi
je 0x3fac
callq 0x20e0
movq 0x8(%rsp), %rax
movq (%rax), %rdi
testq %rdi, %rdi
je 0x3fbe
callq 0x20e0
movq %r15, %rdi
callq 0x2190
// File: /workspace/github_cpp_makefile_star2_O3/lemire[P]runningmaxmin/./mono_wedge.h
// Function: void mono_wedge::mono_wedge_update<std::deque<Sample, std::allocator<Sample>>, Sample, std::greater<Sample>>(std::deque<Sample, std::allocator<Sample>>&, Sample const&, std::greater<Sample>)
void mono_wedge_update(
		Wedge   &wedge,
		const T &value,
		Compare  comp)
	{
		wedge.erase(
			mono_wedge_search(wedge.begin(), wedge.end(), value, comp),
			wedge.end());
		wedge.push_back(value);
	}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
subq $0xc0, %rsp
movq %rsi, %r14
movq %rdi, %rbx
vmovups 0x10(%rdi), %ymm0
leaq 0x40(%rsp), %rsi
vmovups %ymm0, (%rsi)
vmovups 0x30(%rdi), %ymm0
leaq 0x20(%rsp), %rdx
vmovups %ymm0, (%rdx)
leaq 0x60(%rsp), %r15
movq %r15, %rdi
movq %r14, %rcx
vzeroupper
callq 0x676f
movq (%r15), %rax
movq 0x18(%r15), %rcx
movq 0x30(%rbx), %rsi
movq 0x48(%rbx), %rdi
leaq 0xa0(%rsp), %rdx
movq %rax, (%rdx)
movq (%rcx), %rax
movq %rax, 0x8(%rdx)
movl $0x200, %r8d            # imm = 0x200
addq %r8, %rax
movq %rax, 0x10(%rdx)
movq %rcx, 0x18(%rdx)
leaq 0x80(%rsp), %rcx
movq %rsi, (%rcx)
movq (%rdi), %rax
movq %rax, 0x8(%rcx)
addq %r8, %rax
movq %rax, 0x10(%rcx)
movq %rdi, 0x18(%rcx)
movq %rsp, %rdi
movq %rbx, %rsi
callq 0x696e
movq 0x30(%rbx), %rax
movq 0x40(%rbx), %rcx
addq $-0x10, %rcx
cmpq %rcx, %rax
je 0x6757
vmovups (%r14), %xmm0
vmovups %xmm0, (%rax)
addq $0x10, 0x30(%rbx)
jmp 0x6762
movq %rbx, %rdi
movq %r14, %rsi
callq 0x72d4
addq $0xc0, %rsp
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_cpp_makefile_star2_O3/nmmmnu[P]HM3/common/stringtokenizer.cc
// Function: StringTokenizer::getNext()
StringRef StringTokenizer::getNext(){
	size_t start = pos_;

	while(hasNext() && line_[pos_] != delimiter_)
		++pos_;

	size_t size = pos_ - start;

	StringRef s{ &line_[start], size };

	while(hasNext() && line_[pos_] == delimiter_)
		++pos_;

	return s;
}

// Assembly:
movq (%rdi), %rcx
movq 0x8(%rdi), %rax
movq 0x10(%rdi), %rdx
movq %rcx, %rsi
cmpq %rax, %rcx
jae 0x170d
movb 0x18(%rdi), %r8b
movq %rcx, %rsi
cmpb %r8b, (%rdx,%rsi)
je 0x170d
incq %rsi
movq %rsi, (%rdi)
cmpq %rsi, %rax
jne 0x16fa
jmp 0x173a
cmpq %rax, %rsi
jae 0x1737
movb 0x18(%rdi), %r8b
negq %rax
leaq 0x1(%rsi), %r9
cmpb %r8b, -0x1(%rdx,%r9)
jne 0x1737
movq %r9, (%rdi)
leaq (%rax,%r9), %r10
incq %r10
incq %r9
cmpq $0x1, %r10
jne 0x171d
movq %rsi, %rax
leaq (%rdx,%rcx), %rsi
testq %rdx, %rdx
leaq 0x98c(%rip), %rdx       # 0x20d4
cmovneq %rsi, %rdx
subq %rcx, %rax
retq
// File: /workspace/github_cpp_makefile_star2_O3/nmmmnu[P]HM3/common/stringtokenizer.cc
// Function: StringTokenizer::getAll()
std::vector<StringRef> StringTokenizer::getAll(){
	rewind();

	std::vector<StringRef> v;

	while(hasNext())
		v.push_back(getNext());

	return v;
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
subq $0x10, %rsp
movq %rdi, %rbx
xorl %eax, %eax
movq %rax, (%rsi)
movq %rax, 0x10(%rdi)
xorps %xmm0, %xmm0
movups %xmm0, (%rdi)
cmpq %rax, 0x8(%rsi)
je 0x17b4
movq %rsi, %r14
movq %rsp, %r15
movq %r14, %rdi
callq 0x16e0
movq %rax, (%rsp)
movq %rdx, 0x8(%rsp)
movq 0x8(%rbx), %rsi
cmpq 0x10(%rbx), %rsi
je 0x17a0
movups (%rsp), %xmm0
movups %xmm0, (%rsi)
addq $0x10, 0x8(%rbx)
jmp 0x17ab
movq %rbx, %rdi
movq %r15, %rdx
callq 0x17e0
movq (%r14), %rax
cmpq 0x8(%r14), %rax
jb 0x1777
movq %rbx, %rax
addq $0x10, %rsp
popq %rbx
popq %r14
popq %r15
retq
movq %rax, %r14
movq (%rbx), %rdi
testq %rdi, %rdi
je 0x17d8
movq 0x10(%rbx), %rsi
subq %rdi, %rsi
callq 0x1090
movq %r14, %rdi
callq 0x10b0
// File: /workspace/github_cpp_makefile_star2_O3/ticky[P]ps2iconsys/src/iconsys_builder.cpp
// Function: ParseCommandLine(int, char**)
void ParseCommandLine(int argc, char* argv[])
{
	for(int i=1; i<argc; i++) {
		//Flag parameters:
		if( (strcmp( argv[i], "-h" ) == 0) || (strcmp( argv[i], "--help" ) == 0) ) {
			PrintHelp(argv[0]);
			exit(0);
		} else if( (strcmp( argv[i], "-l" ) == 0) || (strcmp( argv[i], "--list-file" ) == 0) ) {
			list_file = true;
		} else if( (strcmp( argv[i], "-v" ) == 0) || (strcmp( argv[i], "--verbose" ) == 0) ) {
			verbose_output = true;
		} else if( (i < argc - 1) && (ParseCommandLine_1Arg(i, argv)) ) {
			i++;
		} else if( (i < argc - 4) && (ParseCommandLine_4Args(i, argv)) ) {
			i += 4;
		} else {
			std::cout << "Invalid argument." << std::endl << std::endl;
			PrintHelp(argv[0]);
			exit(1);
		}
	}
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
cmpl $0x2, %edi
jl 0x9398
movq %rsi, %rbx
movl %edi, %r14d
leal -0x1(%r14), %eax
movl %eax, 0x4(%rsp)
leal -0x4(%r14), %eax
movl %eax, (%rsp)
movl $0x1, %ebp
leaq 0x2ebe(%rip), %r15      # 0xc14c
movslq %ebp, %rax
movq (%rbx,%rax,8), %r13
movb (%r13), %r12b
cmpb $0x2d, %r12b
jne 0x92eb
cmpb $0x68, 0x1(%r13)
jne 0x92b1
cmpb $0x0, 0x2(%r13)
je 0x93a7
movq %r13, %rdi
movq %r15, %rsi
callq 0x2280
testl %eax, %eax
je 0x93a7
cmpb $0x6c, 0x1(%r13)
jne 0x9313
cmpb $0x0, 0x2(%r13)
je 0x9365
movq %r13, %rdi
leaq 0x2e73(%rip), %rsi      # 0xc153
callq 0x2280
testl %eax, %eax
jne 0x932c
jmp 0x9365
movq %r13, %rdi
movq %r15, %rsi
callq 0x2280
testl %eax, %eax
je 0x93a7
movq %r13, %rdi
leaq 0x2e4b(%rip), %rsi      # 0xc153
callq 0x2280
testl %eax, %eax
jne 0x933a
jmp 0x9365
movq %r13, %rdi
leaq 0x2e36(%rip), %rsi      # 0xc153
callq 0x2280
testl %eax, %eax
je 0x9365
cmpb $0x2d, %r12b
jne 0x933a
cmpb $0x76, 0x1(%r13)
jne 0x933a
cmpb $0x0, 0x2(%r13)
je 0x9386
movq %r13, %rdi
leaq 0x2e1b(%rip), %rsi      # 0xc15f
callq 0x2280
testl %eax, %eax
je 0x9386
cmpl 0x4(%rsp), %ebp
jge 0x936e
movl %ebp, %edi
movq %rbx, %rsi
callq 0x8de6
testb %al, %al
je 0x936e
incl %ebp
jmp 0x938d
movb $0x1, 0x7f0c(%rip)      # 0x11278
jmp 0x938d
cmpl (%rsp), %ebp
jge 0x93b6
movl %ebp, %edi
movq %rbx, %rsi
callq 0x8fbf
testb %al, %al
je 0x93b6
addl $0x4, %ebp
jmp 0x938d
movb $0x1, 0x7eec(%rip)      # 0x11279
incl %ebp
cmpl %r14d, %ebp
jl 0x928e
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq (%rbx), %rdi
callq 0x8454
xorl %edi, %edi
callq 0x2210
movq 0x7c1b(%rip), %rdi      # 0x10fd8
leaq 0x2da5(%rip), %rsi      # 0xc169
callq 0x21b0
movq %rax, %rdi
callq 0x20d0
movq %rax, %rdi
callq 0x20d0
movq (%rbx), %rdi
callq 0x8454
movl $0x1, %edi
callq 0x2210
// File: /workspace/github_cpp_makefile_star2_O3/ticky[P]ps2iconsys/src/iconsys_builder.cpp
// Function: CheckColor(int*)
void CheckColor(int* c) {
	if(c) {		//NULL pointer is okay
		for(int i=0; i<4; i++) {
			if((c[i] < 0) || (c[i] > 255)) {		//numbers must range between 0..255
				std::cout << "All color values must range between 0 and 255." << std::endl;
				exit(1);
			}
		}
	}
}

// Assembly:
testq %rdi, %rdi
je 0x9404
xorl %eax, %eax
cmpl $0x100, (%rdi,%rax,4)   # imm = 0x100
jae 0x9405
incq %rax
cmpq $0x4, %rax
jne 0x93f2
retq
pushq %rax
movq 0x7bcb(%rip), %rdi      # 0x10fd8
leaq 0x2d67(%rip), %rsi      # 0xc17b
callq 0x21b0
movq %rax, %rdi
callq 0x20d0
movl $0x1, %edi
callq 0x2210
// File: /workspace/github_cpp_makefile_star2_O3/ticky[P]ps2iconsys/src/iconsys_builder.cpp
// Function: CheckParameters()
void CheckParameters()
{
	CheckColor(light1_color);
	CheckColor(light2_color);
	CheckColor(light3_color);
	CheckColor(ambient_color);
	CheckColor(bg_color_ul);
	CheckColor(bg_color_ur);
	CheckColor(bg_color_ll);
	CheckColor(bg_color_lr);
	if((bg_opacity < 0) || (bg_opacity > 255)) {
		std::cout << "Background opacity must range between 0 and 255." << std::endl;
		exit(1);
	}
	if((title_linebreak <= 0) || (title_linebreak > 32)) {
		std::cout << "Invalid title linebreak." << std::endl;
		exit(1);
	}
	if(title_string) {
		if(strlen(title_string) > 32) {
			std::cout << "Title string exceeds character limit." << std::endl;
			exit(1);
		}
	}
}

// Assembly:
pushq %rax
movq 0x7e8d(%rip), %rdi      # 0x112c0
callq 0x93eb
movq 0x7e89(%rip), %rdi      # 0x112c8
callq 0x93eb
movq 0x7e85(%rip), %rdi      # 0x112d0
callq 0x93eb
movq 0x7e81(%rip), %rdi      # 0x112d8
callq 0x93eb
movq 0x7e7d(%rip), %rdi      # 0x112e0
callq 0x93eb
movq 0x7e79(%rip), %rdi      # 0x112e8
callq 0x93eb
movq 0x7e75(%rip), %rdi      # 0x112f0
callq 0x93eb
movq 0x7e71(%rip), %rdi      # 0x112f8
callq 0x93eb
cmpl $0x100, 0x7e0a(%rip)    # imm = 0x100
jae 0x94bf
movl 0x7d62(%rip), %eax      # 0x11200
addl $-0x21, %eax
cmpl $-0x21, %eax
jbe 0x94cf
movq 0x7dd3(%rip), %rdi      # 0x11280
testq %rdi, %rdi
je 0x94bd
callq 0x20c0
cmpq $0x21, %rax
jae 0x94df
popq %rax
retq
movq 0x7b12(%rip), %rdi      # 0x10fd8
leaq 0x2cdd(%rip), %rsi      # 0xc1aa
jmp 0x94ed
movq 0x7b02(%rip), %rdi      # 0x10fd8
leaq 0x2cfe(%rip), %rsi      # 0xc1db
jmp 0x94ed
movq 0x7af2(%rip), %rdi      # 0x10fd8
leaq 0x2d07(%rip), %rsi      # 0xc1f4
callq 0x21b0
movq %rax, %rdi
callq 0x20d0
movl $0x1, %edi
callq 0x2210
// File: /workspace/github_cpp_makefile_star2_O3/ticky[P]ps2iconsys/src/iconsys_builder.cpp
// Function: WriteOutput(IconSys*)
void WriteOutput(IconSys* icon_sys) 
{
	if(verbose_output)
		std::cout << " * Writing output file to \"" << output_file << "\"...";
	try {
		icon_sys->WriteFile(output_file);
	} catch(Ghulbus::gbException e) {
		std::cout << "\nFile write error: \"" << output_file << "\"" << std::endl;
	}
	if(verbose_output)
		std::cout << "done." << std::endl;
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
subq $0x20, %rsp
movq %rdi, %rbx
cmpb $0x1, 0x6c5a(%rip)      # 0x11279
jne 0xa694
movq 0x69b0(%rip), %r14      # 0x10fd8
leaq 0x1dfb(%rip), %rsi      # 0xc42a
movl $0x1b, %edx
movq %r14, %rdi
callq 0x21f0
movq 0x6c2d(%rip), %r15      # 0x11270
testq %r15, %r15
je 0xa664
movq %r15, %rdi
callq 0x20c0
movq 0x6981(%rip), %rdi      # 0x10fd8
movq %r15, %rsi
movq %rax, %rdx
callq 0x21f0
jmp 0xa67c
movq (%r14), %rax
movq -0x18(%rax), %rax
leaq (%r14,%rax), %rdi
movl 0x20(%r14,%rax), %esi
orl $0x1, %esi
callq 0x2310
movq 0x6955(%rip), %rdi      # 0x10fd8
leaq 0x1dbc(%rip), %rsi      # 0xc446
movl $0x4, %edx
callq 0x21f0
movq 0x6bd5(%rip), %rsi      # 0x11270
movq %rbx, %rdi
callq 0x553c
cmpb $0x1, 0x6bcf(%rip)      # 0x11279
jne 0xa6ee
movq 0x6925(%rip), %rbx      # 0x10fd8
leaq 0x1bf8(%rip), %rsi      # 0xc2b2
movl $0x5, %edx
movq %rbx, %rdi
callq 0x21f0
movq (%rbx), %rax
movq -0x18(%rax), %rdi
addq %rbx, %rdi
movl $0xa, %esi
callq 0x2190
movsbl %al, %esi
movq %rbx, %rdi
callq 0x2040
movq %rax, %rdi
callq 0x2120
addq $0x20, %rsp
popq %rbx
popq %r14
popq %r15
retq
movq %rax, %rbx
cmpl $0x1, %edx
jne 0xa791
movq %rbx, %rdi
callq 0x2230
leaq 0x8(%rsp), %rdi
movq %rax, %rsi
callq 0x8342
movq %rbx, %rdi
callq 0x20b0
movq 0x68b0(%rip), %rdi      # 0x10fd8
leaq 0x1d1c(%rip), %rsi      # 0xc44b
movl $0x14, %edx
callq 0x21f0
movq 0x6b30(%rip), %rsi      # 0x11270
movq 0x6891(%rip), %rdi      # 0x10fd8
callq 0x21b0
movq %rax, %rbx
leaq 0x1b94(%rip), %rsi      # 0xc2ea
movl $0x1, %edx
movq %rax, %rdi
callq 0x21f0
movq %rbx, %rdi
callq 0x20d0
leaq 0x8(%rsp), %rdi
callq 0x835c
callq 0x2300
jmp 0xa6a3
movq %rax, %rbx
leaq 0x8(%rsp), %rdi
callq 0x835c
callq 0x2300
movq %rbx, %rdi
callq 0x2350
movq %rax, %rdi
callq 0x7088
// File: /workspace/github_cpp_makefile_star2_O3/ticky[P]ps2iconsys/src/iconsys_builder.cpp
// Function: Cleanup()
void Cleanup()
{
	if(title_string)       { delete[] title_string;              title_string = NULL; }
	if(icon_string)        { delete[] icon_string;                icon_string = NULL; }
	if(icon_copy_string)   { delete[] icon_copy_string;      icon_copy_string = NULL; }
	if(icon_delete_string) { delete[] icon_delete_string;  icon_delete_string = NULL; }
	if(light1_dir)         { delete[] light1_dir;                  light1_dir = NULL; }
	if(light2_dir)         { delete[] light2_dir;                  light2_dir = NULL; }
	if(light3_dir)         { delete[] light3_dir;                  light3_dir = NULL; }
	if(light1_color)       { delete[] light1_color;              light1_color = NULL; }
	if(light2_color)       { delete[] light2_color;              light2_color = NULL; }
	if(light3_color)       { delete[] light3_color;              light3_color = NULL; }
	if(ambient_color)      { delete[] ambient_color;            ambient_color = NULL; }
	if(bg_color_ul)        { delete[] bg_color_ul;                bg_color_ul = NULL; }
	if(bg_color_ur)        { delete[] bg_color_ur;                bg_color_ur = NULL; }
	if(bg_color_ll)        { delete[] bg_color_ll;                bg_color_ll = NULL; }
	if(bg_color_lr)        { delete[] bg_color_lr;                bg_color_lr = NULL; }
}

// Assembly:
pushq %rax
movq 0x6ad7(%rip), %rdi      # 0x11280
testq %rdi, %rdi
je 0xa7be
callq 0x2250
movq $0x0, 0x6ac2(%rip) # 0x11280
movq 0x6ac3(%rip), %rdi      # 0x11288
testq %rdi, %rdi
je 0xa7da
callq 0x2250
movq $0x0, 0x6aae(%rip) # 0x11288
movq 0x6aaf(%rip), %rdi      # 0x11290
testq %rdi, %rdi
je 0xa7f6
callq 0x2250
movq $0x0, 0x6a9a(%rip) # 0x11290
movq 0x6a9b(%rip), %rdi      # 0x11298
testq %rdi, %rdi
je 0xa812
callq 0x2250
movq $0x0, 0x6a86(%rip) # 0x11298
movq 0x6a8f(%rip), %rdi      # 0x112a8
testq %rdi, %rdi
je 0xa82e
callq 0x2250
movq $0x0, 0x6a7a(%rip) # 0x112a8
movq 0x6a7b(%rip), %rdi      # 0x112b0
testq %rdi, %rdi
je 0xa84a
callq 0x2250
movq $0x0, 0x6a66(%rip) # 0x112b0
movq 0x6a67(%rip), %rdi      # 0x112b8
testq %rdi, %rdi
je 0xa866
callq 0x2250
movq $0x0, 0x6a52(%rip) # 0x112b8
movq 0x6a53(%rip), %rdi      # 0x112c0
testq %rdi, %rdi
je 0xa882
callq 0x2250
movq $0x0, 0x6a3e(%rip) # 0x112c0
movq 0x6a3f(%rip), %rdi      # 0x112c8
testq %rdi, %rdi
je 0xa89e
callq 0x2250
movq $0x0, 0x6a2a(%rip) # 0x112c8
movq 0x6a2b(%rip), %rdi      # 0x112d0
testq %rdi, %rdi
je 0xa8ba
callq 0x2250
movq $0x0, 0x6a16(%rip) # 0x112d0
movq 0x6a17(%rip), %rdi      # 0x112d8
testq %rdi, %rdi
je 0xa8d6
callq 0x2250
movq $0x0, 0x6a02(%rip) # 0x112d8
movq 0x6a03(%rip), %rdi      # 0x112e0
testq %rdi, %rdi
je 0xa8f2
callq 0x2250
movq $0x0, 0x69ee(%rip) # 0x112e0
movq 0x69ef(%rip), %rdi      # 0x112e8
testq %rdi, %rdi
je 0xa90e
callq 0x2250
movq $0x0, 0x69da(%rip) # 0x112e8
movq 0x69db(%rip), %rdi      # 0x112f0
testq %rdi, %rdi
je 0xa92a
callq 0x2250
movq $0x0, 0x69c6(%rip) # 0x112f0
movq 0x69c7(%rip), %rdi      # 0x112f8
testq %rdi, %rdi
je 0xa946
callq 0x2250
movq $0x0, 0x69b2(%rip) # 0x112f8
popq %rax
retq
// File: /workspace/github_cpp_makefile_star2_O3/ticky[P]ps2iconsys/src/iconsys_builder.cpp
// Function: void PrintColors<IconSys::IconSys_Color>(IconSys::IconSys_Color)
void PrintColors(T t)
{
	std::cout << std::hex << std::setfill('0')
		<< "0x" << std::setw(2) << t.GetR8() << ", 0x" << std::setw(2) << t.GetG8() 
		<< ", 0x" << std::setw(2) << t.GetB8() << ", 0x" << std::setw(2) << t.GetX8() 
		<< std::dec << std::setfill(' ') << std::endl;
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rdi, %rbx
movq 0x6367(%rip), %r14      # 0x10fd8
movq (%r14), %rax
movq -0x18(%rax), %rcx
movl 0x18(%r14,%rcx), %edx
andl $-0x4b, %edx
orl $0x8, %edx
movl %edx, 0x18(%r14,%rcx)
movq -0x18(%rax), %rax
leaq (%r14,%rax), %r15
cmpb $0x0, 0xe1(%r14,%rax)
jne 0xacb0
movq %r15, %rdi
movl $0x20, %esi
callq 0x2190
movb $0x1, 0xe1(%r15)
movb $0x30, 0xe0(%r15)
leaq 0x183f(%rip), %rsi      # 0xc4fe
movl $0x2, %r12d
movl $0x2, %edx
movq %r14, %rdi
callq 0x21f0
movq (%r14), %rax
movq -0x18(%rax), %rax
movq %r12, 0x10(%r14,%rax)
movq %rbx, %rdi
callq 0x5724
movq %r14, %rdi
movl %eax, %esi
callq 0x2330
movq %rax, %r15
leaq 0x1802(%rip), %r14      # 0xc4fc
movl $0x4, %edx
movq %rax, %rdi
movq %r14, %rsi
callq 0x21f0
movq (%r15), %rax
movq -0x18(%rax), %rax
movq %r12, 0x10(%r15,%rax)
movq %rbx, %rdi
callq 0x5734
movq %r15, %rdi
movl %eax, %esi
callq 0x2330
movq %rax, %r15
movl $0x4, %edx
movq %rax, %rdi
movq %r14, %rsi
callq 0x21f0
movq (%r15), %rax
movq -0x18(%rax), %rax
movq %r12, 0x10(%r15,%rax)
movq %rbx, %rdi
callq 0x5744
movq %r15, %rdi
movl %eax, %esi
callq 0x2330
movq %rax, %r15
movl $0x4, %edx
movq %rax, %rdi
movq %r14, %rsi
callq 0x21f0
movq (%r15), %rax
movq -0x18(%rax), %rax
movq %r12, 0x10(%r15,%rax)
movq %rbx, %rdi
callq 0x5754
movq %r15, %rdi
movl %eax, %esi
callq 0x2330
movq %rax, %rbx
movq (%rax), %rax
movq -0x18(%rax), %rcx
movl 0x18(%rbx,%rcx), %edx
andl $-0x4b, %edx
orl $0x2, %edx
movl %edx, 0x18(%rbx,%rcx)
movq -0x18(%rax), %rcx
leaq (%rbx,%rcx), %r14
cmpb $0x0, 0xe1(%rbx,%rcx)
jne 0xadcc
movq %r14, %rdi
movl $0x20, %esi
callq 0x2190
movb $0x1, 0xe1(%r14)
movq (%rbx), %rax
movb $0x20, 0xe0(%r14)
movq -0x18(%rax), %rdi
addq %rbx, %rdi
movl $0xa, %esi
callq 0x2190
movsbl %al, %esi
movq %rbx, %rdi
callq 0x2040
movq %rax, %rdi
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
jmp 0x2120
// File: /workspace/github_cpp_makefile_star2_O3/misohena[P]drawstars/drawstars.cpp
// Function: saturateKeepColor(ColorRGB<double>)
ColorType saturateKeepColor(ColorType c)
{
    const ColorElementType maxValue = std::max(std::max(c.r, c.g), c.b);
    if(maxValue > ColorElementType(1.0)){
        const ColorElementType invMaxValue = ColorElementType(1.0)/maxValue;
        return ColorType(
            c.r * invMaxValue,
            c.g * invMaxValue,
            c.b * invMaxValue);
    }
    else{
        return c;
    }
}

// Assembly:
movq %rdi, %rax
movapd 0x8(%rsp), %xmm0
movapd %xmm0, %xmm3
unpckhpd %xmm0, %xmm3            # xmm3 = xmm3[1],xmm0[1]
maxsd %xmm0, %xmm3
movsd 0x18(%rsp), %xmm1
movapd %xmm1, %xmm2
maxsd %xmm3, %xmm2
ucomisd 0x6b51(%rip), %xmm2     # 0xd060
jbe 0x6533
movsd 0x6b47(%rip), %xmm3     # 0xd060
divsd %xmm2, %xmm3
mulsd %xmm3, %xmm1
unpcklpd %xmm3, %xmm3            # xmm3 = xmm3[0,0]
mulpd %xmm3, %xmm0
movupd %xmm0, (%rax)
movsd %xmm1, 0x10(%rax)
retq
leaq 0x8(%rsp), %rcx
movq 0x10(%rcx), %rdx
movq %rdx, 0x10(%rax)
movups (%rcx), %xmm0
movups %xmm0, (%rax)
retq
// File: /workspace/github_cpp_makefile_star2_O3/misohena[P]drawstars/drawstars.cpp
// Function: writeImageFile(char const*, Image<ColorRGB<double>> const&, int)
bool writeImageFile(const char *filename, const ImageType &image, int jpegQuality)
{
    const std::string ext = std::filesystem::path(filename).extension();
    if(ext == ".jpg" || ext == ".jpeg"){
        return writeJpegFile(filename, image, jpegQuality);
    }
    else if(ext == ".png"){
        return writePNGFile(filename, image);
    }
    else if(ext == ".bmp"){
        return writeBMPFile(filename, image);
    }
    else{
        return writeBMPFile(filename, image);
    }
}

// Assembly:
pushq %rbp
pushq %r14
pushq %rbx
subq $0xa0, %rsp
movl %edx, %ebp
movq %rsi, %rbx
leaq 0x8(%rsp), %rsi
movq %rdi, (%rsi)
leaq 0x78(%rsp), %r14
movq %r14, %rdi
movl $0x2, %edx
callq 0x962c
movq %r14, %rdi
callq 0x4130
testq %rax, %rax
setne %cl
cmpq $-0x1, %rdx
setne %sil
andb %cl, %sil
cmpb $0x1, %sil
jne 0x65d5
leaq 0x30(%rsp), %rdi
movq %rax, %rsi
movq $-0x1, %rcx
callq 0x4300
leaq 0x50(%rsp), %rdi
leaq 0x30(%rsp), %rsi
movl $0x2, %edx
callq 0xa29a
leaq 0x40(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x65df
movq 0x40(%rsp), %rsi
incq %rsi
callq 0x42e0
jmp 0x65df
leaq 0x50(%rsp), %rdi
callq 0xa33e
leaq 0x20(%rsp), %r14
movq %r14, -0x10(%r14)
movq 0x50(%rsp), %rsi
movq 0x58(%rsp), %rdx
addq %rsi, %rdx
leaq 0x10(%rsp), %rdi
callq 0xa3fc
leaq 0x50(%rsp), %rdi
callq 0x96b4
leaq 0x78(%rsp), %rdi
callq 0x96b4
leaq 0x6c26(%rip), %rsi      # 0xd240
leaq 0x10(%rsp), %rdi
callq 0x40c0
testl %eax, %eax
je 0x6672
leaq 0x6c16(%rip), %rsi      # 0xd245
leaq 0x10(%rsp), %rdi
callq 0x40c0
testl %eax, %eax
je 0x6672
leaq 0x6c9d(%rip), %rsi      # 0xd2e1
leaq 0x10(%rsp), %rdi
callq 0x40c0
testl %eax, %eax
je 0x66a8
leaq 0x6bf2(%rip), %rsi      # 0xd24b
leaq 0x10(%rsp), %rdi
callq 0x40c0
movq 0x8(%rsp), %rdi
movq %rbx, %rsi
callq 0x9b93
jmp 0x6681
movq 0x8(%rsp), %rdi
movq %rbx, %rsi
movl %ebp, %edx
callq 0x96ec
movl %eax, %ebx
movq 0x10(%rsp), %rdi
cmpq %r14, %rdi
je 0x669a
movq 0x20(%rsp), %rsi
incq %rsi
callq 0x42e0
movl %ebx, %eax
addq $0xa0, %rsp
popq %rbx
popq %r14
popq %rbp
retq
movq 0x8(%rsp), %rdi
movq %rbx, %rsi
callq 0x98dc
jmp 0x6681
movq %rax, %rbx
leaq 0x40(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x6705
movq 0x40(%rsp), %rsi
incq %rsi
callq 0x42e0
jmp 0x6705
movq %rax, %rbx
jmp 0x6705
movq %rax, %rbx
movq 0x10(%rsp), %rdi
cmpq %r14, %rdi
je 0x670f
movq 0x20(%rsp), %rsi
incq %rsi
callq 0x42e0
jmp 0x670f
movq %rax, %rbx
leaq 0x50(%rsp), %rdi
callq 0x96b4
leaq 0x78(%rsp), %rdi
callq 0x96b4
movq %rbx, %rdi
callq 0x4510
// File: /workspace/github_cpp_makefile_star2_O3/misohena[P]drawstars/drawstars.cpp
// Function: temperatureToRGB(double)
ColorType temperatureToRGB(double k)
{
    k = clamp(k, 1000.0, 40000.0) / 100.0;
    return ColorType(
        k <= 66.0 ? 1.0 : clamp(1.29293618606274509804 * std::pow(k - 60.0, -0.1332047592), 0.0, 1.0),
        k <= 66.0 ? clamp(0.39008157876901960784 * std::log(k) - 0.63184144378862745098, 0.0, 1.0) : clamp(1.12989086089529411765 * std::pow(k - 60.0, -0.0755148492), 0.0, 1.0),
        k >= 66.0 ? 1.0 : k <= 19.0 ? 0.0 : clamp(0.54320678911019607843 * std::log(k - 10.0) - 1.19625408914, 0.0, 1.0) );
}

// Assembly:
pushq %rbx
subq $0x30, %rsp
movsd 0x694c(%rip), %xmm2     # 0xd070
minsd %xmm0, %xmm2
divsd 0x6948(%rip), %xmm2     # 0xd078
cmpltsd 0x6947(%rip), %xmm0     # 0xd080
movq %rdi, %rbx
movsd 0x6944(%rip), %xmm1     # 0xd088
andpd %xmm0, %xmm1
andnpd %xmm2, %xmm0
orpd %xmm1, %xmm0
movsd 0x6938(%rip), %xmm1     # 0xd090
ucomisd %xmm0, %xmm1
movapd %xmm0, 0x10(%rsp)
jae 0x67d2
movsd 0x693c(%rip), %xmm2     # 0xd0a8
addsd %xmm0, %xmm2
movsd %xmm2, 0x28(%rsp)
movsd 0x6932(%rip), %xmm1     # 0xd0b0
movapd %xmm2, %xmm0
callq 0x44f0
mulsd 0x6929(%rip), %xmm0     # 0xd0b8
movsd 0x68c9(%rip), %xmm2     # 0xd060
minsd %xmm0, %xmm2
xorpd %xmm1, %xmm1
cmpltsd %xmm1, %xmm0
andnpd %xmm2, %xmm0
movapd %xmm0, (%rsp)
movsd 0x690b(%rip), %xmm1     # 0xd0c0
movsd 0x28(%rsp), %xmm0
callq 0x44f0
movaps (%rsp), %xmm3
movapd %xmm0, %xmm4
mulsd 0x68f8(%rip), %xmm4     # 0xd0c8
jmp 0x67f3
callq 0x4250
movapd %xmm0, %xmm4
mulsd 0x68b5(%rip), %xmm4     # 0xd098
addsd 0x68b5(%rip), %xmm4     # 0xd0a0
movsd 0x686d(%rip), %xmm3     # 0xd060
movsd 0x6865(%rip), %xmm5     # 0xd060
movapd 0x10(%rsp), %xmm2
ucomisd 0x6887(%rip), %xmm2     # 0xd090
movapd %xmm5, %xmm0
jae 0x6877
xorpd %xmm0, %xmm0
movsd 0x68b5(%rip), %xmm1     # 0xd0d0
ucomisd %xmm2, %xmm1
jae 0x6877
movsd 0x68af(%rip), %xmm0     # 0xd0d8
addsd %xmm2, %xmm0
movaps %xmm3, (%rsp)
movapd %xmm4, 0x10(%rsp)
callq 0x4250
movsd 0x681c(%rip), %xmm5     # 0xd060
movapd 0x10(%rsp), %xmm4
movaps (%rsp), %xmm3
mulsd 0x688a(%rip), %xmm0     # 0xd0e0
addsd 0x688a(%rip), %xmm0     # 0xd0e8
movsd 0x67fa(%rip), %xmm1     # 0xd060
minsd %xmm0, %xmm1
xorpd %xmm2, %xmm2
cmpltsd %xmm2, %xmm0
andnpd %xmm1, %xmm0
minsd %xmm4, %xmm5
xorpd %xmm1, %xmm1
cmpltsd %xmm1, %xmm4
andnpd %xmm5, %xmm4
movsd %xmm3, (%rbx)
movlpd %xmm4, 0x8(%rbx)
movsd %xmm0, 0x10(%rbx)
movq %rbx, %rax
addq $0x30, %rsp
popq %rbx
retq