LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_cpp_makefile_star2_O1/jpbalarini[P]otsus/./algo.cpp
// Function: computeOtsusSegmentation(CImage&, unsigned int*, CImage*, int)
void computeOtsusSegmentation(CImage &input, unsigned* hist, CImage *output, int overrided_threshold){
  // Compute number of pixels
  long int N = input.get_width() * input.get_height();
  int threshold = 0;

  if (overrided_threshold != 0){
    // If threshold was manually entered
    threshold = overrided_threshold;
  }else{
    // Compute threshold
    // Init variables
    float sum = 0;
    float sumB = 0;
    int q1 = 0;
    int q2 = 0;
    float varMax = 0;

    // Auxiliary value for computing m2
    for (int i = 0; i <= MAX_INTENSITY; i++){
      sum += i * ((int)hist[i]);
    }

    for (int i = 0 ; i <= MAX_INTENSITY ; i++) {
      // Update q1
      q1 += hist[i];
      if (q1 == 0)
        continue;
      // Update q2
      q2 = N - q1;

      if (q2 == 0)
        break;
      // Update m1 and m2
      sumB += (float) (i * ((int)hist[i]));
      float m1 = sumB / q1;
      float m2 = (sum - sumB) / q2;

      // Update the between class variance
      float varBetween = (float) q1 * (float) q2 * (m1 - m2) * (m1 - m2);

      // Update the threshold if necessary
      if (varBetween > varMax) {
        varMax = varBetween;
        threshold = i;
      }
    }
  }

  // Perform the segmentation
  segmentImage(input, output, threshold);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movl %ecx, %ebp
movq %rdx, %rbx
movq %rsi, %r15
movq %rdi, %r14
callq 0x5d06
movl %eax, %r12d
movq %r14, %rdi
callq 0x5d02
testl %ebp, %ebp
je 0x7541
movq %r14, %rdi
movq %rbx, %rsi
movl %ebp, %edx
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
jmp 0x7492
movl 0x4d69(%rip), %ecx      # 0xc2b0
testl %ecx, %ecx
js 0x7570
leaq 0x1(%rcx), %rdx
xorps %xmm0, %xmm0
xorl %esi, %esi
movl (%r15,%rsi,4), %edi
imull %esi, %edi
xorps %xmm1, %xmm1
cvtsi2ss %edi, %xmm1
addss %xmm1, %xmm0
incq %rsi
cmpq %rsi, %rdx
jne 0x7554
jmp 0x7573
xorps %xmm0, %xmm0
testl %ecx, %ecx
js 0x75f2
imull %r12d, %eax
incl %ecx
xorps %xmm1, %xmm1
xorl %edx, %edx
xorl %ebp, %ebp
xorps %xmm2, %xmm2
xorl %esi, %esi
movl (%r15,%rdx,4), %r8d
addl %r8d, %esi
je 0x75e5
movl %eax, %edi
subl %esi, %edi
je 0x752c
imull %edx, %r8d
xorps %xmm3, %xmm3
cvtsi2ss %r8d, %xmm3
xorps %xmm4, %xmm4
cvtsi2ss %esi, %xmm4
addss %xmm3, %xmm1
movaps %xmm1, %xmm3
divss %xmm4, %xmm3
movaps %xmm0, %xmm5
subss %xmm1, %xmm5
xorps %xmm6, %xmm6
cvtsi2ss %edi, %xmm6
divss %xmm6, %xmm5
subss %xmm5, %xmm3
mulss %xmm6, %xmm4
mulss %xmm3, %xmm4
mulss %xmm3, %xmm4
ucomiss %xmm2, %xmm4
maxss %xmm2, %xmm4
cmoval %edx, %ebp
movaps %xmm4, %xmm2
incq %rdx
cmpq %rdx, %rcx
jne 0x7589
jmp 0x752c
xorl %ebp, %ebp
jmp 0x752c
// File: /workspace/github_cpp_makefile_star2_O1/kiudee[P]VAHD-Projekt/Supervisor.cpp
// Function: Supervisor::Init(NumObj*)
Action Supervisor::Init(NumObj *num)
{
    total = num->num;
    count = 0;
    printcount = 0;


    std::ofstream *tmpfilestream = new std::ofstream("data.csv");
    csvFile = std::shared_ptr<std::ofstream>(tmpfilestream);

    InitObj *tempObj;
    for (int i = 1; i <= num->num; i++) {
        std::shared_ptr<std::ofstream> tmpfile(csvFile);
        tempObj = new InitObj(h(i), true, tmpfile);
        auto subject = new Node((Object* &) tempObj);
        Subjects.push_back((Subject *) subject);
        _create((Subject *) this, (Subject *) subject);
    }

    delete num;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x38, %rsp
movq %rsi, %r13
movq %rdi, %r14
movl 0x20(%rsi), %eax
movl %eax, 0x64(%rdi)
xorl %eax, %eax
movl %eax, 0x60(%rdi)
movl %eax, 0xf8(%rdi)
movl $0x200, %edi            # imm = 0x200
callq 0x3160
movq %rax, %r15
leaq 0x9aef(%rip), %rsi      # 0xd034
movq %rax, %rdi
movl $0x10, %edx
callq 0x3180
leaq 0x18(%rsp), %rbx
movq %r15, -0x8(%rbx)
movq %rbx, %rdi
movq %r15, %rsi
callq 0x63b8
movaps -0x8(%rbx), %xmm0
xorps %xmm1, %xmm1
movaps %xmm1, -0x8(%rbx)
movq 0xa0(%r14), %rdi
movups %xmm0, 0x98(%r14)
testq %rdi, %rdi
je 0x358a
callq 0x503a
movq 0x18(%rsp), %rdi
testq %rdi, %rdi
je 0x3599
callq 0x503a
movq %r13, %r12
cmpl $0x0, 0x20(%r13)
jle 0x36a6
leaq 0xe0(%r14), %rax
movq %rax, 0x28(%rsp)
xorl %ebp, %ebp
movq 0x98(%r14), %rbx
movq 0xa0(%r14), %r15
testq %r15, %r15
je 0x35df
movq 0xe9f9(%rip), %rax      # 0x11fc8
cmpb $0x0, (%rax)
je 0x35da
incl 0x8(%r15)
jmp 0x35df
lock
incl 0x8(%r15)
movl $0x40, %edi
callq 0x3160
movq %rax, %r13
incl %ebp
movl %ebp, %edi
callq 0x71bc
movq %rbx, (%rsp)
movq %r15, 0x8(%rsp)
testq %r15, %r15
je 0x361a
movq 0xe9be(%rip), %rax      # 0x11fc8
cmpb $0x0, (%rax)
je 0x3615
incl 0x8(%r15)
jmp 0x361a
lock
incl 0x8(%r15)
movq %r13, %rdi
movl $0x1, %esi
movq %rsp, %rdx
callq 0x4c46
movq %r13, 0x10(%rsp)
movq 0x8(%rsp), %rdi
testq %rdi, %rdi
je 0x363e
callq 0x503a
movl $0xe8, %edi
callq 0x3160
movq %rax, %r13
movq %rax, %rdi
leaq 0x10(%rsp), %rsi
callq 0x4ca0
movq %r13, 0x30(%rsp)
movq 0x28(%rsp), %rdi
leaq 0x30(%rsp), %rsi
callq 0x645e
leaq 0xeb2d(%rip), %rax      # 0x121a0
movq %r14, (%rax)
movl $0x60, %edi
callq 0x3160
movq %rax, %rbx
movq %rax, %rdi
movq %r13, %rsi
callq 0x60d2
testq %r15, %r15
je 0x369b
movq %r15, %rdi
callq 0x503a
cmpl 0x20(%r12), %ebp
jl 0x35b5
testq %r12, %r12
je 0x36b8
movl $0x28, %esi
movq %r12, %rdi
callq 0x3170
addq $0x38, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %r14
movl $0x200, %esi            # imm = 0x200
movq %r15, %rdi
callq 0x3170
jmp 0x372a
jmp 0x371a
movq %rax, %r14
jmp 0x36f2
movq %rax, %r14
movq 0x8(%rsp), %rdi
testq %rdi, %rdi
je 0x36f2
callq 0x503a
movl $0x40, %esi
jmp 0x3701
movq %rax, %r14
movl $0xe8, %esi
movq %r13, %rdi
jmp 0x3713
jmp 0x371a
movq %rax, %r14
movl $0x60, %esi
movq %rbx, %rdi
callq 0x3170
jmp 0x371d
movq %rax, %r14
testq %r15, %r15
je 0x372a
movq %r15, %rdi
callq 0x503a
movq %r14, %rdi
callq 0x3280
// File: /workspace/github_cpp_makefile_star2_O1/kiudee[P]VAHD-Projekt/Supervisor.cpp
// Function: Supervisor::RemoveRealChild(DoubleObj*)
Action Supervisor::RemoveRealChild(DoubleObj *dob)
{
    std::cout << "Node " << (dob->num) << " leaves. Ciao.\n";
    Relay *subj = subjects.at(dob->num);
    subjects.erase(dob->num);
    delete(subj);
    delete dob;
}

// Assembly:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
movq %rsi, %rbx
movq %rdi, %r14
movq 0xd42a(%rip), %r12      # 0x11fd0
leaq 0x8675(%rip), %rsi      # 0xd222
movl $0x5, %edx
movq %r12, %rdi
callq 0x31a0
leaq 0x20(%rbx), %r15
movsd 0x20(%rbx), %xmm0
movq %r12, %rdi
callq 0x3230
leaq 0x8656(%rip), %rsi      # 0xd228
movl $0xf, %edx
movq %rax, %rdi
callq 0x31a0
leaq 0xa8(%r14), %r12
movq %r12, %rdi
movq %r15, %rsi
callq 0x7050
testq %rax, %rax
je 0x4c39
movq 0x10(%rax), %r13
movq %r12, %rdi
movq %r15, %rsi
callq 0x708e
movq (%r14), %rax
movq %r14, %rdi
movq %r14, %rsi
movq %r13, %rdx
callq *0x20(%rax)
testq %rbx, %rbx
je 0x4c2f
movl $0x28, %esi
movq %rbx, %rdi
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
jmp 0x3170
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
leaq 0x865e(%rip), %rdi      # 0xd29e
callq 0x31e0
nop
// File: /workspace/github_cpp_makefile_star2_O1/kiudee[P]VAHD-Projekt/./Subjects1-6.h
// Function: InitObj::InitObj(double, bool, std::shared_ptr<std::basic_ofstream<char, std::char_traits<char>>>)
Object::Object()
{
    _debugID = _numObjects;
    _numObjects++;
    if (WARNING && _numObjects > MAXOBJECTS) {
        std::cout << "-- Warning! More than " << MAXOBJECTS << " objects.\n";
    }
    _owner = NULL;
    _source = NULL;
    _sink = NULL;
    if (_activeSubject == NULL) {
        if (WARNING) {
            std::cout << "--Warning! Object created outside of subjects environment.\n";
        }
    } else {
        _owner = _activeSubject;
        if (DEBUG) {
            std::cout << "-- Creating object " << _debugID << " by subject " << _activeSubject->_debugID << ".\n";
        }
    }
}

// Assembly:
leaq 0xd53b(%rip), %rax      # 0x12188
movq (%rax), %rcx
movq %rcx, (%rdi)
incq (%rax)
xorps %xmm1, %xmm1
movups %xmm1, 0x8(%rdi)
movq $0x0, 0x18(%rdi)
leaq 0xd534(%rip), %rax      # 0x121a0
movq (%rax), %rax
testq %rax, %rax
je 0x4c7b
leaq 0x8(%rdi), %rcx
movq %rax, (%rcx)
movups %xmm1, 0x30(%rdi)
movb %sil, 0x20(%rdi)
movsd %xmm0, 0x28(%rdi)
movq (%rdx), %rax
movq %rax, 0x30(%rdi)
addq $0x38, %rdi
addq $0x8, %rdx
movq %rdx, %rsi
jmp 0x50b4
nop
// File: /workspace/github_cpp_makefile_star2_O1/kiudee[P]VAHD-Projekt/./Subjects1-6.h
// Function: Subject::Subject()
Subject::Subject()
{
    _setup();
    _Relays = new _rLinks();
    _Subjects = new _sLinks();
    _activeRelays = new _rLinks();
    _activeSubjects = new _sLinks();
    _sink = new Relay(SINK, (Subject *) this);

    if (_activeSubject == NULL && _debugID > 0) {
        if (WARNING) {
            std::cout << "-- Warning! Subject created outside of the subjects environment.\n";
        }
    } else {
        if (DEBUG) {
            std::cout << "-- Creating subject " << _debugID << ".\n";
        }
        _activeSubject = NULL;  // new subject can only use 'call' in constructor
    }
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rdi, %rbx
leaq 0xca97(%rip), %rax      # 0x11ba0
movq %rax, (%rdi)
leaq 0xd085(%rip), %rax      # 0x12198
movq (%rax), %rcx
movq %rcx, 0x8(%rdi)
incq %rcx
movq %rcx, (%rax)
leaq 0xd079(%rip), %r15      # 0x121a0
movq (%r15), %rax
movq %rax, 0x10(%rdi)
xorps %xmm0, %xmm0
movups %xmm0, 0x18(%rdi)
movups %xmm0, 0x28(%rdi)
movups %xmm0, 0x38(%rdi)
movups %xmm0, 0x48(%rdi)
movq $0x0, 0x58(%rdi)
movl $0x10, %edi
callq 0x3160
xorps %xmm0, %xmm0
movups %xmm0, (%rax)
movq %rax, 0x30(%rbx)
movl $0x10, %edi
callq 0x3160
xorps %xmm0, %xmm0
movups %xmm0, (%rax)
movq %rax, 0x40(%rbx)
movl $0x10, %edi
callq 0x3160
xorps %xmm0, %xmm0
movups %xmm0, (%rax)
movq %rax, 0x38(%rbx)
movl $0x10, %edi
callq 0x3160
xorps %xmm0, %xmm0
movups %xmm0, (%rax)
movq %rax, 0x48(%rbx)
movl $0x48, %edi
callq 0x3160
movq %rax, %r14
leaq 0xca73(%rip), %rax      # 0x11c20
movq %rax, (%r14)
movq %rbx, 0x18(%r14)
movq %r14, %rdi
callq 0x58ce
movq %r14, 0x20(%rbx)
cmpq $0x0, (%r15)
jne 0x51cd
cmpq $0x0, 0x8(%rbx)
jne 0x51d4
movq $0x0, (%r15)
popq %rbx
popq %r14
popq %r15
retq
movq %rax, %rbx
movl $0x48, %esi
movq %r14, %rdi
callq 0x3170
movq %rbx, %rdi
callq 0x3280
// File: /workspace/github_cpp_makefile_star2_O1/kiudee[P]VAHD-Projekt/./Subjects1-6.h
// Function: Subject::_wake(Subject*, Subject*)
int Subject::_wake(Subject *s, Subject *t)
{
    if (_activeSubject == NULL || (_parent == NULL && _debugID > 0)) {
        if (WARNING) {
            std::cout << "-- Warning! " << _debugID << "called 'wakeup' outside of the subjects environment.\n";
        }
    } else {
        if (t == NULL) {
            if (WARNING) {
                std::cout << "-- Warning! " << _debugID << " cannot wake up NULL.\n";
            }
        } else {
            if (s != this) {
                if (WARNING) {
                    std::cout << "-- Warning! " << s->_debugID << " cannot call 'wakeup' for subject " << _debugID << ".\n";
                }
            } else {
                if (s != t->_parent) {
                    if (WARNING) {
                        std::cout << "-- Warning! " << _debugID << " cannot call 'wakeup' for subject " << t->_debugID << ".\n";
                    }
                } else {
                    _activeSubjects->add(t);  // wake up subject t
                    return 1;
                }
            }
        }
    }
    return 0;
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
leaq 0xcd79(%rip), %rcx      # 0x121a0
xorl %eax, %eax
cmpq $0x0, (%rcx)
je 0x5462
movq %rdx, %rbx
cmpq $0x0, 0x10(%rdi)
je 0x544b
testq %rbx, %rbx
sete %cl
cmpq %rdi, %rsi
setne %dl
orb %cl, %dl
je 0x545c
jmp 0x5462
cmpq %rdi, %rsi
jne 0x5462
testq %rbx, %rbx
je 0x5462
cmpq $0x0, 0x8(%rdi)
jne 0x5462
cmpq %rsi, 0x10(%rbx)
je 0x546a
addq $0x8, %rsp
popq %rbx
popq %r14
retq
movl $0x1, %eax
testq %rbx, %rbx
je 0x5462
movq 0x48(%rdi), %r14
movq (%r14), %rax
testq %rax, %rax
je 0x54a2
xorl %ecx, %ecx
movl $0x1, %edx
cmpq %rbx, (%rax)
movq 0x8(%rax), %rsi
cmovel %edx, %ecx
movq %rsi, %rax
testq %rsi, %rsi
jne 0x5487
movl $0x1, %eax
testl %ecx, %ecx
jne 0x5462
movl $0x10, %edi
callq 0x3160
movq %rbx, (%rax)
movq $0x0, 0x8(%rax)
movq 0x8(%r14), %rcx
xorl %edx, %edx
testq %rcx, %rcx
cmoveq %r14, %rcx
setne %dl
movq %rax, 0x8(%rcx)
movq %rax, (%r14,%rdx,8)
movl $0x1, %eax
jmp 0x5462
// File: /workspace/github_cpp_makefile_star2_O1/kiudee[P]VAHD-Projekt/./Subjects1-6.h
// Function: Subject::_wake(Subject*, Relay*)
int Subject::_wake(Subject *s, Relay *r)
{
    if (_activeSubject == NULL || (_parent == NULL && _debugID > 0)) {
        if (WARNING) {
            std::cout << "-- Warning! " << _debugID << "called 'wakeup' outside of the subjects environment.\n";
        }
    } else {
        if (r == NULL) {
            if (WARNING) {
                std::cout << "-- Warning! " << _debugID << " cannot wake up NULL.\n";
            }
        } else {
            if (s != this) {
                if (WARNING) {
                    std::cout << "-- Warning! " << s->_debugID << " cannot call 'wakeup' for subject " << _debugID << ".\n";
                }
            } else {
                if (s != r->_home) {
                    if (WARNING) {
                        std::cout << "-- Warning! " << _debugID << " cannot call 'wakeup' for relay " << r->ID << ".\n";
                    }
                } else {
                    r->_awake = 1;
                    _activeRelays->add(r);  // wake up relay point r
                    r->_iLinks->wake(r);    // wake up connections to r
                    if (DEBUG) {
                        std::cout << "-- Subject " << _debugID << " wakes up relay " << r->ID << ".\n";
                    }
                    return 1;
                }
            }
        }
    }
    return 0;
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
leaq 0xccbf(%rip), %rcx      # 0x121a0
xorl %eax, %eax
cmpq $0x0, (%rcx)
je 0x551c
movq %rdx, %rbx
cmpq $0x0, 0x10(%rdi)
je 0x5505
testq %rbx, %rbx
sete %cl
cmpq %rdi, %rsi
setne %dl
orb %cl, %dl
je 0x5516
jmp 0x551c
cmpq %rdi, %rsi
jne 0x551c
testq %rbx, %rbx
je 0x551c
cmpq $0x0, 0x8(%rdi)
jne 0x551c
cmpq %rsi, 0x18(%rbx)
je 0x5524
addq $0x8, %rsp
popq %rbx
popq %r14
retq
movl $0x1, 0x10(%rbx)
testq %rbx, %rbx
je 0x5586
movq 0x38(%rdi), %r14
movq (%r14), %rcx
testq %rcx, %rcx
je 0x5559
xorl %eax, %eax
movl $0x1, %edx
cmpq %rbx, (%rcx)
movq 0x8(%rcx), %rsi
cmovel %edx, %eax
movq %rsi, %rcx
testq %rsi, %rsi
jne 0x5543
testl %eax, %eax
jne 0x5586
movl $0x10, %edi
callq 0x3160
movq %rbx, (%rax)
movq $0x0, 0x8(%rax)
movq 0x8(%r14), %rcx
xorl %edx, %edx
testq %rcx, %rcx
setne %dl
cmoveq %r14, %rcx
movq %rax, 0x8(%rcx)
movq %rax, (%r14,%rdx,8)
movq 0x20(%rbx), %rax
movq (%rax), %rcx
movl $0x1, %eax
testq %rcx, %rcx
je 0x551c
movq (%rcx), %rdx
movq %rbx, 0x28(%rdx)
movq 0x8(%rcx), %rcx
jmp 0x5592
// File: /workspace/github_cpp_makefile_star2_O1/kiudee[P]VAHD-Projekt/./Subjects1-6.h
// Function: Subject::_halt(Subject*, Subject*)
int Subject::_halt(Subject *s, Subject *t)
{
    if (_activeSubject == NULL || (_parent == NULL && _debugID > 0)) {
        if (WARNING) {
            std::cout << "-- Warning! " << _debugID << "called 'freeze' outside of the subjects environment.\n";
        }
    } else {
        if (t == 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 != t->_parent) {
                    if (WARNING) {
                        std::cout << "-- Warning! " << _debugID << " cannot call 'freeze' for subject " << t->_debugID << ".\n";
                    }
                } else {
                    _activeSubjects->remove(t);  // freezes subject t
                    return 1;
                }
            }
        }
    }
    return 0;
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
leaq 0xcbed(%rip), %rax      # 0x121a0
xorl %ebx, %ebx
cmpq $0x0, (%rax)
je 0x568a
movq %rdx, %r14
cmpq $0x0, 0x10(%rdi)
je 0x55de
testq %r14, %r14
sete %al
cmpq %rdi, %rsi
setne %cl
orb %al, %cl
je 0x55fb
jmp 0x568a
cmpq %rdi, %rsi
jne 0x568a
testq %r14, %r14
je 0x568a
cmpq $0x0, 0x8(%rdi)
jne 0x568a
cmpq %rsi, 0x10(%r14)
jne 0x568a
movq 0x48(%rdi), %r15
movq (%r15), %r12
movl $0x1, %ebx
testq %r12, %r12
je 0x568a
cmpq %r14, (%r12)
je 0x5666
xorl %eax, %eax
movq %r12, (%r15)
testb %al, %al
jne 0x5683
movq 0x8(%r12), %rdi
testq %rdi, %rdi
je 0x5686
leaq 0x8(%r12), %rax
cmpq %r14, (%rdi)
je 0x563e
movq %rdi, %r12
jmp 0x564f
movq 0x8(%rdi), %rcx
movq %rcx, (%rax)
movl $0x10, %esi
callq 0x3170
leaq 0x8(%r12), %rax
movq 0x8(%r12), %rdi
testq %rdi, %rdi
jne 0x5634
jmp 0x5686
cmpq %r14, (%r12)
jne 0x561e
movq %r12, %rdi
movq 0x8(%r12), %r12
movl $0x10, %esi
callq 0x3170
testq %r12, %r12
sete %al
jne 0x5660
movq %r12, (%r15)
xorl %r12d, %r12d
movq %r12, 0x8(%r15)
movl %ebx, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
// File: /workspace/github_cpp_makefile_star2_O1/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 %r15
pushq %r14
pushq %rbx
leaq 0xcafc(%rip), %rcx      # 0x121a0
xorl %eax, %eax
cmpq $0x0, (%rcx)
je 0x56df
movq %rdx, %rbx
cmpq $0x0, 0x10(%rdi)
je 0x56c8
testq %rbx, %rbx
sete %cl
cmpq %rdi, %rsi
setne %dl
orb %cl, %dl
je 0x56d9
jmp 0x56df
cmpq %rdi, %rsi
jne 0x56df
testq %rbx, %rbx
je 0x56df
cmpq $0x0, 0x8(%rdi)
jne 0x56df
cmpq %rsi, 0x18(%rbx)
je 0x56e5
popq %rbx
popq %r14
popq %r15
retq
movl $0x0, 0x10(%rbx)
movq 0x38(%rdi), %r14
movq (%r14), %r15
testq %r15, %r15
je 0x5765
cmpq %rbx, (%r15)
je 0x5742
xorl %eax, %eax
movq %r15, (%r14)
testb %al, %al
jne 0x575e
movq 0x8(%r15), %rdi
testq %rdi, %rdi
je 0x5761
leaq 0x8(%r15), %rax
cmpq %rbx, (%rdi)
je 0x571d
movq %rdi, %r15
jmp 0x572e
movq 0x8(%rdi), %rcx
movq %rcx, (%rax)
movl $0x10, %esi
callq 0x3170
leaq 0x8(%r15), %rax
movq 0x8(%r15), %rdi
testq %rdi, %rdi
jne 0x5713
jmp 0x5761
cmpq %rbx, (%r15)
jne 0x56ff
movq %r15, %rdi
movq 0x8(%r15), %r15
movl $0x10, %esi
callq 0x3170
testq %r15, %r15
sete %al
jne 0x573d
movq %r15, (%r14)
xorl %r15d, %r15d
movq %r15, 0x8(%r14)
movq 0x20(%rbx), %rax
movq (%rax), %rcx
movl $0x1, %eax
testq %rcx, %rcx
je 0x56df
movq (%rcx), %rdx
movq $0x0, 0x28(%rdx)
movq 0x8(%rcx), %rcx
jmp 0x5771
nop
// File: /workspace/github_cpp_makefile_star2_O1/kiudee[P]VAHD-Projekt/./Subjects1-6.h
// Function: Subject::_handle(Subject*, _Message*)
int Subject::_handle(Subject *s, _Message *m)
{
    // only here, _activeSubject==NULL is allowed
    if (m == NULL) {
        if (WARNING) {
            std::cout << "-- Warning! " << _debugID << " cannot handle NULL.\n";
        }
    } else {
        if (s != this) {
            if (WARNING) {
                std::cout << "-- Warning! " << s->_debugID << " cannot call 'call' for subject " << _debugID << ".\n";
            }
            delete m;
        } else {
            if (_sink != NULL) {
                if (DEBUG) {
                    std::cout << "-- Message " << m->debugID << " stored in subject " << _debugID << ".\n";
                }
                _sink->_oQueue->enqueue(m);
                return 1;
            } else {
                if (WARNING) {
                    std::cout << "-- Warning! Sink of subject " << _debugID << " not well-defined.\n";
                }
                delete m;
            }
        }
    }
    return 0;
}

// Assembly:
pushq %rbx
xorl %ebx, %ebx
testq %rdx, %rdx
je 0x57e3
cmpq %rdi, %rsi
je 0x57a8
movl $0x38, %esi
movq %rdx, %rdi
callq 0x3170
jmp 0x57e3
movq 0x20(%rdi), %rax
testq %rax, %rax
je 0x5799
movq 0x38(%rax), %rax
leaq 0x8(%rax), %rcx
movq 0x8(%rax), %rsi
leaq 0x30(%rsi), %rdi
xorl %r8d, %r8d
testq %rsi, %rsi
setne %r8b
cmoveq %rcx, %rdi
movq %rdx, (%rdi)
movq %rdx, (%rax,%r8,8)
movq $0x0, 0x30(%rdx)
movl $0x1, %ebx
movl %ebx, %eax
popq %rbx
retq
nop
// File: /workspace/github_cpp_makefile_star2_O1/kiudee[P]VAHD-Projekt/./Subjects1-6.h
// Function: Subject::idle()
int Subject::idle()
{
    if (_activeSubject == NULL) {
        if (WARNING) {
            std::cout << "-- Warning! Method 'idle' called outside of the subjects environment.\n";
        }
    } else {
        if (_activeSubject != this) {
            if (WARNING) {
                std::cout << "-- Warning! Subject " << _activeSubject->_debugID << " cannot call " << _debugID << "->idle().\n";
            }
        } else {
            return _Relays->idle();
        }
        // return _sink->_oQueue->empty();
    }
    return 0;
}

// Assembly:
leaq 0xc9b1(%rip), %rcx      # 0x121a0
xorl %eax, %eax
cmpq %rdi, (%rcx)
je 0x57f7
retq
movq 0x30(%rdi), %rax
movq (%rax), %rcx
movl $0x1, %eax
testq %rcx, %rcx
je 0x57f6
movq (%rcx), %rdx
testq %rdx, %rdx
je 0x581d
movq 0x38(%rdx), %rdx
xorl %eax, %eax
cmpq $0x0, (%rdx)
sete %al
movq 0x8(%rcx), %rcx
testq %rcx, %rcx
je 0x57f6
testl %eax, %eax
jne 0x5808
jmp 0x57f6
// File: /workspace/github_cpp_makefile_star2_O1/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 0xc96d(%rip), %rax      # 0x121a0
movq (%rax), %rcx
testq %rcx, %rcx
sete %dl
testq %rsi, %rsi
sete %dil
xorl %eax, %eax
orb %dl, %dil
jne 0x5850
cmpq 0x18(%rsi), %rcx
je 0x5851
retq
movq 0x38(%rsi), %rcx
xorl %eax, %eax
cmpq $0x0, (%rcx)
sete %al
retq
nop
// File: /workspace/github_cpp_makefile_star2_O1/kiudee[P]VAHD-Projekt/./Subjects1-6.h
// Function: Subject::indeg(Relay*)
int Subject::indeg(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->_iLinks->count();
            }
        }
    }
    return 0;
}

// Assembly:
leaq 0xc939(%rip), %rax      # 0x121a0
movq (%rax), %rcx
testq %rcx, %rcx
sete %dl
testq %rsi, %rsi
sete %dil
xorl %eax, %eax
orb %dl, %dil
jne 0x589d
cmpq 0x18(%rsi), %rcx
jne 0x589d
movq 0x20(%rsi), %rcx
movq (%rcx), %rcx
testq %rcx, %rcx
je 0x589d
xorl %eax, %eax
incl %eax
movq 0x8(%rcx), %rcx
testq %rcx, %rcx
jne 0x5892
retq
// File: /workspace/github_cpp_makefile_star2_O1/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 %r15
pushq %r14
pushq %rbx
movq %rdi, %rbx
leaq 0xc8b3(%rip), %rax      # 0x12190
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)
xorl %r14d, %r14d
movq %r14, 0x28(%rdi)
movl $0x10, %edi
callq 0x3160
xorps %xmm0, %xmm0
movups %xmm0, (%rax)
movq %rax, 0x38(%rbx)
movl $0x10, %edi
callq 0x3160
xorps %xmm0, %xmm0
movups %xmm0, (%rax)
movq %rax, 0x20(%rbx)
movl $0x18, %edi
callq 0x3160
xorps %xmm0, %xmm0
movups %xmm0, (%rax)
movq %r14, 0x10(%rax)
movq %rax, 0x40(%rbx)
movq 0x18(%rbx), %r14
testq %r14, %r14
je 0x5a05
movq 0x30(%r14), %r15
testq %r15, %r15
je 0x5a05
movq (%r15), %rcx
testq %rcx, %rcx
je 0x5982
xorl %eax, %eax
movl $0x1, %edx
cmpq %rbx, (%rcx)
movq 0x8(%rcx), %rsi
cmovel %edx, %eax
movq %rsi, %rcx
testq %rsi, %rsi
jne 0x596c
testl %eax, %eax
jne 0x59af
movl $0x10, %edi
callq 0x3160
movq %rbx, (%rax)
movq $0x0, 0x8(%rax)
movq 0x8(%r15), %rcx
xorl %edx, %edx
testq %rcx, %rcx
setne %dl
cmoveq %r15, %rcx
movq %rax, 0x8(%rcx)
movq %rax, (%r15,%rdx,8)
movq 0x38(%r14), %r14
movq (%r14), %rcx
testq %rcx, %rcx
je 0x59d8
xorl %eax, %eax
movl $0x1, %edx
cmpq %rbx, (%rcx)
movq 0x8(%rcx), %rsi
cmovel %edx, %eax
movq %rsi, %rcx
testq %rsi, %rsi
jne 0x59c2
testl %eax, %eax
jne 0x5a05
movl $0x10, %edi
callq 0x3160
movq %rbx, (%rax)
movq $0x0, 0x8(%rax)
movq 0x8(%r14), %rcx
xorl %edx, %edx
testq %rcx, %rcx
setne %dl
cmoveq %r14, %rcx
movq %rax, 0x8(%rcx)
movq %rax, (%r14,%rdx,8)
popq %rbx
popq %r14
popq %r15
retq
nop
// File: /workspace/github_cpp_makefile_star2_O1/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:
pushq %rbx
cmpq %rsi, 0x18(%rdi)
je 0x5a29
xorl %ebx, %ebx
testq %rdx, %rdx
je 0x5a79
movl $0x38, %esi
movq %rdx, %rdi
callq 0x3170
jmp 0x5a79
movl $0x1, %ebx
testq %rdx, %rdx
je 0x5a79
movq 0x8(%rdi), %rax
movq %rax, 0x8(%rdx)
movq 0x28(%rdx), %rax
testq %rax, %rax
je 0x5a4c
movq $0x0, 0x8(%rax)
movq 0x38(%rdi), %rax
leaq 0x8(%rax), %rcx
movq 0x8(%rax), %rsi
leaq 0x30(%rsi), %rdi
xorl %r8d, %r8d
testq %rsi, %rsi
cmoveq %rcx, %rdi
setne %r8b
movq %rdx, (%rdi)
movq %rdx, (%rax,%r8,8)
movq $0x0, 0x30(%rdx)
movl %ebx, %eax
popq %rbx
retq
nop
// File: /workspace/github_cpp_makefile_star2_O1/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:
movq 0x28(%rdi), %rsi
xorl %eax, %eax
testq %rsi, %rsi
je 0x5b1b
movq 0x18(%rdi), %r8
movq 0x38(%rdi), %rdx
movq (%rdx), %rcx
cmpq 0x20(%r8), %rsi
je 0x5ac3
xorl %eax, %eax
testq %rcx, %rcx
je 0x5b1c
movq 0x30(%rcx), %rdi
movq %rdi, (%rdx)
testq %rdi, %rdi
jne 0x5ab9
movq $0x0, 0x8(%rdx)
movq $0x0, 0x30(%rcx)
jmp 0x5b1e
testq %rcx, %rcx
je 0x5b1b
movq 0x8(%rdi), %rdi
movq 0x38(%rsi), %rsi
leaq 0x8(%rsi), %r8
movq 0x30(%rcx), %rax
movq %rax, (%rdx)
testq %rax, %rax
jne 0x5ae8
movq $0x0, 0x8(%rdx)
xorl %eax, %eax
movq %rax, 0x30(%rcx)
movq %rdi, 0x10(%rcx)
movq 0x8(%rsi), %r9
leaq 0x30(%r9), %r10
xorl %r11d, %r11d
testq %r9, %r9
setne %r11b
cmoveq %r8, %r10
movq %rcx, (%r10)
movq %rcx, (%rsi,%r11,8)
movq %rax, 0x30(%rcx)
movq (%rdx), %rcx
testq %rcx, %rcx
jne 0x5ad4
retq
xorl %ecx, %ecx
testq %rcx, %rcx
je 0x5b1b
movq 0x38(%rsi), %rax
leaq 0x8(%rax), %rdx
movq 0x8(%rax), %rsi
leaq 0x30(%rsi), %rdi
xorl %r8d, %r8d
testq %rsi, %rsi
setne %r8b
cmoveq %rdx, %rdi
movq %rcx, (%rdi)
movq %rcx, (%rax,%r8,8)
movq $0x0, 0x30(%rcx)
movl $0x1, %eax
retq
// File: /workspace/github_cpp_makefile_star2_O1/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 %rbx
subq $0x10, %rsp
movq %rsi, %r15
movq %rdi, %rbx
movsd 0x20(%rsi), %xmm0
movsd %xmm0, 0x8(%rsp)
movsd 0xb0(%rdi), %xmm0
mulsd 0x55c2(%rip), %xmm0     # 0xd3b8
movsd %xmm0, (%rsp)
movl $0x38, %edi
callq 0x3160
movq %rax, %r14
movsd 0x8(%rsp), %xmm0
ucomisd (%rsp), %xmm0
jne 0x7e2b
jp 0x7e2b
movq %r14, %rdi
movq %r15, %rsi
callq 0x4dae
movq %r14, 0xd8(%rbx)
jmp 0x7e3d
movq %r14, %rdi
movq %r15, %rsi
callq 0x4dae
movq %r14, 0xe0(%rbx)
movl $0x28, %edi
callq 0x3160
movq %rax, %r15
leaq 0xa337(%rip), %rax      # 0x12188
movq (%rax), %rcx
movq %rcx, (%r15)
incq %rcx
movq %rcx, (%rax)
xorpd %xmm0, %xmm0
movupd %xmm0, 0x8(%r15)
movq $0x0, 0x18(%r15)
leaq 0xa32a(%rip), %rax      # 0x121a0
movq (%rax), %rax
testq %rax, %rax
je 0x7e88
movq %r15, %rcx
addq $0x8, %rcx
movq %rax, (%rcx)
movl $0x5, 0x20(%r15)
movq 0x28(%r14), %r14
movl $0x38, %edi
callq 0x3160
leaq 0xa303(%rip), %rcx      # 0x121a8
movq (%rcx), %rdx
movq %rdx, (%rax)
incq %rdx
movq %rdx, (%rcx)
xorpd %xmm0, %xmm0
movupd %xmm0, 0x8(%rax)
leaq 0x47(%rip), %rcx        # 0x7f08
movq %rcx, 0x18(%rax)
xorl %ecx, %ecx
movq %rcx, 0x20(%rax)
movq %r15, 0x28(%rax)
movq %rcx, 0x30(%rax)
movq (%r14), %rcx
movq 0x8(%rcx), %rcx
movq %r14, %rdi
movq %rbx, %rsi
movq %rax, %rdx
addq $0x10, %rsp
popq %rbx
popq %r14
popq %r15
jmpq *%rcx
jmp 0x7ef0
movq %rax, %rbx
movl $0x38, %esi
movq %r14, %rdi
callq 0x3170
movq %rbx, %rdi
callq 0x3280
// File: /workspace/github_cpp_makefile_star2_O1/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 0x7f74
movq %rsi, %r14
decl %eax
movl %eax, 0x20(%rsi)
movl $0x38, %edi
callq 0x3160
leaq 0xa279(%rip), %rcx      # 0x121a8
movq (%rcx), %rdx
movq %rdx, (%rax)
incq %rdx
movq %rdx, (%rcx)
xorps %xmm0, %xmm0
movups %xmm0, 0x8(%rax)
leaq -0x41(%rip), %rcx       # 0x7f08
movq %rcx, 0x18(%rax)
xorl %ecx, %ecx
movq %rcx, 0x20(%rax)
movq %r14, 0x28(%rax)
movq %rcx, 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
xorl %esi, %esi
callq 0x8410
movq %rbx, %rdi
xorl %esi, %esi
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x8bcc
nop
// File: /workspace/github_cpp_makefile_star2_O1/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 0x801e
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 0x8014
movq (%r14), %rax
movq 0x28(%rax), %r15
testq %r15, %r15
je 0x7fec
movq %r15, %rdi
callq 0x5b6e
movl $0x48, %esi
movq %r15, %rdi
callq 0x3170
movq (%r14), %rdi
testq %rdi, %rdi
je 0x7ffe
movl $0x38, %esi
callq 0x3170
movq $0x0, (%r14)
testb %bpl, %bpl
je 0x8010
movb $0x0, 0x61(%rbx)
jmp 0x8014
movb $0x0, 0x60(%rbx)
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O1/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 0x8b31
movq 0xd0(%rdi), %rax
testq %rax, %rax
je 0x8b31
movsd 0x20(%rax), %xmm1
movsd 0xb0(%rdi), %xmm0
ucomisd %xmm0, %xmm1
jne 0x8b79
jp 0x8b79
cmpb $0x1, 0x60(%rdi)
jne 0x8b58
movq 0xc8(%rdi), %rax
testq %rax, %rax
je 0x8b58
movsd 0x20(%rax), %xmm1
movsd 0xb0(%rdi), %xmm0
ucomisd %xmm0, %xmm1
jne 0x8b79
jp 0x8b79
movq 0xd0(%rdi), %rax
testq %rax, %rax
je 0x8b7f
movsd 0x20(%rax), %xmm1
movsd 0xb0(%rdi), %xmm0
ucomisd %xmm0, %xmm1
jne 0x8b79
jnp 0x8b7f
subsd %xmm1, %xmm0
jmp 0x8ba8
movq 0xc8(%rdi), %rax
xorpd %xmm1, %xmm1
testq %rax, %rax
je 0x8bc6
movsd 0x20(%rax), %xmm2
movsd 0xb0(%rdi), %xmm0
ucomisd %xmm0, %xmm2
jne 0x8ba4
jnp 0x8bc6
subsd %xmm2, %xmm0
pushq %rax
andpd 0x482f(%rip), %xmm0     # 0xd3e0
callq 0x3120
movapd %xmm0, %xmm1
mulsd 0x480e(%rip), %xmm1     # 0xd3d0
addq $0x8, %rsp
movapd %xmm1, %xmm0
retq
nop
// File: /workspace/github_cpp_makefile_star2_O1/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 0x89cc(%rip), %rdi      # 0x11fd0
callq 0x3230
movq %rax, %r15
leaq 0x3df5(%rip), %rsi      # 0xd408
movl $0xe, %edx
movq %rax, %rdi
callq 0x31a0
movl 0x20(%r14), %esi
movq %r15, %rdi
callq 0x3270
movq %rax, %r15
leaq 0x3de1(%rip), %rsi      # 0xd417
movl $0x8, %edx
movq %rax, %rdi
callq 0x31a0
movq 0x28(%r14), %rsi
movq 0x30(%r14), %rdx
movq %r15, %rdi
callq 0x31a0
leaq 0x3dc6(%rip), %rsi      # 0xd420
movl $0x2, %edx
movq %rax, %rdi
callq 0x31a0
movl $0x60, %edi
callq 0x3160
movq %rax, %r15
movl 0x20(%r14), %edi
callq 0x71d2
movsd %xmm0, 0x8(%rsp)
movq %rbx, %rdi
callq 0x8b0a
movsd 0xb0(%rbx), %xmm1
leaq 0x8aee(%rip), %rax      # 0x12188
movq (%rax), %rcx
movq %rcx, (%r15)
incq %rcx
movq %rcx, (%rax)
xorps %xmm2, %xmm2
movups %xmm2, 0x8(%r15)
movq $0x0, 0x18(%r15)
leaq 0x8ae3(%rip), %rax      # 0x121a0
movq (%rax), %rax
testq %rax, %rax
je 0x96cf
movq %r15, %rcx
addq $0x8, %rcx
movq %rax, (%rcx)
movsd 0x8(%rsp), %xmm2
movsd %xmm2, 0x20(%r15)
movq %r14, 0x28(%r15)
xorl %eax, %eax
movq %rax, 0x30(%r15)
movl %eax, 0x38(%r15)
movsd %xmm0, 0x40(%r15)
movq %rax, 0x48(%r15)
movl %eax, 0x50(%r15)
movsd %xmm1, 0x58(%r15)
movq %rbx, %rdi
movq %r15, %rsi
addq $0x10, %rsp
popq %rbx
popq %r14
popq %r15
jmp 0x972a
movq %rax, %rbx
movl $0x60, %esi
movq %r15, %rdi
callq 0x3170
movq %rbx, %rdi
callq 0x3280
nop
// File: /workspace/github_cpp_makefile_star2_O1/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
testq %rax, %rax
je 0x97ca
movsd 0xb0(%r14), %xmm1
ucomisd %xmm1, %xmm0
jae 0x97af
testq %rax, %rax
jne 0x9777
ucomisd 0x3c5b(%rip), %xmm0     # 0xd3c0
jne 0x9777
jp 0x9777
movsd 0x3c4f(%rip), %xmm2     # 0xd3c0
ucomisd %xmm1, %xmm2
ja 0x97ef
cmpl $0x3, 0x38(%rbx)
jne 0x978d
cmpq $0x0, 0xc8(%r14)
jne 0x978d
ucomisd %xmm0, %xmm1
ja 0x97ef
movl 0x48(%rbx), %eax
xorps %xmm0, %xmm0
cvtsi2sd %eax, %xmm0
ucomisd 0x40(%rbx), %xmm0
jae 0x9830
cmpb $0x0, 0x61(%r14)
je 0x9801
testl %eax, %eax
jg 0x980c
jmp 0x9819
movsd 0x3c09(%rip), %xmm2     # 0xd3c0
ucomisd %xmm1, %xmm2
jbe 0x9758
movsd 0x20(%rax), %xmm2
ucomisd %xmm0, %xmm2
ja 0x97ef
jmp 0x9758
movsd 0xb0(%r14), %xmm1
ucomisd %xmm1, %xmm0
jb 0x9749
movsd 0x3bdb(%rip), %xmm2     # 0xd3c0
ucomisd %xmm1, %xmm2
jbe 0x9749
movq %r14, %rdi
movq %rbx, %rsi
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x998e
testl %eax, %eax
jle 0x9819
cmpb $0x0, 0x60(%r14)
je 0x9819
movq %r14, %rdi
callq 0x8b0a
movsd %xmm0, 0x40(%rbx)
movq %r14, %rdi
movq %rbx, %rsi
callq 0xa7f8
testb %al, %al
je 0x9830
addq $0x8, %rsp
popq %rbx
popq %r14
retq
movq %r14, %rdi
movq %rbx, %rsi
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0xaaac
// File: /workspace/github_cpp_makefile_star2_O1/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 0x8770(%rip), %rdi      # 0x11fd0
callq 0x3230
movq %rax, %r15
leaq 0x3bb4(%rip), %rsi      # 0xd423
movl $0x12, %edx
movq %rax, %rdi
callq 0x31a0
movl 0x20(%r14), %esi
movq %r15, %rdi
callq 0x3270
movq %rax, %r15
leaq 0x3b85(%rip), %rsi      # 0xd417
movl $0x8, %edx
movq %rax, %rdi
callq 0x31a0
movq 0x28(%r14), %rsi
movq 0x30(%r14), %rdx
movq %r15, %rdi
callq 0x31a0
leaq 0x3b6a(%rip), %rsi      # 0xd420
movl $0x2, %edx
movq %rax, %rdi
callq 0x31a0
movl $0x60, %edi
callq 0x3160
movq %rax, %r15
movl 0x20(%r14), %edi
callq 0x71d2
movsd %xmm0, 0x8(%rsp)
movq %rbx, %rdi
callq 0x8b0a
movsd 0xb0(%rbx), %xmm1
leaq 0x8892(%rip), %rax      # 0x12188
movq (%rax), %rcx
movq %rcx, (%r15)
incq %rcx
movq %rcx, (%rax)
xorps %xmm2, %xmm2
movups %xmm2, 0x8(%r15)
movq $0x0, 0x18(%r15)
leaq 0x8887(%rip), %rax      # 0x121a0
movq (%rax), %rax
testq %rax, %rax
je 0x992b
movq %r15, %rcx
addq $0x8, %rcx
movq %rax, (%rcx)
movsd 0x8(%rsp), %xmm2
movsd %xmm2, 0x20(%r15)
movq %r14, 0x28(%r15)
xorl %eax, %eax
movq %rax, 0x30(%r15)
movl $0x5, 0x38(%r15)
movsd %xmm0, 0x40(%r15)
movq %rax, 0x48(%r15)
movl $0x0, 0x50(%r15)
movsd %xmm1, 0x58(%r15)
movq %rbx, %rdi
movq %r15, %rsi
addq $0x10, %rsp
popq %rbx
popq %r14
popq %r15
jmp 0x998e
movq %rax, %rbx
movl $0x60, %esi
movq %r15, %rdi
callq 0x3170
movq %rbx, %rdi
callq 0x3280
nop
// File: /workspace/github_cpp_makefile_star2_O1/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, %r14
leaq 0x28(%rsi), %rdi
leaq 0x3060(%rip), %rsi      # 0xd470
callq 0x3050
movl %eax, %ebp
movq 0x7bb2(%rip), %r15      # 0x11fd0
leaq 0x2dfd(%rip), %rsi      # 0xd222
movl $0x5, %edx
movq %r15, %rdi
callq 0x31a0
movsd 0xb0(%r14), %xmm0
movq %r15, %rdi
callq 0x3230
movq %rax, %r14
leaq 0x3083(%rip), %rsi      # 0xd4d0
movl $0x17, %edx
movq %rax, %rdi
callq 0x31a0
movl 0x20(%rbx), %esi
movq %r14, %rdi
callq 0x3270
movq %rax, %r14
testl %ebp, %ebp
je 0xa4a1
leaq 0x2faa(%rip), %rsi      # 0xd41d
movl $0x2, %edx
movq %r14, %rdi
callq 0x31a0
movq 0x28(%rbx), %rsi
movq 0x30(%rbx), %rdx
movq %r14, %rdi
callq 0x31a0
leaq 0x2fd8(%rip), %rsi      # 0xd46f
movl $0x1, %edx
movq %rax, %rdi
jmp 0xa4b0
leaq 0x3040(%rip), %rsi      # 0xd4e8
movl $0x8, %edx
movq %r14, %rdi
callq 0x31a0
testq %rbx, %rbx
je 0xa4e9
movq 0x28(%rbx), %rdi
leaq 0x38(%rbx), %rax
cmpq %rax, %rdi
je 0xa4d2
movq (%rax), %rsi
incq %rsi
callq 0x3170
movl $0x48, %esi
movq %rbx, %rdi
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
jmp 0x3170
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O1/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 %r15
pushq %r14
pushq %rbx
subq $0x10, %rsp
movq %rsi, %r15
movq %rdi, %rbx
movl $0x60, %edi
callq 0x3160
movq %rax, %r14
movsd 0x20(%r15), %xmm0
movsd %xmm0, 0x8(%rsp)
movq %rbx, %rdi
callq 0x8b0a
leaq 0x70e7(%rip), %rax      # 0x12188
movq (%rax), %rcx
movq %rcx, (%r14)
incq %rcx
movq %rcx, (%rax)
xorps %xmm1, %xmm1
movups %xmm1, 0x8(%r14)
movq $0x0, 0x18(%r14)
leaq 0x70dc(%rip), %rax      # 0x121a0
movq (%rax), %rax
testq %rax, %rax
je 0xb0d6
movq %r14, %rcx
addq $0x8, %rcx
movq %rax, (%rcx)
movsd 0x8(%rsp), %xmm1
movsd %xmm1, 0x20(%r14)
xorl %eax, %eax
movq %rax, 0x28(%r14)
movq %r15, 0x30(%r14)
movl $0x3, 0x38(%r14)
movsd %xmm0, 0x40(%r14)
movq %rax, 0x48(%r14)
movl $0x0, 0x50(%r14)
movq %rax, 0x58(%r14)
movq %rbx, %rdi
movq %r14, %rsi
addq $0x10, %rsp
popq %rbx
popq %r14
popq %r15
jmp 0x972a
// File: /workspace/github_cpp_makefile_star2_O1/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 %r15
pushq %r14
pushq %rbx
movq %rsi, %r14
movq %rdi, %r15
movl $0x28, %edi
callq 0x3160
movq %rax, %rbx
movq 0xc0(%r15), %r15
leaq 0x64ba(%rip), %rax      # 0x12188
movq (%rax), %rcx
movq %rcx, (%rbx)
incq %rcx
movq %rcx, (%rax)
xorps %xmm0, %xmm0
movups %xmm0, 0x8(%rbx)
movq $0x0, 0x18(%rbx)
leaq 0x64b0(%rip), %rax      # 0x121a0
movq (%rax), %rax
testq %rax, %rax
je 0xbcff
leaq 0x8(%rbx), %rcx
movq %rax, (%rcx)
testq %rax, %rax
sete %cl
testq %r15, %r15
sete %dl
orb %cl, %dl
movups %xmm0, 0x10(%rbx)
movq $0x0, 0x20(%rbx)
jne 0xbd5c
cmpq %rax, 0x18(%r15)
jne 0xbd5c
movq %r15, 0x10(%rbx)
movq 0x30(%r15), %rax
movq %rax, 0x20(%rbx)
movl $0x18, %edi
callq 0x3160
xorps %xmm0, %xmm0
movups %xmm0, (%rax)
movq %rbx, 0x10(%rax)
movq 0x40(%r15), %rcx
movq 0x8(%rcx), %rdx
testq %rdx, %rdx
je 0xbd51
movq %rax, (%rdx)
movq %rdx, 0x8(%rax)
movq %rcx, (%rax)
movq %rax, 0x8(%rcx)
movq 0x10(%rbx), %rax
movq 0x20(%rbx), %rcx
movq 0x8(%rcx), %r15
movq 0x28(%r14), %rcx
movq 0x20(%rcx), %rcx
movq 0x8(%rcx), %r14
testq %rax, %rax
je 0xbdc3
movq 0x40(%rax), %rdi
movq %rdi, %rax
movq 0x8(%rdi), %rdi
testq %rdi, %rdi
je 0xbdab
cmpq %rbx, 0x10(%rdi)
jne 0xbd7d
movq 0x8(%rdi), %rcx
testq %rcx, %rcx
je 0xbd9b
movq %rax, (%rcx)
movq %rcx, 0x8(%rax)
movl $0x18, %esi
callq 0x3170
jmp 0xbdc3
movq 0x621e(%rip), %rdi      # 0x11fd0
leaq 0x147f(%rip), %rsi      # 0xd238
movl $0x21, %edx
callq 0x31a0
movl $0x28, %esi
movq %rbx, %rdi
callq 0x3170
cmpq %r14, %r15
sete %al
popq %rbx
popq %r14
popq %r15
retq
movq %rax, %r14
movl $0x28, %esi
movq %rbx, %rdi
callq 0x3170
movq %r14, %rdi
callq 0x3280
movq %rax, %rdi
callq 0x50a9