LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O0/theovosse[P]llgen/llgen.c
// Function: DefineProcs
static void DefineProcs(void) {
	TREE sym;
	Name name;

	for (sym = GetFirstNode(idTree); sym != NULL; sym = GetNextNode(sym)) {
		name = GetKey(sym);
		if (name->nameType == identifier) {
			RuleResult res = name->ruleResult;
			Name returnType = res == NULL? NULL: res->returnType;
			if (HasProperty("line")) {
				fprintf(outputFile, "#line %d \"%s\"\n", name->lineNr, inputFileName);
			}
            openFunctionDeclaration(outputFile, name->name, name->arglist, returnType);
            targetLanguage->parameterDeclarationName(outputFile, "follow", 0);
            targetLanguage->nextDeclarationParameterSymbol(outputFile, llTokenSetTypeString, 1);
            closeFunctionDeclaration(outputFile);
            fprintf(outputFile, "%s\n", targetLanguage->terminateStatement);
		}
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq 0x1a4a1(%rip), %rdi     # 0x20d50
callq 0x10330
movq %rax, -0x8(%rbp)
cmpq $0x0, -0x8(%rbp)
je 0x69e7
movq -0x8(%rbp), %rdi
callq 0x10400
movq %rax, -0x10(%rbp)
movq -0x10(%rbp), %rax
cmpl $0x0, 0x38(%rax)
jne 0x69d3
movq -0x10(%rbp), %rax
movq 0x50(%rax), %rax
movq %rax, -0x18(%rbp)
cmpq $0x0, -0x18(%rbp)
jne 0x68f9
xorl %eax, %eax
movq %rax, -0x28(%rbp)
jmp 0x6905
movq -0x18(%rbp), %rax
movq 0x8(%rax), %rax
movq %rax, -0x28(%rbp)
movq -0x28(%rbp), %rax
movq %rax, -0x20(%rbp)
leaq 0x12b83(%rip), %rdi     # 0x19497
callq 0x4940
cmpw $0x0, %ax
je 0x6942
movq 0x1a412(%rip), %rdi     # 0x20d38
movq -0x10(%rbp), %rax
movl 0x20(%rax), %edx
movq 0x19844(%rip), %rcx     # 0x20178
leaq 0x12b61(%rip), %rsi     # 0x1949c
movb $0x0, %al
callq 0x3140
movq 0x1a3ef(%rip), %rdi     # 0x20d38
movq -0x10(%rbp), %rax
movq (%rax), %rsi
movq -0x10(%rbp), %rax
movq 0x40(%rax), %rdx
movq -0x20(%rbp), %rcx
callq 0x87d0
movq 0x19808(%rip), %rax     # 0x20170
movq 0x118(%rax), %rax
movq 0x1a3c2(%rip), %rdi     # 0x20d38
leaq 0x13425(%rip), %rsi     # 0x19da2
xorl %edx, %edx
callq *%rax
movq 0x197e8(%rip), %rax     # 0x20170
movq 0x120(%rax), %rax
movq 0x1a3a2(%rip), %rdi     # 0x20d38
leaq 0x19783(%rip), %rsi     # 0x20120
movl $0x1, %edx
callq *%rax
movq 0x1a38d(%rip), %rdi     # 0x20d38
callq 0x8990
movq 0x1a381(%rip), %rdi     # 0x20d38
movq 0x197b2(%rip), %rax     # 0x20170
movq 0x80(%rax), %rdx
leaq 0x12ee9(%rip), %rsi     # 0x198b5
movb $0x0, %al
callq 0x3140
jmp 0x69d5
movq -0x8(%rbp), %rdi
callq 0x10430
movq %rax, -0x8(%rbp)
jmp 0x68b8
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/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
movq %rsp, %rbp
subq $0x120, %rsp            # imm = 0x120
movq $0x0, -0x18(%rbp)
leaq 0x11d93(%rip), %rdi     # 0x1975d
callq 0x4940
cmpw $0x0, %ax
jne 0x79e1
leaq 0x1b514(%rip), %rax     # 0x22ef0
movw $0xffff, (%rax)         # imm = 0xFFFF
callq 0x11760
callq 0x120c0
movq %rax, -0x18(%rbp)
xorl %edi, %edi
callq 0x11a80
leaq 0x11d6a(%rip), %rdi     # 0x19767
callq 0x4940
cmpw $0x0, %ax
je 0x7a14
movl $0x100, %edi            # imm = 0x100
callq 0x11a50
jmp 0x7a1e
movl $0x80, %edi
callq 0x11a50
movq 0x1932b(%rip), %rdi     # 0x20d50
callq 0x10330
movq %rax, -0x8(%rbp)
cmpq $0x0, -0x8(%rbp)
je 0x7af7
movq -0x8(%rbp), %rdi
callq 0x10400
movq %rax, -0x10(%rbp)
movq -0x10(%rbp), %rax
cmpl $0x1, 0x38(%rax)
jne 0x7ae3
movq -0x10(%rbp), %rax
cmpq $0x0, 0x28(%rax)
je 0x7ae3
movq -0x10(%rbp), %rax
movswl 0x34(%rax), %eax
cmpl $0x0, %eax
je 0x7ae3
leaq -0x120(%rbp), %rdi
movq -0x10(%rbp), %rax
movq (%rax), %rsi
callq 0x8c90
movq -0x18(%rbp), %rdi
leaq -0x120(%rbp), %rsi
movq -0x10(%rbp), %rax
movq 0x28(%rax), %rdx
callq 0x12180
movl %eax, -0x1c(%rbp)
cmpl $0x0, %eax
je 0x7ae1
movq 0x1854e(%rip), %rax     # 0x1fff8
movq (%rax), %rdi
movq 0x186c4(%rip), %rdx     # 0x20178
movq -0x10(%rbp), %rax
movl 0x20(%rax), %ecx
movslq -0x1c(%rbp), %rsi
leaq 0x186ca(%rip), %rax     # 0x20190
movq (%rax,%rsi,8), %r8
leaq 0x11ca1(%rip), %rsi     # 0x19772
movb $0x0, %al
callq 0x3140
movw $0xffff, 0x19289(%rip)  # imm = 0xFFFF
jmp 0x7ae3
jmp 0x7ae5
movq -0x8(%rbp), %rdi
callq 0x10430
movq %rax, -0x8(%rbp)
jmp 0x7a2e
movq -0x18(%rbp), %rdi
callq 0x13400
movq %rax, 0x19281(%rip)     # 0x20d88
movq 0x1927a(%rip), %rdi     # 0x20d88
callq 0x13980
addq $0x120, %rsp            # imm = 0x120
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/theovosse[P]llgen/llgen.c
// Function: FormatTokenSets
static void FormatTokenSets(FILE *f, RegExp dfa) {
	RegExp regExp;

	for (regExp = dfa; regExp != NULL; regExp = regExp->next) {
		if (regExp->info != NULL) {
			CreateTokenSet(f, regExp->info);
		}
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x18(%rbp)
cmpq $0x0, -0x18(%rbp)
je 0x7b6b
movq -0x18(%rbp), %rax
cmpq $0x0, 0x10(%rax)
je 0x7b5b
movq -0x8(%rbp), %rdi
movq -0x18(%rbp), %rax
movq 0x10(%rax), %rsi
callq 0x8e00
jmp 0x7b5d
movq -0x18(%rbp), %rax
movq 0x18(%rax), %rax
movq %rax, -0x18(%rbp)
jmp 0x7b38
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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
movq %rsp, %rbp
subq $0x10, %rsp
movq 0x191a9(%rip), %rdi     # 0x20d38
movq 0x185da(%rip), %rax     # 0x20170
movq 0x48(%rax), %rdx
movl 0x191b7(%rip), %r9d     # 0x20d58
addl $0x2, %r9d
leaq 0x11aea(%rip), %rsi     # 0x19696
leaq 0x11c9d(%rip), %rcx     # 0x19850
movq $-0x1, %r8
callq 0x89c0
movq 0x19172(%rip), %rsi     # 0x20d38
leaq 0x11c8d(%rip), %rdi     # 0x1985a
callq 0x3100
movl $0x1, -0xc(%rbp)
movl -0xc(%rbp), %eax
cmpl 0x19176(%rip), %eax     # 0x20d58
jg 0x7c7c
movl -0xc(%rbp), %edi
movl $0xffffffff, %esi       # imm = 0xFFFFFFFF
callq 0x9110
movq %rax, -0x8(%rbp)
cmpq $0x0, -0x8(%rbp)
je 0x7c28
movq -0x8(%rbp), %rax
cmpl $0x4, 0x38(%rax)
jne 0x7c28
movq 0x19127(%rip), %rdi     # 0x20d38
movq -0x8(%rbp), %rax
movq (%rax), %rdx
leaq 0x11c48(%rip), %rsi     # 0x19867
movb $0x0, %al
callq 0x3140
jmp 0x7c6c
cmpq $0x0, -0x8(%rbp)
je 0x7c57
movq -0x8(%rbp), %rax
cmpl $0x1, 0x38(%rax)
jne 0x7c57
movq 0x190f8(%rip), %rdi     # 0x20d38
movq -0x8(%rbp), %rax
movq (%rax), %rdx
leaq 0x11c21(%rip), %rsi     # 0x1986f
movb $0x0, %al
callq 0x3140
jmp 0x7c6a
movq 0x190da(%rip), %rsi     # 0x20d38
leaq 0x11c10(%rip), %rdi     # 0x19875
callq 0x3100
jmp 0x7c6c
jmp 0x7c6e
movl -0xc(%rbp), %eax
addl $0x1, %eax
movl %eax, -0xc(%rbp)
jmp 0x7bd9
movq 0x190b5(%rip), %rsi     # 0x20d38
leaq 0x11bf8(%rip), %rdi     # 0x19882
callq 0x3100
movq 0x190a2(%rip), %rdi     # 0x20d38
movq 0x184d3(%rip), %rax     # 0x20170
movq 0x70(%rax), %rdx
movq 0x184c8(%rip), %rax     # 0x20170
movq 0x78(%rax), %rcx
leaq 0x11a10(%rip), %rsi     # 0x196c3
movb $0x0, %al
callq 0x3140
addq $0x10, %rsp
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O0/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 %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
cmpq $0x0, -0x8(%rbp)
je 0x8b03
movq -0x8(%rbp), %rax
cmpq $0x0, 0x10(%rax)
je 0x8b03
movq 0x182cb(%rip), %rdi     # 0x20db0
movq -0x8(%rbp), %rax
movq 0x10(%rax), %rsi
leaq 0xbc(%rip), %rdx        # 0x8bb0
callq 0x10560
movq %rax, -0x10(%rbp)
cmpq $0x0, %rax
jne 0x8b1c
movq 0x17666(%rip), %rax     # 0x20170
movq 0x40(%rax), %rsi
leaq 0x1828b(%rip), %rdi     # 0x20da0
callq 0x3080
jmp 0x8b3c
movq -0x10(%rbp), %rdi
callq 0x103d0
movl %eax, %edx
leaq 0x18272(%rip), %rdi     # 0x20da0
leaq 0x10c1b(%rip), %rsi     # 0x19750
movb $0x0, %al
callq 0x31d0
leaq 0x1825d(%rip), %rax     # 0x20da0
addq $0x10, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/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 %rbp
movq %rsp, %rbp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x20(%rbp)
movq -0x18(%rbp), %rax
movq %rax, -0x28(%rbp)
xorl %eax, %eax
cmpq $0x0, -0x20(%rbp)
movb %al, -0x39(%rbp)
je 0x8be3
cmpq $0x0, -0x28(%rbp)
setne %al
movb %al, -0x39(%rbp)
movb -0x39(%rbp), %al
testb $0x1, %al
jne 0x8bec
jmp 0x8c57
movq -0x20(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x30(%rbp)
movq -0x28(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x38(%rbp)
movq -0x30(%rbp), %rax
movq 0x8(%rax), %rax
movq -0x38(%rbp), %rcx
cmpq 0x8(%rcx), %rax
jbe 0x8c1d
movl $0x1, -0x4(%rbp)
jmp 0x8c83
movq -0x30(%rbp), %rax
movq 0x8(%rax), %rax
movq -0x38(%rbp), %rcx
cmpq 0x8(%rcx), %rax
jae 0x8c38
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
jmp 0x8c83
jmp 0x8c3a
movq -0x20(%rbp), %rax
movq 0x8(%rax), %rax
movq %rax, -0x20(%rbp)
movq -0x28(%rbp), %rax
movq 0x8(%rax), %rax
movq %rax, -0x28(%rbp)
jmp 0x8bcc
cmpq $0x0, -0x20(%rbp)
je 0x8c68
movl $0x1, %eax
movl %eax, -0x40(%rbp)
jmp 0x8c7d
movq -0x28(%rbp), %rdx
xorl %eax, %eax
movl $0xffffffff, %ecx       # imm = 0xFFFFFFFF
cmpq $0x0, %rdx
cmovnel %ecx, %eax
movl %eax, -0x40(%rbp)
movl -0x40(%rbp), %eax
movl %eax, -0x4(%rbp)
movl -0x4(%rbp), %eax
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/theovosse[P]llgen/llgen.c
// Function: regexpcopy
static void regexpcopy(char *copy, char *regexp) {
	regexp++;
	while (*regexp != '\0') {
		if (*regexp == '"') {
			if (regexp[1] != '\0') {
				yyerror("quote error in regexp\n");
				errorOccurred = true;
			}
			*copy = '\0';
			return;
		} else if (*regexp == '\\') {
			if (regexp[1] == '\0') {
				yyerror("escape error in regexp\n");
				errorOccurred = true;
				regexp++;
			} else if (regexp[1] == '"') {
				*copy++ = '"';
				regexp += 2;
			} else if (regexp[1] == '\\') {
				*copy++ = '\\';
				*copy++ = '\\';
				regexp += 2;
			} else {
				*copy++ = *regexp++;
			}
		} else {
			*copy++ = *regexp++;
		}
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x10(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x10(%rbp)
movq -0x10(%rbp), %rax
movsbl (%rax), %eax
cmpl $0x0, %eax
je 0x8dfa
movq -0x10(%rbp), %rax
movsbl (%rax), %eax
cmpl $0x22, %eax
jne 0x8cf8
movq -0x10(%rbp), %rax
movsbl 0x1(%rax), %eax
cmpl $0x0, %eax
je 0x8cec
leaq 0x10aa1(%rip), %rdi     # 0x1977d
movb $0x0, %al
callq 0x37d0
movw $0xffff, 0x1807e(%rip)  # imm = 0xFFFF
movq -0x8(%rbp), %rax
movb $0x0, (%rax)
jmp 0x8dfa
movq -0x10(%rbp), %rax
movsbl (%rax), %eax
cmpl $0x5c, %eax
jne 0x8dd1
movq -0x10(%rbp), %rax
movsbl 0x1(%rax), %eax
cmpl $0x0, %eax
jne 0x8d3d
leaq 0x10a78(%rip), %rdi     # 0x19794
movb $0x0, %al
callq 0x37d0
movw $0xffff, 0x1803e(%rip)  # imm = 0xFFFF
movq -0x10(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x10(%rbp)
jmp 0x8dcf
movq -0x10(%rbp), %rax
movsbl 0x1(%rax), %eax
cmpl $0x22, %eax
jne 0x8d6a
movq -0x8(%rbp), %rax
movq %rax, %rcx
addq $0x1, %rcx
movq %rcx, -0x8(%rbp)
movb $0x22, (%rax)
movq -0x10(%rbp), %rax
addq $0x2, %rax
movq %rax, -0x10(%rbp)
jmp 0x8dcd
movq -0x10(%rbp), %rax
movsbl 0x1(%rax), %eax
cmpl $0x5c, %eax
jne 0x8da9
movq -0x8(%rbp), %rax
movq %rax, %rcx
addq $0x1, %rcx
movq %rcx, -0x8(%rbp)
movb $0x5c, (%rax)
movq -0x8(%rbp), %rax
movq %rax, %rcx
addq $0x1, %rcx
movq %rcx, -0x8(%rbp)
movb $0x5c, (%rax)
movq -0x10(%rbp), %rax
addq $0x2, %rax
movq %rax, -0x10(%rbp)
jmp 0x8dcb
movq -0x10(%rbp), %rax
movq %rax, %rcx
addq $0x1, %rcx
movq %rcx, -0x10(%rbp)
movb (%rax), %cl
movq -0x8(%rbp), %rax
movq %rax, %rdx
addq $0x1, %rdx
movq %rdx, -0x8(%rbp)
movb %cl, (%rax)
jmp 0x8dcd
jmp 0x8dcf
jmp 0x8df3
movq -0x10(%rbp), %rax
movq %rax, %rcx
addq $0x1, %rcx
movq %rcx, -0x10(%rbp)
movb (%rax), %cl
movq -0x8(%rbp), %rax
movq %rax, %rdx
addq $0x1, %rdx
movq %rdx, -0x8(%rbp)
movb %cl, (%rax)
jmp 0x8df5
jmp 0x8cac
addq $0x10, %rsp
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O0/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
movq %rsp, %rbp
subq $0x20, %rsp
movw %si, %ax
movl %edi, -0xc(%rbp)
movw %ax, -0xe(%rbp)
movq 0x17c27(%rip), %rdi     # 0x20d50
callq 0x10330
movq %rax, -0x18(%rbp)
cmpq $0x0, -0x18(%rbp)
je 0x917c
movq -0x18(%rbp), %rdi
callq 0x10400
movq %rax, -0x20(%rbp)
movq -0x20(%rbp), %rax
cmpl $0x4, 0x38(%rax)
jne 0x916b
movq -0x20(%rbp), %rax
movq 0x28(%rax), %rax
movslq -0xc(%rbp), %rcx
cmpq %rcx, %rax
jne 0x916b
movq -0x20(%rbp), %rax
movq %rax, -0x8(%rbp)
jmp 0x91e7
jmp 0x916d
movq -0x18(%rbp), %rdi
callq 0x10430
movq %rax, -0x18(%rbp)
jmp 0x9132
cmpw $0x0, -0xe(%rbp)
je 0x91df
movq 0x17bc6(%rip), %rdi     # 0x20d50
callq 0x10330
movq %rax, -0x18(%rbp)
cmpq $0x0, -0x18(%rbp)
je 0x91dd
movq -0x18(%rbp), %rdi
callq 0x10400
movq %rax, -0x20(%rbp)
movq -0x20(%rbp), %rax
cmpl $0x1, 0x38(%rax)
jne 0x91cc
movq -0x20(%rbp), %rax
movq 0x28(%rax), %rax
movslq -0xc(%rbp), %rcx
cmpq %rcx, %rax
jne 0x91cc
movq -0x20(%rbp), %rax
movq %rax, -0x8(%rbp)
jmp 0x91e7
jmp 0x91ce
movq -0x18(%rbp), %rdi
callq 0x10430
movq %rax, -0x18(%rbp)
jmp 0x9193
jmp 0x91df
movq $0x0, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/theovosse[P]llgen/llgen.c
// Function: ifCondition
static void ifCondition(Boolean open, int indent) {
    if (open) {
        fputs(targetLanguage->openIf, outputFile);
    } else {
        fputs(targetLanguage->closeIf, outputFile);
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movw %di, %ax
movw %ax, -0x2(%rbp)
movl %esi, -0x8(%rbp)
cmpw $0x0, -0x2(%rbp)
je 0xaf45
movq 0x15240(%rip), %rax     # 0x20170
movq 0x88(%rax), %rdi
movq 0x15dfa(%rip), %rsi     # 0x20d38
callq 0x3100
jmp 0xaf5f
movq 0x15224(%rip), %rax     # 0x20170
movq 0x90(%rax), %rdi
movq 0x15dde(%rip), %rsi     # 0x20d38
callq 0x3100
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movw %di, %ax
movw %ax, -0x2(%rbp)
movl %esi, -0x8(%rbp)
cmpw $0x0, -0x2(%rbp)
je 0xafd0
movq 0x151e0(%rip), %rax     # 0x20170
movq 0x98(%rax), %rdi
movq 0x15d9a(%rip), %rsi     # 0x20d38
callq 0x3100
movq 0x15d8e(%rip), %rsi     # 0x20d38
movl $0x20, %edi
callq 0x3120
movq 0x151b5(%rip), %rax     # 0x20170
movq 0x88(%rax), %rdi
movq 0x15d6f(%rip), %rsi     # 0x20d38
callq 0x3100
jmp 0xafea
movq 0x15199(%rip), %rax     # 0x20170
movq 0x90(%rax), %rdi
movq 0x15d53(%rip), %rsi     # 0x20d38
callq 0x3100
addq $0x10, %rsp
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O0/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 %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x10(%rbp), %rdi
callq 0x10330
movq %rax, -0x10(%rbp)
cmpq $0x0, -0x10(%rbp)
je 0xb060
movq -0x8(%rbp), %rax
movq %rax, -0x18(%rbp)
movq -0x10(%rbp), %rdi
callq 0x10400
movq -0x18(%rbp), %rdi
movq (%rax), %rdx
leaq 0x10742(%rip), %rsi     # 0x1b775
movb $0x0, %al
callq 0x3140
movq -0x10(%rbp), %rdi
callq 0x10430
movq %rax, -0x10(%rbp)
cmpq $0x0, -0x10(%rbp)
je 0xb05e
movq -0x8(%rbp), %rsi
leaq 0xe51a(%rip), %rdi      # 0x19573
callq 0x3100
jmp 0xb00d
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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 %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq 0x15ab5(%rip), %rdi     # 0x20dc8
movq -0x8(%rbp), %rsi
leaq 0x822(%rip), %rdx       # 0xbb40
callq 0x10560
movq %rax, -0x10(%rbp)
cmpq $0x0, -0x10(%rbp)
jne 0xb36b
movq 0x14cc3(%rip), %rax     # 0x1fff8
movq (%rax), %rsi
leaq 0xe90d(%rip), %rdi      # 0x19c4c
callq 0x3100
movq 0x14cad(%rip), %rax     # 0x1fff8
movq (%rax), %rdi
movq -0x8(%rbp), %rsi
callq 0xaff0
movq 0x14c9a(%rip), %rax     # 0x1fff8
movq (%rax), %rsi
movl $0xa, %edi
callq 0x3120
movq 0x14dfe(%rip), %rax     # 0x20170
movq 0x100(%rax), %rax
movq %rax, -0x18(%rbp)
movq 0x159b4(%rip), %rax     # 0x20d38
movq %rax, -0x20(%rbp)
movq -0x10(%rbp), %rdi
callq 0x103d0
movq -0x20(%rbp), %rdi
movq %rax, %rdx
movq -0x18(%rbp), %rax
leaq 0xe4a2(%rip), %rsi      # 0x19845
callq *%rax
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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 %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq 0x159d1(%rip), %rdi     # 0x20dc8
movq -0x10(%rbp), %rsi
leaq 0x73e(%rip), %rdx       # 0xbb40
callq 0x10560
movq %rax, -0x18(%rbp)
cmpq $0x0, -0x18(%rbp)
jne 0xb4c4
movq 0x1599b(%rip), %rax     # 0x20db8
addq $0x1, %rax
movq %rax, 0x15990(%rip)     # 0x20db8
movq -0x10(%rbp), %rdi
xorl %eax, %eax
movl %eax, %edx
movq %rdx, %rsi
callq 0x10ad0
movq %rax, %rsi
movq 0x15976(%rip), %rdx     # 0x20db8
leaq 0x1597f(%rip), %rdi     # 0x20dc8
leaq 0x6f0(%rip), %rcx       # 0xbb40
callq 0xfc60
movq 0x14d14(%rip), %rax     # 0x20170
movq 0xc0(%rax), %rax
movq %rax, -0x20(%rbp)
movq -0x8(%rbp), %rdi
movq 0x14cfe(%rip), %rax     # 0x20170
movq 0x50(%rax), %rax
movq %rax, -0x28(%rbp)
movq 0x15937(%rip), %r8      # 0x20db8
movl 0x158d1(%rip), %eax     # 0x20d58
addl $0x1, %eax
cltd
idivl 0x14ccf(%rip)           # 0x20160
movq -0x28(%rbp), %rdx
movl %eax, %r9d
movq -0x20(%rbp), %rax
addl $0x1, %r9d
leaq 0xe1ef(%rip), %rsi      # 0x19696
leaq 0xe397(%rip), %rcx      # 0x19845
movl $0xffffffff, (%rsp)     # imm = 0xFFFFFFFF
callq *%rax
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
callq 0x8550
addq $0x30, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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 %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rdi
callq 0xbe80
movq %rax, -0x18(%rbp)
movq -0x10(%rbp), %rdi
callq 0xbe80
movq %rax, -0x20(%rbp)
movq -0x18(%rbp), %rdi
movq -0x20(%rbp), %rsi
callq 0xbf30
movq %rax, -0x28(%rbp)
movq -0x18(%rbp), %rdi
xorl %eax, %eax
movl %eax, %esi
callq 0x106c0
movq -0x20(%rbp), %rdi
xorl %eax, %eax
movl %eax, %esi
callq 0x106c0
movq -0x28(%rbp), %rax
addq $0x30, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/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:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x10(%rbp), %rax
movl 0x4(%rax), %eax
movl %eax, -0x1c(%rbp)
subl $0x5, %eax
je 0xbaab
jmp 0xbaa1
movl -0x1c(%rbp), %eax
subl $0x6, %eax
je 0xbab9
jmp 0xbacb
movq -0x10(%rbp), %rax
movq 0x18(%rax), %rax
movq %rax, -0x18(%rbp)
jmp 0xbaec
movq -0x10(%rbp), %rax
movq 0x18(%rax), %rax
movq 0x18(%rax), %rax
movq %rax, -0x18(%rbp)
jmp 0xbaec
movq 0x14526(%rip), %rax     # 0x1fff8
movq (%rax), %rdi
movq -0x10(%rbp), %rax
movl 0x4(%rax), %edx
leaq 0xe1f3(%rip), %rsi      # 0x19cd6
movb $0x0, %al
callq 0x3140
jmp 0xbb3a
movq -0x18(%rbp), %rax
cmpl $0x0, 0x38(%rax)
jne 0xbb17
movq 0x144fb(%rip), %rax     # 0x1fff8
movq (%rax), %rdi
movq -0x10(%rbp), %rax
movswl (%rax), %edx
leaq 0xe1ed(%rip), %rsi      # 0x19cfb
movb $0x0, %al
callq 0x3140
jmp 0xbb3a
movq -0x18(%rbp), %rax
cmpl $0x4, 0x38(%rax)
je 0xbb2b
movq -0x18(%rbp), %rax
cmpl $0x1, 0x38(%rax)
jne 0xbb38
movq -0x8(%rbp), %rdi
movq -0x18(%rbp), %rsi
callq 0x57b0
jmp 0xbb3a
addq $0x20, %rsp
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O0/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 %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x10(%rbp), %rdi
callq 0x10330
movq %rax, -0x20(%rbp)
movq -0x18(%rbp), %rdi
callq 0x10330
movq %rax, -0x28(%rbp)
xorl %eax, %eax
cmpq $0x0, -0x20(%rbp)
movb %al, -0x3d(%rbp)
je 0xbb81
cmpq $0x0, -0x28(%rbp)
setne %al
movb %al, -0x3d(%rbp)
movb -0x3d(%rbp), %al
testb $0x1, %al
jne 0xbb8a
jmp 0xbbe4
movq -0x20(%rbp), %rdi
callq 0x10400
movq %rax, -0x30(%rbp)
movq -0x28(%rbp), %rdi
callq 0x10400
movq %rax, -0x38(%rbp)
movq -0x30(%rbp), %rax
movq (%rax), %rdi
movq -0x38(%rbp), %rax
movq (%rax), %rsi
callq 0x3220
movl %eax, -0x3c(%rbp)
cmpl $0x0, -0x3c(%rbp)
je 0xbbc8
movl -0x3c(%rbp), %eax
movl %eax, -0x4(%rbp)
jmp 0xbc10
movq -0x20(%rbp), %rdi
callq 0x10430
movq %rax, -0x20(%rbp)
movq -0x28(%rbp), %rdi
callq 0x10430
movq %rax, -0x28(%rbp)
jmp 0xbb6a
cmpq $0x0, -0x20(%rbp)
je 0xbbf5
movl $0x1, %eax
movl %eax, -0x44(%rbp)
jmp 0xbc0a
movq -0x28(%rbp), %rdx
xorl %eax, %eax
movl $0xffffffff, %ecx       # imm = 0xFFFFFFFF
cmpq $0x0, %rdx
cmovnel %ecx, %eax
movl %eax, -0x44(%rbp)
movl -0x44(%rbp), %eax
movl %eax, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x50, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/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 %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq $0x0, -0x10(%rbp)
movq -0x8(%rbp), %rdi
callq 0x10330
movq %rax, -0x18(%rbp)
cmpq $0x0, -0x18(%rbp)
je 0xbf1f
movq 0x14f11(%rip), %rax     # 0x20dc0
movq %rax, -0x28(%rbp)
movq -0x18(%rbp), %rdi
callq 0x10400
movq -0x28(%rbp), %rdi
movq %rax, %rsi
leaq -0x876a(%rip), %rdx     # 0x3760
callq 0x10560
movq %rax, -0x20(%rbp)
cmpq $0x0, %rax
jne 0xbefb
movq -0x18(%rbp), %rdi
callq 0x10400
movq %rax, %rsi
leaq -0x10(%rbp), %rdi
xorl %eax, %eax
movl %eax, %edx
leaq -0x8794(%rip), %rcx     # 0x3760
callq 0xfc60
jmp 0xbf10
movq -0x20(%rbp), %rdi
callq 0x103d0
movq %rax, %rsi
leaq -0x10(%rbp), %rdi
callq 0x5e00
movq -0x18(%rbp), %rdi
callq 0x10430
movq %rax, -0x18(%rbp)
jmp 0xbea1
movq -0x10(%rbp), %rax
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/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 %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq $0x0, -0x18(%rbp)
movq -0x8(%rbp), %rdi
callq 0x10330
movq %rax, -0x20(%rbp)
cmpq $0x0, -0x20(%rbp)
je 0xbfc2
movq -0x10(%rbp), %rax
movq %rax, -0x28(%rbp)
movq -0x20(%rbp), %rdi
callq 0x10400
movq -0x28(%rbp), %rdi
movq %rax, %rsi
leaq -0x881b(%rip), %rdx     # 0x3760
callq 0x10560
cmpq $0x0, %rax
je 0xbfb3
movq -0x20(%rbp), %rdi
callq 0x10400
movq %rax, -0x30(%rbp)
movq -0x20(%rbp), %rdi
callq 0x10400
movq -0x30(%rbp), %rsi
movq %rax, %rdx
leaq -0x18(%rbp), %rdi
leaq -0x884e(%rip), %rcx     # 0x3760
callq 0xfc60
movq -0x20(%rbp), %rdi
callq 0x10430
movq %rax, -0x20(%rbp)
jmp 0xbf55
movq -0x18(%rbp), %rax
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/theovosse[P]llgen/llgen.c
// Function: NotEmptyIntersection
static Boolean NotEmptyIntersection(TREE t1, TREE t2) {
	TREE t = GetFirstNode(t1);

	while (t != NULL) {
		if (FindNode(t2, GetKey(t), (TreeCmp) NameCmp) != NULL) {
			return (true);
		}
		t = GetNextNode(t);
	}
	return (false);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x10(%rbp), %rdi
callq 0x10330
movq %rax, -0x20(%rbp)
cmpq $0x0, -0x20(%rbp)
je 0xc035
movq -0x18(%rbp), %rax
movq %rax, -0x28(%rbp)
movq -0x20(%rbp), %rdi
callq 0x10400
movq -0x28(%rbp), %rdi
movq %rax, %rsi
leaq -0x88b3(%rip), %rdx     # 0x3760
callq 0x10560
cmpq $0x0, %rax
je 0xc026
movw $0xffff, -0x2(%rbp)     # imm = 0xFFFF
jmp 0xc03b
movq -0x20(%rbp), %rdi
callq 0x10430
movq %rax, -0x20(%rbp)
jmp 0xbfed
movw $0x0, -0x2(%rbp)
movw -0x2(%rbp), %ax
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/theovosse[P]llgen/avl3.c
// Function: GetFirstNode
TREE GetFirstNode(TREE tree)
{
	if (tree != NULL)
	{
		while (tree->left != NULL)
		{
			tree = tree->left;
		}
	}
	return (tree);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
cmpq $0x0, -0x8(%rbp)
je 0x1035c
jmp 0x10341
movq -0x8(%rbp), %rax
cmpq $0x0, 0x10(%rax)
je 0x1035a
movq -0x8(%rbp), %rax
movq 0x10(%rax), %rax
movq %rax, -0x8(%rbp)
jmp 0x10341
jmp 0x1035c
movq -0x8(%rbp), %rax
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/theovosse[P]llgen/avl3.c
// Function: GetLastNode
TREE GetLastNode(TREE tree)
{
	if (tree != NULL)
	{
		while (tree->right != NULL)
		{
			tree = tree->right;
		}
	}
	return (tree);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
cmpq $0x0, -0x8(%rbp)
je 0x1039c
jmp 0x10381
movq -0x8(%rbp), %rax
cmpq $0x0, 0x18(%rax)
je 0x1039a
movq -0x8(%rbp), %rax
movq 0x18(%rax), %rax
movq %rax, -0x8(%rbp)
jmp 0x10381
jmp 0x1039c
movq -0x8(%rbp), %rax
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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 %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
cmpq $0x0, -0x8(%rbp)
je 0x104de
movq -0x8(%rbp), %rax
movq 0x10(%rax), %rdi
movq -0x10(%rbp), %rsi
callq 0x10490
movq -0x10(%rbp), %rax
movq -0x8(%rbp), %rcx
movq (%rcx), %rdi
movq -0x8(%rbp), %rcx
movq 0x8(%rcx), %rsi
callq *%rax
movq -0x8(%rbp), %rax
movq 0x18(%rax), %rdi
movq -0x10(%rbp), %rsi
callq 0x10490
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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 %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
cmpq $0x0, -0x8(%rbp)
je 0x1054e
movq -0x8(%rbp), %rax
movq 0x10(%rax), %rdi
movq -0x10(%rbp), %rsi
movq -0x18(%rbp), %rdx
callq 0x104f0
movq -0x10(%rbp), %rax
movq -0x8(%rbp), %rcx
movq (%rcx), %rdi
movq -0x8(%rbp), %rcx
movq 0x8(%rcx), %rsi
movq -0x18(%rbp), %rdx
callq *%rax
movq -0x8(%rbp), %rax
movq 0x18(%rax), %rdi
movq -0x10(%rbp), %rsi
movq -0x18(%rbp), %rdx
callq 0x104f0
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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 %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x20(%rbp)
movw $0x0, -0x22(%rbp)
xorl %eax, %eax
cmpq $0x0, -0x20(%rbp)
movb %al, -0x29(%rbp)
je 0x1059b
cmpw $0x0, -0x22(%rbp)
setne %al
xorb $-0x1, %al
movb %al, -0x29(%rbp)
movb -0x29(%rbp), %al
testb $0x1, %al
jne 0x105a4
jmp 0x105e9
movq -0x18(%rbp), %rax
movq -0x20(%rbp), %rcx
movq (%rcx), %rdi
movq -0x10(%rbp), %rsi
callq *%rax
movl %eax, -0x28(%rbp)
cmpl $0x0, %eax
jne 0x105c5
movw $0xffff, -0x22(%rbp)    # imm = 0xFFFF
jmp 0x105e7
cmpl $0x0, -0x28(%rbp)
jge 0x105d9
movq -0x20(%rbp), %rax
movq 0x18(%rax), %rax
movq %rax, -0x20(%rbp)
jmp 0x105e5
movq -0x20(%rbp), %rax
movq 0x10(%rax), %rax
movq %rax, -0x20(%rbp)
jmp 0x105e7
jmp 0x10582
movq -0x20(%rbp), %rax
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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 %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq $0x0, -0x20(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x28(%rbp)
movw $0x0, -0x2a(%rbp)
xorl %eax, %eax
cmpq $0x0, -0x28(%rbp)
movb %al, -0x31(%rbp)
je 0x10643
cmpw $0x0, -0x2a(%rbp)
setne %al
xorb $-0x1, %al
movb %al, -0x31(%rbp)
movb -0x31(%rbp), %al
testb $0x1, %al
jne 0x1064c
jmp 0x10699
movq -0x18(%rbp), %rax
movq -0x28(%rbp), %rcx
movq (%rcx), %rdi
movq -0x10(%rbp), %rsi
callq *%rax
movl %eax, -0x30(%rbp)
cmpl $0x0, %eax
jne 0x1066d
movw $0xffff, -0x2a(%rbp)    # imm = 0xFFFF
jmp 0x10697
cmpl $0x0, -0x30(%rbp)
jge 0x10681
movq -0x28(%rbp), %rax
movq 0x18(%rax), %rax
movq %rax, -0x28(%rbp)
jmp 0x10695
movq -0x28(%rbp), %rax
movq %rax, -0x20(%rbp)
movq -0x28(%rbp), %rax
movq 0x10(%rax), %rax
movq %rax, -0x28(%rbp)
jmp 0x10697
jmp 0x1062a
movswl -0x2a(%rbp), %eax
cmpl $0x0, %eax
je 0x106ac
movq -0x28(%rbp), %rax
movq %rax, -0x40(%rbp)
jmp 0x106b4
movq -0x20(%rbp), %rax
movq %rax, -0x40(%rbp)
movq -0x40(%rbp), %rax
addq $0x40, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/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:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
cmpq $0x0, -0x8(%rbp)
je 0x1072f
movq -0x8(%rbp), %rax
movq 0x10(%rax), %rdi
movq -0x10(%rbp), %rsi
callq 0x106c0
cmpq $0x0, -0x10(%rbp)
je 0x10704
movq -0x10(%rbp), %rax
movq -0x8(%rbp), %rcx
movq (%rcx), %rdi
movq -0x8(%rbp), %rcx
movq 0x8(%rcx), %rsi
callq *%rax
movq -0x8(%rbp), %rax
movq 0x18(%rax), %rdi
movq -0x10(%rbp), %rsi
callq 0x106c0
movq 0x12774(%rip), %rcx     # 0x22e90
movq -0x8(%rbp), %rax
movq %rcx, 0x10(%rax)
movq -0x8(%rbp), %rax
movq %rax, 0x12761(%rip)     # 0x22e90
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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 %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
cmpq $0x0, -0x10(%rbp)
jne 0x107b1
movq $0x0, -0x8(%rbp)
jmp 0x1081f
movq -0x10(%rbp), %rax
movq 0x10(%rax), %rdi
movq -0x18(%rbp), %rsi
callq 0x10790
movq %rax, -0x28(%rbp)
movq -0x10(%rbp), %rax
movq 0x18(%rax), %rdi
movq -0x18(%rbp), %rsi
callq 0x10790
movq %rax, %rcx
movq -0x28(%rbp), %rax
addq %rcx, %rax
movq %rax, -0x20(%rbp)
cmpq $0x0, -0x18(%rbp)
jne 0x107f7
movl $0x1, %eax
movq %rax, -0x30(%rbp)
jmp 0x10810
movq -0x18(%rbp), %rax
movq -0x10(%rbp), %rcx
movq (%rcx), %rdi
movq -0x10(%rbp), %rcx
movq 0x8(%rcx), %rsi
callq *%rax
movq %rax, -0x30(%rbp)
movq -0x20(%rbp), %rax
movq -0x30(%rbp), %rcx
addq %rcx, %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/theovosse[P]llgen/avl3.c
// Function: CopyTree
TREE CopyTree(TREE tree, CopyProc copyKey, CopyProc copyInfo)
{
	TREE copy = CopyTree2(tree, copyKey, copyInfo);
	TREE finalNode = SetOrder(copy, NULL);

	if (finalNode != NULL) finalNode->next = NULL;
	return (copy);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
movq -0x18(%rbp), %rdx
callq 0x10b30
movq %rax, -0x20(%rbp)
movq -0x20(%rbp), %rdi
xorl %eax, %eax
movl %eax, %esi
callq 0x10c70
movq %rax, -0x28(%rbp)
cmpq $0x0, -0x28(%rbp)
je 0x10b1d
movq -0x28(%rbp), %rax
movq $0x0, 0x20(%rax)
movq -0x20(%rbp), %rax
addq $0x30, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/theovosse[P]llgen/avl3.c
// Function: CopyTree2
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 %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
cmpq $0x0, -0x10(%rbp)
jne 0x10b58
movq $0x0, -0x8(%rbp)
jmp 0x10c65
cmpq $0x0, 0x12330(%rip)     # 0x22e90
jne 0x10b8f
movl $0x38, %edi
callq 0x11110
movq %rax, -0x28(%rbp)
cmpq $0x0, -0x28(%rbp)
jne 0x10b8d
leaq 0xa48d(%rip), %rdi      # 0x1b00b
callq 0x31a0
movl $0x1, %edi
callq 0x31e0
jmp 0x10bac
movq 0x122fa(%rip), %rax     # 0x22e90
movq %rax, -0x28(%rbp)
movq 0x122ef(%rip), %rax     # 0x22e90
movq 0x10(%rax), %rax
movq %rax, 0x122e4(%rip)     # 0x22e90
cmpq $0x0, -0x18(%rbp)
jne 0x10bc0
movq -0x10(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x30(%rbp)
jmp 0x10bd1
movq -0x18(%rbp), %rax
movq -0x10(%rbp), %rcx
movq (%rcx), %rdi
callq *%rax
movq %rax, -0x30(%rbp)
movq -0x30(%rbp), %rcx
movq -0x28(%rbp), %rax
movq %rcx, (%rax)
cmpq $0x0, -0x20(%rbp)
jne 0x10bf1
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rax
movq %rax, -0x38(%rbp)
jmp 0x10c03
movq -0x20(%rbp), %rax
movq -0x10(%rbp), %rcx
movq 0x8(%rcx), %rdi
callq *%rax
movq %rax, -0x38(%rbp)
movq -0x38(%rbp), %rcx
movq -0x28(%rbp), %rax
movq %rcx, 0x8(%rax)
movq -0x10(%rbp), %rax
movq 0x10(%rax), %rdi
movq -0x18(%rbp), %rsi
movq -0x20(%rbp), %rdx
callq 0x10ad0
movq %rax, %rcx
movq -0x28(%rbp), %rax
movq %rcx, 0x10(%rax)
movq -0x10(%rbp), %rax
movq 0x18(%rax), %rdi
movq -0x18(%rbp), %rsi
movq -0x20(%rbp), %rdx
callq 0x10ad0
movq %rax, %rcx
movq -0x28(%rbp), %rax
movq %rcx, 0x18(%rax)
movq -0x10(%rbp), %rax
movl 0x30(%rax), %ecx
movq -0x28(%rbp), %rax
movl %ecx, 0x30(%rax)
movq -0x28(%rbp), %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x40, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/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 %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
cmpq $0x0, -0x10(%rbp)
jne 0x10c91
movq -0x18(%rbp), %rax
movq %rax, -0x8(%rbp)
jmp 0x10cdd
movq -0x10(%rbp), %rax
movq 0x10(%rax), %rdi
movq -0x18(%rbp), %rsi
callq 0x10c70
movq %rax, %rcx
movq -0x10(%rbp), %rax
movq %rcx, 0x28(%rax)
movq -0x10(%rbp), %rax
cmpq $0x0, 0x28(%rax)
je 0x10cc8
movq -0x10(%rbp), %rcx
movq -0x10(%rbp), %rax
movq 0x28(%rax), %rax
movq %rcx, 0x20(%rax)
movq -0x10(%rbp), %rax
movq 0x18(%rax), %rdi
movq -0x10(%rbp), %rsi
callq 0x10c70
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x20, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x10(%rbp)
cmpq $0x0, -0x10(%rbp)
jne 0x10d08
movl $0x0, -0x4(%rbp)
jmp 0x10d73
movq -0x10(%rbp), %rax
cmpq $0x0, 0x10(%rax)
jne 0x10d1a
xorl %eax, %eax
movl %eax, -0x1c(%rbp)
jmp 0x10d28
movq -0x10(%rbp), %rax
movq 0x10(%rax), %rax
movl 0x30(%rax), %eax
movl %eax, -0x1c(%rbp)
movl -0x1c(%rbp), %eax
movl %eax, -0x14(%rbp)
movq -0x10(%rbp), %rax
cmpq $0x0, 0x18(%rax)
jne 0x10d40
xorl %eax, %eax
movl %eax, -0x20(%rbp)
jmp 0x10d4e
movq -0x10(%rbp), %rax
movq 0x18(%rax), %rax
movl 0x30(%rax), %eax
movl %eax, -0x20(%rbp)
movl -0x20(%rbp), %eax
movl %eax, -0x18(%rbp)
movl -0x14(%rbp), %eax
cmpl -0x18(%rbp), %eax
jle 0x10d64
movl -0x14(%rbp), %eax
movl %eax, -0x24(%rbp)
jmp 0x10d6a
movl -0x18(%rbp), %eax
movl %eax, -0x24(%rbp)
movl -0x24(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x4(%rbp)
movl -0x4(%rbp), %eax
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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 %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x10(%rbp), %rax
cmpq $0x0, 0x18(%rax)
je 0x10dc6
movq -0x10(%rbp), %rax
movq 0x18(%rax), %rdi
movq -0x18(%rbp), %rsi
callq 0x10d80
movq %rax, %rcx
movq -0x10(%rbp), %rax
movq %rcx, 0x18(%rax)
movq -0x10(%rbp), %rdi
callq 0x10e60
movq %rax, -0x8(%rbp)
jmp 0x10ddd
movq -0x10(%rbp), %rcx
movq -0x18(%rbp), %rax
movq %rcx, (%rax)
movq -0x10(%rbp), %rax
movq 0x10(%rax), %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x20, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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 %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x10(%rbp), %rax
cmpq $0x0, 0x10(%rax)
je 0x10e36
movq -0x10(%rbp), %rax
movq 0x10(%rax), %rdi
movq -0x18(%rbp), %rsi
callq 0x10df0
movq %rax, %rcx
movq -0x10(%rbp), %rax
movq %rcx, 0x10(%rax)
movq -0x10(%rbp), %rdi
callq 0x10e60
movq %rax, -0x8(%rbp)
jmp 0x10e4d
movq -0x10(%rbp), %rcx
movq -0x18(%rbp), %rax
movq %rcx, (%rax)
movq -0x10(%rbp), %rax
movq 0x18(%rax), %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x20, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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 %rbp
movq %rsp, %rbp
subq $0x10, %rsp
cmpq $0x0, 0x11a98(%rip)     # 0x22ec8
je 0x11451
movq 0x11a8f(%rip), %rax     # 0x22ec8
movq %rax, -0x8(%rbp)
movq 0x11a84(%rip), %rax     # 0x22ec8
movq 0x10(%rax), %rax
movq %rax, 0x11a79(%rip)     # 0x22ec8
jmp 0x11491
xorl %eax, %eax
cmpq 0x11a46(%rip), %rax     # 0x22ea0
jge 0x11475
cmpq $0x8000, 0x11a39(%rip) # imm = 0x8000
jge 0x11475
movq 0x11a30(%rip), %rax     # 0x22ea0
movl %eax, -0xc(%rbp)
jmp 0x1147c
movl $0x8000, -0xc(%rbp)     # imm = 0x8000
movl -0xc(%rbp), %edi
callq 0x11110
movq %rax, -0x8(%rbp)
movl -0xc(%rbp), %ecx
movq -0x8(%rbp), %rax
movl %ecx, (%rax)
movq -0x8(%rbp), %rax
movl (%rax), %eax
subq $0x18, %rax
movl %eax, %ecx
movq -0x8(%rbp), %rax
movl %ecx, 0x4(%rax)
movq -0x8(%rbp), %rcx
addq $0x18, %rcx
movq -0x8(%rbp), %rax
movq %rcx, 0x8(%rax)
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rax
movl $0x4, %ecx
cqto
idivq %rcx
cmpq $0x0, %rdx
je 0x11511
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rax
movl $0x4, %ecx
cqto
idivq %rcx
movl %edx, %eax
movl %eax, -0x10(%rbp)
movl $0x4, %edx
subl -0x10(%rbp), %edx
movq -0x8(%rbp), %rax
movl 0x4(%rax), %ecx
subl %edx, %ecx
movl %ecx, 0x4(%rax)
movl $0x4, %edx
subl -0x10(%rbp), %edx
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rcx
movslq %edx, %rdx
addq %rdx, %rcx
movq %rcx, 0x8(%rax)
movq -0x8(%rbp), %rax
addq $0x10, %rsp
popq %rbp
retq
nopl (%rax,%rax)