LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O1/theovosse[P]llgen/storage.c
// Function: pop_tempmalloc
void pop_tempmalloc()
{
    TempBlokPtr tbp;

    while (temp_blok != stackBlok)
    {
	tbp = temp_blok->volgende;
	temp_blok->volgende = vrije_blokken;
	vrije_blokken = temp_blok;
	temp_blok = tbp;
    }
    temp_blok->top = stackTop;
    temp_blok->vrij += sizeof(unsigned int);
    temp_blok->top -= sizeof(unsigned int);
    if ((long int) temp_blok->top % ALIGNMENTSIZE != 0)
    {
	int v = (long int) temp_blok->top % ALIGNMENTSIZE;
	temp_blok->vrij += v;
	temp_blok->top += v;
    }
    temp_blok->vrij = *((unsigned int *) temp_blok->top);
    temp_blok->vrij += sizeof(char *);
    temp_blok->top -= sizeof(char *);
    stackTop = *((char **) temp_blok->top);
    temp_blok->vrij += sizeof(TempBlokPtr);
    temp_blok->top -= sizeof(TempBlokPtr);
    stackBlok = *((TempBlokPtr *) temp_blok->top);
}

// Assembly:
movq 0xf3d5(%rip), %rcx      # 0x1bc58
movq 0xf3c6(%rip), %rax      # 0x1bc50
cmpq %rcx, %rax
je 0xc8b7
movq 0xf3d2(%rip), %rdx      # 0x1bc68
movq %rdx, %rsi
movq %rax, %rdx
movq 0x10(%rax), %rax
movq %rsi, 0x10(%rdx)
cmpq %rcx, %rax
jne 0xc896
movq %rdx, 0xf3b8(%rip)      # 0x1bc68
movq %rax, 0xf399(%rip)      # 0x1bc50
movq 0xf3a2(%rip), %rdi      # 0x1bc60
movl 0x4(%rax), %ecx
addl $0x4, %ecx
movl %ecx, 0x4(%rax)
leaq -0x4(%rdi), %rdx
decq %rdi
testq %rdx, %rdx
cmovnsq %rdx, %rdi
movq %rdx, 0x8(%rax)
andq $-0x4, %rdi
movq %rdx, %rsi
subq %rdi, %rsi
je 0xc8f1
addl %esi, %ecx
movl %ecx, 0x4(%rax)
addq %rsi, %rdx
movq %rdx, 0x8(%rax)
movq 0x8(%rax), %rcx
movl (%rcx), %edx
leal 0x8(%rdx), %esi
movl %esi, 0x4(%rax)
leaq -0x8(%rcx), %rsi
movq %rsi, 0x8(%rax)
movq -0x8(%rcx), %rsi
movq %rsi, 0xf350(%rip)      # 0x1bc60
addl $0x10, %edx
movl %edx, 0x4(%rax)
leaq -0x10(%rcx), %rdx
movq %rdx, 0x8(%rax)
movq -0x10(%rcx), %rax
movq %rax, 0xf32f(%rip)      # 0x1bc58
retq
nop
// File: /workspace/github_c_makefile_star2_O1/theovosse[P]llgen/regexp.c
// Function: push_localadm
void push_localadm(void) {
	struct localadm *la;

	push_tempmalloc();
	la = (struct localadm *) temp_malloc(sizeof(struct localadm));
	if (la == NULL) {
		OutOfMemory("push_localadm");
		exit(1);
	}
	la->oldRegExps = oldRegExps;
	la->oldTransitions = oldTransitions;
	la->oldSets = oldSets;
	la->totalMalloc = totalMalloc;
	la->totalFree = totalFree;
	la->nrTransition = nrTransition;
	la->nrSet = nrSet;
	la->nrRegExp = nrRegExp;
	la->nrOldTransitions = nrOldTransitions;
	la->nrOldSets = nrOldSets;
	la->nrOldRegExps = nrOldRegExps;
	la->next = las;
	las = la;
	oldRegExps = NULL;
	oldTransitions = NULL;
	oldSets = NULL;
	totalMalloc += sizeof(struct localadm);
}

// Assembly:
pushq %rax
callq 0xc6dd
movl $0x60, %edi
callq 0xc827
testq %rax, %rax
je 0xc9f3
movq 0xf36c(%rip), %rcx      # 0x1bcb8
movq %rcx, (%rax)
movq 0xf36a(%rip), %rcx      # 0x1bcc0
movq %rcx, 0x8(%rax)
movq 0xf367(%rip), %rcx      # 0x1bcc8
movq %rcx, 0x10(%rax)
movq 0xf304(%rip), %rcx      # 0x1bc70
movq %rcx, 0x18(%rax)
movq 0xf321(%rip), %rdx      # 0x1bc98
movq %rdx, 0x38(%rax)
movq 0xf2f6(%rip), %rdx      # 0x1bc78
movq %rdx, 0x20(%rax)
movq 0xf2f3(%rip), %rdx      # 0x1bc80
movq %rdx, 0x28(%rax)
movq 0xf2f0(%rip), %rdx      # 0x1bc88
movq %rdx, 0x30(%rax)
movq 0xf30d(%rip), %rdx      # 0x1bcb0
movq %rdx, 0x50(%rax)
movq 0xf2fa(%rip), %rdx      # 0x1bca8
movq %rdx, 0x48(%rax)
movq 0xf2e7(%rip), %rdx      # 0x1bca0
movq %rdx, 0x40(%rax)
movq 0xf30c(%rip), %rdx      # 0x1bcd0
movq %rdx, 0x58(%rax)
movq %rax, 0xf301(%rip)      # 0x1bcd0
xorl %eax, %eax
movq %rax, 0xf2e0(%rip)      # 0x1bcb8
movq %rax, 0xf2e1(%rip)      # 0x1bcc0
movq %rax, 0xf2e2(%rip)      # 0x1bcc8
addq $0x60, %rcx
movq %rcx, 0xf27f(%rip)      # 0x1bc70
popq %rax
retq
leaq 0x64b0(%rip), %rdi      # 0x12eaa
callq 0x39cd
movl $0x1, %edi
callq 0x3200
// File: /workspace/github_c_makefile_star2_O1/theovosse[P]llgen/regexp.c
// Function: pop_localadm
void pop_localadm(void) {
	if (las == NULL) {
		(void) fprintf(stderr, "pop_localadm: las == NULL\n");
		exit(1);
	}
	oldRegExps = las->oldRegExps;
	oldTransitions = las->oldTransitions;
	oldSets = las->oldSets;
	totalMalloc = las->totalMalloc;
	nrTransition = las->nrTransition;
	nrSet = las->nrSet;
	nrRegExp = las->nrRegExp;
	totalFree = las->totalFree;
	nrOldTransitions = las->nrOldTransitions;
	nrOldSets = las->nrOldSets;
	nrOldRegExps = las->nrOldRegExps;
	las = las->next;
	pop_tempmalloc();
}

// Assembly:
movq 0xf2c0(%rip), %rax      # 0x1bcd0
testq %rax, %rax
je 0xcaa1
movq (%rax), %rcx
movq %rcx, 0xf295(%rip)      # 0x1bcb8
movq 0x8(%rax), %rcx
movq %rcx, 0xf292(%rip)      # 0x1bcc0
movq 0x10(%rax), %rcx
movq %rcx, 0xf28f(%rip)      # 0x1bcc8
movq 0x18(%rax), %rcx
movq %rcx, 0xf22c(%rip)      # 0x1bc70
movq 0x20(%rax), %rcx
movq %rcx, 0xf229(%rip)      # 0x1bc78
movq 0x28(%rax), %rcx
movq %rcx, 0xf226(%rip)      # 0x1bc80
movq 0x30(%rax), %rcx
movq %rcx, 0xf223(%rip)      # 0x1bc88
movq 0x38(%rax), %rcx
movq %rcx, 0xf228(%rip)      # 0x1bc98
movq 0x50(%rax), %rcx
movq %rcx, 0xf235(%rip)      # 0x1bcb0
movq 0x48(%rax), %rcx
movq %rcx, 0xf222(%rip)      # 0x1bca8
movq 0x40(%rax), %rcx
movq %rcx, 0xf20f(%rip)      # 0x1bca0
movq 0x58(%rax), %rax
movq %rax, 0xf234(%rip)      # 0x1bcd0
jmp 0xc87c
pushq %rax
callq 0x3a4a
// File: /workspace/github_c_makefile_star2_O1/theovosse[P]llgen/regexp.c
// Function: MakeRegExp
RegExp MakeRegExp(Transition transitions, Transition eTransitions, ESet info) {
	RegExp regExp;

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

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rdx, %rbx
movq %rsi, %r14
movq %rdi, %r15
movq 0xf1de(%rip), %rax      # 0x1bcb8
testq %rax, %rax
je 0xcafb
movq 0x18(%rax), %rcx
decq 0xf1b6(%rip)            # 0x1bca0
movq %rcx, 0xf1c7(%rip)      # 0x1bcb8
addq $-0x30, 0xf19f(%rip)    # 0x1bc98
jmp 0xcb19
movl $0x30, %edi
callq 0xc827
addq $0x30, 0xf163(%rip)     # 0x1bc70
incq 0xf174(%rip)            # 0x1bc88
testq %rax, %rax
je 0xcb59
movq %r15, (%rax)
movq %r14, 0x8(%rax)
movq %rbx, 0x10(%rax)
movslq 0xf1b1(%rip), %rcx      # 0x1bcdc
leal 0x1(%rcx), %edx
movl %edx, 0xf1a8(%rip)      # 0x1bcdc
movq %rcx, 0x28(%rax)
movq $0x0, 0x20(%rax)
movq 0xf199(%rip), %rcx      # 0x1bce0
movq 0x18(%rcx), %rdx
movq %rdx, 0x18(%rax)
movq %rax, 0x18(%rcx)
popq %rbx
popq %r14
popq %r15
retq
callq 0x3a6f
// File: /workspace/github_c_makefile_star2_O1/theovosse[P]llgen/regexp.c
// Function: MakeTransition
Transition MakeTransition(int transitionChar, RegExp destination, Transition next) {
	Transition transition;

	if (oldTransitions == NULL) {
		transition = (Transition) temp_malloc(sizeof(struct Transition));
		totalMalloc += sizeof(struct Transition); nrTransition++;
		if (transition == NULL) {
			OutOfMemory("MakeTransition");
			exit(1);
		}
	} else {
		transition = oldTransitions;
		oldTransitions = oldTransitions->next;
		nrOldTransitions--;
		totalFree -= sizeof(struct Transition);
	}
	transition->transitionChar = transitionChar;
	transition->destination = destination;
	transition->next = next;
	return (transition);
}

// Assembly:
pushq %rbp
pushq %r14
pushq %rbx
movq %rdx, %rbx
movq %rsi, %r14
movl %edi, %ebp
movq 0xf14f(%rip), %rax      # 0x1bcc0
testq %rax, %rax
je 0xcb92
movq 0x10(%rax), %rcx
decq 0xf12f(%rip)            # 0x1bcb0
movq %rcx, 0xf138(%rip)      # 0x1bcc0
addq $-0x18, 0xf108(%rip)    # 0x1bc98
jmp 0xcbb0
movl $0x18, %edi
callq 0xc827
addq $0x18, 0xf0cc(%rip)     # 0x1bc70
incq 0xf0cd(%rip)            # 0x1bc78
testq %rax, %rax
je 0xcbbf
movl %ebp, (%rax)
movq %r14, 0x8(%rax)
movq %rbx, 0x10(%rax)
popq %rbx
popq %r14
popq %rbp
retq
callq 0x3a84
// File: /workspace/github_c_makefile_star2_O1/theovosse[P]llgen/regexp.c
// Function: AddElement
ESet AddElement(void *element, ESet next) {
	ESet sPtr;

	if (oldSets == NULL) {
		sPtr = (ESet) temp_malloc(sizeof(struct ESet));
		totalMalloc += sizeof(struct ESet); nrSet++;
		if (sPtr == NULL) {
			OutOfMemory("AddElement");
			exit(1);
		}
	} else {
		sPtr = oldSets;
		oldSets = oldSets->next;
		nrOldSets--;
		totalFree -= sizeof(struct ESet);
	}
	sPtr->element = element;
	sPtr->next = next;
	return (sPtr);
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq %rdi, %r14
movq 0xf0f3(%rip), %rax      # 0x1bcc8
testq %rax, %rax
je 0xcbf6
movq 0x8(%rax), %rcx
decq 0xf0c3(%rip)            # 0x1bca8
movq %rcx, 0xf0dc(%rip)      # 0x1bcc8
addq $-0x10, 0xf0a4(%rip)    # 0x1bc98
jmp 0xcc14
movl $0x10, %edi
callq 0xc827
addq $0x10, 0xf068(%rip)     # 0x1bc70
incq 0xf071(%rip)            # 0x1bc80
testq %rax, %rax
je 0xcc23
movq %r14, (%rax)
movq %rbx, 0x8(%rax)
addq $0x8, %rsp
popq %rbx
popq %r14
retq
callq 0x3a99
// File: /workspace/github_c_makefile_star2_O1/theovosse[P]llgen/regexp.c
// Function: RemoveSet
void RemoveSet(ESet set) {
	ESet aux;

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

// Assembly:
testq %rdi, %rdi
je 0xcc71
movq 0xf064(%rip), %rax      # 0x1bc98
movq 0xf06d(%rip), %rcx      # 0x1bca8
movq 0xf086(%rip), %rdx      # 0x1bcc8
movq %rdx, %rsi
movq %rdi, %rdx
movq 0x8(%rdi), %rdi
movq %rsi, 0x8(%rdx)
incq %rcx
addq $0x10, %rax
testq %rdi, %rdi
jne 0xcc42
movq %rdx, 0xf065(%rip)      # 0x1bcc8
movq %rcx, 0xf03e(%rip)      # 0x1bca8
movq %rax, 0xf027(%rip)      # 0x1bc98
retq
// File: /workspace/github_c_makefile_star2_O1/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 0xcc97
cmpq %rdi, (%rsi)
je 0xcc9a
movq 0x8(%rsi), %rsi
jmp 0xcc87
xorl %eax, %eax
retq
movw $0xffff, %ax            # imm = 0xFFFF
retq
// File: /workspace/github_c_makefile_star2_O1/theovosse[P]llgen/regexp.c
// Function: SubSet
Boolean SubSet(ESet s1, ESet s2) {
	ESet s;

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

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

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

// Assembly:
pushq %rbp
pushq %rbx
pushq %rax
movq %rsi, %rbx
movl %edi, %ebp
movl $0x10, %edi
callq 0xc827
testq %rax, %rax
je 0xcd65
addq $0x10, 0xef18(%rip)     # 0x1bc70
movl %ebp, (%rax)
movq %rbx, 0x8(%rax)
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
callq 0x3aae
// File: /workspace/github_c_makefile_star2_O1/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 0xcd8a
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
movq 0xef6b(%rip), %rax      # 0x1bce8
cmpq %rax, 0x20(%rdi)
jne 0xcd8b
addq $0x8, %rsp
popq %rbx
popq %r14
retq
movq %rax, 0x20(%rbx)
movq 0xef5a(%rip), %rax      # 0x1bcf0
testq %rax, %rax
je 0xcda5
movq 0x28(%rbx), %rcx
movq %rbx, (%rax,%rcx,8)
jmp 0xcdb9
movslq 0xef4c(%rip), %rax      # 0x1bcf8
leal 0x1(%rax), %ecx
movl %ecx, 0xef43(%rip)      # 0x1bcf8
movq %rax, 0x28(%rbx)
movq 0x8(%rbx), %r14
testq %r14, %r14
je 0xcdd1
movq 0x8(%r14), %rdi
callq 0xcd6a
movq 0x10(%r14), %r14
jmp 0xcdbd
movq (%rbx), %rbx
testq %rbx, %rbx
je 0xcd83
movq 0x8(%rbx), %rdi
callq 0xcd6a
movq 0x10(%rbx), %rbx
jmp 0xcdd4
// File: /workspace/github_c_makefile_star2_O1/theovosse[P]llgen/regexp.c
// Function: InitRegExp
RegExp InitRegExp(void) {
	RegExp regExp = (RegExp) temp_malloc(sizeof(struct RegExp));

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

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

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

// Assembly:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x10, %rsp
movq %rsi, %r14
movq %rdi, %r12
leaq 0x8(%rsp), %r15
movq $0x0, (%r15)
movq %rdi, 0xee86(%rip)      # 0x1bce0
movl 0xee9c(%rip), %edi      # 0x1bcfc
leal 0x1(%rdi), %eax
movl %eax, 0xee93(%rip)      # 0x1bcfc
movq %rdx, %rsi
callq 0xcd39
movq %rax, %rbx
xorl %edi, %edi
xorl %esi, %esi
xorl %edx, %edx
callq 0xcac5
movq %rax, %r13
movq 0x8(%r12), %rdx
xorl %edi, %edi
movq %rax, %rsi
callq 0xcb5e
movq %rax, 0x8(%r12)
movl $0x0, 0xee60(%rip)      # 0x1bd00
movq %r13, %rdi
movq %r14, %rsi
movq %r15, %rdx
callq 0xcefb
movq %rax, %r14
movl 0xee49(%rip), %eax      # 0x1bd00
testl %eax, %eax
jne 0xceed
movq %rbx, %rdi
xorl %esi, %esi
callq 0xcbc4
movq 0x8(%rsp), %rcx
movq %rax, 0x10(%rcx)
cmpb $0x0, (%r14)
je 0xcee7
cmpl $0x0, 0xee25(%rip)      # 0x1bd00
jne 0xcee7
movl $0x4, 0xee19(%rip)      # 0x1bd00
movl 0xee13(%rip), %eax      # 0x1bd00
addq $0x10, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O1/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 0xcac5
movq %rax, %r12
movq 0x8(%r14), %rdx
xorl %edi, %edi
movq %rax, %rsi
callq 0xcb5e
movq %rax, 0x8(%r14)
movq %r12, %rdi
movq %r15, %rsi
movq %rbx, %rdx
callq 0xf073
movq %rax, %r12
leaq 0x8(%rsp), %rdi
movq %rax, (%rdi)
leaq 0x6(%rsp), %rsi
xorl %edx, %edx
callq 0xf657
cmpl $0x0, 0xeda2(%rip)      # 0x1bd00
jne 0xd027
cmpb $0x7c, %al
jne 0xd027
cmpw $0x0, 0x6(%rsp)
je 0xd027
xorl %edi, %edi
xorl %esi, %esi
xorl %edx, %edx
callq 0xcac5
movq %rax, %r15
leaq 0x10(%rsp), %rax
movq %r15, (%rax)
movq (%rbx), %r12
movq 0x8(%r12), %rdx
xorl %edi, %edi
movq %r15, %rsi
callq 0xcb5e
movq %rax, 0x8(%r12)
movq %r15, (%rbx)
leaq 0x6(%rsp), %rbp
xorl %edi, %edi
xorl %esi, %esi
xorl %edx, %edx
callq 0xcac5
movq %rax, %r15
movq 0x8(%r14), %rdx
xorl %edi, %edi
movq %rax, %rsi
callq 0xcb5e
movq %rax, 0x8(%r14)
movq 0x8(%rsp), %rsi
movq %r15, %rdi
leaq 0x10(%rsp), %rdx
callq 0xf073
movq %rax, %r12
movq %rax, 0x8(%rsp)
leaq 0x8(%rsp), %rdi
movq %rbp, %rsi
xorl %edx, %edx
callq 0xf657
movl %eax, %r15d
movq 0x10(%rsp), %r13
movq (%rbx), %rsi
movq 0x8(%r13), %rdx
xorl %edi, %edi
callq 0xcb5e
movq %rax, 0x8(%r13)
cmpl $0x0, 0xece9(%rip)      # 0x1bd00
jne 0xd027
cmpb $0x7c, %r15b
jne 0xd027
cmpw $0x0, 0x6(%rsp)
jne 0xcfad
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_O1/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 0xea66(%rip)            # 0x1bce8
movq %rdi, %rbx
movl $0x0, 0xea69(%rip)      # 0x1bcf8
movq $0x0, 0xea56(%rip) # 0x1bcf0
callq 0xcd6a
callq 0xc92c
movl 0xea4e(%rip), %edi      # 0x1bcf8
shll $0x3, %edi
callq 0xc827
movq %rax, 0xea37(%rip)      # 0x1bcf0
movl 0xea39(%rip), %edi      # 0x1bcf8
addl %edi, %edi
callq 0xc827
movq %rax, 0xea3b(%rip)      # 0x1bd08
movl 0xea25(%rip), %edi      # 0x1bcf8
addl %edi, %edi
callq 0xc827
movq %rax, 0xea2f(%rip)      # 0x1bd10
cmpq $0x0, 0xea07(%rip)      # 0x1bcf0
je 0xd30a
cmpq $0x0, 0xea15(%rip)      # 0x1bd08
je 0xd30a
testq %rax, %rax
je 0xd30a
incq 0xe9e7(%rip)            # 0x1bce8
movq %rbx, %rdi
popq %rbx
jmp 0xcd6a
leaq 0x5bfd(%rip), %rdi      # 0x12f0e
popq %rbx
jmp 0x39cd
// File: /workspace/github_c_makefile_star2_O1/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
sete %dl
testq %rdi, %rdi
setne %cl
sete %r8b
orb %dl, %r8b
jne 0xd5ce
movq (%rdi), %rcx
testq %rcx, %rcx
je 0xd5b7
cmpl %eax, (%rcx)
jne 0xd5a5
movq 0x8(%rcx), %rdi
jmp 0xd5a7
xorl %edi, %edi
movq 0x10(%rcx), %rcx
testq %rcx, %rcx
je 0xd5b9
testq %rdi, %rdi
je 0xd59b
jmp 0xd5b9
xorl %edi, %edi
incq %rsi
movsbl (%rsi), %eax
testq %rdi, %rdi
setne %cl
testl %eax, %eax
je 0xd5ce
testq %rdi, %rdi
jne 0xd593
testb %cl, %cl
je 0xd5d7
movq 0x10(%rdi), %rax
retq
xorl %eax, %eax
retq
// File: /workspace/github_c_makefile_star2_O1/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 0xda40
pushq %r14
pushq %rbx
movq 0xe35a(%rip), %rax      # 0x1bca0
movq 0xe36b(%rip), %r10      # 0x1bcb8
movq 0xe374(%rip), %rsi      # 0x1bcc8
movq 0xe34d(%rip), %rdx      # 0x1bca8
movq 0xe336(%rip), %rcx      # 0x1bc98
movq 0xe347(%rip), %r8       # 0x1bcb0
movq 0xe350(%rip), %r9       # 0x1bcc0
movq %rdi, %r11
movq (%rdi), %rbx
movq 0x18(%rdi), %rdi
testq %rbx, %rbx
je 0xd9a7
movq %r9, %r14
movq %rbx, %r9
movq 0x10(%rbx), %rbx
movq %r14, 0x10(%r9)
incq %r8
addq $0x18, %rcx
testq %rbx, %rbx
jne 0xd97f
movq %r9, 0xe320(%rip)       # 0x1bcc0
movq %r8, 0xe309(%rip)       # 0x1bcb0
movq 0x8(%r11), %rbx
testq %rbx, %rbx
je 0xd9d8
movq %r9, %r14
movq %rbx, %r9
movq 0x10(%rbx), %rbx
movq %r14, 0x10(%r9)
incq %r8
addq $0x18, %rcx
testq %rbx, %rbx
jne 0xd9b0
movq %r9, 0xe2ef(%rip)       # 0x1bcc0
movq %r8, 0xe2d8(%rip)       # 0x1bcb0
movq 0x10(%r11), %rbx
testq %rbx, %rbx
je 0xda11
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 0xd9e9
movq %rsi, 0xe2be(%rip)      # 0x1bcc8
movq %rdx, 0xe297(%rip)      # 0x1bca8
movq %r10, 0x18(%r11)
incq %rax
addq $0x30, %rcx
movq %r11, %r10
testq %rdi, %rdi
jne 0xd970
movq %rcx, 0xe269(%rip)      # 0x1bc98
movq %r11, 0xe282(%rip)      # 0x1bcb8
movq %rax, 0xe263(%rip)      # 0x1bca0
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O1/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 0xe025(%rip), %rax      # 0x1bce8
incq %rax
movq %rax, 0xe01b(%rip)      # 0x1bce8
movq 0x8(%rdi), %rcx
movq %rdi, %r14
testq %rcx, %rcx
je 0xdcf2
movq %rbx, %rdx
movq %rcx, %r14
movq (%rdx), %rcx
movq %rax, 0x20(%rcx)
movq 0x8(%r14), %rcx
movq %r14, %rdx
testq %rcx, %rcx
jne 0xdcdc
movq (%r14), %rcx
movq %rax, 0x20(%rcx)
testq %rbx, %rbx
je 0xdd54
addq $0x8, %r14
movq %rbx, %r15
movq (%r15), %rax
movq 0x8(%rax), %r12
testq %r12, %r12
je 0xdd4b
movq 0x8(%r12), %rdi
movq 0x20(%rdi), %rax
cmpq 0xdfc7(%rip), %rax      # 0x1bce8
je 0xdd44
xorl %esi, %esi
callq 0xcbc4
movq %rax, (%r14)
movq 0xdfb4(%rip), %rcx      # 0x1bce8
movq 0x8(%r12), %rdx
movq %rcx, 0x20(%rdx)
addq $0x8, %rax
movq %rax, %r14
movq 0x10(%r12), %r12
jmp 0xdd0c
movq 0x8(%r15), %r15
testq %r15, %r15
jne 0xdd05
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O1/theovosse[P]llgen/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 0xdd99
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
xorl %r14d, %r14d
movq %r14, 0x28(%rbx)
cmpq $0x0, 0x8(%rbx)
jne 0xdd8b
movq 0x18(%rbx), %rbx
incq %r14
testq %rbx, %rbx
jne 0xdd72
jmp 0xdd92
callq 0x3ad8
jmp 0xdd7d
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O1/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 0xde6a
pushq %r14
pushq %rbx
movq 0xdef3(%rip), %rax      # 0x1bca0
movq 0xdf04(%rip), %r10      # 0x1bcb8
movq 0xdf0d(%rip), %rsi      # 0x1bcc8
movq 0xdee6(%rip), %rdx      # 0x1bca8
movq 0xdecf(%rip), %rcx      # 0x1bc98
movq 0xdee0(%rip), %r8       # 0x1bcb0
movq 0xdee9(%rip), %r9       # 0x1bcc0
movq %rdi, %r11
movq (%rdi), %rbx
movq 0x18(%rdi), %rdi
testq %rbx, %rbx
je 0xde0e
movq %r9, %r14
movq %rbx, %r9
movq 0x10(%rbx), %rbx
movq %r14, 0x10(%r9)
incq %r8
addq $0x18, %rcx
testq %rbx, %rbx
jne 0xdde6
movq %r9, 0xdeb9(%rip)       # 0x1bcc0
movq %r8, 0xdea2(%rip)       # 0x1bcb0
movq 0x10(%r11), %rbx
testq %rbx, %rbx
je 0xde3f
movq %rsi, %r14
movq %rbx, %rsi
movq 0x8(%rbx), %rbx
movq %r14, 0x8(%rsi)
incq %rdx
addq $0x10, %rcx
testq %rbx, %rbx
jne 0xde17
movq %rsi, 0xde90(%rip)      # 0x1bcc8
movq %rdx, 0xde69(%rip)      # 0x1bca8
movq %r10, 0x18(%r11)
incq %rax
addq $0x30, %rcx
movq %r11, %r10
testq %rdi, %rdi
jne 0xddd7
movq %rcx, 0xde3f(%rip)      # 0x1bc98
movq %r11, 0xde58(%rip)      # 0x1bcb8
movq %rax, 0xde39(%rip)      # 0x1bca0
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O1/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 0xda40(%rip), %rax      # 0x1bce8
cmpq %rax, 0x20(%rdi)
je 0xe2cb
pushq %rbx
movq %rax, 0x20(%rdi)
movq (%rdi), %rbx
testq %rbx, %rbx
je 0xe2ca
movq 0x8(%rbx), %rdi
callq 0xe2a1
movq 0x10(%rbx), %rbx
jmp 0xe2b6
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O1/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 0xc827
testq %rax, %rax
je 0xf037
movq %rax, %r14
addq $0x810, 0xccfd(%rip) # imm = 0x810
movq %r15, (%rax)
movq $0x0, 0x8(%rax)
movq %rax, 0xcd93(%rip)      # 0x1bd18
movq %rax, 0x28(%rbx)
movq 0x18(%rbx), %r15
testq %r15, %r15
je 0xefd4
movq 0x10(%r15), %r12
movl $0x810, %edi            # imm = 0x810
callq 0xc827
testq %rax, %rax
je 0xf032
addq $0x810, 0xccbc(%rip) # imm = 0x810
movq %r12, (%rax)
movq 0xcd5a(%rip), %rcx      # 0x1bd18
movq 0x8(%rcx), %rdx
movq %rdx, 0x8(%rax)
movq %rax, 0x8(%rcx)
movq %rax, 0x28(%r15)
movq 0x18(%r15), %r15
jmp 0xef8d
testq %rbx, %rbx
je 0xf025
movl 0xa27c(%rip), %r12d     # 0x1925c
movq %r12, %r15
shlq $0x3, %r15
movq 0x28(%rbx), %r13
testl %r12d, %r12d
je 0xeffe
leaq 0x10(%r13), %rdi
xorl %esi, %esi
movq %r15, %rdx
callq 0x3120
movq (%rbx), %rax
testq %rax, %rax
je 0xf01c
movq 0x8(%rax), %rcx
movq 0x28(%rcx), %rcx
movslq (%rax), %rdx
movq %rcx, 0x10(%r13,%rdx,8)
movq 0x10(%rax), %rax
jmp 0xf001
movq 0x18(%rbx), %rbx
testq %rbx, %rbx
jne 0xefe7
movq %r14, %rax
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
callq 0x3af4
callq 0x3b09
// File: /workspace/github_c_makefile_star2_O1/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 0xf06d
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 0xf04b
jmp 0xf06f
xorl %ecx, %ecx
movq %rcx, (%rdx)
retq
// File: /workspace/github_c_makefile_star2_O1/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 0xf678
testl %ecx, %ecx
jne 0xf69b
movw $0x0, (%rbx)
xorl %ebp, %ebp
jmp 0xf722
leaq 0x1(%rax), %rcx
movq %rcx, (%rdi)
movb 0x1(%rax), %bpl
movzbl %bpl, %ecx
cmpl $0x71, %ecx
jg 0xf6c6
cmpl $0x30, %ecx
je 0xf70d
cmpl $0x6e, %ecx
jne 0xf6f8
movb $0xa, %bpl
jmp 0xf716
leaq 0x1(%rax), %rcx
movq %rcx, (%rdi)
movb (%rax), %bpl
cmpw $0x0, 0xc5e3(%rip)      # 0x1bc90
je 0xf6d5
movsbl %bpl, %esi
testw %dx, %dx
je 0xf6d9
leaq 0x3a10(%rip), %rdi      # 0x130cf
movl $0x4, %edx
jmp 0xf6e5
cmpl $0x72, %ecx
je 0xf713
cmpl $0x74, %ecx
jne 0xf6f8
movb $0x9, %bpl
jmp 0xf716
xorl %eax, %eax
jmp 0xf6f0
leaq 0x39e6(%rip), %rdi      # 0x130c6
movl $0x9, %edx
callq 0x3140
testq %rax, %rax
setne %al
movzbl %al, %eax
movw %ax, (%rbx)
jmp 0xf722
cmpw $0x0, 0xc590(%rip)      # 0x1bc90
jne 0xf716
xorl %ecx, %ecx
cmpb $0x5c, %bpl
setne %cl
jmp 0xf718
xorl %ecx, %ecx
xorl %ebp, %ebp
jmp 0xf718
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
nop
// File: /workspace/github_c_makefile_star2_O1/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 0xf770
movl %edx, %ebp
movl %edx, %edi
callq 0x42f1
leaq 0xa3ab(%rip), %rax      # 0x19b0c
cmpw $0x0, (%rax)
je 0xf77e
movl %ebp, %edi
callq 0x4284
jmp 0xf78b
leaq 0x248e(%rip), %rdi      # 0x11c05
movl $0x2, %esi
jmp 0xf797
movl $0x20, %edi
movq %rbx, %rsi
callq 0x3130
leaq 0x3e50(%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_O1/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 0x3e1a(%rip), %rsi      # 0x135ea
xorl %eax, %eax
callq 0x3160
testq %r14, %r14
js 0xf7f0
leaq 0x1e58(%rip), %rsi      # 0x1163b
movq %rbx, %rdi
movq %r14, %rdx
xorl %eax, %eax
callq 0x3160
testl %ebp, %ebp
js 0xf809
leaq 0x3df8(%rip), %rsi      # 0x135f3
movq %rbx, %rdi
movl %ebp, %edx
xorl %eax, %eax
callq 0x3160
jmp 0xf822
leaq 0x3e87(%rip), %rdi      # 0x13697
movl $0x2, %esi
movl $0x1, %edx
movq %rbx, %rcx
callq 0x3210
testw %r15w, %r15w
je 0xf84b
leaq 0x3f37(%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_O1/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 0x3d21(%rip), %rdi      # 0x1360e
movl $0x2, %esi
movl $0x1, %edx
movq %r15, %rcx
callq 0x3210
cmpl $0x5c, %r12d
je 0xf92c
cmpl $0x27, %r12d
je 0xf92c
cmpl $-0x1, %r12d
jne 0xf962
leaq 0x3cf9(%rip), %rdi      # 0x13611
movl $0x2, %esi
movl $0x1, %edx
movq %r15, %rcx
callq 0x3210
jmp 0xf940
leaq 0x3ce1(%rip), %rsi      # 0x13614
movq %r15, %rdi
movl %r12d, %edx
xorl %eax, %eax
callq 0x3160
leaq 0x3ce1(%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 0xf975
leaq 0x3ca7(%rip), %rsi      # 0x1361a
jmp 0xf933
leaq 0x3ca3(%rip), %rsi      # 0x1361f
jmp 0xf933
// File: /workspace/github_c_makefile_star2_O1/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
cmpl $0x0, 0xc327(%rip)      # 0x1bd20
jle 0xfa38
movq %rdi, %r15
movl 0xc320(%rip), %eax      # 0x1bd24
cmpl $0x2, %eax
movl $0x1, %ebp
cmovgel %eax, %ebp
movl $0x20, %edi
movq %r15, %rsi
callq 0x3130
decl %ebp
jne 0xfa0f
movq 0xc301(%rip), %rdx      # 0x1bd28
leaq 0x3c16(%rip), %rsi      # 0x13644
movq %r15, %rdi
xorl %eax, %eax
callq 0x3160
movq %r14, 0xc2e9(%rip)      # 0x1bd28
movl %ebx, 0xc2eb(%rip)      # 0x1bd30
movb $0x0, 0xc2e8(%rip)      # 0x1bd34
incl 0xc2ce(%rip)            # 0x1bd20
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/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, 0xc2c1(%rip)      # 0x1bd34
je 0xfa8c
testl %ebp, %ebp
jle 0xfacb
movl $0x20, %edi
movq %rbx, %rsi
callq 0x3130
decl %ebp
jne 0xfa79
jmp 0xfacb
movl 0xc29e(%rip), %eax      # 0x1bd30
xorl %r15d, %r15d
cmpl $0x0, 0xc284(%rip)      # 0x1bd20
setg %r15b
cmpl %r15d, %eax
cmovgl %eax, %r15d
testl %r15d, %r15d
je 0xfabe
movl $0x20, %edi
movq %rbx, %rsi
callq 0x3130
decl %r15d
jne 0xfaac
movl %ebp, 0xc260(%rip)      # 0x1bd24
movb $0x1, 0xc269(%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_O1/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, 0xc233(%rip)      # 0x1bd20
jle 0xfb29
movl 0xc23b(%rip), %eax      # 0x1bd30
cmpl $0x2, %eax
movl $0x1, %ebp
cmovgel %eax, %ebp
movl $0x20, %edi
movq %rbx, %rsi
callq 0x3130
decl %ebp
jne 0xfb00
movq 0xc210(%rip), %rdx      # 0x1bd28
leaq 0x3c39(%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_O1/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 0xfb6b
leaq 0x3ae8(%rip), %rsi      # 0x13649
movq %r14, %rdi
xorl %eax, %eax
callq 0x3160
testq %r15, %r15
je 0xfb84
leaq 0x3bed(%rip), %rsi      # 0x13764
movq %r14, %rdi
movq %r15, %rdx
xorl %eax, %eax
callq 0x3160
leaq 0x3c57(%rip), %rsi      # 0x137e2
movq %r14, %rdi
movq %rbx, %rdx
xorl %eax, %eax
callq 0x3160
movl $0x0, 0xc17e(%rip)      # 0x1bd20
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O1/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 0xfc40
movl %ebp, %edi
callq 0x4284
movq (%r14), %rdx
leaq 0x3a17(%rip), %rsi      # 0x1364d
movq %rbx, %rdi
xorl %eax, %eax
callq 0x3160
movl %ebp, %edi
callq 0x4284
movq (%r14), %rdx
leaq 0x3a19(%rip), %rsi      # 0x1366a
movq %rbx, %rdi
xorl %eax, %eax
popq %rbx
popq %r14
popq %rbp
jmp 0x3160
// File: /workspace/github_c_makefile_star2_O1/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 0x3a12(%rip), %rsi      # 0x13687
movq %rcx, %rdx
xorl %eax, %eax
callq 0x3160
testq %r14, %r14
js 0xfc98
leaq 0x19b0(%rip), %rsi      # 0x1163b
movq %rbx, %rdi
movq %r14, %rdx
xorl %eax, %eax
callq 0x3160
testw %bp, %bp
je 0xfcba
leaq 0x3a92(%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_O1/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 0x197f(%rip), %rdi      # 0x116c9
movl $0x2, %esi
movl $0x1, %edx
movq %rbx, %rcx
callq 0x3210
cmpl $0x5c, %r12d
je 0xfd8d
cmpl $0x27, %r12d
je 0xfd8d
cmpl $-0x1, %r12d
jne 0xfe32
leaq 0x3939(%rip), %rdi      # 0x136b2
movl $0x2, %esi
movl $0x1, %edx
movq %rbx, %rcx
callq 0x3210
jmp 0xfda1
leaq 0x3880(%rip), %rsi      # 0x13614
movq %rbx, %rdi
movl %r12d, %edx
xorl %eax, %eax
callq 0x3160
leaq 0x390d(%rip), %rdi      # 0x136b5
movl $0x3, %esi
movl $0x1, %edx
movq %rbx, %rcx
callq 0x3210
cmpq $-0x1, %r15
je 0xfdd4
leaq 0x38f2(%rip), %rsi      # 0x136b9
movq %rbx, %rdi
movq %r15, %rdx
xorl %eax, %eax
callq 0x3160
leaq 0x376d(%rip), %rsi      # 0x13548
movq %r14, %rdi
callq 0x3240
testl %eax, %eax
je 0xfe0e
cmpq $-0x1, %r15
je 0xfdfa
movl $0x2c, %edi
movq %rbx, %rsi
callq 0x3130
leaq 0x38c8(%rip), %rsi      # 0x136c9
movq %rbx, %rdi
movq %r14, %rdx
xorl %eax, %eax
callq 0x3160
leaq 0x38df(%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 0xfe48
leaq 0x37d7(%rip), %rsi      # 0x1361a
jmp 0xfd94
leaq 0x37d0(%rip), %rsi      # 0x1361f
jmp 0xfd94
// File: /workspace/github_c_makefile_star2_O1/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, 0xbe22(%rip)      # 0x1bd20
jle 0xff19
leaq 0x15e8(%rip), %rdi      # 0x114ef
movl $0x2, %esi
movl $0x1, %edx
movq %rbx, %rcx
callq 0x3210
movq %r14, %rdi
movq %rbx, %rsi
callq 0x3110
incl 0xbdf6(%rip)            # 0x1bd20
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O1/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 0xff79
leaq 0x37a8(%rip), %rdi      # 0x1370f
movl $0x4, %esi
movl $0x1, %edx
movq %r14, %rcx
callq 0x3210
testq %r15, %r15
je 0xff92
leaq 0x37df(%rip), %rsi      # 0x13764
movq %r14, %rdi
movq %r15, %rdx
xorl %eax, %eax
callq 0x3160
leaq 0x3849(%rip), %rsi      # 0x137e2
movq %r14, %rdi
movq %rbx, %rdx
xorl %eax, %eax
callq 0x3160
movl $0x0, 0xbd70(%rip)      # 0x1bd20
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O1/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 0x36bc(%rip), %rsi      # 0x13729
movq %rcx, %rdx
xorl %eax, %eax
callq 0x3160
testq %r15, %r15
js 0x10090
leaq 0x15b8(%rip), %rsi      # 0x1163b
movq %r14, %rdi
movq %r15, %rdx
xorl %eax, %eax
callq 0x3160
testw %bp, %bp
je 0x100b3
leaq 0x3694(%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_O1/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, 0xbb94(%rip)      # 0x1bd20
jle 0x1019b
movl $0x2c, %edi
movq %rbx, %rsi
callq 0x3130
xorl %r15d, %r15d
cmpl $0x0, 0xbb7b(%rip)      # 0x1bd20
setg %r15b
cmpl %r15d, %ebp
cmovgl %ebp, %r15d
testl %r15d, %r15d
je 0x101c7
movl $0x20, %edi
movq %rbx, %rsi
callq 0x3130
decl %r15d
jne 0x101b5
movq %r14, %rdi
movq %rbx, %rsi
callq 0x3110
movb $0x0, 0xbb5b(%rip)      # 0x1bd34
incl 0xbb41(%rip)            # 0x1bd20
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/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, 0xbb37(%rip)      # 0x1bd34
jne 0x10215
leaq 0x2e2b(%rip), %rdi      # 0x13031
movq %rbx, %rsi
callq 0x3110
movb $0x1, 0xbb1f(%rip)      # 0x1bd34
testl %ebp, %ebp
jle 0x1022a
movl $0x20, %edi
movq %rbx, %rsi
callq 0x3130
decl %ebp
jne 0x10219
movq %r14, %rdi
movq %rbx, %rsi
popq %rbx
popq %r14
popq %rbp
jmp 0x3110
// File: /workspace/github_c_makefile_star2_O1/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 0x10286
leaq 0x34e8(%rip), %rsi      # 0x1375c
movq %r14, %rdi
movq %rcx, %rdx
movq %rax, %rcx
xorl %eax, %eax
callq 0x3160
jmp 0x1029f
testq %rcx, %rcx
je 0x1029f
leaq 0x34d2(%rip), %rsi      # 0x13764
movq %r14, %rdi
movq %rcx, %rdx
xorl %eax, %eax
callq 0x3160
leaq 0x353c(%rip), %rsi      # 0x137e2
movq %r14, %rdi
movq %rbx, %rdx
xorl %eax, %eax
callq 0x3160
movl $0x0, 0xba63(%rip)      # 0x1bd20
addq $0x8, %rsp
popq %rbx
popq %r14
retq