LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_cpp_makefile_star2_O3/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 0xc92c(%rip), %rax      # 0x11190
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 0x2160
xorps %xmm0, %xmm0
movups %xmm0, (%rax)
movq %rax, 0x38(%rbx)
movl $0x10, %edi
callq 0x2160
xorps %xmm0, %xmm0
movups %xmm0, (%rax)
movq %rax, 0x20(%rbx)
movl $0x18, %edi
callq 0x2160
xorps %xmm0, %xmm0
movups %xmm0, (%rax)
movq %r14, 0x10(%rax)
movq %rax, 0x40(%rbx)
movq 0x18(%rbx), %rax
testq %rax, %rax
je 0x4990
movq 0x30(%rax), %r14
testq %r14, %r14
je 0x4990
movq (%r14), %rdx
testq %rdx, %rdx
je 0x4909
xorl %ecx, %ecx
movl $0x1, %esi
cmpq %rbx, (%rdx)
movq 0x8(%rdx), %rdi
cmovel %esi, %ecx
movq %rdi, %rdx
testq %rdi, %rdi
jne 0x48f3
testl %ecx, %ecx
jne 0x493a
movl $0x10, %edi
callq 0x2160
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)
movq 0x18(%rbx), %rax
movq 0x38(%rax), %r14
movq (%r14), %rcx
testq %rcx, %rcx
je 0x4963
xorl %eax, %eax
movl $0x1, %edx
cmpq %rbx, (%rcx)
movq 0x8(%rcx), %rsi
cmovel %edx, %eax
movq %rsi, %rcx
testq %rsi, %rsi
jne 0x494d
testl %eax, %eax
jne 0x4990
movl $0x10, %edi
callq 0x2160
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)
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_cpp_makefile_star2_O3/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 0x49b3
pushq %rax
movl $0x38, %esi
movq %rdx, %rdi
callq 0x2170
xorl %eax, %eax
addq $0x8, %rsp
retq
movl $0x1, %eax
testq %rdx, %rdx
je 0x49f8
movq 0x8(%rdi), %rcx
movq %rcx, 0x8(%rdx)
movq 0x28(%rdx), %rcx
testq %rcx, %rcx
je 0x49d6
movq $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)
movq $0x0, 0x30(%rdx)
retq
nop
// File: /workspace/github_cpp_makefile_star2_O3/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 0x4ab2
movq 0x18(%rdi), %r8
movq 0x38(%rdi), %rdx
movq (%rdx), %rcx
cmpq 0x20(%r8), %rsi
je 0x4a5f
testq %rcx, %rcx
je 0x4ab2
movq 0x30(%rcx), %rax
movq %rax, (%rdx)
testq %rax, %rax
jne 0x4a37
movq $0x0, 0x8(%rdx)
movq 0x38(%rsi), %rax
movq 0x8(%rax), %rdx
leaq 0x30(%rdx), %rsi
testq %rdx, %rdx
cmoveq %rax, %rsi
movq %rcx, (%rsi)
movq %rcx, 0x8(%rax)
movq $0x0, 0x30(%rcx)
movl $0x1, %eax
retq
testq %rcx, %rcx
je 0x4ab2
movq 0x8(%rdi), %rsi
movq 0x30(%rcx), %r8
movq %r8, (%rdx)
testq %r8, %r8
jne 0x4a7c
movq $0x0, 0x8(%rdx)
movq %rsi, 0x10(%rcx)
movq 0x28(%rdi), %rdx
movq 0x38(%rdx), %rdx
movq 0x8(%rdx), %r8
leaq 0x30(%r8), %r9
testq %r8, %r8
cmoveq %rdx, %r9
movq %rcx, (%r9)
movq %rcx, 0x8(%rdx)
movq $0x0, 0x30(%rcx)
movq 0x38(%rdi), %rdx
movq (%rdx), %rcx
testq %rcx, %rcx
jne 0x4a68
retq
nop
// File: /workspace/github_cpp_makefile_star2_O3/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 0x564a(%rip), %xmm0     # 0xc3b8
movsd %xmm0, (%rsp)
movl $0x38, %edi
callq 0x2160
movq %rax, %r14
movsd 0x8(%rsp), %xmm0
ucomisd (%rsp), %xmm0
jne 0x6da3
jp 0x6da3
movq %r14, %rdi
movq %r15, %rsi
callq 0x3d6c
movq %r14, 0xd8(%rbx)
jmp 0x6db5
movq %r14, %rdi
movq %r15, %rsi
callq 0x3d6c
movq %r14, 0xe0(%rbx)
movl $0x28, %edi
callq 0x2160
movq %rax, %r15
leaq 0xa3bf(%rip), %rax      # 0x11188
movq (%rax), %rcx
movq %rcx, (%r15)
incq %rcx
movq %rcx, (%rax)
xorpd %xmm0, %xmm0
movupd %xmm0, 0x8(%r15)
movq $0x0, 0x18(%r15)
leaq 0xa3b2(%rip), %rax      # 0x111a0
movq (%rax), %rax
testq %rax, %rax
je 0x6e00
movq %r15, %rcx
addq $0x8, %rcx
movq %rax, (%rcx)
movl $0x5, 0x20(%r15)
movq 0x28(%r14), %r14
movl $0x38, %edi
callq 0x2160
leaq 0xa38b(%rip), %rcx      # 0x111a8
movq (%rcx), %rdx
movq %rdx, (%rax)
incq %rdx
movq %rdx, (%rcx)
xorpd %xmm0, %xmm0
movupd %xmm0, 0x8(%rax)
leaq 0x47(%rip), %rcx        # 0x6e80
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 0x6e68
movq %rax, %rbx
movl $0x38, %esi
movq %r14, %rdi
callq 0x2170
movq %rbx, %rdi
callq 0x2280
// File: /workspace/github_cpp_makefile_star2_O3/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 0x6eec
movq %rsi, %r14
decl %eax
movl %eax, 0x20(%rsi)
movl $0x38, %edi
callq 0x2160
leaq 0xa301(%rip), %rcx      # 0x111a8
movq (%rcx), %rdx
movq %rdx, (%rax)
incq %rdx
movq %rdx, (%rcx)
xorps %xmm0, %xmm0
movups %xmm0, 0x8(%rax)
leaq -0x41(%rip), %rcx       # 0x6e80
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 0x7364
movq %rbx, %rdi
xorl %esi, %esi
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x7b42
nop
// File: /workspace/github_cpp_makefile_star2_O3/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 0x6f91
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 0x6f87
movq (%r14), %rax
movq 0x28(%rax), %r15
testq %r15, %r15
je 0x6f57
movq %r15, %rdi
callq 0x4acc
movl $0x48, %esi
movq %r15, %rdi
callq 0x2170
movq (%r14), %rdi
movl $0x38, %esi
callq 0x2170
movq $0x0, (%r14)
testb %bpl, %bpl
je 0x6f83
movb $0x0, 0x61(%rbx)
jmp 0x6f87
movb $0x0, 0x60(%rbx)
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O3/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 0x7aa7
movq 0xd0(%rdi), %rax
testq %rax, %rax
je 0x7aa7
movsd 0x20(%rax), %xmm1
movsd 0xb0(%rdi), %xmm0
ucomisd %xmm0, %xmm1
jne 0x7aef
jp 0x7aef
cmpb $0x1, 0x60(%rdi)
jne 0x7ace
movq 0xc8(%rdi), %rax
testq %rax, %rax
je 0x7ace
movsd 0x20(%rax), %xmm1
movsd 0xb0(%rdi), %xmm0
ucomisd %xmm0, %xmm1
jne 0x7aef
jp 0x7aef
movq 0xd0(%rdi), %rax
testq %rax, %rax
je 0x7af5
movsd 0x20(%rax), %xmm1
movsd 0xb0(%rdi), %xmm0
ucomisd %xmm0, %xmm1
jne 0x7aef
jnp 0x7af5
subsd %xmm1, %xmm0
jmp 0x7b1e
movq 0xc8(%rdi), %rax
xorpd %xmm1, %xmm1
testq %rax, %rax
je 0x7b3c
movsd 0x20(%rax), %xmm2
movsd 0xb0(%rdi), %xmm0
ucomisd %xmm0, %xmm2
jne 0x7b1a
jnp 0x7b3c
subsd %xmm2, %xmm0
pushq %rax
andpd 0x48b9(%rip), %xmm0     # 0xc3e0
callq 0x2120
movapd %xmm0, %xmm1
mulsd 0x4898(%rip), %xmm1     # 0xc3d0
addq $0x8, %rsp
movapd %xmm1, %xmm0
retq
nop
// File: /workspace/github_cpp_makefile_star2_O3/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 0x8982(%rip), %rdi      # 0x10fd0
callq 0x2230
movq %rax, %r15
leaq 0x3dab(%rip), %rsi      # 0xc408
movl $0xe, %edx
movq %rax, %rdi
callq 0x21a0
movl 0x20(%r14), %esi
movq %r15, %rdi
callq 0x2270
movq %rax, %r15
leaq 0x3d97(%rip), %rsi      # 0xc417
movl $0x8, %edx
movq %rax, %rdi
callq 0x21a0
movq 0x28(%r14), %rsi
movq 0x30(%r14), %rdx
movq %r15, %rdi
callq 0x21a0
leaq 0x3d7c(%rip), %rsi      # 0xc420
movl $0x2, %edx
movq %rax, %rdi
callq 0x21a0
movl $0x60, %edi
callq 0x2160
movq %rax, %r15
movl 0x20(%r14), %edi
callq 0x60ea
movsd %xmm0, 0x8(%rsp)
movq %rbx, %rdi
callq 0x7a80
movsd 0xb0(%rbx), %xmm1
leaq 0x8aa4(%rip), %rax      # 0x11188
movq (%rax), %rcx
movq %rcx, (%r15)
incq %rcx
movq %rcx, (%rax)
xorps %xmm2, %xmm2
movups %xmm2, 0x8(%r15)
movq $0x0, 0x18(%r15)
leaq 0x8a99(%rip), %rax      # 0x111a0
movq (%rax), %rax
testq %rax, %rax
je 0x8719
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 0x8774
movq %rax, %rbx
movl $0x60, %esi
movq %r15, %rdi
callq 0x2170
movq %rbx, %rdi
callq 0x2280
nop
// File: /workspace/github_cpp_makefile_star2_O3/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 0x880b
ucomisd %xmm1, %xmm0
jae 0x87be
testq %rax, %rax
jne 0x87d7
ucomisd 0x3c16(%rip), %xmm0     # 0xc3c0
jne 0x87d7
jp 0x87d7
movsd 0x3c0a(%rip), %xmm2     # 0xc3c0
ucomisd %xmm1, %xmm2
ja 0x8823
jmp 0x87d7
movsd 0x3bfa(%rip), %xmm2     # 0xc3c0
ucomisd %xmm1, %xmm2
jbe 0x87d7
movsd 0x20(%rax), %xmm2
ucomisd %xmm0, %xmm2
ja 0x8823
cmpl $0x3, 0x38(%rbx)
jne 0x87ed
cmpq $0x0, 0xc8(%r14)
jne 0x87ed
ucomisd %xmm0, %xmm1
ja 0x8823
movl 0x48(%rbx), %eax
xorps %xmm0, %xmm0
cvtsi2sd %eax, %xmm0
ucomisd 0x40(%rbx), %xmm0
jae 0x8864
cmpb $0x0, 0x61(%r14)
je 0x8835
testl %eax, %eax
jg 0x8840
jmp 0x884d
ucomisd %xmm1, %xmm0
jb 0x8797
movsd 0x3ba7(%rip), %xmm2     # 0xc3c0
ucomisd %xmm1, %xmm2
jbe 0x8797
movq %r14, %rdi
movq %rbx, %rsi
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x89c2
testl %eax, %eax
jle 0x884d
cmpb $0x0, 0x60(%r14)
je 0x884d
movq %r14, %rdi
callq 0x7a80
movsd %xmm0, 0x40(%rbx)
movq %r14, %rdi
movq %rbx, %rsi
callq 0x9864
testb %al, %al
je 0x8864
addq $0x8, %rsp
popq %rbx
popq %r14
retq
movq %r14, %rdi
movq %rbx, %rsi
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x9b32
// File: /workspace/github_cpp_makefile_star2_O3/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 0x873c(%rip), %rdi      # 0x10fd0
callq 0x2230
movq %rax, %r15
leaq 0x3b80(%rip), %rsi      # 0xc423
movl $0x12, %edx
movq %rax, %rdi
callq 0x21a0
movl 0x20(%r14), %esi
movq %r15, %rdi
callq 0x2270
movq %rax, %r15
leaq 0x3b51(%rip), %rsi      # 0xc417
movl $0x8, %edx
movq %rax, %rdi
callq 0x21a0
movq 0x28(%r14), %rsi
movq 0x30(%r14), %rdx
movq %r15, %rdi
callq 0x21a0
leaq 0x3b36(%rip), %rsi      # 0xc420
movl $0x2, %edx
movq %rax, %rdi
callq 0x21a0
movl $0x60, %edi
callq 0x2160
movq %rax, %r15
movl 0x20(%r14), %edi
callq 0x60ea
movsd %xmm0, 0x8(%rsp)
movq %rbx, %rdi
callq 0x7a80
movsd 0xb0(%rbx), %xmm1
leaq 0x885e(%rip), %rax      # 0x11188
movq (%rax), %rcx
movq %rcx, (%r15)
incq %rcx
movq %rcx, (%rax)
xorps %xmm2, %xmm2
movups %xmm2, 0x8(%r15)
movq $0x0, 0x18(%r15)
leaq 0x8853(%rip), %rax      # 0x111a0
movq (%rax), %rax
testq %rax, %rax
je 0x895f
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 0x89c2
movq %rax, %rbx
movl $0x60, %esi
movq %r15, %rdi
callq 0x2170
movq %rbx, %rdi
callq 0x2280
nop
// File: /workspace/github_cpp_makefile_star2_O3/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 0x2fe2(%rip), %rsi      # 0xc470
callq 0x2050
movl %eax, %ebp
movq 0x7b34(%rip), %r15      # 0x10fd0
leaq 0x2d7f(%rip), %rsi      # 0xc222
movl $0x5, %edx
movq %r15, %rdi
callq 0x21a0
movsd 0xb0(%r14), %xmm0
movq %r15, %rdi
callq 0x2230
movq %rax, %r14
leaq 0x3005(%rip), %rsi      # 0xc4d0
movl $0x17, %edx
movq %rax, %rdi
callq 0x21a0
movl 0x20(%rbx), %esi
movq %r14, %rdi
callq 0x2270
movq %rax, %r14
testl %ebp, %ebp
je 0x951f
leaq 0x2f2c(%rip), %rsi      # 0xc41d
movl $0x2, %edx
movq %r14, %rdi
callq 0x21a0
movq 0x28(%rbx), %rsi
movq 0x30(%rbx), %rdx
movq %r14, %rdi
callq 0x21a0
leaq 0x2f5a(%rip), %rsi      # 0xc46f
movl $0x1, %edx
movq %rax, %rdi
jmp 0x952e
leaq 0x2fc2(%rip), %rsi      # 0xc4e8
movl $0x8, %edx
movq %r14, %rdi
callq 0x21a0
movq 0x28(%rbx), %rdi
leaq 0x38(%rbx), %rax
cmpq %rax, %rdi
je 0x954b
movq (%rax), %rsi
incq %rsi
callq 0x2170
movl $0x48, %esi
movq %rbx, %rdi
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
jmp 0x2170
// File: /workspace/github_cpp_makefile_star2_O3/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 0x2160
movq %rax, %r14
movsd 0x20(%r15), %xmm0
movsd %xmm0, 0x8(%rsp)
movq %rbx, %rdi
callq 0x7a80
leaq 0x702f(%rip), %rax      # 0x11188
movq (%rax), %rcx
movq %rcx, (%r14)
incq %rcx
movq %rcx, (%rax)
xorps %xmm1, %xmm1
movups %xmm1, 0x8(%r14)
movq $0x0, 0x18(%r14)
leaq 0x7024(%rip), %rax      # 0x111a0
movq (%rax), %rax
testq %rax, %rax
je 0xa18e
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 0x8774
// File: /workspace/github_cpp_makefile_star2_O3/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 %r12
pushq %rbx
movq %rsi, %r14
movq %rdi, %r15
movl $0x28, %edi
callq 0x2160
movq %rax, %rbx
movq 0xc0(%r15), %r12
leaq 0x6479(%rip), %rax      # 0x11188
movq (%rax), %rcx
movq %rcx, (%rbx)
incq %rcx
movq %rcx, (%rax)
xorps %xmm0, %xmm0
movups %xmm0, 0x8(%rbx)
movq $0x0, 0x18(%rbx)
leaq 0x646f(%rip), %rax      # 0x111a0
movq (%rax), %rax
testq %rax, %rax
je 0xaddb
movq %rax, 0x8(%rbx)
movups %xmm0, 0x10(%rbx)
movq $0x0, 0x20(%rbx)
testq %r12, %r12
je 0xade7
cmpq %rax, 0x18(%r12)
jne 0xade7
movq %r12, 0x10(%rbx)
movq 0x30(%r12), %r15
movq %r15, 0x20(%rbx)
movl $0x18, %edi
callq 0x2160
movq %rbx, 0x10(%rax)
movq 0x40(%r12), %rcx
movq 0x8(%rcx), %rdx
testq %rdx, %rdx
je 0xad8d
movq %rax, (%rdx)
movq %rdx, 0x8(%rax)
movq %rcx, (%rax)
movq %rax, 0x8(%rcx)
movq 0x8(%r15), %r15
movq 0x28(%r14), %rax
movq 0x20(%rax), %rax
movq 0x8(%rax), %r14
movq 0x40(%r12), %rdi
movq %rdi, %rax
movq 0x8(%rdi), %rdi
testq %rdi, %rdi
je 0xae1a
cmpq %rbx, 0x10(%rdi)
jne 0xadad
movq 0x8(%rdi), %rcx
testq %rcx, %rcx
je 0xadcb
movq %rax, (%rcx)
movq %rcx, 0x8(%rax)
movl $0x18, %esi
callq 0x2170
jmp 0xadfb
movups %xmm0, 0x10(%rbx)
movq $0x0, 0x20(%rbx)
movq 0x8, %r15
movq 0x28(%r14), %rax
movq 0x20(%rax), %rax
movq 0x8(%rax), %r14
cmpq %r14, %r15
sete %bpl
movl $0x28, %esi
movq %rbx, %rdi
callq 0x2170
movl %ebp, %eax
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
movq 0x61af(%rip), %rdi      # 0x10fd0
leaq 0x1410(%rip), %rsi      # 0xc238
movl $0x21, %edx
callq 0x21a0
jmp 0xadfb
movq %rax, %rdi
callq 0x4071
movq %rax, %r14
movl $0x28, %esi
movq %rbx, %rdi
callq 0x2170
movq %r14, %rdi
callq 0x2280
// File: /workspace/github_cpp_makefile_star2_O3/kiudee[P]VAHD-Projekt/Node.cpp
// Function: Node::_DebugRouteFromLeftToRight(NumObj*)
Action Node::_DebugRouteFromLeftToRight(NumObj *numo)
{
    std::cout << num << "<-_DebugRouteFromLeftToRight() debugid?" << numo->num << " real?" << isReal << "\n";
    if (right != NULL) {
        right->out->call(Node::_DebugRouteFromLeftToRight, numo);
    } else {
        std::cout << "END DEBUG\n";
    }
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rsi, %r14
movq %rdi, %rbx
movsd 0xb0(%rdi), %xmm0
movq 0x6162(%rip), %rdi      # 0x10fd0
callq 0x2230
movq %rax, %r15
leaq 0x16b5(%rip), %rsi      # 0xc532
movl $0x27, %edx
movq %rax, %rdi
callq 0x21a0
movl 0x20(%r14), %esi
movq %r15, %rdi
callq 0x2270
movq %rax, %r15
leaq 0x16e3(%rip), %rsi      # 0xc583
movl $0x6, %edx
movq %rax, %rdi
callq 0x21a0
movzbl 0xb8(%rbx), %esi
movq %r15, %rdi
callq 0x2260
leaq 0x15ac(%rip), %rsi      # 0xc46f
movl $0x1, %edx
movq %rax, %rdi
callq 0x21a0
movq 0xd0(%rbx), %rax
testq %rax, %rax
je 0xaf34
movq 0x28(%rax), %r15
movl $0x38, %edi
callq 0x2160
leaq 0x62b7(%rip), %rcx      # 0x111a8
movq (%rcx), %rdx
movq %rdx, (%rax)
incq %rdx
movq %rdx, (%rcx)
xorps %xmm0, %xmm0
movups %xmm0, 0x8(%rax)
leaq -0xb7(%rip), %rcx       # 0xae54
movq %rcx, 0x18(%rax)
xorl %ecx, %ecx
movq %rcx, 0x20(%rax)
movq %r14, 0x28(%rax)
movq %rcx, 0x30(%rax)
movq (%r15), %rcx
movq 0x8(%rcx), %rcx
movq %r15, %rdi
movq %rbx, %rsi
movq %rax, %rdx
popq %rbx
popq %r14
popq %r15
jmpq *%rcx
movq 0x6095(%rip), %rdi      # 0x10fd0
leaq 0x1618(%rip), %rsi      # 0xc55a
movl $0xa, %edx
popq %rbx
popq %r14
popq %r15
jmp 0x21a0
nop
// File: /workspace/github_cpp_makefile_star2_O3/kiudee[P]VAHD-Projekt/Node.cpp
// Function: Node::_DebugRouteFromRightToLeft()
Action Node::_DebugRouteFromRightToLeft()
{
    std::cout << num << "<-_DebugRouteFromRightToLeft() real?" << isReal << "\n";
    if (left != NULL) {
        left->out->call(Node::_DebugRouteFromRightToLeft, NONE);
    } else {
        std::cout << "END DEBUG\n";
    }
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
movsd 0xb0(%rdi), %xmm0
movq 0x6068(%rip), %rdi      # 0x10fd0
callq 0x2230
movq %rax, %r14
leaq 0x15ee(%rip), %rsi      # 0xc565
movl $0x24, %edx
movq %rax, %rdi
callq 0x21a0
movzbl 0xb8(%rbx), %esi
movq %r14, %rdi
callq 0x2260
leaq 0x14d5(%rip), %rsi      # 0xc46f
movl $0x1, %edx
movq %rax, %rdi
callq 0x21a0
movq 0xc8(%rbx), %rax
testq %rax, %rax
je 0xb01a
movq 0x28(%rax), %r14
movl $0x38, %edi
callq 0x2160
leaq 0x61e0(%rip), %rcx      # 0x111a8
movq (%rcx), %rdx
movq %rdx, (%rax)
incq %rdx
movq %rdx, (%rcx)
xorps %xmm0, %xmm0
movups %xmm0, 0x8(%rax)
leaq -0x90(%rip), %rcx       # 0xaf52
movq %rcx, 0x18(%rax)
xorl %ecx, %ecx
movq %rcx, 0x20(%rax)
leaq 0x61bd(%rip), %rdx      # 0x111b0
movq (%rdx), %rsi
movq %rsi, 0x28(%rax)
movq %rcx, 0x30(%rax)
movq %rcx, (%rdx)
movq (%r14), %rcx
movq 0x8(%rcx), %rcx
movq %r14, %rdi
movq %rbx, %rsi
movq %rax, %rdx
addq $0x8, %rsp
popq %rbx
popq %r14
jmpq *%rcx
movq 0x5faf(%rip), %rdi      # 0x10fd0
leaq 0x1532(%rip), %rsi      # 0xc55a
movl $0xa, %edx
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x21a0
nop
// File: /workspace/github_cpp_makefile_star2_O3/mirkat1206[P]Quine-McCluskey-Petrick-Method/main.cpp
// Function: Output(std::basic_ofstream<char, std::char_traits<char>>&, Quine_McCluskey&, Petrick_Method&)
void Output(ofstream &fout, Quine_McCluskey &QM, Petrick_Method &PM) {
	QM.HW1_Print_Prime_Impli();
	QM.HW1_Print_Prime_Impli(fout);
	PM.HW1_Print_Minimum_Cover();	
	PM.HW1_Print_Minimum_Cover(fout);	
	cout<< endl;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rdx, %rbx
movq %rsi, %r14
movq %rdi, %r15
movq %rsi, %rdi
callq 0x391c
movq %r14, %rdi
movq %r15, %rsi
callq 0x3a58
movq %rbx, %rdi
callq 0x6992
movq %rbx, %rdi
movq %r15, %rsi
callq 0x6b16
movq 0xa400(%rip), %rbx      # 0xcfd0
movq (%rbx), %rax
movq -0x18(%rax), %rdi
addq %rbx, %rdi
movl $0xa, %esi
callq 0x21a0
movsbl %al, %esi
movq %rbx, %rdi
callq 0x2030
movq %rax, %rdi
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
jmp 0x2100
nop
// File: /workspace/github_cpp_makefile_star2_O3/mirkat1206[P]Quine-McCluskey-Petrick-Method/Quine_McCluskey.cpp
// Function: Quine_McCluskey::Solve[abi:cxx11]()
vector<string> Quine_McCluskey::Solve() {
	Init_Impli();
	sort( Impli.begin() , Impli.end() );
	sort( Impli.begin() , Impli.end() , sort_by_num_of_1 );

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

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rsi, %r14
movq %rdi, %rbx
movq %rsi, %rdi
callq 0x2f82
movq 0x50(%r14), %r12
movq 0x58(%r14), %r15
cmpq %r15, %r12
je 0x2f0e
movq %r15, %rax
subq %r12, %rax
sarq $0x5, %rax
bsrq %rax, %rdx
xorl $0x3f, %edx
addl %edx, %edx
xorq $0x7e, %rdx
movq %r12, %rdi
movq %r15, %rsi
callq 0x3eda
movq %r12, %rdi
movq %r15, %rsi
callq 0x3fae
movq 0x50(%r14), %r12
movq 0x58(%r14), %r15
cmpq %r15, %r12
je 0x2f61
movq %r15, %rax
subq %r12, %rax
sarq $0x5, %rax
bsrq %rax, %rdx
xorl $0x3f, %edx
addl %edx, %edx
xorq $0x7e, %rdx
leaq -0x221(%rip), %r13      # 0x2d10
movq %r12, %rdi
movq %r15, %rsi
movq %r13, %rcx
callq 0x470a
movq %r12, %rdi
movq %r15, %rsi
movq %r13, %rdx
callq 0x47fc
movq 0x50(%r14), %rax
cmpq 0x58(%r14), %rax
je 0x2f61
movq %r14, %rdi
callq 0x30a8
jmp 0x2f4d
addq $0x68, %r14
movq %rbx, %rdi
movq %r14, %rsi
callq 0x3b88
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O3/mirkat1206[P]Quine-McCluskey-Petrick-Method/Quine_McCluskey.cpp
// Function: Quine_McCluskey::Init_Impli()
void Quine_McCluskey::Init_Impli() {
	int size;	
	// on set
	size = On_Set.size() ;
	for( int i=0 ; i<size ; i++ ) {
		Impli.push_back( Dec2Bin(On_Set[i]) ) ;
		s_On_Set.push_back( Impli.back() );
	}
	// don't care set
	size = DC_Set.size() ;
	for( int i=0 ; i<size ; i++ )
		Impli.push_back( Dec2Bin(DC_Set[i]) ) ;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x28, %rsp
movq %rdi, %rbx
movq 0x10(%rdi), %r13
subq 0x8(%rdi), %r13
shrq $0x2, %r13
testl %r13d, %r13d
jle 0x3011
leaq 0x50(%rbx), %rax
movq %rax, -0x50(%rbp)
leaq 0x38(%rbx), %r15
andl $0x7fffffff, %r13d      # imm = 0x7FFFFFFF
xorl %r14d, %r14d
leaq -0x48(%rbp), %r12
movq 0x8(%rbx), %rax
movl (%rax,%r14,4), %edx
movq %r12, %rdi
movq %rbx, %rsi
callq 0x36b6
movq -0x50(%rbp), %rdi
movq %r12, %rsi
callq 0x5a4e
movq -0x48(%rbp), %rdi
leaq -0x38(%rbp), %rax
cmpq %rax, %rdi
je 0x2ff9
movq -0x38(%rbp), %rsi
incq %rsi
callq 0x21d0
movq 0x58(%rbx), %rsi
addq $-0x20, %rsi
movq %r15, %rdi
callq 0x3c70
incq %r14
cmpq %r14, %r13
jne 0x2fc1
movq 0x28(%rbx), %r12
subq 0x20(%rbx), %r12
shrq $0x2, %r12
testl %r12d, %r12d
jle 0x3073
leaq 0x50(%rbx), %r14
andl $0x7fffffff, %r12d      # imm = 0x7FFFFFFF
xorl %r13d, %r13d
leaq -0x48(%rbp), %r15
movq 0x20(%rbx), %rax
movl (%rax,%r13,4), %edx
movq %r15, %rdi
movq %rbx, %rsi
callq 0x36b6
movq %r14, %rdi
movq %r15, %rsi
callq 0x5a4e
movq -0x48(%rbp), %rdi
leaq -0x38(%rbp), %rax
cmpq %rax, %rdi
je 0x306b
movq -0x38(%rbp), %rsi
incq %rsi
callq 0x21d0
incq %r13
cmpq %r13, %r12
jne 0x3034
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
jmp 0x3084
movq %rax, %rbx
movq -0x48(%rbp), %rdi
leaq -0x38(%rbp), %rax
cmpq %rax, %rdi
je 0x30a0
movq -0x38(%rbp), %rsi
incq %rsi
callq 0x21d0
movq %rbx, %rdi
callq 0x22e0
// File: /workspace/github_cpp_makefile_star2_O3/mirkat1206[P]Quine-McCluskey-Petrick-Method/Quine_McCluskey.cpp
// Function: Quine_McCluskey::Merge(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>)
string Quine_McCluskey::Merge(string a, string b) {
	int size = a.length() ;
	for( int i=0 ; i<size ; i++ ) {
		if( a[i]!=b[i] ) {
			a[i] = '-' ;
			return a ;
		}
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, %rax
movq (%rdx), %rsi
movq (%rcx), %rcx
movb (%rsi), %dil
cmpb (%rcx), %dil
jne 0x3670
movq 0x8(%rdx), %rdi
andl $0x7fffffff, %edi       # imm = 0x7FFFFFFF
movl $0x1, %r9d
cmpq %r9, %rdi
je 0x36b4
movb (%rsi,%r9), %r10b
leaq 0x1(%r9), %r8
cmpb (%rcx,%r9), %r10b
movq %r8, %r9
je 0x3655
decq %r8
jmp 0x3673
xorl %r8d, %r8d
movb $0x2d, (%rsi,%r8)
leaq 0x10(%rax), %rsi
movq %rsi, (%rax)
movq (%rdx), %rdi
leaq 0x10(%rdx), %rcx
cmpq %rcx, %rdi
je 0x3697
movq %rdi, (%rax)
movq (%rcx), %rsi
movq %rsi, 0x10(%rax)
jmp 0x369d
movups (%rcx), %xmm0
movups %xmm0, (%rsi)
movq 0x8(%rdx), %rsi
movq %rsi, 0x8(%rax)
movq %rcx, (%rdx)
movq $0x0, 0x8(%rdx)
movb $0x0, 0x10(%rdx)
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O3/mirkat1206[P]Quine-McCluskey-Petrick-Method/Quine_McCluskey.cpp
// Function: Quine_McCluskey::Dec2Bin[abi:cxx11](int)
string Quine_McCluskey::Dec2Bin(int n) {
	string s;
	while( n!=0 ) {
		s += '0'+n%2 ;
		n /= 2 ;
	}
	int pad = Num_Var - s.length() ;
	while( pad-- ) {
		s += '0' ;
	}
	reverse( s.begin() , s.end() );
	return s ;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rsi, %r14
movq %rdi, %rbx
leaq 0x10(%rdi), %r12
movq %r12, (%rdi)
movq $0x0, 0x8(%rdi)
movb $0x0, 0x10(%rdi)
testl %edx, %edx
je 0x371d
movl %edx, %r15d
movl %edx, %r13d
shrl $0x1f, %r13d
addl %r15d, %r13d
movl %r13d, %eax
andl $0xfe, %eax
movl %r15d, %ecx
subl %eax, %ecx
addb $0x30, %cl
movsbl %cl, %esi
movq %rbx, %rdi
callq 0x2180
sarl %r13d
incl %r15d
cmpl $0x3, %r15d
movl %r13d, %r15d
jae 0x36e7
movl 0x8(%rbx), %eax
jmp 0x371f
xorl %eax, %eax
movl (%r14), %r14d
notl %r14d
addl %eax, %r14d
incl %r14d
je 0x373c
movq %rbx, %rdi
movl $0x30, %esi
callq 0x2180
jmp 0x3728
movq (%rbx), %rax
movq 0x8(%rbx), %rcx
testq %rcx, %rcx
setne %dl
addq %rax, %rcx
decq %rcx
cmpq %rax, %rcx
seta %sil
andb %dl, %sil
cmpb $0x1, %sil
jne 0x377d
incq %rax
movb -0x1(%rax), %dl
movb (%rcx), %sil
movb %sil, -0x1(%rax)
movb %dl, (%rcx)
decq %rcx
leaq 0x1(%rax), %rdx
cmpq %rcx, %rax
movq %rdx, %rax
jb 0x3762
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
jmp 0x3791
movq %rax, %r14
movq (%rbx), %rdi
cmpq %r12, %rdi
je 0x37a8
movq (%r12), %rsi
incq %rsi
callq 0x21d0
movq %r14, %rdi
callq 0x22e0
// File: /workspace/github_cpp_makefile_star2_O3/mirkat1206[P]Quine-McCluskey-Petrick-Method/Quine_McCluskey.cpp
// Function: Quine_McCluskey::Print_Prime_Impli()
void Quine_McCluskey::Print_Prime_Impli() {
	int size = Prime_Impli.size() ;
	cout<<"Total number of Prime Implicant = "<< size << endl;
	for( int i=0 ; i<size ; i++ )
		cout<< Prime_Impli[i] << endl;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rdi, %rbx
movq 0x70(%rdi), %r14
subq 0x68(%rdi), %r14
shrq $0x5, %r14
movq 0x976e(%rip), %r15      # 0xcfd0
leaq 0x58a2(%rip), %rsi      # 0x910b
movl $0x22, %edx
movq %r15, %rdi
callq 0x2210
movq %r15, %rdi
movl %r14d, %esi
callq 0x22d0
movq %rax, %r15
movq (%rax), %rax
movq -0x18(%rax), %rdi
addq %r15, %rdi
movl $0xa, %esi
callq 0x21a0
movsbl %al, %esi
movq %r15, %rdi
callq 0x2030
movq %rax, %rdi
callq 0x2100
testl %r14d, %r14d
jle 0x390c
andl $0x7fffffff, %r14d      # imm = 0x7FFFFFFF
movl $0x8, %r13d
movq 0x970c(%rip), %r15      # 0xcfd0
movq 0x68(%rbx), %rax
movq -0x8(%rax,%r13), %rsi
movq (%rax,%r13), %rdx
movq %r15, %rdi
callq 0x2210
movq %rax, %r12
movq (%rax), %rax
movq -0x18(%rax), %rdi
addq %r12, %rdi
movl $0xa, %esi
callq 0x21a0
movsbl %al, %esi
movq %r12, %rdi
callq 0x2030
movq %rax, %rdi
callq 0x2100
addq $0x20, %r13
decq %r14
jne 0x38c4
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O3/mirkat1206[P]Quine-McCluskey-Petrick-Method/Quine_McCluskey.cpp
// Function: Quine_McCluskey::HW1_Print_Prime_Impli()
void Quine_McCluskey::HW1_Print_Prime_Impli() {
	sort( Prime_Impli.begin() , Prime_Impli.end() , sort_by_num_of_literal );
	int size = Prime_Impli.size() ;
	cout<<".pi "<< size << endl;
	for( int i=0 ; i<size && i<20 ; i++ )
		cout<< Prime_Impli[i] << endl;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rdi, %rbx
movq 0x68(%rdi), %r15
movq 0x70(%rdi), %r14
cmpq %r14, %r15
je 0x397e
movq %r14, %rax
subq %r15, %rax
sarq $0x5, %rax
bsrq %rax, %rdx
xorl $0x3f, %edx
addl %edx, %edx
xorq $0x7e, %rdx
leaq -0xbf7(%rip), %r12      # 0x2d61
movq %r15, %rdi
movq %r14, %rsi
movq %r12, %rcx
callq 0x470a
movq %r15, %rdi
movq %r14, %rsi
movq %r12, %rdx
callq 0x47fc
movq 0x68(%rbx), %r15
movq 0x70(%rbx), %r14
jmp 0x3981
movq %r15, %r14
subq %r15, %r14
shrq $0x5, %r14
movq 0x9641(%rip), %r15      # 0xcfd0
leaq 0x5798(%rip), %rsi      # 0x912e
movl $0x4, %edx
movq %r15, %rdi
callq 0x2210
movq %r15, %rdi
movl %r14d, %esi
callq 0x22d0
movq %rax, %r15
movq (%rax), %rax
movq -0x18(%rax), %rdi
addq %r15, %rdi
movl $0xa, %esi
callq 0x21a0
movsbl %al, %esi
movq %r15, %rdi
callq 0x2030
movq %rax, %rdi
callq 0x2100
testl %r14d, %r14d
jle 0x3a48
decl %r14d
cmpq $0x13, %r14
movl $0x13, %r12d
cmovbq %r14, %r12
shll $0x5, %r12d
addq $0x20, %r12
xorl %r13d, %r13d
movq 0x95d0(%rip), %r14      # 0xcfd0
movq 0x68(%rbx), %rax
movq (%rax,%r13), %rsi
movq 0x8(%rax,%r13), %rdx
movq %r14, %rdi
callq 0x2210
movq %rax, %r15
movq (%rax), %rax
movq -0x18(%rax), %rdi
addq %r15, %rdi
movl $0xa, %esi
callq 0x21a0
movsbl %al, %esi
movq %r15, %rdi
callq 0x2030
movq %rax, %rdi
callq 0x2100
addq $0x20, %r13
cmpq %r13, %r12
jne 0x3a00
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O3/mirkat1206[P]Quine-McCluskey-Petrick-Method/Quine_McCluskey.cpp
// Function: Quine_McCluskey::HW1_Print_Prime_Impli(std::basic_ofstream<char, std::char_traits<char>>&)
void Quine_McCluskey::HW1_Print_Prime_Impli(ofstream &fout) {
	sort( Prime_Impli.begin() , Prime_Impli.end() , sort_by_num_of_literal );
	int size = Prime_Impli.size() ;
	fout<<".pi "<< size << endl;
	for( int i=0 ; i<size && i<20 ; i++ )
		fout<< Prime_Impli[i] << endl;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq %rdi, %r14
movq 0x68(%rdi), %r12
movq 0x70(%rdi), %r15
cmpq %r15, %r12
je 0x3abd
movq %r15, %rax
subq %r12, %rax
sarq $0x5, %rax
bsrq %rax, %rdx
xorl $0x3f, %edx
addl %edx, %edx
xorq $0x7e, %rdx
leaq -0xd36(%rip), %r13      # 0x2d61
movq %r12, %rdi
movq %r15, %rsi
movq %r13, %rcx
callq 0x470a
movq %r12, %rdi
movq %r15, %rsi
movq %r13, %rdx
callq 0x47fc
movq 0x68(%r14), %r12
movq 0x70(%r14), %r15
jmp 0x3ac0
movq %r12, %r15
subq %r12, %r15
shrq $0x5, %r15
leaq 0x5660(%rip), %rsi      # 0x912e
movl $0x4, %edx
movq %rbx, %rdi
callq 0x2210
movq %rbx, %rdi
movl %r15d, %esi
callq 0x22d0
movq %rax, %r12
movq (%rax), %rax
movq -0x18(%rax), %rdi
addq %r12, %rdi
movl $0xa, %esi
callq 0x21a0
movsbl %al, %esi
movq %r12, %rdi
callq 0x2030
movq %rax, %rdi
callq 0x2100
testl %r15d, %r15d
jle 0x3b79
decl %r15d
cmpq $0x13, %r15
movl $0x13, %r12d
cmovbq %r15, %r12
shll $0x5, %r12d
addq $0x20, %r12
xorl %r13d, %r13d
movq 0x68(%r14), %rax
movq (%rax,%r13), %rsi
movq 0x8(%rax,%r13), %rdx
movq %rbx, %rdi
callq 0x2210
movq %rax, %r15
movq (%rax), %rax
movq -0x18(%rax), %rdi
addq %r15, %rdi
movl $0xa, %esi
callq 0x21a0
movsbl %al, %esi
movq %r15, %rdi
callq 0x2030
movq %rax, %rdi
callq 0x2100
addq $0x20, %r13
cmpq %r13, %r12
jne 0x3b31
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O3/mirkat1206[P]Quine-McCluskey-Petrick-Method/Petrick_Method.cpp
// Function: Petrick_Method::Solve[abi:cxx11]()
set<string> Petrick_Method::Solve() {
	POS2SOP();
	sort( SOP.begin() , SOP.end() , sort_by_SOP );
	CountAllCost();
	return SOP[0] ;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rsi, %r14
movq %rdi, %rbx
movq %rsi, %rdi
callq 0x601e
movq 0x18(%r14), %r15
movq 0x20(%r14), %r12
cmpq %r12, %r15
je 0x5ff7
movq %r12, %rax
subq %r15, %rax
sarq $0x4, %rax
movabsq $-0x5555555555555555, %rcx # imm = 0xAAAAAAAAAAAAAAAB
imulq %rax, %rcx
bsrq %rcx, %rdx
xorl $0x3f, %edx
addl %edx, %edx
xorq $0x7e, %rdx
leaq -0x36b(%rip), %r13      # 0x5c70
movq %r15, %rdi
movq %r12, %rsi
movq %r13, %rcx
callq 0x71e8
movq %r15, %rdi
movq %r12, %rsi
movq %r13, %rdx
callq 0x72e7
movq %r14, %rdi
callq 0x6084
movq 0x18(%r14), %rsi
movq %rbx, %rdi
callq 0x6dae
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O3/mirkat1206[P]Quine-McCluskey-Petrick-Method/Petrick_Method.cpp
// Function: Petrick_Method::CountAllCost()
void Petrick_Method::CountAllCost() {
	int min_cover = SOP[0].size() ;
	for( int i=0 ; SOP[i].size()==min_cover ; i++ ) {
		int cost = 0 ;
		for( iter=SOP[i].begin() ; iter!=SOP[i].end() ; iter++ )
			cost += CountCost( *iter ) ;
		SOP_cost.push_back(cost);
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x38, %rsp
movq 0x18(%rdi), %rcx
movq 0x28(%rcx), %rdx
movslq %edx, %rax
movq %rdx, -0x40(%rbp)
cmpq %rdx, %rax
jne 0x61a6
movq %rdi, %rbx
leaq -0x50(%rbp), %r15
leaq 0x60(%rdi), %rax
movq %rax, -0x38(%rbp)
xorl %r14d, %r14d
leaq -0x60(%rbp), %r12
movq %rcx, %rax
movl $0x0, -0x2c(%rbp)
movq 0x18(%rax), %rax
movq %rax, 0x70e0(%rip)      # 0xd1b8
leaq (%r14,%r14,2), %r13
shlq $0x4, %r13
leaq (%rcx,%r13), %rdx
addq $0x8, %rdx
cmpq %rdx, %rax
je 0x615e
movq %r15, -0x60(%rbp)
movq 0x20(%rax), %rsi
movq 0x28(%rax), %rdx
addq %rsi, %rdx
movq %r12, %rdi
callq 0x3cbc
movq -0x60(%rbp), %rdi
movq -0x58(%rbp), %rax
testl %eax, %eax
jle 0x612f
andl $0x7fffffff, %eax       # imm = 0x7FFFFFFF
xorl %edx, %edx
xorl %ecx, %ecx
xorl %esi, %esi
cmpb $0x2d, (%rdi,%rdx)
setne %sil
addl %esi, %ecx
incq %rdx
cmpq %rdx, %rax
jne 0x6119
jmp 0x6131
xorl %ecx, %ecx
addl %ecx, -0x2c(%rbp)
cmpq %r15, %rdi
je 0x6145
movq -0x50(%rbp), %rsi
incq %rsi
callq 0x21d0
movq 0x706c(%rip), %rdi      # 0xd1b8
callq 0x2220
movq %rax, 0x7060(%rip)      # 0xd1b8
movq 0x18(%rbx), %rcx
jmp 0x60e0
movq 0x68(%rbx), %rsi
cmpq 0x70(%rbx), %rsi
je 0x6177
movl -0x2c(%rbp), %eax
movl %eax, (%rsi)
addq $0x4, %rsi
movq %rsi, 0x68(%rbx)
jmp 0x6188
movq -0x38(%rbp), %rdi
leaq -0x2c(%rbp), %rdx
callq 0x3d9a
movq 0x18(%rbx), %rcx
incq %r14
leaq (%r14,%r14,2), %rdx
shlq $0x4, %rdx
leaq (%rcx,%rdx), %rax
movq -0x40(%rbp), %rsi
cmpq %rsi, 0x28(%rcx,%rdx)
je 0x60c6
addq $0x38, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O3/mirkat1206[P]Quine-McCluskey-Petrick-Method/Petrick_Method.cpp
// Function: Petrick_Method::Expansion(std::set<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, std::less<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>, std::allocator<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>>&, int, int)
void Petrick_Method::Expansion(set<string> &product, int i_POS, int maxi) {
	if( i_POS==maxi ) { 
		string s = set2string(product) ;
		if( s_SOP.find(s)==s_SOP.end() ) {
			s_SOP.insert( s );
			SOP.push_back( product );
		}
	}
	int size = POS[ i_POS ].size() ;
	for( int i=0 ; i<size ; i++ ) {
		if( product.find( POS[ i_POS ][i] )==product.end() ) {
			product.insert( POS[ i_POS ][ i ] );
			Expansion( product , i_POS+1 , maxi );
			product.erase( POS[ i_POS ][i] );
		}
		else
			Expansion( product , i_POS+1 , maxi );
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x48, %rsp
movq %rsi, %r15
movq %rdi, %r12
movl %ecx, -0x30(%rbp)
movl %edx, -0x2c(%rbp)
cmpl %ecx, %edx
jne 0x6232
leaq -0x68(%rbp), %rbx
movq %rbx, %rdi
movq %r15, %rdx
callq 0x632c
leaq 0x30(%r12), %r13
movq %r13, %rdi
movq %rbx, %rsi
callq 0x7f86
leaq 0x38(%r12), %rcx
cmpq %rcx, %rax
jne 0x6219
leaq -0x68(%rbp), %rsi
movq %r13, %rdi
callq 0x8024
leaq 0x18(%r12), %rdi
movq %r15, %rsi
callq 0x6d72
leaq -0x58(%rbp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x6232
movq -0x58(%rbp), %rsi
incq %rsi
callq 0x21d0
movslq -0x2c(%rbp), %rax
movq (%r12), %rcx
leaq (%rax,%rax,2), %r13
movq 0x8(%rcx,%r13,8), %rbx
subq (%rcx,%r13,8), %rbx
shrq $0x5, %rbx
testl %ebx, %ebx
jle 0x62f6
leaq 0x8(%r15), %rcx
movq %rcx, -0x48(%rbp)
incl -0x2c(%rbp)
andl $0x7fffffff, %ebx       # imm = 0x7FFFFFFF
xorl %r14d, %r14d
shlq $0x3, %rax
leaq (%rax,%rax,2), %rax
movq %rax, -0x40(%rbp)
movq %r13, -0x38(%rbp)
movq (%r12), %rax
movq (%rax,%r13,8), %rsi
addq %r14, %rsi
movq %r15, %rdi
callq 0x7f86
cmpq -0x48(%rbp), %rax
je 0x62a3
movq %r12, %rdi
movq %r15, %rsi
movl -0x2c(%rbp), %edx
movl -0x30(%rbp), %ecx
callq 0x61b6
jmp 0x62ed
movq (%r12), %rax
movq -0x40(%rbp), %r13
movq (%rax,%r13), %rsi
addq %r14, %rsi
movq %r15, %rdi
callq 0x8024
movq %r12, %rdi
movq %r15, %rsi
movl -0x2c(%rbp), %edx
movl -0x30(%rbp), %ecx
callq 0x61b6
movq (%r12), %rax
movq (%rax,%r13), %rsi
movq -0x38(%rbp), %r13
addq %r14, %rsi
movq %r15, %rdi
callq 0x8378
movq %r15, %rdi
movq %rax, %rsi
callq 0x8434
addq $0x20, %r14
decq %rbx
jne 0x6277
addq $0x48, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
jmp 0x6307
movq %rax, %rbx
leaq -0x58(%rbp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x6323
movq -0x58(%rbp), %rsi
incq %rsi
callq 0x21d0
movq %rbx, %rdi
callq 0x22e0
nop
// File: /workspace/github_cpp_makefile_star2_O3/mirkat1206[P]Quine-McCluskey-Petrick-Method/Petrick_Method.cpp
// Function: Petrick_Method::set2string(std::set<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, std::less<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>, std::allocator<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>>&)
string Petrick_Method::set2string(set<string> &temp) {
	stringstream ss;
	for( iter=temp.begin() ; iter!=temp.end() ; iter++ )
		ss<< *iter ;
	string s;
	ss>> s ;
	return s ;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
subq $0x188, %rsp            # imm = 0x188
movq %rdx, %r14
movq %rdi, %rbx
leaq -0x1a0(%rbp), %rdi
callq 0x2110
movq 0x18(%r14), %rax
addq $0x8, %r14
movq %rax, 0x6e5b(%rip)      # 0xd1b8
cmpq %r14, %rax
je 0x6391
leaq -0x190(%rbp), %r15
movq 0x20(%rax), %rsi
movq 0x28(%rax), %rdx
movq %r15, %rdi
callq 0x2210
movq 0x6e38(%rip), %rdi      # 0xd1b8
callq 0x2220
movq %rax, 0x6e2c(%rip)      # 0xd1b8
cmpq %r14, %rax
jne 0x6369
leaq 0x10(%rbx), %r15
movq %r15, (%rbx)
movq $0x0, 0x8(%rbx)
movb $0x0, 0x10(%rbx)
leaq -0x1a0(%rbp), %rdi
movq %rbx, %rsi
callq 0x2250
movq 0x6bf6(%rip), %rsi      # 0xcfb0
leaq -0x1a0(%rbp), %rdi
callq 0x2140
leaq -0x120(%rbp), %rdi
callq 0x2090
movq %rbx, %rax
addq $0x188, %rsp            # imm = 0x188
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %r14
movq (%rbx), %rdi
cmpq %r15, %rdi
je 0x63fe
movq (%r15), %rsi
incq %rsi
callq 0x21d0
jmp 0x63fe
movq %rax, %r14
movq 0x6bab(%rip), %rsi      # 0xcfb0
leaq -0x1a0(%rbp), %rdi
callq 0x2140
leaq -0x120(%rbp), %rdi
callq 0x2090
movq %r14, %rdi
callq 0x22e0
nop
// File: /workspace/github_cpp_makefile_star2_O3/mirkat1206[P]Quine-McCluskey-Petrick-Method/Petrick_Method.cpp
// Function: Petrick_Method::Print_POS()
void Petrick_Method::Print_POS() {
	cout<<"Product of Sum = ";
	int size1 = POS.size() ;
	for( int i=0 ; i<size1 ; i++ ) {
		cout<<"( "<< POS[i][0] ;
		int size2 = POS[i].size() ;
		for( int j=1 ; j<size2 ; j++ )
			cout<<" + "<< POS[i][j] ;
		cout<<" )";
	}
	cout<< endl;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %rdi, %r14
movq 0x6b5d(%rip), %rdi      # 0xcfd0
leaq 0x2d36(%rip), %rsi      # 0x91b0
movl $0x11, %edx
callq 0x2210
movq 0x8(%r14), %rax
subq (%r14), %rax
sarq $0x3, %rax
movabsq $-0x5555555555555555, %rcx # imm = 0xAAAAAAAAAAAAAAAB
imulq %rax, %rcx
movq %rcx, -0x30(%rbp)
testl %ecx, %ecx
jle 0x6590
movq -0x30(%rbp), %rax
andl $0x7fffffff, %eax       # imm = 0x7FFFFFFF
movq %rax, -0x30(%rbp)
xorl %ebx, %ebx
movq 0x6b11(%rip), %r15      # 0xcfd0
movq %r14, -0x40(%rbp)
movl $0x2, %edx
movq %r15, %rdi
leaq 0x2cf0(%rip), %rsi      # 0x91c2
callq 0x2210
movq (%r14), %rax
movq %rbx, -0x38(%rbp)
leaq (,%rbx,8), %rcx
leaq (%rcx,%rcx,2), %rbx
movq (%rax,%rbx), %rax
movq (%rax), %rsi
movq 0x8(%rax), %rdx
movq %r15, %rdi
callq 0x2210
movq (%r14), %rax
movq 0x8(%rax,%rbx), %r12
subq (%rax,%rbx), %r12
shrq $0x5, %r12
cmpl $0x2, %r12d
leaq 0x2cad(%rip), %r14      # 0x91c5
jl 0x6567
andl $0x7fffffff, %r12d      # imm = 0x7FFFFFFF
decq %r12
movl $0x28, %r13d
movq -0x38(%rbp), %rax
leaq (%rax,%rax,2), %rbx
movl $0x3, %edx
movq %r15, %rdi
movq %r14, %rsi
callq 0x2210
movq -0x40(%rbp), %rax
movq (%rax), %rax
movq (%rax,%rbx,8), %rax
movq -0x8(%rax,%r13), %rsi
movq (%rax,%r13), %rdx
movq %r15, %rdi
callq 0x2210
addq $0x20, %r13
decq %r12
jne 0x6532
movl $0x2, %edx
movq %r15, %rdi
leaq 0x2c53(%rip), %rsi      # 0x91c9
callq 0x2210
movq -0x38(%rbp), %rbx
incq %rbx
cmpq -0x30(%rbp), %rbx
movq -0x40(%rbp), %r14
jne 0x64c3
movq 0x6a39(%rip), %rbx      # 0xcfd0
movq (%rbx), %rax
movq -0x18(%rax), %rdi
addq %rbx, %rdi
movl $0xa, %esi
callq 0x21a0
movsbl %al, %esi
movq %rbx, %rdi
callq 0x2030
movq %rax, %rdi
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x2100