LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O3/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 0xc775
movq %rax, %r12
movq 0x8(%r14), %rdx
xorl %edi, %edi
movq %rax, %rsi
callq 0xc80e
movq %rax, 0x8(%r14)
movq %r12, %rdi
movq %r15, %rsi
movq %rbx, %rdx
callq 0xedf5
movq %rax, %r12
leaq 0x8(%rsp), %rdi
movq %rax, (%rdi)
leaq 0x6(%rsp), %rsi
xorl %edx, %edx
callq 0xf3f4
cmpl $0x0, 0xf0f2(%rip)      # 0x1bd00
jne 0xccd7
cmpb $0x7c, %al
jne 0xccd7
cmpw $0x0, 0x6(%rsp)
je 0xccd7
xorl %edi, %edi
xorl %esi, %esi
xorl %edx, %edx
callq 0xc775
movq %rax, %r15
leaq 0x10(%rsp), %rax
movq %r15, (%rax)
movq (%rbx), %r12
movq 0x8(%r12), %rdx
xorl %edi, %edi
movq %r15, %rsi
callq 0xc80e
movq %rax, 0x8(%r12)
movq %r15, (%rbx)
leaq 0x6(%rsp), %rbp
xorl %edi, %edi
xorl %esi, %esi
xorl %edx, %edx
callq 0xc775
movq %rax, %r15
movq 0x8(%r14), %rdx
xorl %edi, %edi
movq %rax, %rsi
callq 0xc80e
movq %rax, 0x8(%r14)
movq 0x8(%rsp), %rsi
movq %r15, %rdi
leaq 0x10(%rsp), %rdx
callq 0xedf5
movq %rax, %r12
movq %rax, 0x8(%rsp)
leaq 0x8(%rsp), %rdi
movq %rbp, %rsi
xorl %edx, %edx
callq 0xf3f4
movl %eax, %r15d
movq 0x10(%rsp), %r13
movq (%rbx), %rsi
movq 0x8(%r13), %rdx
xorl %edi, %edi
callq 0xc80e
movq %rax, 0x8(%r13)
cmpl $0x0, 0xf039(%rip)      # 0x1bd00
jne 0xccd7
cmpb $0x7c, %r15b
jne 0xccd7
cmpw $0x0, 0x6(%rsp)
jne 0xcc5d
movq %r12, %rax
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/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 0xedc5(%rip)            # 0x1bce8
movq %rdi, %rbx
movl $0x0, 0xedc8(%rip)      # 0x1bcf8
movq $0x0, 0xedb5(%rip) # 0x1bcf0
callq 0xca11
callq 0xc5dc
movl 0xedad(%rip), %edi      # 0x1bcf8
shll $0x3, %edi
callq 0xc4e9
movq %rax, 0xed96(%rip)      # 0x1bcf0
movl 0xed98(%rip), %edi      # 0x1bcf8
addl %edi, %edi
callq 0xc4e9
movq %rax, 0xed9a(%rip)      # 0x1bd08
movl 0xed84(%rip), %edi      # 0x1bcf8
addl %edi, %edi
callq 0xc4e9
movq %rax, 0xed8e(%rip)      # 0x1bd10
cmpq $0x0, 0xed66(%rip)      # 0x1bcf0
je 0xcfab
cmpq $0x0, 0xed74(%rip)      # 0x1bd08
je 0xcfab
testq %rax, %rax
je 0xcfab
incq 0xed46(%rip)            # 0x1bce8
movq %rbx, %rdi
popq %rbx
jmp 0xca11
leaq 0x5f5c(%rip), %rdi      # 0x12f0e
popq %rbx
jmp 0x39b2
// File: /workspace/github_c_makefile_star2_O3/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), %ecx
testl %ecx, %ecx
sete %al
testq %rdi, %rdi
setne %dl
sete %r8b
orb %al, %r8b
jne 0xd263
xorl %eax, %eax
movq (%rdi), %rdx
testq %rdx, %rdx
je 0xd26b
incq %rsi
cmpl %ecx, (%rdx)
jne 0xd241
movq 0x8(%rdx), %rdi
jmp 0xd243
xorl %edi, %edi
movq 0x10(%rdx), %rdx
testq %rdx, %rdx
je 0xd251
testq %rdi, %rdi
je 0xd237
movsbl (%rsi), %ecx
testq %rdi, %rdi
setne %dl
testl %ecx, %ecx
je 0xd263
testq %rdi, %rdi
jne 0xd22c
testb %dl, %dl
je 0xd26c
movq 0x10(%rdi), %rax
retq
xorl %eax, %eax
retq
// File: /workspace/github_c_makefile_star2_O3/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:
testq %rdi, %rdi
je 0xd6c0
pushq %r14
pushq %rbx
movq 0xe6da(%rip), %rax      # 0x1bca0
movq 0xe6eb(%rip), %r10      # 0x1bcb8
movq 0xe6f4(%rip), %rsi      # 0x1bcc8
movq 0xe6cd(%rip), %rdx      # 0x1bca8
movq 0xe6b6(%rip), %rcx      # 0x1bc98
movq 0xe6c7(%rip), %r8       # 0x1bcb0
movq 0xe6d0(%rip), %r9       # 0x1bcc0
movq %rdi, %r11
movq (%rdi), %rbx
movq 0x18(%rdi), %rdi
testq %rbx, %rbx
je 0xd627
movq %r9, %r14
movq %rbx, %r9
movq 0x10(%rbx), %rbx
movq %r14, 0x10(%r9)
incq %r8
addq $0x18, %rcx
testq %rbx, %rbx
jne 0xd5ff
movq %r9, 0xe6a0(%rip)       # 0x1bcc0
movq %r8, 0xe689(%rip)       # 0x1bcb0
movq 0x8(%r11), %rbx
testq %rbx, %rbx
je 0xd658
movq %r9, %r14
movq %rbx, %r9
movq 0x10(%rbx), %rbx
movq %r14, 0x10(%r9)
incq %r8
addq $0x18, %rcx
testq %rbx, %rbx
jne 0xd630
movq %r9, 0xe66f(%rip)       # 0x1bcc0
movq %r8, 0xe658(%rip)       # 0x1bcb0
movq 0x10(%r11), %rbx
testq %rbx, %rbx
je 0xd691
movq $0x0, 0x8(%rbx)
movq %rsi, %r14
movq %rbx, %rsi
movq 0x8(%rbx), %rbx
movq %r14, 0x8(%rsi)
incq %rdx
addq $0x10, %rcx
testq %rbx, %rbx
jne 0xd669
movq %rsi, 0xe63e(%rip)      # 0x1bcc8
movq %rdx, 0xe617(%rip)      # 0x1bca8
movq %r10, 0x18(%r11)
incq %rax
addq $0x30, %rcx
movq %r11, %r10
testq %rdi, %rdi
jne 0xd5f0
movq %rcx, 0xe5e9(%rip)      # 0x1bc98
movq %r11, 0xe602(%rip)      # 0x1bcb8
movq %rax, 0xe5e3(%rip)      # 0x1bca0
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O3/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
movq 0xe3b6(%rip), %rcx      # 0x1bce8
incq %rcx
movq %rcx, 0xe3ac(%rip)      # 0x1bce8
movq 0x8(%rdi), %rax
testq %rax, %rax
je 0xd969
movq %rbx, %r14
movq (%r14), %rdx
movq %rax, %r14
movq %rcx, 0x20(%rdx)
movq 0x8(%rax), %rax
testq %rax, %rax
jne 0xd948
movq (%r14), %rax
movq %rcx, 0x20(%rax)
testq %rbx, %rbx
jne 0xd973
jmp 0xd9c2
movq (%rbx), %rax
movq %rcx, 0x20(%rax)
movq %rbx, %r14
addq $0x8, %r14
movq %rbx, %r15
movq (%r15), %rax
movq 0x8(%rax), %r12
testq %r12, %r12
je 0xd9b9
movq 0x8(%r12), %rdi
cmpq %rcx, 0x20(%rdi)
je 0xd9b2
xorl %esi, %esi
callq 0xc874
movq %rax, (%r14)
movq 0xe346(%rip), %rcx      # 0x1bce8
movq 0x8(%r12), %rdx
movq %rcx, 0x20(%rdx)
addq $0x8, %rax
movq %rax, %r14
movq 0x10(%r12), %r12
jmp 0xd981
movq 0x8(%r15), %r15
testq %r15, %r15
jne 0xd97a
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O3/theovosse[P]llgen/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:
testq %rdi, %rdi
je 0xda07
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
xorl %r14d, %r14d
movq %r14, 0x28(%rbx)
cmpq $0x0, 0x8(%rbx)
jne 0xd9f9
movq 0x18(%rbx), %rbx
incq %r14
testq %rbx, %rbx
jne 0xd9e0
jmp 0xda00
callq 0x3abd
jmp 0xd9eb
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O3/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:
testq %rdi, %rdi
je 0xdad8
pushq %r14
pushq %rbx
movq 0xe285(%rip), %rax      # 0x1bca0
movq 0xe296(%rip), %r10      # 0x1bcb8
movq 0xe29f(%rip), %rsi      # 0x1bcc8
movq 0xe278(%rip), %rdx      # 0x1bca8
movq 0xe261(%rip), %rcx      # 0x1bc98
movq 0xe272(%rip), %r8       # 0x1bcb0
movq 0xe27b(%rip), %r9       # 0x1bcc0
movq %rdi, %r11
movq (%rdi), %rbx
movq 0x18(%rdi), %rdi
testq %rbx, %rbx
je 0xda7c
movq %r9, %r14
movq %rbx, %r9
movq 0x10(%rbx), %rbx
movq %r14, 0x10(%r9)
incq %r8
addq $0x18, %rcx
testq %rbx, %rbx
jne 0xda54
movq %r9, 0xe24b(%rip)       # 0x1bcc0
movq %r8, 0xe234(%rip)       # 0x1bcb0
movq 0x10(%r11), %rbx
testq %rbx, %rbx
je 0xdaad
movq %rsi, %r14
movq %rbx, %rsi
movq 0x8(%rbx), %rbx
movq %r14, 0x8(%rsi)
incq %rdx
addq $0x10, %rcx
testq %rbx, %rbx
jne 0xda85
movq %rsi, 0xe222(%rip)      # 0x1bcc8
movq %rdx, 0xe1fb(%rip)      # 0x1bca8
movq %r10, 0x18(%r11)
incq %rax
addq $0x30, %rcx
movq %r11, %r10
testq %rdi, %rdi
jne 0xda45
movq %rcx, 0xe1d1(%rip)      # 0x1bc98
movq %r11, 0xe1ea(%rip)      # 0x1bcb8
movq %rax, 0xe1cb(%rip)      # 0x1bca0
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O3/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 0xddd0(%rip), %rax      # 0x1bce8
cmpq %rax, 0x20(%rdi)
je 0xdf3b
pushq %rbx
movq %rax, 0x20(%rdi)
movq (%rdi), %rbx
testq %rbx, %rbx
je 0xdf3a
movq 0x8(%rbx), %rdi
callq 0xdf11
movq 0x10(%rbx), %rbx
jmp 0xdf26
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O3/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 %r13
pushq %r12
pushq %rbx
movq %rdi, %rbx
movq 0x10(%rdi), %r15
movl $0x810, %edi            # imm = 0x810
callq 0xc4e9
testq %rax, %rax
je 0xedb9
movq %rax, %r14
addq $0x810, 0xcf7e(%rip) # imm = 0x810
movq %r15, (%rax)
movq $0x0, 0x8(%rax)
movq %rax, 0xd014(%rip)      # 0x1bd18
movq %rax, 0x28(%rbx)
movq 0x18(%rbx), %r15
testq %r15, %r15
je 0xed5b
movq 0x10(%r15), %r12
movl $0x810, %edi            # imm = 0x810
callq 0xc4e9
testq %rax, %rax
je 0xedb4
addq $0x810, 0xcf3d(%rip) # imm = 0x810
movq %r12, (%rax)
movq 0xcfdb(%rip), %rcx      # 0x1bd18
movq 0x8(%rcx), %rdx
movq %rdx, 0x8(%rax)
movq %rax, 0x8(%rcx)
movq %rax, 0x28(%r15)
movq 0x18(%r15), %r15
testq %r15, %r15
jne 0xed11
testq %rbx, %rbx
je 0xeda7
movl 0xa4fa(%rip), %r12d     # 0x1925c
movq %r12, %r15
shlq $0x3, %r15
movq 0x28(%rbx), %r13
testl %r12d, %r12d
je 0xed80
leaq 0x10(%r13), %rdi
xorl %esi, %esi
movq %r15, %rdx
callq 0x3120
movq (%rbx), %rax
testq %rax, %rax
je 0xed9e
movq 0x8(%rax), %rcx
movq 0x28(%rcx), %rcx
movslq (%rax), %rdx
movq %rcx, 0x10(%r13,%rdx,8)
movq 0x10(%rax), %rax
jmp 0xed83
movq 0x18(%rbx), %rbx
testq %rbx, %rbx
jne 0xed69
movq %r14, %rax
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
callq 0x3ad9
callq 0x3aee
// File: /workspace/github_c_makefile_star2_O3/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:
movl $0xffffffff, %eax       # imm = 0xFFFFFFFF
testq %rdi, %rdi
je 0xedef
xorl %r8d, %r8d
xorl %ecx, %ecx
movq (%rdi), %r9
testq %r9, %r9
cmovneq %r9, %rcx
cmovnel %r8d, %eax
movzbl (%rsi,%r8), %r9d
movq 0x10(%rdi,%r9,8), %rdi
incq %r8
testq %rdi, %rdi
jne 0xedcd
jmp 0xedf1
xorl %ecx, %ecx
movq %rcx, (%rdx)
retq
// File: /workspace/github_c_makefile_star2_O3/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 0xf415
testl %ecx, %ecx
jne 0xf438
movw $0x0, (%rbx)
xorl %ebp, %ebp
jmp 0xf4bf
leaq 0x1(%rax), %rcx
movq %rcx, (%rdi)
movb 0x1(%rax), %bpl
movzbl %bpl, %ecx
cmpl $0x71, %ecx
jg 0xf463
cmpl $0x30, %ecx
je 0xf4aa
cmpl $0x6e, %ecx
jne 0xf495
movb $0xa, %bpl
jmp 0xf4b3
leaq 0x1(%rax), %rcx
movq %rcx, (%rdi)
movb (%rax), %bpl
cmpw $0x0, 0xc846(%rip)      # 0x1bc90
je 0xf472
movsbl %bpl, %esi
testw %dx, %dx
je 0xf476
leaq 0x3c73(%rip), %rdi      # 0x130cf
movl $0x4, %edx
jmp 0xf482
cmpl $0x72, %ecx
je 0xf4b0
cmpl $0x74, %ecx
jne 0xf495
movb $0x9, %bpl
jmp 0xf4b3
xorl %eax, %eax
jmp 0xf48d
leaq 0x3c49(%rip), %rdi      # 0x130c6
movl $0x9, %edx
callq 0x3140
testq %rax, %rax
setne %al
movzbl %al, %eax
movw %ax, (%rbx)
jmp 0xf4bf
cmpw $0x0, 0xc7f3(%rip)      # 0x1bc90
jne 0xf4b3
xorl %ecx, %ecx
cmpb $0x5c, %bpl
setne %cl
jmp 0xf4b5
xorl %ecx, %ecx
xorl %ebp, %ebp
jmp 0xf4b5
movb $0xd, %bpl
xorl %ecx, %ecx
movw %cx, (%rbx)
addq $0x2, %rax
movq %rax, (%rdi)
movl %ebp, %eax
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/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 0xf50c
movl %edx, %ebp
movl %edx, %edi
callq 0x427c
leaq 0xa60f(%rip), %rax      # 0x19b0c
cmpw $0x0, (%rax)
je 0xf51a
movl %ebp, %edi
callq 0x420f
jmp 0xf527
leaq 0x26ea(%rip), %rdi      # 0x11bfd
movl $0x2, %esi
jmp 0xf533
movl $0x20, %edi
movq %rbx, %rsi
callq 0x3130
leaq 0x40b4(%rip), %rdi      # 0x135e2
movl $0x7, %esi
movl $0x1, %edx
movq %rbx, %rcx
addq $0x8, %rsp
popq %rbx
popq %rbp
jmp 0x3210
// File: /workspace/github_c_makefile_star2_O3/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 0x407e(%rip), %rsi      # 0x135ea
xorl %eax, %eax
callq 0x3160
testq %r14, %r14
js 0xf58c
leaq 0x20b4(%rip), %rsi      # 0x11633
movq %rbx, %rdi
movq %r14, %rdx
xorl %eax, %eax
callq 0x3160
testl %ebp, %ebp
js 0xf5a5
leaq 0x405c(%rip), %rsi      # 0x135f3
movq %rbx, %rdi
movl %ebp, %edx
xorl %eax, %eax
callq 0x3160
jmp 0xf5be
leaq 0x40eb(%rip), %rdi      # 0x13697
movl $0x2, %esi
movl $0x1, %edx
movq %rbx, %rcx
callq 0x3210
testw %r15w, %r15w
je 0xf5e7
leaq 0x419b(%rip), %rdi      # 0x13766
movl $0x3, %esi
movl $0x1, %edx
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_O3/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 0x3f85(%rip), %rdi      # 0x1360e
movl $0x2, %esi
movl $0x1, %edx
movq %r15, %rcx
callq 0x3210
cmpl $0x5c, %r12d
je 0xf6c8
cmpl $0x27, %r12d
je 0xf6c8
cmpl $-0x1, %r12d
jne 0xf6fe
leaq 0x3f5d(%rip), %rdi      # 0x13611
movl $0x2, %esi
movl $0x1, %edx
movq %r15, %rcx
callq 0x3210
jmp 0xf6dc
leaq 0x3f45(%rip), %rsi      # 0x13614
movq %r15, %rdi
movl %r12d, %edx
xorl %eax, %eax
callq 0x3160
leaq 0x3f45(%rip), %rsi      # 0x13628
movq %r15, %rdi
movq %r14, %rdx
movq %rbx, %rcx
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
jmp 0x3160
leal -0x20(%r12), %eax
cmpl $0x5e, %eax
ja 0xf711
leaq 0x3f0b(%rip), %rsi      # 0x1361a
jmp 0xf6cf
leaq 0x3f07(%rip), %rsi      # 0x1361f
jmp 0xf6cf
// File: /workspace/github_c_makefile_star2_O3/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 %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movl %edx, %ebx
movq %rsi, %r14
movl 0xc58c(%rip), %eax      # 0x1bd20
testl %eax, %eax
jle 0xf7db
movq %rdi, %r15
movl 0xc583(%rip), %eax      # 0x1bd24
cmpl $0x2, %eax
movl $0x1, %ebp
cmovgel %eax, %ebp
movl $0x20, %edi
movq %r15, %rsi
callq 0x3130
decl %ebp
jne 0xf7ac
movq 0xc564(%rip), %rdx      # 0x1bd28
leaq 0x3e79(%rip), %rsi      # 0x13644
movq %r15, %rdi
xorl %eax, %eax
callq 0x3160
movl 0xc545(%rip), %eax      # 0x1bd20
movq %r14, 0xc546(%rip)      # 0x1bd28
movl %ebx, 0xc548(%rip)      # 0x1bd30
movb $0x0, 0xc545(%rip)      # 0x1bd34
incl %eax
movl %eax, 0xc529(%rip)      # 0x1bd20
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/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 %r15
pushq %r14
pushq %rbx
pushq %rax
movl %edx, %ebp
movq %rsi, %r14
movq %rdi, %rbx
cmpb $0x0, 0xc51c(%rip)      # 0x1bd34
je 0xf831
testl %ebp, %ebp
jle 0xf870
movl $0x20, %edi
movq %rbx, %rsi
callq 0x3130
decl %ebp
jne 0xf81e
jmp 0xf870
movl 0xc4f9(%rip), %eax      # 0x1bd30
xorl %r15d, %r15d
cmpl $0x0, 0xc4df(%rip)      # 0x1bd20
setg %r15b
cmpl %r15d, %eax
cmovgl %eax, %r15d
testl %r15d, %r15d
je 0xf863
movl $0x20, %edi
movq %rbx, %rsi
callq 0x3130
decl %r15d
jne 0xf851
movl %ebp, 0xc4bb(%rip)      # 0x1bd24
movb $0x1, 0xc4c4(%rip)      # 0x1bd34
movq %r14, %rdi
movq %rbx, %rsi
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
jmp 0x3110
// File: /workspace/github_c_makefile_star2_O3/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 %rbp
pushq %rbx
pushq %rax
movq %rdi, %rbx
cmpl $0x0, 0xc48e(%rip)      # 0x1bd20
jle 0xf8ce
movl 0xc496(%rip), %eax      # 0x1bd30
cmpl $0x2, %eax
movl $0x1, %ebp
cmovgel %eax, %ebp
movl $0x20, %edi
movq %rbx, %rsi
callq 0x3130
decl %ebp
jne 0xf8a5
movq 0xc46b(%rip), %rdx      # 0x1bd28
leaq 0x3e94(%rip), %rsi      # 0x13758
movq %rbx, %rdi
xorl %eax, %eax
callq 0x3160
movl $0x29, %edi
movq %rbx, %rsi
addq $0x8, %rsp
popq %rbx
popq %rbp
jmp 0x3130
// File: /workspace/github_c_makefile_star2_O3/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 0xf912
leaq 0x3d43(%rip), %rsi      # 0x13649
movq %r14, %rdi
xorl %eax, %eax
callq 0x3160
jmp 0xf917
testq %r15, %r15
je 0xf92b
leaq 0x3e46(%rip), %rsi      # 0x13764
movq %r14, %rdi
movq %r15, %rdx
xorl %eax, %eax
callq 0x3160
leaq 0x3eb0(%rip), %rsi      # 0x137e2
movq %r14, %rdi
movq %rbx, %rdx
xorl %eax, %eax
callq 0x3160
movl $0x0, 0xc3d7(%rip)      # 0x1bd20
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O3/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 0xf9f0
movl %ebp, %edi
callq 0x420f
movq (%r14), %rdx
leaq 0x3c67(%rip), %rsi      # 0x1364d
movq %rbx, %rdi
xorl %eax, %eax
callq 0x3160
movl %ebp, %edi
callq 0x420f
movq (%r14), %rdx
leaq 0x3c69(%rip), %rsi      # 0x1366a
movq %rbx, %rdi
xorl %eax, %eax
popq %rbx
popq %r14
popq %rbp
jmp 0x3160
// File: /workspace/github_c_makefile_star2_O3/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 0x3c62(%rip), %rsi      # 0x13687
movq %rcx, %rdx
xorl %eax, %eax
callq 0x3160
testq %r14, %r14
js 0xfa48
leaq 0x1bf8(%rip), %rsi      # 0x11633
movq %rbx, %rdi
movq %r14, %rdx
xorl %eax, %eax
callq 0x3160
testw %bp, %bp
je 0xfa6a
leaq 0x3ce2(%rip), %rdi      # 0x13736
movl $0x4, %esi
movl $0x1, %edx
movq %rbx, %rcx
popq %rbx
popq %r14
popq %rbp
jmp 0x3210
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/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 0x1bc7(%rip), %rdi      # 0x116c1
movl $0x2, %esi
movl $0x1, %edx
movq %rbx, %rcx
callq 0x3210
cmpl $0x5c, %r12d
je 0xfb3d
cmpl $0x27, %r12d
je 0xfb3d
cmpl $-0x1, %r12d
jne 0xfbf1
leaq 0x3b89(%rip), %rdi      # 0x136b2
movl $0x2, %esi
movl $0x1, %edx
movq %rbx, %rcx
callq 0x3210
jmp 0xfb51
leaq 0x3ad0(%rip), %rsi      # 0x13614
movq %rbx, %rdi
movl %r12d, %edx
xorl %eax, %eax
callq 0x3160
leaq 0x3b5d(%rip), %rdi      # 0x136b5
movl $0x3, %esi
movl $0x1, %edx
movq %rbx, %rcx
callq 0x3210
cmpq $-0x1, %r15
je 0xfba6
leaq 0x3b42(%rip), %rsi      # 0x136b9
movq %rbx, %rdi
movq %r15, %rdx
xorl %eax, %eax
callq 0x3160
leaq 0x39bd(%rip), %rsi      # 0x13548
movq %r14, %rdi
callq 0x3240
testl %eax, %eax
je 0xfbcd
movl $0x2c, %edi
movq %rbx, %rsi
callq 0x3130
jmp 0xfbb9
leaq 0x399b(%rip), %rsi      # 0x13548
movq %r14, %rdi
callq 0x3240
testl %eax, %eax
je 0xfbcd
leaq 0x3b09(%rip), %rsi      # 0x136c9
movq %rbx, %rdi
movq %r14, %rdx
xorl %eax, %eax
callq 0x3160
leaq 0x3b20(%rip), %rdi      # 0x136f4
movl $0x3, %esi
movl $0x1, %edx
movq %rbx, %rcx
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
jmp 0x3210
leal -0x20(%r12), %eax
cmpl $0x5e, %eax
ja 0xfc07
leaq 0x3a18(%rip), %rsi      # 0x1361a
jmp 0xfb44
leaq 0x3a11(%rip), %rsi      # 0x1361f
jmp 0xfb44
// File: /workspace/github_c_makefile_star2_O3/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, 0xc063(%rip)      # 0x1bd20
jle 0xfcd8
leaq 0x1821(%rip), %rdi      # 0x114e7
movl $0x2, %esi
movl $0x1, %edx
movq %rbx, %rcx
callq 0x3210
movq %r14, %rdi
movq %rbx, %rsi
callq 0x3110
incl 0xc037(%rip)            # 0x1bd20
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O3/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 0xfd3a
leaq 0x39e9(%rip), %rdi      # 0x1370f
movl $0x4, %esi
movl $0x1, %edx
movq %r14, %rcx
callq 0x3210
jmp 0xfd3f
testq %r15, %r15
je 0xfd53
leaq 0x3a1e(%rip), %rsi      # 0x13764
movq %r14, %rdi
movq %r15, %rdx
xorl %eax, %eax
callq 0x3160
leaq 0x3a88(%rip), %rsi      # 0x137e2
movq %r14, %rdi
movq %rbx, %rdx
xorl %eax, %eax
callq 0x3160
movl $0x0, 0xbfaf(%rip)      # 0x1bd20
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O3/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 0x38f2(%rip), %rsi      # 0x13729
movq %rcx, %rdx
xorl %eax, %eax
callq 0x3160
testq %r15, %r15
js 0xfe5a
leaq 0x17e6(%rip), %rsi      # 0x11633
movq %r14, %rdi
movq %r15, %rdx
xorl %eax, %eax
callq 0x3160
testw %bp, %bp
je 0xfe7d
leaq 0x38ca(%rip), %rsi      # 0x13730
movq %r14, %rdi
movq %rbx, %rdx
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
jmp 0x3160
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/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 %r15
pushq %r14
pushq %rbx
pushq %rax
movl %edx, %ebp
movq %rsi, %r14
movq %rdi, %rbx
cmpl $0x0, 0xbdca(%rip)      # 0x1bd20
jle 0xff75
movl $0x2c, %edi
movq %rbx, %rsi
callq 0x3130
xorl %r15d, %r15d
cmpl $0x0, 0xbdb1(%rip)      # 0x1bd20
setg %r15b
jmp 0xff78
xorl %r15d, %r15d
cmpl %r15d, %ebp
cmovgl %ebp, %r15d
testl %r15d, %r15d
je 0xff96
movl $0x20, %edi
movq %rbx, %rsi
callq 0x3130
decl %r15d
jne 0xff84
movq %r14, %rdi
movq %rbx, %rsi
callq 0x3110
movb $0x0, 0xbd8c(%rip)      # 0x1bd34
incl 0xbd72(%rip)            # 0x1bd20
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/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, 0xbd68(%rip)      # 0x1bd34
jne 0xffe4
leaq 0x305c(%rip), %rdi      # 0x13031
movq %rbx, %rsi
callq 0x3110
movb $0x1, 0xbd50(%rip)      # 0x1bd34
testl %ebp, %ebp
jle 0xfff9
movl $0x20, %edi
movq %rbx, %rsi
callq 0x3130
decl %ebp
jne 0xffe8
movq %r14, %rdi
movq %rbx, %rsi
popq %rbx
popq %r14
popq %rbp
jmp 0x3110
// File: /workspace/github_c_makefile_star2_O3/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 0x10055
leaq 0x3719(%rip), %rsi      # 0x1375c
movq %r14, %rdi
movq %rcx, %rdx
movq %rax, %rcx
xorl %eax, %eax
callq 0x3160
jmp 0x1006e
testq %rcx, %rcx
je 0x1006e
leaq 0x3703(%rip), %rsi      # 0x13764
movq %r14, %rdi
movq %rcx, %rdx
xorl %eax, %eax
callq 0x3160
leaq 0x376d(%rip), %rsi      # 0x137e2
movq %r14, %rdi
movq %rbx, %rdx
xorl %eax, %eax
callq 0x3160
movl $0x0, 0xbc94(%rip)      # 0x1bd20
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O3/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 0x1012c
movl %ebp, %edi
callq 0x420f
leaq 0x3671(%rip), %rdi      # 0x13787
movl $0x4, %esi
movl $0x1, %edx
movq %rbx, %rcx
popq %rbx
popq %r14
popq %rbp
jmp 0x3210
movl %ebp, %edi
callq 0x424c
leal 0x2(%r14), %edi
callq 0x420f
leaq 0x33f3(%rip), %rdi      # 0x13536
movq %rbx, %rsi
callq 0x3110
movl %ebp, %edi
callq 0x427c
movl %r14d, %edi
popq %rbx
popq %r14
popq %rbp
jmp 0x427c
// File: /workspace/github_c_makefile_star2_O3/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 0x3508(%rip), %rsi      # 0x13687
movq %rcx, %rdx
xorl %eax, %eax
callq 0x3160
testq %r15, %r15
js 0x101a2
leaq 0x149e(%rip), %rsi      # 0x11633
movq %rbx, %rdi
movq %r15, %rdx
xorl %eax, %eax
callq 0x3160
testw %r12w, %r12w
je 0x101c1
leaq 0x35dd(%rip), %rdi      # 0x1378c
movl $0x2, %esi
movl $0x1, %edx
movq %rbx, %rcx
callq 0x3210
testl %ebp, %ebp
js 0x101dd
leaq 0x35c3(%rip), %rsi      # 0x1378f
movq %rbx, %rdi
movl %ebp, %edx
movq %r14, %rcx
xorl %eax, %eax
callq 0x3160
jmp 0x101f1
leaq 0x35b3(%rip), %rsi      # 0x13797
movq %rbx, %rdi
movq %r14, %rdx
xorl %eax, %eax
callq 0x3160
testw %r12w, %r12w
je 0x1020c
movl $0x7b, %edi
movq %rbx, %rsi
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
jmp 0x3130
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/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
movl $0x7b, %edi
movq %r15, %rsi
callq 0x3130
cmpl $0x5c, %r12d
je 0x1030b
cmpl $0x27, %r12d
je 0x1030b
cmpl $-0x1, %r12d
jne 0x1035d
leaq 0x331a(%rip), %rdi      # 0x13611
movl $0x2, %esi
movl $0x1, %edx
movq %r15, %rcx
callq 0x3210
jmp 0x1031f
leaq 0x3302(%rip), %rsi      # 0x13614
movq %r15, %rdi
movl %r12d, %edx
xorl %eax, %eax
callq 0x3160
leaq 0x3266(%rip), %rsi      # 0x1358c
movq %rbx, %rdi
callq 0x3240
testl %eax, %eax
leaq 0x3487(%rip), %rax      # 0x137be
leaq 0x348d(%rip), %rsi      # 0x137cb
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 0x3160
leal -0x20(%r12), %eax
cmpl $0x5e, %eax
ja 0x10370
leaq 0x32ac(%rip), %rsi      # 0x1361a
jmp 0x10312
leaq 0x32a8(%rip), %rsi      # 0x1361f
jmp 0x10312
// File: /workspace/github_c_makefile_star2_O3/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 %r15
pushq %r14
pushq %rbx
pushq %rax
movl %edx, %ebp
movq %rsi, %r14
movq %rdi, %rbx
cmpl $0x0, 0xb910(%rip)      # 0x1bd20
jle 0x1042f
movl $0x2c, %edi
movq %rbx, %rsi
callq 0x3130
xorl %r15d, %r15d
cmpl $0x0, 0xb8f7(%rip)      # 0x1bd20
setg %r15b
jmp 0x10432
xorl %r15d, %r15d
cmpl %r15d, %ebp
cmovgl %ebp, %r15d
testl %r15d, %r15d
je 0x10450
movl $0x20, %edi
movq %rbx, %rsi
callq 0x3130
decl %r15d
jne 0x1043e
movq %r14, %rdi
movq %rbx, %rsi
callq 0x3110
incl 0xb8bf(%rip)            # 0x1bd20
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/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 0x10525
leaq 0x32d3(%rip), %rsi      # 0x137e6
movq %r14, %rdi
movq %rcx, %rdx
movq %rax, %rcx
xorl %eax, %eax
callq 0x3160
jmp 0x1053e
testq %rcx, %rcx
je 0x1053e
leaq 0x3233(%rip), %rsi      # 0x13764
movq %r14, %rdi
movq %rax, %rdx
xorl %eax, %eax
callq 0x3160
leaq 0x329d(%rip), %rsi      # 0x137e2
movq %r14, %rdi
movq %rbx, %rdx
xorl %eax, %eax
callq 0x3160
movl $0x0, 0xb7c4(%rip)      # 0x1bd20
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O3/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 0x3163(%rip), %rsi      # 0x1380f
movq %rcx, %rdx
xorl %eax, %eax
callq 0x3160
testq %r15, %r15
js 0x106cf
leaq 0xf71(%rip), %rsi       # 0x11633
movq %rbx, %rdi
movq %r15, %rdx
xorl %eax, %eax
callq 0x3160
testl %ebp, %ebp
js 0x106eb
leaq 0x313e(%rip), %rsi      # 0x13818
movq %rbx, %rdi
movq %r14, %rdx
movl %ebp, %ecx
xorl %eax, %eax
callq 0x3160
jmp 0x106ff
leaq 0x3131(%rip), %rsi      # 0x13823
movq %rbx, %rdi
movq %r14, %rdx
xorl %eax, %eax
callq 0x3160
testw %r12w, %r12w
je 0x10726
leaq 0x302a(%rip), %rdi      # 0x13736
movl $0x4, %esi
movl $0x1, %edx
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_O3/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 0x306e(%rip), %rdi      # 0x13840
movl $0xe, %esi
movl $0x1, %edx
movq %rbx, %rcx
callq 0x3210
cmpl $-0x1, %r12d
je 0x10830
leaq 0x3063(%rip), %rsi      # 0x13854
movq %rbx, %rdi
movl %r12d, %edx
xorl %eax, %eax
callq 0x3160
cmpl $0xc, %r12d
jle 0x10839
cmpl $0xd, %r12d
je 0x10852
cmpl $0x2f, %r12d
je 0x1081a
cmpl $0x21, %r12d
jne 0x108f5
leaq 0x303a(%rip), %rsi      # 0x1385b
movq %rbx, %rdi
movl %r12d, %edx
xorl %eax, %eax
callq 0x3160
jmp 0x1086a
leaq 0x3018(%rip), %rdi      # 0x1384f
jmp 0x10862
cmpl $0x9, %r12d
je 0x1085b
cmpl $0xa, %r12d
jne 0x108f5
leaq 0x301b(%rip), %rdi      # 0x1386b
jmp 0x10862
leaq 0x3019(%rip), %rdi      # 0x13872
jmp 0x10862
leaq 0x3002(%rip), %rdi      # 0x13864
movq %rbx, %rsi
callq 0x3110
cmpq $-0x1, %r15
je 0x10886
leaq 0x301c(%rip), %rsi      # 0x13893
movq %rbx, %rdi
movq %r15, %rdx
xorl %eax, %eax
callq 0x3160
jmp 0x1089f
leaq 0x2ff3(%rip), %rdi      # 0x13880
movl $0x12, %esi
movl $0x1, %edx
movq %rbx, %rcx
callq 0x3210
leaq 0x2ce6(%rip), %rsi      # 0x1358c
movq %r14, %rdi
callq 0x3240
testl %eax, %eax
je 0x108d1
leaq 0x2ffc(%rip), %rsi      # 0x138b5
movq %rbx, %rdi
movq %r14, %rdx
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
jmp 0x3160
leaq 0x2fc7(%rip), %rdi      # 0x1389f
movl $0x15, %esi
movl $0x1, %edx
movq %rbx, %rcx
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
jmp 0x3210
leal -0x20(%r12), %eax
cmpl $0x5e, %eax
ja 0x1086a
leaq 0x2f6f(%rip), %rsi      # 0x13879
jmp 0x10821
// File: /workspace/github_c_makefile_star2_O3/theovosse[P]llgen/lang.c
// Function: rustLanguageStartFunctionDeclaration
static void rustLanguageStartFunctionDeclaration(FILE* f, const char* functionName, const char* type) {
    if (globalIndent == 0) {
        fprintf(f, "    ");
        globalIndent = 1;
    }
    fprintf(f, "fn %s(&mut self", functionName);
    returnType = type;
    nrFunctionParameters = 1;
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rdx, %rbx
movq %rsi, %r14
movq %rdi, %r15
leaq 0x9176(%rip), %r12      # 0x19af0
cmpl $0x0, (%r12)
jne 0x109a2
leaq 0x2d25(%rip), %rdi      # 0x136ad
movl $0x4, %esi
movl $0x1, %edx
movq %r15, %rcx
callq 0x3210
movl $0x1, (%r12)
leaq 0x2f26(%rip), %rsi      # 0x138cf
movq %r15, %rdi
movq %r14, %rdx
xorl %eax, %eax
callq 0x3160
movq %rbx, 0xb37b(%rip)      # 0x1bd38
movl $0x1, 0xb359(%rip)      # 0x1bd20
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O3/theovosse[P]llgen/lang.c
// Function: rustLanguageParameterDeclarationName
static void rustLanguageParameterDeclarationName(FILE* f, const char* str, int nrSpaces) {
    if (nrFunctionParameters > 0) {
        fputc(',', f);
    }
    spaces(f, nrSpaces, nrFunctionParameters > 0? 1: 0);
    fputs(str, f);
    fputc(':', f);
    nrFunctionParameters++;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movl %edx, %ebp
movq %rsi, %r14
movq %rdi, %rbx
cmpl $0x0, 0xb337(%rip)      # 0x1bd20
jle 0x10a08
movl $0x2c, %edi
movq %rbx, %rsi
callq 0x3130
xorl %r15d, %r15d
cmpl $0x0, 0xb31e(%rip)      # 0x1bd20
setg %r15b
jmp 0x10a0b
xorl %r15d, %r15d
cmpl %r15d, %ebp
cmovgl %ebp, %r15d
testl %r15d, %r15d
je 0x10a29
movl $0x20, %edi
movq %rbx, %rsi
callq 0x3130
decl %r15d
jne 0x10a17
movq %r14, %rdi
movq %rbx, %rsi
callq 0x3110
movl $0x3a, %edi
movq %rbx, %rsi
callq 0x3130
incl 0xb2d9(%rip)            # 0x1bd20
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/mabdi[P]bunney/bunny-exec.c
// Function: prepare_shm
static void prepare_shm(void) {
  _u8 buf[128];
  _u32 i;

#ifdef __CYGWIN__
  if (!getenv("CYGWIN")) {
    debug("Sorry, you need to enable SHM support in Cygwin first:\n"
          "  1. Install Cygwin IPC service ('cygserver-config').\n"
          "  2. Launch the service ('net start cygserver').\n"
          "  3. Export 'CYGWIN=server' to your environment.\n");
    exit(1);
  }
#endif /* __CYGWIN__ */
    
  if (!(outfile=fdopen(99,"a"))) fatal("unable to create a FILE object");

  shmid = shmget(0, OUTPUT_BUF + sizeof(struct shm_record), IPC_CREAT | 0600);
  if (shmid < 0) pfatal("unable to get %d kB of shared memory", OUTPUT_BUF / 1024);

  shmreg = shmat(shmid, 0, 0);
  if (!shmreg || (long)shmreg == -1) pfatal("unable to attach shared memory");

  sprintf(buf,"%u",shmid);
  setenv("BUNNY_SHMID",buf,1);

  shmreg->length      = OUTPUT_BUF;
  shmreg->child_crash = 0;

  for (i=0;i<16;i++)
    shmreg->func_quota[i] = func_limit;

}

// Assembly:
pushq %r14
pushq %rbx
subq $0x88, %rsp
leaq 0x1334(%rip), %rsi      # 0x30a1
movl $0x63, %edi
callq 0x1100
movq %rax, 0x3402(%rip)      # 0x5180
testq %rax, %rax
je 0x1e23
movl $0x80054, %esi          # imm = 0x80054
xorl %edi, %edi
movl $0x380, %edx            # imm = 0x380
callq 0x1070
movl %eax, 0x33ea(%rip)      # 0x5188
movl %eax, %edi
xorl %esi, %esi
xorl %edx, %edx
callq 0x1190
movq %rax, 0x33e0(%rip)      # 0x5190
incq %rax
cmpq $0x1, %rax
jbe 0x1e1e
movl 0x33c9(%rip), %edx      # 0x5188
leaq 0x1519(%rip), %rsi      # 0x32df
xorl %r14d, %r14d
movq %rsp, %rbx
movq %rbx, %rdi
xorl %eax, %eax
callq 0x1030
leaq 0x134d(%rip), %rdi      # 0x312a
movq %rbx, %rsi
movl $0x1, %edx
callq 0x11e0
movq 0x339f(%rip), %rax      # 0x5190
movl $0x80000, 0x4(%rax)     # imm = 0x80000
movl $0x0, 0x10(%rax)
movl 0x3353(%rip), %ecx      # 0x5158
movl %ecx, 0x14(%rax,%r14,4)
incq %r14
cmpq $0x10, %r14
jne 0x1dff
addq $0x88, %rsp
popq %rbx
popq %r14
retq
callq 0x1280
callq 0x12d6