LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O2/theovosse[P]llgen/regexp.c
// Function: RemoveSet
void RemoveSet(ESet set) {
	ESet aux;

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

// Assembly:
movq 0xed90(%rip), %rdx      # 0x1acc8
movq 0xed69(%rip), %rax      # 0x1aca8
movq 0xed52(%rip), %rcx      # 0x1ac98
addq $0x10, %rcx
incq %rax
testq %rdi, %rdi
je 0xbf7e
movq 0x8(%rdi), %rsi
movq %rdx, 0x8(%rdi)
movq %rdi, 0xed67(%rip)      # 0x1acc8
movq %rax, 0xed40(%rip)      # 0x1aca8
movq %rcx, 0xed29(%rip)      # 0x1ac98
addq $0x10, %rcx
incq %rax
movq %rdi, %rdx
movq %rsi, %rdi
jmp 0xbf4d
retq
// File: /workspace/github_c_makefile_star2_O2/theovosse[P]llgen/regexp.c
// Function: SetMember
Boolean SetMember(void *element, ESet set) {
	while (set != NULL) {
		if (set->element == element) {
			return (true);
		}
		set = set->next;
	}
	return (false);
}

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

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

// Assembly:
testq %rdi, %rdi
je 0xbfd0
movq %rsi, %rax
testq %rax, %rax
je 0xbfcd
movq (%rax), %rcx
cmpq (%rdi), %rcx
je 0xbfc7
movq 0x8(%rax), %rax
jmp 0xbfb4
movq 0x8(%rdi), %rdi
jmp 0xbfac
xorl %eax, %eax
retq
movw $0xffff, %ax            # imm = 0xFFFF
retq
// File: /workspace/github_c_makefile_star2_O2/theovosse[P]llgen/regexp.c
// Function: MakeAnswer
Answer MakeAnswer(int number, void *info) {
	Answer answer = (Answer) temp_malloc(sizeof(struct Answer));

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

// Assembly:
pushq %rbp
pushq %rbx
pushq %rax
movq %rsi, %rbx
movl %edi, %ebp
pushq $0x10
popq %rdi
callq 0xba6d
testq %rax, %rax
je 0xc034
addq $0x10, 0xec49(%rip)     # 0x1ac70
movl %ebp, (%rax)
movq %rbx, 0x8(%rax)
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
leaq 0x5e9d(%rip), %rdi      # 0x11ed8
callq 0xbc52
pushq $0x1
popq %rdi
callq 0x3200
// File: /workspace/github_c_makefile_star2_O2/theovosse[P]llgen/regexp.c
// Function: CountNrStates
void CountNrStates(RegExp regExp) {
	Transition tr;

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

// Assembly:
testq %rdi, %rdi
je 0xc0c6
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
movq 0xec8d(%rip), %rax      # 0x1ace8
cmpq %rax, 0x20(%rdi)
je 0xc0bf
movq %rax, 0x20(%rbx)
movq 0xec84(%rip), %rax      # 0x1acf0
testq %rax, %rax
je 0xc07b
movq 0x28(%rbx), %rcx
movq %rbx, (%rax,%rcx,8)
jmp 0xc08f
movslq 0xec76(%rip), %rax      # 0x1acf8
leal 0x1(%rax), %ecx
movl %ecx, 0xec6d(%rip)      # 0x1acf8
movq %rax, 0x28(%rbx)
leaq 0x8(%rbx), %r14
movq (%r14), %r14
testq %r14, %r14
je 0xc0b7
movq 0x8(%r14), %rdi
callq 0xc048
addq $0x10, %r14
jmp 0xc093
movq 0x8(%rbx), %rdi
callq 0xc048
addq $0x10, %rbx
movq (%rbx), %rbx
testq %rbx, %rbx
jne 0xc0aa
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O2/theovosse[P]llgen/regexp.c
// Function: InitRegExp
RegExp InitRegExp(void) {
	RegExp regExp = (RegExp) temp_malloc(sizeof(struct RegExp));

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

// Assembly:
pushq %rax
pushq $0x30
popq %rdi
callq 0xba6d
addq $0x30, 0xeb98(%rip)     # 0x1ac70
incq 0xeba9(%rip)            # 0x1ac88
testq %rax, %rax
je 0xc109
andq $0x0, 0x10(%rax)
xorps %xmm0, %xmm0
movups %xmm0, (%rax)
movslq 0xebe6(%rip), %rcx      # 0x1acdc
leal 0x1(%rcx), %edx
movl %edx, 0xebdd(%rip)      # 0x1acdc
movq %rcx, 0x28(%rax)
movups %xmm0, 0x18(%rax)
popq %rcx
retq
leaq 0x5dd3(%rip), %rdi      # 0x11ee3
callq 0xbc52
pushq $0x1
popq %rdi
callq 0x3200
// File: /workspace/github_c_makefile_star2_O2/theovosse[P]llgen/regexp.c
// Function: AddRegExp
int AddRegExp(RegExp regExp, char *pattern, void *info) {
	RegExp end = NULL;
	char *rest;
	RegExp newRe;
	Answer answer;
	static int number = 0;

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

// Assembly:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x10, %rsp
movq %rsi, %r14
movq %rdi, %r12
leaq 0x8(%rsp), %r15
andq $0x0, (%r15)
movq %rdi, 0xeba0(%rip)      # 0x1ace0
movl 0xebb6(%rip), %edi      # 0x1acfc
leal 0x1(%rdi), %eax
movl %eax, 0xebad(%rip)      # 0x1acfc
movq %rdx, %rsi
callq 0xc00a
movq %rax, %rbx
xorl %edi, %edi
xorl %esi, %esi
xorl %edx, %edx
callq 0xbdaa
movq %rax, %r13
movq %r12, %rdi
movq %rax, %rsi
callq 0xbf7f
andl $0x0, 0xeb86(%rip)      # 0x1ad00
movq %r13, %rdi
movq %r14, %rsi
movq %r15, %rdx
callq 0xc1dc
movq %rax, %r14
movl 0xeb6f(%rip), %eax      # 0x1ad00
testl %eax, %eax
jne 0xc1ce
movq %rbx, %rdi
xorl %esi, %esi
callq 0xbec0
movq 0x8(%rsp), %rcx
movq %rax, 0x10(%rcx)
cmpb $0x0, (%r14)
setne %cl
movl 0xeb4b(%rip), %eax      # 0x1ad00
testl %eax, %eax
sete %dl
andb %cl, %dl
cmpb $0x1, %dl
jne 0xc1ce
movl $0x4, 0xeb35(%rip)      # 0x1ad00
pushq $0x4
popq %rax
addq $0x10, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O2/theovosse[P]llgen/regexp.c
// Function: choice
static char *choice(RegExp start, char *pattern, RegExp *end) {
	char *rest;
	char nextCh;
	Boolean special;
	char *rest2;
	RegExp startSequence = MakeRegExp(NULL, NULL, NULL);

	ELink(start, startSequence);
	rest2 = rest = sequence(startSequence, pattern, end);
	nextCh = chardenot(&rest2, &special, false);
	if (errorInExpression == 0 && nextCh == '|' && special) {
		RegExp endSequence = MakeRegExp(NULL, NULL, NULL);
		ELink(*end, endSequence);
		*end = endSequence;
		do {
			startSequence = MakeRegExp(NULL, NULL, NULL);
			ELink(start, startSequence);
			rest2 = rest = sequence(startSequence, rest2, &endSequence);
			nextCh = chardenot(&rest2, &special, false);
			ELink(endSequence, *end);
		}
		while (errorInExpression == 0 && nextCh == '|' && special);
	}
	return (rest);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %rdx, %rbx
movq %rsi, %r15
movq %rdi, %r14
xorl %edi, %edi
xorl %esi, %esi
xorl %edx, %edx
callq 0xbdaa
movq %rax, %r12
movq %r14, %rdi
movq %rax, %rsi
callq 0xbf7f
movq %r12, %rdi
movq %r15, %rsi
movq %rbx, %rdx
callq 0xdf67
movq %rax, %r15
leaq 0x8(%rsp), %rdi
movq %rax, (%rdi)
leaq 0x6(%rsp), %rsi
xorl %edx, %edx
callq 0xe535
cmpl $0x0, 0xeac8(%rip)      # 0x1ad00
jne 0xc2e7
cmpb $0x7c, %al
jne 0xc2e7
cmpw $0x0, 0x6(%rsp)
je 0xc2e7
xorl %edi, %edi
xorl %esi, %esi
xorl %edx, %edx
callq 0xbdaa
movq %rax, %r15
leaq 0x10(%rsp), %rax
movq %r15, (%rax)
movq (%rbx), %rdi
movq %r15, %rsi
callq 0xbf7f
movq %r15, (%rbx)
leaq 0x8(%rsp), %r13
leaq 0x6(%rsp), %rbp
xorl %edi, %edi
xorl %esi, %esi
xorl %edx, %edx
callq 0xbdaa
movq %rax, %r15
movq %r14, %rdi
movq %rax, %rsi
callq 0xbf7f
movq 0x8(%rsp), %rsi
movq %r15, %rdi
leaq 0x10(%rsp), %rdx
callq 0xdf67
movq %rax, %r15
movq %rax, 0x8(%rsp)
movq %r13, %rdi
movq %rbp, %rsi
xorl %edx, %edx
callq 0xe535
movl %eax, %r12d
movq 0x10(%rsp), %rdi
movq (%rbx), %rsi
callq 0xbf7f
cmpl $0x0, 0xea29(%rip)      # 0x1ad00
jne 0xc2e7
cmpb $0x7c, %r12b
jne 0xc2e7
cmpw $0x0, 0x6(%rsp)
jne 0xc280
movq %r15, %rax
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/theovosse[P]llgen/regexp.c
// Function: PrepareMatchNFA2
void PrepareMatchNFA2(RegExp regExp) {
	lastVisit++; globStateNr = 0;
	state = NULL;
	CountNrStates(regExp);
	push_localadm();
	state = (RegExp *) temp_malloc(globStateNr * sizeof(RegExp));
	stateState = (Boolean *) temp_malloc(globStateNr * sizeof(Boolean));
	oStates = (Boolean *) temp_malloc(globStateNr * sizeof(Boolean));
	if (state == NULL || stateState == NULL || oStates == NULL) {
		OutOfMemory("MatchNFA");
		return;
	}
	lastVisit++;
	CountNrStates(regExp);
}

// Assembly:
pushq %rbx
incq 0xe840(%rip)            # 0x1ace8
andl $0x0, 0xe849(%rip)      # 0x1acf8
movq %rdi, %rbx
andq $0x0, 0xe836(%rip)      # 0x1acf0
callq 0xc048
callq 0xbb78
movl 0xe82e(%rip), %edi      # 0x1acf8
shll $0x3, %edi
callq 0xba6d
movq %rax, 0xe817(%rip)      # 0x1acf0
movl 0xe819(%rip), %edi      # 0x1acf8
addl %edi, %edi
callq 0xba6d
movq %rax, 0xe81b(%rip)      # 0x1ad08
movl 0xe805(%rip), %edi      # 0x1acf8
addl %edi, %edi
callq 0xba6d
movq %rax, 0xe80f(%rip)      # 0x1ad10
cmpq $0x0, 0xe7e7(%rip)      # 0x1acf0
sete %cl
cmpq $0x0, 0xe7f4(%rip)      # 0x1ad08
sete %dl
orb %cl, %dl
testq %rax, %rax
sete %al
orb %dl, %al
cmpb $0x1, %al
jne 0xc532
leaq 0x59c2(%rip), %rdi      # 0x11eee
popq %rbx
jmp 0xbc52
incq 0xe7af(%rip)            # 0x1ace8
movq %rbx, %rdi
popq %rbx
jmp 0xc048
// File: /workspace/github_c_makefile_star2_O2/theovosse[P]llgen/regexp.c
// Function: MatchDFA
ESet MatchDFA(RegExp regExp, char *line) {
	RegExp currState = regExp;
	Transition tr;
	int currChar;

	for (currChar = (int) *line++ & 0xFF; currChar != '\0' && currState != NULL; currChar = *line++) {
		for (tr = currState->transitions, currState = NULL; tr != NULL && currState == NULL; tr = tr->next) {
			if (tr->transitionChar == currChar) {
				currState = tr->destination;
			}
		}
	}
	if (currState != NULL) {
		return ((ESet) currState->info);
	} else {
		return (NULL);
	}
}

// Assembly:
movzbl (%rsi), %eax
testl %eax, %eax
je 0xc792
testq %rdi, %rdi
je 0xc792
incq %rsi
xorl %ecx, %ecx
movq (%rdi), %rdi
testq %rdi, %rdi
je 0xc78a
testq %rcx, %rcx
jne 0xc78a
cmpl %eax, (%rdi)
jne 0xc782
movq 0x8(%rdi), %rcx
jmp 0xc784
xorl %ecx, %ecx
addq $0x10, %rdi
jmp 0xc76b
movsbl (%rsi), %eax
movq %rcx, %rdi
jmp 0xc75d
testq %rdi, %rdi
je 0xc79c
movq 0x10(%rdi), %rax
retq
xorl %eax, %eax
retq
// File: /workspace/github_c_makefile_star2_O2/theovosse[P]llgen/regexp.c
// Function: RemoveNFA
void RemoveNFA(RegExp nfa) {
	RegExp aux;
	Transition tr;
	Transition auxTr;

	while (nfa != NULL) {
		aux = nfa->next;
		for (tr = nfa->transitions; tr != NULL; tr = auxTr) {
			auxTr = tr->next;
			FreeTransition(tr);
		}
		for (tr = nfa->eTransitions; tr != NULL; tr = auxTr) {
			auxTr = tr->next;
			FreeTransition(tr);
		}
		if (nfa->info != NULL) {
			((ESet) nfa->info)->next = NULL;
			RemoveSet((ESet) nfa->info);
		}
		FreeRegExp(nfa);
		nfa = aux;
	}
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rdi, %rbx
testq %rbx, %rbx
je 0xcaed
movq (%rbx), %rdi
movq 0x18(%rbx), %r14
testq %rdi, %rdi
je 0xcab6
movq 0x10(%rdi), %r15
callq 0xcaf3
movq %r15, %rdi
jmp 0xcaa3
movq 0x8(%rbx), %rdi
testq %rdi, %rdi
je 0xcacd
movq 0x10(%rdi), %r15
callq 0xcaf3
movq %r15, %rdi
jmp 0xcaba
movq 0x10(%rbx), %rdi
testq %rdi, %rdi
je 0xcae0
andq $0x0, 0x8(%rdi)
callq 0xbf31
movq %rbx, %rdi
callq 0xcb15
movq %r14, %rbx
jmp 0xca97
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O2/theovosse[P]llgen/regexp.c
// Function: FreeTransition
static void FreeTransition(Transition tr) {
	tr->next = oldTransitions;
	oldTransitions = tr;
	nrOldTransitions++;
	totalFree += sizeof(struct Transition);
}

// Assembly:
movq 0xe1c6(%rip), %rax      # 0x1acc0
movq %rax, 0x10(%rdi)
incq 0xe1ab(%rip)            # 0x1acb0
movq %rdi, 0xe1b4(%rip)      # 0x1acc0
addq $0x18, 0xe184(%rip)     # 0x1ac98
retq
// File: /workspace/github_c_makefile_star2_O2/theovosse[P]llgen/regexp.c
// Function: FreeRegExp
static void FreeRegExp(RegExp re) {
	re->next = oldRegExps;
	oldRegExps = re;
	nrOldRegExps++;
	totalFree += sizeof(struct RegExp);
}

// Assembly:
movq 0xe19c(%rip), %rax      # 0x1acb8
movq %rax, 0x18(%rdi)
incq 0xe179(%rip)            # 0x1aca0
movq %rdi, 0xe18a(%rip)      # 0x1acb8
addq $0x30, 0xe162(%rip)     # 0x1ac98
retq
// File: /workspace/github_c_makefile_star2_O2/theovosse[P]llgen/regexp.c
// Function: EClosure
static ESet EClosure(ESet stateSet) {
	ESet *tail;
	ESet element;
	Transition tr;

	lastVisit++;
	for (element = stateSet; element->next != NULL; element = element->next) {
		((RegExp) element->element)->lastVisit = lastVisit;
	}
	((RegExp) element->element)->lastVisit = lastVisit;
	tail = &element->next;
	element = stateSet;
	while (element != NULL) {
		for (tr = ((RegExp) element->element)->eTransitions; tr != NULL; tr = tr->next) {
			if (tr->destination->lastVisit != lastVisit) {
				*tail = AddElement(tr->destination, NULL);
				tr->destination->lastVisit = lastVisit;
				tail = &((*tail)->next);
			}
		}
		element = element->next;
	}
	return (stateSet);
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rdi, %rbx
leaq 0xdfbf(%rip), %rax      # 0x1ace8
movq 0xdfb8(%rip), %rcx      # 0x1ace8
incq %rcx
movq %rdi, %r14
movq %rcx, (%rax)
movq 0x8(%r14), %rdx
testq %rdx, %rdx
je 0xcd4e
movq (%r14), %rax
addq $0x20, %rax
movq %rdx, %r14
jmp 0xcd36
movq (%r14), %rax
addq $0x8, %r14
movq %rcx, 0x20(%rax)
movq %rbx, %r15
testq %r15, %r15
je 0xcda9
movq (%r15), %r12
addq $0x8, %r12
movq (%r12), %r12
testq %r12, %r12
je 0xcda3
movq 0x8(%r12), %rdi
cmpq %rcx, 0x20(%rdi)
je 0xcd9d
xorl %esi, %esi
callq 0xbec0
movq %rax, (%r14)
movq 0xdf5b(%rip), %rcx      # 0x1ace8
movq 0x8(%r12), %rdx
movq %rcx, 0x20(%rdx)
addq $0x8, %rax
movq %rax, %r14
addq $0x10, %r12
jmp 0xcd68
movq 0x8(%r15), %r15
jmp 0xcd5c
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O2/theovosse[P]llgen/regexp.c
// Function: RenumberDFA
static void RenumberDFA(RegExp dfa) {
	long int dfaStateNumber = 0;
	RegExp state;

	for (state = dfa; state != NULL; state = state->next) {
		state->state.number = dfaStateNumber++;
		if (state->eTransitions != NULL) {
			fprintf(stderr, "epsilon transitions in dfa?\n");
		}
	}
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rdi, %rbx
xorl %r13d, %r13d
movq 0xb228(%rip), %rbp      # 0x17ff8
leaq 0x5334(%rip), %r14      # 0x1210b
pushq $0x1c
popq %r15
pushq $0x1
popq %r12
testq %rbx, %rbx
je 0xce0c
movq %r13, 0x28(%rbx)
cmpq $0x0, 0x8(%rbx)
jne 0xcdf8
movq 0x18(%rbx), %rbx
incq %r13
jmp 0xcddf
movq (%rbp), %rcx
movq %r14, %rdi
movq %r15, %rsi
movq %r12, %rdx
callq 0x3210
jmp 0xcdef
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/theovosse[P]llgen/regexp.c
// Function: RemoveDFA
void RemoveDFA(RegExp dfa) {
	RegExp aux;
	Transition tr, auxTr;

	while (dfa != NULL) {
		aux = dfa->next;
		for (tr = dfa->transitions; tr != NULL; tr = auxTr) {
			auxTr = tr->next;
			FreeTransition(tr);
		}
		RemoveSet((ESet) dfa->info);
		FreeRegExp(dfa);
		dfa = aux;
	}
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rdi, %rbx
testq %rbx, %rbx
je 0xce58
movq (%rbx), %rdi
movq 0x18(%rbx), %r14
testq %rdi, %rdi
je 0xce42
movq 0x10(%rdi), %r15
callq 0xcaf3
movq %r15, %rdi
jmp 0xce2f
movq 0x10(%rbx), %rdi
callq 0xbf31
movq %rbx, %rdi
callq 0xcb15
movq %r14, %rbx
jmp 0xce23
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O2/theovosse[P]llgen/regexp.c
// Function: MarkDFA
static void MarkDFA(RegExp dfa) {
	Transition tr;

	if (dfa->lastVisit != lastVisit) {
		dfa->lastVisit = lastVisit;
		for (tr = dfa->transitions; tr != NULL; tr = tr->next) {
			MarkDFA(tr->destination);
		}
	}
}

// Assembly:
movq 0xdb78(%rip), %rax      # 0x1ace8
cmpq %rax, 0x20(%rdi)
je 0xd196
pushq %rbx
movq %rdi, %rbx
movq %rax, 0x20(%rdi)
movq (%rbx), %rbx
testq %rbx, %rbx
je 0xd195
movq 0x8(%rbx), %rdi
callq 0xd169
addq $0x10, %rbx
jmp 0xd17e
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O2/theovosse[P]llgen/regexp.c
// Function: CompileFDFA
FRegExp CompileFDFA(RegExp dfa) {
	RegExp state;
	Transition tr;
	FRegExp fDfa = InitFRegExp(dfa->info);
	FRegExp fState;
	int i;

	dfa->state.fRegExp = fDfa;
	for (state = dfa->next; state != NULL; state = state->next) {
		fState = MakeFRegExp(state->info);
		state->state.fRegExp = fState;
	}
	for (state = dfa; state != NULL; state = state->next) {
		fState = state->state.fRegExp;
		for (i = 0; i != charSetSize; i++) {
			fState->destination[i] = NULL;
		}
		for (tr = state->transitions; tr != NULL; tr = tr->next) {
			fState->destination[tr->transitionChar] = tr->destination->state.fRegExp;
		}
	}
	return (fDfa);
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rdi, %rbx
movq 0x10(%rdi), %r15
movl $0x810, %edi            # imm = 0x810
callq 0xba6d
testq %rax, %rax
je 0xdf26
movq %rax, %r14
addq $0x810, 0xcdf6(%rip) # imm = 0x810
movq %r15, (%rax)
andq $0x0, 0x8(%rax)
movq %rax, 0xce8f(%rip)      # 0x1ad18
movq %rbx, %r15
movq %rax, 0x28(%r15)
movq 0x18(%r15), %r15
testq %r15, %r15
je 0xdecf
movq 0x10(%r15), %r12
movl $0x810, %edi            # imm = 0x810
callq 0xba6d
testq %rax, %rax
je 0xdf26
addq $0x810, 0xcdb9(%rip) # imm = 0x810
movq %r12, (%rax)
movq 0xce57(%rip), %rcx      # 0x1ad18
movq 0x8(%rcx), %rdx
movq %rdx, 0x8(%rax)
movq %rax, 0x8(%rcx)
jmp 0xde8c
movl 0xa387(%rip), %eax      # 0x1825c
testq %rbx, %rbx
je 0xdf17
movq 0x28(%rbx), %rcx
xorl %edx, %edx
cmpq %rdx, %rax
je 0xdef0
andq $0x0, 0x10(%rcx,%rdx,8)
incq %rdx
jmp 0xdee0
movq %rbx, %rdx
movq (%rdx), %rdx
testq %rdx, %rdx
je 0xdf11
movq 0x8(%rdx), %rsi
movq 0x28(%rsi), %rsi
movslq (%rdx), %rdi
movq %rsi, 0x10(%rcx,%rdi,8)
addq $0x10, %rdx
jmp 0xdef3
movq 0x18(%rbx), %rbx
jmp 0xded5
movq %r14, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
leaq 0x41fb(%rip), %rdi      # 0x12128
callq 0xbc52
pushq $0x1
popq %rdi
callq 0x3200
// File: /workspace/github_c_makefile_star2_O2/theovosse[P]llgen/regexp.c
// Function: MatchFDFA
int MatchFDFA(FRegExp fDfa, char *line, ESet *answer) {
	register FRegExp fState = fDfa;
	register unsigned char *ptr = (unsigned char *) line;
	ESet info = NULL;
	int rLen = -1;

	while (fState != NULL) {
		if (fState->info != NULL) {
			info = fState->info;
			rLen = ptr - (unsigned char *) line;
		}
		fState = fState->destination[*ptr++];
	}
	*answer = info;
	return (rLen);
}

// Assembly:
pushq $-0x1
popq %rax
xorl %ecx, %ecx
xorl %r8d, %r8d
testq %rdi, %rdi
je 0xdf63
movq (%rdi), %r9
testq %r9, %r9
cmovneq %r9, %r8
cmovnel %ecx, %eax
movzbl (%rsi,%rcx), %r9d
movq 0x10(%rdi,%r9,8), %rdi
incq %rcx
jmp 0xdf42
movq %r8, (%rdx)
retq
// File: /workspace/github_c_makefile_star2_O2/theovosse[P]llgen/regexp.c
// Function: chardenot
static char chardenot(char **rest, Boolean *special, Boolean callFromCharList) {
	char ch;

	if (**rest == '\0') {
		*special = false;
		return ('\0');
	}
	if (**rest == '\\') {
		(*rest)++;
		switch (**rest) {
			case '0':
				*special = false;
				ch = '\0';
				break;
			case 't':
				*special = false;
				ch = '\t';
				break;
			case 'n':
				*special = false;
				ch = '\n';
				break;
			case 'r':
				*special = false;
				ch = '\r';
				break;
			default:
				ch = **rest;
				if (viMode) {
					*special = false;
				} else {
					*special = ch != '\\';
				}
				break;
		}
		(*rest)++;
		return (ch);
	}
	ch = *(*rest)++;
	if (viMode) {
		*special = (!callFromCharList && strchr("()[|*+?.", ch) != NULL) || (callFromCharList && strchr("^-]", ch) != NULL);
	} else {
		*special = false;
	}
	return (ch);
}

// Assembly:
pushq %rbp
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq (%rdi), %rax
movzbl (%rax), %ecx
cmpl $0x5c, %ecx
je 0xe555
testl %ecx, %ecx
jne 0xe579
andw $0x0, (%rbx)
xorl %ebp, %ebp
jmp 0xe5e8
leaq 0x1(%rax), %rcx
movq %rcx, (%rdi)
movzbl 0x1(%rax), %ebp
cmpl $0x30, %ebp
je 0xe5cc
cmpl $0x6e, %ebp
je 0xe5c2
cmpl $0x72, %ebp
je 0xe5c7
cmpl $0x74, %ebp
jne 0xe5d2
movb $0x9, %bpl
jmp 0xe5dc
leaq 0x1(%rax), %rcx
movq %rcx, (%rdi)
movb (%rax), %bpl
cmpw $0x0, 0xc705(%rip)      # 0x1ac90
je 0xe5a1
movsbl %bpl, %esi
testw %dx, %dx
je 0xe5a5
leaq 0x3b12(%rip), %rdi      # 0x120af
pushq $0x4
jmp 0xe5ae
xorl %eax, %eax
jmp 0xe5ba
leaq 0x3afa(%rip), %rdi      # 0x120a6
pushq $0x9
popq %rdx
callq 0x3130
testq %rax, %rax
setne %al
movzbl %al, %eax
movw %ax, (%rbx)
jmp 0xe5e8
movb $0xa, %bpl
jmp 0xe5dc
movb $0xd, %bpl
jmp 0xe5dc
xorl %ecx, %ecx
xorl %ebp, %ebp
jmp 0xe5de
cmpw $0x0, 0xc6b6(%rip)      # 0x1ac90
je 0xe5f1
xorl %ecx, %ecx
movw %cx, (%rbx)
addq $0x2, %rax
movq %rax, (%rdi)
movl %ebp, %eax
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
xorl %ecx, %ecx
cmpb $0x5c, %bpl
setne %cl
jmp 0xe5de
// File: /workspace/github_c_makefile_star2_O2/theovosse[P]llgen/lang.c
// Function: cLanguageEndDoWhileLoop
static void cLanguageEndDoWhileLoop(FILE* outputFile, Boolean open, int indent) {
    if (open) {
        terminateBlock(indent);
        if (bracesOnNewLine) {
           doIndent(indent);
        } else {
            fputc(' ', outputFile);
        }
        fprintf(outputFile, "while (");
    } else {
        fprintf(outputFile, ");");
    }
}

// Assembly:
pushq %rbp
pushq %rbx
pushq %rax
movq %rdi, %rbx
testw %si, %si
je 0xe640
movl %edx, %ebp
movl %edx, %edi
callq 0x3a30
leaq 0xa4db(%rip), %rax      # 0x18b0c
cmpw $0x0, (%rax)
je 0xe64b
movl %ebp, %edi
callq 0x39c6
jmp 0xe656
leaq 0x2596(%rip), %rdi      # 0x10bdd
pushq $0x2
jmp 0xe65f
pushq $0x20
popq %rdi
movq %rbx, %rsi
callq 0x3120
leaq 0x3f65(%rip), %rdi      # 0x125c2
pushq $0x7
popq %rsi
pushq $0x1
popq %rdx
movq %rbx, %rcx
addq $0x8, %rsp
popq %rbx
popq %rbp
jmp 0x3210
// File: /workspace/github_c_makefile_star2_O2/theovosse[P]llgen/lang.c
// Function: cLanguageArrayDeclaration
static void cLanguageArrayDeclaration(FILE* f, const char* scope, const char* type, const char* name, long int suffix, int size, Boolean init) {
    fprintf(f, "%s %s %s", scope, type, name);
    if (suffix >= 0) {
        fprintf(f, "%ld", suffix);
    }
    if (size >= 0) {
        fprintf(f, "[%d]", size);
    } else {
        fprintf(f, "[]");
    }
    if (init) {
        fprintf(f, " = ");
    }
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movl %r9d, %ebp
movq %r8, %r14
movq %rcx, %r8
movq %rdx, %rcx
movq %rsi, %rdx
movq %rdi, %rbx
movzwl 0x30(%rsp), %r15d
leaq 0x3f33(%rip), %rsi      # 0x125ca
xorl %eax, %eax
callq 0x3150
testq %r14, %r14
js 0xe6b7
leaq 0x1f69(%rip), %rsi      # 0x10613
movq %rbx, %rdi
movq %r14, %rdx
xorl %eax, %eax
callq 0x3150
testl %ebp, %ebp
js 0xe6d0
leaq 0x3f11(%rip), %rsi      # 0x125d3
movq %rbx, %rdi
movl %ebp, %edx
xorl %eax, %eax
callq 0x3150
jmp 0xe6e5
leaq 0x3fa0(%rip), %rdi      # 0x12677
pushq $0x2
popq %rsi
pushq $0x1
popq %rdx
movq %rbx, %rcx
callq 0x3210
testw %r15w, %r15w
je 0xe70a
leaq 0x4054(%rip), %rdi      # 0x12746
pushq $0x3
popq %rsi
pushq $0x1
popq %rdx
movq %rbx, %rcx
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
jmp 0x3210
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/theovosse[P]llgen/lang.c
// Function: cLanguageStateTransition
static void cLanguageStateTransition(FILE* f, int ch, long int destination, const char* accept) {
    fprintf(f, "{ ");
    if (ch == -1) {
        fprintf(f, "-1");
    } else if (ch == '\'' || ch == '\\') {
        fprintf(f, "'\\%c'", ch);
    } else if (' ' <= ch && ch <= '~') {
        fprintf(f, "'%c'", ch);
    } else {
        fprintf(f, "'\\x%02x'", ch);
    }
    fprintf(f, ", %ld, %s },\n", destination, accept);
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rcx, %rbx
movq %rdx, %r14
movl %esi, %r12d
movq %rdi, %r15
leaq 0x3e42(%rip), %rdi      # 0x125ee
pushq $0x2
popq %rsi
pushq $0x1
popq %rdx
movq %r15, %rcx
callq 0x3210
cmpl $0x5c, %r12d
je 0xe7e3
cmpl $0x27, %r12d
je 0xe7e3
cmpl $-0x1, %r12d
jne 0xe819
leaq 0x3e1e(%rip), %rdi      # 0x125f1
pushq $0x2
popq %rsi
pushq $0x1
popq %rdx
movq %r15, %rcx
callq 0x3210
jmp 0xe7f7
leaq 0x3e0a(%rip), %rsi      # 0x125f4
movq %r15, %rdi
movl %r12d, %edx
xorl %eax, %eax
callq 0x3150
leaq 0x3e0a(%rip), %rsi      # 0x12608
movq %r15, %rdi
movq %r14, %rdx
movq %rbx, %rcx
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
jmp 0x3150
leal -0x20(%r12), %eax
cmpl $0x5e, %eax
ja 0xe82c
leaq 0x3dd0(%rip), %rsi      # 0x125fa
jmp 0xe7ea
leaq 0x3dcc(%rip), %rsi      # 0x125ff
jmp 0xe7ea
// File: /workspace/github_c_makefile_star2_O2/theovosse[P]llgen/lang.c
// Function: cLanguageParameterDeclarationName
static void cLanguageParameterDeclarationName(FILE* f, const char* str, int nrSpaces) {
    if (nrFunctionParameters > 0) {
        spaces(f, firstTypeNameSpaces, 1);
        fprintf(f, " %s,", lastParameterName);
    }
    lastParameterName = str;
    lastParameterNameSpaces = nrSpaces;
    inParamType = false;
    nrFunctionParameters++;
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movl %edx, %ebx
movq %rsi, %r14
movl 0xc476(%rip), %eax      # 0x1ad20
testl %eax, %eax
jle 0xe8dd
movq %rdi, %r15
movl 0xc46d(%rip), %esi      # 0x1ad24
pushq $0x1
popq %rdx
callq 0xfb83
movq 0xc462(%rip), %rdx      # 0x1ad28
leaq 0x3d57(%rip), %rsi      # 0x12624
movq %r15, %rdi
xorl %eax, %eax
callq 0x3150
movl 0xc443(%rip), %eax      # 0x1ad20
movq %r14, 0xc444(%rip)      # 0x1ad28
movl %ebx, 0xc446(%rip)      # 0x1ad30
movb $0x0, 0xc443(%rip)      # 0x1ad34
incl %eax
movl %eax, 0xc427(%rip)      # 0x1ad20
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O2/theovosse[P]llgen/lang.c
// Function: cLanguageNextDeclarationParameterSymbol
static void cLanguageNextDeclarationParameterSymbol(FILE* f, const char* str, int nrSpaces) {
    if (!inParamType) {
        spaces(f, lastParameterNameSpaces, nrFunctionParameters > 0? 1: 0);
        firstTypeNameSpaces = nrSpaces;
        inParamType = true;
    } else {
        spaces(f, nrSpaces, 0);
    }
    fputs(str, f);
}

// Assembly:
pushq %rbp
pushq %r14
pushq %rbx
movl %edx, %ebp
movq %rsi, %r14
movq %rdi, %rbx
cmpb $0x0, 0xc422(%rip)      # 0x1ad34
je 0xe922
movq %rbx, %rdi
movl %ebp, %esi
xorl %edx, %edx
callq 0xfb83
jmp 0xe949
movl 0xc408(%rip), %esi      # 0x1ad30
xorl %edx, %edx
cmpl $0x0, 0xc3ef(%rip)      # 0x1ad20
setg %dl
movq %rbx, %rdi
callq 0xfb83
movl %ebp, 0xc3e2(%rip)      # 0x1ad24
movb $0x1, 0xc3eb(%rip)      # 0x1ad34
movq %r14, %rdi
movq %rbx, %rsi
popq %rbx
popq %r14
popq %rbp
jmp 0x3110
// File: /workspace/github_c_makefile_star2_O2/theovosse[P]llgen/lang.c
// Function: cLanguageEndFunctionDeclaration
static void cLanguageEndFunctionDeclaration(FILE* f) {
    if (nrFunctionParameters > 0) {
        spaces(f, lastParameterNameSpaces, 1);
        fprintf(f, " %s", lastParameterName);
    }
    fprintf(f, ")");
}

// Assembly:
pushq %rbx
movq %rdi, %rbx
cmpl $0x0, 0xc3bd(%rip)      # 0x1ad20
jle 0xe98e
movl 0xc3c5(%rip), %esi      # 0x1ad30
pushq $0x1
popq %rdx
movq %rbx, %rdi
callq 0xfb83
movq 0xc3ab(%rip), %rdx      # 0x1ad28
leaq 0x3db4(%rip), %rsi      # 0x12738
movq %rbx, %rdi
xorl %eax, %eax
callq 0x3150
pushq $0x29
popq %rdi
movq %rbx, %rsi
popq %rbx
jmp 0x3120
// File: /workspace/github_c_makefile_star2_O2/theovosse[P]llgen/lang.c
// Function: cLanguageStartFunctionCall
static void cLanguageStartFunctionCall(FILE* f, const char*functionName, const char* returnType, const char* assignTo) {
    if (returnType != NULL && assignTo != NULL) {
        fprintf(f, "%s ", returnType);
    }
    if (assignTo != NULL) {
        fprintf(f, "%s = ", assignTo);
    }
    fprintf(f, "%s(", functionName);
    nrFunctionParameters = 0;
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rcx, %r15
movq %rsi, %rbx
movq %rdi, %r14
testq %rdx, %rdx
sete %al
testq %rcx, %rcx
sete %cl
orb %al, %cl
jne 0xe9cb
leaq 0x3c6a(%rip), %rsi      # 0x12629
movq %r14, %rdi
xorl %eax, %eax
callq 0x3150
jmp 0xe9d0
testq %r15, %r15
je 0xe9e4
leaq 0x3d6d(%rip), %rsi      # 0x12744
movq %r14, %rdi
movq %r15, %rdx
xorl %eax, %eax
callq 0x3150
leaq 0x3dd7(%rip), %rsi      # 0x127c2
movq %r14, %rdi
movq %rbx, %rdx
xorl %eax, %eax
callq 0x3150
andl $0x0, 0xc321(%rip)      # 0x1ad20
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O2/theovosse[P]llgen/lang.c
// Function: cLanguageAssignLastSymbolTo
static void cLanguageAssignLastSymbolTo(FILE* f, int indent, Name name, Boolean noDecl) {
    if (!noDecl) {
        doIndent(indent);
        fprintf(f, "char %s[sizeof(lastSymbol)];", name->name);
    }
    doIndent(indent);
    fprintf(f, "strcpy(%s, lastSymbol);", name->name);
}

// Assembly:
pushq %rbp
pushq %r14
pushq %rbx
movq %rdx, %r14
movl %esi, %ebp
movq %rdi, %rbx
testw %cx, %cx
jne 0xea9d
movl %ebp, %edi
callq 0x39c6
movq (%r14), %rdx
leaq 0x3b9a(%rip), %rsi      # 0x1262d
movq %rbx, %rdi
xorl %eax, %eax
callq 0x3150
movl %ebp, %edi
callq 0x39c6
movq (%r14), %rdx
leaq 0x3b9c(%rip), %rsi      # 0x1264a
movq %rbx, %rdi
xorl %eax, %eax
popq %rbx
popq %r14
popq %rbp
jmp 0x3150
// File: /workspace/github_c_makefile_star2_O2/theovosse[P]llgen/lang.c
// Function: jsLanguageArrayDeclaration
static void jsLanguageArrayDeclaration(FILE* f, const char* scope, const char* type, const char* name, long int suffix, int size, Boolean init) {
    fprintf(f, "var %s", name);
    if (suffix >= 0) {
        fprintf(f, "%ld", suffix);
    }
    if (init) {
        fprintf(f, " = [");
    }
}

// Assembly:
pushq %rbp
pushq %r14
pushq %rbx
movq %r8, %r14
movq %rdi, %rbx
movzwl 0x20(%rsp), %ebp
leaq 0x3b95(%rip), %rsi      # 0x12667
movq %rcx, %rdx
xorl %eax, %eax
callq 0x3150
testq %r14, %r14
js 0xeaf5
leaq 0x1b2b(%rip), %rsi      # 0x10613
movq %rbx, %rdi
movq %r14, %rdx
xorl %eax, %eax
callq 0x3150
testw %bp, %bp
je 0xeb13
leaq 0x3c15(%rip), %rdi      # 0x12716
pushq $0x4
popq %rsi
pushq $0x1
popq %rdx
movq %rbx, %rcx
popq %rbx
popq %r14
popq %rbp
jmp 0x3210
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/theovosse[P]llgen/lang.c
// Function: jsLanguageStateTransition
static void jsLanguageStateTransition(FILE* f, int ch, long int destination, const char* accept) {
    fprintf(f, "  ");
    if (ch == -1) {
        fprintf(f, "''");
    } else if (ch == '\'' || ch == '\\') {
        fprintf(f, "'\\%c'", ch);
    } else if (' ' <= ch && ch <= '~') {
        fprintf(f, "'%c'", ch);
    } else {
        fprintf(f, "'\\x%02x'", ch);
    }
    fprintf(f, ": {");
    if (destination != -1) {
        fprintf(f, "destination:%ld", destination);
    }
    if (strcmp(accept, "undefined") != 0) {
        if (destination != -1) {
            fprintf(f, ",");
        }
        fprintf(f, "accept:%s", accept);
    }
    fprintf(f, "},\n");
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rcx, %r14
movq %rdx, %r15
movl %esi, %r12d
movq %rdi, %rbx
leaq 0x1afe(%rip), %rdi      # 0x106a1
pushq $0x2
popq %rsi
pushq $0x1
popq %rdx
movq %rbx, %rcx
callq 0x3210
cmpl $0x5c, %r12d
je 0xebde
cmpl $0x27, %r12d
je 0xebde
cmpl $-0x1, %r12d
jne 0xec79
leaq 0x3ac4(%rip), %rdi      # 0x12692
pushq $0x2
popq %rsi
pushq $0x1
popq %rdx
movq %rbx, %rcx
callq 0x3210
jmp 0xebf2
leaq 0x3a0f(%rip), %rsi      # 0x125f4
movq %rbx, %rdi
movl %r12d, %edx
xorl %eax, %eax
callq 0x3150
leaq 0x3a9c(%rip), %rdi      # 0x12695
pushq $0x3
popq %rsi
pushq $0x1
popq %rdx
movq %rbx, %rcx
callq 0x3210
cmpq $-0x1, %r15
je 0xec21
leaq 0x3a85(%rip), %rsi      # 0x12699
movq %rbx, %rdi
movq %r15, %rdx
xorl %eax, %eax
callq 0x3150
leaq 0x3900(%rip), %rsi      # 0x12528
movq %r14, %rdi
callq 0x3240
testl %eax, %eax
je 0xec59
cmpq $-0x1, %r15
je 0xec45
pushq $0x2c
popq %rdi
movq %rbx, %rsi
callq 0x3120
leaq 0x3a5d(%rip), %rsi      # 0x126a9
movq %rbx, %rdi
movq %r14, %rdx
xorl %eax, %eax
callq 0x3150
leaq 0x3a74(%rip), %rdi      # 0x126d4
pushq $0x3
popq %rsi
pushq $0x1
popq %rdx
movq %rbx, %rcx
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
jmp 0x3210
leal -0x20(%r12), %eax
cmpl $0x5e, %eax
ja 0xec8f
leaq 0x3970(%rip), %rsi      # 0x125fa
jmp 0xebe5
leaq 0x3969(%rip), %rsi      # 0x125ff
jmp 0xebe5
// File: /workspace/github_c_makefile_star2_O2/theovosse[P]llgen/lang.c
// Function: jsLanguageParameterDeclarationName
static void jsLanguageParameterDeclarationName(FILE* f, const char* str, int nrSpaces) {
    if (nrFunctionParameters > 0) {
        fprintf(f, ", ");
    }
    fputs(str, f);
    nrFunctionParameters++;
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %r14
movq %rdi, %rbx
cmpl $0x0, 0xbfe2(%rip)      # 0x1ad20
jle 0xed55
leaq 0x1780(%rip), %rdi      # 0x104c7
pushq $0x2
popq %rsi
pushq $0x1
popq %rdx
movq %rbx, %rcx
callq 0x3210
movq %r14, %rdi
movq %rbx, %rsi
callq 0x3110
incl 0xbfba(%rip)            # 0x1ad20
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O2/theovosse[P]llgen/lang.c
// Function: jsLanguageStartFunctionCall
static void jsLanguageStartFunctionCall(FILE* f, const char*functionName, const char* returnType, const char* assignTo) {
    if (returnType != NULL && assignTo != NULL) {
        fprintf(f, "var ");
    }
    if (assignTo != NULL) {
        fprintf(f, "%s = ", assignTo);
    }
    fprintf(f, "%s(", functionName);
    nrFunctionParameters = 0;
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rcx, %r15
movq %rsi, %rbx
movq %rdi, %r14
testq %rdx, %rdx
sete %al
testq %rcx, %rcx
sete %cl
orb %al, %cl
jne 0xedb3
leaq 0x394c(%rip), %rdi      # 0x126ef
pushq $0x4
popq %rsi
pushq $0x1
popq %rdx
movq %r14, %rcx
callq 0x3210
jmp 0xedb8
testq %r15, %r15
je 0xedcc
leaq 0x3985(%rip), %rsi      # 0x12744
movq %r14, %rdi
movq %r15, %rdx
xorl %eax, %eax
callq 0x3150
leaq 0x39ef(%rip), %rsi      # 0x127c2
movq %r14, %rdi
movq %rbx, %rdx
xorl %eax, %eax
callq 0x3150
andl $0x0, 0xbf39(%rip)      # 0x1ad20
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O2/theovosse[P]llgen/lang.c
// Function: tsLanguageArrayDeclaration
static void tsLanguageArrayDeclaration(FILE* f, const char* scope, const char* type, const char* name, long int suffix, int size, Boolean init) {
    fprintf(f, "let %s", name);
    if (suffix >= 0) {
        fprintf(f, "%ld", suffix);
    }
    if (init) {
        fprintf(f, ": %s[] = [", type);
    }
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %r8, %r15
movq %rdx, %rbx
movq %rdi, %r14
movzwl 0x30(%rsp), %ebp
leaq 0x3863(%rip), %rsi      # 0x12709
movq %rcx, %rdx
xorl %eax, %eax
callq 0x3150
testq %r15, %r15
js 0xeec9
leaq 0x1757(%rip), %rsi      # 0x10613
movq %r14, %rdi
movq %r15, %rdx
xorl %eax, %eax
callq 0x3150
testw %bp, %bp
je 0xeeec
leaq 0x383b(%rip), %rsi      # 0x12710
movq %r14, %rdi
movq %rbx, %rdx
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
jmp 0x3150
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/theovosse[P]llgen/lang.c
// Function: tsLanguageParameterDeclarationName
static void tsLanguageParameterDeclarationName(FILE* f, const char* str, int nrSpaces) {
    if (nrFunctionParameters > 0) {
        fprintf(f, ",");
    }
    spaces(f, nrSpaces, nrFunctionParameters > 0? 1: 0);
    fputs(str, f);
    inParamType = false;
    nrFunctionParameters++;
}

// Assembly:
pushq %rbp
pushq %r14
pushq %rbx
movl %edx, %ebp
movq %rsi, %r14
movq %rdi, %rbx
cmpl $0x0, 0xbd61(%rip)      # 0x1ad20
jle 0xefda
pushq $0x2c
popq %rdi
movq %rbx, %rsi
callq 0x3120
xorl %edx, %edx
cmpl $0x0, 0xbd4b(%rip)      # 0x1ad20
setg %dl
jmp 0xefdc
xorl %edx, %edx
movq %rbx, %rdi
movl %ebp, %esi
callq 0xfb83
movq %r14, %rdi
movq %rbx, %rsi
callq 0x3110
movb $0x0, 0xbd3c(%rip)      # 0x1ad34
incl 0xbd22(%rip)            # 0x1ad20
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/theovosse[P]llgen/lang.c
// Function: tsLanguageNextDeclarationParameterSymbol
static void tsLanguageNextDeclarationParameterSymbol(FILE* f, const char* str, int nrSpaces) {
    if (!inParamType) {
        fputs(":", f);
        inParamType = true;
    }
    spaces(f, nrSpaces, 0);
    fputs(str, f);
}

// Assembly:
pushq %rbp
pushq %r14
pushq %rbx
movl %edx, %ebp
movq %rsi, %r14
movq %rdi, %rbx
cmpb $0x0, 0xbd1e(%rip)      # 0x1ad34
jne 0xf02e
leaq 0x2ff2(%rip), %rdi      # 0x12011
movq %rbx, %rsi
callq 0x3110
movb $0x1, 0xbd06(%rip)      # 0x1ad34
movq %rbx, %rdi
movl %ebp, %esi
xorl %edx, %edx
callq 0xfb83
movq %r14, %rdi
movq %rbx, %rsi
popq %rbx
popq %r14
popq %rbp
jmp 0x3110
// File: /workspace/github_c_makefile_star2_O2/theovosse[P]llgen/lang.c
// Function: tsLanguageStartFunctionCall
static void tsLanguageStartFunctionCall(FILE* f, const char*functionName, const char* returnType, const char* assignTo) {
    if (returnType != NULL && assignTo != NULL) {
        fprintf(f, "let %s: %s = ", assignTo, returnType);
    } else if (assignTo != NULL) {
        fprintf(f, "%s = ", assignTo);
    }
    fprintf(f, "%s(", functionName);
    nrFunctionParameters = 0;
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rdx, %rax
movq %rsi, %rbx
movq %rdi, %r14
testq %rdx, %rdx
sete %dl
testq %rcx, %rcx
sete %sil
orb %dl, %sil
jne 0xf096
leaq 0x36b8(%rip), %rsi      # 0x1273c
movq %r14, %rdi
movq %rcx, %rdx
movq %rax, %rcx
xorl %eax, %eax
callq 0x3150
jmp 0xf0af
testq %rcx, %rcx
je 0xf0af
leaq 0x36a2(%rip), %rsi      # 0x12744
movq %r14, %rdi
movq %rcx, %rdx
xorl %eax, %eax
callq 0x3150
leaq 0x370c(%rip), %rsi      # 0x127c2
movq %r14, %rdi
movq %rbx, %rdx
xorl %eax, %eax
callq 0x3150
andl $0x0, 0xbc56(%rip)      # 0x1ad20
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O2/theovosse[P]llgen/lang.c
// Function: goLanguageEndDoWhileLoop
static void goLanguageEndDoWhileLoop(FILE* outputFile, Boolean open, int indent) {
    if (open) {
        doIndent(indent + 1);
        fprintf(outputFile, "if !");
    } else {
        startBlock(indent + 1);
        doIndent(indent + 2);
        fputs("break", outputFile);
        terminateBlock(indent + 1);
        terminateBlock(indent);
    }
}

// Assembly:
pushq %rbp
pushq %r14
pushq %rbx
movl %edx, %r14d
movq %rdi, %rbx
leal 0x1(%r14), %ebp
testw %si, %si
je 0xf163
movl %ebp, %edi
callq 0x39c6
leaq 0x3616(%rip), %rdi      # 0x12767
pushq $0x4
popq %rsi
pushq $0x1
popq %rdx
movq %rbx, %rcx
popq %rbx
popq %r14
popq %rbp
jmp 0x3210
movl %ebp, %edi
callq 0x3a00
leal 0x2(%r14), %edi
callq 0x39c6
leaq 0x339c(%rip), %rdi      # 0x12516
movq %rbx, %rsi
callq 0x3110
movl %ebp, %edi
callq 0x3a30
movl %r14d, %edi
popq %rbx
popq %r14
popq %rbp
jmp 0x3a30
// File: /workspace/github_c_makefile_star2_O2/theovosse[P]llgen/lang.c
// Function: goLanguageArrayDeclaration
static void goLanguageArrayDeclaration(FILE* f, const char* scope, const char* type, const char* name, long int suffix, int size, Boolean init) {
    fprintf(f, "var %s", name);
    if (suffix >= 0) {
        fprintf(f, "%ld", suffix);
    }
    if (init) {
        fprintf(f, " =");
    }
    if (size >= 0) {
        fprintf(f, " [%d]%s", size, type);
    } else {
        fprintf(f, " []%s", type);
    }
    if (init) {
        fprintf(f, "{");
    }
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movl %r9d, %ebp
movq %r8, %r15
movq %rdx, %r14
movq %rdi, %rbx
movzwl 0x30(%rsp), %r12d
leaq 0x34b1(%rip), %rsi      # 0x12667
movq %rcx, %rdx
xorl %eax, %eax
callq 0x3150
testq %r15, %r15
js 0xf1d9
leaq 0x1447(%rip), %rsi      # 0x10613
movq %rbx, %rdi
movq %r15, %rdx
xorl %eax, %eax
callq 0x3150
testw %r12w, %r12w
je 0xf1f4
leaq 0x3586(%rip), %rdi      # 0x1276c
pushq $0x2
popq %rsi
pushq $0x1
popq %rdx
movq %rbx, %rcx
callq 0x3210
testl %ebp, %ebp
js 0xf210
leaq 0x3570(%rip), %rsi      # 0x1276f
movq %rbx, %rdi
movl %ebp, %edx
movq %r14, %rcx
xorl %eax, %eax
callq 0x3150
jmp 0xf224
leaq 0x3560(%rip), %rsi      # 0x12777
movq %rbx, %rdi
movq %r14, %rdx
xorl %eax, %eax
callq 0x3150
testw %r12w, %r12w
je 0xf23d
pushq $0x7b
popq %rdi
movq %rbx, %rsi
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
jmp 0x3120
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/theovosse[P]llgen/lang.c
// Function: goLanguageStateTransition
static void goLanguageStateTransition(FILE* f, int ch, long int destination, const char* accept) {
    fprintf(f, "{");
    if (ch == -1) {
        fprintf(f, "-1");
    } else if (ch == '\'' || ch == '\\') {
        fprintf(f, "'\\%c'", ch);
    } else if (' ' <= ch && ch <= '~') {
        fprintf(f, "'%c'", ch);
    } else {
        fprintf(f, "'\\x%02x'", ch);
    }
    if (strcmp(accept, "nil") == 0) {
        fprintf(f, ", %ld, %s},\n", destination, accept);
    } else {
        fprintf(f, ", %ld, &%s},\n", destination, accept);
    }
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rcx, %rbx
movq %rdx, %r14
movl %esi, %r12d
movq %rdi, %r15
pushq $0x7b
popq %rdi
movq %r15, %rsi
callq 0x3120
cmpl $0x5c, %r12d
je 0xf336
cmpl $0x27, %r12d
je 0xf336
cmpl $-0x1, %r12d
jne 0xf388
leaq 0x32cb(%rip), %rdi      # 0x125f1
pushq $0x2
popq %rsi
pushq $0x1
popq %rdx
movq %r15, %rcx
callq 0x3210
jmp 0xf34a
leaq 0x32b7(%rip), %rsi      # 0x125f4
movq %r15, %rdi
movl %r12d, %edx
xorl %eax, %eax
callq 0x3150
leaq 0x321b(%rip), %rsi      # 0x1256c
movq %rbx, %rdi
callq 0x3240
testl %eax, %eax
leaq 0x343c(%rip), %rax      # 0x1279e
leaq 0x3442(%rip), %rsi      # 0x127ab
cmoveq %rax, %rsi
movq %r15, %rdi
movq %r14, %rdx
movq %rbx, %rcx
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
jmp 0x3150
leal -0x20(%r12), %eax
cmpl $0x5e, %eax
ja 0xf39b
leaq 0x3261(%rip), %rsi      # 0x125fa
jmp 0xf33d
leaq 0x325d(%rip), %rsi      # 0x125ff
jmp 0xf33d
// File: /workspace/github_c_makefile_star2_O2/theovosse[P]llgen/lang.c
// Function: goLanguageParameterDeclarationName
static void goLanguageParameterDeclarationName(FILE* f, const char* str, int nrSpaces) {
    if (nrFunctionParameters > 0) {
        fprintf(f, ",");
    }
    spaces(f, nrSpaces, nrFunctionParameters > 0? 1: 0);
    fputs(str, f);
    nrFunctionParameters++;
}

// Assembly:
pushq %rbp
pushq %r14
pushq %rbx
movl %edx, %ebp
movq %rsi, %r14
movq %rdi, %rbx
cmpl $0x0, 0xb8eb(%rip)      # 0x1ad20
jle 0xf450
pushq $0x2c
popq %rdi
movq %rbx, %rsi
callq 0x3120
xorl %edx, %edx
cmpl $0x0, 0xb8d5(%rip)      # 0x1ad20
setg %dl
jmp 0xf452
xorl %edx, %edx
movq %rbx, %rdi
movl %ebp, %esi
callq 0xfb83
movq %r14, %rdi
movq %rbx, %rsi
callq 0x3110
incl 0xb8b3(%rip)            # 0x1ad20
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/theovosse[P]llgen/lang.c
// Function: goLanguageStartFunctionCall
static void goLanguageStartFunctionCall(FILE* f, const char*functionName, const char* returnType, const char* assignTo) {
    if (returnType != NULL && assignTo != NULL) {
        fprintf(f, "var %s %s = ", assignTo, returnType);
    } else if (assignTo != NULL) {
        fprintf(f, "%s = ", returnType);
    }
    fprintf(f, "%s(", functionName);
    nrFunctionParameters = 0;
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rdx, %rax
movq %rsi, %rbx
movq %rdi, %r14
testq %rdx, %rdx
sete %dl
testq %rcx, %rcx
sete %sil
orb %dl, %sil
jne 0xf51e
leaq 0x32ba(%rip), %rsi      # 0x127c6
movq %r14, %rdi
movq %rcx, %rdx
movq %rax, %rcx
xorl %eax, %eax
callq 0x3150
jmp 0xf537
testq %rcx, %rcx
je 0xf537
leaq 0x321a(%rip), %rsi      # 0x12744
movq %r14, %rdi
movq %rax, %rdx
xorl %eax, %eax
callq 0x3150
leaq 0x3284(%rip), %rsi      # 0x127c2
movq %r14, %rdi
movq %rbx, %rdx
xorl %eax, %eax
callq 0x3150
andl $0x0, 0xb7ce(%rip)      # 0x1ad20
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O2/theovosse[P]llgen/lang.c
// Function: rustLanguageArrayDeclaration
static void rustLanguageArrayDeclaration(FILE* f, const char* scope, const char* type, const char* name, long int suffix, int size, Boolean init) {
    fprintf(f, "const %s", name);
    if (suffix >= 0) {
        fprintf(f, "%ld", suffix);
    }
    if (size >= 0) {
        fprintf(f, ": [%s; %d]", type, size);
    } else {
        fprintf(f, ": [%s]", type);
    }
    if (init) {
        fprintf(f, " = [");
    }
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movl %r9d, %ebp
movq %r8, %r15
movq %rdx, %r14
movq %rdi, %rbx
movzwl 0x30(%rsp), %r12d
leaq 0x3158(%rip), %rsi      # 0x127ef
movq %rcx, %rdx
xorl %eax, %eax
callq 0x3150
testq %r15, %r15
js 0xf6ba
leaq 0xf66(%rip), %rsi       # 0x10613
movq %rbx, %rdi
movq %r15, %rdx
xorl %eax, %eax
callq 0x3150
testl %ebp, %ebp
js 0xf6d6
leaq 0x3133(%rip), %rsi      # 0x127f8
movq %rbx, %rdi
movq %r14, %rdx
movl %ebp, %ecx
xorl %eax, %eax
callq 0x3150
jmp 0xf6ea
leaq 0x3126(%rip), %rsi      # 0x12803
movq %rbx, %rdi
movq %r14, %rdx
xorl %eax, %eax
callq 0x3150
testw %r12w, %r12w
je 0xf70d
leaq 0x301f(%rip), %rdi      # 0x12716
pushq $0x4
popq %rsi
pushq $0x1
popq %rdx
movq %rbx, %rcx
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
jmp 0x3210
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/theovosse[P]llgen/lang.c
// Function: rustLanguageStateTransition
static void rustLanguageStateTransition(FILE* f, int ch, long int destination, const char* accept) {
    fprintf(f, "DFAState {ch: ");
    if (ch == -1) {
        fputs("0xff", f);
    } else {
        fprintf(f, "0x%02x", (unsigned) ch);
        switch (ch) {
            case '/': case '!':
                fprintf(f, "/* %c */", ch);
                break;
            case '\t':
                fputs("/*\\t*/", f);
                break;
            case '\n':
                fputs("/*\\n*/", f);
                break;
            case '\r':
                fputs("/*\\r*/", f);
                break;
            default:
                if (' ' <= ch && ch < 127) {
                    fprintf(f, "/*%c*/", ch);
                }
        }
    }
    if (destination == -1) {
        fprintf(f, ", next: 0xffffffff");
    } else {
        fprintf(f, ", next: %ld", destination);
    }
    if (strcmp(accept, "nil") == 0) {
        fprintf(f, ", llTokenSet: None},\n");
    } else {
        fprintf(f, ", llTokenSet: Some(%s)},\n", accept);
    }
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rcx, %r14
movq %rdx, %r15
movl %esi, %r12d
movq %rdi, %rbx
leaq 0x3067(%rip), %rdi      # 0x12820
pushq $0xe
popq %rsi
pushq $0x1
popq %rdx
movq %rbx, %rcx
callq 0x3210
cmpl $-0x1, %r12d
je 0xf815
leaq 0x3060(%rip), %rsi      # 0x12834
movq %rbx, %rdi
movl %r12d, %edx
xorl %eax, %eax
callq 0x3150
cmpl $0x9, %r12d
je 0xf843
cmpl $0xa, %r12d
je 0xf81e
cmpl $0xd, %r12d
je 0xf827
cmpl $0x2f, %r12d
je 0xf7ff
cmpl $0x21, %r12d
jne 0xf830
leaq 0x3035(%rip), %rsi      # 0x1283b
movq %rbx, %rdi
movl %r12d, %edx
xorl %eax, %eax
callq 0x3150
jmp 0xf852
leaq 0x3013(%rip), %rdi      # 0x1282f
jmp 0xf84a
leaq 0x3026(%rip), %rdi      # 0x1284b
jmp 0xf84a
leaq 0x3024(%rip), %rdi      # 0x12852
jmp 0xf84a
leal -0x20(%r12), %eax
cmpl $0x5e, %eax
ja 0xf852
leaq 0x3018(%rip), %rsi      # 0x12859
jmp 0xf806
leaq 0x2ffa(%rip), %rdi      # 0x12844
movq %rbx, %rsi
callq 0x3110
cmpq $-0x1, %r15
je 0xf86e
leaq 0x3014(%rip), %rsi      # 0x12873
movq %rbx, %rdi
movq %r15, %rdx
xorl %eax, %eax
callq 0x3150
jmp 0xf883
leaq 0x2feb(%rip), %rdi      # 0x12860
pushq $0x12
popq %rsi
pushq $0x1
popq %rdx
movq %rbx, %rcx
callq 0x3210
leaq 0x2ce2(%rip), %rsi      # 0x1256c
movq %r14, %rdi
callq 0x3240
testl %eax, %eax
je 0xf8b5
leaq 0x2ff8(%rip), %rsi      # 0x12895
movq %rbx, %rdi
movq %r14, %rdx
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
jmp 0x3150
leaq 0x2fc3(%rip), %rdi      # 0x1287f
pushq $0x15
popq %rsi
pushq $0x1
popq %rdx
movq %rbx, %rcx
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
jmp 0x3210