LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: 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:
subq $0x38, %rsp
movq %rdi, 0x30(%rsp)
movsd %xmm0, 0x28(%rsp)
movq 0x30(%rsp), %rax
movq %rax, 0x8(%rsp)
movsd 0x509f(%rip), %xmm0     # 0x9110
mulsd 0x28(%rsp), %xmm0
movl 0x50(%rax), %ecx
subl $0x1, %ecx
cvtsi2sd %ecx, %xmm1
mulsd %xmm1, %xmm0
movsd %xmm0, 0x18(%rsp)
movsd 0x18(%rsp), %xmm0
divsd 0x78(%rax), %xmm0
callq 0x20f0
movq 0x8(%rsp), %rax
movsd %xmm0, 0x10(%rsp)
xorps %xmm0, %xmm0
movsd %xmm0, 0x78(%rax)
movl $0x0, 0x24(%rsp)
movq 0x8(%rsp), %rcx
movl 0x24(%rsp), %eax
cmpl 0x50(%rcx), %eax
jge 0x4168
movl $0x0, 0x20(%rsp)
cmpl $0x3, 0x20(%rsp)
jge 0x4156
movq 0x8(%rsp), %rax
movsd 0x10(%rsp), %xmm0
movq 0x10(%rax), %rcx
movslq 0x24(%rsp), %rdx
movq (%rcx,%rdx,8), %rcx
movslq 0x20(%rsp), %rdx
mulsd (%rcx,%rdx,8), %xmm0
movsd %xmm0, (%rcx,%rdx,8)
movq 0x10(%rax), %rcx
movslq 0x24(%rsp), %rdx
movq (%rcx,%rdx,8), %rcx
movslq 0x20(%rsp), %rdx
movsd (%rcx,%rdx,8), %xmm0
movq 0x10(%rax), %rcx
movslq 0x24(%rsp), %rdx
movq (%rcx,%rdx,8), %rcx
movslq 0x20(%rsp), %rdx
mulsd (%rcx,%rdx,8), %xmm0
movsd 0x78(%rax), %xmm1
movsd 0x4fc7(%rip), %xmm2     # 0x9100
mulsd %xmm2, %xmm0
addsd %xmm1, %xmm0
movsd %xmm0, 0x78(%rax)
movl 0x20(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x20(%rsp)
jmp 0x40d0
jmp 0x4158
movl 0x24(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x24(%rsp)
jmp 0x40b6
addq $0x38, %rsp
retq
nopl (%rax)
// File: 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:
movq %rdi, -0x8(%rsp)
movq -0x8(%rsp), %rax
movq %rax, -0x18(%rsp)
movl $0x0, -0xc(%rsp)
movq -0x18(%rsp), %rcx
movl -0xc(%rsp), %eax
cmpl 0x50(%rcx), %eax
jge 0x41df
movl $0x0, -0x10(%rsp)
cmpl $0x3, -0x10(%rsp)
jge 0x41d0
movq -0x18(%rsp), %rax
movq 0x18(%rax), %rax
movslq -0xc(%rsp), %rcx
movq (%rax,%rcx,8), %rax
movslq -0x10(%rsp), %rcx
xorps %xmm0, %xmm0
movsd %xmm0, (%rax,%rcx,8)
movl -0x10(%rsp), %eax
addl $0x1, %eax
movl %eax, -0x10(%rsp)
jmp 0x419d
jmp 0x41d2
movl -0xc(%rsp), %eax
addl $0x1, %eax
movl %eax, -0xc(%rsp)
jmp 0x4187
movq -0x18(%rsp), %rax
xorps %xmm0, %xmm0
movsd %xmm0, 0x80(%rax)
retq
// File: 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:
subq $0x28, %rsp
movq %rdi, 0x20(%rsp)
movq 0x20(%rsp), %rax
movq %rax, (%rsp)
movsd 0x18(%rax), %xmm0
mulsd 0x18(%rax), %xmm0
movsd %xmm0, 0x10(%rsp)
movq 0x8(%rax), %rdi
callq 0x5da0
cvttsd2si %xmm0, %eax
movl %eax, 0xc(%rsp)
movl $0x0, 0x1c(%rsp)
movl 0x1c(%rsp), %eax
cmpl 0xc(%rsp), %eax
jge 0x5653
movl $0x0, 0x18(%rsp)
cmpl $0x3, 0x18(%rsp)
jge 0x5641
movq (%rsp), %rax
movq 0x8(%rax), %rcx
movq 0x10(%rcx), %rcx
movslq 0x1c(%rsp), %rdx
movq (%rcx,%rdx,8), %rcx
movslq 0x18(%rsp), %rdx
movsd (%rcx,%rdx,8), %xmm0
movsd 0x18(%rax), %xmm2
movq 0x8(%rax), %rcx
movq 0x18(%rcx), %rcx
movslq 0x1c(%rsp), %rdx
movq (%rcx,%rdx,8), %rcx
movslq 0x18(%rsp), %rdx
movsd 0x3b5a(%rip), %xmm1     # 0x9108
mulsd (%rcx,%rdx,8), %xmm1
mulsd 0x10(%rsp), %xmm1
mulsd %xmm2, %xmm0
addsd %xmm1, %xmm0
movq 0x8(%rax), %rcx
movq 0x8(%rcx), %rcx
movslq 0x1c(%rsp), %rdx
movq (%rcx,%rdx,8), %rcx
movslq 0x18(%rsp), %rdx
addsd (%rcx,%rdx,8), %xmm0
movsd %xmm0, (%rcx,%rdx,8)
movq 0x8(%rax), %rcx
movq 0x18(%rcx), %rcx
movslq 0x1c(%rsp), %rdx
movq (%rcx,%rdx,8), %rcx
movslq 0x18(%rsp), %rdx
movsd 0x3b09(%rip), %xmm0     # 0x9108
mulsd (%rcx,%rdx,8), %xmm0
movsd 0x18(%rax), %xmm2
movq 0x8(%rax), %rax
movq 0x10(%rax), %rax
movslq 0x1c(%rsp), %rcx
movq (%rax,%rcx,8), %rax
movslq 0x18(%rsp), %rcx
movsd (%rax,%rcx,8), %xmm1
mulsd %xmm2, %xmm0
addsd %xmm1, %xmm0
movsd %xmm0, (%rax,%rcx,8)
movl 0x18(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x18(%rsp)
jmp 0x5561
jmp 0x5643
movl 0x1c(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x1c(%rsp)
jmp 0x554b
movq (%rsp), %rax
movq 0x8(%rax), %rdi
movq (%rdi), %rax
callq *(%rax)
movl $0x0, 0x1c(%rsp)
movl 0x1c(%rsp), %eax
cmpl 0xc(%rsp), %eax
jge 0x56f8
movl $0x0, 0x18(%rsp)
cmpl $0x3, 0x18(%rsp)
jge 0x56e6
movq (%rsp), %rax
movsd 0x3a77(%rip), %xmm0     # 0x9108
mulsd 0x18(%rax), %xmm0
movq 0x8(%rax), %rcx
movq 0x18(%rcx), %rcx
movslq 0x1c(%rsp), %rdx
movq (%rcx,%rdx,8), %rcx
movslq 0x18(%rsp), %rdx
movsd (%rcx,%rdx,8), %xmm2
movq 0x8(%rax), %rax
movq 0x10(%rax), %rax
movslq 0x1c(%rsp), %rcx
movq (%rax,%rcx,8), %rax
movslq 0x18(%rsp), %rcx
movsd (%rax,%rcx,8), %xmm1
mulsd %xmm2, %xmm0
addsd %xmm1, %xmm0
movsd %xmm0, (%rax,%rcx,8)
movl 0x18(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x18(%rsp)
jmp 0x567e
jmp 0x56e8
movl 0x1c(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x1c(%rsp)
jmp 0x5668
movq (%rsp), %rax
movq 0x8(%rax), %rdi
callq 0x3fa0
movq (%rsp), %rax
movsd 0x18(%rax), %xmm0
addsd 0x20(%rax), %xmm0
movsd %xmm0, 0x20(%rax)
addq $0x28, %rsp
retq
nopl (%rax)
// File: 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:
subq $0x98, %rsp
movq %rdi, 0x90(%rsp)
movq 0x90(%rsp), %rax
movq %rax, 0x18(%rsp)
movsd 0x10(%rax), %xmm1
movsd 0x18(%rax), %xmm0
addsd %xmm0, %xmm0
mulsd %xmm1, %xmm0
callq 0x20f0
movq 0x18(%rsp), %rax
movsd %xmm0, 0x60(%rax)
movq 0x8(%rax), %rdi
callq 0x5da0
cvttsd2si %xmm0, %eax
movl %eax, 0x84(%rsp)
movl $0x3, 0x6c(%rsp)
leaq 0x70(%rsp), %rdi
movq %rdi, 0x20(%rsp)
leaq 0x84(%rsp), %rsi
leaq 0x6c(%rsp), %rdx
callq 0x3250
movq 0x18(%rsp), %rdi
movq 0x20(%rsp), %rsi
addq $0x68, %rdi
callq 0x3350
jmp 0x57aa
leaq 0x70(%rsp), %rdi
callq 0x36a0
movl $0x3, 0x44(%rsp)
leaq 0x48(%rsp), %rdi
movq %rdi, 0x10(%rsp)
leaq 0x84(%rsp), %rsi
leaq 0x44(%rsp), %rdx
callq 0x3250
movq 0x18(%rsp), %rdi
movq 0x10(%rsp), %rsi
addq $0x78, %rdi
callq 0x3350
jmp 0x57ed
leaq 0x48(%rsp), %rdi
callq 0x36a0
movl $0x3, 0x2c(%rsp)
leaq 0x30(%rsp), %rdi
movq %rdi, 0x8(%rsp)
leaq 0x84(%rsp), %rsi
leaq 0x2c(%rsp), %rdx
callq 0x3250
movq 0x18(%rsp), %rdi
movq 0x8(%rsp), %rsi
addq $0x88, %rdi
callq 0x3350
jmp 0x5833
leaq 0x30(%rsp), %rdi
callq 0x36a0
movq 0x18(%rsp), %rdi
addq $0x68, %rdi
callq 0x4f00
movq 0x18(%rsp), %rdi
movq %rax, 0x98(%rdi)
addq $0x78, %rdi
callq 0x4f00
movq 0x18(%rsp), %rdi
movq %rax, 0xa0(%rdi)
addq $0x88, %rdi
callq 0x4f00
movq %rax, %rcx
movq 0x18(%rsp), %rax
movq %rcx, 0xa8(%rax)
movl $0x0, 0x8c(%rsp)
movl 0x8c(%rsp), %eax
cmpl 0x84(%rsp), %eax
jge 0x59a9
movl $0x0, 0x88(%rsp)
cmpl $0x3, 0x88(%rsp)
jge 0x5991
movq 0x18(%rsp), %rax
movq 0x98(%rax), %rcx
movslq 0x8c(%rsp), %rdx
movq (%rcx,%rdx,8), %rcx
movslq 0x88(%rsp), %rdx
xorps %xmm0, %xmm0
movsd %xmm0, (%rcx,%rdx,8)
movq 0xa0(%rax), %rcx
movslq 0x8c(%rsp), %rdx
movq (%rcx,%rdx,8), %rcx
movslq 0x88(%rsp), %rdx
xorps %xmm0, %xmm0
movsd %xmm0, (%rcx,%rdx,8)
movq 0xa8(%rax), %rax
movslq 0x8c(%rsp), %rcx
movq (%rax,%rcx,8), %rax
movslq 0x88(%rsp), %rcx
xorps %xmm0, %xmm0
movsd %xmm0, (%rax,%rcx,8)
movl 0x88(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x88(%rsp)
jmp 0x58b1
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x60(%rsp)
movl %eax, 0x5c(%rsp)
leaq 0x70(%rsp), %rdi
callq 0x36a0
jmp 0x59b1
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x60(%rsp)
movl %eax, 0x5c(%rsp)
leaq 0x48(%rsp), %rdi
callq 0x36a0
jmp 0x59b1
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x60(%rsp)
movl %eax, 0x5c(%rsp)
leaq 0x30(%rsp), %rdi
callq 0x36a0
jmp 0x59b1
jmp 0x5993
movl 0x8c(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x8c(%rsp)
jmp 0x5892
addq $0x98, %rsp
retq
movq 0x60(%rsp), %rdi
callq 0x2210
nopl (%rax,%rax)
// File: 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 %rbp
movq %rsp, %rbp
subq $0x150, %rsp            # imm = 0x150
movq %rdi, -0x140(%rbp)
movq %rdi, %rax
movq %rax, -0x138(%rbp)
movq 0x10(%rbp), %rax
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq %rcx, -0x20(%rbp)
movl %r8d, -0x24(%rbp)
movq %r9, -0x30(%rbp)
movq -0x10(%rbp), %rsi
movq -0x18(%rbp), %rdx
movq -0x20(%rbp), %rcx
movl -0x24(%rbp), %r8d
leaq -0x120(%rbp), %rdi
callq 0xcce0
movq -0x100(%rbp), %rax
movq %rax, -0x148(%rbp)
movq -0x10(%rbp), %rdi
callq 0xc910
movq %rax, %rcx
movq -0x148(%rbp), %rax
cmpq %rcx, %rax
jae 0xa3fe
movq -0x30(%rbp), %rsi
leaq -0x120(%rbp), %rdi
callq 0x9fe0
jmp 0xa3dc
jmp 0xa3a4
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x128(%rbp)
movl %eax, -0x12c(%rbp)
leaq -0x120(%rbp), %rdi
callq 0xce20
jmp 0xa44c
cmpq $0x0, 0x10(%rbp)
je 0xa419
leaq -0x120(%rbp), %rsi
addq $0x60, %rsi
movq 0x10(%rbp), %rdi
callq 0xcd70
movq -0x140(%rbp), %rdi
leaq -0x120(%rbp), %rsi
addq $0x28, %rsi
callq 0xcdd0
leaq -0x120(%rbp), %rdi
callq 0xce20
movq -0x138(%rbp), %rax
addq $0x150, %rsp            # imm = 0x150
popq %rbp
retq
movq -0x128(%rbp), %rdi
callq 0x85d0
nopl (%rax,%rax)
// File: 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
movq %rsp, %rbp
subq $0xc0, %rsp
movq %rdi, -0x98(%rbp)
movq %rdi, %rax
movq %rax, -0xa8(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movl %ecx, -0x1c(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0xa0(%rbp)
movq -0x18(%rbp), %rdi
callq 0xc910
movq %rax, -0x28(%rbp)
movb $0x0, -0x29(%rbp)
movq -0x28(%rbp), %rax
movq %rax, -0x90(%rbp)
movl $0x1, -0x30(%rbp)
leaq -0x31(%rbp), %rdi
movq %rdi, -0x88(%rbp)
callq 0xce50
movq -0x98(%rbp), %rdi
movq -0x90(%rbp), %rsi
movq -0x88(%rbp), %rcx
leaq -0x30(%rbp), %rdx
callq 0xce70
jmp 0xa4e9
leaq -0x31(%rbp), %rdi
callq 0xcef0
leaq -0x60(%rbp), %rdi
movq %rdi, -0xb0(%rbp)
callq 0xcf10
movq -0xa0(%rbp), %rax
movq -0xb0(%rbp), %r8
movq (%rax), %rdi
movq -0x18(%rbp), %rsi
movl -0x1c(%rbp), %edx
xorl %eax, %eax
movl %eax, %r9d
movq %r9, %rcx
callq 0xcf30
jmp 0xa529
leaq -0x60(%rbp), %rax
movq %rax, -0x68(%rbp)
movq -0x68(%rbp), %rdi
callq 0xd040
movq %rax, -0x70(%rbp)
movq -0x68(%rbp), %rdi
callq 0xd070
movq %rax, -0x78(%rbp)
leaq -0x70(%rbp), %rdi
leaq -0x78(%rbp), %rsi
callq 0xd0a0
testb $0x1, %al
jne 0xa55e
jmp 0xa5d9
leaq -0x70(%rbp), %rdi
callq 0xd0e0
movq -0x98(%rbp), %rdi
movq (%rax), %rax
movq %rax, -0x80(%rbp)
movq -0x80(%rbp), %rsi
callq 0xd100
movq %rax, -0xb8(%rbp)
jmp 0xa587
movq -0xb8(%rbp), %rax
movl $0x0, (%rax)
leaq -0x70(%rbp), %rdi
callq 0xd140
jmp 0xa54b
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x40(%rbp)
movl %eax, -0x44(%rbp)
leaq -0x31(%rbp), %rdi
callq 0xcef0
jmp 0xa608
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x40(%rbp)
movl %eax, -0x44(%rbp)
leaq -0x60(%rbp), %rdi
callq 0xd160
movq -0x98(%rbp), %rdi
callq 0xd1c0
jmp 0xa608
movb $0x1, -0x29(%rbp)
leaq -0x60(%rbp), %rdi
callq 0xd160
testb $0x1, -0x29(%rbp)
jne 0xa5f8
movq -0x98(%rbp), %rdi
callq 0xd1c0
movq -0xa8(%rbp), %rax
addq $0xc0, %rsp
popq %rbp
retq
movq -0x40(%rbp), %rdi
callq 0x85d0
nopw %cs:(%rax,%rax)
// File: 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 %rbp
movq %rsp, %rbp
subq $0xb0, %rsp
movq %rdi, -0x98(%rbp)
movq %rdi, %rax
movq %rax, -0x90(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movb $0x0, -0x11(%rbp)
callq 0x111f0
movq -0x10(%rbp), %rsi
leaq -0x38(%rbp), %rdi
callq 0x11390
jmp 0xa72c
movq -0x98(%rbp), %rdi
leaq -0x38(%rbp), %rsi
movq %rsi, -0xa0(%rbp)
callq 0x8690
movq -0xa0(%rbp), %rdi
callq 0x8590
movq -0x10(%rbp), %rsi
addq $0x18, %rsi
leaq -0x68(%rbp), %rdi
callq 0x11390
jmp 0xa762
movq -0x98(%rbp), %rdi
addq $0x20, %rdi
leaq -0x68(%rbp), %rsi
movq %rsi, -0xa8(%rbp)
callq 0x8690
movq -0xa8(%rbp), %rdi
callq 0x8590
movq -0x10(%rbp), %rsi
addq $0x30, %rsi
leaq -0x88(%rbp), %rdi
callq 0x11390
jmp 0xa79f
movq -0x98(%rbp), %rdi
addq $0x40, %rdi
leaq -0x88(%rbp), %rsi
callq 0x8690
leaq -0x88(%rbp), %rdi
callq 0x8590
movq -0x98(%rbp), %rax
movq -0x10(%rbp), %rcx
movl 0x48(%rcx), %ecx
movl %ecx, 0x60(%rax)
movb $0x1, -0x11(%rbp)
testb $0x1, -0x11(%rbp)
jne 0xa805
jmp 0xa7f9
movq -0x98(%rbp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x40(%rbp)
movl %eax, -0x44(%rbp)
callq 0x11350
jmp 0xa815
movq -0x98(%rbp), %rdi
callq 0x11350
movq -0x90(%rbp), %rax
addq $0xb0, %rsp
popq %rbp
retq
movq -0x40(%rbp), %rdi
callq 0x85d0
nop
// File: 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
movq %rsp, %rbp
subq $0x80, %rsp
movq %rsi, -0x70(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x78(%rbp)
movl $0xb0, %edi
callq 0x8310
movq -0x70(%rbp), %rsi
movq %rax, -0x60(%rbp)
movq %rax, -0x68(%rbp)
movb $0x1, -0x4d(%rbp)
leaq -0x40(%rbp), %rdi
movq %rdi, -0x58(%rbp)
callq 0x8440
movq -0x60(%rbp), %rdi
movq -0x58(%rbp), %rsi
callq 0xdcf0
jmp 0xa969
movb $0x0, -0x4d(%rbp)
leaq -0x40(%rbp), %rdi
callq 0x8590
movq -0x68(%rbp), %rax
movq %rax, -0x20(%rbp)
movq -0x20(%rbp), %rdi
movq -0x18(%rbp), %rsi
callq 0xdd60
movq -0x20(%rbp), %rdi
movq -0x18(%rbp), %rsi
callq 0xe410
andb $0x1, %al
movb %al, -0x4e(%rbp)
testb $0x1, -0x4e(%rbp)
je 0xa9df
movq -0x78(%rbp), %rdi
leaq -0x20(%rbp), %rsi
callq 0xe740
jmp 0xa9df
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x48(%rbp)
movl %eax, -0x4c(%rbp)
leaq -0x40(%rbp), %rdi
callq 0x8590
testb $0x1, -0x4d(%rbp)
jne 0xa9cf
jmp 0xa9dd
movq -0x68(%rbp), %rdi
movl $0xb0, %esi
callq 0x8330
jmp 0xaa12
movq -0x20(%rbp), %rax
movq %rax, -0x80(%rbp)
cmpq $0x0, %rax
je 0xaa04
movq -0x80(%rbp), %rdi
callq 0xe780
movq -0x80(%rbp), %rdi
movl $0xb0, %esi
callq 0x8330
movb -0x4e(%rbp), %al
andb $0x1, %al
addq $0x80, %rsp
popq %rbp
retq
movq -0x48(%rbp), %rdi
callq 0x85d0
nopl (%rax,%rax)
// File: 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 %rbp
movq %rsp, %rbp
subq $0x70, %rsp
movq %rsi, -0x60(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x68(%rbp)
movl $0xb0, %edi
callq 0x8310
movq -0x60(%rbp), %rsi
movq %rax, -0x50(%rbp)
movq %rax, -0x58(%rbp)
movb $0x1, -0x3d(%rbp)
leaq -0x30(%rbp), %rdi
movq %rdi, -0x48(%rbp)
callq 0xe7f0
movq -0x50(%rbp), %rdi
movq -0x48(%rbp), %rsi
callq 0xe820
jmp 0xaa72
movb $0x0, -0x3d(%rbp)
leaq -0x30(%rbp), %rdi
callq 0xe890
movq -0x58(%rbp), %rax
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rdi
callq 0xe8f0
movq -0x18(%rbp), %rdi
xorl %eax, %eax
movl %eax, %esi
callq 0xe410
andb $0x1, %al
movb %al, -0x3e(%rbp)
testb $0x1, -0x3e(%rbp)
je 0xaae4
movq -0x68(%rbp), %rdi
leaq -0x18(%rbp), %rsi
callq 0xe740
jmp 0xaae4
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x38(%rbp)
movl %eax, -0x3c(%rbp)
leaq -0x30(%rbp), %rdi
callq 0xe890
testb $0x1, -0x3d(%rbp)
jne 0xaad4
jmp 0xaae2
movq -0x58(%rbp), %rdi
movl $0xb0, %esi
callq 0x8330
jmp 0xab0f
movq -0x18(%rbp), %rax
movq %rax, -0x70(%rbp)
cmpq $0x0, %rax
je 0xab09
movq -0x70(%rbp), %rdi
callq 0xe780
movq -0x70(%rbp), %rdi
movl $0xb0, %esi
callq 0x8330
addq $0x70, %rsp
popq %rbp
retq
movq -0x38(%rbp), %rdi
callq 0x85d0
nopl (%rax,%rax)
// File: 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 %rbp
movq %rsp, %rbp
subq $0x1c0, %rsp            # imm = 0x1C0
movq %rdi, -0x1b0(%rbp)
movq %rdi, %rax
movq %rax, -0x1a8(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq %rcx, -0x20(%rbp)
leaq -0x88(%rbp), %rdi
callq 0x111f0
movq -0x18(%rbp), %rdi
movq -0x10(%rbp), %rsi
callq 0x11240
movq %rax, -0x1a0(%rbp)
jmp 0xaefe
movq -0x1a0(%rbp), %rax
movq %rax, -0x90(%rbp)
movq -0x18(%rbp), %rdi
callq 0x112a0
movq %rax, -0xa8(%rbp)
leaq -0x90(%rbp), %rdi
leaq -0xa8(%rbp), %rsi
callq 0x11270
testb $0x1, %al
jne 0xaf35
jmp 0xaf8e
leaq -0x90(%rbp), %rdi
callq 0x112d0
movq %rax, %rsi
addq $0x18, %rsi
leaq -0x110(%rbp), %rdi
callq 0xa6f0
jmp 0xaf56
leaq -0x88(%rbp), %rdi
leaq -0x110(%rbp), %rsi
callq 0x112f0
leaq -0x110(%rbp), %rdi
callq 0x11350
jmp 0xaf8e
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x98(%rbp)
movl %eax, -0x9c(%rbp)
jmp 0xb038
movq -0x10(%rbp), %rsi
leaq -0x130(%rbp), %rdi
callq 0x11390
jmp 0xafa0
leaq -0x198(%rbp), %rdi
movq %rdi, -0x1b8(%rbp)
leaq -0x88(%rbp), %rsi
callq 0x11410
movq -0x1b0(%rbp), %rdi
movq -0x1b8(%rbp), %rdx
movq -0x20(%rbp), %rcx
leaq -0x130(%rbp), %rsi
callq 0x11470
jmp 0xafda
leaq -0x198(%rbp), %rdi
callq 0x11350
leaq -0x130(%rbp), %rdi
callq 0x8590
leaq -0x88(%rbp), %rdi
callq 0x11350
movq -0x1a8(%rbp), %rax
addq $0x1c0, %rsp            # imm = 0x1C0
popq %rbp
retq
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x98(%rbp)
movl %eax, -0x9c(%rbp)
leaq -0x198(%rbp), %rdi
callq 0x11350
leaq -0x130(%rbp), %rdi
callq 0x8590
leaq -0x88(%rbp), %rdi
callq 0x11350
movq -0x98(%rbp), %rdi
callq 0x85d0
// File: 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 %rbp
movq %rsp, %rbp
subq $0x60, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
cmpq $0x0, -0x18(%rbp)
je 0xb069
jmp 0xb088
leaq 0x40ab4(%rip), %rdi     # 0x4bb24
leaq 0x40011(%rip), %rsi     # 0x4b088
movl $0xf0, %edx
leaq 0x40ab7(%rip), %rcx     # 0x4bb3a
callq 0x81e0
movq -0x18(%rbp), %rdi
callq 0x1c0d0
movq %rax, -0x20(%rbp)
movq -0x20(%rbp), %rax
movq %rax, -0x50(%rbp)
movq -0x10(%rbp), %rdi
callq 0x8230
movq %rax, %rcx
movq -0x50(%rbp), %rax
cmpq %rcx, %rax
ja 0xb0b4
jmp 0xb0d3
leaq 0x40abe(%rip), %rdi     # 0x4bb79
leaq 0x3ffc6(%rip), %rsi     # 0x4b088
movl $0xf3, %edx
leaq 0x40a6c(%rip), %rcx     # 0x4bb3a
callq 0x81e0
movq -0x20(%rbp), %rax
movq %rax, -0x58(%rbp)
movq -0x10(%rbp), %rdi
callq 0x8230
movq %rax, %rcx
movq -0x58(%rbp), %rax
cmpq %rcx, %rax
jne 0xb0f9
movb $0x0, -0x1(%rbp)
jmp 0xb1ce
movq -0x10(%rbp), %rdi
movq -0x20(%rbp), %rdx
movl $0xa, %esi
callq 0x82d0
movq %rax, -0x28(%rbp)
cmpq $-0x1, -0x28(%rbp)
jne 0xb125
movq -0x10(%rbp), %rdi
callq 0x8230
movq %rax, -0x60(%rbp)
jmp 0xb131
movq -0x28(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x60(%rbp)
movq -0x60(%rbp), %rax
movq %rax, -0x30(%rbp)
movq -0x30(%rbp), %rax
cmpq -0x20(%rbp), %rax
jbe 0xb145
jmp 0xb164
leaq 0x40a47(%rip), %rdi     # 0x4bb93
leaq 0x3ff35(%rip), %rsi     # 0x4b088
movl $0xfc, %edx
leaq 0x409db(%rip), %rcx     # 0x4bb3a
callq 0x81e0
movq -0x10(%rbp), %rsi
movq -0x20(%rbp), %rdx
movq -0x30(%rbp), %rcx
subq -0x20(%rbp), %rcx
leaq -0x48(%rbp), %rdi
callq 0xc430
movq -0x18(%rbp), %rax
movq -0x48(%rbp), %rcx
movq %rcx, (%rax)
movq -0x40(%rbp), %rcx
movq %rcx, 0x8(%rax)
movq -0x38(%rbp), %rcx
movq %rcx, 0x10(%rax)
movq -0x18(%rbp), %rdi
callq 0xbe30
xorb $-0x1, %al
testb $0x1, %al
jne 0xb1a9
jmp 0xb1ab
jmp 0xb1ca
leaq 0x409f7(%rip), %rdi     # 0x4bba9
leaq 0x3fecf(%rip), %rsi     # 0x4b088
movl $0xff, %edx
leaq 0x40975(%rip), %rcx     # 0x4bb3a
callq 0x81e0
movb $0x1, -0x1(%rbp)
movb -0x1(%rbp), %al
andb $0x1, %al
addq $0x60, %rsp
popq %rbp
retq
nopl (%rax)
// File: ridiculousfish[P]docopt_fish/docopt_fish.cpp
// Function: docopt_fish::find_header(docopt_fish::rstring_t const&)
static rstring_t find_header(const rstring_t &src) {
    rstring_t result;
    for (size_t i = 0; i < src.length(); i++) {
        rstring_t::char_t c = src[i];
        if (c == ':') {
            result = src.substr(0, i + 1);
            break;
        } else if (c != ' ' && !isalnum(c)) {
            // Not a header
            break;
        }
    }
    return result;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movq %rdi, -0x40(%rbp)
movq %rdi, %rax
movq %rax, -0x38(%rbp)
movq %rsi, -0x8(%rbp)
callq 0xbe70
movq $0x0, -0x10(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x48(%rbp)
movq -0x8(%rbp), %rdi
callq 0xbf20
movq %rax, %rcx
movq -0x48(%rbp), %rax
cmpq %rcx, %rax
jae 0xb297
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
callq 0x110a0
movl %eax, -0x14(%rbp)
cmpl $0x3a, -0x14(%rbp)
jne 0xb26d
movq -0x8(%rbp), %rsi
movq -0x10(%rbp), %rcx
addq $0x1, %rcx
leaq -0x30(%rbp), %rdi
xorl %eax, %eax
movl %eax, %edx
callq 0xc520
movq -0x40(%rbp), %rax
movq -0x30(%rbp), %rcx
movq %rcx, (%rax)
movq -0x28(%rbp), %rcx
movq %rcx, 0x8(%rax)
movq -0x20(%rbp), %rcx
movq %rcx, 0x10(%rax)
jmp 0xb297
cmpl $0x20, -0x14(%rbp)
je 0xb282
movl -0x14(%rbp), %edi
callq 0x8340
cmpl $0x0, %eax
jne 0xb282
jmp 0xb297
jmp 0xb284
jmp 0xb286
movq -0x10(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x10(%rbp)
jmp 0xb204
movq -0x38(%rbp), %rax
addq $0x50, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: 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 %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x10(%rbp), %rdi
callq 0xf010
movq %rax, -0x40(%rbp)
movq -0x8(%rbp), %rdi
callq 0xf010
movq -0x40(%rbp), %rcx
movq %rax, %rdx
xorl %eax, %eax
cmpq %rdx, %rcx
movb %al, -0x31(%rbp)
jb 0xb30d
movq -0x10(%rbp), %rdi
callq 0x1c0d0
movq %rax, -0x48(%rbp)
movq -0x8(%rbp), %rdi
callq 0x1c0d0
movq %rax, %rcx
movq -0x48(%rbp), %rax
cmpq %rcx, %rax
setbe %al
movb %al, -0x31(%rbp)
movb -0x31(%rbp), %al
testb $0x1, %al
jne 0xb316
jmp 0xb318
jmp 0xb337
leaq 0x40946(%rip), %rdi     # 0x4bc65
leaq 0x3fd62(%rip), %rsi     # 0x4b088
movl $0x162, %edx            # imm = 0x162
leaq 0x40988(%rip), %rcx     # 0x4bcba
callq 0x81e0
movq $0x4, -0x18(%rbp)
movq $0x0, -0x20(%rbp)
movq -0x10(%rbp), %rdi
callq 0xf010
movq %rax, -0x50(%rbp)
movq -0x8(%rbp), %rdi
callq 0xf010
movq %rax, %rcx
movq -0x50(%rbp), %rax
subq %rcx, %rax
movq %rax, -0x28(%rbp)
movq $0x0, -0x30(%rbp)
movq -0x30(%rbp), %rax
cmpq -0x28(%rbp), %rax
jae 0xb3c1
movq -0x8(%rbp), %rdi
movq -0x30(%rbp), %rsi
callq 0xfb70
cmpl $0x9, %eax
je 0xb39d
movq -0x20(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x20(%rbp)
jmp 0xb3b1
movq -0x20(%rbp), %rax
addq $0x4, %rax
shrq $0x2, %rax
shlq $0x2, %rax
movq %rax, -0x20(%rbp)
jmp 0xb3b3
movq -0x30(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x30(%rbp)
jmp 0xb373
movq -0x20(%rbp), %rax
addq $0x50, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: 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 %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x30(%rbp)
movq -0x18(%rbp), %rdi
callq 0x8110
movq -0x30(%rbp), %rdi
movq %rax, -0x20(%rbp)
movq -0x20(%rbp), %rax
movq %rax, -0x28(%rbp)
callq 0xbf20
movq %rax, %rcx
movq -0x28(%rbp), %rax
cmpq %rcx, %rax
jbe 0xbf88
movb $0x0, -0x1(%rbp)
jmp 0xbfba
movq -0x30(%rbp), %rdi
movq -0x18(%rbp), %rax
movq %rax, -0x40(%rbp)
movq -0x18(%rbp), %rax
addq -0x20(%rbp), %rax
movq %rax, -0x38(%rbp)
callq 0xf960
movq -0x40(%rbp), %rdi
movq -0x38(%rbp), %rsi
movq %rax, %rdx
callq 0xf930
andb $0x1, %al
movb %al, -0x1(%rbp)
movb -0x1(%rbp), %al
andb $0x1, %al
addq $0x40, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
nop
// File: ridiculousfish[P]docopt_fish/./docopt_fish_types.h
// Function: docopt_fish::rstring_t::merge(docopt_fish::rstring_t const&) const
rstring_t merge(const rstring_t &rhs) const {
        if (this->empty()) {
            return rhs;
        } else if (rhs.empty()) {
            return *this;
        } else {
            assert(this->base_ == rhs.base_);
            size_t start = std::min(this->start_, rhs.start_);
            size_t end = std::max(this->start_ + this->length_, rhs.start_ + rhs.length_);
            return rstring_t(this->base_, start, end - start);
        }
    }

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movq %rdi, -0x48(%rbp)
movq %rdi, -0x40(%rbp)
movq %rsi, -0x8(%rbp)
movq %rdx, -0x10(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x38(%rbp)
callq 0xbe30
testb $0x1, %al
jne 0xc03b
jmp 0xc05e
movq -0x48(%rbp), %rax
movq -0x10(%rbp), %rcx
movq (%rcx), %rdx
movq %rdx, (%rax)
movq 0x8(%rcx), %rdx
movq %rdx, 0x8(%rax)
movq 0x10(%rcx), %rcx
movq %rcx, 0x10(%rax)
jmp 0xc12d
movq -0x10(%rbp), %rdi
callq 0xbe30
testb $0x1, %al
jne 0xc06d
jmp 0xc090
movq -0x48(%rbp), %rax
movq -0x38(%rbp), %rcx
movq (%rcx), %rdx
movq %rdx, (%rax)
movq 0x8(%rcx), %rdx
movq %rdx, 0x8(%rax)
movq 0x10(%rcx), %rcx
movq %rcx, 0x10(%rax)
jmp 0xc12d
movq -0x38(%rbp), %rax
movq 0x10(%rax), %rax
movq -0x10(%rbp), %rcx
cmpq 0x10(%rcx), %rax
jne 0xc0a4
jmp 0xc0c3
leaq 0x3f63f(%rip), %rdi     # 0x4b6ea
leaq 0x3f54d(%rip), %rsi     # 0x4b5ff
movl $0xa4, %edx
leaq 0x3f645(%rip), %rcx     # 0x4b703
callq 0x81e0
movq -0x38(%rbp), %rdi
movq -0x10(%rbp), %rsi
callq 0xf630
movq -0x38(%rbp), %rcx
movq (%rax), %rax
movq %rax, -0x18(%rbp)
movq (%rcx), %rax
addq 0x8(%rcx), %rax
movq %rax, -0x28(%rbp)
movq -0x10(%rbp), %rax
movq (%rax), %rax
movq -0x10(%rbp), %rcx
addq 0x8(%rcx), %rax
movq %rax, -0x30(%rbp)
leaq -0x28(%rbp), %rdi
leaq -0x30(%rbp), %rsi
callq 0xf570
movq -0x48(%rbp), %rdi
movq %rax, %rcx
movq -0x38(%rbp), %rax
movq (%rcx), %rcx
movq %rcx, -0x20(%rbp)
movq 0x10(%rax), %rsi
movq -0x18(%rbp), %rdx
movq -0x20(%rbp), %rcx
subq -0x18(%rbp), %rcx
callq 0x11010
movq -0x40(%rbp), %rax
addq $0x50, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: 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 %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movq %rdx, -0x18(%rbp)
movq %rcx, -0x20(%rbp)
movl %r8d, -0x24(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x30(%rbp)
callq 0x11050
movq -0x30(%rbp), %rdi
movq -0x20(%rbp), %rax
movq (%rax), %rcx
movq %rcx, 0x48(%rdi)
movq 0x8(%rax), %rcx
movq %rcx, 0x50(%rdi)
movq 0x10(%rax), %rax
movq %rax, 0x58(%rdi)
addq $0x60, %rdi
callq 0xbe70
movq -0x30(%rbp), %rax
movl -0x24(%rbp), %ecx
movl %ecx, 0x78(%rax)
cmpl $0x3, -0xc(%rbp)
jge 0xc1a2
jmp 0xc1c1
leaq 0x3f59b(%rip), %rdi     # 0x4b744
leaq 0x3f44f(%rip), %rsi     # 0x4b5ff
movl $0x188, %edx            # imm = 0x188
leaq 0x3f59f(%rip), %rcx     # 0x4b75b
callq 0x81e0
movq -0x18(%rbp), %rdi
callq 0xbf20
cmpq $0x2, %rax
jb 0xc1d2
jmp 0xc1f1
leaq 0x3f5e5(%rip), %rdi     # 0x4b7be
leaq 0x3f41f(%rip), %rsi     # 0x4b5ff
movl $0x189, %edx            # imm = 0x189
leaq 0x3f56f(%rip), %rcx     # 0x4b75b
callq 0x81e0
movq -0x18(%rbp), %rdi
xorl %eax, %eax
movl %eax, %esi
callq 0x110a0
cmpl $0x2d, %eax
jne 0xc205
jmp 0xc224
leaq 0x3f5c5(%rip), %rdi     # 0x4b7d1
leaq 0x3f3ec(%rip), %rsi     # 0x4b5ff
movl $0x18a, %edx            # imm = 0x18A
leaq 0x3f53c(%rip), %rcx     # 0x4b75b
callq 0x81e0
cmpl $0x2, -0xc(%rbp)
jne 0xc290
movq -0x18(%rbp), %rdi
callq 0xbf20
cmpq $0x3, %rax
jb 0xc23b
jmp 0xc25a
leaq 0x3f59e(%rip), %rdi     # 0x4b7e0
leaq 0x3f3b6(%rip), %rsi     # 0x4b5ff
movl $0x18c, %edx            # imm = 0x18C
leaq 0x3f506(%rip), %rcx     # 0x4b75b
callq 0x81e0
movq -0x18(%rbp), %rdi
movl $0x1, %esi
callq 0x110a0
cmpl $0x2d, %eax
jne 0xc26f
jmp 0xc28e
leaq 0x3f57d(%rip), %rdi     # 0x4b7f3
leaq 0x3f382(%rip), %rsi     # 0x4b5ff
movl $0x18d, %edx            # imm = 0x18D
leaq 0x3f4d2(%rip), %rcx     # 0x4b75b
callq 0x81e0
jmp 0xc290
movq -0x30(%rbp), %rdi
movq -0x18(%rbp), %rax
movq %rax, -0x38(%rbp)
movl -0xc(%rbp), %eax
movl %eax, %esi
callq 0xc7b0
movq -0x38(%rbp), %rcx
movq (%rcx), %rdx
movq %rdx, (%rax)
movq 0x8(%rcx), %rdx
movq %rdx, 0x8(%rax)
movq 0x10(%rcx), %rcx
movq %rcx, 0x10(%rax)
addq $0x40, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: 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
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x40(%rbp)
movb %dl, %al
movq %rdi, %rcx
movq %rcx, -0x38(%rbp)
movq %rsi, -0x8(%rbp)
movb %al, -0x9(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x30(%rbp)
callq 0xbe70
movq -0x30(%rbp), %rdi
callq 0xbf20
cmpq $0x0, %rax
jbe 0xc6da
movq -0x30(%rbp), %rdi
xorl %eax, %eax
movl %eax, %esi
callq 0xfb70
movsbl -0x9(%rbp), %ecx
cmpl %ecx, %eax
jne 0xc6da
movq -0x30(%rbp), %rsi
leaq -0x28(%rbp), %rdi
movl $0x1, %edx
callq 0x10070
movq -0x40(%rbp), %rax
movq -0x28(%rbp), %rcx
movq %rcx, (%rax)
movq -0x20(%rbp), %rcx
movq %rcx, 0x8(%rax)
movq -0x18(%rbp), %rcx
movq %rcx, 0x10(%rax)
movq -0x38(%rbp), %rax
addq $0x40, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
nop
// File: 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
movq %rsp, %rbp
subq $0x110, %rsp            # imm = 0x110
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl %edx, -0x14(%rbp)
movq %rcx, -0x20(%rbp)
movq %r8, -0x28(%rbp)
movq %r9, -0x30(%rbp)
movq -0x8(%rbp), %rcx
movq %rcx, -0x100(%rbp)
movq -0x10(%rbp), %rsi
movq %rcx, %rdx
addq $0x68, %rdx
subq $-0x80, %rcx
movl -0x14(%rbp), %r8d
movq -0x20(%rbp), %r9
movq %rsp, %rax
movq $0x0, (%rax)
leaq -0x68(%rbp), %rdi
movq %rdi, -0xf8(%rbp)
callq 0xa350
movq -0x100(%rbp), %rsi
movq -0xf8(%rbp), %r8
movb -0x12(%rbp), %al
orb $0x2, %al
movb %al, -0x12(%rbp)
movl -0x14(%rbp), %edx
movq %rsi, %rcx
addq $0x50, %rcx
movq -0x10(%rbp), %r9
leaq -0xe0(%rbp), %rdi
callq 0x2fb00
jmp 0xcfc0
cmpq $0x0, -0x28(%rbp)
je 0xcff6
leaq -0xe0(%rbp), %rsi
movq -0x28(%rbp), %rdi
callq 0x12830
jmp 0xcff6
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0xe8(%rbp)
movl %eax, -0xec(%rbp)
leaq -0x68(%rbp), %rdi
callq 0x11f30
jmp 0xd02f
cmpq $0x0, -0x30(%rbp)
je 0xd011
leaq -0xe0(%rbp), %rsi
addq $0x18, %rsi
movq -0x30(%rbp), %rdi
callq 0x12860
leaq -0xe0(%rbp), %rdi
callq 0x12890
leaq -0x68(%rbp), %rdi
callq 0x11f30
addq $0x110, %rsp            # imm = 0x110
popq %rbp
retq
movq -0xe8(%rbp), %rdi
callq 0x85d0
nopl (%rax,%rax)
// File: 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 %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x38(%rbp)
movq %rdi, %rax
movq %rax, -0x30(%rbp)
movq %rsi, -0x8(%rbp)
movq %rdx, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x28(%rbp)
callq 0x18a80
movq -0x28(%rbp), %rdi
addq $0x80, %rdi
movq -0x10(%rbp), %rsi
callq 0x11240
movq -0x28(%rbp), %rdi
movq %rax, -0x18(%rbp)
addq $0x80, %rdi
callq 0x112a0
movq %rax, -0x20(%rbp)
leaq -0x18(%rbp), %rdi
leaq -0x20(%rbp), %rsi
callq 0x11270
testb $0x1, %al
jne 0xd777
jmp 0xd795
leaq -0x18(%rbp), %rdi
callq 0x112d0
movq -0x38(%rbp), %rdi
movq %rax, %rsi
addq $0x18, %rsi
movl $0x4c, %edx
callq 0x8270
movq -0x30(%rbp), %rax
addq $0x40, %rsp
popq %rbp
retq
nop
// File: 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
movq %rsp, %rbp
subq $0xf0, %rsp
movq %rdi, -0xd8(%rbp)
movq %rdi, %rax
movq %rax, -0xd0(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0xc8(%rbp)
movb $0x0, -0x11(%rbp)
callq 0x18ad0
leaq -0x48(%rbp), %rdi
callq 0x18af0
movq -0xc8(%rbp), %rax
movq %rax, -0x50(%rbp)
movq -0x50(%rbp), %rdi
callq 0x18b10
movq %rax, -0x58(%rbp)
movq -0x50(%rbp), %rdi
callq 0x18b40
movq %rax, -0x60(%rbp)
leaq -0x58(%rbp), %rdi
leaq -0x60(%rbp), %rsi
callq 0x18b70
testb $0x1, %al
jne 0xd81c
jmp 0xd921
leaq -0x58(%rbp), %rdi
callq 0x18bb0
movq %rax, -0x68(%rbp)
movq -0x68(%rbp), %rax
movq %rax, -0x70(%rbp)
movq -0x70(%rbp), %rdi
callq 0xbe30
movb %al, %cl
xorl %eax, %eax
testb $0x1, %cl
movb %al, -0xd9(%rbp)
jne 0xd89c
movq -0x70(%rbp), %rsi
leaq -0x48(%rbp), %rdi
callq 0x18bd0
movb %dl, -0xe9(%rbp)
movq %rax, -0xe8(%rbp)
jmp 0xd865
movb -0xe9(%rbp), %al
movq -0xe8(%rbp), %rcx
movq %rcx, -0xa0(%rbp)
movb %al, -0x98(%rbp)
movq -0xa0(%rbp), %rax
movq %rax, -0x80(%rbp)
movb -0x98(%rbp), %al
movb %al, -0x78(%rbp)
movb -0x78(%rbp), %al
movb %al, -0xd9(%rbp)
movb -0xd9(%rbp), %al
testb $0x1, %al
jne 0xd8a8
jmp 0xd911
movq -0x70(%rbp), %rsi
leaq -0xc0(%rbp), %rdi
callq 0x11390
jmp 0xd8ba
movq -0xd8(%rbp), %rdi
leaq -0xc0(%rbp), %rsi
callq 0x18c20
jmp 0xd8cf
leaq -0xc0(%rbp), %rdi
callq 0x8590
jmp 0xd911
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x88(%rbp)
movl %eax, -0x8c(%rbp)
jmp 0xd936
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x88(%rbp)
movl %eax, -0x8c(%rbp)
leaq -0xc0(%rbp), %rdi
callq 0x8590
jmp 0xd936
jmp 0xd913
leaq -0x58(%rbp), %rdi
callq 0x18c50
jmp 0xd806
movb $0x1, -0x11(%rbp)
leaq -0x48(%rbp), %rdi
callq 0x132e0
testb $0x1, -0x11(%rbp)
jne 0xd959
jmp 0xd94d
leaq -0x48(%rbp), %rdi
callq 0x132e0
movq -0xd8(%rbp), %rdi
callq 0x12f80
jmp 0xd969
movq -0xd8(%rbp), %rdi
callq 0x12f80
movq -0xd0(%rbp), %rax
addq $0xf0, %rsp
popq %rbp
retq
movq -0x88(%rbp), %rdi
callq 0x85d0
nopw %cs:(%rax,%rax)
nop
// File: 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 %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x30(%rbp)
movq %rdi, -0x28(%rbp)
movq %rsi, -0x8(%rbp)
movq %rdx, -0x10(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x20(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x18(%rbp)
callq 0xbf20
movq %rax, %rcx
movq -0x18(%rbp), %rax
cmpq %rcx, %rax
ja 0x100ab
jmp 0x100ca
leaq 0x3b5de(%rip), %rdi     # 0x4b690
leaq 0x3b546(%rip), %rsi     # 0x4b5ff
movl $0x56, %edx
leaq 0x3b5e1(%rip), %rcx     # 0x4b6a6
callq 0x81e0
movq -0x20(%rbp), %rsi
movq -0x30(%rbp), %rdi
movq -0x10(%rbp), %rcx
xorl %eax, %eax
movl %eax, %edx
callq 0xc520
movq -0x20(%rbp), %rcx
movq -0x28(%rbp), %rax
movq -0x10(%rbp), %rdx
addq (%rcx), %rdx
movq %rdx, (%rcx)
movq -0x10(%rbp), %rsi
movq 0x8(%rcx), %rdx
subq %rsi, %rdx
movq %rdx, 0x8(%rcx)
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: 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:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x20(%rbp)
cmpq -0x18(%rbp), %rax
jne 0x11847
movl $0x0, -0x4(%rbp)
jmp 0x11894
movq -0x20(%rbp), %rax
movq 0x10(%rax), %rax
movq -0x18(%rbp), %rcx
cmpq 0x10(%rcx), %rax
jne 0x11884
movq -0x20(%rbp), %rax
movq (%rax), %rax
movq -0x18(%rbp), %rcx
cmpq (%rcx), %rax
jne 0x11884
movq -0x20(%rbp), %rax
movq 0x8(%rax), %rax
movq -0x18(%rbp), %rcx
cmpq 0x8(%rcx), %rax
jne 0x11884
movl $0x0, -0x4(%rbp)
jmp 0x11894
movq -0x20(%rbp), %rdi
movq -0x18(%rbp), %rsi
callq 0x118a0
movl %eax, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax)
// File: ridiculousfish[P]docopt_fish/./docopt_fish_types.h
// Function: docopt_fish::rstring_t::compare_internal(docopt_fish::rstring_t const&, docopt_fish::rstring_t const&)
static int compare_internal(const rstring_t &lhs, const rstring_t &rhs) {
        size_t len1 = lhs.length(), len2 = rhs.length();
        size_t amt = std::min(len1, len2);
        const char_t *lhs_end = lhs.begin() + amt;
        auto diffs = std::mismatch(lhs.begin(), lhs_end, rhs.begin());
        if (diffs.first != lhs_end) {
            // Some character differed
            return *diffs.first < *diffs.second ? -1 : 1;
        } else if (len1 != len2) {
            // No character differed, but lengths are different
            return len1 < len2 ? -1 : 1;
        } else {
            return 0;
        }
    }

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x60, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x10(%rbp), %rdi
callq 0xbf20
movq %rax, -0x20(%rbp)
movq -0x18(%rbp), %rdi
callq 0xbf20
movq %rax, -0x28(%rbp)
leaq -0x20(%rbp), %rdi
leaq -0x28(%rbp), %rsi
callq 0xf630
movq (%rax), %rax
movq %rax, -0x30(%rbp)
movq -0x10(%rbp), %rdi
callq 0xf960
movq -0x30(%rbp), %rcx
shlq $0x2, %rcx
addq %rcx, %rax
movq %rax, -0x38(%rbp)
movq -0x10(%rbp), %rdi
callq 0xf960
movq %rax, -0x58(%rbp)
movq -0x38(%rbp), %rax
movq %rax, -0x50(%rbp)
movq -0x18(%rbp), %rdi
callq 0xf960
movq -0x58(%rbp), %rdi
movq -0x50(%rbp), %rsi
movq %rax, %rdx
callq 0x11990
movq %rax, -0x48(%rbp)
movq %rdx, -0x40(%rbp)
movq -0x48(%rbp), %rax
cmpq -0x38(%rbp), %rax
je 0x11956
movq -0x48(%rbp), %rax
movl (%rax), %edx
movq -0x40(%rbp), %rax
movl (%rax), %esi
movl $0x1, %eax
movl $0xffffffff, %ecx       # imm = 0xFFFFFFFF
cmpl %esi, %edx
cmovll %ecx, %eax
movl %eax, -0x4(%rbp)
jmp 0x11984
movq -0x20(%rbp), %rax
cmpq -0x28(%rbp), %rax
je 0x1197d
movq -0x20(%rbp), %rdx
movq -0x28(%rbp), %rsi
movl $0x1, %eax
movl $0xffffffff, %ecx       # imm = 0xFFFFFFFF
cmpq %rsi, %rdx
cmovbl %ecx, %eax
movl %eax, -0x4(%rbp)
jmp 0x11984
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x60, %rsp
popq %rbp
retq
nopl (%rax)