LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O1/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 0x4462
movl %edx, %eax
notl %eax
xorl %ecx, %ecx
cmpl $0x2, 0x10(%rdi)
jl 0x442c
movq (%rdi), %r8
movq %r8, (%rsi,%rcx,8)
movq 0x10(%r8), %r9
movq 0x18(%r8), %r10
movq 0x8(%r9), %r9
testq %r9, %r9
je 0x4421
cmpq %r10, 0x18(%r9)
jne 0x43f1
andl %eax, 0x24(%r9)
jmp 0x4421
movq 0x10(%r8), %r10
movq 0x18(%r8), %r9
movq 0x8(%r9), %r9
testq %r9, %r9
je 0x4421
cmpq %r10, 0x18(%r9)
jne 0x440e
orl %edx, 0x24(%r9)
movq 0x8(%r8), %r8
testq %r8, %r8
jne 0x4406
jmp 0x4452
movq $0x0, (%rsi,%rcx,8)
movq (%rdi), %r9
movq 0x10(%r9), %r8
movq 0x18(%r9), %r9
movq 0x8(%r8), %r8
testq %r8, %r8
je 0x4452
cmpq %r9, 0x18(%r8)
jne 0x443f
orl %edx, 0x24(%r8)
incq %rcx
movq 0x18(%rdi), %rdi
testq %rdi, %rdi
jne 0x43dc
retq
// File: /workspace/github_c_makefile_star2_O1/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 0x4c1d
movl (%rdi), %eax
cmpl %esi, %eax
jge 0x4bf5
movq 0x10(%rdi), %rdi
jmp 0x4be4
jne 0x4c1d
movq 0x8(%rdi), %rax
movslq %edx, %rdx
movq (%rax,%rdx,8), %rax
movslq %ecx, %rcx
movq (%rax,%rcx,8), %rax
testq %rax, %rax
je 0x4c1d
cmpl %r8d, (%rax)
jge 0x4c19
movq 0x8(%rax), %rax
jmp 0x4c09
movb $0x1, %al
je 0x4c1f
xorl %eax, %eax
retq
// File: /workspace/github_c_makefile_star2_O1/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 0x4c41
cmpl %edx, (%r14)
jle 0x4c8d
movl %esi, %edi
movl %edx, %esi
callq 0x4cf4
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 0x4e00
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 0x4ca0
cmpl %edx, (%rax)
jle 0x4c90
cmpl %edx, (%r12)
jge 0x4c54
movl %esi, %edi
movl %edx, %esi
callq 0x4cf4
movq 0x10(%r12), %rcx
movq %rcx, 0x10(%rax)
movq %rax, 0x10(%r12)
movq %rax, %r12
jmp 0x4c54
// File: /workspace/github_c_makefile_star2_O1/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 0x4d85
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 0x4d7d
testl %ebp, %ebp
jle 0x4d87
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 0x4d62
incq %r12
cmpq %r12, %r13
jne 0x4d42
jmp 0x4d87
testq %r12, %r12
je 0x4d7a
xorl %ebx, %ebx
movq (%r14,%rbx,8), %rdi
callq 0x1030
incq %rbx
cmpq %rbx, %r12
jne 0x4d69
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_O1/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 0x4deb
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 0x4e62
movq (%rbx,%r12,8), %rcx
movq %rax, (%rcx,%r13,8)
incq %r13
cmpq %r13, %r15
jne 0x4db5
movq (%r14,%r12,8), %rdi
callq 0x1030
incq %r12
cmpq %r15, %r12
jne 0x4db2
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_O1/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 0x4e15
cmpl %ebp, (%rbx)
jle 0x4e39
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 0x4e4d
cmpl %ebp, (%r14)
jle 0x4e3c
cmpl %ebp, (%r15)
jge 0x4e2b
movl $0x10, %edi
callq 0x1190
movq %rax, 0x8(%r15)
jmp 0x4e25
// File: /workspace/github_c_makefile_star2_O1/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 0x4eed
movq %rdi, %rbx
testq %r14, %r14
je 0x4ef0
movl (%rbx), %eax
cmpl (%r14), %eax
jne 0x4e8d
movq 0x8(%rbx), %r15
movq %rbx, %rdi
callq 0x1030
movq %r15, %rbx
testq %rbx, %rbx
je 0x4eed
movl (%rbx), %eax
cmpl (%r14), %eax
cmovgq %r14, %rbx
movq 0x8(%rbx), %rdi
testq %rdi, %rdi
setne %cl
je 0x4ef9
movq %rbx, %r15
movl (%r14), %eax
cmpl %eax, (%rdi)
jge 0x4ebb
movq %rdi, 0x8(%r15)
movq 0x8(%rdi), %rdi
jmp 0x4ed4
movq %r14, 0x8(%r15)
jne 0x4ed0
movq 0x8(%rdi), %r14
callq 0x1030
movq %r14, %rdi
movq %r15, %r14
movq 0x8(%r14), %r14
movq 0x8(%r15), %r15
testq %r14, %r14
setne %al
testq %rdi, %rdi
setne %cl
je 0x4efe
testq %r14, %r14
jne 0x4eaa
jmp 0x4efe
movq %r14, %rbx
movq %rbx, %rax
popq %rbx
popq %r14
popq %r15
retq
movb $0x1, %al
movq %rbx, %r15
testb %cl, %cl
je 0x4f06
movq %rdi, 0x8(%r15)
testb %al, %al
je 0x4ef0
movq %r14, 0x8(%r15)
jmp 0x4ef0
// File: /workspace/github_c_makefile_star2_O1/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 0x4ff0
testl %r14d, %r14d
jle 0x4f64
movq 0x10(%rbx), %rcx
xorl %edx, %edx
movq (%rcx,%rdx,8), %rsi
movl $0x0, 0x1c(%rsi)
incq %rdx
cmpq %rdx, %r14
jne 0x4f51
testl %r14d, %r14d
jle 0x4f82
movq 0x10(%rbx), %rcx
xorl %edx, %edx
movq (%rcx,%rdx,8), %rsi
movl $0x0, 0x1c(%rsi)
incq %rdx
cmpq %rdx, %r14
jne 0x4f6f
movq 0x10(%rbx), %rcx
movq (%rcx), %rcx
movq %rcx, (%rax)
movl $0x1, 0x1c(%rcx)
movl $0x0, 0x28(%rcx)
testl %r14d, %r14d
jle 0x4fe4
xorl %ecx, %ecx
xorl %edx, %edx
movq (%rax,%rcx,8), %rsi
movq 0x8(%rsi), %rsi
testq %rsi, %rsi
je 0x4fdc
movq 0x18(%rsi), %rdi
cmpl $0x0, 0x1c(%rdi)
jne 0x4fa7
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 0x4fa7
incq %rcx
cmpq %r14, %rcx
jne 0x4fa3
movq %rax, %rdi
callq 0x1030
xorl %eax, %eax
jmp 0x5003
leaq 0x1b08d(%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_O1/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 0x50e6
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rdi, %rbx
leaq 0x1b08e(%rip), %r12     # 0x200b7
movq 0x8(%rbx), %rdx
leaq 0x1b072(%rip), %rdi     # 0x200a6
movq %rbx, %rsi
xorl %eax, %eax
callq 0x10b0
leaq 0x1b83b(%rip), %rdi     # 0x20880
callq 0x1070
cmpl $0x0, 0x4(%rbx)
jle 0x50cb
xorl %ebp, %ebp
xorl %r15d, %r15d
cmpl $0x0, 0x4(%rbx)
jle 0x50bf
xorl %r14d, %r14d
movq 0x8(%rbx), %rax
movq (%rax,%rbp,8), %rax
movq (%rax,%r14,8), %r13
testq %r13, %r13
je 0x50b3
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 0x509c
incl %r15d
jmp 0x50ad
xorl %r15d, %r15d
leaq 0x1b021(%rip), %rdi     # 0x200c7
xorl %eax, %eax
callq 0x10b0
movq 0x8(%r13), %r13
jmp 0x506a
incq %r14
movslq 0x4(%rbx), %rax
cmpq %rax, %r14
jl 0x505e
incq %rbp
movslq 0x4(%rbx), %rax
cmpq %rax, %rbp
jl 0x5055
movq 0x10(%rbx), %rbx
testq %rbx, %rbx
jne 0x5029
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_O1/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 0x1afcd(%rip), %rdi     # 0x200cb
xorl %eax, %eax
callq 0x10b0
testq %rbx, %rbx
je 0x5126
leaq 0x1afc1(%rip), %r14     # 0x200d2
movl (%rbx), %esi
movq %r14, %rdi
xorl %eax, %eax
callq 0x10b0
movq 0x8(%rbx), %rbx
testq %rbx, %rbx
jne 0x5111
movl $0xa, %edi
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x1040
// File: /workspace/github_c_makefile_star2_O1/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 0x5160
movq %rdi, %r14
movq 0x18(%rdi), %rdi
callq 0x142d9
movq 0x10(%r14), %rdi
callq 0x14560
movq %r14, %rdi
callq 0x14789
testq %rbx, %rbx
je 0x5174
movq %rbx, %rdi
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x14a5c
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O1/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 0x51dd
movq %rcx, %r14
movl %esi, %ebp
movq 0x18(%r15), %rdi
cmpl $-0x1, 0x20(%rdi)
jne 0x51ae
movl %ebp, %esi
movq %rbx, %rdx
movq %r14, %rcx
callq 0x517c
movq 0x10(%r15), %rax
movq 0x18(%r15), %rcx
movl 0x18(%rax), %eax
cmpl 0x18(%rcx), %eax
jge 0x51d4
movq %r15, %rdi
movq %r14, %rsi
callq 0x7bc0
movq %rbx, %rdi
movq %rax, %rsi
callq 0x840c
movq 0x8(%r15), %r15
testq %r15, %r15
jne 0x5197
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/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 0x5217
movl %esi, %ebx
movq 0x18(%r14), %rdi
cmpl $-0x1, 0x20(%rdi)
jne 0x520e
movl %ebx, %esi
callq 0x51eb
movq 0x8(%r14), %r14
testq %r14, %r14
jne 0x51fd
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O1/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
movslq (%rdi), %rax
testq %rax, %rax
jle 0x5256
movq 0x10(%r14), %rcx
xorl %edx, %edx
movq (%rcx,%rdx,8), %rsi
movl $0xffffffff, 0x20(%rsi) # imm = 0xFFFFFFFF
incq %rdx
cmpq %rdx, %rax
jne 0x5243
xorl %r12d, %r12d
cmpl $0x0, (%r14)
jle 0x52c4
xorl %ebx, %ebx
xorl %ebp, %ebp
movq 0x8(%rsp), %r15
movq 0x10(%r14), %rax
movq (%rax,%rbx,8), %r13
cmpl $-0x1, 0x20(%r13)
jne 0x52a5
movq %r15, %rdi
callq 0x14aae
movq %rbp, 0x10(%rsp)
movq %rax, %rbp
movq 0x10(%r15), %rcx
movq %r13, %rdi
movl %r12d, %esi
movq %rax, %rdx
callq 0x517c
movq 0x10(%rsp), %rax
movq %rax, 0x18(%rbp)
incl %r12d
movq 0x10(%r14), %rax
movq (%rax,%rbx,8), %rax
cmpq $0x0, 0x8(%rax)
jne 0x52b7
movl %ebx, 0x28(%rbp)
incq %rbx
movslq (%r14), %rax
cmpq %rax, %rbx
jl 0x5268
jmp 0x52c6
xorl %ebp, %ebp
movq %rbp, %rax
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/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 0x14aae
movq %rax, %r15
movslq (%r14), %rax
testq %rax, %rax
jle 0x5315
movq 0x10(%r14), %rcx
xorl %edx, %edx
movq (%rcx,%rdx,8), %rsi
movl $0xffffffff, 0x20(%rsi) # imm = 0xFFFFFFFF
incq %rdx
cmpq %rdx, %rax
jne 0x5302
cmpl $0x0, (%r14)
jle 0x536a
xorl %r13d, %r13d
xorl %ebp, %ebp
movq 0x10(%r14), %rax
movq (%rax,%r13,8), %rax
cmpl $-0x1, 0x20(%rax)
jne 0x535f
movq 0x10(%rbx), %rdi
callq 0x1432b
movq %rax, %r12
movq %r15, %rdi
movq %rax, %rsi
callq 0x840c
movq 0x10(%r14), %rax
movq (%rax,%r13,8), %rcx
movq %rcx, 0x18(%r12)
movq (%rax,%r13,8), %rdi
movl %ebp, %esi
callq 0x51eb
incl %ebp
incq %r13
movslq (%r14), %rax
cmpq %rax, %r13
jl 0x5320
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_O1/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 0x53db
movq %rdi, %r14
testl %eax, %eax
jle 0x53a9
movq 0x10(%r14), %rcx
xorl %edx, %edx
movq (%rcx,%rdx,8), %rsi
movl $0xffffffff, 0x20(%rsi) # imm = 0xFFFFFFFF
incq %rdx
cmpq %rdx, %rax
jne 0x5396
movq 0x10(%r14), %rax
movq (%rax), %rdi
xorl %esi, %esi
callq 0x51eb
movslq (%r14), %rax
testq %rax, %rax
jle 0x53db
movq 0x10(%r14), %rcx
xorl %edx, %edx
movq (%rcx,%rdx,8), %rsi
cmpl $-0x1, 0x20(%rsi)
je 0x53d9
incq %rdx
cmpq %rdx, %rax
jne 0x53c5
jmp 0x53db
xorl %ebx, %ebx
movl %ebx, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O1/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 0x5a6d
movl $0x1, %eax
jg 0x5a6d
movq 0x18(%rcx), %rcx
movq 0x18(%rdx), %rax
movl 0x18(%rax), %edx
movl $0xffffffff, %eax       # imm = 0xFFFFFFFF
cmpl %edx, 0x18(%rcx)
jl 0x5a6d
setg %al
movzbl %al, %eax
retq
// File: /workspace/github_c_makefile_star2_O1/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 %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
movq %rsi, %r14
movq (%rbx), %rdi
movq (%rsi), %rsi
callq 0x1140
testl %eax, %eax
jne 0x5ad9
movq 0x8(%rbx), %rbx
testq %rbx, %rbx
je 0x5aba
movq 0x8(%r14), %rsi
testq %rsi, %rsi
jne 0x5a91
testq %rbx, %rbx
jne 0x5ac6
movl $0xffffffff, %eax       # imm = 0xFFFFFFFF
cmpq $0x0, 0x8(%r14)
jne 0x5ad9
testq %rbx, %rbx
setne %al
cmpq $0x0, 0x8(%r14)
sete %cl
andb %al, %cl
movzbl %cl, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O1/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 0x5b34
testl %eax, %eax
js 0x5b3d
jne 0x5b3a
movq 0x18(%r12), %rax
movq (%rax), %rdi
movq 0x18(%r15), %rax
movq (%rax), %rsi
callq 0x1140
testl %eax, %eax
js 0x5b3d
je 0x5af8
jmp 0x5b3a
testl %eax, %eax
js 0x5b3d
je 0x5b4c
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 0x5b3d
cmovneq %r14, %rbx
jmp 0x5b3d
// File: /workspace/github_c_makefile_star2_O1/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 0x5ae4
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_O1/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 0x88e2
movq %rax, %rcx
movq (%rbx), %rax
movq %r15, 0x8(%rcx)
movq 0x8(%r15), %r14
cmpq %r15, %r14
je 0x5bef
movq %rax, %rdi
movq %r14, %rsi
callq 0x5ae4
movq 0x8(%r14), %r14
jmp 0x5bd9
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_O1/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 0x14aae
movq %rax, %r15
movq 0x10(%rbx), %rdi
callq 0x7060
movq %r15, %rdi
movq %rax, %rsi
callq 0x88b9
movq (%r14), %r12
testq %r12, %r12
je 0x5c7e
movq 0x10(%rbx), %rdi
callq 0x1432b
movq %rax, %r13
movq 0x18(%r12), %rax
movq (%rax), %rax
movq %rax, (%r13)
movq 0x8(%r12), %rbp
movq %r15, %rdi
movq %r12, %rsi
callq 0x88b9
movq %r15, %rdi
movq %r13, %rsi
callq 0x88b9
movq %rbp, %r12
testq %rbp, %rbp
jne 0x5c43
movq 0x10(%rbx), %rdi
callq 0x704e
movq %r15, %rdi
movq %rax, %rsi
callq 0x88b9
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 0x14b19
// File: /workspace/github_c_makefile_star2_O1/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 0x14aae
movq %rax, %rbx
movq 0x10(%r14), %rdi
callq 0x7060
movq %rbx, %rdi
movq %rax, %rsi
callq 0x88b9
movq (%r15), %r15
testq %r15, %r15
je 0x5d36
movq 0x10(%r14), %rdi
callq 0x1432b
movq %rax, %r12
movq 0x18(%r15), %rax
movq (%rax), %rax
movq %rax, (%r12)
movq 0x10(%r14), %rsi
movq %r15, %rdi
callq 0x7bc0
movq %rbx, %rdi
movq %rax, %rsi
callq 0x88b9
movq %rbx, %rdi
movq %r12, %rsi
callq 0x88b9
movq 0x8(%r15), %r15
jmp 0x5cf2
movq 0x10(%r14), %rdi
callq 0x704e
movq %rbx, %rdi
movq %rax, %rsi
callq 0x88b9
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O1/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 0x5e0b
movq %rsi, %r13
movq %rdi, %r14
xorl %ebx, %ebx
movq %rsi, (%rsp)
movq 0x18(%r14), %rbp
movq %r14, %rdi
callq 0x5bbb
movq %r14, %rdi
movq %r13, %rsi
callq 0x8908
movq %rax, %r15
movq %rax, %rdi
callq 0x5bbb
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 0x5ae4
xorl %ecx, %ecx
movq %rcx, 0x8(%r13)
movq %rcx, 0x8(%r12)
movq %r14, %r12
cmpq %r13, %rax
je 0x5dd3
movq %r15, %r12
movq %rbx, 0x18(%r12)
cmpq %r14, %r12
je 0x5de0
movq %r14, %r15
movq (%rsp), %r13
movq %r13, %rdi
movq %r15, %rsi
callq 0x14b19
movq %r12, %rdi
movq %r13, %rsi
callq 0x5c0b
movq %rbp, %r14
movq %r12, %rbx
testq %rbp, %rbp
jne 0x5d79
jmp 0x5e0e
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_O1/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 0x7060
movq %rbx, %rdi
movq %rax, %rsi
callq 0x88b9
movq %r14, %rdi
callq 0x1432b
movq %rbx, %rdi
movq %rax, %rsi
callq 0x88b9
movl $0xc, %edi
callq 0x1190
movq 0x8(%rbx), %rcx
movq %rax, (%rcx)
movl $0x1, %r15d
movl %r15d, 0x28(%rcx)
leaq 0x1b318(%rip), %r13     # 0x215aa
movq %rax, %rdi
movq %r13, %rsi
movl %r12d, %edx
xorl %eax, %eax
callq 0x1210
movq %r14, %rdi
callq 0x1432b
movq %rbx, %rdi
movq %rax, %rsi
callq 0x88b9
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 0x1432b
movq %rbx, %rdi
movq %rax, %rsi
callq 0x88b9
movq 0x8(%rbx), %rax
movq (%rsp), %rcx
movq %rcx, (%rax)
movq %r14, %rdi
callq 0x704e
movq %rbx, %rdi
movq %rax, %rsi
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x88b9
// File: /workspace/github_c_makefile_star2_O1/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 0x81e0
movq %rax, %r14
movq %rax, %rdi
movq %r15, %rsi
callq 0x67b1
testq %rax, %rax
je 0x7030
movq 0x18(%rax), %rsi
movq $0x0, 0x18(%rax)
movq %rax, %rdi
movq %r15, %rdx
callq 0x6676
movq %rax, %r15
jmp 0x7033
xorl %r15d, %r15d
movq %rbx, %rdi
movq %r14, %rsi
callq 0x14832
movq %r15, %rax
popq %rbx
popq %r14
popq %r15
retq
nop
// File: /workspace/github_c_makefile_star2_O1/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
movq (%rdi), %r14
testq %r14, %r14
je 0x70a7
xorl %r15d, %r15d
movq (%r14), %rdi
callq 0x10a0
addl %eax, %r15d
incl %r15d
movq 0x8(%r14), %r14
testq %r14, %r14
jne 0x7088
incl %r15d
movslq %r15d, %rdi
jmp 0x70ac
movl $0x1, %edi
callq 0x1190
movq %rax, %r14
movq (%rbx), %r15
testq %r15, %r15
je 0x70f0
leaq 0x1912c(%rip), %rbx     # 0x201ef
xorl %eax, %eax
movslq %eax, %r12
leaq (%r14,%r12), %rdi
movq (%r15), %rdx
movq %rbx, %rsi
xorl %eax, %eax
callq 0x1210
movq (%r15), %rdi
callq 0x10a0
addq %r12, %rax
incq %rax
movq 0x8(%r15), %r15
testq %r15, %r15
jne 0x70c5
movq %r14, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O1/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 0x7144
movq (%r14), %r15
movb (%r15), %al
testb %al, %al
je 0x7131
incq %r15
movsbl %al, %edi
movq %rbx, %rsi
callq 0x1110
movb (%r15), %al
incq %r15
testb %al, %al
jne 0x711c
movl $0x20, %edi
movq %rbx, %rsi
callq 0x1110
movq 0x8(%r14), %r14
jmp 0x710a
movl $0xa, %edi
movq %rbx, %rsi
popq %rbx
popq %r14
popq %r15
jmp 0x1110
// File: /workspace/github_c_makefile_star2_O1/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 0x7196
movq %rbx, %rdi
jmp 0x7187
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_O1/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 0x14aae
movq %rax, %r12
movq %r15, %rdi
callq 0x7181
testb %al, %al
je 0x72a0
movq %r15, %rdi
movq %r14, %rsi
callq 0x71b6
movq 0x10(%rbx), %rdi
callq 0x1432b
movq %rax, %r13
movq 0x25f17(%rip), %rbp     # 0x2d150
movq %r14, %rdi
movq %rbp, %rsi
callq 0x1140
testl %eax, %eax
je 0x728c
movq 0x25ef9(%rip), %rbp     # 0x2d148
movq %r14, %rdi
movq %rbp, %rsi
callq 0x1140
testl %eax, %eax
je 0x728c
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 0x7290
movq %rbp, (%r13)
movq %r12, %rdi
movq %r13, %rsi
callq 0x88b9
jmp 0x720b
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_O1/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 0x18e28(%rip), %r15     # 0x200f2
leaq 0x1a402(%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 0x18e07(%rip), %rsi     # 0x200fd
movq %r15, %rdi
callq 0x11d0
movq %rax, %r14
movq %rsp, %rsi
movq %rax, %rdi
movq %rbx, %rdx
callq 0x71ec
movq %rax, %rbx
movq %r14, %rdi
callq 0x1090
movq %rbx, %rax
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O1/pwelke[P]GraphMiningTools/cs_Tree.c
// Function: canonicalStringOfLevelTree
struct ShallowGraph* canonicalStringOfLevelTree(struct ShallowGraph* vertexList, int maxDepth, struct ShallowGraphPool* sgp) {

	struct VertexList* idx;
	struct ShallowGraph* canonicalString = NULL;

	/* compute the canonical string of the unique tree rooted at vertex i and save it at the correct position of the
	canonicalStrings array */
	for (idx=vertexList->edges; idx && (idx->endPoint->visited <= maxDepth); idx=idx->next) {

		/* compute the canonical string */
		struct ShallowGraph *cs = canonicalStringOfRootedLevelTree(idx->endPoint, NULL, maxDepth, sgp);

		/* keep the string if its the first one, computed for this component or lexicograhically smaller
			than the saved string */
		if (canonicalString) {
			if (compareCanonicalStrings(canonicalString, cs) > 0) {
				dumpShallowGraph(sgp, canonicalString);
				canonicalString = cs;
			} else {
				dumpShallowGraph(sgp, cs);
			}
		} else {
			canonicalString = cs;
		}

	}

	return canonicalString;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movq (%rdi), %r12
testq %r12, %r12
je 0x779d
movq %rdx, %rbx
movl %esi, %ebp
xorl %r14d, %r14d
movq 0x18(%r12), %rdi
cmpl %ebp, 0x1c(%rdi)
jg 0x77a2
xorl %esi, %esi
movl %ebp, %edx
movq %rbx, %rcx
callq 0x750d
movq %rax, %r15
testq %r14, %r14
je 0x778e
movq %r14, %rdi
movq %r15, %rsi
callq 0x5a7f
movq %rbx, %rdi
testl %eax, %eax
jle 0x7783
movq %r14, %rsi
callq 0x14b19
jmp 0x778e
movq %r15, %rsi
callq 0x14b19
movq %r14, %r15
movq 0x8(%r12), %r12
movq %r15, %r14
testq %r12, %r12
jne 0x7749
jmp 0x77a5
xorl %r15d, %r15d
jmp 0x77a5
movq %r14, %r15
movq %r15, %rax
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/pwelke[P]GraphMiningTools/cs_Tree.c
// Function: canonicalStringOfTree
struct ShallowGraph* canonicalStringOfTree(struct Graph* tree, struct ShallowGraphPool* sgp) {
	struct ShallowGraph* cString;
	int* center = treeCenter(tree);

	cString = canonicalStringOfRootedTree(tree->vertices[center[1]], tree->vertices[center[1]], sgp);
	
	if (center[0] == 3) {
		struct ShallowGraph* cString2 = canonicalStringOfRootedTree(tree->vertices[center[2]], tree->vertices[center[2]], sgp);
		if (compareCanonicalStrings(cString, cString2) < 0) {
			dumpShallowGraph(sgp, cString2);
		} else {
			dumpShallowGraph(sgp, cString);
			cString = cString2;
		}
	}
	free(center);
	return cString;
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rsi, %r14
movq %rdi, %r12
callq 0x1d487
movq %rax, %rbx
movq 0x10(%r12), %rax
movslq 0x4(%rbx), %rcx
movq (%rax,%rcx,8), %rdi
movq %rdi, %rsi
movq %r14, %rdx
callq 0x732c
movq %rax, %r15
cmpl $0x3, (%rbx)
jne 0x796d
movq 0x10(%r12), %rax
movslq 0x8(%rbx), %rcx
movq (%rax,%rcx,8), %rdi
movq %rdi, %rsi
movq %r14, %rdx
callq 0x732c
movq %rax, %r12
movq %r15, %rdi
movq %rax, %rsi
callq 0x5a7f
testl %eax, %eax
movq %r15, %rsi
cmovsq %r12, %rsi
cmovnsq %r12, %r15
movq %r14, %rdi
callq 0x14b19
movq %rbx, %rdi
callq 0x1030
movq %r15, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq