LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O1/theovosse[P]llgen/llgen.c
// Function: nrParameters
int nrParameters(Node argList) {
	int level = 0;
	int nrParameters = argList == NULL? 0: 1;

	for (Node nPtr = argList; nPtr != NULL; nPtr = nPtr->next) {
        const char *str = (const char *) nPtr->element.name;
        if (strcmp(str, ",") == 0 && level == 0) {
			nrParameters++;
        } else {
            if (strcmp(str, "{") == 0 || strcmp(str, "(") == 0 || strcmp(str, "[") == 0) {
                level++;
            } else if (strcmp(str, "}") == 0 || strcmp(str, ")") == 0 || strcmp(str, "]") == 0) {
                level--;
            }
        }
	}
	return nrParameters;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
xorl %ebx, %ebx
testq %rdi, %rdi
setne %bl
je 0x3d4e
movq %rdi, %r14
xorl %r13d, %r13d
leaq 0xf99e(%rip), %r15      # 0x13647
leaq 0xf54a(%rip), %r12      # 0x131fa
movq 0x18(%r14), %rbp
movq %rbp, %rdi
movq %r15, %rsi
callq 0x3240
orl %r13d, %eax
jne 0x3ccb
incl %ebx
xorl %r13d, %r13d
jmp 0x3d41
movq %rbp, %rdi
movq %r12, %rsi
callq 0x3240
testl %eax, %eax
je 0x3d3e
movq %rbp, %rdi
leaq 0xd4f9(%rip), %rsi      # 0x111dd
callq 0x3240
testl %eax, %eax
je 0x3d3e
movq %rbp, %rdi
leaq 0xfa42(%rip), %rsi      # 0x13739
callq 0x3240
testl %eax, %eax
je 0x3d3e
movq %rbp, %rdi
leaq 0xf49a(%rip), %rsi      # 0x131a4
callq 0x3240
testl %eax, %eax
je 0x3d39
movq %rbp, %rdi
leaq 0xf162(%rip), %rsi      # 0x12e7f
callq 0x3240
testl %eax, %eax
je 0x3d39
movq %rbp, %rdi
leaq 0xf3a1(%rip), %rsi      # 0x130d1
callq 0x3240
testl %eax, %eax
jne 0x3d41
decl %r13d
jmp 0x3d41
incl %r13d
movq 0x28(%r14), %r14
testq %r14, %r14
jne 0x3cb0
movl %ebx, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/theovosse[P]llgen/llgen.c
// Function: MakeRuleResult
RuleResult MakeRuleResult(Name returnVariable, Name returnType, Name initialValue) {
	RuleResult ruleResult = (RuleResult) mmalloc(sizeof(struct RuleResult));

	ruleResult->returnVariable = returnVariable;
	ruleResult->returnType = returnType;
	ruleResult->initialValue = initialValue;
	return ruleResult;
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rdx, %rbx
movq %rsi, %r14
movq %rdi, %r15
movl $0x18, %edi
callq 0xc614
movq %r15, (%rax)
movq %r14, 0x8(%rax)
movq %rbx, 0x10(%rax)
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O1/theovosse[P]llgen/llgen.c
// Function: MakeName
Name MakeName(char *str, int index, NameType nameType, short int lineNr) {
	Name name = (Name) mmalloc(sizeof(struct Name));

	name->name = MakeString(str);
	name->index = index;
	name->lineNr = lineNr;
	name->empty = false;
	name->first = NULL;
	name->nameType = nameType;
	name->rules = NULL;
	name->follow = NULL;
	name->arglist = NULL;
	name->ruleResult = NULL;
	name->keywords = NULL;
	name->usesLA = false;
	name->functions = NULL;
	name->nrParameters = 0;
	name->isTerminal = false;
	return (name);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movl %ecx, %ebx
movl %edx, %ebp
movl %esi, %r14d
movq %rdi, %r15
movl $0x68, %edi
callq 0xc614
movq %rax, %r12
movq %r15, %rdi
callq 0x3c0c
movq %rax, (%r12)
movslq %r14d, %rax
movq %rax, 0x28(%r12)
movl %ebx, 0x20(%r12)
movw $0x0, 0x30(%r12)
xorl %eax, %eax
movq %rax, 0x8(%r12)
movl %ebp, 0x38(%r12)
movq %rax, 0x40(%r12)
movl %eax, 0x32(%r12)
movl %eax, 0x48(%r12)
xorps %xmm0, %xmm0
movups %xmm0, 0x10(%r12)
movups %xmm0, 0x50(%r12)
movq %rax, 0x60(%r12)
movq %r12, %rax
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/theovosse[P]llgen/llgen.c
// Function: InsertSymbol
Name InsertSymbol(char *str, NodeList rules, Boolean lhs, NameType nameType) {
	Name name = GetInfo(FindNode(idTree, str, (TreeCmp) NameCmpStr));

	if (name == NULL) {
		name = MakeName(str, -1, nameType, lineNumber);
		InsertNodeSingle(&idTree, name, name, (TreeCmp) NameCmp);
	}
	if (lhs) {
		if (name->rules == NULL && name->nameType != token) {
			name->rules = rules;
		} else {
			yyerror("lhs %s already used", str);
		}
	}
	return (name);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movl %ecx, %r12d
movl %edx, %ebp
movq %rsi, %r14
movq %rdi, %rbx
movq 0x15ce3(%rip), %rdi     # 0x19b00
leaq 0x84(%rip), %rdx        # 0x3ea8
movq %rbx, %rsi
callq 0xbf59
movq %rax, %rdi
callq 0xbeb9
movq %rax, %r15
testq %rax, %rax
jne 0x3e72
leaq 0x15361(%rip), %rax     # 0x191a4
movswl (%rax), %ecx
movq %rbx, %rdi
movl $0xffffffff, %esi       # imm = 0xFFFFFFFF
movl %r12d, %edx
callq 0x3d88
movq %rax, %r15
leaq 0x15ca0(%rip), %rdi     # 0x19b00
leaq 0x49(%rip), %rcx        # 0x3eb0
movq %rax, %rsi
movq %rax, %rdx
callq 0xbaa8
testw %bp, %bp
je 0x3e89
cmpq $0x0, 0x18(%r15)
jne 0x3e95
cmpl $0x4, 0x38(%r15)
je 0x3e95
movq %r14, 0x18(%r15)
movq %r15, %rax
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
leaq 0xd274(%rip), %rdi      # 0x11110
movq %rbx, %rsi
xorl %eax, %eax
callq 0x3250
jmp 0x3e89
// File: /workspace/github_c_makefile_star2_O1/theovosse[P]llgen/llgen.c
// Function: InsertString
Name InsertString(char *str) {
	Name name = GetInfo(FindNode(idTree, str, (TreeCmp) NameCmpStr));

	if (name == NULL) {
		name = MakeName(str, ++nodeNumber, string, lineNumber);
		InsertNodeSingle(&idTree, name, name, (TreeCmp) NameCmp);
	}
	return (name);
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
movq 0x15c1f(%rip), %rdi     # 0x19b00
leaq -0x40(%rip), %rdx       # 0x3ea8
movq %rbx, %rsi
callq 0xbf59
movq %rax, %rdi
callq 0xbeb9
movq %rax, %r14
testq %rax, %rax
jne 0x3f41
movl 0x15c02(%rip), %esi     # 0x19b08
incl %esi
movl %esi, 0x15bfa(%rip)     # 0x19b08
leaq 0x1528f(%rip), %rax     # 0x191a4
movswl (%rax), %ecx
movq %rbx, %rdi
movl $0x1, %edx
callq 0x3d88
movq %rax, %r14
leaq 0x15bd1(%rip), %rdi     # 0x19b00
leaq -0x86(%rip), %rcx       # 0x3eb0
movq %rax, %rsi
movq %rax, %rdx
callq 0xbaa8
movq %r14, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O1/theovosse[P]llgen/llgen.c
// Function: AssignString
void AssignString(Name name, Name str) {
	if (name->rules == NULL && name->nameType == identifier) {
		name->nameType = token;
		name->index = str->index;
	} else {
		yyerror("token already defined as lhs %s", name->name);
	}
}

// Assembly:
cmpq $0x0, 0x18(%rdi)
jne 0x3f69
cmpl $0x0, 0x38(%rdi)
jne 0x3f69
movl $0x4, 0x38(%rdi)
movq 0x28(%rsi), %rax
movq %rax, 0x28(%rdi)
retq
movq (%rdi), %rsi
leaq 0xd1b1(%rip), %rdi      # 0x11124
xorl %eax, %eax
jmp 0x3250
// File: /workspace/github_c_makefile_star2_O1/theovosse[P]llgen/llgen.c
// Function: KeywordString
void KeywordString(Name name, Name str, Name ident) {
    if (name->keywords != NULL || name->functions != NULL) {
		yyerror("no keyword hierarchie allowed: %s", name->name);
	} else if (name->rules == NULL && name->nameType == identifier && (ident->nameType == identifier || ident->nameType == token)) {
		name->nameType = token;
		if (str == NULL) {
			name->index = ++nodeNumber;
		} else {
			name->index = str->index;
			str->index = 0;
		}
		ident->nameType = token;
		InsertNodeSingle(&ident->keywords, str, name, (TreeCmp) NameCmp);
		AddProperty("keywords");
	} else if (ident->nameType != identifier && ident->nameType != token) {
		yyerror("identifier already defined as lhs %s", ident->name);
	} else {
		yyerror("token already defined as lhs %s", name->name);
	}
}

// Assembly:
movq %rdi, %rax
cmpq $0x0, 0x58(%rdi)
jne 0x401b
cmpq $0x0, 0x60(%rax)
jne 0x401b
cmpq $0x0, 0x18(%rax)
jne 0x4006
cmpl $0x0, 0x38(%rax)
jne 0x4006
testl $0xfffffffb, 0x38(%rdx) # imm = 0xFFFFFFFB
jne 0x4006
movl $0x4, 0x38(%rax)
testq %rsi, %rsi
je 0x3fc7
movq 0x28(%rsi), %rcx
movq %rcx, 0x28(%rax)
movq $0x0, 0x28(%rsi)
jmp 0x3fdb
movslq 0x15b3a(%rip), %rcx     # 0x19b08
incq %rcx
movl %ecx, 0x15b31(%rip)     # 0x19b08
movq %rcx, 0x28(%rax)
pushq %rax
movl $0x4, 0x38(%rdx)
addq $0x58, %rdx
leaq -0x13e(%rip), %rcx      # 0x3eb0
movq %rdx, %rdi
movq %rax, %rdx
callq 0xbaa8
leaq 0xd166(%rip), %rdi      # 0x11166
popq %rax
jmp 0x3c29
testl $0xfffffffb, 0x38(%rdx) # imm = 0xFFFFFFFB
jne 0x4027
movq (%rax), %rsi
leaq 0xd10b(%rip), %rdi      # 0x11124
jmp 0x4031
movq (%rax), %rsi
leaq 0xd11f(%rip), %rdi      # 0x11144
jmp 0x4031
movq (%rdx), %rsi
leaq 0xd13e(%rip), %rdi      # 0x1116f
xorl %eax, %eax
jmp 0x3250
// File: /workspace/github_c_makefile_star2_O1/theovosse[P]llgen/llgen.c
// Function: Function
void Function(Name name, Name fun, Name ident) {
	if (name->keywords != NULL || name->functions != NULL) {
		yyerror("no function hierarchie allowed: %s", name->name);
	} else if (name->rules == NULL && name->nameType == identifier && (ident->nameType == identifier || ident->nameType == token)) {
		name->nameType = token;
		name->index = ++nodeNumber;
		fun->index = 0;
		fun->nameType = function;
		ident->nameType = token;
		InsertNodeSingle(&ident->functions, fun, name, (TreeCmp) NameCmp);
		AddProperty("functions");
	} else if (ident->nameType != identifier && ident->nameType != token) {
		yyerror("identifier already defined as lhs %s", ident->name);
	} else {
		yyerror("token already defined as lhs %s", name->name);
	}
}

// Assembly:
movq %rdi, %rax
cmpq $0x0, 0x58(%rdi)
jne 0x40ca
cmpq $0x0, 0x60(%rax)
jne 0x40ca
cmpq $0x0, 0x18(%rax)
jne 0x40b5
cmpl $0x0, 0x38(%rax)
jne 0x40b5
testl $0xfffffffb, 0x38(%rdx) # imm = 0xFFFFFFFB
jne 0x40b5
pushq %rax
movl $0x4, %ecx
movl %ecx, 0x38(%rax)
movslq 0x15a95(%rip), %rdi     # 0x19b08
incq %rdi
movl %edi, 0x15a8c(%rip)     # 0x19b08
movq %rdi, 0x28(%rax)
movq $0x0, 0x28(%rsi)
movl $0x5, 0x38(%rsi)
movl %ecx, 0x38(%rdx)
addq $0x60, %rdx
leaq -0x1ed(%rip), %rcx      # 0x3eb0
movq %rdx, %rdi
movq %rax, %rdx
callq 0xbaa8
leaq 0xd3f5(%rip), %rdi      # 0x114a4
popq %rax
jmp 0x3c29
testl $0xfffffffb, 0x38(%rdx) # imm = 0xFFFFFFFB
jne 0x40d6
movq (%rax), %rsi
leaq 0xd05c(%rip), %rdi      # 0x11124
jmp 0x40e0
movq (%rax), %rsi
leaq 0xd0c0(%rip), %rdi      # 0x11194
jmp 0x40e0
movq (%rdx), %rsi
leaq 0xd08f(%rip), %rdi      # 0x1116f
xorl %eax, %eax
jmp 0x3250
// File: /workspace/github_c_makefile_star2_O1/theovosse[P]llgen/llgen.c
// Function: MakeNodeList
NodeList MakeNodeList(Node first, NodeList rest) {
	NodeList nodeList = (NodeList) mmalloc(sizeof(struct NodeList));

	nodeList->first = first;
	nodeList->rest = rest;
	nodeList->empty = false;
	return (nodeList);
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq %rdi, %r14
movl $0x18, %edi
callq 0xc614
movq %r14, (%rax)
movq %rbx, 0x8(%rax)
movw $0x0, 0x10(%rax)
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O1/theovosse[P]llgen/llgen.c
// Function: containsGrammarSymbol
Boolean containsGrammarSymbol(NodeList list) {
	NodeList ptr = list;

	while (ptr != NULL) {
		if (nodeContainsGrammarSymbol(ptr->first)) {
			return true;
		}
		ptr = ptr->rest;
	}
	return false;
}

// Assembly:
testq %rdi, %rdi
je 0x41a6
pushq %rbx
movq %rdi, %rbx
movq (%rbx), %rdi
callq 0x41af
testw %ax, %ax
jne 0x41a9
movq 0x8(%rbx), %rbx
testq %rbx, %rbx
jne 0x418c
xorl %eax, %eax
jmp 0x41ad
xorl %eax, %eax
retq
movw $0xffff, %ax            # imm = 0xFFFF
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O1/theovosse[P]llgen/llgen.c
// Function: nodeContainsGrammarSymbol
static Boolean nodeContainsGrammarSymbol(Node node) {
	while (node != NULL) {
		switch (node->nodeType) {
			case single:
				if (node->element.name->nameType != code && node->element.name->nameType != output) {
					return true;
				}
				break;
			case option:
				if (nodeContainsGrammarSymbol(node->element.sub)) {
					return true;
				}
				break;
			case sequence:
				if (nodeContainsGrammarSymbol(node->element.sub)) {
					return true;
				}
				break;
			case chain:
				if (nodeContainsGrammarSymbol(node->element.sub->element.sub) ||
					  nodeContainsGrammarSymbol(node->element.sub->next->element.sub)) {
					return true;
				}
			case alternative:
				if (containsGrammarSymbol(node->element.alternatives)) {
					return true;
				}
				break;
			case breakToken:
			case errorMessage:
				return true;
		}
		node = node->next;
	}
	return false;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
testq %rdi, %rdi
je 0x4257
movq %rdi, %rbx
leaq 0xce3a(%rip), %r14      # 0x11004
movl 0x4(%rbx), %eax
cmpq $0x6, %rax
ja 0x424a
movw $0xffff, %bp            # imm = 0xFFFF
movslq (%r14,%rax,4), %rax
addq %r14, %rax
jmpq *%rax
movq 0x18(%rbx), %rdi
callq 0x41af
testw %ax, %ax
je 0x424a
jmp 0x4259
movq 0x18(%rbx), %r15
movq 0x18(%r15), %rdi
callq 0x41af
testw %ax, %ax
jne 0x4259
movq 0x28(%r15), %rax
movq 0x18(%rax), %rdi
callq 0x41af
testw %ax, %ax
jne 0x4259
movq 0x18(%rbx), %r15
testq %r15, %r15
sete %r12b
je 0x424a
movq (%r15), %rdi
callq 0x41af
testw %ax, %ax
jne 0x4245
movq 0x8(%r15), %r15
jmp 0x4218
movq 0x18(%rbx), %rax
movl 0x38(%rax), %eax
andl $-0x2, %eax
cmpl $0x2, %eax
je 0x424a
jmp 0x4259
testb %r12b, %r12b
je 0x4259
movq 0x28(%rbx), %rbx
testq %rbx, %rbx
jne 0x41ca
xorl %ebp, %ebp
movl %ebp, %eax
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/theovosse[P]llgen/llgen.c
// Function: doIndent
void doIndent(int level) {
    fputc('\n', outputFile);
	while (level != 0) {
		fputs("	", outputFile);
		level--;
	}
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movl %edi, %ebx
movq 0x15857(%rip), %rsi     # 0x19ae8
movl $0xa, %edi
callq 0x3130
testl %ebx, %ebx
je 0x42b9
leaq 0xcf11(%rip), %r14      # 0x111b7
movq 0x1583b(%rip), %rsi     # 0x19ae8
movq %r14, %rdi
callq 0x3110
decl %ebx
jne 0x42a6
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O1/theovosse[P]llgen/llgen.c
// Function: HasProperty
static Boolean HasProperty(char *property) {
	if (*property == '!') {
		return (FindNode(properties, property + 1, (TreeCmp) strcmp) == NULL);
	} else {
		return (FindNode(properties, property, (TreeCmp) strcmp) != NULL);
	}
}

// Assembly:
pushq %rax
movq %rdi, %rsi
cmpb $0x21, (%rdi)
movq 0x13732(%rip), %rdi     # 0x19af8
jne 0x63df
incq %rsi
movq 0x12bf6(%rip), %rdx     # 0x18fc8
callq 0xbf59
testq %rax, %rax
sete %al
jmp 0x63f1
movq 0x12be2(%rip), %rdx     # 0x18fc8
callq 0xbf59
testq %rax, %rax
setne %al
movzbl %al, %eax
popq %rcx
retq
// File: /workspace/github_c_makefile_star2_O1/theovosse[P]llgen/llgen.c
// Function: InsertElement
static Boolean InsertElement(TREE *first, Name name) {
	Name sym = GetInfo(FindNode(*first, name, (TreeCmp) NameCmp));

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

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq %rdi, %r14
movq (%rdi), %rdi
leaq -0x2560(%rip), %rdx     # 0x3eb0
callq 0xbf59
movq %rax, %rdi
callq 0xbeb9
testq %rax, %rax
je 0x6426
xorl %eax, %eax
jmp 0x643f
leaq -0x257d(%rip), %rcx     # 0x3eb0
movq %r14, %rdi
movq %rbx, %rsi
movq %rbx, %rdx
callq 0xbaa8
movw $0xffff, %ax            # imm = 0xFFFF
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O1/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 0xbe8a
xorl %ebp, %ebp
testq %rax, %rax
je 0x67f6
movq %rax, %r14
xorl %r15d, %r15d
movq %r14, %rdi
callq 0xbec6
movq %rbx, %rdi
movq %rax, %rsi
callq 0x63fc
negw %ax
movl $0x0, %ebp
sbbl %ebp, %ebp
orl %r15d, %ebp
movq %r14, %rdi
callq 0xbed2
movq %rax, %r14
movl %ebp, %r15d
testq %rax, %rax
jne 0x67c3
movl %ebp, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/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 0xab0f(%rip), %rdi      # 0x116d9
callq 0x63b8
testw %ax, %ax
jne 0x6be0
leaq 0x150b5(%rip), %rax     # 0x1bc90
movw $0xffff, (%rax)         # imm = 0xFFFF
callq 0xc92c
callq 0xcde8
movq %rax, %rbx
xorl %edi, %edi
callq 0xcab5
leaq 0xaae8(%rip), %rdi      # 0x116e3
callq 0x63b8
xorl %edi, %edi
testw %ax, %ax
setne %dil
shll $0x7, %edi
subl $-0x80, %edi
callq 0xcaa7
movq 0x12ee5(%rip), %rdi     # 0x19b00
callq 0xbe8a
testq %rax, %rax
je 0x6cfe
movq %rax, %r14
movq %rsp, %r15
movq %r14, %rdi
callq 0xbec6
cmpl $0x1, 0x38(%rax)
jne 0x6cd5
movq %rax, %r12
cmpq $0x0, 0x28(%rax)
je 0x6cd5
cmpw $0x0, 0x34(%r12)
je 0x6cd5
movq (%r12), %rbp
incq %rbp
movq %r15, %r13
incq %rbp
movzbl -0x1(%rbp), %eax
cmpl $0x5c, %eax
jne 0x6ca4
movzbl (%rbp), %ecx
testl %ecx, %ecx
je 0x6c90
cmpl $0x22, %ecx
je 0x6c97
cmpl $0x5c, %ecx
jne 0x6cad
movw $0x5c5c, (%r13)         # imm = 0x5C5C
addq $0x2, %r13
incq %rbp
jmp 0x6c62
callq 0x33c3
jmp 0x6c62
movb $0x22, (%r13)
incq %r13
incq %rbp
jmp 0x6c62
testl %eax, %eax
je 0x6cc1
cmpl $0x22, %eax
je 0x6cb6
movb %al, (%r13)
incq %r13
jmp 0x6c62
cmpb $0x0, (%rbp)
jne 0x6cf7
movb $0x0, (%r13)
movq 0x28(%r12), %rdx
movq %rbx, %rdi
movq %r15, %rsi
callq 0xce34
testl %eax, %eax
jne 0x6ceb
movq %r14, %rdi
callq 0xbed2
movq %rax, %r14
testq %rax, %rax
jne 0x6c2f
jmp 0x6cfe
movq %r12, %rdi
movl %eax, %esi
callq 0x33f9
jmp 0x6cd5
callq 0x33de
jmp 0x6cbc
movq %rbx, %rdi
callq 0xda41
movq %rax, 0x12e23(%rip)     # 0x19b30
movq %rax, %rdi
callq 0xde6b
addq $0x108, %rsp            # imm = 0x108
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/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 0x12ae8(%rip), %rdi     # 0x19ae8
movq 0x12179(%rip), %rax     # 0x19180
movq 0x48(%rax), %rdx
movl 0x12af6(%rip), %r9d     # 0x19b08
addl $0x2, %r9d
movl $0xffffffff, (%rsp)     # imm = 0xFFFFFFFF
leaq 0xa5ee(%rip), %rsi      # 0x11612
leaq 0xa7a1(%rip), %rcx      # 0x117cc
movq $-0x1, %r8
callq *0xc0(%rax)
movq 0x12aa9(%rip), %rsi     # 0x19ae8
leaq 0xa790(%rip), %rdi      # 0x117d6
callq 0x3110
cmpl $0x0, 0x12ab6(%rip)     # 0x19b08
jle 0x70c7
leaq 0xa796(%rip), %rbx      # 0x117f1
leaq 0xa789(%rip), %r14      # 0x117eb
leaq 0xa77a(%rip), %r15      # 0x117e3
xorl %ebp, %ebp
incl %ebp
movl %ebp, %edi
movl $0xffffffff, %esi       # imm = 0xFFFFFFFF
callq 0x7b34
testq %rax, %rax
je 0x709a
movl 0x38(%rax), %ecx
cmpl $0x1, %ecx
je 0x70ab
cmpl $0x4, %ecx
jne 0x709a
movq 0x12a56(%rip), %rdi     # 0x19ae8
movq (%rax), %rdx
movq %r15, %rsi
jmp 0x70b8
movq 0x12a47(%rip), %rsi     # 0x19ae8
movq %rbx, %rdi
callq 0x3110
jmp 0x70bf
movq 0x12a36(%rip), %rdi     # 0x19ae8
movq (%rax), %rdx
movq %r14, %rsi
xorl %eax, %eax
callq 0x3160
cmpl 0x12a43(%rip), %ebp     # 0x19b08
jl 0x706b
movq 0x12a1a(%rip), %rsi     # 0x19ae8
leaq 0xa729(%rip), %rdi      # 0x117fe
callq 0x3110
movq 0x12a07(%rip), %rdi     # 0x19ae8
movq 0x12098(%rip), %rax     # 0x19180
movq 0x70(%rax), %rdx
movq 0x78(%rax), %rcx
leaq 0xa548(%rip), %rsi      # 0x1163f
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
jmp 0x3160
// File: /workspace/github_c_makefile_star2_O1/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 %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rdx, %rbx
movq %rdi, %r14
movq 0x1181c(%rip), %rax     # 0x19180
movq 0x110(%rax), %rax
testq %rcx, %rcx
je 0x7975
movq (%rcx), %rdx
jmp 0x797c
leaq 0x9bc1(%rip), %rdx      # 0x1153d
movq %r14, %rdi
callq *%rax
testq %rbx, %rbx
je 0x7a6c
movw $0xffff, %r12w          # imm = 0xFFFF
xorl %r13d, %r13d
leaq 0xbcae(%rip), %r15      # 0x13647
movq 0x18(%rbx), %rbp
movq %rbp, %rdi
movq %r15, %rsi
callq 0x3240
orl %r13d, %eax
movw $0xffff, %ax            # imm = 0xFFFF
movl $0x0, %ecx
je 0x7a59
movswl (%rbx), %edx
xorl %eax, %eax
testw %r12w, %r12w
sete %al
movq 0x117b3(%rip), %rcx     # 0x19180
movq %r14, %rdi
movq %rbp, %rsi
callq *0x118(%rcx,%rax,8)
movq %rbp, %rdi
leaq 0xb816(%rip), %rsi      # 0x131fa
callq 0x3240
testl %eax, %eax
je 0x7a51
movq %rbp, %rdi
leaq 0x97e6(%rip), %rsi      # 0x111dd
callq 0x3240
testl %eax, %eax
je 0x7a51
movq %rbp, %rdi
leaq 0xbd2f(%rip), %rsi      # 0x13739
callq 0x3240
testl %eax, %eax
je 0x7a51
movq %rbp, %rdi
leaq 0xb787(%rip), %rsi      # 0x131a4
callq 0x3240
testl %eax, %eax
je 0x7a4c
movq %rbp, %rdi
leaq 0xb44f(%rip), %rsi      # 0x12e7f
callq 0x3240
testl %eax, %eax
je 0x7a4c
movq %rbp, %rdi
leaq 0xb68e(%rip), %rsi      # 0x130d1
callq 0x3240
testl %eax, %eax
jne 0x7a54
decl %r13d
jmp 0x7a54
incl %r13d
xorl %eax, %eax
movl %r13d, %ecx
movq 0x28(%rbx), %rbx
movl %ecx, %r13d
movl %eax, %r12d
testq %rbx, %rbx
jne 0x7999
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/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 0x7acb
movq 0x10(%rdi), %rsi
testq %rsi, %rsi
je 0x7acb
movq 0x120b6(%rip), %rdi     # 0x19b50
leaq 0x42(%rip), %rdx        # 0x7ae3
callq 0xbf59
testq %rax, %rax
je 0x7acb
movq %rax, %rdi
callq 0xbeb9
leaq 0x12086(%rip), %rdi     # 0x19b40
leaq 0x9c0b(%rip), %rsi      # 0x116cc
movl %eax, %edx
xorl %eax, %eax
popq %rcx
jmp 0x31f0
movq 0x116ae(%rip), %rax     # 0x19180
movq 0x40(%rax), %rsi
leaq 0x12063(%rip), %rdi     # 0x19b40
popq %rax
jmp 0x3080
// File: /workspace/github_c_makefile_star2_O1/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
je 0x7b21
testq %rsi, %rsi
je 0x7b21
movq (%rdi), %rcx
movq (%rsi), %rdx
movq 0x8(%rcx), %rcx
movq 0x8(%rdx), %rdx
cmpq %rdx, %rcx
jbe 0x7b07
movl $0x1, %eax
jmp 0x7b0e
jae 0x7b12
movl $0xffffffff, %eax       # imm = 0xFFFFFFFF
xorl %ecx, %ecx
jmp 0x7b1c
movq 0x8(%rdi), %rdi
movq 0x8(%rsi), %rsi
movb $0x1, %cl
testb %cl, %cl
jne 0x7ae3
retq
xorl %ecx, %ecx
negq %rsi
sbbl %ecx, %ecx
testq %rdi, %rdi
movl $0x1, %eax
cmovel %ecx, %eax
retq
// File: /workspace/github_c_makefile_star2_O1/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 0x11fba(%rip), %rdi     # 0x19b00
callq 0xbe8a
testq %rax, %rax
je 0x7b7a
movq %rax, %r14
movslq %ebx, %r15
movq %r14, %rdi
callq 0xbec6
cmpl $0x4, 0x38(%rax)
jne 0x7b6a
cmpq %r15, 0x28(%rax)
je 0x7bbc
movq %r14, %rdi
callq 0xbed2
movq %rax, %r14
testq %rax, %rax
jne 0x7b56
testw %bp, %bp
je 0x7bba
movq 0x11f7a(%rip), %rdi     # 0x19b00
callq 0xbe8a
testq %rax, %rax
je 0x7bba
movq %rax, %r14
movslq %ebx, %rbx
movq %r14, %rdi
callq 0xbec6
cmpl $0x1, 0x38(%rax)
jne 0x7baa
cmpq %rbx, 0x28(%rax)
je 0x7bbc
movq %r14, %rdi
callq 0xbed2
movq %rax, %r14
testq %rax, %rax
jne 0x7b96
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/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 0xfb1f(%rip), %rax      # 0x19180
movq 0x10480(%rip), %rsi     # 0x19ae8
testw %di, %di
je 0x96a6
pushq %rax
movq 0x98(%rax), %rdi
callq 0x3110
movq 0x10467(%rip), %rsi     # 0x19ae8
movl $0x20, %edi
callq 0x3130
movq 0xfaee(%rip), %rax      # 0x19180
movq 0x88(%rax), %rdi
movq 0x10448(%rip), %rsi     # 0x19ae8
popq %rax
jmp 0x3110
movq 0x90(%rax), %rdi
jmp 0x3110
// File: /workspace/github_c_makefile_star2_O1/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 0xbe8a
testq %rax, %rax
je 0x9722
movq %rax, %r14
movq %rax, %rdi
callq 0xbec6
movq (%rax), %rdi
movq %rbx, %rsi
callq 0x3110
movq %r14, %rdi
callq 0xbed2
testq %rax, %rax
je 0x9722
movq %rax, %r14
leaq 0x7dfb(%rip), %r15      # 0x114ef
movq %r15, %rdi
movq %rbx, %rsi
callq 0x3110
movq %r14, %rdi
callq 0xbec6
movq (%rax), %rdi
movq %rbx, %rsi
callq 0x3110
movq %r14, %rdi
callq 0xbed2
movq %rax, %r14
testq %rax, %rax
jne 0x96f4
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O1/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 0x10431(%rip), %rdi     # 0x19b68
leaq 0x396(%rip), %rdx       # 0x9ad4
movq %rbx, %rsi
callq 0xbf59
movq %rax, %r14
testq %rax, %rax
je 0x9782
movq 0xfa2b(%rip), %rax      # 0x19180
movq 0x100(%rax), %r15
movq 0x10385(%rip), %rbx     # 0x19ae8
movq %r14, %rdi
callq 0xbeb9
leaq 0x804f(%rip), %rsi      # 0x117c1
movq %rbx, %rdi
movq %rax, %rdx
movq %r15, %rax
popq %rbx
popq %r14
popq %r15
jmpq *%rax
movq %rbx, %rdi
callq 0x3734
jmp 0x974e
// File: /workspace/github_c_makefile_star2_O1/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 0x103cb(%rip), %rdi     # 0x19b68
leaq 0x330(%rip), %rdx       # 0x9ad4
callq 0xbf59
testq %rax, %rax
je 0x97b6
addq $0x8, %rsp
popq %rbx
popq %r14
retq
incq 0x1039b(%rip)           # 0x19b58
movq %rbx, %rdi
xorl %esi, %esi
xorl %edx, %edx
callq 0xc25e
movq 0x10388(%rip), %rdx     # 0x19b58
leaq 0x10391(%rip), %rdi     # 0x19b68
leaq 0x2f6(%rip), %rcx       # 0x9ad4
movq %rax, %rsi
callq 0xbaa8
movq 0xf993(%rip), %r11      # 0x19180
movq 0x50(%r11), %r10
movq 0x10360(%rip), %r8      # 0x19b58
movl 0x1030a(%rip), %eax     # 0x19b08
incl %eax
cltd
idivl 0xf969(%rip)            # 0x19170
leal 0x1(%rax), %r9d
movl $0xffffffff, (%rsp)     # imm = 0xFFFFFFFF
leaq 0x7df9(%rip), %rsi      # 0x11612
leaq 0x7fa1(%rip), %rcx      # 0x117c1
movq %r14, %rdi
movq %r10, %rdx
callq *0xc0(%r11)
movq %r14, %rdi
movq %rbx, %rsi
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x7728
// File: /workspace/github_c_makefile_star2_O1/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 0x9b61
movq %rax, %r14
movq %rbx, %rdi
callq 0x9b61
movq %rax, %rbx
movq %r14, %rdi
movq %rax, %rsi
callq 0x9bf7
movq %rax, %r15
movq %r14, %rdi
xorl %esi, %esi
callq 0xc008
movq %rbx, %rdi
xorl %esi, %esi
callq 0xc008
movq %r15, %rax
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O1/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 0x9a90
cmpl $0x6, %edx
jne 0x9aae
movq 0x18(%rsi), %rax
movq 0x18(%rax), %rax
movl 0x38(%rax), %ecx
cmpl $0x1, %ecx
je 0x9aa6
cmpl $0x4, %ecx
je 0x9aa6
testl %ecx, %ecx
je 0x9ac6
retq
movq %rax, %rsi
jmp 0x63fc
movq 0xf543(%rip), %rax      # 0x18ff8
movq (%rax), %rdi
leaq 0x8175(%rip), %rsi      # 0x11c34
xorl %eax, %eax
jmp 0x3160
pushq %rax
movq %rsi, %rdi
callq 0x376e
addq $0x8, %rsp
retq
// File: /workspace/github_c_makefile_star2_O1/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
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %r14
callq 0xbe8a
movq %rax, %rbx
movq %r14, %rdi
callq 0xbe8a
movq %rax, %r14
testq %rbx, %rbx
je 0x9b42
testq %r14, %r14
je 0x9b42
movq %rbx, %rdi
callq 0xbec6
movq %rax, %r15
movq %r14, %rdi
callq 0xbec6
movq (%r15), %rdi
movq (%rax), %rsi
callq 0x3240
movl %eax, %r15d
testl %eax, %eax
je 0x9b25
movl %r15d, %ebp
jmp 0x9b3b
movq %rbx, %rdi
callq 0xbed2
movq %rax, %rbx
movq %r14, %rdi
callq 0xbed2
movq %rax, %r14
testl %r15d, %r15d
je 0x9af1
jmp 0x9b54
xorl %eax, %eax
negq %r14
sbbl %eax, %eax
testq %rbx, %rbx
movl $0x1, %ebp
cmovel %eax, %ebp
movl %ebp, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/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 0xbe8a
testq %rax, %rax
je 0x9be7
movq %rax, %rbx
leaq -0x5cd5(%rip), %r14     # 0x3eb0
movq %rsp, %r15
movq 0xffd1(%rip), %r12      # 0x19b60
movq %rbx, %rdi
callq 0xbec6
movq %r12, %rdi
movq %rax, %rsi
movq %r14, %rdx
callq 0xbf59
testq %rax, %rax
je 0x9bbf
movq %rax, %rdi
callq 0xbeb9
movq %r15, %rdi
movq %rax, %rsi
callq 0x67a4
jmp 0x9bd7
movq %rbx, %rdi
callq 0xbec6
movq %r15, %rdi
movq %rax, %rsi
xorl %edx, %edx
movq %r14, %rcx
callq 0xbaa8
movq %rbx, %rdi
callq 0xbed2
movq %rax, %rbx
testq %rax, %rax
jne 0x9b88
movq (%rsp), %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O1/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 0xbe8a
testq %rax, %rax
je 0x9c78
movq %rax, %r14
leaq -0x5d74(%rip), %r15     # 0x3eb0
leaq 0x8(%rsp), %r12
movq %r14, %rdi
callq 0xbec6
movq %rbx, %rdi
movq %rax, %rsi
movq %r15, %rdx
callq 0xbf59
testq %rax, %rax
je 0x9c68
movq %r14, %rdi
callq 0xbec6
movq %rax, %r13
movq %r14, %rdi
callq 0xbec6
movq %r12, %rdi
movq %r13, %rsi
movq %rax, %rdx
movq %r15, %rcx
callq 0xbaa8
movq %r14, %rdi
callq 0xbed2
movq %rax, %r14
testq %rax, %rax
jne 0x9c29
movq 0x8(%rsp), %rax
addq $0x10, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
nop
// File: /workspace/github_c_makefile_star2_O1/theovosse[P]llgen/avl3.c
// Function: TraverseTreeInOrder
void TraverseTreeInOrder(tree, proc)
TREE tree;
void (*proc)(void *, void *);
{
	if (tree != NULL)
	{
		TraverseTreeInOrder(tree->left, proc);
		(*proc)(tree->key, tree->info);
		TraverseTreeInOrder(tree->right, proc);
	}
}

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

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rdx, %rbx
movq %rsi, %r14
movq %rdi, %r15
testq %r15, %r15
je 0xbf53
movq 0x10(%r15), %rdi
movq %r14, %rsi
movq %rbx, %rdx
callq 0xbf1e
movq (%r15), %rdi
movq 0x8(%r15), %rsi
movq %rbx, %rdx
callq *%r14
movq 0x18(%r15), %r15
jmp 0xbf2c
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O1/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
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
testq %rdi, %rdi
je 0xbf95
movq %rdx, %r14
movq %rsi, %r15
xorl %ebp, %ebp
movq (%rbx), %rdi
movq %r15, %rsi
callq *%r14
testl %eax, %eax
je 0xbf87
shrl $0x1f, %eax
movq 0x10(%rbx,%rax,8), %rbx
jmp 0xbf8b
movw $0xffff, %bp            # imm = 0xFFFF
testq %rbx, %rbx
je 0xbf95
testw %bp, %bp
je 0xbf70
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/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 %r13
pushq %r12
pushq %rbx
testq %rdi, %rdi
je 0xbff9
movq %rdx, %r14
movq %rsi, %r15
movq %rdi, %rbx
xorl %r12d, %r12d
xorl %r13d, %r13d
movq (%rbx), %rdi
movq %r15, %rsi
callq *%r14
testl %eax, %eax
je 0xbfdf
movl %eax, %ecx
shrl $0x1f, %ecx
testl %eax, %eax
cmovnsq %rbx, %r12
movq 0x10(%rbx,%rcx,8), %rbx
jmp 0xbfe4
movw $0xffff, %r13w          # imm = 0xFFFF
testq %rbx, %rbx
je 0xbfef
testw %r13w, %r13w
je 0xbfc0
testw %r13w, %r13w
cmoveq %r12, %rbx
jmp 0xbffb
xorl %ebx, %ebx
movq %rbx, %rax
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O1/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 0xc054
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %r14
movq %rdi, %rbx
movq 0x10(%rdi), %rdi
callq 0xc008
testq %r14, %r14
je 0xc02f
movq (%rbx), %rdi
movq 0x8(%rbx), %rsi
callq *%r14
movq 0x18(%rbx), %rdi
movq %r14, %rsi
callq 0xc008
movq 0xfbee(%rip), %rax      # 0x1bc30
movq %rax, 0x10(%rbx)
movq %rbx, 0xfbe3(%rip)      # 0x1bc30
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O1/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 0xc0c2
movq %rsi, %r14
movq %rdi, %r15
movq 0x10(%rdi), %rdi
callq 0xc080
movq %rax, %r12
movq 0x18(%r15), %rdi
movq %r14, %rsi
callq 0xc080
movq %rax, %rbx
addq %r12, %rbx
testq %r14, %r14
je 0xc0c6
movq (%r15), %rdi
movq 0x8(%r15), %rsi
callq *%r14
jmp 0xc0cb
xorl %ebx, %ebx
jmp 0xc0ce
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_O1/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 0xc28d
movq %rdx, %r15
movq %rsi, %r12
movq %rdi, %r14
movq 0xf9b5(%rip), %rbx      # 0x1bc30
testq %rbx, %rbx
je 0xc291
movq 0x10(%rbx), %rax
movq %rax, 0xf9a5(%rip)      # 0x1bc30
jmp 0xc2a3
xorl %ebx, %ebx
jmp 0xc2f4
movl $0x38, %edi
callq 0xc614
movq %rax, %rbx
testq %rax, %rax
je 0xc31a
movq (%r14), %rax
testq %r12, %r12
je 0xc2b1
movq %rax, %rdi
callq *%r12
movq %rax, (%rbx)
movq 0x8(%r14), %rax
testq %r15, %r15
je 0xc2c3
movq %rax, %rdi
callq *%r15
movq %rax, 0x8(%rbx)
movq 0x10(%r14), %rdi
movq %r12, %rsi
movq %r15, %rdx
callq 0xc25e
movq %rax, 0x10(%rbx)
movq 0x18(%r14), %rdi
movq %r12, %rsi
movq %r15, %rdx
callq 0xc25e
movq %rax, 0x18(%rbx)
movl 0x30(%r14), %eax
movl %eax, 0x30(%rbx)
movq %rbx, %rdi
xorl %esi, %esi
callq 0xc31f
testq %rax, %rax
je 0xc30b
movq $0x0, 0x20(%rax)
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
callq 0x396e
// File: /workspace/github_c_makefile_star2_O1/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 0xc347
movq %rdi, %rbx
movq 0x10(%rdi), %rdi
callq 0xc31f
movq %rax, 0x28(%rbx)
testq %rax, %rax
je 0xc33e
movq %rbx, 0x20(%rax)
movq 0x18(%rbx), %rdi
movq %rbx, %rsi
jmp 0xc320
movq %rsi, %rax
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O1/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 0xc368
callq 0xc34c
movq %rax, 0x18(%rbx)
movq %rbx, %rdi
popq %rbx
jmp 0xc396
movq %rbx, (%rsi)
movq 0x10(%rbx), %rax
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O1/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 0xc38d
callq 0xc371
movq %rax, 0x10(%rbx)
movq %rbx, %rdi
popq %rbx
jmp 0xc396
movq %rbx, (%rsi)
movq 0x18(%rbx), %rax
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O1/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 0xf56b(%rip), %rax      # 0x1bc50
testq %rax, %rax
je 0xc6f0
cmpl $0x3f, 0x4(%rax)
ja 0xc710
callq 0xc7ae
testq %rax, %rax
je 0xc7a9
movq 0xf54b(%rip), %rcx      # 0x1bc50
movq %rcx, 0x10(%rax)
movq %rax, 0xf540(%rip)      # 0x1bc50
movq 0xf541(%rip), %rcx      # 0x1bc58
movq 0xf532(%rip), %rax      # 0x1bc50
movq 0x8(%rax), %rdx
movq %rcx, (%rdx)
movq 0x8(%rax), %rcx
leaq 0x8(%rcx), %rdx
movq %rdx, 0x8(%rax)
movl 0x4(%rax), %edx
leal -0x8(%rdx), %esi
movl %esi, 0x4(%rax)
movq 0xf51f(%rip), %rsi      # 0x1bc60
movq %rsi, 0x8(%rcx)
movq 0x8(%rax), %rdi
leaq 0x8(%rdi), %rcx
movq %rcx, 0x8(%rax)
addl $-0x10, %edx
movl %edx, 0x4(%rax)
movl %edx, 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 0xc795
movl $0x4, %edi
subl %esi, %edi
subl %edi, %edx
movl %edx, 0x4(%rax)
addq %rdi, %rcx
movq %rcx, 0x8(%rax)
movq 0x8(%rax), %rcx
movq %rcx, 0xf4c0(%rip)      # 0x1bc60
movq %rax, 0xf4b1(%rip)      # 0x1bc58
popq %rax
retq
callq 0x3983
// File: /workspace/github_c_makefile_star2_O1/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 0xf4b2(%rip), %rax      # 0x1bc68
testq %rax, %rax
je 0xc7c8
movq 0x10(%rax), %rcx
movq %rcx, 0xf4a2(%rip)      # 0x1bc68
jmp 0xc7eb
movq 0xf471(%rip), %rax      # 0x1bc40
leaq -0x1(%rax), %rcx
cmpq $0x7fff, %rcx           # imm = 0x7FFF
movl $0x8000, %ebx           # imm = 0x8000
cmovbl %eax, %ebx
movl %ebx, %edi
callq 0xc614
movl %ebx, (%rax)
movl (%rax), %ecx
addl $-0x18, %ecx
movl %ecx, 0x4(%rax)
leaq 0x18(%rax), %rdx
leaq 0x1b(%rax), %rdi
testq %rdx, %rdx
cmovnsq %rdx, %rdi
movq %rdx, 0x8(%rax)
andq $-0x4, %rdi
movq %rdx, %rsi
subq %rdi, %rsi
je 0xc825
movl $0x4, %edi
subl %esi, %edi
subl %edi, %ecx
movl %ecx, 0x4(%rax)
addq %rdi, %rdx
movq %rdx, 0x8(%rax)
popq %rbx
retq