LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O2/theovosse[P]llgen/llgen.c
// Function: HasProperty
static Boolean HasProperty(char *property) {
	if (*property == '!') {
		return (FindNode(properties, property + 1, (TreeCmp) strcmp) == NULL);
	} else {
		return (FindNode(properties, property, (TreeCmp) strcmp) != NULL);
	}
}

// Assembly:
pushq %rax
movq %rdi, %rsi
cmpb $0x21, (%rdi)
movq 0x129c4(%rip), %rdi     # 0x18af8
jne 0x614d
incq %rsi
movq 0x11e88(%rip), %rdx     # 0x17fc8
callq 0xb305
testq %rax, %rax
sete %al
jmp 0x615f
movq 0x11e74(%rip), %rdx     # 0x17fc8
callq 0xb305
testq %rax, %rax
setne %al
movzbl %al, %eax
popq %rcx
retq
// File: /workspace/github_c_makefile_star2_O2/theovosse[P]llgen/llgen.c
// Function: InsertElement
static Boolean InsertElement(TREE *first, Name name) {
	Name sym = GetInfo(FindNode(*first, name, (TreeCmp) NameCmp));

	if (sym == NULL) {
		InsertNodeSingle(first, name, name, (TreeCmp) NameCmp);
		return (true);
	} else {
		return (false);
	}
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq %rdi, %r14
movq (%rdi), %rdi
leaq -0x2c12(%rip), %rdx     # 0x356a
callq 0xb305
movq %rax, %rdi
callq 0xb265
testq %rax, %rax
je 0x6192
xorl %eax, %eax
jmp 0x61ab
leaq -0x2c2f(%rip), %rcx     # 0x356a
movq %r14, %rdi
movq %rbx, %rsi
movq %rbx, %rdx
callq 0xaecc
movw $0xffff, %ax            # imm = 0xFFFF
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O2/theovosse[P]llgen/llgen.c
// Function: Unite
static Boolean Unite(TREE *set, TREE addition) {
	TREE t = GetFirstNode(addition);
	Boolean change = false;

	while (t != NULL) {
		if (InsertElement(set, GetKey(t))) {
			change = true;
		}
		t = GetNextNode(t);
	}
	return (change);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
movq %rsi, %rdi
callq 0xb236
movq %rax, %r14
xorl %ebp, %ebp
testq %r14, %r14
je 0x656b
movq %r14, %rdi
callq 0xb272
movq %rbx, %rdi
movq %rax, %rsi
callq 0x6168
negw %ax
movl $0x0, %r15d
sbbl %r15d, %r15d
orl %ebp, %r15d
movq %r14, %rdi
callq 0xb27e
movq %rax, %r14
movl %r15d, %ebp
jmp 0x6534
movl %ebp, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/theovosse[P]llgen/llgen.c
// Function: openFunctionDeclaration
static void openFunctionDeclaration(FILE *f, const char* functionName, Node argList, Name returnType) {
	int level = 0;
    Boolean firstStringOfParameter = true;

    targetLanguage->startFunctionDeclaration(f, functionName, returnType == NULL? "void": returnType->name);
	for (Node nPtr = argList; nPtr != NULL; nPtr = nPtr->next) {
        int nrSpaces = nPtr->lineNr;
        const char *str = (const char *) nPtr->element.name;
        if (strcmp(str, ",") == 0 && level == 0) {
            firstStringOfParameter = true;
        } else {
            if (firstStringOfParameter) {
                targetLanguage->parameterDeclarationName(f, str, nrSpaces);
                firstStringOfParameter = false;
            } else {
                targetLanguage->nextDeclarationParameterSymbol(f, str, nrSpaces);
            }
            if (strcmp(str, "{") == 0 || strcmp(str, "(") == 0 || strcmp(str, "[") == 0) {
                level++;
            } else if (strcmp(str, "}") == 0 || strcmp(str, ")") == 0 || strcmp(str, "]") == 0) {
                level--;
            }
        }
	}
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rdx, %rbx
movq %rdi, %r14
movq 0x11332(%rip), %rax     # 0x18180
movq 0x110(%rax), %rax
testq %rcx, %rcx
je 0x6e5f
movq (%rcx), %rdx
jmp 0x6e66
leaq 0x96af(%rip), %rdx      # 0x10515
movq %r14, %rdi
callq *%rax
xorl %ebp, %ebp
movw $0xffff, %ax            # imm = 0xFFFF
testq %rbx, %rbx
je 0x6eff
movswl (%rbx), %edx
movq 0x18(%rbx), %r15
cmpb $0x2c, (%r15)
jne 0x6ea2
cmpb $0x0, 0x1(%r15)
sete %cl
testl %ebp, %ebp
sete %sil
testb %sil, %cl
je 0x6ea2
xorl %ebp, %ebp
movw $0xffff, %ax            # imm = 0xFFFF
jmp 0x6ef6
xorl %ecx, %ecx
testw %ax, %ax
sete %cl
movq 0x112cf(%rip), %rax     # 0x18180
movq %r14, %rdi
movq %r15, %rsi
callq *0x118(%rax,%rcx,8)
movzbl (%r15), %eax
cmpl $0x28, %eax
je 0x6ee0
cmpl $0x29, %eax
je 0x6eeb
cmpl $0x5b, %eax
je 0x6ee0
cmpl $0x5d, %eax
je 0x6eeb
cmpl $0x7d, %eax
je 0x6eeb
cmpl $0x7b, %eax
jne 0x6ef4
cmpb $0x0, 0x1(%r15)
jne 0x6ef4
incl %ebp
jmp 0x6ef4
cmpb $0x0, 0x1(%r15)
jne 0x6ef4
decl %ebp
xorl %eax, %eax
movq 0x28(%rbx), %rbx
jmp 0x6e71
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/theovosse[P]llgen/llgen.c
// Function: TokenSetName
static char *TokenSetName(RegExp state) {
	static char tokenSetName[16];
	TREE node;

	if (state == NULL || state->info == NULL || (node = FindNode(tokenSets, state->info, TokenSetCmp)) == NULL) {
		strcpy(tokenSetName, targetLanguage->nullValue);
	} else {
		sprintf(tokenSetName, "llTokenSet%d", (int) GetInfo(node));
	}
	return (tokenSetName);
}

// Assembly:
pushq %rax
testq %rdi, %rdi
je 0x6f5a
movq 0x10(%rdi), %rsi
testq %rsi, %rsi
je 0x6f5a
movq 0x11c27(%rip), %rdi     # 0x18b50
leaq 0x42(%rip), %rdx        # 0x6f72
callq 0xb305
testq %rax, %rax
je 0x6f5a
movq %rax, %rdi
callq 0xb265
leaq 0x11bf7(%rip), %rdi     # 0x18b40
leaq 0x9754(%rip), %rsi      # 0x106a4
movl %eax, %edx
xorl %eax, %eax
popq %rcx
jmp 0x31f0
movq 0x1121f(%rip), %rax     # 0x18180
movq 0x40(%rax), %rsi
leaq 0x11bd4(%rip), %rdi     # 0x18b40
popq %rax
jmp 0x3080
// File: /workspace/github_c_makefile_star2_O2/theovosse[P]llgen/llgen.c
// Function: TokenSetCmp
static int TokenSetCmp(void *tSet1, void *tSet2) {
	ESet tokenSet1 = tSet1;
	ESet tokenSet2 = tSet2;

	while (tokenSet1 != NULL && tokenSet2 != NULL) {
		Answer answer1 = (Answer) tokenSet1->element;
		Answer answer2 = (Answer) tokenSet2->element;
		if (answer1->info > answer2->info) {
			return (1);
		} else if (answer1->info < answer2->info) {
			return (-1);
		}
		tokenSet1 = tokenSet1->next;
		tokenSet2 = tokenSet2->next;
	}
	return (tokenSet1 != NULL? 1: tokenSet2 != NULL? -1: 0);
}

// Assembly:
pushq $0x1
popq %rax
pushq $-0x1
popq %rcx
testq %rdi, %rdi
je 0x6f9e
testq %rsi, %rsi
je 0x6f9e
movq (%rdi), %rdx
movq (%rsi), %r8
movq 0x8(%r8), %r8
cmpq %r8, 0x8(%rdx)
ja 0x6fae
jb 0x6faf
movq 0x8(%rdi), %rdi
movq 0x8(%rsi), %rsi
jmp 0x6f78
xorl %ecx, %ecx
negq %rsi
sbbl %ecx, %ecx
testq %rdi, %rdi
pushq $0x1
popq %rax
cmovel %ecx, %eax
retq
movl %ecx, %eax
retq
// File: /workspace/github_c_makefile_star2_O2/theovosse[P]llgen/llgen.c
// Function: TokenIndexName
static Name TokenIndexName(int i, Boolean strings) {
	TREE sym;
	Name name;

	for (sym = GetFirstNode(idTree); sym != NULL; sym = GetNextNode(sym)) {
		name = GetKey(sym);
		if (name->nameType == token && name->index == i) {
			return name;
		}
	}
    if (strings) {
        for (sym = GetFirstNode(idTree); sym != NULL; sym = GetNextNode(sym)) {
            name = GetKey(sym);
            if (name->nameType == string && name->index == i) {
                return name;
            }
        }
    }
	return NULL;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movl %esi, %ebx
movl %edi, %ebp
movq 0x11b3c(%rip), %rdi     # 0x18b00
callq 0xb236
movq %rax, %r14
movslq %ebp, %r15
testq %r14, %r14
je 0x6ff5
movq %r14, %rdi
callq 0xb272
cmpl $0x4, 0x38(%rax)
jne 0x6fe8
cmpq %r15, 0x28(%rax)
je 0x702e
movq %r14, %rdi
callq 0xb27e
movq %rax, %r14
jmp 0x6fcf
testw %bx, %bx
je 0x702c
movq 0x11aff(%rip), %rdi     # 0x18b00
callq 0xb236
movq %rax, %rbx
testq %rax, %rax
je 0x702c
movq %rbx, %rdi
callq 0xb272
cmpl $0x1, 0x38(%rax)
jne 0x7022
cmpq %r15, 0x28(%rax)
je 0x702e
movq %rbx, %rdi
callq 0xb27e
jmp 0x7006
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/theovosse[P]llgen/llgen.c
// Function: VerifyTokenOverlap
static void VerifyTokenOverlap(ESet oTokenSet) {
	int nrTokens = 0;
	ESet tokenSet = oTokenSet;
	ESet token;

	while (tokenSet != NULL) {
        int tokenIndex = (int) ((Answer) tokenSet->element)->info;
        if (tokenIndex != -1) {
            /* Ignore overlap with endOfInput/IGNORE, since endOfInput can't
               happen, and IGNORE is skipped during parsing when the overlapping
               token is not in the expected set. */
            nrTokens++;
        }
		tokenSet = tokenSet->next;
	}
	if (nrTokens > 1) {
		fprintf(stderr, "Overlap between tokens:\n");
		for (tokenSet = oTokenSet; tokenSet != NULL; tokenSet = tokenSet->next) {
			int tokenIndex = (int) ((Answer) tokenSet->element)->info;
			Name name = TokenIndexName(tokenIndex, true);
			TREE node = InsertNodeSingle(&overlap, name, NULL, (TreeCmp) NameCmp);
			TREE nOverlap = GetInfo(node);
			fprintf(stderr, "%s:%d: token %d: %s\n", inputFileName, name->lineNr, tokenIndex, name->name);
			for (token = oTokenSet; token != NULL; token = token->next) {
				InsertNodeSingle(&nOverlap, TokenIndexName((int) ((Answer) token->element)->info, true), NULL, (TreeCmp) NameCmp);
			}
			SetInfo(node, nOverlap);
		}
	}
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %rdi, %rbx
xorl %eax, %eax
movq %rdi, %rcx
testq %rcx, %rcx
je 0x7069
movq (%rcx), %rdx
movq 0x8(%rcx), %rcx
xorl %esi, %esi
cmpl $-0x1, 0x8(%rdx)
setne %sil
addl %esi, %eax
jmp 0x704f
cmpl $0x2, %eax
jae 0x707d
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq 0x10f74(%rip), %rax     # 0x17ff8
movq (%rax), %rcx
leaq 0x9751(%rip), %rdi      # 0x107df
pushq $0x18
popq %rsi
pushq $0x1
popq %rdx
callq 0x3210
pushq $-0x1
popq %rbp
leaq -0x3b39(%rip), %r15     # 0x356a
movq %rsp, %r13
movq %rbx, %rax
testq %rax, %rax
je 0x706e
movq %rax, 0x10(%rsp)
movq (%rax), %rax
movl 0x8(%rax), %r12d
movl %r12d, %edi
movl %ebp, %esi
callq 0x6fb2
movq %rax, %r14
leaq 0x11a92(%rip), %rdi     # 0x18b60
movq %rax, %rsi
xorl %edx, %edx
movq %r15, %rcx
callq 0xaecc
movq %rax, 0x8(%rsp)
movq %rax, %rdi
callq 0xb265
movq %rax, (%rsp)
movq 0x10f05(%rip), %rax     # 0x17ff8
movq (%rax), %rdi
movq 0x1108b(%rip), %rdx     # 0x18188
movl 0x20(%r14), %ecx
movq (%r14), %r9
leaq 0x96ed(%rip), %rsi      # 0x107f8
movl %r12d, %r8d
xorl %eax, %eax
callq 0x3150
movq %rbx, %r14
testq %r14, %r14
je 0x7140
movq (%r14), %rax
movl 0x8(%rax), %edi
movl %ebp, %esi
callq 0x6fb2
movq %r13, %rdi
movq %rax, %rsi
xorl %edx, %edx
movq %r15, %rcx
callq 0xaecc
movq 0x8(%r14), %r14
jmp 0x7118
movq (%rsp), %rsi
movq 0x8(%rsp), %rdi
callq 0xb260
movq 0x10(%rsp), %rax
movq 0x8(%rax), %rax
jmp 0x70a9
// File: /workspace/github_c_makefile_star2_O2/theovosse[P]llgen/llgen.c
// Function: elseIfCondition
static void elseIfCondition(Boolean open, int indent) {
    if (open) {
        fputs(targetLanguage->elseStr, outputFile);
        fputc(' ', outputFile);
        fputs(targetLanguage->openIf, outputFile);
    } else {
        fputs(targetLanguage->closeIf, outputFile);
    }
}

// Assembly:
movq 0xf505(%rip), %rax      # 0x18180
movq 0xfe66(%rip), %rsi      # 0x18ae8
testw %di, %di
je 0x8cbe
pushq %rax
movq 0x98(%rax), %rdi
callq 0x3110
movq 0xfe4d(%rip), %rsi      # 0x18ae8
pushq $0x20
popq %rdi
callq 0x3120
movq 0xf4d6(%rip), %rax      # 0x18180
movq 0x88(%rax), %rdi
movq 0xfe30(%rip), %rsi      # 0x18ae8
popq %rax
jmp 0x3110
movq 0x90(%rax), %rdi
jmp 0x3110
// File: /workspace/github_c_makefile_star2_O2/theovosse[P]llgen/llgen.c
// Function: PrintTree
static void PrintTree(FILE *f, TREE set) {
	set = GetFirstNode(set);
	while (set != NULL) {
		fprintf(f, "%s", ((Name) GetKey(set))->name);
		set = GetNextNode(set);
		if (set != NULL) {
			fputs(", ", f);
		}
	}
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rdi, %rbx
movq %rsi, %rdi
callq 0xb236
movq %rax, %r15
leaq 0x77e3(%rip), %r14      # 0x104c7
testq %r15, %r15
je 0x8d19
movq %r15, %rdi
callq 0xb272
movq (%rax), %rdi
movq %rbx, %rsi
callq 0x3110
movq %r15, %rdi
callq 0xb27e
movq %rax, %r15
testq %rax, %rax
je 0x8ce4
movq %r14, %rdi
movq %rbx, %rsi
callq 0x3110
jmp 0x8ce4
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O2/theovosse[P]llgen/llgen.c
// Function: TokenSetName2
static void TokenSetName2(TREE tokenSet) {
	TREE node = FindNode(tokenSets2, tokenSet, TokenSetCmp2);

	if (node == NULL) {
		fputs("cannot find token set: ", stderr);
		PrintTree(stderr, tokenSet);
		fputc('\n', stderr);
	}
    targetLanguage->pointerToArray(outputFile, "llTokenSet", (long int) GetInfo(node));
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rdi, %r14
movq 0xfe3a(%rip), %rdi      # 0x18b68
leaq 0x3ec(%rip), %rdx       # 0x9121
movq %r14, %rsi
callq 0xb305
movq %rax, %rbx
testq %rax, %rax
je 0x8d79
movq 0xf434(%rip), %rax      # 0x18180
movq 0x100(%rax), %r15
movq 0xfd8e(%rip), %r14      # 0x18ae8
movq %rbx, %rdi
callq 0xb265
leaq 0x7a30(%rip), %rsi      # 0x10799
movq %r14, %rdi
movq %rax, %rdx
movq %r15, %rax
popq %rbx
popq %r14
popq %r15
jmpq *%rax
movq 0xf278(%rip), %r15      # 0x17ff8
movq (%r15), %rsi
leaq 0x7e16(%rip), %rdi      # 0x10ba0
callq 0x3110
movq (%r15), %rdi
movq %r14, %rsi
callq 0x8cca
movq (%r15), %rsi
pushq $0xa
popq %rdi
callq 0x3120
jmp 0x8d45
// File: /workspace/github_c_makefile_star2_O2/theovosse[P]llgen/llgen.c
// Function: CreateTokenSet2
static void CreateTokenSet2(FILE *f, TREE tokenSet) {
	TREE node = FindNode(tokenSets2, tokenSet, TokenSetCmp2);

	if (node == NULL) {
		tokenSetNr++;
		InsertNodeSingle(&tokenSets2, CopyTree(tokenSet, NULL, NULL), (void *) tokenSetNr, TokenSetCmp2);
        targetLanguage->arrayDeclaration(f, "static", targetLanguage->tokenSetType,
                                         "llTokenSet", tokenSetNr, (nodeNumber + 1) / nrBitsInElement + 1, true);
		printTokenSet(f, tokenSet);
	}
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq %rdi, %r14
movq 0xfdb0(%rip), %rdi      # 0x18b68
leaq 0x362(%rip), %rdx       # 0x9121
callq 0xb305
testq %rax, %rax
je 0x8dd1
addq $0x8, %rsp
popq %rbx
popq %r14
retq
incq 0xfd80(%rip)            # 0x18b58
movq %rbx, %rdi
xorl %esi, %esi
xorl %edx, %edx
callq 0xb5c5
movq 0xfd6d(%rip), %rdx      # 0x18b58
leaq 0xfd76(%rip), %rdi      # 0x18b68
leaq 0x328(%rip), %rcx       # 0x9121
movq %rax, %rsi
callq 0xaecc
movq 0xf378(%rip), %r11      # 0x18180
movq 0x50(%r11), %r10
movq 0xfd45(%rip), %r8       # 0x18b58
movl 0xfcef(%rip), %eax      # 0x18b08
incl %eax
cltd
idivl 0xf34e(%rip)            # 0x18170
leal 0x1(%rax), %r9d
orl $-0x1, (%rsp)
leaq 0x77b9(%rip), %rsi      # 0x105ea
leaq 0x7961(%rip), %rcx      # 0x10799
movq %r14, %rdi
movq %r10, %rdx
callq *0xc0(%r11)
movq %r14, %rdi
movq %rbx, %rsi
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x6c34
// File: /workspace/github_c_makefile_star2_O2/theovosse[P]llgen/llgen.c
// Function: Intersection2
static TREE Intersection2(TREE t1, TREE t2) {
	TREE ta1 = ExpandOverlap(t1);
	TREE ta2 = ExpandOverlap(t2);
	TREE result = Intersection(ta1, ta2);

	KillTree(ta1, NULL);
	KillTree(ta2, NULL);
	return (result);
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rsi, %rbx
callq 0x9193
movq %rax, %r14
movq %rbx, %rdi
callq 0x9193
movq %rax, %rbx
movq %r14, %rdi
movq %rax, %rsi
callq 0x9222
movq %rax, %r15
movq %r14, %rdi
xorl %esi, %esi
callq 0xb397
movq %rbx, %rdi
xorl %esi, %esi
callq 0xb397
movq %r15, %rax
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O2/theovosse[P]llgen/llgen.c
// Function: collectFirstOn
static void collectFirstOn(TREE *firsts, Node rule) {
	Name name;

	switch (rule->nodeType) {
		case breakToken:
			name = rule->element.name;
			break;
		case errorMessage:
			name = rule->element.sub->element.name;
			break;
		default:
			fprintf(stderr, "collectFirstOn: unknown nodetype %d\n", rule->nodeType);
			return;
	}
	if (name->nameType == identifier) {
		fprintf(stderr, "%d: on non-terminal\n", rule->lineNr);
	} else if (name->nameType == token || name->nameType == string) {
		(void) InsertElement(firsts, name);
	}
}

// Assembly:
movl 0x4(%rsi), %edx
movq %rsi, %rax
cmpl $0x5, %edx
je 0x90d5
cmpl $0x6, %edx
jne 0x90f3
movq 0x18(%rsi), %rax
movq 0x18(%rax), %rax
movl 0x38(%rax), %ecx
cmpl $0x1, %ecx
je 0x90eb
cmpl $0x4, %ecx
je 0x90eb
testl %ecx, %ecx
je 0x9106
retq
movq %rax, %rsi
jmp 0x6168
movq 0xeefe(%rip), %rax      # 0x17ff8
movq (%rax), %rdi
leaq 0x7b08(%rip), %rsi      # 0x10c0c
jmp 0x911a
movq 0xeeeb(%rip), %rax      # 0x17ff8
movq (%rax), %rdi
movswl (%rsi), %edx
leaq 0x7b17(%rip), %rsi      # 0x10c31
xorl %eax, %eax
jmp 0x3150
// File: /workspace/github_c_makefile_star2_O2/theovosse[P]llgen/llgen.c
// Function: TokenSetCmp2
static int TokenSetCmp2(void *tSet1, void *tSet2) {
	TREE t1 = GetFirstNode(tSet1);
	TREE t2 = GetFirstNode(tSet2);

	while (t1 != NULL && t2 != NULL) {
		Name token1 = (Name) GetKey(t1);
		Name token2 = (Name) GetKey(t2);
		int res = strcmp(token1->name, token2->name);
		if (res != 0) {
			return (res);
		}
		t1 = GetNextNode(t1);
		t2 = GetNextNode(t2);
	}
	return (t1 != NULL? 1: t2 != NULL? -1: 0);
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rsi, %r14
callq 0xb236
movq %rax, %rbx
movq %r14, %rdi
callq 0xb236
movq %rax, %r14
testq %rbx, %rbx
je 0x917d
testq %r14, %r14
je 0x917d
movq %rbx, %rdi
callq 0xb272
movq %rax, %r15
movq %r14, %rdi
callq 0xb272
movq (%r15), %rdi
movq (%rax), %rsi
callq 0x3240
testl %eax, %eax
jne 0x918d
movq %rbx, %rdi
callq 0xb27e
movq %rax, %rbx
movq %r14, %rdi
callq 0xb27e
jmp 0x9139
xorl %ecx, %ecx
negq %r14
sbbl %ecx, %ecx
testq %rbx, %rbx
pushq $0x1
popq %rax
cmovel %ecx, %eax
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O2/theovosse[P]llgen/llgen.c
// Function: ExpandOverlap
static TREE ExpandOverlap(TREE tr) {
	TREE ta = NULL;
	TREE t = GetFirstNode(tr);
	TREE node;

	while (t != NULL) {
		if ((node = FindNode(overlap, GetKey(t), (TreeCmp) NameCmp)) == NULL) {
			InsertNodeSingle(&ta, GetKey(t), NULL, (TreeCmp) NameCmp);
		} else {
			Unite(&ta, GetInfo(node));
		}
		t = GetNextNode(t);
	}
	return (ta);
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rsp, %rbx
andq $0x0, (%rbx)
callq 0xb236
movq %rax, %r15
leaq -0x5c47(%rip), %r14     # 0x356a
testq %r15, %r15
je 0x9212
movq 0xf9a3(%rip), %r12      # 0x18b60
movq %r15, %rdi
callq 0xb272
movq %r12, %rdi
movq %rax, %rsi
movq %r14, %rdx
callq 0xb305
testq %rax, %rax
je 0x91ed
movq %rax, %rdi
callq 0xb265
movq %rbx, %rdi
movq %rax, %rsi
callq 0x651d
jmp 0x9205
movq %r15, %rdi
callq 0xb272
movq %rbx, %rdi
movq %rax, %rsi
xorl %edx, %edx
movq %r14, %rcx
callq 0xaecc
movq %r15, %rdi
callq 0xb27e
movq %rax, %r15
jmp 0x91b1
movq (%rsp), %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O2/theovosse[P]llgen/llgen.c
// Function: Intersection
static TREE Intersection(TREE t1, TREE t2) {
	TREE result = NULL;
	TREE t = GetFirstNode(t1);

	while (t != NULL) {
		if (FindNode(t2, GetKey(t), (TreeCmp) NameCmp) != NULL) {
			InsertNodeSingle(&result, GetKey(t), GetKey(t), (TreeCmp) NameCmp);
		}
		t = GetNextNode(t);
	}
	return (result);
}

// Assembly:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x10, %rsp
movq %rsi, %rbx
leaq 0x8(%rsp), %r14
andq $0x0, (%r14)
callq 0xb236
movq %rax, %r12
leaq -0x5ce0(%rip), %r15     # 0x356a
testq %r12, %r12
je 0x929b
movq %r12, %rdi
callq 0xb272
movq %rbx, %rdi
movq %rax, %rsi
movq %r15, %rdx
callq 0xb305
testq %rax, %rax
je 0x928e
movq %r12, %rdi
callq 0xb272
movq %rax, %r13
movq %r12, %rdi
callq 0xb272
movq %r14, %rdi
movq %r13, %rsi
movq %rax, %rdx
movq %r15, %rcx
callq 0xaecc
movq %r12, %rdi
callq 0xb27e
movq %rax, %r12
jmp 0x924a
movq 0x8(%rsp), %rax
addq $0x10, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
nop
// File: /workspace/github_c_makefile_star2_O2/theovosse[P]llgen/avl3.c
// Function: TraverseTreeInOrder
void TraverseTreeInOrder(tree, proc)
TREE tree;
void (*proc)(void *, void *);
{
	if (tree != NULL)
	{
		TraverseTreeInOrder(tree->left, proc);
		(*proc)(tree->key, tree->info);
		TraverseTreeInOrder(tree->right, proc);
	}
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq %rdi, %r14
testq %r14, %r14
je 0xb2c2
movq 0x10(%r14), %rdi
movq %rbx, %rsi
callq 0xb298
movq (%r14), %rdi
movq 0x8(%r14), %rsi
callq *%rbx
movq 0x18(%r14), %r14
jmp 0xb2a2
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O2/theovosse[P]llgen/avl3.c
// Function: TraverseTreeInOrder2
void TraverseTreeInOrder2(tree, proc, info)
TREE tree;
void (*proc)(void *, void *, void *);
void *info;
{
	if (tree != NULL)
	{
		TraverseTreeInOrder2(tree->left, proc, info);
		(*proc)(tree->key, tree->info, info);
		TraverseTreeInOrder2(tree->right, proc, info);
	}
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rdx, %rbx
movq %rsi, %r14
movq %rdi, %r15
testq %r15, %r15
je 0xb2ff
movq 0x10(%r15), %rdi
movq %r14, %rsi
movq %rbx, %rdx
callq 0xb2ca
movq (%r15), %rdi
movq 0x8(%r15), %rsi
movq %rbx, %rdx
callq *%r14
movq 0x18(%r15), %r15
jmp 0xb2d8
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O2/theovosse[P]llgen/avl3.c
// Function: FindNode
TREE FindNode(TREE tree, void *key, TreeCmp keyCmp)
{
	TREE n = tree;
	Boolean gevonden = false;
	int res;
	
	while (n != NULL && !gevonden)
	{
		if ((res = (*keyCmp)(n->key, key)) == 0)
		{
			gevonden = true;
		}
		else if (res < 0)
		{
			n = n->right;
		}
		else
		{
			n = n->left;
		}
	}
	return (n);
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rdx, %rbx
movq %rsi, %r15
movq %rdi, %r14
movb $0x1, %cl
testb $0x1, %cl
je 0xb337
testq %r14, %r14
je 0xb337
movq (%r14), %rdi
movq %r15, %rsi
callq *%rbx
xorl %ecx, %ecx
testl %eax, %eax
je 0xb315
shrl $0x1f, %eax
movq 0x10(%r14,%rax,8), %r14
jmp 0xb313
movq %r14, %rax
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O2/theovosse[P]llgen/avl3.c
// Function: FindApprox
TREE FindApprox(TREE tree, void *key, TreeCmp keyCmp)
{
	TREE laatste = NULL;
	TREE n = tree;
	Boolean gevonden = false;
	int res;
	
	while (n != NULL && !gevonden)
	{
		if ((res = (*keyCmp)(n->key, key)) == 0)
		{
			gevonden = true;
		}
		else if (res < 0)
		{
			n = n->right;
		}
		else
		{
			laatste = n;
			n = n->left;
		}
	}
	return (gevonden? n: laatste);
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rdx, %r14
movq %rsi, %r15
movq %rdi, %rbx
xorl %r12d, %r12d
movb $0x1, %cl
testq %rbx, %rbx
je 0xb381
testb $0x1, %cl
je 0xb381
movq (%rbx), %rdi
movq %r15, %rsi
callq *%r14
xorl %ecx, %ecx
testl %eax, %eax
je 0xb356
movl %eax, %ecx
shrl $0x1f, %ecx
testl %eax, %eax
cmovnsq %rbx, %r12
movq 0x10(%rbx,%rcx,8), %rbx
jmp 0xb354
testb $0x1, %cl
cmovneq %r12, %rbx
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O2/theovosse[P]llgen/avl3.c
// Function: KillTree
void KillTree(TREE tree, void (*proc)(void *, void *))
{
	if (tree != NULL)
	{
		KillTree(tree->left, proc);
		if (proc != NULL)
		{
			(*proc)(tree->key, tree->info);
		}
		KillTree(tree->right, proc);
		tree->left = oldNodes;
		oldNodes = tree;
	}
}

// Assembly:
testq %rdi, %rdi
je 0xb3e3
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %r14
movq %rdi, %rbx
movq 0x10(%rdi), %rdi
callq 0xb397
testq %r14, %r14
je 0xb3be
movq (%rbx), %rdi
movq 0x8(%rbx), %rsi
callq *%r14
movq 0x18(%rbx), %rdi
movq %r14, %rsi
callq 0xb397
movq 0xf85f(%rip), %rax      # 0x1ac30
movq %rax, 0x10(%rbx)
movq %rbx, 0xf854(%rip)      # 0x1ac30
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O2/theovosse[P]llgen/avl3.c
// Function: CountTree
long int CountTree(TREE tree, long int (*NodeCount)(void *, void *))
{
	if (tree == NULL) return (0);
	return (CountTree(tree->left, NodeCount) +
			CountTree(tree->right, NodeCount) +
			(NodeCount == NULL? 1: (*NodeCount)(tree->key, tree->info)));
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
testq %rdi, %rdi
je 0xb451
movq %rsi, %r14
movq %rdi, %r15
movq 0x10(%rdi), %rdi
callq 0xb40f
movq %rax, %r12
movq 0x18(%r15), %rdi
movq %r14, %rsi
callq 0xb40f
movq %rax, %rbx
addq %r12, %rbx
testq %r14, %r14
je 0xb455
movq (%r15), %rdi
movq 0x8(%r15), %rsi
callq *%r14
jmp 0xb458
xorl %ebx, %ebx
jmp 0xb45b
pushq $0x1
popq %rax
addq %rax, %rbx
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O2/theovosse[P]llgen/avl3.c
// Function: RemoveNode
static TREE RemoveNode(TREE node, void *key, int (*keyCmp)(void *, void *), void (*freeProc)(void *, void *))
{
	short int lDepth;
	short int rDepth;
	int rescmp;

	if (node == NULL)
	{
		return (NULL);
	}
	if ((rescmp = (*keyCmp)(node->key, key)) == 0)
	{
		TREE sNode = NULL;

		if (node->previous != NULL)
		{
			node->previous->next = node->next;
		}
		if (node->next != NULL)
		{
			node->next->previous = node->previous;
		}
		if (node->left == NULL && node->right == NULL)
		{
			if (freeProc != NULL) (*freeProc)(node->key, node->info);
			node->left = oldNodes; oldNodes = node;
			return (NULL);
		}
		lDepth = (node->left == 0? 0: node->left->depth);
		rDepth = (node->right == 0? 0: node->right->depth);
		if (lDepth > rDepth)
		{
			node->left = delmax(node->left, &sNode);
		}
		else
		{
			node->right = delmin(node->right, &sNode);
		}
		sNode->left = node->left;
		sNode->right = node->right;
		sNode->depth = NDepth(sNode);
		if (freeProc != NULL) (*freeProc)(node->key, node->info);
		node->left = oldNodes; oldNodes = node;
		return (Reorder(sNode));
	}
	else
	{
		if (rescmp > 0)
		{
			node->left = RemoveNode(node->left, key, keyCmp, freeProc);
		}
		else
		{
			node->right = RemoveNode(node->right, key, keyCmp, freeProc);
		}
		return (Reorder(node));
	}
}

// Assembly:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x10, %rsp
testq %rdi, %rdi
je 0xb5b5
movq %rcx, %r14
movq %rdx, %r15
movq %rsi, %r12
movq %rdi, %rbx
movq (%rdi), %rdi
callq *%rdx
testl %eax, %eax
je 0xb4da
setle %al
movzbl %al, %r13d
movq 0x10(%rbx,%r13,8), %rdi
movq %r12, %rsi
movq %r15, %rdx
movq %r14, %rcx
callq 0xb47b
movq %rax, 0x10(%rbx,%r13,8)
movq %rbx, %rdi
addq $0x10, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
jmp 0xb736
andq $0x0, 0x8(%rsp)
movq 0x20(%rbx), %rax
movq 0x28(%rbx), %rcx
testq %rcx, %rcx
je 0xb4f1
movq %rax, 0x20(%rcx)
testq %rax, %rax
je 0xb4fa
movq %rcx, 0x28(%rax)
movq 0x10(%rbx), %rdi
testq %rdi, %rdi
je 0xb516
movswl 0x30(%rdi), %ecx
movq 0x18(%rbx), %rax
testq %rax, %rax
jne 0xb521
xorl %eax, %eax
xorl %edx, %edx
jmp 0xb525
movq 0x18(%rbx), %rax
testq %rax, %rax
je 0xb594
xorl %ecx, %ecx
movswl 0x30(%rax), %edx
leaq 0x8(%rsp), %rsi
cmpl %edx, %ecx
jle 0xb540
callq 0xb6ec
movq %rax, %rcx
movq %rax, 0x10(%rbx)
movq 0x18(%rbx), %rax
jmp 0xb550
movq %rax, %rdi
callq 0xb711
movq %rax, 0x18(%rbx)
movq 0x10(%rbx), %rcx
movq 0x8(%rsp), %r15
movq %rcx, 0x10(%r15)
movq %rax, 0x18(%r15)
movq %r15, %rdi
callq 0xb6bd
movl %eax, 0x30(%r15)
testq %r14, %r14
je 0xb578
movq (%rbx), %rdi
movq 0x8(%rbx), %rsi
callq *%r14
movq 0xf6b1(%rip), %rax      # 0x1ac30
movq %rax, 0x10(%rbx)
movq %rbx, 0xf6a6(%rip)      # 0x1ac30
movq %r15, %rdi
callq 0xb736
jmp 0xb5b7
testq %r14, %r14
je 0xb5a3
movq (%rbx), %rdi
movq 0x8(%rbx), %rsi
callq *%r14
movq 0xf686(%rip), %rax      # 0x1ac30
movq %rax, 0x10(%rbx)
movq %rbx, 0xf67b(%rip)      # 0x1ac30
xorl %eax, %eax
addq $0x10, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O2/theovosse[P]llgen/avl3.c
// Function: CopyTree
static TREE CopyTree2(TREE tree, CopyProc copyKey, CopyProc copyInfo)
{
	TREE n0;

	if (tree == NULL)
	{
		return (NULL);
	}
	if (oldNodes == NULL)
	{
		n0 = (TREE) mmalloc(sizeof(struct tree));
		if (n0 == NULL)
		{
			perror("CopyTree");
			exit(1);
		}
	}
	else
	{
		n0 = oldNodes;
		oldNodes = oldNodes->left;
	}
	n0->key = (copyKey == NULL? tree->key: copyKey(tree->key));
	n0->info = (copyInfo == NULL? tree->info: copyInfo(tree->info));
	n0->left = CopyTree(tree->left, copyKey, copyInfo);
	n0->right = CopyTree(tree->right, copyKey, copyInfo);
	n0->depth = tree->depth;
	return (n0);
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
testq %rdi, %rdi
je 0xb5f4
movq %rdx, %r15
movq %rsi, %r12
movq %rdi, %r14
movq 0xf64e(%rip), %rbx      # 0x1ac30
testq %rbx, %rbx
je 0xb5f8
movq 0x10(%rbx), %rax
movq %rax, 0xf63e(%rip)      # 0x1ac30
jmp 0xb608
xorl %ebx, %ebx
jmp 0xb659
pushq $0x38
popq %rdi
callq 0xb85c
movq %rax, %rbx
testq %rax, %rax
je 0xb67c
movq (%r14), %rax
testq %r12, %r12
je 0xb616
movq %rax, %rdi
callq *%r12
movq %rax, (%rbx)
movq 0x8(%r14), %rax
testq %r15, %r15
je 0xb628
movq %rax, %rdi
callq *%r15
movq %rax, 0x8(%rbx)
movq 0x10(%r14), %rdi
movq %r12, %rsi
movq %r15, %rdx
callq 0xb5c5
movq %rax, 0x10(%rbx)
movq 0x18(%r14), %rdi
movq %r12, %rsi
movq %r15, %rdx
callq 0xb5c5
movq %rax, 0x18(%rbx)
movl 0x30(%r14), %eax
movl %eax, 0x30(%rbx)
movq %rbx, %rdi
xorl %esi, %esi
callq 0xb690
testq %rax, %rax
je 0xb66d
andq $0x0, 0x20(%rax)
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
leaq 0x67e9(%rip), %rdi      # 0x11e6c
callq 0x31c0
pushq $0x1
popq %rdi
callq 0x3200
// File: /workspace/github_c_makefile_star2_O2/theovosse[P]llgen/avl3.c
// Function: SetOrder
static TREE SetOrder(TREE tree, TREE previous)
{
	if (tree == NULL)
	{
		return (previous);
	}
	tree->previous = SetOrder(tree->left, previous);
	if (tree->previous != NULL) tree->previous->next = tree;
	return (SetOrder(tree->right, tree));
}

// Assembly:
pushq %rbx
testq %rdi, %rdi
je 0xb6b8
movq %rdi, %rbx
movq 0x10(%rdi), %rdi
callq 0xb690
movq %rax, 0x28(%rbx)
testq %rax, %rax
je 0xb6af
movq %rbx, 0x20(%rax)
movq 0x18(%rbx), %rdi
movq %rbx, %rsi
jmp 0xb691
movq %rsi, %rax
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O2/theovosse[P]llgen/avl3.c
// Function: NDepth
static int NDepth(TREE t)
{
	int lDepth;
	int rDepth;
	
	if (t == NULL)
	{
		return (0);
	}
	lDepth = Depth(t->left);
	rDepth = Depth(t->right);
	return ((lDepth > rDepth? lDepth: rDepth) + 1);
}

// Assembly:
testq %rdi, %rdi
je 0xb6e9
movq 0x10(%rdi), %rdx
xorl %eax, %eax
movl $0x0, %ecx
testq %rdx, %rdx
je 0xb6d5
movl 0x30(%rdx), %ecx
movq 0x18(%rdi), %rdx
testq %rdx, %rdx
je 0xb6e1
movl 0x30(%rdx), %eax
cmpl %eax, %ecx
cmovgl %ecx, %eax
incl %eax
retq
xorl %eax, %eax
retq
// File: /workspace/github_c_makefile_star2_O2/theovosse[P]llgen/avl3.c
// Function: delmax
static TREE delmax(TREE node, TREE *subst)
{
	if (node->right != NULL)
	{
		node->right = delmax(node->right, subst);
		return (Reorder(node));
	}
	else
	{
		*subst = node;
		return (node->left);
	}
}

// Assembly:
pushq %rbx
movq %rdi, %rbx
movq 0x18(%rdi), %rdi
testq %rdi, %rdi
je 0xb708
callq 0xb6ec
movq %rax, 0x18(%rbx)
movq %rbx, %rdi
popq %rbx
jmp 0xb736
movq %rbx, (%rsi)
movq 0x10(%rbx), %rax
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O2/theovosse[P]llgen/avl3.c
// Function: delmin
static TREE delmin(TREE node, TREE *subst)
{
	if (node->left != NULL)
	{
		node->left = delmin(node->left, subst);
		return (Reorder(node));
	}
	else
	{
		*subst = node;
		return (node->right);
	}
}

// Assembly:
pushq %rbx
movq %rdi, %rbx
movq 0x10(%rdi), %rdi
testq %rdi, %rdi
je 0xb72d
callq 0xb711
movq %rax, 0x10(%rbx)
movq %rbx, %rdi
popq %rbx
jmp 0xb736
movq %rbx, (%rsi)
movq 0x18(%rbx), %rax
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O2/theovosse[P]llgen/avl3.c
// Function: Reorder
static TREE Reorder(TREE node)
{
	short int lDepth = (node->left == 0? 0: node->left->depth);
	short int rDepth = (node->right == 0? 0: node->right->depth);
	TREE n1;
	TREE n2;

	if (lDepth > rDepth + 1)
	{
		n1 = node->left;
		n2 = n1->right;
		if (n2 == 0 || n2->depth < n1->depth - 1)
		{
			node->left = n2;
			n1->right = node;
			node->depth = NDepth(node);
			n1->depth = NDepth(n1);
			return (n1);
		}
		else
		{
			node->left = n2->right;
			n1->right = n2->left;
			n2->right = node;
			n2->left = n1;
			node->depth = NDepth(node);
			n1->depth = NDepth(n1);
			n2->depth = NDepth(n2);
			return (n2);
		}
	}
	else if (rDepth > lDepth + 1)
	{
		n1 = node->right;
		n2 = n1->left;
		if (n2 == 0 || n2->depth < n1->depth - 1)
		{
			node->right = n2;
			n1->left = node;
			node->depth = NDepth(node);
			n1->depth = NDepth(n1);
			return (n1);
		}
		else
		{
			node->right = n2->left;
			n1->left = n2->right;
			n2->left = node;
			n2->right = n1;
			node->depth = NDepth(node);
			n1->depth = NDepth(n1);
			n2->depth = NDepth(n2);
			return (n2);
		}
	}
	node->depth = (lDepth > rDepth? lDepth: rDepth) + 1;
	return (node);
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rdi, %r14
movq 0x10(%rdi), %rbx
xorl %eax, %eax
movl $0x0, %ecx
testq %rbx, %rbx
je 0xb752
movswl 0x30(%rbx), %ecx
movq 0x18(%r14), %r15
testq %r15, %r15
je 0xb760
movswl 0x30(%r15), %eax
leal 0x1(%rax), %edx
cmpl %edx, %ecx
jle 0xb79c
movq 0x18(%rbx), %r15
testq %r15, %r15
je 0xb77b
movl 0x30(%rbx), %eax
decl %eax
cmpl %eax, 0x30(%r15)
jge 0xb7dd
movq %r15, 0x10(%r14)
movq %r14, 0x18(%rbx)
movq %r14, %rdi
callq 0xb6bd
movl %eax, 0x30(%r14)
movq %rbx, %rdi
callq 0xb6bd
movl %eax, 0x30(%rbx)
jmp 0xb81b
leal 0x1(%rcx), %edx
cmpl %edx, %eax
jle 0xb7cd
movq 0x10(%r15), %rbx
testq %rbx, %rbx
je 0xb7b7
movl 0x30(%r15), %eax
decl %eax
cmpl %eax, 0x30(%rbx)
jge 0xb824
movq %rbx, 0x18(%r14)
movq %r14, 0x10(%r15)
movq %r14, %rdi
callq 0xb6bd
movl %eax, 0x30(%r14)
jmp 0xb80c
cmpl %eax, %ecx
cmovgl %ecx, %eax
incl %eax
movl %eax, 0x30(%r14)
movq %r14, %rbx
jmp 0xb81b
movq 0x18(%r15), %rax
movq %rax, 0x10(%r14)
movq 0x10(%r15), %rax
movq %rax, 0x18(%rbx)
movq %r14, 0x18(%r15)
movq %rbx, 0x10(%r15)
movq %r14, %rdi
callq 0xb6bd
movl %eax, 0x30(%r14)
movq %rbx, %rdi
callq 0xb6bd
movl %eax, 0x30(%rbx)
movq %r15, %rdi
callq 0xb6bd
movl %eax, 0x30(%r15)
movq %r15, %rbx
movq %rbx, %rax
popq %rbx
popq %r14
popq %r15
retq
movq 0x10(%rbx), %rax
movq %rax, 0x18(%r14)
movq 0x18(%rbx), %rax
movq %rax, 0x10(%r15)
movq %r14, 0x10(%rbx)
movq %r15, 0x18(%rbx)
movq %r14, %rdi
callq 0xb6bd
movl %eax, 0x30(%r14)
movq %r15, %rdi
callq 0xb6bd
movl %eax, 0x30(%r15)
jmp 0xb78f
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O2/theovosse[P]llgen/storage.c
// Function: push_tempmalloc
void push_tempmalloc()
{
    TempBlokPtr nieuw_blok;

    if (temp_blok == NULL || temp_blok->vrij < 64)
    {
	if ((nieuw_blok = NieuwTempBlok()) == NULL)
	{
	    (void) fprintf(stderr, "Out of temp memory!\n");
	    exit(1);
	}
	else
	{
	    nieuw_blok->volgende = temp_blok;
	    temp_blok = nieuw_blok;
	}
    }
    *((TempBlokPtr *) temp_blok->top) = stackBlok;
    temp_blok->top += sizeof(TempBlokPtr);
    temp_blok->vrij -= sizeof(TempBlokPtr);
    *((char **) temp_blok->top) = stackTop;
    temp_blok->top += sizeof(char *);
    temp_blok->vrij -= sizeof(char *);
    *((unsigned int *) temp_blok->top) = temp_blok->vrij;
    temp_blok->top += sizeof(unsigned int);
    temp_blok->vrij -= sizeof(unsigned int);
    if ((long int) temp_blok->top % ALIGNMENTSIZE != 0)
    {
	int v = (long int) temp_blok->top % ALIGNMENTSIZE;
	temp_blok->vrij -= ALIGNMENTSIZE - v;
	temp_blok->top += ALIGNMENTSIZE - v;
    }
    stackTop = temp_blok->top;
    stackBlok = temp_blok;
}

// Assembly:
pushq %rax
movq 0xf325(%rip), %rcx      # 0x1ac50
testq %rcx, %rcx
je 0xb938
movl 0x4(%rcx), %eax
cmpl $0x3f, %eax
ja 0xb95e
callq 0xb9f7
testq %rax, %rax
je 0xb9d3
movq %rax, %rcx
movq 0xf300(%rip), %rax      # 0x1ac50
movq %rax, 0x10(%rcx)
movq %rcx, 0xf2f5(%rip)      # 0x1ac50
movl 0x4(%rcx), %eax
movq 0xf2f3(%rip), %rdx      # 0x1ac58
movq 0x8(%rcx), %rsi
movq %rdx, (%rsi)
movq 0x8(%rcx), %rdx
leaq 0x8(%rdx), %rsi
movq %rsi, 0x8(%rcx)
movq 0xf2e1(%rip), %rsi      # 0x1ac60
movq %rsi, 0x8(%rdx)
movq 0x8(%rcx), %rsi
addl $-0x10, %eax
movl %eax, 0x4(%rcx)
movl %eax, 0x8(%rsi)
addq $0xc, %rsi
movq %rsi, 0x8(%rcx)
movl 0x4(%rcx), %edi
addl $-0x4, %edi
movl %edi, 0x4(%rcx)
pushq $0x4
popq %r8
movq %rsi, %rax
cqto
idivq %r8
testq %rdx, %rdx
je 0xb9c3
pushq $0x4
popq %rax
subl %edx, %eax
subl %eax, %edi
movl %edi, 0x4(%rcx)
addq %rax, %rsi
movq %rsi, 0x8(%rcx)
movq %rsi, 0xf296(%rip)      # 0x1ac60
movq %rcx, 0xf287(%rip)      # 0x1ac58
popq %rax
retq
movq 0xc61e(%rip), %rax      # 0x17ff8
movq (%rax), %rcx
leaq 0x6491(%rip), %rdi      # 0x11e75
pushq $0x14
popq %rsi
pushq $0x1
popq %rdx
callq 0x3210
pushq $0x1
popq %rdi
callq 0x3200
// File: /workspace/github_c_makefile_star2_O2/theovosse[P]llgen/storage.c
// Function: NieuwTempBlok
static TempBlokPtr NieuwTempBlok(void)
{
    TempBlokPtr nieuw_blok;
    unsigned int blokruimte;

    if (vrije_blokken != NULL)
    {
	nieuw_blok = vrije_blokken;
	vrije_blokken = vrije_blokken->volgende;
    }
    else
    {
	if (0 < ruimte_over && ruimte_over < 32768)
	{
	    blokruimte = ruimte_over;
	}
	else
	{
	    blokruimte = 32768;
	}
	nieuw_blok = (TempBlokPtr) mmalloc(blokruimte);
	nieuw_blok->grootte = blokruimte;
    }
    nieuw_blok->vrij = nieuw_blok->grootte - sizeof(struct TempBlok);
    nieuw_blok->top = (char *) nieuw_blok + sizeof(struct TempBlok);
    if ((long int) nieuw_blok->top % ALIGNMENTSIZE != 0)
    {
	int v = (long int) nieuw_blok->top % ALIGNMENTSIZE;
	nieuw_blok->vrij -= ALIGNMENTSIZE - v;
	nieuw_blok->top += ALIGNMENTSIZE - v;
    }
    return (nieuw_blok);
}

// Assembly:
pushq %rbx
movq 0xf269(%rip), %rcx      # 0x1ac68
testq %rcx, %rcx
je 0xba13
movq 0x10(%rcx), %rax
movq %rax, 0xf259(%rip)      # 0x1ac68
movl (%rcx), %ebx
jmp 0xba39
movq 0xf226(%rip), %rax      # 0x1ac40
leaq -0x1(%rax), %rcx
cmpq $0x7fff, %rcx           # imm = 0x7FFF
movl $0x8000, %ebx           # imm = 0x8000
cmovbl %eax, %ebx
movl %ebx, %edi
callq 0xb85c
movq %rax, %rcx
movl %ebx, (%rax)
addl $-0x18, %ebx
movl %ebx, 0x4(%rcx)
leaq 0x18(%rcx), %rsi
movq %rsi, 0x8(%rcx)
pushq $0x4
popq %rdi
movq %rsi, %rax
cqto
idivq %rdi
testq %rdx, %rdx
je 0xba68
pushq $0x4
popq %rax
subl %edx, %eax
subl %eax, %ebx
movl %ebx, 0x4(%rcx)
addq %rax, %rsi
movq %rsi, 0x8(%rcx)
movq %rcx, %rax
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O2/theovosse[P]llgen/storage.c
// Function: pop_tempmalloc
void pop_tempmalloc()
{
    TempBlokPtr tbp;

    while (temp_blok != stackBlok)
    {
	tbp = temp_blok->volgende;
	temp_blok->volgende = vrije_blokken;
	vrije_blokken = temp_blok;
	temp_blok = tbp;
    }
    temp_blok->top = stackTop;
    temp_blok->vrij += sizeof(unsigned int);
    temp_blok->top -= sizeof(unsigned int);
    if ((long int) temp_blok->top % ALIGNMENTSIZE != 0)
    {
	int v = (long int) temp_blok->top % ALIGNMENTSIZE;
	temp_blok->vrij += v;
	temp_blok->top += v;
    }
    temp_blok->vrij = *((unsigned int *) temp_blok->top);
    temp_blok->vrij += sizeof(char *);
    temp_blok->top -= sizeof(char *);
    stackTop = *((char **) temp_blok->top);
    temp_blok->vrij += sizeof(TempBlokPtr);
    temp_blok->top -= sizeof(TempBlokPtr);
    stackBlok = *((TempBlokPtr *) temp_blok->top);
}

// Assembly:
movq 0xf175(%rip), %rax      # 0x1ac58
movq 0xf166(%rip), %rsi      # 0x1ac50
movq 0xf177(%rip), %rcx      # 0x1ac68
cmpq %rax, %rsi
je 0xbb14
movq 0x10(%rsi), %rdx
movq %rcx, 0x10(%rsi)
movq %rsi, 0xf163(%rip)      # 0x1ac68
movq %rdx, 0xf144(%rip)      # 0x1ac50
movq %rsi, %rcx
movq %rdx, %rsi
jmp 0xbaf1
movq 0xf145(%rip), %rcx      # 0x1ac60
movl 0x4(%rsi), %edi
addl $0x4, %edi
movl %edi, 0x4(%rsi)
addq $-0x4, %rcx
movq %rcx, 0x8(%rsi)
pushq $0x4
popq %r8
movq %rcx, %rax
cqto
idivq %r8
testq %rdx, %rdx
je 0xbb49
addl %edx, %edi
movl %edi, 0x4(%rsi)
addq %rdx, %rcx
movq %rcx, 0x8(%rsi)
movl (%rcx), %eax
leaq -0x8(%rcx), %rdx
movq %rdx, 0x8(%rsi)
movq -0x8(%rcx), %rdx
movq %rdx, 0xf102(%rip)      # 0x1ac60
addl $0x10, %eax
movl %eax, 0x4(%rsi)
leaq -0x10(%rcx), %rax
movq %rax, 0x8(%rsi)
movq -0x10(%rcx), %rax
movq %rax, 0xf0e1(%rip)      # 0x1ac58
retq
// File: /workspace/github_c_makefile_star2_O2/theovosse[P]llgen/regexp.c
// Function: push_localadm
void push_localadm(void) {
	struct localadm *la;

	push_tempmalloc();
	la = (struct localadm *) temp_malloc(sizeof(struct localadm));
	if (la == NULL) {
		OutOfMemory("push_localadm");
		exit(1);
	}
	la->oldRegExps = oldRegExps;
	la->oldTransitions = oldTransitions;
	la->oldSets = oldSets;
	la->totalMalloc = totalMalloc;
	la->totalFree = totalFree;
	la->nrTransition = nrTransition;
	la->nrSet = nrSet;
	la->nrRegExp = nrRegExp;
	la->nrOldTransitions = nrOldTransitions;
	la->nrOldSets = nrOldSets;
	la->nrOldRegExps = nrOldRegExps;
	la->next = las;
	las = la;
	oldRegExps = NULL;
	oldTransitions = NULL;
	oldSets = NULL;
	totalMalloc += sizeof(struct localadm);
}

// Assembly:
pushq %rax
callq 0xb923
pushq $0x60
popq %rdi
callq 0xba6d
testq %rax, %rax
je 0xbc3e
movq 0xf122(%rip), %rcx      # 0x1acb8
movq %rcx, (%rax)
movq 0xf120(%rip), %rcx      # 0x1acc0
movq %rcx, 0x8(%rax)
movq 0xf11d(%rip), %rcx      # 0x1acc8
movq %rcx, 0x10(%rax)
movq 0xf0ba(%rip), %rcx      # 0x1ac70
movq %rcx, 0x18(%rax)
movq 0xf0d7(%rip), %rdx      # 0x1ac98
movq %rdx, 0x38(%rax)
movq 0xf0ac(%rip), %rdx      # 0x1ac78
movq %rdx, 0x20(%rax)
movq 0xf0a9(%rip), %rdx      # 0x1ac80
movq %rdx, 0x28(%rax)
movq 0xf0a6(%rip), %rdx      # 0x1ac88
movq %rdx, 0x30(%rax)
movq 0xf0c3(%rip), %rdx      # 0x1acb0
movq %rdx, 0x50(%rax)
movq 0xf0b0(%rip), %rdx      # 0x1aca8
movq %rdx, 0x48(%rax)
movq 0xf09d(%rip), %rdx      # 0x1aca0
movq %rdx, 0x40(%rax)
movq 0xf0c2(%rip), %rdx      # 0x1acd0
movq %rdx, 0x58(%rax)
andq $0x0, 0xf09e(%rip)      # 0x1acb8
andq $0x0, 0xf09e(%rip)      # 0x1acc0
andq $0x0, 0xf09e(%rip)      # 0x1acc8
movq %rax, 0xf09f(%rip)      # 0x1acd0
addq $0x60, %rcx
movq %rcx, 0xf034(%rip)      # 0x1ac70
popq %rax
retq
leaq 0x6245(%rip), %rdi      # 0x11e8a
callq 0xbc52
pushq $0x1
popq %rdi
callq 0x3200
// File: /workspace/github_c_makefile_star2_O2/theovosse[P]llgen/regexp.c
// Function: OutOfMemory
static void OutOfMemory(char *func) {
	(void) fprintf(stderr, "Out of memory in %s\n", func);
	(void) fprintf(stderr, "%ld bytes allocated\n", totalMalloc);
	(void) fprintf(stderr, "%ld transitions\n", nrTransition);
	(void) fprintf(stderr, "%ld sets\n", nrSet);
	(void) fprintf(stderr, "%ld regexps\n", nrRegExp);
}

// Assembly:
pushq %rbx
movq %rdi, %rdx
movq 0xc39b(%rip), %rbx      # 0x17ff8
movq (%rbx), %rdi
leaq 0x63e1(%rip), %rsi      # 0x12048
xorl %eax, %eax
callq 0x3150
movq (%rbx), %rdi
movq 0xeff8(%rip), %rdx      # 0x1ac70
leaq 0x63de(%rip), %rsi      # 0x1205d
xorl %eax, %eax
callq 0x3150
movq (%rbx), %rdi
movq 0xefe8(%rip), %rdx      # 0x1ac78
leaq 0x63db(%rip), %rsi      # 0x12072
xorl %eax, %eax
callq 0x3150
movq (%rbx), %rdi
movq 0xefd8(%rip), %rdx      # 0x1ac80
leaq 0x63d4(%rip), %rsi      # 0x12083
xorl %eax, %eax
callq 0x3150
movq (%rbx), %rdi
movq 0xefc8(%rip), %rdx      # 0x1ac88
leaq 0x63c6(%rip), %rsi      # 0x1208d
xorl %eax, %eax
popq %rbx
jmp 0x3150
// File: /workspace/github_c_makefile_star2_O2/theovosse[P]llgen/regexp.c
// Function: pop_localadm
void pop_localadm(void) {
	if (las == NULL) {
		(void) fprintf(stderr, "pop_localadm: las == NULL\n");
		exit(1);
	}
	oldRegExps = las->oldRegExps;
	oldTransitions = las->oldTransitions;
	oldSets = las->oldSets;
	totalMalloc = las->totalMalloc;
	nrTransition = las->nrTransition;
	nrSet = las->nrSet;
	nrRegExp = las->nrRegExp;
	totalFree = las->totalFree;
	nrOldTransitions = las->nrOldTransitions;
	nrOldSets = las->nrOldSets;
	nrOldRegExps = las->nrOldRegExps;
	las = las->next;
	pop_tempmalloc();
}

// Assembly:
movq 0xeffa(%rip), %rax      # 0x1acd0
testq %rax, %rax
je 0xbd67
movq (%rax), %rcx
movq %rcx, 0xefcf(%rip)      # 0x1acb8
movq 0x8(%rax), %rcx
movq %rcx, 0xefcc(%rip)      # 0x1acc0
movq 0x10(%rax), %rcx
movq %rcx, 0xefc9(%rip)      # 0x1acc8
movq 0x18(%rax), %rcx
movq %rcx, 0xef66(%rip)      # 0x1ac70
movq 0x20(%rax), %rcx
movq %rcx, 0xef63(%rip)      # 0x1ac78
movq 0x28(%rax), %rcx
movq %rcx, 0xef60(%rip)      # 0x1ac80
movq 0x30(%rax), %rcx
movq %rcx, 0xef5d(%rip)      # 0x1ac88
movq 0x38(%rax), %rcx
movq %rcx, 0xef62(%rip)      # 0x1ac98
movq 0x50(%rax), %rcx
movq %rcx, 0xef6f(%rip)      # 0x1acb0
movq 0x48(%rax), %rcx
movq %rcx, 0xef5c(%rip)      # 0x1aca8
movq 0x40(%rax), %rcx
movq %rcx, 0xef49(%rip)      # 0x1aca0
movq 0x58(%rax), %rax
movq %rax, 0xef6e(%rip)      # 0x1acd0
jmp 0xbadc
pushq %rax
movq 0xc289(%rip), %rax      # 0x17ff8
movq (%rax), %rcx
leaq 0x611f(%rip), %rdi      # 0x11e98
pushq $0x1a
popq %rsi
pushq $0x1
popq %rdx
callq 0x3210
pushq $0x1
popq %rdi
callq 0x3200
// File: /workspace/github_c_makefile_star2_O2/theovosse[P]llgen/regexp.c
// Function: MakeRegExp
RegExp MakeRegExp(Transition transitions, Transition eTransitions, ESet info) {
	RegExp regExp;

	if (oldRegExps == NULL) {
		regExp = (RegExp) temp_malloc(sizeof(struct RegExp));
		totalMalloc += sizeof(struct RegExp); nrRegExp++;
		if (regExp == NULL) { 
			OutOfMemory("MakeRegExp");
			exit(1);
		}
	} else {
		regExp = oldRegExps;
		oldRegExps = oldRegExps->next;
		nrOldRegExps--;
		totalFree -= sizeof(struct RegExp);
	}
	regExp->transitions = transitions;
	regExp->eTransitions = eTransitions;
	regExp->info = info;
	regExp->state.number = stateNumber++;
	regExp->lastVisit = 0;
	regExp->next = currentAutomaton->next;
	currentAutomaton->next = regExp;
	return (regExp);
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rdx, %rbx
movq %rsi, %r14
movq %rdi, %r15
movq 0xeef9(%rip), %rax      # 0x1acb8
testq %rax, %rax
je 0xbde0
movq 0x18(%rax), %rcx
decq 0xeed1(%rip)            # 0x1aca0
movq %rcx, 0xeee2(%rip)      # 0x1acb8
addq $-0x30, 0xeeba(%rip)    # 0x1ac98
jmp 0xbdfc
pushq $0x30
popq %rdi
callq 0xba6d
addq $0x30, 0xee80(%rip)     # 0x1ac70
incq 0xee91(%rip)            # 0x1ac88
testq %rax, %rax
je 0xbe39
movq %r15, (%rax)
movq %r14, 0x8(%rax)
movq %rbx, 0x10(%rax)
movslq 0xeece(%rip), %rcx      # 0x1acdc
leal 0x1(%rcx), %edx
movl %edx, 0xeec5(%rip)      # 0x1acdc
movq %rcx, 0x28(%rax)
andq $0x0, 0x20(%rax)
movq 0xeeb9(%rip), %rcx      # 0x1ace0
movq 0x18(%rcx), %rdx
movq %rdx, 0x18(%rax)
movq %rax, 0x18(%rcx)
popq %rbx
popq %r14
popq %r15
retq
leaq 0x6073(%rip), %rdi      # 0x11eb3
callq 0xbc52
pushq $0x1
popq %rdi
callq 0x3200
// File: /workspace/github_c_makefile_star2_O2/theovosse[P]llgen/regexp.c
// Function: MakeTransition
Transition MakeTransition(int transitionChar, RegExp destination, Transition next) {
	Transition transition;

	if (oldTransitions == NULL) {
		transition = (Transition) temp_malloc(sizeof(struct Transition));
		totalMalloc += sizeof(struct Transition); nrTransition++;
		if (transition == NULL) {
			OutOfMemory("MakeTransition");
			exit(1);
		}
	} else {
		transition = oldTransitions;
		oldTransitions = oldTransitions->next;
		nrOldTransitions--;
		totalFree -= sizeof(struct Transition);
	}
	transition->transitionChar = transitionChar;
	transition->destination = destination;
	transition->next = next;
	return (transition);
}

// Assembly:
pushq %rbp
pushq %r14
pushq %rbx
movq %rdx, %rbx
movq %rsi, %r14
movl %edi, %ebp
movq 0xee60(%rip), %rax      # 0x1acc0
testq %rax, %rax
je 0xbe81
movq 0x10(%rax), %rcx
decq 0xee40(%rip)            # 0x1acb0
movq %rcx, 0xee49(%rip)      # 0x1acc0
addq $-0x18, 0xee19(%rip)    # 0x1ac98
jmp 0xbe9d
pushq $0x18
popq %rdi
callq 0xba6d
addq $0x18, 0xeddf(%rip)     # 0x1ac70
incq 0xede0(%rip)            # 0x1ac78
testq %rax, %rax
je 0xbeac
movl %ebp, (%rax)
movq %r14, 0x8(%rax)
movq %rbx, 0x10(%rax)
popq %rbx
popq %r14
popq %rbp
retq
leaq 0x600b(%rip), %rdi      # 0x11ebe
callq 0xbc52
pushq $0x1
popq %rdi
callq 0x3200
// File: /workspace/github_c_makefile_star2_O2/theovosse[P]llgen/regexp.c
// Function: AddElement
ESet AddElement(void *element, ESet next) {
	ESet sPtr;

	if (oldSets == NULL) {
		sPtr = (ESet) temp_malloc(sizeof(struct ESet));
		totalMalloc += sizeof(struct ESet); nrSet++;
		if (sPtr == NULL) {
			OutOfMemory("AddElement");
			exit(1);
		}
	} else {
		sPtr = oldSets;
		oldSets = oldSets->next;
		nrOldSets--;
		totalFree -= sizeof(struct ESet);
	}
	sPtr->element = element;
	sPtr->next = next;
	return (sPtr);
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq %rdi, %r14
movq 0xedf7(%rip), %rax      # 0x1acc8
testq %rax, %rax
je 0xbef2
movq 0x8(%rax), %rcx
decq 0xedc7(%rip)            # 0x1aca8
movq %rcx, 0xede0(%rip)      # 0x1acc8
addq $-0x10, 0xeda8(%rip)    # 0x1ac98
jmp 0xbf0e
pushq $0x10
popq %rdi
callq 0xba6d
addq $0x10, 0xed6e(%rip)     # 0x1ac70
incq 0xed77(%rip)            # 0x1ac80
testq %rax, %rax
je 0xbf1d
movq %r14, (%rax)
movq %rbx, 0x8(%rax)
addq $0x8, %rsp
popq %rbx
popq %r14
retq
leaq 0x5fa9(%rip), %rdi      # 0x11ecd
callq 0xbc52
pushq $0x1
popq %rdi
callq 0x3200