LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O2/pwelke[P]GraphMiningTools/cachedGraph.c
// Function: returnCachedGraph
void returnCachedGraph(struct CachedGraph* cache) {
	struct Vertex** vertices = cache->g->vertices;
	struct ListPool* lp = cache->gp->listPool;
	int n = cache->g->n;
	for (int wi=0; wi<n; ++wi) {
		struct Vertex* w = vertices[wi];
		dumpVertexListRecursively(lp, w->neighborhood);
		wipeVertexButKeepNumber(w);
	}
	cache->inUse = 0;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rdi, %rbx
movq 0x8(%rdi), %rax
movq 0x20(%rdi), %rcx
movq 0x10(%rax), %r12
movq 0x18(%rcx), %r14
movl (%rax), %r13d
xorl %ebp, %ebp
testl %r13d, %r13d
cmovlel %ebp, %r13d
cmpq %rbp, %r13
je 0x2020
movq (%r12,%rbp,8), %r15
movq 0x8(%r15), %rsi
movq %r14, %rdi
callq 0x1138e
movq %r15, %rdi
callq 0x11502
incq %rbp
jmp 0x1ffe
movb $0x0, (%rbx)
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/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 0x630e
movq %rax, %r13
testq %r12, %r12
je 0x2293
movq (%r12), %rax
movq 0x10(%rax), %rax
movslq 0x28(%rax), %rbp
cmpl $0x0, 0x1c(%rax)
je 0x2242
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)
movq %rax, %r12
jmp 0x2206
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 0x2273
movl 0x28(%rax), %esi
movl %ebp, %edi
xorl %edx, %edx
movq %r13, %rcx
movq %rbx, %r8
callq 0x6200
movl $0x1, 0x28(%r12)
movq %r12, (%r14,%rbp,8)
movq 0x18(%r12), %rax
andq $0x0, 0x18(%r12)
movq %rax, %r12
jmp 0x2206
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_O2/pwelke[P]GraphMiningTools/cactustree.c
// Function: processRootTree
struct Characteristics *processRootTree(struct Vertex *root, struct Graph *graph, struct ShallowGraph **rootedComponents, struct Graph *pattern, struct GraphPool *gPool, struct ShallowGraphPool *sgPool){
    struct VertexList *ehlp;
    struct VertexList **deletedEdges;
    struct Characteristics *chars=NULL, *newChars, *res;
    int numComponents, treeNumber=0;
    char exNext;
    root->visited=root->visited | 1;
    for(ehlp=root->neighborhood;ehlp;ehlp=ehlp->next){
        if(1^(ehlp->endPoint->visited)){
            res=processRootTree(ehlp->endPoint, graph, rootedComponents, pattern, gPool, sgPool);
            if(hasSolution(res)){
                freeCharacteristics(chars);
                return res;
            }
            chars=mergeCharacteristics(chars,res);
        }
    }
    //printf("root tree %i", root->number);
    //printCharacteristics(chars);

    numComponents=rootedComponents[root->number]->data;
    deletedEdges=malloc(numComponents*sizeof(struct VertexList *));
    newChars=NULL;
    initSpanningTree(rootedComponents[root->number], deletedEdges,1);
    treeNumber=0;
    do{
        newChars=processComponentTree(graph, graph->vertices[root->d], graph->vertices[root->d], treeNumber, rootedComponents, chars, newChars, pattern, gPool, sgPool);
        exNext=nextSpanningTree(rootedComponents[root->number], deletedEdges,1);
        ++treeNumber;
    }while(exNext);
    freeCharacteristics(chars);
    free(deletedEdges);
    return newChars;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x28, %rsp
movq %r9, %r14
movq %rdi, %r12
orb $0x1, 0x1c(%rdi)
movq %rdx, %r13
movq %rsi, %rbp
xorl %r15d, %r15d
movq %rdi, %rbx
movq %rcx, 0x18(%rsp)
movq %r8, 0x10(%rsp)
movq %r9, 0x8(%rsp)
movq 0x8(%rbx), %rbx
testq %rbx, %rbx
je 0x232b
movq 0x18(%rbx), %rdi
cmpl $0x1, 0x1c(%rdi)
je 0x22d8
movq %rbp, %rsi
movq %r13, %rdx
movq %r14, %r9
callq 0x22a5
movq %rax, %r14
movq %rax, %rdi
callq 0x23da
movq %r15, %rdi
testb %al, %al
jne 0x23d3
movq %r14, %rsi
callq 0x248e
movq %rax, %r15
movq 0x10(%rsp), %r8
movq 0x18(%rsp), %rcx
movq 0x8(%rsp), %r14
jmp 0x22d8
movslq 0x18(%r12), %rdx
movq (%r13,%rdx,8), %rbx
movslq 0x28(%rbx), %rdi
shlq $0x3, %rdi
movq %r15, 0x20(%rsp)
callq 0x1180
pushq $0x1
popq %rdx
movq %rbx, %rdi
movq %rax, %r15
movq %rax, %rsi
callq 0x25c3
xorl %r14d, %r14d
xorl %ebx, %ebx
movq 0x10(%rbp), %rax
movslq 0x28(%r12), %rcx
movq (%rax,%rcx,8), %rdx
movq %rbp, %rdi
movq %rdx, %rsi
movl %ebx, %ecx
movq %r13, %r8
movq 0x20(%rsp), %r9
pushq 0x8(%rsp)
pushq 0x18(%rsp)
pushq 0x28(%rsp)
pushq %r14
callq 0x2641
addq $0x20, %rsp
movq %rax, %r14
movslq 0x18(%r12), %rax
movq (%r13,%rax,8), %rdi
movq %r15, %rsi
pushq $0x1
popq %rdx
callq 0x27ba
incl %ebx
testb %al, %al
jne 0x235d
movq 0x20(%rsp), %rdi
callq 0x2411
movq %r15, %rdi
callq 0x1030
movq %r14, %rax
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
callq 0x2411
jmp 0x23c1
// File: /workspace/github_c_makefile_star2_O2/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:
xorl %eax, %eax
testq %rdi, %rdi
je 0x240e
movl 0x4(%rdi), %ecx
testl %ecx, %ecx
cmovlel %eax, %ecx
xorl %edx, %edx
cmpq %rdx, %rcx
je 0x2405
movq 0x8(%rdi), %rsi
movq (%rsi,%rdx,8), %rsi
cmpq $0x0, (%rsi,%rdx,8)
leaq 0x1(%rdx), %rdx
je 0x23eb
jmp 0x240b
movq 0x10(%rdi), %rdi
jmp 0x23dc
movb $0x1, %al
retq
xorl %eax, %eax
retq
// File: /workspace/github_c_makefile_star2_O2/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:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rdi, %rbx
testq %rbx, %rbx
je 0x2482
xorl %r14d, %r14d
movslq 0x4(%rbx), %rax
cmpq %rax, %r14
jge 0x2468
xorl %r15d, %r15d
cltq
movq 0x8(%rbx), %rcx
movq (%rcx,%r14,8), %rdi
cmpq %rax, %r15
jge 0x245e
movq (%rdi,%r15,8), %rdi
testq %rdi, %rdi
je 0x2456
movq 0x8(%rdi), %r12
callq 0x1030
movq %r12, %rdi
jmp 0x2443
incq %r15
movl 0x4(%rbx), %eax
jmp 0x2430
callq 0x1030
incq %r14
jmp 0x2424
movq 0x8(%rbx), %rdi
callq 0x1030
movq 0x10(%rbx), %r14
movq %rbx, %rdi
callq 0x1030
movq %r14, %rbx
jmp 0x241c
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O2/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:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
movl %edx, %ebx
movq %rsi, %r14
movq %rdi, %r15
xorl %r12d, %r12d
testq %r15, %r15
je 0x2637
cmpl $0x2, 0x10(%r15)
jl 0x2617
movq (%r15), %rax
movq %rax, (%r14,%r12,8)
movq 0x10(%rax), %rdi
movq 0x18(%rax), %rsi
movl %ebx, %edx
callq 0x2df0
movq (%r14,%r12,8), %r13
movq 0x8(%r13), %r13
testq %r13, %r13
je 0x262e
movq 0x10(%r13), %rsi
movq 0x18(%r13), %rdi
movl %ebx, %edx
callq 0x2e05
jmp 0x25fd
andq $0x0, (%r14,%r12,8)
movq (%r15), %rax
movq 0x10(%rax), %rdi
movq 0x18(%rax), %rsi
movl %ebx, %edx
callq 0x2e05
incq %r12
movq 0x18(%r15), %r15
jmp 0x25d7
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O2/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 0x2d6f
cmpl %edx, (%r14)
jle 0x2dbb
movl %esi, %edi
movl %edx, %esi
callq 0x2e22
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 0x2f3c
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 0x2dce
cmpl %edx, (%rax)
jle 0x2dbe
cmpl %edx, (%r12)
jge 0x2d82
movl %esi, %edi
movl %edx, %esi
callq 0x2e22
movq 0x10(%r12), %rcx
movq %rcx, 0x10(%rax)
movq %rax, 0x10(%r12)
movq %rax, %r12
jmp 0x2d82
// File: /workspace/github_c_makefile_star2_O2/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, %ebp
movl %edi, %r15d
pushq $0x18
popq %rdi
callq 0x1180
testq %rax, %rax
je 0x2eaf
movq %rax, %rbx
movl %r15d, 0x4(%rax)
movl %ebp, (%rax)
movslq %r15d, %r12
leaq (,%r12,8), %rdi
callq 0x1180
movq %rax, 0x8(%rbx)
testq %rax, %rax
je 0x2ea7
movq %rax, %r14
xorl %ebp, %ebp
testl %r15d, %r15d
cmovlel %ebp, %r15d
pushq $0x8
popq %r13
cmpq %rbp, %r15
je 0x2eb1
movq %r12, %rdi
movq %r13, %rsi
callq 0x1110
movq %rax, (%r14,%rbp,8)
testq %rax, %rax
je 0x2e8f
incq %rbp
jmp 0x2e71
xorl %ebx, %ebx
cmpq %rbx, %rbp
je 0x2ea4
movq (%r14,%rbx,8), %rdi
callq 0x1030
incq %rbx
jmp 0x2e91
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_O2/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 %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rsi, %r14
movq %rdi, %rbx
xorl %r15d, %r15d
testl %edx, %edx
movl $0x0, %r12d
cmovgl %edx, %r12d
movl %edx, %r13d
cmpq %r12, %r15
je 0x2f22
xorl %ebp, %ebp
cmpq %rbp, %r13
je 0x2f14
movq (%rbx,%r15,8), %rax
movq (%rax,%rbp,8), %rdi
movq (%r14,%r15,8), %rax
movq (%rax,%rbp,8), %rsi
callq 0x2f9a
movq (%rbx,%r15,8), %rcx
movq %rax, (%rcx,%rbp,8)
incq %rbp
jmp 0x2eed
movq (%r14,%r15,8), %rdi
callq 0x1030
incq %r15
jmp 0x2ee6
movq %r14, %rdi
callq 0x1030
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_O2/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 0x2f51
cmpl %ebp, (%rbx)
jle 0x2f73
pushq $0x10
popq %rdi
callq 0x1180
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 0x2f87
cmpl %ebp, (%r14)
jle 0x2f76
cmpl %ebp, (%r15)
jge 0x2f65
pushq $0x10
popq %rdi
callq 0x1180
movq %rax, 0x8(%r15)
jmp 0x2f5f
// File: /workspace/github_c_makefile_star2_O2/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 %r12
pushq %rbx
pushq %rax
movq %rsi, %r14
testq %rdi, %rdi
je 0x3028
movq %rdi, %rbx
testq %r14, %r14
je 0x303f
movl (%rbx), %eax
movl (%r14), %ecx
cmpl %ecx, %eax
jne 0x2fd9
movq 0x8(%rbx), %r15
movq %rbx, %rdi
callq 0x1030
testq %r15, %r15
je 0x3028
movl (%r15), %eax
movl (%r14), %ecx
movq %r15, %rbx
cmpl %ecx, %eax
cmovgq %r14, %rbx
movq 0x8(%rbx), %r12
movq %rbx, %rdi
movq %rdi, %r15
movq %r12, %rdi
testq %rdi, %rdi
je 0x302d
testq %r14, %r14
je 0x302d
movl (%r14), %eax
cmpl %eax, (%rdi)
jl 0x300c
movq %r14, 0x8(%r15)
je 0x3016
movq %r14, %r15
movq 0x8(%r14), %r14
jmp 0x2fec
movq %rdi, 0x8(%r15)
movq 0x8(%rdi), %r12
jmp 0x2fe6
movq 0x8(%rdi), %r12
callq 0x1030
movq 0x8(%r15), %r14
movq %r14, %rdi
jmp 0x2fe6
movq %r14, %rbx
jmp 0x303f
testq %rdi, %rdi
je 0x3036
movq %rdi, 0x8(%r15)
testq %r14, %r14
je 0x303f
movq %r14, 0x8(%r15)
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O2/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 0x1180
testq %rax, %rax
je 0x311f
xorl %ecx, %ecx
testl %r14d, %r14d
cmovlel %ecx, %r14d
cmpq %rcx, %r14
je 0x30a3
movq 0x10(%rbx), %rdx
movq (%rdx,%rcx,8), %rdx
andl $0x0, 0x1c(%rdx)
incq %rcx
jmp 0x308d
movq 0x10(%rbx), %rcx
xorl %edx, %edx
cmpq %rdx, %r14
je 0x30bb
movq (%rcx,%rdx,8), %rsi
andl $0x0, 0x1c(%rsi)
incq %rdx
jmp 0x30a9
movq (%rcx), %rcx
movq %rcx, (%rax)
movl $0x1, 0x1c(%rcx)
andl $0x0, 0x28(%rcx)
xorl %ecx, %ecx
xorl %edx, %edx
cmpq %r14, %rcx
je 0x3113
movq (%rax,%rcx,8), %rsi
movq 0x8(%rsi), %rsi
testq %rsi, %rsi
je 0x310e
movq 0x18(%rsi), %rdi
cmpl $0x0, 0x1c(%rdi)
jne 0x30d9
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 0x30d9
incq %rcx
jmp 0x30d0
movq %rax, %rdi
callq 0x1030
xorl %eax, %eax
jmp 0x3130
leaq 0x19f5e(%rip), %rdi     # 0x1d084
xorl %eax, %eax
callq 0x10b0
pushq $0x1
popq %rax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O2/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:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rdi, %rbx
leaq 0x19f6a(%rip), %r12     # 0x1d0b7
testq %rbx, %rbx
je 0x31fd
movq 0x8(%rbx), %rdx
xorl %ebp, %ebp
leaq 0x19f43(%rip), %rdi     # 0x1d0a6
movq %rbx, %rsi
xorl %eax, %eax
callq 0x10b0
leaq 0x1a6d7(%rip), %rdi     # 0x1d84b
callq 0x1070
movl 0x4(%rbx), %eax
xorl %r14d, %r14d
movslq %eax, %rcx
cmpq %rcx, %rbp
jge 0x31f4
xorl %r15d, %r15d
movslq %eax, %rcx
cmpq %rcx, %r15
jge 0x31ef
movq 0x8(%rbx), %rax
leaq (,%r15,8), %r13
addq (%rax,%rbp,8), %r13
movq (%r13), %r13
testq %r13, %r13
je 0x31e7
movl (%rbx), %esi
movl (%r13), %r8d
movq %r12, %rdi
movl %ebp, %edx
movl %r15d, %ecx
xorl %eax, %eax
callq 0x10b0
incl %r14d
movl %r14d, %eax
cltd
pushq $0x5
popq %rcx
idivl %ecx
testl %edx, %edx
jne 0x31e1
xorl %r14d, %r14d
leaq 0x19eed(%rip), %rdi     # 0x1d0c7
xorl %eax, %eax
callq 0x10b0
addq $0x8, %r13
jmp 0x31a2
incq %r15
movl 0x4(%rbx), %eax
jmp 0x318a
incq %rbp
jmp 0x317f
movq 0x10(%rbx), %rbx
jmp 0x314d
pushq $0xa
popq %rdi
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x1040
// File: /workspace/github_c_makefile_star2_O2/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 0x19eaa(%rip), %rdi     # 0x1d0cb
xorl %eax, %eax
callq 0x10b0
leaq 0x19ea3(%rip), %r14     # 0x1d0d2
testq %rbx, %rbx
je 0x3246
movl (%rbx), %esi
movq %r14, %rdi
xorl %eax, %eax
callq 0x10b0
movq 0x8(%rbx), %rbx
jmp 0x322f
pushq $0xa
popq %rdi
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x1040
// File: /workspace/github_c_makefile_star2_O2/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 0x327e
movq %rdi, %r14
movq 0x18(%rdi), %rdi
callq 0x112b6
movq 0x10(%r14), %rdi
callq 0x11454
movq %r14, %rdi
callq 0x115c8
testq %rbx, %rbx
je 0x3292
movq %rbx, %rdi
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x11798
addq $0x8, %rsp
popq %rbx
popq %r14
retq
nop
// File: /workspace/github_c_makefile_star2_O2/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 %rcx, %r14
movq %rdx, %rbx
movl %esi, %ebp
movq %rdi, %r15
movl %esi, 0x20(%rdi)
movq 0x8(%r15), %r15
testq %r15, %r15
je 0x32f9
movq 0x18(%r15), %rdi
cmpl $-0x1, 0x20(%rdi)
jne 0x32d5
movl %ebp, %esi
movq %rbx, %rdx
movq %r14, %rcx
callq 0x329c
movq 0x18(%r15), %rdi
movq 0x10(%r15), %rax
movl 0x18(%rax), %eax
cmpl 0x18(%rdi), %eax
jge 0x32b1
movq %r15, %rdi
movq %r14, %rsi
callq 0x5a28
movq %rbx, %rdi
movq %rax, %rsi
callq 0x61e7
jmp 0x32b1
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/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, %ebx
movq %rdi, %r14
movl %esi, 0x20(%rdi)
movq 0x8(%r14), %r14
testq %r14, %r14
je 0x332f
movq 0x18(%r14), %rdi
cmpl $-0x1, 0x20(%rdi)
jne 0x3313
movl %ebx, %esi
callq 0x3307
jmp 0x3313
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O2/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, 0x8(%rsp)
movq %rdi, %r14
movl (%rdi), %eax
xorl %ecx, %ecx
testl %eax, %eax
movl $0x0, %edx
cmovgl %eax, %edx
cmpq %rcx, %rdx
je 0x3371
movq 0x10(%r14), %rsi
movq (%rsi,%rcx,8), %rsi
orl $-0x1, 0x20(%rsi)
incq %rcx
jmp 0x335b
xorl %ebx, %ebx
xorl %r15d, %r15d
xorl %r13d, %r13d
movq 0x8(%rsp), %rbp
cltq
cmpq %rax, %rbx
jge 0x33df
movq 0x10(%r14), %rax
movq (%rax,%rbx,8), %r12
cmpl $-0x1, 0x20(%r12)
jne 0x33cb
movq %rbp, %rdi
callq 0x117e9
movq %r13, 0x10(%rsp)
movq %rax, %r13
movq 0x10(%rbp), %rcx
movq %r12, %rdi
movl %r15d, %esi
movq %rax, %rdx
callq 0x329c
movq 0x10(%rsp), %rax
movq %rax, 0x18(%r13)
incl %r15d
movq 0x10(%r14), %rax
movq (%rax,%rbx,8), %r12
cmpq $0x0, 0x8(%r12)
jne 0x33d7
movl %ebx, 0x28(%r13)
incq %rbx
movl (%r14), %eax
jmp 0x337e
movq %r13, %rax
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/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 0x117e9
movq %rax, %r15
movl (%r14), %eax
movslq %eax, %rcx
xorl %edx, %edx
cmpq %rcx, %rdx
jge 0x342b
movq 0x10(%r14), %rsi
movq (%rsi,%rdx,8), %rsi
orl $-0x1, 0x20(%rsi)
incq %rdx
jmp 0x3415
xorl %r13d, %r13d
xorl %ebp, %ebp
movslq %eax, %rcx
cmpq %rcx, %r13
jge 0x347b
movq 0x10(%r14), %rcx
movq (%rcx,%r13,8), %rcx
cmpl $-0x1, 0x20(%rcx)
jne 0x3476
movq 0x10(%rbx), %rdi
callq 0x11307
movq %rax, %r12
movq %r15, %rdi
movq %rax, %rsi
callq 0x61e7
movq 0x10(%r14), %rax
movq (%rax,%r13,8), %rdi
movq %rdi, 0x18(%r12)
movl %ebp, %esi
callq 0x3307
incl %ebp
movl (%r14), %eax
incq %r13
jmp 0x3430
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_O2/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 %r15
pushq %r14
pushq %rbx
movl (%rdi), %eax
movb $0x1, %bl
testl %eax, %eax
je 0x34e8
movq %rdi, %r14
xorl %ecx, %ecx
testl %eax, %eax
cmovlel %ecx, %eax
movq 0x10(%rdi), %rdx
cmpq %rcx, %rax
je 0x34ba
movq (%rdx,%rcx,8), %rsi
orl $-0x1, 0x20(%rsi)
incq %rcx
jmp 0x34a8
movq (%rdx), %rdi
xorl %r15d, %r15d
xorl %esi, %esi
callq 0x3307
movl (%r14), %eax
testl %eax, %eax
cmovlel %r15d, %eax
cmpq %r15, %rax
je 0x34e8
movq 0x10(%r14), %rcx
movq (%rcx,%r15,8), %rcx
incq %r15
cmpl $-0x1, 0x20(%rcx)
jne 0x34d0
xorl %ebx, %ebx
movl %ebx, %eax
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O2/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
pushq $-0x1
popq %rax
cmpl %edi, 0x18(%rsi)
jge 0x3b0a
retq
jle 0x3b10
pushq $0x1
popq %rax
retq
movq 0x18(%rcx), %rcx
movq 0x18(%rdx), %rdx
movl 0x18(%rdx), %edx
cmpl %edx, 0x18(%rcx)
jl 0x3b09
setg %al
movzbl %al, %eax
retq
// File: /workspace/github_c_makefile_star2_O2/pwelke[P]GraphMiningTools/cs_Compare.c
// Function: compareVertexLists
int compareVertexLists(const struct VertexList* e1, const struct VertexList* e2) {

	/* if this value is larger than 0 the first label is lex. larger than the second etc. */
	int returnValue = strcmp(e1->label, e2->label);

	/* if the two paths are identical so far wrt. labels check the next vertex on each path */
	if (returnValue == 0) {

		if ((e1->next) && (e2->next)) {
			/* if both lists have a next, proceed recursively */
			return compareVertexLists(e1->next, e2->next);
		} else {
			/* if the first list is shorter, its lex. smaller */
			if ((e1->next == NULL) && (e2->next)){
				return -1;
			}
			/* if the second is shorter, this one is lex.smaller */
			if ((e2->next == NULL) && (e1->next)){
				return 1;
			}
		}

		/* if none of the cases above was chosen, both paths end here and we have to return 0 as both strings
		represented by the lists are identical */
		return 0;

	} else {
		/* if the paths differ in the current vertices, we return the return value of the comparison function */
		return returnValue;
	} 
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rsi, %r14
movq %rdi, %r15
pushq $0x1
popq %rbx
movq (%r15), %rdi
movq (%r14), %rsi
callq 0x1130
testl %eax, %eax
jne 0x3b6e
movq 0x8(%r15), %r15
movq 0x8(%r14), %r14
testq %r15, %r15
je 0x3b72
testq %r14, %r14
jne 0x3b4b
jmp 0x3b79
movl %eax, %ebx
jmp 0x3b79
xorl %ebx, %ebx
negq %r14
sbbl %ebx, %ebx
movl %ebx, %eax
popq %rbx
popq %r14
popq %r15
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O2/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 0x1130
cmpq %rbx, %r12
je 0x3bd4
testl %eax, %eax
js 0x3bdd
jne 0x3bda
movq 0x18(%r12), %rax
movq (%rax), %rdi
movq 0x18(%r15), %rax
movq (%rax), %rsi
callq 0x1130
testl %eax, %eax
js 0x3bdd
je 0x3b98
jmp 0x3bda
testl %eax, %eax
js 0x3bdd
je 0x3bec
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 0x1130
testl %eax, %eax
js 0x3bdd
cmovneq %r14, %rbx
jmp 0x3bdd
// File: /workspace/github_c_makefile_star2_O2/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 0x3b84
andq $0x0, 0x8(%r15)
andq $0x0, 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_O2/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 0x6646
movq %rax, %rcx
movq (%rbx), %rax
movq %r15, 0x8(%rcx)
movq %r15, %r14
movq 0x8(%r14), %r14
cmpq %r15, %r14
je 0x3c8e
movq %rax, %rdi
movq %r14, %rsi
callq 0x3b84
jmp 0x3c78
movq 0x8(%rax), %rcx
movq %rcx, (%rbx)
movq %rax, 0x8(%rbx)
andq $0x0, 0x8(%rax)
movq %rbx, %rax
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O2/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 0x117e9
movq %rax, %r15
movq 0x10(%rbx), %rdi
callq 0x4fac
movq %r15, %rdi
movq %rax, %rsi
callq 0x6620
movq (%r14), %r12
movq 0x10(%rbx), %rdi
testq %r12, %r12
je 0x3d17
callq 0x11307
movq %rax, %r13
movq 0x18(%r12), %rax
movq (%rax), %rax
movq %rax, (%r13)
movq 0x8(%r12), %rbp
movq %r15, %rdi
movq %r12, %rsi
callq 0x6620
movq %r15, %rdi
movq %r13, %rsi
callq 0x6620
movq %rbp, %r12
jmp 0x3cda
callq 0x4f9a
movq %r15, %rdi
movq %rax, %rsi
callq 0x6620
movups (%r15), %xmm0
movups %xmm0, (%r14)
movl 0x10(%r15), %eax
movl %eax, 0x10(%r14)
andq $0x0, (%r15)
movq %rbx, %rdi
movq %r15, %rsi
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x1184e
// File: /workspace/github_c_makefile_star2_O2/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 0x117e9
movq %rax, %rbx
movq 0x10(%r14), %rdi
callq 0x4fac
movq %rbx, %rdi
movq %rax, %rsi
callq 0x6620
movq (%r15), %r15
movq 0x10(%r14), %rdi
testq %r15, %r15
je 0x3dc8
callq 0x11307
movq %rax, %r12
movq 0x18(%r15), %rax
movq (%rax), %rax
movq %rax, (%r12)
movq 0x10(%r14), %rsi
movq %r15, %rdi
callq 0x5a28
movq %rbx, %rdi
movq %rax, %rsi
callq 0x6620
movq %rbx, %rdi
movq %r12, %rsi
callq 0x6620
addq $0x8, %r15
jmp 0x3d81
callq 0x4f9a
movq %rbx, %rdi
movq %rax, %rsi
callq 0x6620
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O2/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
movq %rsi, %rbx
movq %rdi, %r14
xorl %r15d, %r15d
testq %r14, %r14
je 0x3e5c
movq 0x18(%r14), %rbp
movq %r14, %rdi
callq 0x3c5b
movq %r14, %rdi
movq %rbx, %rsi
callq 0x666c
movq %rax, %r13
movq %rax, %rdi
callq 0x3c5b
movq %r14, %rdi
movq %r13, %rsi
callq 0x3c0a
movq %rax, %r12
movq %r15, 0x18(%rax)
movq %rbx, %rdi
cmpq %r14, %rax
je 0x3e41
movq %r14, %rsi
jmp 0x3e44
movq %r13, %rsi
callq 0x1184e
movq %r12, %rdi
movq %rbx, %rsi
callq 0x3ca7
movq %r12, %r15
movq %rbp, %r14
jmp 0x3dfb
movq %r15, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O2/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
subq $0x18, %rsp
movq %r8, %r14
movq %rcx, 0x10(%rsp)
movl %edx, 0xc(%rsp)
movl %esi, %r12d
movq %rdi, %rbx
movq %r8, %rdi
callq 0x4fac
movq %rbx, %rdi
movq %rax, %rsi
callq 0x6620
movq %r14, %rdi
callq 0x11307
movq %rbx, %rdi
movq %rax, %rsi
callq 0x6620
pushq $0xc
popq %r13
movq %r13, %rdi
callq 0x1180
movq 0x8(%rbx), %rcx
movq %rax, (%rcx)
pushq $0x1
popq %rbp
movl %ebp, 0x28(%rcx)
leaq 0x1a2e4(%rip), %r15     # 0x1e54a
movq %rax, %rdi
movq %r15, %rsi
movl %r12d, %edx
xorl %eax, %eax
callq 0x1200
movq %r14, %rdi
callq 0x11307
movq %rbx, %rdi
movq %rax, %rsi
callq 0x6620
movq %r13, %rdi
callq 0x1180
movq 0x8(%rbx), %rcx
movq %rax, (%rcx)
movl %ebp, 0x28(%rcx)
movq %rax, %rdi
movq %r15, %rsi
movl 0xc(%rsp), %edx
xorl %eax, %eax
callq 0x1200
movq %r14, %rdi
callq 0x11307
movq %rbx, %rdi
movq %rax, %rsi
callq 0x6620
movq 0x8(%rbx), %rax
movq 0x10(%rsp), %rcx
movq %rcx, (%rax)
movq %r14, %rdi
callq 0x4f9a
movq %rbx, %rdi
movq %rax, %rsi
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x6620
// File: /workspace/github_c_makefile_star2_O2/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 0x5fe8
movq %rax, %r14
movq %rax, %rdi
movq %r15, %rsi
callq 0x475b
testq %rax, %rax
je 0x4f7b
movq 0x18(%rax), %rsi
andq $0x0, 0x18(%rax)
movq %rax, %rdi
movq %r15, %rdx
callq 0x461c
movq %rax, %r15
jmp 0x4f7e
xorl %r15d, %r15d
movq %rbx, %rdi
movq %r14, %rsi
callq 0x1166e
movq %r15, %rax
popq %rbx
popq %r14
popq %r15
retq
nop
// File: /workspace/github_c_makefile_star2_O2/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, %rbx
xorl %r14d, %r14d
movq %rdi, %r15
movq (%r15), %r15
testq %r15, %r15
je 0x4feb
movq (%r15), %rdi
callq 0x10a0
addl %eax, %r14d
incl %r14d
addq $0x8, %r15
jmp 0x4fcf
incl %r14d
movslq %r14d, %rdi
callq 0x1180
movq %rax, %r14
leaq 0x181ef(%rip), %r15     # 0x1d1ef
xorl %eax, %eax
movq (%rbx), %rbx
testq %rbx, %rbx
je 0x5032
movslq %eax, %r12
leaq (%r14,%r12), %rdi
movq (%rbx), %rdx
movq %r15, %rsi
xorl %eax, %eax
callq 0x1200
movq (%rbx), %rdi
callq 0x10a0
addq %r12, %rax
incq %rax
addq $0x8, %rbx
jmp 0x5002
movq %r14, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O2/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 %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq %rdi, %r14
pushq $0x20
popq %rbp
movq (%r14), %r14
testq %r14, %r14
je 0x5081
movq (%r14), %r15
movsbl (%r15), %edi
testl %edi, %edi
je 0x5071
movq %rbx, %rsi
callq 0x1100
incq %r15
jmp 0x505c
movl %ebp, %edi
movq %rbx, %rsi
callq 0x1100
addq $0x8, %r14
jmp 0x5051
pushq $0xa
popq %rdi
movq %rbx, %rsi
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
jmp 0x1100
// File: /workspace/github_c_makefile_star2_O2/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
movq %rbx, %rdi
callq 0x10d0
cmpl $0x20, %eax
je 0x50c4
movl %eax, %ebp
movl %eax, %edi
movq %rbx, %rsi
callq 0x11a0
testl %ebp, %ebp
setne %cl
cmpl $0xa, %ebp
setne %al
andb %cl, %al
addq $0x8, %rsp
popq %rbx
popq %rbp
retq