LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_cpp_makefile_star2_O3/orbitcowboy[P]gnuplot-cpp/./gnuplot_i.hpp
// Function: Gnuplot::reset_all()
Gnuplot& Gnuplot::reset_all(void)
{
    //  remove_tmpfiles();

    nplots = 0;
    (void)cmd("reset");
    (void)cmd("clear");
    pstyle = "points";
    smooth.clear();
    showonscreen();

    return *this;
}

// Assembly:
pushq %r14
pushq %rbx
subq $0x28, %rsp
movq %rdi, %rbx
movl $0x0, 0xc(%rdi)
leaq 0x18(%rsp), %r14
movq %r14, -0x10(%r14)
leaq 0x97b7(%rip), %rsi      # 0xd194
leaq 0x97b5(%rip), %rdx      # 0xd199
leaq 0x8(%rsp), %rdi
callq 0xc700
leaq 0x8(%rsp), %rsi
movq %rbx, %rdi
callq 0x3aba
movq 0x8(%rsp), %rdi
cmpq %r14, %rdi
je 0x3a12
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x3210
leaq 0x8(%rsp), %rdi
movq %r14, (%rdi)
leaq 0x9779(%rip), %rsi      # 0xd19a
leaq 0x9777(%rip), %rdx      # 0xd19f
callq 0xc700
leaq 0x8(%rsp), %rsi
movq %rbx, %rdi
callq 0x3aba
movq 0x8(%rsp), %rdi
cmpq %r14, %rdi
je 0x3a51
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x3210
leaq 0x10(%rbx), %rdi
movq 0x18(%rbx), %rdx
leaq 0x9d74(%rip), %rcx      # 0xd7d4
movl $0x6, %r8d
xorl %esi, %esi
callq 0x3320
movq $0x0, 0x38(%rbx)
movq 0x30(%rbx), %rax
movb $0x0, (%rax)
movq %rbx, %rdi
callq 0x3ba8
movq %rbx, %rax
addq $0x28, %rsp
popq %rbx
popq %r14
retq
jmp 0x3a93
jmp 0x3aaf
movq %rax, %rbx
movq 0x8(%rsp), %rdi
cmpq %r14, %rdi
je 0x3ab2
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x3210
jmp 0x3ab2
movq %rax, %rbx
movq %rbx, %rdi
callq 0x33f0
// File: /workspace/github_cpp_makefile_star2_O3/orbitcowboy[P]gnuplot-cpp/./gnuplot_i.hpp
// Function: Gnuplot::cmd(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&)
Gnuplot& Gnuplot::cmd(const std::string &cmdstr)
{
    if( !(valid) )
    {
        return *this;
    }


    // int fputs ( const char * str, FILE * stream );
    // writes the string str to the stream.
    // The function begins copying from the address specified (str) until it
    // reaches the terminating null character ('\0'). This final
    // null-character is not copied to the stream.
    fputs( (cmdstr + "\n").c_str(), gnucmd );

    // int fflush ( FILE * stream );
    // If the given stream was open for writing and the last i/o operation was
    // an output operation, any unwritten data in the output buffer is written
    // to the file.  If the argument is a null pointer, all open files are
    // flushed.  The stream remains open after this call.
    fflush(gnucmd);

    if( cmdstr.find("splot") != std::string::npos )
    {
        two_dim = false;
        ++nplots;
        return *this;
    }
    else if( cmdstr.find("plot") != std::string::npos )
    {
        two_dim = true;
        ++nplots;
        return *this;
    }
    else
    {
        return *this;
    }
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x28, %rsp
movq %rdi, %rbx
cmpb $0x1, 0x8(%rdi)
jne 0x3b76
movq %rsi, %r14
leaq 0x18(%rsp), %r12
movq %r12, -0x10(%r12)
movq (%rsi), %rsi
movq 0x8(%r14), %rdx
addq %rsi, %rdx
leaq 0x8(%rsp), %r15
movq %r15, %rdi
callq 0xc66a
leaq 0x985d(%rip), %rsi      # 0xd35a
movq %r15, %rdi
callq 0x3420
movq 0x8(%rsp), %rdi
movq (%rbx), %rsi
callq 0x3240
movq 0x8(%rsp), %rdi
cmpq %r12, %rdi
je 0x3b29
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x3210
movq (%rbx), %rdi
callq 0x3260
leaq 0x9824(%rip), %rsi      # 0xd35c
xorl %r15d, %r15d
movl $0x5, %ecx
movq %r14, %rdi
xorl %edx, %edx
callq 0x33e0
cmpq $-0x1, %rax
jne 0x3b6f
leaq 0x9e67(%rip), %rsi      # 0xd9be
movl $0x4, %ecx
movq %r14, %rdi
xorl %edx, %edx
callq 0x33e0
movb $0x1, %r15b
cmpq $-0x1, %rax
je 0x3b76
movb %r15b, 0x9(%rbx)
incl 0xc(%rbx)
movq %rbx, %rax
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
movq %rax, %rbx
movq 0x8(%rsp), %rdi
cmpq %r12, %rdi
je 0x3b9f
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x3210
movq %rbx, %rdi
callq 0x33f0
nop
// File: /workspace/github_cpp_makefile_star2_O3/orbitcowboy[P]gnuplot-cpp/./gnuplot_i.hpp
// Function: Gnuplot::set_smooth(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&)
Gnuplot& Gnuplot::set_smooth(const std::string &stylestr)
{
    if (stylestr.find("unique")    == std::string::npos  &&
            stylestr.find("frequency") == std::string::npos  &&
            stylestr.find("csplines")  == std::string::npos  &&
            stylestr.find("bezier")    == std::string::npos  )
    {
        smooth.clear();
    }
    else
    {
        smooth = stylestr;
    }

    return *this;
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %r14
movq %rdi, %rbx
leaq 0x94df(%rip), %rsi      # 0xd1a0
movl $0x6, %ecx
movq %r14, %rdi
xorl %edx, %edx
callq 0x33e0
cmpq $-0x1, %rax
jne 0x3d2a
leaq 0x94ca(%rip), %rsi      # 0xd1a7
movl $0x9, %ecx
movq %r14, %rdi
xorl %edx, %edx
callq 0x33e0
cmpq $-0x1, %rax
jne 0x3d2a
leaq 0x94b8(%rip), %rsi      # 0xd1b1
movl $0x8, %ecx
movq %r14, %rdi
xorl %edx, %edx
callq 0x33e0
cmpq $-0x1, %rax
jne 0x3d2a
leaq 0x94a5(%rip), %rsi      # 0xd1ba
movl $0x6, %ecx
movq %r14, %rdi
xorl %edx, %edx
callq 0x33e0
cmpq $-0x1, %rax
je 0x3d41
leaq 0x30(%rbx), %rdi
movq %r14, %rsi
callq 0x3150
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
movq $0x0, 0x38(%rbx)
movq 0x30(%rbx), %rax
movb $0x0, (%rax)
jmp 0x3d36
// File: /workspace/github_cpp_makefile_star2_O3/orbitcowboy[P]gnuplot-cpp/./gnuplot_i.hpp
// Function: Gnuplot::savetofigure(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&)
Gnuplot& Gnuplot::savetofigure(const std::string &filename,
                               const std::string &terminal)
{
    std::ostringstream cmdstr;
    cmdstr << "set terminal " << terminal;
    (void)cmd(cmdstr.str() );

    cmdstr.str("");     // Clear cmdstr
    cmdstr << "set output \"" << filename << "\"";
    return cmd(cmdstr.str());
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x198, %rsp            # imm = 0x198
movq %rdx, %r15
movq %rsi, %r14
movq %rdi, %rbx
leaq 0x20(%rsp), %r12
movq %r12, %rdi
callq 0x32b0
leaq 0x944f(%rip), %rsi      # 0xd1cc
movl $0xd, %edx
movq %r12, %rdi
callq 0x3250
movq (%r15), %rsi
movq 0x8(%r15), %rdx
leaq 0x20(%rsp), %rdi
callq 0x3250
leaq 0x28(%rsp), %r15
movq %rsp, %rdi
movq %r15, %rsi
callq 0x3340
movq %rsp, %rsi
movq %rbx, %rdi
callq 0x3aba
leaq 0x10(%rsp), %r12
movq -0x10(%r12), %rdi
cmpq %r12, %rdi
je 0x3dd2
movq 0x10(%rsp), %rsi
incq %rsi
callq 0x3210
movq %rsp, %rdi
movq %r12, (%rdi)
leaq 0x957c(%rip), %rdx      # 0xd35b
movq %rdx, %rsi
callq 0xc700
movq %rsp, %rsi
movq %r15, %rdi
callq 0x32f0
movq (%rsp), %rdi
cmpq %r12, %rdi
je 0x3e08
movq 0x10(%rsp), %rsi
incq %rsi
callq 0x3210
leaq 0x93cb(%rip), %rsi      # 0xd1da
leaq 0x20(%rsp), %rdi
movl $0xc, %edx
callq 0x3250
movq (%r14), %rsi
movq 0x8(%r14), %rdx
leaq 0x20(%rsp), %rdi
callq 0x3250
leaq 0x960c(%rip), %rsi      # 0xd442
movl $0x1, %edx
movq %rax, %rdi
callq 0x3250
movq %rsp, %rdi
movq %r15, %rsi
callq 0x3340
movq %rsp, %rsi
movq %rbx, %rdi
callq 0x3aba
movq (%rsp), %rdi
cmpq %r12, %rdi
je 0x3e6f
movq 0x10(%rsp), %rsi
incq %rsi
callq 0x3210
movq 0xd13a(%rip), %rsi      # 0x10fb0
leaq 0x20(%rsp), %rdi
callq 0x3140
leaq 0x90(%rsp), %rdi
callq 0x30c0
movq %rbx, %rax
addq $0x198, %rsp            # imm = 0x198
popq %rbx
popq %r12
popq %r14
popq %r15
retq
jmp 0x3ea3
jmp 0x3ed5
movq %rax, %rbx
movq (%rsp), %rdi
cmpq %r12, %rdi
jne 0x3ec4
jmp 0x3ed8
jmp 0x3ed5
movq %rax, %rbx
leaq 0x10(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x3ed8
movq 0x10(%rsp), %rsi
incq %rsi
callq 0x3210
jmp 0x3ed8
jmp 0x3ed5
movq %rax, %rbx
movq 0xd0d1(%rip), %rsi      # 0x10fb0
leaq 0x20(%rsp), %rdi
callq 0x3140
leaq 0x90(%rsp), %rdi
callq 0x30c0
movq %rbx, %rdi
callq 0x33f0
// File: /workspace/github_cpp_makefile_star2_O3/orbitcowboy[P]gnuplot-cpp/./gnuplot_i.hpp
// Function: Gnuplot::set_contour(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&)
Gnuplot& Gnuplot::set_contour(const std::string &position)
{
    if (position.find("base")    == std::string::npos  &&
            position.find("surface") == std::string::npos  &&
            position.find("both")    == std::string::npos  )
    {
        return cmd("set contour base");
    }

    return cmd("set contour " + position);
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
subq $0x20, %rsp
movq %rsi, %r14
movq %rdi, %rbx
leaq 0x8cb5(%rip), %rsi      # 0xd25d
movl $0x4, %ecx
movq %r14, %rdi
xorl %edx, %edx
callq 0x33e0
cmpq $-0x1, %rax
jne 0x45f5
leaq 0x9412(%rip), %rsi      # 0xd9d6
movl $0x7, %ecx
movq %r14, %rdi
xorl %edx, %edx
callq 0x33e0
cmpq $-0x1, %rax
jne 0x45f5
leaq 0x8c6c(%rip), %rsi      # 0xd24c
movl $0x4, %ecx
movq %r14, %rdi
xorl %edx, %edx
callq 0x33e0
cmpq $-0x1, %rax
je 0x463d
leaq 0x8c66(%rip), %rsi      # 0xd262
movq %rsp, %r15
movq %r15, %rdi
movq %r14, %rdx
callq 0xb4a4
movq %rbx, %rdi
movq %r15, %rsi
callq 0x3aba
leaq 0x10(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x4630
movq 0x10(%rsp), %rsi
incq %rsi
callq 0x3210
movq %rbx, %rax
addq $0x20, %rsp
popq %rbx
popq %r14
popq %r15
retq
leaq 0x10(%rsp), %r14
movq %r14, -0x10(%r14)
leaq 0x8c04(%rip), %rsi      # 0xd251
leaq 0x8c0d(%rip), %rdx      # 0xd261
movq %rsp, %rdi
callq 0xc700
movq %rsp, %rsi
movq %rbx, %rdi
callq 0x3aba
movq (%rsp), %rdi
cmpq %r14, %rdi
jne 0x4623
jmp 0x4630
movq %rax, %rbx
movq (%rsp), %rdi
cmpq %r14, %rdi
jne 0x4696
jmp 0x46a3
movq %rax, %rbx
jmp 0x46a3
movq %rax, %rbx
leaq 0x10(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x46a3
movq 0x10(%rsp), %rsi
incq %rsi
callq 0x3210
movq %rbx, %rdi
callq 0x33f0
nop
// File: /workspace/github_cpp_makefile_star2_O3/orbitcowboy[P]gnuplot-cpp/./gnuplot_i.hpp
// Function: Gnuplot::plot_slope(double, double, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&)
Gnuplot& Gnuplot::plot_slope(const double a,
                             const double b,
                             const std::string &title)
{
    std::ostringstream cmdstr;
    //
    // command to be sent to gnuplot
    //
    if (nplots > 0  &&  two_dim == true)
    {
        cmdstr << "replot ";
    }
    else
    {
        cmdstr << "plot ";
    }

    cmdstr << a << " * x + " << b << " title \"";

    if (title.empty())
    {
        cmdstr << "f(x) = " << a << " * x + " << b;
    }
    else
    {
        cmdstr << title;
    }

    cmdstr << "\" with " << pstyle;

    //
    // Do the actual plot
    //
    return cmd(cmdstr.str());
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
subq $0x1b0, %rsp            # imm = 0x1B0
movq %rsi, %r14
movsd %xmm1, 0x8(%rsp)
movsd %xmm0, 0x10(%rsp)
movq %rdi, %rbx
leaq 0x38(%rsp), %r15
movq %r15, %rdi
callq 0x32b0
cmpl $0x0, 0xc(%rbx)
setg %al
andb 0x9(%rbx), %al
leaq 0x840b(%rip), %rcx      # 0xd2cb
leaq 0x8406(%rip), %rsi      # 0xd2cd
cmovneq %rcx, %rsi
movzbl %al, %eax
leaq 0x5(,%rax,2), %rdx
movq %r15, %rdi
callq 0x3250
leaq 0x38(%rsp), %rdi
movsd 0x10(%rsp), %xmm0
callq 0x3350
movq %rax, %r15
leaq 0x83db(%rip), %rsi      # 0xd2d3
movl $0x7, %edx
movq %rax, %rdi
callq 0x3250
movq %r15, %rdi
movsd 0x8(%rsp), %xmm0
callq 0x3350
leaq 0x8437(%rip), %rsi      # 0xd351
movl $0x8, %edx
movq %rax, %rdi
callq 0x3250
movq 0x8(%r14), %rdx
testq %rdx, %rdx
je 0x4f3f
movq (%r14), %rsi
leaq 0x38(%rsp), %rdi
callq 0x3250
jmp 0x4f8a
leaq 0x8395(%rip), %rsi      # 0xd2db
leaq 0x38(%rsp), %rdi
movl $0x7, %edx
callq 0x3250
leaq 0x38(%rsp), %rdi
movsd 0x10(%rsp), %xmm0
callq 0x3350
movq %rax, %r14
leaq 0x8364(%rip), %rsi      # 0xd2d3
movl $0x7, %edx
movq %rax, %rdi
callq 0x3250
movq %r14, %rdi
movsd 0x8(%rsp), %xmm0
callq 0x3350
leaq 0x8352(%rip), %rsi      # 0xd2e3
leaq 0x38(%rsp), %rdi
movl $0x7, %edx
callq 0x3250
movq 0x10(%rbx), %rsi
movq 0x18(%rbx), %rdx
leaq 0x38(%rsp), %rdi
callq 0x3250
leaq 0x40(%rsp), %rsi
leaq 0x18(%rsp), %rdi
callq 0x3340
leaq 0x18(%rsp), %rsi
movq %rbx, %rdi
callq 0x3aba
leaq 0x28(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x4fe9
movq 0x28(%rsp), %rsi
incq %rsi
callq 0x3210
movq 0xbfc0(%rip), %rsi      # 0x10fb0
leaq 0x38(%rsp), %rdi
callq 0x3140
leaq 0xa8(%rsp), %rdi
callq 0x30c0
movq %rbx, %rax
addq $0x1b0, %rsp            # imm = 0x1B0
popq %rbx
popq %r14
popq %r15
retq
movq %rax, %rbx
leaq 0x28(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x503c
movq 0x28(%rsp), %rsi
incq %rsi
callq 0x3210
jmp 0x503c
jmp 0x5039
movq %rax, %rbx
movq 0xbf6d(%rip), %rsi      # 0x10fb0
leaq 0x38(%rsp), %rdi
callq 0x3140
leaq 0xa8(%rsp), %rdi
callq 0x30c0
movq %rbx, %rdi
callq 0x33f0
// File: /workspace/github_cpp_makefile_star2_O3/orbitcowboy[P]gnuplot-cpp/./gnuplot_i.hpp
// Function: Gnuplot::plot_equation(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&)
Gnuplot& Gnuplot::plot_equation(const std::string &equation,
                                const std::string &title)
{
    std::ostringstream cmdstr;
    //
    // command to be sent to gnuplot
    //
    if (nplots > 0  &&  two_dim == true)
    {
        cmdstr << "replot ";
    }
    else
    {
        cmdstr << "plot ";
    }

    cmdstr << equation;

    if (title.empty())
    {
        cmdstr << " notitle";
    }
    else
    {
        cmdstr << " title \"" << title << "\"";
    }

    cmdstr << " with " << pstyle;

    //
    // Do the actual plot
    //
    return cmd(cmdstr.str());
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x198, %rsp            # imm = 0x198
movq %rdx, %r14
movq %rsi, %r15
movq %rdi, %rbx
leaq 0x20(%rsp), %r12
movq %r12, %rdi
callq 0x32b0
cmpl $0x0, 0xc(%rbx)
setg %al
andb 0x9(%rbx), %al
leaq 0x8234(%rip), %rcx      # 0xd2cb
leaq 0x822f(%rip), %rsi      # 0xd2cd
cmovneq %rcx, %rsi
movzbl %al, %eax
leaq 0x5(,%rax,2), %rdx
movq %r12, %rdi
callq 0x3250
movq (%r15), %rsi
movq 0x8(%r15), %rdx
leaq 0x20(%rsp), %r15
movq %r15, %rdi
callq 0x3250
cmpq $0x0, 0x8(%r14)
je 0x5108
leaq 0x827a(%rip), %rsi      # 0xd351
leaq 0x20(%rsp), %rdi
movl $0x8, %edx
callq 0x3250
movq (%r14), %rsi
movq 0x8(%r14), %rdx
leaq 0x20(%rsp), %rdi
callq 0x3250
movq %rax, %r15
movl $0x1, %edx
leaq 0x833c(%rip), %rsi      # 0xd442
jmp 0x5114
movl $0x8, %edx
leaq 0x81d7(%rip), %rsi      # 0xd2eb
movq %r15, %rdi
callq 0x3250
leaq 0x81c1(%rip), %rsi      # 0xd2e4
leaq 0x20(%rsp), %rdi
movl $0x6, %edx
callq 0x3250
movq 0x10(%rbx), %rsi
movq 0x18(%rbx), %rdx
leaq 0x20(%rsp), %rdi
callq 0x3250
leaq 0x28(%rsp), %rsi
movq %rsp, %rdi
callq 0x3340
movq %rsp, %rsi
movq %rbx, %rdi
callq 0x3aba
leaq 0x10(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x5177
movq 0x10(%rsp), %rsi
incq %rsi
callq 0x3210
movq 0xbe32(%rip), %rsi      # 0x10fb0
leaq 0x20(%rsp), %rdi
callq 0x3140
leaq 0x90(%rsp), %rdi
callq 0x30c0
movq %rbx, %rax
addq $0x198, %rsp            # imm = 0x198
popq %rbx
popq %r12
popq %r14
popq %r15
retq
movq %rax, %rbx
leaq 0x10(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x51cc
movq 0x10(%rsp), %rsi
incq %rsi
callq 0x3210
jmp 0x51cc
jmp 0x51c9
movq %rax, %rbx
movq 0xbddd(%rip), %rsi      # 0x10fb0
leaq 0x20(%rsp), %rdi
callq 0x3140
leaq 0x90(%rsp), %rdi
callq 0x30c0
movq %rbx, %rdi
callq 0x33f0
// File: /workspace/github_cpp_makefile_star2_O3/orbitcowboy[P]gnuplot-cpp/./gnuplot_i.hpp
// Function: Gnuplot::plot_equation3d(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&)
Gnuplot& Gnuplot::plot_equation3d(const std::string &equation,
                                  const std::string &title)
{
    std::ostringstream cmdstr;
    //
    // command to be sent to gnuplot
    //
    if (nplots > 0  &&  two_dim == false)
    {
        cmdstr << "replot ";
    }
    else
    {
        cmdstr << "splot ";
    }

    cmdstr << equation << " title \"";

    if (title.empty())
    {
        cmdstr << "f(x,y) = " << equation;
    }
    else
    {
        cmdstr << title;
    }

    cmdstr << "\" with " << pstyle;

    //
    // Do the actual plot
    //
    return cmd(cmdstr.str());
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x198, %rsp            # imm = 0x198
movq %rdx, %r15
movq %rsi, %r14
movq %rdi, %rbx
leaq 0x20(%rsp), %r12
movq %r12, %rdi
callq 0x32b0
cmpl $0x0, 0xc(%rbx)
setg %al
cmpb $0x0, 0x9(%rbx)
sete %cl
andb %al, %cl
leaq 0x809e(%rip), %rax      # 0xd2cb
leaq 0x80c0(%rip), %rsi      # 0xd2f4
cmovneq %rax, %rsi
movzbl %cl, %edx
orq $0x6, %rdx
movq %r12, %rdi
callq 0x3250
movq (%r14), %rsi
movq 0x8(%r14), %rdx
leaq 0x20(%rsp), %rdi
callq 0x3250
leaq 0x80f2(%rip), %rsi      # 0xd351
movl $0x8, %edx
movq %rax, %rdi
callq 0x3250
movq 0x8(%r15), %rdx
testq %rdx, %rdx
jne 0x5292
leaq 0x807f(%rip), %rsi      # 0xd2fb
leaq 0x20(%rsp), %rdi
movl $0x9, %edx
callq 0x3250
movq 0x8(%r14), %rdx
movq %r14, %r15
movq (%r15), %rsi
leaq 0x20(%rsp), %rdi
callq 0x3250
leaq 0x803d(%rip), %rsi      # 0xd2e3
leaq 0x20(%rsp), %rdi
movl $0x7, %edx
callq 0x3250
movq 0x10(%rbx), %rsi
movq 0x18(%rbx), %rdx
leaq 0x20(%rsp), %rdi
callq 0x3250
leaq 0x28(%rsp), %rsi
movq %rsp, %rdi
callq 0x3340
movq %rsp, %rsi
movq %rbx, %rdi
callq 0x3aba
leaq 0x10(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x52fa
movq 0x10(%rsp), %rsi
incq %rsi
callq 0x3210
movq 0xbcaf(%rip), %rsi      # 0x10fb0
leaq 0x20(%rsp), %rdi
callq 0x3140
leaq 0x90(%rsp), %rdi
callq 0x30c0
movq %rbx, %rax
addq $0x198, %rsp            # imm = 0x198
popq %rbx
popq %r12
popq %r14
popq %r15
retq
movq %rax, %rbx
leaq 0x10(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x534f
movq 0x10(%rsp), %rsi
incq %rsi
callq 0x3210
jmp 0x534f
jmp 0x534c
movq %rax, %rbx
movq 0xbc5a(%rip), %rsi      # 0x10fb0
leaq 0x20(%rsp), %rdi
callq 0x3140
leaq 0x90(%rsp), %rdi
callq 0x30c0
movq %rbx, %rdi
callq 0x33f0
nop
// File: /workspace/github_cpp_makefile_star2_O3/orbitcowboy[P]gnuplot-cpp/./gnuplot_i.hpp
// Function: Gnuplot::file_available(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&)
bool Gnuplot::file_available(const std::string &filename)
{
    std::ostringstream except;
    if( Gnuplot::file_exists(filename, 0) ) // check existence
    {
        if( !(Gnuplot::file_exists(filename, 4)) ) // check read permission
        {
            except << "No read permission for File \"" << filename << "\"";
            throw GnuplotException( except.str() );
        }
        return true;
    }
    except << "File \"" << filename << "\" does not exist";
    throw GnuplotException( except.str() );
}

// Assembly:
pushq %rbp
pushq %r14
pushq %rbx
subq $0x1a0, %rsp            # imm = 0x1A0
movq %rdi, %rbx
leaq 0x28(%rsp), %rdi
callq 0x32b0
movq (%rbx), %rdi
xorl %esi, %esi
callq 0x3380
testl %eax, %eax
jne 0x55e1
movq (%rbx), %rdi
movl $0x4, %esi
callq 0x3380
testl %eax, %eax
jne 0x566f
movq 0xb9f4(%rip), %rsi      # 0x10fb0
leaq 0x28(%rsp), %rdi
callq 0x3140
leaq 0x98(%rsp), %rdi
callq 0x30c0
movb $0x1, %al
addq $0x1a0, %rsp            # imm = 0x1A0
popq %rbx
popq %r14
popq %rbp
retq
leaq 0x7e55(%rip), %rsi      # 0xd43d
leaq 0x28(%rsp), %rdi
movl $0x6, %edx
callq 0x3250
movq (%rbx), %rsi
movq 0x8(%rbx), %rdx
leaq 0x28(%rsp), %rdi
callq 0x3250
leaq 0x7e35(%rip), %rsi      # 0xd444
movl $0x10, %edx
movq %rax, %rdi
callq 0x3250
movl $0x10, %edi
callq 0x3120
movq %rax, %r14
leaq 0x30(%rsp), %rsi
leaq 0x8(%rsp), %rdi
callq 0x3340
movb $0x1, %bpl
leaq 0x8(%rsp), %rsi
movq %r14, %rdi
callq 0x32a0
leaq 0xb711(%rip), %rax      # 0x10d60
movq %rax, (%r14)
xorl %ebp, %ebp
leaq 0xb6dd(%rip), %rsi      # 0x10d38
movq 0xb956(%rip), %rdx      # 0x10fb8
movq %r14, %rdi
callq 0x33c0
jmp 0x56f8
leaq 0x7db0(%rip), %rsi      # 0xd426
leaq 0x28(%rsp), %rdi
movl $0x1d, %edx
callq 0x3250
movq (%rbx), %rsi
movq 0x8(%rbx), %rdx
leaq 0x28(%rsp), %rdi
callq 0x3250
leaq 0x7da5(%rip), %rsi      # 0xd442
movl $0x1, %edx
movq %rax, %rdi
callq 0x3250
movl $0x10, %edi
callq 0x3120
movq %rax, %r14
leaq 0x30(%rsp), %rsi
leaq 0x8(%rsp), %rdi
callq 0x3340
movb $0x1, %bpl
leaq 0x8(%rsp), %rsi
movq %r14, %rdi
callq 0x32a0
leaq 0xb683(%rip), %rax      # 0x10d60
movq %rax, (%r14)
xorl %ebp, %ebp
leaq 0xb64f(%rip), %rsi      # 0x10d38
movq 0xb8c8(%rip), %rdx      # 0x10fb8
movq %r14, %rdi
callq 0x33c0
jmp 0x56fc
jmp 0x5721
movq %rax, %rbx
leaq 0x18(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x571a
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x3210
testb %bpl, %bpl
jne 0x5724
jmp 0x5731
movq %rax, %rbx
movq %r14, %rdi
callq 0x3190
jmp 0x5731
movq %rax, %rbx
movq 0xb878(%rip), %rsi      # 0x10fb0
leaq 0x28(%rsp), %rdi
callq 0x3140
leaq 0x98(%rsp), %rdi
callq 0x30c0
movq %rbx, %rdi
callq 0x33f0
nop
// File: /workspace/github_cpp_makefile_star2_O3/rossy[P]crossc/SPIRV-Cross/spirv_cfg.cpp
// Function: spirv_cross::CFG::CFG(spirv_cross::Compiler&, spirv_cross::SPIRFunction const&)
CFG::CFG(Compiler &compiler_, const SPIRFunction &func_)
    : compiler(compiler_)
    , func(func_)
{
	preceding_edges.resize(compiler.get_current_id_bound());
	succeeding_edges.resize(compiler.get_current_id_bound());
	visit_order.resize(compiler.get_current_id_bound());
	immediate_dominators.resize(compiler.get_current_id_bound());

	build_post_order_visit_order();
	build_immediate_dominators();
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rdi, %r14
movq %rsi, (%rdi)
movq %rdx, 0x8(%rdi)
leaq 0x10(%rdi), %rbx
leaq 0x28(%rdi), %r15
leaq 0x40(%rdi), %r12
leaq 0x58(%rdi), %r13
xorps %xmm0, %xmm0
movups %xmm0, 0x10(%rdi)
movups %xmm0, 0x20(%rdi)
movups %xmm0, 0x30(%rdi)
movups %xmm0, 0x40(%rdi)
movups %xmm0, 0x50(%rdi)
movups %xmm0, 0x60(%rdi)
movups %xmm0, 0x70(%rdi)
movups %xmm0, 0x7c(%rdi)
movq 0x28(%rsi), %rax
subq 0x20(%rsi), %rax
shrq $0x4, %rax
movl %eax, %esi
movq %rbx, %rdi
callq 0x777c
movq (%r14), %rax
movq 0x28(%rax), %rcx
subq 0x20(%rax), %rcx
shrq $0x4, %rcx
movl %ecx, %esi
movq %r15, %rdi
callq 0x777c
movq (%r14), %rax
movq 0x28(%rax), %rcx
subq 0x20(%rax), %rcx
shrq $0x4, %rcx
movl %ecx, %esi
movq %r13, %rdi
callq 0x77b8
movq (%r14), %rax
movq 0x28(%rax), %rcx
subq 0x20(%rax), %rcx
shrq $0x4, %rcx
movl %ecx, %esi
movq %r12, %rdi
callq 0x77ea
movq %r14, %rdi
callq 0x7294
movq %r14, %rdi
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x72f0
movq %rax, %rbp
movq 0x70(%r14), %rdi
testq %rdi, %rdi
je 0x726e
movq 0x80(%r14), %rsi
subq %rdi, %rsi
callq 0x6260
movq %r13, %rdi
movq %r12, %rsi
movq %r14, %rdx
callq 0x6520
movq %r15, %rdi
callq 0x781c
movq %rbx, %rdi
callq 0x781c
movq %rbp, %rdi
callq 0x64a0
// File: /workspace/github_cpp_makefile_star2_O3/rossy[P]crossc/SPIRV-Cross/spirv_cfg.cpp
// Function: spirv_cross::CFG::build_post_order_visit_order()
void CFG::build_post_order_visit_order()
{
	uint32_t block = func.entry_block;
	visit_count = 0;
	fill(begin(visit_order), end(visit_order), -1);
	post_order.clear();
	post_order_visit(block);
}

// Assembly:
pushq %rbp
pushq %rbx
pushq %rax
movq %rdi, %rbx
movq 0x8(%rdi), %rax
movq 0x58(%rdi), %rdi
movl 0x60(%rax), %ebp
movl $0x0, 0x88(%rbx)
movq 0x60(%rbx), %rdx
cmpq %rdx, %rdi
je 0x72d1
subq %rdi, %rdx
addq $-0x4, %rdx
andq $-0x4, %rdx
addq $0x4, %rdx
movl $0xff, %esi
callq 0x6180
movq 0x70(%rbx), %rax
cmpq %rax, 0x78(%rbx)
je 0x72df
movq %rax, 0x78(%rbx)
movq %rbx, %rdi
movl %ebp, %esi
addq $0x8, %rsp
popq %rbx
popq %rbp
jmp 0x741e
nop
// File: /workspace/github_cpp_makefile_star2_O3/rossy[P]crossc/SPIRV-Cross/spirv_cfg.cpp
// Function: spirv_cross::CFG::build_immediate_dominators()
void CFG::build_immediate_dominators()
{
	// Traverse the post-order in reverse and build up the immediate dominator tree.
	fill(begin(immediate_dominators), end(immediate_dominators), 0);
	immediate_dominators[func.entry_block] = func.entry_block;

	for (auto i = post_order.size(); i; i--)
	{
		uint32_t block = post_order[i - 1];
		auto &pred = preceding_edges[block];
		if (pred.empty()) // This is for the entry block, but we've already set up the dominators.
			continue;

		for (auto &edge : pred)
		{
			if (immediate_dominators[block])
			{
				assert(immediate_dominators[edge]);
				immediate_dominators[block] = find_common_dominator(block, edge);
			}
			else
				immediate_dominators[block] = edge;
		}
	}
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rdi, %rbx
movq 0x40(%rdi), %r14
movq 0x48(%rdi), %rdx
cmpq %rdx, %r14
je 0x7324
subq %r14, %rdx
addq $-0x4, %rdx
andq $-0x4, %rdx
addq $0x4, %rdx
movq %r14, %rdi
xorl %esi, %esi
callq 0x6180
movq 0x8(%rbx), %rax
movl 0x60(%rax), %eax
movl %eax, (%r14,%rax,4)
movq 0x70(%rbx), %rax
movq 0x78(%rbx), %rcx
subq %rax, %rcx
je 0x73b6
sarq $0x2, %rcx
movq 0x10(%rbx), %rdx
movl -0x4(%rax,%rcx,4), %esi
leaq (%rsi,%rsi,2), %r8
movq (%rdx,%r8,8), %rdi
movq 0x8(%rdx,%r8,8), %r8
cmpq %r8, %rdi
je 0x73b1
movq 0x58(%rbx), %r9
movl (%r14,%rsi,4), %r10d
movl (%rdi), %r11d
testl %r10d, %r10d
je 0x73a1
cmpl $0x0, (%r14,%r11,4)
je 0x73c5
movl %esi, %r10d
cmpl %r11d, %esi
je 0x73a4
movq 0x40(%rbx), %r15
movl %esi, %r10d
movl %r10d, %r12d
movl (%r9,%r12,4), %ebp
movl %r11d, %r13d
cmpl (%r9,%r13,4), %ebp
jge 0x7396
movl (%r15,%r12,4), %r10d
jmp 0x739a
movl (%r15,%r13,4), %r11d
cmpl %r11d, %r10d
jne 0x7380
jmp 0x73a4
movl %r11d, %r10d
movl %r10d, (%r14,%rsi,4)
addq $0x4, %rdi
cmpq %r8, %rdi
jne 0x7362
decq %rcx
jne 0x7344
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
leaq 0xacc34(%rip), %rdi     # 0xb4000
leaq 0xacc48(%rip), %rsi     # 0xb401b
leaq 0xacc5b(%rip), %rcx     # 0xb4035
movl $0x44, %edx
callq 0x61b0
// File: /workspace/github_cpp_makefile_star2_O3/rossy[P]crossc/SPIRV-Cross/spirv_cfg.cpp
// Function: spirv_cross::CFG::find_common_dominator(unsigned int, unsigned int) const
uint32_t CFG::find_common_dominator(uint32_t a, uint32_t b) const
{
	while (a != b)
	{
		if (visit_order[a] < visit_order[b])
			a = immediate_dominators[a];
		else
			b = immediate_dominators[b];
	}
	return a;
}

// Assembly:
movl %esi, %eax
cmpl %edx, %esi
je 0x740e
movq 0x40(%rdi), %rcx
movq 0x58(%rdi), %rsi
movl %eax, %edi
movl (%rsi,%rdi,4), %r9d
movl %edx, %r8d
cmpl (%rsi,%r8,4), %r9d
jge 0x7406
movl (%rcx,%rdi,4), %eax
jmp 0x740a
movl (%rcx,%r8,4), %edx
cmpl %edx, %eax
jne 0x73f2
retq
nop
// File: /workspace/github_cpp_makefile_star2_O3/rossy[P]crossc/SPIRV-Cross/spirv_cfg.cpp
// Function: spirv_cross::CFG::add_branch(unsigned int, unsigned int)
void CFG::add_branch(uint32_t from, uint32_t to)
{
	const auto add_unique = [](vector<uint32_t> &l, uint32_t value) {
		auto itr = find(begin(l), end(l), value);
		if (itr == end(l))
			l.push_back(value);
	};
	add_unique(preceding_edges[to], from);
	add_unique(succeeding_edges[from], to);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x10, %rsp
movl %edx, %ebx
movl %esi, %ebp
movq %rdi, %r14
movl %edx, %eax
movq 0x10(%rdi), %r15
leaq (%rax,%rax,2), %r12
leaq 0x8(%rsp), %rdx
movl %esi, (%rdx)
movq (%r15,%r12,8), %rdi
movq 0x8(%r15,%r12,8), %rsi
callq 0x78d8
movq 0x8(%r15,%r12,8), %rsi
cmpq %rsi, %rax
jne 0x75ee
leaq (%r15,%r12,8), %rdi
cmpq 0x10(%rdi), %rax
je 0x75e4
movl 0x8(%rsp), %eax
movl %eax, (%rsi)
addq $0x4, %rsi
movq %rsi, 0x8(%rdi)
jmp 0x75ee
leaq 0x8(%rsp), %rdx
callq 0x797e
movl %ebp, %eax
movq 0x28(%r14), %r14
leaq (%rax,%rax,2), %r15
leaq 0xc(%rsp), %rdx
movl %ebx, (%rdx)
movq (%r14,%r15,8), %rdi
movq 0x8(%r14,%r15,8), %rsi
callq 0x78d8
movq 0x8(%r14,%r15,8), %rsi
cmpq %rsi, %rax
jne 0x763b
leaq (%r14,%r15,8), %rdi
cmpq 0x10(%rdi), %rax
je 0x7631
movl 0xc(%rsp), %eax
movl %eax, (%rsi)
addq $0x4, %rsi
movq %rsi, 0x8(%rdi)
jmp 0x763b
leaq 0xc(%rsp), %rdx
callq 0x797e
addq $0x10, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O3/rossy[P]crossc/SPIRV-Cross/spirv_cfg.cpp
// Function: spirv_cross::DominatorBuilder::add_block(unsigned int)
void DominatorBuilder::add_block(uint32_t block)
{
	if (!cfg.get_immediate_dominator(block))
	{
		// Unreachable block via the CFG, we will never emit this code anyways.
		return;
	}

	if (!dominator)
	{
		dominator = block;
		return;
	}

	if (block != dominator)
		dominator = cfg.find_common_dominator(block, dominator);
}

// Assembly:
movq (%rdi), %rdx
movl %esi, %ecx
movq 0x40(%rdx), %rax
cmpl $0x0, (%rax,%rcx,4)
je 0x7693
movl 0x8(%rdi), %ecx
testl %ecx, %ecx
je 0x7690
cmpl %esi, %ecx
je 0x7693
movq 0x58(%rdx), %rdx
movl %esi, %r8d
movl (%rdx,%r8,4), %r10d
movl %ecx, %r9d
cmpl (%rdx,%r9,4), %r10d
jge 0x7688
movl (%rax,%r8,4), %esi
jmp 0x768c
movl (%rax,%r9,4), %ecx
cmpl %ecx, %esi
jne 0x7672
movl %esi, 0x8(%rdi)
retq
// File: /workspace/github_cpp_makefile_star2_O3/rossy[P]crossc/SPIRV-Cross/spirv_cfg.cpp
// Function: spirv_cross::DominatorBuilder::lift_continue_block_dominator()
void DominatorBuilder::lift_continue_block_dominator()
{
	// It is possible for a continue block to be the dominator of a variable is only accessed inside the while block of a do-while loop.
	// We cannot safely declare variables inside a continue block, so move any variable declared
	// in a continue block to the entry block to simplify.
	// It makes very little sense for a continue block to ever be a dominator, so fall back to the simplest
	// solution.

	if (!dominator)
		return;

	auto &block = cfg.get_compiler().get<SPIRBlock>(dominator);
	auto post_order = cfg.get_visit_order(dominator);

	// If we are branching to a block with a higher post-order traversal index (continue blocks), we have a problem
	// since we cannot create sensible GLSL code for this, fallback to entry block.
	bool back_edge_dominator = false;
	switch (block.terminator)
	{
	case SPIRBlock::Direct:
		if (cfg.get_visit_order(block.next_block) > post_order)
			back_edge_dominator = true;
		break;

	case SPIRBlock::Select:
		if (cfg.get_visit_order(block.true_block) > post_order)
			back_edge_dominator = true;
		if (cfg.get_visit_order(block.false_block) > post_order)
			back_edge_dominator = true;
		break;

	case SPIRBlock::MultiSelect:
		for (auto &target : block.cases)
		{
			if (cfg.get_visit_order(target.block) > post_order)
				back_edge_dominator = true;
		}
		if (block.default_block && cfg.get_visit_order(block.default_block) > post_order)
			back_edge_dominator = true;
		break;

	default:
		break;
	}

	if (back_edge_dominator)
		dominator = cfg.get_function().entry_block;
}

// Assembly:
pushq %rbx
movl 0x8(%rdi), %esi
testl %esi, %esi
je 0x7703
movq %rdi, %rbx
movq (%rdi), %rax
movq (%rax), %rdi
callq 0x78a4
movq (%rbx), %rcx
movl 0x8(%rbx), %edx
movq 0x58(%rcx), %rsi
movl (%rsi,%rdx,4), %edx
testl %edx, %edx
jle 0x775c
movl 0xc(%rax), %edi
cmpl $0x3, %edi
je 0x7705
cmpl $0x2, %edi
je 0x76dd
cmpl $0x1, %edi
jne 0x7703
movl 0x18(%rax), %eax
movl (%rsi,%rax,4), %eax
testl %eax, %eax
jg 0x76f5
jmp 0x775c
movl 0x2c(%rax), %edi
movl (%rsi,%rdi,4), %edi
testl %edi, %edi
jle 0x775c
movl 0x30(%rax), %eax
movl (%rsi,%rax,4), %eax
testl %eax, %eax
jle 0x775c
cmpl %edx, %edi
ja 0x76f9
cmpl %edx, %eax
jbe 0x7703
movq 0x8(%rcx), %rax
movl 0x60(%rax), %eax
movl %eax, 0x8(%rbx)
popq %rbx
retq
movq 0x98(%rax), %r8
movq 0xa0(%rax), %r9
xorl %edi, %edi
cmpq %r9, %r8
je 0x7737
movl 0x4(%r8), %r10d
movl (%rsi,%r10,4), %r10d
testl %r10d, %r10d
jle 0x775c
cmpl %edx, %r10d
seta %r10b
orb %r10b, %dil
addq $0x8, %r8
jmp 0x7715
movl 0x34(%rax), %eax
testq %rax, %rax
je 0x7754
movl (%rsi,%rax,4), %eax
testl %eax, %eax
jle 0x775c
cmpl %edx, %eax
seta %al
orb %dil, %al
testb $0x1, %al
jne 0x76f9
jmp 0x7703
testb $0x1, %dil
jne 0x76f9
jmp 0x7703
leaq 0xac906(%rip), %rdi     # 0xb4069
leaq 0xac905(%rip), %rsi     # 0xb406f
leaq 0xac918(%rip), %rcx     # 0xb4089
movl $0x36, %edx
callq 0x61b0
nop
// File: /workspace/github_cpp_makefile_star2_O3/rossy[P]crossc/SPIRV-Cross/spirv_cpp.cpp
// Function: spirv_cross::CompilerCPP::emit_shared(spirv_cross::SPIRVariable const&)
void CompilerCPP::emit_shared(const SPIRVariable &var)
{
	add_resource_name(var.self);

	auto instance_name = to_name(var.self);
	statement(CompilerGLSL::variable_decl(var), ";");
	statement_no_indent("#define ", instance_name, " __res->", instance_name);
}

// Assembly:
pushq %rbp
pushq %r14
pushq %rbx
subq $0x40, %rsp
movq %rsi, %r14
movq %rdi, %rbx
movl 0x8(%rsi), %esi
callq 0x281be
movl 0x8(%r14), %edx
movq (%rbx), %rax
leaq 0x20(%rsp), %rdi
movq %rbx, %rsi
movl $0x1, %ecx
callq *0x38(%rax)
movq %rsp, %rdi
movq %rbx, %rsi
movq %r14, %rdx
callq 0x2c7ac
leaq 0xb628d(%rip), %rdx     # 0xbeaf1
movq %rsp, %rsi
movq %rbx, %rdi
callq 0xaa14
leaq 0x10(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x888a
movq 0x10(%rsp), %rsi
incq %rsi
callq 0x6260
movl 0x638(%rbx), %ebp
movl $0x0, 0x638(%rbx)
leaq 0xab94b(%rip), %rsi     # 0xb41ec
leaq 0xab94d(%rip), %rcx     # 0xb41f5
leaq 0x20(%rsp), %rdx
movq %rbx, %rdi
movq %rdx, %r8
callq 0xf456
movl %ebp, 0x638(%rbx)
leaq 0x30(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x88d9
movq 0x30(%rsp), %rsi
incq %rsi
callq 0x6260
addq $0x40, %rsp
popq %rbx
popq %r14
popq %rbp
retq
jmp 0x8904
movq %rax, %rbx
leaq 0x10(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x8907
movq 0x10(%rsp), %rsi
incq %rsi
callq 0x6260
jmp 0x8907
movq %rax, %rbx
leaq 0x30(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x8922
movq 0x30(%rsp), %rsi
incq %rsi
callq 0x6260
movq %rbx, %rdi
callq 0x64a0
// File: /workspace/github_cpp_makefile_star2_O3/rossy[P]crossc/SPIRV-Cross/spirv_cross.hpp
// Function: spirv_cross::SPIRVariable* spirv_cross::Compiler::maybe_get<spirv_cross::SPIRVariable>(unsigned int)
T *maybe_get(uint32_t id)
	{
		if (ir.ids.at(id).get_type() == T::type)
			return &get<T>(id);
		else
			return nullptr;
	}

// Assembly:
movl %esi, %eax
movq 0x20(%rdi), %rcx
movq 0x28(%rdi), %rdx
subq %rcx, %rdx
sarq $0x4, %rdx
cmpq %rax, %rdx
jbe 0xc7dc
shlq $0x4, %rax
cmpl $0x2, 0x8(%rcx,%rax)
je 0xb3ca
xorl %eax, %eax
retq
pushq %rax
leaq 0xa7935(%rip), %rdi     # 0xb4119
movq %rax, %rsi
xorl %eax, %eax
callq 0x63d0
// File: /workspace/github_cpp_makefile_star2_O3/rossy[P]crossc/SPIRV-Cross/spirv_cross.cpp
// Function: spirv_cross::Compiler::parse_fixup()
void Compiler::parse_fixup()
{
	// Figure out specialization constants for work group sizes.
	for (auto &id : ir.ids)
	{
		if (id.get_type() == TypeConstant)
		{
			auto &c = id.get<SPIRConstant>();
			if (ir.meta[c.self].decoration.builtin && ir.meta[c.self].decoration.builtin_type == BuiltInWorkgroupSize)
			{
				// In current SPIR-V, there can be just one constant like this.
				// All entry points will receive the constant value.
				for (auto &entry : ir.entry_points)
				{
					entry.second.workgroup_size.constant = c.self;
					entry.second.workgroup_size.x = c.scalar(0, 0);
					entry.second.workgroup_size.y = c.scalar(0, 1);
					entry.second.workgroup_size.z = c.scalar(0, 2);
				}
			}
		}
		else if (id.get_type() == TypeVariable)
		{
			auto &var = id.get<SPIRVariable>();
			if (var.storage == StorageClassPrivate || var.storage == StorageClassWorkgroup ||
			    var.storage == StorageClassOutput)
				global_variables.push_back(var.self);
			if (variable_storage_is_aliased(var))
				aliased_variables.push_back(var.self);
		}
	}

	fixup_type_alias();
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rdi, %rbx
movq 0x20(%rdi), %r14
movq 0x28(%rdi), %rbp
cmpq %rbp, %r14
je 0x12842
leaq 0x118(%rbx), %r15
leaq 0x130(%rbx), %rax
movq %rax, (%rsp)
movl $0x58, %r12d
movl 0x8(%r14), %eax
cmpl $0x2, %eax
je 0x127ad
cmpl $0x3, %eax
jne 0x12835
movq %r14, %rdi
callq 0x1b808
movl 0x8(%rax), %ecx
movq 0x38(%rbx), %rdx
imulq $0x148, %rcx, %rsi      # imm = 0x148
cmpb $0x1, 0xcc(%rdx,%rsi)
jne 0x12835
addq %rsi, %rdx
cmpl $0x19, 0xa0(%rdx)
jne 0x12835
movq 0xe0(%rbx), %rdx
testq %rdx, %rdx
je 0x12835
movl %ecx, 0xbc(%rdx)
movl 0x10(%rax), %esi
movl %esi, 0xb0(%rdx)
movl 0x18(%rax), %esi
movl %esi, 0xb4(%rdx)
movl 0x20(%rax), %esi
movl %esi, 0xb8(%rdx)
movq (%rdx), %rdx
jmp 0x1277e
movq %r14, %rdi
callq 0xb2a4
movq %rax, %r13
movl 0x10(%rax), %eax
cmpl $0x6, %eax
ja 0x127f3
btl %eax, %r12d
jae 0x127f3
leaq 0x8(%r13), %rdx
movq 0x120(%rbx), %rsi
cmpq 0x128(%rbx), %rsi
je 0x127eb
movl (%rdx), %eax
movl %eax, (%rsi)
addq $0x4, %rsi
movq %rsi, 0x120(%rbx)
jmp 0x127f3
movq %r15, %rdi
callq 0x797e
movq %rbx, %rdi
movq %r13, %rsi
callq 0x128ac
testb %al, %al
je 0x12835
addq $0x8, %r13
movq 0x138(%rbx), %rsi
cmpq 0x140(%rbx), %rsi
je 0x12829
movl (%r13), %eax
movl %eax, (%rsi)
addq $0x4, %rsi
movq %rsi, 0x138(%rbx)
jmp 0x12835
movq (%rsp), %rdi
movq %r13, %rdx
callq 0x797e
addq $0x10, %r14
cmpq %rbp, %r14
jne 0x12731
movq %rbx, %rdi
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x14074
// File: /workspace/github_cpp_makefile_star2_O3/rossy[P]crossc/SPIRV-Cross/spirv_cross.cpp
// Function: spirv_cross::Compiler::variable_storage_is_aliased(spirv_cross::SPIRVariable const&)
bool Compiler::variable_storage_is_aliased(const SPIRVariable &v)
{
	auto &type = get<SPIRType>(v.basetype);
	bool ssbo = v.storage == StorageClassStorageBuffer ||
	            ir.meta[type.self].decoration.decoration_flags.get(DecorationBufferBlock);
	bool image = type.basetype == SPIRType::Image;
	bool counter = type.basetype == SPIRType::AtomicCounter;

	bool is_restrict;
	if (ssbo)
		is_restrict = ir.get_buffer_block_flags(v).get(DecorationRestrict);
	else
		is_restrict = has_decoration(v.self, DecorationRestrict);

	return !is_restrict && (ssbo || image || counter);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x40, %rsp
movq %rsi, %r14
movq %rdi, %rbx
movl 0xc(%rsi), %esi
callq 0xa3ea
cmpl $0xc, 0x10(%r14)
jne 0x128e0
movl 0xc(%rax), %eax
cmpl $0xd, %eax
sete %bpl
cmpl $0x8, %eax
sete %r12b
jmp 0x12921
movl 0x8(%rax), %ecx
movl 0xc(%rax), %eax
movq 0x38(%rbx), %rdx
imulq $0x148, %rcx, %rcx      # imm = 0x148
cmpl $0xd, %eax
sete %bpl
cmpl $0x8, %eax
sete %r12b
testb $0x8, 0x60(%rdx,%rcx)
jne 0x12921
movl 0x8(%r14), %esi
addq $0x8, %rbx
movq %rbx, %rdi
movl $0x13, %edx
callq 0x2492a
movl %eax, %ebx
xorl %ecx, %ecx
jmp 0x1294b
addq $0x8, %rbx
movq %rsp, %r15
movq %r15, %rdi
movq %rbx, %rsi
movq %r14, %rdx
callq 0x2460e
movl (%r15), %ebx
shrl $0x13, %ebx
andl $0x1, %ebx
leaq 0x8(%rsp), %rdi
callq 0xd570
movb $0x1, %cl
orb %bpl, %r12b
movl %ebx, %edx
xorb $0x1, %dl
movzbl %r12b, %eax
movzbl %dl, %edx
testb %bl, %bl
cmovnel %edx, %eax
testb %cl, %cl
cmovnel %edx, %eax
andb $0x1, %al
addq $0x40, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O3/rossy[P]crossc/SPIRV-Cross/spirv_cross.cpp
// Function: spirv_cross::Compiler::to_name[abi:cxx11](unsigned int, bool) const
string Compiler::to_name(uint32_t id, bool allow_alias) const
{
	if (allow_alias && ir.ids.at(id).get_type() == TypeType)
	{
		// If this type is a simple alias, emit the
		// name of the original type instead.
		// We don't want to override the meta alias
		// as that can be overridden by the reflection APIs after parse.
		auto &type = get<SPIRType>(id);
		if (type.type_alias)
		{
			// If the alias master has been specially packed, we will have emitted a clean variant as well,
			// so skip the name aliasing here.
			if (!has_decoration(type.type_alias, DecorationCPacked))
				return to_name(type.type_alias);
		}
	}

	if (ir.meta[id].decoration.alias.empty())
		return join("_", id);
	else
		return ir.meta[id].decoration.alias;
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rsi, %r14
movq %rdi, %rbx
movl %edx, 0x4(%rsp)
testl %ecx, %ecx
je 0x12b09
movl %edx, %r15d
movq 0x20(%r14), %rcx
movq 0x28(%r14), %rax
subq %rcx, %rax
sarq $0x4, %rax
cmpq %r15, %rax
jbe 0x12b5e
movq %r15, %rax
shlq $0x4, %rax
cmpl $0x1, 0x8(%rcx,%rax)
jne 0x12b0c
movq %r14, %rdi
movl %edx, %esi
callq 0x1b382
movl 0x98(%rax), %esi
testl %esi, %esi
je 0x12b0c
movq %rax, %r12
leaq 0x8(%r14), %rdi
movl $0xa, %edx
callq 0x2492a
testb %al, %al
jne 0x12b0c
movl 0x98(%r12), %edx
movq (%r14), %rax
movq %rbx, %rdi
movq %r14, %rsi
movl $0x1, %ecx
callq *0x38(%rax)
jmp 0x12b4f
movl %edx, %r15d
movq 0x38(%r14), %rax
imulq $0x148, %r15, %rcx      # imm = 0x148
movq 0x8(%rax,%rcx), %rdx
testq %rdx, %rdx
je 0x12b3b
addq %rcx, %rax
leaq 0x10(%rbx), %rcx
movq %rcx, (%rbx)
movq (%rax), %rsi
addq %rsi, %rdx
movq %rbx, %rdi
callq 0xe456
jmp 0x12b4f
leaq 0xab475(%rip), %rsi     # 0xbdfb7
leaq 0x4(%rsp), %rdx
movq %rbx, %rdi
callq 0xe397
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
leaq 0xa15b4(%rip), %rdi     # 0xb4119
movq %r15, %rsi
movq %rax, %rdx
xorl %eax, %eax
callq 0x63d0
// File: /workspace/github_cpp_makefile_star2_O3/rossy[P]crossc/SPIRV-Cross/spirv_cross.cpp
// Function: spirv_cross::Compiler::register_global_read_dependencies(spirv_cross::SPIRBlock const&, unsigned int)
void Compiler::register_global_read_dependencies(const SPIRBlock &block, uint32_t id)
{
	for (auto &i : block.ops)
	{
		auto ops = stream(i);
		auto op = static_cast<Op>(i.op);

		switch (op)
		{
		case OpFunctionCall:
		{
			uint32_t func = ops[2];
			register_global_read_dependencies(get<SPIRFunction>(func), id);
			break;
		}

		case OpLoad:
		case OpImageRead:
		{
			// If we're in a storage class which does not get invalidated, adding dependencies here is no big deal.
			auto *var = maybe_get_backing_variable(ops[2]);
			if (var && var->storage != StorageClassFunction)
			{
				auto &type = get<SPIRType>(var->basetype);

				// InputTargets are immutable.
				if (type.basetype != SPIRType::Image && type.image.dim != DimSubpassData)
					var->dependees.push_back(id);
			}
			break;
		}

		default:
			break;
		}
	}
}

// Assembly:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x10, %rsp
movl %edx, 0xc(%rsp)
movq 0x38(%rsi), %r14
movq 0x40(%rsi), %r13
cmpq %r13, %r14
je 0x12c44
movq %rdi, %rbx
leaq 0xc(%rsp), %r15
movq %rbx, %rdi
movq %r14, %rsi
callq 0x1b2ac
movzwl (%r14), %ecx
cmpl $0x62, %ecx
je 0x12bd6
cmpl $0x3d, %ecx
je 0x12bd6
cmpl $0x39, %ecx
jne 0x12c37
movl 0x8(%rax), %esi
movq %rbx, %rdi
callq 0xb98a
movl 0xc(%rsp), %edx
movq %rbx, %rdi
movq %rax, %rsi
callq 0x12c52
jmp 0x12c37
movl 0x8(%rax), %esi
movq %rbx, %rdi
callq 0x12c9a
testq %rax, %rax
je 0x12c37
movq %rax, %r12
cmpl $0x7, 0x10(%rax)
je 0x12c37
movl 0xc(%r12), %esi
movq %rbx, %rdi
callq 0xa3ea
cmpl $0xd, 0xc(%rax)
je 0x12c37
cmpl $0x6, 0x84(%rax)
je 0x12c37
movq 0x48(%r12), %rsi
cmpq 0x50(%r12), %rsi
je 0x12c28
movl 0xc(%rsp), %eax
movl %eax, (%rsi)
addq $0x4, %rsi
movq %rsi, 0x48(%r12)
jmp 0x12c37
addq $0x40, %r12
movq %r12, %rdi
movq %r15, %rdx
callq 0x797e
addq $0xc, %r14
cmpq %r13, %r14
jne 0x12b9c
addq $0x10, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
// File: /workspace/github_cpp_makefile_star2_O3/rossy[P]crossc/SPIRV-Cross/spirv_cross.cpp
// Function: spirv_cross::Compiler::maybe_get_backing_variable(unsigned int)
SPIRVariable *Compiler::maybe_get_backing_variable(uint32_t chain)
{
	auto *var = maybe_get<SPIRVariable>(chain);
	if (!var)
	{
		auto *cexpr = maybe_get<SPIRExpression>(chain);
		if (cexpr)
			var = maybe_get<SPIRVariable>(cexpr->loaded_from);

		auto *access_chain = maybe_get<SPIRAccessChain>(chain);
		if (access_chain)
			var = maybe_get<SPIRVariable>(access_chain->loaded_from);
	}

	return var;
}

// Assembly:
pushq %rbp
pushq %r14
pushq %rbx
movl %esi, %ebp
movq %rdi, %rbx
callq 0xc7b4
movq %rax, %r14
testq %rax, %rax
je 0x12cb8
movq %r14, %rax
popq %rbx
popq %r14
popq %rbp
retq
movq %rbx, %rdi
movl %ebp, %esi
callq 0x1b3b6
testq %rax, %rax
je 0x12cd7
movl 0x34(%rax), %esi
movq %rbx, %rdi
callq 0xc7b4
movq %rax, %r14
jmp 0x12cda
xorl %r14d, %r14d
movq %rbx, %rdi
movl %ebp, %esi
callq 0x1b3f0
testq %rax, %rax
je 0x12cb0
movl 0x5c(%rax), %esi
movq %rbx, %rdi
popq %rbx
popq %r14
popq %rbp
jmp 0xc7b4
// File: /workspace/github_cpp_makefile_star2_O3/rossy[P]crossc/SPIRV-Cross/spirv_cross.cpp
// Function: spirv_cross::Compiler::register_read(unsigned int, unsigned int, bool)
void Compiler::register_read(uint32_t expr, uint32_t chain, bool forwarded)
{
	auto &e = get<SPIRExpression>(expr);
	auto *var = maybe_get_backing_variable(chain);

	if (var)
	{
		e.loaded_from = var->self;

		// If the backing variable is immutable, we do not need to depend on the variable.
		if (forwarded && !is_immutable(var->self))
			var->dependees.push_back(e.self);

		// If we load from a parameter, make sure we create "inout" if we also write to the parameter.
		// The default is "in" however, so we never invalidate our compilation by reading.
		if (var && var->parameter)
			var->parameter->read_count++;
	}
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movl %ecx, %ebp
movl %edx, %ebx
movq %rdi, %r15
callq 0x1b42a
movq %rax, %r14
movq %r15, %rdi
movl %ebx, %esi
callq 0x12c9a
testq %rax, %rax
je 0x12d70
movq %rax, %rbx
movl 0x8(%rax), %esi
movl %esi, 0x34(%r14)
testb %bpl, %bpl
je 0x12d64
movq %r15, %rdi
callq 0x12d7c
testb %al, %al
jne 0x12d64
addq $0x8, %r14
movq 0x48(%rbx), %rsi
cmpq 0x50(%rbx), %rsi
je 0x12d55
movl (%r14), %eax
movl %eax, (%rsi)
addq $0x4, %rsi
movq %rsi, 0x48(%rbx)
jmp 0x12d64
movq %rbx, %rdi
addq $0x40, %rdi
movq %r14, %rdx
callq 0x797e
movq 0x68(%rbx), %rax
testq %rax, %rax
je 0x12d70
incl 0x8(%rax)
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O3/rossy[P]crossc/SPIRV-Cross/spirv_cross.cpp
// Function: spirv_cross::Compiler::is_immutable(unsigned int) const
bool Compiler::is_immutable(uint32_t id) const
{
	if (ir.ids[id].get_type() == TypeVariable)
	{
		auto &var = get<SPIRVariable>(id);

		// Anything we load from the UniformConstant address space is guaranteed to be immutable.
		bool pointer_to_const = var.storage == StorageClassUniformConstant;
		return pointer_to_const || var.phi_variable || !expression_is_lvalue(id);
	}
	else if (ir.ids[id].get_type() == TypeAccessChain)
		return get<SPIRAccessChain>(id).immutable;
	else if (ir.ids[id].get_type() == TypeExpression)
		return get<SPIRExpression>(id).immutable;
	else if (ir.ids[id].get_type() == TypeConstant || ir.ids[id].get_type() == TypeConstantOp ||
	         ir.ids[id].get_type() == TypeUndef)
		return true;
	else
		return false;
}

// Assembly:
pushq %rbp
pushq %r14
pushq %rbx
movl %esi, %eax
movq 0x20(%rdi), %rcx
shlq $0x4, %rax
movl 0x8(%rcx,%rax), %eax
addl $-0x2, %eax
cmpl $0xb, %eax
ja 0x12df7
movl %esi, %ebp
movq %rdi, %rbx
movb $0x1, %r14b
leaq 0xa1b2b(%rip), %rcx     # 0xb48d0
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
movq %rbx, %rdi
movl %ebp, %esi
callq 0x1b45e
cmpl $0x0, 0x10(%rax)
je 0x12e0a
cmpb $0x0, 0x5a(%rax)
jne 0x12e0a
movq %rbx, %rdi
movl %ebp, %esi
callq 0x130d0
movq %rbx, %rdi
movl %eax, %esi
callq 0x1b382
movl 0xc(%rax), %eax
addl $-0xd, %eax
cmpl $0x3, %eax
setb %r14b
jmp 0x12e0a
movq %rbx, %rdi
movl %ebp, %esi
callq 0x1b596
movb 0x65(%rax), %r14b
jmp 0x12e0a
xorl %r14d, %r14d
jmp 0x12e0a
movq %rbx, %rdi
movl %ebp, %esi
callq 0x1b492
movb 0x38(%rax), %r14b
movl %r14d, %eax
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O3/rossy[P]crossc/SPIRV-Cross/spirv_cross.cpp
// Function: spirv_cross::Compiler::register_write(unsigned int)
void Compiler::register_write(uint32_t chain)
{
	auto *var = maybe_get<SPIRVariable>(chain);
	if (!var)
	{
		// If we're storing through an access chain, invalidate the backing variable instead.
		auto *expr = maybe_get<SPIRExpression>(chain);
		if (expr && expr->loaded_from)
			var = maybe_get<SPIRVariable>(expr->loaded_from);

		auto *access_chain = maybe_get<SPIRAccessChain>(chain);
		if (access_chain && access_chain->loaded_from)
			var = maybe_get<SPIRVariable>(access_chain->loaded_from);
	}

	if (var)
	{
		// If our variable is in a storage class which can alias with other buffers,
		// invalidate all variables which depend on aliased variables.
		if (variable_storage_is_aliased(*var))
			flush_all_aliased_variables();
		else if (var)
			flush_dependees(*var);

		// We tried to write to a parameter which is not marked with out qualifier, force a recompile.
		if (var->parameter && var->parameter->write_count == 0)
		{
			var->parameter->write_count++;
			force_recompile = true;
		}
	}
}

// Assembly:
pushq %rbp
pushq %r14
pushq %rbx
movl %esi, %ebp
movq %rdi, %rbx
callq 0xc7b4
movq %rax, %r14
testq %rax, %rax
jne 0x12e74
movq %rbx, %rdi
movl %ebp, %esi
callq 0x1b3b6
testq %rax, %rax
je 0x12e4b
movl 0x34(%rax), %esi
testl %esi, %esi
je 0x12e4b
movq %rbx, %rdi
callq 0xc7b4
movq %rax, %r14
jmp 0x12e4e
xorl %r14d, %r14d
movq %rbx, %rdi
movl %ebp, %esi
callq 0x1b3f0
testq %rax, %rax
je 0x12e6f
movl 0x5c(%rax), %esi
testl %esi, %esi
je 0x12e6f
movq %rbx, %rdi
callq 0xc7b4
movq %rax, %r14
testq %r14, %r14
je 0x12eb2
movq %rbx, %rdi
movq %r14, %rsi
callq 0x128ac
movq %rbx, %rdi
testb %al, %al
je 0x12e8d
callq 0x12eb8
jmp 0x12e95
movq %r14, %rsi
callq 0x12ef8
movq 0x68(%r14), %rax
testq %rax, %rax
je 0x12eb2
cmpl $0x0, 0xc(%rax)
jne 0x12eb2
movl $0x1, 0xc(%rax)
movb $0x1, 0x1d0(%rbx)
popq %rbx
popq %r14
popq %rbp
retq
nop