LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: kiudee[P]VAHD-Projekt/./Subjects1-6.h
// Function: sLinks::add(Subject*)
inline void add(Subject *s) {
        _sLink *l;
        int contained;

        if (s == NULL) {
            if (WARNING) {
                std::cout << "-- Warning! Cannot add NULL to list of subjects.\n";
            }
        } else {
            contained = 0;      // r already in list?
            l = first;
            while (l != NULL) {
                if (l->subject == s) {
                    contained = 1;
                }
                l = l->next;
            }
            if (!contained) {   // no: add r to end of list
                l = new _sLink(s);
                if (last == NULL) { // list empty
                    first = last = l;
                } else {          // list not empty
                    last->next = l;
                    last = l;
                }
            }
        }
    }

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x38(%rbp)
cmpq $0x0, -0x10(%rbp)
jne 0x8484
jmp 0x8540
movq -0x38(%rbp), %rax
movl $0x0, -0x1c(%rbp)
movq (%rax), %rax
movq %rax, -0x18(%rbp)
cmpq $0x0, -0x18(%rbp)
je 0x84bf
movq -0x18(%rbp), %rax
movq (%rax), %rax
cmpq -0x10(%rbp), %rax
jne 0x84b1
movl $0x1, -0x1c(%rbp)
movq -0x18(%rbp), %rax
movq 0x8(%rax), %rax
movq %rax, -0x18(%rbp)
jmp 0x8496
cmpl $0x0, -0x1c(%rbp)
jne 0x853e
movl $0x10, %edi
callq 0x31c0
movq %rax, %rdi
movq %rdi, %rax
movq %rax, -0x40(%rbp)
movq -0x10(%rbp), %rsi
callq 0x8550
jmp 0x84e4
movq -0x38(%rbp), %rax
movq -0x40(%rbp), %rcx
movq %rcx, -0x18(%rbp)
cmpq $0x0, 0x8(%rax)
jne 0x8524
movq -0x38(%rbp), %rax
movq -0x18(%rbp), %rcx
movq %rcx, 0x8(%rax)
movq %rcx, (%rax)
jmp 0x853c
movq -0x40(%rbp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x28(%rbp)
movl %eax, -0x2c(%rbp)
movl $0x10, %esi
callq 0x31d0
jmp 0x8546
movq -0x38(%rbp), %rax
movq -0x18(%rbp), %rdx
movq 0x8(%rax), %rcx
movq %rdx, 0x8(%rcx)
movq -0x18(%rbp), %rcx
movq %rcx, 0x8(%rax)
jmp 0x853e
jmp 0x8540
addq $0x40, %rsp
popq %rbp
retq
movq -0x28(%rbp), %rdi
callq 0x3330
nop
// File: kiudee[P]VAHD-Projekt/./Subjects1-6.h
// Function: rLinks::wake(Relay*)
inline void wake(Relay *r) {
        _Link *l;

        l = first;
        while (l != NULL) {
            l->relay->_oLink = r;    // activate links to relay
            l = l->next;
        }
    }

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x18(%rbp)
cmpq $0x0, -0x18(%rbp)
je 0x85bb
movq -0x10(%rbp), %rcx
movq -0x18(%rbp), %rax
movq (%rax), %rax
movq %rcx, 0x28(%rax)
movq -0x18(%rbp), %rax
movq 0x8(%rax), %rax
movq %rax, -0x18(%rbp)
jmp 0x8597
popq %rbp
retq
nopl (%rax)
// File: kiudee[P]VAHD-Projekt/./Subjects1-6.h
// Function: rLinks::idle()
inline int idle() {
        _Link *r;
        int allidle;

        allidle = 1;
        r = first;
        while (r != NULL && allidle) {
            if (r->relay != NULL) {
                allidle = r->relay->_oQueue->empty();
            }
            r = r->next;
        }
        return allidle;
    }

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movl $0x1, -0x14(%rbp)
movq (%rax), %rax
movq %rax, -0x10(%rbp)
xorl %eax, %eax
cmpq $0x0, -0x10(%rbp)
movb %al, -0x15(%rbp)
je 0x85f4
cmpl $0x0, -0x14(%rbp)
setne %al
movb %al, -0x15(%rbp)
movb -0x15(%rbp), %al
testb $0x1, %al
jne 0x85fd
jmp 0x8628
movq -0x10(%rbp), %rax
cmpq $0x0, (%rax)
je 0x861a
movq -0x10(%rbp), %rax
movq (%rax), %rax
movq 0x38(%rax), %rdi
callq 0x7440
movl %eax, -0x14(%rbp)
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rax
movq %rax, -0x10(%rbp)
jmp 0x85de
movl -0x14(%rbp), %eax
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
nopl (%rax,%rax)
// File: kiudee[P]VAHD-Projekt/./Subjects1-6.h
// Function: rLinks::count()
inline int count() {
        _Link *r;
        int i;

        r = first;
        i = 0;
        while (r != NULL) {
            i++;
            r = r->next;
        }
        return i;
    }

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x10(%rbp)
movl $0x0, -0x14(%rbp)
cmpq $0x0, -0x10(%rbp)
je 0x8678
movl -0x14(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x14(%rbp)
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rax
movq %rax, -0x10(%rbp)
jmp 0x865a
movl -0x14(%rbp), %eax
popq %rbp
retq
nopl (%rax)
// File: kiudee[P]VAHD-Projekt/./Subjects1-6.h
// Function: Subject::Subject(Subject*)
Subject::Subject(Subject *s)
{
    _setup();
    if (_activeSubject == NULL) {
        if (WARNING && _debugID > 0) {
            std::cout << "-- Warning! Subject created outside of the subjects environment.\n";
        }
    } else {
        if (DEBUG) {
            std::cout << "-- Creating relay subject " << _debugID << ".\n";
        }
        if (s == NULL) {
            if (WARNING) {
                std::cout << "-- Warning! New subject not well-defined.\n";
            }
        } else {
            _parent->_Subjects->add(this);
            _parent->_activeSubjects->add(this);
            if (DEBUG) {
                std::cout << "-- Activating subject " << s->_debugID << ".\n";
            }
            _child = s;
            _child->_parent = _parent;
            _child->parent = new Relay(ROOT, _child);
        }
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x28(%rbp)
leaq 0x18501(%rip), %rax     # 0x20ba0
addq $0x10, %rax
movq %rax, (%rdi)
movq (%rdi), %rax
callq *(%rax)
leaq 0x18b5e(%rip), %rax     # 0x21210
cmpq $0x0, (%rax)
jne 0x86bd
jmp 0x875b
cmpq $0x0, -0x10(%rbp)
jne 0x86c9
jmp 0x8759
movq -0x28(%rbp), %rsi
movq 0x10(%rsi), %rax
movq 0x40(%rax), %rdi
callq 0x8460
movq -0x28(%rbp), %rsi
movq 0x10(%rsi), %rax
movq 0x48(%rax), %rdi
callq 0x8460
movq -0x28(%rbp), %rax
movq -0x10(%rbp), %rcx
movq %rcx, 0x18(%rax)
movq 0x10(%rax), %rcx
movq 0x18(%rax), %rax
movq %rcx, 0x10(%rax)
movl $0x48, %edi
callq 0x31c0
movq %rax, %rdi
movq -0x28(%rbp), %rax
movq %rdi, %rcx
movq %rcx, -0x30(%rbp)
movq 0x18(%rax), %rdx
movl $0x1, %esi
callq 0x6e50
jmp 0x872b
movq -0x30(%rbp), %rcx
movq -0x28(%rbp), %rax
movq 0x18(%rax), %rax
movq %rcx, 0x28(%rax)
jmp 0x8759
movq -0x30(%rbp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x18(%rbp)
movl %eax, -0x1c(%rbp)
movl $0x48, %esi
callq 0x31d0
jmp 0x8761
jmp 0x875b
addq $0x30, %rsp
popq %rbp
retq
movq -0x18(%rbp), %rdi
callq 0x3330
nopw (%rax,%rax)
// File: kiudee[P]VAHD-Projekt/./Subjects1-6.h
// Function: Identity::~Identity()
Identity::~Identity()
{
    _idLinks *idl;
    _idLinks *delidl;

    if (_source != NULL) {
        idl = _source->_identities;  // remove identity from id list
        while (idl->next != NULL && idl->next->id != this) {
            idl = idl->next;
        }
        if (idl->next != NULL) {
            delidl = idl->next;
            if (idl->next->next != NULL) {
                idl->next->next->prev = idl;
            }
            idl->next = idl->next->next;
            delete delidl;
        } else {
            std::cout << "Error: Identity missing in list!\n";
        }
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x20(%rbp)
cmpq $0x0, 0x10(%rax)
je 0x8860
movq -0x20(%rbp), %rax
movq 0x10(%rax), %rax
movq 0x40(%rax), %rax
movq %rax, -0x10(%rbp)
movq -0x10(%rbp), %rcx
xorl %eax, %eax
cmpq $0x0, 0x8(%rcx)
movb %al, -0x21(%rbp)
je 0x87c5
movq -0x20(%rbp), %rcx
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rax
cmpq %rcx, 0x10(%rax)
setne %al
movb %al, -0x21(%rbp)
movb -0x21(%rbp), %al
testb $0x1, %al
jne 0x87ce
jmp 0x87dc
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rax
movq %rax, -0x10(%rbp)
jmp 0x879f
movq -0x10(%rbp), %rax
cmpq $0x0, 0x8(%rax)
je 0x8847
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rax
movq %rax, -0x18(%rbp)
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rax
cmpq $0x0, 0x8(%rax)
je 0x8815
movq -0x10(%rbp), %rcx
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rax
movq 0x8(%rax), %rax
movq %rcx, (%rax)
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rax
movq 0x8(%rax), %rcx
movq -0x10(%rbp), %rax
movq %rcx, 0x8(%rax)
movq -0x18(%rbp), %rax
movq %rax, -0x30(%rbp)
cmpq $0x0, %rax
je 0x8845
movq -0x30(%rbp), %rdi
movl $0x18, %esi
callq 0x31d0
jmp 0x885e
movq 0x18782(%rip), %rdi     # 0x20fd0
leaq 0xe9fe(%rip), %rsi      # 0x17253
callq 0x31b0
jmp 0x885c
jmp 0x885e
jmp 0x8860
addq $0x30, %rsp
popq %rbp
retq
movq %rax, %rdi
callq 0x6030
nop
// File: kiudee[P]VAHD-Projekt/Hash.cpp
// Function: h(int)
double h(int kk)
{
    uint32_t i = 15;  // m = 2^i
    uint64_t k = static_cast<uint32_t>(kk);
    uint64_t t = s * k & 0x00000000FFFFFFFF;
    t = t >> (32 - i);

    return t / static_cast<double>(2 << 14);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movl %edi, -0x4(%rbp)
movl $0xf, -0x8(%rbp)
movl -0x4(%rbp), %eax
movq %rax, -0x10(%rbp)
movl -0x10(%rbp), %eax
imull $0x9e3779b9, %eax, %eax # imm = 0x9E3779B9
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rax
movb -0x8(%rbp), %cl
addb $0x20, %cl
negb %cl
shrq %cl, %rax
movq %rax, -0x18(%rbp)
movaps 0x9684(%rip), %xmm1     # 0x173b0
movq -0x18(%rbp), %xmm0
punpckldq %xmm1, %xmm0    # xmm0 = xmm0[0],xmm1[0],xmm0[1],xmm1[1]
movapd 0x9683(%rip), %xmm1     # 0x173c0
subpd %xmm1, %xmm0
movaps %xmm0, %xmm1
unpckhpd %xmm0, %xmm0            # xmm0 = xmm0[1,1]
addsd %xmm1, %xmm0
movsd 0x9654(%rip), %xmm1     # 0x173a8
divsd %xmm1, %xmm0
popq %rbp
retq
nopw (%rax,%rax)
// File: kiudee[P]VAHD-Projekt/./Subjects1-6.h
// Function: runSubjects(Subject*, unsigned long)
inline void _runSubjects(Subject *s, unsigned long T)
{
    unsigned long t;
    int busy;

    if (T == 0) {
        T = 0xFFFFFFFF;
    }
    t = 1;
    busy = 1;
    while (t <= T && busy) {
        if (DEBUG > 1) {   // step-by-step mode
            sys_pause();
            std::cout << "\n";
            std::cout << "-- Round " << t << ":\n";
        }
        busy = s->_process();
        t++;
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
cmpq $0x0, -0x10(%rbp)
jne 0xde50
movl $0xffffffff, %eax       # imm = 0xFFFFFFFF
movq %rax, -0x10(%rbp)
movq $0x1, -0x18(%rbp)
movl $0x1, -0x1c(%rbp)
movq -0x18(%rbp), %rcx
xorl %eax, %eax
cmpq -0x10(%rbp), %rcx
movb %al, -0x1d(%rbp)
ja 0xde78
cmpl $0x0, -0x1c(%rbp)
setne %al
movb %al, -0x1d(%rbp)
movb -0x1d(%rbp), %al
testb $0x1, %al
jne 0xde81
jmp 0xde9c
movq -0x8(%rbp), %rdi
movq (%rdi), %rax
callq *0x8(%rax)
movl %eax, -0x1c(%rbp)
movq -0x18(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x18(%rbp)
jmp 0xde5f
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
nopl (%rax)
// File: kiudee[P]VAHD-Projekt/./Subjects1-6.h
// Function: sys_pause()
inline void sys_pause()
{
    std::cout << "press [return] to continue \n";
    char c;
    do {
        std::cin.get(c);
    } while (std::cin.good() && c != '\n');
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq 0x12fc1(%rip), %rdi     # 0x20fd0
leaq 0x93c7(%rip), %rsi      # 0x173dd
callq 0x31b0
movq 0x12fbe(%rip), %rdi     # 0x20fe0
leaq -0x1(%rbp), %rsi
callq 0x3290
movq 0x12fae(%rip), %rax     # 0x20fe0
movq (%rax), %rax
movq 0x12fa4(%rip), %rdi     # 0x20fe0
addq -0x18(%rax), %rdi
callq 0x3310
movb %al, %cl
xorl %eax, %eax
testb $0x1, %cl
movb %al, -0x2(%rbp)
jne 0xe053
jmp 0xe060
movsbl -0x1(%rbp), %eax
cmpl $0xa, %eax
setne %al
movb %al, -0x2(%rbp)
movb -0x2(%rbp), %al
testb $0x1, %al
jne 0xe01b
addq $0x10, %rsp
popq %rbp
retq
nopl (%rax)
// File: kiudee[P]VAHD-Projekt/Node.cpp
// Function: Node::Wakeup(NumObj*)
Action Node::Wakeup(NumObj *num)
{
    if (num->num == 0) {
        BuildDeBruijn();
    } else {
        num->num--;
        call(Node::Wakeup, num);
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x38(%rbp)
movq -0x10(%rbp), %rax
cmpl $0x0, 0x20(%rax)
jne 0xf5ad
movq -0x38(%rbp), %rdi
callq 0xf640
jmp 0xf622
movq -0x10(%rbp), %rax
movl 0x20(%rax), %ecx
decl %ecx
movl %ecx, 0x20(%rax)
movl $0x38, %edi
callq 0x31c0
movq %rax, %rdi
movq %rdi, %rax
movq %rax, -0x40(%rbp)
leaq -0x54(%rip), %rax       # 0xf580
movq %rax, -0x20(%rbp)
movq $0x0, -0x18(%rbp)
movq -0x20(%rbp), %rsi
movq -0x18(%rbp), %rdx
leaq -0x10(%rbp), %rcx
callq 0x5ae0
jmp 0xf5f3
movq -0x40(%rbp), %rdx
movq -0x38(%rbp), %rsi
movq (%rsi), %rax
movq %rsi, %rdi
callq *0x48(%rax)
jmp 0xf622
movq -0x40(%rbp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x28(%rbp)
movl %eax, -0x2c(%rbp)
movl $0x38, %esi
callq 0x31d0
jmp 0xf628
addq $0x40, %rsp
popq %rbp
retq
movq -0x28(%rbp), %rdi
callq 0x3330
nopw %cs:(%rax,%rax)
// File: kiudee[P]VAHD-Projekt/Node.cpp
// Function: Node::checkDead(NodeRelay**, bool)
void Node::checkDead(NodeRelay **side, bool right)
{
    if ((*side) != NULL && outdeg((*side)->out) == 0) {
        NodeRelay *tmpptr = *side;
        delete tmpptr->out;
        delete *side;
        *side = NULL;
        if (right) {

            rightstable = false;
        } else {

            leftstable = false;
        }
    }

}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movb %dl, %al
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
andb $0x1, %al
movb %al, -0x11(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x28(%rbp)
movq -0x10(%rbp), %rax
cmpq $0x0, (%rax)
je 0xf72f
movq -0x28(%rbp), %rdi
movq -0x10(%rbp), %rax
movq (%rax), %rax
movq 0x28(%rax), %rsi
movq (%rdi), %rax
callq *0x68(%rax)
cmpl $0x0, %eax
jne 0xf72f
movq -0x10(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x20(%rbp)
movq -0x20(%rbp), %rax
movq 0x28(%rax), %rax
movq %rax, -0x30(%rbp)
cmpq $0x0, %rax
je 0xf6eb
movq -0x30(%rbp), %rdi
callq 0x74c0
movq -0x30(%rbp), %rdi
movl $0x48, %esi
callq 0x31d0
movq -0x10(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x38(%rbp)
cmpq $0x0, %rax
je 0xf70a
movq -0x38(%rbp), %rdi
movl $0x38, %esi
callq 0x31d0
movq -0x10(%rbp), %rax
movq $0x0, (%rax)
testb $0x1, -0x11(%rbp)
je 0xf725
movq -0x28(%rbp), %rax
movb $0x0, 0x61(%rax)
jmp 0xf72d
movq -0x28(%rbp), %rax
movb $0x0, 0x60(%rax)
jmp 0xf72f
addq $0x40, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: kiudee[P]VAHD-Projekt/Node.cpp
// Function: Node::calcRoutingBound()
double Node::calcRoutingBound()
{
    double r;
    if (rightstable && right != NULL && right->num != num) {
        r = -2 * log(fabs(num - right->num));
    } else if (leftstable && left != NULL  && left->num != num) {
        r = -2 * log(fabs(num - left->num));
    } else if (right != NULL && right->num != num) {
        r = -2 * log(fabs(num - right->num));
    } else if (left != NULL  && left->num != num) {
        r = -2 * log(fabs(num - left->num)); //in expectancy: |s-pred(s)|=|s-succ(s)|; s is the node where we started a search
    } else {
        r = 0.0; //it is a better strategy to wait until one neighbor is available instead of routing in O(n)
    }
    return r;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x18(%rbp)
testb $0x1, 0x61(%rax)
je 0x10337
movq -0x18(%rbp), %rax
cmpq $0x0, 0xd0(%rax)
je 0x10337
movq -0x18(%rbp), %rax
movq 0xd0(%rax), %rcx
movsd 0x20(%rcx), %xmm0
ucomisd 0xb0(%rax), %xmm0
jne 0x102f6
jp 0x102f6
jmp 0x10337
movq -0x18(%rbp), %rax
movsd 0xb0(%rax), %xmm0
movq 0xd0(%rax), %rax
subsd 0x20(%rax), %xmm0
movaps 0x711b(%rip), %xmm1     # 0x17430
pand %xmm1, %xmm0
callq 0x3160
movaps %xmm0, %xmm1
movsd 0x70f7(%rip), %xmm0     # 0x17420
mulsd %xmm1, %xmm0
movsd %xmm0, -0x10(%rbp)
jmp 0x10490
movq -0x18(%rbp), %rax
testb $0x1, 0x60(%rax)
je 0x103ae
movq -0x18(%rbp), %rax
cmpq $0x0, 0xc8(%rax)
je 0x103ae
movq -0x18(%rbp), %rax
movq 0xc8(%rax), %rcx
movsd 0x20(%rcx), %xmm0
ucomisd 0xb0(%rax), %xmm0
jne 0x1036d
jp 0x1036d
jmp 0x103ae
movq -0x18(%rbp), %rax
movsd 0xb0(%rax), %xmm0
movq 0xc8(%rax), %rax
subsd 0x20(%rax), %xmm0
movaps 0x70a4(%rip), %xmm1     # 0x17430
pand %xmm1, %xmm0
callq 0x3160
movaps %xmm0, %xmm1
movsd 0x7080(%rip), %xmm0     # 0x17420
mulsd %xmm1, %xmm0
movsd %xmm0, -0x10(%rbp)
jmp 0x1048e
movq -0x18(%rbp), %rax
cmpq $0x0, 0xd0(%rax)
je 0x10418
movq -0x18(%rbp), %rax
movq 0xd0(%rax), %rcx
movsd 0x20(%rcx), %xmm0
ucomisd 0xb0(%rax), %xmm0
jne 0x103da
jp 0x103da
jmp 0x10418
movq -0x18(%rbp), %rax
movsd 0xb0(%rax), %xmm0
movq 0xd0(%rax), %rax
subsd 0x20(%rax), %xmm0
movaps 0x7037(%rip), %xmm1     # 0x17430
pand %xmm1, %xmm0
callq 0x3160
movaps %xmm0, %xmm1
movsd 0x7013(%rip), %xmm0     # 0x17420
mulsd %xmm1, %xmm0
movsd %xmm0, -0x10(%rbp)
jmp 0x1048c
movq -0x18(%rbp), %rax
cmpq $0x0, 0xc8(%rax)
je 0x10482
movq -0x18(%rbp), %rax
movq 0xc8(%rax), %rcx
movsd 0x20(%rcx), %xmm0
ucomisd 0xb0(%rax), %xmm0
jne 0x10444
jp 0x10444
jmp 0x10482
movq -0x18(%rbp), %rax
movsd 0xb0(%rax), %xmm0
movq 0xc8(%rax), %rax
subsd 0x20(%rax), %xmm0
movaps 0x6fcd(%rip), %xmm1     # 0x17430
pand %xmm1, %xmm0
callq 0x3160
movaps %xmm0, %xmm1
movsd 0x6fa9(%rip), %xmm0     # 0x17420
mulsd %xmm1, %xmm0
movsd %xmm0, -0x10(%rbp)
jmp 0x1048a
xorps %xmm0, %xmm0
movsd %xmm0, -0x10(%rbp)
jmp 0x1048c
jmp 0x1048e
jmp 0x10490
movsd -0x10(%rbp), %xmm0
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: kiudee[P]VAHD-Projekt/Node.cpp
// Function: Node::Insert(DateObj*)
Action Node::Insert(DateObj *dob)
{

    std::cout << num << "<-Insert(key: " << dob->num << ", data: " << dob->date << ")\n";
    SearchJob *sj = new SearchJob(g(dob->num), INSERT,
                                  Node::calcRoutingBound(), dob, num);
    Search(sj);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x40(%rbp)
movsd 0xb0(%rax), %xmm0
movq 0xf839(%rip), %rdi      # 0x20fd0
callq 0x3370
movq %rax, %rdi
leaq 0x5cb2(%rip), %rsi      # 0x17458
callq 0x31b0
movq %rax, %rdi
movq -0x10(%rbp), %rax
movl 0x20(%rax), %esi
callq 0x3320
movq %rax, %rdi
leaq 0x5ca3(%rip), %rsi      # 0x17467
callq 0x31b0
movq %rax, %rdi
movq -0x10(%rbp), %rsi
addq $0x28, %rsi
callq 0x3190
movq %rax, %rdi
leaq 0x5c8d(%rip), %rsi      # 0x17470
callq 0x31b0
movl $0x60, %edi
callq 0x31c0
movq %rax, -0x38(%rbp)
movq -0x10(%rbp), %rax
movl 0x20(%rax), %edi
callq 0xdd60
movsd %xmm0, -0x30(%rbp)
jmp 0x11809
movq -0x40(%rbp), %rdi
callq 0x102b0
movq -0x40(%rbp), %rax
movq -0x38(%rbp), %rdi
movaps %xmm0, %xmm1
movsd -0x30(%rbp), %xmm0
movq -0x10(%rbp), %rdx
movsd 0xb0(%rax), %xmm2
xorl %esi, %esi
callq 0x15800
jmp 0x11837
movq -0x40(%rbp), %rdi
movq -0x38(%rbp), %rax
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rsi
callq 0x11880
addq $0x40, %rsp
popq %rbp
retq
movq -0x38(%rbp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x20(%rbp)
movl %eax, -0x24(%rbp)
movl $0x60, %esi
callq 0x31d0
movq -0x20(%rbp), %rdi
callq 0x3330
nopw %cs:(%rax,%rax)
// File: kiudee[P]VAHD-Projekt/Node.cpp
// Function: Node::DataInsert(DateObj*)
Action Node::DataInsert(DateObj *dob)
{

    std::cout << num << "<-DataInsert(key: " << dob->num << ", data: " << dob->date << ")\n";
    SearchJob *sj = new SearchJob(g(dob->num), DATAINSERT,
                                  Node::calcRoutingBound(), dob, num);
    FinishSearch(sj);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x40(%rbp)
movsd 0xb0(%rax), %xmm0
movq 0xf579(%rip), %rdi      # 0x20fd0
callq 0x3370
movq %rax, %rdi
leaq 0x5a0d(%rip), %rsi      # 0x17473
callq 0x31b0
movq %rax, %rdi
movq -0x10(%rbp), %rax
movl 0x20(%rax), %esi
callq 0x3320
movq %rax, %rdi
leaq 0x59e3(%rip), %rsi      # 0x17467
callq 0x31b0
movq %rax, %rdi
movq -0x10(%rbp), %rsi
addq $0x28, %rsi
callq 0x3190
movq %rax, %rdi
leaq 0x59cd(%rip), %rsi      # 0x17470
callq 0x31b0
movl $0x60, %edi
callq 0x31c0
movq %rax, -0x38(%rbp)
movq -0x10(%rbp), %rax
movl 0x20(%rax), %edi
callq 0xdd60
movsd %xmm0, -0x30(%rbp)
jmp 0x11ac9
movq -0x40(%rbp), %rdi
callq 0x102b0
movq -0x40(%rbp), %rax
movq -0x38(%rbp), %rdi
movaps %xmm0, %xmm1
movsd -0x30(%rbp), %xmm0
movq -0x10(%rbp), %rdx
movsd 0xb0(%rax), %xmm2
movl $0x5, %esi
callq 0x15800
jmp 0x11afa
movq -0x40(%rbp), %rdi
movq -0x38(%rbp), %rax
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rsi
callq 0x11b40
addq $0x40, %rsp
popq %rbp
retq
movq -0x38(%rbp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x20(%rbp)
movl %eax, -0x24(%rbp)
movl $0x60, %esi
callq 0x31d0
movq -0x20(%rbp), %rdi
callq 0x3330
nopl (%rax,%rax)
// File: kiudee[P]VAHD-Projekt/Node.cpp
// Function: Node::ReceiveLookUp(DateObj*)
Action Node::ReceiveLookUp(DateObj *dob)
{
    if (dob->date != "") {
        std::cout << "Node " << num << " receives data for key " << dob->num << ": " << dob->date << "\n";
    } else {
        std::cout << "Node " << num << " receives data for key " << dob->num << ":  NULL\n";
    }
    delete dob;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x18(%rbp)
movq -0x10(%rbp), %rdi
addq $0x28, %rdi
leaq 0x4ba9(%rip), %rsi      # 0x174c0
callq 0x15af0
testb $0x1, %al
jne 0x12922
jmp 0x12997
movq 0xe6a7(%rip), %rdi      # 0x20fd0
leaq 0x48da(%rip), %rsi      # 0x1720a
callq 0x31b0
movq %rax, %rdi
movq -0x18(%rbp), %rax
movsd 0xb0(%rax), %xmm0
callq 0x3370
movq %rax, %rdi
leaq 0x4bcd(%rip), %rsi      # 0x17520
callq 0x31b0
movq %rax, %rdi
movq -0x10(%rbp), %rax
movl 0x20(%rax), %esi
callq 0x3320
movq %rax, %rdi
leaq 0x4afc(%rip), %rsi      # 0x1746d
callq 0x31b0
movq %rax, %rdi
movq -0x10(%rbp), %rsi
addq $0x28, %rsi
callq 0x3190
movq %rax, %rdi
leaq 0x4b2f(%rip), %rsi      # 0x174bf
callq 0x31b0
jmp 0x129eb
movq 0xe632(%rip), %rdi      # 0x20fd0
leaq 0x4865(%rip), %rsi      # 0x1720a
callq 0x31b0
movq %rax, %rdi
movq -0x18(%rbp), %rax
movsd 0xb0(%rax), %xmm0
callq 0x3370
movq %rax, %rdi
leaq 0x4b58(%rip), %rsi      # 0x17520
callq 0x31b0
movq %rax, %rdi
movq -0x10(%rbp), %rax
movl 0x20(%rax), %esi
callq 0x3320
movq %rax, %rdi
leaq 0x4b52(%rip), %rsi      # 0x17538
callq 0x31b0
movq -0x10(%rbp), %rax
movq %rax, -0x20(%rbp)
cmpq $0x0, %rax
je 0x12a10
movq -0x20(%rbp), %rdi
callq 0x15b20
movq -0x20(%rbp), %rdi
movl $0x48, %esi
callq 0x31d0
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: kiudee[P]VAHD-Projekt/Node.cpp
// Function: Node::delegateSearchJobToLastNode(SearchJob*)
void Node::delegateSearchJobToLastNode(SearchJob *sj)
{
    //SearchJob *newsj = new SearchJob(sj);
    sj->sid = MAX;//TO DO this won't work because we want to search for MAX and not for g(MAX)! adjust searchjob=> fixed
    sj->round = 0;
    //std::cout << num << "<-delegateSearchJobToLastNode(" << sj->sid << ");\n";
    Search(sj);
    //delete sj;
    return;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rax
movsd 0x4578(%rip), %xmm0     # 0x17408
movsd %xmm0, 0x20(%rax)
movq -0x10(%rbp), %rax
movl $0x0, 0x48(%rax)
movq -0x10(%rbp), %rsi
callq 0x11880
addq $0x10, %rsp
popq %rbp
retq
nop
// File: kiudee[P]VAHD-Projekt/Node.cpp
// Function: Node::LookUp(NumObj*)
Action Node::LookUp(NumObj *key)
{

    std::cout << num << "<-LookUp(" << g(key->num) << ")\n";
    IdObj *ido = new IdObj(num, new Identity(in), _debugID);
    SearchJob *sj = new SearchJob(g(key->num), LOOKUP,
                                  Node::calcRoutingBound(), ido, key->num, num);
    Search(sj);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x70, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x50(%rbp)
movsd 0xb0(%rax), %xmm0
movq 0xd789(%rip), %rdi      # 0x20fd0
callq 0x3370
movq %rax, %rdi
leaq 0x3cc0(%rip), %rsi      # 0x17516
callq 0x31b0
movq %rax, -0x58(%rbp)
movq -0x10(%rbp), %rax
movl 0x20(%rax), %edi
callq 0xdd60
movq -0x58(%rbp), %rdi
callq 0x3370
movq %rax, %rdi
leaq 0x3bf2(%rip), %rsi      # 0x17470
callq 0x31b0
movl $0x38, %edi
callq 0x31c0
movq %rax, %rcx
movq -0x50(%rbp), %rax
movq %rcx, -0x48(%rbp)
movsd 0xb0(%rax), %xmm0
movsd %xmm0, -0x40(%rbp)
movl $0x28, %edi
callq 0x31c0
movq %rax, -0x38(%rbp)
jmp 0x138b5
movq -0x38(%rbp), %rdi
movq -0x50(%rbp), %rax
movq 0xc0(%rax), %rsi
callq 0x153e0
jmp 0x138cb
movq -0x38(%rbp), %rsi
movsd -0x40(%rbp), %xmm0
movq -0x48(%rbp), %rdi
movq -0x50(%rbp), %rax
movl 0x8(%rax), %edx
callq 0x15520
jmp 0x138e6
movq -0x48(%rbp), %rax
movq %rax, -0x18(%rbp)
movl $0x60, %edi
callq 0x31c0
movq %rax, -0x68(%rbp)
movq -0x10(%rbp), %rax
movl 0x20(%rax), %edi
callq 0xdd60
movsd %xmm0, -0x60(%rbp)
jmp 0x1390f
movq -0x50(%rbp), %rdi
callq 0x102b0
movq -0x50(%rbp), %rax
movq -0x68(%rbp), %rdi
movaps %xmm0, %xmm1
movsd -0x60(%rbp), %xmm0
movq -0x18(%rbp), %rdx
movq -0x10(%rbp), %rcx
movl 0x20(%rcx), %ecx
movsd 0xb0(%rax), %xmm2
movl $0x2, %esi
callq 0x15a60
jmp 0x13947
movq -0x50(%rbp), %rdi
movq -0x68(%rbp), %rax
movq %rax, -0x30(%rbp)
movq -0x30(%rbp), %rsi
callq 0x11880
addq $0x70, %rsp
popq %rbp
retq
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x20(%rbp)
movl %eax, -0x24(%rbp)
jmp 0x1398a
movq -0x38(%rbp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x20(%rbp)
movl %eax, -0x24(%rbp)
movl $0x28, %esi
callq 0x31d0
movq -0x48(%rbp), %rdi
movl $0x38, %esi
callq 0x31d0
jmp 0x139b4
movq -0x68(%rbp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x20(%rbp)
movl %eax, -0x24(%rbp)
movl $0x60, %esi
callq 0x31d0
movq -0x20(%rbp), %rdi
callq 0x3330
nopl (%rax)
// File: kiudee[P]VAHD-Projekt/Node.cpp
// Function: Node::Join(IdObj*)
Action Node::Join(IdObj *ido)
{
    /* TO DO move data from predecessor to the new node. but how
     * and when do we trigger the data transfer at the predecessor???
     * the predecessor does not know the new node and vice versa.
     * solution: we are routing only in stable state and the node
     * joins at the right place!
     */
    //std::cout << num << "<-Join(" << ido->num << ");\n";
    SearchJob *sj =
        new SearchJob(ido->num, JOIN, Node::calcRoutingBound(), ido);
    Search(sj);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x48(%rbp)
movl $0x60, %edi
callq 0x31c0
movq -0x48(%rbp), %rdi
movq %rax, -0x38(%rbp)
movq %rax, -0x40(%rbp)
movq -0x10(%rbp), %rax
movsd 0x20(%rax), %xmm0
movsd %xmm0, -0x30(%rbp)
callq 0x102b0
movq -0x38(%rbp), %rdi
movaps %xmm0, %xmm1
movsd -0x30(%rbp), %xmm0
movq -0x10(%rbp), %rdx
movl $0x3, %esi
callq 0x15960
jmp 0x13a1d
movq -0x48(%rbp), %rdi
movq -0x40(%rbp), %rax
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rsi
callq 0x11880
addq $0x50, %rsp
popq %rbp
retq
movq -0x40(%rbp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x20(%rbp)
movl %eax, -0x24(%rbp)
movl $0x60, %esi
callq 0x31d0
movq -0x20(%rbp), %rdi
callq 0x3330
nopl (%rax,%rax)
// File: kiudee[P]VAHD-Projekt/Node.cpp
// Function: Node::isSelf(IdObj*)
bool Node::isSelf(IdObj *ido)
{
    Identity *self = new Identity(in);
    bool r = self->_base->ID == ido->id->_base->ID;
    delete self;
    return r;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x38(%rbp)
movl $0x28, %edi
callq 0x31c0
movq %rax, %rdi
movq -0x38(%rbp), %rax
movq %rdi, %rcx
movq %rcx, -0x30(%rbp)
movq 0xc0(%rax), %rsi
callq 0x153e0
jmp 0x148ce
movq -0x30(%rbp), %rax
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rax
movq 0x20(%rax), %rax
movq 0x8(%rax), %rax
movq -0x10(%rbp), %rcx
movq 0x28(%rcx), %rcx
movq 0x20(%rcx), %rcx
cmpq 0x8(%rcx), %rax
sete %al
andb $0x1, %al
movb %al, -0x25(%rbp)
movq -0x18(%rbp), %rax
movq %rax, -0x40(%rbp)
cmpq $0x0, %rax
je 0x1491f
movq -0x40(%rbp), %rdi
callq 0x8770
movq -0x40(%rbp), %rdi
movl $0x28, %esi
callq 0x31d0
movb -0x25(%rbp), %al
andb $0x1, %al
addq $0x40, %rsp
popq %rbp
retq
movq -0x30(%rbp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x20(%rbp)
movl %eax, -0x24(%rbp)
movl $0x28, %esi
callq 0x31d0
movq -0x20(%rbp), %rdi
callq 0x3330
nopl (%rax)
// File: kiudee[P]VAHD-Projekt/Node.cpp
// Function: Node::_DebugRouteFromLeftToRight(NumObj*)
Action Node::_DebugRouteFromLeftToRight(NumObj *numo)
{
    std::cout << num << "<-_DebugRouteFromLeftToRight() debugid?" << numo->num << " real?" << isReal << "\n";
    if (right != NULL) {
        right->out->call(Node::_DebugRouteFromLeftToRight, numo);
    } else {
        std::cout << "END DEBUG\n";
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x38(%rbp)
movsd 0xb0(%rax), %xmm0
movq 0xc659(%rip), %rdi      # 0x20fd0
callq 0x3370
movq %rax, %rdi
leaq 0x2bfc(%rip), %rsi      # 0x17582
callq 0x31b0
movq %rax, %rdi
movq -0x10(%rbp), %rax
movl 0x20(%rax), %esi
callq 0x3320
movq %rax, %rdi
leaq 0x2c2f(%rip), %rsi      # 0x175d3
callq 0x31b0
movq %rax, %rdi
movq -0x38(%rbp), %rax
movb 0xb8(%rax), %al
andb $0x1, %al
movzbl %al, %esi
callq 0x3350
movq %rax, %rdi
leaq 0x2af5(%rip), %rsi      # 0x174bf
callq 0x31b0
movq -0x38(%rbp), %rax
cmpq $0x0, 0xd0(%rax)
je 0x14a5a
movq -0x38(%rbp), %rax
movq 0xd0(%rax), %rax
movq 0x28(%rax), %rax
movq %rax, -0x48(%rbp)
movl $0x38, %edi
callq 0x31c0
movq %rax, %rdi
movq %rdi, %rax
movq %rax, -0x40(%rbp)
leaq -0xbb(%rip), %rax       # 0x14950
movq %rax, -0x20(%rbp)
movq $0x0, -0x18(%rbp)
movq -0x20(%rbp), %rsi
movq -0x18(%rbp), %rdx
leaq -0x10(%rbp), %rcx
callq 0x5ae0
jmp 0x14a2a
movq -0x40(%rbp), %rdx
movq -0x38(%rbp), %rsi
movq -0x48(%rbp), %rdi
movq (%rdi), %rax
callq *0x8(%rax)
jmp 0x14a6d
movq -0x40(%rbp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x28(%rbp)
movl %eax, -0x2c(%rbp)
movl $0x38, %esi
callq 0x31d0
jmp 0x14a73
movq 0xc56f(%rip), %rdi      # 0x20fd0
leaq 0x2b42(%rip), %rsi      # 0x175aa
callq 0x31b0
addq $0x50, %rsp
popq %rbp
retq
movq -0x28(%rbp), %rdi
callq 0x3330
nopl (%rax)
// File: kiudee[P]VAHD-Projekt/Node.cpp
// Function: Node::_DebugRouteFromRightToLeft()
Action Node::_DebugRouteFromRightToLeft()
{
    std::cout << num << "<-_DebugRouteFromRightToLeft() real?" << isReal << "\n";
    if (left != NULL) {
        left->out->call(Node::_DebugRouteFromRightToLeft, NONE);
    } else {
        std::cout << "END DEBUG\n";
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x30(%rbp)
movsd 0xb0(%rax), %xmm0
movq 0xc52d(%rip), %rdi      # 0x20fd0
callq 0x3370
movq %rax, %rdi
leaq 0x2b03(%rip), %rsi      # 0x175b5
callq 0x31b0
movq %rax, %rdi
movq -0x30(%rbp), %rax
movb 0xb8(%rax), %al
andb $0x1, %al
movzbl %al, %esi
callq 0x3350
movq %rax, %rdi
leaq 0x29e7(%rip), %rsi      # 0x174bf
callq 0x31b0
movq -0x30(%rbp), %rax
cmpq $0x0, 0xc8(%rax)
je 0x14b6f
movq -0x30(%rbp), %rax
movq 0xc8(%rax), %rax
movq 0x28(%rax), %rax
movq %rax, -0x40(%rbp)
movl $0x38, %edi
callq 0x31c0
movq %rax, %rdi
movq %rdi, %rax
movq %rax, -0x38(%rbp)
leaq -0x9d(%rip), %rax       # 0x14a80
movq %rax, -0x18(%rbp)
movq $0x0, -0x10(%rbp)
movq -0x18(%rbp), %rsi
movq -0x10(%rbp), %rdx
leaq 0xc6e8(%rip), %rcx      # 0x21220
callq 0x5ae0
jmp 0x14b3f
movq -0x38(%rbp), %rdx
movq -0x30(%rbp), %rsi
movq -0x40(%rbp), %rdi
movq (%rdi), %rax
callq *0x8(%rax)
jmp 0x14b82
movq -0x38(%rbp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x20(%rbp)
movl %eax, -0x24(%rbp)
movl $0x38, %esi
callq 0x31d0
jmp 0x14b88
movq 0xc45a(%rip), %rdi      # 0x20fd0
leaq 0x2a2d(%rip), %rsi      # 0x175aa
callq 0x31b0
addq $0x40, %rsp
popq %rbp
retq
movq -0x20(%rbp), %rdi
callq 0x3330
nopw %cs:(%rax,%rax)
// File: kiudee[P]VAHD-Projekt/./Subjects1-6.h
// Function: Relay::Relay()
Relay::Relay()
{
    _home = _activeSubject;
    _setup();
    if (_home != NULL) {
        if (DEBUG) {
            std::cout << "-- Creating relay point " << ID << " by subject " << _home->_debugID << ".\n";
        }
        if (_home->_sink != NULL) {
            _oLink = _home->_sink;     // Relay has link to own subject
            _oLink->_iLinks->add(this);
        }
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x10(%rbp)
leaq 0xb8c5(%rip), %rax      # 0x20c20
addq $0x10, %rax
movq %rax, (%rdi)
leaq 0xbea7(%rip), %rax      # 0x21210
movq (%rax), %rax
movq %rax, 0x18(%rdi)
movq (%rdi), %rax
callq *(%rax)
movq -0x10(%rbp), %rax
cmpq $0x0, 0x18(%rax)
je 0x153ae
movq -0x10(%rbp), %rax
movq 0x18(%rax), %rax
cmpq $0x0, 0x20(%rax)
je 0x153ac
movq -0x10(%rbp), %rsi
movq 0x18(%rsi), %rax
movq 0x20(%rax), %rax
movq %rax, 0x28(%rsi)
movq 0x28(%rsi), %rax
movq 0x20(%rax), %rdi
callq 0x6ef0
jmp 0x153ae
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
nop
// File: kiudee[P]VAHD-Projekt/./Subjects1-6.h
// Function: Identity::Identity(Relay*)
Identity::Identity(Relay *r)
{
    _idLinks *idl;

    _source = NULL;
    _sink = NULL;
    _base = NULL;
    if (_activeSubject == NULL) {
        if (WARNING) {
            std::cout << "-- Warning! Identity not created within active subject.\n";
        }
    } else {
        if (r == NULL) {
            if (WARNING) {
                std::cout << "-- Warning! Cannot create identity of NULL.\n";
            }
        } else {
            if (r->_home != _activeSubject) {
                if (WARNING) {
                    std::cout << "Warning! Subject " << _activeSubject->_debugID << " cannot create identity for relay " << r->ID << ".\n";
                }
            } else {
                if (DEBUG) {
                    std::cout << "-- Creating public identity of " << r->ID << ".\n";
                }
                _source = r;               // set source and base
                _base = r->_base;
                idl = new _idLinks(this);  // add identity at beginning of list
                if (r->_identities->next != NULL) {
                    r->_identities->next->prev = idl;
                }
                idl->next = r->_identities->next;
                idl->prev = r->_identities;
                r->_identities->next = idl;
            }
        }
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x30(%rbp)
callq 0x6140
movq -0x30(%rbp), %rax
movq $0x0, 0x10(%rax)
movq $0x0, 0x18(%rax)
movq $0x0, 0x20(%rax)
leaq 0xbdf0(%rip), %rax      # 0x21210
cmpq $0x0, (%rax)
jne 0x1542b
jmp 0x15506
cmpq $0x0, -0x10(%rbp)
jne 0x15437
jmp 0x15504
movq -0x10(%rbp), %rax
movq 0x18(%rax), %rax
leaq 0xbdca(%rip), %rcx      # 0x21210
cmpq (%rcx), %rax
je 0x15450
jmp 0x15502
movq -0x30(%rbp), %rax
movq -0x10(%rbp), %rcx
movq %rcx, 0x10(%rax)
movq -0x10(%rbp), %rcx
movq 0x30(%rcx), %rcx
movq %rcx, 0x20(%rax)
movl $0x18, %edi
callq 0x31c0
movq -0x30(%rbp), %rsi
movq %rax, %rdi
movq %rdi, %rax
movq %rax, -0x38(%rbp)
callq 0x73b0
jmp 0x15487
movq -0x38(%rbp), %rax
movq %rax, -0x18(%rbp)
movq -0x10(%rbp), %rax
movq 0x40(%rax), %rax
cmpq $0x0, 0x8(%rax)
je 0x154cf
movq -0x18(%rbp), %rcx
movq -0x10(%rbp), %rax
movq 0x40(%rax), %rax
movq 0x8(%rax), %rax
movq %rcx, (%rax)
jmp 0x154cf
movq -0x38(%rbp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x20(%rbp)
movl %eax, -0x24(%rbp)
movl $0x18, %esi
callq 0x31d0
jmp 0x1550c
movq -0x10(%rbp), %rax
movq 0x40(%rax), %rax
movq 0x8(%rax), %rcx
movq -0x18(%rbp), %rax
movq %rcx, 0x8(%rax)
movq -0x10(%rbp), %rax
movq 0x40(%rax), %rcx
movq -0x18(%rbp), %rax
movq %rcx, (%rax)
movq -0x18(%rbp), %rcx
movq -0x10(%rbp), %rax
movq 0x40(%rax), %rax
movq %rcx, 0x8(%rax)
jmp 0x15504
jmp 0x15506
addq $0x40, %rsp
popq %rbp
retq
movq -0x20(%rbp), %rdi
callq 0x3330
nopw %cs:(%rax,%rax)
nop
// File: kiudee[P]VAHD-Projekt/./Subjects1-6.h
// Function: Identity::Identity()
Identity::Identity()
{
    _source = NULL;
    _sink = NULL;
    _base = NULL;
    //if (WARNING)
    //  std::cout << "-- Warning! Creating empty identity.\n";
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x10(%rbp)
callq 0x6140
movq -0x10(%rbp), %rax
movq $0x0, 0x10(%rax)
movq $0x0, 0x18(%rax)
movq $0x0, 0x20(%rax)
addq $0x10, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: mirkat1206[P]Quine-McCluskey-Petrick-Method/main.cpp
// Function: Output(std::basic_ofstream<char, std::char_traits<char>>&, Quine_McCluskey&, Petrick_Method&)
void Output(ofstream &fout, Quine_McCluskey &QM, Petrick_Method &PM) {
	QM.HW1_Print_Prime_Impli();
	QM.HW1_Print_Prime_Impli(fout);
	PM.HW1_Print_Minimum_Cover();	
	PM.HW1_Print_Minimum_Cover(fout);	
	cout<< endl;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x10(%rbp), %rdi
callq 0x3f60
movq -0x10(%rbp), %rdi
movq -0x8(%rbp), %rsi
callq 0x4050
movq -0x18(%rbp), %rdi
callq 0xbcb0
movq -0x18(%rbp), %rdi
movq -0x8(%rbp), %rsi
callq 0xbe70
movq 0x16429(%rip), %rdi     # 0x18fd0
movq 0x16412(%rip), %rsi     # 0x18fc0
callq 0x2210
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax)
// File: mirkat1206[P]Quine-McCluskey-Petrick-Method/Quine_McCluskey.cpp
// Function: sort_by_num_of_1(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>)
bool sort_by_num_of_1(const string a, const string b) {
	int cnt_a = 0 , cnt_b = 0 , size = a.length() ;
	for( int i=0 ; i<size ; i++ ) {
		if( a[i]=='1' )		cnt_a++ ;
		if( b[i]=='1' )		cnt_b++ ;
	}
	return ( cnt_a < cnt_b ) ;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x30(%rbp)
movq %rsi, -0x28(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl $0x0, -0x14(%rbp)
movl $0x0, -0x18(%rbp)
callq 0x22f0
movl %eax, -0x1c(%rbp)
movl $0x0, -0x20(%rbp)
movl -0x20(%rbp), %eax
cmpl -0x1c(%rbp), %eax
jge 0x3226
movq -0x30(%rbp), %rdi
movslq -0x20(%rbp), %rsi
callq 0x2230
movsbl (%rax), %eax
cmpl $0x31, %eax
jne 0x31fb
movl -0x14(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x14(%rbp)
movq -0x28(%rbp), %rdi
movslq -0x20(%rbp), %rsi
callq 0x2230
movsbl (%rax), %eax
cmpl $0x31, %eax
jne 0x3219
movl -0x18(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x18(%rbp)
jmp 0x321b
movl -0x20(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x20(%rbp)
jmp 0x31d5
movl -0x14(%rbp), %eax
cmpl -0x18(%rbp), %eax
setl %al
andb $0x1, %al
addq $0x30, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: mirkat1206[P]Quine-McCluskey-Petrick-Method/Quine_McCluskey.cpp
// Function: sort_by_num_of_literal(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>)
bool sort_by_num_of_literal(const string a, const string b) {
	int cnt_a = 0 , cnt_b = 0 , size = a.length() ;
	for( int i=0 ; i<size ; i++ ) {
		if( a[i]!='-' )		cnt_a++ ;
		if( b[i]!='-' )		cnt_b++ ;
	}
	return ( cnt_a < cnt_b ) ;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x30(%rbp)
movq %rsi, -0x28(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl $0x0, -0x14(%rbp)
movl $0x0, -0x18(%rbp)
callq 0x22f0
movl %eax, -0x1c(%rbp)
movl $0x0, -0x20(%rbp)
movl -0x20(%rbp), %eax
cmpl -0x1c(%rbp), %eax
jge 0x32c6
movq -0x30(%rbp), %rdi
movslq -0x20(%rbp), %rsi
callq 0x2230
movsbl (%rax), %eax
cmpl $0x2d, %eax
je 0x329b
movl -0x14(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x14(%rbp)
movq -0x28(%rbp), %rdi
movslq -0x20(%rbp), %rsi
callq 0x2230
movsbl (%rax), %eax
cmpl $0x2d, %eax
je 0x32b9
movl -0x18(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x18(%rbp)
jmp 0x32bb
movl -0x20(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x20(%rbp)
jmp 0x3275
movl -0x14(%rbp), %eax
cmpl -0x18(%rbp), %eax
setl %al
andb $0x1, %al
addq $0x30, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: mirkat1206[P]Quine-McCluskey-Petrick-Method/Quine_McCluskey.cpp
// Function: Quine_McCluskey::Solve[abi:cxx11]()
vector<string> Quine_McCluskey::Solve() {
	Init_Impli();
	sort( Impli.begin() , Impli.end() );
	sort( Impli.begin() , Impli.end() , sort_by_num_of_1 );

	int round = 0 ;
	while( !Impli.empty() ) {
//		cout<<"round "<< round++ <<" : "<< endl;
//		Print_Impli();
		Generate_Prime_Impli();
	}
	return Prime_Impli ;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movq %rdi, -0x50(%rbp)
movq %rdi, %rax
movq %rax, -0x48(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x10(%rbp), %rdi
movq %rdi, -0x40(%rbp)
callq 0x34f0
movq -0x40(%rbp), %rdi
addq $0x50, %rdi
callq 0x4290
movq -0x40(%rbp), %rdi
movq %rax, -0x18(%rbp)
addq $0x50, %rdi
callq 0x42c0
movq %rax, -0x20(%rbp)
movq -0x18(%rbp), %rdi
movq -0x20(%rbp), %rsi
callq 0x4250
movq -0x40(%rbp), %rdi
addq $0x50, %rdi
callq 0x4290
movq -0x40(%rbp), %rdi
movq %rax, -0x28(%rbp)
addq $0x50, %rdi
callq 0x42c0
movq %rax, -0x30(%rbp)
movq -0x28(%rbp), %rdi
movq -0x30(%rbp), %rsi
leaq -0x308(%rip), %rdx      # 0x31a0
callq 0x42f0
movl $0x0, -0x34(%rbp)
movq -0x40(%rbp), %rdi
addq $0x50, %rdi
callq 0x4340
xorb $-0x1, %al
testb $0x1, %al
jne 0x34c9
jmp 0x34d4
movq -0x40(%rbp), %rdi
callq 0x3660
jmp 0x34b4
movq -0x50(%rbp), %rdi
movq -0x40(%rbp), %rsi
addq $0x68, %rsi
callq 0x4380
movq -0x48(%rbp), %rax
addq $0x50, %rsp
popq %rbp
retq
nop
// File: mirkat1206[P]Quine-McCluskey-Petrick-Method/Quine_McCluskey.cpp
// Function: Quine_McCluskey::Init_Impli()
void Quine_McCluskey::Init_Impli() {
	int size;	
	// on set
	size = On_Set.size() ;
	for( int i=0 ; i<size ; i++ ) {
		Impli.push_back( Dec2Bin(On_Set[i]) ) ;
		s_On_Set.push_back( Impli.back() );
	}
	// don't care set
	size = DC_Set.size() ;
	for( int i=0 ; i<size ; i++ )
		Impli.push_back( Dec2Bin(DC_Set[i]) ) ;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x90, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x68(%rbp)
addq $0x8, %rdi
callq 0x47c0
movl %eax, -0xc(%rbp)
movl $0x0, -0x10(%rbp)
movl -0x10(%rbp), %eax
cmpl -0xc(%rbp), %eax
jge 0x35b9
movq -0x68(%rbp), %rdi
movq %rdi, %rax
addq $0x50, %rax
movq %rax, -0x78(%rbp)
addq $0x8, %rdi
movslq -0x10(%rbp), %rsi
callq 0x4810
movq -0x68(%rbp), %rsi
movl (%rax), %edx
leaq -0x30(%rbp), %rdi
movq %rdi, -0x70(%rbp)
callq 0x3d30
movq -0x78(%rbp), %rdi
movq -0x70(%rbp), %rsi
callq 0x47e0
jmp 0x3564
leaq -0x30(%rbp), %rdi
callq 0x2120
movq -0x68(%rbp), %rdi
movq %rdi, %rax
addq $0x38, %rax
movq %rax, -0x80(%rbp)
addq $0x50, %rdi
callq 0x4830
movq -0x80(%rbp), %rdi
movq %rax, %rsi
callq 0x4630
movl -0x10(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x10(%rbp)
jmp 0x351a
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x38(%rbp)
movl %eax, -0x3c(%rbp)
leaq -0x30(%rbp), %rdi
callq 0x2120
jmp 0x3656
movq -0x68(%rbp), %rdi
addq $0x20, %rdi
callq 0x47c0
movl %eax, -0xc(%rbp)
movl $0x0, -0x40(%rbp)
movl -0x40(%rbp), %eax
cmpl -0xc(%rbp), %eax
jge 0x364d
movq -0x68(%rbp), %rdi
movq %rdi, %rax
addq $0x50, %rax
movq %rax, -0x90(%rbp)
addq $0x20, %rdi
movslq -0x40(%rbp), %rsi
callq 0x4810
movq -0x68(%rbp), %rsi
movl (%rax), %edx
leaq -0x60(%rbp), %rdi
movq %rdi, -0x88(%rbp)
callq 0x3d30
movq -0x90(%rbp), %rdi
movq -0x88(%rbp), %rsi
callq 0x47e0
jmp 0x3622
leaq -0x60(%rbp), %rdi
callq 0x2120
movl -0x40(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x40(%rbp)
jmp 0x35d0
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x38(%rbp)
movl %eax, -0x3c(%rbp)
leaq -0x60(%rbp), %rdi
callq 0x2120
jmp 0x3656
addq $0x90, %rsp
popq %rbp
retq
movq -0x38(%rbp), %rdi
callq 0x2340
nop
// File: mirkat1206[P]Quine-McCluskey-Petrick-Method/Quine_McCluskey.cpp
// Function: Quine_McCluskey::is_GrayCode(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>)
bool Quine_McCluskey::is_GrayCode(string a, string b) {
	int flag = 0 , size = a.length() ;
	for( int i=0 ; i<size ; i++ ) {
		if( a[i]!=b[i] )
			flag++ ;
	}
	return ( flag==1 );
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movq %rsi, -0x40(%rbp)
movq %rdi, %rax
movq -0x40(%rbp), %rdi
movq %rdi, -0x38(%rbp)
movq %rdx, -0x30(%rbp)
movq %rax, -0x8(%rbp)
movq %rdi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movl $0x0, -0x1c(%rbp)
callq 0x22f0
movl %eax, -0x20(%rbp)
movl $0x0, -0x24(%rbp)
movl -0x24(%rbp), %eax
cmpl -0x20(%rbp), %eax
jge 0x3c68
movq -0x38(%rbp), %rdi
movslq -0x24(%rbp), %rsi
callq 0x2360
movq -0x30(%rbp), %rdi
movsbl (%rax), %eax
movl %eax, -0x44(%rbp)
movslq -0x24(%rbp), %rsi
callq 0x2360
movq %rax, %rcx
movl -0x44(%rbp), %eax
movsbl (%rcx), %ecx
cmpl %ecx, %eax
je 0x3c5b
movl -0x1c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x1c(%rbp)
jmp 0x3c5d
movl -0x24(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x24(%rbp)
jmp 0x3c1d
cmpl $0x1, -0x1c(%rbp)
sete %al
andb $0x1, %al
addq $0x50, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: mirkat1206[P]Quine-McCluskey-Petrick-Method/Quine_McCluskey.cpp
// Function: Quine_McCluskey::Merge(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>)
string Quine_McCluskey::Merge(string a, string b) {
	int size = a.length() ;
	for( int i=0 ; i<size ; i++ ) {
		if( a[i]!=b[i] ) {
			a[i] = '-' ;
			return a ;
		}
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movq %rcx, -0x48(%rbp)
movq %rdx, -0x40(%rbp)
movq %rdi, %rax
movq -0x40(%rbp), %rdi
movq %rax, -0x38(%rbp)
movq %rax, %rdx
movq %rdx, -0x30(%rbp)
movq %rax, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdi, -0x18(%rbp)
movq %rcx, -0x20(%rbp)
callq 0x22f0
movl %eax, -0x24(%rbp)
movl $0x0, -0x28(%rbp)
movl -0x28(%rbp), %eax
cmpl -0x24(%rbp), %eax
jge 0x3d2a
movq -0x40(%rbp), %rdi
movslq -0x28(%rbp), %rsi
callq 0x2360
movq -0x48(%rbp), %rdi
movsbl (%rax), %eax
movl %eax, -0x4c(%rbp)
movslq -0x28(%rbp), %rsi
callq 0x2360
movq %rax, %rcx
movl -0x4c(%rbp), %eax
movsbl (%rcx), %ecx
cmpl %ecx, %eax
je 0x3d1d
movq -0x40(%rbp), %rdi
movslq -0x28(%rbp), %rsi
callq 0x2360
movq -0x38(%rbp), %rdi
movq -0x40(%rbp), %rsi
movb $0x2d, (%rax)
callq 0x20f0
movq -0x30(%rbp), %rax
addq $0x50, %rsp
popq %rbp
retq
jmp 0x3d1f
movl -0x28(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x28(%rbp)
jmp 0x3cc1
ud2
nopl (%rax)
// File: mirkat1206[P]Quine-McCluskey-Petrick-Method/Quine_McCluskey.cpp
// Function: Quine_McCluskey::Dec2Bin[abi:cxx11](int)
string Quine_McCluskey::Dec2Bin(int n) {
	string s;
	while( n!=0 ) {
		s += '0'+n%2 ;
		n /= 2 ;
	}
	int pad = Num_Var - s.length() ;
	while( pad-- ) {
		s += '0' ;
	}
	reverse( s.begin() , s.end() );
	return s ;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x60, %rsp
movq %rdi, -0x50(%rbp)
movq %rdi, %rax
movq %rax, -0x48(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl %edx, -0x14(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x40(%rbp)
movb $0x0, -0x15(%rbp)
callq 0x22b0
cmpl $0x0, -0x14(%rbp)
je 0x3db9
movq -0x50(%rbp), %rdi
movl -0x14(%rbp), %ecx
movl %ecx, %eax
shrl $0x1f, %eax
movl %ecx, %edx
addl %eax, %edx
andl $0xfe, %edx
movl %ecx, %eax
negl %edx
movl %edx, %ecx
leal 0x30(%rax,%rcx), %eax
movsbl %al, %esi
callq 0x2130
jmp 0x3d8f
movl -0x14(%rbp), %eax
movl $0x2, %ecx
cltd
idivl %ecx
movl %eax, -0x14(%rbp)
jmp 0x3d5f
movq -0x50(%rbp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x20(%rbp)
movl %eax, -0x24(%rbp)
callq 0x2120
jmp 0x3e42
movq -0x50(%rbp), %rdi
movq -0x40(%rbp), %rax
movslq (%rax), %rax
movq %rax, -0x58(%rbp)
callq 0x22f0
movq %rax, %rcx
movq -0x58(%rbp), %rax
subq %rcx, %rax
movl %eax, -0x28(%rbp)
movl -0x28(%rbp), %eax
movl %eax, %ecx
addl $-0x1, %ecx
movl %ecx, -0x28(%rbp)
cmpl $0x0, %eax
je 0x3dfc
movq -0x50(%rbp), %rdi
movl $0x30, %esi
callq 0x2130
jmp 0x3dfa
jmp 0x3dda
movq -0x50(%rbp), %rdi
callq 0x21a0
movq -0x50(%rbp), %rdi
movq %rax, -0x30(%rbp)
callq 0x20e0
movq %rax, -0x38(%rbp)
movq -0x30(%rbp), %rdi
movq -0x38(%rbp), %rsi
callq 0x4870
jmp 0x3e25
movb $0x1, -0x15(%rbp)
testb $0x1, -0x15(%rbp)
jne 0x3e38
movq -0x50(%rbp), %rdi
callq 0x2120
movq -0x48(%rbp), %rax
addq $0x60, %rsp
popq %rbp
retq
movq -0x20(%rbp), %rdi
callq 0x2340
nopl (%rax,%rax)
// File: mirkat1206[P]Quine-McCluskey-Petrick-Method/Quine_McCluskey.cpp
// Function: Quine_McCluskey::Print_Prime_Impli()
void Quine_McCluskey::Print_Prime_Impli() {
	int size = Prime_Impli.size() ;
	cout<<"Total number of Prime Implicant = "<< size << endl;
	for( int i=0 ; i<size ; i++ )
		cout<< Prime_Impli[i] << endl;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x18(%rbp)
addq $0x68, %rdi
callq 0x4490
movl %eax, -0xc(%rbp)
movq 0x150e9(%rip), %rdi     # 0x18fd0
leaq 0xd22e(%rip), %rsi      # 0x1111c
callq 0x21d0
movq %rax, %rdi
movl -0xc(%rbp), %esi
callq 0x2330
movq %rax, %rdi
movq 0x150b8(%rip), %rsi     # 0x18fc0
callq 0x2210
movl $0x0, -0x10(%rbp)
movl -0x10(%rbp), %eax
cmpl -0xc(%rbp), %eax
jge 0x3f56
movq -0x18(%rbp), %rdi
addq $0x68, %rdi
movslq -0x10(%rbp), %rsi
callq 0x4580
movq %rax, %rsi
movq 0x15099(%rip), %rdi     # 0x18fd0
callq 0x21c0
movq %rax, %rdi
movq 0x1507a(%rip), %rsi     # 0x18fc0
callq 0x2210
movl -0x10(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x10(%rbp)
jmp 0x3f14
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax)