LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O1/dwbuiten[P]obuparse/obuparse.c
// Function: obp_read_delta_q
static inline int _obp_read_delta_q(_OBPBitReader *br, int32_t *out, OBPError *err)
{
    int delta_coded;
    _obp_br(delta_coded, br, 1);
    if (delta_coded) {
        int32_t val;
        int ret = _obp_su(br, 7, &val, err);
        if (ret < 0)
            return ret;
        *out = val;
    } else {
        *out = 0;
    }
    return 0;
}

// Assembly:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
movq %rdx, %r14
movq %rsi, %rbx
movq %rdi, %r15
movzbl 0x20(%rdi), %eax
movl $0x8, %ecx
subl %eax, %ecx
sarl $0x3, %ecx
movslq %ecx, %r12
movq 0x8(%rdi), %r13
subq 0x10(%rdi), %r13
cmpq %r12, %r13
jae 0x9eb8
movq (%r14), %rdi
movq 0x8(%r14), %rsi
leaq 0x12ce(%rip), %rdx      # 0xb17d
xorl %eax, %eax
callq 0x1030
jmp 0x9eca
movq %r15, %rdi
movl $0x1, %esi
callq 0x2cf9
testl %eax, %eax
sete %cl
movl $0xffffffff, %eax       # imm = 0xFFFFFFFF
cmpq %r12, %r13
jb 0x9f4e
testb $0x1, %cl
je 0x9ee1
movl $0x0, (%rbx)
jmp 0x9f4c
movzbl 0x20(%r15), %eax
movl $0xe, %r12d
subl %eax, %r12d
shrl $0x3, %r12d
movq 0x8(%r15), %r13
subq 0x10(%r15), %r13
cmpq %r12, %r13
jae 0x9f17
movq (%r14), %rdi
movq 0x8(%r14), %rsi
leaq 0x126f(%rip), %rdx      # 0xb17d
xorl %eax, %eax
callq 0x1030
jmp 0x9f27
movq %r15, %rdi
movl $0x7, %esi
callq 0x2cf9
movq %rax, %rcx
xorl %eax, %eax
cmpq %r12, %r13
sbbl %eax, %eax
cmpq %r12, %r13
jb 0x9f47
movl %ecx, %eax
shll $0x19, %eax
sarl $0x1f, %eax
andl $-0x80, %eax
addl %ecx, %eax
movl %eax, (%rbx)
movl $0xffffffff, %eax       # imm = 0xFFFFFFFF
cmpq %r12, %r13
jb 0x9f4e
xorl %eax, %eax
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O1/dwbuiten[P]obuparse/obuparse.c
// Function: obp_su
static inline int _obp_su(_OBPBitReader *br, uint32_t n, int32_t *out, OBPError *err)
{
    int32_t value;
    uint32_t signMask;

    _obp_br(value, br, n);
    signMask = ((uint32_t)1) << (n - 1);
    if (value & signMask) {
        value = value - 2 * signMask;
    }
    *out = value;
    return 0;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rdx, %rbx
movl %esi, %ebp
movzbl 0x20(%rdi), %eax
movl %esi, %r14d
subl %eax, %r14d
addl $0x7, %r14d
shrl $0x3, %r14d
movq 0x8(%rdi), %r15
subq 0x10(%rdi), %r15
cmpq %r14, %r15
jae 0x9f9a
movq (%rcx), %rdi
movq 0x8(%rcx), %rsi
leaq 0x11ec(%rip), %rdx      # 0xb17d
xorl %eax, %eax
callq 0x1030
jmp 0x9fa3
movzbl %bpl, %esi
callq 0x2cf9
movl $0xffffffff, %edx       # imm = 0xFFFFFFFF
cmpq %r14, %r15
jb 0x9fc7
decb %bpl
movzbl %bpl, %ecx
movl $0xfffffffe, %esi       # imm = 0xFFFFFFFE
shll %cl, %esi
xorl %edx, %edx
btl %ecx, %eax
cmovael %edx, %esi
addl %eax, %esi
movl %esi, (%rbx)
movl %edx, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/pwelke[P]GraphMiningTools/poset_pathCover.c
// Function: dfsDownwardEmbeddingForTrees
struct IntSet* dfsDownwardEmbeddingForTrees(struct Graph* g, struct EvaluationPlan p, struct GraphPool* gp) {

	int nEvaluations = 0;
	cleanEvaluationPlan(p);
	for (int i=1; i<p.poset->n; ++i) {
		nEvaluations += dfsRaySearch(g, p, p.poset->vertices[i], gp);
	}

	fprintf(stderr, "%i\n", nEvaluations);
	return patternPosetInfoToFeatureSet(p);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x30, %rsp
movq %rsi, %rbx
movq %rdi, %r14
movaps 0x60(%rsp), %xmm0
movaps 0x70(%rsp), %xmm1
movaps 0x80(%rsp), %xmm2
movups %xmm2, 0x20(%rsp)
movups %xmm1, 0x10(%rsp)
movups %xmm0, (%rsp)
callq 0x1539d
movq 0x60(%rsp), %rax
xorl %ebp, %ebp
cmpl $0x2, (%rax)
jl 0x206e
leaq 0x60(%rsp), %r15
xorl %ebp, %ebp
pushq $0x1
popq %r12
movq 0x10(%rax), %rax
movq (%rax,%r12,8), %rsi
movups (%r15), %xmm0
movups 0x10(%r15), %xmm1
movups 0x20(%r15), %xmm2
movups %xmm2, 0x20(%rsp)
movups %xmm1, 0x10(%rsp)
movups %xmm0, (%rsp)
movq %r14, %rdi
movq %rbx, %rdx
callq 0x188ae
addl %eax, %ebp
incq %r12
movq (%r15), %rax
movslq (%rax), %rcx
cmpq %rcx, %r12
jl 0x202f
movq 0x2af83(%rip), %rax     # 0x2cff8
movq (%rax), %rdi
leaq 0x1dfb7(%rip), %rsi     # 0x20036
movl %ebp, %edx
xorl %eax, %eax
callq 0x1160
addq $0x30, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
jmp 0x15543
// File: /workspace/github_c_makefile_star2_O1/pwelke[P]GraphMiningTools/poset_pathCover.c
// Function: latticePathEmbeddingForTrees
struct IntSet* latticePathEmbeddingForTrees(struct Graph* g, struct EvaluationPlan p, struct GraphPool* gp) {

	int nEvaluations = 0;
	cleanEvaluationPlan(p);

	for (int i=1; i<p.poset->n; ++i) {
		if (!embeddingValueKnown(p.poset->vertices[i])) {
			int* path = getPathInDAG(p.poset->vertices[i]);
			nEvaluations += binarySearchEvaluation(g, p, path, gp);
			free(path);
		}
	}

	fprintf(stderr, "%i\n", nEvaluations);
	return patternPosetInfoToFeatureSet(p);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x38, %rsp
movq %rsi, %rbx
movq %rdi, %r14
movaps 0x70(%rsp), %xmm0
movaps 0x80(%rsp), %xmm1
movaps 0x90(%rsp), %xmm2
movups %xmm2, 0x20(%rsp)
movups %xmm1, 0x10(%rsp)
movups %xmm0, (%rsp)
callq 0x1539d
movq 0x70(%rsp), %rax
xorl %ebp, %ebp
cmpl $0x2, (%rax)
jl 0x2157
leaq 0x70(%rsp), %r12
xorl %ebp, %ebp
pushq $0x1
popq %r13
movq 0x10(%rax), %rax
movq (%rax,%r13,8), %rdi
callq 0x153d8
testl %eax, %eax
jne 0x2148
movq (%r12), %rax
movq 0x10(%rax), %rax
movq (%rax,%r13,8), %rdi
callq 0x18978
movq %rax, %r15
movups (%r12), %xmm0
movups 0x10(%r12), %xmm1
movups 0x20(%r12), %xmm2
movups %xmm2, 0x20(%rsp)
movups %xmm1, 0x10(%rsp)
movups %xmm0, (%rsp)
movq %r14, %rdi
movq %rax, %rsi
movq %rbx, %rdx
callq 0x189e4
addl %eax, %ebp
movq %r15, %rdi
callq 0x1030
incq %r13
movq (%r12), %rax
movslq (%rax), %rcx
cmpq %rcx, %r13
jl 0x20ec
movq 0x2ae9a(%rip), %rax     # 0x2cff8
movq (%rax), %rdi
leaq 0x1dece(%rip), %rsi     # 0x20036
movl %ebp, %edx
xorl %eax, %eax
callq 0x1160
addq $0x38, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x15543
// File: /workspace/github_c_makefile_star2_O1/pwelke[P]GraphMiningTools/poset_pathCover.c
// Function: latticeLongestPathEmbeddingForTrees
struct IntSet* latticeLongestPathEmbeddingForTrees(struct Graph* g, struct EvaluationPlan p, struct GraphPool* gp, struct ShallowGraphPool* sgp) {

	int nEvaluations = 0;
	cleanEvaluationPlan(p);

	for (int i=1; i<p.poset->n; ++i) {
		if (!embeddingValueKnown(p.poset->vertices[i])) {
			int* path = getLongestPathInDAG(p.poset->vertices[i], p.poset, sgp);
			nEvaluations += binarySearchEvaluation(g, p, path, gp);
			free(path);
		}
	}

	fprintf(stderr, "%i\n", nEvaluations);
	return patternPosetInfoToFeatureSet(p);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x38, %rsp
movq %rdx, 0x30(%rsp)
movq %rsi, %r14
movq %rdi, %r15
movaps 0x70(%rsp), %xmm0
movaps 0x80(%rsp), %xmm1
movaps 0x90(%rsp), %xmm2
movups %xmm2, 0x20(%rsp)
movups %xmm1, 0x10(%rsp)
movups %xmm0, (%rsp)
callq 0x1539d
movq 0x70(%rsp), %rax
xorl %ebp, %ebp
cmpl $0x2, (%rax)
jl 0x2249
leaq 0x70(%rsp), %r13
xorl %ebp, %ebp
pushq $0x1
popq %rbx
movq 0x10(%rax), %rax
movq (%rax,%rbx,8), %rdi
callq 0x153d8
testl %eax, %eax
jne 0x223a
movq (%r13), %rsi
movq 0x10(%rsi), %rax
movq (%rax,%rbx,8), %rdi
movq 0x30(%rsp), %rdx
callq 0x18acf
movq %rax, %r12
movups (%r13), %xmm0
movups 0x10(%r13), %xmm1
movups 0x20(%r13), %xmm2
movups %xmm2, 0x20(%rsp)
movups %xmm1, 0x10(%rsp)
movups %xmm0, (%rsp)
movq %r15, %rdi
movq %rax, %rsi
movq %r14, %rdx
callq 0x189e4
addl %eax, %ebp
movq %r12, %rdi
callq 0x1030
incq %rbx
movq (%r13), %rax
movslq (%rax), %rcx
cmpq %rcx, %rbx
jl 0x21db
movq 0x2ada8(%rip), %rax     # 0x2cff8
movq (%rax), %rdi
leaq 0x1dddc(%rip), %rsi     # 0x20036
movl %ebp, %edx
xorl %eax, %eax
callq 0x1160
addq $0x38, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x15543
// File: /workspace/github_c_makefile_star2_O1/pwelke[P]GraphMiningTools/poset_pathCover.c
// Function: staticPathCoverEmbeddingForTrees
struct IntSet* staticPathCoverEmbeddingForTrees(struct Graph* g, struct EvaluationPlan p, struct GraphPool* gp) {

	int nEvaluations = 0;
	cleanEvaluationPlan(p);

	for (size_t i=0; i<p.sketchSize; ++i) {
		nEvaluations += binarySearchEvaluation(g, p, p.shrunkPermutations[i], gp);
	}

	fprintf(stderr, "%i\n", nEvaluations);
	return patternPosetInfoToFeatureSet(p);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x30, %rsp
movq %rsi, %rbx
movq %rdi, %r14
movaps 0x60(%rsp), %xmm0
movaps 0x70(%rsp), %xmm1
movaps 0x80(%rsp), %xmm2
movups %xmm2, 0x20(%rsp)
movups %xmm1, 0x10(%rsp)
movups %xmm0, (%rsp)
callq 0x1539d
xorl %ebp, %ebp
cmpq $0x0, 0x88(%rsp)
je 0x22fe
leaq 0x60(%rsp), %r15
xorl %r12d, %r12d
xorl %ebp, %ebp
movq 0x18(%r15), %rax
movq (%rax,%r12,8), %rsi
movups (%r15), %xmm0
movups 0x10(%r15), %xmm1
movups 0x20(%r15), %xmm2
movups %xmm2, 0x20(%rsp)
movups %xmm1, 0x10(%rsp)
movups %xmm0, (%rsp)
movq %r14, %rdi
movq %rbx, %rdx
callq 0x189e4
addl %eax, %ebp
incq %r12
cmpq 0x28(%r15), %r12
jb 0x22c4
movq 0x2acf3(%rip), %rax     # 0x2cff8
movq (%rax), %rdi
leaq 0x1dd27(%rip), %rsi     # 0x20036
movl %ebp, %edx
xorl %eax, %eax
callq 0x1160
addq $0x30, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
jmp 0x15543
// File: /workspace/github_c_makefile_star2_O1/pwelke[P]GraphMiningTools/poset_pathCover.c
// Function: dfsDownwardEmbeddingForLocalEasy
struct IntSet* dfsDownwardEmbeddingForLocalEasy(struct Graph* g, struct EvaluationPlan p, int sampleSize, struct GraphPool* gp, struct ShallowGraphPool* sgp) {

	struct SpanningtreeTree spTree = getSampledSpanningtreeTree(getBlockTreeT(g, sgp), sampleSize, 1, gp, sgp);

	int nEvaluations = 0;
	cleanEvaluationPlan(p);
	for (int i=1; i<p.poset->n; ++i) {
		nEvaluations += dfsRaySearchLE(&spTree, p, p.poset->vertices[i], gp);
	}

	dumpSpanningtreeTree(spTree, gp);

	fprintf(stderr, "%i\n", nEvaluations);
	return patternPosetInfoToFeatureSet(p);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0xa0, %rsp
movq %rcx, %r14
movq %rdx, %rbx
movl %esi, %ebp
movq %rdi, %rsi
leaq 0xd0(%rsp), %r12
leaq 0x78(%rsp), %r15
movq %r15, %rdi
movq %rcx, %rdx
callq 0xe85c
movq 0x20(%r15), %rax
movq %rax, 0x20(%rsp)
movups (%r15), %xmm0
movups 0x10(%r15), %xmm1
movups %xmm1, 0x10(%rsp)
movups %xmm0, (%rsp)
leaq 0x40(%rsp), %rdi
pushq $0x1
popq %rdx
movl %ebp, %esi
movq %rbx, %rcx
movq %r14, %r8
callq 0xf05d
movaps (%r12), %xmm0
movaps 0x10(%r12), %xmm1
movaps 0x20(%r12), %xmm2
movups %xmm2, 0x20(%rsp)
movups %xmm1, 0x10(%rsp)
movups %xmm0, (%rsp)
callq 0x1539d
movq (%r12), %rax
xorl %ebp, %ebp
cmpl $0x2, (%rax)
jl 0x268b
xorl %ebp, %ebp
pushq $0x1
popq %r15
leaq 0x40(%rsp), %r14
movq 0x10(%rax), %rax
movq (%rax,%r15,8), %rsi
movups (%r12), %xmm0
movups 0x10(%r12), %xmm1
movups 0x20(%r12), %xmm2
movups %xmm2, 0x20(%rsp)
movups %xmm1, 0x10(%rsp)
movups %xmm0, (%rsp)
movq %r14, %rdi
movq %rbx, %rdx
callq 0x18c54
addl %eax, %ebp
incq %r15
movq (%r12), %rax
movslq (%rax), %rcx
cmpq %rcx, %r15
jl 0x2648
movq 0x70(%rsp), %rax
movq %rax, 0x30(%rsp)
movups 0x40(%rsp), %xmm0
movups 0x50(%rsp), %xmm1
movups 0x60(%rsp), %xmm2
movups %xmm2, 0x20(%rsp)
movups %xmm1, 0x10(%rsp)
movups %xmm0, (%rsp)
movq %rbx, %rdi
callq 0xf502
movq 0x2a937(%rip), %rax     # 0x2cff8
movq (%rax), %rdi
leaq 0x1d96b(%rip), %rsi     # 0x20036
movl %ebp, %edx
xorl %eax, %eax
callq 0x1160
movups (%r12), %xmm0
movups 0x10(%r12), %xmm1
movups 0x20(%r12), %xmm2
movups %xmm2, 0x20(%rsp)
movups %xmm1, 0x10(%rsp)
movups %xmm0, (%rsp)
callq 0x15543
addq $0xa0, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/pwelke[P]GraphMiningTools/poset_pathCover.c
// Function: latticePathEmbeddingForLocalEasy
struct IntSet* latticePathEmbeddingForLocalEasy(struct Graph* g, struct EvaluationPlan p, int sampleSize, struct GraphPool* gp, struct ShallowGraphPool* sgp) {

	struct SpanningtreeTree spTree = getSampledSpanningtreeTree(getBlockTreeT(g, sgp), sampleSize, 1, gp, sgp);

	int nEvaluations = 0;
	cleanEvaluationPlan(p);
	for (int i=1; i<p.poset->n; ++i) {
		if (!embeddingValueKnown(p.poset->vertices[i])) {
			int* path = getPathInDAG(p.poset->vertices[i]);
			nEvaluations += binarySearchEvaluationLE(&spTree, p, path, gp);
			free(path);
		}
	}

	dumpSpanningtreeTree(spTree, gp);

	fprintf(stderr, "%i\n", nEvaluations);
	return patternPosetInfoToFeatureSet(p);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x98, %rsp
movq %rcx, %r14
movq %rdx, %rbx
movl %esi, %ebp
movq %rdi, %rsi
leaq 0xd0(%rsp), %r12
leaq 0x70(%rsp), %r15
movq %r15, %rdi
movq %rcx, %rdx
callq 0xe85c
movq 0x20(%r15), %rax
movq %rax, 0x20(%rsp)
movups (%r15), %xmm0
movups 0x10(%r15), %xmm1
movups %xmm1, 0x10(%rsp)
movups %xmm0, (%rsp)
leaq 0x38(%rsp), %rdi
pushq $0x1
popq %rdx
movl %ebp, %esi
movq %rbx, %rcx
movq %r14, %r8
callq 0xf05d
movaps (%r12), %xmm0
movaps 0x10(%r12), %xmm1
movaps 0x20(%r12), %xmm2
movups %xmm2, 0x20(%rsp)
movups %xmm1, 0x10(%rsp)
movups %xmm0, (%rsp)
callq 0x1539d
movq (%r12), %rax
xorl %ebp, %ebp
cmpl $0x2, (%rax)
jl 0x2811
xorl %ebp, %ebp
pushq $0x1
popq %r13
leaq 0x38(%rsp), %r14
movq 0x10(%rax), %rax
movq (%rax,%r13,8), %rdi
callq 0x153d8
testl %eax, %eax
jne 0x2802
movq (%r12), %rax
movq 0x10(%rax), %rax
movq (%rax,%r13,8), %rdi
callq 0x18978
movq %rax, %r15
movups (%r12), %xmm0
movups 0x10(%r12), %xmm1
movups 0x20(%r12), %xmm2
movups %xmm2, 0x20(%rsp)
movups %xmm1, 0x10(%rsp)
movups %xmm0, (%rsp)
movq %r14, %rdi
movq %rax, %rsi
movq %rbx, %rdx
callq 0x18d4a
addl %eax, %ebp
movq %r15, %rdi
callq 0x1030
incq %r13
movq (%r12), %rax
movslq (%rax), %rcx
cmpq %rcx, %r13
jl 0x27a6
movq 0x68(%rsp), %rax
movq %rax, 0x30(%rsp)
movups 0x38(%rsp), %xmm0
movups 0x48(%rsp), %xmm1
movups 0x58(%rsp), %xmm2
movups %xmm2, 0x20(%rsp)
movups %xmm1, 0x10(%rsp)
movups %xmm0, (%rsp)
movq %rbx, %rdi
callq 0xf502
movq 0x2a7b1(%rip), %rax     # 0x2cff8
movq (%rax), %rdi
leaq 0x1d7e5(%rip), %rsi     # 0x20036
movl %ebp, %edx
xorl %eax, %eax
callq 0x1160
movups (%r12), %xmm0
movups 0x10(%r12), %xmm1
movups 0x20(%r12), %xmm2
movups %xmm2, 0x20(%rsp)
movups %xmm1, 0x10(%rsp)
movups %xmm0, (%rsp)
callq 0x15543
addq $0x98, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/pwelke[P]GraphMiningTools/poset_pathCover.c
// Function: latticeLongestPathEmbeddingForLocalEasy
struct IntSet* latticeLongestPathEmbeddingForLocalEasy(struct Graph* g, struct EvaluationPlan p, int sampleSize, struct GraphPool* gp, struct ShallowGraphPool* sgp) {

	struct SpanningtreeTree spTree = getSampledSpanningtreeTree(getBlockTreeT(g, sgp), sampleSize, 1, gp, sgp);

	int nEvaluations = 0;
	cleanEvaluationPlan(p);
	for (int i=1; i<p.poset->n; ++i) {
		if (!embeddingValueKnown(p.poset->vertices[i])) {
			int* path = getLongestPathInDAG(p.poset->vertices[i], p.poset, sgp);
			nEvaluations += binarySearchEvaluationLE(&spTree, p, path, gp);
			free(path);
		}
	}

	dumpSpanningtreeTree(spTree, gp);

	fprintf(stderr, "%i\n", nEvaluations);
	return patternPosetInfoToFeatureSet(p);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x98, %rsp
movq %rcx, %r14
movq %rdx, %rbx
movl %esi, %ebp
movq %rdi, %rsi
leaq 0xd0(%rsp), %r13
leaq 0x70(%rsp), %r15
movq %r15, %rdi
movq %rcx, %rdx
callq 0xe85c
movq 0x20(%r15), %rax
movq %rax, 0x20(%rsp)
movups (%r15), %xmm0
movups 0x10(%r15), %xmm1
movups %xmm1, 0x10(%rsp)
movups %xmm0, (%rsp)
leaq 0x38(%rsp), %rdi
pushq $0x1
popq %rdx
movl %ebp, %esi
movq %rbx, %rcx
movq %r14, %r8
callq 0xf05d
movaps (%r13), %xmm0
movaps 0x10(%r13), %xmm1
movaps 0x20(%r13), %xmm2
movups %xmm2, 0x20(%rsp)
movups %xmm1, 0x10(%rsp)
movups %xmm0, (%rsp)
callq 0x1539d
movq (%r13), %rax
xorl %ebp, %ebp
cmpl $0x2, (%rax)
jl 0x2995
xorl %ebp, %ebp
pushq $0x1
popq %r15
movq 0x10(%rax), %rax
movq (%rax,%r15,8), %rdi
callq 0x153d8
testl %eax, %eax
jne 0x2986
movq (%r13), %rsi
movq 0x10(%rsi), %rax
movq (%rax,%r15,8), %rdi
movq %r14, %rdx
callq 0x18acf
movq %rax, %r12
movups (%r13), %xmm0
movups 0x10(%r13), %xmm1
movups 0x20(%r13), %xmm2
movups %xmm2, 0x20(%rsp)
movups %xmm1, 0x10(%rsp)
movups %xmm0, (%rsp)
leaq 0x38(%rsp), %rdi
movq %rax, %rsi
movq %rbx, %rdx
callq 0x18d4a
addl %eax, %ebp
movq %r12, %rdi
callq 0x1030
incq %r15
movq (%r13), %rax
movslq (%rax), %rcx
cmpq %rcx, %r15
jl 0x2927
movq 0x68(%rsp), %rax
movq %rax, 0x30(%rsp)
movups 0x38(%rsp), %xmm0
movups 0x48(%rsp), %xmm1
movups 0x58(%rsp), %xmm2
movups %xmm2, 0x20(%rsp)
movups %xmm1, 0x10(%rsp)
movups %xmm0, (%rsp)
movq %rbx, %rdi
callq 0xf502
movq 0x2a62d(%rip), %rax     # 0x2cff8
movq (%rax), %rdi
leaq 0x1d661(%rip), %rsi     # 0x20036
movl %ebp, %edx
xorl %eax, %eax
callq 0x1160
movups (%r13), %xmm0
movups 0x10(%r13), %xmm1
movups 0x20(%r13), %xmm2
movups %xmm2, 0x20(%rsp)
movups %xmm1, 0x10(%rsp)
movups %xmm0, (%rsp)
callq 0x15543
addq $0x98, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/pwelke[P]GraphMiningTools/poset_pathCover.c
// Function: staticPathCoverEmbeddingForLocalEasy
struct IntSet* staticPathCoverEmbeddingForLocalEasy(struct Graph* g, struct EvaluationPlan p, int sampleSize, struct GraphPool* gp, struct ShallowGraphPool* sgp) {

	struct SpanningtreeTree spTree = getSampledSpanningtreeTree(getBlockTreeT(g, sgp), sampleSize, 1, gp, sgp);

	int nEvaluations = 0;
	cleanEvaluationPlan(p);
	for (size_t i=0; i<p.sketchSize; ++i) {
		nEvaluations += binarySearchEvaluationLE(&spTree, p, p.shrunkPermutations[i], gp);
	}

	dumpSpanningtreeTree(spTree, gp);

	fprintf(stderr, "%i\n", nEvaluations);
	return patternPosetInfoToFeatureSet(p);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0xa0, %rsp
movq %rcx, %r14
movq %rdx, %rbx
movl %esi, %ebp
movq %rdi, %rsi
leaq 0xd0(%rsp), %r12
leaq 0x78(%rsp), %r15
movq %r15, %rdi
movq %rcx, %rdx
callq 0xe85c
movq 0x20(%r15), %rax
movq %rax, 0x20(%rsp)
movups (%r15), %xmm0
movups 0x10(%r15), %xmm1
movups %xmm1, 0x10(%rsp)
movups %xmm0, (%rsp)
leaq 0x40(%rsp), %rdi
pushq $0x1
popq %rdx
movl %ebp, %esi
movq %rbx, %rcx
movq %r14, %r8
callq 0xf05d
movaps (%r12), %xmm0
movaps 0x10(%r12), %xmm1
movaps 0x20(%r12), %xmm2
movups %xmm2, 0x20(%rsp)
movups %xmm1, 0x10(%rsp)
movups %xmm0, (%rsp)
callq 0x1539d
xorl %ebp, %ebp
cmpq $0x0, 0x28(%r12)
je 0x2aeb
xorl %r15d, %r15d
leaq 0x40(%rsp), %r14
xorl %ebp, %ebp
movq 0x18(%r12), %rax
movq (%rax,%r15,8), %rsi
movups (%r12), %xmm0
movups 0x10(%r12), %xmm1
movups 0x20(%r12), %xmm2
movups %xmm2, 0x20(%rsp)
movups %xmm1, 0x10(%rsp)
movups %xmm0, (%rsp)
movq %r14, %rdi
movq %rbx, %rdx
callq 0x18d4a
addl %eax, %ebp
incq %r15
cmpq 0x28(%r12), %r15
jb 0x2aac
movq 0x70(%rsp), %rax
movq %rax, 0x30(%rsp)
movups 0x40(%rsp), %xmm0
movups 0x50(%rsp), %xmm1
movups 0x60(%rsp), %xmm2
movups %xmm2, 0x20(%rsp)
movups %xmm1, 0x10(%rsp)
movups %xmm0, (%rsp)
movq %rbx, %rdi
callq 0xf502
movq 0x2a4d7(%rip), %rax     # 0x2cff8
movq (%rax), %rdi
leaq 0x1d50b(%rip), %rsi     # 0x20036
movl %ebp, %edx
xorl %eax, %eax
callq 0x1160
movups (%r12), %xmm0
movups 0x10(%r12), %xmm1
movups 0x20(%r12), %xmm2
movups %xmm2, 0x20(%rsp)
movups %xmm1, 0x10(%rsp)
movups %xmm0, (%rsp)
callq 0x15543
addq $0xa0, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/pwelke[P]GraphMiningTools/bipartiteMatching.c
// Function: pr_sanityOfFlow
int pr_sanityOfFlow(struct Graph* g, struct Vertex* s, struct Vertex* t, FILE* out) {
	int sOuttIn = s->visited + t->visited;

	int excessViolated = 0;
	for (int vi=0; vi<g->n; ++vi) {
		struct Vertex* v = g->vertices[vi];
		if ((v != s) && (v != t)) {
			if (v->visited != 0) {
				++excessViolated;
			}
		}
	}

	if (out) {
		fprintf(out, "excess s: %i, excess t:%i, violations in between: %i\n", s->visited, t->visited, excessViolated);
	}

	return !sOuttIn && !excessViolated;
}

// Assembly:
pushq %rbp
pushq %r14
pushq %rbx
movslq (%rdi), %rax
testq %rax, %rax
jle 0x3025
movq 0x10(%rdi), %rdi
xorl %r8d, %r8d
xorl %ebx, %ebx
movq (%rdi,%r8,8), %r9
cmpq %rsi, %r9
sete %r10b
cmpq %rdx, %r9
sete %r11b
orb %r10b, %r11b
jne 0x301b
cmpl $0x1, 0x1c(%r9)
sbbl $-0x1, %ebx
incq %r8
cmpq %r8, %rax
jne 0x2ffc
jmp 0x3027
xorl %ebx, %ebx
movl 0x1c(%rsi), %ebp
movl 0x1c(%rdx), %r14d
testq %rcx, %rcx
je 0x304c
leaq 0x1cfca(%rip), %rsi     # 0x20004
movq %rcx, %rdi
movl %ebp, %edx
movl %r14d, %ecx
movl %ebx, %r8d
xorl %eax, %eax
callq 0x1160
negl %r14d
xorl %r14d, %ebp
xorl %eax, %eax
orl %ebx, %ebp
sete %al
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/pwelke[P]GraphMiningTools/bipartiteMatching.c
// Function: pr_sanityOfFinalActiveArray
int pr_sanityOfFinalActiveArray(struct ShallowGraph** activeVertices, int nLists, FILE* out) {
	int forgottenVertices = 0;
	for (int i=0; i<nLists; ++i) {
		if (peekFromVertexQueue(activeVertices[i])) {
			forgottenVertices += activeVertices[i]->m;
			if (out) {
				fprintf(out, "Level %i: Vertex %i\n", i, peekFromVertexQueue(activeVertices[i])->number);
			}
		}
	}
	if (out) {
		fprintf(out, "total of forgotten vertices: %i\n", forgottenVertices);
	}
	return forgottenVertices;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rdx, %rbx
testl %esi, %esi
jle 0x30be
movq %rdi, %r14
movl %esi, %r13d
leaq 0x1cfbd(%rip), %r15     # 0x2003a
xorl %r12d, %r12d
xorl %ebp, %ebp
movq (%r14,%r12,8), %rdi
callq 0x1e905
testq %rax, %rax
je 0x30b4
movq (%r14,%r12,8), %rdi
addl 0x10(%rdi), %ebp
testq %rbx, %rbx
je 0x30b4
callq 0x1e905
movl 0x18(%rax), %ecx
movq %rbx, %rdi
movq %r15, %rsi
movl %r12d, %edx
xorl %eax, %eax
callq 0x1160
incq %r12
cmpq %r12, %r13
jne 0x3082
jmp 0x30c0
xorl %ebp, %ebp
testq %rbx, %rbx
je 0x30d8
leaq 0x1cf83(%rip), %rsi     # 0x2004f
movq %rbx, %rdi
movl %ebp, %edx
xorl %eax, %eax
callq 0x1160
movl %ebp, %eax
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/bipartiteMatching.c
// Function: augment
char augment(struct Vertex* s, struct Vertex* t) {
	struct VertexList* e;

	if (s == t) {
		return 1;
	}
	s->visited = 1;
	for (e=s->neighborhood; e!=NULL; e=e->next) {
		if ((e->flag == 0) && (e->endPoint->visited == 0)) {
			char found = augment(e->endPoint, t);
			if (found) {
				setFlag(e, 1);
				s->visited = 0;
				return 1;
			}
		}
	}
	s->visited = 0;
	return 0;
}

// Assembly:
cmpq %rsi, %rdi
je 0x337a
pushq %r15
pushq %r14
pushq %rbx
movq %rdi, %rbx
movl $0x1, 0x1c(%rdi)
movq 0x8(%rdi), %r15
testq %r15, %r15
je 0x336b
movq %rsi, %r14
cmpl $0x0, 0x24(%r15)
jne 0x3362
movq 0x18(%r15), %rdi
cmpl $0x0, 0x1c(%rdi)
jne 0x3362
movq %r14, %rsi
callq 0x3325
testb %al, %al
jne 0x337d
movq 0x8(%r15), %r15
testq %r15, %r15
jne 0x3345
xorl %eax, %eax
movl $0x0, 0x1c(%rbx)
popq %rbx
popq %r14
popq %r15
retq
movb $0x1, %al
retq
movl $0x1, 0x24(%r15)
movq (%r15), %rax
movl $0x0, 0x24(%rax)
movb $0x1, %al
jmp 0x336d
// File: /workspace/github_c_makefile_star2_O1/pwelke[P]GraphMiningTools/bipartiteMatching.c
// Function: augmentWithCapacity
char augmentWithCapacity(struct Vertex* s, struct Vertex* t) {
	if (s == t) {
		return 1;
	}

	s->visited = 1;
	for (struct VertexList* e=s->neighborhood; e!=NULL; e=e->next) {
		if ((e->flag < e->used) && (e->endPoint->visited == 0)) {
			char found = augmentWithCapacity(e->endPoint, t);
			if (found) {
				addFlow(e, 1);
				s->visited = 0;
				return 1;
			}
		}
	}
	s->visited = 0;
	return 0;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movb $0x1, %bl
cmpq %rsi, %rdi
je 0x33f7
movq %rdi, %r14
movl $0x1, 0x1c(%rdi)
movq 0x8(%rdi), %r12
testq %r12, %r12
sete %bpl
je 0x33ed
movq %rsi, %r15
movl 0x24(%r12), %eax
cmpl 0x20(%r12), %eax
jge 0x33df
movq 0x18(%r12), %rdi
cmpl $0x0, 0x1c(%rdi)
jne 0x33df
movq %r15, %rsi
callq 0x3393
testb %al, %al
jne 0x3402
movq 0x8(%r12), %r12
testq %r12, %r12
sete %bpl
jne 0x33bc
movl $0x0, 0x1c(%r14)
xorl %ebx, %ebx
movl %ebx, %eax
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
incl 0x24(%r12)
movq (%r12), %rax
decl 0x24(%rax)
movl $0x0, 0x1c(%r14)
testb $0x1, %bpl
jne 0x33ed
jmp 0x33f7
// File: /workspace/github_c_makefile_star2_O1/pwelke[P]GraphMiningTools/bipartiteMatching.c
// Function: getMatchedVertex
struct Vertex* getMatchedVertex(struct Vertex* a) {
	struct VertexList* e;
	for (e=a->neighborhood; e!=NULL; e=e->next) {
		if (e->flag == 1) {
			return e->endPoint;
		}
	}
	return NULL;
}

// Assembly:
xorl %eax, %eax
movq 0x8(%rdi), %rdi
testq %rdi, %rdi
je 0x3433
cmpl $0x1, 0x24(%rdi)
jne 0x3420
movq 0x18(%rdi), %rax
retq
// File: /workspace/github_c_makefile_star2_O1/pwelke[P]GraphMiningTools/bipartiteMatching.c
// Function: addResidualEdges
void addResidualEdges(struct Vertex* v, struct Vertex* w, struct ListPool* lp) {
	struct VertexList* f1;
	struct VertexList* f2;

	f1 = getVertexList(lp);
	f1->startPoint = v;
	f1->endPoint = w;
	f2 = inverseEdge(f1, lp);

	f1->flag = 0;
	f2->flag = 1;
	f1->label = (char*)f2;
	f2->label = (char*)f1;

	addEdge(v, f1);
	addEdge(w, f2);
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rdx, %rbx
movq %rsi, %r14
movq %rdi, %r15
movq %rdx, %rdi
callq 0x1432b
movq %rax, %r12
movq %r15, 0x10(%rax)
movq %r14, 0x18(%rax)
movq %rax, %rdi
movq %rbx, %rsi
callq 0x7bdc
movq %rax, %rbx
movl $0x0, 0x24(%r12)
movl $0x1, 0x24(%rax)
movq %rax, (%r12)
movq %r12, (%rax)
movq %r15, %rdi
movq %r12, %rsi
callq 0x7cd0
movq %r14, %rdi
movq %rbx, %rsi
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
jmp 0x7cd0
// File: /workspace/github_c_makefile_star2_O1/pwelke[P]GraphMiningTools/bipartiteMatching.c
// Function: addResidualEdgesWithCapacity
void addResidualEdgesWithCapacity(struct Vertex* v, struct Vertex* w, int capacity, struct ListPool* lp) {
	struct VertexList* f1;
	struct VertexList* f2;

	f1 = getVertexList(lp);
	f1->startPoint = v;
	f1->endPoint = w;
	f2 = inverseEdge(f1, lp);

	f1->used = capacity;
	f2->used = capacity;
	f1->flag = 0;
	f2->flag = capacity;
	f1->label = (char*)f2;
	f2->label = (char*)f1;

	addEdge(v, f1);
	addEdge(w, f2);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movq %rcx, %rbx
movl %edx, %ebp
movq %rsi, %r14
movq %rdi, %r15
movq %rcx, %rdi
callq 0x1432b
movq %rax, %r12
movq %r15, 0x10(%rax)
movq %r14, 0x18(%rax)
movq %rax, %rdi
movq %rbx, %rsi
callq 0x7bdc
movq %rax, %rbx
movl %ebp, 0x20(%r12)
movl %ebp, 0x20(%rax)
movl $0x0, 0x24(%r12)
movl %ebp, 0x24(%rax)
movq %rax, (%r12)
movq %r12, (%rax)
movq %r15, %rdi
movq %r12, %rsi
callq 0x7cd0
movq %r14, %rdi
movq %rbx, %rsi
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
jmp 0x7cd0
// File: /workspace/github_c_makefile_star2_O1/pwelke[P]GraphMiningTools/bipartiteMatching.c
// Function: _cloneStrangeBipartite
struct Graph* __cloneStrangeBipartite(struct Graph* g, struct GraphPool* gp) {
	int v; 
	struct VertexList* e;
	struct Graph* h = createGraph(g->n, gp);
	h->number = g->number;
	h->m = g->m;

	for (v=0; v<g->number; ++v) {
		for (e=g->vertices[v]->neighborhood; e!=NULL; e=e->next) {		
			addResidualEdges(h->vertices[v], h->vertices[e->endPoint->number], gp->listPool);
		}
	}
	return h;
}

// Assembly:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
movq %rsi, %rbx
movq %rdi, %r14
movl (%rdi), %edi
callq 0x8565
movq %rax, %r15
movq 0x4(%r14), %rax
movq %rax, 0x4(%r15)
cmpl $0x0, 0x8(%r14)
jle 0x3591
xorl %r12d, %r12d
movq 0x10(%r14), %rax
movq (%rax,%r12,8), %rax
movq 0x8(%rax), %r13
testq %r13, %r13
je 0x3585
movq 0x10(%r15), %rax
movq (%rax,%r12,8), %rdi
movq 0x18(%r13), %rcx
movslq 0x18(%rcx), %rcx
movq (%rax,%rcx,8), %rsi
movq 0x18(%rbx), %rdx
callq 0x344f
movq 0x8(%r13), %r13
jmp 0x355d
incq %r12
movslq 0x8(%r14), %rax
cmpq %rax, %r12
jl 0x3551
movq %r15, %rax
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O1/pwelke[P]GraphMiningTools/bipartiteMatching.c
// Function: initBipartite
void initBipartite(struct Graph* B) {
	int i;
	struct VertexList* e;
	for (i=0; i<B->number; ++i) {
		for (e=B->vertices[i]->neighborhood; e!=NULL; e=e->next) {
			setFlag(e, 0);
		}
	}
}

// Assembly:
movslq 0x8(%rdi), %rax
testq %rax, %rax
jle 0x35d5
movq 0x10(%rdi), %rcx
xorl %edx, %edx
movq (%rcx,%rdx,8), %rsi
movq 0x8(%rsi), %rsi
testq %rsi, %rsi
je 0x35cd
movl $0x0, 0x24(%rsi)
movq (%rsi), %rdi
movl $0x1, 0x24(%rdi)
jmp 0x35b1
incq %rdx
cmpq %rax, %rdx
jne 0x35ad
retq
// File: /workspace/github_c_makefile_star2_O1/pwelke[P]GraphMiningTools/bipartiteMatching.c
// Function: removeSandT
void removeSandT(struct Graph* B, struct Vertex* s, struct Vertex* t, struct GraphPool* gp) {	
	int w;

	for (w=0; w<B->number; ++w) {
		removeEdge(B->vertices[w], s, gp->listPool);
	}

	for (w=B->number; w<B->n; ++w) {
		removeEdge(B->vertices[w], t, gp->listPool);
	}

	dumpVertexListRecursively(gp->listPool, s->neighborhood);
	dumpVertexListRecursively(gp->listPool, t->neighborhood);

	dumpVertex(gp->vertexPool, s);
	dumpVertex(gp->vertexPool, t);
}

// Assembly:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
movq %rcx, %r14
movq %rdx, %rbx
movq %rsi, %r15
movq %rdi, %r12
movl 0x8(%rdi), %eax
testl %eax, %eax
jle 0x3617
xorl %r13d, %r13d
movq 0x10(%r12), %rax
movq (%rax,%r13,8), %rdi
movq 0x18(%r14), %rdx
movq %r15, %rsi
callq 0x7cdd
incq %r13
movslq 0x8(%r12), %rax
cmpq %rax, %r13
jl 0x35f5
cmpl (%r12), %eax
jge 0x3641
movslq %eax, %r13
movq 0x10(%r12), %rax
movq (%rax,%r13,8), %rdi
movq 0x18(%r14), %rdx
movq %rbx, %rsi
callq 0x7cdd
incq %r13
movslq (%r12), %rax
cmpq %rax, %r13
jl 0x3620
movq 0x18(%r14), %rdi
movq 0x8(%r15), %rsi
callq 0x143b8
movq 0x18(%r14), %rdi
movq 0x8(%rbx), %rsi
callq 0x143b8
movq 0x10(%r14), %rdi
movq %r15, %rsi
callq 0x14628
movq 0x10(%r14), %rdi
movq %rbx, %rsi
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
jmp 0x14628
// File: /workspace/github_c_makefile_star2_O1/pwelke[P]GraphMiningTools/bipartiteMatching.c
// Function: bipartiteMatchingFastAndDirty
int bipartiteMatchingFastAndDirty(struct Graph* g, struct GraphPool* gp) {
	int v;
	int matchingSize = 0;

	struct Vertex* s = getVertex(gp->vertexPool);
	struct Vertex* t = getVertex(gp->vertexPool);
	s->number = -1;
	t->number = -2;

	/* Add s, t and edges from s to A and from B to t.
	Also, set residual capacities for these edges correctly */
	for (v=0; v<g->number; ++v) {
		addResidualEdges(s, g->vertices[v], gp->listPool);
	}

	for (v=g->number; v<g->n; ++v) {
		addResidualEdges(g->vertices[v], t, gp->listPool);
	}

	while (augment(s, t)) {
		++matchingSize;
	}

	removeSandT(g, s, t, gp);

	return matchingSize;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq %rdi, %r14
movq 0x10(%rsi), %rdi
callq 0x145b2
movq %rax, %r15
movq 0x10(%rbx), %rdi
callq 0x145b2
movq %rax, %r12
movl $0xffffffff, 0x18(%r15) # imm = 0xFFFFFFFF
movl $0xfffffffe, 0x18(%rax) # imm = 0xFFFFFFFE
movl 0x8(%r14), %eax
testl %eax, %eax
jle 0x36df
xorl %r13d, %r13d
movq 0x10(%r14), %rax
movq (%rax,%r13,8), %rsi
movq 0x18(%rbx), %rdx
movq %r15, %rdi
callq 0x344f
incq %r13
movslq 0x8(%r14), %rax
cmpq %rax, %r13
jl 0x36bf
cmpl (%r14), %eax
jge 0x3706
movslq %eax, %r13
movq 0x10(%r14), %rax
movq (%rax,%r13,8), %rdi
movq 0x18(%rbx), %rdx
movq %r12, %rsi
callq 0x344f
incq %r13
movslq (%r14), %rax
cmpq %rax, %r13
jl 0x36e7
movl $0xffffffff, %ebp       # imm = 0xFFFFFFFF
movq %r15, %rdi
movq %r12, %rsi
callq 0x3325
incl %ebp
testb %al, %al
jne 0x370b
movq %r14, %rdi
movq %r15, %rsi
movq %r12, %rdx
movq %rbx, %rcx
callq 0x35d6
movl %ebp, %eax
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/bipartiteMatching.c
// Function: bipartiteMatchingEvenMoreDirty
int bipartiteMatchingEvenMoreDirty(struct Graph* g) {
	int matchingSize = 0;
	int activity = g->activity;
	while (augment_B(g)) {
		++matchingSize;
	}
	g->activity = activity;
	return matchingSize;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rdi, %rbx
movl 0xc(%rdi), %r14d
xorl %ebp, %ebp
cmpl 0x8(%rdi), %r14d
jge 0x37b9
xorl %ebp, %ebp
movl %r14d, %eax
movslq %eax, %r15
leal 0x1(%r15), %r12d
movb $0x1, %r13b
movq 0x10(%rbx), %rax
movq (%rax,%r15,8), %rsi
cmpl $0x0, 0x28(%rsi)
jne 0x3781
movq %rbx, %rdi
callq 0x3826
testb %al, %al
jne 0x3796
incq %r15
movslq 0x8(%rbx), %rax
incl %r12d
cmpq %rax, %r15
setl %r13b
jl 0x3767
jmp 0x37b9
movl %r12d, 0xc(%rbx)
movq 0x10(%rbx), %rax
movq (%rax,%r15,8), %rax
movl $0x1, 0x28(%rax)
testb $0x1, %r13b
je 0x37b9
incl %ebp
movl 0xc(%rbx), %eax
cmpl 0x8(%rbx), %eax
jl 0x375d
movl %r14d, 0xc(%rbx)
movl %ebp, %eax
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/bipartiteMatching.c
// Function: bipartiteMatchingTerminateEarly
char bipartiteMatchingTerminateEarly(struct Graph* B) {

	for (int v=0; v<B->number; ++v) {
		if (B->vertices[v]->d == 0) {
			char found = augment_B_rec(B, B->vertices[v]);
			if (found) {
				B->vertices[v]->d = 1;
			} else {
				return 0;
			}
		}
	}
	return 1;
}

// Assembly:
pushq %rbp
pushq %r14
pushq %rbx
cmpl $0x0, 0x8(%rdi)
setle %bpl
jle 0x381b
movq %rdi, %rbx
xorl %r14d, %r14d
movq 0x10(%rbx), %rax
movq (%rax,%r14,8), %rsi
cmpl $0x0, 0x28(%rsi)
jne 0x380b
movq %rbx, %rdi
callq 0x3826
testb %al, %al
je 0x381b
movq 0x10(%rbx), %rax
movq (%rax,%r14,8), %rax
movl $0x1, 0x28(%rax)
incq %r14
movslq 0x8(%rbx), %rax
cmpq %rax, %r14
setge %bpl
jl 0x37e2
andb $0x1, %bpl
movl %ebp, %eax
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/pwelke[P]GraphMiningTools/bipartiteMatching.c
// Function: augment_B_rec
static char augment_B_rec(struct Graph* B, struct Vertex* v) {
	struct VertexList* e;

	if ((v->number >= B->number) && (v->d == 0)) {
		v->d = 1;
		return 1;
	}
	v->visited = 1;
	for (e=v->neighborhood; e!=NULL; e=e->next) {
		if ((e->flag == 0) && (e->endPoint->visited == 0)) {
			char found = augment_B_rec(B, e->endPoint);
			if (found) {
				setFlag(e, 1);
				v->visited = 0;
				return 1;
			}
		}
	}
	v->visited = 0;
	return 0;
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rsi, %rbx
movq %rdi, %r14
movl 0x18(%rsi), %eax
cmpl 0x8(%rdi), %eax
jl 0x383f
cmpl $0x0, 0x28(%rbx)
je 0x387d
movl $0x1, 0x1c(%rbx)
movq 0x8(%rbx), %r15
testq %r15, %r15
je 0x3872
cmpl $0x0, 0x24(%r15)
jne 0x386c
movq 0x18(%r15), %rsi
cmpl $0x0, 0x1c(%rsi)
jne 0x386c
movq %r14, %rdi
callq 0x3826
testb %al, %al
jne 0x3886
movq 0x8(%r15), %r15
jmp 0x384a
movl $0x0, 0x1c(%rbx)
xorl %eax, %eax
jmp 0x389b
movl $0x1, 0x28(%rbx)
jmp 0x3899
movl $0x1, 0x24(%r15)
movq (%r15), %rax
xorl %ecx, %ecx
movl %ecx, 0x24(%rax)
movl %ecx, 0x1c(%rbx)
movb $0x1, %al
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O1/pwelke[P]GraphMiningTools/bipartiteMatching.c
// Function: getMatching
struct ShallowGraph* getMatching(struct Graph* g, struct ShallowGraphPool* sgp) {
	struct ShallowGraph* matching = getShallowGraph(sgp);
	struct VertexList* e;
	int v;
	
	for (v=0; v<g->number; ++v) {
		for (e=g->vertices[v]->neighborhood; e!=NULL; e=e->next) {
			if (e->flag == 1) {
				struct VertexList* f = shallowCopyEdge(e, sgp->listPool);
				f->label = NULL;
				appendEdge(matching, f);
			}
		}
	}
	return matching;
}

// Assembly:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
movq %rsi, %rbx
movq %rdi, %r14
movq %rsi, %rdi
callq 0x14aae
movq %rax, %r15
cmpl $0x0, 0x8(%r14)
jle 0x390f
xorl %r13d, %r13d
movq 0x10(%r14), %rax
movq (%rax,%r13,8), %rax
movq 0x8(%rax), %r12
testq %r12, %r12
je 0x3903
cmpl $0x1, 0x24(%r12)
jne 0x38fc
movq 0x10(%rbx), %rsi
movq %r12, %rdi
callq 0x7bc0
movq $0x0, (%rax)
movq %r15, %rdi
movq %rax, %rsi
callq 0x88b9
movq 0x8(%r12), %r12
jmp 0x38d1
incq %r13
movslq 0x8(%r14), %rax
cmpq %rax, %r13
jl 0x38c5
movq %r15, %rax
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O1/pwelke[P]GraphMiningTools/bipartiteMatching.c
// Function: bipartiteMatching
struct ShallowGraph* bipartiteMatching(struct Graph* h, struct GraphPool* gp, struct ShallowGraphPool* sgp) {
	struct ShallowGraph* matching;
	struct Graph* g = __cloneStrangeBipartite(h, gp);

	bipartiteMatchingFastAndDirty(g, gp);
	matching = getMatching(g, sgp);
	rebaseShallowGraphs(matching, h); 

	/* garbage collection */
	dumpGraph(gp, g);

	return matching;
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rdx, %rbx
movq %rsi, %r14
movq %rdi, %r15
callq 0x3526
movq %rax, %r12
movq %rax, %rdi
movq %r14, %rsi
callq 0x367c
movq %r12, %rdi
movq %rbx, %rsi
callq 0x38a1
movq %rax, %rbx
movq %rax, %rdi
movq %r15, %rsi
callq 0x873a
movq %r14, %rdi
movq %r12, %rsi
callq 0x14832
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
nop
// File: /workspace/github_c_makefile_star2_O1/pwelke[P]GraphMiningTools/bitSet.c
// Function: copyBitset
uint8_t* copyBitset(uint8_t* bitset, size_t n) {
	uint8_t* copy = createBitset(n);
	size_t nBytes = (n % 8 == 0) ? (n / 8) : (n / 8 + 1);
	memcpy(copy, bitset, nBytes);
	return copy;
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq %rdi, %r14
movq %rsi, %rdi
callq 0x3974
movl %ebx, %ecx
andl $0x7, %ecx
shrq $0x3, %rbx
cmpq $0x1, %rcx
sbbq $-0x1, %rbx
movq %rax, %rdi
movq %r14, %rsi
movq %rbx, %rdx
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x1170
// File: /workspace/github_c_makefile_star2_O1/pwelke[P]GraphMiningTools/bitSet.c
// Function: printBitset
void printBitset(uint8_t* bitset, size_t n, FILE* out) {
	fprintf(out, "[");
	for (size_t i=0; i<n; ++i) {
		fprintf(out, "%i", getBit(bitset, i));
	}
	fprintf(out, "]\n");
}

// Assembly:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
movq %rdx, %rbx
movq %rsi, %r14
movq %rdi, %r15
movl $0x5b, %edi
movq %rdx, %rsi
callq 0x1110
testq %r14, %r14
je 0x3a7d
leaq 0x1db5f(%rip), %r12     # 0x215aa
xorl %r13d, %r13d
movq %r13, %rax
shrq $0x3, %rax
movzbl (%r15,%rax), %eax
movl %r13d, %ecx
andl $0x7, %ecx
xorl %edx, %edx
btl %ecx, %eax
setb %dl
movq %rbx, %rdi
movq %r12, %rsi
xorl %eax, %eax
callq 0x1160
incq %r13
cmpq %r13, %r14
jne 0x3a4e
leaq 0x1c5ec(%rip), %rdi     # 0x20070
movl $0x2, %esi
movl $0x1, %edx
movq %rbx, %rcx
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
jmp 0x1220
// File: /workspace/github_c_makefile_star2_O1/pwelke[P]GraphMiningTools/bloomFilter.c
// Function: initPruning
void initPruning(const int nGraphs) {
	nPruning = nGraphs;
	if ((pruning = malloc(nGraphs * sizeof(int)))) {
		int i;
		for (i=0; i<nGraphs; ++i) {
			pruning[i] = 0;
		}
	}
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movl %edi, %ebx
movl %edi, 0x2966c(%rip)     # 0x2d170
movslq %edi, %r14
leaq (,%r14,4), %rdi
callq 0x1190
movq %rax, 0x2965d(%rip)     # 0x2d178
testq %rax, %rax
sete %cl
testl %r14d, %r14d
setle %dl
orb %cl, %dl
jne 0x3b42
movl %ebx, %edx
shlq $0x2, %rdx
movq %rax, %rdi
xorl %esi, %esi
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x10d0
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O1/pwelke[P]GraphMiningTools/bloomFilter.c
// Function: initialAddToPruningSet
void initialAddToPruningSet(const int elementID, const int index) {
	if (index >= nPruning) {
		int i;
		pruning = realloc(pruning, 2 * nPruning * sizeof(int));
		for (i=nPruning; i<2*nPruning; ++i) {
			pruning[i] = 0;
		}
		nPruning *= 2;
	}
	addToPruningSet(elementID, index);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movl %esi, %ebx
movl %edi, %ebp
movslq 0x295d5(%rip), %r14     # 0x2d170
cmpl %esi, %r14d
jg 0x3be2
movq 0x295d1(%rip), %rdi     # 0x2d178
leal (%r14,%r14), %r15d
leaq (,%r14,8), %rsi
callq 0x11c0
movq %rax, 0x295b9(%rip)     # 0x2d178
cmpl %r15d, %r14d
jge 0x3bdb
leaq (%rax,%r14,4), %rdi
leal -0x1(%r14), %eax
leaq 0x4(,%rax,4), %rdx
xorl %esi, %esi
callq 0x10d0
movl %r15d, 0x2958e(%rip)    # 0x2d170
movl $0x1, %eax
movl %ebp, %ecx
shll %cl, %eax
movq 0x29586(%rip), %rcx     # 0x2d178
movslq %ebx, %rdx
orl %eax, (%rcx,%rdx,4)
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/pwelke[P]GraphMiningTools/cachedGraph.c
// Function: initCachedGraph
struct CachedGraph* initCachedGraph(struct GraphPool* gp, int size) {
	struct CachedGraph* cache;
	if ((cache = malloc(sizeof(struct CachedGraph)))) {
		cache->gp = gp;
		cache->inUse = 0;
		cache->g = createGraph(size, gp);
		// __setVertexNumber(cache->g, size, gp);
		cache->maxCap = size;
		cache->next = NULL;
	}
	return cache;
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movl %esi, %ebx
movq %rdi, %r15
movl $0x28, %edi
callq 0x1190
movq %rax, %r14
testq %rax, %rax
je 0x3c7e
movq %r15, 0x20(%r14)
movb $0x0, (%r14)
movl %ebx, %edi
movq %r15, %rsi
callq 0x8565
movq %rax, 0x8(%r14)
movl %ebx, 0x10(%r14)
movq $0x0, 0x18(%r14)
movq %r14, %rax
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O1/pwelke[P]GraphMiningTools/cachedGraph.c
// Function: getCachedGraph
struct Graph* getCachedGraph(int size, struct CachedGraph* cache) {
	 if (!cache->inUse) {
	 	cache->inUse = 1;
		if (cache->maxCap < size) {
			// do the 'increase size by factor of two' thing to avoid many reallocs
			int newCap = max(size, 2 * cache->maxCap);
			
			// dump old graph
			cache->g->n = cache->maxCap;
			dumpGraph(cache->gp, cache->g);
			
			// create larger new graph
			cache->g = createGraph(newCap, cache->gp);
			cache->maxCap = newCap;
		} 
		cache->g->n = size;	
		return cache->g;
	} else {
		fprintf(stderr, "Graph is in use\n");
		return NULL;
	}
}

// Assembly:
pushq %rbp
pushq %r14
pushq %rbx
cmpb $0x0, (%rsi)
jne 0x3cdb
movq %rsi, %r14
movl %edi, %ebx
movb $0x1, (%rsi)
movl 0x10(%rsi), %esi
cmpl %edi, %esi
jge 0x3cd0
addl %esi, %esi
movl %ebx, %edi
callq 0x98ec
movl %eax, %ebp
movl 0x10(%r14), %eax
movq 0x8(%r14), %rsi
movl %eax, (%rsi)
movq 0x20(%r14), %rdi
callq 0x14832
movq 0x20(%r14), %rsi
movl %ebp, %edi
callq 0x8565
movq %rax, 0x8(%r14)
movl %ebp, 0x10(%r14)
movq 0x8(%r14), %rax
movl %ebx, (%rax)
popq %rbx
popq %r14
popq %rbp
retq
callq 0x1280
xorl %eax, %eax
jmp 0x3cd6
// File: /workspace/github_c_makefile_star2_O1/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
movslq (%rax), %r12
testq %r12, %r12
jle 0x3d2d
movq 0x20(%rbx), %rcx
movq 0x10(%rax), %r13
movq 0x18(%rcx), %r14
xorl %ebp, %ebp
movq (%r13,%rbp,8), %r15
movq 0x8(%r15), %rsi
movq %r14, %rdi
callq 0x143b8
movq %r15, %rdi
callq 0x14615
incq %rbp
cmpq %rbp, %r12
jne 0x3d0c
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_O1/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 0x8565
movq %rax, %r13
testq %r12, %r12
je 0x3fff
movq (%r12), %rax
movq 0x10(%rax), %rax
movslq 0x28(%rax), %rbp
cmpl $0x0, 0x1c(%rax)
je 0x3fab
movq 0x18(%r12), %rax
movq (%r14,%rbp,8), %rcx
movl 0x28(%rcx), %edx
incl %edx
movl %edx, 0x28(%r12)
movq %rcx, 0x18(%r12)
movq %r12, (%r14,%rbp,8)
jmp 0x3ff7
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 0x3fdc
movl 0x28(%rax), %esi
movl %ebp, %edi
xorl %edx, %edx
movq %r13, %rcx
movq %rbx, %r8
callq 0x8425
movl $0x1, 0x28(%r12)
movq %r12, (%r14,%rbp,8)
movq 0x18(%r12), %rax
movq $0x0, 0x18(%r12)
movq %rax, %r12
jmp 0x3f72
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_O1/pwelke[P]GraphMiningTools/cactustree.c
// Function: hasSolution
char hasSolution(struct Characteristics *characteristic){
    struct Characteristics *chlp=characteristic;
    int i;
    for(;chlp;chlp=chlp->next){
        for(i=0;i<chlp->size;++i){
            if(chlp->treeIDs[i][i]){
 //               printf("\n\nFOUND SOMETHING\n\n)");
                return 1;
            }
        }
    }
    return 0;
}

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

// Assembly:
testq %rdi, %rdi
je 0x426b
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rdi, %rbx
cmpl $0x0, 0x4(%rbx)
jle 0x4243
xorl %r14d, %r14d
cmpl $0x0, 0x4(%rbx)
jle 0x422a
xorl %r15d, %r15d
movq 0x8(%rbx), %rax
movq (%rax,%r14,8), %rax
movq (%rax,%r15,8), %rdi
testq %rdi, %rdi
je 0x421e
movq 0x8(%rdi), %r12
callq 0x1030
movq %r12, %rdi
testq %r12, %r12
jne 0x420d
incq %r15
movslq 0x4(%rbx), %rax
cmpq %rax, %r15
jl 0x41fc
movq 0x8(%rbx), %rax
movq (%rax,%r14,8), %rdi
callq 0x1030
incq %r14
movslq 0x4(%rbx), %rax
cmpq %rax, %r14
jl 0x41f3
movq 0x8(%rbx), %rdi
callq 0x1030
movq 0x10(%rbx), %r14
movq %rbx, %rdi
callq 0x1030
movq %r14, %rbx
testq %r14, %r14
jne 0x41ea
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq