LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O3/pwelke[P]GraphMiningTools/cactustree.c
// Function: computeComponentTree
struct Graph *computeComponentTree(struct Vertex **representatives,  struct ShallowGraph * bComponents, int numComponents, struct ShallowGraph **rootedComponents, struct GraphPool *gPool){
    struct Graph * componentTree = createGraph(numComponents, gPool);
    struct ShallowGraph *tmp, *shlp;
    int oldNumber, newNumber;
    struct Vertex *currentRoot;
    //TODO error behviour for componentTree 
    //printf("constructing component Tree\n");
    shlp=bComponents;
    while(shlp){
        currentRoot=shlp->edges->startPoint;
        oldNumber=currentRoot->number;
        newNumber=currentRoot->d;
        //No root should be processed twice, to avoid double edges.
        if(!(currentRoot->visited)){
            currentRoot->visited=1;
            //setting backreference to original graph.
            componentTree->vertices[newNumber]->d=oldNumber;
            //printf("testing for representative\n");
            if(representatives[oldNumber]){
                //printf("adding edge between original (%i,%i) and new (%i,%i)\n",representatives[shlp->edges->startPoint->number]->number, 
                        //shlp->edges->startPoint->number, newNumber, representatives[oldNumber]->d);
                addEdgeBetweenVertices(newNumber,representatives[oldNumber]->d,NULL,componentTree,gPool);
            }
            shlp->data=1;
            rootedComponents[newNumber]=shlp;
            shlp=shlp->next;
            rootedComponents[newNumber]->next=NULL; 
        }
        else{
            tmp=shlp->next;
            //data is used to keep track of componnents assigned to a root.
            shlp->data=rootedComponents[newNumber]->data+1;
            shlp->next=rootedComponents[newNumber];
            rootedComponents[newNumber]=shlp;
            shlp=tmp;
        }
    }
    return componentTree;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %r8, %rbx
movq %rcx, %r14
movq %rsi, %r12
movq %rdi, %r15
movl %edx, %edi
movq %r8, %rsi
callq 0x85e3
movq %rax, %r13
testq %r12, %r12
je 0x400d
movq (%r12), %rax
movq 0x10(%rax), %rax
movslq 0x28(%rax), %rbp
cmpl $0x0, 0x1c(%rax)
je 0x3fb9
movq 0x18(%r12), %rax
movq (%r14,%rbp,8), %rcx
movl 0x28(%rcx), %edx
incl %edx
movl %edx, 0x28(%r12)
movq %rcx, 0x18(%r12)
movq %r12, (%r14,%rbp,8)
jmp 0x4005
movslq 0x18(%rax), %rcx
movl $0x1, 0x1c(%rax)
movq 0x10(%r13), %rax
movq (%rax,%rbp,8), %rax
movl %ecx, 0x28(%rax)
movq (%r15,%rcx,8), %rax
testq %rax, %rax
je 0x3fea
movl 0x28(%rax), %esi
movl %ebp, %edi
xorl %edx, %edx
movq %r13, %rcx
movq %rbx, %r8
callq 0x84a3
movl $0x1, 0x28(%r12)
movq %r12, (%r14,%rbp,8)
movq 0x18(%r12), %rax
movq $0x0, 0x18(%r12)
movq %rax, %r12
jmp 0x3f80
movq %r13, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/pwelke[P]GraphMiningTools/cactustree.c
// Function: hasSolution
char hasSolution(struct Characteristics *characteristic){
    struct Characteristics *chlp=characteristic;
    int i;
    for(;chlp;chlp=chlp->next){
        for(i=0;i<chlp->size;++i){
            if(chlp->treeIDs[i][i]){
 //               printf("\n\nFOUND SOMETHING\n\n)");
                return 1;
            }
        }
    }
    return 0;
}

// Assembly:
testq %rdi, %rdi
je 0x41e1
movslq 0x4(%rdi), %rax
testq %rax, %rax
jle 0x41d8
movq 0x8(%rdi), %rcx
xorl %edx, %edx
movq (%rcx,%rdx,8), %rsi
cmpq $0x0, (%rsi,%rdx,8)
jne 0x41de
incq %rdx
cmpq %rdx, %rax
jne 0x41c5
movq 0x10(%rdi), %rdi
jmp 0x41b1
movb $0x1, %al
retq
xorl %eax, %eax
retq
// File: /workspace/github_c_makefile_star2_O3/pwelke[P]GraphMiningTools/cactustree.c
// Function: freeCharacteristics
void freeCharacteristics(struct Characteristics *characteristics){
    struct Characteristics *chlp1,*chlp2;
    struct TreeList *hlp1,*hlp2;
    int i, j;
    chlp1=characteristics;
    while(chlp1){
        for(i=0;i<chlp1->size;++i){
            for(j=0;j<chlp1->size;++j){
                hlp1=chlp1->treeIDs[i][j];
                while(hlp1){
                    hlp2=hlp1->next;
                    free(hlp1);
                    hlp1=hlp2;
                }
            }
            free(chlp1->treeIDs[i]);
        }
        free(chlp1->treeIDs);
        chlp2=chlp1->next;
        free(chlp1);
        chlp1=chlp2;
    }
}

// Assembly:
testq %rdi, %rdi
je 0x427a
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rdi, %rbx
movl 0x4(%rbx), %eax
testl %eax, %eax
jle 0x4252
xorl %r14d, %r14d
testl %eax, %eax
jle 0x4239
xorl %r15d, %r15d
movq 0x8(%rbx), %rcx
movq (%rcx,%r14,8), %rcx
movq (%rcx,%r15,8), %rdi
testq %rdi, %rdi
je 0x422e
movq 0x8(%rdi), %r12
callq 0x1030
movq %r12, %rdi
testq %r12, %r12
jne 0x421a
movl 0x4(%rbx), %eax
incq %r15
movslq %eax, %rcx
cmpq %rcx, %r15
jl 0x4209
movq 0x8(%rbx), %rax
movq (%rax,%r14,8), %rdi
callq 0x1030
incq %r14
movslq 0x4(%rbx), %rax
cmpq %rax, %r14
jl 0x4202
movq 0x8(%rbx), %rdi
callq 0x1030
movq 0x10(%rbx), %r14
movq %rbx, %rdi
callq 0x1030
movq %r14, %rbx
testq %r14, %r14
jne 0x41f8
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O3/pwelke[P]GraphMiningTools/cactustree.c
// Function: initSpanningTree
void initSpanningTree( struct ShallowGraph *rootedComponent, struct VertexList **deletedEdges, int mask){
    int i=0;
    struct ShallowGraph *shlp;
    struct VertexList *edgehlp;
    //printf("Initializing spanning tree for vertex %i\n", rootedComponent->edges->startPoint->number);
    for(shlp=rootedComponent; shlp; shlp=shlp->next){
        if(shlp->m > 1){
            //printf("Deleteing edge %i %i", shlp->edges->startPoint->number, shlp->edges->endPoint->number);
            deletedEdges[i]=shlp->edges;
            unmarkEdgeBetweenVertices(deletedEdges[i]->startPoint, deletedEdges[i]->endPoint,mask);
            for(edgehlp=deletedEdges[i]->next;edgehlp;edgehlp=edgehlp->next){
                //printf("marking edge reverse to %i %i", edgehlp->startPoint->number, edgehlp->endPoint->number);
                markEdgeBetweenVertices(edgehlp->endPoint, edgehlp->startPoint, mask);
            }
        }
        else{
            deletedEdges[i]=NULL;
            markEdgeBetweenVertices(shlp->edges->startPoint, shlp->edges->endPoint,mask);
        }
        i++;
    }
}

// Assembly:
testq %rdi, %rdi
je 0x4465
movl %edx, %eax
notl %eax
xorl %ecx, %ecx
cmpl $0x2, 0x10(%rdi)
jl 0x442f
movq (%rdi), %r8
movq %r8, (%rsi,%rcx,8)
movq 0x10(%r8), %r9
movq 0x18(%r8), %r10
movq 0x8(%r9), %r9
testq %r9, %r9
je 0x4424
cmpq %r10, 0x18(%r9)
jne 0x43f4
andl %eax, 0x24(%r9)
jmp 0x4424
movq 0x10(%r8), %r10
movq 0x18(%r8), %r9
movq 0x8(%r9), %r9
testq %r9, %r9
je 0x4424
cmpq %r10, 0x18(%r9)
jne 0x4411
orl %edx, 0x24(%r9)
movq 0x8(%r8), %r8
testq %r8, %r8
jne 0x4409
jmp 0x4455
movq $0x0, (%rsi,%rcx,8)
movq (%rdi), %r9
movq 0x10(%r9), %r8
movq 0x18(%r9), %r9
movq 0x8(%r8), %r8
testq %r8, %r8
je 0x4455
cmpq %r9, 0x18(%r8)
jne 0x4442
orl %edx, 0x24(%r8)
incq %rcx
movq 0x18(%rdi), %rdi
testq %rdi, %rdi
jne 0x43df
retq
// File: /workspace/github_c_makefile_star2_O3/pwelke[P]GraphMiningTools/cactustree.c
// Function: checkCharacteristic
char checkCharacteristic(struct Characteristics *characteristics, const int masterID, const int patternRoot, const int patternSubRoot, const int treeID){
    struct Characteristics *hlp=characteristics;
    for(; hlp && hlp->masterID < masterID; hlp=hlp->next);
    if (hlp && hlp->masterID==masterID) return checkTreeList(hlp->treeIDs[patternRoot][patternSubRoot], treeID);
    return 0;
}

// Assembly:
testq %rdi, %rdi
je 0x4c33
movl (%rdi), %eax
cmpl %esi, %eax
jge 0x4c0b
movq 0x10(%rdi), %rdi
jmp 0x4bfa
jne 0x4c33
movq 0x8(%rdi), %rax
movslq %edx, %rdx
movq (%rax,%rdx,8), %rax
movslq %ecx, %rcx
movq (%rax,%rcx,8), %rax
testq %rax, %rax
je 0x4c33
cmpl %r8d, (%rax)
jge 0x4c2f
movq 0x8(%rax), %rax
jmp 0x4c1f
movb $0x1, %al
je 0x4c35
xorl %eax, %eax
retq
// File: /workspace/github_c_makefile_star2_O3/pwelke[P]GraphMiningTools/cactustree.c
// Function: insertCharacteristic
struct Characteristics *insertCharacteristic(struct Characteristics * characteristics, int size, int masterID, int patternRoot, int patternSubRoot, int treeID){
    struct Characteristics *start=characteristics, *hlp1=characteristics, *hlp2;
    //printf("\tchar %i %i %i %i\n", masterID, patternRoot,patternSubRoot,treeID);
    if(hlp1 && hlp1->masterID<=masterID){
        //printf("\t\t\tinster at middle of chars\n");
        while(hlp1->next && hlp1->next->masterID <= masterID){
            hlp1=hlp1->next;
        }
        if(hlp1->masterID<masterID){
       // printf("\t\t\tinster at new Entry of chars\n");
            hlp2=allocateCharacteristics(size, masterID);
            hlp2->next=hlp1->next;
            hlp1->next=hlp2;
            hlp1=hlp2;
        }
        // o/w hlp1 is already at the equal entry.
    }
    else{//hlp1==NULL or beginning is larger.
        //printf("\t\t\tinster at beginning of chars\n");
        start=allocateCharacteristics(size,masterID);
        start->next=hlp1;//hlp1 is either NULL or the beginning.
        hlp1=start;
        
        // o/w we have already the right entry as it has the correct masterID.
    }
   // printCharacteristics(hlp1);
    //printf("insert %i %i %i at master %i\n",patternRoot, patternSubRoot, treeID,hlp1->masterID);
    //printTL(hlp1->treeIDs[patternRoot][patternSubRoot]);
    hlp1->treeIDs[patternRoot][patternSubRoot]=insertTree(hlp1->treeIDs[patternRoot][patternSubRoot],treeID);
    //printTL(hlp1->treeIDs[patternRoot][patternSubRoot]);
   // printCharacteristics(hlp1);
    //printf("char for return \n");
    //printCharacteristics(start);
    return start;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movl %r9d, %ebx
movl %r8d, %ebp
movl %ecx, %r15d
movq %rdi, %r14
testq %rdi, %rdi
je 0x4c57
cmpl %edx, (%r14)
jle 0x4ca3
movl %esi, %edi
movl %edx, %esi
callq 0x4d0a
movq %rax, %r12
movq %r14, 0x10(%rax)
movq %rax, %r14
movq 0x8(%r12), %rax
movslq %r15d, %r15
movq (%rax,%r15,8), %rax
movslq %ebp, %r13
movq (%rax,%r13,8), %rdi
movl %ebx, %esi
callq 0x4e16
movq 0x8(%r12), %rcx
movq (%rcx,%r15,8), %rcx
movq %rax, (%rcx,%r13,8)
movq %r14, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %r14, %rax
movq %rax, %r12
movq 0x10(%rax), %rax
testq %rax, %rax
je 0x4cb6
cmpl %edx, (%rax)
jle 0x4ca6
cmpl %edx, (%r12)
jge 0x4c6a
movl %esi, %edi
movl %edx, %esi
callq 0x4d0a
movq 0x10(%r12), %rcx
movq %rcx, 0x10(%rax)
movq %rax, 0x10(%r12)
movq %rax, %r12
jmp 0x4c6a
// File: /workspace/github_c_makefile_star2_O3/pwelke[P]GraphMiningTools/cactustree.c
// Function: allocateCharacteristics
struct Characteristics *allocateCharacteristics(int size, int master){
    struct Characteristics *ret;
    int i=0, j=0;
    ret=malloc(sizeof(struct Characteristics));
    if (!ret) return NULL;
    ret->size=size;
    ret->masterID=master;
    ret->treeIDs=malloc(size*sizeof(struct TreeList **));
    if(!(ret->treeIDs)){
        free(ret);
        return NULL;
    }
    
    for(;i<size;++i){
        ret->treeIDs[i]=calloc(size,sizeof(struct TreeList*));
        if(!(ret->treeIDs[i])){
            for(j=0;j<i;++j){
                free(ret->treeIDs[j]);
            }
            free(ret->treeIDs);
            return NULL;
        }
    }
    
    return ret;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movl %esi, %r14d
movl %edi, %ebp
movl $0x18, %edi
callq 0x1190
testq %rax, %rax
je 0x4d9b
movq %rax, %rbx
movl %ebp, 0x4(%rax)
movl %r14d, (%rax)
movslq %ebp, %r15
leaq (,%r15,8), %rdi
callq 0x1190
movq %rax, 0x8(%rbx)
testq %rax, %rax
je 0x4d93
testl %ebp, %ebp
jle 0x4d9d
movq %rax, %r14
movl %ebp, %r13d
xorl %r12d, %r12d
movl $0x8, %esi
movq %r15, %rdi
callq 0x1120
movq %rax, (%r14,%r12,8)
testq %rax, %rax
je 0x4d78
incq %r12
cmpq %r12, %r13
jne 0x4d58
jmp 0x4d9d
testq %r12, %r12
je 0x4d90
xorl %ebx, %ebx
movq (%r14,%rbx,8), %rdi
callq 0x1030
incq %rbx
cmpq %rbx, %r12
jne 0x4d7f
movq %r14, %rbx
movq %rbx, %rdi
callq 0x1030
xorl %ebx, %ebx
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/pwelke[P]GraphMiningTools/cactustree.c
// Function: mergeTreeArrays
struct TreeList ***mergeTreeArrays(struct TreeList ***one, struct TreeList ***two, int size){
    int i=0,j=0;
    for(;i<size;++i){
        for(j=0;j<size;++j){
            one[i][j]=mergeTreeLists(one[i][j], two[i][j]);
        }
        free(two[i]);
    }
    free(two);
    return one;
}

// Assembly:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
movq %rsi, %r14
movq %rdi, %rbx
testl %edx, %edx
jle 0x4e01
movl %edx, %r15d
xorl %r12d, %r12d
xorl %r13d, %r13d
movq (%rbx,%r12,8), %rax
movq (%rax,%r13,8), %rdi
movq (%r14,%r12,8), %rax
movq (%rax,%r13,8), %rsi
callq 0x4e78
movq (%rbx,%r12,8), %rcx
movq %rax, (%rcx,%r13,8)
incq %r13
cmpq %r13, %r15
jne 0x4dcb
movq (%r14,%r12,8), %rdi
callq 0x1030
incq %r12
cmpq %r15, %r12
jne 0x4dc8
movq %r14, %rdi
callq 0x1030
movq %rbx, %rax
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O3/pwelke[P]GraphMiningTools/cactustree.c
// Function: insertTree
struct TreeList* insertTree(struct TreeList *trees, int treeID){
    struct TreeList *treehlp=trees, *treehlp2=NULL;
    if(treehlp){
        if(treehlp->treeID <= treeID){
            while(treehlp->next && treehlp->next->treeID <= treeID){
                treehlp=treehlp->next;
            }
            if(treehlp->treeID<treeID){
                //printf("Inserting new tree in the middle\n");
                treehlp2=treehlp->next;
                treehlp->next=malloc(sizeof(struct TreeList));
                treehlp=treehlp->next;
                treehlp->treeID=treeID;
                treehlp->next=treehlp2;
            }
            return trees;
        }
    }
    //printf("insert at the beginning\n");
    treehlp2=malloc(sizeof(struct TreeList));
    treehlp2->treeID=treeID;
    treehlp2->next=treehlp;//treehlp is either null or has a larger treeID
    return treehlp2;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movl %esi, %ebp
movq %rdi, %rbx
testq %rdi, %rdi
je 0x4e2b
cmpl %ebp, (%rbx)
jle 0x4e4f
movl $0x10, %edi
callq 0x1190
movq %rbx, %r14
movq %rax, %rbx
movl %ebp, (%rax)
movq %r14, 0x8(%rax)
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
movq %rbx, %r14
movq %r14, %r15
movq 0x8(%r14), %r14
testq %r14, %r14
je 0x4e63
cmpl %ebp, (%r14)
jle 0x4e52
cmpl %ebp, (%r15)
jge 0x4e41
movl $0x10, %edi
callq 0x1190
movq %rax, 0x8(%r15)
jmp 0x4e3b
// File: /workspace/github_c_makefile_star2_O3/pwelke[P]GraphMiningTools/cactustree.c
// Function: mergeTreeLists
struct TreeList *mergeTreeLists(struct TreeList *one, struct TreeList *two){
    struct TreeList *hlp1=one, *hlp2=two, *hlp3, *start;
    if(!one) return two;
    if(!two) return one;
    if(one->treeID==two->treeID){//can only happen once as we keep the list sorted and compressed.
        hlp1=one->next;
        free(one);
    }
    //hlp1 may be null, if one had only one element.
    if(!hlp1) return two;
    if(hlp1->treeID>hlp2->treeID){
//        hlp3=hlp1; // value is never read.
        hlp1=hlp2;
        hlp2=hlp1;
    }
    start=hlp1;
    hlp1=hlp1->next;
    hlp3=start;
    while(hlp1 && hlp2){
        if(hlp1->treeID < hlp2->treeID){
            hlp3->next=hlp1;
            hlp1=hlp1->next;
        }
        else{
            hlp3->next=hlp2;
            if(hlp1->treeID==hlp2->treeID){
                hlp2=hlp1->next;
                free(hlp1);
                hlp1=hlp2;
                hlp2=hlp3;
            }
            hlp2=hlp2->next;
        }
        hlp3=hlp3->next;
    }
    if(hlp1) hlp3->next=hlp1;
    if(hlp2) hlp3->next=hlp2;
    return start;
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rsi, %r14
testq %rdi, %rdi
je 0x4f1e
movq %rdi, %rbx
testq %r14, %r14
je 0x4f21
movl (%rbx), %eax
movl (%r14), %ecx
cmpl %ecx, %eax
jne 0x4eb8
movq 0x8(%rbx), %r15
movq %rbx, %rdi
callq 0x1030
testq %r15, %r15
je 0x4f1e
movl (%r15), %eax
movl (%r14), %ecx
movq %r15, %rbx
cmpl %ecx, %eax
cmovgq %r14, %rbx
movq 0x8(%rbx), %rdi
movq %rbx, %r15
testq %rdi, %rdi
je 0x4f18
movl (%r14), %eax
cmpl %eax, (%rdi)
jge 0x4ede
movq %rdi, 0x8(%r15)
movq %rdi, %r15
movq 0x8(%rdi), %rdi
jmp 0x4f00
movq %r14, 0x8(%r15)
jne 0x4ef9
movq 0x8(%rdi), %r14
callq 0x1030
movq 0x8(%r15), %r15
movq %r14, %rdi
movq %r15, %r14
jmp 0x4f00
movq %r14, %r15
movq 0x8(%r14), %r14
testq %rdi, %rdi
je 0x4f0a
testq %r14, %r14
jne 0x4eca
testq %rdi, %rdi
je 0x4f13
movq %rdi, 0x8(%r15)
testq %r14, %r14
je 0x4f21
movq %r14, 0x8(%r15)
jmp 0x4f21
movq %r14, %rbx
movq %rbx, %rax
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O3/pwelke[P]GraphMiningTools/cactustree.c
// Function: bfs
int bfs(struct Graph *graph){

    struct Vertex **queue;
    struct VertexList *hlp;
    int i;
    queue=malloc(graph->n * sizeof(struct Vertex*));
    if(queue==NULL){
        printf("Could not initalise queue for BFS");
        return EXIT_FAILURE;
    }
    for(i=0;i<graph->n;++i) graph->vertices[i]->visited=0;

    for(i=0; i<graph->n;++i) graph->vertices[i]->visited=0;
    //TODO  disconnected graph here or preProcessing??
    queue[0] = graph->vertices[0];
    queue[0]->visited=1;
    queue[0]->d = 0; //TODO is using d ok???
    int end = 0;
    for(i=0;i<graph->n;++i){
        for(hlp=queue[i]->neighborhood;hlp;hlp=hlp->next) if(!hlp->endPoint->visited){
            queue[++end]=hlp->endPoint;
            queue[end]->visited=1;
            queue[end]->d=queue[i]->d+1;
        }

    } 
    free(queue);
    return EXIT_SUCCESS;
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
movslq (%rdi), %r14
leaq (,%r14,8), %rdi
callq 0x1190
testq %rax, %rax
je 0x5021
testl %r14d, %r14d
jle 0x5000
movq 0x10(%rbx), %rcx
xorl %edx, %edx
movq (%rcx,%rdx,8), %rsi
movl $0x0, 0x1c(%rsi)
incq %rdx
cmpq %rdx, %r14
jne 0x4f6f
testl %r14d, %r14d
jle 0x5000
movq 0x10(%rbx), %rcx
xorl %edx, %edx
movq (%rcx,%rdx,8), %rsi
movl $0x0, 0x1c(%rsi)
incq %rdx
cmpq %rdx, %r14
jne 0x4f8d
movq (%rcx), %rcx
movq %rcx, (%rax)
movl $0x1, 0x1c(%rcx)
movl $0x0, 0x28(%rcx)
testl %r14d, %r14d
jle 0x5015
xorl %ecx, %ecx
xorl %edx, %edx
movq (%rax,%rcx,8), %rsi
movq 0x8(%rsi), %rsi
testq %rsi, %rsi
je 0x4ff6
movq 0x18(%rsi), %rdi
cmpl $0x0, 0x1c(%rdi)
jne 0x4fc1
movslq %edx, %r8
incl %edx
movq %rdi, 0x8(%rax,%r8,8)
movl $0x1, 0x1c(%rdi)
movq (%rax,%rcx,8), %r8
movl 0x28(%r8), %r8d
incl %r8d
movl %r8d, 0x28(%rdi)
jmp 0x4fc1
incq %rcx
cmpq %r14, %rcx
jne 0x4fbd
jmp 0x5015
movq 0x10(%rbx), %rcx
movq (%rcx), %rcx
movl $0x1, 0x1c(%rcx)
movl $0x0, 0x28(%rcx)
movq %rax, %rdi
callq 0x1030
xorl %eax, %eax
jmp 0x5034
leaq 0x1b05c(%rip), %rdi     # 0x20084
xorl %eax, %eax
callq 0x10b0
movl $0x1, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O3/pwelke[P]GraphMiningTools/cactustree.c
// Function: printCharacteristics
void printCharacteristics(struct Characteristics *chars){
    struct Characteristics *hlp;
    struct TreeList *thlp;
    int i,j ,k;
    for(hlp=chars; hlp; hlp=hlp->next){
        k=0;
        printf("\n\tCA %li TIA %li",(long) hlp, (long)hlp->treeIDs);
        /*
    for (i=0;i<hlp->size;++i){
        printf("\t%i\n",hlp->treeIDs[i]);
        for(j=0;j<hlp->size;++j) printf("\t %i", hlp->treeIDs[i][j]);
        printf("\n\n");
    }
    */
    printf("\n\n");
        for(i=0;i<hlp->size;++i){
            for(j=0;j<hlp->size;++j){
                for(thlp=hlp->treeIDs[i][j];thlp;thlp=thlp->next){
                    printf("\t[%i %i %i %i ]",  hlp->masterID, i, j, thlp->treeID);
                    if(++k % 5 == 0){
                        printf("\n\t\t");
                        k=0;
                    }
                }
            }
        }
    }
    printf("\n");
}

// Assembly:
testq %rdi, %rdi
je 0x511a
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rdi, %rbx
leaq 0x1b05d(%rip), %r12     # 0x200b7
movq 0x8(%rbx), %rdx
leaq 0x1b041(%rip), %rdi     # 0x200a6
movq %rbx, %rsi
xorl %eax, %eax
callq 0x10b0
leaq 0x1b80a(%rip), %rdi     # 0x20880
callq 0x1070
movl 0x4(%rbx), %eax
testl %eax, %eax
jle 0x50ff
xorl %ebp, %ebp
xorl %r15d, %r15d
testl %eax, %eax
jle 0x50f4
xorl %r14d, %r14d
movq 0x8(%rbx), %rcx
movq (%rcx,%rbp,8), %rcx
movq (%rcx,%r14,8), %r13
testq %r13, %r13
je 0x50e9
movl (%rbx), %esi
movl (%r13), %r8d
movq %r12, %rdi
movl %ebp, %edx
movl %r14d, %ecx
xorl %eax, %eax
callq 0x10b0
imull $0xcccccccd, %r15d, %eax # imm = 0xCCCCCCCD
addl $0xe6666666, %eax       # imm = 0xE6666666
cmpl $0x33333332, %eax       # imm = 0x33333332
jbe 0x50cc
incl %r15d
jmp 0x50dd
xorl %r15d, %r15d
leaq 0x1aff1(%rip), %rdi     # 0x200c7
xorl %eax, %eax
callq 0x10b0
movq 0x8(%r13), %r13
testq %r13, %r13
jne 0x509f
movl 0x4(%rbx), %eax
incq %r14
movslq %eax, %rcx
cmpq %rcx, %r14
jl 0x508e
incq %rbp
movslq %eax, %rcx
cmpq %rcx, %rbp
jl 0x5087
movq 0x10(%rbx), %rbx
testq %rbx, %rbx
jne 0x505a
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
movl $0xa, %edi
jmp 0x1040
// File: /workspace/github_c_makefile_star2_O3/pwelke[P]GraphMiningTools/cactustree.c
// Function: printTL
void printTL(struct TreeList *tl){
    struct TreeList *hlp=tl;
    printf("\t[TL| ");
    for(;hlp;hlp=hlp->next) printf("%i   ",hlp->treeID);
    printf("\n");
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
leaq 0x1af99(%rip), %rdi     # 0x200cb
xorl %eax, %eax
callq 0x10b0
testq %rbx, %rbx
je 0x515a
leaq 0x1af8d(%rip), %r14     # 0x200d2
movl (%rbx), %esi
movq %r14, %rdi
xorl %eax, %eax
callq 0x10b0
movq 0x8(%rbx), %rbx
testq %rbx, %rbx
jne 0x5145
movl $0xa, %edi
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x1040
// File: /workspace/github_c_makefile_star2_O3/pwelke[P]GraphMiningTools/cactustree.c
// Function: freeAllPools
void freeAllPools(struct GraphPool *gPool, struct ShallowGraphPool *sgPool){
    if(gPool!=NULL){

        freeListPool(gPool->listPool);
        freeVertexPool(gPool->vertexPool);
        freeGraphPool(gPool);
    }
    if(sgPool!=NULL) freeShallowGraphPool(sgPool);
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %rbx
testq %rdi, %rdi
je 0x5194
movq %rdi, %r14
movq 0x18(%rdi), %rdi
callq 0x14199
movq 0x10(%r14), %rdi
callq 0x14426
movq %r14, %rdi
callq 0x14655
testq %rbx, %rbx
je 0x51a8
movq %rbx, %rdi
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x14935
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O3/pwelke[P]GraphMiningTools/connectedComponents.c
// Function: getComp
struct ShallowGraph* getComp(struct Vertex* v, int compNumber, struct ShallowGraph* comp, struct ListPool* lp) {
	struct VertexList* e;

	v->lowPoint = compNumber;

	for (e=v->neighborhood; e!=NULL; e=e->next) {
		/* go to the vertex, if it was not visited before */
		if (e->endPoint->lowPoint == -1) {
			getComp(e->endPoint, compNumber, comp, lp);
		} 
		/* add e = (v,w) to comp, if v<w. This is to have only one 
		copy of each edge in comp */
		if (e->startPoint->number < e->endPoint->number) {
			pushEdge(comp, shallowCopyEdge(e, lp));
		}
	}
	return comp;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rdx, %rbx
movl %esi, 0x20(%rdi)
movq 0x8(%rdi), %r15
testq %r15, %r15
je 0x5211
movq %rcx, %r14
movl %esi, %ebp
movq 0x18(%r15), %rdi
cmpl $-0x1, 0x20(%rdi)
jne 0x51e6
movl %ebp, %esi
movq %rbx, %rdx
movq %r14, %rcx
callq 0x51b0
movq 0x18(%r15), %rdi
movq 0x10(%r15), %rax
movl 0x18(%rax), %eax
cmpl 0x18(%rdi), %eax
jge 0x5208
movq %r15, %rdi
movq %r14, %rsi
callq 0x7bec
movq %rbx, %rdi
movq %rax, %rsi
callq 0x848a
movq 0x8(%r15), %r15
testq %r15, %r15
jne 0x51cb
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/pwelke[P]GraphMiningTools/connectedComponents.c
// Function: markComp
void markComp(struct Vertex* v, int compNumber) {
	struct VertexList* e;

	v->lowPoint = compNumber;

	for (e=v->neighborhood; e!=NULL; e=e->next) {
		if (e->endPoint->lowPoint == -1) {
			markComp(e->endPoint, compNumber);
		} 
	}
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movl %esi, 0x20(%rdi)
movq 0x8(%rdi), %r14
testq %r14, %r14
je 0x524b
movl %esi, %ebx
movq 0x18(%r14), %rdi
cmpl $-0x1, 0x20(%rdi)
jne 0x5242
movl %ebx, %esi
callq 0x521f
movq 0x8(%r14), %r14
testq %r14, %r14
jne 0x5231
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O3/pwelke[P]GraphMiningTools/connectedComponents.c
// Function: getConnectedComponents
struct ShallowGraph* getConnectedComponents(struct Graph* g, struct ShallowGraphPool* sgp) {
	int v;
	int i = 0;
	struct ShallowGraph* result = NULL;

	for (v=0; v<g->n; ++v) {
		g->vertices[v]->lowPoint = -1;
	}

	for (v=0; v<g->n; ++v) {
		if (g->vertices[v]->lowPoint == -1) {
			struct ShallowGraph* comp = getComp(g->vertices[v], i, getShallowGraph(sgp), sgp->listPool);
			comp->next = result;
			result = comp;
			++i;
		}
		/* there might be connected components consisting of a single vertex.
		in this case, we store its number in the -> data field of the shallow graph */
		if (g->vertices[v]->neighborhood == NULL) {
			result->data = v;
		}
	}
	return result;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %rsi, 0x10(%rsp)
movslq (%rdi), %rax
testq %rax, %rax
jle 0x52fd
movq 0x10(%rdi), %rcx
xorl %edx, %edx
movq (%rcx,%rdx,8), %rsi
movl $0xffffffff, 0x20(%rsi) # imm = 0xFFFFFFFF
incq %rdx
cmpq %rdx, %rax
jne 0x5278
xorl %r14d, %r14d
testl %eax, %eax
jle 0x52fd
movq 0x10(%rdi), %rax
xorl %ebx, %ebx
xorl %r12d, %r12d
movq %rdi, 0x8(%rsp)
movq 0x10(%rsp), %r15
movq (%rax,%rbx,8), %r13
cmpl $-0x1, 0x20(%r13)
jne 0x52e4
movq %r15, %rdi
callq 0x1498d
movq %rax, %rbp
movq 0x10(%r15), %rcx
movq %r13, %rdi
movl %r14d, %esi
movq %rax, %rdx
callq 0x51b0
movq 0x8(%rsp), %rdi
movq %r12, 0x18(%rbp)
incl %r14d
movq 0x10(%rdi), %rax
movq (%rax,%rbx,8), %r13
movq %rbp, %r12
cmpq $0x0, 0x8(%r13)
jne 0x52f0
movl %ebx, 0x28(%r12)
incq %rbx
movslq (%rdi), %rcx
cmpq %rcx, %rbx
jl 0x52a5
jmp 0x5300
xorl %r12d, %r12d
movq %r12, %rax
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/pwelke[P]GraphMiningTools/connectedComponents.c
// Function: getRepresentativeVertices
struct ShallowGraph* getRepresentativeVertices(struct Graph* g, struct ShallowGraphPool* sgp) {
	int v;
	int i = 0;
	struct ShallowGraph* result = getShallowGraph(sgp);

	for (v=0; v<g->n; ++v) {
		g->vertices[v]->lowPoint = -1;
	}

	for (v=0; v<g->n; ++v) {
		if (g->vertices[v]->lowPoint == -1) {
			struct VertexList* e = getVertexList(sgp->listPool);
			pushEdge(result, e);
			e->endPoint = g->vertices[v];
			markComp(g->vertices[v], i);
			++i;
		}
	}
	return result;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq %rdi, %r14
movq %rsi, %rdi
callq 0x1498d
movq %rax, %r15
movslq (%r14), %rax
testq %rax, %rax
jle 0x53a1
movq 0x10(%r14), %rcx
xorl %edx, %edx
movq (%rcx,%rdx,8), %rsi
movl $0xffffffff, 0x20(%rsi) # imm = 0xFFFFFFFF
incq %rdx
cmpq %rdx, %rax
jne 0x533c
testl %eax, %eax
jle 0x53a1
xorl %r13d, %r13d
xorl %ebp, %ebp
movq 0x10(%r14), %rcx
movq (%rcx,%r13,8), %rcx
cmpl $-0x1, 0x20(%rcx)
jne 0x5396
movq 0x10(%rbx), %rdi
callq 0x141f1
movq %rax, %r12
movq %r15, %rdi
movq %rax, %rsi
callq 0x848a
movq 0x10(%r14), %rax
movq (%rax,%r13,8), %rdi
movq %rdi, 0x18(%r12)
movl %ebp, %esi
callq 0x521f
incl %ebp
movl (%r14), %eax
incq %r13
movslq %eax, %rcx
cmpq %rcx, %r13
jl 0x5358
movq %r15, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/pwelke[P]GraphMiningTools/connectedComponents.c
// Function: isConnected
char isConnected(struct Graph* g) {
	int v;

	/* the empty graph is connected: for all pairs of vertices (there are none) there is a path :) */
	if (g->n == 0) {
		return 1;
	}

	for (v=0; v<g->n; ++v) {
		g->vertices[v]->lowPoint = -1;
	}

	markComp(g->vertices[0], 0);

	for (v=0; v<g->n; ++v) {
		if (g->vertices[v]->lowPoint == -1) {
			return 0;
		}
	}
	return 1;
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movl (%rdi), %eax
movb $0x1, %bl
testq %rax, %rax
je 0x540e
movq %rdi, %r14
movq 0x10(%rdi), %rcx
testl %eax, %eax
jle 0x53e0
xorl %edx, %edx
movq (%rcx,%rdx,8), %rsi
movl $0xffffffff, 0x20(%rsi) # imm = 0xFFFFFFFF
incq %rdx
cmpq %rdx, %rax
jne 0x53cd
movq (%rcx), %rdi
xorl %esi, %esi
callq 0x521f
movslq (%r14), %rax
testq %rax, %rax
jle 0x540e
movq 0x10(%r14), %rcx
xorl %edx, %edx
movq (%rcx,%rdx,8), %rsi
cmpl $-0x1, 0x20(%rsi)
je 0x540c
incq %rdx
cmpq %rdx, %rax
jne 0x53f8
jmp 0x540e
xorl %ebx, %ebx
movl %ebx, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O3/pwelke[P]GraphMiningTools/cs_Compare.c
// Function: compareDirectedEdges
int compareDirectedEdges(const void* p1, const void* p2) {
	struct VertexList* e1 = *(struct VertexList**)p1;
	struct VertexList* e2 = *(struct VertexList**)p2;

	if (e1->startPoint->number < e2->startPoint->number) {
		return -1;
	}
	if (e1->startPoint->number > e2->startPoint->number) {
		return 1;
	}
	if (e1->endPoint->number < e2->endPoint->number) {
		return -1;
	}
	if (e1->endPoint->number > e2->endPoint->number) {
		return 1;
	}
	return 0;

}

// Assembly:
movq (%rdi), %rcx
movq (%rsi), %rdx
movq 0x10(%rcx), %rsi
movq 0x10(%rdx), %rax
movl 0x18(%rax), %edi
movl $0xffffffff, %eax       # imm = 0xFFFFFFFF
cmpl %edi, 0x18(%rsi)
jl 0x5b0d
movl $0x1, %eax
jg 0x5b0d
movq 0x18(%rcx), %rcx
movq 0x18(%rdx), %rax
movl 0x18(%rax), %edx
movl $0xffffffff, %eax       # imm = 0xFFFFFFFF
cmpl %edx, 0x18(%rcx)
jl 0x5b0d
setg %al
movzbl %al, %eax
retq
// File: /workspace/github_c_makefile_star2_O3/pwelke[P]GraphMiningTools/cs_Cycle.c
// Function: _compareCycles
struct VertexList* __compareCycles(struct VertexList* c1, struct VertexList* c2) {
	struct VertexList* idx1 = c1;
	struct VertexList* idx2 = c2;

	/* check for differences in the following edges */
	for (idx1=idx1->next, idx2=idx2->next; idx1!=c1; idx1=idx1->next, idx2=idx2->next) {

		/* check for differences in the edge label */
		if (strcmp(idx1->label, idx2->label) < 0) {
			return c1;
		}
		if (strcmp(idx1->label, idx2->label) > 0) {
			return c2;
		}
		if (strcmp(idx1->label, idx2->label) == 0) {
			/* if edge labels do not differ, check for differences in endPoint label */
			if (strcmp(idx1->endPoint->label, idx2->endPoint->label) < 0) {
				return c1;
			}
			if (strcmp(idx1->endPoint->label, idx2->endPoint->label) > 0) {
				return c2;
			}
		}
	}

	/* check for differences in the edge label of the first edge*/
	if (strcmp(idx1->label, idx2->label) < 0) {
		return c1;
	}
	if (strcmp(idx1->label, idx2->label) > 0) {
		return c2;
	}
	if (strcmp(idx1->label, idx2->label) == 0) {
		/* if edge labels do not differ, check for differences in endPoint label */
		if (strcmp(idx1->endPoint->label, idx2->endPoint->label) < 0) {
			return c1;
		}
		if (strcmp(idx1->endPoint->label, idx2->endPoint->label) > 0) {
			return c2;
		}
	}

	/* if no difference is found, return c1 */
	return c1;
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rsi, %r14
movq %rdi, %rbx
movq %rdi, %r12
movq %rsi, %r15
movq 0x8(%r15), %r15
movq 0x8(%r12), %r12
movq (%r12), %rdi
movq (%r15), %rsi
callq 0x1140
cmpq %rbx, %r12
je 0x5bbc
testl %eax, %eax
js 0x5bc5
jne 0x5bc2
movq 0x18(%r12), %rax
movq (%rax), %rdi
movq 0x18(%r15), %rax
movq (%rax), %rsi
callq 0x1140
testl %eax, %eax
js 0x5bc5
je 0x5b80
jmp 0x5bc2
testl %eax, %eax
js 0x5bc5
je 0x5bd4
movq %r14, %rbx
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
movq 0x18(%r12), %rax
movq (%rax), %rdi
movq 0x18(%r15), %rax
movq (%rax), %rsi
callq 0x1140
testl %eax, %eax
js 0x5bc5
cmovneq %r14, %rbx
jmp 0x5bc5
// File: /workspace/github_c_makefile_star2_O3/pwelke[P]GraphMiningTools/cs_Cycle.c
// Function: compareShallowGraphCycles
struct ShallowGraph* compareShallowGraphCycles(struct ShallowGraph* c1, struct ShallowGraph* c2) {
	struct VertexList* smallest;

	c1->lastEdge->next = c1->edges;
	c2->lastEdge->next = c2->edges;

	/* see doc of __compareCycles for explanation of this call */
	smallest = __compareCycles(c1->lastEdge, c2->lastEdge);

	c1->lastEdge->next = NULL;
	c2->lastEdge->next = NULL;

	return (smallest == c1->lastEdge) ? c1 : c2;

}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq %rdi, %r14
movq (%rdi), %rax
movq 0x8(%rdi), %r15
movq %rax, 0x8(%r15)
movq (%rsi), %rax
movq 0x8(%rsi), %r12
movq %rax, 0x8(%r12)
movq %r15, %rdi
movq %r12, %rsi
callq 0x5b6c
xorl %ecx, %ecx
movq %rcx, 0x8(%r15)
movq %rcx, 0x8(%r12)
cmpq %r15, %rax
cmoveq %r14, %rbx
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O3/pwelke[P]GraphMiningTools/cs_Cycle.c
// Function: permutateCycle
struct ShallowGraph* permutateCycle(struct ShallowGraph* cycle) {
	struct VertexList* start = cycle->edges;
	struct VertexList* end = assertLastPointer(cycle);
	/* best points to the edge before the starting edge of the lex smallest cycle */
	struct VertexList* best = cycle->edges;
	struct VertexList* idx;

	/* make actual cycle */
	end->next = start;

	for (idx = start->next; idx != start; idx=idx->next) {
		best = __compareCycles(best, idx);
	}

	/* turn cycle s.t. the shallow graph is lex. smallest */
	cycle->edges = best->next;
	cycle->lastEdge = best;
	best->next = NULL;

	return cycle;
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rdi, %rbx
movq (%rdi), %r15
callq 0x893c
movq %rax, %rcx
movq (%rbx), %rax
movq %r15, 0x8(%rcx)
movq 0x8(%r15), %r14
cmpq %r15, %r14
je 0x5c77
movq %rax, %rdi
movq %r14, %rsi
callq 0x5b6c
movq 0x8(%r14), %r14
jmp 0x5c61
movq 0x8(%rax), %rcx
movq %rcx, (%rbx)
movq %rax, 0x8(%rbx)
movq $0x0, 0x8(%rax)
movq %rbx, %rax
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O3/pwelke[P]GraphMiningTools/cs_Cycle.c
// Function: _cycleToString
void __cycleToString(struct ShallowGraph* cycle, struct ShallowGraphPool* sgp) {
	struct VertexList* idx, *tmp;
	struct ShallowGraph* tmpString = getShallowGraph(sgp);

	appendEdge(tmpString, getInitialisatorEdge(sgp->listPool));

	for (idx=cycle->edges; idx; idx=tmp) {
		struct VertexList* endPoint = getVertexList(sgp->listPool);
		endPoint->label = idx->endPoint->label;

		tmp = idx->next;

		appendEdge(tmpString, idx);
		appendEdge(tmpString, endPoint);
	}

	appendEdge(tmpString, getTerminatorEdge(sgp->listPool));

	/* move all to cycle */
	cycle->edges = tmpString->edges;
	cycle->lastEdge = tmpString->lastEdge;
	cycle->m = tmpString->m;
	/* ->next and ->prev remain */

	/* dump tmpString */
	tmpString->edges = NULL;
	dumpShallowGraph(sgp, tmpString);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq %rdi, %r14
movq %rsi, %rdi
callq 0x1498d
movq %rax, %r15
movq 0x10(%rbx), %rdi
callq 0x709c
movq %r15, %rdi
movq %rax, %rsi
callq 0x8916
movq (%r14), %r12
testq %r12, %r12
je 0x5d06
movq 0x10(%rbx), %rdi
callq 0x141f1
movq %rax, %r13
movq 0x18(%r12), %rax
movq (%rax), %rax
movq %rax, (%r13)
movq 0x8(%r12), %rbp
movq %r15, %rdi
movq %r12, %rsi
callq 0x8916
movq %r15, %rdi
movq %r13, %rsi
callq 0x8916
movq %rbp, %r12
testq %rbp, %rbp
jne 0x5ccb
movq 0x10(%rbx), %rdi
callq 0x708a
movq %r15, %rdi
movq %rax, %rsi
callq 0x8916
movups (%r15), %xmm0
movups %xmm0, (%r14)
movl 0x10(%r15), %eax
movl %eax, 0x10(%r14)
movq $0x0, (%r15)
movq %rbx, %rdi
movq %r15, %rsi
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x149f4
// File: /workspace/github_c_makefile_star2_O3/pwelke[P]GraphMiningTools/cs_Cycle.c
// Function: canonicalStringOfCycle
struct ShallowGraph* canonicalStringOfCycle(struct ShallowGraph* cycle, struct ShallowGraphPool* sgp) {
	struct VertexList* idx;
	struct ShallowGraph* tmpString = getShallowGraph(sgp);

	appendEdge(tmpString, getInitialisatorEdge(sgp->listPool));

	for (idx=cycle->edges; idx; idx=idx->next) {
		struct VertexList* endPoint = getVertexList(sgp->listPool);
		endPoint->label = idx->endPoint->label;

		appendEdge(tmpString, shallowCopyEdge(idx, sgp->listPool));
		appendEdge(tmpString, endPoint);
	}

	appendEdge(tmpString, getTerminatorEdge(sgp->listPool));

	return tmpString;
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rsi, %r14
movq %rdi, %r15
movq %rsi, %rdi
callq 0x1498d
movq %rax, %rbx
movq 0x10(%r14), %rdi
callq 0x709c
movq %rbx, %rdi
movq %rax, %rsi
callq 0x8916
movq (%r15), %r15
testq %r15, %r15
je 0x5dbe
movq 0x10(%r14), %rdi
callq 0x141f1
movq %rax, %r12
movq 0x18(%r15), %rax
movq (%rax), %rax
movq %rax, (%r12)
movq 0x10(%r14), %rsi
movq %r15, %rdi
callq 0x7bec
movq %rbx, %rdi
movq %rax, %rsi
callq 0x8916
movq %rbx, %rdi
movq %r12, %rsi
callq 0x8916
movq 0x8(%r15), %r15
jmp 0x5d7a
movq 0x10(%r14), %rdi
callq 0x708a
movq %rbx, %rdi
movq %rax, %rsi
callq 0x8916
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O3/pwelke[P]GraphMiningTools/cs_Cycle.c
// Function: getCyclePatterns
struct ShallowGraph* getCyclePatterns(struct ShallowGraph* cycles, struct ShallowGraphPool* sgp) {
	struct ShallowGraph* idx;
	struct ShallowGraph* result = NULL;
	struct ShallowGraph* next;

	for (idx = cycles; idx; idx=next) {
		struct ShallowGraph* tmpResult1;
		struct ShallowGraph* rev;

		next = idx->next;

		tmpResult1 = result;
		idx = permutateCycle(idx);
		rev = permutateCycle(inverseCycle(idx, sgp));

		result = compareShallowGraphCycles(idx, rev);
		result->next = tmpResult1;

		/* dump the larger of the two cycles */
		(result == idx) ? dumpShallowGraph(sgp, rev) : dumpShallowGraph(sgp, idx);

		/* convert the cycle to its canonical string */
		__cycleToString(result, sgp);

	}

	return result;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
testq %rdi, %rdi
je 0x5e93
movq %rsi, %r13
movq %rdi, %r14
xorl %ebx, %ebx
movq %rsi, (%rsp)
movq 0x18(%r14), %rbp
movq %r14, %rdi
callq 0x5c43
movq %r14, %rdi
movq %r13, %rsi
callq 0x8965
movq %rax, %r15
movq %rax, %rdi
callq 0x5c43
movq (%r14), %rax
movq 0x8(%r14), %r13
movq %rax, 0x8(%r13)
movq (%r15), %rax
movq 0x8(%r15), %r12
movq %rax, 0x8(%r12)
movq %r13, %rdi
movq %r12, %rsi
callq 0x5b6c
xorl %ecx, %ecx
movq %rcx, 0x8(%r13)
movq %rcx, 0x8(%r12)
movq %r14, %r12
cmpq %r13, %rax
je 0x5e5b
movq %r15, %r12
movq %rbx, 0x18(%r12)
cmpq %r14, %r12
je 0x5e68
movq %r14, %r15
movq (%rsp), %r13
movq %r13, %rdi
movq %r15, %rsi
callq 0x149f4
movq %r12, %rdi
movq %r13, %rsi
callq 0x5c93
movq %rbp, %r14
movq %r12, %rbx
testq %rbp, %rbp
jne 0x5e01
jmp 0x5e96
xorl %r12d, %r12d
movq %r12, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/pwelke[P]GraphMiningTools/cs_Outerplanar.c
// Function: _appendDiagonal
void __appendDiagonal(struct ShallowGraph* diags, int start, int end, char* label, struct ListPool* p) {
	appendEdge(diags, getInitialisatorEdge(p));

	appendEdge(diags, getVertexList(p));
	diags->lastEdge->label = malloc(12*sizeof(char));
	diags->lastEdge->isStringMaster = 1;
	sprintf(diags->lastEdge->label, "%i", start);

	appendEdge(diags, getVertexList(p));
	diags->lastEdge->label = malloc(12*sizeof(char));
	diags->lastEdge->isStringMaster = 1;
	sprintf(diags->lastEdge->label, "%i", end);

	appendEdge(diags, getVertexList(p));
	diags->lastEdge->label = label;

	appendEdge(diags, getTerminatorEdge(p));
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %r8, %r14
movq %rcx, (%rsp)
movl %edx, %ebp
movl %esi, %r12d
movq %rdi, %rbx
movq %r8, %rdi
callq 0x709c
movq %rbx, %rdi
movq %rax, %rsi
callq 0x8916
movq %r14, %rdi
callq 0x141f1
movq %rbx, %rdi
movq %rax, %rsi
callq 0x8916
movl $0xc, %edi
callq 0x1190
movq 0x8(%rbx), %rcx
movq %rax, (%rcx)
movl $0x1, %r15d
movl %r15d, 0x28(%rcx)
leaq 0x1b2ba(%rip), %r13     # 0x215aa
movq %rax, %rdi
movq %r13, %rsi
movl %r12d, %edx
xorl %eax, %eax
callq 0x1210
movq %r14, %rdi
callq 0x141f1
movq %rbx, %rdi
movq %rax, %rsi
callq 0x8916
movl $0xc, %edi
callq 0x1190
movq 0x8(%rbx), %rcx
movq %rax, (%rcx)
movl %r15d, 0x28(%rcx)
movq %rax, %rdi
movq %r13, %rsi
movl %ebp, %edx
xorl %eax, %eax
callq 0x1210
movq %r14, %rdi
callq 0x141f1
movq %rbx, %rdi
movq %rax, %rsi
callq 0x8916
movq 0x8(%rbx), %rax
movq (%rsp), %rcx
movq %rcx, (%rax)
movq %r14, %rdi
callq 0x708a
movq %rbx, %rdi
movq %rax, %rsi
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x8916
// File: /workspace/github_c_makefile_star2_O3/pwelke[P]GraphMiningTools/cs_Outerplanar.c
// Function: canonicalStringOfOuterplanarGraph
struct ShallowGraph* canonicalStringOfOuterplanarGraph(struct ShallowGraph* original, struct ShallowGraphPool* sgp, struct GraphPool* gp) {
	struct Graph* g = shallowGraphToGraph(original, gp);
	struct ShallowGraph* hamiltonianCycle = __getCycleAndDiagonals(g, sgp);
	if (hamiltonianCycle != NULL) {
		struct ShallowGraph* diagonals = hamiltonianCycle->next;	
		struct ShallowGraph* cString;
		hamiltonianCycle->next = NULL;
		cString = canonicalStringOfOuterplanarBlock(hamiltonianCycle, diagonals, sgp);
		dumpGraph(gp, g);
		return cString;
	} else {
		dumpGraph(gp, g);
		return NULL;
	}
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rdx, %rbx
movq %rsi, %r15
movq %rdx, %rsi
callq 0x8250
movq %rax, %r14
movq %rax, %rdi
movq %r15, %rsi
callq 0x6817
testq %rax, %rax
je 0x706a
movq 0x18(%rax), %rsi
movq $0x0, 0x18(%rax)
movq %rax, %rdi
movq %r15, %rdx
callq 0x66dc
movq %rax, %r15
jmp 0x706d
xorl %r15d, %r15d
movq %rbx, %rdi
movq %r14, %rsi
callq 0x14700
movq %r15, %rax
popq %rbx
popq %r14
popq %r15
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O3/pwelke[P]GraphMiningTools/cs_Parsing.c
// Function: canonicalStringToChar
char* canonicalStringToChar(struct ShallowGraph* string) {
	char* out;
	struct VertexList* e;
	int size = 0;
	int i;

	/* count the space needed for the string (+1 for a whitespace separating two labels) */
	for (e=string->edges; e; e=e->next) {
		size += strlen(e->label) + 1;
	}
	out = malloc((size + 1) * sizeof(char));


	for (e=string->edges, i=0; e; e=e->next) {
		sprintf(&(out[i]), "%s ", e->label);
		i += strlen(e->label) + 1;
	}

	return out;
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq (%rdi), %r15
testq %r15, %r15
je 0x712d
xorl %ebx, %ebx
movq %r15, %r14
movq (%r14), %rdi
callq 0x10a0
addl %eax, %ebx
incl %ebx
movq 0x8(%r14), %r14
testq %r14, %r14
jne 0x70c3
incl %ebx
movslq %ebx, %rdi
callq 0x1190
movq %rax, %rbx
testq %r15, %r15
je 0x711e
leaq 0x190fe(%rip), %r14     # 0x201ef
xorl %eax, %eax
movslq %eax, %r12
leaq (%rbx,%r12), %rdi
movq (%r15), %rdx
movq %r14, %rsi
xorl %eax, %eax
callq 0x1210
movq (%r15), %rdi
callq 0x10a0
addq %r12, %rax
incq %rax
movq 0x8(%r15), %r15
testq %r15, %r15
jne 0x70f3
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
movl $0x1, %edi
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
jmp 0x1190
// File: /workspace/github_c_makefile_star2_O3/pwelke[P]GraphMiningTools/cs_Parsing.c
// Function: printCanonicalString
void printCanonicalString(struct ShallowGraph* s, FILE* stream) {
	struct VertexList *i;
	for (i=s->edges; i; i = i->next) {	
		char* j;
		for (j=i->label; *j != '\0'; ++j) {
			fputc(*j, stream);
		}
		fputc(' ', stream);
	}
	fputc('\n', stream);
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rsi, %rbx
movq (%rdi), %r14
testq %r14, %r14
je 0x7187
movq (%r14), %r15
movb (%r15), %al
testb %al, %al
je 0x7174
incq %r15
movsbl %al, %edi
movq %rbx, %rsi
callq 0x1110
movb (%r15), %al
incq %r15
testb %al, %al
jne 0x715f
movl $0x20, %edi
movq %rbx, %rsi
callq 0x1110
movq 0x8(%r14), %r14
jmp 0x714d
movl $0xa, %edi
movq %rbx, %rsi
popq %rbx
popq %r14
popq %r15
jmp 0x1110
// File: /workspace/github_c_makefile_star2_O3/pwelke[P]GraphMiningTools/cs_Parsing.c
// Function: _notDone
char __notDone(FILE* stream) {
	int c;
    for (c = fgetc(stream); c == ' '; c = fgetc(stream));
    ungetc(c, stream);
	return (c != '\0') && (c != '\n');
}

// Assembly:
pushq %rbp
pushq %rbx
pushq %rax
movq %rdi, %rbx
callq 0x10e0
cmpl $0x20, %eax
jne 0x71d9
movq %rbx, %rdi
jmp 0x71ca
movl %eax, %ebp
movl %eax, %edi
movq %rbx, %rsi
callq 0x11b0
testl %ebp, %ebp
setne %cl
cmpl $0xa, %ebp
setne %al
andb %cl, %al
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/pwelke[P]GraphMiningTools/cs_Parsing.c
// Function: parseCString
struct ShallowGraph* parseCString(FILE* stream, char* buffer, struct ShallowGraphPool* sgp) {
	struct ShallowGraph* string = getShallowGraph(sgp);
	struct VertexList* e;
	
	while (__notDone(stream)) {
		__readLabel(stream, buffer);
		e = getVertexList(sgp->listPool);
		if (strcmp(buffer, termString) == 0) {
			e->label = termString;
		} else {
			if (strcmp(buffer, initString) == 0) {
				e->label = initString;
			} else {
				int length = strlen(buffer) + 1;
				char* label = malloc(length * sizeof(char));
				strcpy(label, buffer);
				e->label = label;
				e->isStringMaster = 1;
			}
		}
		appendEdge(string, e);
	}
	return string;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rdx, %rbx
movq %rsi, %r14
movq %rdi, %r15
movq %rdx, %rdi
callq 0x1498d
movq %rax, %r12
movq %r15, %rdi
callq 0x71c4
testb %al, %al
je 0x72e3
movq %r15, %rdi
movq %r14, %rsi
callq 0x71f9
movq 0x10(%rbx), %rdi
callq 0x141f1
movq %rax, %r13
movq 0x25ed4(%rip), %rbp     # 0x2d150
movq %r14, %rdi
movq %rbp, %rsi
callq 0x1140
testl %eax, %eax
je 0x72cf
movq 0x25eb6(%rip), %rbp     # 0x2d148
movq %r14, %rdi
movq %rbp, %rsi
callq 0x1140
testl %eax, %eax
je 0x72cf
movq %r14, %rdi
callq 0x10a0
incl %eax
movslq %eax, %rdi
callq 0x1190
movq %rax, %rbp
movq %rax, %rdi
movq %r14, %rsi
callq 0x1050
movq %rbp, (%r13)
movl $0x1, 0x28(%r13)
jmp 0x72d3
movq %rbp, (%r13)
movq %r12, %rdi
movq %r13, %rsi
callq 0x8916
jmp 0x724e
movq %r12, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/pwelke[P]GraphMiningTools/cs_Parsing.c
// Function: string2cstring
struct ShallowGraph* string2cstring(char* str, struct ShallowGraphPool* sgp) {
	FILE* f = str2stream(str);
	char x[20];
	struct ShallowGraph* cstr = parseCString(f, x, sgp);
	fclose(f);
	return cstr;
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %rsi, %rbx
movq %rdi, %r14
leaq 0x18de5(%rip), %r15     # 0x200f2
leaq 0x1a3bf(%rip), %rsi     # 0x216d3
movq %r15, %rdi
callq 0x11d0
movq %rax, %r12
movq %r14, %rdi
movq %rax, %rsi
callq 0x10c0
movq %r12, %rdi
callq 0x1090
leaq 0x18dc4(%rip), %rsi     # 0x200fd
movq %r15, %rdi
callq 0x11d0
movq %rax, %r14
movq %rsp, %rsi
movq %rax, %rdi
movq %rbx, %rdx
callq 0x722f
movq %rax, %rbx
movq %r14, %rdi
callq 0x1090
movq %rbx, %rax
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq