LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_cpp_makefile_star2_O2/kiudee[P]VAHD-Projekt/./Subjects1-6.h
// Function: Subject::_halt(Subject*, Relay*)
int Subject::_halt(Subject *s, Relay *r)
{
    if (_activeSubject == NULL || (_parent == NULL && _debugID > 0)) {
        if (WARNING) {
            std::cout << "-- Warning! " << _debugID << "called 'freeze' outside of the subjects environment.\n";
        }
    } else {
        if (r == NULL) {
            if (WARNING) {
                std::cout << "-- Warning! " << _debugID << " cannot freeze NULL.\n";
            }
        } else {
            if (s != this) {
                if (WARNING) {
                    std::cout << "-- Warning! " << s->_debugID << " cannot call 'freeze' for subject " << _debugID << ".\n";
                }
            } else {
                if (s != r->_home) {
                    if (WARNING) {
                        std::cout << "-- Warning! " << _debugID << " cannot call 'freeze' for relay " << r->ID << ".\n";
                    }
                } else {
                    r->_awake = 0;
                    _activeRelays->remove(r);  // freeze relay point r
                    r->_iLinks->halt();        // freeze connections to r
                    if (DEBUG) {
                        std::cout << "-- Subject " << _debugID << " freezes relay " << r->ID << ".\n";
                    }
                    return 1;
                }
            }
        }
    }
    return 0;
}

// Assembly:
pushq %rbx
leaq 0xc31e(%rip), %rcx      # 0x101b0
xorl %eax, %eax
cmpq $0x0, (%rcx)
je 0x3ee9
movq %rdx, %rbx
cmpq $0x0, 0x10(%rdi)
je 0x3eb6
testq %rbx, %rbx
sete %cl
cmpq %rdi, %rsi
setne %dl
orb %cl, %dl
je 0x3ec7
jmp 0x3ee9
cmpq %rdi, %rsi
jne 0x3ee9
testq %rbx, %rbx
je 0x3ee9
cmpq $0x0, 0x8(%rdi)
jne 0x3ee9
cmpq %rsi, 0x18(%rbx)
jne 0x3ee9
andl $0x0, 0x10(%rbx)
movq 0x38(%rdi), %rdi
movq %rbx, %rsi
callq 0x4336
movq 0x20(%rbx), %rdi
callq 0x43e4
pushq $0x1
popq %rax
popq %rbx
retq
nop
// File: /workspace/github_cpp_makefile_star2_O2/kiudee[P]VAHD-Projekt/./Subjects1-6.h
// Function: Subject::idle(Relay*)
int Subject::idle(Relay *r)
{
    if (_activeSubject == NULL) {
        if (WARNING) {
            std::cout << "-- Warning! Method 'idle' called outside of the subjects environment.\n";
        }
    } else {
        if (r != NULL) {
            if (_activeSubject != r->_home) {
                if (WARNING) {
                    std::cout << "-- Warning! Subject " << _activeSubject->_debugID << " cannot call " << _debugID << "->idle().\n";
                }
            } else {
                return r->_oQueue->empty();
            }
        }
    }
    return 0;
}

// Assembly:
leaq 0xc25b(%rip), %rax      # 0x101b0
movq (%rax), %rcx
testq %rcx, %rcx
sete %dl
testq %rsi, %rsi
sete %dil
xorl %eax, %eax
orb %dl, %dil
jne 0x3f72
cmpq 0x18(%rsi), %rcx
je 0x3f73
retq
movq 0x38(%rsi), %rcx
xorl %eax, %eax
cmpq $0x0, (%rcx)
sete %al
retq
nop
// File: /workspace/github_cpp_makefile_star2_O2/kiudee[P]VAHD-Projekt/./Subjects1-6.h
// Function: Relay::Relay(int, Subject*)
Relay::Relay(int type, Subject *s)
{
    _home = s;
    _setup();
    if (_home != NULL) {
        if (type == ROOT) {
            if (_home->_parent != NULL && _home->_parent->_sink != NULL) {
                _oLink = _home->_parent->_sink;
                _oLink->_iLinks->add(this);
                if (DEBUG) {
                    std::cout << "-- Creating parent " << ID << " for subject " << _home->_debugID << ".\n";
                }
            }
        } else {
            if (DEBUG) {
                std::cout << "-- Creating sink " << ID << " for subject " << _home->_debugID << ".\n";
            }
        }
    }
}

// Assembly:
pushq %rbp
pushq %rbx
pushq %rax
movl %esi, %ebp
movq %rdi, %rbx
leaq 0xbc7b(%rip), %rax      # 0xfc68
movq %rax, (%rdi)
movq %rdx, 0x18(%rdi)
callq 0x409c
movq 0x18(%rbx), %rax
testq %rax, %rax
sete %cl
cmpl $0x1, %ebp
setne %dl
orb %cl, %dl
jne 0x4035
movq 0x10(%rax), %rax
testq %rax, %rax
je 0x4035
movq 0x20(%rax), %rax
testq %rax, %rax
je 0x4035
movq %rax, 0x28(%rbx)
movq 0x20(%rax), %rdi
movq %rbx, %rsi
addq $0x8, %rsp
popq %rbx
popq %rbp
jmp 0x403c
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/kiudee[P]VAHD-Projekt/./Subjects1-6.h
// Function: rLinks::add(Relay*)
inline void add(Relay *r) {
        _Link *l;
        int contained;

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

// Assembly:
testq %rsi, %rsi
je 0x409a
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %r14
movq %rdi, %rbx
xorl %eax, %eax
pushq $0x1
popq %rcx
movq %rdi, %rdx
movq (%rdx), %rdx
testq %rdx, %rdx
je 0x4067
cmpq %r14, (%rdx)
cmovel %ecx, %eax
addq $0x8, %rdx
jmp 0x4053
testl %eax, %eax
jne 0x4093
pushq $0x10
popq %rdi
callq 0x2170
movq %r14, (%rax)
andq $0x0, 0x8(%rax)
movq 0x8(%rbx), %rcx
xorl %edx, %edx
testq %rcx, %rcx
setne %dl
cmoveq %rbx, %rcx
movq %rax, 0x8(%rcx)
movq %rax, (%rbx,%rdx,8)
addq $0x8, %rsp
popq %rbx
popq %r14
retq
nop
// File: /workspace/github_cpp_makefile_star2_O2/kiudee[P]VAHD-Projekt/./Subjects1-6.h
// Function: Relay::_setup()
void Relay::_setup()
{
    ID = _numRelays;
    _numRelays++;
    if (_numRelays > MAXRELAYS && WARNING) {
        std::cout << "-- Warning! More than " << MAXRELAYS << " relay points.\n";
    }

    _awake = 1;
    _private = 1;
    _base = this;
    _oLink = NULL;
    _oQueue = new _Queue();
    _iLinks = new _rLinks();
    _identities = new _idLinks(NULL);  // dummy element for _identities

    if (_home == NULL) {
        if (WARNING && ID > 0) {
            std::cout << "-- Warning! Relay point not created within active subject.\n";
        }
    } else {
        if (_home->_Relays != NULL) {
            _home->_Relays->add(this);
            _home->_activeRelays->add(this);
        }
    }
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
leaq 0xc0f6(%rip), %rax      # 0x101a0
movq (%rax), %rcx
movq %rcx, 0x8(%rdi)
incq %rcx
movq %rcx, (%rax)
movabsq $0x100000001, %rax      # imm = 0x100000001
movq %rax, 0x10(%rdi)
movq %rdi, 0x30(%rdi)
andq $0x0, 0x28(%rdi)
pushq $0x10
popq %r14
movq %r14, %rdi
callq 0x2170
xorps %xmm0, %xmm0
movups %xmm0, (%rax)
movq %rax, 0x38(%rbx)
movq %r14, %rdi
callq 0x2170
xorps %xmm0, %xmm0
movups %xmm0, (%rax)
movq %rax, 0x20(%rbx)
pushq $0x18
popq %rdi
callq 0x2170
andq $0x0, 0x10(%rax)
xorps %xmm0, %xmm0
movups %xmm0, (%rax)
movq %rax, 0x40(%rbx)
movq 0x18(%rbx), %rax
testq %rax, %rax
je 0x413e
movq 0x30(%rax), %rdi
testq %rdi, %rdi
je 0x413e
movq %rbx, %rsi
callq 0x403c
movq 0x18(%rbx), %rax
movq 0x38(%rax), %rdi
movq %rbx, %rsi
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x403c
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_cpp_makefile_star2_O2/kiudee[P]VAHD-Projekt/./Subjects1-6.h
// Function: Relay::_handle(Subject*, _Message*)
int Relay::_handle(Subject *s, _Message *m)
{
    if (s != _home) {
        if (WARNING) {
            std::cout << "-- Warning! Subject " << s->_debugID << " cannot call " << ID << "->call().\n";
        }
        delete m;
    } else {
        if (m != NULL) {  // message well-defined?
            if (DEBUG) {
                std::cout << "-- Message " << m->debugID << " stored in relay " << ID << ".\n";
            }
            m->source = ID;
            if (m->ObjPtr != NULL) {
                m->ObjPtr->_owner = NULL;    // object in transit
            }
            _oQueue->enqueue(m);
        }
        return 1;
    }
    return 0;
}

// Assembly:
cmpq %rsi, 0x18(%rdi)
je 0x415f
pushq %rax
pushq $0x38
popq %rsi
movq %rdx, %rdi
callq 0x2180
xorl %eax, %eax
addq $0x8, %rsp
retq
pushq $0x1
popq %rax
testq %rdx, %rdx
je 0x419c
movq 0x8(%rdi), %rcx
movq %rcx, 0x8(%rdx)
movq 0x28(%rdx), %rcx
testq %rcx, %rcx
je 0x417d
andq $0x0, 0x8(%rcx)
movq 0x38(%rdi), %rcx
movq 0x8(%rcx), %rsi
leaq 0x30(%rsi), %rdi
testq %rsi, %rsi
cmoveq %rcx, %rdi
movq %rdx, (%rdi)
movq %rdx, 0x8(%rcx)
andq $0x0, 0x30(%rdx)
retq
nop
// File: /workspace/github_cpp_makefile_star2_O2/kiudee[P]VAHD-Projekt/./Subjects1-6.h
// Function: Relay::_process()
int Relay::_process()
{
    _Message *m;

    if (_oLink != NULL) { // relay has outgoing link?
        if (_oLink == _home->_sink) {  // outgoing link to home?
            while (!_oQueue->empty()) {  // queue has messages?
                m = _oQueue->dequeue();
                m->sink = ID;      // set sink of message to current relay
                _oLink->_oQueue->enqueue(m);
            }
            if (DEBUG) {
                std::cout << "-- All messages in " << ID << " to " << _home->_sink->ID << ".\n";
            }
        } else {
            m = _oQueue->dequeue();
            if (m != NULL) {   // queue has message?
                _oLink->_oQueue->enqueue(m); // forward message along outgoing link
                if (DEBUG) {
                    std::cout << "-- Message " << m->debugID << "  => " << _oLink->ID << ".\n";
                }
                return 1;        // relay busy
            }
        }
    }
    return 0;
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq 0x28(%rdi), %rax
xorl %ebx, %ebx
testq %rax, %rax
je 0x422a
movq %rdi, %r14
movq 0x18(%rdi), %rcx
cmpq 0x20(%rcx), %rax
je 0x4220
movq 0x38(%r14), %rdi
callq 0x424a
testq %rax, %rax
je 0x422a
movq 0x28(%r14), %rcx
movq 0x38(%rcx), %rcx
movq 0x8(%rcx), %rdx
leaq 0x30(%rdx), %rsi
testq %rdx, %rdx
cmoveq %rcx, %rsi
movq %rax, (%rsi)
movq %rax, 0x8(%rcx)
andq $0x0, 0x30(%rax)
pushq $0x1
popq %rbx
jmp 0x422a
callq 0x424a
movq 0x8(%r14), %rcx
movq %rcx, 0x10(%rax)
movq 0x28(%r14), %rcx
movq 0x38(%rcx), %rcx
movq 0x8(%rcx), %rdx
leaq 0x30(%rdx), %rsi
testq %rdx, %rdx
cmoveq %rcx, %rsi
movq %rax, (%rsi)
movq %rax, 0x8(%rcx)
andq $0x0, 0x30(%rax)
movq 0x38(%r14), %rdi
cmpq $0x0, (%rdi)
jne 0x41f0
movl %ebx, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_cpp_makefile_star2_O2/kiudee[P]VAHD-Projekt/./Subjects1-6.h
// Function: Relay::~Relay()
Relay::~Relay()
{
    _idLinks *idl;

    if (DEBUG) {
        std::cout << "-- Relay " << ID << " deleted.\n";
    }
    if (_oLink != NULL) {
        _oLink->_iLinks->remove(this);    // cut outgoing link
    }
    delete _oQueue;                  // delete remaining messages
    if (_iLinks != NULL) {
        _iLinks->halt();               // cut all incoming links
        delete _iLinks;
    }
    if (_home != NULL && _home->_Relays != NULL) {
        _home->_Relays->remove(this);
        _home->_activeRelays->remove(this);
    }
    while (_identities != NULL) {
        idl = _identities;
        if (_identities->id != NULL) {
            _identities->id->_source = NULL;
        }
        _identities = _identities->next;
        delete idl;
    }
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
leaq 0xb9f0(%rip), %rax      # 0xfc68
movq %rax, (%rdi)
movq 0x28(%rdi), %rax
testq %rax, %rax
je 0x4290
movq 0x20(%rax), %rdi
movq %rbx, %rsi
callq 0x4336
movq 0x38(%rbx), %r14
testq %r14, %r14
je 0x42a1
movq %r14, %rdi
callq 0x43b2
pushq $0x10
popq %rsi
movq %r14, %rdi
callq 0x2180
movq 0x20(%rbx), %rdi
testq %rdi, %rdi
je 0x42d6
callq 0x43e4
movq 0x20(%rbx), %r14
testq %r14, %r14
je 0x42cb
movq %r14, %rdi
callq 0x43fc
pushq $0x10
popq %rsi
movq %r14, %rdi
callq 0x2180
movq 0x18(%rbx), %rax
testq %rax, %rax
je 0x4300
movq 0x30(%rax), %rdi
testq %rdi, %rdi
je 0x4300
movq %rbx, %rsi
callq 0x4336
movq 0x18(%rbx), %rax
movq 0x38(%rax), %rdi
movq %rbx, %rsi
callq 0x4336
pushq $0x18
popq %r14
movq 0x40(%rbx), %rdi
testq %rdi, %rdi
je 0x432d
movq 0x10(%rdi), %rax
testq %rax, %rax
je 0x431b
andq $0x0, 0x10(%rax)
movq 0x8(%rdi), %rax
movq %rax, 0x40(%rbx)
movq %r14, %rsi
callq 0x2180
jmp 0x4304
addq $0x8, %rsp
popq %rbx
popq %r14
retq
nop
// File: /workspace/github_cpp_makefile_star2_O2/kiudee[P]VAHD-Projekt/./Subjects1-6.h
// Function: rLinks::remove(Relay*)
inline void remove(Relay *r) {
        _Link *l, *tl;

        if (first != NULL) { // list non-empty
            l = first;
            while (l != NULL && l->relay == r) {
                tl = l;
                l = l->next;
                delete tl;                 // remove all r's in front of list
            }
            first = l;                   // l==NULL or l->relay!=r
            if (l == NULL) {
                last = l;    // l==NULL: done
            } else {                     // l->relay!=r: continue with l->next
                while (l->next != NULL) {
                    if (l->next->relay == r) {
                        tl = l->next;
                        l->next = l->next->next;
                        delete tl;
                    } else {
                        l = l->next;
                    }
                }
                last = l;                  // l points to (new) last element
            }
        }
    }

// Assembly:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
movq (%rdi), %r15
testq %r15, %r15
je 0x43a7
movq %rsi, %r14
movq %rdi, %rbx
pushq $0x10
popq %r12
testq %r15, %r15
je 0x436f
cmpq %r14, (%r15)
jne 0x4377
movq 0x8(%r15), %r13
movq %r15, %rdi
movq %r12, %rsi
callq 0x2180
movq %r13, %r15
jmp 0x4351
xorps %xmm0, %xmm0
movups %xmm0, (%rbx)
jmp 0x43a7
movq %r15, (%rbx)
pushq $0x10
popq %r12
movq 0x8(%r15), %rdi
testq %rdi, %rdi
je 0x43a3
cmpq %r14, (%rdi)
jne 0x439e
movq 0x8(%rdi), %rax
movq %rax, 0x8(%r15)
movq %r12, %rsi
callq 0x2180
jmp 0x437e
movq %rdi, %r15
jmp 0x437e
movq %r15, 0x8(%rbx)
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
nop
// File: /workspace/github_cpp_makefile_star2_O2/kiudee[P]VAHD-Projekt/./Subjects1-6.h
// Function: Queue::~_Queue()
inline ~_Queue() {
        _Message *m;

        while (first != NULL) {
            m = first;
            first = first->next;
            delete m;
        }
        last = NULL;
    }

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
pushq $0x38
popq %r14
movq (%rbx), %rdi
testq %rdi, %rdi
je 0x43d6
movq 0x30(%rdi), %rax
movq %rax, (%rbx)
movq %r14, %rsi
callq 0x2180
jmp 0x43bd
andq $0x0, 0x8(%rbx)
addq $0x8, %rsp
popq %rbx
popq %r14
retq
nop
// File: /workspace/github_cpp_makefile_star2_O2/kiudee[P]VAHD-Projekt/./Subjects1-6.h
// Function: rLinks::halt()
inline void halt() {
        _Link *l;

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

// Assembly:
movq (%rdi), %rdi
testq %rdi, %rdi
je 0x43fa
movq (%rdi), %rax
andq $0x0, 0x28(%rax)
addq $0x8, %rdi
jmp 0x43e4
retq
nop
// File: /workspace/github_cpp_makefile_star2_O2/kiudee[P]VAHD-Projekt/./Subjects1-6.h
// Function: rLinks::~_rLinks()
inline ~_rLinks() {
        _Link *l;

        l = first;
        while (first != NULL) {
            first = first->next;
            delete l;
            l = first;
        }
    }

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
pushq $0x10
popq %r14
movq (%rbx), %rdi
testq %rdi, %rdi
je 0x4420
movq 0x8(%rdi), %rax
movq %rax, (%rbx)
movq %r14, %rsi
callq 0x2180
jmp 0x4407
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_cpp_makefile_star2_O2/kiudee[P]VAHD-Projekt/./Subjects1-6.h
// Function: Subject::~Subject()
Subject::~Subject()
{
    _rLinks *rl;
    _sLinks *sl;

    if (DEBUG) {
        std::cout << "-- Subject " << _debugID << " deleted.\n";
    }
    if (_child != NULL) { // relay subject?
        delete _child;
        if (_parent != NULL && _parent->_Subjects != NULL) {
            _parent->_Subjects->remove(this);
            _parent->_activeSubjects->remove(this);
        }
    } else { // bad relay subject or standard subject
        if (_Relays != NULL) {        // standard subject
            rl = _Relays;               // necessary to avoid self-removal of
            _Relays = NULL;             // relay points from _Relays
            rl->deleteRelays();         // delete relays (including _sink and parent)
            delete rl;                  // delete list of relays
            delete _activeRelays;
            sl = _Subjects;             // dito
            _Subjects = NULL;
            sl->deleteSubjects();       // delete subjects
            delete sl;                  // delete list of subjects
            delete _activeSubjects;
        }
    }
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
leaq 0xb6f4(%rip), %rax      # 0xfbe8
movq %rax, (%rdi)
movq 0x18(%rdi), %r14
testq %r14, %r14
je 0x454c
movq %r14, %rdi
callq 0x44e6
pushq $0x60
popq %rsi
movq %r14, %rdi
callq 0x2180
movq 0x10(%rbx), %rax
testq %rax, %rax
je 0x45dc
movq 0x40(%rax), %rdi
testq %rdi, %rdi
je 0x45dc
movq %rbx, %rsi
callq 0x45ec
movq 0x10(%rbx), %rax
movq 0x48(%rax), %rdi
movq %rbx, %rsi
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x45ec
movq 0x30(%rbx), %r14
testq %r14, %r14
je 0x45dc
andq $0x0, 0x30(%rbx)
movq %r14, %rdi
callq 0x4668
movq %r14, %rdi
callq 0x43fc
pushq $0x10
popq %rsi
movq %r14, %rdi
callq 0x2180
movq 0x38(%rbx), %r14
testq %r14, %r14
je 0x458a
movq %r14, %rdi
callq 0x43fc
pushq $0x10
popq %rsi
movq %r14, %rdi
callq 0x2180
movq 0x40(%rbx), %r14
andq $0x0, 0x40(%rbx)
movq %r14, %rdi
callq 0x4686
movq %r14, %rdi
callq 0x46a4
pushq $0x10
popq %rsi
movq %r14, %rdi
callq 0x2180
movq 0x48(%rbx), %rbx
testq %rbx, %rbx
je 0x45ca
movq %rbx, %rdi
callq 0x46a4
pushq $0x10
popq %rsi
movq %rbx, %rdi
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x2180
addq $0x8, %rsp
popq %rbx
popq %r14
retq
movq %rax, %rdi
callq 0x39f3
// File: /workspace/github_cpp_makefile_star2_O2/kiudee[P]VAHD-Projekt/./Subjects1-6.h
// Function: sLinks::remove(Subject*)
inline void remove(Subject *s) {
        _sLink *l, *tl;

        if (first != NULL) { // list non-empty
            l = first;
            while (l != NULL && l->subject == s) {
                tl = l;
                l = l->next;
                delete tl;                 // remove all s's in front of list
            }
            first = l;                   // l==NULL or l->subject!=s
            if (l == NULL) {
                last = l;    // l==NULL: done
            } else {                     // l->subject!=s: continue with l->next
                while (l->next != NULL) {
                    if (l->next->subject == s) {
                        tl = l->next;
                        l->next = l->next->next;
                        delete tl;
                    } else {
                        l = l->next;
                    }
                }
                last = l;                  // l points to (new) last element
            }
        }
    }

// Assembly:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
movq (%rdi), %r15
testq %r15, %r15
je 0x465d
movq %rsi, %r14
movq %rdi, %rbx
pushq $0x10
popq %r12
testq %r15, %r15
je 0x4625
cmpq %r14, (%r15)
jne 0x462d
movq 0x8(%r15), %r13
movq %r15, %rdi
movq %r12, %rsi
callq 0x2180
movq %r13, %r15
jmp 0x4607
xorps %xmm0, %xmm0
movups %xmm0, (%rbx)
jmp 0x465d
movq %r15, (%rbx)
pushq $0x10
popq %r12
movq 0x8(%r15), %rdi
testq %rdi, %rdi
je 0x4659
cmpq %r14, (%rdi)
jne 0x4654
movq 0x8(%rdi), %rax
movq %rax, 0x8(%r15)
movq %r12, %rsi
callq 0x2180
jmp 0x4634
movq %rdi, %r15
jmp 0x4634
movq %r15, 0x8(%rbx)
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
nop
// File: /workspace/github_cpp_makefile_star2_O2/kiudee[P]VAHD-Projekt/./Subjects1-6.h
// Function: rLinks::deleteRelays()
inline void deleteRelays() {
        _Link *l;

        l = first;
        while (l != NULL) {
            l->relay->_destruct();      // remove all relay points
            l = l->next;
        }
    }

// Assembly:
pushq %rbx
movq %rdi, %rbx
movq (%rbx), %rbx
testq %rbx, %rbx
je 0x4683
movq (%rbx), %rdi
movq (%rdi), %rax
callq *0x18(%rax)
addq $0x8, %rbx
jmp 0x466c
popq %rbx
retq
nop
// File: /workspace/github_cpp_makefile_star2_O2/kiudee[P]VAHD-Projekt/./Subjects1-6.h
// Function: sLinks::deleteSubjects()
inline void deleteSubjects() {
        _sLink *l;

        l = first;
        while (l != NULL) {
            l->subject->_destruct();      // remove all subjects
            l = l->next;
        }
    }

// Assembly:
pushq %rbx
movq %rdi, %rbx
movq (%rbx), %rbx
testq %rbx, %rbx
je 0x46a1
movq (%rbx), %rdi
movq (%rdi), %rax
callq *0x10(%rax)
addq $0x8, %rbx
jmp 0x468a
popq %rbx
retq
nop
// File: /workspace/github_cpp_makefile_star2_O2/kiudee[P]VAHD-Projekt/./Subjects1-6.h
// Function: sLinks::~_sLinks()
inline ~_sLinks() {
        _sLink *l;

        l = first;
        while (first != NULL) {
            first = first->next;
            delete l;
            l = first;
        }
    }

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
pushq $0x10
popq %r14
movq (%rbx), %rdi
testq %rdi, %rdi
je 0x46c8
movq 0x8(%rdi), %rax
movq %rax, (%rbx)
movq %r14, %rsi
callq 0x2180
jmp 0x46af
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_cpp_makefile_star2_O2/kiudee[P]VAHD-Projekt/./Subjects1-6.h
// Function: sLinks::process()
inline int process() {
        _sLink *l;
        int busy;

        l = first;
        busy = 0;
        while (l != NULL) {
            busy = busy | l->subject->_process();
            l = l->next;
        }
        return busy;
    }

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %r14
xorl %ebx, %ebx
movq (%r14), %r14
testq %r14, %r14
je 0x46f2
movq (%r14), %rdi
movq (%rdi), %rax
callq *0x8(%rax)
orl %eax, %ebx
addq $0x8, %r14
jmp 0x46d9
movl %ebx, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_cpp_makefile_star2_O2/kiudee[P]VAHD-Projekt/./Subjects1-6.h
// Function: rLinks::process()
inline int process() {
        _Link *l;
        int busy;

        l = first;
        busy = 0;
        while (l != NULL) {
            busy = busy | l->relay->_process();
            l = l->next;
        }
        return busy;
    }

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %r14
xorl %ebx, %ebx
movq (%r14), %r14
testq %r14, %r14
je 0x471e
movq (%r14), %rdi
movq (%rdi), %rax
callq *0x10(%rax)
orl %eax, %ebx
addq $0x8, %r14
jmp 0x4705
movl %ebx, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_cpp_makefile_star2_O2/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:
testq %rsi, %rsi
je 0x4786
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %r14
movq %rdi, %rbx
xorl %eax, %eax
pushq $0x1
popq %rcx
movq %rdi, %rdx
movq (%rdx), %rdx
testq %rdx, %rdx
je 0x4753
cmpq %r14, (%rdx)
cmovel %ecx, %eax
addq $0x8, %rdx
jmp 0x473f
testl %eax, %eax
jne 0x477f
pushq $0x10
popq %rdi
callq 0x2170
movq %r14, (%rax)
andq $0x0, 0x8(%rax)
movq 0x8(%rbx), %rcx
xorl %edx, %edx
testq %rcx, %rcx
setne %dl
cmoveq %rbx, %rcx
movq %rax, 0x8(%rcx)
movq %rax, (%rbx,%rdx,8)
addq $0x8, %rsp
popq %rbx
popq %r14
retq
nop
// File: /workspace/github_cpp_makefile_star2_O2/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:
movq (%rdi), %rdi
testq %rdi, %rdi
je 0x479d
movq (%rdi), %rax
movq %rsi, 0x28(%rax)
addq $0x8, %rdi
jmp 0x4788
retq
// File: /workspace/github_cpp_makefile_star2_O2/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 $0x1
popq %rax
movq (%rdi), %rdi
testq %rdi, %rdi
je 0x47c8
testl %eax, %eax
je 0x47c8
movq (%rdi), %rcx
testq %rcx, %rcx
je 0x47c2
movq 0x38(%rcx), %rcx
xorl %eax, %eax
cmpq $0x0, (%rcx)
sete %al
addq $0x8, %rdi
jmp 0x47a1
retq
nop
// File: /workspace/github_cpp_makefile_star2_O2/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 %r15
pushq %r14
pushq %rbx
leaq 0xb3fe(%rip), %rax      # 0xfbe8
movq %rax, (%rdi)
leaq 0xb9b4(%rip), %rax      # 0x101a8
movq (%rax), %rcx
movq %rcx, 0x8(%rdi)
incq %rcx
movq %rcx, (%rax)
leaq 0xb9a8(%rip), %rax      # 0x101b0
movq (%rax), %rax
movq %rax, 0x10(%rdi)
xorps %xmm0, %xmm0
movups %xmm0, 0x18(%rdi)
movups %xmm0, 0x28(%rdi)
movups %xmm0, 0x38(%rdi)
movups %xmm0, 0x48(%rdi)
andq $0x0, 0x58(%rdi)
testq %rax, %rax
sete %cl
testq %rsi, %rsi
sete %dl
orb %cl, %dl
jne 0x4889
movq %rsi, %r14
movq %rdi, %rbx
movq 0x40(%rax), %rdi
movq %rbx, %rsi
callq 0x4728
movq 0x10(%rbx), %rax
movq 0x48(%rax), %rdi
movq %rbx, %rsi
callq 0x4728
movq %r14, 0x18(%rbx)
movq 0x10(%rbx), %rax
movq %rax, 0x10(%r14)
pushq $0x48
popq %rdi
callq 0x2170
movq %rax, %r15
pushq $0x1
popq %rsi
movq %rax, %rdi
movq %r14, %rdx
callq 0x3fde
addq $0x18, %rbx
movq (%rbx), %rax
movq %r15, 0x28(%rax)
popq %rbx
popq %r14
popq %r15
retq
movq %rax, %rbx
pushq $0x48
popq %rsi
movq %r15, %rdi
callq 0x2180
movq %rbx, %rdi
callq 0x2290
nop
// File: /workspace/github_cpp_makefile_star2_O2/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 %rax
movq 0x10(%rdi), %rcx
testq %rcx, %rcx
je 0x48f5
movq %rdi, %rax
movq 0x40(%rcx), %rdi
movq %rdi, %rcx
movq 0x8(%rdi), %rdi
testq %rdi, %rdi
je 0x48e2
cmpq %rax, 0x10(%rdi)
jne 0x48b7
movq 0x8(%rdi), %rax
testq %rax, %rax
je 0x48d5
movq %rcx, (%rax)
movq %rax, 0x8(%rcx)
pushq $0x18
popq %rsi
popq %rax
jmp 0x2180
movq 0xb6e7(%rip), %rdi      # 0xffd0
leaq 0x5948(%rip), %rsi      # 0xa238
callq 0x2160
popq %rax
retq
movq %rax, %rdi
callq 0x39f3
nop
// File: /workspace/github_cpp_makefile_star2_O2/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 %r15
pushq %r14
pushq %rbx
movq %rdi, %rbx
testq %rsi, %rsi
movl $0xffffffff, %r14d      # imm = 0xFFFFFFFF
cmovneq %rsi, %r14
pushq $0x1
popq %rax
pushq $0x1
popq %r15
cmpq %r14, %r15
ja 0x5aeb
testl %eax, %eax
je 0x5aeb
movq (%rbx), %rax
movq %rbx, %rdi
callq *0x8(%rax)
incq %r15
jmp 0x5ad4
popq %rbx
popq %r14
popq %r15
retq
nop
// File: /workspace/github_cpp_makefile_star2_O2/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 %r14
pushq %rbx
pushq %rax
movq 0xa3bf(%rip), %rdi      # 0xffd0
leaq 0x4785(%rip), %rsi      # 0xa39d
callq 0x2160
movq 0xa3bc(%rip), %rbx      # 0xffe0
leaq 0x7(%rsp), %r14
movq %rbx, %rdi
movq %r14, %rsi
callq 0x21e0
movq (%rbx), %rax
movq -0x18(%rax), %rax
cmpl $0x0, 0x20(%rbx,%rax)
jne 0x5c49
cmpb $0xa, 0x7(%rsp)
jne 0x5c29
addq $0x8, %rsp
popq %rbx
popq %r14
retq
nop
// File: /workspace/github_cpp_makefile_star2_O2/kiudee[P]VAHD-Projekt/Node.cpp
// Function: Node::ConnectChild(IdObj*)
Action Node::ConnectChild(IdObj *ido)
{
    if (ido->num == num / 2) {
        node0 = new NodeRelay(ido);
        NumObj *numo0 = new NumObj(5);
        node0->out->call(Node::Wakeup, numo0); //WAAAAAAAAAAAAAAAAAH!!!!!!!!!!!!
    } else {
        node1 = new NodeRelay(ido);
        NumObj *numo1 = new NumObj(5);
        node1->out->call(Node::Wakeup, numo1); //HOW WE COULD FORGET THAT???
    }
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %rsi, %r15
movq %rdi, %rbx
movsd 0x20(%rsi), %xmm0
movsd %xmm0, 0x10(%rsp)
movsd 0xb0(%rdi), %xmm0
mulsd 0x4198(%rip), %xmm0     # 0xa3c0
movsd %xmm0, 0x8(%rsp)
pushq $0x38
popq %rdi
callq 0x2170
movq %rax, %r14
movsd 0x10(%rsp), %xmm0
ucomisd 0x8(%rsp), %xmm0
jne 0x625c
jp 0x625c
movl $0xd8, %r12d
movq %r14, %rdi
movq %r15, %rsi
callq 0x3766
jmp 0x626d
movl $0xe0, %r12d
movq %r14, %rdi
movq %r15, %rsi
callq 0x3766
movq %r14, (%rbx,%r12)
pushq $0x28
popq %rdi
callq 0x2170
movq %rax, %r14
movq %rax, %rdi
callq 0x3a32
movl $0x5, 0x20(%r14)
movq (%rbx,%r12), %rax
movq 0x28(%rax), %r15
pushq $0x38
popq %rdi
callq 0x2170
leaq 0x9f15(%rip), %rcx      # 0x101b8
movq (%rcx), %rdx
movq %rdx, (%rax)
incq %rdx
movq %rdx, (%rcx)
xorpd %xmm0, %xmm0
movupd %xmm0, 0x8(%rax)
leaq 0x47(%rip), %rcx        # 0x6306
movq %rcx, 0x18(%rax)
andq $0x0, 0x20(%rax)
movq %r14, 0x28(%rax)
andq $0x0, 0x30(%rax)
movq (%r15), %rcx
movq 0x8(%rcx), %rcx
movq %r15, %rdi
movq %rbx, %rsi
movq %rax, %rdx
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
jmpq *%rcx
jmp 0x62f0
movq %rax, %rbx
pushq $0x38
popq %rsi
movq %r14, %rdi
callq 0x2180
movq %rbx, %rdi
callq 0x2290
// File: /workspace/github_cpp_makefile_star2_O2/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 %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
movl 0x20(%rsi), %eax
testl %eax, %eax
je 0x6370
movq %rsi, %r14
decl %eax
movl %eax, 0x20(%rsi)
pushq $0x38
popq %rdi
callq 0x2170
leaq 0x9e8d(%rip), %rcx      # 0x101b8
movq (%rcx), %rdx
movq %rdx, (%rax)
incq %rdx
movq %rdx, (%rcx)
xorps %xmm0, %xmm0
movups %xmm0, 0x8(%rax)
leaq -0x3f(%rip), %rcx       # 0x6306
movq %rcx, 0x18(%rax)
andq $0x0, 0x20(%rax)
movq %r14, 0x28(%rax)
andq $0x0, 0x30(%rax)
movq (%rbx), %rcx
movq 0x48(%rcx), %rcx
movq %rbx, %rdi
movq %rbx, %rsi
movq %rax, %rdx
addq $0x8, %rsp
popq %rbx
popq %r14
jmpq *%rcx
movq %rbx, %rdi
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x6380
nop
// File: /workspace/github_cpp_makefile_star2_O2/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:
movq (%rsi), %rax
testq %rax, %rax
je 0x6402
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movl %edx, %ebp
movq %rsi, %r14
movq %rdi, %rbx
movq 0x28(%rax), %rsi
movq (%rdi), %rax
callq *0x68(%rax)
testl %eax, %eax
jne 0x63f8
movq (%r14), %rax
movq 0x28(%rax), %r15
testq %r15, %r15
je 0x63cf
movq %r15, %rdi
callq 0x426a
pushq $0x48
popq %rsi
movq %r15, %rdi
callq 0x2180
movq (%r14), %rdi
pushq $0x38
popq %rsi
callq 0x2180
andq $0x0, (%r14)
testb %bpl, %bpl
je 0x63f4
movb $0x0, 0x61(%rbx)
jmp 0x63f8
movb $0x0, 0x60(%rbx)
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O2/kiudee[P]VAHD-Projekt/Node.cpp
// Function: Node::checkValid()
void Node::checkValid()
{
    IdObj *tempido;
    if (left != NULL && left->num > num) {
        tempido = new IdObj(left->num, extractIdentity(left->out), left->debugID);
        delete left;
        left = NULL;
        leftstable = false;

        call(Node::BuildList, tempido);
    }
    if (right != NULL && right->num < num) {
        tempido = new IdObj(right->num, extractIdentity(right->out), right->debugID);
        delete right;
        right = NULL;
        rightstable = false;

        call(Node::BuildList, tempido);
    }
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
movq 0xc8(%rdi), %r15
testq %r15, %r15
je 0x64e7
movsd 0x20(%r15), %xmm0
ucomisd 0xb0(%rbx), %xmm0
jbe 0x64e7
movsd %xmm0, (%rsp)
pushq $0x38
popq %rdi
callq 0x2170
movq %rax, %r14
addq $0x28, %r15
movq %rbx, %rdi
movq %rbx, %rsi
movq %r15, %rdx
callq 0x933a
movq %rax, %r15
movq 0xc8(%rbx), %rax
movl 0x30(%rax), %ebp
movq %r14, %rdi
callq 0x3a32
movsd (%rsp), %xmm0
movsd %xmm0, 0x20(%r14)
movq %r15, 0x28(%r14)
movl %ebp, 0x30(%r14)
movq 0xc8(%rbx), %rdi
pushq $0x38
popq %r15
movq %r15, %rsi
callq 0x2180
andq $0x0, 0xc8(%rbx)
movb $0x0, 0x60(%rbx)
movq %r15, %rdi
callq 0x2170
leaq 0x9d0e(%rip), %rcx      # 0x101b8
movq (%rcx), %rdx
movq %rdx, (%rax)
incq %rdx
movq %rdx, (%rcx)
xorpd %xmm0, %xmm0
movupd %xmm0, 0x8(%rax)
leaq 0x12c(%rip), %rcx       # 0x65f2
movq %rcx, 0x18(%rax)
andq $0x0, 0x20(%rax)
movq %r14, 0x28(%rax)
andq $0x0, 0x30(%rax)
movq (%rbx), %rcx
movq %rbx, %rdi
movq %rbx, %rsi
movq %rax, %rdx
callq *0x48(%rcx)
movq 0xd0(%rbx), %r15
testq %r15, %r15
je 0x65cf
movsd 0x20(%r15), %xmm1
movsd 0xb0(%rbx), %xmm0
ucomisd %xmm1, %xmm0
jbe 0x65cf
movsd %xmm1, (%rsp)
pushq $0x38
popq %rdi
callq 0x2170
movq %rax, %r14
addq $0x28, %r15
movq %rbx, %rdi
movq %rbx, %rsi
movq %r15, %rdx
callq 0x933a
movq %rax, %r15
movq 0xd0(%rbx), %rax
movl 0x30(%rax), %ebp
movq %r14, %rdi
callq 0x3a32
movsd (%rsp), %xmm0
movsd %xmm0, 0x20(%r14)
movq %r15, 0x28(%r14)
movl %ebp, 0x30(%r14)
movq 0xd0(%rbx), %rdi
pushq $0x38
popq %r15
movq %r15, %rsi
callq 0x2180
andq $0x0, 0xd0(%rbx)
movb $0x0, 0x61(%rbx)
movq %r15, %rdi
callq 0x2170
leaq 0x9c31(%rip), %rcx      # 0x101b8
movq (%rcx), %rdx
movq %rdx, (%rax)
incq %rdx
movq %rdx, (%rcx)
xorps %xmm0, %xmm0
movups %xmm0, 0x8(%rax)
leaq 0x51(%rip), %rcx        # 0x65f2
movq %rcx, 0x18(%rax)
andq $0x0, 0x20(%rax)
movq %r14, 0x28(%rax)
andq $0x0, 0x30(%rax)
movq (%rbx), %rcx
movq 0x48(%rcx), %rcx
movq %rbx, %rdi
movq %rbx, %rsi
movq %rax, %rdx
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
jmpq *%rcx
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
jmp 0x65dc
movq %rax, %rbx
pushq $0x38
popq %rsi
movq %r14, %rdi
callq 0x2180
movq %rbx, %rdi
callq 0x2290
// File: /workspace/github_cpp_makefile_star2_O2/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:
cmpb $0x1, 0x61(%rdi)
jne 0x6abd
movq 0xd0(%rdi), %rax
testq %rax, %rax
je 0x6abd
movsd 0x20(%rax), %xmm1
movsd 0xb0(%rdi), %xmm0
ucomisd %xmm0, %xmm1
jne 0x6b05
jp 0x6b05
cmpb $0x1, 0x60(%rdi)
jne 0x6ae4
movq 0xc8(%rdi), %rax
testq %rax, %rax
je 0x6ae4
movsd 0x20(%rax), %xmm1
movsd 0xb0(%rdi), %xmm0
ucomisd %xmm0, %xmm1
jne 0x6b05
jp 0x6b05
movq 0xd0(%rdi), %rax
testq %rax, %rax
je 0x6b0b
movsd 0x20(%rax), %xmm1
movsd 0xb0(%rdi), %xmm0
ucomisd %xmm0, %xmm1
jne 0x6b05
jnp 0x6b0b
subsd %xmm1, %xmm0
jmp 0x6b34
movq 0xc8(%rdi), %rax
xorpd %xmm1, %xmm1
testq %rax, %rax
je 0x6b52
movsd 0x20(%rax), %xmm2
movsd 0xb0(%rdi), %xmm0
ucomisd %xmm0, %xmm2
jne 0x6b30
jnp 0x6b52
subsd %xmm2, %xmm0
pushq %rax
andpd 0x38a3(%rip), %xmm0     # 0xa3e0
callq 0x2120
movapd %xmm0, %xmm1
mulsd 0x388a(%rip), %xmm1     # 0xa3d8
addq $0x8, %rsp
movapd %xmm1, %xmm0
retq
nop
// File: /workspace/github_cpp_makefile_star2_O2/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 %r15
pushq %r14
pushq %rbx
subq $0x10, %rsp
movq %rsi, %r14
movq %rdi, %rbx
movsd 0xb0(%rdi), %xmm0
movq 0x8e5c(%rip), %rdi      # 0xffd0
callq 0x2240
leaq 0x3288(%rip), %rsi      # 0xa408
movq %rax, %rdi
callq 0x2160
movl 0x20(%r14), %esi
movq %rax, %rdi
callq 0x2280
leaq 0x327c(%rip), %rsi      # 0xa417
movq %rax, %rdi
callq 0x2160
leaq 0x28(%r14), %rsi
movq %rax, %rdi
callq 0x2150
leaq 0x326a(%rip), %rsi      # 0xa420
movq %rax, %rdi
callq 0x2160
pushq $0x60
popq %rdi
callq 0x2170
movq %rax, %r15
movl 0x20(%r14), %edi
callq 0x5a32
movsd %xmm0, 0x8(%rsp)
movq %rbx, %rdi
callq 0x6a96
movaps %xmm0, %xmm1
movsd 0xb0(%rbx), %xmm2
movq %r15, %rdi
movsd 0x8(%rsp), %xmm0
xorl %esi, %esi
movq %r14, %rdx
callq 0x9406
movq %rbx, %rdi
movq %r15, %rsi
addq $0x10, %rsp
popq %rbx
popq %r14
popq %r15
jmp 0x7228
movq %rax, %rbx
pushq $0x60
popq %rsi
movq %r15, %rdi
callq 0x2180
movq %rbx, %rdi
callq 0x2290
// File: /workspace/github_cpp_makefile_star2_O2/kiudee[P]VAHD-Projekt/Node.cpp
// Function: Node::Search(SearchJob*)
Action Node::Search(SearchJob *sj)
{
    double hashedkey = sj->sid;
    //std::cout << "(" << sj->_debugID << ") " << num << "<-Search(" << sj->sid << ")\n";
    //responsible node for date was found
    if ((right == NULL && num <= hashedkey && num < MAX) // There is no right node and this node is responsible
            || (num <= hashedkey && right->num > hashedkey && num < MAX)// There is a right node but not responsible
            || (sj->sid == MAX && right == NULL && num < MAX) //The searchjob was delegated to the last node and now we reached the last node
            || (sj->type == JOIN && left == NULL && hashedkey < num)) {
        //it is prohibited to do operations on virtual nodes (TO DO except for Join? => yes!)
        FinishSearch(sj);
        return;
    }

    if (sj->round >= sj->bound) {
        doListHop(sj);
    } else {
        //TODO check this if case
        if ((rightstable || leftstable) && sj->round > 0) {
            double bound = Node::calcRoutingBound();
            sj->bound = bound;
        }
        if (!doDebruijnHop(sj)) {
            doListHop(sj);
        }
    }

}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq %rdi, %r14
movsd 0x20(%rsi), %xmm0
movq 0xd0(%rdi), %rax
movsd 0xb0(%rdi), %xmm1
testq %rax, %rax
je 0x72c0
ucomisd %xmm1, %xmm0
jae 0x72a5
testq %rax, %rax
jne 0x7270
ucomisd 0x316a(%rip), %xmm0     # 0xa3c8
jne 0x7270
jp 0x7270
movsd 0x315e(%rip), %xmm2     # 0xa3c8
ucomisd %xmm1, %xmm2
ja 0x72d8
cmpl $0x3, 0x38(%rbx)
jne 0x7286
cmpq $0x0, 0xc8(%r14)
jne 0x7286
ucomisd %xmm0, %xmm1
ja 0x72d8
movl 0x48(%rbx), %eax
cvtsi2sd %eax, %xmm0
ucomisd 0x40(%rbx), %xmm0
jae 0x7319
cmpb $0x0, 0x61(%r14)
je 0x72ea
testl %eax, %eax
jg 0x72f5
jmp 0x7302
movsd 0x311b(%rip), %xmm2     # 0xa3c8
ucomisd %xmm1, %xmm2
jbe 0x7251
movsd 0x20(%rax), %xmm2
ucomisd %xmm0, %xmm2
ja 0x72d8
jmp 0x7251
ucomisd %xmm1, %xmm0
jb 0x724b
movsd 0x30fa(%rip), %xmm2     # 0xa3c8
ucomisd %xmm1, %xmm2
jbe 0x724b
movq %r14, %rdi
movq %rbx, %rsi
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x7400
testl %eax, %eax
jle 0x7302
cmpb $0x0, 0x60(%r14)
je 0x7302
movq %r14, %rdi
callq 0x6a96
movsd %xmm0, 0x40(%rbx)
movq %r14, %rdi
movq %rbx, %rsi
callq 0x7e22
testb %al, %al
je 0x7319
addq $0x8, %rsp
popq %rbx
popq %r14
retq
movq %r14, %rdi
movq %rbx, %rsi
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x80a4
nop
// File: /workspace/github_cpp_makefile_star2_O2/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 %r15
pushq %r14
pushq %rbx
subq $0x10, %rsp
movq %rsi, %r14
movq %rdi, %rbx
movsd 0xb0(%rdi), %xmm0
movq 0x8c86(%rip), %rdi      # 0xffd0
callq 0x2240
leaq 0x30cd(%rip), %rsi      # 0xa423
movq %rax, %rdi
callq 0x2160
movl 0x20(%r14), %esi
movq %rax, %rdi
callq 0x2280
leaq 0x30a6(%rip), %rsi      # 0xa417
movq %rax, %rdi
callq 0x2160
leaq 0x28(%r14), %rsi
movq %rax, %rdi
callq 0x2150
leaq 0x3094(%rip), %rsi      # 0xa420
movq %rax, %rdi
callq 0x2160
pushq $0x60
popq %rdi
callq 0x2170
movq %rax, %r15
movl 0x20(%r14), %edi
callq 0x5a32
movsd %xmm0, 0x8(%rsp)
movq %rbx, %rdi
callq 0x6a96
movaps %xmm0, %xmm1
movsd 0xb0(%rbx), %xmm2
pushq $0x5
popq %rsi
movq %r15, %rdi
movsd 0x8(%rsp), %xmm0
movq %r14, %rdx
callq 0x9406
movq %rbx, %rdi
movq %r15, %rsi
addq $0x10, %rsp
popq %rbx
popq %r14
popq %r15
jmp 0x7400
movq %rax, %rbx
pushq $0x60
popq %rsi
movq %r15, %rdi
callq 0x2180
movq %rbx, %rdi
callq 0x2290
nop
// File: /workspace/github_cpp_makefile_star2_O2/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
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq %rdi, %r15
leaq 0x28(%rsi), %r14
leaq 0x293e(%rip), %rsi      # 0xa470
movq %r14, %rdi
callq 0x95a4
movl %eax, %ebp
movq 0x848d(%rip), %rdi      # 0xffd0
leaq 0x26d8(%rip), %rsi      # 0xa222
callq 0x2160
movsd 0xb0(%r15), %xmm0
movq %rax, %rdi
callq 0x2240
leaq 0x2969(%rip), %rsi      # 0xa4d0
movq %rax, %rdi
callq 0x2160
movl 0x20(%rbx), %esi
movq %rax, %rdi
callq 0x2280
testb %bpl, %bpl
je 0x7ba2
leaq 0x2897(%rip), %rsi      # 0xa41d
movq %rax, %rdi
callq 0x2160
movq %rax, %rdi
movq %r14, %rsi
callq 0x2150
leaq 0x28cf(%rip), %rsi      # 0xa46f
jmp 0x7ba9
leaq 0x293f(%rip), %rsi      # 0xa4e8
movq %rax, %rdi
callq 0x2160
movq %r14, %rdi
callq 0x20a0
pushq $0x48
popq %rsi
movq %rbx, %rdi
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
jmp 0x2180
// File: /workspace/github_cpp_makefile_star2_O2/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
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x10, %rsp
movq %rsi, %r14
movq %rdi, %rbx
movsd 0xb0(%rdi), %xmm0
movq 0x7c5d(%rip), %rdi      # 0xffd0
callq 0x2240
leaq 0x2147(%rip), %rsi      # 0xa4c6
movq %rax, %rdi
callq 0x2160
movq %rax, %r15
movl 0x20(%r14), %edi
callq 0x5a32
movq %r15, %rdi
callq 0x2240
leaq 0x207e(%rip), %rsi      # 0xa420
movq %rax, %rdi
callq 0x2160
pushq $0x38
popq %rdi
callq 0x2170
movq %rax, %r15
movsd 0xb0(%rbx), %xmm0
movsd %xmm0, 0x8(%rsp)
pushq $0x28
popq %rdi
callq 0x2170
movq %rax, %r12
movq 0xc0(%rbx), %rsi
movq %rax, %rdi
callq 0x92c2
movl 0x8(%rbx), %ebp
movq %r15, %rdi
callq 0x3a32
movsd 0x8(%rsp), %xmm0
movsd %xmm0, 0x20(%r15)
movq %r12, 0x28(%r15)
movl %ebp, 0x30(%r15)
pushq $0x60
popq %rdi
callq 0x2170
movq %rax, %r12
movl 0x20(%r14), %edi
callq 0x5a32
movsd %xmm0, 0x8(%rsp)
movq %rbx, %rdi
callq 0x6a96
movaps %xmm0, %xmm1
movl 0x20(%r14), %ecx
movsd 0xb0(%rbx), %xmm2
pushq $0x2
popq %rsi
movq %r12, %rdi
movsd 0x8(%rsp), %xmm0
movq %r15, %rdx
callq 0x9536
movq %rbx, %rdi
movq %r12, %rsi
addq $0x10, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
jmp 0x7228
movq %rax, %rbx
pushq $0x60
popq %rsi
movq %r12, %rdi
jmp 0x847c
movq %rax, %rbx
pushq $0x28
popq %rsi
movq %r12, %rdi
callq 0x2180
jmp 0x8476
movq %rax, %rbx
pushq $0x38
popq %rsi
movq %r15, %rdi
callq 0x2180
movq %rbx, %rdi
callq 0x2290
nop
// File: /workspace/github_cpp_makefile_star2_O2/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
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %r14
movq %rdi, %r15
pushq $0x28
popq %rdi
callq 0x2170
movq %rax, %rbx
movq 0xc0(%r15), %rsi
movq %rax, %rdi
callq 0x92c2
movq 0x20(%rbx), %rax
movq 0x8(%rax), %rax
movq 0x28(%r14), %rcx
movq 0x20(%rcx), %rcx
cmpq 0x8(%rcx), %rax
sete %bpl
movq %rbx, %rdi
callq 0x48a6
pushq $0x28
popq %rsi
movq %rbx, %rdi
callq 0x2180
movl %ebp, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %r14
pushq $0x28
popq %rsi
movq %rbx, %rdi
callq 0x2180
movq %r14, %rdi
callq 0x2290
nop