LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_cpp_makefile_star2_O3/gtarcoder[P]libevent_utils/utils.cpp
// Function: SetKeepLive(int, int, int, int)
int SetKeepLive(int fd, int idle, int interval, int count){
  if ( setsockopt(fd, SOL_TCP, TCP_KEEPIDLE, (void *)&idle, sizeof(idle)) < 0 ){
    perror("setsocketopt tcp_keepidle error : ");
    return -1;
  }
  if ( setsockopt(fd, SOL_TCP,  TCP_KEEPINTVL, (void *)&interval, sizeof(idle)) < 0 ){
    perror("setsocketopt tcp_keepintvl error : ");
    return -1;
  }
  if ( setsockopt(fd, SOL_TCP,  TCP_KEEPCNT, (void *)&count, sizeof(count)) < 0 ){
    perror("setsocketopt tcp_keepcnt error : ");
    return -1;
  }
  return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %rbx
subq $0x18, %rsp
movl %edi, %ebx
leaq -0x14(%rbp), %rax
movl %esi, (%rax)
movl %edx, -0x10(%rbp)
movl %ecx, -0xc(%rbp)
movl $0x6, %esi
movl $0x4, %edx
movq %rax, %rcx
movl $0x4, %r8d
callq 0x23c0
testl %eax, %eax
js 0x3eac
leaq -0x10(%rbp), %rcx
movl %ebx, %edi
movl $0x6, %esi
movl $0x5, %edx
movl $0x4, %r8d
callq 0x23c0
testl %eax, %eax
js 0x3eb5
leaq -0xc(%rbp), %rcx
movl %ebx, %edi
movl $0x6, %esi
movl $0x6, %edx
movl $0x4, %r8d
callq 0x23c0
movl %eax, %ecx
xorl %eax, %eax
testl %ecx, %ecx
js 0x3ebe
addq $0x18, %rsp
popq %rbx
popq %rbp
retq
leaq 0x5cd(%rip), %rdi       # 0x4480
jmp 0x3ec5
leaq 0x5e7(%rip), %rdi       # 0x44a3
jmp 0x3ec5
leaq 0x602(%rip), %rdi       # 0x44c7
callq 0x2200
movl $0xffffffff, %eax       # imm = 0xFFFFFFFF
jmp 0x3ea5
// File: /workspace/github_cpp_makefile_star2_O3/alex-courtis[P]xlayoutdisplay/src/Edid.cpp
// Function: Edid::dpiForMode(std::shared_ptr<Mode const> const&) const
long Edid::dpiForMode(const std::shared_ptr<const Mode> &mode) const {
    if (maxCmVert() == 0 || maxCmHoriz() == 0) {
        return 0;
    }
    double dpiHoriz = mode->width * INCHES_PER_CM / maxCmHoriz();
    double dpiVert = mode->height * INCHES_PER_CM / maxCmVert();

    // nearest 12 dpi
    return lround((dpiHoriz + dpiVert) / 24) * 12;
}

// Assembly:
pushq %r14
pushq %rbx
subq $0x18, %rsp
movq %rsi, %r14
movq %rdi, %rbx
movq (%rdi), %rax
callq *0x18(%rax)
testl %eax, %eax
je 0x6e68
movq (%rbx), %rax
movq %rbx, %rdi
callq *0x10(%rax)
testl %eax, %eax
je 0x6e68
movq (%r14), %rax
movl 0x8(%rax), %eax
cvtsi2sd %rax, %xmm0
mulsd 0x13223(%rip), %xmm0    # 0x1a008
movsd %xmm0, 0x8(%rsp)
movq (%rbx), %rax
movq %rbx, %rdi
callq *0x10(%rax)
movl %eax, %eax
xorps %xmm0, %xmm0
cvtsi2sd %rax, %xmm0
movsd 0x8(%rsp), %xmm1
divsd %xmm0, %xmm1
movsd %xmm1, 0x8(%rsp)
movq (%r14), %rax
movl 0xc(%rax), %eax
xorps %xmm0, %xmm0
cvtsi2sd %rax, %xmm0
mulsd 0x131e4(%rip), %xmm0    # 0x1a008
movsd %xmm0, 0x10(%rsp)
movq (%rbx), %rax
movq %rbx, %rdi
callq *0x18(%rax)
movl %eax, %eax
xorps %xmm0, %xmm0
cvtsi2sd %rax, %xmm0
movsd 0x10(%rsp), %xmm1
divsd %xmm0, %xmm1
addsd 0x8(%rsp), %xmm1
divsd 0x131bb(%rip), %xmm1    # 0x1a010
movapd %xmm1, %xmm0
callq 0x6060
shlq $0x2, %rax
leaq (%rax,%rax,2), %rax
jmp 0x6e6a
xorl %eax, %eax
addq $0x18, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_cpp_makefile_star2_O3/alex-courtis[P]xlayoutdisplay/src/Monitors.cpp
// Function: calculateLaptopLidClosed(char const*)
bool calculateLaptopLidClosed(const char *laptopLidRootPath) {
    static char lidFileName[PATH_MAX];
    static char line[512];

    // find the lid state directory
    DIR *dir = opendir(laptopLidRootPath);
    if (dir) {
        struct dirent *dirent;
        while ((dirent = readdir(dir)) != nullptr) {
            if (dirent->d_type == DT_DIR && strcmp(dirent->d_name, ".") != 0 && strcmp(dirent->d_name, "..") != 0) {

                // read the lid state file
                snprintf(lidFileName, PATH_MAX, "%s/%s/%s", laptopLidRootPath, dirent->d_name, "state");
                FILE *lidFile = fopen(lidFileName, "r");
                if (lidFile != nullptr) {
                    if (fgets(line, 512, lidFile))
                        if (strcasestr(line, "closed"))
                            return true;
                    fclose(lidFile);
                }

                // drivers/acpi/button.c acpi_button_add_fs seems to indicate there will be only one file
                break;
            }
        }
        closedir(dir);
    }
    return false;
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rdi, %r14
callq 0x65c0
testq %rax, %rax
je 0x72f7
movq %rax, %rbx
movq %rbx, %rdi
callq 0x65d0
testq %rax, %rax
je 0x72ef
cmpb $0x4, 0x12(%rax)
jne 0x723d
cmpb $0x2e, 0x13(%rax)
jne 0x726c
cmpb $0x0, 0x14(%rax)
je 0x723d
cmpb $0x2e, 0x14(%rax)
jne 0x726c
cmpb $0x0, 0x15(%rax)
je 0x723d
addq $0x13, %rax
leaq 0x1e749(%rip), %r15     # 0x259c0
leaq 0x12f8b(%rip), %rdx     # 0x1a209
leaq 0x12f8d(%rip), %r9      # 0x1a212
movl $0x1000, %esi           # imm = 0x1000
movq %r15, %rdi
movq %r14, %rcx
movq %rax, %r8
xorl %eax, %eax
callq 0x6640
leaq 0x13abe(%rip), %rsi     # 0x1ad5f
movq %r15, %rdi
callq 0x6490
testq %rax, %rax
je 0x72ef
movq %rax, %r14
leaq 0x1f708(%rip), %rdi     # 0x269c0
movl $0x200, %esi            # imm = 0x200
movq %rax, %rdx
callq 0x6620
testq %rax, %rax
je 0x72e7
leaq 0x1f6ef(%rip), %rdi     # 0x269c0
leaq 0x12f40(%rip), %rsi     # 0x1a218
callq 0x67d0
movq %rax, %rcx
movb $0x1, %al
testq %rcx, %rcx
jne 0x72f9
movq %r14, %rdi
callq 0x6370
movq %rbx, %rdi
callq 0x6650
xorl %eax, %eax
popq %rbx
popq %r14
popq %r15
retq
nop
// File: /workspace/github_cpp_makefile_star2_O3/alex-courtis[P]xlayoutdisplay/src/calculations.cpp
// Function: orderOutputs(std::__cxx11::list<std::shared_ptr<Output>, std::allocator<std::shared_ptr<Output>>> const&, std::vector<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, std::allocator<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>> const&)
const std::list<std::shared_ptr<Output>> orderOutputs(const list<shared_ptr<Output>> &outputs, const vector<string> &order) {
    list<shared_ptr<Output>> orderedOutputs(outputs);

    // stack all the preferred, available outputs
    stack<shared_ptr<Output>> preferredOutputs;
    for (const auto &name : order) {
        for (const auto &output : outputs) {
            if (strcasecmp(name.c_str(), output->name.c_str()) == 0) {
                preferredOutputs.push(output);
            }
        }
    }

    // move preferred to the front
    while (!preferredOutputs.empty()) {
        orderedOutputs.remove(preferredOutputs.top());
        orderedOutputs.push_front(preferredOutputs.top());
        preferredOutputs.pop();
    }

    return orderedOutputs;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x58, %rsp
movq %rdx, %r15
movq %rsi, %r14
movq %rdi, %rbx
callq 0x88bc
xorps %xmm0, %xmm0
movq %rsp, %rdi
movaps %xmm0, 0x40(%rdi)
movaps %xmm0, 0x30(%rdi)
movaps %xmm0, 0x20(%rdi)
movaps %xmm0, 0x10(%rdi)
movaps %xmm0, (%rdi)
xorl %esi, %esi
callq 0x8bd8
movq (%r15), %r12
movq 0x8(%r15), %r13
cmpq %r13, %r12
je 0x7c3e
movq %rsp, %r15
movq (%r14), %rbp
cmpq %r14, %rbp
je 0x7c35
movq (%r12), %rdi
movq 0x10(%rbp), %rax
movq (%rax), %rsi
callq 0x6400
testl %eax, %eax
jne 0x7c2f
leaq 0x10(%rbp), %rsi
movq %r15, %rdi
callq 0x8d50
movq (%rbp), %rbp
jmp 0x7c0a
addq $0x20, %r12
cmpq %r13, %r12
jne 0x7c07
movq 0x30(%rsp), %rsi
cmpq 0x10(%rsp), %rsi
je 0x7cbc
movl $0x200, %r12d           # imm = 0x200
movq %rsp, %r14
cmpq 0x38(%rsp), %rsi
jne 0x7c66
movq 0x48(%rsp), %rax
movq -0x8(%rax), %rsi
addq %r12, %rsi
addq $-0x10, %rsi
movq %rbx, %rdi
callq 0x88f8
movq 0x30(%rsp), %rsi
cmpq 0x38(%rsp), %rsi
jne 0x7c8a
movq 0x48(%rsp), %rax
movq -0x8(%rax), %rsi
addq %r12, %rsi
addq $-0x10, %rsi
movq (%rbx), %r15
movq %rbx, %rdi
callq 0x8b9e
movq %rax, %rdi
movq %r15, %rsi
callq 0x6080
incq 0x10(%rbx)
movq %r14, %rdi
callq 0x8fd4
movq 0x30(%rsp), %rsi
cmpq 0x10(%rsp), %rsi
jne 0x7c53
movq %rsp, %rdi
callq 0x8972
movq %rbx, %rax
addq $0x58, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %r14
jmp 0x7ce8
jmp 0x7cdd
movq %rax, %r14
movq %rsp, %rdi
callq 0x8972
movq %rbx, %rdi
callq 0x8adc
movq %r14, %rdi
callq 0x6700
// File: /workspace/github_cpp_makefile_star2_O3/alex-courtis[P]xlayoutdisplay/src/calculations.cpp
// Function: ltrOutputs(std::__cxx11::list<std::shared_ptr<Output>, std::allocator<std::shared_ptr<Output>>> const&)
void ltrOutputs(const list<shared_ptr<Output>> &outputs) {
    int xpos = 0;
    int ypos = 0;
    for (const auto &output : outputs) {

        if (output->desiredActive) {

            // set the desired mode to optimal
            output->desiredMode = output->optimalMode;

            // position the screen
            output->desiredPos = make_shared<Pos>(xpos, ypos);

            // next position
            xpos += output->desiredMode->width;
        }
    }
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movq (%rdi), %r14
cmpq %rdi, %r14
je 0x7ef3
movq %rdi, %rbx
xorl %ebp, %ebp
movabsq $0x100000001, %r15      # imm = 0x100000001
leaq 0x1caed(%rip), %r12     # 0x24960
movq 0x10(%r14), %rsi
cmpb $0x1, 0x90(%rsi)
jne 0x7eeb
movq 0x60(%rsi), %rax
movq %rax, 0x98(%rsi)
leaq 0xa0(%rsi), %rdi
addq $0x68, %rsi
callq 0x8b18
movl $0x18, %edi
callq 0x6390
movq %r15, 0x8(%rax)
movq %r12, (%rax)
leaq 0x10(%rax), %rcx
movl %ebp, 0x10(%rax)
movl $0x0, 0x14(%rax)
movq 0x10(%r14), %rdx
movq %rcx, 0xa8(%rdx)
movq 0xb0(%rdx), %rdi
movq %rax, 0xb0(%rdx)
testq %rdi, %rdi
je 0x7edd
callq 0x7a04
movq 0x10(%r14), %rax
movq 0x98(%rax), %rax
addl 0x8(%rax), %ebp
movq (%r14), %r14
cmpq %rbx, %r14
jne 0x7e73
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O3/alex-courtis[P]xlayoutdisplay/src/calculations.cpp
// Function: calculateOptimalMode(std::__cxx11::list<std::shared_ptr<Mode const>, std::allocator<std::shared_ptr<Mode const>>> const&, std::shared_ptr<Mode const> const&)
const shared_ptr<const Mode> calculateOptimalMode(const list<shared_ptr<const Mode>> &modes, const shared_ptr<const Mode> &preferredMode) {
    shared_ptr<const Mode> optimalMode;

    // default optimal mode is empty
    if (!modes.empty()) {

        // use highest resolution/refresh for optimal
        const list<shared_ptr<const Mode>> reverseOrderedModes = reverseSort(modes);
        optimalMode = reverseOrderedModes.front();

        // override with highest refresh of preferred resolution, if available
        if (preferredMode)
            for (const auto &mode : reverseOrderedModes)
                if (mode->width == preferredMode->width && mode->height == preferredMode->height) {
                    optimalMode = mode;
                    break;
                }
    }

    return optimalMode;
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %rdi, %rbx
xorps %xmm0, %xmm0
movups %xmm0, (%rdi)
cmpq %rsi, (%rsi)
je 0x8899
movq %rdx, %r12
movq %rsp, %r14
movq %r14, %rdi
callq 0x7940
leaq 0xace(%rip), %rsi       # 0x92f3
movq %r14, %rdi
callq 0x90a0
movq %rsp, %r14
movq %r14, %rdi
callq 0x6430
movq (%r14), %rsi
movq 0x10(%rsi), %rax
movq %rax, (%rbx)
leaq 0x8(%rbx), %r15
addq $0x18, %rsi
movq %r15, %rdi
callq 0x8b18
movq (%r12), %rax
testq %rax, %rax
je 0x8891
movq (%rsp), %rsi
cmpq %r14, %rsi
je 0x8891
movl 0x8(%rax), %ecx
movq 0x10(%rsi), %rdx
cmpl %ecx, 0x8(%rdx)
jne 0x8878
movl 0xc(%rdx), %edi
cmpl 0xc(%rax), %edi
je 0x8882
movq (%rsi), %rsi
cmpq %r14, %rsi
jne 0x8867
jmp 0x8891
movq %rdx, (%rbx)
addq $0x18, %rsi
movq %r15, %rdi
callq 0x8b18
movq %rsp, %rdi
callq 0x7a74
movq %rbx, %rax
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
movq %rax, %rbx
movq %rsp, %rdi
callq 0x7a74
movq %rbx, %rdi
callq 0x6700
nop
// File: /workspace/github_cpp_makefile_star2_O3/alex-courtis[P]xlayoutdisplay/src/xrandrrutil.cpp
// Function: refreshFromModeInfo(_XRRModeInfo const&)
unsigned int refreshFromModeInfo(const XRRModeInfo &modeInfo) {
    double rate;
    double vTotal = modeInfo.vTotal;

    if (modeInfo.modeFlags & RR_DoubleScan)
        /* doublescan doubles the number of lines */
        vTotal *= 2;

    if (modeInfo.modeFlags & RR_Interlace)
        /* interlace splits the frame into two fields */
        /* the field rate is what is typically reported by monitors */
        vTotal /= 2;

    if (modeInfo.hTotal && vTotal)
        rate = ((double) modeInfo.dotClock / ((double) modeInfo.hTotal * vTotal));
    else
        rate = 0;

    // round up
    return static_cast<unsigned int>(round(rate));
}

// Assembly:
movl 0x30(%rdi), %eax
cvtsi2sd %rax, %xmm1
movq 0x48(%rdi), %rcx
testb $0x20, %cl
je 0x9b15
addsd %xmm1, %xmm1
movl 0x20(%rdi), %eax
testb $0x10, %cl
je 0x9b25
mulsd 0x10b23(%rip), %xmm1    # 0x1a648
xorpd %xmm0, %xmm0
testl %eax, %eax
je 0x9b6b
xorpd %xmm2, %xmm2
ucomisd %xmm2, %xmm1
jne 0x9b39
jnp 0x9b6b
movsd 0x10(%rdi), %xmm2
unpcklps 0x10b0b(%rip), %xmm2    # xmm2 = xmm2[0],mem[0],xmm2[1],mem[1]
subpd 0x10b13(%rip), %xmm2    # 0x1a660
movapd %xmm2, %xmm0
unpckhpd %xmm2, %xmm0            # xmm0 = xmm0[1],xmm2[1]
addsd %xmm2, %xmm0
movl %eax, %eax
xorps %xmm2, %xmm2
cvtsi2sd %rax, %xmm2
mulsd %xmm2, %xmm1
divsd %xmm1, %xmm0
pushq %rax
callq 0x6180
cvttsd2si %xmm0, %rax
popq %rcx
retq
// File: /workspace/github_cpp_makefile_star2_O3/alex-courtis[P]xlayoutdisplay/src/xrandrrutil.cpp
// Function: modeFromXRR(unsigned long, _XRRScreenResources const*)
Mode *modeFromXRR(RRMode id, const XRRScreenResources *resources) {
    if (resources == nullptr)
        throw invalid_argument("cannot construct Mode: NULL XRRScreenResources");

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

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

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

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
subq $0x68, %rsp
testq %rsi, %rsi
je 0x9f06
movq %rdi, %r14
movslq 0x30(%rsi), %rax
testq %rax, %rax
jle 0x9e26
movq 0x38(%rsi), %rbx
cmpq %r14, (%rbx)
je 0x9e88
addq $0x50, %rbx
decq %rax
jne 0x9e18
movl $0x10, %edi
callq 0x61c0
movq %rax, %rbx
leaq 0x8(%rsp), %rdi
movq %r14, %rsi
callq 0x6f57
leaq 0x108a3(%rip), %rsi     # 0x1a6ea
leaq 0x48(%rsp), %rdi
leaq 0x8(%rsp), %rdx
callq 0xa708
leaq 0x108bb(%rip), %rsi     # 0x1a718
leaq 0x48(%rsp), %rdi
callq 0x67c0
leaq 0x38(%rsp), %r15
movq %r15, -0x10(%r15)
movq (%rax), %rdx
movq %rax, %rcx
addq $0x10, %rcx
cmpq %rcx, %rdx
jne 0x9eba
movups (%rcx), %xmm0
movups %xmm0, (%r15)
jmp 0x9ec7
movl $0x18, %edi
callq 0x6390
movq %rax, %r15
movq %rbx, %rdi
callq 0x9b00
movq %r14, (%r15)
movq 0x8(%rbx), %rcx
movq %rcx, 0x8(%r15)
movl %eax, 0x10(%r15)
movq %r15, %rax
addq $0x68, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
movq %rdx, 0x28(%rsp)
movq (%rcx), %rdx
movq %rdx, 0x38(%rsp)
movq 0x8(%rax), %rdx
leaq 0x28(%rsp), %rsi
movq %rdx, 0x8(%rsi)
movq %rcx, (%rax)
movq $0x0, 0x8(%rax)
movb $0x0, 0x10(%rax)
movb $0x1, %bpl
movq %rbx, %rdi
callq 0x66f0
xorl %ebp, %ebp
movq 0x1b0d1(%rip), %rsi     # 0x24fc8
movq 0x1b0b2(%rip), %rdx     # 0x24fb0
movq %rbx, %rdi
callq 0x66c0
movl $0x10, %edi
callq 0x61c0
movq %rax, %rbx
leaq 0x107a1(%rip), %rsi     # 0x1a6bb
movq %rax, %rdi
callq 0x6790
movq 0x1b09f(%rip), %rsi     # 0x24fc8
movq 0x1b080(%rip), %rdx     # 0x24fb0
movq %rbx, %rdi
callq 0x66c0
jmp 0x9fb9
movq %rax, %r14
movq 0x28(%rsp), %rdi
cmpq %r15, %rdi
je 0x9f5c
movq 0x38(%rsp), %rsi
incq %rsi
callq 0x63a0
jmp 0x9f5c
movq %rax, %r14
movb $0x1, %bpl
leaq 0x58(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x9f77
movq 0x58(%rsp), %rsi
incq %rsi
callq 0x63a0
leaq 0x18(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x9f92
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x63a0
testb %bpl, %bpl
jne 0x9fbc
jmp 0x9fc4
movq %rax, %r14
leaq 0x18(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x9fbc
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x63a0
jmp 0x9fbc
movq %rax, %r14
movq %rbx, %rdi
callq 0x62b0
movq %r14, %rdi
callq 0x6700
// File: /workspace/github_cpp_makefile_star2_O3/alex-courtis[P]xlayoutdisplay/src/xrdbutil.cpp
// Function: renderXrdbCmd[abi:cxx11](long const&)
const std::string renderXrdbCmd(const long &dpi) {
    stringstream ss;
    ss << "echo \"Xft.dpi: "
       << dpi
       << "\" | xrdb -merge";
    return ss.str();
}

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

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

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x68, %rsp
movq %rsi, %r14
movq %rdi, %r12
movq (%rsi), %r15
callq 0x6070
movq %rax, %rbx
movl (%rax), %ebp
movl $0x0, (%rax)
leaq 0x48(%rsp), %r13
movq %r15, %rdi
movq %r13, %rsi
movl $0xa, %edx
callq 0x6570
cmpq %r15, (%r13)
je 0xaea2
movslq %eax, %rcx
cmpq %rax, %rcx
jne 0xaeae
movl (%rbx), %ecx
cmpl $0x22, %ecx
je 0xaeae
testl %ecx, %ecx
jne 0xae93
movl %ebp, (%rbx)
addq $0x68, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
leaq 0xff5e(%rip), %rdi      # 0x1ae07
callq 0x6220
leaq 0xff52(%rip), %rdi      # 0x1ae07
callq 0x65a0
movq %rax, %r15
cmpl $0x0, (%rbx)
jne 0xaec4
movl %ebp, (%rbx)
cmpl $0x1, %edx
jne 0xb017
movq %r15, %rdi
callq 0x6160
movl $0x10, %edi
callq 0x61c0
movq %rax, %rbx
leaq 0xfa79(%rip), %rsi      # 0x1a962
leaq 0x8(%rsp), %rdi
movq %r12, %rdx
callq 0x797c
leaq 0xf911(%rip), %rsi      # 0x1a80e
leaq 0x8(%rsp), %rdi
callq 0x67c0
leaq 0x38(%rsp), %r12
movq %r12, -0x10(%r12)
movq (%rax), %rdx
movq %rax, %rcx
addq $0x10, %rcx
cmpq %rcx, %rdx
jne 0xaf2a
movups (%rcx), %xmm0
movups %xmm0, (%r12)
jmp 0xaf37
movq %rdx, 0x28(%rsp)
movq (%rcx), %rdx
movq %rdx, 0x38(%rsp)
movq 0x8(%rax), %rdx
leaq 0x28(%rsp), %rsi
movq %rdx, 0x8(%rsi)
movq %rcx, (%rax)
movq $0x0, 0x8(%rax)
movb $0x0, 0x10(%rax)
leaq 0x48(%rsp), %rdi
movq %r14, %rdx
callq 0xc509
movb $0x1, %bpl
leaq 0x48(%rsp), %rsi
movq %rbx, %rdi
callq 0x66f0
xorl %ebp, %ebp
movq 0x1a04f(%rip), %rsi     # 0x24fc8
movq 0x1a030(%rip), %rdx     # 0x24fb0
movq %rbx, %rdi
callq 0x66c0
movq %rax, %r15
leaq 0x58(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0xafae
movq 0x58(%rsp), %rsi
incq %rsi
callq 0x63a0
jmp 0xafae
movq %rax, %r15
movb $0x1, %bpl
movq 0x28(%rsp), %rdi
cmpq %r12, %rdi
je 0xafc5
movq 0x38(%rsp), %rsi
incq %rsi
callq 0x63a0
leaq 0x18(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0xafe0
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x63a0
testb %bpl, %bpl
jne 0xb00a
jmp 0xb012
movq %rax, %r15
leaq 0x18(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0xb00a
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x63a0
jmp 0xb00a
movq %rax, %r15
movq %rbx, %rdi
callq 0x62b0
callq 0x6690
movq %r15, %rdi
callq 0x6700
movq %rax, %rdi
callq 0x89bb
// File: /workspace/github_cpp_makefile_star2_O3/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
movq $-0x1, %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)
cmpq $0x2, %r12
jl 0x2e12
movl $0x1, %eax
shlq $0x3, %r15
movq 0x8(%rbx), %rcx
movq -0x8(%rcx,%rax,8), %rdx
addq %r15, %rdx
movq %rdx, (%rcx,%rax,8)
incq %rax
cmpq %rax, %r12
jne 0x2dfa
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
// File: /workspace/github_cpp_makefile_star2_O3/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 0x2f11
movq %rsi, %r14
movq (%rsi), %rax
movq %rax, (%rbx)
movq 0x8(%rbx), %rdi
testq %rdi, %rdi
je 0x2e63
movq (%rdi), %rax
testq %rax, %rax
je 0x2e5e
movq %rax, %rdi
callq 0x2200
movq 0x8(%rbx), %rdi
testq %rdi, %rdi
je 0x2e63
callq 0x2200
movslq (%rbx), %r12
leaq (,%r12,8), %rdi
testq %r12, %r12
movq $-0x1, %rbp
cmovsq %rbp, %rdi
callq 0x2030
movq %rax, %r15
movq %rax, 0x8(%rbx)
movslq 0x4(%rbx), %r13
movq %r13, %rax
imulq %r12, %rax
movq %rax, %rdi
shlq $0x3, %rdi
testl %eax, %eax
cmovsq %rbp, %rdi
callq 0x2030
movq %rax, (%r15)
cmpq $0x2, %r12
jl 0x2ed3
movl $0x1, %eax
leaq (,%r13,8), %rcx
movq 0x8(%rbx), %rdx
movq -0x8(%rdx,%rax,8), %rsi
addq %rcx, %rsi
movq %rsi, (%rdx,%rax,8)
incq %rax
cmpq %rax, %r12
jne 0x2ebb
testl %r12d, %r12d
jle 0x2f11
movq 0x8(%r14), %rax
movq 0x8(%rbx), %rcx
movl %r13d, %edx
xorl %esi, %esi
testl %r13d, %r13d
jle 0x2f09
movq (%rax,%rsi,8), %rdi
movq (%rcx,%rsi,8), %r8
xorl %r9d, %r9d
movsd (%rdi,%r9,8), %xmm0
movsd %xmm0, (%r8,%r9,8)
incq %r9
cmpq %r9, %rdx
jne 0x2ef5
incq %rsi
cmpq %r12, %rsi
jne 0x2ee5
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_O3/joraso[P]Glassius/Matrix.cpp
// Function: Matrix::Matrix(Matrix const&)
Matrix::Matrix(const Matrix& rhs){
    int i,j;
    rows = rhs.rows;
    columns = rhs.columns;
    if(data !=0){
        data = 0;
    }
    data = new double* [rows];
    data[0] = new double [rows*columns];
    for(i=1;i<rows;i++)
        data[i]=data[i-1]+columns;
    for(i=0;i<rows;i++)
        for(j=0;j<columns;j++)
            data[i][j] = rhs.data[i][j];
}

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

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

// Assembly:
movq $0x0, 0x78(%rdi)
movslq 0x50(%rdi), %rax
testq %rax, %rax
jle 0x3634
movq 0x10(%rdi), %rcx
xorpd %xmm0, %xmm0
xorl %edx, %edx
movsd 0x4b03(%rip), %xmm1     # 0x8108
movq (%rcx,%rdx,8), %rsi
xorl %r8d, %r8d
movsd (%rsi,%r8,8), %xmm2
mulsd %xmm2, %xmm2
mulsd %xmm1, %xmm2
addsd %xmm2, %xmm0
movsd %xmm0, 0x78(%rdi)
incq %r8
cmpq $0x3, %r8
jne 0x360c
incq %rdx
cmpq %rax, %rdx
jne 0x3605
retq
nop
// File: /workspace/github_cpp_makefile_star2_O3/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 0x4aca(%rip), %xmm1     # 0x8110
movl 0x50(%rdi), %eax
decl %eax
xorps %xmm0, %xmm0
cvtsi2sd %eax, %xmm0
mulsd %xmm1, %xmm0
divsd 0x78(%rdi), %xmm0
xorpd %xmm1, %xmm1
ucomisd %xmm1, %xmm0
jb 0x366b
sqrtsd %xmm0, %xmm0
jmp 0x3670
callq 0x2150
movq $0x0, 0x78(%rbx)
movslq 0x50(%rbx), %rax
testq %rax, %rax
jle 0x36c6
movq 0x10(%rbx), %rcx
xorl %edx, %edx
movsd 0x4a79(%rip), %xmm1     # 0x8108
movq (%rcx,%rdx,8), %rsi
xorl %edi, %edi
movsd (%rsi,%rdi,8), %xmm2
mulsd %xmm0, %xmm2
movsd %xmm2, (%rsi,%rdi,8)
mulsd %xmm2, %xmm2
mulsd %xmm1, %xmm2
addsd 0x78(%rbx), %xmm2
movsd %xmm2, 0x78(%rbx)
incq %rdi
cmpq $0x3, %rdi
jne 0x3695
incq %rdx
cmpq %rax, %rdx
jne 0x368f
popq %rbx
retq
// File: /workspace/github_cpp_makefile_star2_O3/joraso[P]Glassius/Particles.cpp
// Function: Free::UpdateForces()
void Free::UpdateForces(){
    int i, k;
    // Zero out the forces and potential energy
    for(i=0;i<N;i++){for(k=0;k<3;k++){f[i][k]=0;};};
    potential_energy = 0;
    return;
}

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

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
movq 0x8(%rdi), %rdi
movslq 0x50(%rdi), %r14
testq %r14, %r14
jle 0x4263
movsd 0x18(%rbx), %xmm0
mulsd %xmm0, %xmm0
movq 0x8(%rdi), %rax
movq 0x10(%rdi), %rcx
movq 0x18(%rdi), %rdx
xorl %esi, %esi
movsd 0x3f01(%rip), %xmm1     # 0x8100
movq (%rcx,%rsi,8), %r8
movq (%rdx,%rsi,8), %r9
movq (%rax,%rsi,8), %r10
xorl %r11d, %r11d
movsd (%r8,%r11,8), %xmm2
movsd (%r9,%r11,8), %xmm3
mulsd %xmm1, %xmm3
mulsd 0x18(%rbx), %xmm2
mulsd %xmm0, %xmm3
addsd %xmm3, %xmm2
addsd (%r10,%r11,8), %xmm2
movsd %xmm2, (%r10,%r11,8)
movsd (%r9,%r11,8), %xmm2
mulsd %xmm1, %xmm2
mulsd 0x18(%rbx), %xmm2
addsd (%r8,%r11,8), %xmm2
movsd %xmm2, (%r8,%r11,8)
incq %r11
cmpq $0x3, %r11
jne 0x420e
incq %rsi
cmpq %r14, %rsi
jne 0x41ff
movq (%rdi), %rax
callq *(%rax)
movq 0x8(%rbx), %rdi
testl %r14d, %r14d
jle 0x42ba
movq 0x10(%rdi), %rax
movq 0x18(%rdi), %rcx
xorl %edx, %edx
movsd 0x3e7d(%rip), %xmm0     # 0x8100
movq (%rcx,%rdx,8), %rsi
movq (%rax,%rdx,8), %r8
xorl %r9d, %r9d
movsd 0x18(%rbx), %xmm1
mulsd %xmm0, %xmm1
mulsd (%rsi,%r9,8), %xmm1
addsd (%r8,%r9,8), %xmm1
movsd %xmm1, (%r8,%r9,8)
incq %r9
cmpq $0x3, %r9
jne 0x428e
incq %rdx
cmpq %r14, %rdx
jne 0x4283
callq 0x35e2
movsd 0x18(%rbx), %xmm0
addsd 0x20(%rbx), %xmm0
movsd %xmm0, 0x20(%rbx)
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_cpp_makefile_star2_O3/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 0x42fe
sqrtsd %xmm0, %xmm0
jmp 0x4303
callq 0x2150
movsd %xmm0, 0x60(%rbx)
movq 0x8(%rbx), %rax
movl 0x50(%rax), %eax
movq %rsp, %rsi
movl %eax, (%rsi)
leaq 0x4(%rsp), %rdx
movl $0x3, (%rdx)
leaq 0x8(%rsp), %r14
movq %r14, %rdi
callq 0x2d90
leaq 0x68(%rbx), %rdi
movq %r14, %rsi
callq 0x2e1c
leaq 0x8(%rsp), %rdi
callq 0x300a
leaq 0x4(%rsp), %rdx
movl $0x3, (%rdx)
leaq 0x8(%rsp), %r14
movq %rsp, %rsi
movq %r14, %rdi
callq 0x2d90
leaq 0x78(%rbx), %rdi
movq %r14, %rsi
callq 0x2e1c
leaq 0x8(%rsp), %rdi
callq 0x300a
leaq 0x4(%rsp), %rdx
movl $0x3, (%rdx)
leaq 0x8(%rsp), %r14
movq %rsp, %rsi
movq %r14, %rdi
callq 0x2d90
leaq 0x88(%rbx), %rdi
movq %r14, %rsi
callq 0x2e1c
leaq 0x8(%rsp), %rdi
callq 0x300a
movq 0x70(%rbx), %rax
movq 0x80(%rbx), %rcx
movq %rax, 0x98(%rbx)
movq %rcx, 0xa0(%rbx)
movq 0x90(%rbx), %rdx
movq %rdx, 0xa8(%rbx)
movslq (%rsp), %rsi
testq %rsi, %rsi
jle 0x4407
xorl %edi, %edi
xorl %r8d, %r8d
movq (%rax,%r8,8), %r9
movq (%rcx,%r8,8), %r10
movq (%rdx,%r8,8), %r11
xorl %ebx, %ebx
movq %rdi, (%r9,%rbx,8)
movq %rdi, (%r10,%rbx,8)
movq %rdi, (%r11,%rbx,8)
incq %rbx
cmpq $0x3, %rbx
jne 0x43ea
incq %r8
cmpq %rsi, %r8
jne 0x43dc
addq $0x18, %rsp
popq %rbx
popq %r14
retq
jmp 0x4413
jmp 0x4413
movq %rax, %rbx
leaq 0x8(%rsp), %rdi
callq 0x300a
movq %rbx, %rdi
callq 0x22b0
// File: /workspace/github_cpp_makefile_star2_O3/joraso[P]Glassius/Integration.cpp
// Function: Brownian::Propigate()
void Brownian::Propigate(){
    /* Advances the velocity huen calculation one step.*/
    
    int i,k;
    int n = System->Number();
    double dtinv = 1/dt;
    for(i=0;i<n;i++){
        for(k=0;k<3;k++){
            eta[i][k] = prefactor*chaos::gaussian(0.0, 1.0);
            f0[i][k] = System->f[i][k];
            x0[i][k] = System->r[i][k];
            System->r[i][k] = x0[i][k] + dt*System->f[i][k] + eta[i][k];
        }
    }
    System->UpdateForces();
    for(i=0;i<n;i++){
        for(k=0;k<3;k++){
            System->r[i][k] = x0[i][k] + 0.5*dt*(System->f[i][k] + f0[i][k])
                                + eta[i][k];
            System->v[i][k] = dtinv*(System->r[i][k] - x0[i][k]);
        }
    }
    System->UpdateForces();
    System->UpdateKinetic();
    time += dt;
    return;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %rdi, %rbx
movq 0x8(%rdi), %rdi
movslq 0x50(%rdi), %r14
movsd 0x3c0f(%rip), %xmm0     # 0x8058
divsd 0x18(%rbx), %xmm0
movsd %xmm0, 0x10(%rsp)
testq %r14, %r14
jle 0x450a
xorl %r15d, %r15d
xorl %r12d, %r12d
movsd 0x60(%rbx), %xmm0
movsd %xmm0, (%rsp)
xorpd %xmm0, %xmm0
movsd 0x3bdf(%rip), %xmm1     # 0x8058
callq 0x2987
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), %xmm1
mulsd (%rdx,%r12,8), %xmm1
addsd %xmm0, %xmm1
addsd (%rax,%r12,8), %xmm1
movsd %xmm1, (%rcx,%r12,8)
incq %r12
cmpq $0x3, %r12
jne 0x4463
incq %r15
cmpq %r14, %r15
jne 0x4460
movq (%rdi), %rax
callq *(%rax)
movq 0x8(%rbx), %rax
movq %rax, 0x8(%rsp)
testl %r14d, %r14d
movsd 0x10(%rsp), %xmm3
jle 0x45c7
movq 0xa8(%rbx), %rax
movq %rax, (%rsp)
movq 0x8(%rsp), %rax
movq 0x18(%rax), %rcx
movq 0x98(%rbx), %rdx
movq 0xa0(%rbx), %rsi
movq 0x8(%rax), %r8
movq 0x10(%rax), %r9
xorl %r10d, %r10d
movsd 0x3ba4(%rip), %xmm0     # 0x8100
movq (%rsp), %rax
movq (%rax,%r10,8), %r11
movq (%rcx,%r10,8), %r15
movq (%rsi,%r10,8), %r12
movq (%rdx,%r10,8), %r13
movq (%r8,%r10,8), %rbp
movq (%r9,%r10,8), %rax
xorl %edi, %edi
movsd 0x18(%rbx), %xmm1
mulsd %xmm0, %xmm1
movsd (%r15,%rdi), %xmm2
addsd (%r12,%rdi), %xmm2
mulsd %xmm1, %xmm2
addsd (%r11,%rdi), %xmm2
addsd (%r13,%rdi), %xmm2
movsd %xmm2, (%rbp,%rdi)
subsd (%r11,%rdi), %xmm2
mulsd %xmm3, %xmm2
movsd %xmm2, (%rax,%rdi)
addq $0x8, %rdi
cmpq $0x18, %rdi
jne 0x457a
incq %r10
cmpq %r14, %r10
jne 0x455c
movq 0x8(%rsp), %rdi
movq (%rdi), %rax
callq *(%rax)
movq 0x8(%rbx), %rdi
callq 0x35e2
movsd 0x18(%rbx), %xmm0
addsd 0x20(%rbx), %xmm0
movsd %xmm0, 0x20(%rbx)
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O3/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 0x9194
xorps %xmm0, %xmm0
movaps %xmm0, (%r12)
movq $0x0, 0x10(%r12)
movq (%r15), %rdi
leaq 0x10(%rsp), %r8
movq %r14, %rsi
movl %ebp, %edx
xorl %ecx, %ecx
xorl %r9d, %r9d
callq 0x9310
movq 0x10(%rsp), %rdi
movq 0x18(%rsp), %rax
cmpq %rax, %rdi
je 0x7e06
movq (%rbx), %rcx
movq 0x8(%rbx), %rdx
subq %rcx, %rdx
sarq $0x2, %rdx
movq %rdi, %r8
movq (%r8), %rsi
cmpq %rsi, %rdx
jbe 0x7e28
movl $0x0, (%rcx,%rsi,4)
addq $0x8, %r8
cmpq %rax, %r8
jne 0x7dee
testq %rdi, %rdi
je 0x7e18
movq 0x20(%rsp), %rsi
subq %rdi, %rsi
callq 0x6200
movq %rbx, %rax
addq $0x30, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
leaq 0x18f9f(%rip), %rdi     # 0x20dce
xorl %eax, %eax
callq 0x6300
jmp 0x7e38
movq %rax, %r14
movq 0x10(%rsp), %rdi
testq %rdi, %rdi
je 0x7e52
movq 0x20(%rsp), %rsi
subq %rdi, %rsi
callq 0x6200
movq (%rbx), %rdi
testq %rdi, %rdi
je 0x7e66
movq 0x10(%rbx), %rsi
subq %rdi, %rsi
callq 0x6200
movq %r14, %rdi
callq 0x6360
// File: /workspace/github_cpp_makefile_star2_O3/ridiculousfish[P]docopt_fish/docopt_fish.cpp
// Function: docopt_fish::copyout_metadata[abi:cxx11](docopt_fish::base_metadata_t<docopt_fish::rstring_t> const&)
static metadata_t copyout_metadata(const base_metadata_t<rstring_t> &md) {
    metadata_t result;
    result.command = md.command.std_string();
    result.condition = md.condition.std_string();
    result.description = md.description.std_string();
    result.tag = md.tag;
    return result;
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x28, %rsp
movq %rsi, %r14
movq %rdi, %rbx
leaq 0x10(%rdi), %rax
movq %rax, (%rdi)
xorl %eax, %eax
movq %rax, 0x8(%rdi)
movl %eax, 0x10(%rdi)
leaq 0x30(%rdi), %rcx
movq %rcx, 0x20(%rdi)
movq %rax, 0x28(%rdi)
movl %eax, 0x30(%rdi)
leaq 0x50(%rdi), %rcx
movq %rcx, 0x40(%rdi)
movq %rax, 0x48(%rdi)
movl %eax, 0x50(%rdi)
movl %eax, 0x60(%rdi)
leaq 0x8(%rsp), %rdi
callq 0xaf0c
leaq 0x8(%rsp), %r15
movq %rbx, %rdi
movq %r15, %rsi
callq 0x63c0
movq (%r15), %rdi
leaq 0x18(%rsp), %r12
cmpq %r12, %rdi
je 0x7f8a
movq 0x18(%rsp), %rax
leaq 0x4(,%rax,4), %rsi
callq 0x6200
leaq 0x18(%r14), %rsi
leaq 0x8(%rsp), %rdi
callq 0xaf0c
leaq 0x20(%rbx), %rdi
leaq 0x8(%rsp), %r15
movq %r15, %rsi
callq 0x63c0
movq (%r15), %rdi
cmpq %r12, %rdi
je 0x7fc3
movq 0x18(%rsp), %rax
leaq 0x4(,%rax,4), %rsi
callq 0x6200
leaq 0x30(%r14), %rsi
leaq 0x8(%rsp), %rdi
callq 0xaf0c
leaq 0x40(%rbx), %rdi
leaq 0x8(%rsp), %r15
movq %r15, %rsi
callq 0x63c0
movq (%r15), %rdi
cmpq %r12, %rdi
je 0x7ffc
movq 0x18(%rsp), %rax
leaq 0x4(,%rax,4), %rsi
callq 0x6200
movl 0x48(%r14), %eax
movl %eax, 0x60(%rbx)
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
jmp 0x8013
jmp 0x8013
movq %rax, %r14
movq %rbx, %rdi
callq 0xaeae
movq %r14, %rdi
callq 0x6360
// File: /workspace/github_cpp_makefile_star2_O3/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 0x61e0
movq %rax, %rbx
leaq 0x8(%rsp), %r13
movq %r13, %rdi
movq %r12, %rsi
callq 0x63e0
xorl %r12d, %r12d
movq %r12, 0x10(%rbx)
xorps %xmm0, %xmm0
movups %xmm0, (%rbx)
leaq 0x18(%rbx), %rdi
movq %r13, %rsi
callq 0x63e0
leaq 0x88(%rbx), %rax
movl $0x0, 0x88(%rbx)
movq %r12, 0x90(%rbx)
xorps %xmm0, %xmm0
movups %xmm0, 0x38(%rbx)
movups %xmm0, 0x48(%rbx)
movups %xmm0, 0x58(%rbx)
movups %xmm0, 0x68(%rbx)
movq %r12, 0x78(%rbx)
movq %rax, 0x98(%rbx)
movq %rax, 0xa0(%rbx)
movq %r12, 0xa8(%rbx)
movq (%r13), %rdi
leaq 0x18(%rsp), %rax
cmpq %rax, %rdi
je 0x8169
movq 0x18(%rsp), %rax
leaq 0x4(,%rax,4), %rsi
callq 0x6200
movq %rbx, %rdi
movq %r15, %rsi
callq 0x9d9a
movq %rbx, %rdi
movq %r15, %rsi
callq 0xa648
movl %eax, %ebp
testb %al, %al
je 0x8197
movq (%r14), %rax
movq %rbx, (%r14)
movq %rax, %rbx
testq %rax, %rax
je 0x8219
leaq 0x80(%rbx), %rdi
callq 0xee78
movq 0x68(%rbx), %rdi
testq %rdi, %rdi
je 0x81b8
movq 0x78(%rbx), %rsi
subq %rdi, %rsi
callq 0x6200
movq 0x50(%rbx), %rdi
testq %rdi, %rdi
je 0x81cd
movq 0x60(%rbx), %rsi
subq %rdi, %rsi
callq 0x6200
leaq 0x38(%rbx), %rdi
callq 0xa76c
movq 0x18(%rbx), %rdi
leaq 0x28(%rbx), %rax
cmpq %rax, %rdi
je 0x81f3
movq (%rax), %rax
leaq 0x4(,%rax,4), %rsi
callq 0x6200
movq %rbx, %rdi
callq 0xee30
movl $0xb0, %esi
movq %rbx, %rdi
callq 0x6200
movl %ebp, %eax
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
xorl %ebx, %ebx
jmp 0x81fb
nop
// File: /workspace/github_cpp_makefile_star2_O3/ridiculousfish[P]docopt_fish/docopt_fish.cpp
// Function: docopt_fish::argument_parser_t::set_options(std::vector<docopt_fish::annotated_option_t, std::allocator<docopt_fish::annotated_option_t>>)
void argument_parser_t::set_options(std::vector<annotated_option_t> opts) {
    docopt_impl *new_impl = new docopt_impl(std::move(opts));
    new_impl->populate_from_annotated_options();
    bool preflighted = new_impl->preflight(nullptr);
    if (preflighted) {
        // install the new impl
        // any existing one will be deleted
        std::swap(this->impl, new_impl);
    }
    delete new_impl;  // may be null
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
subq $0x20, %rsp
movq %rsi, %r15
movq %rdi, %r14
movl $0xb0, %edi
callq 0x61e0
movq %rax, %rbx
movq 0x10(%r15), %rax
leaq 0x28(%rbx), %rcx
movups (%r15), %xmm0
xorl %edx, %edx
movq %rdx, 0x10(%r15)
xorps %xmm1, %xmm1
movups %xmm1, (%r15)
movq %rdx, 0x10(%rbx)
movups %xmm1, (%rbx)
movq %rcx, 0x18(%rbx)
movq %rdx, 0x20(%rbx)
movl %edx, 0x28(%rbx)
movups %xmm0, 0x38(%rbx)
movq %rax, 0x48(%rbx)
movq %rsp, %rdi
movaps %xmm1, (%rdi)
movq %rdx, 0x10(%rdi)
leaq 0x88(%rbx), %rax
movl %edx, 0x88(%rbx)
movq %rdx, 0x90(%rbx)
movups %xmm1, 0x50(%rbx)
movups %xmm1, 0x60(%rbx)
movups %xmm1, 0x70(%rbx)
movq %rax, 0x98(%rbx)
movq %rax, 0xa0(%rbx)
movq %rdx, 0xa8(%rbx)
callq 0xa76c
movq %rbx, %rdi
callq 0xa79c
movq %rbx, %rdi
xorl %esi, %esi
callq 0xa648
testb %al, %al
je 0x82d5
movq (%r14), %rax
movq %rbx, (%r14)
movq %rax, %rbx
testq %rax, %rax
je 0x8350
leaq 0x80(%rbx), %rdi
callq 0xee78
movq 0x68(%rbx), %rdi
testq %rdi, %rdi
je 0x82f6
movq 0x78(%rbx), %rsi
subq %rdi, %rsi
callq 0x6200
movq 0x50(%rbx), %rdi
testq %rdi, %rdi
je 0x830b
movq 0x60(%rbx), %rsi
subq %rdi, %rsi
callq 0x6200
leaq 0x38(%rbx), %rdi
callq 0xa76c
movq 0x18(%rbx), %rdi
leaq 0x28(%rbx), %rax
cmpq %rax, %rdi
je 0x8331
movq (%rax), %rax
leaq 0x4(,%rax,4), %rsi
callq 0x6200
movq %rbx, %rdi
callq 0xee30
movl $0xb0, %esi
movq %rbx, %rdi
callq 0x6200
addq $0x20, %rsp
popq %rbx
popq %r14
popq %r15
retq
xorl %ebx, %ebx
jmp 0x8339
// File: /workspace/github_cpp_makefile_star2_O3/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 0x8896
movq %rsi, %rbx
movq 0x8(%rsi), %r14
addq (%rsi), %r14
jb 0x88b5
movq %rdi, %r15
movq 0x8(%rdi), %r12
cmpq %r12, %r14
ja 0x88d4
je 0x8884
movq %r15, %rdi
movl $0xa, %esi
movq %r14, %rdx
callq 0x61b0
incq %rax
movq 0x8(%r15), %rcx
cmoveq %rcx, %rax
subq %r14, %rax
jbe 0x88f3
subq %r14, %rcx
cmpq %rax, %rcx
cmovaeq %rax, %rcx
movq (%r15), %rax
movq %r14, (%rbx)
movq %rcx, 0x8(%rbx)
movq %rax, 0x10(%rbx)
testq %rcx, %rcx
je 0x8912
cmpq %r12, %r14
setne %al
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
leaq 0x1826d(%rip), %rdi     # 0x20b0a
leaq 0x177c0(%rip), %rsi     # 0x20064
leaq 0x18275(%rip), %rcx     # 0x20b20
movl $0xf0, %edx
callq 0x6120
leaq 0x182e8(%rip), %rdi     # 0x20ba4
leaq 0x17cf8(%rip), %rsi     # 0x205bb
leaq 0x18307(%rip), %rcx     # 0x20bd1
movl $0x67, %edx
callq 0x6120
leaq 0x18284(%rip), %rdi     # 0x20b5f
leaq 0x17782(%rip), %rsi     # 0x20064
leaq 0x18237(%rip), %rcx     # 0x20b20
movl $0xf3, %edx
callq 0x6120
leaq 0x1827f(%rip), %rdi     # 0x20b79
leaq 0x17763(%rip), %rsi     # 0x20064
leaq 0x18218(%rip), %rcx     # 0x20b20
movl $0xfc, %edx
callq 0x6120
leaq 0x18276(%rip), %rdi     # 0x20b8f
leaq 0x17744(%rip), %rsi     # 0x20064
leaq 0x181f9(%rip), %rcx     # 0x20b20
movl $0xff, %edx
callq 0x6120