LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_cpp_makefile_star2_O2/theuni[P]libbtcnet/src/bareproxy.cpp
// Function: CBareProxy::write_auth(bufferevent*, CProxyAuth const&)
bool CBareProxy::write_auth(bufferevent* bev, const CProxyAuth& auth)
{
    const std::string& username = auth.GetUsername();
    const std::string& password = auth.GetPassword();
    // Perform username/password authentication (as described in RFC1929)
    std::vector<uint8_t> vAuth;
    vAuth.push_back(0x01);
    if (username.size() > 255 || password.size() > 255)
        return false;
    vAuth.push_back(username.size());
    vAuth.insert(vAuth.end(), username.begin(), username.end());
    vAuth.push_back(password.size());
    vAuth.insert(vAuth.end(), password.begin(), password.end());
    bufferevent_setwatermark(bev, EV_READ, 2, 0);
    bufferevent_write(bev, &vAuth[0], vAuth.size());
    return true;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
subq $0x28, %rsp
movq %rsi, %r14
movq %rdi, %rbx
movq %rsi, %rdi
callq 0x58a2
movq %rax, %r15
movq %r14, %rdi
callq 0x58a6
movq %rax, %r14
leaq 0x10(%rsp), %rdi
andq $0x0, 0x10(%rdi)
xorps %xmm0, %xmm0
movaps %xmm0, (%rdi)
leaq 0xf(%rsp), %rsi
movb $0x1, (%rsi)
callq 0x73f2
movq 0x8(%r15), %rax
cmpq $0xff, %rax
ja 0xe195
cmpq $0xff, 0x8(%r14)
jbe 0xe199
xorl %ebp, %ebp
jmp 0xe217
leaq 0xf(%rsp), %rsi
movb %al, (%rsi)
leaq 0x10(%rsp), %rdi
callq 0x73f2
leaq 0x10(%rsp), %rdi
movq 0x8(%rdi), %rsi
movq (%r15), %rdx
movq 0x8(%r15), %rcx
addq %rdx, %rcx
callq 0xe6ec
movb 0x8(%r14), %al
leaq 0xf(%rsp), %rsi
movb %al, (%rsi)
leaq 0x10(%rsp), %rdi
callq 0x73f2
leaq 0x10(%rsp), %rdi
movq 0x8(%rdi), %rsi
movq (%r14), %rdx
movq 0x8(%r14), %rcx
addq %rdx, %rcx
callq 0xe6ec
pushq $0x2
popq %rsi
pushq $0x2
popq %rdx
movq %rbx, %rdi
xorl %ecx, %ecx
callq 0x40c0
movq 0x10(%rsp), %rsi
movq 0x18(%rsp), %rdx
subq %rsi, %rdx
movb $0x1, %bpl
movq %rbx, %rdi
callq 0x41f0
leaq 0x10(%rsp), %rdi
callq 0x4fd0
movl %ebp, %eax
addq $0x28, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
jmp 0xe238
jmp 0xe238
jmp 0xe238
jmp 0xe238
jmp 0xe238
movq %rax, %rbx
leaq 0x10(%rsp), %rdi
callq 0x4fd0
movq %rbx, %rdi
callq 0x4660
nop
// File: /workspace/github_cpp_makefile_star2_O2/theuni[P]libbtcnet/src/bareproxy.cpp
// Function: CBareProxy::check_auth_response(bufferevent*, void*)
void CBareProxy::check_auth_response(bufferevent* bev, void* ctx)
{
    CBareProxy* data = static_cast<CBareProxy*>(ctx);
    const CConnection& conn(data->m_proxy_connection);
    char pchRetA[2];

    if (bufferevent_read(bev, pchRetA, sizeof(pchRetA)) != sizeof(pchRetA)) {
        data->ProxyFailure(0);
        return;
    }

    if (pchRetA[0] != 0x01 && pchRetA[1] != 0x00) {
        data->ProxyFailure(0);
        return;
    }

    bufferevent_setcb(bev, read_final, nullptr, event_cb, ctx);

    if (!writeproto(bev, conn)) {
        data->ProxyFailure(0);
        return;
    }
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
subq $0x10, %rsp
movq %rsi, %rbx
movq %rdi, %r15
movq 0x8(%rsi), %r14
leaq 0xe(%rsp), %rsi
pushq $0x2
popq %rdx
callq 0x4720
cmpq $0x2, %rax
jne 0xe6d8
cmpb $0x1, 0xe(%rsp)
je 0xe6ae
cmpb $0x0, 0xf(%rsp)
jne 0xe6d8
leaq -0x467(%rip), %rsi      # 0xe24e
leaq -0x95e(%rip), %rcx      # 0xdd5e
movq %r15, %rdi
xorl %edx, %edx
movq %rbx, %r8
callq 0x4370
movq %r15, %rdi
movq %r14, %rsi
callq 0xdd98
testb %al, %al
jne 0xe6e2
movq %rbx, %rdi
xorl %esi, %esi
callq 0xdd70
addq $0x10, %rsp
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_cpp_makefile_star2_O2/theuni[P]libbtcnet/src/listener.cpp
// Function: CConnListener::listen_error_cb(evconnlistener*, void*)
void CConnListener::listen_error_cb(evconnlistener* /*unused*/, void* ctx)
{
    assert(ctx != nullptr);
    CConnListener* bind = static_cast<CConnListener*>(ctx);
    bind->m_listener.free();
    bind->m_handler.OnListenFailure(bind->m_id, bind->m_connection);
}

// Assembly:
pushq %rbx
testq %rsi, %rsi
je 0xee1b
movq %rsi, %rbx
leaq 0x190(%rsi), %rdi
callq 0xee70
movq (%rbx), %rdi
movq 0x10(%rbx), %rsi
addq $0x18, %rbx
movq %rbx, %rdx
popq %rbx
jmp 0x8552
leaq 0x2728(%rip), %rdi      # 0x1154a
leaq 0x32a5(%rip), %rsi      # 0x120ce
leaq 0x331d(%rip), %rcx      # 0x1214d
pushq $0x44
popq %rdx
callq 0x4260
// File: /workspace/github_cpp_makefile_star2_O2/theuni[P]libbtcnet/src/resolveonly.cpp
// Function: CResolveOnly::OnResolveSuccess(CDNSResponse&&)
void CResolveOnly::OnResolveSuccess(CDNSResponse&& response)
{
    m_request.reset(nullptr);
    std::list<CConnection> connections;
    for (auto it = response.begin(); it != response.end(); ++it)
        connections.emplace_back(m_connection.GetOptions(), m_connection.GetNetConfig(), it->ai_addr, it->ai_addrlen);
    m_retries = m_connection.GetOptions().nRetries;
    m_handler.OnResolveComplete(m_id, m_connection, std::move(connections));
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x48, %rsp
movq %rdi, %rbx
andq $0x0, 0x190(%rdi)
movq %rsi, %r12
movq %rsp, %rax
movq %rax, 0x8(%rax)
movq %rax, (%rax)
andq $0x0, 0x10(%rax)
movq %rsi, %rdi
callq 0xa910
leaq 0x40(%rsp), %r13
movq %rax, (%r13)
movq %rbx, 0x30(%rsp)
addq $0x10, %rbx
movq %r12, %rdi
callq 0xa914
movq %rax, 0x38(%rsp)
movq %r13, %rdi
leaq 0x38(%rsp), %rsi
callq 0xa8d4
testb %al, %al
je 0xf21a
movq %rbx, %rdi
callq 0x63e8
movq %rax, %r14
movq %rbx, %rdi
callq 0x63f0
movq %rax, %r15
movq %r13, %rdi
callq 0xa8a2
movq %rax, %rbp
movq %r13, %rdi
callq 0xa8a2
addq $0x18, %rbp
addq $0x10, %rax
movq %rsp, %rdi
movq %r14, %rsi
movq %r15, %rdx
movq %rbp, %rcx
movq %rax, %r8
callq 0xf334
movq %r13, %rdi
callq 0xa842
jmp 0xf1ad
movq %rbx, %rdi
callq 0x63e8
movl 0x8(%rax), %eax
movq 0x30(%rsp), %rcx
movl %eax, 0x188(%rcx)
movq 0x8(%rcx), %rsi
movq 0x198(%rcx), %rdi
movq (%rsp), %rax
movq 0x8(%rsp), %rcx
movq %rax, 0x18(%rsp)
movq %rcx, 0x20(%rsp)
movq 0x10(%rsp), %rdx
movq %rdx, 0x28(%rsp)
movq %rsp, %r8
cmpq %r8, %rax
je 0xf27d
leaq 0x18(%rsp), %rdx
movq %rdx, (%rcx)
movq %rdx, 0x8(%rax)
movq %r8, 0x8(%rsp)
movq %r8, (%rsp)
andq $0x0, 0x10(%rsp)
jmp 0xf289
leaq 0x18(%rsp), %rax
movq %rax, 0x8(%rax)
movq %rax, (%rax)
leaq 0x18(%rsp), %rcx
movq %rbx, %rdx
callq 0x8046
leaq 0x18(%rsp), %rdi
callq 0x4cf2
movq %rsp, %rdi
callq 0x4cf2
addq $0x48, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
leaq 0x18(%rsp), %rdi
callq 0x4cf2
jmp 0xf2cf
jmp 0xf2cc
jmp 0xf2cc
jmp 0xf2cc
movq %rax, %rbx
movq %rsp, %rdi
callq 0x4cf2
movq %rbx, %rdi
callq 0x4660
nop
// File: /workspace/github_cpp_makefile_star2_O2/iZhangHui[P]CppPrimer/CH12_DynamicMemory/exercises/ex12_02_test.cc
// Function: main
int main(int argc, char const *argv[])
{
	StrBlob sb = { "Hello", "C++ Primer" };

	std::cout << sb.front() << " " << sb.back() << std::endl;
	sb.back() = "C++ Primer 5th";
	std::cout << sb.front() << " " << sb.back() << std::endl;

	const StrBlob csb = { "StrBlob", "Test" };
	std::cout << csb.front() << " " << csb.back() << std::endl;
	// csb.back() = "error";
	// std::cout << csb.front() << " " << csb.back() << std::endl;

	return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
subq $0x70, %rsp
leaq 0xd06(%rip), %rsi       # 0x3004
leaq -0x78(%rbp), %rdi
leaq -0x38(%rbp), %rdx
callq 0x2050
leaq -0x58(%rbp), %rdi
leaq 0xcf4(%rip), %rsi       # 0x300a
leaq -0x11(%rbp), %rdx
callq 0x2050
leaq -0x28(%rbp), %rdi
leaq -0x78(%rbp), %rsi
pushq $0x2
popq %rdx
callq 0x2528
pushq $0x20
popq %rbx
leaq (%rbx,%rbp), %rdi
addq $-0x78, %rdi
callq 0x2070
addq $-0x20, %rbx
cmpq $-0x20, %rbx
jne 0x2332
leaq -0x28(%rbp), %rdi
callq 0x254a
movq 0x2c6f(%rip), %rdi      # 0x4fc8
movq %rax, %rsi
callq 0x20e0
leaq 0xcad(%rip), %rsi       # 0x3015
movq %rax, %rdi
callq 0x20f0
movq %rax, %rbx
leaq -0x28(%rbp), %rdi
callq 0x25a8
movq %rbx, %rdi
movq %rax, %rsi
callq 0x20e0
movq %rax, %rdi
callq 0x2080
leaq -0x28(%rbp), %rdi
callq 0x25a8
leaq 0xc78(%rip), %rsi       # 0x3017
movq %rax, %rdi
callq 0x21a0
leaq -0x28(%rbp), %rdi
callq 0x254a
movq 0x2c11(%rip), %rdi      # 0x4fc8
movq %rax, %rsi
callq 0x20e0
leaq 0xc4f(%rip), %rsi       # 0x3015
movq %rax, %rdi
callq 0x20f0
movq %rax, %rbx
leaq -0x28(%rbp), %rdi
callq 0x25a8
movq %rbx, %rdi
movq %rax, %rsi
callq 0x20e0
movq %rax, %rdi
callq 0x2080
leaq 0xc77(%rip), %rsi       # 0x306b
leaq -0x78(%rbp), %rdi
leaq -0x11(%rbp), %rdx
callq 0x2050
leaq -0x58(%rbp), %rdi
leaq 0xc1a(%rip), %rsi       # 0x3026
leaq -0x12(%rbp), %rdx
callq 0x2050
leaq -0x38(%rbp), %rdi
leaq -0x78(%rbp), %rsi
pushq $0x2
popq %rdx
callq 0x2528
pushq $0x20
popq %rbx
leaq (%rbx,%rbp), %rdi
addq $-0x78, %rdi
callq 0x2070
addq $-0x20, %rbx
cmpq $-0x20, %rbx
jne 0x2428
leaq -0x38(%rbp), %rdi
callq 0x260c
movq 0x2b79(%rip), %rdi      # 0x4fc8
movq %rax, %rsi
callq 0x20e0
leaq 0xbb7(%rip), %rsi       # 0x3015
movq %rax, %rdi
callq 0x20f0
movq %rax, %rbx
leaq -0x38(%rbp), %rdi
callq 0x266a
movq %rbx, %rdi
movq %rax, %rsi
callq 0x20e0
movq %rax, %rdi
callq 0x2080
leaq -0x30(%rbp), %rdi
callq 0x2b54
leaq -0x20(%rbp), %rdi
callq 0x2b54
xorl %eax, %eax
addq $0x70, %rsp
popq %rbx
popq %r14
popq %rbp
retq
movq %rax, %rbx
pushq $0x20
popq %r14
leaq (%r14,%rbp), %rdi
addq $-0x78, %rdi
callq 0x2070
addq $-0x20, %r14
cmpq $-0x20, %r14
jne 0x24a9
jmp 0x2516
movq %rax, %rbx
leaq -0x78(%rbp), %rdi
callq 0x2070
jmp 0x2516
jmp 0x2513
movq %rax, %rbx
pushq $0x20
popq %r14
leaq (%r14,%rbp), %rdi
addq $-0x78, %rdi
callq 0x2070
addq $-0x20, %r14
cmpq $-0x20, %r14
jne 0x24d9
jmp 0x251f
movq %rax, %rbx
leaq -0x78(%rbp), %rdi
callq 0x2070
jmp 0x251f
movq %rax, %rbx
jmp 0x251f
movq %rax, %rbx
leaq -0x30(%rbp), %rdi
callq 0x2b54
jmp 0x2516
movq %rax, %rbx
leaq -0x20(%rbp), %rdi
callq 0x2b54
movq %rbx, %rdi
callq 0x2190
nop
// File: /workspace/github_cpp_makefile_star2_O2/iZhangHui[P]CppPrimer/CH10_GenericAlgorithms/examples/ostreamIter2.cc
// Function: main
int main() {
	vector<int> vec;
	istream_iterator<int> in_iter(cin);  // read ints from cin
	istream_iterator<int> eof;           // istream ``end'' iterator
	
	while (in_iter != eof)
		vec.push_back(*in_iter++);
	ostream_iterator<int> out_iter(cout, " ");
	
	for (auto e : vec)
		out_iter = e;  // the assignment writes this element to cout
	cout << endl;

	return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x40, %rsp
xorps %xmm0, %xmm0
movaps %xmm0, -0x40(%rbp)
andq $0x0, -0x30(%rbp)
movq 0x2d62(%rip), %rsi      # 0x3fe0
leaq -0x60(%rbp), %rdi
callq 0x1336
leaq -0x48(%rbp), %rbx
leaq -0x50(%rbp), %r14
leaq -0x60(%rbp), %r15
leaq -0x40(%rbp), %r12
cmpb $0x0, -0x54(%rbp)
je 0x12b7
movq %r14, %rdi
movq %r15, %rsi
xorl %edx, %edx
callq 0x136e
movq %r12, %rdi
movq %rbx, %rsi
callq 0x1348
jmp 0x1297
movq 0x2d12(%rip), %rax      # 0x3fd0
leaq -0x50(%rbp), %rbx
movq %rax, (%rbx)
leaq 0xd38(%rip), %rax       # 0x2004
movq %rax, 0x8(%rbx)
movq -0x40(%rbp), %r15
movq -0x38(%rbp), %r12
leaq -0x24(%rbp), %r14
cmpq %r12, %r15
je 0x12f8
movl (%r15), %eax
movl %eax, -0x24(%rbp)
movq %rbx, %rdi
movq %r14, %rsi
callq 0x139c
addq $0x4, %r15
jmp 0x12dc
movq 0x2cd1(%rip), %rdi      # 0x3fd0
callq 0x1060
leaq -0x40(%rbp), %rdi
callq 0x13d8
xorl %eax, %eax
addq $0x40, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
jmp 0x1322
jmp 0x1322
jmp 0x1322
movq %rax, %rbx
leaq -0x40(%rbp), %rdi
callq 0x13d8
movq %rbx, %rdi
callq 0x1110
// File: /workspace/github_cpp_makefile_star2_O2/Couragewang[P]50_clss/TcpClient.cc
// Function: main
int main(int argc, char *argv[])
{
    if(argc != 3){
        Usage(argv[0]);
        exit(1);
    }
    std::string ip = argv[1];
    int port = atoi(argv[2]);
    TcpClient *cli = new TcpClient(ip, port);
    cli->InitClient();
    cli->Start();
    return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
subq $0x70, %rsp
movq %rsi, %rbx
cmpl $0x3, %edi
jne 0x404790
movq 0x8(%rbx), %rsi
leaq -0x38(%rbp), %rdi
leaq -0x11(%rbp), %rdx
callq 0x4047fc
movq 0x10(%rbx), %rdi
callq 0x4c0d40
movl %eax, %r14d
pushq $0x30
popq %rdi
callq 0x405760
movq %rax, %rbx
leaq -0x58(%rbp), %rdi
leaq -0x38(%rbp), %rsi
callq 0x476fa0
leaq -0x58(%rbp), %rsi
movq %rbx, %rdi
movl %r14d, %edx
callq 0x404838
leaq -0x58(%rbp), %rdi
callq 0x474810
movq %rbx, %rdi
callq 0x40485a
movq %rbx, %rdi
callq 0x4048a0
leaq -0x38(%rbp), %rdi
callq 0x474810
xorl %eax, %eax
addq $0x70, %rsp
popq %rbx
popq %r14
popq %rbp
retq
movq (%rbx), %rsi
leaq -0x78(%rbp), %rdi
leaq -0x38(%rbp), %rdx
callq 0x4047fc
leaq -0x78(%rbp), %rdi
callq 0x4046c8
leaq -0x78(%rbp), %rdi
callq 0x474810
pushq $0x1
popq %rdi
callq 0x4c18c0
movq %rax, %r14
leaq -0x78(%rbp), %rdi
jmp 0x4047ef
jmp 0x4047e3
movq %rax, %r14
leaq -0x58(%rbp), %rdi
callq 0x474810
jmp 0x4047d6
movq %rax, %r14
pushq $0x30
popq %rsi
movq %rbx, %rdi
callq 0x404a60
jmp 0x4047eb
movq %rax, %r14
jmp 0x4047f4
movq %rax, %r14
leaq -0x38(%rbp), %rdi
callq 0x474810
movq %r14, %rdi
callq 0x4a5ff0
// File: /workspace/github_cpp_makefile_star2_O2/Couragewang[P]50_clss/./TcpClient.hpp
// Function: TcpClient::InitClient()
void InitClient()
        {
            sock = socket(AF_INET, SOCK_STREAM, 0);
            if(sock < 0){
                std::cerr << "socket error" << std::endl;
                exit(2);
            }
        }

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %rbx
pushq %rax
movq %rdi, %rbx
pushq $0x2
popq %rdi
pushq $0x1
popq %rsi
xorl %edx, %edx
callq 0x52e860
movl %eax, (%rbx)
testl %eax, %eax
js 0x40487d
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
movq $0x5e4320, %rdi         # imm = 0x5E4320
leaq 0x172798(%rip), %rsi    # 0x577023
callq 0x46e440
movq %rax, %rdi
callq 0x46dd20
pushq $0x2
popq %rdi
callq 0x4c18c0
// File: /workspace/github_cpp_makefile_star2_O2/Couragewang[P]50_clss/./TcpClient.hpp
// Function: TcpClient::Start()
void Start()
        {
            struct sockaddr_in peer;
            bzero(&peer, sizeof(peer));
            peer.sin_family = AF_INET;
            peer.sin_port = htons(port);
            peer.sin_addr.s_addr = inet_addr(ip.c_str());

            if(connect(sock, (struct sockaddr*)&peer, sizeof(peer)) < 0){
                std::cerr << "connect error" << std::endl;
                exit(3);
            }
            char buf[1024];
            std::string in;
            while(1){
                std::cout << "Please Enter# ";
                std::cin >> in;
                write(sock, in.c_str(), in.size());
                ssize_t s = read(sock, buf, sizeof(buf)-1);
                if(s > 0){
                    buf[s] = 0;
                    std::cout << "Server Echo# " << buf << std::endl;
                }
            }
        }

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x438, %rsp            # imm = 0x438
leaq -0x58(%rbp), %r14
andq $0x0, 0x8(%r14)
movq %rdi, %rbx
movw $0x2, (%r14)
movzwl 0x28(%rdi), %eax
rolw $0x8, %ax
movw %ax, 0x2(%r14)
movq 0x8(%rdi), %rdi
callq 0x52f450
movl %eax, 0x4(%r14)
movl (%rbx), %edi
pushq $0x10
popq %rdx
movq %r14, %rsi
callq 0x52e7c0
testl %eax, %eax
jns 0x404914
movq $0x5e4320, %rdi         # imm = 0x5E4320
leaq 0x172731(%rip), %rsi    # 0x577030
callq 0x46e440
movq %rax, %rdi
callq 0x46dd20
pushq $0x3
popq %rdi
callq 0x4c18c0
leaq -0x38(%rbp), %rax
movq %rax, -0x10(%rax)
andq $0x0, -0x8(%rax)
movb $0x0, (%rax)
movq $0x5e4440, %r14         # imm = 0x5E4440
movq $0x5e4560, %r12         # imm = 0x5E4560
leaq -0x48(%rbp), %r13
leaq -0x460(%rbp), %r15
movq %r14, %rdi
leaq 0x1726f7(%rip), %rsi    # 0x57703e
callq 0x46e440
movq %r12, %rdi
movq %r13, %rsi
callq 0x406410
movl (%rbx), %edi
movq -0x48(%rbp), %rsi
movq -0x40(%rbp), %rdx
callq 0x52b990
movl (%rbx), %edi
movl $0x3ff, %edx            # imm = 0x3FF
movq %r15, %rsi
callq 0x52b8f0
testq %rax, %rax
jle 0x40493d
movb $0x0, -0x460(%rbp,%rax)
movq %r14, %rdi
leaq 0x1726c1(%rip), %rsi    # 0x57704d
callq 0x46e440
movq %rax, %rdi
movq %r15, %rsi
callq 0x46e440
movq %rax, %rdi
callq 0x46dd20
jmp 0x40493d
jmp 0x4049a8
movq %rax, %rbx
leaq -0x48(%rbp), %rdi
callq 0x474810
movq %rbx, %rdi
callq 0x4a5ff0
// File: /workspace/github_cpp_makefile_star2_O2/tomfunkhouser[P]gaps/apps/msh2prp/msh2prp.cpp
// Function: Sigma(gaps::R3Mesh*)
RNScalar
Sigma(R3Mesh *mesh)
{
  // Compute smallest sigma
  static RNScalar sigma = 0;
  static R3Mesh *last_mesh = NULL;
  if (mesh != last_mesh) {
    sigma = 0.005 * sqrt(mesh->Area());
    last_mesh = mesh;
  }

  // Return sigma
  return sigma;
}

// Assembly:
cmpq %rdi, 0xf06fd(%rip)     # 0x102d50
je 0x1266e
pushq %rbx
movq %rdi, %rbx
callq 0x1e45e
xorpd %xmm1, %xmm1
ucomisd %xmm1, %xmm0
jb 0x12677
sqrtsd %xmm0, %xmm0
jmp 0x1267c
movsd 0xf06d2(%rip), %xmm0    # 0x102d48
retq
callq 0x10420
mulsd 0x9b984(%rip), %xmm0    # 0xae008
movsd %xmm0, 0xf06bc(%rip)    # 0x102d48
movq %rbx, 0xf06bd(%rip)     # 0x102d50
popq %rbx
retq
// File: /workspace/github_cpp_makefile_star2_O2/tomfunkhouser[P]gaps/apps/msh2prp/msh2prp.cpp
// Function: InsertProperty(gaps::R3MeshPropertySet*, gaps::R3MeshProperty*, int)
int 
InsertProperty(R3MeshPropertySet *properties, R3MeshProperty *property, int num_blurs = 0)
{
  // Insert property
  properties->Insert(property);

  // Insert coies of property with increasing blur
  if (num_blurs > 0) {
    char buffer[4096];
    RNScalar sigma = Sigma(properties->Mesh());
    R3MeshProperty *p = property;
    for (int i = 1; i < num_blurs; i++) {
      p = new R3MeshProperty(*p);
      sprintf(buffer, "%s%d", property->Name(), i);
      p->SetName(buffer);
      p->Blur(sigma);
      properties->Insert(p);
      sigma *= 2;
    }
  }

  // Return success
  return 1;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x1018, %rsp           # imm = 0x1018
movl %edx, %ebp
movq %rsi, %rbx
movq %rdi, %r15
callq 0x19010
movl %ebp, 0x4(%rsp)
testl %ebp, %ebp
jle 0x12745
pushq $0x1
popq %rbp
movq %r15, %r14
movq (%r15), %rdi
callq 0x1264c
leaq 0x8(%rbx), %r15
leaq 0x10(%rsp), %r13
cmpl %ebp, 0x4(%rsp)
je 0x12745
movl $0x448, %edi            # imm = 0x448
movsd %xmm0, 0x8(%rsp)
callq 0x10560
movq %rax, %r12
movq %rax, %rdi
movq %rbx, %rsi
callq 0x1a8dc
movq %r13, %rdi
leaq 0x9ba0c(%rip), %rsi     # 0xae110
movq %r15, %rdx
movl %ebp, %ecx
xorl %eax, %eax
callq 0x10100
movq %r12, %rdi
movq %r13, %rsi
callq 0x1c180
movq %r12, %rdi
movsd 0x8(%rsp), %xmm0
callq 0x1c6c4
movq %r14, %rdi
movq %r12, %rsi
callq 0x19010
movsd 0x8(%rsp), %xmm0
addsd %xmm0, %xmm0
incl %ebp
movq %r12, %rbx
jmp 0x126d6
pushq $0x1
popq %rax
addq $0x1018, %rsp           # imm = 0x1018
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
movl $0x448, %esi            # imm = 0x448
movq %r12, %rdi
callq 0x10570
movq %rbx, %rdi
callq 0x10a00
// File: /workspace/github_cpp_makefile_star2_O2/tomfunkhouser[P]gaps/apps/msh2prp/msh2prp.cpp
// Function: rot_coord_sys(gaps::R3Vector const&, gaps::R3Vector const&, gaps::R3Vector const&, gaps::R3Vector&, gaps::R3Vector&)
static void rot_coord_sys(const R3Vector &old_u, const R3Vector &old_v,
			  const R3Vector &new_norm,
			  R3Vector &new_u, R3Vector &new_v)
{
  new_u = old_u;
  new_v = old_v;
  if (new_u.IsZero()) return;
  if (new_v.IsZero()) return;
  R3Vector old_norm = old_u % old_v;
  if (old_norm.IsZero()) return;
  RNScalar ndot = old_norm.Dot(new_norm);
  if (ndot >= 1.0) return;
  if (ndot <= -1.0) {
    new_u = -new_u;
    new_v = -new_v;
    return;
  }
  R3Vector perp_old = new_norm - ndot * old_norm;
  R3Vector dperp = 1.0f / (1 + ndot) * (old_norm + new_norm);
  new_u -= dperp * new_u.Dot(perp_old);
  new_v -= dperp * new_v.Dot(perp_old);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x68, %rsp
movq %r8, %rbx
movq %rcx, %r14
movq %rdx, %r15
movq %rsi, %r12
movq %rdi, %r13
movq %rcx, %rdi
movq %r13, %rsi
callq 0x45578
movq %rbx, %rdi
movq %r12, %rsi
callq 0x45578
movq %r14, %rdi
callq 0x17b04
testl %eax, %eax
jne 0x179a7
movq %rbx, %rdi
callq 0x17b04
testl %eax, %eax
jne 0x179a7
leaq 0x8(%rsp), %rbp
movq %rbp, %rdi
movq %r13, %rsi
movq %r12, %rdx
callq 0x456ba
movsd (%rbp), %xmm1
xorpd %xmm0, %xmm0
ucomisd %xmm0, %xmm1
jne 0x17887
jp 0x17887
movsd 0x10(%rsp), %xmm1
ucomisd %xmm0, %xmm1
jne 0x17887
jp 0x17887
movsd 0x18(%rsp), %xmm0
xorpd %xmm1, %xmm1
ucomisd %xmm1, %xmm0
jne 0x17887
jnp 0x179a7
leaq 0x8(%rsp), %rdi
movq %r15, %rsi
callq 0x45282
ucomisd 0x96784(%rip), %xmm0    # 0xae020
jae 0x179a7
movsd 0x967fe(%rip), %xmm1    # 0xae0a8
ucomisd %xmm0, %xmm1
jae 0x17971
leaq 0x50(%rsp), %r13
leaq 0x8(%rsp), %rbp
movq %r13, %rdi
movq %rbp, %rsi
movsd %xmm0, (%rsp)
callq 0x456fe
leaq 0x38(%rsp), %r12
movq %r12, %rdi
movq %r15, %rsi
movq %r13, %rdx
callq 0x459b1
movsd 0x96737(%rip), %xmm0    # 0xae020
movsd (%rsp), %xmm1
addsd %xmm0, %xmm1
divsd %xmm1, %xmm0
movsd %xmm0, (%rsp)
leaq 0x20(%rsp), %r13
movq %r13, %rdi
movq %rbp, %rsi
movq %r15, %rdx
callq 0x4598e
leaq 0x50(%rsp), %r15
movq %r15, %rdi
movq %r13, %rsi
movsd (%rsp), %xmm0
callq 0x456fe
movq %r14, %rdi
movq %r12, %rsi
callq 0x45282
leaq 0x20(%rsp), %r13
movq %r13, %rdi
movq %r15, %rsi
callq 0x456fe
movq %r14, %rdi
movq %r13, %rsi
callq 0x4574e
movq %rbx, %rdi
movq %r12, %rsi
callq 0x45282
leaq 0x20(%rsp), %r14
movq %r14, %rdi
movq %r15, %rsi
callq 0x456fe
movq %rbx, %rdi
movq %r14, %rsi
callq 0x4574e
jmp 0x179a7
leaq 0x38(%rsp), %r15
movq %r15, %rdi
movq %r14, %rsi
callq 0x4596e
movq %r14, %rdi
movq %r15, %rsi
callq 0x45578
leaq 0x38(%rsp), %r14
movq %r14, %rdi
movq %rbx, %rsi
callq 0x4596e
movq %rbx, %rdi
movq %r14, %rsi
callq 0x45578
addq $0x68, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/tomfunkhouser[P]gaps/apps/msh2prp/msh2prp.cpp
// Function: Mean(double*, int)
static RNScalar
Mean(RNScalar *values, int nvalues)
{
  // Return mean
  if (nvalues == 0) return 0;
  RNScalar sum = 0;
  for (int i = 0; i < nvalues; i++) 
    sum += values[i];
  return sum / nvalues;
}

// Assembly:
testl %esi, %esi
je 0x179e2
xorl %eax, %eax
testl %esi, %esi
movl $0x0, %ecx
cmovgl %esi, %ecx
xorpd %xmm0, %xmm0
cmpq %rax, %rcx
je 0x179d9
addsd (%rdi,%rax,8), %xmm0
incq %rax
jmp 0x179ca
cvtsi2sd %esi, %xmm1
divsd %xmm1, %xmm0
retq
xorps %xmm0, %xmm0
retq
// File: /workspace/github_cpp_makefile_star2_O2/tomfunkhouser[P]gaps/apps/msh2prp/msh2prp.cpp
// Function: Percentile(double*, int, double)
static RNScalar
Percentile(RNScalar *values, int nvalues, RNScalar percentile)
{
  // Return value at given percentile (0-100)
  if (nvalues == 0) return 0;
  RNScalar *copy = new RNScalar [ nvalues ];
  for (int i = 0; i < nvalues; i++) copy[i] = values[i];
  qsort(copy, nvalues, sizeof(RNScalar), RNCompareScalars);
  int index = (int) (percentile * nvalues / 100.0);
  if (index >= nvalues) index = nvalues-1;
  RNScalar result = copy[index];
  delete [] copy;
  return result;
}

// Assembly:
testl %esi, %esi
je 0x17aa6
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movl %esi, %ebx
movq %rdi, %r12
movsd %xmm0, (%rsp)
movslq %esi, %r15
leaq (,%r15,8), %rax
xorl %r13d, %r13d
testl %esi, %esi
pushq $-0x1
popq %rdi
cmovnsq %rax, %rdi
movl $0x0, %ebp
cmovgl %esi, %ebp
callq 0x10040
movq %rax, %r14
cmpq %r13, %rbp
je 0x17a4a
movsd (%r12,%r13,8), %xmm0
movsd %xmm0, (%r14,%r13,8)
incq %r13
jmp 0x17a34
leaq 0x5cb44(%rip), %rcx     # 0x74595
pushq $0x8
popq %rdx
movq %r14, %rdi
movq %r15, %rsi
callq 0x10ad0
cvtsi2sd %ebx, %xmm0
mulsd (%rsp), %xmm0
divsd 0x96648(%rip), %xmm0    # 0xae0b8
cvttsd2si %xmm0, %eax
leal -0x1(%rbx), %ecx
cmpl %ebx, %eax
cmovll %eax, %ecx
movslq %ecx, %rax
movsd (%r14,%rax,8), %xmm0
movsd %xmm0, (%rsp)
movq %r14, %rdi
callq 0x10720
movsd (%rsp), %xmm0
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
xorps %xmm0, %xmm0
retq
// File: /workspace/github_cpp_makefile_star2_O2/marknelson[P]LZW/./lzw-d.h
// Function: lzw::output_code_stream<std::ostream>::operator<<(unsigned int const&)
void operator<<( const unsigned int &i )
    {
        m_pending_output |= i << m_pending_bits;
        m_pending_bits += m_code_size;
        flush( 8 );
        if ( m_current_code < m_max_code ) {
            m_current_code++;
            if ( m_current_code == m_next_bump ) {
                m_next_bump *= 2;
                m_code_size++;
            }
        }
    }

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %rbx
pushq %rax
movq %rdi, %rbx
movl (%rsi), %eax
movl 0x10(%rdi), %ecx
shll %cl, %eax
orl %eax, 0x14(%rdi)
addl (%rdi), %ecx
movl %ecx, 0x10(%rdi)
pushq $0x8
popq %rsi
callq 0x325a
movl 0x18(%rbx), %eax
cmpl 0x20(%rbx), %eax
jae 0x2ab7
incl %eax
movl %eax, 0x18(%rbx)
cmpl 0x1c(%rbx), %eax
jne 0x2ab7
addl %eax, %eax
movl %eax, 0x1c(%rbx)
incl (%rbx)
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/marknelson[P]LZW/./lzw-d.h
// Function: lzw::output_code_stream<std::ostream>::flush(int)
void flush( const int val )
    {
        while ( m_pending_bits >= val ) {
            m_output.put( m_pending_output & 0xff );
            m_pending_output >>= 8;
            m_pending_bits -= 8;
        }
    }

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
movl %esi, %ebx
movq %rdi, %r14
movl 0x10(%rdi), %eax
cmpl %ebx, %eax
jl 0x328d
movq 0x8(%r14), %rdi
movsbl 0x14(%r14), %esi
callq 0x2030
shrl $0x8, 0x14(%r14)
movl 0x10(%r14), %eax
addl $-0x8, %eax
movl %eax, 0x10(%r14)
jmp 0x3269
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/marknelson[P]LZW/./lzw-d.h
// Function: lzw::input_code_stream<std::istream>::operator>>(unsigned int&)
bool operator>>( unsigned int &i )
    {
        while ( m_available_bits < m_code_size )
        {
            char c;
            if ( !m_input.get(c) )
                return false;
            m_pending_input |= (c & 0xff) << m_available_bits;
            m_available_bits += 8;
        }
        i = m_pending_input & ~(~0 << m_code_size);
        m_pending_input >>= m_code_size;
        m_available_bits -= m_code_size;
        if ( m_current_code < m_max_code ) {
            m_current_code++;
            if ( m_current_code == m_next_bump ) {
                m_next_bump *= 2;
                m_code_size++;
            }
        }
        if ( i == EOF_CODE )
            return false;
        else
            return true;
    }

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq %rdi, %r14
movl 0x10(%rdi), %ecx
leaq -0x19(%rbp), %r15
movl (%r14), %eax
cmpl %eax, %ecx
jge 0x3307
movq 0x8(%r14), %rdi
movq %r15, %rsi
callq 0x21f0
movq (%rax), %rcx
movq -0x18(%rcx), %rcx
testb $0x5, 0x20(%rax,%rcx)
jne 0x334d
movzbl -0x19(%rbp), %eax
movl 0x10(%r14), %ecx
shll %cl, %eax
orl %eax, 0x14(%r14)
addl $0x8, %ecx
movl %ecx, 0x10(%r14)
jmp 0x32cf
pushq $-0x1
popq %rdx
movl %eax, %ecx
shll %cl, %edx
notl %edx
andl 0x14(%r14), %edx
movl %edx, (%rbx)
movl (%r14), %ecx
movl 0x18(%r14), %eax
shrl %cl, 0x14(%r14)
subl %ecx, 0x10(%r14)
cmpl 0x20(%r14), %eax
jae 0x3342
incl %eax
movl %eax, 0x18(%r14)
cmpl 0x1c(%r14), %eax
jne 0x3342
addl %eax, %eax
movl %eax, 0x1c(%r14)
incl %ecx
movl %ecx, (%r14)
cmpl $0x100, (%rbx)          # imm = 0x100
setne %al
jmp 0x334f
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/Saevon[P]node-diskfree/build/../src/disk-gyp.cpp
// Function: diskfree::checkArgs(v8::FunctionCallbackInfo<v8::Value> const&)
bool checkArgs(const FunctionCallbackInfo<Value> &args) {
        Isolate *isolate = args.GetIsolate();

        // Check the args
        if (args.Length() != 2) {
            isolate->ThrowException(Exception::TypeError(
                String::NewFromUtf8(isolate, "diskPath and callback are required", NewStringType::kNormal).ToLocalChecked()
            ));
            return false;
        } else if (!args[0]->IsString()) {
            isolate->ThrowException(Exception::TypeError(
                String::NewFromUtf8(isolate, "diskPath should be a string", NewStringType::kNormal).ToLocalChecked()
            ));
            return false;
        } else if (!args[1]->IsFunction()) {
            isolate->ThrowException(Exception::TypeError(
                String::NewFromUtf8(isolate, "diskPath should be a function", NewStringType::kNormal).ToLocalChecked()
            ));
            return false;
        }

        return true;
    }

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
movq (%rdi), %rax
movq 0x8(%rax), %rbx
cmpl $0x2, 0x10(%rdi)
jne 0x2612
movq 0x8(%rdi), %rdi
movq (%rdi), %rax
movl %eax, %ecx
andl $0x3, %ecx
cmpl $0x1, %ecx
jne 0x261b
movq -0x1(%rax), %rax
cmpw $0x40, 0xb(%rax)
jae 0x261b
addq $-0x8, %rdi
callq 0x2050
movl %eax, %ecx
movb $0x1, %al
testb %cl, %cl
jne 0x264c
leaq 0xa7b(%rip), %rsi       # 0x308b
jmp 0x2622
leaq 0xa33(%rip), %rsi       # 0x304c
jmp 0x2622
leaq 0xa4d(%rip), %rsi       # 0x306f
pushq $-0x1
popq %rcx
movq %rbx, %rdi
xorl %edx, %edx
callq 0x2290
movq %rax, %r14
testq %rax, %rax
je 0x2651
movq %r14, %rdi
callq 0x2220
movq %rbx, %rdi
movq %rax, %rsi
callq 0x21b0
xorl %eax, %eax
popq %rbx
popq %r14
popq %rbp
retq
callq 0x2120
jmp 0x2637
// File: /workspace/github_cpp_makefile_star2_O2/Saevon[P]node-diskfree/build/../src/disk-gyp.cpp
// Function: diskfree::DiskSpace(v8::FunctionCallbackInfo<v8::Value> const&)
void DiskSpace(const FunctionCallbackInfo<Value> &args) {
        Isolate *isolate = args.GetIsolate();

        // Check the input args
        bool shouldRun = checkArgs(args);
        if (!shouldRun) {
            return;
        }

        // Get the Args
        String::Utf8Value diskPath(isolate, args[0]);
        Local<Function> callback = Local<Function>::Cast(args[1]);

        // Copy the string into a C String (+1 or the null char)
        char *diskPathC = (char *) calloc(diskPath.length() + 1, sizeof(char));
        strcpy(diskPathC, *diskPath);

        // Store the args in a request
        reqData_t *requestData = new reqData_t();
        requestData->callback.Reset(isolate, callback);
        requestData->diskPath = diskPathC;

        // Run the worker
        uv_work_t *request = new uv_work_t();
        request->data = requestData;

        uv_queue_work(uv_default_loop(), request, &DiskSpaceWorker, &AfterDiskSpaceWorker);

        // Return to the parent early
        args.GetReturnValue().Set(Undefined(isolate));
    }

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %rdi, %r14
movq (%rdi), %rax
movq 0x8(%rax), %rbx
callq 0x2160
testb %al, %al
je 0x2779
cmpl $0x0, 0x10(%r14)
jle 0x268d
movq 0x8(%r14), %rdx
jmp 0x2698
movq (%r14), %rax
movq 0x8(%rax), %rdx
addq $0x58, %rdx
leaq -0x38(%rbp), %rdi
movq %rbx, %rsi
callq 0x20b0
cmpl $0x1, 0x10(%r14)
jle 0x26b5
movq 0x8(%r14), %r15
addq $-0x8, %r15
jmp 0x26c0
movq (%r14), %rax
movq 0x8(%rax), %r15
addq $0x58, %r15
movslq -0x30(%rbp), %rdi
incq %rdi
pushq $0x1
popq %rsi
callq 0x21d0
movq %rax, %r13
movq -0x38(%rbp), %rsi
movq %rax, %rdi
callq 0x2150
pushq $0x30
popq %rdi
callq 0x2080
movq %rax, %r12
xorps %xmm0, %xmm0
movups %xmm0, (%rax)
movups %xmm0, 0x10(%rax)
movups %xmm0, 0x20(%rax)
testq %r15, %r15
je 0x270b
movq %rbx, %rdi
movq %r15, %rsi
callq 0x20d0
movq %rax, (%r12)
movq %r13, 0x8(%r12)
movl $0x80, %edi
callq 0x2080
movq %rax, %r15
xorps %xmm0, %xmm0
movaps %xmm0, (%rax)
movaps %xmm0, 0x10(%rax)
movaps %xmm0, 0x20(%rax)
movaps %xmm0, 0x30(%rax)
movaps %xmm0, 0x40(%rax)
movaps %xmm0, 0x50(%rax)
movaps %xmm0, 0x60(%rax)
movaps %xmm0, 0x70(%rax)
movq %r12, (%rax)
callq 0x2230
movq 0x287a(%rip), %rdx      # 0x4fc8
movq 0x2893(%rip), %rcx      # 0x4fe8
movq %rax, %rdi
movq %r15, %rsi
callq 0x20f0
movq (%r14), %rax
addq $0x58, %rbx
je 0x2788
movq (%rbx), %rcx
movq %rcx, 0x18(%rax)
leaq -0x38(%rbp), %rdi
callq 0x21c0
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
leaq 0x10(%rax), %rbx
jmp 0x2769
// File: /workspace/github_cpp_makefile_star2_O2/Saevon[P]node-diskfree/build/../src/disk-gyp.cpp
// Function: diskfree::checkErrorcodeArgs(v8::FunctionCallbackInfo<v8::Value> const&)
bool checkErrorcodeArgs(const FunctionCallbackInfo<Value> &args) {
        Isolate *isolate = args.GetIsolate();

        // Check the args
        if (args.Length() != 1) {
            isolate->ThrowException(Exception::TypeError(
                String::NewFromUtf8(isolate, "errno is required", NewStringType::kNormal).ToLocalChecked()
            ));
            return false;
        } else if (!args[0]->IsNumber()) {
            isolate->ThrowException(Exception::TypeError(
                String::NewFromUtf8(isolate, "errno should be a Number", NewStringType::kNormal).ToLocalChecked()
            ));
            return false;
        }

        return true;
    }

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
movq (%rdi), %rax
movq 0x8(%rax), %rbx
cmpl $0x1, 0x10(%rdi)
jne 0x27bc
movq 0x8(%rdi), %rdi
callq 0x2170
movl %eax, %ecx
movb $0x1, %al
testb %cl, %cl
jne 0x27ed
leaq 0x901(%rip), %rsi       # 0x30bb
jmp 0x27c3
leaq 0x8e6(%rip), %rsi       # 0x30a9
pushq $-0x1
popq %rcx
movq %rbx, %rdi
xorl %edx, %edx
callq 0x2290
movq %rax, %r14
testq %rax, %rax
je 0x27f2
movq %r14, %rdi
callq 0x2220
movq %rbx, %rdi
movq %rax, %rsi
callq 0x21b0
xorl %eax, %eax
popq %rbx
popq %r14
popq %rbp
retq
callq 0x2120
jmp 0x27d8
// File: /workspace/github_cpp_makefile_star2_O2/Saevon[P]node-diskfree/build/../src/disk-gyp.cpp
// Function: diskfree::checkErr(v8::FunctionCallbackInfo<v8::Value> const&, bool (*)(unsigned long))
void checkErr(const FunctionCallbackInfo<Value> &args, diskErrFunc_t errChecker) {
        Isolate *isolate = args.GetIsolate();
        Local<Context> context = isolate->GetCurrentContext();

        // Check the input args
        bool shouldRun = checkErrorcodeArgs(args);
        if (!shouldRun) {
            return;
        }

        // Get the args
        double error;
        if (args[0]->IsUndefined()) {
            error = 0;
        } else {
            error = args[0]->NumberValue(context).FromMaybe(0);
        }

        // Convert to proper type
        args.GetReturnValue().Set(
            static_cast<double>(errChecker(static_cast<uint64_t>(error)))
        );
    }

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq %rdi, %r14
movq (%rdi), %rax
movq 0x8(%rax), %rdi
callq 0x2130
movq %rax, %r15
movq %r14, %rdi
callq 0x2110
testb %al, %al
je 0x28c8
movl 0x10(%r14), %eax
testl %eax, %eax
jle 0x2836
movq 0x8(%r14), %rcx
jmp 0x2841
movq (%r14), %rcx
movq 0x8(%rcx), %rcx
addq $0x58, %rcx
movq (%rcx), %rcx
movl %ecx, %edx
andl $0x3, %edx
cmpl $0x1, %edx
jne 0x2863
movq -0x1(%rcx), %rdx
cmpw $0x43, 0xb(%rdx)
jne 0x2863
cmpl $0x5, 0x2b(%rcx)
jne 0x2863
xorl %edi, %edi
jmp 0x28a7
testl %eax, %eax
jle 0x286d
movq 0x8(%r14), %rdi
jmp 0x2878
movq (%r14), %rax
movq 0x8(%rax), %rdi
addq $0x58, %rdi
movq %r15, %rsi
callq 0x2100
cvttsd2si %xmm0, %rcx
movq %rcx, %rdx
sarq $0x3f, %rdx
subsd 0x794(%rip), %xmm0      # 0x3028
cvttsd2si %xmm0, %rsi
andq %rdx, %rsi
orq %rcx, %rsi
xorl %edi, %edi
testb $0x1, %al
cmovneq %rsi, %rdi
movq (%r14), %r14
callq *%rbx
movzbl %al, %eax
cvtsi2sd %eax, %xmm0
movq 0x8(%r14), %rdi
callq 0x2200
testq %rax, %rax
je 0x28d3
movq (%rax), %rax
movq %rax, 0x18(%r14)
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
leaq 0x10(%r14), %rax
jmp 0x28c1
// File: /workspace/github_cpp_makefile_star2_O2/Saevon[P]node-diskfree/build/../src/disk-gyp.cpp
// Function: diskfree::init(v8::Local<v8::Object>)
void init(Local<Object> exports) {
        NODE_SET_METHOD(exports, "check", DiskSpace);
        NODE_SET_METHOD(exports, "isErrDenied", nodeIsErrDenied);
        NODE_SET_METHOD(exports, "isErrBadPath", nodeIsErrBadPath);
        NODE_SET_METHOD(exports, "isErrIO", nodeIsErrIO);
    }

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %rbx
pushq %rax
movq %rdi, %rbx
leaq 0x7b8(%rip), %rsi       # 0x30d4
movq 0x269d(%rip), %rdx      # 0x4fc0
callq 0x22a0
leaq 0x7ab(%rip), %rsi       # 0x30da
movq 0x2682(%rip), %rdx      # 0x4fb8
movq %rbx, %rdi
callq 0x22a0
leaq 0x7a1(%rip), %rsi       # 0x30e6
movq 0x26ac(%rip), %rdx      # 0x4ff8
movq %rbx, %rdi
callq 0x22a0
leaq 0x798(%rip), %rsi       # 0x30f3
movq 0x2636(%rip), %rdx      # 0x4f98
movq %rbx, %rdi
addq $0x8, %rsp
popq %rbx
popq %rbp
jmp 0x22a0
// File: /workspace/github_cpp_makefile_star2_O2/fiveseven-lambda[P]michaelis-menten/a.cpp
// Function: in_polygon(Vector<short> const&, std::vector<XPoint, std::allocator<XPoint>> const&)
bool in_polygon(const Vector<short> &p, const std::vector<XPoint> &v){
	bool ret = false;
	for(std::size_t i = 0; i < v.size(); ++i){
		std::size_t j = i + 1;
		if(j == v.size()) j = 0;
		bool tmp = (p.x - v[i].x) * (v[j].y - v[i].y) < (p.y - v[i].y) * (v[j].x - v[i].x);
		if(v[i].y <= p.y && v[j].y > p.y){
			ret ^= tmp;
		}else if(v[i].y > p.y && v[j].y <= p.y){
			ret ^= !tmp;
		}
	}
	return ret;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
movq (%rsi), %rcx
movq 0x8(%rsi), %rdx
subq %rcx, %rdx
sarq $0x2, %rdx
movswl (%rdi), %esi
movswl 0x2(%rdi), %edi
negq %rdx
xorl %r8d, %r8d
xorl %eax, %eax
incq %r8
leaq (%rdx,%r8), %r9
cmpq $0x1, %r9
je 0x27bd
movq %rdx, %r9
addq %r8, %r9
movl $0x0, %r10d
cmovneq %r8, %r10
movswl 0x2(%rcx,%r10,4), %r9d
movswl -0x2(%rcx,%r8,4), %r11d
cmpw %di, %r11w
jle 0x2783
cmpw %di, %r9w
jg 0x2712
movswl -0x4(%rcx,%r8,4), %ebx
movl %esi, %r14d
subl %ebx, %r14d
subl %r11d, %r9d
imull %r14d, %r9d
movl %edi, %r14d
subl %r11d, %r14d
movswl (%rcx,%r10,4), %r10d
subl %ebx, %r10d
imull %r14d, %r10d
cmpl %r10d, %r9d
setl %r9b
xorb %al, %r9b
xorb $0x1, %r9b
movl %r9d, %eax
jmp 0x2712
cmpw %di, %r9w
jle 0x2712
movswl -0x4(%rcx,%r8,4), %ebx
movl %esi, %r14d
subl %ebx, %r14d
subl %r11d, %r9d
imull %r14d, %r9d
movl %edi, %r14d
subl %r11d, %r14d
movswl (%rcx,%r10,4), %r10d
subl %ebx, %r10d
imull %r14d, %r10d
cmpl %r10d, %r9d
setl %r9b
xorb %r9b, %al
jmp 0x2712
andb $0x1, %al
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/fiveseven-lambda[P]michaelis-menten/a.cpp
// Function: object::node::find(Vector<short> const&)
void node::find(const Vector<short> &p){
		focused = nodes.size();
		double min = std::numeric_limits<double>::max();
		for(std::size_t i = 0; i < nodes.size(); ++i){
			Arc arc = nodes[i].arc();
			if((arc.x - p.x) * (arc.x - p.x) + (arc.y - p.y) * (arc.y - p.y) < arc.r * arc.r && min > nodes[i].am){
				focused = i;
				min = nodes[i].am;
			}
		}
		edge::focused = edge::edges.size();
	}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
movq 0x59f8(%rip), %rax      # 0x81d0
movq 0x59e9(%rip), %rdi      # 0x81c8
movq %rax, %rcx
subq %rdi, %rcx
sarq $0x5, %rcx
movq %rcx, 0x59f0(%rip)      # 0x81e0
movsd 0x2820(%rip), %xmm0     # 0x5018
movsd %xmm0, -0x20(%rbp)
xorl %r14d, %r14d
xorl %r15d, %r15d
subq %rdi, %rax
sarq $0x5, %rax
cmpq %rax, %r15
jae 0x2875
addq %r14, %rdi
callq 0x3d30
movq %rax, %rcx
shrq $0x20, %rcx
movzwl %cx, %ecx
movswl %ax, %edx
movswl (%rbx), %esi
subl %esi, %edx
imull %edx, %edx
sarl $0x10, %eax
movswl 0x2(%rbx), %esi
subl %esi, %eax
imull %eax, %eax
addl %edx, %eax
imull %ecx, %ecx
movq 0x5984(%rip), %rdi      # 0x81c8
cmpl %ecx, %eax
jae 0x2865
movsd (%rdi,%r14), %xmm0
movsd -0x20(%rbp), %xmm1
ucomisd %xmm0, %xmm1
jbe 0x2865
movq %r15, 0x5980(%rip)      # 0x81e0
movsd %xmm0, -0x20(%rbp)
incq %r15
movq 0x5961(%rip), %rax      # 0x81d0
addq $0x20, %r14
jmp 0x2803
movq 0x597c(%rip), %rax      # 0x81f8
subq 0x596d(%rip), %rax      # 0x81f0
pushq $0x68
popq %rcx
cqto
idivq %rcx
movq %rax, 0x5976(%rip)      # 0x8208
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/sbingner[P]kerneldec/lzfse/src/lzfse_encode.c
// Function: lzfse_encode_buffer
size_t lzfse_encode_buffer(uint8_t *__restrict dst_buffer, size_t dst_size,
                           const uint8_t *__restrict src_buffer,
                           size_t src_size, void *__restrict scratch_buffer) {
  int has_malloc = 0;
  size_t ret = 0;

  // Deal with the possible NULL pointer
  if (scratch_buffer == NULL) {
    // +1 in case scratch size could be zero
    scratch_buffer = malloc(lzfse_encode_scratch_size() + 1);
    has_malloc = 1;
  }
  if (scratch_buffer == NULL)
    return 0;
  ret = lzfse_encode_buffer_with_scratch(dst_buffer, 
                        dst_size, src_buffer, 
                        src_size, scratch_buffer);
  if (has_malloc)
    free(scratch_buffer);
  return ret;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %r8, %rbx
movq %rcx, %r14
movq %rdx, %r15
movq %rsi, %r12
movq %rdi, %rbp
movq %r8, %r13
testq %r8, %r8
jne 0x37ca
callq 0x35b4
leaq 0x1(%rax), %rdi
callq 0x30d0
movq %rax, %r13
testq %rax, %rax
je 0x37f0
movq %rbp, %rdi
movq %r12, %rsi
movq %r15, %rdx
movq %r14, %rcx
movq %r13, %r8
callq 0x35cb
movq %rax, %r14
testq %rbx, %rbx
jne 0x37f3
movq %r13, %rdi
callq 0x3030
jmp 0x37f3
xorl %r14d, %r14d
movq %r14, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_cpp_makefile_star2_O2/sbingner[P]kerneldec/lzfse/src/lzfse_decode.c
// Function: lzfse_decode_buffer_with_scratch
size_t lzfse_decode_buffer_with_scratch(uint8_t *__restrict dst_buffer, 
                         size_t dst_size, const uint8_t *__restrict src_buffer,
                         size_t src_size, void *__restrict scratch_buffer) {
  lzfse_decoder_state *s = (lzfse_decoder_state *)scratch_buffer;
  memset(s, 0x00, sizeof(*s));

  // Initialize state
  s->src = src_buffer;
  s->src_begin = src_buffer;
  s->src_end = s->src + src_size;
  s->dst = dst_buffer;
  s->dst_begin = dst_buffer;
  s->dst_end = dst_buffer + dst_size;

  // Decode
  int status = lzfse_decode(s);
  if (status == LZFSE_STATUS_DST_FULL)
    return dst_size;
  if (status != LZFSE_STATUS_OK)
    return 0;                           // failed
  return (size_t)(s->dst - dst_buffer); // bytes written
}

// Assembly:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
movq %r8, %r14
movq %rcx, %r12
movq %rdx, %r13
movq %rsi, %rbx
movq %rdi, %r15
leaq 0x30(%r8), %rdi
movl $0xb8f0, %edx           # imm = 0xB8F0
xorl %esi, %esi
callq 0x3080
movq %r13, (%r14)
movq %r13, 0x8(%r14)
addq %r13, %r12
movq %r12, 0x10(%r14)
movq %r15, 0x18(%r14)
movq %r15, 0x20(%r14)
leaq (%r15,%rbx), %rax
movq %rax, 0x28(%r14)
movq %r14, %rdi
callq 0x4f10
cmpl $-0x2, %eax
je 0x3870
testl %eax, %eax
jne 0x386e
movq 0x18(%r14), %rbx
subq %r15, %rbx
jmp 0x3870
xorl %ebx, %ebx
movq %rbx, %rax
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
// File: /workspace/github_cpp_makefile_star2_O2/sbingner[P]kerneldec/lzfse/src/lzfse_decode.c
// Function: lzfse_decode_buffer
size_t lzfse_decode_buffer(uint8_t *__restrict dst_buffer, size_t dst_size,
                           const uint8_t *__restrict src_buffer,
                           size_t src_size, void *__restrict scratch_buffer) {
  int has_malloc = 0;
  size_t ret = 0;

  // Deal with the possible NULL pointer
  if (scratch_buffer == NULL) {
    // +1 in case scratch size could be zero
    scratch_buffer = malloc(lzfse_decode_scratch_size() + 1);
    has_malloc = 1;
  }
  if (scratch_buffer == NULL)
    return 0;
  ret = lzfse_decode_buffer_with_scratch(dst_buffer, 
                               dst_size, src_buffer, 
                               src_size, scratch_buffer);
  if (has_malloc)
    free(scratch_buffer);
  return ret;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %r8, %rbx
movq %rcx, %r14
movq %rdx, %r12
movq %rsi, %r13
movq %rdi, %rbp
movq %r8, %r15
testq %r8, %r8
jne 0x3b2c
movl $0xb921, %edi           # imm = 0xB921
callq 0x30d0
movq %rax, %r15
testq %rax, %rax
je 0x3b52
movq %rbp, %rdi
movq %r13, %rsi
movq %r12, %rdx
movq %r14, %rcx
movq %r15, %r8
callq 0x380e
movq %rax, %r14
testq %rbx, %rbx
jne 0x3b55
movq %r15, %rdi
callq 0x3030
jmp 0x3b55
xorl %r14d, %r14d
movq %r14, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/sbingner[P]kerneldec/lzfse/src/lzfse_decode.c
// Function: lzfse_decode_file
size_t lzfse_decode_file(FILE *dst_file, FILE *src_file, size_t src_size,
                         int *error, void *__restrict scratch_buffer) {
  int has_malloc = 0;
  size_t ret = 0;

  // Deal with the possible NULL pointer
  if (scratch_buffer == NULL) {
    // +1 in case scratch size could be zero
    scratch_buffer = malloc(lzfse_decode_scratch_size() + 1);
    has_malloc = 1;
  }
  if (scratch_buffer == NULL) {
    if (error != NULL) *error = 1;
    return 0;
  }
  ret = lzfse_decode_file_with_scratch(dst_file, src_file, src_size, error, scratch_buffer);
  if (has_malloc)
    free(scratch_buffer);
  return ret;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %r8, %rbx
movq %rcx, %r14
movq %rdx, %r12
movq %rsi, %r13
movq %rdi, %rbp
movq %r8, %r15
testq %r8, %r8
jne 0x3b9b
movl $0xb921, %edi           # imm = 0xB921
callq 0x30d0
movq %rax, %r15
testq %rax, %rax
je 0x3bc1
movq %rbp, %rdi
movq %r13, %rsi
movq %r12, %rdx
movq %r14, %rcx
movq %r15, %r8
callq 0x387d
movq %rax, %r14
testq %rbx, %rbx
jne 0x3bd0
movq %r15, %rdi
callq 0x3030
jmp 0x3bd0
testq %r14, %r14
je 0x3bcd
movl $0x1, (%r14)
xorl %r14d, %r14d
movq %r14, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O2/sbingner[P]kerneldec/lzfse/src/lzfse_encode_base.c
// Function: lzfse_encode_init
int lzfse_encode_init(lzfse_encoder_state *s) {
  const lzfse_match NO_MATCH = {0};
  lzfse_history_set line;
  for (int i = 0; i < LZFSE_ENCODE_HASH_WIDTH; i++) {
    line.pos[i] = -4 * LZFSE_ENCODE_MAX_D_VALUE; // invalid pos
    line.value[i] = 0;
  }
  // Fill table
  for (int i = 0; i < LZFSE_ENCODE_HASH_VALUES; i++)
    s->history_table[i] = line;
  s->pending = NO_MATCH;
  s->src_literal = 0;

  return LZFSE_STATUS_OK; // OK
}

// Assembly:
movabsq $0x4, %rax
cmpq $0x8, %rax
je 0x3c06
movl $0xfff00014, -0x30(%rsp,%rax,4) # imm = 0xFFF00014
andl $0x0, -0x20(%rsp,%rax,4)
incq %rax
jmp 0x3bee
leaq 0x27160(%rdi), %rax
xorl %ecx, %ecx
cmpq $0x80000, %rcx          # imm = 0x80000
je 0x3c31
movups -0x20(%rsp), %xmm0
movups -0x10(%rsp), %xmm1
movups %xmm1, 0x10(%rax,%rcx)
movups %xmm0, (%rax,%rcx)
addq $0x20, %rcx
jmp 0x3c0f
xorps %xmm0, %xmm0
movups %xmm0, 0x40(%rdi)
andq $0x0, 0x50(%rdi)
andq $0x0, 0x10(%rdi)
xorl %eax, %eax
retq
// File: /workspace/github_cpp_makefile_star2_O2/sbingner[P]kerneldec/lzfse/src/lzfse_encode_base.c
// Function: lzfse_encode_translate
int lzfse_encode_translate(lzfse_encoder_state *s, lzfse_offset delta) {
  assert(delta >= 0);
  if (delta == 0)
    return LZFSE_STATUS_OK; // OK

  // SRC
  s->src += delta;

  // Offsets in SRC
  s->src_end -= delta;
  s->src_encode_i -= delta;
  s->src_encode_end -= delta;
  s->src_literal -= delta;

  // Pending match
  s->pending.pos -= delta;
  s->pending.ref -= delta;

  // history_table positions, translated, and clamped to invalid pos
  int32_t invalidPos = -4 * LZFSE_ENCODE_MAX_D_VALUE;
  for (int i = 0; i < LZFSE_ENCODE_HASH_VALUES; i++) {
    int32_t *p = &(s->history_table[i].pos[0]);
    for (int j = 0; j < LZFSE_ENCODE_HASH_WIDTH; j++) {
      lzfse_offset newPos = p[j] - delta; // translate
      p[j] = (int32_t)((newPos < invalidPos) ? invalidPos : newPos); // clamp
    }
  }

  return LZFSE_STATUS_OK; // OK
}

// Assembly:
pushq %rax
testq %rsi, %rsi
js 0x3cd0
je 0x3ccc
addq %rsi, (%rdi)
movq %rsi, %xmm0
pshufd $0x44, %xmm0, %xmm0     # xmm0 = xmm0[0,1,0,1]
movdqu 0x8(%rdi), %xmm1
movdqu 0x18(%rdi), %xmm2
movdqu 0x40(%rdi), %xmm3
psubq %xmm0, %xmm2
movdqu %xmm2, 0x18(%rdi)
psubq %xmm0, %xmm1
movdqu %xmm1, 0x8(%rdi)
psubq %xmm0, %xmm3
movdqu %xmm3, 0x40(%rdi)
addq $0x27160, %rdi          # imm = 0x27160
xorl %eax, %eax
movq $-0xfffec, %rcx         # imm = 0xFFF00014
cmpq $0x4000, %rax           # imm = 0x4000
je 0x3ccc
xorl %edx, %edx
cmpq $0x4, %rdx
je 0x3cc3
movslq (%rdi,%rdx,4), %r8
subq %rsi, %r8
cmpq $-0xfffeb, %r8          # imm = 0xFFF00015
cmovlq %rcx, %r8
movl %r8d, (%rdi,%rdx,4)
incq %rdx
jmp 0x3ca2
incq %rax
addq $0x20, %rdi
jmp 0x3c98
xorl %eax, %eax
popq %rcx
retq
leaq 0x5866(%rip), %rdi      # 0x953d
leaq 0x586a(%rip), %rsi      # 0x9548
leaq 0x587b(%rip), %rcx      # 0x9560
movl $0x262, %edx            # imm = 0x262
callq 0x3070