LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O3/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 0xbbcb
xorl %ebp, %ebp
testq %rax, %rax
je 0x66a7
movq %rax, %r14
xorl %r15d, %r15d
movq %r14, %rdi
callq 0xbc07
movq %rbx, %rdi
movq %rax, %rsi
callq 0x62d3
negw %ax
movl $0x0, %ebp
sbbl %ebp, %ebp
orl %r15d, %ebp
movq %r14, %rdi
callq 0xbc13
movq %rax, %r14
movl %ebp, %r15d
testq %rax, %rax
jne 0x6674
movl %ebp, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/theovosse[P]llgen/llgen.c
// Function: CompileScanner
static void CompileScanner(void) {
	TREE sym;
	Name name;
	RegExp nfa = NULL;
	int res;
	char regexpbuf[256];

	if (!HasProperty("escregexp")) {
		viMode = true;
	}
	push_localadm();
	nfa = InitRegExp();
	SetSingleAnswer(false);
	if (HasProperty("extcharset")) {
		SetCharSetSize(256);
	} else {
		SetCharSetSize(128);
	}

	for (sym = GetFirstNode(idTree); sym != NULL; sym = GetNextNode(sym)) {
		name = GetKey(sym);
		if (name->nameType == string && name->index != 0 && name->isTerminal) {
			regexpcopy(regexpbuf, name->name);
			if ((res = AddRegExp(nfa, regexpbuf, (void *) name->index)) != 0) {
				fprintf(stderr, "%s:%d: %s\n", inputFileName, name->lineNr, regExpError[res]);
				errorOccurred = true;
			}
		}
	}
	dfa = N2DFA(nfa);
	MinimizeDFA(dfa);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x108, %rsp            # imm = 0x108
leaq 0xac46(%rip), %rdi      # 0x116d1
callq 0x628f
testw %ax, %ax
jne 0x6aa1
leaq 0x151f4(%rip), %rax     # 0x1bc90
movw $0xffff, (%rax)         # imm = 0xFFFF
callq 0xc5dc
callq 0xca8f
movq %rax, %rbx
xorl %edi, %edi
callq 0xc765
leaq 0xac1f(%rip), %rdi      # 0x116db
callq 0x628f
xorl %edi, %edi
testw %ax, %ax
setne %dil
shll $0x7, %edi
subl $-0x80, %edi
callq 0xc757
movq 0x13024(%rip), %rdi     # 0x19b00
callq 0xbbcb
testq %rax, %rax
je 0x6bcd
movq %rax, %r14
movq %rsp, %r15
movq %r14, %rdi
callq 0xbc07
cmpl $0x1, 0x38(%rax)
jne 0x6ba4
movq %rax, %r12
cmpq $0x0, 0x28(%rax)
je 0x6ba4
cmpw $0x0, 0x34(%r12)
je 0x6ba4
movq (%r12), %rbp
incq %rbp
movq %r15, %r13
incq %rbp
movzbl -0x1(%rbp), %eax
cmpl $0x5c, %eax
jne 0x6b73
movzbl (%rbp), %eax
testl %eax, %eax
je 0x6b55
cmpl $0x22, %eax
je 0x6b5c
cmpl $0x5c, %eax
jne 0x6b69
movw $0x5c5c, (%r13)         # imm = 0x5C5C
addq $0x2, %r13
incq %rbp
jmp 0x6b27
callq 0x33a1
jmp 0x6b27
movb $0x22, (%r13)
incq %r13
incq %rbp
jmp 0x6b27
movb $0x5c, (%r13)
incq %r13
jmp 0x6b27
testl %eax, %eax
je 0x6b90
cmpl $0x22, %eax
je 0x6b85
movb %al, (%r13)
incq %r13
jmp 0x6b27
cmpb $0x0, (%rbp)
jne 0x6bc6
movb $0x0, (%r13)
movq 0x28(%r12), %rdx
movq %rbx, %rdi
movq %r15, %rsi
callq 0xcadb
testl %eax, %eax
jne 0x6bba
movq %r14, %rdi
callq 0xbc13
movq %rax, %r14
testq %rax, %rax
jne 0x6af0
jmp 0x6bcd
movq %r12, %rdi
movl %eax, %esi
callq 0x33d7
jmp 0x6ba4
callq 0x33bc
jmp 0x6b8b
movq %rbx, %rdi
callq 0xd6c1
movq %rax, 0x12f54(%rip)     # 0x19b30
movq %rax, %rdi
callq 0xdad9
addq $0x108, %rsp            # imm = 0x108
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/theovosse[P]llgen/llgen.c
// Function: CreateTokenNames
static void CreateTokenNames(void) {
	Name name;
	int i;

    PrintArrayDeclaration(outputFile, "static", targetLanguage->stringType, "tokenName", -1, nodeNumber + 2);
	fputs("\n\t\"IGNORE\",\n", outputFile);
	for (i = 1; i <= nodeNumber; i++) {
		name = TokenIndexName(i, true);
		if (name != NULL && name->nameType == token) {
			fprintf(outputFile, "	\"%s\",\n", name->name);
		} else if (name != NULL && name->nameType == string) {
			fprintf(outputFile, "	%s,\n", name->name);
		} else {
			fputs("	\"@&^@#&^\",\n", outputFile);
		}
	}
	fputs("	\"EOF\",\n", outputFile);
	fprintf(outputFile, "%s%s\n", targetLanguage->endOfArrayLiteral, targetLanguage->terminateDeclaration);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq 0x12c17(%rip), %rdi     # 0x19ae8
movq 0x122a8(%rip), %rax     # 0x19180
movq 0x48(%rax), %rdx
movl 0x12c25(%rip), %r9d     # 0x19b08
addl $0x2, %r9d
movl $0xffffffff, (%rsp)     # imm = 0xFFFFFFFF
leaq 0xa715(%rip), %rsi      # 0x1160a
leaq 0xa8c8(%rip), %rcx      # 0x117c4
movq $-0x1, %r8
callq *0xc0(%rax)
movq 0x12bd8(%rip), %rsi     # 0x19ae8
leaq 0xa8b7(%rip), %rdi      # 0x117ce
callq 0x3110
cmpl $0x0, 0x12be5(%rip)     # 0x19b08
jle 0x6f98
leaq 0xa8bd(%rip), %rbx      # 0x117e9
leaq 0xa8b0(%rip), %r14      # 0x117e3
leaq 0xa8a1(%rip), %r15      # 0x117db
xorl %ebp, %ebp
incl %ebp
movl %ebp, %edi
movl $0xffffffff, %esi       # imm = 0xFFFFFFFF
callq 0x79be
testq %rax, %rax
je 0x6f6b
movl 0x38(%rax), %ecx
cmpl $0x1, %ecx
je 0x6f7c
cmpl $0x4, %ecx
jne 0x6f6b
movq 0x12b85(%rip), %rdi     # 0x19ae8
movq (%rax), %rdx
movq %r15, %rsi
jmp 0x6f89
movq 0x12b76(%rip), %rsi     # 0x19ae8
movq %rbx, %rdi
callq 0x3110
jmp 0x6f90
movq 0x12b65(%rip), %rdi     # 0x19ae8
movq (%rax), %rdx
movq %r14, %rsi
xorl %eax, %eax
callq 0x3160
cmpl 0x12b72(%rip), %ebp     # 0x19b08
jl 0x6f3c
movq 0x12b49(%rip), %rsi     # 0x19ae8
leaq 0xa850(%rip), %rdi      # 0x117f6
callq 0x3110
movq 0x12b36(%rip), %rdi     # 0x19ae8
movq 0x121c7(%rip), %rax     # 0x19180
movq 0x70(%rax), %rdx
movq 0x78(%rax), %rcx
leaq 0xa66f(%rip), %rsi      # 0x11637
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
jmp 0x3160
// File: /workspace/github_c_makefile_star2_O3/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 0x11951(%rip), %rax     # 0x19180
movq 0x110(%rax), %rax
testq %rcx, %rcx
je 0x7840
movq (%rcx), %rdx
jmp 0x7847
leaq 0x9cee(%rip), %rdx      # 0x11535
movq %r14, %rdi
callq *%rax
testq %rbx, %rbx
je 0x78ed
movw $0xffff, %ax            # imm = 0xFFFF
xorl %ebp, %ebp
movswl (%rbx), %edx
movq 0x18(%rbx), %r15
cmpb $0x2c, (%r15)
jne 0x7883
cmpb $0x0, 0x1(%r15)
sete %cl
testl %ebp, %ebp
sete %sil
testb %sil, %cl
je 0x7883
xorl %ebp, %ebp
movw $0xffff, %ax            # imm = 0xFFFF
jmp 0x78e0
xorl %ecx, %ecx
testw %ax, %ax
sete %cl
movq 0x118ee(%rip), %rax     # 0x19180
movq %r14, %rdi
movq %r15, %rsi
callq *0x118(%rax,%rcx,8)
movzbl (%r15), %ecx
xorl %eax, %eax
cmpl $0x5c, %ecx
jg 0x78bb
cmpl $0x28, %ecx
je 0x78ca
cmpl $0x29, %ecx
je 0x78d5
cmpl $0x5b, %ecx
je 0x78ca
jmp 0x78e0
cmpl $0x5d, %ecx
je 0x78d5
cmpl $0x7d, %ecx
je 0x78d5
cmpl $0x7b, %ecx
jne 0x78e0
cmpb $0x0, 0x1(%r15)
jne 0x78de
incl %ebp
jmp 0x78de
cmpb $0x0, 0x1(%r15)
jne 0x78de
decl %ebp
xorl %eax, %eax
movq 0x28(%rbx), %rbx
testq %rbx, %rbx
jne 0x785b
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/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 0x7948
movq 0x10(%rdi), %rsi
testq %rsi, %rsi
je 0x7948
movq 0x12239(%rip), %rdi     # 0x19b50
leaq 0x42(%rip), %rdx        # 0x7960
callq 0xbca0
testq %rax, %rax
je 0x7948
movq %rax, %rdi
callq 0xbbfa
leaq 0x12209(%rip), %rdi     # 0x19b40
leaq 0x9d86(%rip), %rsi      # 0x116c4
movl %eax, %edx
xorl %eax, %eax
popq %rcx
jmp 0x31f0
movq 0x11831(%rip), %rax     # 0x19180
movq 0x40(%rax), %rsi
leaq 0x121e6(%rip), %rdi     # 0x19b40
popq %rax
jmp 0x3080
// File: /workspace/github_c_makefile_star2_O3/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:
testq %rdi, %rdi
setne %al
testq %rsi, %rsi
setne %cl
movl %eax, %edx
andb %cl, %dl
cmpb $0x1, %dl
jne 0x79a2
movq (%rdi), %rax
movq (%rsi), %rcx
movq 0x8(%rcx), %rcx
cmpq %rcx, 0x8(%rax)
ja 0x79b2
jb 0x79b8
movq 0x8(%rdi), %rdi
movq 0x8(%rsi), %rsi
testq %rsi, %rsi
setne %cl
testq %rdi, %rdi
setne %al
je 0x79a2
testq %rsi, %rsi
jne 0x7975
movzbl %cl, %ecx
negl %ecx
testb %al, %al
movl $0x1, %eax
cmovel %ecx, %eax
retq
movl $0x1, %eax
retq
movl $0xffffffff, %eax       # imm = 0xFFFFFFFF
retq
// File: /workspace/github_c_makefile_star2_O3/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, %ebp
movl %edi, %ebx
movq 0x12130(%rip), %rdi     # 0x19b00
callq 0xbbcb
testq %rax, %rax
je 0x7a04
movq %rax, %r14
movslq %ebx, %r15
movq %r14, %rdi
callq 0xbc07
cmpl $0x4, 0x38(%rax)
jne 0x79f4
cmpq %r15, 0x28(%rax)
je 0x7a46
movq %r14, %rdi
callq 0xbc13
movq %rax, %r14
testq %rax, %rax
jne 0x79e0
testw %bp, %bp
je 0x7a44
movq 0x120f0(%rip), %rdi     # 0x19b00
callq 0xbbcb
testq %rax, %rax
je 0x7a44
movq %rax, %r14
movslq %ebx, %rbx
movq %r14, %rdi
callq 0xbc07
cmpl $0x1, 0x38(%rax)
jne 0x7a34
cmpq %rbx, 0x28(%rax)
je 0x7a46
movq %r14, %rdi
callq 0xbc13
movq %rax, %r14
testq %rax, %rax
jne 0x7a20
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/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 0xfcf1(%rip), %rax      # 0x19180
movq 0x10652(%rip), %rsi     # 0x19ae8
testw %di, %di
je 0x94d4
pushq %rax
movq 0x98(%rax), %rdi
callq 0x3110
movq 0x10639(%rip), %rsi     # 0x19ae8
movl $0x20, %edi
callq 0x3130
movq 0xfcc0(%rip), %rax      # 0x19180
movq 0x88(%rax), %rdi
movq 0x1061a(%rip), %rsi     # 0x19ae8
popq %rax
jmp 0x3110
movq 0x90(%rax), %rdi
jmp 0x3110
// File: /workspace/github_c_makefile_star2_O3/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 0xbbcb
testq %rax, %rax
je 0x9550
movq %rax, %r14
movq %rax, %rdi
callq 0xbc07
movq (%rax), %rdi
movq %rbx, %rsi
callq 0x3110
movq %r14, %rdi
callq 0xbc13
testq %rax, %rax
je 0x9550
movq %rax, %r14
leaq 0x7fc5(%rip), %r15      # 0x114e7
movq %r15, %rdi
movq %rbx, %rsi
callq 0x3110
movq %r14, %rdi
callq 0xbc07
movq (%rax), %rdi
movq %rbx, %rsi
callq 0x3110
movq %r14, %rdi
callq 0xbc13
movq %rax, %r14
testq %rax, %rax
jne 0x9522
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O3/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, %rbx
movq 0x10603(%rip), %rdi     # 0x19b68
leaq 0x396(%rip), %rdx       # 0x9902
movq %rbx, %rsi
callq 0xbca0
movq %rax, %r14
testq %rax, %rax
je 0x95b0
movq 0xfbfd(%rip), %rax      # 0x19180
movq 0x100(%rax), %r15
movq 0x10557(%rip), %rbx     # 0x19ae8
movq %r14, %rdi
callq 0xbbfa
leaq 0x8219(%rip), %rsi      # 0x117b9
movq %rbx, %rdi
movq %rax, %rdx
movq %r15, %rax
popq %rbx
popq %r14
popq %r15
jmpq *%rax
movq %rbx, %rdi
callq 0x3719
jmp 0x957c
// File: /workspace/github_c_makefile_star2_O3/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 0x1059d(%rip), %rdi     # 0x19b68
leaq 0x330(%rip), %rdx       # 0x9902
callq 0xbca0
testq %rax, %rax
je 0x95e4
addq $0x8, %rsp
popq %rbx
popq %r14
retq
incq 0x1056d(%rip)           # 0x19b58
movq %rbx, %rdi
xorl %esi, %esi
xorl %edx, %edx
callq 0xbf8b
movq 0x1055a(%rip), %rdx     # 0x19b58
leaq 0x10563(%rip), %rdi     # 0x19b68
leaq 0x2f6(%rip), %rcx       # 0x9902
movq %rax, %rsi
callq 0xb7fc
movq 0xfb65(%rip), %r11      # 0x19180
movq 0x50(%r11), %r10
movq 0x10532(%rip), %r8      # 0x19b58
movl 0x104dc(%rip), %eax     # 0x19b08
incl %eax
cltd
idivl 0xfb3b(%rip)            # 0x19170
leal 0x1(%rax), %r9d
movl $0xffffffff, (%rsp)     # imm = 0xFFFFFFFF
leaq 0x7fc3(%rip), %rsi      # 0x1160a
leaq 0x816b(%rip), %rcx      # 0x117b9
movq %r14, %rdi
movq %r10, %rdx
callq *0xc0(%r11)
movq %r14, %rdi
movq %rbx, %rsi
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x75f1
// File: /workspace/github_c_makefile_star2_O3/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 0x9992
movq %rax, %r14
movq %rbx, %rdi
callq 0x9992
movq %rax, %rbx
movq %r14, %rdi
movq %rax, %rsi
callq 0x9a2c
movq %rax, %r15
movq %r14, %rdi
xorl %esi, %esi
callq 0xbd36
movq %rbx, %rdi
xorl %esi, %esi
callq 0xbd36
movq %r15, %rax
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O3/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 0x98be
cmpl $0x6, %edx
jne 0x98dc
movq 0x18(%rsi), %rax
movq 0x18(%rax), %rax
movl 0x38(%rax), %ecx
cmpl $0x1, %ecx
je 0x98d4
cmpl $0x4, %ecx
je 0x98d4
testl %ecx, %ecx
je 0x98f4
retq
movq %rax, %rsi
jmp 0x62d3
movq 0xf715(%rip), %rax      # 0x18ff8
movq (%rax), %rdi
leaq 0x833f(%rip), %rsi      # 0x11c2c
xorl %eax, %eax
jmp 0x3160
pushq %rax
movq %rsi, %rdi
callq 0x3753
addq $0x8, %rsp
retq
// File: /workspace/github_c_makefile_star2_O3/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 0xbbcb
movq %rax, %rbx
movq %r14, %rdi
callq 0xbbcb
movq %rax, %r14
testq %rbx, %rbx
setne %al
testq %r14, %r14
setne %cl
movl %eax, %edx
andb %cl, %dl
cmpb $0x1, %dl
jne 0x997d
movq %rbx, %rdi
callq 0xbc07
movq %rax, %r15
movq %r14, %rdi
callq 0xbc07
movq (%r15), %rdi
movq (%rax), %rsi
callq 0x3240
testl %eax, %eax
jne 0x998c
movq %rbx, %rdi
callq 0xbc13
movq %rax, %rbx
movq %r14, %rdi
callq 0xbc13
movq %rax, %r14
testq %rax, %rax
setne %cl
testq %rbx, %rbx
setne %al
je 0x997d
testq %r14, %r14
jne 0x9932
movzbl %cl, %ecx
negl %ecx
testb %al, %al
movl $0x1, %eax
cmovel %ecx, %eax
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O3/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 $0x0, (%rsp)
callq 0xbbcb
testq %rax, %rax
je 0x9a1e
movq %rax, %rbx
leaq -0x5b7c(%rip), %r14     # 0x3e3a
movq %rsp, %r15
movq 0x101a0(%rip), %r12     # 0x19b60
movq %rbx, %rdi
callq 0xbc07
movq %r12, %rdi
movq %rax, %rsi
movq %r14, %rdx
callq 0xbca0
testq %rax, %rax
je 0x99f0
movq %rax, %rdi
callq 0xbbfa
movq %r15, %rdi
movq %rax, %rsi
callq 0x6655
jmp 0x9a08
movq %rbx, %rdi
callq 0xbc07
movq %r15, %rdi
movq %rax, %rsi
xorl %edx, %edx
movq %r14, %rcx
callq 0xb7fc
movq %rbx, %rdi
callq 0xbc13
movq %rax, %rbx
testq %rax, %rax
jne 0x99b9
movq (%rsp), %rax
jmp 0x9a20
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O3/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
movq $0x0, 0x8(%rsp)
callq 0xbbcb
testq %rax, %rax
je 0x9ab4
movq %rax, %r14
leaq -0x5c1f(%rip), %r15     # 0x3e3a
leaq 0x8(%rsp), %r12
movq %r14, %rdi
callq 0xbc07
movq %rbx, %rdi
movq %rax, %rsi
movq %r15, %rdx
callq 0xbca0
testq %rax, %rax
je 0x9a9d
movq %r14, %rdi
callq 0xbc07
movq %rax, %r13
movq %r14, %rdi
callq 0xbc07
movq %r12, %rdi
movq %r13, %rsi
movq %rax, %rdx
movq %r15, %rcx
callq 0xb7fc
movq %r14, %rdi
callq 0xbc13
movq %rax, %r14
testq %rax, %rax
jne 0x9a5e
movq 0x8(%rsp), %rax
jmp 0x9ab6
xorl %eax, %eax
addq $0x10, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O3/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:
testq %rdi, %rdi
je 0xbc61
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq %rdi, %r14
movq 0x10(%r14), %rdi
movq %rbx, %rsi
callq 0xbc2d
movq (%r14), %rdi
movq 0x8(%r14), %rsi
callq *%rbx
movq 0x18(%r14), %r14
testq %r14, %r14
jne 0xbc3c
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O3/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:
testq %rdi, %rdi
je 0xbc9f
pushq %r15
pushq %r14
pushq %rbx
movq %rdx, %rbx
movq %rsi, %r14
movq %rdi, %r15
movq 0x10(%r15), %rdi
movq %r14, %rsi
movq %rbx, %rdx
callq 0xbc62
movq (%r15), %rdi
movq 0x8(%r15), %rsi
movq %rbx, %rdx
callq *%r14
movq 0x18(%r15), %r15
testq %r15, %r15
jne 0xbc75
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O3/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
testq %rdi, %rdi
je 0xbcd5
movq %rdx, %r14
movq %rsi, %r15
movq %rdi, %rbx
movq (%rbx), %rdi
movq %r15, %rsi
callq *%r14
testl %eax, %eax
je 0xbcd7
movl %eax, %ecx
shrl $0x1f, %ecx
movq 0x10(%rbx,%rcx,8), %rbx
testl %eax, %eax
je 0xbcd7
testq %rbx, %rbx
jne 0xbcb3
jmp 0xbcd7
xorl %ebx, %ebx
movq %rbx, %rax
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O3/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
testq %rdi, %rdi
je 0xbd20
movq %rdx, %r14
movq %rsi, %r12
movq %rdi, %r15
xorl %ebx, %ebx
movq (%r15), %rdi
movq %r12, %rsi
callq *%r14
testl %eax, %eax
je 0xbd24
movl %eax, %ecx
shrl $0x1f, %ecx
testl %eax, %eax
cmovnsq %r15, %rbx
movq 0x10(%r15,%rcx,8), %r15
testq %r15, %r15
je 0xbd27
testl %eax, %eax
jne 0xbcf8
jmp 0xbd27
xorl %ebx, %ebx
jmp 0xbd27
movq %r15, %rbx
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O3/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 0xbd8a
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %r14
movq %rdi, %rbx
movq 0x10(%rdi), %rdi
callq 0xbd36
testq %r14, %r14
je 0xbd66
movq (%rbx), %rdi
movq 0x8(%rbx), %rsi
callq *%r14
movq 0x18(%rbx), %rdi
movq %r14, %rsi
jmp 0xbd6c
movq 0x18(%rbx), %rdi
xorl %esi, %esi
callq 0xbd36
movq 0xfeb8(%rip), %rax      # 0x1bc30
movq %rax, 0x10(%rbx)
movq %rbx, 0xfead(%rip)      # 0x1bc30
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O3/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 0xbdf8
movq %rsi, %r14
movq %rdi, %r15
movq 0x10(%rdi), %rdi
callq 0xbdb6
movq %rax, %r12
movq 0x18(%r15), %rdi
movq %r14, %rsi
callq 0xbdb6
movq %rax, %rbx
addq %r12, %rbx
testq %r14, %r14
je 0xbdfc
movq (%r15), %rdi
movq 0x8(%r15), %rsi
callq *%r14
jmp 0xbe01
xorl %ebx, %ebx
jmp 0xbe04
movl $0x1, %eax
addq %rax, %rbx
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O3/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 0xbfba
movq %rdx, %r12
movq %rsi, %r15
movq %rdi, %r14
movq 0xfc88(%rip), %rbx      # 0x1bc30
testq %rbx, %rbx
je 0xbfc1
movq 0x10(%rbx), %rax
movq %rax, 0xfc78(%rip)      # 0x1bc30
jmp 0xbfd7
xorl %ebx, %ebx
jmp 0xc046
movl $0x38, %edi
callq 0xc2f0
movq %rax, %rbx
testq %rax, %rax
je 0xc06c
movq (%r14), %rax
testq %r15, %r15
je 0xbfe5
movq %rax, %rdi
callq *%r15
movq %rax, (%rbx)
movq 0x8(%r14), %rdi
testq %r12, %r12
je 0xc017
callq *%r12
movq %rax, 0x8(%rbx)
movq 0x10(%r14), %rdi
movq %r15, %rsi
movq %r12, %rdx
callq 0xbf8b
movq %rax, 0x10(%rbx)
movq 0x18(%r14), %rdi
movq %r15, %rsi
movq %r12, %rdx
jmp 0xc036
movq %rdi, 0x8(%rbx)
movq 0x10(%r14), %rdi
movq %r15, %rsi
xorl %edx, %edx
callq 0xbf8b
movq %rax, 0x10(%rbx)
movq 0x18(%r14), %rdi
movq %r15, %rsi
xorl %edx, %edx
callq 0xbf8b
movq %rax, 0x18(%rbx)
movl 0x30(%r14), %eax
movl %eax, 0x30(%rbx)
movq %rbx, %rdi
xorl %esi, %esi
callq 0xc071
testq %rax, %rax
je 0xc05d
movq $0x0, 0x20(%rax)
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
callq 0x3953
// File: /workspace/github_c_makefile_star2_O3/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 0xc09e
movq %rdi, %rbx
movq 0x10(%rdi), %rdi
callq 0xc071
movq %rax, 0x28(%rbx)
testq %rax, %rax
je 0xc090
movq %rbx, 0x20(%rax)
movq 0x18(%rbx), %rdi
movq %rbx, %rsi
testq %rdi, %rdi
jne 0xc077
jmp 0xc0a1
movq %rsi, %rbx
movq %rbx, %rax
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O3/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 0xc0c2
callq 0xc0a6
movq %rax, 0x18(%rbx)
movq %rbx, %rdi
popq %rbx
jmp 0xc0f0
movq %rbx, (%rsi)
movq 0x10(%rbx), %rax
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O3/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 0xc0e7
callq 0xc0cb
movq %rax, 0x10(%rbx)
movq %rbx, %rdi
popq %rbx
jmp 0xc0f0
movq %rbx, (%rsi)
movq 0x18(%rbx), %rax
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O3/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 0xf892(%rip), %rax      # 0x1bc50
testq %rax, %rax
je 0xc3cb
movl 0x4(%rax), %ecx
cmpl $0x3f, %ecx
ja 0xc3ee
callq 0xc470
testq %rax, %rax
je 0xc46b
movq 0xf870(%rip), %rcx      # 0x1bc50
movq %rcx, 0x10(%rax)
movq %rax, 0xf865(%rip)      # 0x1bc50
movl 0x4(%rax), %ecx
movq 0xf863(%rip), %rdx      # 0x1bc58
movq 0x8(%rax), %rsi
movq %rdx, (%rsi)
movq 0x8(%rax), %rdx
leaq 0x8(%rdx), %rsi
movq %rsi, 0x8(%rax)
movq 0xf851(%rip), %rsi      # 0x1bc60
movq %rsi, 0x8(%rdx)
movq 0x8(%rax), %rdi
addl $-0x10, %ecx
movl %ecx, 0x4(%rax)
movl %ecx, 0x8(%rdi)
leaq 0xc(%rdi), %rcx
movq %rcx, 0x8(%rax)
movl 0x4(%rax), %edx
addl $-0x4, %edx
addq $0xf, %rdi
testq %rcx, %rcx
cmovnsq %rcx, %rdi
movl %edx, 0x4(%rax)
andq $-0x4, %rdi
movq %rcx, %rsi
subq %rdi, %rsi
je 0xc45b
movl $0x4, %edi
subl %esi, %edi
subl %edi, %edx
movl %edx, 0x4(%rax)
addq %rdi, %rcx
movq %rcx, 0x8(%rax)
movq %rcx, 0xf7fe(%rip)      # 0x1bc60
movq %rax, 0xf7ef(%rip)      # 0x1bc58
popq %rax
retq
callq 0x3968
// File: /workspace/github_c_makefile_star2_O3/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 0xf7f0(%rip), %rax      # 0x1bc68
testq %rax, %rax
je 0xc48c
movq 0x10(%rax), %rcx
movq %rcx, 0xf7e0(%rip)      # 0x1bc68
movl (%rax), %ebx
jmp 0xc4af
movq 0xf7ad(%rip), %rax      # 0x1bc40
leaq -0x1(%rax), %rcx
cmpq $0x7fff, %rcx           # imm = 0x7FFF
movl $0x8000, %ebx           # imm = 0x8000
cmovbl %eax, %ebx
movl %ebx, %edi
callq 0xc2f0
movl %ebx, (%rax)
addl $-0x18, %ebx
movl %ebx, 0x4(%rax)
leaq 0x18(%rax), %rcx
leaq 0x1b(%rax), %rsi
testq %rcx, %rcx
cmovnsq %rcx, %rsi
movq %rcx, 0x8(%rax)
andq $-0x4, %rsi
movq %rcx, %rdx
subq %rsi, %rdx
je 0xc4e7
movl $0x4, %esi
subl %edx, %esi
subl %esi, %ebx
movl %ebx, 0x4(%rax)
addq %rsi, %rcx
movq %rcx, 0x8(%rax)
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O3/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 0xf713(%rip), %rcx      # 0x1bc58
movq 0xf704(%rip), %rax      # 0x1bc50
cmpq %rcx, %rax
je 0xc579
movq 0xf710(%rip), %rdx      # 0x1bc68
movq %rdx, %rsi
movq %rax, %rdx
movq 0x10(%rax), %rax
movq %rsi, 0x10(%rdx)
cmpq %rcx, %rax
jne 0xc558
movq %rdx, 0xf6f6(%rip)      # 0x1bc68
movq %rax, 0xf6d7(%rip)      # 0x1bc50
movq 0xf6e0(%rip), %rdi      # 0x1bc60
movl 0x4(%rax), %edx
addl $0x4, %edx
leaq -0x4(%rdi), %rcx
decq %rdi
testq %rcx, %rcx
cmovnsq %rcx, %rdi
movl %edx, 0x4(%rax)
andq $-0x4, %rdi
movq %rcx, %rsi
subq %rdi, %rsi
je 0xc5ab
addl %esi, %edx
movl %edx, 0x4(%rax)
addq %rsi, %rcx
movl (%rcx), %edx
leaq -0x8(%rcx), %rsi
movq %rsi, 0x8(%rax)
movq -0x8(%rcx), %rsi
movq %rsi, 0xf6a0(%rip)      # 0x1bc60
addl $0x10, %edx
movl %edx, 0x4(%rax)
leaq -0x10(%rcx), %rdx
movq %rdx, 0x8(%rax)
movq -0x10(%rcx), %rax
movq %rax, 0xf67f(%rip)      # 0x1bc58
retq
nop
// File: /workspace/github_c_makefile_star2_O3/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 0xc3b6
movl $0x60, %edi
callq 0xc4e9
testq %rax, %rax
je 0xc6a3
movq 0xf6bc(%rip), %rcx      # 0x1bcb8
movq %rcx, (%rax)
movq 0xf6ba(%rip), %rcx      # 0x1bcc0
movq %rcx, 0x8(%rax)
movq 0xf6b7(%rip), %rcx      # 0x1bcc8
movq %rcx, 0x10(%rax)
movq 0xf654(%rip), %rcx      # 0x1bc70
movq %rcx, 0x18(%rax)
movq 0xf671(%rip), %rdx      # 0x1bc98
movq %rdx, 0x38(%rax)
movq 0xf646(%rip), %rdx      # 0x1bc78
movq %rdx, 0x20(%rax)
movq 0xf643(%rip), %rdx      # 0x1bc80
movq %rdx, 0x28(%rax)
movq 0xf640(%rip), %rdx      # 0x1bc88
movq %rdx, 0x30(%rax)
movq 0xf65d(%rip), %rdx      # 0x1bcb0
movq %rdx, 0x50(%rax)
movq 0xf64a(%rip), %rdx      # 0x1bca8
movq %rdx, 0x48(%rax)
movq 0xf637(%rip), %rdx      # 0x1bca0
movq %rdx, 0x40(%rax)
movq 0xf65c(%rip), %rdx      # 0x1bcd0
movq %rdx, 0x58(%rax)
movq %rax, 0xf651(%rip)      # 0x1bcd0
xorl %eax, %eax
movq %rax, 0xf630(%rip)      # 0x1bcb8
movq %rax, 0xf631(%rip)      # 0x1bcc0
movq %rax, 0xf632(%rip)      # 0x1bcc8
addq $0x60, %rcx
movq %rcx, 0xf5cf(%rip)      # 0x1bc70
popq %rax
retq
leaq 0x6800(%rip), %rdi      # 0x12eaa
callq 0x39b2
movl $0x1, %edi
callq 0x3200
// File: /workspace/github_c_makefile_star2_O3/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 0xf610(%rip), %rax      # 0x1bcd0
testq %rax, %rax
je 0xc751
movq (%rax), %rcx
movq %rcx, 0xf5e5(%rip)      # 0x1bcb8
movq 0x8(%rax), %rcx
movq %rcx, 0xf5e2(%rip)      # 0x1bcc0
movq 0x10(%rax), %rcx
movq %rcx, 0xf5df(%rip)      # 0x1bcc8
movq 0x18(%rax), %rcx
movq %rcx, 0xf57c(%rip)      # 0x1bc70
movq 0x20(%rax), %rcx
movq %rcx, 0xf579(%rip)      # 0x1bc78
movq 0x28(%rax), %rcx
movq %rcx, 0xf576(%rip)      # 0x1bc80
movq 0x30(%rax), %rcx
movq %rcx, 0xf573(%rip)      # 0x1bc88
movq 0x38(%rax), %rcx
movq %rcx, 0xf578(%rip)      # 0x1bc98
movq 0x50(%rax), %rcx
movq %rcx, 0xf585(%rip)      # 0x1bcb0
movq 0x48(%rax), %rcx
movq %rcx, 0xf572(%rip)      # 0x1bca8
movq 0x40(%rax), %rcx
movq %rcx, 0xf55f(%rip)      # 0x1bca0
movq 0x58(%rax), %rax
movq %rax, 0xf584(%rip)      # 0x1bcd0
jmp 0xc53e
pushq %rax
callq 0x3a2f
// File: /workspace/github_c_makefile_star2_O3/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 0xf52e(%rip), %rax      # 0x1bcb8
testq %rax, %rax
je 0xc7ab
movq 0x18(%rax), %rcx
decq 0xf506(%rip)            # 0x1bca0
movq %rcx, 0xf517(%rip)      # 0x1bcb8
addq $-0x30, 0xf4ef(%rip)    # 0x1bc98
jmp 0xc7c9
movl $0x30, %edi
callq 0xc4e9
addq $0x30, 0xf4b3(%rip)     # 0x1bc70
incq 0xf4c4(%rip)            # 0x1bc88
testq %rax, %rax
je 0xc809
movq %r15, (%rax)
movq %r14, 0x8(%rax)
movq %rbx, 0x10(%rax)
movslq 0xf501(%rip), %rcx      # 0x1bcdc
leal 0x1(%rcx), %edx
movl %edx, 0xf4f8(%rip)      # 0x1bcdc
movq %rcx, 0x28(%rax)
movq $0x0, 0x20(%rax)
movq 0xf4e9(%rip), %rcx      # 0x1bce0
movq 0x18(%rcx), %rdx
movq %rdx, 0x18(%rax)
movq %rax, 0x18(%rcx)
popq %rbx
popq %r14
popq %r15
retq
callq 0x3a54
// File: /workspace/github_c_makefile_star2_O3/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 0xf49f(%rip), %rax      # 0x1bcc0
testq %rax, %rax
je 0xc842
movq 0x10(%rax), %rcx
decq 0xf47f(%rip)            # 0x1bcb0
movq %rcx, 0xf488(%rip)      # 0x1bcc0
addq $-0x18, 0xf458(%rip)    # 0x1bc98
jmp 0xc860
movl $0x18, %edi
callq 0xc4e9
addq $0x18, 0xf41c(%rip)     # 0x1bc70
incq 0xf41d(%rip)            # 0x1bc78
testq %rax, %rax
je 0xc86f
movl %ebp, (%rax)
movq %r14, 0x8(%rax)
movq %rbx, 0x10(%rax)
popq %rbx
popq %r14
popq %rbp
retq
callq 0x3a69
// File: /workspace/github_c_makefile_star2_O3/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 0xf443(%rip), %rax      # 0x1bcc8
testq %rax, %rax
je 0xc8a6
movq 0x8(%rax), %rcx
decq 0xf413(%rip)            # 0x1bca8
movq %rcx, 0xf42c(%rip)      # 0x1bcc8
addq $-0x10, 0xf3f4(%rip)    # 0x1bc98
jmp 0xc8c4
movl $0x10, %edi
callq 0xc4e9
addq $0x10, 0xf3b8(%rip)     # 0x1bc70
incq 0xf3c1(%rip)            # 0x1bc80
testq %rax, %rax
je 0xc8d3
movq %r14, (%rax)
movq %rbx, 0x8(%rax)
addq $0x8, %rsp
popq %rbx
popq %r14
retq
callq 0x3a7e
// File: /workspace/github_c_makefile_star2_O3/theovosse[P]llgen/regexp.c
// Function: RemoveSet
void RemoveSet(ESet set) {
	ESet aux;

	while (set != NULL) {
		aux = set->next;
		FreeSet(set);
		set = aux;
	}
}

// Assembly:
testq %rdi, %rdi
je 0xc921
movq 0xf3b4(%rip), %rax      # 0x1bc98
movq 0xf3bd(%rip), %rcx      # 0x1bca8
movq 0xf3d6(%rip), %rdx      # 0x1bcc8
movq %rdx, %rsi
movq %rdi, %rdx
movq 0x8(%rdi), %rdi
movq %rsi, 0x8(%rdx)
incq %rcx
addq $0x10, %rax
testq %rdi, %rdi
jne 0xc8f2
movq %rdx, 0xf3b5(%rip)      # 0x1bcc8
movq %rcx, 0xf38e(%rip)      # 0x1bca8
movq %rax, 0xf377(%rip)      # 0x1bc98
retq
// File: /workspace/github_c_makefile_star2_O3/theovosse[P]llgen/regexp.c
// Function: SetMember
Boolean SetMember(void *element, ESet set) {
	while (set != NULL) {
		if (set->element == element) {
			return (true);
		}
		set = set->next;
	}
	return (false);
}

// Assembly:
testq %rsi, %rsi
je 0xc947
cmpq %rdi, (%rsi)
je 0xc94a
movq 0x8(%rsi), %rsi
jmp 0xc937
xorl %eax, %eax
retq
movw $0xffff, %ax            # imm = 0xFFFF
retq
// File: /workspace/github_c_makefile_star2_O3/theovosse[P]llgen/regexp.c
// Function: SubSet
Boolean SubSet(ESet s1, ESet s2) {
	ESet s;

	while (s1 != NULL) {
		for (s = s2; s != NULL; s = s->next) if (s->element == s1->element) break;
		if (s == NULL) return (false);
		s1 = s1->next;
	}
	return (true);
}

// Assembly:
movw $0xffff, %ax            # imm = 0xFFFF
testq %rdi, %rdi
je 0xc980
testq %rsi, %rsi
je 0xc97e
movq (%rdi), %rcx
movq %rsi, %rdx
cmpq %rcx, (%rdx)
je 0xc973
movq 0x8(%rdx), %rdx
testq %rdx, %rdx
jne 0xc963
jmp 0xc97e
movq 0x8(%rdi), %rdi
testq %rdi, %rdi
jne 0xc95d
jmp 0xc980
xorl %eax, %eax
retq
// File: /workspace/github_c_makefile_star2_O3/theovosse[P]llgen/regexp.c
// Function: MakeAnswer
Answer MakeAnswer(int number, void *info) {
	Answer answer = (Answer) temp_malloc(sizeof(struct Answer));

	if (answer == NULL) {
		OutOfMemory("MakeAnswer");
		exit(1);
	}
	totalMalloc += sizeof(struct Answer);
	answer->number = number;
	answer->info = info;
	return (answer);
}

// Assembly:
pushq %rbp
pushq %rbx
pushq %rax
movq %rsi, %rbx
movl %edi, %ebp
movl $0x10, %edi
callq 0xc4e9
testq %rax, %rax
je 0xca0c
addq $0x10, 0xf271(%rip)     # 0x1bc70
movl %ebp, (%rax)
movq %rbx, 0x8(%rax)
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
callq 0x3a93
// File: /workspace/github_c_makefile_star2_O3/theovosse[P]llgen/regexp.c
// Function: CountNrStates
void CountNrStates(RegExp regExp) {
	Transition tr;

	if (regExp == NULL || regExp->lastVisit == lastVisit) {
		return;
	}
	regExp->lastVisit = lastVisit;
	if (state != NULL) {
		state[regExp->state.number] = regExp;
	} else {
		regExp->state.number = globStateNr++;
	}
	for (tr = regExp->eTransitions; tr != NULL; tr = tr->next) {
		CountNrStates(tr->destination);
	}
	for (tr = regExp->transitions; tr != NULL; tr = tr->next) {
		CountNrStates(tr->destination);
	}
}

// Assembly:
testq %rdi, %rdi
je 0xca31
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
movq 0xf2c4(%rip), %rax      # 0x1bce8
cmpq %rax, 0x20(%rdi)
jne 0xca32
addq $0x8, %rsp
popq %rbx
popq %r14
retq
movq %rax, 0x20(%rbx)
movq 0xf2b3(%rip), %rax      # 0x1bcf0
testq %rax, %rax
je 0xca4c
movq 0x28(%rbx), %rcx
movq %rbx, (%rax,%rcx,8)
jmp 0xca60
movslq 0xf2a5(%rip), %rax      # 0x1bcf8
leal 0x1(%rax), %ecx
movl %ecx, 0xf29c(%rip)      # 0x1bcf8
movq %rax, 0x28(%rbx)
movq 0x8(%rbx), %r14
testq %r14, %r14
je 0xca78
movq 0x8(%r14), %rdi
callq 0xca11
movq 0x10(%r14), %r14
jmp 0xca64
movq (%rbx), %rbx
testq %rbx, %rbx
je 0xca2a
movq 0x8(%rbx), %rdi
callq 0xca11
movq 0x10(%rbx), %rbx
jmp 0xca7b
// File: /workspace/github_c_makefile_star2_O3/theovosse[P]llgen/regexp.c
// Function: InitRegExp
RegExp InitRegExp(void) {
	RegExp regExp = (RegExp) temp_malloc(sizeof(struct RegExp));

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

// Assembly:
pushq %rax
movl $0x30, %edi
callq 0xc4e9
addq $0x30, 0xf1ce(%rip)     # 0x1bc70
incq 0xf1df(%rip)            # 0x1bc88
testq %rax, %rax
je 0xcad6
xorps %xmm0, %xmm0
movups %xmm0, (%rax)
movq $0x0, 0x10(%rax)
movslq 0xf219(%rip), %rcx      # 0x1bcdc
leal 0x1(%rcx), %edx
movl %edx, 0xf210(%rip)      # 0x1bcdc
movq %rcx, 0x28(%rax)
movups %xmm0, 0x18(%rax)
popq %rcx
retq
callq 0x3aa8
// File: /workspace/github_c_makefile_star2_O3/theovosse[P]llgen/regexp.c
// Function: AddRegExp
int AddRegExp(RegExp regExp, char *pattern, void *info) {
	RegExp end = NULL;
	char *rest;
	RegExp newRe;
	Answer answer;
	static int number = 0;

	currentAutomaton = regExp;
	answer = MakeAnswer(number++, info);
	newRe = MakeRegExp(NULL, NULL, NULL);
	ELink(regExp, newRe);
	errorInExpression = 0;
	rest = choice(newRe, pattern, &end);
    if (errorInExpression != 0) {
        return errorInExpression;
    }
	end->info = AddElement(answer, NULL); /* An NFA has 1 info per final state */
	if (*rest != '\0') {
		if (errorInExpression == 0) errorInExpression = 4; /* End of expression expected */
	}
	return (errorInExpression);
}

// Assembly:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x10, %rsp
movq %rsi, %r14
movq %rdi, %r12
leaq 0x8(%rsp), %r15
movq $0x0, (%r15)
movq %rdi, 0xf1df(%rip)      # 0x1bce0
movl 0xf1f5(%rip), %edi      # 0x1bcfc
leal 0x1(%rdi), %eax
movl %eax, 0xf1ec(%rip)      # 0x1bcfc
movq %rdx, %rsi
callq 0xc9e0
movq %rax, %rbx
xorl %edi, %edi
xorl %esi, %esi
xorl %edx, %edx
callq 0xc775
movq %rax, %r13
movq 0x8(%r12), %rdx
xorl %edi, %edi
movq %rax, %rsi
callq 0xc80e
movq %rax, 0x8(%r12)
movl $0x0, 0xf1b9(%rip)      # 0x1bd00
movq %r13, %rdi
movq %r14, %rsi
movq %r15, %rdx
callq 0xcbab
movq %rax, %r14
movl 0xf1a2(%rip), %eax      # 0x1bd00
testl %eax, %eax
jne 0xcb9d
movq %rbx, %rdi
xorl %esi, %esi
callq 0xc874
movq 0x8(%rsp), %rcx
movq %rax, 0x10(%rcx)
cmpb $0x0, (%r14)
setne %cl
movl 0xf17e(%rip), %eax      # 0x1bd00
testl %eax, %eax
sete %dl
andb %cl, %dl
cmpb $0x1, %dl
jne 0xcb9d
movl $0x4, 0xf168(%rip)      # 0x1bd00
movl $0x4, %eax
addq $0x10, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq