LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_cpp_makefile_star2_O2/hariguchi[P]rtacl/unitTest.cpp
// Function: void showRTaclEnt<long, sockaddr_in>(boost::geometry::model::box<boost::geometry::model::point<long, 6ul, boost::geometry::cs::cartesian>> const&, unsigned long)
static void
showRTaclEnt (const rtacl::range<ADDR>& r, const uintptr_t index)
{
    rtacl::sockEnt<SADDR>* p =
        reinterpret_cast<rtacl::sockEnt<SADDR>*>(index);

    std::cout << (bfmt("rtree: %s\nacl:   %s\n")
                  % rtacl::range2str(r)
                  % p->str()).str();
}

// Assembly:
pushq %r14
pushq %rbx
subq $0x148, %rsp            # imm = 0x148
movq %rsi, %rbx
movq %rdi, %r14
leaq 0x15052(%rip), %rsi     # 0x1b8b6
leaq 0x68(%rsp), %rdi
callq 0x6bb4
leaq 0x28(%rsp), %rdi
movq %r14, %rsi
callq 0x6e98
leaq 0x68(%rsp), %rdi
leaq 0x28(%rsp), %rsi
callq 0xdc63
movq %rax, %r14
leaq 0x8(%rsp), %rdi
movq %rbx, %rsi
callq 0xf2ac
leaq 0x8(%rsp), %rsi
movq %r14, %rdi
callq 0xdc63
leaq 0x48(%rsp), %rdi
movq %rax, %rsi
callq 0x6c96
movq 0x62705(%rip), %rdi     # 0x68fc0
leaq 0x48(%rsp), %rsi
callq 0x4210
leaq 0x48(%rsp), %rdi
callq 0x4100
leaq 0x8(%rsp), %rdi
callq 0x4100
leaq 0x28(%rsp), %rdi
callq 0x4100
leaq 0x68(%rsp), %rdi
callq 0x6dfa
addq $0x148, %rsp            # imm = 0x148
popq %rbx
popq %r14
retq
movq %rax, %rbx
leaq 0x48(%rsp), %rdi
callq 0x4100
jmp 0x6916
jmp 0x6909
movq %rax, %rbx
jmp 0x6920
movq %rax, %rbx
jmp 0x692a
movq %rax, %rbx
leaq 0x8(%rsp), %rdi
callq 0x4100
leaq 0x28(%rsp), %rdi
callq 0x4100
leaq 0x68(%rsp), %rdi
callq 0x6dfa
movq %rbx, %rdi
callq 0x4430
// File: /workspace/github_cpp_makefile_star2_O2/hariguchi[P]rtacl/./rtacl.hpp
// Function: rtacl::db<long>::find(boost::geometry::model::point<long, 6ul, boost::geometry::cs::cartesian> const&)
inline result<ADDR>
db<ADDR>::find (const tuple<ADDR>& key)
{
    result<ADDR> r;
    size_t n = rtree.query(bgi::contains(key), std::back_inserter(r));
    if (n != r.size()) {
        fprintf(stderr, "n(%ld) != r.size()(%ld)\n", n, r.size());
    }
    assert(n == r.size());

    return r;
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
subq $0x30, %rsp
movq %rsi, %rax
movq %rdi, %rbx
xorps %xmm0, %xmm0
andq $0x0, 0x10(%rdi)
movups %xmm0, (%rdi)
movups (%rdx), %xmm0
movups 0x10(%rdx), %xmm1
movups 0x20(%rdx), %xmm2
movq %rsp, %rsi
movaps %xmm2, 0x20(%rsi)
movaps %xmm1, 0x10(%rsi)
movaps %xmm0, (%rsi)
movq %rax, %rdi
movq %rbx, %rdx
callq 0xde1a
movq %rax, %r14
movq 0x8(%rbx), %rax
subq (%rbx), %rax
pushq $0x68
popq %r15
cqto
idivq %r15
cmpq %rax, %r14
jne 0x7118
cmpq %rax, %r14
jne 0x7144
movq %rbx, %rax
addq $0x30, %rsp
popq %rbx
popq %r14
popq %r15
retq
movq 0x61ea9(%rip), %rcx     # 0x68fc8
movq (%rcx), %rdi
leaq 0x24896(%rip), %rsi     # 0x2b9bf
movq %r14, %rdx
movq %rax, %rcx
xorl %eax, %eax
callq 0x4370
movq 0x8(%rbx), %rax
subq (%rbx), %rax
cqto
idivq %r15
jmp 0x7106
leaq 0x2488d(%rip), %rdi     # 0x2b9d8
leaq 0x24894(%rip), %rsi     # 0x2b9e6
leaq 0x24899(%rip), %rcx     # 0x2b9f2
movl $0x23d, %edx            # imm = 0x23D
callq 0x4180
movq %rax, %r14
movq %rbx, %rdi
callq 0xe0d6
movq %r14, %rdi
callq 0x4430
// File: /workspace/github_cpp_makefile_star2_O2/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 %r15
pushq %r14
pushq %rbx
subq $0x130, %rsp            # imm = 0x130
movq %rsi, %r14
movq %rdi, %rbx
leaq 0x248a5(%rip), %rsi     # 0x2ba34
leaq 0x50(%rsp), %rdi
callq 0x6bb4
movq (%r14), %rsi
leaq 0x30(%rsp), %rdi
callq 0xdc96
leaq 0x50(%rsp), %rdi
leaq 0x30(%rsp), %rsi
callq 0xdc63
movq %rax, %r15
movq 0x8(%r14), %rsi
leaq 0x10(%rsp), %rdi
callq 0xdc96
leaq 0x10(%rsp), %rsi
movq %r15, %rdi
callq 0xdc63
movl 0x10(%r14), %ecx
leaq 0xc(%rsp), %rsi
movl %ecx, (%rsi)
movq %rax, %rdi
callq 0xdddf
movl 0x18(%r14), %ecx
leaq 0x8(%rsp), %rsi
movl %ecx, (%rsi)
movq %rax, %rdi
callq 0xdddf
movl 0x20(%r14), %ecx
leaq 0x4(%rsp), %rsi
movl %ecx, (%rsi)
movq %rax, %rdi
callq 0xdddf
movl 0x28(%r14), %ecx
movq %rsp, %rsi
movl %ecx, (%rsi)
movq %rax, %rdi
callq 0xdddf
movq %rbx, %rdi
movq %rax, %rsi
callq 0x6c96
leaq 0x10(%rsp), %rdi
callq 0x4100
leaq 0x30(%rsp), %rdi
callq 0x4100
leaq 0x50(%rsp), %rdi
callq 0x6dfa
movq %rbx, %rax
addq $0x130, %rsp            # imm = 0x130
popq %rbx
popq %r14
popq %r15
retq
jmp 0x726a
jmp 0x726a
jmp 0x726a
jmp 0x726a
jmp 0x7260
movq %rax, %rbx
jmp 0x7277
movq %rax, %rbx
jmp 0x7281
movq %rax, %rbx
leaq 0x10(%rsp), %rdi
callq 0x4100
leaq 0x30(%rsp), %rdi
callq 0x4100
leaq 0x50(%rsp), %rdi
callq 0x6dfa
movq %rbx, %rdi
callq 0x4430
nop
// File: /workspace/github_cpp_makefile_star2_O2/hariguchi[P]rtacl/./rtacl.hpp
// Function: rtacl::sockItem<sockaddr_in6>::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 %rbx
movq %rdi, %rbx
xorps %xmm0, %xmm0
movups %xmm0, 0xc(%rdi)
movaps %xmm0, (%rdi)
movaps %xmm0, 0x20(%rdi)
movups %xmm0, 0x2c(%rdi)
leaq 0x594cf(%rip), %rdi     # 0x68b98
leaq 0x594b8(%rip), %rsi     # 0x68b88
callq 0x72a2
testb %al, %al
je 0xf6e3
movw $0x4, %ax
movw $0x2, %cx
jmp 0xf6fe
leaq 0x594ae(%rip), %rdi     # 0x68b98
movq %rdi, %rsi
callq 0x72a2
testb %al, %al
je 0xf713
movw $0x8, %ax
movw $0xa, %cx
movw %cx, (%rbx)
movw %cx, 0x20(%rbx)
movw %cx, 0x3c(%rbx)
movw %ax, 0x3e(%rbx)
movw $0x2, 0x40(%rbx)
popq %rbx
retq
nop
// File: /workspace/github_cpp_makefile_star2_O2/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 %rax
cmpw $0x2, 0x18(%rdi)
jne 0xf28c
movq 0x10(%rsp), %rax
movl 0x4(%rsi), %r10d
bswapl %r10d
movslq %r9d, %rdi
addq %rdi, %r10
movq %r10, (%rax)
movl 0x4(%rdx), %r9d
bswapl %r9d
addq %rdi, %r9
movq %r9, 0x8(%rax)
movzwl 0x2(%rsi), %esi
rolw $0x8, %si
movzwl %si, %esi
addq %rdi, %rsi
movq %rsi, 0x10(%rax)
movzwl 0x2(%rdx), %edx
rolw $0x8, %dx
movzwl %dx, %edx
addq %rdi, %rdx
movq %rdx, 0x18(%rax)
movzbl %cl, %ecx
addq %rdi, %rcx
movq %rcx, 0x20(%rax)
movzbl %r8b, %ecx
addq %rdi, %rcx
movq %rcx, 0x28(%rax)
popq %rax
retq
leaq 0x2344f(%rip), %rdi     # 0x326e2
leaq 0x1c74c(%rip), %rsi     # 0x2b9e6
leaq 0x2344f(%rip), %rcx     # 0x326f0
movl $0x25b, %edx            # imm = 0x25B
callq 0x4180
nop
// File: /workspace/github_cpp_makefile_star2_O2/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
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x170, %rsp            # imm = 0x170
movq %rsi, %r14
movq %rdi, %rbx
movzwl 0x20(%rsi), %edi
movzwl 0x22(%rsi), %esi
addq %r14, %rsi
leaq 0x50(%rsp), %r15
pushq $0x40
popq %rbp
movq %r15, %rdx
movl %ebp, %ecx
callq 0x4280
movzwl 0x20(%r14), %edi
movzwl 0x22(%r14), %eax
leaq (%r14,%rax), %rsi
addq $0x10, %rsi
leaq 0x10(%rsp), %rdx
movl %ebp, %ecx
callq 0x4280
leaq 0x1c4fb(%rip), %rsi     # 0x2ba34
leaq 0x90(%rsp), %r12
movq %r12, %rdi
callq 0x6bb4
movq %r12, %rdi
movq %r15, %rsi
callq 0xf4ae
leaq 0x10(%rsp), %rsi
movq %rax, %rdi
callq 0xf4ae
movzwl 0x24(%r14), %ecx
movzwl (%r14,%rcx), %ecx
rolw $0x8, %cx
movzwl %cx, %ecx
leaq 0xc(%rsp), %rsi
movl %ecx, (%rsi)
movq %rax, %rdi
callq 0xdddf
movzwl 0x24(%r14), %ecx
movzwl 0x10(%r14,%rcx), %ecx
rolw $0x8, %cx
movzwl %cx, %ecx
leaq 0x8(%rsp), %rsi
movl %ecx, (%rsi)
movq %rax, %rdi
callq 0xdddf
movzbl 0x26(%r14), %ecx
leaq 0x4(%rsp), %rsi
movl %ecx, (%rsi)
movq %rax, %rdi
callq 0xdddf
movzbl 0x27(%r14), %ecx
movq %rsp, %rsi
movl %ecx, (%rsi)
movq %rax, %rdi
callq 0xdddf
movq %rbx, %rdi
movq %rax, %rsi
callq 0x6c96
leaq 0x90(%rsp), %rdi
callq 0x6dfa
movq %rbx, %rax
addq $0x170, %rsp            # imm = 0x170
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
jmp 0xf5fb
jmp 0xf5fb
jmp 0xf5fb
jmp 0xf5fb
movq %rax, %rbx
leaq 0x90(%rsp), %rdi
callq 0x6dfa
movq %rbx, %rdi
callq 0x4430
// File: /workspace/github_cpp_makefile_star2_O2/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
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movq %rsi, %r14
movq %rdi, %rbx
xorps %xmm0, %xmm0
movaps %xmm0, 0x10(%rdi)
movaps %xmm0, (%rdi)
movw $0x1, 0x20(%rdi)
movb $0x0, 0x22(%rdi)
leaq 0x8(%rsi), %r15
xorl %r12d, %r12d
pushq $0x8
popq %rbp
cmpq $0xf, %r12
je 0xfcff
leaq (%r15,%r12), %rsi
movq %rbx, %rdi
callq 0xff82
movq %rbx, %rdi
movl %ebp, %esi
callq 0xffa4
incq %r12
jmp 0xfcde
addq $0x17, %r14
movq %rbx, %rdi
movq %r14, %rsi
callq 0xff82
movq %rbx, %rax
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/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
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x78, %rsp
movq %rsi, %r15
movq %rdi, 0x8(%rsp)
xorps %xmm0, %xmm0
leaq 0x18(%rsp), %r14
movaps %xmm0, -0x8(%r14)
movups %xmm0, 0x4(%r14)
movw $0xa, -0x8(%r14)
leaq 0x27(%rsp), %rbp
xorl %ebx, %ebx
leaq 0x30(%rsp), %r12
movq %rsp, %r13
cmpq $0x80, %rbx
je 0x18247
movq %rbx, (%rsp)
movq %r12, %rdi
movq %r15, %rsi
movq %r13, %rdx
callq 0x182b7
movq %r12, %rdi
callq 0x18558
movb %al, (%rbp)
addq $0x8, %rbx
decq %rbp
jmp 0x18218
pushq $0xa
popq %rdi
leaq 0x30(%rsp), %r15
pushq $0x40
popq %rcx
movq %r14, %rsi
movq %r15, %rdx
callq 0x4280
movq %rsp, %rdx
movq 0x8(%rsp), %rbx
movq %rbx, %rdi
movq %r15, %rsi
callq 0xa238
movq %rbx, %rax
addq $0x78, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/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
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movl %esi, %ebp
movq %rdi, %rbx
movl %esi, %edi
callq 0x7dde
movq %rax, %r14
movslq %ebp, %r15
leaq (,%r15,8), %rdx
movq %rax, %rdi
movq %rbx, %rsi
callq 0x41c0
movq %r14, %rdi
movl %r15d, %esi
callq 0x52ac
decl %r15d
xorpd %xmm0, %xmm0
xorl %eax, %eax
movsd 0x275c0(%rip), %xmm1    # 0x2c8e8
cmpl %eax, %r15d
jle 0x5355
addsd (%r14,%rax,8), %xmm0
movapd %xmm0, %xmm3
addsd %xmm1, %xmm3
leaq 0x1(%rax), %rcx
cvtsi2sd %ecx, %xmm2
divsd %xmm2, %xmm3
ucomisd 0x8(%r14,%rax,8), %xmm3
movq %rcx, %rax
jb 0x5328
jmp 0x5376
movslq %r15d, %rax
addsd (%r14,%rax,8), %xmm0
addsd 0x27582(%rip), %xmm0    # 0x2c8e8
movsbl %bpl, %eax
cvtsi2sd %eax, %xmm1
divsd %xmm1, %xmm0
movapd %xmm0, %xmm3
movsd %xmm3, (%rsp)
movq %r14, %rdi
callq 0x4290
movsd (%rsp), %xmm2
movzbl %bpl, %ecx
xorl %eax, %eax
testb %bpl, %bpl
cmovlel %eax, %ecx
movzbl %cl, %ecx
cmpq %rax, %rcx
je 0x53b7
movsd (%rbx,%rax,8), %xmm0
subsd %xmm2, %xmm0
xorpd %xmm1, %xmm1
maxsd %xmm0, %xmm1
movsd %xmm1, (%rbx,%rax,8)
incq %rax
jmp 0x5397
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/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:
xorl %edx, %edx
testb %sil, %sil
movl %esi, %eax
cmovlel %edx, %eax
movslq %eax, %rcx
movsd 0x27519(%rip), %xmm1    # 0x2c8f0
xorpd %xmm2, %xmm2
movapd %xmm1, %xmm0
movq %rdx, %rax
cmpq %rdx, %rcx
je 0x5400
movsd (%rdi,%rax,8), %xmm3
subsd %xmm3, %xmm0
ucomisd %xmm3, %xmm2
ja 0x5400
leaq 0x1(%rax), %rdx
ucomisd %xmm1, %xmm3
jbe 0x53df
movsbq %sil, %rcx
cmpq %rcx, %rax
andpd 0x27521(%rip), %xmm0    # 0x2c930
setge %cl
movsd 0x274de(%rip), %xmm1    # 0x2c8f8
ucomisd %xmm0, %xmm1
seta %al
andb %cl, %al
retq
// File: /workspace/github_cpp_makefile_star2_O2/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:
xorl %r9d, %r9d
testb %cl, %cl
movl %ecx, %eax
cmovlel %r9d, %eax
movslq %eax, %r8
movsd 0x274b6(%rip), %xmm0    # 0x2c8f0
movq %r9, %rax
cmpq %r9, %r8
je 0x5461
movsd (%rdi,%rax,8), %xmm1
subsd %xmm1, %xmm0
movsd (%rsi,%rax,8), %xmm2
ucomisd %xmm1, %xmm2
ja 0x5461
leaq 0x1(%rax), %r9
ucomisd (%rdx,%rax,8), %xmm1
jbe 0x543a
movsbq %cl, %rcx
cmpq %rcx, %rax
andpd 0x274c0(%rip), %xmm0    # 0x2c930
setge %cl
movsd 0x2747d(%rip), %xmm1    # 0x2c8f8
ucomisd %xmm0, %xmm1
seta %al
andb %cl, %al
retq
// File: /workspace/github_cpp_makefile_star2_O2/myudelson[P]hmm-scalable/utils.cpp
// Function: projectsimplexOld(double*, signed char)
void projectsimplexOld(NUMBER* ar, NPAR size) {
	NPAR i, num_at_hi, num_at_lo; // number of elements at lower,upper boundary
	NPAR *at_hi = Calloc(NPAR, (size_t)size);
	NPAR *at_lo = Calloc(NPAR, (size_t)size);
	NUMBER err, lambda;
	while( !issimplex(ar, size)) {
        lambda = 0;
		num_at_hi = 0;
		num_at_lo = 0;
		err = -1; // so that of the sum is over 1, the error is 1-sum
		// threshold
		for(i=0; i<size; i++) {
			at_lo[i] = (ar[i]<0)?1:0;
			ar[i] = (at_lo[i]==1)?0:ar[i];
			num_at_lo = (NPAR)(num_at_lo + at_lo[i]);
            
			at_hi[i] = (ar[i]>1)?1:0;
			ar[i] = (at_hi[i]==1)?1:ar[i];
			num_at_hi = (NPAR)(num_at_hi + at_hi[i]);
			
			err += ar[i];
		}
		if (size > (num_at_hi + num_at_lo) )
			lambda = err / (size - (num_at_hi + num_at_lo));
		for(i=0; i<size; i++)
			ar[i] -= (at_lo[i]==0 && at_hi[i]==0)?lambda:0;
		
	} // until satisfied
    // force last to be 1 - sum of all but last
    err = 1;
    for(i=0; i<(size-1); i++) err -= ar[i];
    ar[size-1] = err;
    err = 1;
    for(i=1; i<(size-0); i++) err -= ar[i];
    ar[0] = err;

	free(at_hi);
	free(at_lo);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movl %esi, %ebp
movq %rdi, %rbx
movslq %esi, %r14
pushq $0x1
popq %r15
movq %r14, %rdi
movq %r15, %rsi
callq 0x4120
movq %rax, %r12
movq %r14, %rdi
movq %r15, %rsi
callq 0x4120
movq %rax, %r13
xorl %eax, %eax
testb %bpl, %bpl
movq %r14, 0x10(%rsp)
movl %r14d, %ecx
cmovlel %eax, %ecx
movzbl %cl, %r14d
movsbl %bpl, %eax
movl %eax, 0xc(%rsp)
movq %rbx, %rdi
movl 0xc(%rsp), %esi
callq 0x53c2
testb %al, %al
jne 0x559f
xorl %eax, %eax
xorl %ecx, %ecx
xorl %edx, %edx
movsd 0x273ef(%rip), %xmm0    # 0x2c8e8
movsd 0x273ef(%rip), %xmm3    # 0x2c8f0
xorpd %xmm4, %xmm4
cmpq %rax, %r14
je 0x554e
movsd (%rbx,%rax,8), %xmm1
ucomisd %xmm1, %xmm4
seta (%r13,%rax)
seta %sil
xorpd %xmm2, %xmm2
maxsd %xmm1, %xmm2
addb %sil, %cl
ucomisd %xmm3, %xmm2
seta (%r12,%rax)
seta %sil
movapd %xmm3, %xmm1
minsd %xmm2, %xmm1
movsd %xmm1, (%rbx,%rax,8)
addb %sil, %dl
addsd %xmm1, %xmm0
incq %rax
jmp 0x5505
movsbl %dl, %eax
movsbl %cl, %ecx
addl %eax, %ecx
movl %ebp, %eax
subl %ecx, %eax
jg 0x5562
xorpd %xmm0, %xmm0
jmp 0x556a
cvtsi2sd %eax, %xmm1
divsd %xmm1, %xmm0
xorl %eax, %eax
cmpq %rax, %r14
je 0x54d7
xorpd %xmm1, %xmm1
cmpb $0x0, (%r13,%rax)
jne 0x558c
cmpb $0x0, (%r12,%rax)
jne 0x558c
movapd %xmm0, %xmm1
movsd (%rbx,%rax,8), %xmm2
subsd %xmm1, %xmm2
movsd %xmm2, (%rbx,%rax,8)
incq %rax
jmp 0x556c
decl %ebp
xorl %eax, %eax
movsd 0x27345(%rip), %xmm0    # 0x2c8f0
cmpl %eax, %ebp
jle 0x55b9
subsd (%rbx,%rax,8), %xmm0
incq %rax
jmp 0x55ab
movslq %ebp, %rax
movsd %xmm0, (%rbx,%rax,8)
movsd 0x27327(%rip), %xmm0    # 0x2c8f0
movq 0x10(%rsp), %rax
cmpq %rax, %r15
jge 0x55de
subsd (%rbx,%r15,8), %xmm0
incq %r15
jmp 0x55ce
movsd %xmm0, (%rbx)
movq %r12, %rdi
callq 0x4290
movq %r13, %rdi
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x4290
// File: /workspace/github_cpp_makefile_star2_O2/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:
movsd (%rdi), %xmm0
movslq %esi, %rax
pushq $0x1
popq %rcx
cmpq %rax, %rcx
jge 0x6995
movsd (%rdi,%rcx,8), %xmm1
maxsd %xmm0, %xmm1
incq %rcx
movapd %xmm1, %xmm0
jmp 0x697e
retq
// File: /workspace/github_cpp_makefile_star2_O2/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 %rbx
xorl %eax, %eax
testb %r8b, %r8b
cmovlel %eax, %r8d
testb %cl, %cl
cmovlel %eax, %ecx
testb %dl, %dl
cmovlel %eax, %edx
movslq %edx, %rdx
movslq %ecx, %rcx
movzbl %r8b, %r8d
cmpq %rdx, %rax
je 0x6a8b
xorl %r9d, %r9d
cmpq %rcx, %r9
je 0x6a86
xorl %r10d, %r10d
cmpq %r10, %r8
je 0x6a81
movq (%rsi,%rax,8), %r11
movq (%r11,%r9,8), %r11
movq (%rdi,%rax,8), %rbx
movq (%rbx,%r9,8), %rbx
movsd (%rbx,%r10,8), %xmm1
mulsd %xmm0, %xmm1
addsd (%r11,%r10,8), %xmm1
movsd %xmm1, (%r11,%r10,8)
incq %r10
jmp 0x6a51
incq %r9
jmp 0x6a49
incq %rax
jmp 0x6a41
popq %rbx
retq
// File: /workspace/github_cpp_makefile_star2_O2/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:
xorl %eax, %eax
testb %sil, %sil
movl %esi, %ecx
cmovlel %eax, %ecx
movslq %ecx, %rcx
xorpd %xmm1, %xmm1
movsd 0x25e4a(%rip), %xmm2    # 0x2c8f0
xorpd %xmm0, %xmm0
cmpq %rax, %rcx
je 0x6ac9
movsd (%rdi,%rax,8), %xmm3
ucomisd %xmm3, %xmm1
ja 0x6ac9
ucomisd %xmm2, %xmm3
ja 0x6ac9
addsd %xmm3, %xmm0
incq %rax
jmp 0x6aaa
movsbq %sil, %rcx
cmpq %rcx, %rax
setge %cl
ucomisd 0x25e15(%rip), %xmm0    # 0x2c8f0
setnp %dl
sete %al
andb %dl, %al
andb %cl, %al
retq
// File: /workspace/github_cpp_makefile_star2_O2/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:
xorl %eax, %eax
testb %sil, %sil
cmovlel %eax, %esi
movslq %esi, %rsi
xorpd %xmm0, %xmm0
movsd 0x25dfb(%rip), %xmm1    # 0x2c8f8
cmpq %rax, %rsi
je 0x6b31
movsd (%rdx,%rax,8), %xmm3
movsd (%rdi,%rax,8), %xmm2
subsd %xmm2, %xmm3
ucomisd %xmm1, %xmm3
ja 0x6b2e
movapd %xmm2, %xmm3
subsd (%rcx,%rax,8), %xmm3
ucomisd %xmm1, %xmm3
ja 0x6b2e
addsd %xmm2, %xmm0
incq %rax
jmp 0x6afd
xorl %eax, %eax
retq
addsd 0x25daf(%rip), %xmm0    # 0x2c8e8
andpd 0x25def(%rip), %xmm0    # 0x2c930
ucomisd %xmm0, %xmm1
seta %al
retq
// File: /workspace/github_cpp_makefile_star2_O2/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 %r15
pushq %r14
pushq %rbx
subq $0x10, %rsp
movq %rdi, %rbx
xorl %r15d, %r15d
testb %sil, %sil
cmovlel %r15d, %esi
movslq %esi, %r14
xorpd %xmm0, %xmm0
movsd %xmm0, (%rsp)
movapd 0x25dbd(%rip), %xmm1    # 0x2c930
movsd 0x25d7d(%rip), %xmm2    # 0x2c8f8
cmpq %r15, %r14
je 0x6bce
movsd (%rbx,%r15,8), %xmm0
andpd %xmm1, %xmm0
ucomisd %xmm0, %xmm2
ja 0x6bc9
callq 0x4100
movsd (%rbx,%r15,8), %xmm0
andpd 0x25d8d(%rip), %xmm0    # 0x2c930
callq 0x4100
callq 0x4090
movsd 0x25d43(%rip), %xmm2    # 0x2c8f8
movapd 0x25d73(%rip), %xmm1    # 0x2c930
ucomisd (%rsp), %xmm0
jbe 0x6bc9
movsd %xmm0, (%rsp)
incq %r15
jmp 0x6b7b
movsd (%rsp), %xmm1
addsd 0x25d15(%rip), %xmm1    # 0x2c8f0
xorpd %xmm0, %xmm0
movsd %xmm1, (%rsp)
ucomisd %xmm0, %xmm1
jbe 0x6c25
xorl %r15d, %r15d
cmpq %r15, %r14
je 0x6c25
movsd (%rbx,%r15,8), %xmm0
movsd %xmm0, 0x8(%rsp)
movsd 0x25d0a(%rip), %xmm0    # 0x2c910
movsd (%rsp), %xmm1
callq 0x4440
movsd 0x8(%rsp), %xmm1
divsd %xmm0, %xmm1
movsd %xmm1, (%rbx,%r15,8)
incq %r15
jmp 0x6bed
movsd 0x25ce3(%rip), %xmm0    # 0x2c910
movsd (%rsp), %xmm1
addq $0x10, %rsp
popq %rbx
popq %r14
popq %r15
jmp 0x4440
// File: /workspace/github_cpp_makefile_star2_O2/myudelson[P]hmm-scalable/utils.cpp
// Function: doLog10Scale2D(double**, signed char, signed char)
NUMBER doLog10Scale2D(NUMBER **ar, NPAR size1, NPAR size2) {
	NPAR i,j;
	NUMBER min_10_scale = 1000, max_10_scale = 0, candidate;
	for(i=0; i<size1; i++)
		for(j=0; j<size2; j++) {
			if( fabs(ar[i][j]) < SAFETY ) // 0 gradient
				continue;
			candidate = floor( log10( fabs(ar[i][j]) ) );
			if(candidate < min_10_scale)
				min_10_scale = candidate;
			candidate = ceil( log10( fabs(ar[i][j]) ) );
			if(candidate > max_10_scale)
				max_10_scale = candidate;
		}
	min_10_scale++;
	max_10_scale++;
	if(max_10_scale >0 )
		for(i=0; i<size1; i++)
			for(j=0; j<size2; j++)
				ar[i][j] = ar[i][j] / pow(10, max_10_scale);
    //	if(min_10_scale<1000)
    //		for(i=0; i<size1; i++)
    //			for(j=0; j<size2; j++)
    //				ar[i][j] = ar[i][j] / pow(10, min_10_scale);
	return pow(10, max_10_scale);
}

// Assembly:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x10, %rsp
movq %rdi, %rbx
xorl %r12d, %r12d
testb %dl, %dl
cmovlel %r12d, %edx
testb %sil, %sil
cmovlel %r12d, %esi
movslq %esi, %r14
movzbl %dl, %r15d
xorpd %xmm0, %xmm0
movsd %xmm0, (%rsp)
movapd 0x25cb8(%rip), %xmm1    # 0x2c930
movsd 0x25c78(%rip), %xmm2    # 0x2c8f8
cmpq %r14, %r12
je 0x6ce8
xorl %r13d, %r13d
cmpq %r13, %r15
je 0x6ce3
movq (%rbx,%r12,8), %rax
movsd (%rax,%r13,8), %xmm0
andpd %xmm1, %xmm0
ucomisd %xmm0, %xmm2
ja 0x6cde
callq 0x4100
movq (%rbx,%r12,8), %rax
movsd (%rax,%r13,8), %xmm0
andpd 0x25c78(%rip), %xmm0    # 0x2c930
callq 0x4100
callq 0x4090
movsd 0x25c2e(%rip), %xmm2    # 0x2c8f8
movapd 0x25c5e(%rip), %xmm1    # 0x2c930
ucomisd (%rsp), %xmm0
jbe 0x6cde
movsd %xmm0, (%rsp)
incq %r13
jmp 0x6c88
incq %r12
jmp 0x6c80
movsd (%rsp), %xmm1
addsd 0x25bfb(%rip), %xmm1    # 0x2c8f0
xorpd %xmm0, %xmm0
movsd %xmm1, (%rsp)
ucomisd %xmm0, %xmm1
jbe 0x6d54
xorl %r12d, %r12d
cmpq %r14, %r12
je 0x6d54
xorl %r13d, %r13d
cmpq %r13, %r15
je 0x6d4f
movq (%rbx,%r12,8), %rax
movsd (%rax,%r13,8), %xmm0
movsd %xmm0, 0x8(%rsp)
movsd 0x25be4(%rip), %xmm0    # 0x2c910
movsd (%rsp), %xmm1
callq 0x4440
movsd 0x8(%rsp), %xmm1
divsd %xmm0, %xmm1
movq (%rbx,%r12,8), %rax
movsd %xmm1, (%rax,%r13,8)
incq %r13
jmp 0x6d0f
incq %r12
jmp 0x6d07
movsd 0x25bb4(%rip), %xmm0    # 0x2c910
movsd (%rsp), %xmm1
addq $0x10, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
jmp 0x4440
// File: /workspace/github_cpp_makefile_star2_O2/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:
xorl %eax, %eax
testl %edi, %edi
cmovlel %eax, %edi
cmpq %rax, %rdi
je 0x7531
movq (%rsi,%rax,8), %rcx
andl $0x0, 0x4(%rcx)
incq %rax
jmp 0x751f
retq
// File: /workspace/github_cpp_makefile_star2_O2/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 %r14
pushq %rbx
pushq %rax
movq %rsi, %r14
movq %rdi, %rbx
movsbl 0x40(%rsi), %r8d
testl %r8d, %r8d
jle 0x7974
movsbl 0x3e(%r14), %edx
movsbl 0x3f(%r14), %ecx
leaq 0x25195(%rip), %rsi     # 0x2cafd
movq %rbx, %rdi
xorl %eax, %eax
callq 0x4350
jmp 0x798f
movsbl 0x3e(%r14), %edx
movsbl 0x3f(%r14), %ecx
leaq 0x2518b(%rip), %rsi     # 0x2cb10
movq %rbx, %rdi
xorl %eax, %eax
callq 0x4350
movl 0x8c0(%r14), %edx
leaq 0x25183(%rip), %rsi     # 0x2cb20
movq %rbx, %rdi
xorl %eax, %eax
callq 0x4350
movl 0x8bc(%r14), %edx
leaq 0x25172(%rip), %rsi     # 0x2cb27
movq %rbx, %rdi
xorl %eax, %eax
callq 0x4350
movsbl 0x8b8(%r14), %edx
leaq 0x25160(%rip), %rsi     # 0x2cb2e
movq %rbx, %rdi
xorl %eax, %eax
callq 0x4350
movsbl 0x8b9(%r14), %edx
leaq 0x2514e(%rip), %rsi     # 0x2cb35
movq %rbx, %rdi
xorl %eax, %eax
callq 0x4350
movsbl 0x8c8(%r14), %edx
leaq 0x2513c(%rip), %rsi     # 0x2cb3c
movq %rbx, %rdi
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x4350
// File: /workspace/github_cpp_makefile_star2_O2/myudelson[P]hmm-scalable/utils.cpp
// Function: readSolverInfo(_IO_FILE*, param*, int*)
void readSolverInfo(FILE *fid, struct param *param, NDAT *line_no) {
    string s;
    int c, i1, i2;
    // SolverId
    fscanf(fid,"SolverId\t%i.%i", &i1, &i2);
    param->structure = (NPAR) i1;
    param->solver    = (NPAR) i2;
    fscanf(fid,"SolverId\t%hhu.%hhu", &param->structure, &param->solver);
    c = fscanf(fid,".%hhu\n", &param->solver_setting);
    if( c<1 ) {
        fscanf(fid,"\n");
        param->solver_setting = -1;
    }
    (*line_no)++;
	// nK
    fscanf(fid,"nK\t%i\n",&param->nK);
    (*line_no)++;
    // nG
    fscanf(fid,"nG\t%i\n",&param->nG);
    (*line_no)++;
    // nS
    fscanf(fid,"nS\t%hhu\n",&param->nS);
    (*line_no)++;
    // nO
    fscanf(fid,"nO\t%hhu\n",&param->nO);
    (*line_no)++;
    // nZ
    fscanf(fid,"nZ\t%hhu\n",&param->nZ);
    (*line_no)++;
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x28, %rsp
movq %rdx, %rbx
movq %rsi, %r14
movq %rdi, %r15
leaq 0x18(%rsp), %rax
movq %rax, -0x10(%rax)
andq $0x0, -0x8(%rax)
movb $0x0, (%rax)
leaq 0x25106(%rip), %rsi     # 0x2cb43
leaq 0x4(%rsp), %rdx
movq %rsp, %rcx
xorl %eax, %eax
callq 0x4480
movb 0x4(%rsp), %al
leaq 0x3e(%r14), %rdx
movb %al, 0x3e(%r14)
movb (%rsp), %al
leaq 0x3f(%r14), %rcx
movb %al, 0x3f(%r14)
leaq 0x250e8(%rip), %rsi     # 0x2cb52
movq %r15, %rdi
xorl %eax, %eax
callq 0x4480
leaq 0x40(%r14), %r12
leaq 0x250e6(%rip), %rsi     # 0x2cb65
movq %r15, %rdi
movq %r12, %rdx
xorl %eax, %eax
callq 0x4480
testl %eax, %eax
jg 0x7aa6
leaq 0x247c6(%rip), %rsi     # 0x2c25d
movq %r15, %rdi
xorl %eax, %eax
callq 0x4480
movb $-0x1, (%r12)
incl (%rbx)
leaq 0x8c0(%r14), %rdx
leaq 0x250b6(%rip), %rsi     # 0x2cb6c
movq %r15, %rdi
xorl %eax, %eax
callq 0x4480
incl (%rbx)
leaq 0x8bc(%r14), %rdx
leaq 0x250a3(%rip), %rsi     # 0x2cb73
movq %r15, %rdi
xorl %eax, %eax
callq 0x4480
incl (%rbx)
leaq 0x8b8(%r14), %rdx
leaq 0x25090(%rip), %rsi     # 0x2cb7a
movq %r15, %rdi
xorl %eax, %eax
callq 0x4480
incl (%rbx)
leaq 0x8b9(%r14), %rdx
leaq 0x2507f(%rip), %rsi     # 0x2cb83
movq %r15, %rdi
xorl %eax, %eax
callq 0x4480
incl (%rbx)
addq $0x8c8, %r14            # imm = 0x8C8
leaq 0x2506e(%rip), %rsi     # 0x2cb8c
movq %r15, %rdi
movq %r14, %rdx
xorl %eax, %eax
callq 0x4480
incl (%rbx)
leaq 0x8(%rsp), %rdi
callq 0x40f0
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
movq %rax, %rbx
leaq 0x8(%rsp), %rdi
callq 0x40f0
movq %rbx, %rdi
callq 0x4450
// File: /workspace/github_cpp_makefile_star2_O2/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:
movl 0x8c0(%rdi), %eax
xorl %ecx, %ecx
testl %eax, %eax
cmovlel %ecx, %eax
cmpq %rax, %rcx
je 0x7b9a
movq 0x8e0(%rdi), %rdx
xorl %esi, %esi
movslq (%rdx,%rcx,4), %r8
cmpq %r8, %rsi
jge 0x7b95
movq 0x8f8(%rdi), %r8
movq (%r8,%rcx,8), %r8
movq (%r8,%rsi,8), %r8
andl $0x0, 0x4(%r8)
incq %rsi
jmp 0x7b73
incq %rcx
jmp 0x7b65
retq
// File: /workspace/github_cpp_makefile_star2_O2/myudelson[P]hmm-scalable/utils.cpp
// Function: RecycleFitData(int, data**, param*)
void RecycleFitData(NCAT xndat, struct data** x_data, struct param *param) {
	NCAT x;
	NDAT t;
	for(x=0; x<xndat; x++) {
        //        if( x_data[x][0].cnt != 0)
        //            continue;
		if( x_data[x][0].alpha != NULL ) {
			free2D<NUMBER>(x_data[x][0].alpha, x_data[x][0].n);  // only free data here
			x_data[x][0].alpha = NULL;
		}
		if( x_data[x][0].c != NULL ) {
			free(x_data[x][0].c);  // only free data here
			x_data[x][0].c = NULL;
		}
		if( x_data[x][0].beta != NULL ) {
			free2D<NUMBER>(x_data[x][0].beta,  x_data[x][0].n); // only free data here
			x_data[x][0].beta = NULL;
		}
		if( x_data[x][0].gamma != NULL ) {
			free2D<NUMBER>(x_data[x][0].gamma, x_data[x][0].n); // only free data here
			x_data[x][0].gamma = NULL;
		}
		if( x_data[x][0].xi != NULL ) {
			for(t=0;t<x_data[x][0].n; t++)
				free2D<NUMBER>(x_data[x][0].xi[t],  (NDAT)param->nS); // only free data here
			x_data[x][0].xi = NULL;
		}
	}
}

// Assembly:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
movq %rdx, %rbx
movq %rsi, %r14
movl %edi, %r15d
xorl %r12d, %r12d
testl %edi, %edi
cmovlel %r12d, %r15d
cmpq %r15, %r12
je 0x7c71
movq (%r14,%r12,8), %rax
movq 0x28(%rax), %rdi
testq %rdi, %rdi
je 0x7be0
movl (%rax), %esi
callq 0x7f2c
movq (%r14,%r12,8), %rax
andq $0x0, 0x28(%rax)
movq (%r14,%r12,8), %rax
movq 0x20(%rax), %rdi
testq %rdi, %rdi
je 0x7bfb
callq 0x4290
movq (%r14,%r12,8), %rax
andq $0x0, 0x20(%rax)
movq (%r14,%r12,8), %rax
movq 0x30(%rax), %rdi
testq %rdi, %rdi
je 0x7c18
movl (%rax), %esi
callq 0x7f2c
movq (%r14,%r12,8), %rax
andq $0x0, 0x30(%rax)
movq (%r14,%r12,8), %rax
movq 0x38(%rax), %rdi
testq %rdi, %rdi
je 0x7c35
movl (%rax), %esi
callq 0x7f2c
movq (%r14,%r12,8), %rax
andq $0x0, 0x38(%rax)
movq (%r14,%r12,8), %rax
cmpq $0x0, 0x40(%rax)
je 0x7c69
xorl %r13d, %r13d
movslq (%rax), %rcx
cmpq %rcx, %r13
jge 0x7c64
movq 0x40(%rax), %rax
movq (%rax,%r13,8), %rdi
movsbl 0x8b8(%rbx), %esi
callq 0x7f2c
incq %r13
movq (%r14,%r12,8), %rax
jmp 0x7c3f
andq $0x0, 0x40(%rax)
incq %r12
jmp 0x7bb6
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
// File: /workspace/github_cpp_makefile_star2_O2/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:
xorl %ecx, %ecx
testb %dl, %dl
movl %edx, %eax
cmovlel %ecx, %eax
movslq %eax, %r8
cmpq %rcx, %r8
je 0x7c98
cmpl %edi, (%rsi,%rcx,4)
jg 0x7c96
incq %rcx
jmp 0x7c87
movl %ecx, %eax
movzbl %al, %ecx
movzbl %dl, %eax
cmpb %dl, %cl
cmovll %ecx, %eax
retq
// File: /workspace/github_cpp_makefile_star2_O2/myudelson[P]hmm-scalable/utils.cpp
// Function: sec_to_9cat(int, int, int*, signed char)
NPAR sec_to_9cat(int time1, int time2, int *limits, NPAR nlimits) {
    int diff = time2 - time1;
    
    if(diff <0 ) {
        fprintf(stderr,"ERROR! time 1 should be smaller than time 2\n");
        return 0;
    } else if ( diff < (2*60) ) { // 20min
        return 0;
    } else if ( diff < (20*60) ) { // 20min
        return 1;
    } else if (diff < (60*60) ) { // 1h
        return 2;
    } else if(diff < (14*24*60*60)) { // detect date structures
        time_t t1 = (time_t)time1;
        time_t t2 = (time_t)time2;
        struct tm * ttm1 = localtime (&t1);
        struct tm * ttm2 = localtime (&t2);
        if( diff < (24*60*60) && ttm1->tm_mday==ttm2->tm_mday ) { // same day
            return 3;
        } else if(    diff < (2*24*60*60) &&                      // next day
                  ( (ttm2->tm_wday == (ttm1->tm_wday+1)) ||
                   (ttm1->tm_wday==6 && ttm2->tm_wday==0)
                   )
                  ) {
            return 4;
        } else if( diff < (7*24*60*60) && (ttm1->tm_wday<ttm2->tm_wday) ) { // this week
            return 5;
        } else { // next week
            return 6;
        }
    } else if(diff < (30*24*60*60)) { // less than 30 days
        return 7;
    } else if(diff >= (30*24*60*60)) { // 30 days or more
        return 8;
    }
    return 0;
}

// Assembly:
pushq %rbp
pushq %r14
pushq %rbx
subq $0x10, %rsp
movl %esi, %ebp
subl %edi, %ebp
js 0x7d25
cmpl $0x78, %ebp
jae 0x7cbb
xorl %eax, %eax
jmp 0x7d1c
movb $0x1, %al
cmpl $0x4b0, %ebp            # imm = 0x4B0
jb 0x7d1c
movb $0x2, %al
cmpl $0xe10, %ebp            # imm = 0xE10
jb 0x7d1c
cmpl $0x1274ff, %ebp         # imm = 0x1274FF
ja 0x7d12
movslq %edi, %rax
leaq 0x8(%rsp), %rdi
movq %rax, (%rdi)
movslq %esi, %rax
movq %rsp, %r14
movq %rax, (%r14)
callq 0x4170
movq %rax, %rbx
movq %r14, %rdi
callq 0x4170
movq %rax, %rcx
cmpl $0x1517f, %ebp          # imm = 0x1517F
ja 0x7d46
movl 0xc(%rbx), %edx
movb $0x3, %al
cmpl 0xc(%rcx), %edx
je 0x7d1c
jmp 0x7d4e
cmpl $0x278d00, %ebp         # imm = 0x278D00
movb $0x8, %al
sbbb $0x0, %al
addq $0x10, %rsp
popq %rbx
popq %r14
popq %rbp
retq
movq 0x312ac(%rip), %rax     # 0x38fd8
movq (%rax), %rcx
leaq 0x24e5f(%rip), %rdi     # 0x2cb95
pushq $0x2c
popq %rsi
pushq $0x1
popq %rdx
callq 0x44b0
jmp 0x7cb7
cmpl $0x2a2ff, %ebp          # imm = 0x2A2FF
ja 0x7d68
movl 0x18(%rcx), %ecx
movl 0x18(%rbx), %edx
leal 0x1(%rdx), %esi
movb $0x4, %al
cmpl %esi, %ecx
je 0x7d1c
movl %edx, %esi
xorl $0x6, %esi
orl %ecx, %esi
je 0x7d1c
jmp 0x7d76
cmpl $0x93a7f, %ebp          # imm = 0x93A7F
ja 0x7d7c
movl 0x18(%rbx), %edx
movl 0x18(%rcx), %ecx
movb $0x5, %al
cmpl %ecx, %edx
jl 0x7d1c
movb $0x6, %al
jmp 0x7d1c
// File: /workspace/github_cpp_makefile_star2_O2/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 %r15
pushq %r14
pushq %rbx
movl %esi, %r14d
movq %rdi, %rbx
xorl %r15d, %r15d
testl %esi, %esi
cmovlel %r15d, %r14d
cmpq %r15, %r14
je 0x7f53
movq (%rbx,%r15,8), %rdi
callq 0x4290
incq %r15
jmp 0x7f40
movq %rbx, %rdi
popq %rbx
popq %r14
popq %r15
jmp 0x4290
// File: /workspace/github_cpp_makefile_star2_O2/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 %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rcx, %rbx
movq %rdx, %r15
movq %rdi, %r14
cmpq $0x0, 0x10(%rdi)
je 0x8442
movq %rsi, %r12
movq (%rsi), %rdi
movsbl 0x1(%r14), %esi
testq %rdi, %rdi
je 0x8437
callq 0x9311
jmp 0x8442
movl %esi, %edi
callq 0x7dde
movq %rax, (%r12)
cmpq $0x0, 0x18(%r14)
je 0x8469
movq (%r15), %rdi
movsbl 0x1(%r14), %esi
testq %rdi, %rdi
je 0x845f
movl %esi, %edx
callq 0x9381
jmp 0x8469
movl %esi, %edi
callq 0x9328
movq %rax, (%r15)
cmpq $0x0, 0x20(%r14)
je 0x849d
movq (%rbx), %rdi
movsbl 0x1(%r14), %esi
movsbl (%r14), %edx
testq %rdi, %rdi
je 0x8491
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
jmp 0x9381
movl %esi, %edi
movl %edx, %esi
callq 0x9328
movq %rax, (%rbx)
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
nop
// File: /workspace/github_cpp_makefile_star2_O2/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:
cmpq $0x0, 0x10(%rdi)
je 0x84e3
movzbl 0x1(%rdi), %r8d
movq (%rsi), %rax
xorl %esi, %esi
testb %r8b, %r8b
cmovlel %esi, %r8d
movzbl %r8b, %r8d
movaps 0x24473(%rip), %xmm0    # 0x2c940
cmpq %rsi, %r8
je 0x84e3
movsd (%rax,%rsi,8), %xmm1
xorps %xmm0, %xmm1
movlps %xmm1, (%rax,%rsi,8)
incq %rsi
jmp 0x84cd
cmpq $0x0, 0x18(%rdi)
je 0x852f
movzbl 0x1(%rdi), %eax
xorl %esi, %esi
testb %al, %al
movl $0x0, %r8d
cmovgl %eax, %r8d
movaps 0x2443d(%rip), %xmm0    # 0x2c940
cmpq %r8, %rsi
je 0x852f
movq (%rdx), %r9
xorl %r10d, %r10d
cmpq %r10, %rax
je 0x852a
movq (%r9,%rsi,8), %r11
movsd (%r11,%r10,8), %xmm1
xorps %xmm0, %xmm1
movlps %xmm1, (%r11,%r10,8)
incq %r10
jmp 0x850e
incq %rsi
jmp 0x8503
cmpq $0x0, 0x20(%rdi)
je 0x8585
movl (%rdi), %eax
xorl %edx, %edx
testb %al, %al
cmovlel %edx, %eax
movzbl 0x1(%rdi), %esi
testb %sil, %sil
cmovlel %edx, %esi
movl $0xff, %edi
andl %edi, %esi
andl %edi, %eax
movaps 0x243e7(%rip), %xmm0    # 0x2c940
cmpq %rsi, %rdx
je 0x8585
movq (%rcx), %rdi
xorl %r8d, %r8d
cmpq %r8, %rax
je 0x8580
movq (%rdi,%rdx,8), %r9
movsd (%r9,%r8,8), %xmm1
xorps %xmm0, %xmm1
movlps %xmm1, (%r9,%r8,8)
incq %r8
jmp 0x8564
incq %rdx
jmp 0x8559
retq
// File: /workspace/github_cpp_makefile_star2_O2/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 %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rcx, %rbx
movq %rdx, %r14
movq %rsi, %r15
movq %rdi, %r12
cmpq $0x0, 0x10(%rdi)
je 0x873d
movq (%r15), %rdi
callq 0x4290
cmpq $0x0, 0x18(%r12)
je 0x8758
movq (%r14), %rdi
testq %rdi, %rdi
je 0x8758
movsbl 0x1(%r12), %esi
callq 0x7f2c
cmpq $0x0, 0x20(%r12)
je 0x8773
movq (%rbx), %rdi
testq %rdi, %rdi
je 0x8773
movsbl 0x1(%r12), %esi
callq 0x7f2c
andq $0x0, (%r15)
andq $0x0, (%r14)
andq $0x0, (%rbx)
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
nop
// File: /workspace/github_cpp_makefile_star2_O2/myudelson[P]hmm-scalable/FitBit.cpp
// Function: FitBit::copy(FIT_BIT_SLOT, FIT_BIT_SLOT)
void FitBit::copy(enum FIT_BIT_SLOT sourse_fbs, enum FIT_BIT_SLOT target_fbs) {
    NUMBER *soursePI = NULL;
    NUMBER **sourseA = NULL;
    NUMBER **sourseB = NULL;
    get(sourse_fbs, soursePI, sourseA, sourseB);
    NUMBER *targetPI = NULL;
    NUMBER **targetA = NULL;
    NUMBER **targetB = NULL;
    get(target_fbs, targetPI, targetA, targetB);
    
    copy(soursePI, sourseA, sourseB, targetPI, targetA, targetB);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x38, %rsp
movl %edx, %ebp
movq %rdi, %rbx
leaq 0x10(%rsp), %rdx
andq $0x0, (%rdx)
leaq 0x8(%rsp), %rcx
andq $0x0, (%rcx)
leaq 0x30(%rsp), %r12
andq $0x0, (%r12)
movq %r12, %r8
callq 0x8876
leaq 0x28(%rsp), %r13
andq $0x0, (%r13)
leaq 0x20(%rsp), %r14
andq $0x0, (%r14)
leaq 0x18(%rsp), %r15
andq $0x0, (%r15)
movq %rbx, %rdi
movl %ebp, %esi
movq %r13, %rdx
movq %r14, %rcx
movq %r15, %r8
callq 0x8876
movq %r15, (%rsp)
movq %rbx, %rdi
leaq 0x10(%rsp), %rsi
leaq 0x8(%rsp), %rdx
movq %r12, %rcx
movq %r13, %r8
movq %r14, %r9
callq 0x860e
addq $0x38, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/myudelson[P]hmm-scalable/FitBit.cpp
// Function: FitBit::add(FIT_BIT_SLOT, FIT_BIT_SLOT)
void FitBit::add(enum FIT_BIT_SLOT sourse_fbs, enum FIT_BIT_SLOT target_fbs) {
    NUMBER *soursePI = NULL;
    NUMBER **sourseA = NULL;
    NUMBER **sourseB = NULL;
    get(sourse_fbs, soursePI, sourseA, sourseB);
    NUMBER *targetPI = NULL;
    NUMBER **targetA = NULL;
    NUMBER **targetB = NULL;
    get(target_fbs, targetPI, targetA, targetB);
    
    add(soursePI, sourseA, sourseB, targetPI, targetA, targetB);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x38, %rsp
movl %edx, %ebp
movq %rdi, %rbx
leaq 0x10(%rsp), %rdx
andq $0x0, (%rdx)
leaq 0x8(%rsp), %rcx
andq $0x0, (%rcx)
leaq 0x30(%rsp), %r12
andq $0x0, (%r12)
movq %r12, %r8
callq 0x8876
leaq 0x28(%rsp), %r13
andq $0x0, (%r13)
leaq 0x20(%rsp), %r14
andq $0x0, (%r14)
leaq 0x18(%rsp), %r15
andq $0x0, (%r15)
movq %rbx, %rdi
movl %ebp, %esi
movq %r13, %rdx
movq %r14, %rcx
movq %r15, %r8
callq 0x8876
leaq 0x10(%rsp), %rax
movq (%rax), %rsi
leaq 0x8(%rsp), %rax
movq (%rax), %rdx
movq (%r12), %rcx
movq (%r13), %r8
movq (%r14), %r9
movq (%r15), %rax
movq %rax, (%rsp)
movq %rbx, %rdi
callq 0x868a
addq $0x38, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O2/myudelson[P]hmm-scalable/./utils.h
// Function: double** init2D<double>(int, int)
T** init2D(NDAT size1, NDAT size2) {
	T** ar = (T **)Calloc(T *, (size_t)size1);
	for(NDAT i=0; i<size1; i++)
		ar[i] = (T *)Calloc(T, (size_t)size2);
	return ar;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movl %esi, %ebp
movslq %edi, %rbx
pushq $0x8
popq %r14
movq %rbx, %rdi
movq %r14, %rsi
callq 0x4120
movq %rax, %r15
movslq %ebp, %r12
xorl %r13d, %r13d
testl %ebx, %ebx
cmovlel %r13d, %ebx
cmpq %r13, %rbx
je 0x936f
movq %r12, %rdi
movq %r14, %rsi
callq 0x4120
movq %rax, (%r15,%r13,8)
incq %r13
jmp 0x9356
movq %r15, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/myudelson[P]hmm-scalable/FitBitSlicedA.cpp
// Function: FitBitSlicedA::init(double*&, double***&, double**&)
void FitBitSlicedA::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  = init3D<NUMBER>((NDAT)this->nZ, (NDAT)this->nS, (NDAT)this->nS);
        else
            toZero3D<NUMBER>(a_A, (NDAT)this->nZ, (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 %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rcx, %rbx
movq %rdx, %r15
movq %rdi, %r14
cmpq $0x0, 0x10(%rdi)
je 0x9650
movq %rsi, %r12
movq (%rsi), %rdi
movsbl 0x1(%r14), %esi
testq %rdi, %rdi
je 0x9645
callq 0x9311
jmp 0x9650
movl %esi, %edi
callq 0x7dde
movq %rax, (%r12)
cmpq $0x0, 0x18(%r14)
je 0x967e
movq (%r15), %rdi
movsbl 0x2(%r14), %esi
movsbl 0x1(%r14), %edx
testq %rdi, %rdi
je 0x9672
movl %edx, %ecx
callq 0xa15f
jmp 0x967e
movl %esi, %edi
movl %edx, %esi
callq 0xa0be
movq %rax, (%r15)
cmpq $0x0, 0x20(%r14)
je 0x96b2
movq (%rbx), %rdi
movsbl 0x1(%r14), %esi
movsbl (%r14), %edx
testq %rdi, %rdi
je 0x96a6
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
jmp 0x9381
movl %esi, %edi
movl %edx, %esi
callq 0x9328
movq %rax, (%rbx)
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq