LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_cpp_makefile_star2_O2/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 0x2130
leaq 0x8(%rbx), %rdi
movq %rax, 0x8(%rbx)
callq 0x2080
movq %rax, %r14
movq 0x65ba(%rip), %r15      # 0x8fd0
leaq 0x36aa(%rip), %rsi      # 0x60c7
movq %r15, %rdi
callq 0x2150
movq %rax, %rdi
movq %r14, %rsi
callq 0x2150
movq (%rbx), %rsi
movq 0x8(%rbx), %rdi
callq 0x20d0
movsd %xmm0, 0x8(%rsp)
leaq 0x3694(%rip), %rsi      # 0x60dd
movq %r15, %rdi
callq 0x2150
movq %rax, %rdi
movsd 0x8(%rsp), %xmm0
callq 0x21c0
leaq 0x365c(%rip), %rsi      # 0x60c2
movq %rax, %rdi
callq 0x2150
movq %rax, %rdi
addq $0x10, %rsp
popq %rbx
popq %r14
popq %r15
jmp 0x20c0
nop
// File: /workspace/github_cpp_makefile_star2_O2/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 %rdi, %rbx
movl (%rsi), %eax
movl %eax, (%rdi)
movslq (%rdx), %r15
movl %r15d, 0x4(%rdi)
movslq (%rsi), %r12
leaq (,%r12,8), %rdi
testq %r12, %r12
pushq $-0x1
popq %r13
cmovsq %r13, %rdi
callq 0x2030
movq %rax, %r14
movq %rax, 0x8(%rbx)
movl %r12d, %eax
imull %r15d, %eax
cltq
leaq (,%rax,8), %rdi
testl %eax, %eax
cmovsq %r13, %rdi
callq 0x2030
movq %rax, (%r14)
pushq $0x1
popq %rax
shlq $0x3, %r15
cmpq %r12, %rax
jge 0x2b01
movq 0x8(%rbx), %rcx
movq -0x8(%rcx,%rax,8), %rdx
addq %r15, %rdx
movq %rdx, (%rcx,%rax,8)
incq %rax
jmp 0x2ae7
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
nop
// File: /workspace/github_cpp_makefile_star2_O2/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 0x2bf9
movq %rsi, %r14
movq (%rsi), %rax
movq %rax, (%rbx)
movq 0x8(%rbx), %rdi
testq %rdi, %rdi
je 0x2b53
movq (%rdi), %rax
testq %rax, %rax
je 0x2b4e
movq %rax, %rdi
callq 0x2170
movq 0x8(%rbx), %rdi
testq %rdi, %rdi
je 0x2b53
callq 0x2170
movslq (%rbx), %r12
leaq (,%r12,8), %rdi
testq %r12, %r12
pushq $-0x1
popq %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)
pushq $0x1
popq %rax
leaq (,%r13,8), %rcx
cmpq %r12, %rax
jge 0x2bb9
movq 0x8(%rbx), %rdx
movq -0x8(%rdx,%rax,8), %rsi
addq %rcx, %rsi
movq %rsi, (%rdx,%rax,8)
incq %rax
jmp 0x2b9f
xorl %eax, %eax
testl %r13d, %r13d
cmovlel %eax, %r13d
testl %r12d, %r12d
cmovlel %eax, %r12d
cmpq %r12, %rax
je 0x2bf9
movq 0x8(%r14), %rcx
movq 0x8(%rbx), %rdx
xorl %esi, %esi
cmpq %rsi, %r13
je 0x2bf4
movq (%rcx,%rax,8), %rdi
movsd (%rdi,%rsi,8), %xmm0
movq (%rdx,%rax,8), %rdi
movsd %xmm0, (%rdi,%rsi,8)
incq %rsi
jmp 0x2bd8
incq %rax
jmp 0x2bc9
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O2/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, %rbx
movq %rdi, %r14
movslq (%rsi), %r12
movl %r12d, (%rdi)
movslq 0x4(%rsi), %r13
movl %r13d, 0x4(%rdi)
cmpq $0x0, 0x8(%rdi)
je 0x2c37
andq $0x0, 0x8(%r14)
leaq (,%r12,8), %rdi
testl %r12d, %r12d
pushq $-0x1
popq %rbp
cmovsq %rbp, %rdi
callq 0x2030
movq %rax, %r15
movq %rax, 0x8(%r14)
movl %r13d, %eax
imull %r12d, %eax
cltq
leaq (,%rax,8), %rdi
testl %eax, %eax
cmovsq %rbp, %rdi
callq 0x2030
movq %rax, (%r15)
pushq $0x1
popq %rax
leaq (,%r13,8), %rcx
cmpq %r12, %rax
jge 0x2c99
movq 0x8(%r14), %rdx
movq -0x8(%rdx,%rax,8), %rsi
addq %rcx, %rsi
movq %rsi, (%rdx,%rax,8)
incq %rax
jmp 0x2c7f
xorl %eax, %eax
testl %r13d, %r13d
cmovlel %eax, %r13d
testl %r12d, %r12d
cmovlel %eax, %r12d
cmpq %r12, %rax
je 0x2cd9
movq 0x8(%rbx), %rcx
movq 0x8(%r14), %rdx
xorl %esi, %esi
cmpq %rsi, %r13
je 0x2cd4
movq (%rcx,%rax,8), %rdi
movsd (%rdi,%rsi,8), %xmm0
movq (%rdx,%rax,8), %rdi
movsd %xmm0, (%rdi,%rsi,8)
incq %rsi
jmp 0x2cb8
incq %rax
jmp 0x2ca9
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/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 %rsi, %r14
movq %rdi, %rbx
xorl %r12d, %r12d
leaq 0x33c3(%rip), %r15      # 0x60f2
movslq (%r14), %rax
cmpq %rax, %r12
jge 0x2d82
xorl %r13d, %r13d
movslq 0x4(%r14), %rax
cmpq %rax, %r13
jge 0x2d75
movq 0x8(%r14), %rax
movq (%rax,%r12,8), %rax
movsd (%rax,%r13,8), %xmm0
movq %rbx, %rdi
callq 0x21c0
movslq 0x4(%r14), %rax
decq %rax
cmpq %rax, %r13
jge 0x2d70
movq %rbx, %rdi
movq %r15, %rsi
callq 0x2150
incq %r13
jmp 0x2d3a
movq %rbx, %rdi
callq 0x20c0
incq %r12
jmp 0x2d2f
movq %rbx, %rax
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
nop
// File: /workspace/github_cpp_makefile_star2_O2/joraso[P]Glassius/Particles.cpp
// Function: Particles::SaveTrajectory()
void Particles::SaveTrajectory(){
    /* Writes positions, velocities and forces to their respective trajectory
    files. */
    ofstream rtraj, vtraj, ftraj;
    
    rtraj.open("Data/rtraj.csv", std::ios::app);
    vtraj.open("Data/vtraj.csv", std::ios::app);
    ftraj.open("Data/ftraj.csv", std::ios::app);
    
    // File check-stops
    if(!rtraj.is_open()){
        cout << "Error opening position-trajectory file!" << endl;
        exit(1);
    }
    if(!vtraj.is_open()){
        cout << "Error opening velocity-trajectory file!" << endl;
        exit(1);
    }
    if(!ftraj.is_open()){
        cout << "Error opening force-trajectory file!" << endl;
        exit(1);
    }
    
    rtraj << positions; vtraj << velocities; ftraj << forces;
    rtraj.close(); vtraj.close(); ftraj.close();
    
}

// Assembly:
pushq %rbx
subq $0x600, %rsp            # imm = 0x600
movq %rdi, %rbx
leaq 0x400(%rsp), %rdi
callq 0x21d0
leaq 0x200(%rsp), %rdi
callq 0x21d0
movq %rsp, %rdi
callq 0x21d0
leaq 0x3140(%rip), %rsi      # 0x6180
leaq 0x400(%rsp), %rdi
pushq $0x1
popq %rdx
callq 0x2050
leaq 0x3138(%rip), %rsi      # 0x618f
leaq 0x200(%rsp), %rdi
pushq $0x1
popq %rdx
callq 0x2050
leaq 0x3130(%rip), %rsi      # 0x619e
movq %rsp, %rdi
pushq $0x1
popq %rdx
callq 0x2050
leaq 0x470(%rsp), %rdi
callq 0x2060
testb %al, %al
je 0x3133
leaq 0x270(%rsp), %rdi
callq 0x2060
testb %al, %al
je 0x3150
leaq 0x70(%rsp), %rdi
callq 0x2060
testb %al, %al
je 0x316d
leaq 0x20(%rbx), %rsi
leaq 0x400(%rsp), %rdi
callq 0x2d16
leaq 0x30(%rbx), %rsi
leaq 0x200(%rsp), %rdi
callq 0x2d16
addq $0x40, %rbx
movq %rsp, %rdi
movq %rbx, %rsi
callq 0x2d16
leaq 0x400(%rsp), %rdi
callq 0x2180
leaq 0x200(%rsp), %rdi
callq 0x2180
movq %rsp, %rdi
callq 0x2180
movq %rsp, %rdi
callq 0x21a0
leaq 0x200(%rsp), %rdi
callq 0x21a0
leaq 0x400(%rsp), %rdi
callq 0x21a0
addq $0x600, %rsp            # imm = 0x600
popq %rbx
retq
movq 0x5e96(%rip), %rdi      # 0x8fd0
leaq 0x306c(%rip), %rsi      # 0x61ad
callq 0x2150
movq %rax, %rdi
callq 0x20c0
jmp 0x3188
movq 0x5e79(%rip), %rdi      # 0x8fd0
leaq 0x3077(%rip), %rsi      # 0x61d5
callq 0x2150
movq %rax, %rdi
callq 0x20c0
jmp 0x3188
movq 0x5e5c(%rip), %rdi      # 0x8fd0
leaq 0x3082(%rip), %rsi      # 0x61fd
callq 0x2150
movq %rax, %rdi
callq 0x20c0
pushq $0x1
popq %rdi
callq 0x2160
movq %rax, %rbx
jmp 0x31a5
movq %rax, %rbx
jmp 0x31b2
movq %rax, %rbx
movq %rsp, %rdi
callq 0x21a0
leaq 0x200(%rsp), %rdi
callq 0x21a0
leaq 0x400(%rsp), %rdi
callq 0x21a0
movq %rbx, %rdi
callq 0x2200
nop
// File: /workspace/github_cpp_makefile_star2_O2/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:
andq $0x0, 0x78(%rdi)
movl 0x50(%rdi), %eax
movq 0x10(%rdi), %rcx
xorl %edx, %edx
testl %eax, %eax
cmovlel %edx, %eax
xorpd %xmm0, %xmm0
movsd 0x2f19(%rip), %xmm1     # 0x6100
cmpq %rax, %rdx
je 0x321a
movq (%rcx,%rdx,8), %rsi
xorl %r8d, %r8d
cmpq $0x3, %r8
je 0x3215
movsd (%rsi,%r8,8), %xmm2
mulsd %xmm2, %xmm2
mulsd %xmm1, %xmm2
addsd %xmm2, %xmm0
movsd %xmm0, 0x78(%rdi)
incq %r8
jmp 0x31f3
incq %rdx
jmp 0x31e7
retq
nop
// File: /workspace/github_cpp_makefile_star2_O2/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 0x2ee4(%rip), %xmm1     # 0x6110
movl 0x50(%rdi), %eax
decl %eax
cvtsi2sd %eax, %xmm0
mulsd %xmm1, %xmm0
divsd 0x78(%rdi), %xmm0
xorpd %xmm1, %xmm1
ucomisd %xmm1, %xmm0
jb 0x324e
sqrtsd %xmm0, %xmm0
jmp 0x3253
callq 0x2100
andq $0x0, 0x78(%rbx)
movl 0x50(%rbx), %eax
movq 0x10(%rbx), %rcx
xorl %edx, %edx
testl %eax, %eax
cmovlel %edx, %eax
movsd 0x2e92(%rip), %xmm1     # 0x6100
cmpq %rax, %rdx
je 0x32a9
movq (%rcx,%rdx,8), %rsi
xorl %edi, %edi
cmpq $0x3, %rdi
je 0x32a4
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
jmp 0x3279
incq %rdx
jmp 0x326e
popq %rbx
retq
nop
// File: /workspace/github_cpp_makefile_star2_O2/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:
movl 0x50(%rdi), %eax
movq 0x18(%rdi), %rcx
xorl %edx, %edx
testl %eax, %eax
cmovlel %edx, %eax
cmpq %rax, %rdx
je 0x32db
movq (%rcx,%rdx,8), %rsi
xorl %r8d, %r8d
cmpq $0x3, %r8
je 0x32d6
andq $0x0, (%rsi,%r8,8)
incq %r8
jmp 0x32c6
incq %rdx
jmp 0x32ba
andq $0x0, 0x80(%rdi)
retq
// File: /workspace/github_cpp_makefile_star2_O2/joraso[P]Glassius/Integration.cpp
// Function: Integrator::Run(double)
void Integrator::Run(double t){
    /* Advanced the integration for time=t. Records into an energy file AND a 
    trajectory file as it does. Does not themostate the system. */
    
    // Cycling indeces
    int m, n; int steps = int(t/dt);
    int cycles = int(steps/Nrecord);
    
    // Retrieving the system time
    time = System->Time();
    
    // Prepping output file
    std::ofstream energyfile;
    energyfile.open(efilename, std::ios::app);
    
    // File check-stop
    if(!energyfile.is_open()){
        cout << "Error opening energy file!" << endl;
        exit(1);
    }
    
    // Integrating
    for(m=0;m<cycles;m++){
        for(n=0;n<Nrecord;n++){Propigate();}
        energyfile << time << ", ";
        energyfile << System->KE() << ", ";
        energyfile << System->PE() << ", ";
        energyfile << System->TotalEnergy() << std::endl;
        if (recordtraj) {System->SaveTrajectory();};
    }
    
    // Closing the energy file
    energyfile.close();
    
    // Storing the system time
    System->setTime(time);
    
    return;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x208, %rsp            # imm = 0x208
movq %rdi, %rbx
divsd 0x18(%rdi), %xmm0
cvttsd2si %xmm0, %eax
cltd
idivl 0x28(%rdi)
movl %eax, %ebp
movq 0x8(%rdi), %rax
movsd 0x70(%rax), %xmm0
movsd %xmm0, 0x20(%rdi)
leaq 0x8(%rsp), %r14
movq %r14, %rdi
callq 0x21d0
leaq 0x30(%rbx), %rsi
pushq $0x1
popq %rdx
movq %r14, %rdi
callq 0x20b0
leaq 0x78(%rsp), %rdi
callq 0x2060
testb %al, %al
je 0x3c77
xorl %r12d, %r12d
testl %ebp, %ebp
cmovlel %r12d, %ebp
leaq 0x8(%rsp), %r14
leaq 0x26c4(%rip), %r15      # 0x625c
cmpl %ebp, %r12d
je 0x3c43
xorl %r13d, %r13d
cmpl 0x28(%rbx), %r13d
jge 0x3bb8
movq (%rbx), %rax
movq %rbx, %rdi
callq *0x8(%rax)
incl %r13d
jmp 0x3ba4
movsd 0x20(%rbx), %xmm0
movq %r14, %rdi
callq 0x21c0
movq %rax, %rdi
movq %r15, %rsi
callq 0x2150
movq 0x8(%rbx), %rdi
callq 0x40dc
movq %r14, %rdi
callq 0x21c0
movq %rax, %rdi
movq %r15, %rsi
callq 0x2150
movq 0x8(%rbx), %rax
movsd 0x80(%rax), %xmm0
movq %r14, %rdi
callq 0x21c0
movq %rax, %rdi
movq %r15, %rsi
callq 0x2150
movq 0x8(%rbx), %rax
movsd 0x78(%rax), %xmm0
addsd 0x80(%rax), %xmm0
movq %r14, %rdi
callq 0x21c0
movq %rax, %rdi
callq 0x20c0
cmpb $0x1, 0x50(%rbx)
jne 0x3c3b
movq 0x8(%rbx), %rdi
callq 0x300c
incl %r12d
jmp 0x3b98
leaq 0x8(%rsp), %rdi
callq 0x2180
movq 0x8(%rbx), %rax
movsd 0x20(%rbx), %xmm0
movsd %xmm0, 0x70(%rax)
leaq 0x8(%rsp), %rdi
callq 0x21a0
addq $0x208, %rsp            # imm = 0x208
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq 0x5352(%rip), %rdi      # 0x8fd0
leaq 0x25bc(%rip), %rsi      # 0x6241
callq 0x2150
movq %rax, %rdi
callq 0x20c0
pushq $0x1
popq %rdi
callq 0x2160
jmp 0x3c9e
jmp 0x3c9e
movq %rax, %rbx
leaq 0x8(%rsp), %rdi
callq 0x21a0
movq %rbx, %rdi
callq 0x2200
nop
// File: /workspace/github_cpp_makefile_star2_O2/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
movsd 0x18(%rdi), %xmm0
mulsd %xmm0, %xmm0
movq 0x8(%rdi), %rdi
movl 0x50(%rdi), %r14d
xorl %eax, %eax
testl %r14d, %r14d
cmovlel %eax, %r14d
movsd 0x2429(%rip), %xmm3     # 0x6108
cmpq %r14, %rax
je 0x3d53
movq 0x8(%rdi), %rsi
movq 0x10(%rdi), %rcx
movq (%rcx,%rax,8), %rcx
movq 0x18(%rdi), %rdx
movq (%rdx,%rax,8), %rdx
movq (%rsi,%rax,8), %rsi
xorl %r8d, %r8d
cmpq $0x3, %r8
je 0x3d4e
movsd (%rcx,%r8,8), %xmm1
movsd (%rdx,%r8,8), %xmm2
mulsd %xmm3, %xmm2
mulsd %xmm0, %xmm2
mulsd 0x18(%rbx), %xmm1
addsd %xmm2, %xmm1
addsd (%rsi,%r8,8), %xmm1
movsd %xmm1, (%rsi,%r8,8)
movsd (%rdx,%r8,8), %xmm1
mulsd %xmm3, %xmm1
mulsd 0x18(%rbx), %xmm1
addsd (%rcx,%r8,8), %xmm1
movsd %xmm1, (%rcx,%r8,8)
incq %r8
jmp 0x3cff
incq %rax
jmp 0x3cdf
movq (%rdi), %rax
callq *(%rax)
movsd 0x23a8(%rip), %xmm1     # 0x6108
movq 0x8(%rbx), %rdi
xorl %eax, %eax
cmpq %r14, %rax
je 0x3da5
movq 0x10(%rdi), %rdx
movq 0x18(%rdi), %rcx
movq (%rcx,%rax,8), %rcx
movq (%rdx,%rax,8), %rdx
xorl %esi, %esi
cmpq $0x3, %rsi
je 0x3da0
movsd 0x18(%rbx), %xmm0
mulsd %xmm1, %xmm0
mulsd (%rcx,%rsi,8), %xmm0
addsd (%rdx,%rsi,8), %xmm0
movsd %xmm0, (%rdx,%rsi,8)
incq %rsi
jmp 0x3d7d
incq %rax
jmp 0x3d66
callq 0x31c8
movsd 0x18(%rbx), %xmm0
addsd 0x20(%rbx), %xmm0
movsd %xmm0, 0x20(%rbx)
addq $0x8, %rsp
popq %rbx
popq %r14
retq
nop
// File: /workspace/github_cpp_makefile_star2_O2/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 0x3dea
sqrtsd %xmm0, %xmm0
jmp 0x3def
callq 0x2100
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 0x2a88
leaq 0x68(%rbx), %rdi
movq %r14, %rsi
callq 0x2b0c
leaq 0x8(%rsp), %rdi
callq 0x2ce8
leaq 0x4(%rsp), %rdx
movl $0x3, (%rdx)
leaq 0x8(%rsp), %r14
movq %rsp, %rsi
movq %r14, %rdi
callq 0x2a88
leaq 0x78(%rbx), %rdi
movq %r14, %rsi
callq 0x2b0c
leaq 0x8(%rsp), %rdi
callq 0x2ce8
leaq 0x4(%rsp), %rdx
movl $0x3, (%rdx)
leaq 0x8(%rsp), %r14
movq %rsp, %rsi
movq %r14, %rdi
callq 0x2a88
leaq 0x88(%rbx), %rdi
movq %r14, %rsi
callq 0x2b0c
leaq 0x8(%rsp), %rdi
callq 0x2ce8
movq 0x70(%rbx), %rax
movq 0x80(%rbx), %rcx
movq %rax, 0x98(%rbx)
movq %rcx, 0xa0(%rbx)
movq 0x90(%rbx), %rdx
movq %rdx, 0xa8(%rbx)
movl (%rsp), %esi
xorl %edi, %edi
testl %esi, %esi
cmovlel %edi, %esi
cmpq %rsi, %rdi
je 0x3ef7
movq (%rax,%rdi,8), %r8
movq (%rcx,%rdi,8), %r9
movq (%rdx,%rdi,8), %r10
xorl %r11d, %r11d
cmpq $0x3, %r11
je 0x3ef2
andq $0x0, (%r8,%r11,8)
andq $0x0, (%r9,%r11,8)
andq $0x0, (%r10,%r11,8)
incq %r11
jmp 0x3ed8
incq %rdi
jmp 0x3ec4
addq $0x18, %rsp
popq %rbx
popq %r14
retq
jmp 0x3f03
jmp 0x3f03
movq %rax, %rbx
leaq 0x8(%rsp), %rdi
callq 0x2ce8
movq %rbx, %rdi
callq 0x2200
// File: /workspace/github_cpp_makefile_star2_O2/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 %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x10, %rsp
movq %rdi, %rbx
movq 0x8(%rdi), %rdi
movl 0x50(%rdi), %r14d
movsd 0x18(%rbx), %xmm0
movsd %xmm0, 0x8(%rsp)
xorl %r15d, %r15d
testl %r14d, %r14d
cmovlel %r15d, %r14d
movsd 0x210b(%rip), %xmm1     # 0x6058
cmpq %r14, %r15
je 0x4001
xorl %r12d, %r12d
cmpq $0x3, %r12
je 0x3ff9
movsd 0x60(%rbx), %xmm0
movsd %xmm0, (%rsp)
xorpd %xmm0, %xmm0
callq 0x27f2
movsd 0x20da(%rip), %xmm1     # 0x6058
mulsd (%rsp), %xmm0
movq 0x98(%rbx), %rax
movq (%rax,%r15,8), %rax
movsd %xmm0, (%rax,%r12,8)
movq 0x8(%rbx), %rdi
movq 0xa0(%rbx), %rcx
movq 0x18(%rdi), %rdx
movq (%rdx,%r15,8), %rdx
movsd (%rdx,%r12,8), %xmm0
movq (%rcx,%r15,8), %rcx
movsd %xmm0, (%rcx,%r12,8)
movq 0x8(%rdi), %rcx
movq (%rcx,%r15,8), %rcx
movsd (%rcx,%r12,8), %xmm0
movq 0xa8(%rbx), %rsi
movq (%rsi,%r15,8), %rsi
movsd %xmm0, (%rsi,%r12,8)
movsd 0x18(%rbx), %xmm2
mulsd (%rdx,%r12,8), %xmm2
addsd %xmm0, %xmm2
addsd (%rax,%r12,8), %xmm2
movsd %xmm2, (%rcx,%r12,8)
incq %r12
jmp 0x3f59
incq %r15
jmp 0x3f4d
divsd 0x8(%rsp), %xmm1
movsd %xmm1, (%rsp)
movq (%rdi), %rax
callq *(%rax)
movsd (%rsp), %xmm3
movq 0xa8(%rbx), %rax
movq 0x8(%rbx), %rdi
movq 0x98(%rbx), %rcx
movq 0xa0(%rbx), %rdx
xorl %esi, %esi
movsd 0x20cf(%rip), %xmm0     # 0x6108
cmpq %r14, %rsi
je 0x40b1
movq (%rax,%rsi,8), %r8
movq 0x18(%rdi), %r9
movq (%r9,%rsi,8), %r9
movq (%rdx,%rsi,8), %r10
movq (%rcx,%rsi,8), %r11
movq 0x8(%rdi), %r15
movq 0x10(%rdi), %r12
movq (%r15,%rsi,8), %r15
movq (%r12,%rsi,8), %r12
xorl %r13d, %r13d
cmpq $0x18, %r13
je 0x40ac
movsd 0x18(%rbx), %xmm1
mulsd %xmm0, %xmm1
movsd (%r9,%r13), %xmm2
addsd (%r10,%r13), %xmm2
mulsd %xmm1, %xmm2
addsd (%r8,%r13), %xmm2
addsd (%r11,%r13), %xmm2
movsd %xmm2, (%r15,%r13)
subsd (%r8,%r13), %xmm2
mulsd %xmm3, %xmm2
movsd %xmm2, (%r12,%r13)
addq $0x8, %r13
jmp 0x4065
incq %rsi
jmp 0x4039
movq (%rdi), %rax
callq *(%rax)
movq 0x8(%rbx), %rdi
callq 0x31c8
movsd 0x18(%rbx), %xmm0
addsd 0x20(%rbx), %xmm0
movsd %xmm0, 0x20(%rbx)
addq $0x10, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
// File: /workspace/github_cpp_makefile_star2_O2/ridiculousfish[P]docopt_fish/docopt_fish.cpp
// Function: docopt_fish::argv_classifier_t::classify_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&, std::vector<docopt_fish::option_t, std::allocator<docopt_fish::option_t>> const&, std::map<docopt_fish::rstring_t, docopt_fish::base_metadata_t<docopt_fish::rstring_t>, std::less<docopt_fish::rstring_t>, std::allocator<std::pair<docopt_fish::rstring_t const, docopt_fish::base_metadata_t<docopt_fish::rstring_t>>>> const&, unsigned int, std::vector<docopt_fish::error_t, std::allocator<docopt_fish::error_t>>*, docopt_fish::suggestion_t*)
arg_classification_t argv_classifier_t::classify_arguments(const string_list_t &argv, const option_list_t &options,
                                                          const metadata_map_t &md_map, parse_flags_t flags,
                                                          error_list_t *out_errors, suggestion_t *out_suggestion) {
    argv_classifier_t st(argv, options, md_map, flags);
    while (st.idx < argv.size()) {
        st.parse_next_arg(out_errors);
    }
    
    if (out_suggestion)
        *out_suggestion = std::move(st.suggestion);
    
    return std::move(st.classification);
}

// Assembly:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0xf0, %rsp
movq %r9, %r15
movq %rsi, %r12
movq %rdi, %rbx
movq 0x120(%rsp), %r14
movq %rsp, %r13
movq %r13, %rdi
callq 0x9414
movq 0x8(%r12), %rax
subq (%r12), %rax
sarq $0x5, %rax
cmpq %rax, 0x20(%rsp)
jae 0x86a5
movq %r13, %rdi
movq %r15, %rsi
callq 0x84ca
jmp 0x8684
testq %r14, %r14
je 0x86b7
leaq 0x60(%rsp), %rsi
movq %r14, %rdi
callq 0x946c
leaq 0x28(%rsp), %rsi
movq %rbx, %rdi
callq 0x94a2
movq %rsp, %rdi
callq 0x94de
movq %rbx, %rax
addq $0xf0, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
movq %rax, %rbx
movq %rsp, %rdi
callq 0x94de
movq %rbx, %rdi
callq 0x7390
nop
// File: /workspace/github_cpp_makefile_star2_O2/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 0x94f8
xorps %xmm0, %xmm0
movaps %xmm0, (%r12)
andq $0x0, 0x10(%r12)
movq (%r15), %rdi
leaq 0x10(%rsp), %r8
movq %r14, %rsi
movl %ebp, %edx
xorl %ecx, %ecx
xorl %r9d, %r9d
callq 0x954e
movq 0x10(%rsp), %r14
movq 0x18(%rsp), %r15
cmpq %r15, %r14
je 0x8778
movq (%r14), %rsi
movq %rbx, %rdi
callq 0x9610
andl $0x0, (%rax)
addq $0x8, %r14
jmp 0x875f
leaq 0x10(%rsp), %rdi
callq 0xf208
movq %rbx, %rax
addq $0x30, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
jmp 0x8794
movq %rax, %r14
leaq 0x10(%rsp), %rdi
callq 0xf208
movq %rbx, %rdi
callq 0xf268
movq %r14, %rdi
callq 0x7390
nop
// File: /workspace/github_cpp_makefile_star2_O2/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 %rbx
subq $0x20, %rsp
movq %rsi, %r14
movq %rdi, %rbx
callq 0xabee
movq %rsp, %rdi
movq %r14, %rsi
callq 0xac82
movq %rsp, %r15
movq %rbx, %rdi
movq %r15, %rsi
callq 0x7410
movq %r15, %rdi
callq 0x7050
leaq 0x18(%r14), %rsi
movq %rsp, %rdi
callq 0xac82
leaq 0x20(%rbx), %rdi
movq %rsp, %r15
movq %r15, %rsi
callq 0x7410
movq %r15, %rdi
callq 0x7050
leaq 0x30(%r14), %rsi
movq %rsp, %rdi
callq 0xac82
leaq 0x40(%rbx), %rdi
movq %rsp, %r15
movq %r15, %rsi
callq 0x7410
movq %r15, %rdi
callq 0x7050
movl 0x48(%r14), %eax
movl %eax, 0x60(%rbx)
movq %rbx, %rax
addq $0x20, %rsp
popq %rbx
popq %r14
popq %r15
retq
jmp 0x88a0
jmp 0x88a0
movq %rax, %r14
movq %rbx, %rdi
callq 0xac62
movq %r14, %rdi
callq 0x7390
nop
// File: /workspace/github_cpp_makefile_star2_O2/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 0x7240
movq %rax, %rbx
leaq 0x8(%rsp), %r13
movq %r13, %rdi
movq %r12, %rsi
callq 0x7430
movq %rbx, %rdi
movq %r13, %rsi
callq 0x9b58
movq %r13, %rdi
callq 0x7050
movq %rbx, %rdi
movq %r15, %rsi
callq 0x9bb6
movq %rbx, %rdi
movq %r15, %rsi
callq 0xa2ec
movl %eax, %ebp
testb %al, %al
je 0x89b5
movq (%r14), %rax
movq %rbx, (%r14)
movq %rax, %rbx
testq %rax, %rax
je 0x89db
movq %rbx, %rdi
callq 0xa400
movl $0xb0, %esi
movq %rbx, %rdi
callq 0x7260
movl %ebp, %eax
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
xorl %ebx, %ebx
jmp 0x89bd
nop
// File: /workspace/github_cpp_makefile_star2_O2/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 %r12
pushq %rbx
subq $0x18, %rsp
movq %rsi, %r15
movq %rdi, %r14
movl $0xb0, %edi
callq 0x7240
movq %rax, %rbx
movups (%r15), %xmm0
movq %rsp, %r12
movaps %xmm0, (%r12)
movq 0x10(%r15), %rax
movq %rax, 0x10(%r12)
xorps %xmm0, %xmm0
movups %xmm0, (%r15)
andq $0x0, 0x10(%r15)
movq %rbx, %rdi
movq %r12, %rsi
callq 0xa43e
movq %r12, %rdi
callq 0xa4aa
movq %rbx, %rdi
callq 0xa4cc
movq %rbx, %rdi
xorl %esi, %esi
callq 0xa2ec
testb %al, %al
je 0x8a56
movq (%r14), %rax
movq %rbx, (%r14)
movq %rax, %rbx
testq %rax, %rax
je 0x8a77
movq %rbx, %rdi
callq 0xa400
movl $0xb0, %esi
movq %rbx, %rdi
callq 0x7260
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
xorl %ebx, %ebx
jmp 0x8a5e
nop
// File: /workspace/github_cpp_makefile_star2_O2/ridiculousfish[P]docopt_fish/docopt_fish.cpp
// Function: docopt_fish::suggestion_for(docopt_fish::rstring_t const&, std::map<docopt_fish::rstring_t, docopt_fish::base_metadata_t<docopt_fish::rstring_t>, std::less<docopt_fish::rstring_t>, std::allocator<std::pair<docopt_fish::rstring_t const, docopt_fish::base_metadata_t<docopt_fish::rstring_t>>>> const&, unsigned long)
static suggestion_t suggestion_for(const rstring_t &name, const metadata_map_t &md_map, size_t offset = 0) {
    metadata_t md;
    auto suggestion_iter = md_map.find(name);
    if (suggestion_iter != md_map.end()) {
        md = copyout_metadata(suggestion_iter->second);
    }
    return suggestion_t(name.std_string(), std::move(md), offset);
}

// Assembly:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x160, %rsp            # imm = 0x160
movq %rcx, %rbx
movq %rdx, %r12
leaq 0x38(%rsp), %rax
movq %rax, -0x10(%rax)
andq $0x0, -0x8(%rax)
andl $0x0, (%rax)
leaq 0x58(%rsp), %rax
movq %rax, -0x10(%rax)
andq $0x0, -0x8(%rax)
andl $0x0, (%rax)
leaq 0x78(%rsp), %rax
movq %rax, -0x10(%rax)
andq $0x0, -0x8(%rax)
movq %rsi, %r15
andl $0x0, (%rax)
movq %rdi, %r14
andl $0x0, 0x10(%rax)
movq %rdx, %rdi
callq 0xad26
addq $0x8, %r12
cmpq %r12, %rax
je 0x8c00
addq $0x38, %rax
leaq 0x90(%rsp), %rdi
movq %rax, %rsi
callq 0x880d
leaq 0x28(%rsp), %rdi
leaq 0x90(%rsp), %r12
movq %r12, %rsi
callq 0xac26
movq %r12, %rdi
callq 0xac62
leaq 0x8(%rsp), %rdi
movq %r15, %rsi
callq 0xac82
leaq 0xf8(%rsp), %r15
leaq 0x28(%rsp), %r12
movq %r15, %rdi
movq %r12, %rsi
callq 0xacc2
leaq 0x8(%rsp), %r13
movq %r14, %rdi
movq %r13, %rsi
movq %r15, %rdx
movq %rbx, %rcx
callq 0xacfa
movq %r15, %rdi
callq 0xac62
movq %r13, %rdi
callq 0x7050
movq %r12, %rdi
callq 0xac62
movq %r14, %rax
addq $0x160, %rsp            # imm = 0x160
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
jmp 0x8c69
movq %rax, %rbx
leaq 0x28(%rsp), %rdi
callq 0xac62
movq %rbx, %rdi
callq 0x7390
// File: /workspace/github_cpp_makefile_star2_O2/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 0x8cf4
movq %rsi, %rbx
movq %rdi, %r14
movq %rsi, %rdi
callq 0xd2d2
movq 0x8(%r14), %r12
cmpq %r12, %rax
ja 0x8d13
movq %rax, %r15
je 0x8ce2
pushq $0xa
popq %rsi
movq %r14, %rdi
movq %r15, %rdx
callq 0x71f0
incq %rax
movq 0x8(%r14), %rcx
cmoveq %rcx, %rax
subq %r15, %rax
jbe 0x8d32
subq %r15, %rcx
cmpq %rax, %rcx
cmovaeq %rax, %rcx
movq (%r14), %rax
movq %r15, (%rbx)
movq %rcx, 0x8(%rbx)
movq %rax, 0x10(%rbx)
testq %rcx, %rcx
je 0x8d51
cmpq %r12, %r15
setne %al
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
leaq 0x13ddf(%rip), %rdi     # 0x1cada
leaq 0x13332(%rip), %rsi     # 0x1c034
leaq 0x13de7(%rip), %rcx     # 0x1caf0
movl $0xf0, %edx
callq 0x7150
leaq 0x13e15(%rip), %rdi     # 0x1cb2f
leaq 0x13313(%rip), %rsi     # 0x1c034
leaq 0x13dc8(%rip), %rcx     # 0x1caf0
movl $0xf3, %edx
callq 0x7150
leaq 0x13e10(%rip), %rdi     # 0x1cb49
leaq 0x132f4(%rip), %rsi     # 0x1c034
leaq 0x13da9(%rip), %rcx     # 0x1caf0
movl $0xfc, %edx
callq 0x7150
leaq 0x13e07(%rip), %rdi     # 0x1cb5f
leaq 0x132d5(%rip), %rsi     # 0x1c034
leaq 0x13d8a(%rip), %rcx     # 0x1caf0
movl $0xff, %edx
callq 0x7150
// File: /workspace/github_cpp_makefile_star2_O2/ridiculousfish[P]docopt_fish/./docopt_fish_types.h
// Function: docopt_fish::rstring_t::has_prefix(char const*) const
inline bool has_prefix(const char *s) const {
        size_t len = strlen(s);
        if (len > this->length()) {
            return false;
        }
        return std::equal(s, s + len, this->begin());
    }

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq %rdi, %r14
movq %rsi, %rdi
callq 0x70c0
cmpq 0x8(%r14), %rax
jbe 0x8f3c
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
movq (%r14), %rdx
shlq $0x2, %rdx
addq 0x10(%r14), %rdx
addq %rbx, %rax
movq %rbx, %rdi
movq %rax, %rsi
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0xa906
// File: /workspace/github_cpp_makefile_star2_O2/ridiculousfish[P]docopt_fish/./docopt_fish_types.h
// Function: docopt_fish::rstring_t::scan_1_char(char)
rstring_t scan_1_char(char c) {
        rstring_t result;
        if (this->length() > 0 && this->at(0) == c) {
            result = this->chop_length(1);
        }
        return result;
    }

// Assembly:
pushq %rbp
pushq %r14
pushq %rbx
movq %rdi, %rbx
andq $0x0, 0x10(%rdi)
xorps %xmm0, %xmm0
movups %xmm0, (%rdi)
cmpq $0x0, 0x8(%rsi)
je 0x9226
movl %edx, %ebp
movq %rsi, %r14
movq %rsi, %rdi
xorl %esi, %esi
callq 0xa94e
movsbl %bpl, %ecx
cmpl %ecx, %eax
jne 0x9226
pushq $0x1
popq %rdx
movq %rbx, %rdi
movq %r14, %rsi
callq 0xaa86
movq %rbx, %rax
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/ridiculousfish[P]docopt_fish/docopt_fish.cpp
// Function: docopt_fish::docopt_impl::best_assignment_for_argv(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, std::vector<docopt_fish::error_t, std::allocator<docopt_fish::error_t>>*, std::vector<unsigned long, std::allocator<unsigned long>>*, std::map<docopt_fish::rstring_t, docopt_fish::argument_t, std::less<docopt_fish::rstring_t>, std::allocator<std::pair<docopt_fish::rstring_t const, docopt_fish::argument_t>>>*) const
void best_assignment_for_argv(const string_list_t &argv, parse_flags_t flags,
                                  error_list_t *out_errors, index_list_t *out_unused_arguments,
                                  option_rmap_t *out_option_map) const {
        // Extract positionals and arguments from argv, then produce an option map
        arg_classification_t aclass = argv_classifier_t::classify_arguments(argv, all_options,
                                                                            names_to_metadata,
                                                                            flags, out_errors);
        
        // The flag_stop_after_consuming_everything allows us to early-out in the matching process
        flags |= flag_stop_after_consuming_everything;
        match_results_t mr = match_usages(this->usages, flags, this->shortcut_options, aclass, argv);
        if (out_unused_arguments) {
            *out_unused_arguments = std::move(mr.unused_args);
        }
        if (out_option_map) {
            *out_option_map = std::move(mr.option_map);
        }
    }

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0xb8, %rsp
movq %r9, %rbx
movq %r8, %r14
movq %rcx, %r9
movl %edx, %ebp
movq %rsi, %r15
movq %rdi, %r12
leaq 0x68(%rdi), %rdx
leaq 0x80(%rdi), %rcx
andq $0x0, (%rsp)
leaq 0x8(%rsp), %r13
movq %r13, %rdi
movl %ebp, %r8d
callq 0x8658
orl $0x20000, %ebp          # imm = 0x20000
leaq 0x50(%r12), %rcx
leaq 0x40(%rsp), %rdi
movq %r12, %rsi
movl %ebp, %edx
movq %r13, %r8
movq %r15, %r9
callq 0x11d84
testq %r14, %r14
je 0x95c2
leaq 0x40(%rsp), %rsi
movq %r14, %rdi
callq 0xaf74
testq %rbx, %rbx
je 0x95d4
leaq 0x58(%rsp), %rsi
movq %rbx, %rdi
callq 0xafc6
leaq 0x40(%rsp), %rdi
callq 0xaf54
leaq 0x8(%rsp), %rdi
callq 0xaeca
addq $0xb8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
leaq 0x8(%rsp), %rdi
callq 0xaeca
movq %rbx, %rdi
callq 0x7390
nop
// File: /workspace/github_cpp_makefile_star2_O2/ridiculousfish[P]docopt_fish/docopt_fish.cpp
// Function: docopt_fish::docopt_impl::metadata_for_name(docopt_fish::rstring_t const&) const
base_metadata_t<rstring_t> metadata_for_name(const rstring_t &name) const {
        base_metadata_t<rstring_t> result;
        metadata_map_t::const_iterator where = this->names_to_metadata.find(name);
        if (where != this->names_to_metadata.end()) {
            result = where->second;
        }
        return result;
    }

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %r14
movq %rdi, %rbx
xorps %xmm0, %xmm0
movups %xmm0, 0x3c(%rdi)
movups %xmm0, 0x30(%rdi)
movups %xmm0, 0x20(%rdi)
movups %xmm0, 0x10(%rdi)
movups %xmm0, (%rdi)
leaq 0x80(%rsi), %rdi
movq %rdx, %rsi
callq 0xad26
addq $0x88, %r14
cmpq %r14, %rax
je 0x9902
addq $0x38, %rax
pushq $0x4c
popq %rcx
movq %rbx, %rdi
movq %rax, %rsi
rep  movsb (%rsi), %es:(%rdi)
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
nop
// File: /workspace/github_cpp_makefile_star2_O2/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 %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x50, %rsp
movq %rdi, %rbx
xorps %xmm0, %xmm0
movups %xmm0, (%rdi)
andq $0x0, 0x10(%rdi)
leaq 0x8(%rsp), %rax
andl $0x0, (%rax)
andq $0x0, 0x8(%rax)
movq %rax, 0x10(%rax)
movq %rax, 0x18(%rax)
andq $0x0, 0x20(%rax)
movq (%rsi), %r14
movq 0x8(%rsi), %r13
movq %rsp, %r15
leaq 0x30(%rsp), %r12
cmpq %r13, %r14
je 0x9992
cmpq $0x0, 0x8(%r14)
je 0x998c
movq %r15, %rdi
movq %r14, %rsi
callq 0xc73c
testb $0x1, %dl
je 0x998c
movq %r12, %rdi
movq %r14, %rsi
callq 0xac82
movq %rbx, %rdi
movq %r12, %rsi
callq 0xc8d0
movq %r12, %rdi
callq 0x7050
addq $0x30, %r14
jmp 0x9952
movq %rsp, %rdi
callq 0xb142
movq %rbx, %rax
addq $0x50, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
movq %rax, %r14
leaq 0x30(%rsp), %rdi
callq 0x7050
jmp 0x99bf
jmp 0x99bc
movq %rax, %r14
movq %rsp, %rdi
callq 0xb142
movq %rbx, %rdi
callq 0xb092
movq %r14, %rdi
callq 0x7390
nop
// File: /workspace/github_cpp_makefile_star2_O2/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 0xaab4
movq %rdx, %rbx
movq %rsi, %r15
movq %rdi, %r14
xorl %edx, %edx
movq %rbx, %rcx
callq 0x916e
addq %rbx, (%r15)
subq %rbx, 0x8(%r15)
movq %r14, %rax
popq %rbx
popq %r14
popq %r15
retq
leaq 0x11b61(%rip), %rdi     # 0x1c61c
leaq 0x11ac9(%rip), %rsi     # 0x1c58b
leaq 0x11b69(%rip), %rcx     # 0x1c632
pushq $0x56
popq %rdx
callq 0x7150
// File: /workspace/github_cpp_makefile_star2_O2/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 0xadd5
movq 0x10(%rdi), %rax
cmpq 0x10(%rsi), %rax
jne 0xadd8
movq (%rdi), %rax
cmpq (%rsi), %rax
jne 0xadd8
movq 0x8(%rdi), %rax
cmpq 0x8(%rsi), %rax
jne 0xadd8
xorl %eax, %eax
retq
// File: /workspace/github_cpp_makefile_star2_O2/ridiculousfish[P]docopt_fish/./docopt_fish_types.h
// Function: docopt_fish::rstring_t::trim_whitespace() const
rstring_t trim_whitespace() const {
        size_t left = 0, right = this->length();
        while (left < right && char_is_whitespace(this->at(left))) {
            left++;
        }
        while (right > left && char_is_whitespace(this->at(right - 1))) {
            right--;
        }
        assert(left <= right);
        return this->substr(left, right - left);
    }

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rsi, %r14
movq %rdi, (%rsp)
movq 0x8(%rsi), %r15
xorl %ebx, %ebx
movabsq $0x100002600, %rbp      # imm = 0x100002600
cmpq %rbx, %r15
je 0xd12e
movq %r14, %rdi
movq %rbx, %rsi
callq 0xa94e
cmpl $0x20, %eax
ja 0xd131
movl %eax, %eax
btq %rax, %rbp
jae 0xd131
incq %rbx
jmp 0xd10c
movq %r15, %rbx
movq %r15, %r12
movq %r15, %r13
subq %rbx, %r13
jbe 0xd159
leaq -0x1(%r12), %r15
movq %r14, %rdi
movq %r15, %rsi
callq 0xa94e
cmpl $0x20, %eax
ja 0xd159
movl %eax, %eax
btq %rax, %rbp
jb 0xd131
cmpq %r12, %rbx
ja 0xd185
movq (%rsp), %r15
movq %r15, %rdi
movq %r14, %rsi
movq %rbx, %rdx
movq %r13, %rcx
callq 0x916e
movq %r15, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
leaq 0xfa47(%rip), %rdi      # 0x1cbd3
leaq 0xf3f8(%rip), %rsi      # 0x1c58b
leaq 0xfa47(%rip), %rcx      # 0x1cbe1
movl $0x13c, %edx            # imm = 0x13C
callq 0x7150
// File: /workspace/github_cpp_makefile_star2_O2/ridiculousfish[P]docopt_fish/./docopt_fish_types.h
// Function: unsigned long docopt_fish::rstring_t::find_internal<true>(char const*) const
inline size_t find_internal(const char *needle) const {
        // Empty string always found first
        if (needle[0] == '\0') {
            return 0;
        }
        
        auto does_match = [](char_t a, char b){
            if (static_cast<long>(a) >= CHAR_MAX) {
                // Outside of ASCII, no match possible
                return false;
            }
            return a == b || (case_insensitive && tolower(a) == tolower(b));
        };
        
        const char_t *result = std::search(this->begin(), this->end(),
                                           needle, needle + strlen(needle),
                                           does_match);
        return result == this->end() ? npos : result - this->begin();
    }

// Assembly:
cmpb $0x0, (%rsi)
je 0xd366
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rsi, %r14
movq %rdi, %rbx
movq (%rdi), %r15
movq 0x8(%rdi), %rax
shlq $0x2, %r15
addq 0x10(%rdi), %r15
leaq (%r15,%rax,4), %r12
movq %rsi, %rdi
callq 0x70c0
leaq (%rax,%r14), %rcx
movq %r15, %rdi
movq %r12, %rsi
movq %r14, %rdx
callq 0xd36d
movq (%rbx), %rcx
movq 0x8(%rbx), %rdx
shlq $0x2, %rcx
addq 0x10(%rbx), %rcx
leaq (%rcx,%rdx,4), %rdx
cmpq %rdx, %rax
leaq 0x8(%rsp), %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
je 0xd369
subq %rcx, %rax
sarq $0x2, %rax
retq
xorl %eax, %eax
retq
pushq $-0x1
popq %rax
retq
// File: /workspace/github_cpp_makefile_star2_O2/ridiculousfish[P]docopt_fish/./docopt_fish_types.h
// Function: docopt_fish::option_t::merge_from(docopt_fish::option_t const&)
void merge_from(const option_t &rhs) {
        for (size_t i = 0; i < NAME_TYPE_COUNT; i++) {
            this->names[i].replace_if_empty(rhs.names[i]);
        }
        this->flags |= rhs.flags;
        this->value.replace_if_empty(rhs.value);
        this->default_value.replace_if_empty(rhs.default_value);
    }

// Assembly:
leaq 0x8(%rdi), %rax
xorl %ecx, %ecx
cmpq $0x48, %rcx
je 0xd765
cmpq $0x0, (%rax,%rcx)
jne 0xd75f
leaq (%rax,%rcx), %rdx
addq $-0x8, %rdx
movq 0x10(%rsi,%rcx), %r8
movq %r8, 0x10(%rdx)
movups (%rsi,%rcx), %xmm0
movups %xmm0, (%rdx)
addq $0x18, %rcx
jmp 0xd73a
movl 0x78(%rsi), %eax
orl %eax, 0x78(%rdi)
cmpq $0x0, 0x50(%rdi)
jne 0xd782
movq 0x58(%rsi), %rax
movq %rax, 0x58(%rdi)
movups 0x48(%rsi), %xmm0
movups %xmm0, 0x48(%rdi)
cmpq $0x0, 0x68(%rdi)
je 0xd78a
retq
movq 0x70(%rsi), %rax
movq %rax, 0x70(%rdi)
movups 0x60(%rsi), %xmm0
movups %xmm0, 0x60(%rdi)
retq
nop
// File: /workspace/github_cpp_makefile_star2_O2/ridiculousfish[P]docopt_fish/./docopt_fish_types.h
// Function: docopt_fish::option_t::has_same_name(docopt_fish::option_t const&) const
bool has_same_name(const option_t &opt2) const {
        bool result = false;
        for (size_t i = 0; i < NAME_TYPE_COUNT; i++) {
            const rstring_t &s1 = this->names[i], &s2 = opt2.names[i];
            if (s1.length() > 0 && s1 == s2) {
                result = true;
                break;
            }
        }
        return result;
    }

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rsi, %rbx
movq %rdi, %r14
xorl %r15d, %r15d
cmpq $0x3, %r15
je 0xdff1
cmpq $0x0, 0x8(%r14)
je 0xdfe4
movq %r14, %rdi
movq %rbx, %rsi
callq 0xb81e
testb %al, %al
jne 0xdff1
incq %r15
addq $0x18, %rbx
addq $0x18, %r14
jmp 0xdfc8
cmpq $0x3, %r15
setb %al
popq %rbx
popq %r14
popq %r15
retq