LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_cpp_makefile_star2_O1/Heptagon196[P]Gos/GosASTCompiler.cpp
// Function: Gos::AST::SingleAttr::CompileAST(Gos::Compiler::VMCompiler&)
Compile(SingleAttr) {
    START();
    std::string attr = nodes[0]->token.str;
    std::vector<std::string> attrs;
    if (nodes.size() > 1) {
        for (int i = 0; i < nodes[1]->nodes.size(); i++) {
            attrs.push_back(nodes[1]->nodes[i]->token.str);
        }
    }
    vm.WriteCommandAttributes(attr, attrs);
    return 0;
}

// Assembly:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x40, %rsp
movl 0x2c(%rdi), %eax
movl %eax, 0x72b6a(%rip)     # 0x11f288
movq 0x10(%rdi), %rax
cmpq %rax, 0x18(%rdi)
je 0xac7ec
movq %rsi, %rbx
movq %rdi, %r14
movq (%rax), %rax
leaq 0x30(%rsp), %r12
movq %r12, -0x10(%r12)
movq 0x40(%rax), %rsi
movq 0x48(%rax), %rdx
addq %rsi, %rdx
leaq 0x20(%rsp), %rdi
callq 0x37586
xorps %xmm0, %xmm0
movaps %xmm0, (%rsp)
movq $0x0, 0x10(%rsp)
movq 0x18(%r14), %rax
subq 0x10(%r14), %rax
cmpq $0x9, %rax
jb 0xac7b9
movq 0x10(%r14), %rax
movq 0x8(%rax), %rcx
movq 0x10(%rcx), %rax
cmpq %rax, 0x18(%rcx)
je 0xac7b9
xorl %r13d, %r13d
movq %rsp, %r15
movq (%rax,%r13,8), %rsi
addq $0x40, %rsi
movq %r15, %rdi
callq 0x9b36e
incq %r13
movq 0x10(%r14), %rax
movq 0x8(%rax), %rcx
movq 0x10(%rcx), %rax
movq 0x18(%rcx), %rcx
subq %rax, %rcx
sarq $0x3, %rcx
cmpq %r13, %rcx
ja 0xac78a
movq 0xe8(%rbx), %rdi
leaq 0x20(%rsp), %rsi
movq %rsp, %rdx
callq 0x9aa4c
movq %rsp, %rdi
callq 0x3740c
movq 0x20(%rsp), %rdi
cmpq %r12, %rdi
je 0xac7ec
movq 0x30(%rsp), %rsi
incq %rsi
callq 0x11360
xorl %eax, %eax
addq $0x40, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
jmp 0xac7fe
movq %rax, %rbx
movq %rsp, %rdi
callq 0x3740c
movq 0x20(%rsp), %rdi
cmpq %r12, %rdi
je 0xac820
movq 0x30(%rsp), %rsi
incq %rsi
callq 0x11360
movq %rbx, %rdi
callq 0x11580
// File: /workspace/github_cpp_makefile_star2_O1/Heptagon196[P]Gos/GosASTCompiler.cpp
// Function: Gos::AST::Attribute::CompileAST(Gos::Compiler::VMCompiler&)
Compile(Attribute) {
    START();
    for (int i = 0; i < nodes.size(); i++) {
        SUB(i);
    }
    return 0;
}

// Assembly:
movl 0x2c(%rdi), %eax
movl %eax, 0x72a57(%rip)     # 0x11f288
movq 0x18(%rdi), %rax
cmpq 0x10(%rdi), %rax
je 0xac87b
pushq %r15
pushq %r14
pushq %rbx
movq %rdi, %r14
movq 0x10(%rdi), %rax
cmpq %rax, 0x18(%rdi)
je 0xac876
movq %rsi, %rbx
xorl %r15d, %r15d
movq (%rax,%r15,8), %rdi
movq (%rdi), %rax
movq %rbx, %rsi
callq *(%rax)
incq %r15
movq 0x10(%r14), %rax
movq 0x18(%r14), %rcx
subq %rax, %rcx
sarq $0x3, %rcx
cmpq %r15, %rcx
ja 0xac853
popq %rbx
popq %r14
popq %r15
xorl %eax, %eax
retq
// File: /workspace/github_cpp_makefile_star2_O1/Heptagon196[P]Gos/Gos.cpp
// Function: Gos::GosScript::SetScriptName(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&)
void Gos::GosScript::SetScriptName(const std::string& name) {
    GosASTError::SetFileName(name);
    scriptName = name;
    int pos = name.length() - 1;
    while (name[pos] != '.' && pos > 0) {
        pos--;
    }
    if (pos == 0) {
        pos = name.length();
    }
    scriptNameClass = TypeID::getRaw(std::string_view(scriptName).substr(0, pos));
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %r14
movq %rdi, %rbx
movq %rsi, %rdi
callq 0xa03dc
movq %rbx, %rdi
movq %r14, %rsi
callq 0x3a2e8
movl 0x8(%r14), %ecx
movq (%r14), %rdx
movl %ecx, %eax
decl %eax
testl %eax, %eax
jle 0xaefb9
movslq %eax, %rsi
cmpb $0x2e, (%rdx,%rsi)
jne 0xaefaa
testl %eax, %eax
cmovnel %eax, %ecx
movabsq $-0x340d631b7bdddcdb, %rdx # imm = 0xCBF29CE484222325
movq (%rbx), %rax
movq 0x8(%rbx), %rsi
movslq %ecx, %rcx
cmpq %rcx, %rsi
cmovbq %rsi, %rcx
testq %rcx, %rcx
je 0xaf003
xorl %esi, %esi
movabsq $0x100000001b3, %rdi    # imm = 0x100000001B3
movsbq (%rax,%rsi), %r8
xorq %rdx, %r8
imulq %rdi, %r8
incq %rsi
movq %r8, %rdx
cmpq %rsi, %rcx
jne 0xaefea
jmp 0xaf006
movq %rdx, %r8
movq %r8, 0x20(%rbx)
movq %rcx, 0x28(%rbx)
movq %rax, 0x30(%rbx)
movw $0x0, 0x38(%rbx)
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_cpp_makefile_star2_O1/Heptagon196[P]Gos/Gos.cpp
// Function: Gos::GosScript::GetClassInfo() const
const GosVM::GosClass& Gos::GosScript::GetClassInfo() const {
    auto& info = GosVM::GosClass::classInfo;
    if (info.find(scriptNameClass) == info.end()) {
        std::cerr << "Error: no such class defined in script " << scriptName << ": " << scriptNameClass.getName() << std::endl;
        return info[TypeID::get<void>()];
    }
    return info[scriptNameClass];
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
subq $0x20, %rsp
movq %rdi, %r14
leaq 0x20(%rdi), %rbx
leaq 0x6f523(%rip), %rdi     # 0x11e5a0
movq %rbx, %rsi
callq 0x9d4aa
testq %rax, %rax
je 0xaf0a2
leaq 0x6f50f(%rip), %rdi     # 0x11e5a0
movq %rbx, %rsi
addq $0x20, %rsp
popq %rbx
popq %r14
popq %r15
jmp 0x9d564
movq 0x6ef47(%rip), %r15     # 0x11dff0
leaq 0x2210f(%rip), %rsi     # 0xd11bf
movl $0x27, %edx
movq %r15, %rdi
callq 0x113c0
movq (%r14), %rsi
movq 0x8(%r14), %rdx
movq %r15, %rdi
callq 0x113c0
movq %rax, %r14
leaq 0xf1e3(%rip), %rsi      # 0xbe2b9
movl $0x2, %edx
movq %rax, %rdi
callq 0x113c0
movq %rbx, %rdi
callq 0x1ff7e
movq %r14, %rdi
movq %rdx, %rsi
movq %rax, %rdx
callq 0x113c0
movq %rax, %rbx
movq (%rax), %rax
movq -0x18(%rax), %rdi
addq %rbx, %rdi
movl $0xa, %esi
callq 0x11340
movsbl %al, %esi
movq %rbx, %rdi
callq 0x11040
movq %rax, %rdi
callq 0x11260
movabsq $0x3173c900e37ae1df, %rax # imm = 0x3173C900E37AE1DF
movq %rsp, %rsi
movq %rax, (%rsi)
movq $0x4, 0x8(%rsi)
leaq 0xdc45(%rip), %rax      # 0xbcd87
movq %rax, 0x10(%rsi)
movw $0x0, 0x18(%rsi)
leaq 0x6f44d(%rip), %rdi     # 0x11e5a0
callq 0xb05aa
addq $0x20, %rsp
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_cpp_makefile_star2_O1/Heptagon196[P]Gos/Gos.cpp
// Function: Gos::GosScript::Read(std::istream&, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>)
void Gos::GosScript::Read(std::istream& fin, std::string inputFileName) {
    GosTokenizer tokenizer(fin, inputFileName);
    SetScriptName(inputFileName);
    Compiler::VMCompiler compiler(vm);
    GosAST ast;
    ast.Build(tokenizer);
    ast.CompileAST(compiler);
    // ast.PrintAST();
}

// Assembly:
pushq %r14
pushq %rbx
subq $0x228, %rsp            # imm = 0x228
movq %rdx, %r14
movq %rdi, %rbx
leaq 0x60(%rsp), %rdi
callq 0x9ef4e
movq %rbx, %rdi
movq %r14, %rsi
callq 0xaef84
addq $0x40, %rbx
leaq 0xd0(%rsp), %rdi
movq %rbx, %rsi
callq 0xa7d98
leaq 0x6de2e(%rip), %rax     # 0x11d058
addq $0x10, %rax
leaq 0x28(%rsp), %rdi
movq %rax, -0x28(%rdi)
xorps %xmm0, %xmm0
movups %xmm0, -0x18(%rdi)
movq $0x0, -0x8(%rdi)
callq 0x9ece0
movq %rsp, %rdi
leaq 0x60(%rsp), %rsi
callq 0xa089c
movq %rsp, %rdi
leaq 0xd0(%rsp), %rsi
callq 0xa06cc
movq %rsp, %rdi
callq 0xa0994
leaq 0x210(%rsp), %rbx
movq %rbx, %rdi
callq 0xb02ce
movq -0x18(%rbx), %rdi
testq %rdi, %rdi
je 0xaf299
movq 0x208(%rsp), %rsi
subq %rdi, %rsi
callq 0x11360
leaq 0x1c0(%rsp), %rdi
callq 0xb02fe
leaq 0x168(%rsp), %rdi
callq 0xad4d8
leaq 0x130(%rsp), %rdi
callq 0xad54c
leaq 0xf8(%rsp), %rdi
callq 0xad4d8
leaq 0xd8(%rsp), %rdi
callq 0xad474
movq 0xc0(%rsp), %rax
testq %rax, %rax
je 0xaf2f9
leaq 0xb0(%rsp), %rdi
movq %rdi, %rsi
movl $0x3, %edx
callq *%rax
leaq 0x98(%rsp), %rbx
movq %rbx, %rdi
callq 0x9ff7c
movq -0x28(%rbx), %rdi
leaq 0x80(%rsp), %rax
cmpq %rax, %rdi
je 0xaf32a
movq 0x80(%rsp), %rsi
incq %rsi
callq 0x11360
addq $0x228, %rsp            # imm = 0x228
popq %rbx
popq %r14
retq
movq %rax, %rdi
callq 0x2789a
movq %rax, %rbx
movq 0x10(%rsp), %rdi
testq %rdi, %rdi
je 0xaf36b
movq 0x20(%rsp), %rsi
subq %rdi, %rsi
callq 0x11360
jmp 0xaf36b
jmp 0xaf35b
movq %rax, %rbx
jmp 0xaf378
movq %rax, %rbx
movq %rsp, %rdi
callq 0xa0994
leaq 0xd0(%rsp), %rdi
callq 0xaffd6
leaq 0x60(%rsp), %rdi
callq 0xb0038
movq %rbx, %rdi
callq 0x11580
// File: /workspace/github_cpp_makefile_star2_O1/Heptagon196[P]Gos/Gos.cpp
// Function: Gos::GosProject::ScanDirectory(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, std::function<bool (std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>)>)
void Gos::GosProject::ScanDirectory(std::string directory, std::function<bool(std::string)> filter) {
    std::queue<std::string> imports;
    FileSystem::Iterate(".", std::function([&filter, &imports, this](Path path) {
        if (filter(path.string())) {
            PreprocessFile(path.string(), imports);
        }
    }));
    ExecuteFiles(imports);
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
subq $0xa0, %rsp
movq %rdx, %r14
movq %rdi, %rbx
xorps %xmm0, %xmm0
leaq 0x50(%rsp), %r15
movaps %xmm0, 0x40(%r15)
movaps %xmm0, 0x30(%r15)
movaps %xmm0, 0x20(%r15)
movaps %xmm0, 0x10(%r15)
movaps %xmm0, (%r15)
movq %r15, %rdi
xorl %esi, %esi
callq 0xb1612
leaq 0xe53a(%rip), %rsi      # 0xbe1a9
leaq 0x28(%rsp), %rdi
movl $0x2, %edx
callq 0xb0100
xorps %xmm0, %xmm0
movaps %xmm0, 0x10(%rsp)
movaps %xmm0, (%rsp)
movl $0x18, %edi
callq 0x11350
movq %r14, (%rax)
movq %r15, 0x8(%rax)
movq %rbx, 0x10(%rax)
movq %rsp, %rsi
movq %rax, (%rsi)
leaq 0x16c(%rip), %rax       # 0xafe18
movq %rax, 0x18(%rsi)
leaq 0x281(%rip), %rax       # 0xaff38
movq %rax, 0x10(%rsi)
leaq 0x28(%rsp), %rdi
callq 0xb272e
movq 0x10(%rsp), %rax
testq %rax, %rax
je 0xafcdc
movq %rsp, %rdi
movq %rdi, %rsi
movl $0x3, %edx
callq *%rax
leaq 0x28(%rsp), %rdi
callq 0xb0188
leaq 0x50(%rsp), %rsi
movq %rbx, %rdi
callq 0xaf908
leaq 0x50(%rsp), %rdi
callq 0xb040c
addq $0xa0, %rsp
popq %rbx
popq %r14
popq %r15
retq
jmp 0xafd28
movq %rax, %rbx
movq 0x10(%rsp), %rax
testq %rax, %rax
je 0xafd33
movq %rsp, %rdi
movq %rdi, %rsi
movl $0x3, %edx
callq *%rax
jmp 0xafd33
movq %rax, %rdi
callq 0x2789a
movq %rax, %rbx
leaq 0x28(%rsp), %rdi
callq 0xb0188
jmp 0xafd42
movq %rax, %rbx
leaq 0x50(%rsp), %rdi
callq 0xb040c
movq %rbx, %rdi
callq 0x11580
// File: /workspace/github_cpp_makefile_star2_O1/Heptagon196[P]Gos/GosFileSystem.cpp
// Function: Gos::FileSystem::Read(std::filesystem::__cxx11::path)
std::stringstream Gos::FileSystem::Read(Path path) {
    std::stringstream ss;
    File& file = instance.files[FileSystem::GetFile(path, false)];
    if (file.packID == -1) {
        std::ifstream fin;
        fin.open(path, std::ios::binary);
        ss << fin.rdbuf();
        fin.close();
    } else {
        std::ifstream fin;
        char* buffer = new char[file.fileSize];
        fin.open(instance.dataPacks[file.packID], std::ios::binary);
        fin.seekg(file.packPos);
        fin.read(buffer, file.fileSize);
        fin.close();
        ss.write(buffer, file.fileSize);
        delete[] buffer;
    }
    return ss;
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x238, %rsp            # imm = 0x238
movq %rsi, %r14
movq %rdi, %rbx
callq 0x11280
leaq 0x8(%rsp), %rdi
movq %r14, %rsi
callq 0xb01c0
leaq 0x8(%rsp), %rdi
xorl %esi, %esi
callq 0xb191c
movslq %eax, %r12
movq 0x6c666(%rip), %r15     # 0x11f410
shlq $0x4, %r12
leaq 0x8(%rsp), %rdi
callq 0xb0188
cmpl $-0x1, (%r15,%r12)
je 0xb2e3a
leaq 0x30(%rsp), %rdi
callq 0x113b0
addq %r12, %r15
movslq 0x8(%r15), %rdi
callq 0x11030
movq %rax, %r14
movslq (%r15), %rsi
shlq $0x5, %rsi
addq 0x6c612(%rip), %rsi     # 0x11f3f8
leaq 0x30(%rsp), %rdi
movl $0x4, %edx
callq 0x11310
movslq 0x4(%r15), %rsi
leaq 0x30(%rsp), %rdi
xorl %edx, %edx
callq 0x11400
movslq 0x8(%r15), %rdx
leaq 0x30(%rsp), %rdi
movq %r14, %rsi
callq 0x113f0
leaq 0x30(%rsp), %rdi
callq 0x110a0
leaq 0x10(%rbx), %rdi
movslq 0x8(%r15), %rdx
movq %r14, %rsi
callq 0x11430
movq %r14, %rdi
callq 0x11420
jmp 0xb2e6e
leaq 0x30(%rsp), %rdi
callq 0x113b0
movq (%r14), %rsi
leaq 0x30(%rsp), %rdi
movl $0x4, %edx
callq 0x11200
leaq 0x10(%rbx), %rdi
leaq 0x40(%rsp), %rsi
callq 0x110b0
leaq 0x30(%rsp), %rdi
callq 0x110a0
leaq 0x30(%rsp), %rdi
callq 0x110d0
movq %rbx, %rax
addq $0x238, %rsp            # imm = 0x238
popq %rbx
popq %r12
popq %r14
popq %r15
retq
jmp 0xb2e9d
jmp 0xb2e9d
movq %rax, %r14
leaq 0x8(%rsp), %rdi
callq 0xb0188
jmp 0xb2eb1
movq %rax, %r14
jmp 0xb2eb1
jmp 0xb2ea4
movq %rax, %r14
leaq 0x30(%rsp), %rdi
callq 0x110d0
movq 0x6b0e0(%rip), %rsi     # 0x11df98
movq %rbx, %rdi
callq 0x112c0
subq $-0x80, %rbx
movq %rbx, %rdi
callq 0x11120
movq %r14, %rdi
callq 0x11580
// File: /workspace/github_cpp_makefile_star2_O1/Heptagon196[P]Gos/main.cpp
// Function: vmTest(int, char**)
int vmTest(int argc, char* argv[]) {
    reflIO();
    GosVM::RTConst constArea;
    GosVM::VMProgram program(&constArea);
    std::ifstream fin;
    if (argc > 1) {
        fin.open(argv[1]);
    } else {
        fin.open("1.in");
    }
    program.Read(fin, true);
    fin.close();
    // program.Write(std::cout, true);
    auto ret = program.Execute();
    /*
    auto v = refl.New("Virtual");
    v.Invoke("print", {});
    v.GetField("x").As<int>() = 2333;
    v.Invoke("print", {});
    std::cout << v.GetField("x") << std::endl;
    */
    return 0;
}

// Assembly:
pushq %rbp
pushq %r14
pushq %rbx
subq $0x390, %rsp            # imm = 0x390
movq %rsi, %rbx
movl %edi, %ebp
callq 0xb41b0
xorl %eax, %eax
leaq 0xc8(%rsp), %rcx
movq %rax, -0x38(%rcx)
xorps %xmm0, %xmm0
movaps %xmm0, -0x48(%rcx)
movq %rcx, -0x30(%rcx)
movl $0x1, %edx
movq %rdx, -0x28(%rcx)
movups %xmm0, -0x20(%rcx)
movl $0x3f800000, %esi       # imm = 0x3F800000
movl %esi, -0x10(%rcx)
leaq 0x118(%rsp), %rcx
movaps %xmm0, -0x58(%rcx)
movaps %xmm0, -0x48(%rcx)
movq %rax, -0x38(%rcx)
movq %rcx, -0x30(%rcx)
movq %rdx, -0x28(%rcx)
movups %xmm0, -0x20(%rcx)
movl %esi, -0x10(%rcx)
movaps %xmm0, -0x8(%rcx)
leaq 0x18(%rsp), %rdi
leaq 0x80(%rsp), %rsi
callq 0x94d5e
leaq 0x188(%rsp), %rdi
callq 0x113b0
cmpl $0x2, %ebp
jl 0xb46c0
movq 0x8(%rbx), %rsi
leaq 0x188(%rsp), %rdi
movl $0x8, %edx
callq 0x11200
jmp 0xb46d9
leaq 0x1cc2d(%rip), %rsi     # 0xd12f4
leaq 0x188(%rsp), %rdi
movl $0x8, %edx
callq 0x11200
leaq 0x18(%rsp), %rdi
leaq 0x188(%rsp), %rsi
movl $0x1, %edx
callq 0x97252
leaq 0x188(%rsp), %rdi
callq 0x110a0
leaq 0x128(%rsp), %rdi
callq 0x194bc
xorps %xmm0, %xmm0
movq %rsp, %rcx
movaps %xmm0, (%rcx)
movq $0x0, 0x10(%rcx)
leaq 0x150(%rsp), %rdi
leaq 0x18(%rsp), %rsi
leaq 0x128(%rsp), %rdx
callq 0x950cc
movq (%rsp), %rdi
testq %rdi, %rdi
je 0xb474b
movq 0x10(%rsp), %rsi
subq %rdi, %rsi
callq 0x11360
leaq 0xe8(%rsp), %rbx
leaq 0x150(%rsp), %rdi
callq 0x1d01a
leaq 0x188(%rsp), %rdi
callq 0x110d0
leaq 0x686ec(%rip), %rax     # 0x11ce60
addq $0x10, %rax
leaq 0x60(%rsp), %r14
movq %rax, -0x48(%r14)
movq %r14, %rdi
callq 0x27756
movq -0x28(%r14), %rdi
leaq 0x48(%rsp), %rax
cmpq %rax, %rdi
je 0xb47a4
movq 0x48(%rsp), %rsi
incq %rsi
callq 0x11360
leaq 0x98(%rsp), %r14
movq %rbx, %rdi
callq 0xb025e
movq 0x38(%r14), %rdi
testq %rdi, %rdi
je 0xb47cd
movq 0xe0(%rsp), %rsi
subq %rdi, %rsi
callq 0x11360
movq %r14, %rdi
callq 0xad4d8
leaq 0x80(%rsp), %rdi
callq 0xb0216
xorl %eax, %eax
addq $0x390, %rsp            # imm = 0x390
popq %rbx
popq %r14
popq %rbp
retq
movq %rax, %rbx
movq (%rsp), %rdi
testq %rdi, %rdi
je 0xb481a
movq 0x10(%rsp), %rsi
subq %rdi, %rsi
callq 0x11360
jmp 0xb481a
jmp 0xb4817
movq %rax, %rbx
jmp 0xb4827
movq %rax, %rbx
jmp 0xb4831
movq %rax, %rbx
leaq 0x188(%rsp), %rdi
callq 0x110d0
leaq 0x18(%rsp), %rdi
callq 0xb66aa
leaq 0x80(%rsp), %rdi
callq 0xaffa2
movq %rbx, %rdi
callq 0x11580
// File: /workspace/github_cpp_makefile_star2_O1/dmarto[P]crrs-xlib/main.cpp
// Function: RenderPixel(ScreenData const&)
Vec3 RenderPixel(const ScreenData &sd)
{
	Vec3 pixclr = sd.color.black;
	//~ Vec3 pixclrBounce = sd.color.black;

	const Ray ray(Vec3(sd.x, sd.y, -3), Vec3(0, 0, 1));
	pixclr = Trace(ray, sd.light, sd.objList);

	return pixclr;
}

// Assembly:
pushq %rbx
subq $0x30, %rsp
movq %rdi, %rbx
movq (%rsi), %rax
movq 0x40(%rax), %rcx
movq %rcx, 0x10(%rdi)
movups 0x30(%rax), %xmm0
movups %xmm0, (%rdi)
cvtdq2pd 0x8(%rsi), %xmm0
movq %rsp, %rax
movaps %xmm0, (%rax)
movabsq $-0x3ff8000000000000, %rcx # imm = 0xC008000000000000
movq %rcx, 0x10(%rax)
xorps %xmm0, %xmm0
movups %xmm0, 0x18(%rax)
movabsq $0x3ff0000000000000, %rcx # imm = 0x3FF0000000000000
movq %rcx, 0x28(%rax)
movq 0x10(%rsi), %rdx
movq 0x18(%rsi), %rcx
movq %rax, %rsi
callq 0x17c2
movq %rbx, %rax
addq $0x30, %rsp
popq %rbx
retq
// File: /workspace/github_cpp_makefile_star2_O1/dmarto[P]crrs-xlib/main.cpp
// Function: HandleEvents(_XEvent&, Sphere&, Sphere&)
void HandleEvents(XEvent &event, Sphere &light, Sphere &world)
{
	if (event.type == MotionNotify)
	{
		light.center.x = event.xmotion.x;
		light.center.y = event.xmotion.y;
	}

	if (event.type == ButtonPress && event.xbutton.button == 4 && world.center.z > 580)
	{
		world.center.z -= 5;
		world.center.y -= 5;

		light.center.z -= 30;
	}

	if (event.type == ButtonPress && event.xbutton.button == 5 && world.center.z < 600)
	{
		world.center.z += 5;
		world.center.y += 5;

		light.center.z += 30;
	}
}

// Assembly:
cmpl $0x6, (%rdi)
jne 0x1a59
cvtsi2sdl 0x40(%rdi), %xmm0
movsd %xmm0, (%rsi)
xorps %xmm0, %xmm0
cvtsi2sdl 0x44(%rdi), %xmm0
movsd %xmm0, 0x8(%rsi)
cmpl $0x4, (%rdi)
jne 0x1a9f
cmpl $0x4, 0x54(%rdi)
jne 0x1a9f
movsd 0x10(%rdx), %xmm0
movsd 0x15df(%rip), %xmm1     # 0x3050
ucomisd %xmm0, %xmm1
jae 0x1a9f
movupd 0x8(%rdx), %xmm1
unpcklpd %xmm0, %xmm1            # xmm1 = xmm1[0],xmm0[0]
addpd 0x1658(%rip), %xmm1     # 0x30e0
movupd %xmm1, 0x8(%rdx)
movsd 0x10(%rsi), %xmm0
addsd 0x15be(%rip), %xmm0     # 0x3058
movsd %xmm0, 0x10(%rsi)
cmpl $0x4, (%rdi)
jne 0x1ae5
cmpl $0x5, 0x54(%rdi)
jne 0x1ae5
movsd 0x10(%rdx), %xmm0
movsd 0x15a9(%rip), %xmm1     # 0x3060
ucomisd %xmm0, %xmm1
jbe 0x1ae5
movupd 0x8(%rdx), %xmm1
unpcklpd %xmm0, %xmm1            # xmm1 = xmm1[0],xmm0[0]
addpd 0x1622(%rip), %xmm1     # 0x30f0
movupd %xmm1, 0x8(%rdx)
movsd 0x10(%rsi), %xmm0
addsd 0x1588(%rip), %xmm0     # 0x3068
movsd %xmm0, 0x10(%rsi)
retq
// File: /workspace/github_cpp_makefile_star2_O1/dmarto[P]crrs-xlib/main.cpp
// Function: Sphere::Intersects(Ray const&, double&) const
bool Intersects(const Ray &ray, double &t) const
	{
		const Vec3 origin = ray.origin;
		const Vec3 dest = ray.destination;
		const Vec3 orgCtr = origin - this->center;
		const double b = 2 * dot(orgCtr, dest);
		const double center = dot(orgCtr, orgCtr) - radius * radius;
		double discrim = b * b - 4 * center;

		if (discrim < 1e-4)
			return false;

		discrim = sqrt(discrim);
		const double t0 = -b - discrim;
		const double t1 = -b + discrim;

		t = (t0 < t1) ? t0 : t1;

		return true;
	}

// Assembly:
movsd (%rsi), %xmm0
subsd (%rdi), %xmm0
movsd 0x18(%rsi), %xmm1
mulsd %xmm0, %xmm1
mulsd %xmm0, %xmm0
movupd 0x8(%rsi), %xmm2
movupd 0x8(%rdi), %xmm3
subpd %xmm3, %xmm2
movapd %xmm2, %xmm3
mulsd %xmm2, %xmm3
addsd %xmm0, %xmm3
unpcklpd %xmm3, %xmm1            # xmm1 = xmm1[0],xmm3[0]
movapd %xmm2, %xmm0
movlpd 0x20(%rsi), %xmm0       # xmm0 = mem[0],xmm0[1]
mulpd %xmm2, %xmm0
addpd %xmm1, %xmm0
movsd 0x18(%rdi), %xmm1
shufpd $0x1, %xmm1, %xmm2      # xmm2 = xmm2[1],xmm1[0]
movsd 0x28(%rsi), %xmm3
unpcklpd %xmm1, %xmm3            # xmm3 = xmm3[0],xmm1[0]
mulpd %xmm2, %xmm3
movapd %xmm0, %xmm1
addpd %xmm3, %xmm1
subpd %xmm3, %xmm0
movsd %xmm1, %xmm0            # xmm0 = xmm1[0],xmm0[1]
mulpd 0xda9(%rip), %xmm0      # 0x30a0
movapd %xmm0, %xmm2
unpckhpd %xmm0, %xmm2            # xmm2 = xmm2[1],xmm0[1]
movapd %xmm0, %xmm1
mulsd %xmm0, %xmm1
subsd %xmm2, %xmm1
ucomisd 0xd1d(%rip), %xmm1      # 0x3030
jb 0x2338
xorps %xmm2, %xmm2
sqrtsd %xmm1, %xmm2
movapd %xmm2, %xmm3
addsd %xmm0, %xmm3
xorpd 0xd84(%rip), %xmm3      # 0x30b0
subsd %xmm0, %xmm2
minsd %xmm3, %xmm2
movsd %xmm2, (%rdx)
ucomisd 0xcf0(%rip), %xmm1      # 0x3030
setae %al
retq
// File: /workspace/github_cpp_makefile_star2_O1/yukimasano[P]cpp_matrix/Matrix.cpp
// Function: Matrix::Matrix(int, int)
Matrix::Matrix(int rows, int cols)
{
  mData = new double* [rows];
  mShape[0] = rows;
  mShape[1] = cols;
	for (int i=0; i<rows;  i++){
		mData[i] = new double[cols];
		for (int j=0; j<cols; j++){
			mData[i][j] = 0.0;
  	}
  }
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movl %edx, %ebx
movl %esi, %ebp
movq %rdi, %r14
movslq %esi, %r15
leaq (,%r15,8), %rdi
testl %r15d, %r15d
movq $-0x1, %r12
cmovsq %r12, %rdi
callq 0x2030
movq %rax, (%r14)
movl %r15d, 0x8(%r14)
movl %ebx, 0xc(%r14)
testl %r15d, %r15d
jle 0x2f3d
movslq %ebx, %r15
shlq $0x3, %r15
testl %ebx, %ebx
cmovsq %r12, %r15
movl %ebx, %r12d
shlq $0x3, %r12
movl %ebp, %r13d
xorl %ebp, %ebp
movq %r15, %rdi
callq 0x2030
movq (%r14), %rcx
movq %rax, (%rcx,%rbp,8)
testl %ebx, %ebx
jle 0x2f35
movq (%r14), %rax
movq (%rax,%rbp,8), %rdi
xorl %esi, %esi
movq %r12, %rdx
callq 0x20a0
incq %rbp
cmpq %rbp, %r13
jne 0x2f11
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O1/yukimasano[P]cpp_matrix/Matrix.cpp
// Function: Matrix::operator()(int, int)
double& Matrix::operator()(int i, int j)
{

  if (i < 1 || j< 1)
    {
      throw Exception("out of range",
		  "accessing vector through () - index too small");
    }
  else if (i > mShape[0] || j >mShape[1] )
    {
      throw Exception("length mismatch",
		  "accessing vector through () - index too high");
    }
  return mData[i-1][j-1];
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x80, %rsp
testl %esi, %esi
jle 0x2fdf
testl %edx, %edx
jle 0x2fdf
cmpl %esi, 0x8(%rdi)
jl 0x305e
cmpl %edx, 0xc(%rdi)
jl 0x305e
movq (%rdi), %rax
movl %esi, %ecx
movq -0x8(%rax,%rcx,8), %rax
movl %edx, %ecx
leaq (%rax,%rcx,8), %rax
addq $-0x8, %rax
addq $0x80, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
movl $0x40, %edi
callq 0x2080
movq %rax, %rbx
leaq 0x70(%rsp), %r15
movq %r15, -0x10(%r15)
leaq 0x70a4(%rip), %rsi      # 0xa0a0
leaq 0x70a9(%rip), %rdx      # 0xa0ac
leaq 0x60(%rsp), %rdi
callq 0x81d6
leaq 0x50(%rsp), %r12
movq %r12, -0x10(%r12)
leaq 0x708f(%rip), %rsi      # 0xa0ad
leaq 0x70b5(%rip), %rdx      # 0xa0da
leaq 0x40(%rsp), %rdi
callq 0x81d6
movb $0x1, %bpl
leaq 0x60(%rsp), %rsi
leaq 0x40(%rsp), %rdx
movq %rbx, %rdi
callq 0x8f64
xorl %ebp, %ebp
leaq 0xad4b(%rip), %rsi      # 0xdd98
leaq 0x5158(%rip), %rdx      # 0x81ac
movq %rbx, %rdi
callq 0x21c0
jmp 0x30d7
movl $0x40, %edi
callq 0x2080
movq %rax, %rbx
leaq 0x30(%rsp), %r15
movq %r15, -0x10(%r15)
leaq 0x7060(%rip), %rsi      # 0xa0db
leaq 0x7068(%rip), %rdx      # 0xa0ea
leaq 0x20(%rsp), %rdi
callq 0x81d6
leaq 0x10(%rsp), %r12
movq %r12, -0x10(%r12)
leaq 0x704e(%rip), %rsi      # 0xa0eb
leaq 0x7073(%rip), %rdx      # 0xa117
movq %rsp, %rdi
callq 0x81d6
movb $0x1, %bpl
leaq 0x20(%rsp), %rsi
movq %rsp, %rdx
movq %rbx, %rdi
callq 0x8f64
xorl %ebp, %ebp
leaq 0xacd0(%rip), %rsi      # 0xdd98
leaq 0x50dd(%rip), %rdx      # 0x81ac
movq %rbx, %rdi
callq 0x21c0
movq %rax, %r14
movq (%rsp), %rdi
cmpq %r12, %rdi
je 0x30f0
callq 0x2140
jmp 0x30f0
movq %rax, %r14
movb $0x1, %bpl
movq 0x20(%rsp), %rdi
jmp 0x3116
movq %rax, %r14
movq 0x40(%rsp), %rdi
cmpq %r12, %rdi
je 0x3111
callq 0x2140
jmp 0x3111
movq %rax, %r14
movb $0x1, %bpl
movq 0x60(%rsp), %rdi
cmpq %r15, %rdi
je 0x312a
callq 0x2140
jmp 0x312a
jmp 0x3124
movq %rax, %r14
movb $0x1, %bpl
testb %bpl, %bpl
je 0x3137
movq %rbx, %rdi
callq 0x20f0
movq %r14, %rdi
callq 0x21f0
nop
// File: /workspace/github_cpp_makefile_star2_O1/yukimasano[P]cpp_matrix/Matrix.cpp
// Function: Matrix::T() const
Matrix Matrix::T() const
{
	Matrix C(mShape[1],mShape[0]);
	for (int i=0; i<mShape[1];  i++){
		for (int j=0; j<mShape[0]; j++){
			C.mData[i][j] = mData[j][i];
		}
	}
	return C;
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %r14
movq %rdi, %rbx
movl 0x8(%rsi), %edx
movl 0xc(%rsi), %esi
callq 0x2eb8
movslq 0xc(%r14), %rax
testq %rax, %rax
jle 0x3195
movl 0x8(%r14), %ecx
movq (%r14), %rdx
movq (%rbx), %rsi
xorl %edi, %edi
testl %ecx, %ecx
jle 0x318d
movq (%rsi,%rdi,8), %r8
xorl %r9d, %r9d
movq (%rdx,%r9,8), %r10
movsd (%r10,%rdi,8), %xmm0
movsd %xmm0, (%r8,%r9,8)
incq %r9
cmpq %r9, %rcx
jne 0x3175
incq %rdi
cmpq %rax, %rdi
jne 0x316a
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_cpp_makefile_star2_O1/yukimasano[P]cpp_matrix/Matrix.cpp
// Function: Matrix::get_col(int)
Vector Matrix::get_col(int k)
{
	//std::cout<<"before all"<<std::endl<< std::flush;
	Vector v(mShape[0]);
  //	std::cout<<"after vec"<<std::endl<< std::flush;
	for (int i =1 ; i<=mShape[0]; i++){
		//std::cout<<"pre-definition"<<std::endl<< std::flush;
		//std::cout<< "this is the val  "<< mData[i][k]<< "this is the size  "<<mShape[0] << std::endl<< std::flush;
		v.set_val(i, mData[i-1][k-1]);
		//std::cout<<"in for loop"<<std::endl<< std::flush;
	}
	//std::cout<<"before return"<<std::endl<< std::flush;
	return v;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movl %edx, %ebp
movq %rsi, %r14
movq %rdi, %rbx
movl 0x8(%rsi), %esi
callq 0x8268
cmpl $0x0, 0x8(%r14)
jle 0x31f4
movslq %ebp, %r15
xorl %r12d, %r12d
movq (%r14), %rax
movq (%rax,%r12,8), %rax
movsd -0x8(%rax,%r15,8), %xmm0
leal 0x1(%r12), %esi
movq %rbx, %rdi
callq 0x8ef8
movslq 0x8(%r14), %rax
incq %r12
cmpq %rax, %r12
jl 0x31cd
movq %rbx, %rax
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %r14
movq %rbx, %rdi
callq 0x8310
movq %r14, %rdi
callq 0x21f0
nop
// File: /workspace/github_cpp_makefile_star2_O1/yukimasano[P]cpp_matrix/Matrix.cpp
// Function: Matrix::get_row(int)
Vector Matrix::get_row(int k)
{
	Vector v(mShape[0]);
	for (int i =1 ; i<=mShape[1]; i++){
		v.set_val(i, mData[k-1][i-1]);
	}
	return v;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movl %edx, %ebp
movq %rsi, %r14
movq %rdi, %rbx
movl 0x8(%rsi), %esi
callq 0x8268
cmpl $0x0, 0xc(%r14)
jle 0x3260
movslq %ebp, %r15
xorl %r12d, %r12d
movq (%r14), %rax
movq -0x8(%rax,%r15,8), %rax
movsd (%rax,%r12,8), %xmm0
leal 0x1(%r12), %esi
movq %rbx, %rdi
callq 0x8ef8
movslq 0xc(%r14), %rax
incq %r12
cmpq %rax, %r12
jl 0x3239
movq %rbx, %rax
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %r14
movq %rbx, %rdi
callq 0x8310
movq %r14, %rdi
callq 0x21f0
// File: /workspace/github_cpp_makefile_star2_O1/yukimasano[P]cpp_matrix/Matrix.cpp
// Function: operator+(Matrix const&, Matrix const&)
Matrix operator+(const Matrix& A, const Matrix& B)
{
	assert(A.mShape[1] == B.mShape[1] && A.mShape[0] == B.mShape[0]);
	Matrix W(A.mShape[0], A.mShape[1]);
  	W.mData=new double* [W.mShape[0]];
  	for (int i=0; i<W.mShape[0];  i++){
  		W.mData[i] = new double[W.mShape[1]];
  		for (int j=0; j<W.mShape[1]; j++){
  			W.mData[i][j] = A.mData[i][j]+ B.mData[i][j];
  		}
  	}
  return W;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %rdx, %r12
movl 0xc(%rsi), %edx
cmpl 0xc(%r12), %edx
jne 0x3368
movq %rsi, %r13
movl 0x8(%rsi), %esi
cmpl 0x8(%r12), %esi
jne 0x3368
movq %rdi, %rbx
callq 0x2eb8
movslq 0x8(%rbx), %rbp
leaq (,%rbp,8), %rax
testq %rbp, %rbp
movq $-0x1, %rdi
cmovnsq %rax, %rdi
movq %rbx, 0x8(%rsp)
callq 0x2030
movq %rax, %r14
movq %rax, (%rbx)
testl %ebp, %ebp
jle 0x3354
movq 0x8(%rsp), %rax
movslq 0xc(%rax), %rax
leaq (,%rax,8), %rcx
testq %rax, %rax
movq $-0x1, %r15
cmovnsq %rcx, %r15
movq (%r13), %rcx
movq %rcx, 0x10(%rsp)
movq (%r12), %r12
movl %eax, %ebx
xorl %r13d, %r13d
movq %r15, %rdi
callq 0x2030
movq %rax, (%r14,%r13,8)
testl %ebx, %ebx
jle 0x334c
movq 0x10(%rsp), %rcx
movq (%rcx,%r13,8), %rcx
movq (%r12,%r13,8), %rdx
xorl %esi, %esi
movsd (%rcx,%rsi,8), %xmm0
addsd (%rdx,%rsi,8), %xmm0
movsd %xmm0, (%rax,%rsi,8)
incq %rsi
cmpq %rsi, %rbx
jne 0x3335
incq %r13
cmpq %rbp, %r13
jne 0x3316
movq 0x8(%rsp), %rax
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
leaq 0x6da9(%rip), %rdi      # 0xa118
leaq 0x6ddb(%rip), %rsi      # 0xa151
leaq 0x6ddf(%rip), %rcx      # 0xa15c
movl $0x5f, %edx
callq 0x20b0
jmp 0x3389
movq %rax, %r14
movq 0x8(%rsp), %rdi
callq 0x2f4c
movq %r14, %rdi
callq 0x21f0
// File: /workspace/github_cpp_makefile_star2_O1/yukimasano[P]cpp_matrix/Matrix.cpp
// Function: operator+(Matrix const&, double)
Matrix operator+(const Matrix& A, const double k)
{
	Matrix W(A.mShape[0], A.mShape[1]);
  	W.mData=new double* [W.mShape[0]];
  	for (int i=0; i<W.mShape[0];  i++){
  		W.mData[i] = new double[W.mShape[1]];
  		for (int j=0; j<W.mShape[1]; j++){
  			W.mData[i][j] = A.mData[i][j]+ k;
  		}
  	}
  return W;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movsd %xmm0, 0x10(%rsp)
movq %rsi, %r12
movq %rdi, %rbx
movl 0x8(%rsi), %esi
movl 0xc(%r12), %edx
callq 0x2eb8
movslq 0x8(%rbx), %r13
leaq (,%r13,8), %rax
testq %r13, %r13
movq $-0x1, %rdi
cmovnsq %rax, %rdi
movq %rbx, 0x8(%rsp)
callq 0x2030
movq %rax, %r14
movq %rax, (%rbx)
testl %r13d, %r13d
jle 0x3455
movq 0x8(%rsp), %rax
movslq 0xc(%rax), %rax
leaq (,%rax,8), %rcx
testq %rax, %rax
movq $-0x1, %r15
cmovnsq %rcx, %r15
movq (%r12), %r12
movl %eax, %ebp
xorl %ebx, %ebx
movq %r15, %rdi
callq 0x2030
movq %rax, (%r14,%rbx,8)
testl %ebp, %ebp
movsd 0x10(%rsp), %xmm1
jle 0x344d
movq (%r12,%rbx,8), %rcx
xorl %edx, %edx
movsd (%rcx,%rdx,8), %xmm0
addsd %xmm1, %xmm0
movsd %xmm0, (%rax,%rdx,8)
incq %rdx
cmpq %rdx, %rbp
jne 0x3437
incq %rbx
cmpq %r13, %rbx
jne 0x341b
movq 0x8(%rsp), %rax
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
jmp 0x346b
movq %rax, %r14
movq 0x8(%rsp), %rdi
callq 0x2f4c
movq %r14, %rdi
callq 0x21f0
// File: /workspace/github_cpp_makefile_star2_O1/yukimasano[P]cpp_matrix/Matrix.cpp
// Function: Matrix::operator=(Matrix const&)
Matrix& Matrix::operator=(const Matrix& A)
{
  if (A.mShape[0] != mShape[0] || A.mShape[1] != mShape[1])
    {
      throw Exception("size mismatch",
		  "matrix assignment operator - matrices have different lengths");
    }
  else
    {
	  for (int i=0; i<mShape[0];  i++){
	  		mData[i] = new double[mShape[1]];
	  		for (int j=0; j<mShape[1]; j++){
	  			mData[i][j] = A.mData[i][j];
	  		}
	  }
  }
  return *this;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x48, %rsp
movl 0x8(%rdi), %r12d
cmpl %r12d, 0x8(%rsi)
jne 0x3641
movq %rdi, %rbx
movslq 0xc(%rdi), %r13
cmpl %r13d, 0xc(%rsi)
jne 0x3641
movq %rsi, (%rsp)
testl %r12d, %r12d
jle 0x362f
movq %r13, %rax
shlq $0x3, %rax
testl %r13d, %r13d
movq $-0x1, %r15
cmovnsq %rax, %r15
movl %r13d, %ebp
xorl %r14d, %r14d
movq %r15, %rdi
callq 0x2030
movq (%rbx), %rcx
movq %rax, (%rcx,%r14,8)
testl %r13d, %r13d
jle 0x3627
movq (%rsp), %rax
movq (%rax), %rax
movq (%rax,%r14,8), %rax
movq (%rbx), %rcx
movq (%rcx,%r14,8), %rcx
xorl %edx, %edx
movsd (%rax,%rdx,8), %xmm0
movsd %xmm0, (%rcx,%rdx,8)
incq %rdx
cmpq %rdx, %rbp
jne 0x3615
incq %r14
cmpq %r12, %r14
jne 0x35ed
movq %rbx, %rax
addq $0x48, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movl $0x40, %edi
callq 0x2080
movq %rax, %rbx
leaq 0x38(%rsp), %r15
movq %r15, -0x10(%r15)
leaq 0x6b60(%rip), %rsi      # 0xa1be
leaq 0x6b66(%rip), %rdx      # 0xa1cb
leaq 0x28(%rsp), %rdi
callq 0x81d6
leaq 0x18(%rsp), %r12
movq %r12, -0x10(%r12)
leaq 0x6b4c(%rip), %rsi      # 0xa1cc
leaq 0x6b81(%rip), %rdx      # 0xa208
leaq 0x8(%rsp), %rdi
callq 0x81d6
movb $0x1, %bpl
leaq 0x28(%rsp), %rsi
leaq 0x8(%rsp), %rdx
movq %rbx, %rdi
callq 0x8f64
xorl %ebp, %ebp
leaq 0xa6e9(%rip), %rsi      # 0xdd98
leaq 0x4af6(%rip), %rdx      # 0x81ac
movq %rbx, %rdi
callq 0x21c0
movq %rax, %r14
movq 0x8(%rsp), %rdi
cmpq %r12, %rdi
je 0x36d8
callq 0x2140
jmp 0x36d8
movq %rax, %r14
movb $0x1, %bpl
movq 0x28(%rsp), %rdi
cmpq %r15, %rdi
je 0x36ef
callq 0x2140
jmp 0x36ef
movq %rax, %r14
movb $0x1, %bpl
testb %bpl, %bpl
je 0x36fc
movq %rbx, %rdi
callq 0x20f0
movq %r14, %rdi
callq 0x21f0
// File: /workspace/github_cpp_makefile_star2_O1/yukimasano[P]cpp_matrix/Matrix.cpp
// Function: operator-(Matrix const&)
Matrix operator-(const Matrix& C)
{
	Matrix W(C.mShape[0],C.mShape[1]);
	W.mData=new double* [W.mShape[0]];
	for (int i=0; i<W.mShape[0];  i++){
		W.mData[i] = new double[W.mShape[1]];
		for (int j=0; j<W.mShape[1]; j++){
			W.mData[i][j] = -C.mData[i][j];
		}
	}
	return W;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rsi, %r12
movq %rdi, %rbx
movl 0x8(%rsi), %esi
movl 0xc(%r12), %edx
callq 0x2eb8
movslq 0x8(%rbx), %r13
leaq (,%r13,8), %rax
testq %r13, %r13
movq $-0x1, %rdi
cmovnsq %rax, %rdi
movq %rbx, (%rsp)
callq 0x2030
movq %rax, %r14
movq %rax, (%rbx)
testl %r13d, %r13d
jle 0x37af
movq (%rsp), %rax
movslq 0xc(%rax), %rax
leaq (,%rax,8), %rcx
testq %rax, %rax
movq $-0x1, %r15
cmovnsq %rcx, %r15
movq (%r12), %r12
movl %eax, %ebp
xorl %ebx, %ebx
movq %r15, %rdi
callq 0x2030
movq %rax, (%r14,%rbx,8)
testl %ebp, %ebp
movaps 0x68d5(%rip), %xmm1     # 0xa060
jle 0x37a7
movq (%r12,%rbx,8), %rcx
xorl %edx, %edx
movsd (%rcx,%rdx,8), %xmm0
xorps %xmm1, %xmm0
movlps %xmm0, (%rax,%rdx,8)
incq %rdx
cmpq %rdx, %rbp
jne 0x3793
incq %rbx
cmpq %r13, %rbx
jne 0x3776
movq (%rsp), %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
jmp 0x37c4
movq %rax, %r14
movq (%rsp), %rdi
callq 0x2f4c
movq %r14, %rdi
callq 0x21f0
// File: /workspace/github_cpp_makefile_star2_O1/yukimasano[P]cpp_matrix/Matrix.cpp
// Function: operator*(Matrix&, Matrix&)
Matrix operator*(Matrix& A, Matrix& B){
	assert(A.mShape[1] == B.mShape[0]);
	Matrix C(A.mShape[0],B.mShape[1]);
	//std::cout<<C<<std::endl;
  Matrix AT = A.T();
	for (int i=0; i<A.mShape[0];  i++){
		for (int j=0; j<B.mShape[1]; j++){
		//	C.mData[i][j] = s_prod(A.get_col(i+1), B.T().get_col(j+1), A.mShape[0]);
			C.set_val(i+1,j+1 , (AT.get_col(i+1) * B.get_col(j+1)));
		}
	}
	return C;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x48, %rsp
movl 0xc(%rsi), %eax
cmpl 0x8(%rdx), %eax
jne 0x38cc
movq %rdx, %r14
movq %rsi, %rbx
movl 0x8(%rsi), %esi
movl 0xc(%rdx), %edx
movq %rdi, (%rsp)
callq 0x2eb8
leaq 0x18(%rsp), %rdi
movq %rbx, %rsi
callq 0x3140
movq %rbx, 0x8(%rsp)
cmpl $0x0, 0x8(%rbx)
jle 0x38af
movq (%rsp), %rax
movq (%rax), %rax
movq %rax, 0x10(%rsp)
xorl %r13d, %r13d
leaq 0x38(%rsp), %r12
leaq 0x28(%rsp), %rbp
cmpl $0x0, 0xc(%r14)
jle 0x389e
leal 0x1(%r13), %ebx
xorl %r15d, %r15d
movq %r12, %rdi
leaq 0x18(%rsp), %rsi
movl %ebx, %edx
callq 0x31a8
leal 0x1(%r15), %edx
movq %rbp, %rdi
movq %r14, %rsi
callq 0x31a8
movq %r12, %rdi
movq %rbp, %rsi
callq 0x8673
movq 0x10(%rsp), %rax
movq (%rax,%r13,8), %rax
movsd %xmm0, (%rax,%r15,8)
incq %r15
movq %rbp, %rdi
callq 0x8310
movq %r12, %rdi
callq 0x8310
movslq 0xc(%r14), %rax
cmpq %rax, %r15
jl 0x384a
incq %r13
movq 0x8(%rsp), %rax
movslq 0x8(%rax), %rax
cmpq %rax, %r13
jl 0x383c
leaq 0x18(%rsp), %rdi
callq 0x2f4c
movq (%rsp), %rax
addq $0x48, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
leaq 0x6936(%rip), %rdi      # 0xa209
leaq 0x6877(%rip), %rsi      # 0xa151
leaq 0x6943(%rip), %rcx      # 0xa224
movl $0xaa, %edx
callq 0x20b0
movq %rax, %rbx
jmp 0x391b
movq %rax, %rbx
jmp 0x3907
movq %rax, %rbx
jmp 0x3911
movq %rax, %rbx
leaq 0x28(%rsp), %rdi
callq 0x8310
leaq 0x38(%rsp), %rdi
callq 0x8310
leaq 0x18(%rsp), %rdi
callq 0x2f4c
movq (%rsp), %rdi
callq 0x2f4c
movq %rbx, %rdi
callq 0x21f0
// File: /workspace/github_cpp_makefile_star2_O1/yukimasano[P]cpp_matrix/Matrix.cpp
// Function: operator*(Matrix&, Vector&)
Vector operator*(Matrix& A, Vector& b){
	assert(nrows(A) == length(b));
	int k = length(b);
	Vector v(k);
	for (int i=1; i<=k;  i++){
		v.set_val(i, A.get_row(i)*b);
	}
	return v;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %rdx, %r14
movq %rsi, %r15
movq %rdi, %rbx
movl 0x8(%rsi), %ebp
movq %rdx, %rdi
callq 0x8df7
cmpl %eax, %ebp
jne 0x39db
movq %r14, %rdi
callq 0x8df7
movl %eax, %r12d
movq %rbx, %rdi
movl %eax, %esi
callq 0x8268
testl %r12d, %r12d
jle 0x39c9
negl %r12d
movl $0x1, %ebp
leaq 0x8(%rsp), %r13
movq %r13, %rdi
movq %r15, %rsi
movl %ebp, %edx
callq 0x3214
movq %r13, %rdi
movq %r14, %rsi
callq 0x8673
movq %rbx, %rdi
movl %ebp, %esi
callq 0x8ef8
movq %r13, %rdi
callq 0x8310
leal (%r12,%rbp), %eax
incl %eax
movl %ebp, %ecx
incl %ecx
movl %ecx, %ebp
cmpl $0x1, %eax
jne 0x398e
movq %rbx, %rax
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
leaq 0x6867(%rip), %rdi      # 0xa249
leaq 0x6768(%rip), %rsi      # 0xa151
leaq 0x686f(%rip), %rcx      # 0xa25f
movl $0xb8, %edx
callq 0x20b0
movq %rax, %r14
jmp 0x3a0c
movq %rax, %r14
leaq 0x8(%rsp), %rdi
callq 0x8310
movq %rbx, %rdi
callq 0x8310
movq %r14, %rdi
callq 0x21f0
// File: /workspace/github_cpp_makefile_star2_O1/yukimasano[P]cpp_matrix/Matrix.cpp
// Function: operator*(Matrix const&, double const&)
Matrix operator*(const Matrix& A, const double& a)
{
	Matrix C(A.mShape[0],A.mShape[1]);
	for (int i=0; i<A.mShape[0];  i++){
		for (int j=0; j<A.mShape[1]; j++){
			C.mData[i][j] = a*A.mData[i][j];
		}
	}
	return C;
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rdx, %rbx
movq %rsi, %r15
movq %rdi, %r14
movl 0x8(%rsi), %esi
movl 0xc(%r15), %edx
callq 0x2eb8
movslq 0x8(%r15), %rax
testq %rax, %rax
jle 0x3a7a
movl 0xc(%r15), %ecx
movq (%r15), %rdx
movq (%r14), %rsi
xorl %edi, %edi
testl %ecx, %ecx
jle 0x3a72
movq (%rdx,%rdi,8), %r8
movq (%rsi,%rdi,8), %r9
xorl %r10d, %r10d
movsd (%rbx), %xmm0
mulsd (%r8,%r10,8), %xmm0
movsd %xmm0, (%r9,%r10,8)
incq %r10
cmpq %r10, %rcx
jne 0x3a5a
incq %rdi
cmpq %rax, %rdi
jne 0x3a4b
movq %r14, %rax
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_cpp_makefile_star2_O1/yukimasano[P]cpp_matrix/Matrix.cpp
// Function: operator/(double const&, Matrix const&)
Matrix operator/(const double& a,const Matrix& A)
{
	Matrix C(A.mShape[0],A.mShape[1]);
	for (int i=0; i<A.mShape[0];  i++){
		for (int j=0; j<A.mShape[1]; j++){
      if (A.mData[i][j]!=0){
			     C.mData[i][j] = a/A.mData[i][j];
      }
		}
	}
	return C;
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rdx, %r15
movq %rsi, %r14
movq %rdi, %rbx
movl 0x8(%rdx), %esi
movl 0xc(%rdx), %edx
callq 0x2eb8
movslq 0x8(%r15), %rax
testq %rax, %rax
jle 0x3af1
movl 0xc(%r15), %ecx
movq (%r15), %rdx
movq (%rbx), %rsi
xorl %edi, %edi
xorpd %xmm0, %xmm0
testl %ecx, %ecx
jle 0x3ae9
movq (%rdx,%rdi,8), %r8
xorl %r9d, %r9d
movsd (%r8,%r9,8), %xmm1
ucomisd %xmm0, %xmm1
jne 0x3ace
jnp 0x3ae1
movsd (%r14), %xmm2
divsd %xmm1, %xmm2
movq (%rsi,%rdi,8), %r10
movsd %xmm2, (%r10,%r9,8)
incq %r9
cmpq %r9, %rcx
jne 0x3ac0
incq %rdi
cmpq %rax, %rdi
jne 0x3ab5
movq %rbx, %rax
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_cpp_makefile_star2_O1/yukimasano[P]cpp_matrix/Matrix.cpp
// Function: operator*(double const&, Matrix const&)
Matrix operator*(const double& a, const Matrix& A)
{
	Matrix C(A.mShape[0],A.mShape[1]);
	for (int i=0; i<A.mShape[0];  i++){
		for (int j=0; j<A.mShape[1]; j++){
			C.mData[i][j] = a*A.mData[i][j];
		}
	}
	return C;
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rdx, %r15
movq %rsi, %r14
movq %rdi, %rbx
movl 0x8(%rdx), %esi
movl 0xc(%rdx), %edx
callq 0x2eb8
movslq 0x8(%r15), %rax
testq %rax, %rax
jle 0x3b58
movl 0xc(%r15), %ecx
movq (%r15), %rdx
movq (%rbx), %rsi
xorl %edi, %edi
testl %ecx, %ecx
jle 0x3b50
movq (%rdx,%rdi,8), %r8
movq (%rsi,%rdi,8), %r9
xorl %r10d, %r10d
movsd (%r14), %xmm0
mulsd (%r8,%r10,8), %xmm0
movsd %xmm0, (%r9,%r10,8)
incq %r10
cmpq %r10, %rcx
jne 0x3b37
incq %rdi
cmpq %rax, %rdi
jne 0x3b28
movq %rbx, %rax
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_cpp_makefile_star2_O1/yukimasano[P]cpp_matrix/Matrix.cpp
// Function: operator<<(std::ostream&, Matrix const&)
std::ostream& operator<<(std::ostream& output, const Matrix& C) {
  for (int i=0; i<C.mShape[0]; i++)
    {
	  output << "(";
	  for (int j=0; j<C.mShape[1]; j++)
	      {
		  output <<  C.mData[i][j];
		  if (j<C.mShape[1]-1)
			  output  << ",\t";
		  else
			  output  << "";
	      }
	  output <<")\n";
    }
  return output;  // for multiple << operators.
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rdi, %rbx
cmpl $0x0, 0x8(%rsi)
jle 0x3c14
movq %rsi, %r14
xorl %r15d, %r15d
leaq 0x66fe(%rip), %r12      # 0xa284
leaq 0x66f9(%rip), %r13      # 0xa286
movl $0x1, %edx
movq %rbx, %rdi
leaq 0x6af2(%rip), %rsi      # 0xa68e
callq 0x2160
cmpl $0x0, 0xc(%r14)
jle 0x3bf0
xorl %ebp, %ebp
movq (%r14), %rax
movq (%rax,%r15,8), %rax
movsd (%rax,%rbp,8), %xmm0
movq %rbx, %rdi
callq 0x21a0
movslq 0xc(%r14), %rax
decq %rax
cmpq %rax, %rbp
jge 0x3bd7
movl $0x2, %edx
movq %rbx, %rdi
movq %r12, %rsi
jmp 0x3bdf
movq %rbx, %rdi
movq %r13, %rsi
xorl %edx, %edx
callq 0x2160
incq %rbp
movslq 0xc(%r14), %rax
cmpq %rax, %rbp
jl 0x3baa
movl $0x2, %edx
movq %rbx, %rdi
leaq 0x6688(%rip), %rsi      # 0xa287
callq 0x2160
incq %r15
movslq 0x8(%r14), %rax
cmpq %rax, %r15
jl 0x3b8d
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O1/yukimasano[P]cpp_matrix/Matrix.cpp
// Function: diag(Matrix const&)
Matrix diag(const Matrix& A){
	Matrix C(A.mShape[0],A.mShape[1]);
	for (int i=0; i<A.mShape[0];  i++){
		C.mData[i][i] = A.mData[i][i];
	}
	return C;
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %r14
movq %rdi, %rbx
movl 0x8(%rsi), %esi
movl 0xc(%r14), %edx
callq 0x2eb8
movslq 0x8(%r14), %rax
testq %rax, %rax
jle 0x3c67
movq (%r14), %rcx
movq (%rbx), %rdx
xorl %esi, %esi
movq (%rcx,%rsi,8), %rdi
movsd (%rdi,%rsi,8), %xmm0
movq (%rdx,%rsi,8), %rdi
movsd %xmm0, (%rdi,%rsi,8)
incq %rsi
cmpq %rsi, %rax
jne 0x3c4d
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_cpp_makefile_star2_O1/yukimasano[P]cpp_matrix/Matrix.cpp
// Function: Matrix::diag()
Vector Matrix::diag(){
  Vector v(mShape[0]);
	if (mShape[0] <= mShape[1]){
		for (int i=0; i<mShape[0];  i++){
			v.set_val( i+1 , mData[i][i]);
		}
	}
	else {
		Vector v(mShape[1]);
		for (int i=0; i<mShape[1];  i++){
				v.set_val(i+1, mData[i][i]);
			}
		}
	return v;
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %rsi, %r14
movq %rdi, %rbx
movl 0x8(%rsi), %esi
callq 0x8268
movl 0xc(%r14), %esi
cmpl %esi, 0x8(%r14)
jle 0x3ccf
leaq 0x8(%rsp), %rdi
callq 0x8268
xorl %eax, %eax
leaq 0x8(%rsp), %r15
movslq 0xc(%r14), %rcx
cmpq %rcx, %rax
jge 0x3cfa
leaq 0x1(%rax), %r12
movq (%r14), %rcx
movq (%rcx,%rax,8), %rcx
movsd (%rcx,%rax,8), %xmm0
movq %r15, %rdi
movl %r12d, %esi
callq 0x8ef8
movq %r12, %rax
jmp 0x3ca6
xorl %eax, %eax
movslq 0x8(%r14), %rcx
cmpq %rcx, %rax
jge 0x3d04
leaq 0x1(%rax), %r15
movq (%r14), %rcx
movq (%rcx,%rax,8), %rcx
movsd (%rcx,%rax,8), %xmm0
movq %rbx, %rdi
movl %r15d, %esi
callq 0x8ef8
movq %r15, %rax
jmp 0x3cd1
leaq 0x8(%rsp), %rdi
callq 0x8310
movq %rbx, %rax
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
jmp 0x3d24
movq %rax, %r14
leaq 0x8(%rsp), %rdi
callq 0x8310
jmp 0x3d27
movq %rax, %r14
movq %rbx, %rdi
callq 0x8310
movq %r14, %rdi
callq 0x21f0
// File: /workspace/github_cpp_makefile_star2_O1/yukimasano[P]cpp_matrix/Matrix.cpp
// Function: diag(Vector&)
Matrix diag(Vector& v){
	int k =length(v);
	Matrix C(k,k);
	for (int i=1; i<=k; i++){
		C.set_val(i,i, v(i));
	}
	return C;
}

// Assembly:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
movq %rsi, %r14
movq %rdi, %rbx
movq %rsi, %rdi
callq 0x8df7
movl %eax, %r15d
movq %rbx, %rdi
movl %eax, %esi
movl %eax, %edx
callq 0x2eb8
testl %r15d, %r15d
jle 0x3d91
movq (%rbx), %r13
incl %r15d
movl $0x1, %r12d
movq %r14, %rdi
movl %r12d, %esi
callq 0x8b5a
movsd (%rax), %xmm0
movq -0x8(%r13,%r12,8), %rax
movsd %xmm0, -0x8(%rax,%r12,8)
incq %r12
cmpq %r12, %r15
jne 0x3d6e
movq %rbx, %rax
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
movq %rax, %r14
movq %rbx, %rdi
callq 0x2f4c
movq %r14, %rdi
callq 0x21f0
nop
// File: /workspace/github_cpp_makefile_star2_O1/yukimasano[P]cpp_matrix/Matrix.cpp
// Function: Matrix::Matrix(Matrix const&)
Matrix::Matrix(const Matrix& C){
	mShape[0]=C.mShape[0];
	mData=new double* [C.mShape[0]];
	mShape[1]=C.mShape[1];
	for (int i=0; i<C.mShape[0];  i++){
		mData[i] = new double[C.mShape[1]];
			for (int j=0; j<C.mShape[1]; j++){
				mData[i][j] =  C.mData[i][j];
			}
	}
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq %rdi, %r14
movl 0x8(%rsi), %eax
movl %eax, 0x8(%rdi)
movslq 0x8(%rsi), %rax
leaq (,%rax,8), %rdi
testq %rax, %rax
movq $-0x1, %r13
cmovsq %r13, %rdi
callq 0x2030
movq %rax, (%r14)
movl 0xc(%rbx), %eax
movl %eax, 0xc(%r14)
movslq 0x8(%rbx), %r12
testq %r12, %r12
jle 0x3e51
movslq 0xc(%rbx), %rax
leaq (,%rax,8), %r15
testq %rax, %rax
cmovsq %r13, %r15
movl %eax, %r13d
xorl %ebp, %ebp
movq %r15, %rdi
callq 0x2030
movq (%r14), %rcx
movq %rax, (%rcx,%rbp,8)
testl %r13d, %r13d
jle 0x3e49
movq (%rbx), %rax
movq (%rax,%rbp,8), %rax
movq (%r14), %rcx
movq (%rcx,%rbp,8), %rcx
xorl %edx, %edx
movsd (%rax,%rdx,8), %xmm0
movsd %xmm0, (%rcx,%rdx,8)
incq %rdx
cmpq %rdx, %r13
jne 0x3e37
incq %rbp
cmpq %r12, %rbp
jne 0x3e13
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O1/yukimasano[P]cpp_matrix/Matrix.cpp
// Function: randm(Matrix&)
Matrix randm(Matrix& A){
	int m = nrows(A);
	//srand( (unsigned)time( NULL ) );
	for (int i=1; i<=m ; i++){
		for (int j=1; j<=m ; j++){
			A.set_val(i,j, (float)rand()/RAND_MAX);
		}
	}
	return A;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rsi, %r14
movq %rdi, %rbx
movl 0x8(%rsi), %r15d
testl %r15d, %r15d
jle 0x3ec4
incq %r15
movl %r15d, %r12d
decq %r12
movl $0x1, %r13d
xorl %ebp, %ebp
callq 0x2060
movss 0x61d8(%rip), %xmm1     # 0xa070
xorps %xmm0, %xmm0
cvtsi2ss %eax, %xmm0
mulss %xmm1, %xmm0
cvtss2sd %xmm0, %xmm0
movq (%r14), %rax
movq -0x8(%rax,%r13,8), %rax
movsd %xmm0, (%rax,%rbp,8)
incq %rbp
cmpq %rbp, %r12
jne 0x3e8b
incq %r13
cmpq %r15, %r13
jne 0x3e89
movq %rbx, %rdi
movq %r14, %rsi
callq 0x3db2
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O1/yukimasano[P]cpp_matrix/Matrix.cpp
// Function: er_graph(Matrix&, float)
Matrix er_graph(Matrix& A,float p){
  assert(nrows(A)==ncols(A));
	int s = nrows(A);
	//srand( (unsigned)time( NULL ) );
	for (int i=1; i<=s ; i++){
		for (int j=1; j<=i ; j++){
			A.set_val(i,j, p>(float)rand()/RAND_MAX);
      A.set_val(j,i, p>(float)rand()/RAND_MAX);
		}
	}
	return A;
}

// Assembly:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x10, %rsp
movss %xmm0, 0xc(%rsp)
movl 0x8(%rsi), %r15d
cmpl 0xc(%rsi), %r15d
jne 0x44ee
movq %rsi, %r14
movq %rdi, %rbx
testl %r15d, %r15d
jle 0x44d2
incq %r15
movl $0x1, %r12d
xorl %r13d, %r13d
callq 0x2060
xorps %xmm0, %xmm0
cvtsi2ss %eax, %xmm0
mulss 0x5c0e(%rip), %xmm0     # 0xa070
movss 0xc(%rsp), %xmm1
ucomiss %xmm0, %xmm1
movsd 0x5ba5(%rip), %xmm0     # 0xa018
ja 0x4478
xorps %xmm0, %xmm0
movq (%r14), %rax
movq -0x8(%rax,%r12,8), %rax
movsd %xmm0, (%rax,%r13,8)
callq 0x2060
xorps %xmm0, %xmm0
cvtsi2ss %eax, %xmm0
mulss 0x5bd6(%rip), %xmm0     # 0xa070
movss 0xc(%rsp), %xmm1
ucomiss %xmm0, %xmm1
movsd 0x5b6d(%rip), %xmm0     # 0xa018
ja 0x44b0
xorps %xmm0, %xmm0
movq (%r14), %rax
movq (%rax,%r13,8), %rax
movsd %xmm0, -0x8(%rax,%r12,8)
incq %r13
cmpq %r13, %r12
jne 0x444e
incq %r12
cmpq %r15, %r12
jne 0x444b
movq %rbx, %rdi
movq %r14, %rsi
callq 0x3db2
movq %rbx, %rax
addq $0x10, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
leaq 0x5d95(%rip), %rdi      # 0xa28a
leaq 0x5c55(%rip), %rsi      # 0xa151
leaq 0x5ddb(%rip), %rcx      # 0xa2de
movl $0x16e, %edx            # imm = 0x16E
callq 0x20b0