LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_cpp_makefile_star2_O2/gchen98[P]macs/algorithm.cpp
// Function: GraphBuilder::getNextPos(double&, std::_List_iterator<HotSpotBin*>&)
bool GraphBuilder::getNextPos(double & curPos,HotSpotBinPtrList::iterator & hotSpotIt){
    bool bBinCrossed = false;
    if (hotSpotIt==pConfig->pHotSpotBinPtrList->end()){
        curPos+=pRandNumGenerator->expRV(getRate());
    }else{
        HotSpotBinPtr hotspot = *hotSpotIt;
        double startPos = hotspot->dStart;
        double endPos = hotspot->dEnd;
        if (curPos>=startPos&&curPos<endPos){
            curPos+=pRandNumGenerator->expRV(getRate()*hotspot->dRate);
            if (curPos>endPos){
                bBinCrossed = true;
                curPos = endPos;
                ++hotSpotIt;
            }
        }else if (curPos<startPos){
            curPos+=pRandNumGenerator->expRV(getRate());
            if (curPos>startPos){
                bBinCrossed = true;
                curPos = startPos;
            }
        }else{
            cerr<<"startPos is "<<startPos<<" endPos is "
            <<endPos<<" and curPos is "<<curPos<<endl;
            throw "Shouldn't be here for variable recomb";
        }
    }
    return bBinCrossed;
}

// Assembly:
pushq %r14
pushq %rbx
subq $0x18, %rsp
movq %rsi, %rbx
movq 0x8(%rdi), %rcx
movq (%rdx), %rax
cmpq 0x88(%rcx), %rax
je 0xd040
movq 0x10(%rax), %rcx
movsd (%rcx), %xmm2
movsd 0x8(%rcx), %xmm1
movsd (%rbx), %xmm0
ucomisd %xmm2, %xmm0
jb 0xd062
ucomisd %xmm0, %xmm1
jbe 0xd062
movq %rdx, %r14
movq (%rdi), %rax
movsd 0x30(%rdi), %xmm0
mulsd 0xc8(%rdi), %xmm0
mulsd 0x10(%rcx), %xmm0
movq %rax, %rdi
movsd %xmm1, 0x8(%rsp)
callq 0xddac
movsd 0x8(%rsp), %xmm1
addsd (%rbx), %xmm0
movsd %xmm0, (%rbx)
ucomisd %xmm1, %xmm0
jbe 0xd0a2
movsd %xmm1, (%rbx)
movq (%r14), %rax
movq (%rax), %rax
movq %rax, (%r14)
jmp 0xd09e
movq (%rdi), %rax
movsd 0x30(%rdi), %xmm0
mulsd 0xc8(%rdi), %xmm0
movq %rax, %rdi
callq 0xddac
addsd (%rbx), %xmm0
movsd %xmm0, (%rbx)
jmp 0xd0a2
ucomisd %xmm0, %xmm2
movsd %xmm2, 0x10(%rsp)
jbe 0xd0ac
movq (%rdi), %rax
movsd 0x30(%rdi), %xmm0
mulsd 0xc8(%rdi), %xmm0
movq %rax, %rdi
callq 0xddac
addsd (%rbx), %xmm0
movsd %xmm0, (%rbx)
movsd 0x10(%rsp), %xmm1
ucomisd %xmm1, %xmm0
jbe 0xd0a2
movsd %xmm1, (%rbx)
movb $0x1, %al
jmp 0xd0a4
xorl %eax, %eax
addq $0x18, %rsp
popq %rbx
popq %r14
retq
movq 0x11f3d(%rip), %rdi     # 0x1eff0
leaq 0x91a9(%rip), %rsi      # 0x16263
movsd %xmm1, 0x8(%rsp)
callq 0x3250
movq %rax, %rdi
movsd 0x10(%rsp), %xmm0
callq 0x3440
leaq 0x9196(%rip), %rsi      # 0x16270
movq %rax, %rdi
callq 0x3250
movq %rax, %rdi
movsd 0x8(%rsp), %xmm0
callq 0x3440
leaq 0x9185(%rip), %rsi      # 0x1627c
movq %rax, %rdi
callq 0x3250
movsd (%rbx), %xmm0
movq %rax, %rdi
callq 0x3440
movq %rax, %rdi
callq 0x3100
pushq $0x8
popq %rdi
callq 0x3110
leaq 0x916a(%rip), %rcx      # 0x1628c
movq %rcx, (%rax)
movq 0x11e94(%rip), %rsi     # 0x1efc0
movq %rax, %rdi
xorl %edx, %edx
callq 0x33e0
// File: /workspace/github_cpp_makefile_star2_O2/gchen98[P]macs/datastructures.cpp
// Function: AlleleFreqBin::AlleleFreqBin(double, double, double)
AlleleFreqBin::AlleleFreqBin(double dStart,
double dEnd, double dFreq){
    this->dStart = dStart;
    this->dEnd = dEnd;
    this->dFreq = dFreq;
    this->iObservedCounts = 0;
}

// Assembly:
movsd %xmm0, (%rdi)
movsd %xmm1, 0x8(%rdi)
movsd %xmm2, 0x10(%rdi)
andl $0x0, 0x18(%rdi)
retq
nop
// File: /workspace/github_cpp_makefile_star2_O2/gchen98[P]macs/datastructures.cpp
// Function: Edge::Edge(boost::intrusive_ptr<Node>&, boost::intrusive_ptr<Node>&)
Edge::Edge(NodePtr & topNode,NodePtr & bottomNode):
PtrRefCountable(){
    #ifdef DIAG

    if (topNode->getHeight()<bottomNode->getHeight()){
        cerr<<"Error in creating edge.  Top node must be higher or equal\n";
        throw "Error in creating edge";
    }
    if (topNode->getType()==Node::MIGRATION &&
    bottomNode->getPopulation()==topNode->getPopulation()){
        cerr<<"Error in creating edge.  Top node must be different from "<<
        "migration node's population\n";
        throw "Error in creating edge";
    }
    cerr<<"edge of constructed.\n";
    #endif
    this->dLength = topNode->getHeight() - bottomNode->getHeight();
    this->topNode = topNode;
    this->getBottomNodeRef() = bottomNode;
    this->bDeleted = false;
    this->bInQueue = false;
    this->bInCurrentTree = false;
    this->iGraphIteration = 0;
}

// Assembly:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x10, %rsp
movq %rdi, %rbx
andq $0x0, 0x8(%rdi)
movq %rdx, %r12
movq %rsi, %r13
leaq 0xf398(%rip), %rax      # 0x1eae8
movq %rax, (%rdi)
leaq 0x18(%rdi), %r14
leaq 0x20(%rdi), %r15
xorps %xmm0, %xmm0
movups %xmm0, 0x18(%rdi)
movq %rsi, %rdi
callq 0xda4e
movsd 0x70(%rax), %xmm0
movsd %xmm0, 0x8(%rsp)
movq %r12, %rdi
callq 0xda4e
movsd 0x8(%rsp), %xmm0
subsd 0x70(%rax), %xmm0
movsd %xmm0, 0x28(%rbx)
movq %r14, %rdi
movq %r13, %rsi
callq 0xdb16
movq %r15, %rdi
movq %r12, %rsi
callq 0xdb16
andw $0x0, 0x10(%rbx)
movb $0x0, 0x12(%rbx)
andl $0x0, 0x14(%rbx)
addq $0x10, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
movq %rax, %rbx
movq %r15, %rdi
callq 0xdb46
movq %r14, %rdi
callq 0xdb46
movq %rbx, %rdi
callq 0x3400
nop
// File: /workspace/github_cpp_makefile_star2_O2/gchen98[P]macs/datastructures.cpp
// Function: Edge::setBottomNode(boost::intrusive_ptr<Node>&)
void Edge::setBottomNode(NodePtr & bottomNode){
    #ifdef DIAG
    if (topNode->getHeight()<bottomNode->getHeight())
    throw "Error in modifying edge.  Top node must be higher or equal";
    #endif
    this->dLength = topNode->getHeight() - bottomNode->getHeight();
    this->bottomNode = bottomNode;
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq %rdi, %r14
addq $0x18, %rdi
callq 0xda4e
movsd 0x70(%rax), %xmm0
movsd %xmm0, (%rsp)
movq %rbx, %rdi
callq 0xda4e
movsd (%rsp), %xmm0
subsd 0x70(%rax), %xmm0
movsd %xmm0, 0x28(%r14)
addq $0x20, %r14
movq %r14, %rdi
movq %rbx, %rsi
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0xdb16
nop
// File: /workspace/github_cpp_makefile_star2_O2/gchen98[P]macs/datastructures.cpp
// Function: Node::replaceOldWithNewEdge(Node::EdgeLocation, boost::shared_ptr<Edge>&, boost::shared_ptr<Edge>&)
void Node::replaceOldWithNewEdge(EdgeLocation iLocation,
EdgePtr & oldEdge,EdgePtr & newEdge){
    bool found = false;
    unsigned int i=0;
    if (iLocation==Node::TOP_EDGE){
        while(!found && i<this->topEdgeSize){
            WeakEdgePtr & topEdge = i?topEdge2:topEdge1;
            if (topEdge.lock()==oldEdge){
                topEdge=WeakEdgePtr(newEdge);
                found = true;
            }else{
                ++i;
            }
        }
        #ifdef DIAG
        if (!found) throw "Can't find top edge in replace edge";
        #endif
    }else if (iLocation==Node::BOTTOM_EDGE){
        while(!found && i<this->bottomEdgeSize){
            WeakEdgePtr & bottomEdge = i?bottomEdge2:bottomEdge1;
            if (bottomEdge.lock()==oldEdge){
                bottomEdge = WeakEdgePtr(newEdge);
                found = true;
            }else{
                ++i;
            }
        }
        if (!found) throw "Can't find bottom edge in replace edge";
    }
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x28, %rsp
movq %rcx, %rbx
movq %rdx, 0x20(%rsp)
movq %rdi, 0x18(%rsp)
testl %esi, %esi
je 0xf9bc
cmpl $0x1, %esi
jne 0xf9ad
xorl %r15d, %r15d
leaq 0x8(%rsp), %r12
xorl %ebp, %ebp
xorl %eax, %eax
testl %r15d, %r15d
setne %al
shll $0x4, %eax
movq 0x18(%rsp), %rcx
leaq (%rcx,%rax), %r13
addq $0x40, %r13
testb $0x1, %bpl
jne 0xf9a3
movq 0x18(%rsp), %rax
movzwl 0x6a(%rax), %eax
cmpl %eax, %r15d
jae 0xf9a3
movq %r12, %r14
movq %r12, %rdi
movq %r13, %rsi
callq 0xe1ca
movq 0x8(%rsp), %r12
movq 0x20(%rsp), %rax
movq (%rax), %rbp
leaq 0x10(%rsp), %rdi
callq 0xdff8
cmpq %rbp, %r12
sete %bpl
jne 0xf998
movq (%rbx), %rax
movq %rax, 0x8(%rsp)
movq 0x8(%rbx), %rax
movq %rax, 0x10(%rsp)
testq %rax, %rax
je 0xf97e
lock
incl 0xc(%rax)
movq %r13, %rdi
movq %r14, %r12
movq %r14, %rsi
callq 0x11c2e
leaq 0x10(%rsp), %rdi
callq 0x11e4a
jmp 0xf922
incl %r15d
movq %r14, %r12
jmp 0xf90a
testb $0x1, %bpl
je 0xfa5f
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
xorl %r12d, %r12d
leaq 0x8(%rsp), %r15
xorl %ebp, %ebp
xorl %eax, %eax
testl %r12d, %r12d
setne %al
shll $0x4, %eax
movq 0x18(%rsp), %rcx
leaq (%rcx,%rax), %r13
addq $0x20, %r13
testb $0x1, %bpl
jne 0xf9ad
movq 0x18(%rsp), %rax
movzwl 0x68(%rax), %eax
cmpl %eax, %r12d
jae 0xf9ad
movq %r15, %r14
movq %r15, %rdi
movq %r13, %rsi
callq 0xe1ca
movq 0x8(%rsp), %rbp
movq 0x20(%rsp), %rax
movq (%rax), %r15
leaq 0x10(%rsp), %rdi
callq 0xdff8
cmpq %r15, %rbp
sete %bpl
jne 0xfa54
movq (%rbx), %rax
movq %rax, 0x8(%rsp)
movq 0x8(%rbx), %rax
movq %rax, 0x10(%rsp)
testq %rax, %rax
je 0xfa3a
lock
incl 0xc(%rax)
movq %r13, %rdi
movq %r14, %r15
movq %r14, %rsi
callq 0x11c2e
leaq 0x10(%rsp), %rdi
callq 0x11e4a
jmp 0xf9de
incl %r12d
movq %r14, %r15
jmp 0xf9c6
pushq $0x8
popq %rdi
callq 0x3110
leaq 0x6b8c(%rip), %rcx      # 0x165fa
movq %rcx, (%rax)
movq 0xf548(%rip), %rsi      # 0x1efc0
movq %rax, %rdi
xorl %edx, %edx
callq 0x33e0
// File: /workspace/github_cpp_makefile_star2_O2/gchen98[P]macs/datastructures.cpp
// Function: GraphBuilder::~GraphBuilder()
GraphBuilder::~GraphBuilder(){
    cerr<<"Graphbuilder destructor\n";
    this->pConfig = NULL;
    this->pRandNumGenerator = NULL;

    delete this->pEdgeListInARG;
    delete this->pEdgeVectorByPop;

    delete this->pVectorIndicesToRecycle;
    delete [] pTreeEdgesToCoalesceArray;
    delete this->pEdgeVectorInTree;
    delete [] this->pSampleNodeArray;
    MutationPtrVector::iterator it;
    for(it=pMutationPtrVector->begin();it!=pMutationPtrVector->end();++it){
        delete(*it);
    }
    delete this->pMutationPtrVector;
    delete this->pEventList;
    delete this->pGeneConversionPtrSet;
    delete [] sites;
    delete pChrPositionQueue;
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rdi, %rbx
movq 0xf28e(%rip), %rdi      # 0x1eff0
leaq 0x68c3(%rip), %rsi      # 0x1662c
callq 0x3250
xorps %xmm0, %xmm0
movups %xmm0, (%rbx)
movq 0x10(%rbx), %r14
testq %r14, %r14
je 0xfd85
movq %r14, %rdi
callq 0xe2ec
pushq $0x18
popq %rsi
movq %r14, %rdi
callq 0x3270
movq 0x98(%rbx), %r14
testq %r14, %r14
je 0xfda4
movq %r14, %rdi
callq 0x11c5c
pushq $0x18
popq %rsi
movq %r14, %rdi
callq 0x3270
movq 0xa0(%rbx), %r14
testq %r14, %r14
je 0xfdc3
movq %r14, %rdi
callq 0x11c7e
pushq $0x18
popq %rsi
movq %r14, %rdi
callq 0x3270
movq 0xb8(%rbx), %r14
testq %r14, %r14
je 0xfe10
movq -0x8(%r14), %r15
addq $-0x8, %r14
testq %r15, %r15
je 0xfdfd
movq %r15, %r12
shlq $0x4, %r12
leaq (%r14,%r12), %rdi
callq 0xdff8
addq $-0x10, %r12
jne 0xfdee
shlq $0x4, %r15
orq $0x8, %r15
movq %r14, %rdi
movq %r15, %rsi
callq 0x3450
movq 0x18(%rbx), %r14
testq %r14, %r14
je 0xfe21
movq %r14, %rdi
callq 0x11ca0
pushq $0x18
popq %rsi
movq %r14, %rdi
callq 0x3270
movq 0xc0(%rbx), %r14
testq %r14, %r14
je 0xfe6c
movq -0x8(%r14), %r15
addq $-0x8, %r14
testq %r15, %r15
je 0xfe5c
leaq (,%r15,8), %r12
leaq (%r14,%r12), %rdi
callq 0xdb46
addq $-0x8, %r12
jne 0xfe4d
leaq 0x8(,%r15,8), %rsi
movq %r14, %rdi
callq 0x3450
movq 0xa8(%rbx), %r15
movq (%r15), %r12
pushq $0x18
popq %r14
cmpq 0x8(%r15), %r12
je 0xfe99
movq (%r12), %rdi
movq %r14, %rsi
callq 0x3270
addq $0x8, %r12
movq 0xa8(%rbx), %r15
jmp 0xfe7a
movq %r15, %rdi
callq 0x120d6
pushq $0x18
popq %rsi
movq %r15, %rdi
callq 0x3270
movq 0x58(%rbx), %r14
testq %r14, %r14
je 0xfebd
movq %r14, %rdi
callq 0x6fde
pushq $0x18
popq %rsi
movq %r14, %rdi
callq 0x3270
movq 0xf0(%rbx), %r14
testq %r14, %r14
je 0xfedc
movq %r14, %rdi
callq 0x11e6a
pushq $0x30
popq %rsi
movq %r14, %rdi
callq 0x3270
movq 0xb0(%rbx), %rdi
testq %rdi, %rdi
je 0xfef8
callq 0x32e0
movq 0xd8(%rbx), %r14
testq %r14, %r14
je 0xff0c
movq %r14, %rdi
callq 0x11ec2
pushq $0x50
popq %rsi
movq %r14, %rdi
callq 0x3270
leaq 0x118(%rbx), %rdi
callq 0xdff8
leaq 0x108(%rbx), %rdi
callq 0xdff8
leaq 0x90(%rbx), %rdi
callq 0xdff8
leaq 0x80(%rbx), %rdi
callq 0xdff8
leaq 0x60(%rbx), %rdi
callq 0x6c12
leaq 0x48(%rbx), %rdi
callq 0xdb46
leaq 0x40(%rbx), %rdi
callq 0xdb46
addq $0x38, %rbx
movq %rbx, %rdi
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
jmp 0xdb46
movq %rax, %rdi
callq 0x6c07
nop
// File: /workspace/github_cpp_makefile_star2_O2/gchen98[P]macs/datastructures.cpp
// Function: GraphBuilder::mergeEdges(boost::shared_ptr<Edge>&, boost::shared_ptr<Edge>&)
void GraphBuilder::mergeEdges(EdgePtr & topEdge,EdgePtr & bottomEdge){
    #ifdef DIAG
    if (topEdge->getBottomNodeRef()->getHeight()!=bottomEdge->getTopNodeRef()->getHeight())
    throw "The top edge and bottom edge are mismatched for the join";
    #endif
    // mark expired node as deleted
    bottomEdge->getTopNodeRef()->bDeleted = true;
    NodePtr & bottomNode = bottomEdge->getBottomNodeRef();
    bottomNode->replaceOldWithNewEdge(Node::TOP_EDGE,bottomEdge,topEdge);
    topEdge->setBottomNode(bottomNode);
    deleteEdge(bottomEdge);
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rdx, %rbx
movq %rsi, %r15
movq %rdi, %r14
movq %rdx, %rdi
callq 0xda24
leaq 0x18(%rax), %rdi
callq 0xda4e
movb $0x1, 0x10(%rax)
movq %rbx, %rdi
callq 0xda24
leaq 0x20(%rax), %r12
movq %r12, %rdi
callq 0xda4e
movq %rax, %rdi
xorl %esi, %esi
movq %rbx, %rdx
movq %r15, %rcx
callq 0xf8d4
movq %r15, %rdi
callq 0xda24
movq %rax, %rdi
movq %r12, %rsi
callq 0xf814
movq %r14, %rdi
movq %rbx, %rsi
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
jmp 0x10f3a
nop
// File: /workspace/github_cpp_makefile_star2_O2/gchen98[P]macs/datastructures.cpp
// Function: GraphBuilder::deleteEdge(boost::shared_ptr<Edge>&)
void GraphBuilder::deleteEdge(EdgePtr & edge){
    if (!edge->bDeleted){
        edge->bDeleted = true;
        if (pConfig->bDebug){
            cerr<<"Deleting edge with hts "<<edge->getBottomNodeRef()->getHeight()<<" and "<<
            edge->getTopNodeRef()->getHeight()<<endl;
        }
    }
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq %rdi, %r14
movq %rsi, %rdi
callq 0xda24
cmpb $0x0, 0x10(%rax)
jne 0x10fdf
movq %rbx, %rdi
callq 0xda24
movb $0x1, 0x10(%rax)
movq 0x8(%r14), %rax
cmpb $0x1, 0x48(%rax)
jne 0x10fdf
movq 0xe07d(%rip), %rdi      # 0x1eff0
leaq 0x5725(%rip), %rsi      # 0x1669f
callq 0x3250
movq %rax, %r14
movq %rbx, %rdi
callq 0xda24
leaq 0x20(%rax), %rdi
callq 0xda4e
movsd 0x70(%rax), %xmm0
movq %r14, %rdi
callq 0x3370
leaq 0x5710(%rip), %rsi      # 0x166b7
movq %rax, %rdi
callq 0x3250
movq %rax, %r14
movq %rbx, %rdi
callq 0xda24
leaq 0x18(%rax), %rdi
callq 0xda4e
movsd 0x70(%rax), %xmm0
movq %r14, %rdi
callq 0x3370
movq %rax, %rdi
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x3100
addq $0x8, %rsp
popq %rbx
popq %r14
retq
nop
// File: /workspace/github_cpp_makefile_star2_O2/gchen98[P]macs/datastructures.cpp
// Function: GraphBuilder::insertNodeInEdge(boost::intrusive_ptr<Node>&, boost::shared_ptr<Edge>&)
void GraphBuilder::insertNodeInEdge(NodePtr & newNode,
EdgePtr & selectedEdge){

    NodePtr bottomNodeCopy = selectedEdge->getBottomNodeRef();
    #ifdef DIAG
    NodePtr & topNode = selectedEdge->getTopNodeRef();
    if (newNode->getHeight()<bottomNodeCopy->getHeight() ||
    newNode->getHeight() > topNode->getHeight()){
        cerr<<"Edge has heights "<<bottomNodeCopy->getHeight()<<
        " and "<<topNode->getHeight()<<endl;
        cerr<<"New node has height "<<newNode->getHeight()<<endl;
        throw "Node to insert does not fit within edge";
    }
    #endif
    int iGraphIteration = selectedEdge->iGraphIteration;
    selectedEdge->setBottomNode(newNode);
    newNode->addNewEdge(Node::TOP_EDGE,selectedEdge);
    EdgePtr newBottomEdge = EdgePtr(new Edge(newNode,bottomNodeCopy));
    newBottomEdge->iGraphIteration = iGraphIteration;
    addEdge(newBottomEdge);
    bottomNodeCopy->replaceOldWithNewEdge(Node::TOP_EDGE,selectedEdge,
    newBottomEdge);
    newNode->addNewEdge(Node::BOTTOM_EDGE,newBottomEdge);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x20, %rsp
movq %rdx, %r14
movq %rsi, %rbx
movq %rdi, %r15
movq %rdx, %rdi
callq 0xda24
movq 0x20(%rax), %rax
movq %rax, 0x8(%rsp)
testq %rax, %rax
je 0x11017
incq 0x8(%rax)
movq %r14, %rdi
callq 0xda24
movl 0x14(%rax), %ebp
movq %r14, %rdi
callq 0xda24
movq %rax, %rdi
movq %rbx, %rsi
callq 0xf814
movq %rbx, %rdi
callq 0xda4e
movq %rax, %rdi
xorl %esi, %esi
movq %r14, %rdx
callq 0xf880
pushq $0x30
popq %rdi
callq 0x3260
movq %rax, %r12
leaq 0x8(%rsp), %rdx
movq %rax, %rdi
movq %rbx, %rsi
callq 0xf72e
leaq 0x10(%rsp), %rdi
movq %r12, %rsi
callq 0xdb9a
leaq 0x10(%rsp), %r12
movq %r12, %rdi
callq 0xda24
movl %ebp, 0x14(%rax)
movq %r15, %rdi
movq %r12, %rsi
callq 0x10d3a
leaq 0x8(%rsp), %rdi
callq 0xda4e
leaq 0x10(%rsp), %rcx
movq %rax, %rdi
xorl %esi, %esi
movq %r14, %rdx
callq 0xf8d4
movq %rbx, %rdi
callq 0xda4e
pushq $0x1
popq %rsi
leaq 0x10(%rsp), %rdx
movq %rax, %rdi
callq 0xf880
leaq 0x18(%rsp), %rdi
callq 0xdff8
leaq 0x8(%rsp), %rdi
callq 0xdb46
addq $0x20, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
pushq $0x30
popq %rsi
movq %r12, %rdi
callq 0x3270
jmp 0x11106
jmp 0x11103
movq %rax, %rbx
leaq 0x18(%rsp), %rdi
callq 0xdff8
jmp 0x11106
movq %rax, %rbx
leaq 0x8(%rsp), %rdi
callq 0xdb46
movq %rbx, %rdi
callq 0x3400
// File: /workspace/github_cpp_makefile_star2_O2/gchen98[P]macs/datastructures.cpp
// Function: GraphBuilder::addEdgeToCurrentTree(boost::shared_ptr<Edge>&)
void GraphBuilder::addEdgeToCurrentTree(EdgePtr & edge){
    edge->bInCurrentTree = true;
    edge->iGraphIteration = this->iGraphIteration;
    if (iTotalTreeEdges<pEdgeVectorInTree->size()){
        pEdgeVectorInTree->at(iTotalTreeEdges) = edge;
    }else{
        pEdgeVectorInTree->push_back(edge);
    }
    ++iTotalTreeEdges;
}

// Assembly:
pushq %rbp
pushq %r14
pushq %rbx
movq %rsi, %r14
movq %rdi, %rbx
movq %rsi, %rdi
callq 0xda24
movb $0x1, 0x12(%rax)
movl 0xd0(%rbx), %ebp
movq %r14, %rdi
callq 0xda24
movl %ebp, 0x14(%rax)
movl 0x20(%rbx), %esi
movq 0x18(%rbx), %rdi
movq 0x8(%rdi), %rax
subq (%rdi), %rax
sarq $0x4, %rax
cmpq %rsi, %rax
jbe 0x11168
callq 0x11d7e
movq %rax, %rdi
movq %r14, %rsi
callq 0xda78
jmp 0x11170
movq %r14, %rsi
callq 0x11d48
incl 0x20(%rbx)
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/gchen98[P]macs/datastructures.cpp
// Function: GraphBuilder::initializeCurrentTree()
void GraphBuilder::initializeCurrentTree(){
    // this method does two things, traverses the edges
    // to compute the total length, and clears out the status for
    // in current tree
    dLastTreeLength = 0.0;
    dArgLength = 0.;
    if (iGraphIteration==0){
        EdgePtrList::iterator it;
        for (it=pEdgeListInARG->begin();it!=pEdgeListInARG->end();++it){
            EdgePtr curEdge=*it;
            dLastTreeLength+=curEdge->getLength();
            this->addEdgeToCurrentTree(curEdge);
            curEdge->bInCurrentTree = false;
        }
        dArgLength = dLastTreeLength;
    }else{
        EdgePtrList::iterator it1=pEdgeListInARG->begin();
        while(it1!=pEdgeListInARG->end()){
            EdgePtr curEdge = *it1;
            if (!curEdge->bDeleted){
              dArgLength+=curEdge->getLength();
              if (curEdge->bInCurrentTree){
                dLastTreeLength+=curEdge->getLength();
                curEdge->bInCurrentTree = false;
              }
              ++it1;
            }else{
              it1 = pEdgeListInARG->erase(it1);
            }
        }
    }
}

// Assembly:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x10, %rsp
movq %rdi, %rbx
xorpd %xmm0, %xmm0
movupd %xmm0, 0x28(%rdi)
cmpl $0x0, 0xd0(%rdi)
movq 0x10(%rdi), %rax
je 0x11254
leaq 0x28(%rbx), %r13
movq (%rax), %r12
leaq 0x8(%rsp), %r14
movq %rsp, %r15
cmpq %rax, %r12
je 0x112ca
movq 0x10(%r12), %rax
movq %rax, (%rsp)
movq 0x18(%r12), %rax
movq %rax, 0x8(%rsp)
testq %rax, %rax
je 0x111d6
lock
incl 0x8(%rax)
movq %r15, %rdi
callq 0xda24
cmpb $0x0, 0x10(%rax)
je 0x111f5
movq 0x10(%rbx), %rdi
movq %r12, %rsi
callq 0x11da0
movq %rax, %r12
jmp 0x11243
movq %r15, %rdi
callq 0xda24
movsd 0x28(%rax), %xmm0
addsd (%r13), %xmm0
movsd %xmm0, (%r13)
movq %r15, %rdi
callq 0xda24
cmpb $0x1, 0x12(%rax)
jne 0x1123f
movq %r15, %rdi
callq 0xda24
movsd 0x28(%rax), %xmm0
addsd 0x30(%rbx), %xmm0
movsd %xmm0, 0x30(%rbx)
movq %r15, %rdi
callq 0xda24
movb $0x0, 0x12(%rax)
movq (%r12), %r12
movq %r14, %rdi
callq 0xdff8
movq 0x10(%rbx), %rax
jmp 0x111b1
leaq 0x8(%rsp), %r14
movq %rsp, %r15
movq %rax, %r12
movq (%r12), %r12
cmpq %rax, %r12
je 0x112c0
movq 0x10(%r12), %rax
movq %rax, (%rsp)
movq 0x18(%r12), %rax
movq %rax, 0x8(%rsp)
testq %rax, %rax
je 0x11284
lock
incl 0x8(%rax)
movq %r15, %rdi
callq 0xda24
movsd 0x28(%rax), %xmm0
addsd 0x30(%rbx), %xmm0
movsd %xmm0, 0x30(%rbx)
movq %rbx, %rdi
movq %r15, %rsi
callq 0x11118
movq %r15, %rdi
callq 0xda24
movb $0x0, 0x12(%rax)
movq %r14, %rdi
callq 0xdff8
movq 0x10(%rbx), %rax
jmp 0x1125f
movsd 0x30(%rbx), %xmm0
movsd %xmm0, 0x28(%rbx)
addq $0x10, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
movq %rax, %rbx
movq %r14, %rdi
callq 0xdff8
movq %rbx, %rdi
callq 0x3400
nop
// File: /workspace/github_cpp_makefile_star2_O2/hoehermann[P]TypedJNI/./typedjni.hpp
// Function: TypedJNIConstructor<_jstring*>::get(JNIEnv_*, _jclass*)
static std::function<TypedJNIObject(Args...)> get(JNIEnv *env, const jclass cls) {
        // yes indeed GetMethodID as illustrated at https://stackoverflow.com/questions/7260376/ (not get GetStaticMethodID)
        const jmethodID mid = TypedJNI::GetMethodID(env, cls, "<init>", "("+TypedJNI::GetTypeString<Args...>()+")"+TypedJNI::GetTypeString<void>());
        return [env, cls, mid](Args... args) -> TypedJNIObject {
            return TypedJNIObject(env, cls, env->NewObject(cls, mid, args...));
        };
    }

// Assembly:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0xd0, %rsp
movq %rdx, %r14
movq %rsi, %r15
movq %rdi, %rbx
leaq 0x266c(%rip), %rsi      # 0x7166
leaq 0xb0(%rsp), %rdi
leaq 0xf(%rsp), %rdx
callq 0x39f0
leaq 0x50(%rsp), %rdi
callq 0x584d
leaq 0x2645(%rip), %rsi      # 0x7162
leaq 0x70(%rsp), %rdi
leaq 0x50(%rsp), %rdx
callq 0x4006
leaq 0x2631(%rip), %rdx      # 0x7164
leaq 0x90(%rsp), %rdi
leaq 0x70(%rsp), %rsi
callq 0x3fe7
leaq 0x30(%rsp), %rdi
callq 0x57c5
leaq 0x10(%rsp), %rdi
leaq 0x90(%rsp), %rsi
leaq 0x30(%rsp), %rdx
callq 0x3f80
leaq 0xb0(%rsp), %rdx
leaq 0x10(%rsp), %rcx
movq %r15, %rdi
movq %r14, %rsi
callq 0x59a8
movq %rax, %r12
leaq 0x10(%rsp), %r13
movq %r13, %rdi
callq 0x30d0
leaq 0x30(%rsp), %rdi
callq 0x30d0
leaq 0x90(%rsp), %rdi
callq 0x30d0
leaq 0x70(%rsp), %rdi
callq 0x30d0
leaq 0x50(%rsp), %rdi
callq 0x30d0
leaq 0xb0(%rsp), %rdi
callq 0x30d0
movq %r15, (%r13)
movq %r14, 0x8(%r13)
movq %r12, 0x10(%r13)
leaq 0x10(%rsp), %rsi
movq %rbx, %rdi
callq 0x4c5a
movq %rbx, %rax
addq $0xd0, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
movq %rax, %rbx
leaq 0x10(%rsp), %rdi
callq 0x30d0
jmp 0x4c05
movq %rax, %rbx
leaq 0x30(%rsp), %rdi
callq 0x30d0
jmp 0x4c14
movq %rax, %rbx
leaq 0x90(%rsp), %rdi
callq 0x30d0
jmp 0x4c26
movq %rax, %rbx
leaq 0x70(%rsp), %rdi
callq 0x30d0
jmp 0x4c35
movq %rax, %rbx
leaq 0x50(%rsp), %rdi
callq 0x30d0
leaq 0xb0(%rsp), %rdi
callq 0x30d0
movq %rbx, %rdi
callq 0x3290
movq %rax, %rbx
jmp 0x4c3f
nop
// File: /workspace/github_cpp_makefile_star2_O2/hoehermann[P]TypedJNI/typedjni.cpp
// Function: TypedJNI::GetStaticMethodID(JNIEnv_*, _jclass*, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&)
jmethodID TypedJNI::GetStaticMethodID(JNIEnv *env, const jclass cls, const std::string name, const std::string & signature) {
    jmethodID mid = env->GetStaticMethodID(cls, name.c_str(), signature.c_str());
    if (mid == NULL) {
        throw TypedJNIError("Failed to find static method '"+name+"' "+signature+".");
    }
    return mid;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
subq $0x88, %rsp
movq %rcx, %r14
movq %rdx, %r15
movq (%rdx), %rdx
movq (%rcx), %rcx
movq (%rdi), %rax
callq *0x388(%rax)
testq %rax, %rax
je 0x58c6
addq $0x88, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
pushq $0x10
popq %rdi
callq 0x30f0
movq %rax, %rbx
leaq 0x1c2d(%rip), %rsi      # 0x7505
leaq 0x8(%rsp), %rdi
movq %r15, %rdx
callq 0x6288
leaq 0x1c38(%rip), %rdx      # 0x7524
leaq 0x28(%rsp), %rdi
leaq 0x8(%rsp), %rsi
callq 0x3fe7
leaq 0x48(%rsp), %rdi
leaq 0x28(%rsp), %rsi
movq %r14, %rdx
callq 0x6269
leaq 0x1c7b(%rip), %rdx      # 0x758f
leaq 0x68(%rsp), %rdi
leaq 0x48(%rsp), %rsi
callq 0x3fe7
movb $0x1, %bpl
leaq 0x68(%rsp), %rsi
movq %rbx, %rdi
callq 0x57b0
xorl %ebp, %ebp
leaq 0x62bc(%rip), %rsi      # 0xbbf8
movq 0x6685(%rip), %rdx      # 0xbfc8
movq %rbx, %rdi
callq 0x3270
movq %rax, %r14
leaq 0x68(%rsp), %rdi
callq 0x30d0
jmp 0x5960
movq %rax, %r14
movb $0x1, %bpl
leaq 0x48(%rsp), %rdi
callq 0x30d0
jmp 0x5972
movq %rax, %r14
movb $0x1, %bpl
leaq 0x28(%rsp), %rdi
callq 0x30d0
jmp 0x5984
movq %rax, %r14
movb $0x1, %bpl
leaq 0x8(%rsp), %rdi
callq 0x30d0
testb %bpl, %bpl
jne 0x5998
jmp 0x59a0
movq %rax, %r14
movq %rbx, %rdi
callq 0x3120
movq %r14, %rdi
callq 0x3290
// File: /workspace/github_cpp_makefile_star2_O2/hoehermann[P]TypedJNI/typedjni.cpp
// Function: TypedJNI::GetMethodID(JNIEnv_*, _jclass*, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&)
jmethodID TypedJNI::GetMethodID(JNIEnv *env, const jclass cls, const std::string name, const std::string & signature) {
    jmethodID mid = env->GetMethodID(cls, name.c_str(), signature.c_str());
    if (mid == NULL) {
        throw TypedJNIError("Failed to find method '"+name+"' "+signature+".");
    }
    return mid;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
subq $0x88, %rsp
movq %rcx, %r14
movq %rdx, %r15
movq (%rdx), %rdx
movq (%rcx), %rcx
movq (%rdi), %rax
callq *0x108(%rax)
testq %rax, %rax
je 0x59dd
addq $0x88, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
pushq $0x10
popq %rdi
callq 0x30f0
movq %rax, %rbx
leaq 0x1b38(%rip), %rsi      # 0x7527
leaq 0x8(%rsp), %rdi
movq %r15, %rdx
callq 0x6288
leaq 0x1b21(%rip), %rdx      # 0x7524
leaq 0x28(%rsp), %rdi
leaq 0x8(%rsp), %rsi
callq 0x3fe7
leaq 0x48(%rsp), %rdi
leaq 0x28(%rsp), %rsi
movq %r14, %rdx
callq 0x6269
leaq 0x1b64(%rip), %rdx      # 0x758f
leaq 0x68(%rsp), %rdi
leaq 0x48(%rsp), %rsi
callq 0x3fe7
movb $0x1, %bpl
leaq 0x68(%rsp), %rsi
movq %rbx, %rdi
callq 0x57b0
xorl %ebp, %ebp
leaq 0x61a5(%rip), %rsi      # 0xbbf8
movq 0x656e(%rip), %rdx      # 0xbfc8
movq %rbx, %rdi
callq 0x3270
movq %rax, %r14
leaq 0x68(%rsp), %rdi
callq 0x30d0
jmp 0x5a77
movq %rax, %r14
movb $0x1, %bpl
leaq 0x48(%rsp), %rdi
callq 0x30d0
jmp 0x5a89
movq %rax, %r14
movb $0x1, %bpl
leaq 0x28(%rsp), %rdi
callq 0x30d0
jmp 0x5a9b
movq %rax, %r14
movb $0x1, %bpl
leaq 0x8(%rsp), %rdi
callq 0x30d0
testb %bpl, %bpl
jne 0x5aaf
jmp 0x5ab7
movq %rax, %r14
movq %rbx, %rdi
callq 0x3120
movq %r14, %rdi
callq 0x3290
nop
// File: /workspace/github_cpp_makefile_star2_O2/hoehermann[P]TypedJNI/typedjni.cpp
// Function: TypedJNIEnv::find_class(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>)
TypedJNIClass TypedJNIEnv::find_class(std::string name) {
    jclass cls = env->FindClass(name.c_str());
    if (cls == NULL) {
        throw TypedJNIError("Failed to find class '"+name+"'.");
    }
    return TypedJNIClass(env, cls);
}

// Assembly:
pushq %rbp
pushq %r14
pushq %rbx
subq $0x40, %rsp
movq %rsi, %r14
movq %rdi, %rbx
movq 0x10(%rdi), %rdi
movq (%rsi), %rsi
movq (%rdi), %rax
callq *0x30(%rax)
testq %rax, %rax
je 0x60ae
movq %rax, %rdx
movq 0x10(%rbx), %rax
addq $0x40, %rsp
popq %rbx
popq %r14
popq %rbp
retq
pushq $0x10
popq %rdi
callq 0x30f0
movq %rax, %rbx
leaq 0x1521(%rip), %rsi      # 0x75e1
movq %rsp, %rdi
movq %r14, %rdx
callq 0x6288
leaq 0x14bc(%rip), %rdx      # 0x758e
leaq 0x20(%rsp), %rdi
movq %rsp, %rsi
callq 0x3fe7
movb $0x1, %bpl
leaq 0x20(%rsp), %rsi
movq %rbx, %rdi
callq 0x57b0
xorl %ebp, %ebp
leaq 0x5b00(%rip), %rsi      # 0xbbf8
movq 0x5ec9(%rip), %rdx      # 0xbfc8
movq %rbx, %rdi
callq 0x3270
movq %rax, %r14
leaq 0x20(%rsp), %rdi
callq 0x30d0
jmp 0x611c
movq %rax, %r14
movb $0x1, %bpl
movq %rsp, %rdi
callq 0x30d0
testb %bpl, %bpl
jne 0x612e
jmp 0x6136
movq %rax, %r14
movq %rbx, %rdi
callq 0x3120
movq %r14, %rdi
callq 0x3290
// File: /workspace/github_cpp_makefile_star2_O2/sykeben[P]overos/os/kernel.cpp
// Function: settitle(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>)
void settitle(string titleMsg) {
	#ifdef WIN32
		string title = "title ";
		title += titleMsg.c_str();
	#else
		string title = "echo -en \"\\033]0;";
		title += titleMsg.c_str();
		title += "\\a\"";
	#endif
	system(title.c_str());
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
subq $0x30, %rsp
movq %rdi, %rbx
leaq 0xbe8(%rip), %rsi       # 0x300a
leaq -0x38(%rbp), %r14
leaq -0x11(%rbp), %rdx
movq %r14, %rdi
callq 0x2928
movq (%rbx), %rsi
movq %r14, %rdi
callq 0x2190
leaq 0xbd8(%rip), %rsi       # 0x301c
leaq -0x38(%rbp), %rdi
callq 0x2190
movq -0x38(%rbp), %rdi
callq 0x2080
leaq -0x38(%rbp), %rdi
callq 0x21d8
addq $0x30, %rsp
popq %rbx
popq %r14
popq %rbp
retq
movq %rax, %rbx
leaq -0x38(%rbp), %rdi
callq 0x21d8
movq %rbx, %rdi
callq 0x2170
// File: /workspace/github_cpp_makefile_star2_O2/sykeben[P]overos/os/kernel.cpp
// Function: fexists(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&)
bool fexists(const string& name) {
    if (FILE *file = fopen(name.c_str(), "r")) {
        fclose(file);
        return true;
    } else {
        return false;
    }   
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %rbx
pushq %rax
movq (%rdi), %rdi
leaq 0xb7c(%rip), %rsi       # 0x3008
callq 0x20f0
movq %rax, %rbx
testq %rax, %rax
je 0x24a1
movq %rbx, %rdi
callq 0x20b0
testq %rbx, %rbx
setne %al
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/SYZYGYfpga[P]brain-tools/src/sequencer-brain.cpp
// Function: i2cWrite(int, int, unsigned short, int, int, unsigned char*)
int i2cWrite (int i2c_file, int i2c_addr, uint16_t sub_addr,
              int sub_addr_length, int length, uint8_t data[32])
{
	uint8_t *buffer = (uint8_t *)malloc((length * sizeof(uint8_t)) + sub_addr_length);
	int i;

	memcpy(buffer + sub_addr_length, data, length * sizeof(uint8_t));

	// Set I2C address
	if (ioctl(i2c_file, I2C_SLAVE, i2c_addr) < 0) {
		return -1;
	}

	if (sub_addr_length == 2) {
		buffer[0] = (sub_addr >> 8) & 0xFF;
		buffer[1] = sub_addr & 0xFF;
	} else {
		buffer[0] = sub_addr & 0xFF;
	}

	for (i = 0; i < I2C_CHECK_COUNT; i++) {
		// The DNA Spec allows an MCU to NAK subsequent writes when multiple
		// writes are performed, keep trying for I2C_CHECK_COUNT tries before
		// giving up.
		if (write(i2c_file, buffer, sub_addr_length + length)
		      == (length + sub_addr_length)) {
			return 0;
		}
	}

	// We gave up trying to write
	return -1;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %r9, %r12
movl %ecx, %ebp
movl %edx, 0xc(%rsp)
movl %esi, 0x14(%rsp)
movl %edi, %ebx
movl %r8d, 0x10(%rsp)
movslq %r8d, %r13
movslq %ecx, %r15
leaq (%r15,%r13), %rdi
callq 0x1130
movq %rax, %r14
addq %rax, %r15
movq %r15, %rdi
movq %r12, %rsi
movq %r13, %rdx
callq 0x10e0
movl $0x703, %esi            # imm = 0x703
movl %ebx, %edi
movl 0x14(%rsp), %edx
xorl %eax, %eax
callq 0x1160
pushq $-0x1
popq %r12
testl %eax, %eax
js 0x137f
cmpl $0x2, %ebp
jne 0x1351
movzwl 0xc(%rsp), %eax
movb %al, 0x1(%r14)
shrl $0x8, %eax
jmp 0x1355
movl 0xc(%rsp), %eax
movb %al, (%r14)
movl 0x10(%rsp), %eax
addl %ebp, %eax
movslq %eax, %r15
movl $0x7d1, %ebp            # imm = 0x7D1
decl %ebp
je 0x137f
movl %ebx, %edi
movq %r14, %rsi
movq %r15, %rdx
callq 0x1060
cmpq %r15, %rax
jne 0x1366
xorl %r12d, %r12d
movl %r12d, %eax
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/SYZYGYfpga[P]brain-tools/src/sequencer-brain.cpp
// Function: i2cRead(int, int, unsigned short, int, int, unsigned char*)
int i2cRead (int i2c_file, int i2c_addr, uint16_t sub_addr,
             int sub_addr_length, int length, uint8_t data[32])
{
	uint8_t temp_buf[2];

	// Set I2C address
	if (ioctl(i2c_file, I2C_SLAVE, i2c_addr) < 0) {
		return -1;
	}

	if (sub_addr_length == 2) {
		temp_buf[0] = (sub_addr >> 8) & 0xFF;
		temp_buf[1] = sub_addr & 0xFF;
	} else {
		temp_buf[0] = sub_addr & 0xFF;
	}

	if (write(i2c_file, temp_buf, sub_addr_length) != sub_addr_length) {
		return -1;
	}

	if (read(i2c_file, data, length) != length) {
		return -1;
	}

	return 0;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %r9, %rbx
movl %r8d, %ebp
movl %ecx, %r12d
movl %edx, %r13d
movl %esi, %edx
movl %edi, %r14d
movl $0x703, %esi            # imm = 0x703
xorl %eax, %eax
callq 0x1160
pushq $-0x1
popq %r15
testl %eax, %eax
js 0x140d
cmpl $0x2, %r12d
jne 0x13d4
movzwl %r13w, %r13d
movb %r13b, 0x7(%rsp)
shrl $0x8, %r13d
leaq 0x6(%rsp), %rsi
movb %r13b, (%rsi)
movslq %r12d, %r12
movl %r14d, %edi
movq %r12, %rdx
callq 0x1060
cmpq %r12, %rax
jne 0x140d
movslq %ebp, %r12
movl %r14d, %edi
movq %rbx, %rsi
movq %r12, %rdx
callq 0x1170
xorl %r15d, %r15d
cmpq %r12, %rax
setne %r15b
negl %r15d
movl %r15d, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/SYZYGYfpga[P]brain-tools/src/sequencer-brain.cpp
// Function: writeMCU(int, unsigned short, int, unsigned char*, int)
int writeMCU (int i2c_file, uint16_t port_addr, int sub_addr, uint8_t *data,
              int length)
{
	int temp_length, current_sub_addr;

	// Useful for debug
	//printf("Writing %d bytes to 0x%X, sub-address 0x%X\n", length, port_addr, sub_addr);

	current_sub_addr = sub_addr;

	while (length > 0) {
		temp_length = (length > 32) ? 32 : length;

		if (i2cWrite(i2c_file, port_addr, current_sub_addr, 2, temp_length,
		             &data[(current_sub_addr - sub_addr)]) != 0) {
			return -1;
		}

		current_sub_addr += temp_length;
		length -= temp_length;
	}

	return 0;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movl %r8d, %ebx
movq %rcx, (%rsp)
movl %edx, %r14d
movl %esi, %r12d
movl %edi, %r13d
movl %edx, %r15d
testl %ebx, %ebx
jle 0x1477
cmpl $0x20, %ebx
pushq $0x20
popq %rbp
cmovbl %ebx, %ebp
movl %r15d, %eax
subl %r14d, %eax
movslq %eax, %r9
addq (%rsp), %r9
movzwl %r15w, %edx
movl %r13d, %edi
movl %r12d, %esi
pushq $0x2
popq %rcx
movl %ebp, %r8d
callq 0x12df
testl %eax, %eax
jne 0x147b
addl %ebp, %r15d
subl %ebp, %ebx
jmp 0x143d
xorl %eax, %eax
jmp 0x147e
pushq $-0x1
popq %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/SYZYGYfpga[P]brain-tools/src/sequencer-brain.cpp
// Function: readMCU(int, unsigned short, int, unsigned char*, int)
int readMCU (int i2c_file, uint16_t port_addr, int sub_addr, uint8_t *data,
             int length)
{
	int current_sub_addr, temp_length;

	// Useful for debug
	//printf("Reading %d bytes from 0x%X, sub-address 0x%X\n", length, port_addr, sub_addr);

	current_sub_addr = sub_addr;

	while (length > 0) {
		temp_length = (length > 32) ? 32 : length;

		if (i2cRead(i2c_file, port_addr, current_sub_addr, 2, temp_length,
		            &data[(current_sub_addr - sub_addr)]) != 0) {
			return -1;
		}

		current_sub_addr += temp_length;
		length -= temp_length;
	}

	return 0;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movl %r8d, %ebx
movq %rcx, (%rsp)
movl %edx, %r14d
movl %esi, %r12d
movl %edi, %r13d
movl %edx, %r15d
testl %ebx, %ebx
jle 0x14e5
cmpl $0x20, %ebx
pushq $0x20
popq %rbp
cmovbl %ebx, %ebp
movl %r15d, %eax
subl %r14d, %eax
movslq %eax, %r9
addq (%rsp), %r9
movzwl %r15w, %edx
movl %r13d, %edi
movl %r12d, %esi
pushq $0x2
popq %rcx
movl %ebp, %r8d
callq 0x1391
testl %eax, %eax
jne 0x14e9
addl %ebp, %r15d
subl %ebp, %ebx
jmp 0x14ab
xorl %eax, %eax
jmp 0x14ec
pushq $-0x1
popq %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/SYZYGYfpga[P]brain-tools/src/sequencer-brain.cpp
// Function: printHelp(char*)
void printHelp (char *progname)
{
	printf("Usage: %s [option [argument]] <i2c device>\n", progname);
	printf("  <i2c device> is required for all commands. It must contain the\n");
	printf("               path to the Linux i2c device\n");
	printf("\n");
	printf("  Exactly one of the following options must be specified:\n");
	printf("    -h - print this text\n");
	printf("    -w <filename> - write a binary DNA to a peripheral, takes the DNA filename\n");
	printf("                    as an argument\n");
	printf("    -d <filename> - dump the DNA from a peripheral to a binary file, takes the\n");
	printf("                    DNA filename as an argument\n");
	printf("\n");
	printf("  Examples:\n");
	printf("    Dump DNA from the MCU on Port 1:\n");
	printf("      %s -d seq_file.bin -p 1 /dev/i2c-1\n", progname);
	printf("    Set VIO1 to 3.3V:\n");
	printf("      %s -s -1 330 /dev/i2c-1\n", progname);
}

// Assembly:
pushq %rbp
pushq %rbx
pushq %rax
movq %rdi, %rbx
leaq 0xafd(%rip), %rdi       # 0x2024
movq %rbx, %rsi
xorl %eax, %eax
callq 0x1030
leaq 0xef9(%rip), %rdi       # 0x2431
callq 0x1180
leaq 0xf2e(%rip), %rdi       # 0x2472
callq 0x1180
pushq $0xa
popq %rbp
movl %ebp, %edi
callq 0x1140
leaq 0xf44(%rip), %rdi       # 0x249e
callq 0x1180
leaq 0xf72(%rip), %rdi       # 0x24d8
callq 0x1180
leaq 0xf7f(%rip), %rdi       # 0x24f1
callq 0x1180
leaq 0xfc2(%rip), %rdi       # 0x2540
callq 0x1180
leaq 0xfd9(%rip), %rdi       # 0x2563
callq 0x1180
leaq 0x101c(%rip), %rdi      # 0x25b2
callq 0x1180
movl %ebp, %edi
callq 0x1140
leaq 0x1039(%rip), %rdi      # 0x25e2
callq 0x1180
leaq 0x1039(%rip), %rdi      # 0x25ee
callq 0x1180
leaq 0xa8f(%rip), %rdi       # 0x2050
movq %rbx, %rsi
xorl %eax, %eax
callq 0x1030
leaq 0x1041(%rip), %rdi      # 0x2613
callq 0x1180
leaq 0xa9c(%rip), %rdi       # 0x207a
movq %rbx, %rsi
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %rbp
jmp 0x1030
// File: /workspace/github_cpp_makefile_star2_O2/tsoding[P]wcc/src/./aids.hpp
// Function: aids::read_file_as_string_view(char const*)
Maybe<String_View> read_file_as_string_view(const char *filename)
    {
        FILE *f = fopen(filename, "rb");
        if (!f) return {};
        defer(fclose(f));

        int err = fseek(f, 0, SEEK_END);
        if (err < 0) return {};

        long size = ftell(f);
        if (size < 0) return {};

        err = fseek(f, 0, SEEK_SET);
        if (err < 0) return {};

        auto data = malloc(size);
        if (!data) return {};

        size_t read_size = fread(data, 1, size, f);
        if (read_size != (size_t) size && ferror(f)) return {};

        return {true, {static_cast<size_t>(size), static_cast<const char*>(data)}};
    }

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movq %rsi, %rax
movq %rdi, %rbx
leaq 0x70b4(%rip), %rsi      # 0x83ac
movq %rax, %rdi
callq 0x10e0
testq %rax, %rax
je 0x1380
movq %rax, %r14
pushq $0x2
popq %rdx
movq %rax, %rdi
xorl %esi, %esi
callq 0x10d0
testl %eax, %eax
js 0x136b
movq %r14, %rdi
callq 0x1030
testq %rax, %rax
js 0x136b
movq %rax, %r15
movq %r14, %rdi
xorl %esi, %esi
xorl %edx, %edx
callq 0x10d0
testl %eax, %eax
js 0x136b
movq %r15, %rdi
callq 0x1110
testq %rax, %rax
je 0x136b
movq %rax, %r12
pushq $0x1
popq %rsi
movq %rax, %rdi
movq %r15, %rdx
movq %r14, %rcx
callq 0x1130
cmpq %r15, %rax
je 0x1397
movq %r14, %rdi
callq 0x1180
testl %eax, %eax
je 0x1397
xorps %xmm0, %xmm0
movups %xmm0, (%rbx)
andq $0x0, 0x10(%rbx)
movq %r14, %rdi
callq 0x10a0
jmp 0x138b
xorps %xmm0, %xmm0
movups %xmm0, (%rbx)
andq $0x0, 0x10(%rbx)
movq %rbx, %rax
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
movb $0x1, (%rbx)
movq %r15, 0x8(%rbx)
movq %r12, 0x10(%rbx)
jmp 0x1376
// File: /workspace/github_cpp_makefile_star2_O2/tsoding[P]wcc/src/./aids.hpp
// Function: aids::sprint1(aids::String_Buffer*, char const*)
void sprint1(String_Buffer *buffer, const char *cstr)
    {
        int n = snprintf(
            buffer->data + buffer->size,
            buffer->capacity - buffer->size,
            "%s", cstr);
        buffer->size = min(buffer->size + n, buffer->capacity - 1);
    }

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %rbx
pushq %rax
movq %rsi, %rcx
movq %rdi, %rbx
movq (%rdi), %rsi
movq 0x10(%rdi), %rax
movq 0x8(%rdi), %rdi
addq %rax, %rdi
subq %rax, %rsi
leaq 0x6fc8(%rip), %rdx      # 0x83af
xorl %eax, %eax
callq 0x1140
cltq
addq 0x10(%rbx), %rax
movq (%rbx), %rcx
decq %rcx
cmpq %rax, %rcx
cmovaeq %rax, %rcx
movq %rcx, 0x10(%rbx)
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/tsoding[P]wcc/src/./aids.hpp
// Function: aids::sprint1(aids::String_Buffer*, aids::String_View)
void sprint1(String_Buffer *buffer, String_View view)
    {
        int n = snprintf(
            buffer->data + buffer->size,
            buffer->capacity - buffer->size,
            "%.*s", (int) view.count, view.data);
        buffer->size = min(buffer->size + n, buffer->capacity - 1);
    }

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %rbx
pushq %rax
movq %rdx, %r8
movq %rsi, %rcx
movq %rdi, %rbx
movq (%rdi), %rsi
movq 0x10(%rdi), %rax
movq 0x8(%rdi), %rdi
addq %rax, %rdi
subq %rax, %rsi
leaq 0x6f7f(%rip), %rdx      # 0x83b2
xorl %eax, %eax
callq 0x1140
cltq
addq 0x10(%rbx), %rax
movq (%rbx), %rcx
decq %rcx
cmpq %rax, %rcx
cmovaeq %rax, %rcx
movq %rcx, 0x10(%rbx)
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/tsoding[P]wcc/src/./aids.hpp
// Function: aids::sprint1(aids::String_Buffer*, char)
void sprint1(String_Buffer *buffer, char c)
    {
        int n = snprintf(
            buffer->data + buffer->size,
            buffer->capacity - buffer->size,
            "%c", c);
        buffer->size = min(buffer->size + n, buffer->capacity - 1);
    }

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %rbx
pushq %rax
movl %esi, %ecx
movq %rdi, %rbx
movq (%rdi), %rsi
movq 0x10(%rdi), %rax
movq 0x8(%rdi), %rdi
addq %rax, %rdi
subq %rax, %rsi
leaq 0x6f3c(%rip), %rdx      # 0x83b7
xorl %eax, %eax
callq 0x1140
cltq
addq 0x10(%rbx), %rax
movq (%rbx), %rcx
decq %rcx
cmpq %rax, %rcx
cmovaeq %rax, %rcx
movq %rcx, 0x10(%rbx)
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/tsoding[P]wcc/src/./aids.hpp
// Function: aids::sprint1(aids::String_Buffer*, float)
void sprint1(String_Buffer *buffer, float f)
    {
        int n = snprintf(
            buffer->data + buffer->size,
            buffer->capacity - buffer->size,
            "%f", f);
        buffer->size = min(buffer->size + n, buffer->capacity - 1);
    }

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %rbx
pushq %rax
movq %rdi, %rbx
movq (%rdi), %rsi
movq 0x10(%rdi), %rax
movq 0x8(%rdi), %rdi
addq %rax, %rdi
subq %rax, %rsi
cvtss2sd %xmm0, %xmm0
leaq 0x6ef5(%rip), %rdx      # 0x83ba
movb $0x1, %al
callq 0x1140
cltq
addq 0x10(%rbx), %rax
movq (%rbx), %rcx
decq %rcx
cmpq %rax, %rcx
cmovaeq %rax, %rcx
movq %rcx, 0x10(%rbx)
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/tsoding[P]wcc/src/./aids.hpp
// Function: aids::sprint1(aids::String_Buffer*, unsigned int)
void sprint1(String_Buffer *buffer, unsigned int x)
    {
        int n = snprintf(
            buffer->data + buffer->size,
            buffer->capacity - buffer->size,
            "%u", x);
        buffer->size = min(buffer->size + n, buffer->capacity - 1);
    }

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %rbx
pushq %rax
movl %esi, %ecx
movq %rdi, %rbx
movq (%rdi), %rsi
movq 0x10(%rdi), %rax
movq 0x8(%rdi), %rdi
addq %rax, %rdi
subq %rax, %rsi
leaq 0x6e6c(%rip), %rdx      # 0x83c2
xorl %eax, %eax
callq 0x1140
cltq
addq 0x10(%rbx), %rax
movq (%rbx), %rcx
decq %rcx
cmpq %rax, %rcx
cmovaeq %rax, %rcx
movq %rcx, 0x10(%rbx)
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/tsoding[P]wcc/src/./aids.hpp
// Function: aids::sprint1(aids::String_Buffer*, long)
void sprint1(String_Buffer *buffer, long int x)
    {
        int n = snprintf(
            buffer->data + buffer->size,
            buffer->capacity - buffer->size,
            "%ld", x);
        buffer->size = min(buffer->size + n, buffer->capacity - 1);
    }

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %rbx
pushq %rax
movq %rsi, %rcx
movq %rdi, %rbx
movq (%rdi), %rsi
movq 0x10(%rdi), %rax
movq 0x8(%rdi), %rdi
addq %rax, %rdi
subq %rax, %rsi
leaq 0x6d9c(%rip), %rdx      # 0x83cc
xorl %eax, %eax
callq 0x1140
cltq
addq 0x10(%rbx), %rax
movq (%rbx), %rcx
decq %rcx
cmpq %rax, %rcx
cmovaeq %rax, %rcx
movq %rcx, 0x10(%rbx)
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/tsoding[P]wcc/src/./aids.hpp
// Function: aids::print1(_IO_FILE*, aids::Escape)
void print1(FILE *stream, Escape escape)
    {
        for (size_t i = 0; i < escape.unwrap.count; ++i) {
            switch (escape.unwrap.data[i]) {
            case '\a': print(stream, "\\a"); break;
            case '\b': print(stream, "\\b"); break;
            case '\f': print(stream, "\\f"); break;
            case '\n': print(stream, "\\n"); break;
            case '\r': print(stream, "\\r"); break;
            case '\t': print(stream, "\\t"); break;
            case '\v': print(stream, "\\v"); break;
            default: print(stream, escape.unwrap.data[i]);
            }
        }
    }

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rdx, %rbx
movq %rsi, %r14
movq %rdi, %r15
xorl %r13d, %r13d
leaq 0x67ec(%rip), %r12      # 0x8010
cmpq %r13, %r14
je 0x18af
movzbl (%rbx,%r13), %eax
leal -0x7(%rax), %ecx
cmpl $0x6, %ecx
ja 0x1873
movslq (%r12,%rcx,4), %rax
addq %r12, %rax
jmpq *%rax
movq %r15, %rdi
leaq 0x6b8e(%rip), %rsi      # 0x83db
jmp 0x18a2
movq %r15, %rdi
leaq 0x6b94(%rip), %rsi      # 0x83ed
jmp 0x18a2
movq %r15, %rdi
leaq 0x6b85(%rip), %rsi      # 0x83ea
jmp 0x18a2
movq %r15, %rdi
leaq 0x6b73(%rip), %rsi      # 0x83e4
jmp 0x18a2
movsbl %al, %esi
movq %r15, %rdi
callq 0x174d
jmp 0x18a7
movq %r15, %rdi
leaq 0x6b54(%rip), %rsi      # 0x83de
jmp 0x18a2
movq %r15, %rdi
leaq 0x6b4b(%rip), %rsi      # 0x83e1
jmp 0x18a2
movq %r15, %rdi
leaq 0x6b45(%rip), %rsi      # 0x83e7
callq 0x16f9
incq %r13
jmp 0x1824
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/tsoding[P]wcc/src/./wcc_type_checker.cpp
// Function: Type_Checker::type_of_name(unsigned long, aids::String_View) const
Type Type_Checker::type_of_name(size_t offset, String_View name) const
{
    auto scope0 = scope;

    while (scope0) {
        Args_List *args_list = scope0->args_list;
        while (args_list) {
            if (name == args_list->var_def.name) {
                return args_list->var_def.type;
            }
            args_list = args_list->next;
        }
        scope0 = scope0->next;
    }

    reporter.fail(offset, "Could not find name `", name, "` in the current scope");
    return Type::Unchecked;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %rsi, %rbx
movq %rdi, %r14
leaq -0x38(%rbp), %r15
movq %rdx, (%r15)
movq %rcx, 0x8(%r15)
leaq 0x28(%rdi), %r12
movq (%r12), %r12
testq %r12, %r12
je 0x1aae
movq %r12, %r13
movq (%r13), %r13
testq %r13, %r13
je 0x1a95
movq (%r13), %rsi
movq 0x8(%r13), %rdx
movq %r15, %rdi
callq 0x5b90
testb %al, %al
jne 0x1a9b
addq $0x18, %r13
jmp 0x1a72
addq $0x8, %r12
jmp 0x1a66
movl 0x10(%r13), %eax
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
addq $0x8, %r14
movq -0x38(%rbp), %rcx
movq -0x30(%rbp), %r8
leaq 0x692f(%rip), %rdx      # 0x83f0
leaq 0x693e(%rip), %r9       # 0x8406
movq %r14, %rdi
movq %rbx, %rsi
callq 0x5bb6
nop
// File: /workspace/github_cpp_makefile_star2_O2/tsoding[P]wcc/src/./wcc_type_checker.cpp
// Function: Type_Checker::push_scope(Args_List*)
void Type_Checker::push_scope(Args_List *args_list)
{
    auto scope0 = memory->alloc<Scope>();
    scope0->args_list = args_list;
    scope0->next = scope;
    scope = scope0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
movq %rsi, %rbx
movq %rdi, %r14
movq (%rdi), %rdi
pushq $0x1
popq %rsi
callq 0x5be2
movq %rbx, (%rax)
movq 0x28(%r14), %rcx
movq %rcx, 0x8(%rax)
movq %rax, 0x28(%r14)
popq %rbx
popq %r14
popq %rbp
retq