LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_cpp_makefile_star2_O1/alex-courtis[P]xlayoutdisplay/src/xrandrrutil.cpp
// Function: modeFromXRR(unsigned long, _XRRScreenResources const*)
Mode *modeFromXRR(RRMode id, const XRRScreenResources *resources) {
    if (resources == nullptr)
        throw invalid_argument("cannot construct Mode: NULL XRRScreenResources");

    XRRModeInfo *modeInfo = nullptr;
    for (int i = 0; i < resources->nmode; i++) {
        if (id == resources->modes[i].id) {
            modeInfo = &(resources->modes[i]);
            break;
        }
    }

    if (modeInfo == nullptr)
        throw invalid_argument("cannot construct Mode: cannot retrieve RRMode '" + to_string(id) + "'");

    return new Mode(id, modeInfo->width, modeInfo->height, refreshFromModeInfo(*modeInfo));
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
subq $0x68, %rsp
testq %rsi, %rsi
je 0x9e7d
movq %rdi, %r14
movslq 0x30(%rsi), %rax
testq %rax, %rax
jle 0x9e3e
movq 0x38(%rsi), %rbx
cmpq %r14, (%rbx)
je 0x9e40
addq $0x50, %rbx
decq %rax
jne 0x9e30
xorl %ebx, %ebx
testq %rbx, %rbx
je 0x9eaf
movl $0x18, %edi
callq 0x6390
movq %rax, %r15
movq %rbx, %rdi
callq 0x9b1c
movq %r14, (%r15)
movl 0x8(%rbx), %ecx
movl %ecx, 0x8(%r15)
movl 0xc(%rbx), %ecx
movl %ecx, 0xc(%r15)
movl %eax, 0x10(%r15)
movq %r15, %rax
addq $0x68, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
movl $0x10, %edi
callq 0x61c0
movq %rax, %rbx
leaq 0x1081a(%rip), %rsi     # 0x1a6ab
movq %rax, %rdi
callq 0x6790
movq 0x1b128(%rip), %rsi     # 0x24fc8
movq 0x1b109(%rip), %rdx     # 0x24fb0
movq %rbx, %rdi
callq 0x66c0
movl $0x10, %edi
callq 0x61c0
movq %rax, %rbx
leaq 0x28(%rsp), %rdi
movq %r14, %rsi
callq 0x6f43
leaq 0x1080a(%rip), %rsi     # 0x1a6da
leaq 0x48(%rsp), %rdi
leaq 0x28(%rsp), %rdx
callq 0xa708
leaq 0x10822(%rip), %rsi     # 0x1a708
leaq 0x48(%rsp), %rdi
callq 0x67c0
leaq 0x18(%rsp), %r15
movq %r15, -0x10(%r15)
movq (%rax), %rdx
movq %rax, %rcx
addq $0x10, %rcx
cmpq %rcx, %rdx
jne 0x9f11
movups (%rcx), %xmm0
movups %xmm0, (%r15)
jmp 0x9f1e
movq %rdx, 0x8(%rsp)
movq (%rcx), %rdx
movq %rdx, 0x18(%rsp)
movq 0x8(%rax), %rdx
leaq 0x8(%rsp), %rsi
movq %rdx, 0x8(%rsi)
movq %rcx, (%rax)
movq $0x0, 0x8(%rax)
movb $0x0, 0x10(%rax)
movb $0x1, %bpl
movq %rbx, %rdi
callq 0x66f0
xorl %ebp, %ebp
movq 0x1b07a(%rip), %rsi     # 0x24fc8
movq 0x1b05b(%rip), %rdx     # 0x24fb0
movq %rbx, %rdi
callq 0x66c0
movq %rax, %r14
movq 0x8(%rsp), %rdi
cmpq %r15, %rdi
je 0x9f7f
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x63a0
jmp 0x9f7f
movq %rax, %r14
movb $0x1, %bpl
leaq 0x58(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x9fa2
movq 0x58(%rsp), %rsi
incq %rsi
callq 0x63a0
jmp 0x9fa2
movq %rax, %r14
movb $0x1, %bpl
leaq 0x38(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x9fc5
movq 0x38(%rsp), %rsi
incq %rsi
callq 0x63a0
jmp 0x9fc5
movq %rax, %r14
movb $0x1, %bpl
testb %bpl, %bpl
jne 0x9fcf
jmp 0x9fd7
movq %rax, %r14
movq %rbx, %rdi
callq 0x62b0
movq %r14, %rdi
callq 0x6700
// File: /workspace/github_cpp_makefile_star2_O1/alex-courtis[P]xlayoutdisplay/src/xrdbutil.cpp
// Function: renderXrdbCmd[abi:cxx11](long const&)
const std::string renderXrdbCmd(const long &dpi) {
    stringstream ss;
    ss << "echo \"Xft.dpi: "
       << dpi
       << "\" | xrdb -merge";
    return ss.str();
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
subq $0x190, %rsp            # imm = 0x190
movq %rsi, %r14
movq %rdi, %rbx
leaq 0x8(%rsp), %rdi
callq 0x6290
leaq 0x18(%rsp), %r15
leaq 0xfb2d(%rip), %rsi      # 0x1a7f1
movl $0xf, %edx
movq %r15, %rdi
callq 0x6460
movq (%r14), %rsi
movq %r15, %rdi
callq 0x6340
leaq 0xfb1e(%rip), %rsi      # 0x1a801
movl $0xf, %edx
movq %rax, %rdi
callq 0x6460
leaq 0x20(%rsp), %rsi
movq %rbx, %rdi
callq 0x6630
movq 0x1a244(%rip), %rsi     # 0x24f48
leaq 0x8(%rsp), %rdi
callq 0x62c0
leaq 0x88(%rsp), %rdi
callq 0x6110
movq %rbx, %rax
addq $0x190, %rsp            # imm = 0x190
popq %rbx
popq %r14
popq %r15
retq
movq %rax, %rbx
movq 0x1a213(%rip), %rsi     # 0x24f48
leaq 0x8(%rsp), %rdi
callq 0x62c0
leaq 0x88(%rsp), %rdi
callq 0x6110
movq %rbx, %rdi
callq 0x6700
// File: /workspace/github_cpp_makefile_star2_O1/alex-courtis[P]xlayoutdisplay/src/xutil.cpp
// Function: resetRootCursor()
void resetRootCursor() {
    Display* dpy = XOpenDisplay(nullptr);
    int screen = DefaultScreen(dpy);
    Window root = RootWindow(dpy, screen);
    Cursor cursor = XcursorLibraryLoadCursor(dpy, "left_ptr");
    XDefineCursor(dpy, root, cursor);
    XFreeCursor(dpy, cursor);
    XCloseDisplay(dpy);
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
xorl %edi, %edi
callq 0x6550
movq %rax, %rbx
movslq 0xe0(%rax), %rax
movq 0xe8(%rbx), %rcx
shlq $0x7, %rax
movq 0x10(%rcx,%rax), %r14
leaq 0xfa90(%rip), %rsi      # 0x1a811
movq %rbx, %rdi
callq 0x6530
movq %rax, %r15
movq %rbx, %rdi
movq %r14, %rsi
movq %rax, %rdx
callq 0x66e0
movq %rbx, %rdi
movq %r15, %rsi
callq 0x63f0
movq %rbx, %rdi
popq %rbx
popq %r14
popq %r15
jmp 0x67a0
nop
// File: /workspace/github_cpp_makefile_star2_O1/alex-courtis[P]xlayoutdisplay/main.cpp
// Function: parseLong(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&)
long parseLong(const string &name, const string &val) {
    try {
        return stoi(val);
    } catch (invalid_argument &e) {
        throw invalid_argument("invalid " + name + ": " + val);
    }
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x68, %rsp
movq %rsi, %r14
movq %rdi, %r12
movq (%rsi), %r15
callq 0x6070
movq %rax, %rbx
movl (%rax), %ebp
movl $0x0, (%rax)
leaq 0x28(%rsp), %r13
movq %r15, %rdi
movq %r13, %rsi
movl $0xa, %edx
callq 0x6570
cmpq %r15, (%r13)
je 0xaeb8
movslq %eax, %rcx
cmpq %rax, %rcx
jne 0xaec4
movl (%rbx), %ecx
cmpl $0x22, %ecx
je 0xaec4
testl %ecx, %ecx
jne 0xaea7
movl %ebp, (%rbx)
cltq
addq $0x68, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
leaq 0xff38(%rip), %rdi      # 0x1adf7
callq 0x6220
leaq 0xff2c(%rip), %rdi      # 0x1adf7
callq 0x65a0
movq %rax, %r15
cmpl $0x0, (%rbx)
jne 0xaeda
movl %ebp, (%rbx)
cmpl $0x1, %edx
jne 0xb018
movq %r15, %rdi
callq 0x6160
movl $0x10, %edi
callq 0x61c0
movq %rax, %rbx
leaq 0xfa53(%rip), %rsi      # 0x1a952
leaq 0x48(%rsp), %rdi
movq %r12, %rdx
callq 0x7976
leaq 0xf8eb(%rip), %rsi      # 0x1a7fe
leaq 0x48(%rsp), %rdi
callq 0x67c0
leaq 0x18(%rsp), %r12
movq %r12, -0x10(%r12)
movq (%rax), %rdx
movq %rax, %rcx
addq $0x10, %rcx
cmpq %rcx, %rdx
jne 0xaf40
movups (%rcx), %xmm0
movups %xmm0, (%r12)
jmp 0xaf4d
movq %rdx, 0x8(%rsp)
movq (%rcx), %rdx
movq %rdx, 0x18(%rsp)
movq 0x8(%rax), %rdx
leaq 0x8(%rsp), %rsi
movq %rdx, 0x8(%rsi)
movq %rcx, (%rax)
movq $0x0, 0x8(%rax)
movb $0x0, 0x10(%rax)
leaq 0x28(%rsp), %rdi
movq %r14, %rdx
callq 0xc54b
movb $0x1, %bpl
leaq 0x28(%rsp), %rsi
movq %rbx, %rdi
callq 0x66f0
xorl %ebp, %ebp
movq 0x1a039(%rip), %rsi     # 0x24fc8
movq 0x1a01a(%rip), %rdx     # 0x24fb0
movq %rbx, %rdi
callq 0x66c0
movq %rax, %r15
leaq 0x38(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0xafc4
movq 0x38(%rsp), %rsi
incq %rsi
callq 0x63a0
jmp 0xafc4
movq %rax, %r15
movb $0x1, %bpl
movq 0x8(%rsp), %rdi
cmpq %r12, %rdi
je 0xafe3
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x63a0
jmp 0xafe3
movq %rax, %r15
movb $0x1, %bpl
leaq 0x58(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0xb006
movq 0x58(%rsp), %rsi
incq %rsi
callq 0x63a0
jmp 0xb006
movq %rax, %r15
movb $0x1, %bpl
testb %bpl, %bpl
je 0xb013
movq %rbx, %rdi
callq 0x62b0
callq 0x6690
movq %r15, %rdi
callq 0x6700
movq %rax, %rdi
callq 0x89bb
// File: /workspace/github_cpp_makefile_star2_O1/joraso[P]Glassius/chaos.cpp
// Function: chaos::seed(double)
void chaos::seed(double s){
    /* Seeds the random number generator. */
    std::cout << "Seeding random number generation with: " << s << std::endl;
    //std::cout << "maximum random is: " << RAND_MAX << std::endl;
    std::srand(s);
    return;
}

// Assembly:
pushq %rbx
subq $0x10, %rsp
movsd %xmm0, 0x8(%rsp)
movq 0x86c2(%rip), %rbx      # 0xafd8
leaq 0x5743(%rip), %rsi      # 0x8060
movl $0x27, %edx
movq %rbx, %rdi
callq 0x21e0
movq %rbx, %rdi
movsd 0x8(%rsp), %xmm0
callq 0x2260
movq %rax, %rbx
movq (%rax), %rax
movq -0x18(%rax), %rdi
addq %rbx, %rdi
movl $0xa, %esi
callq 0x21d0
movsbl %al, %esi
movq %rbx, %rdi
callq 0x2040
movq %rax, %rdi
callq 0x2120
cvttsd2si 0x8(%rsp), %rdi
addq $0x10, %rsp
popq %rbx
jmp 0x21c0
// File: /workspace/github_cpp_makefile_star2_O1/joraso[P]Glassius/chaos.cpp
// Function: chaos::gaussian(double, double)
double chaos::gaussian(double mean, double std){
    /* Draws random numbers from a gaussian using the box-muller method */
    double r1 = chaos::random();
    double r2 = chaos::random();
    double z0 = sqrt(-2.0*log(r1))*cos(2.0*M_PI*r2);
    //double z1 = sqrt(-2.0*log(r1))*sin(2.0*M_PI*r2);
    return (z0 * std) + mean;
}

// Assembly:
subq $0x28, %rsp
movsd %xmm1, 0x18(%rsp)
movsd %xmm0, 0x20(%rsp)
callq 0x2080
xorps %xmm0, %xmm0
cvtsi2sd %eax, %xmm0
divsd 0x5695(%rip), %xmm0     # 0x8040
movsd %xmm0, 0x8(%rsp)
callq 0x2080
xorps %xmm0, %xmm0
cvtsi2sd %eax, %xmm0
divsd 0x567b(%rip), %xmm0     # 0x8040
movsd %xmm0, 0x10(%rsp)
movsd 0x8(%rsp), %xmm0
callq 0x2160
mulsd 0x566a(%rip), %xmm0     # 0x8048
xorpd %xmm1, %xmm1
ucomisd %xmm1, %xmm0
jb 0x29ee
sqrtsd %xmm0, %xmm0
jmp 0x29f3
callq 0x2150
movsd %xmm0, 0x8(%rsp)
movsd 0x10(%rsp), %xmm0
mulsd 0x5649(%rip), %xmm0     # 0x8050
callq 0x22d0
mulsd 0x8(%rsp), %xmm0
mulsd 0x18(%rsp), %xmm0
addsd 0x20(%rsp), %xmm0
addq $0x28, %rsp
retq
// File: /workspace/github_cpp_makefile_star2_O1/joraso[P]Glassius/chaos.cpp
// Function: chaos::test(int)
void chaos::test(int n){
    /* Draw random numbers and prints them to "chaostest.csv" */
    double r;
    
    // Opening the file
    std::ofstream chaosfile;
    chaosfile.open("Data/chaostest.csv");
    
    for(int i=0;i<n;i++){
        // change the function you want to test here:
        r = gaussian(0.0, 1);
        chaosfile << r << std::endl;
    }
    chaosfile.close();
    return;
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
subq $0x200, %rsp            # imm = 0x200
movl %edi, %ebx
movq %rsp, %r14
movq %r14, %rdi
callq 0x2280
leaq 0x5645(%rip), %rsi      # 0x8088
movq %r14, %rdi
movl $0x10, %edx
callq 0x2060
testl %ebx, %ebx
jle 0x2a9d
movq %rsp, %r14
xorps %xmm0, %xmm0
movsd 0x55f6(%rip), %xmm1     # 0x8058
callq 0x2987
movq %r14, %rdi
callq 0x2260
movq %rax, %r15
movq (%rax), %rax
movq -0x18(%rax), %rdi
addq %r15, %rdi
movl $0xa, %esi
callq 0x21d0
movsbl %al, %esi
movq %r15, %rdi
callq 0x2040
movq %rax, %rdi
callq 0x2120
decl %ebx
jne 0x2a57
movq %rsp, %rdi
callq 0x2220
movq 0x8524(%rip), %rax      # 0xafd0
movq (%rax), %rcx
movq 0x18(%rax), %rax
leaq 0x8(%rsp), %rdi
movq %rcx, -0x8(%rdi)
movq -0x18(%rcx), %rcx
movq %rax, (%rsp,%rcx)
callq 0x2180
leaq 0xf8(%rsp), %rdi
callq 0x2090
addq $0x200, %rsp            # imm = 0x200
popq %rbx
popq %r14
popq %r15
retq
jmp 0x2ae5
movq %rax, %rbx
movq %rsp, %rdi
callq 0x2240
movq %rbx, %rdi
callq 0x22b0
// File: /workspace/github_cpp_makefile_star2_O1/joraso[P]Glassius/Stopwatch.cpp
// Function: Stopwatch::Stopwatch()
Stopwatch::Stopwatch(){
    tici = std::time(0);
    ticf = std::time(0);
    ticlast = std::time(0);
    return;
}

// Assembly:
pushq %rbx
movq %rdi, %rbx
xorl %edi, %edi
callq 0x21a0
movq %rax, (%rbx)
xorl %edi, %edi
callq 0x21a0
movq %rax, 0x8(%rbx)
xorl %edi, %edi
callq 0x21a0
movq %rax, 0x10(%rbx)
popq %rbx
retq
// File: /workspace/github_cpp_makefile_star2_O1/joraso[P]Glassius/Stopwatch.cpp
// Function: Stopwatch::StampComplete()
void Stopwatch::StampComplete(){
    time_t lap = std::time(0);
    char* dt = std::ctime(&lap);
    std::cout << "Task completed: " << dt;
    double elapsed = std::difftime(lap, ticlast);
    std::cout << "Elapsed time: " << elapsed << " sec" << std::endl;
    ticlast = lap;
    return;
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
subq $0x10, %rsp
movq %rdi, %rbx
xorl %edi, %edi
callq 0x21a0
movq %rsp, %rdi
movq %rax, (%rdi)
callq 0x20a0
movq %rax, %r14
movq 0x8426(%rip), %r15      # 0xafd8
leaq 0x54f8(%rip), %rsi      # 0x80b1
movl $0x10, %edx
movq %r15, %rdi
callq 0x21e0
testq %r14, %r14
je 0x2be7
movq %r14, %rdi
callq 0x20c0
movq 0x83fe(%rip), %rdi      # 0xafd8
movq %r14, %rsi
movq %rax, %rdx
callq 0x21e0
jmp 0x2bff
movq (%r15), %rax
movq -0x18(%rax), %rax
leaq (%r15,%rax), %rdi
movl 0x20(%r15,%rax), %esi
orl $0x1, %esi
callq 0x2270
movq (%rsp), %rdi
movq 0x10(%rbx), %rsi
callq 0x20f0
movsd %xmm0, 0x8(%rsp)
movq 0x83bf(%rip), %r14      # 0xafd8
leaq 0x54c3(%rip), %rsi      # 0x80e3
movl $0xe, %edx
movq %r14, %rdi
callq 0x21e0
movq %r14, %rdi
movsd 0x8(%rsp), %xmm0
callq 0x2260
movq %rax, %r14
leaq 0x547d(%rip), %rsi      # 0x80c2
movl $0x4, %edx
movq %rax, %rdi
callq 0x21e0
movq (%r14), %rax
movq -0x18(%rax), %rdi
addq %r14, %rdi
movl $0xa, %esi
callq 0x21d0
movsbl %al, %esi
movq %r14, %rdi
callq 0x2040
movq %rax, %rdi
callq 0x2120
movq (%rsp), %rax
movq %rax, 0x10(%rbx)
addq $0x10, %rsp
popq %rbx
popq %r14
popq %r15
retq
nop
// File: /workspace/github_cpp_makefile_star2_O1/joraso[P]Glassius/Stopwatch.cpp
// Function: Stopwatch::EndStamp()
void Stopwatch::EndStamp(){
    ticf = std::time(0);
    char* dt = std::ctime(&ticf);
    std::cout << "Simulation finished: " << dt;
    double elapsed = std::difftime(ticf, tici);
    std::cout << "Total Elapsed time: " << elapsed << " sec" << std::endl;
    return;
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
subq $0x10, %rsp
movq %rdi, %rbx
xorl %edi, %edi
callq 0x21a0
leaq 0x8(%rbx), %rdi
movq %rax, 0x8(%rbx)
callq 0x20a0
movq %rax, %r14
movq 0x8322(%rip), %r15      # 0xafd8
leaq 0x540a(%rip), %rsi      # 0x80c7
movl $0x15, %edx
movq %r15, %rdi
callq 0x21e0
testq %r14, %r14
je 0x2ceb
movq %r14, %rdi
callq 0x20c0
movq 0x82fa(%rip), %rdi      # 0xafd8
movq %r14, %rsi
movq %rax, %rdx
callq 0x21e0
jmp 0x2d03
movq (%r15), %rax
movq -0x18(%rax), %rax
leaq (%r15,%rax), %rdi
movl 0x20(%r15,%rax), %esi
orl $0x1, %esi
callq 0x2270
movq (%rbx), %rsi
movq 0x8(%rbx), %rdi
callq 0x20f0
movsd %xmm0, 0x8(%rsp)
movq 0x82bc(%rip), %rbx      # 0xafd8
leaq 0x53ba(%rip), %rsi      # 0x80dd
movl $0x14, %edx
movq %rbx, %rdi
callq 0x21e0
movq %rbx, %rdi
movsd 0x8(%rsp), %xmm0
callq 0x2260
movq %rax, %rbx
leaq 0x537a(%rip), %rsi      # 0x80c2
movl $0x4, %edx
movq %rax, %rdi
callq 0x21e0
movq (%rbx), %rax
movq -0x18(%rax), %rdi
addq %rbx, %rdi
movl $0xa, %esi
callq 0x21d0
movsbl %al, %esi
movq %rbx, %rdi
callq 0x2040
movq %rax, %rdi
addq $0x10, %rsp
popq %rbx
popq %r14
popq %r15
jmp 0x2120
nopl (%rax)
// File: /workspace/github_cpp_makefile_star2_O1/joraso[P]Glassius/Matrix.cpp
// Function: Matrix::Matrix(int const&, int const&)
Matrix::Matrix(const int& rows,const int& columns):rows(rows),columns(columns){
    data = new double* [rows];
    data[0] = new double [rows*columns];
    for(int i=1;i<rows;i++)
        data[i]=data[i-1]+columns;//Use pointer math to allocate it
}

// Assembly:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
movq %rdx, %r14
movq %rdi, %rbx
movl (%rsi), %eax
movl %eax, (%rdi)
movl (%rdx), %eax
movl %eax, 0x4(%rdi)
movslq (%rsi), %r12
leaq (,%r12,8), %rdi
testq %r12, %r12
movq $-0x1, %r13
cmovsq %r13, %rdi
callq 0x2030
movq %rax, %r15
movq %rax, 0x8(%rbx)
movslq (%r14), %r14
movq %r14, %rax
imulq %r12, %rax
movq %rax, %rdi
shlq $0x3, %rdi
testl %eax, %eax
cmovsq %r13, %rdi
callq 0x2030
movq %rax, (%r15)
cmpq $0x2, %r12
jl 0x2e13
movl $0x1, %eax
shlq $0x3, %r14
movq 0x8(%rbx), %rcx
movq -0x8(%rcx,%rax,8), %rdx
addq %r14, %rdx
movq %rdx, (%rcx,%rax,8)
incq %rax
cmpq %rax, %r12
jne 0x2dfb
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
nop
// File: /workspace/github_cpp_makefile_star2_O1/joraso[P]Glassius/Matrix.cpp
// Function: Matrix::operator=(Matrix const&)
Matrix & Matrix::operator=(const Matrix& rhs){
    if(this!= &rhs){//Check for user/compiler stupidity
        int i,j;
        rows = rhs.rows;
        columns = rhs.columns;
        if(data !=0){
            delete [] data[0];
            delete [] data;
        }
        data = new double* [rows];
        data[0] = new double [rows*columns];
        for(i=1;i<rows;i++)
            data[i]=data[i-1]+columns;
        for(i=0;i<rows;i++)
            for(j=0;j<columns;j++)
                data[i][j] = rhs.data[i][j];
    }
    return *this;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rdi, %rbx
cmpq %rsi, %rdi
je 0x2f10
movq %rsi, %r14
movq (%rsi), %rax
movq %rax, (%rbx)
movq 0x8(%rbx), %rax
testq %rax, %rax
je 0x2e62
movq (%rax), %rdi
testq %rdi, %rdi
je 0x2e54
callq 0x2200
movq 0x8(%rbx), %rdi
testq %rdi, %rdi
je 0x2e62
callq 0x2200
movslq (%rbx), %r12
leaq (,%r12,8), %rdi
testq %r12, %r12
movq $-0x1, %rbp
cmovsq %rbp, %rdi
callq 0x2030
movq %rax, %r15
movq %rax, 0x8(%rbx)
movslq 0x4(%rbx), %r13
movq %r13, %rax
imulq %r12, %rax
movq %rax, %rdi
shlq $0x3, %rdi
testl %eax, %eax
cmovsq %rbp, %rdi
callq 0x2030
movq %rax, (%r15)
cmpq $0x2, %r12
jl 0x2ed2
movl $0x1, %eax
leaq (,%r13,8), %rcx
movq 0x8(%rbx), %rdx
movq -0x8(%rdx,%rax,8), %rsi
addq %rcx, %rsi
movq %rsi, (%rdx,%rax,8)
incq %rax
cmpq %rax, %r12
jne 0x2eba
testl %r12d, %r12d
jle 0x2f10
movq 0x8(%r14), %rax
movq 0x8(%rbx), %rcx
movl %r13d, %edx
xorl %esi, %esi
testl %r13d, %r13d
jle 0x2f08
movq (%rax,%rsi,8), %rdi
movq (%rcx,%rsi,8), %r8
xorl %r9d, %r9d
movsd (%rdi,%r9,8), %xmm0
movsd %xmm0, (%r8,%r9,8)
incq %r9
cmpq %r9, %rdx
jne 0x2ef4
incq %rsi
cmpq %r12, %rsi
jne 0x2ee4
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O1/joraso[P]Glassius/Matrix.cpp
// Function: Matrix::Matrix(Matrix const&)
Matrix::Matrix(const Matrix& rhs){
    int i,j;
    rows = rhs.rows;
    columns = rhs.columns;
    if(data !=0){
        data = 0;
    }
    data = new double* [rows];
    data[0] = new double [rows*columns];
    for(i=1;i<rows;i++)
        data[i]=data[i-1]+columns;
    for(i=0;i<rows;i++)
        for(j=0;j<columns;j++)
            data[i][j] = rhs.data[i][j];
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rsi, %r14
movq %rdi, %rbx
movslq (%rsi), %r12
movl %r12d, (%rdi)
movslq 0x4(%rsi), %r13
movl %r13d, 0x4(%rdi)
cmpq $0x0, 0x8(%rdi)
je 0x2f50
movq $0x0, 0x8(%rbx)
leaq (,%r12,8), %rdi
testl %r12d, %r12d
movq $-0x1, %rbp
cmovsq %rbp, %rdi
callq 0x2030
movq %rax, %r15
movq %rax, 0x8(%rbx)
movl %r13d, %eax
imull %r12d, %eax
cltq
leaq (,%rax,8), %rdi
testl %eax, %eax
cmovsq %rbp, %rdi
callq 0x2030
movq %rax, (%r15)
cmpl $0x2, %r12d
jl 0x2fbb
movl $0x1, %eax
movq %r13, %rcx
shlq $0x3, %rcx
movq 0x8(%rbx), %rdx
movq -0x8(%rdx,%rax,8), %rsi
addq %rcx, %rsi
movq %rsi, (%rdx,%rax,8)
incq %rax
cmpq %rax, %r12
jne 0x2fa3
testl %r12d, %r12d
jle 0x2ff8
movl %r13d, %eax
movq 0x8(%r14), %rcx
movq 0x8(%rbx), %rdx
xorl %esi, %esi
testl %eax, %eax
jle 0x2ff0
movq (%rcx,%rsi,8), %rdi
movq (%rdx,%rsi,8), %r8
xorl %r9d, %r9d
movsd (%rdi,%r9,8), %xmm0
movsd %xmm0, (%r8,%r9,8)
incq %r9
cmpq %r9, %rax
jne 0x2fdc
incq %rsi
cmpq %r12, %rsi
jne 0x2fcd
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O1/joraso[P]Glassius/Matrix.cpp
// Function: operator<<(std::ostream&, Matrix const&)
ostream& operator << (ostream& os,const Matrix& rhs){
    // Edited this to make it comma delimited, cause that's easier to read.-JR
    for(int i=0;i<rhs.rows;i++){
        for(int j=0;j<rhs.columns;j++){
            os << rhs.data[i][j];
            if(j<(rhs.columns-1)){os << ",";}
        }
        os << endl;
    }
    return os;
}

// Assembly:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
movq %rdi, %rbx
cmpl $0x0, (%rsi)
jle 0x30cd
movq %rsi, %r14
xorl %r12d, %r12d
leaq 0x509f(%rip), %r15      # 0x80f2
cmpl $0x0, 0x4(%r14)
jle 0x309b
xorl %r13d, %r13d
movq 0x8(%r14), %rax
movq (%rax,%r12,8), %rax
movsd (%rax,%r13,8), %xmm0
movq %rbx, %rdi
callq 0x2260
movslq 0x4(%r14), %rax
decq %rax
cmpq %rax, %r13
jge 0x308f
movl $0x1, %edx
movq %rbx, %rdi
movq %r15, %rsi
callq 0x21e0
incq %r13
movslq 0x4(%r14), %rax
cmpq %rax, %r13
jl 0x305d
movq (%rbx), %rax
movq -0x18(%rax), %rdi
addq %rbx, %rdi
movl $0xa, %esi
callq 0x21d0
movsbl %al, %esi
movq %rbx, %rdi
callq 0x2040
movq %rax, %rdi
callq 0x2120
incq %r12
movslq (%r14), %rax
cmpq %rax, %r12
jl 0x3053
movq %rbx, %rax
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
nop
// File: /workspace/github_cpp_makefile_star2_O1/joraso[P]Glassius/Particles.cpp
// Function: Particles::UpdateKinetic()
void Particles::UpdateKinetic(){
    /* Updates the kinetic energy according to the current particle
    velocities */
    int i, k;
    kinetic_energy = 0;
    for(i=0;i<N;i++){ 
        for(k=0;k<3;k++){kinetic_energy += (24.0)*(v[i][k]*v[i][k]);}
    }
    return;
}

// Assembly:
movq $0x0, 0x78(%rdi)
movslq 0x50(%rdi), %rax
testq %rax, %rax
jle 0x362f
movsd 0x78(%rdi), %xmm0
movq 0x10(%rdi), %rcx
xorl %edx, %edx
movsd 0x4b08(%rip), %xmm1     # 0x8108
movq (%rcx,%rdx,8), %rsi
xorl %r8d, %r8d
movsd (%rsi,%r8,8), %xmm2
mulsd %xmm2, %xmm2
mulsd %xmm1, %xmm2
addsd %xmm2, %xmm0
movsd %xmm0, 0x78(%rdi)
incq %r8
cmpq $0x3, %r8
jne 0x3607
incq %rdx
cmpq %rax, %rdx
jne 0x3600
retq
// File: /workspace/github_cpp_makefile_star2_O1/joraso[P]Glassius/Particles.cpp
// Function: Particles::Thermalize(double)
void Particles::Thermalize(double Temp){
    /* Thermostats the particle system to temperature T by rescaling the
    velocities of all the particles to be in line with the KE based on the
    ideal gas temperature. Not sure if this belongs here or in the integrator
    section.*/
    int i, k;

    // figuring out the factor needed to readjust the velocities.
    double KEnew = (0.5)*3*Temp*(N-1);
    double scale_factor = sqrt( KEnew / kinetic_energy );
    
    // Zeros KE
    kinetic_energy = 0;
    
    // rescaling all the velocities and re-tally kinetic energy
    for(i=0;i<N;i++){ 
        for(k=0;k<3;k++){
            v[i][k] *= scale_factor;
            kinetic_energy += (24.0)*(v[i][k]*v[i][k]);
        }
    }
    return;
}

// Assembly:
pushq %rbx
movapd %xmm0, %xmm1
movq %rdi, %rbx
mulsd 0x4ad0(%rip), %xmm1     # 0x8110
movl 0x50(%rdi), %eax
decl %eax
xorps %xmm0, %xmm0
cvtsi2sd %eax, %xmm0
mulsd %xmm1, %xmm0
divsd 0x78(%rdi), %xmm0
xorpd %xmm1, %xmm1
ucomisd %xmm1, %xmm0
jb 0x3665
sqrtsd %xmm0, %xmm0
jmp 0x366a
callq 0x2150
movq $0x0, 0x78(%rbx)
movslq 0x50(%rbx), %rax
testq %rax, %rax
jle 0x36c0
movq 0x10(%rbx), %rcx
xorl %edx, %edx
movsd 0x4a7f(%rip), %xmm1     # 0x8108
movq (%rcx,%rdx,8), %rsi
xorl %edi, %edi
movsd (%rsi,%rdi,8), %xmm2
mulsd %xmm0, %xmm2
movsd %xmm2, (%rsi,%rdi,8)
mulsd %xmm2, %xmm2
mulsd %xmm1, %xmm2
addsd 0x78(%rbx), %xmm2
movsd %xmm2, 0x78(%rbx)
incq %rdi
cmpq $0x3, %rdi
jne 0x368f
incq %rdx
cmpq %rax, %rdx
jne 0x3689
popq %rbx
retq
// File: /workspace/github_cpp_makefile_star2_O1/joraso[P]Glassius/Particles.cpp
// Function: Free::UpdateForces()
void Free::UpdateForces(){
    int i, k;
    // Zero out the forces and potential energy
    for(i=0;i<N;i++){for(k=0;k<3;k++){f[i][k]=0;};};
    potential_energy = 0;
    return;
}

// Assembly:
movslq 0x50(%rdi), %rax
testq %rax, %rax
jle 0x36eb
movq 0x18(%rdi), %rcx
xorl %edx, %edx
xorps %xmm0, %xmm0
movq (%rcx,%rdx,8), %rsi
movups %xmm0, (%rsi)
movq $0x0, 0x10(%rsi)
incq %rdx
cmpq %rdx, %rax
jne 0x36d4
movq $0x0, 0x80(%rdi)
retq
nop
// File: /workspace/github_cpp_makefile_star2_O1/joraso[P]Glassius/Integration.cpp
// Function: Verlet::Propigate()
void Verlet::Propigate(){
    /* Advances the velocity Verlet calculation one step.*/
    int i,k;
    double dt2 = dt*dt;
    int n = System->Number();
    for(i=0;i<n;i++){
        for(k=0;k<3;k++){
            System->r[i][k] += System->v[i][k]*dt + 0.5*System->f[i][k]*dt2;
            System->v[i][k] += 0.5*System->f[i][k]*dt;
        }
    }
    System->UpdateForces();
    for(i=0;i<n;i++){
        for(k=0;k<3;k++){
            System->v[i][k] += 0.5*dt*System->f[i][k];
        }
    }
    System->UpdateKinetic();
    time += dt;
    return;
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
movq 0x8(%rdi), %rdi
movslq 0x50(%rdi), %r14
testq %r14, %r14
jle 0x424b
movsd 0x18(%rbx), %xmm0
mulsd %xmm0, %xmm0
movq 0x8(%rdi), %rax
movq 0x10(%rdi), %rcx
movq 0x18(%rdi), %rdx
xorl %esi, %esi
movsd 0x3f19(%rip), %xmm1     # 0x8100
movq (%rcx,%rsi,8), %r8
movq (%rdx,%rsi,8), %r9
movq (%rax,%rsi,8), %r10
xorl %r11d, %r11d
movsd (%r8,%r11,8), %xmm2
movsd (%r9,%r11,8), %xmm3
mulsd %xmm1, %xmm3
mulsd 0x18(%rbx), %xmm2
mulsd %xmm0, %xmm3
addsd %xmm3, %xmm2
addsd (%r10,%r11,8), %xmm2
movsd %xmm2, (%r10,%r11,8)
movsd (%r9,%r11,8), %xmm2
mulsd %xmm1, %xmm2
mulsd 0x18(%rbx), %xmm2
addsd (%r8,%r11,8), %xmm2
movsd %xmm2, (%r8,%r11,8)
incq %r11
cmpq $0x3, %r11
jne 0x41f6
incq %rsi
cmpq %r14, %rsi
jne 0x41e7
movq (%rdi), %rax
callq *(%rax)
testl %r14d, %r14d
jle 0x42a2
movq 0x8(%rbx), %rcx
movq 0x10(%rcx), %rax
movq 0x18(%rcx), %rcx
xorl %edx, %edx
movsd 0x3e95(%rip), %xmm0     # 0x8100
movq (%rcx,%rdx,8), %rsi
movq (%rax,%rdx,8), %rdi
xorl %r8d, %r8d
movsd 0x18(%rbx), %xmm1
mulsd %xmm0, %xmm1
mulsd (%rsi,%r8,8), %xmm1
addsd (%rdi,%r8,8), %xmm1
movsd %xmm1, (%rdi,%r8,8)
incq %r8
cmpq $0x3, %r8
jne 0x4276
incq %rdx
cmpq %r14, %rdx
jne 0x426b
movq 0x8(%rbx), %rdi
callq 0x35dc
movsd 0x18(%rbx), %xmm0
addsd 0x20(%rbx), %xmm0
movsd %xmm0, 0x20(%rbx)
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_cpp_makefile_star2_O1/joraso[P]Glassius/Integration.cpp
// Function: Brownian::Initialize()
void Brownian::Initialize(){
    // Setting stuff up
    int i,k;
    prefactor = sqrt(2*dt*Temp);
    int N = System->Number();
    randomforce = Matrix(N, 3);
    F0 = Matrix(N, 3);
    X0 = Matrix(N, 3);
    eta = randomforce.Data();
    f0 = F0.Data();
    x0 = X0.Data();
    for(i=0;i<N;i++){
        for(k=0;k<3;k++){
            eta[i][k] = 0;
            f0[i][k] = 0;
            x0[i][k] = 0;
        };
    };
}

// Assembly:
pushq %r14
pushq %rbx
subq $0x18, %rsp
movq %rdi, %rbx
movsd 0x18(%rdi), %xmm0
addsd %xmm0, %xmm0
mulsd 0x10(%rdi), %xmm0
xorpd %xmm1, %xmm1
ucomisd %xmm1, %xmm0
jb 0x42ea
sqrtsd %xmm0, %xmm0
jmp 0x42ef
callq 0x2150
movsd %xmm0, 0x60(%rbx)
movq 0x8(%rbx), %rax
movl 0x50(%rax), %eax
movq %rsp, %rsi
movl %eax, (%rsi)
leaq 0x4(%rsp), %rdx
movl $0x3, (%rdx)
leaq 0x8(%rsp), %r14
movq %r14, %rdi
callq 0x2d90
leaq 0x68(%rbx), %rdi
movq %r14, %rsi
callq 0x2e1e
leaq 0x8(%rsp), %rdi
callq 0x3008
leaq 0x4(%rsp), %rdx
movl $0x3, (%rdx)
leaq 0x8(%rsp), %r14
movq %rsp, %rsi
movq %r14, %rdi
callq 0x2d90
leaq 0x78(%rbx), %rdi
movq %r14, %rsi
callq 0x2e1e
leaq 0x8(%rsp), %rdi
callq 0x3008
leaq 0x4(%rsp), %rdx
movl $0x3, (%rdx)
leaq 0x8(%rsp), %r14
movq %rsp, %rsi
movq %r14, %rdi
callq 0x2d90
leaq 0x88(%rbx), %rdi
movq %r14, %rsi
callq 0x2e1e
leaq 0x8(%rsp), %rdi
callq 0x3008
movq 0x70(%rbx), %rax
movq 0x80(%rbx), %rcx
movq %rax, 0x98(%rbx)
movq %rcx, 0xa0(%rbx)
movq 0x90(%rbx), %rdx
movq %rdx, 0xa8(%rbx)
movslq (%rsp), %rsi
testq %rsi, %rsi
jle 0x43f3
xorl %edi, %edi
xorl %r8d, %r8d
movq (%rax,%r8,8), %r9
movq (%rcx,%r8,8), %r10
movq (%rdx,%r8,8), %r11
xorl %ebx, %ebx
movq %rdi, (%r9,%rbx,8)
movq %rdi, (%r10,%rbx,8)
movq %rdi, (%r11,%rbx,8)
incq %rbx
cmpq $0x3, %rbx
jne 0x43d6
incq %r8
cmpq %rsi, %r8
jne 0x43c8
addq $0x18, %rsp
popq %rbx
popq %r14
retq
jmp 0x43ff
jmp 0x43ff
movq %rax, %rbx
leaq 0x8(%rsp), %rdi
callq 0x3008
movq %rbx, %rdi
callq 0x22b0
// File: /workspace/github_cpp_makefile_star2_O1/joraso[P]Glassius/Integration.cpp
// Function: Brownian::Propigate()
void Brownian::Propigate(){
    /* Advances the velocity huen calculation one step.*/
    
    int i,k;
    int n = System->Number();
    double dtinv = 1/dt;
    for(i=0;i<n;i++){
        for(k=0;k<3;k++){
            eta[i][k] = prefactor*chaos::gaussian(0.0, 1.0);
            f0[i][k] = System->f[i][k];
            x0[i][k] = System->r[i][k];
            System->r[i][k] = x0[i][k] + dt*System->f[i][k] + eta[i][k];
        }
    }
    System->UpdateForces();
    for(i=0;i<n;i++){
        for(k=0;k<3;k++){
            System->r[i][k] = x0[i][k] + 0.5*dt*(System->f[i][k] + f0[i][k])
                                + eta[i][k];
            System->v[i][k] = dtinv*(System->r[i][k] - x0[i][k]);
        }
    }
    System->UpdateForces();
    System->UpdateKinetic();
    time += dt;
    return;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %rdi, %rbx
movq 0x8(%rdi), %rax
movslq 0x50(%rax), %r14
movsd 0x3c23(%rip), %xmm0     # 0x8058
divsd 0x18(%rdi), %xmm0
movsd %xmm0, 0x10(%rsp)
testq %r14, %r14
jle 0x44f8
xorl %r15d, %r15d
xorl %r12d, %r12d
movsd 0x60(%rbx), %xmm0
movsd %xmm0, 0x8(%rsp)
xorpd %xmm0, %xmm0
movsd 0x3bf2(%rip), %xmm1     # 0x8058
callq 0x2987
mulsd 0x8(%rsp), %xmm0
movq 0x98(%rbx), %rax
movq (%rax,%r15,8), %rax
movsd %xmm0, (%rax,%r12,8)
movq 0x8(%rbx), %rcx
movq 0xa0(%rbx), %rdx
movq 0x18(%rcx), %rsi
movq (%rsi,%r15,8), %rsi
movsd (%rsi,%r12,8), %xmm0
movq (%rdx,%r15,8), %rdx
movsd %xmm0, (%rdx,%r12,8)
movq 0x8(%rcx), %rcx
movq (%rcx,%r15,8), %rcx
movsd (%rcx,%r12,8), %xmm0
movq 0xa8(%rbx), %rdx
movq (%rdx,%r15,8), %rdx
movsd %xmm0, (%rdx,%r12,8)
movsd 0x18(%rbx), %xmm1
mulsd (%rsi,%r12,8), %xmm1
addsd %xmm0, %xmm1
addsd (%rax,%r12,8), %xmm1
movsd %xmm1, (%rcx,%r12,8)
incq %r12
cmpq $0x3, %r12
jne 0x444f
incq %r15
cmpq %r14, %r15
jne 0x444c
movq 0x8(%rbx), %rdi
movq (%rdi), %rax
callq *(%rax)
testl %r14d, %r14d
movsd 0x10(%rsp), %xmm3
jle 0x45b2
movq 0xa8(%rbx), %rax
movq %rax, 0x8(%rsp)
movq 0x8(%rbx), %rax
movq 0x98(%rbx), %rcx
movq 0x18(%rax), %rdx
movq 0xa0(%rbx), %rsi
movq 0x8(%rax), %rdi
movq 0x10(%rax), %r8
xorl %r9d, %r9d
movsd 0x3bbb(%rip), %xmm0     # 0x8100
movq 0x8(%rsp), %rax
movq (%rax,%r9,8), %r10
movq (%rdx,%r9,8), %r11
movq (%rsi,%r9,8), %r15
movq (%rcx,%r9,8), %r12
movq (%rdi,%r9,8), %r13
movq (%r8,%r9,8), %rbp
xorl %eax, %eax
movsd 0x18(%rbx), %xmm1
mulsd %xmm0, %xmm1
movsd (%r11,%rax), %xmm2
addsd (%r15,%rax), %xmm2
mulsd %xmm1, %xmm2
addsd (%r10,%rax), %xmm2
addsd (%r12,%rax), %xmm2
movsd %xmm2, (%r13,%rax)
subsd (%r10,%rax), %xmm2
mulsd %xmm3, %xmm2
movsd %xmm2, (%rbp,%rax)
addq $0x8, %rax
cmpq $0x18, %rax
jne 0x4564
incq %r9
cmpq %r14, %r9
jne 0x4545
movq 0x8(%rbx), %rdi
movq (%rdi), %rax
callq *(%rax)
movq 0x8(%rbx), %rdi
callq 0x35dc
movsd 0x18(%rbx), %xmm0
addsd 0x20(%rbx), %xmm0
movsd %xmm0, 0x20(%rbx)
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O1/ridiculousfish[P]docopt_fish/docopt_fish.cpp
// Function: docopt_fish::argument_parser_t::validate_arguments(std::vector<std::__cxx11::basic_string<wchar_t, std::char_traits<wchar_t>, std::allocator<wchar_t>>, std::allocator<std::__cxx11::basic_string<wchar_t, std::char_traits<wchar_t>, std::allocator<wchar_t>>>> const&, unsigned int) const
std::vector<argument_status_t> argument_parser_t::validate_arguments(
    const std::vector<string_t> &argv, parse_flags_t flags) const {
    size_t arg_count = argv.size();
    std::vector<argument_status_t> result(arg_count, status_valid);

    index_list_t unused_args;
    impl->best_assignment_for_argv(argv, flags, nullptr /* errors */, &unused_args, nullptr);

    // Unused arguments are all invalid
    for (size_t unused_arg_idx : unused_args) {
        result.at(unused_arg_idx) = status_invalid;
    }
    return result;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x30, %rsp
movl %ecx, %ebp
movq %rdx, %r14
movq %rsi, %r15
movq 0x8(%rdx), %rsi
subq (%rdx), %rsi
movq %rdi, %rbx
sarq $0x5, %rsi
leaq 0x10(%rsp), %r12
movl $0x1, (%r12)
leaq 0xf(%rsp), %rcx
movq %r12, %rdx
callq 0xa204
xorps %xmm0, %xmm0
movaps %xmm0, (%r12)
movq $0x0, 0x10(%r12)
movq (%r15), %rdi
leaq 0x10(%rsp), %r8
movq %r14, %rsi
movl %ebp, %edx
xorl %ecx, %ecx
xorl %r9d, %r9d
callq 0xa282
movq 0x10(%rsp), %rdi
movq 0x18(%rsp), %rax
cmpq %rax, %rdi
je 0x8e72
movq (%rbx), %rcx
movq 0x8(%rbx), %rdx
subq %rcx, %rdx
sarq $0x2, %rdx
movq %rdi, %r8
movq (%r8), %rsi
cmpq %rsi, %rdx
jbe 0x8e94
movl $0x0, (%rcx,%rsi,4)
addq $0x8, %r8
cmpq %rax, %r8
jne 0x8e5a
testq %rdi, %rdi
je 0x8e84
movq 0x20(%rsp), %rsi
subq %rdi, %rsi
callq 0x7200
movq %rbx, %rax
addq $0x30, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
leaq 0x19f84(%rip), %rdi     # 0x22e1f
xorl %eax, %eax
callq 0x7300
jmp 0x8ea4
movq %rax, %r14
movq 0x10(%rsp), %rdi
testq %rdi, %rdi
je 0x8ebe
movq 0x20(%rsp), %rsi
subq %rdi, %rsi
callq 0x7200
movq (%rbx), %rdi
testq %rdi, %rdi
je 0x8ed2
movq 0x10(%rbx), %rsi
subq %rdi, %rsi
callq 0x7200
movq %r14, %rdi
callq 0x7360
// File: /workspace/github_cpp_makefile_star2_O1/ridiculousfish[P]docopt_fish/docopt_fish.cpp
// Function: docopt_fish::copyout_metadata[abi:cxx11](docopt_fish::base_metadata_t<docopt_fish::rstring_t> const&)
static metadata_t copyout_metadata(const base_metadata_t<rstring_t> &md) {
    metadata_t result;
    result.command = md.command.std_string();
    result.condition = md.condition.std_string();
    result.description = md.description.std_string();
    result.tag = md.tag;
    return result;
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x28, %rsp
movq %rsi, %r14
movq %rdi, %rbx
leaq 0x10(%rdi), %rax
movq %rax, (%rdi)
xorl %eax, %eax
movq %rax, 0x8(%rdi)
movl %eax, 0x10(%rdi)
leaq 0x30(%rdi), %rcx
movq %rcx, 0x20(%rdi)
movq %rax, 0x28(%rdi)
movl %eax, 0x30(%rdi)
leaq 0x50(%rdi), %rcx
movq %rcx, 0x40(%rdi)
movq %rax, 0x48(%rdi)
movl %eax, 0x50(%rdi)
movl %eax, 0x60(%rdi)
leaq 0x8(%rsp), %rdi
callq 0xbec4
leaq 0x8(%rsp), %r15
movq %rbx, %rdi
movq %r15, %rsi
callq 0x73c0
movq (%r15), %rdi
leaq 0x18(%rsp), %r12
cmpq %r12, %rdi
je 0x8ff6
movq 0x18(%rsp), %rax
leaq 0x4(,%rax,4), %rsi
callq 0x7200
leaq 0x18(%r14), %rsi
leaq 0x8(%rsp), %rdi
callq 0xbec4
leaq 0x20(%rbx), %rdi
leaq 0x8(%rsp), %r15
movq %r15, %rsi
callq 0x73c0
movq (%r15), %rdi
cmpq %r12, %rdi
je 0x902f
movq 0x18(%rsp), %rax
leaq 0x4(,%rax,4), %rsi
callq 0x7200
leaq 0x30(%r14), %rsi
leaq 0x8(%rsp), %rdi
callq 0xbec4
leaq 0x40(%rbx), %rdi
leaq 0x8(%rsp), %r15
movq %r15, %rsi
callq 0x73c0
movq (%r15), %rdi
cmpq %r12, %rdi
je 0x9068
movq 0x18(%rsp), %rax
leaq 0x4(,%rax,4), %rsi
callq 0x7200
movl 0x48(%r14), %eax
movl %eax, 0x60(%rbx)
movq %rbx, %rax
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
jmp 0x9082
jmp 0x9082
movq %rax, %r14
movq %rbx, %rdi
callq 0xbe66
movq %r14, %rdi
callq 0x7360
nop
// File: /workspace/github_cpp_makefile_star2_O1/ridiculousfish[P]docopt_fish/docopt_fish.cpp
// Function: docopt_fish::argument_parser_t::set_doc(std::__cxx11::basic_string<wchar_t, std::char_traits<wchar_t>, std::allocator<wchar_t>>, std::vector<docopt_fish::error_t, std::allocator<docopt_fish::error_t>>*)
bool argument_parser_t::set_doc(string_t doc, error_list_t *out_errors) {
    docopt_impl *new_impl = new docopt_impl(std::move(doc));
    new_impl->populate_from_usage(out_errors);
    bool preflighted = new_impl->preflight(out_errors);
    if (preflighted) {
        // install the new impl
        // any existing one will be deleted
        std::swap(this->impl, new_impl);
    }
    delete new_impl;  // may be null
    return preflighted;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x28, %rsp
movq %rdx, %r15
movq %rsi, %r12
movq %rdi, %r14
movl $0xb0, %edi
callq 0x71e0
movq %rax, %rbx
leaq 0x8(%rsp), %r13
movq %r13, %rdi
movq %r12, %rsi
callq 0x73e0
xorl %r12d, %r12d
movq %r12, 0x10(%rbx)
xorps %xmm0, %xmm0
movups %xmm0, (%rbx)
leaq 0x18(%rbx), %rdi
movq %r13, %rsi
callq 0x73e0
leaq 0x88(%rbx), %rax
movl $0x0, 0x88(%rbx)
movq %r12, 0x90(%rbx)
xorps %xmm0, %xmm0
movups %xmm0, 0x38(%rbx)
movups %xmm0, 0x48(%rbx)
movups %xmm0, 0x58(%rbx)
movups %xmm0, 0x68(%rbx)
movq %r12, 0x78(%rbx)
movq %rax, 0x98(%rbx)
movq %rax, 0xa0(%rbx)
movq %r12, 0xa8(%rbx)
movq (%r13), %rdi
leaq 0x18(%rsp), %rax
cmpq %rax, %rdi
je 0x91d9
movq 0x18(%rsp), %rax
leaq 0x4(,%rax,4), %rsi
callq 0x7200
movq %rbx, %rdi
movq %r15, %rsi
callq 0xacea
movq %rbx, %rdi
movq %r15, %rsi
callq 0xb60e
movl %eax, %ebp
testb %al, %al
je 0x91fe
movq (%r14), %rax
movq %rbx, (%r14)
movq %rax, %rbx
testq %rbx, %rbx
je 0x9274
leaq 0x80(%rbx), %rdi
callq 0xfeb2
movq 0x68(%rbx), %rdi
testq %rdi, %rdi
je 0x9224
movq 0x78(%rbx), %rsi
subq %rdi, %rsi
callq 0x7200
movq 0x50(%rbx), %rdi
testq %rdi, %rdi
je 0x9239
movq 0x60(%rbx), %rsi
subq %rdi, %rsi
callq 0x7200
leaq 0x38(%rbx), %rdi
callq 0xb746
movq 0x18(%rbx), %rdi
leaq 0x28(%rbx), %rax
cmpq %rax, %rdi
je 0x925f
movq (%rax), %rax
leaq 0x4(,%rax,4), %rsi
callq 0x7200
movq %rbx, %rdi
callq 0xfe70
movl $0xb0, %esi
movq %rbx, %rdi
callq 0x7200
movl %ebp, %eax
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O1/ridiculousfish[P]docopt_fish/docopt_fish.cpp
// Function: docopt_fish::argument_parser_t::set_options(std::vector<docopt_fish::annotated_option_t, std::allocator<docopt_fish::annotated_option_t>>)
void argument_parser_t::set_options(std::vector<annotated_option_t> opts) {
    docopt_impl *new_impl = new docopt_impl(std::move(opts));
    new_impl->populate_from_annotated_options();
    bool preflighted = new_impl->preflight(nullptr);
    if (preflighted) {
        // install the new impl
        // any existing one will be deleted
        std::swap(this->impl, new_impl);
    }
    delete new_impl;  // may be null
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
subq $0x20, %rsp
movq %rsi, %r15
movq %rdi, %r14
movl $0xb0, %edi
callq 0x71e0
movq %rax, %rbx
movq (%r15), %rax
movq %rsp, %rdi
movq %rax, (%rdi)
movq 0x8(%r15), %rcx
movq %rcx, 0x8(%rdi)
movq 0x10(%r15), %rdx
movq %rdx, 0x10(%rdi)
xorl %esi, %esi
movq %rsi, 0x10(%r15)
xorps %xmm0, %xmm0
movups %xmm0, (%r15)
movq %rsi, 0x10(%rbx)
movups %xmm0, (%rbx)
leaq 0x28(%rbx), %r8
movq %r8, 0x18(%rbx)
movq %rsi, 0x20(%rbx)
movl %esi, 0x28(%rbx)
movq %rax, 0x38(%rbx)
movq %rcx, 0x40(%rbx)
movq %rdx, 0x48(%rbx)
movq %rsi, 0x10(%rdi)
movaps %xmm0, (%rdi)
leaq 0x88(%rbx), %rax
movl %esi, 0x88(%rbx)
movq %rsi, 0x90(%rbx)
movups %xmm0, 0x50(%rbx)
movups %xmm0, 0x60(%rbx)
movups %xmm0, 0x70(%rbx)
movq %rax, 0x98(%rbx)
movq %rax, 0xa0(%rbx)
movq %rsi, 0xa8(%rbx)
callq 0xb746
movq %rbx, %rdi
callq 0xb776
movq %rbx, %rdi
xorl %esi, %esi
callq 0xb60e
testb %al, %al
je 0x934a
movq (%r14), %rax
movq %rbx, (%r14)
movq %rax, %rbx
testq %rbx, %rbx
je 0x93c0
leaq 0x80(%rbx), %rdi
callq 0xfeb2
movq 0x68(%rbx), %rdi
testq %rdi, %rdi
je 0x9370
movq 0x78(%rbx), %rsi
subq %rdi, %rsi
callq 0x7200
movq 0x50(%rbx), %rdi
testq %rdi, %rdi
je 0x9385
movq 0x60(%rbx), %rsi
subq %rdi, %rsi
callq 0x7200
leaq 0x38(%rbx), %rdi
callq 0xb746
movq 0x18(%rbx), %rdi
leaq 0x28(%rbx), %rax
cmpq %rax, %rdi
je 0x93ab
movq (%rax), %rax
leaq 0x4(,%rax,4), %rsi
callq 0x7200
movq %rbx, %rdi
callq 0xfe70
movl $0xb0, %esi
movq %rbx, %rdi
callq 0x7200
addq $0x20, %rsp
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_cpp_makefile_star2_O1/ridiculousfish[P]docopt_fish/docopt_fish.cpp
// Function: docopt_fish::get_next_line(std::__cxx11::basic_string<wchar_t, std::char_traits<wchar_t>, std::allocator<wchar_t>> const&, docopt_fish::rstring_t*)
static bool get_next_line(const string_t &base, rstring_t *inout_line) {
    assert(inout_line != nullptr);
    // Start at the end of the last line, or 0 if this is the first
    const size_t line_start = inout_line->end_offset();
    assert(line_start <= base.size());
    if (line_start == base.size()) {
        // Line exhausted
        return false;
    }

    // Take everything up to (and including) the newline if we have one
    size_t newline = base.find('\n', line_start);
    size_t line_end = (newline == string_t::npos ? base.size() : newline + 1);
    assert(line_end > line_start);
    *inout_line = rstring_t(base, line_start, line_end - line_start);
    // Empty lines are impossible
    assert(!inout_line->empty());
    return true;
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
testq %rsi, %rsi
je 0x9913
movq %rsi, %rbx
movq 0x8(%rsi), %r14
addq (%rsi), %r14
jb 0x9932
movq %rdi, %r15
movq 0x8(%rdi), %r12
cmpq %r12, %r14
ja 0x9951
je 0x9901
movq %r15, %rdi
movl $0xa, %esi
movq %r14, %rdx
callq 0x71b0
incq %rax
jne 0x98d3
movq 0x8(%r15), %rax
subq %r14, %rax
jbe 0x9970
movq (%r15), %rcx
movq 0x8(%r15), %rdx
subq %r14, %rdx
cmpq %rax, %rdx
cmovaeq %rax, %rdx
movq %r14, (%rbx)
movq %rdx, 0x8(%rbx)
movq %rcx, 0x10(%rbx)
testq %rdx, %rdx
je 0x998f
cmpq %r12, %r14
setne %al
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
leaq 0x191c0(%rip), %rdi     # 0x22ada
leaq 0x18713(%rip), %rsi     # 0x22034
leaq 0x191c8(%rip), %rcx     # 0x22af0
movl $0xf0, %edx
callq 0x7120
leaq 0x1923b(%rip), %rdi     # 0x22b74
leaq 0x18c4b(%rip), %rsi     # 0x2258b
leaq 0x1925a(%rip), %rcx     # 0x22ba1
movl $0x67, %edx
callq 0x7120
leaq 0x191d7(%rip), %rdi     # 0x22b2f
leaq 0x186d5(%rip), %rsi     # 0x22034
leaq 0x1918a(%rip), %rcx     # 0x22af0
movl $0xf3, %edx
callq 0x7120
leaq 0x191d2(%rip), %rdi     # 0x22b49
leaq 0x186b6(%rip), %rsi     # 0x22034
leaq 0x1916b(%rip), %rcx     # 0x22af0
movl $0xfc, %edx
callq 0x7120
leaq 0x191c9(%rip), %rdi     # 0x22b5f
leaq 0x18697(%rip), %rsi     # 0x22034
leaq 0x1914c(%rip), %rcx     # 0x22af0
movl $0xff, %edx
callq 0x7120
// File: /workspace/github_cpp_makefile_star2_O1/ridiculousfish[P]docopt_fish/docopt_fish.cpp
// Function: docopt_fish::compute_indent(docopt_fish::rstring_t const&, docopt_fish::rstring_t const&)
static size_t compute_indent(const rstring_t &src, const rstring_t &trimmed_src) {
    assert(trimmed_src.offset() >= src.offset() && trimmed_src.end_offset() <= src.end_offset());
    const size_t tabstop = 4;
    // Walk over the prefix of src, up to trimmed_src
    size_t result = 0;
    size_t length = trimmed_src.offset() - src.offset();
    for (size_t i = 0; i < length; i++) {
        if (src.at(i) != '\t') {
            // not a tab
            result += 1;
        } else {
            // is a tab. Round up to the next highest multiple of tabstop.
            // If we're already a multiple of tabstop, we want to go bigger.
            result = (result + tabstop) / tabstop * tabstop;
        }
    }
    return result;
}

// Assembly:
pushq %rax
movq (%rsi), %rcx
movq (%rdi), %rdx
cmpq %rdx, %rcx
jb 0x9a4e
movq 0x8(%rsi), %rax
addq %rcx, %rax
jb 0x9a2f
movq 0x8(%rdi), %rsi
movq %rsi, %r8
addq %rdx, %r8
jb 0x9a2f
cmpq %r8, %rax
ja 0x9a4e
subq %rdx, %rcx
jne 0x99e1
xorl %eax, %eax
jmp 0x9a0e
shlq $0x2, %rdx
addq 0x10(%rdi), %rdx
xorl %edi, %edi
xorl %eax, %eax
cmpq %rdi, %rsi
jb 0x9a10
leaq 0x1(%rax), %r8
andq $-0x4, %rax
addq $0x4, %rax
cmpl $0x9, (%rdx,%rdi,4)
cmovneq %r8, %rax
incq %rdi
cmpq %rdi, %rcx
jne 0x99ed
popq %rcx
retq
leaq 0x18bb7(%rip), %rdi     # 0x225ce
leaq 0x18b6d(%rip), %rsi     # 0x2258b
leaq 0x18bbe(%rip), %rcx     # 0x225e3
movl $0x76, %edx
callq 0x7120
leaq 0x1913e(%rip), %rdi     # 0x22b74
leaq 0x18b4e(%rip), %rsi     # 0x2258b
leaq 0x1915d(%rip), %rcx     # 0x22ba1
movl $0x67, %edx
callq 0x7120
leaq 0x191c6(%rip), %rdi     # 0x22c1b
leaq 0x185d8(%rip), %rsi     # 0x22034
leaq 0x1920d(%rip), %rcx     # 0x22c70
movl $0x162, %edx            # imm = 0x162
callq 0x7120
// File: /workspace/github_cpp_makefile_star2_O1/ridiculousfish[P]docopt_fish/./docopt_fish_types.h
// Function: docopt_fish::option_t::option_t(docopt_fish::option_t::name_type_t, docopt_fish::rstring_t const&, docopt_fish::rstring_t const&, unsigned int)
option_t(name_type_t type, const rstring_t &name, const rstring_t &v, option_flags_t f)
        : value(v), flags(f) {
        assert(type < NAME_TYPE_COUNT);
        assert(name.length() >= 2);
        assert(name[0] == '-');
        if (type == double_long) {
            assert(name.length() >= 3);
            assert(name[1] == '-');
        }
        this->names[type] = name;
    }

// Assembly:
pushq %rax
xorps %xmm0, %xmm0
movups %xmm0, 0x30(%rdi)
movups %xmm0, 0x20(%rdi)
movups %xmm0, 0x10(%rdi)
movups %xmm0, (%rdi)
xorl %eax, %eax
movq %rax, 0x40(%rdi)
movups (%rcx), %xmm1
movups %xmm1, 0x48(%rdi)
movq 0x10(%rcx), %rcx
movq %rcx, 0x58(%rdi)
movups %xmm0, 0x60(%rdi)
movq %rax, 0x70(%rdi)
movl %r8d, 0x78(%rdi)
cmpl $0x3, %esi
jge 0x9d1e
movq 0x8(%rdx), %rax
cmpq $0x1, %rax
jbe 0x9d3d
movq (%rdx), %rcx
movq 0x10(%rdx), %r8
cmpl $0x2d, (%r8,%rcx,4)
jne 0x9d5c
cmpl $0x2, %esi
jne 0x9d06
cmpq $0x2, %rax
je 0x9d7b
cmpl $0x2d, 0x4(%r8,%rcx,4)
jne 0x9d9a
movl %esi, %eax
leaq (%rax,%rax,2), %rax
movq 0x10(%rdx), %rcx
movq %rcx, 0x10(%rdi,%rax,8)
movups (%rdx), %xmm0
movups %xmm0, (%rdi,%rax,8)
popq %rax
retq
leaq 0x189ab(%rip), %rdi     # 0x226d0
leaq 0x1885f(%rip), %rsi     # 0x2258b
leaq 0x189b4(%rip), %rcx     # 0x226e7
movl $0x188, %edx            # imm = 0x188
callq 0x7120
leaq 0x18a06(%rip), %rdi     # 0x2274a
leaq 0x18840(%rip), %rsi     # 0x2258b
leaq 0x18995(%rip), %rcx     # 0x226e7
movl $0x189, %edx            # imm = 0x189
callq 0x7120
leaq 0x189fa(%rip), %rdi     # 0x2275d
leaq 0x18821(%rip), %rsi     # 0x2258b
leaq 0x18976(%rip), %rcx     # 0x226e7
movl $0x18a, %edx            # imm = 0x18A
callq 0x7120
leaq 0x189ea(%rip), %rdi     # 0x2276c
leaq 0x18802(%rip), %rsi     # 0x2258b
leaq 0x18957(%rip), %rcx     # 0x226e7
movl $0x18c, %edx            # imm = 0x18C
callq 0x7120
leaq 0x189de(%rip), %rdi     # 0x2277f
leaq 0x187e3(%rip), %rsi     # 0x2258b
leaq 0x18938(%rip), %rcx     # 0x226e7
movl $0x18d, %edx            # imm = 0x18D
callq 0x7120
nop
// File: /workspace/github_cpp_makefile_star2_O1/ridiculousfish[P]docopt_fish/docopt_fish.cpp
// Function: docopt_fish::docopt_impl::get_command_names[abi:cxx11]() const
std::vector<string_t> get_command_names() const {
        // Get the command names.
        // We store a set of seen names so we only return each name once,
        // but in the order matching their appearance in the usage spec.
        std::vector<string_t> result;
        std::set<rstring_t> seen;
        for (const usage_t &usage : this->usages) {
            const rstring_t &name = usage.prog_name;
            if (!name.empty() && seen.insert(name).second) {
                result.push_back(name.std_string());
            }
        }
        return result;
    }

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x58, %rsp
movq %rdi, %rbx
xorl %eax, %eax
movq %rax, 0x10(%rdi)
xorps %xmm0, %xmm0
movups %xmm0, (%rdi)
leaq 0x30(%rsp), %rcx
movl $0x0, (%rcx)
movq %rax, 0x8(%rcx)
movq %rcx, 0x10(%rcx)
movq %rcx, 0x18(%rcx)
movq %rax, 0x20(%rcx)
movq (%rsi), %r14
movq 0x8(%rsi), %rbp
cmpq %rbp, %r14
je 0xaa49
leaq 0x18(%rsp), %r13
leaq 0x28(%rsp), %r15
leaq 0x8(%rsp), %r12
cmpq $0x0, 0x8(%r14)
je 0xaa40
movq %r15, %rdi
movq %r14, %rsi
callq 0xdcc4
testb $0x1, %dl
je 0xaa40
movq %r12, %rdi
movq %r14, %rsi
callq 0xbec4
movq %rbx, %rdi
movq %r12, %rsi
callq 0xde04
movq 0x8(%rsp), %rdi
cmpq %r13, %rdi
je 0xaa40
movq 0x18(%rsp), %rax
leaq 0x4(,%rax,4), %rsi
callq 0x7200
addq $0x30, %r14
cmpq %rbp, %r14
jne 0xa9f7
leaq 0x28(%rsp), %rdi
callq 0xc244
movq %rbx, %rax
addq $0x58, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %r14
movq 0x8(%rsp), %rdi
cmpq %r13, %rdi
je 0xaa8b
movq 0x18(%rsp), %rax
leaq 0x4(,%rax,4), %rsi
callq 0x7200
jmp 0xaa8b
jmp 0xaa88
movq %rax, %r14
leaq 0x28(%rsp), %rdi
callq 0xc244
movq %rbx, %rdi
callq 0xc1d0
movq %r14, %rdi
callq 0x7360
nop
// File: /workspace/github_cpp_makefile_star2_O1/ridiculousfish[P]docopt_fish/./docopt_fish_types.h
// Function: docopt_fish::rstring_t::chop_length(unsigned long)
rstring_t chop_length(size_t len) {
        assert(len <= this->length());
        rstring_t result = this->substr(0, len);
        this->start_ += len;
        this->length_ -= len;
        return result;
    }

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
cmpq %rdx, 0x8(%rsi)
jb 0xbc54
movq %rdx, %rbx
movq %rsi, %r15
movq %rdi, %r14
xorl %edx, %edx
movq %rbx, %rcx
callq 0x9e70
addq %rbx, (%r15)
subq %rbx, 0x8(%r15)
movq %r14, %rax
popq %rbx
popq %r14
popq %r15
retq
leaq 0x169c1(%rip), %rdi     # 0x2261c
leaq 0x16929(%rip), %rsi     # 0x2258b
leaq 0x169c9(%rip), %rcx     # 0x22632
movl $0x56, %edx
callq 0x7120
// File: /workspace/github_cpp_makefile_star2_O1/ridiculousfish[P]docopt_fish/./docopt_fish_types.h
// Function: docopt_fish::rstring_t::compare(docopt_fish::rstring_t const&) const
int compare(const rstring_t &rhs) const {
        if (this == &rhs) {
            return 0;
        }
        if (this->base_ == rhs.base_ && this->start_ == rhs.start_ &&
            this->length_ == rhs.length_) {
            return 0;
        }

        return compare_internal(*this, rhs);
    }

// Assembly:
cmpq %rsi, %rdi
je 0xc001
movq 0x10(%rdi), %rax
cmpq 0x10(%rsi), %rax
jne 0xc004
movq (%rdi), %rax
cmpq (%rsi), %rax
jne 0xc004
movq 0x8(%rdi), %rax
cmpq 0x8(%rsi), %rax
jne 0xc004
xorl %eax, %eax
retq