LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: hariguchi[P]rtacl/./rtacl.hpp
// Function: rtacl::tuple2str[abi:cxx11](boost::geometry::model::point<long, 6ul, boost::geometry::cs::cartesian> const&)
inline std::string
tuple2str (const rtacl::tuple<ipv4a>& t)
{
    return (boost::format("%s, %s, %d, %d, %d, %d")
            % rtacl::ipv4a2s(t.get<0>())
            % rtacl::ipv4a2s(t.get<1>())
            % static_cast<U32>(t.get<2>())
            % static_cast<U32>(t.get<3>())
            % static_cast<U32>(t.get<4>())
            % static_cast<U32>(t.get<5>())).str();
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x190, %rsp            # imm = 0x190
movq %rdi, -0x160(%rbp)
movq %rdi, %rax
movq %rax, -0x158(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
leaq 0x54f13(%rip), %rsi     # 0x5ffbe
leaq -0xf0(%rbp), %rdi
callq 0xa390
movq -0x10(%rbp), %rdi
callq 0xd830
movq (%rax), %rsi
leaq -0x110(%rbp), %rdi
callq 0x26da0
jmp 0xb0d1
leaq -0xf0(%rbp), %rdi
leaq -0x110(%rbp), %rsi
callq 0xaa00
movq %rax, -0x168(%rbp)
jmp 0xb0ed
movq -0x10(%rbp), %rdi
callq 0xd970
movq (%rax), %rsi
leaq -0x140(%rbp), %rdi
callq 0x26da0
jmp 0xb107
movq -0x168(%rbp), %rdi
leaq -0x140(%rbp), %rsi
callq 0xaa00
movq %rax, -0x170(%rbp)
jmp 0xb123
movq -0x10(%rbp), %rdi
callq 0xdaa0
movq -0x170(%rbp), %rdi
movl (%rax), %eax
movl %eax, -0x144(%rbp)
leaq -0x144(%rbp), %rsi
callq 0x26fe0
movq %rax, -0x178(%rbp)
jmp 0xb150
movq -0x10(%rbp), %rdi
callq 0xdbd0
movq -0x178(%rbp), %rdi
movl (%rax), %eax
movl %eax, -0x148(%rbp)
leaq -0x148(%rbp), %rsi
callq 0x26fe0
movq %rax, -0x180(%rbp)
jmp 0xb17d
movq -0x10(%rbp), %rdi
callq 0xdd00
movq -0x180(%rbp), %rdi
movl (%rax), %eax
movl %eax, -0x14c(%rbp)
leaq -0x14c(%rbp), %rsi
callq 0x26fe0
movq %rax, -0x188(%rbp)
jmp 0xb1aa
movq -0x10(%rbp), %rdi
callq 0xde30
movq -0x188(%rbp), %rdi
movl (%rax), %eax
movl %eax, -0x150(%rbp)
leaq -0x150(%rbp), %rsi
callq 0x26fe0
movq %rax, -0x190(%rbp)
jmp 0xb1d7
movq -0x190(%rbp), %rsi
movq -0x160(%rbp), %rdi
callq 0xa590
jmp 0xb1ec
leaq -0x140(%rbp), %rdi
callq 0x51e0
leaq -0x110(%rbp), %rdi
callq 0x51e0
leaq -0xf0(%rbp), %rdi
callq 0xa7e0
movq -0x158(%rbp), %rax
addq $0x190, %rsp            # imm = 0x190
popq %rbp
retq
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x118(%rbp)
movl %eax, -0x11c(%rbp)
jmp 0xb272
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x118(%rbp)
movl %eax, -0x11c(%rbp)
jmp 0xb266
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x118(%rbp)
movl %eax, -0x11c(%rbp)
leaq -0x140(%rbp), %rdi
callq 0x51e0
leaq -0x110(%rbp), %rdi
callq 0x51e0
leaq -0xf0(%rbp), %rdi
callq 0xa7e0
movq -0x118(%rbp), %rdi
callq 0x5640
nopw (%rax,%rax)
// File: hariguchi[P]rtacl/./rtacl.hpp
// Function: rtacl::db<long>::makeTuple(long, long, long, long, long, long, int, boost::geometry::model::point<long, 6ul, boost::geometry::cs::cartesian>&)
inline void
db<ADDR>::makeTuple (const ADDR sa, const ADDR da,
                     const ADDR sp, const ADDR dp,
                     const ADDR proto, const ADDR dscp,
                     const s32 offset, tuple<ADDR>& result)
{
    bg::set<0>(result, sa + offset);
    bg::set<1>(result, da + offset);
    bg::set<2>(result, sp + offset);
    bg::set<3>(result, dp + offset);
    bg::set<4>(result, proto + offset);
    bg::set<5>(result, dscp + offset);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x60, %rsp
movq 0x20(%rbp), %rax
movl 0x18(%rbp), %eax
movq 0x10(%rbp), %rax
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq %rcx, -0x20(%rbp)
movq %r8, -0x28(%rbp)
movq %r9, -0x30(%rbp)
movq 0x20(%rbp), %rdi
movq -0x10(%rbp), %rax
movslq 0x18(%rbp), %rcx
addq %rcx, %rax
movq %rax, -0x38(%rbp)
leaq -0x38(%rbp), %rsi
xorl %eax, %eax
movl %eax, %edx
callq 0xb5a0
movq 0x20(%rbp), %rdi
movq -0x18(%rbp), %rax
movslq 0x18(%rbp), %rcx
addq %rcx, %rax
movq %rax, -0x40(%rbp)
leaq -0x40(%rbp), %rsi
xorl %eax, %eax
movl %eax, %edx
callq 0xb5d0
movq 0x20(%rbp), %rdi
movq -0x20(%rbp), %rax
movslq 0x18(%rbp), %rcx
addq %rcx, %rax
movq %rax, -0x48(%rbp)
leaq -0x48(%rbp), %rsi
xorl %eax, %eax
movl %eax, %edx
callq 0xb600
movq 0x20(%rbp), %rdi
movq -0x28(%rbp), %rax
movslq 0x18(%rbp), %rcx
addq %rcx, %rax
movq %rax, -0x50(%rbp)
leaq -0x50(%rbp), %rsi
xorl %eax, %eax
movl %eax, %edx
callq 0xb630
movq 0x20(%rbp), %rdi
movq -0x30(%rbp), %rax
movslq 0x18(%rbp), %rcx
addq %rcx, %rax
movq %rax, -0x58(%rbp)
leaq -0x58(%rbp), %rsi
xorl %eax, %eax
movl %eax, %edx
callq 0xb660
movq 0x20(%rbp), %rdi
movq 0x10(%rbp), %rax
movslq 0x18(%rbp), %rcx
addq %rcx, %rax
movq %rax, -0x60(%rbp)
leaq -0x60(%rbp), %rsi
xorl %eax, %eax
movl %eax, %edx
callq 0xb690
addq $0x60, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
nopl (%rax,%rax)
// File: hariguchi[P]rtacl/./rtacl.hpp
// Function: rtacl::ipv4a2s[abi:cxx11](long)
inline std::string
ipv4a2s (const rtacl::ipv4a a)
{
    std::string s;
    u64 mask = 0xff000000;
    u64 val;
    int i;
    for (i = 24; i > 0; i -= 8) {
        val = (a & mask) >> i;
        mask >>= 8;
        s += (boost::format("%d.") % val).str();
    }
    val = (a & mask);
    s += (boost::format("%d") % val).str();
    return s;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x260, %rsp            # imm = 0x260
movq %rdi, -0x250(%rbp)
movq %rdi, %rax
movq %rax, -0x248(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movb $0x0, -0x11(%rbp)
callq 0x54f0
movl $0xff000000, %eax       # imm = 0xFF000000
movq %rax, -0x20(%rbp)
movl $0x18, -0x2c(%rbp)
cmpl $0x0, -0x2c(%rbp)
jle 0x26ed4
movq -0x10(%rbp), %rax
movq -0x20(%rbp), %rcx
andq %rcx, %rax
movb -0x2c(%rbp), %cl
shrq %cl, %rax
movq %rax, -0x28(%rbp)
movq -0x20(%rbp), %rax
shrq $0x8, %rax
movq %rax, -0x20(%rbp)
leaq 0x39136(%rip), %rsi     # 0x5ff45
leaq -0x130(%rbp), %rdi
callq 0xa390
jmp 0x26e1d
leaq -0x130(%rbp), %rdi
leaq -0x28(%rbp), %rsi
callq 0xa560
movq %rax, -0x258(%rbp)
jmp 0x26e36
movq -0x258(%rbp), %rsi
leaq -0x50(%rbp), %rdi
callq 0xa590
jmp 0x26e48
movq -0x250(%rbp), %rdi
leaq -0x50(%rbp), %rsi
callq 0x5480
jmp 0x26e5a
leaq -0x50(%rbp), %rdi
callq 0x51e0
leaq -0x130(%rbp), %rdi
callq 0xa7e0
movl -0x2c(%rbp), %eax
subl $0x8, %eax
movl %eax, -0x2c(%rbp)
jmp 0x26ddd
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x138(%rbp)
movl %eax, -0x13c(%rbp)
jmp 0x26fbb
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x138(%rbp)
movl %eax, -0x13c(%rbp)
jmp 0x26ec3
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x138(%rbp)
movl %eax, -0x13c(%rbp)
leaq -0x50(%rbp), %rdi
callq 0x51e0
leaq -0x130(%rbp), %rdi
callq 0xa7e0
jmp 0x26fbb
movq -0x10(%rbp), %rax
movq -0x20(%rbp), %rcx
andq %rcx, %rax
movq %rax, -0x28(%rbp)
leaq 0x390e8(%rip), %rsi     # 0x5ffd2
leaq -0x240(%rbp), %rdi
callq 0xa390
jmp 0x26ef8
leaq -0x240(%rbp), %rdi
leaq -0x28(%rbp), %rsi
callq 0xa560
movq %rax, -0x260(%rbp)
jmp 0x26f11
movq -0x260(%rbp), %rsi
leaq -0x160(%rbp), %rdi
callq 0xa590
jmp 0x26f26
movq -0x250(%rbp), %rdi
leaq -0x160(%rbp), %rsi
callq 0x5480
jmp 0x26f3b
leaq -0x160(%rbp), %rdi
callq 0x51e0
leaq -0x240(%rbp), %rdi
callq 0xa7e0
movb $0x1, -0x11(%rbp)
testb $0x1, -0x11(%rbp)
jne 0x26fab
jmp 0x26f9f
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x138(%rbp)
movl %eax, -0x13c(%rbp)
jmp 0x26f91
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x138(%rbp)
movl %eax, -0x13c(%rbp)
leaq -0x160(%rbp), %rdi
callq 0x51e0
leaq -0x240(%rbp), %rdi
callq 0xa7e0
jmp 0x26fbb
movq -0x250(%rbp), %rdi
callq 0x51e0
movq -0x248(%rbp), %rax
addq $0x260, %rsp            # imm = 0x260
popq %rbp
retq
movq -0x250(%rbp), %rdi
callq 0x51e0
movq -0x138(%rbp), %rdi
callq 0x5640
nopw %cs:(%rax,%rax)
nopl (%rax)
// File: hariguchi[P]rtacl/./rtacl.hpp
// Function: rtacl::sockItem<sockaddr_in>::sockItem()
sockItem<SADDR>::sockItem ()
{
    memset(&src, 0, sizeof(src));
    memset(&dst, 0, sizeof(dst));
    sockaddr* ps = (sockaddr*)(&src);
    sockaddr* pd = (sockaddr*)(&dst);

    if (typeid(SADDR) == typeid(sockaddr_in)) {
        ps->sa_family = AF_INET;
        pd->sa_family = AF_INET;
        af = AF_INET;
        ao = offsetof(sockaddr_in, sin_addr);
        po = offsetof(sockaddr_in, sin_port);
    } else if (typeid(SADDR) == typeid(sockaddr_in6)) {
        ps->sa_family = AF_INET6;
        pd->sa_family = AF_INET6;
        af = AF_INET6;
        ao = offsetof(sockaddr_in6, sin6_addr);
        po = offsetof(sockaddr_in6, sin6_port);
    } else {
        assert(1);
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x20(%rbp)
xorl %esi, %esi
movl $0x10, %edx
callq 0x51b0
movq -0x20(%rbp), %rdi
addq $0x10, %rdi
xorl %esi, %esi
movl $0x10, %edx
callq 0x51b0
movq -0x20(%rbp), %rax
movq %rax, -0x10(%rbp)
addq $0x10, %rax
movq %rax, -0x18(%rbp)
leaq 0x83b1d(%rip), %rsi     # 0xb0b68
movq %rsi, %rdi
callq 0xb380
testb $0x1, %al
jne 0x2d059
jmp 0x2d083
movq -0x20(%rbp), %rax
movq -0x10(%rbp), %rcx
movw $0x2, (%rcx)
movq -0x18(%rbp), %rcx
movw $0x2, (%rcx)
movw $0x2, 0x20(%rax)
movw $0x4, 0x22(%rax)
movw $0x2, 0x24(%rax)
jmp 0x2d0ca
leaq 0x83ade(%rip), %rdi     # 0xb0b68
leaq 0x83ae7(%rip), %rsi     # 0xb0b78
callq 0xb380
testb $0x1, %al
jne 0x2d09c
jmp 0x2d0c6
movq -0x20(%rbp), %rax
movq -0x10(%rbp), %rcx
movw $0xa, (%rcx)
movq -0x18(%rbp), %rcx
movw $0xa, (%rcx)
movw $0xa, 0x20(%rax)
movw $0x8, 0x22(%rax)
movw $0x2, 0x24(%rax)
jmp 0x2d0c8
jmp 0x2d0c8
jmp 0x2d0ca
addq $0x20, %rsp
popq %rbp
retq
// File: hariguchi[P]rtacl/./rtacl.hpp
// Function: rtacl::sockItem<sockaddr_in>::set(sockaddr_in&, sockaddr_in&, unsigned char, unsigned char)
void set (SADDR& src, SADDR& dst, u8 proto, u8 dscp) {
        this->src =   src;
        this->dst =   dst;
        this->proto = proto;
        this->dscp  = dscp;
    }

// Assembly:
pushq %rbp
movq %rsp, %rbp
movb %r8b, %al
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movb %cl, -0x19(%rbp)
movb %al, -0x1a(%rbp)
movq -0x8(%rbp), %rax
movq -0x10(%rbp), %rcx
movq (%rcx), %rdx
movq %rdx, (%rax)
movq 0x8(%rcx), %rcx
movq %rcx, 0x8(%rax)
movq -0x18(%rbp), %rcx
movq (%rcx), %rdx
movq %rdx, 0x10(%rax)
movq 0x8(%rcx), %rcx
movq %rcx, 0x18(%rax)
movb -0x19(%rbp), %cl
movb %cl, 0x26(%rax)
movb -0x1a(%rbp), %cl
movb %cl, 0x27(%rax)
popq %rbp
retq
// File: hariguchi[P]rtacl/./rtacl.hpp
// Function: rtacl::db<long>::makeTuple(sockaddr_in const&, sockaddr_in const&, unsigned char, unsigned char, int, boost::geometry::model::point<long, 6ul, boost::geometry::cs::cartesian>&)
inline void
db<ADDR>::makeTuple (const sockaddr_in& src,
                     const sockaddr_in& dst,
                     const u8 proto,
                     const u8 dscp,
                     const s32 offset,
                     tuple<rtacl::ipv4a>& result)
{
    assert(af == AF_INET);

    s64 val;

    val = static_cast<s64>(ntohl(src.sin_addr.s_addr)) + offset;
    bg::set<0>(result, val);
    val = static_cast<s64>(ntohl(dst.sin_addr.s_addr)) + offset;
    bg::set<1>(result, val);
    val = static_cast<s64>(ntohs(src.sin_port)) + offset;
    bg::set<2>(result, val);
    val = static_cast<s64>(ntohs(dst.sin_port)) + offset;
    bg::set<3>(result, val);
    val = static_cast<s64>(proto) + offset;
    bg::set<4>(result, val);
    val = static_cast<s64>(dscp) + offset;
    bg::set<5>(result, val);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movb %r8b, %al
movq 0x10(%rbp), %r8
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movb %cl, -0x19(%rbp)
movb %al, -0x1a(%rbp)
movl %r9d, -0x20(%rbp)
movq -0x8(%rbp), %rax
movzwl 0x18(%rax), %eax
cmpl $0x2, %eax
jne 0x2d794
jmp 0x2d7b3
leaq 0x3978c(%rip), %rdi     # 0x66f27
leaq 0x327ce(%rip), %rsi     # 0x5ff70
movl $0x25b, %edx            # imm = 0x25B
leaq 0x39787(%rip), %rcx     # 0x66f35
callq 0x5220
movq -0x10(%rbp), %rax
movl 0x4(%rax), %edi
callq 0x5470
movl %eax, %eax
movslq -0x20(%rbp), %rcx
addq %rcx, %rax
movq %rax, -0x28(%rbp)
movq 0x10(%rbp), %rdi
leaq -0x28(%rbp), %rsi
xorl %eax, %eax
movl %eax, %edx
callq 0xb5a0
movq -0x18(%rbp), %rax
movl 0x4(%rax), %edi
callq 0x5470
movl %eax, %eax
movslq -0x20(%rbp), %rcx
addq %rcx, %rax
movq %rax, -0x28(%rbp)
movq 0x10(%rbp), %rdi
leaq -0x28(%rbp), %rsi
xorl %eax, %eax
movl %eax, %edx
callq 0xb5d0
movq -0x10(%rbp), %rax
movzwl 0x2(%rax), %edi
callq 0x5690
movzwl %ax, %eax
movslq -0x20(%rbp), %rcx
addq %rcx, %rax
movq %rax, -0x28(%rbp)
movq 0x10(%rbp), %rdi
leaq -0x28(%rbp), %rsi
xorl %eax, %eax
movl %eax, %edx
callq 0xb600
movq -0x18(%rbp), %rax
movzwl 0x2(%rax), %edi
callq 0x5690
movzwl %ax, %eax
movslq -0x20(%rbp), %rcx
addq %rcx, %rax
movq %rax, -0x28(%rbp)
movq 0x10(%rbp), %rdi
leaq -0x28(%rbp), %rsi
xorl %eax, %eax
movl %eax, %edx
callq 0xb630
movzbl -0x19(%rbp), %eax
movslq -0x20(%rbp), %rcx
addq %rcx, %rax
movq %rax, -0x28(%rbp)
movq 0x10(%rbp), %rdi
leaq -0x28(%rbp), %rsi
xorl %eax, %eax
movl %eax, %edx
callq 0xb660
movzbl -0x1a(%rbp), %eax
movslq -0x20(%rbp), %rcx
addq %rcx, %rax
movq %rax, -0x28(%rbp)
movq 0x10(%rbp), %rdi
leaq -0x28(%rbp), %rsi
xorl %eax, %eax
movl %eax, %edx
callq 0xb690
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
nop
// File: hariguchi[P]rtacl/./rtacl.hpp
// Function: rtacl::sockItem<sockaddr_in>::str[abi:cxx11]()
inline std::string
sockItem<SADDR>::str ()
{
    char src[64];
    char dst[64];
    inet_ntop(af, getsa(), src, sizeof(src));
    inet_ntop(af, getda(), dst, sizeof(dst));
    return (boost::format("%s, %s, %d, %d, %d, %d")
            % src
            % dst
            % (u32)(getsp())
            % (u32)(getdp())
            % (u32)(getProto())
            % (u32)(getDSCP())).str();

}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x200, %rsp            # imm = 0x200
movq %rdi, -0x1d0(%rbp)
movq %rdi, %rax
movq %rax, -0x1c8(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x10(%rbp), %rdi
movq %rdi, -0x1b8(%rbp)
movzwl 0x20(%rdi), %eax
movl %eax, -0x1bc(%rbp)
callq 0x2dd10
movl -0x1bc(%rbp), %edi
movq %rax, %rsi
leaq -0x50(%rbp), %rdx
movq %rdx, -0x1a0(%rbp)
movl $0x40, %ecx
movl %ecx, -0x1ac(%rbp)
callq 0x53a0
movq -0x1b8(%rbp), %rdi
movzwl 0x20(%rdi), %eax
movl %eax, -0x1b0(%rbp)
callq 0x2dd30
movl -0x1b0(%rbp), %edi
movl -0x1ac(%rbp), %ecx
movq %rax, %rsi
leaq -0x90(%rbp), %rdx
callq 0x53a0
leaq 0x32034(%rip), %rsi     # 0x5ffbe
leaq -0x170(%rbp), %rdi
movq %rdi, -0x1a8(%rbp)
callq 0xa390
movq -0x1a8(%rbp), %rdi
movq -0x1a0(%rbp), %rsi
callq 0x2dd50
movq %rax, -0x198(%rbp)
jmp 0x2dfb9
movq -0x198(%rbp), %rdi
leaq -0x90(%rbp), %rsi
callq 0x2dd50
movq %rax, -0x1d8(%rbp)
jmp 0x2dfd5
movq -0x1b8(%rbp), %rdi
callq 0x2dd80
movq -0x1d8(%rbp), %rdi
movzwl %ax, %eax
movl %eax, -0x180(%rbp)
leaq -0x180(%rbp), %rsi
callq 0x26fe0
movq %rax, -0x1e0(%rbp)
jmp 0x2e006
movq -0x1b8(%rbp), %rdi
callq 0x2ddb0
movq -0x1e0(%rbp), %rdi
movzwl %ax, %eax
movl %eax, -0x184(%rbp)
leaq -0x184(%rbp), %rsi
callq 0x26fe0
movq %rax, -0x1e8(%rbp)
jmp 0x2e037
movq -0x1b8(%rbp), %rdi
callq 0x2d2d0
movq -0x1e8(%rbp), %rdi
movzbl %al, %eax
movl %eax, -0x188(%rbp)
leaq -0x188(%rbp), %rsi
callq 0x26fe0
movq %rax, -0x1f0(%rbp)
jmp 0x2e068
movq -0x1b8(%rbp), %rdi
callq 0x2d2f0
movq -0x1f0(%rbp), %rdi
movzbl %al, %eax
movl %eax, -0x18c(%rbp)
leaq -0x18c(%rbp), %rsi
callq 0x26fe0
movq %rax, -0x1f8(%rbp)
jmp 0x2e099
movq -0x1f8(%rbp), %rsi
movq -0x1d0(%rbp), %rdi
callq 0xa590
jmp 0x2e0ae
leaq -0x170(%rbp), %rdi
callq 0xa7e0
movq -0x1c8(%rbp), %rax
addq $0x200, %rsp            # imm = 0x200
popq %rbp
retq
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x178(%rbp)
movl %eax, -0x17c(%rbp)
leaq -0x170(%rbp), %rdi
callq 0xa7e0
movq -0x178(%rbp), %rdi
callq 0x5640
nopw %cs:(%rax,%rax)
nop
// File: hariguchi[P]rtacl/./rtacl.hpp
// Function: boost::multiprecision::number<boost::multiprecision::backends::cpp_int_backend<256u, 256u, (boost::multiprecision::cpp_integer_type)1, (boost::multiprecision::cpp_int_check_type)0, void>, (boost::multiprecision::expression_template_option)0> rtacl::sin6a2int<boost::multiprecision::number<boost::multiprecision::backends::cpp_int_backend<256u, 256u, (boost::multiprecision::cpp_integer_type)1, (boost::multiprecision::cpp_int_check_type)0, void>, (boost::multiprecision::expression_template_option)0>>(sockaddr_in6 const&)
inline INT
sin6a2int (const sockaddr_in6& sin6)
{
    INT addr;
    size_t i;
    for (i = 0; i < elementsof(sin6.sin6_addr.s6_addr) - 1; ++i) {
        addr |= sin6.sin6_addr.s6_addr[i];
        addr <<= 8;
    }
    addr |= sin6.sin6_addr.s6_addr[i];
    return addr;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x28(%rbp)
movq %rdi, %rax
movq %rax, -0x20(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
callq 0x2f3d0
movq $0x0, -0x18(%rbp)
movq -0x18(%rbp), %rax
movq %rax, -0x30(%rbp)
movq -0x10(%rbp), %rdi
addq $0x8, %rdi
callq 0x30110
movq %rax, %rcx
movq -0x30(%rbp), %rax
subq $0x1, %rcx
cmpq %rcx, %rax
jae 0x2f4ee
movq -0x28(%rbp), %rdi
movq -0x10(%rbp), %rsi
addq $0x8, %rsi
addq -0x18(%rbp), %rsi
callq 0x30120
movq -0x28(%rbp), %rdi
movl $0x8, %esi
callq 0x30160
movq -0x18(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x18(%rbp)
jmp 0x2f498
movq -0x28(%rbp), %rdi
movq -0x10(%rbp), %rsi
addq $0x8, %rsi
addq -0x18(%rbp), %rsi
callq 0x30120
movq -0x20(%rbp), %rax
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax)
// File: hariguchi[P]rtacl/./rtacl.hpp
// Function: rtacl::ipv6a2s[abi:cxx11](boost::multiprecision::number<boost::multiprecision::backends::cpp_int_backend<256u, 256u, (boost::multiprecision::cpp_integer_type)1, (boost::multiprecision::cpp_int_check_type)0, void>, (boost::multiprecision::expression_template_option)0> const&)
inline std::string
ipv6a2s (const rtacl::ipv6a& a)
{
    sockaddr_in6 sa;
    char buf[64];

    memset(&sa, 0, sizeof(sa));
    sa.sin6_family = AF_INET6;
    size_t max = elementsof(sa.sin6_addr.s6_addr) - 1;
    size_t i;
    for (i = 0; i <= max; ++i) {
        u8 n = static_cast<u8>(a >> (i << 3));
        sa.sin6_addr.s6_addr[max - i] = n;
    }
    inet_ntop(AF_INET6, &sa.sin6_addr, buf, sizeof(buf));
    std::string s(buf);
    return s;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x100, %rsp            # imm = 0x100
movq %rdi, -0xf0(%rbp)
movq %rdi, %rax
movq %rax, -0xe8(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
leaq -0x2c(%rbp), %rdi
xorl %esi, %esi
movl $0x1c, %edx
callq 0x51b0
movw $0xa, -0x2c(%rbp)
leaq -0x2c(%rbp), %rdi
addq $0x8, %rdi
callq 0x47130
subq $0x1, %rax
movq %rax, -0x78(%rbp)
movq $0x0, -0x80(%rbp)
movq -0x80(%rbp), %rax
cmpq -0x78(%rbp), %rax
ja 0x46fc9
movq -0x10(%rbp), %rsi
movq -0x80(%rbp), %rax
shlq $0x3, %rax
movq %rax, -0xc8(%rbp)
leaq -0xc0(%rbp), %rdi
leaq -0xc8(%rbp), %rdx
callq 0x47140
leaq -0xc0(%rbp), %rdi
callq 0x471c0
movb %al, -0x81(%rbp)
movb -0x81(%rbp), %cl
movq -0x78(%rbp), %rax
subq -0x80(%rbp), %rax
movb %cl, -0x24(%rbp,%rax)
movq -0x80(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x80(%rbp)
jmp 0x46f67
leaq -0x24(%rbp), %rsi
movl $0xa, %edi
leaq -0x70(%rbp), %rdx
movq %rdx, -0x100(%rbp)
movl $0x40, %ecx
callq 0x53a0
movb $0x0, -0xc9(%rbp)
leaq -0xca(%rbp), %rdi
movq %rdi, -0xf8(%rbp)
callq 0x5650
movq -0xf0(%rbp), %rdi
movq -0x100(%rbp), %rsi
movq -0xf8(%rbp), %rdx
callq 0x19190
jmp 0x4701d
leaq -0xca(%rbp), %rdi
callq 0x53c0
movb $0x1, -0xc9(%rbp)
testb $0x1, -0xc9(%rbp)
jne 0x47067
jmp 0x4705b
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0xd8(%rbp)
movl %eax, -0xdc(%rbp)
leaq -0xca(%rbp), %rdi
callq 0x53c0
jmp 0x47077
movq -0xf0(%rbp), %rdi
callq 0x51e0
movq -0xe8(%rbp), %rax
addq $0x100, %rsp            # imm = 0x100
popq %rbp
retq
movq -0xd8(%rbp), %rdi
callq 0x5640
nopw %cs:(%rax,%rax)
nopl (%rax)
// File: myudelson[P]hmm-scalable/utils.cpp
// Function: projsimplex(double*, signed char)
void projsimplex(NUMBER* y, NPAR size) {
    
	bool bget = false;
	NUMBER *s = init1D<NUMBER>((NDAT)size);
	cpy1D<NUMBER>(y, s, (NDAT)size);
	
	qsortNumberRev(s, size);
	NUMBER tmpsum = 0, tmax = 0;
    
	for(NPAR i=0; i<(size-1); i++) {
		tmpsum = tmpsum + s[i];
		tmax = (tmpsum - 1)/(i+1);
		if(tmax >= s[i+1]) {
			bget = true;
			break;
		}
	}
	if(!bget) tmax = (tmpsum + s[size-1] -1)/size;
	free(s);
    
	for(NPAR i=0; i<size; i++)
		y[i] = ((y[i]-tmax)<0)?0:(y[i]-tmax);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movb %sil, %al
movq %rdi, -0x8(%rbp)
movb %al, -0x9(%rbp)
movb $0x0, -0xa(%rbp)
movsbl -0x9(%rbp), %edi
callq 0xc410
movq %rax, -0x18(%rbp)
movq -0x8(%rbp), %rdi
movq -0x18(%rbp), %rsi
movsbl -0x9(%rbp), %edx
callq 0xc440
movq -0x18(%rbp), %rdi
movsbl -0x9(%rbp), %esi
callq 0x7260
xorps %xmm0, %xmm0
movsd %xmm0, -0x20(%rbp)
xorps %xmm0, %xmm0
movsd %xmm0, -0x28(%rbp)
movb $0x0, -0x29(%rbp)
movsbl -0x29(%rbp), %eax
movsbl -0x9(%rbp), %ecx
subl $0x1, %ecx
cmpl %ecx, %eax
jge 0x73fd
movsd -0x20(%rbp), %xmm0
movq -0x18(%rbp), %rax
movsbq -0x29(%rbp), %rcx
addsd (%rax,%rcx,8), %xmm0
movsd %xmm0, -0x20(%rbp)
movsd -0x20(%rbp), %xmm0
movsd 0x4864f(%rip), %xmm1    # 0x4fa08
subsd %xmm1, %xmm0
movsbl -0x29(%rbp), %eax
addl $0x1, %eax
cvtsi2sd %eax, %xmm1
divsd %xmm1, %xmm0
movsd %xmm0, -0x28(%rbp)
movsd -0x28(%rbp), %xmm0
movq -0x18(%rbp), %rax
movsbl -0x29(%rbp), %ecx
addl $0x1, %ecx
movslq %ecx, %rcx
ucomisd (%rax,%rcx,8), %xmm0
jb 0x73f1
movb $0x1, -0xa(%rbp)
jmp 0x73fd
jmp 0x73f3
movb -0x29(%rbp), %al
addb $0x1, %al
movb %al, -0x29(%rbp)
jmp 0x7385
testb $0x1, -0xa(%rbp)
jne 0x7438
movsd -0x20(%rbp), %xmm0
movq -0x18(%rbp), %rax
movsbl -0x9(%rbp), %ecx
subl $0x1, %ecx
movslq %ecx, %rcx
addsd (%rax,%rcx,8), %xmm0
movsd 0x485e5(%rip), %xmm1    # 0x4fa08
subsd %xmm1, %xmm0
movsbl -0x9(%rbp), %eax
cvtsi2sd %eax, %xmm1
divsd %xmm1, %xmm0
movsd %xmm0, -0x28(%rbp)
movq -0x18(%rbp), %rdi
callq 0x5380
movb $0x0, -0x2a(%rbp)
movsbl -0x2a(%rbp), %eax
movsbl -0x9(%rbp), %ecx
cmpl %ecx, %eax
jge 0x74ac
movq -0x8(%rbp), %rax
movsbq -0x2a(%rbp), %rcx
movsd (%rax,%rcx,8), %xmm1
subsd -0x28(%rbp), %xmm1
xorps %xmm0, %xmm0
ucomisd %xmm1, %xmm0
jbe 0x7477
xorps %xmm0, %xmm0
movsd %xmm0, -0x38(%rbp)
jmp 0x748f
movq -0x8(%rbp), %rax
movsbq -0x2a(%rbp), %rcx
movsd (%rax,%rcx,8), %xmm0
subsd -0x28(%rbp), %xmm0
movsd %xmm0, -0x38(%rbp)
movsd -0x38(%rbp), %xmm0
movq -0x8(%rbp), %rax
movsbq -0x2a(%rbp), %rcx
movsd %xmm0, (%rax,%rcx,8)
movb -0x2a(%rbp), %al
addb $0x1, %al
movb %al, -0x2a(%rbp)
jmp 0x7445
addq $0x40, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: myudelson[P]hmm-scalable/utils.cpp
// Function: issimplex(double*, signed char)
bool issimplex(NUMBER* ar, NPAR size) {
	NUMBER sum = 1;
	for(NPAR i=0; i<size; i++) {
		sum -= ar[i];
		if( ar[i] < 0 || ar[i] > 1)
			return false;
	}
//    for(NPAR i=0; i<size && fabs(sum)<SAFETY && fabs(sum)>0; i++) {
//        if( (ar[i]+sum) >=0 ) {
//            ar[i]+=sum;
//            break;
//        }
//        if( (ar[i]+sum) <=1 ) {
//            ar[i]+=sum;
//            break;
//        }
//    }
	return fabs(sum)<SAFETY;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movb %sil, %al
movq %rdi, -0x10(%rbp)
movb %al, -0x11(%rbp)
movsd 0x48532(%rip), %xmm0    # 0x4fa08
movsd %xmm0, -0x20(%rbp)
movb $0x0, -0x21(%rbp)
movsbl -0x21(%rbp), %eax
movsbl -0x11(%rbp), %ecx
cmpl %ecx, %eax
jge 0x7548
movq -0x10(%rbp), %rax
movsbq -0x21(%rbp), %rcx
movsd (%rax,%rcx,8), %xmm1
movsd -0x20(%rbp), %xmm0
subsd %xmm1, %xmm0
movsd %xmm0, -0x20(%rbp)
movq -0x10(%rbp), %rax
movsbq -0x21(%rbp), %rcx
xorps %xmm0, %xmm0
ucomisd (%rax,%rcx,8), %xmm0
ja 0x7536
movq -0x10(%rbp), %rax
movsbq -0x21(%rbp), %rcx
movsd (%rax,%rcx,8), %xmm0
movsd 0x484d8(%rip), %xmm1    # 0x4fa08
ucomisd %xmm1, %xmm0
jbe 0x753c
movb $0x0, -0x1(%rbp)
jmp 0x756c
jmp 0x753e
movb -0x21(%rbp), %al
addb $0x1, %al
movb %al, -0x21(%rbp)
jmp 0x74df
movsd -0x20(%rbp), %xmm1
movaps 0x4853c(%rip), %xmm0    # 0x4fa90
pand %xmm0, %xmm1
movsd 0x484b0(%rip), %xmm0    # 0x4fa10
ucomisd %xmm1, %xmm0
seta %al
andb $0x1, %al
movb %al, -0x1(%rbp)
movb -0x1(%rbp), %al
andb $0x1, %al
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: myudelson[P]hmm-scalable/utils.cpp
// Function: issimplexbounded(double*, double*, double*, signed char)
bool issimplexbounded(NUMBER* ar, NUMBER *lb, NUMBER *ub, NPAR size) {
	NUMBER sum = 1;
	for(NPAR i=0; i<size; i++) {
		sum -= ar[i];
		if( ar[i] < lb[i] || ar[i] > ub[i])
			return false;
	}
//    for(NPAR i=0; i<size && fabs(sum)<SAFETY && fabs(sum)>0; i++) {
//        if( (ar[i]+sum) >=lb[i] ) {
//            ar[i]+=sum;
//            break;
//        }
//        if( (ar[i]+sum) <=ub[i] ) {
//            ar[i]+=sum;
//            break;
//        }
//    }
	return fabs(sum)<SAFETY;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movb %cl, %al
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movb %al, -0x21(%rbp)
movsd 0x4846b(%rip), %xmm0    # 0x4fa08
movsd %xmm0, -0x30(%rbp)
movb $0x0, -0x31(%rbp)
movsbl -0x31(%rbp), %eax
movsbl -0x21(%rbp), %ecx
cmpl %ecx, %eax
jge 0x7620
movq -0x10(%rbp), %rax
movsbq -0x31(%rbp), %rcx
movsd (%rax,%rcx,8), %xmm1
movsd -0x30(%rbp), %xmm0
subsd %xmm1, %xmm0
movsd %xmm0, -0x30(%rbp)
movq -0x10(%rbp), %rax
movsbq -0x31(%rbp), %rcx
movsd (%rax,%rcx,8), %xmm1
movq -0x18(%rbp), %rax
movsbq -0x31(%rbp), %rcx
movsd (%rax,%rcx,8), %xmm0
ucomisd %xmm1, %xmm0
ja 0x760e
movq -0x10(%rbp), %rax
movsbq -0x31(%rbp), %rcx
movsd (%rax,%rcx,8), %xmm0
movq -0x20(%rbp), %rax
movsbq -0x31(%rbp), %rcx
ucomisd (%rax,%rcx,8), %xmm0
jbe 0x7614
movb $0x0, -0x1(%rbp)
jmp 0x7644
jmp 0x7616
movb -0x31(%rbp), %al
addb $0x1, %al
movb %al, -0x31(%rbp)
jmp 0x75a6
movsd -0x30(%rbp), %xmm1
movaps 0x48464(%rip), %xmm0    # 0x4fa90
pand %xmm0, %xmm1
movsd 0x483d8(%rip), %xmm0    # 0x4fa10
ucomisd %xmm1, %xmm0
seta %al
andb $0x1, %al
movb %al, -0x1(%rbp)
movb -0x1(%rbp), %al
andb $0x1, %al
popq %rbp
retq
nopl (%rax,%rax)
// File: myudelson[P]hmm-scalable/utils.cpp
// Function: maxn(double*, int)
NUMBER maxn(NUMBER *ar, NDAT n) {
	NUMBER mx = ar[0];
	for(NDAT i=1; i<n; i++)
		if(ar[i]>mx) mx = ar[i];
	return mx;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movq -0x8(%rbp), %rax
movsd (%rax), %xmm0
movsd %xmm0, -0x18(%rbp)
movl $0x1, -0x1c(%rbp)
movl -0x1c(%rbp), %eax
cmpl -0xc(%rbp), %eax
jge 0x9dda
movq -0x8(%rbp), %rax
movslq -0x1c(%rbp), %rcx
movsd (%rax,%rcx,8), %xmm0
ucomisd -0x18(%rbp), %xmm0
jbe 0x9dcd
movq -0x8(%rbp), %rax
movslq -0x1c(%rbp), %rcx
movsd (%rax,%rcx,8), %xmm0
movsd %xmm0, -0x18(%rbp)
jmp 0x9dcf
movl -0x1c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x1c(%rbp)
jmp 0x9d9f
movsd -0x18(%rbp), %xmm0
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: myudelson[P]hmm-scalable/utils.cpp
// Function: add3DNumbersWeighted(double***, double***, signed char, signed char, signed char, double)
void add3DNumbersWeighted(NUMBER*** sourse, NUMBER*** target, NPAR size1, NPAR size2, NPAR size3, NUMBER weight) {
    for(NPAR i=0; i<size1; i++)
        for(NPAR j=0; j<size2; j++)
            for(NPAR l=0; l<size3; l++)
                target[i][j][l] = target[i][j][l] + sourse[i][j][l]*weight;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movb %r8b, %al
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movb %dl, -0x11(%rbp)
movb %cl, -0x12(%rbp)
movb %al, -0x13(%rbp)
movsd %xmm0, -0x20(%rbp)
movb $0x0, -0x21(%rbp)
movsbl -0x21(%rbp), %eax
movsbl -0x11(%rbp), %ecx
cmpl %ecx, %eax
jge 0xa03d
movb $0x0, -0x22(%rbp)
movsbl -0x22(%rbp), %eax
movsbl -0x12(%rbp), %ecx
cmpl %ecx, %eax
jge 0xa02e
movb $0x0, -0x23(%rbp)
movsbl -0x23(%rbp), %eax
movsbl -0x13(%rbp), %ecx
cmpl %ecx, %eax
jge 0xa01f
movq -0x10(%rbp), %rax
movsbq -0x21(%rbp), %rcx
movq (%rax,%rcx,8), %rax
movsbq -0x22(%rbp), %rcx
movq (%rax,%rcx,8), %rax
movsbq -0x23(%rbp), %rcx
movsd (%rax,%rcx,8), %xmm1
movq -0x8(%rbp), %rax
movsbq -0x21(%rbp), %rcx
movq (%rax,%rcx,8), %rax
movsbq -0x22(%rbp), %rcx
movq (%rax,%rcx,8), %rax
movsbq -0x23(%rbp), %rcx
movsd (%rax,%rcx,8), %xmm0
movsd -0x20(%rbp), %xmm2
mulsd %xmm2, %xmm0
addsd %xmm1, %xmm0
movq -0x10(%rbp), %rax
movsbq -0x21(%rbp), %rcx
movq (%rax,%rcx,8), %rax
movsbq -0x22(%rbp), %rcx
movq (%rax,%rcx,8), %rax
movsbq -0x23(%rbp), %rcx
movsd %xmm0, (%rax,%rcx,8)
movb -0x23(%rbp), %al
addb $0x1, %al
movb %al, -0x23(%rbp)
jmp 0x9f99
jmp 0xa021
movb -0x22(%rbp), %al
addb $0x1, %al
movb %al, -0x22(%rbp)
jmp 0x9f85
jmp 0xa030
movb -0x21(%rbp), %al
addb $0x1, %al
movb %al, -0x21(%rbp)
jmp 0x9f71
popq %rbp
retq
nop
// File: myudelson[P]hmm-scalable/utils.cpp
// Function: isPasses(double*, signed char)
bool isPasses(NUMBER* ar, NPAR size) {
	NUMBER sum = 0;
	for(NPAR i=0; i<size; i++) {
		if( ar[i]<0 || ar[i]>1)
			return false;
		sum += ar[i];
	}
	return sum==1;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movb %sil, %al
movq %rdi, -0x10(%rbp)
movb %al, -0x11(%rbp)
xorps %xmm0, %xmm0
movsd %xmm0, -0x20(%rbp)
movb $0x0, -0x21(%rbp)
movsbl -0x21(%rbp), %eax
movsbl -0x11(%rbp), %ecx
cmpl %ecx, %eax
jge 0xa0bd
movq -0x10(%rbp), %rax
movsbq -0x21(%rbp), %rcx
xorps %xmm0, %xmm0
ucomisd (%rax,%rcx,8), %xmm0
ja 0xa095
movq -0x10(%rbp), %rax
movsbq -0x21(%rbp), %rcx
movsd (%rax,%rcx,8), %xmm0
movsd 0x45979(%rip), %xmm1    # 0x4fa08
ucomisd %xmm1, %xmm0
jbe 0xa09b
movb $0x0, -0x1(%rbp)
jmp 0xa0db
movq -0x10(%rbp), %rax
movsbq -0x21(%rbp), %rcx
movsd (%rax,%rcx,8), %xmm0
addsd -0x20(%rbp), %xmm0
movsd %xmm0, -0x20(%rbp)
movb -0x21(%rbp), %al
addb $0x1, %al
movb %al, -0x21(%rbp)
jmp 0xa05a
movsd -0x20(%rbp), %xmm0
movsd 0x4593e(%rip), %xmm1    # 0x4fa08
ucomisd %xmm1, %xmm0
sete %al
setnp %cl
andb %cl, %al
andb $0x1, %al
movb %al, -0x1(%rbp)
movb -0x1(%rbp), %al
andb $0x1, %al
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: myudelson[P]hmm-scalable/utils.cpp
// Function: isPassesLim(double*, signed char, double*, double*)
bool isPassesLim(NUMBER* ar, NPAR size, NUMBER *lb, NUMBER* ub) {
	NUMBER sum = 0;
	for(NPAR i=0; i<size; i++) {
		if( (lb[i]-ar[i])>SAFETY || (ar[i]-ub[i])>SAFETY )
			return false;
		sum += ar[i];
	}
	return fabs(sum-1)<SAFETY;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movb %sil, %al
movq %rdi, -0x10(%rbp)
movb %al, -0x11(%rbp)
movq %rdx, -0x20(%rbp)
movq %rcx, -0x28(%rbp)
xorps %xmm0, %xmm0
movsd %xmm0, -0x30(%rbp)
movb $0x0, -0x31(%rbp)
movsbl -0x31(%rbp), %eax
movsbl -0x11(%rbp), %ecx
cmpl %ecx, %eax
jge 0xa19d
movq -0x20(%rbp), %rax
movsbq -0x31(%rbp), %rcx
movsd (%rax,%rcx,8), %xmm0
movq -0x10(%rbp), %rax
movsbq -0x31(%rbp), %rcx
subsd (%rax,%rcx,8), %xmm0
movsd 0x458ce(%rip), %xmm1    # 0x4fa10
ucomisd %xmm1, %xmm0
ja 0xa172
movq -0x10(%rbp), %rax
movsbq -0x31(%rbp), %rcx
movsd (%rax,%rcx,8), %xmm0
movq -0x28(%rbp), %rax
movsbq -0x31(%rbp), %rcx
subsd (%rax,%rcx,8), %xmm0
movsd 0x458a4(%rip), %xmm1    # 0x4fa10
ucomisd %xmm1, %xmm0
jbe 0xa178
movb $0x0, -0x1(%rbp)
jmp 0xa1cd
movq -0x10(%rbp), %rax
movsbq -0x31(%rbp), %rcx
movsd (%rax,%rcx,8), %xmm0
addsd -0x30(%rbp), %xmm0
movsd %xmm0, -0x30(%rbp)
movb -0x31(%rbp), %al
addb $0x1, %al
movb %al, -0x31(%rbp)
jmp 0xa112
movsd -0x30(%rbp), %xmm1
movsd 0x4585e(%rip), %xmm0    # 0x4fa08
subsd %xmm0, %xmm1
movaps 0x458db(%rip), %xmm0    # 0x4fa90
pand %xmm0, %xmm1
movsd 0x4584f(%rip), %xmm0    # 0x4fa10
ucomisd %xmm1, %xmm0
seta %al
andb $0x1, %al
movb %al, -0x1(%rbp)
movb -0x1(%rbp), %al
andb $0x1, %al
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: myudelson[P]hmm-scalable/utils.cpp
// Function: doLog10Scale1D(double*, signed char)
NUMBER doLog10Scale1D(NUMBER *ar, NPAR size) {
	NPAR i;
	NUMBER min_10_scale = 1000, max_10_scale = 0, candidate;
	for(i=0; i<size; i++) {
		if( fabs(ar[i]) < SAFETY ) // 0 gradient
			continue;
		candidate = floor( log10( fabs(ar[i]) ) );
		if(candidate < min_10_scale)
			min_10_scale = candidate;
		candidate = ceil( log10( fabs(ar[i]) ) );
		if(candidate > max_10_scale)
			max_10_scale = candidate;
	}
	min_10_scale++;
	max_10_scale++;
	if(max_10_scale > 0)
		for(i=0; i<size; i++)
			ar[i] = ar[i] / pow(10, max_10_scale);
    //	if(min_10_scale<1000)
    //		for(i=0; i<size; i++)
    //			ar[i] = ar[i] / pow(10, min_10_scale);
	return pow(10, max_10_scale);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movb %sil, %al
movq %rdi, -0x8(%rbp)
movb %al, -0x9(%rbp)
movsd 0x4582e(%rip), %xmm0    # 0x4fa28
movsd %xmm0, -0x18(%rbp)
xorps %xmm0, %xmm0
movsd %xmm0, -0x20(%rbp)
movb $0x0, -0xa(%rbp)
movsbl -0xa(%rbp), %eax
movsbl -0x9(%rbp), %ecx
cmpl %ecx, %eax
jge 0xa2d6
movq -0x8(%rbp), %rax
movsbq -0xa(%rbp), %rcx
movsd (%rax,%rcx,8), %xmm1
movaps 0x45860(%rip), %xmm0    # 0x4fa90
pand %xmm0, %xmm1
movsd 0x457d4(%rip), %xmm0    # 0x4fa10
ucomisd %xmm1, %xmm0
jbe 0xa247
jmp 0xa2c9
movq -0x8(%rbp), %rax
movsbq -0xa(%rbp), %rcx
movsd (%rax,%rcx,8), %xmm0
movaps 0x45834(%rip), %xmm1    # 0x4fa90
pand %xmm1, %xmm0
callq 0x5140
callq 0x5500
movsd %xmm0, -0x28(%rbp)
movsd -0x28(%rbp), %xmm1
movsd -0x18(%rbp), %xmm0
ucomisd %xmm1, %xmm0
jbe 0xa289
movsd -0x28(%rbp), %xmm0
movsd %xmm0, -0x18(%rbp)
movq -0x8(%rbp), %rax
movsbq -0xa(%rbp), %rcx
movsd (%rax,%rcx,8), %xmm0
movaps 0x457f2(%rip), %xmm1    # 0x4fa90
pand %xmm1, %xmm0
callq 0x5140
callq 0x50a0
movsd %xmm0, -0x28(%rbp)
movsd -0x28(%rbp), %xmm0
ucomisd -0x20(%rbp), %xmm0
jbe 0xa2c7
movsd -0x28(%rbp), %xmm0
movsd %xmm0, -0x20(%rbp)
jmp 0xa2c9
movb -0xa(%rbp), %al
addb $0x1, %al
movb %al, -0xa(%rbp)
jmp 0xa20b
movsd 0x4572a(%rip), %xmm0    # 0x4fa08
addsd -0x18(%rbp), %xmm0
movsd %xmm0, -0x18(%rbp)
movsd 0x45718(%rip), %xmm0    # 0x4fa08
addsd -0x20(%rbp), %xmm0
movsd %xmm0, -0x20(%rbp)
movsd -0x20(%rbp), %xmm0
xorps %xmm1, %xmm1
ucomisd %xmm1, %xmm0
jbe 0xa360
movb $0x0, -0xa(%rbp)
movsbl -0xa(%rbp), %eax
movsbl -0x9(%rbp), %ecx
cmpl %ecx, %eax
jge 0xa35e
movq -0x8(%rbp), %rax
movsbq -0xa(%rbp), %rcx
movsd (%rax,%rcx,8), %xmm0
movsd %xmm0, -0x30(%rbp)
movsd -0x20(%rbp), %xmm0
movl $0xa, %edi
callq 0xc7b0
movaps %xmm0, %xmm1
movsd -0x30(%rbp), %xmm0
divsd %xmm1, %xmm0
movq -0x8(%rbp), %rax
movsbq -0xa(%rbp), %rcx
movsd %xmm0, (%rax,%rcx,8)
movb -0xa(%rbp), %al
addb $0x1, %al
movb %al, -0xa(%rbp)
jmp 0xa30c
jmp 0xa360
movsd -0x20(%rbp), %xmm0
movl $0xa, %edi
callq 0xc7b0
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: myudelson[P]hmm-scalable/utils.cpp
// Function: zeroLabels(int, data**)
void zeroLabels(NCAT xdat, struct data** x_data) { // set counts in data sequences to zero
	NCAT x;
	for(x=0; x<xdat; x++)
		x_data[x][0].cnt = 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movl %edi, -0x4(%rbp)
movq %rsi, -0x10(%rbp)
movl $0x0, -0x14(%rbp)
movl -0x14(%rbp), %eax
cmpl -0x4(%rbp), %eax
jge 0xb1c8
movq -0x10(%rbp), %rax
movslq -0x14(%rbp), %rcx
movq (%rax,%rcx,8), %rax
movl $0x0, 0x4(%rax)
movl -0x14(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x14(%rbp)
jmp 0xb1a2
popq %rbp
retq
nopw (%rax,%rax)
// File: myudelson[P]hmm-scalable/utils.cpp
// Function: writeSolverInfo(_IO_FILE*, param*)
void writeSolverInfo(FILE *fid, struct param *param) {
    // solver id
    if( param->solver_setting>0 ) {
        fprintf(fid,"SolverId\t%d.%d.%d\n",param->structure,param->solver,param->solver_setting);
    } else {
        fprintf(fid,"SolverId\t%d.%d\n",param->structure,param->solver);
    }
	// nK
    fprintf(fid,"nK\t%d\n",param->nK);
    // nG
    fprintf(fid,"nG\t%d\n",param->nG);
    // nS
    fprintf(fid,"nS\t%d\n",param->nS);
    // nO
    fprintf(fid,"nO\t%d\n",param->nO);
    // nZ
    fprintf(fid,"nZ\t%d\n",param->nZ);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x10(%rbp), %rax
movsbl 0x40(%rax), %eax
cmpl $0x0, %eax
jle 0xbcba
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rax
movsbl 0x3e(%rax), %edx
movq -0x10(%rbp), %rax
movsbl 0x3f(%rax), %ecx
movq -0x10(%rbp), %rax
movsbl 0x40(%rax), %r8d
leaq 0x43f0c(%rip), %rsi     # 0x4fbbd
movb $0x0, %al
callq 0x5440
jmp 0xbcdc
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rax
movsbl 0x3e(%rax), %edx
movq -0x10(%rbp), %rax
movsbl 0x3f(%rax), %ecx
leaq 0x43efb(%rip), %rsi     # 0x4fbd0
movb $0x0, %al
callq 0x5440
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rax
movl 0x8c0(%rax), %edx
leaq 0x43eef(%rip), %rsi     # 0x4fbe0
movb $0x0, %al
callq 0x5440
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rax
movl 0x8bc(%rax), %edx
leaq 0x43eda(%rip), %rsi     # 0x4fbe7
movb $0x0, %al
callq 0x5440
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rax
movsbl 0x8b8(%rax), %edx
leaq 0x43ec4(%rip), %rsi     # 0x4fbee
movb $0x0, %al
callq 0x5440
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rax
movsbl 0x8b9(%rax), %edx
leaq 0x43eae(%rip), %rsi     # 0x4fbf5
movb $0x0, %al
callq 0x5440
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rax
movsbl 0x8c8(%rax), %edx
leaq 0x43e98(%rip), %rsi     # 0x4fbfc
movb $0x0, %al
callq 0x5440
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: myudelson[P]hmm-scalable/utils.cpp
// Function: zeroLabels(param*)
void zeroLabels(struct param* param) { // set counts in data sequences to zero
	NCAT k,g;
	for(k=0; k<param->nK; k++)
		for(g=0; g<param->k_numg[k]; g++)
			param->k_g_data[k][g]->cnt = 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movl $0x0, -0xc(%rbp)
movl -0xc(%rbp), %eax
movq -0x8(%rbp), %rcx
cmpl 0x8c0(%rcx), %eax
jge 0xbfc6
movl $0x0, -0x10(%rbp)
movl -0x10(%rbp), %eax
movq -0x8(%rbp), %rcx
movq 0x8e0(%rcx), %rcx
movslq -0xc(%rbp), %rdx
cmpl (%rcx,%rdx,4), %eax
jge 0xbfb9
movq -0x8(%rbp), %rax
movq 0x8f8(%rax), %rax
movslq -0xc(%rbp), %rcx
movq (%rax,%rcx,8), %rax
movslq -0x10(%rbp), %rcx
movq (%rax,%rcx,8), %rax
movl $0x0, 0x4(%rax)
movl -0x10(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x10(%rbp)
jmp 0xbf75
jmp 0xbfbb
movl -0xc(%rbp), %eax
addl $0x1, %eax
movl %eax, -0xc(%rbp)
jmp 0xbf5f
popq %rbp
retq
nopl (%rax,%rax)
// File: myudelson[P]hmm-scalable/utils.cpp
// Function: sec_to_linear_interval(int, int*, signed char)
NPAR sec_to_linear_interval(int time, int *limits, NPAR nlimits){
    for(NPAR i=0; i<nlimits; i++)
        if( time < limits[i] )
            return i;
    return nlimits;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movb %dl, %al
movl %edi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movb %al, -0x11(%rbp)
movb $0x0, -0x12(%rbp)
movsbl -0x12(%rbp), %eax
movsbl -0x11(%rbp), %ecx
cmpl %ecx, %eax
jge 0xc1e5
movl -0x8(%rbp), %eax
movq -0x10(%rbp), %rcx
movsbq -0x12(%rbp), %rdx
cmpl (%rcx,%rdx,4), %eax
jge 0xc1d9
movb -0x12(%rbp), %al
movb %al, -0x1(%rbp)
jmp 0xc1eb
jmp 0xc1db
movb -0x12(%rbp), %al
addb $0x1, %al
movb %al, -0x12(%rbp)
jmp 0xc1b4
movb -0x11(%rbp), %al
movb %al, -0x1(%rbp)
movb -0x1(%rbp), %al
popq %rbp
retq
// File: myudelson[P]hmm-scalable/./utils.h
// Function: void free2D<double>(double**, int)
void free2D(T** ar, NDAT size1) {
	for(NDAT i=0; i<size1; i++)
		free(ar[i]);
	free(ar);
    //    &ar = NULL;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movl $0x0, -0x10(%rbp)
movl -0x10(%rbp), %eax
cmpl -0xc(%rbp), %eax
jge 0xc82a
movq -0x8(%rbp), %rax
movslq -0x10(%rbp), %rcx
movq (%rax,%rcx,8), %rdi
callq 0x5380
movl -0x10(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x10(%rbp)
jmp 0xc806
movq -0x8(%rbp), %rdi
callq 0x5380
addq $0x10, %rsp
popq %rbp
retq
nopl (%rax)
// File: myudelson[P]hmm-scalable/FitBit.cpp
// Function: FitBit::FitBit(signed char, signed char, int, int, double, signed char)
FitBit::FitBit(NPAR a_nS, NPAR a_nO, NCAT a_nK, NCAT a_nG, NUMBER a_tol, NPAR a_tol_mode) {
    this->nS = a_nS;
    this->nO = a_nO;
    this->nG = a_nG;
    this->nK = a_nK;
    this->tol = a_tol;
    this->tol_mode = a_tol_mode;
    this->pi = NULL;
    this->A = NULL;
    this->B = NULL;
    this->PIm1 = NULL;
    this->Am1 = NULL;
    this->Bm1 = NULL;
    this->PIm2 = NULL;
    this->Am2 = NULL;
    this->Bm2 = NULL;
    this->gradPI = NULL;
    this->gradA = NULL;
    this->gradB = NULL;
    this->gradPIm1 = NULL;
    this->gradAm1 = NULL;
    this->gradBm1 = NULL;
    this->gradPIcopy = NULL;
    this->gradAcopy = NULL;
    this->gradBcopy = NULL;
    this->PIcopy = NULL;
    this->Acopy = NULL;
    this->Bcopy = NULL;
    this->dirPI = NULL;
    this->dirA = NULL;
    this->dirB = NULL;
    this->dirPIm1 = NULL;
    this->dirAm1 = NULL;
    this->dirBm1 = NULL;
    this->xndat = 0;
    this->x_data = 0;
    this->projecttosimplex = 1;
    this->observe_non01_boundaries = 1;
    this->Cslice = 0;
    this->tag = 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movb %r9b, %al
movq %rdi, -0x8(%rbp)
movb %sil, -0x9(%rbp)
movb %dl, -0xa(%rbp)
movl %ecx, -0x10(%rbp)
movl %r8d, -0x14(%rbp)
movsd %xmm0, -0x20(%rbp)
movb %al, -0x21(%rbp)
movq -0x8(%rbp), %rax
movb -0x9(%rbp), %cl
movb %cl, 0x1(%rax)
movb -0xa(%rbp), %cl
movb %cl, (%rax)
movl -0x14(%rbp), %ecx
movl %ecx, 0x4(%rax)
movl -0x10(%rbp), %ecx
movl %ecx, 0x8(%rax)
movsd -0x20(%rbp), %xmm0
movsd %xmm0, 0x100(%rax)
movb -0x21(%rbp), %cl
movb %cl, 0x108(%rax)
movq $0x0, 0x10(%rax)
movq $0x0, 0x18(%rax)
movq $0x0, 0x20(%rax)
movq $0x0, 0x28(%rax)
movq $0x0, 0x30(%rax)
movq $0x0, 0x38(%rax)
movq $0x0, 0x40(%rax)
movq $0x0, 0x48(%rax)
movq $0x0, 0x50(%rax)
movq $0x0, 0x58(%rax)
movq $0x0, 0x60(%rax)
movq $0x0, 0x68(%rax)
movq $0x0, 0x70(%rax)
movq $0x0, 0x78(%rax)
movq $0x0, 0x80(%rax)
movq $0x0, 0x88(%rax)
movq $0x0, 0x90(%rax)
movq $0x0, 0x98(%rax)
movq $0x0, 0xa0(%rax)
movq $0x0, 0xa8(%rax)
movq $0x0, 0xb0(%rax)
movq $0x0, 0xb8(%rax)
movq $0x0, 0xc0(%rax)
movq $0x0, 0xc8(%rax)
movq $0x0, 0xd0(%rax)
movq $0x0, 0xd8(%rax)
movq $0x0, 0xe0(%rax)
movl $0x0, 0xe8(%rax)
movq $0x0, 0xf0(%rax)
movb $0x1, 0xf8(%rax)
movb $0x1, 0xf9(%rax)
movb $0x0, 0xfa(%rax)
movb $0x0, 0xfb(%rax)
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: myudelson[P]hmm-scalable/FitBit.cpp
// Function: FitBit::init(double*&, double**&, double**&)
void FitBit::init(NUMBER* &a_PI, NUMBER** &a_A, NUMBER** &a_B) {
    if(this->pi != NULL) {
        if(a_PI == NULL)
            a_PI = init1D<NUMBER>((NDAT)this->nS); // init1DNumber(this->nS);
        else
            toZero1D<NUMBER>(a_PI, (NDAT)this->nS);
    }
    if(this->A  != NULL) {
        if(a_A == NULL)
            a_A  = init2D<NUMBER>((NDAT)this->nS, (NDAT)this->nS);
        else
            toZero2D<NUMBER>(a_A,  (NDAT)this->nS, (NDAT)this->nS);
    }
    if(this->B  != NULL) {
        if(a_B == NULL)
            a_B  = init2D<NUMBER>((NDAT)this->nS, (NDAT)this->nO);
        else
            toZero2D<NUMBER>(a_B, (NDAT)this->nS, (NDAT)this->nO);
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq %rcx, -0x20(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x28(%rbp)
cmpq $0x0, 0x10(%rax)
je 0xd730
movq -0x10(%rbp), %rax
cmpq $0x0, (%rax)
jne 0xd71a
movq -0x28(%rbp), %rax
movsbl 0x1(%rax), %edi
callq 0xc410
movq %rax, %rcx
movq -0x10(%rbp), %rax
movq %rcx, (%rax)
jmp 0xd72e
movq -0x28(%rbp), %rax
movq -0x10(%rbp), %rcx
movq (%rcx), %rdi
movsbl 0x1(%rax), %esi
callq 0xf540
jmp 0xd730
movq -0x28(%rbp), %rax
cmpq $0x0, 0x18(%rax)
je 0xd77c
movq -0x18(%rbp), %rax
cmpq $0x0, (%rax)
jne 0xd762
movq -0x28(%rbp), %rax
movsbl 0x1(%rax), %edi
movsbl 0x1(%rax), %esi
callq 0xf580
movq %rax, %rcx
movq -0x18(%rbp), %rax
movq %rcx, (%rax)
jmp 0xd77a
movq -0x28(%rbp), %rax
movq -0x18(%rbp), %rcx
movq (%rcx), %rdi
movsbl 0x1(%rax), %esi
movsbl 0x1(%rax), %edx
callq 0xf5f0
jmp 0xd77c
movq -0x28(%rbp), %rax
cmpq $0x0, 0x20(%rax)
je 0xd7c6
movq -0x20(%rbp), %rax
cmpq $0x0, (%rax)
jne 0xd7ad
movq -0x28(%rbp), %rax
movsbl 0x1(%rax), %edi
movsbl (%rax), %esi
callq 0xf580
movq %rax, %rcx
movq -0x20(%rbp), %rax
movq %rcx, (%rax)
jmp 0xd7c4
movq -0x28(%rbp), %rax
movq -0x20(%rbp), %rcx
movq (%rcx), %rdi
movsbl 0x1(%rax), %esi
movsbl (%rax), %edx
callq 0xf5f0
jmp 0xd7c6
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax)
// File: myudelson[P]hmm-scalable/FitBit.cpp
// Function: FitBit::negate(double*&, double**&, double**&)
void FitBit::negate(NUMBER* &a_PI, NUMBER** &a_A, NUMBER** &a_B) {
    if(this->pi != NULL) {
        for(NPAR i=0; i<this->nS; i++) a_PI[i] = -a_PI[i];
    }
    if(this->A  != NULL) {
        for(NPAR i=0; i<this->nS; i++)
            for(NPAR j=0; j<this->nS; j++)
                a_A[i][j] = -a_A[i][j];
    }
    if(this->B  != NULL) {
        for(NPAR i=0; i<this->nS; i++)
            for(NPAR m=0; m<this->nO; m++)
                a_B[i][m] = -a_B[i][m];
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq %rcx, -0x20(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x30(%rbp)
cmpq $0x0, 0x10(%rax)
je 0xd84c
movb $0x0, -0x21(%rbp)
movq -0x30(%rbp), %rcx
movsbl -0x21(%rbp), %eax
movsbl 0x1(%rcx), %ecx
cmpl %ecx, %eax
jge 0xd84a
movq -0x10(%rbp), %rax
movq (%rax), %rax
movsbq -0x21(%rbp), %rcx
movsd (%rax,%rcx,8), %xmm0
movq %xmm0, %rax
movabsq $-0x8000000000000000, %rcx # imm = 0x8000000000000000
xorq %rcx, %rax
movq %rax, %xmm0
movq -0x10(%rbp), %rax
movq (%rax), %rax
movsbq -0x21(%rbp), %rcx
movsd %xmm0, (%rax,%rcx,8)
movb -0x21(%rbp), %al
addb $0x1, %al
movb %al, -0x21(%rbp)
jmp 0xd7f7
jmp 0xd84c
movq -0x30(%rbp), %rax
cmpq $0x0, 0x18(%rax)
je 0xd8e9
movb $0x0, -0x22(%rbp)
movq -0x30(%rbp), %rcx
movsbl -0x22(%rbp), %eax
movsbl 0x1(%rcx), %ecx
cmpl %ecx, %eax
jge 0xd8e7
movb $0x0, -0x23(%rbp)
movq -0x30(%rbp), %rcx
movsbl -0x23(%rbp), %eax
movsbl 0x1(%rcx), %ecx
cmpl %ecx, %eax
jge 0xd8d8
movq -0x18(%rbp), %rax
movq (%rax), %rax
movsbq -0x22(%rbp), %rcx
movq (%rax,%rcx,8), %rax
movsbq -0x23(%rbp), %rcx
movsd (%rax,%rcx,8), %xmm0
movq %xmm0, %rax
movabsq $-0x8000000000000000, %rcx # imm = 0x8000000000000000
xorq %rcx, %rax
movq %rax, %xmm0
movq -0x18(%rbp), %rax
movq (%rax), %rax
movsbq -0x22(%rbp), %rcx
movq (%rax,%rcx,8), %rax
movsbq -0x23(%rbp), %rcx
movsd %xmm0, (%rax,%rcx,8)
movb -0x23(%rbp), %al
addb $0x1, %al
movb %al, -0x23(%rbp)
jmp 0xd873
jmp 0xd8da
movb -0x22(%rbp), %al
addb $0x1, %al
movb %al, -0x22(%rbp)
jmp 0xd85f
jmp 0xd8e9
movq -0x30(%rbp), %rax
cmpq $0x0, 0x20(%rax)
je 0xd985
movb $0x0, -0x24(%rbp)
movq -0x30(%rbp), %rcx
movsbl -0x24(%rbp), %eax
movsbl 0x1(%rcx), %ecx
cmpl %ecx, %eax
jge 0xd983
movb $0x0, -0x25(%rbp)
movq -0x30(%rbp), %rcx
movsbl -0x25(%rbp), %eax
movsbl (%rcx), %ecx
cmpl %ecx, %eax
jge 0xd974
movq -0x20(%rbp), %rax
movq (%rax), %rax
movsbq -0x24(%rbp), %rcx
movq (%rax,%rcx,8), %rax
movsbq -0x25(%rbp), %rcx
movsd (%rax,%rcx,8), %xmm0
movq %xmm0, %rax
movabsq $-0x8000000000000000, %rcx # imm = 0x8000000000000000
xorq %rcx, %rax
movq %rax, %xmm0
movq -0x20(%rbp), %rax
movq (%rax), %rax
movsbq -0x24(%rbp), %rcx
movq (%rax,%rcx,8), %rax
movsbq -0x25(%rbp), %rcx
movsd %xmm0, (%rax,%rcx,8)
movb -0x25(%rbp), %al
addb $0x1, %al
movb %al, -0x25(%rbp)
jmp 0xd910
jmp 0xd976
movb -0x24(%rbp), %al
addb $0x1, %al
movb %al, -0x24(%rbp)
jmp 0xd8fc
jmp 0xd985
popq %rbp
retq
nopw (%rax,%rax)
// File: myudelson[P]hmm-scalable/FitBit.cpp
// Function: FitBit::link(double*, double**, double**, int, data**)
void FitBit::link(NUMBER *a_PI, NUMBER **a_A, NUMBER **a_B, NCAT a_xndat, struct data** a_x_data) {
    this->pi = a_PI;
    this->A  = a_A;
    this->B  = a_B;
    this->xndat = a_xndat;
    this->x_data = a_x_data;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq %rcx, -0x20(%rbp)
movl %r8d, -0x24(%rbp)
movq %r9, -0x30(%rbp)
movq -0x8(%rbp), %rax
movq -0x10(%rbp), %rcx
movq %rcx, 0x10(%rax)
movq -0x18(%rbp), %rcx
movq %rcx, 0x18(%rax)
movq -0x20(%rbp), %rcx
movq %rcx, 0x20(%rax)
movl -0x24(%rbp), %ecx
movl %ecx, 0xe8(%rax)
movq -0x30(%rbp), %rcx
movq %rcx, 0xf0(%rax)
popq %rbp
retq
nop
// File: myudelson[P]hmm-scalable/FitBit.cpp
// Function: FitBit::destroy(double*&, double**&, double**&)
void FitBit::destroy(NUMBER* &a_PI, NUMBER** &a_A, NUMBER** &a_B) {
    if(this->pi != NULL && a_PI != NULL) free(a_PI);
    if(this->A  != NULL && a_A  != NULL) free2D<NUMBER>(a_A, (NDAT)this->nS);
    if(this->B  != NULL && a_B  != NULL) free2D<NUMBER>(a_B, (NDAT)this->nS);
    a_PI = NULL;
    a_A  = NULL;
    a_B  = NULL;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq %rcx, -0x20(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x28(%rbp)
cmpq $0x0, 0x10(%rax)
je 0xdc2d
movq -0x10(%rbp), %rax
cmpq $0x0, (%rax)
je 0xdc2d
movq -0x10(%rbp), %rax
movq (%rax), %rdi
callq 0x5380
movq -0x28(%rbp), %rax
cmpq $0x0, 0x18(%rax)
je 0xdc56
movq -0x18(%rbp), %rax
cmpq $0x0, (%rax)
je 0xdc56
movq -0x28(%rbp), %rax
movq -0x18(%rbp), %rcx
movq (%rcx), %rdi
movsbl 0x1(%rax), %esi
callq 0xc7f0
movq -0x28(%rbp), %rax
cmpq $0x0, 0x20(%rax)
je 0xdc7f
movq -0x20(%rbp), %rax
cmpq $0x0, (%rax)
je 0xdc7f
movq -0x28(%rbp), %rax
movq -0x20(%rbp), %rcx
movq (%rcx), %rdi
movsbl 0x1(%rax), %esi
callq 0xc7f0
movq -0x10(%rbp), %rax
movq $0x0, (%rax)
movq -0x18(%rbp), %rax
movq $0x0, (%rax)
movq -0x20(%rbp), %rax
movq $0x0, (%rax)
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)