LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O0/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:
pushq %rbp
movq %rsp, %rbp
movq 0x118b5(%rip), %rax     # 0x22eb0
cmpq 0x118b6(%rip), %rax     # 0x22eb8
je 0x11640
movq 0x118a5(%rip), %rax     # 0x22eb0
movq 0x10(%rax), %rax
movq %rax, -0x8(%rbp)
movq 0x118ae(%rip), %rcx     # 0x22ec8
movq 0x1188f(%rip), %rax     # 0x22eb0
movq %rcx, 0x10(%rax)
movq 0x11884(%rip), %rax     # 0x22eb0
movq %rax, 0x11895(%rip)     # 0x22ec8
movq -0x8(%rbp), %rax
movq %rax, 0x11872(%rip)     # 0x22eb0
jmp 0x115f4
movq 0x11879(%rip), %rcx     # 0x22ec0
movq 0x11862(%rip), %rax     # 0x22eb0
movq %rcx, 0x8(%rax)
movq 0x11857(%rip), %rax     # 0x22eb0
movl 0x4(%rax), %ecx
addq $0x4, %rcx
movl %ecx, 0x4(%rax)
movq 0x11846(%rip), %rax     # 0x22eb0
movq 0x8(%rax), %rcx
addq $-0x4, %rcx
movq %rcx, 0x8(%rax)
movq 0x11833(%rip), %rax     # 0x22eb0
movq 0x8(%rax), %rax
movl $0x4, %ecx
cqto
idivq %rcx
cmpq $0x0, %rdx
je 0x116d3
movq 0x11818(%rip), %rax     # 0x22eb0
movq 0x8(%rax), %rax
movl $0x4, %ecx
cqto
idivq %rcx
movl %edx, %eax
movl %eax, -0xc(%rbp)
movl -0xc(%rbp), %ecx
movq 0x117fb(%rip), %rax     # 0x22eb0
addl 0x4(%rax), %ecx
movl %ecx, 0x4(%rax)
movl -0xc(%rbp), %edx
movq 0x117eb(%rip), %rax     # 0x22eb0
movq 0x8(%rax), %rcx
movslq %edx, %rdx
addq %rdx, %rcx
movq %rcx, 0x8(%rax)
movq 0x117d6(%rip), %rax     # 0x22eb0
movq 0x8(%rax), %rax
movl (%rax), %ecx
movq 0x117c9(%rip), %rax     # 0x22eb0
movl %ecx, 0x4(%rax)
movq 0x117bf(%rip), %rax     # 0x22eb0
movl 0x4(%rax), %ecx
addq $0x8, %rcx
movl %ecx, 0x4(%rax)
movq 0x117ae(%rip), %rax     # 0x22eb0
movq 0x8(%rax), %rcx
addq $-0x8, %rcx
movq %rcx, 0x8(%rax)
movq 0x1179b(%rip), %rax     # 0x22eb0
movq 0x8(%rax), %rax
movq (%rax), %rax
movq %rax, 0x1179d(%rip)     # 0x22ec0
movq 0x11786(%rip), %rax     # 0x22eb0
movl 0x4(%rax), %ecx
addq $0x8, %rcx
movl %ecx, 0x4(%rax)
movq 0x11775(%rip), %rax     # 0x22eb0
movq 0x8(%rax), %rcx
addq $-0x8, %rcx
movq %rcx, 0x8(%rax)
movq 0x11762(%rip), %rax     # 0x22eb0
movq 0x8(%rax), %rax
movq (%rax), %rax
movq %rax, 0x1175c(%rip)     # 0x22eb8
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/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 %rbp
movq %rsp, %rbp
subq $0x10, %rsp
callq 0x11270
movl $0x60, %edi
callq 0x11520
movq %rax, -0x8(%rbp)
cmpq $0x0, -0x8(%rbp)
jne 0x11798
leaq 0x98a0(%rip), %rdi      # 0x1b029
callq 0x11890
movl $0x1, %edi
callq 0x31e0
movq 0x11779(%rip), %rcx     # 0x22f18
movq -0x8(%rbp), %rax
movq %rcx, (%rax)
movq 0x11773(%rip), %rcx     # 0x22f20
movq -0x8(%rbp), %rax
movq %rcx, 0x8(%rax)
movq 0x1176c(%rip), %rcx     # 0x22f28
movq -0x8(%rbp), %rax
movq %rcx, 0x10(%rax)
movq 0x11705(%rip), %rcx     # 0x22ed0
movq -0x8(%rbp), %rax
movq %rcx, 0x18(%rax)
movq 0x1171e(%rip), %rcx     # 0x22ef8
movq -0x8(%rbp), %rax
movq %rcx, 0x38(%rax)
movq 0x116ef(%rip), %rcx     # 0x22ed8
movq -0x8(%rbp), %rax
movq %rcx, 0x20(%rax)
movq 0x116e8(%rip), %rcx     # 0x22ee0
movq -0x8(%rbp), %rax
movq %rcx, 0x28(%rax)
movq 0x116e1(%rip), %rcx     # 0x22ee8
movq -0x8(%rbp), %rax
movq %rcx, 0x30(%rax)
movq 0x116fa(%rip), %rcx     # 0x22f10
movq -0x8(%rbp), %rax
movq %rcx, 0x50(%rax)
movq 0x116e3(%rip), %rcx     # 0x22f08
movq -0x8(%rbp), %rax
movq %rcx, 0x48(%rax)
movq 0x116cc(%rip), %rcx     # 0x22f00
movq -0x8(%rbp), %rax
movq %rcx, 0x40(%rax)
movq 0x116ed(%rip), %rcx     # 0x22f30
movq -0x8(%rbp), %rax
movq %rcx, 0x58(%rax)
movq -0x8(%rbp), %rax
movq %rax, 0x116da(%rip)     # 0x22f30
movq $0x0, 0x116b7(%rip) # 0x22f18
movq $0x0, 0x116b4(%rip) # 0x22f20
movq $0x0, 0x116b1(%rip) # 0x22f28
movq 0x11652(%rip), %rax     # 0x22ed0
addq $0x60, %rax
movq %rax, 0x11647(%rip)     # 0x22ed0
addq $0x10, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/theovosse[P]llgen/regexp.c
// Function: OutOfMemory
static void OutOfMemory(char *func) {
	(void) fprintf(stderr, "Out of memory in %s\n", func);
	(void) fprintf(stderr, "%ld bytes allocated\n", totalMalloc);
	(void) fprintf(stderr, "%ld transitions\n", nrTransition);
	(void) fprintf(stderr, "%ld sets\n", nrSet);
	(void) fprintf(stderr, "%ld regexps\n", nrRegExp);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq 0xe755(%rip), %rax      # 0x1fff8
movq (%rax), %rdi
movq -0x8(%rbp), %rdx
leaq 0x9aa2(%rip), %rsi      # 0x1b353
movb $0x0, %al
callq 0x3140
movq 0xe739(%rip), %rax      # 0x1fff8
movq (%rax), %rdi
movq 0x11607(%rip), %rdx     # 0x22ed0
leaq 0x9a98(%rip), %rsi      # 0x1b368
movb $0x0, %al
callq 0x3140
movq 0xe71a(%rip), %rax      # 0x1fff8
movq (%rax), %rdi
movq 0x115f0(%rip), %rdx     # 0x22ed8
leaq 0x9a8e(%rip), %rsi      # 0x1b37d
movb $0x0, %al
callq 0x3140
movq 0xe6fb(%rip), %rax      # 0x1fff8
movq (%rax), %rdi
movq 0x115d9(%rip), %rdx     # 0x22ee0
leaq 0x9a80(%rip), %rsi      # 0x1b38e
movb $0x0, %al
callq 0x3140
movq 0xe6dc(%rip), %rax      # 0x1fff8
movq (%rax), %rdi
movq 0x115c2(%rip), %rdx     # 0x22ee8
leaq 0x9a6b(%rip), %rsi      # 0x1b398
movb $0x0, %al
callq 0x3140
addq $0x10, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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:
pushq %rbp
movq %rsp, %rbp
cmpq $0x0, 0x115e4(%rip)     # 0x22f30
jne 0x11970
movq 0xe6a3(%rip), %rax      # 0x1fff8
movq (%rax), %rdi
leaq 0x96d8(%rip), %rsi      # 0x1b037
movb $0x0, %al
callq 0x3140
movl $0x1, %edi
callq 0x31e0
movq 0x115b9(%rip), %rax     # 0x22f30
movq (%rax), %rax
movq %rax, 0x11597(%rip)     # 0x22f18
movq 0x115a8(%rip), %rax     # 0x22f30
movq 0x8(%rax), %rax
movq %rax, 0x1158d(%rip)     # 0x22f20
movq 0x11596(%rip), %rax     # 0x22f30
movq 0x10(%rax), %rax
movq %rax, 0x11583(%rip)     # 0x22f28
movq 0x11584(%rip), %rax     # 0x22f30
movq 0x18(%rax), %rax
movq %rax, 0x11519(%rip)     # 0x22ed0
movq 0x11572(%rip), %rax     # 0x22f30
movq 0x20(%rax), %rax
movq %rax, 0x1150f(%rip)     # 0x22ed8
movq 0x11560(%rip), %rax     # 0x22f30
movq 0x28(%rax), %rax
movq %rax, 0x11505(%rip)     # 0x22ee0
movq 0x1154e(%rip), %rax     # 0x22f30
movq 0x30(%rax), %rax
movq %rax, 0x114fb(%rip)     # 0x22ee8
movq 0x1153c(%rip), %rax     # 0x22f30
movq 0x38(%rax), %rax
movq %rax, 0x114f9(%rip)     # 0x22ef8
movq 0x1152a(%rip), %rax     # 0x22f30
movq 0x50(%rax), %rax
movq %rax, 0x114ff(%rip)     # 0x22f10
movq 0x11518(%rip), %rax     # 0x22f30
movq 0x48(%rax), %rax
movq %rax, 0x114e5(%rip)     # 0x22f08
movq 0x11506(%rip), %rax     # 0x22f30
movq 0x40(%rax), %rax
movq %rax, 0x114cb(%rip)     # 0x22f00
movq 0x114f4(%rip), %rax     # 0x22f30
movq 0x58(%rax), %rax
movq %rax, 0x114e9(%rip)     # 0x22f30
callq 0x115f0
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/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 %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
cmpq $0x0, 0x1144c(%rip)     # 0x22f18
jne 0x11b1f
movl $0x30, %edi
callq 0x11520
movq %rax, -0x20(%rbp)
movq 0x113ed(%rip), %rax     # 0x22ed0
addq $0x30, %rax
movq %rax, 0x113e2(%rip)     # 0x22ed0
movq 0x113f3(%rip), %rax     # 0x22ee8
addq $0x1, %rax
movq %rax, 0x113e8(%rip)     # 0x22ee8
cmpq $0x0, -0x20(%rbp)
jne 0x11b1d
leaq 0x9544(%rip), %rdi      # 0x1b052
callq 0x11890
movl $0x1, %edi
callq 0x31e0
jmp 0x11b60
movq 0x113f2(%rip), %rax     # 0x22f18
movq %rax, -0x20(%rbp)
movq 0x113e7(%rip), %rax     # 0x22f18
movq 0x18(%rax), %rax
movq %rax, 0x113dc(%rip)     # 0x22f18
movq 0x113bd(%rip), %rax     # 0x22f00
addq $-0x1, %rax
movq %rax, 0x113b2(%rip)     # 0x22f00
movq 0x113a3(%rip), %rax     # 0x22ef8
subq $0x30, %rax
movq %rax, 0x11398(%rip)     # 0x22ef8
movq -0x8(%rbp), %rcx
movq -0x20(%rbp), %rax
movq %rcx, (%rax)
movq -0x10(%rbp), %rcx
movq -0x20(%rbp), %rax
movq %rcx, 0x8(%rax)
movq -0x18(%rbp), %rcx
movq -0x20(%rbp), %rax
movq %rcx, 0x10(%rax)
movl 0x113b3(%rip), %eax     # 0x22f3c
movl %eax, %ecx
addl $0x1, %ecx
movl %ecx, 0x113a8(%rip)     # 0x22f3c
movslq %eax, %rcx
movq -0x20(%rbp), %rax
movq %rcx, 0x28(%rax)
movq -0x20(%rbp), %rax
movq $0x0, 0x20(%rax)
movq 0x1138e(%rip), %rax     # 0x22f40
movq 0x18(%rax), %rcx
movq -0x20(%rbp), %rax
movq %rcx, 0x18(%rax)
movq -0x20(%rbp), %rcx
movq 0x11377(%rip), %rax     # 0x22f40
movq %rcx, 0x18(%rax)
movq -0x20(%rbp), %rax
addq $0x20, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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
movq %rsp, %rbp
subq $0x20, %rsp
movl %edi, -0x4(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
cmpq $0x0, 0x11325(%rip)     # 0x22f20
jne 0x11c4e
movl $0x18, %edi
callq 0x11520
movq %rax, -0x20(%rbp)
movq 0x112be(%rip), %rax     # 0x22ed0
addq $0x18, %rax
movq %rax, 0x112b3(%rip)     # 0x22ed0
movq 0x112b4(%rip), %rax     # 0x22ed8
addq $0x1, %rax
movq %rax, 0x112a9(%rip)     # 0x22ed8
cmpq $0x0, -0x20(%rbp)
jne 0x11c4c
leaq 0x9420(%rip), %rdi      # 0x1b05d
callq 0x11890
movl $0x1, %edi
callq 0x31e0
jmp 0x11c8f
movq 0x112cb(%rip), %rax     # 0x22f20
movq %rax, -0x20(%rbp)
movq 0x112c0(%rip), %rax     # 0x22f20
movq 0x10(%rax), %rax
movq %rax, 0x112b5(%rip)     # 0x22f20
movq 0x1129e(%rip), %rax     # 0x22f10
addq $-0x1, %rax
movq %rax, 0x11293(%rip)     # 0x22f10
movq 0x11274(%rip), %rax     # 0x22ef8
subq $0x18, %rax
movq %rax, 0x11269(%rip)     # 0x22ef8
movl -0x4(%rbp), %ecx
movq -0x20(%rbp), %rax
movl %ecx, (%rax)
movq -0x10(%rbp), %rcx
movq -0x20(%rbp), %rax
movq %rcx, 0x8(%rax)
movq -0x18(%rbp), %rcx
movq -0x20(%rbp), %rax
movq %rcx, 0x10(%rax)
movq -0x20(%rbp), %rax
addq $0x20, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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 %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
cmpq $0x0, 0x11250(%rip)     # 0x22f28
jne 0x11d2b
movl $0x10, %edi
callq 0x11520
movq %rax, -0x18(%rbp)
movq 0x111e1(%rip), %rax     # 0x22ed0
addq $0x10, %rax
movq %rax, 0x111d6(%rip)     # 0x22ed0
movq 0x111df(%rip), %rax     # 0x22ee0
addq $0x1, %rax
movq %rax, 0x111d4(%rip)     # 0x22ee0
cmpq $0x0, -0x18(%rbp)
jne 0x11d29
leaq 0x9352(%rip), %rdi      # 0x1b06c
callq 0x11890
movl $0x1, %edi
callq 0x31e0
jmp 0x11d6c
movq 0x111f6(%rip), %rax     # 0x22f28
movq %rax, -0x18(%rbp)
movq 0x111eb(%rip), %rax     # 0x22f28
movq 0x8(%rax), %rax
movq %rax, 0x111e0(%rip)     # 0x22f28
movq 0x111b9(%rip), %rax     # 0x22f08
addq $-0x1, %rax
movq %rax, 0x111ae(%rip)     # 0x22f08
movq 0x11197(%rip), %rax     # 0x22ef8
subq $0x10, %rax
movq %rax, 0x1118c(%rip)     # 0x22ef8
movq -0x8(%rbp), %rcx
movq -0x18(%rbp), %rax
movq %rcx, (%rax)
movq -0x10(%rbp), %rcx
movq -0x18(%rbp), %rax
movq %rcx, 0x8(%rax)
movq -0x18(%rbp), %rax
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/theovosse[P]llgen/regexp.c
// Function: RemoveSet
void RemoveSet(ESet set) {
	ESet aux;

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

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
cmpq $0x0, -0x8(%rbp)
je 0x11dc2
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rax
movq %rax, -0x10(%rbp)
movq -0x8(%rbp), %rdi
callq 0x11dd0
movq -0x10(%rbp), %rax
movq %rax, -0x8(%rbp)
jmp 0x11d9c
addq $0x10, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/theovosse[P]llgen/regexp.c
// Function: FreeSet
static void FreeSet(ESet set) {
	set->next = oldSets;
	oldSets = set;
	nrOldSets++;
	totalFree += sizeof(struct ESet);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movq 0x11149(%rip), %rcx     # 0x22f28
movq -0x8(%rbp), %rax
movq %rcx, 0x8(%rax)
movq -0x8(%rbp), %rax
movq %rax, 0x11136(%rip)     # 0x22f28
movq 0x1110f(%rip), %rax     # 0x22f08
addq $0x1, %rax
movq %rax, 0x11104(%rip)     # 0x22f08
movq 0x110ed(%rip), %rax     # 0x22ef8
addq $0x10, %rax
movq %rax, 0x110e2(%rip)     # 0x22ef8
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
cmpq $0x0, -0x18(%rbp)
je 0x11e96
movq -0x18(%rbp), %rax
movq (%rax), %rax
cmpq -0x10(%rbp), %rax
jne 0x11e88
movw $0xffff, -0x2(%rbp)     # imm = 0xFFFF
jmp 0x11e9c
movq -0x18(%rbp), %rax
movq 0x8(%rax), %rax
movq %rax, -0x18(%rbp)
jmp 0x11e6c
movw $0x0, -0x2(%rbp)
movw -0x2(%rbp), %ax
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
cmpq $0x0, -0x10(%rbp)
je 0x11f11
movq -0x18(%rbp), %rax
movq %rax, -0x20(%rbp)
cmpq $0x0, -0x20(%rbp)
je 0x11ef4
movq -0x20(%rbp), %rax
movq (%rax), %rax
movq -0x10(%rbp), %rcx
cmpq (%rcx), %rax
jne 0x11ee4
jmp 0x11ef4
jmp 0x11ee6
movq -0x20(%rbp), %rax
movq 0x8(%rax), %rax
movq %rax, -0x20(%rbp)
jmp 0x11ecb
cmpq $0x0, -0x20(%rbp)
jne 0x11f03
movw $0x0, -0x2(%rbp)
jmp 0x11f17
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rax
movq %rax, -0x10(%rbp)
jmp 0x11ebc
movw $0xffff, -0x2(%rbp)     # imm = 0xFFFF
movw -0x2(%rbp), %ax
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/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
movq %rsp, %rbp
subq $0x20, %rsp
movl %edi, -0x4(%rbp)
movq %rsi, -0x10(%rbp)
movl $0x10, %edi
callq 0x11520
movq %rax, -0x18(%rbp)
cmpq $0x0, -0x18(%rbp)
jne 0x11faa
leaq 0x90dc(%rip), %rdi      # 0x1b077
callq 0x11890
movl $0x1, %edi
callq 0x31e0
movq 0x10f1f(%rip), %rax     # 0x22ed0
addq $0x10, %rax
movq %rax, 0x10f14(%rip)     # 0x22ed0
movl -0x4(%rbp), %ecx
movq -0x18(%rbp), %rax
movl %ecx, (%rax)
movq -0x10(%rbp), %rcx
movq -0x18(%rbp), %rax
movq %rcx, 0x8(%rax)
movq -0x18(%rbp), %rax
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
cmpq $0x0, -0x8(%rbp)
je 0x12004
movq -0x8(%rbp), %rax
movq 0x20(%rax), %rax
cmpq 0x10f46(%rip), %rax     # 0x22f48
jne 0x12009
jmp 0x120b2
movq 0x10f38(%rip), %rcx     # 0x22f48
movq -0x8(%rbp), %rax
movq %rcx, 0x20(%rax)
cmpq $0x0, 0x10f30(%rip)     # 0x22f50
je 0x1203b
movq -0x8(%rbp), %rdx
movq 0x10f23(%rip), %rax     # 0x22f50
movq -0x8(%rbp), %rcx
movq 0x28(%rcx), %rcx
movq %rdx, (%rax,%rcx,8)
jmp 0x12057
movl 0x10f17(%rip), %eax     # 0x22f58
movl %eax, %ecx
addl $0x1, %ecx
movl %ecx, 0x10f0c(%rip)     # 0x22f58
movslq %eax, %rcx
movq -0x8(%rbp), %rax
movq %rcx, 0x28(%rax)
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rax
movq %rax, -0x10(%rbp)
cmpq $0x0, -0x10(%rbp)
je 0x12085
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rdi
callq 0x11fe0
movq -0x10(%rbp), %rax
movq 0x10(%rax), %rax
movq %rax, -0x10(%rbp)
jmp 0x12063
movq -0x8(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x10(%rbp)
cmpq $0x0, -0x10(%rbp)
je 0x120b2
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rdi
callq 0x11fe0
movq -0x10(%rbp), %rax
movq 0x10(%rax), %rax
movq %rax, -0x10(%rbp)
jmp 0x12090
addq $0x10, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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 %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movl $0x30, %edi
callq 0x11520
movq %rax, -0x8(%rbp)
movq 0x10df3(%rip), %rax     # 0x22ed0
addq $0x30, %rax
movq %rax, 0x10de8(%rip)     # 0x22ed0
movq 0x10df9(%rip), %rax     # 0x22ee8
addq $0x1, %rax
movq %rax, 0x10dee(%rip)     # 0x22ee8
cmpq $0x0, -0x8(%rbp)
jne 0x12117
leaq 0x8f7a(%rip), %rdi      # 0x1b082
callq 0x11890
movl $0x1, %edi
callq 0x31e0
movq -0x8(%rbp), %rax
movq $0x0, (%rax)
movq -0x8(%rbp), %rax
movq $0x0, 0x8(%rax)
movq -0x8(%rbp), %rax
movq $0x0, 0x10(%rax)
movl 0x10dfc(%rip), %eax     # 0x22f3c
movl %eax, %ecx
addl $0x1, %ecx
movl %ecx, 0x10df1(%rip)     # 0x22f3c
movslq %eax, %rcx
movq -0x8(%rbp), %rax
movq %rcx, 0x28(%rax)
movq -0x8(%rbp), %rax
movq $0x0, 0x20(%rax)
movq -0x8(%rbp), %rax
movq $0x0, 0x18(%rax)
movq -0x8(%rbp), %rax
addq $0x10, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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 %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movq $0x0, -0x28(%rbp)
movq -0x10(%rbp), %rax
movq %rax, 0x10d99(%rip)     # 0x22f40
movl 0x10daf(%rip), %edi     # 0x22f5c
movl %edi, %eax
addl $0x1, %eax
movl %eax, 0x10da4(%rip)     # 0x22f5c
movq -0x20(%rbp), %rsi
callq 0x11f70
movq %rax, -0x40(%rbp)
xorl %eax, %eax
movl %eax, %edx
movq %rdx, %rdi
movq %rdx, %rsi
callq 0x11ab0
movq %rax, -0x38(%rbp)
movq -0x10(%rbp), %rdi
movq -0x38(%rbp), %rsi
callq 0x11e20
movl $0x0, 0x10d71(%rip)     # 0x22f60
movq -0x38(%rbp), %rdi
movq -0x18(%rbp), %rsi
leaq -0x28(%rbp), %rdx
callq 0x12270
movq %rax, -0x30(%rbp)
cmpl $0x0, 0x10d55(%rip)     # 0x22f60
je 0x12218
movl 0x10d4d(%rip), %eax     # 0x22f60
movl %eax, -0x4(%rbp)
jmp 0x1225a
movq -0x40(%rbp), %rdi
xorl %eax, %eax
movl %eax, %esi
callq 0x11cc0
movq %rax, %rcx
movq -0x28(%rbp), %rax
movq %rcx, 0x10(%rax)
movq -0x30(%rbp), %rax
movsbl (%rax), %eax
cmpl $0x0, %eax
je 0x12251
cmpl $0x0, 0x10d1d(%rip)     # 0x22f60
jne 0x1224f
movl $0x4, 0x10d11(%rip)     # 0x22f60
jmp 0x12251
movl 0x10d09(%rip), %eax     # 0x22f60
movl %eax, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x40, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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
movq %rsp, %rbp
subq $0x50, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
xorl %eax, %eax
movl %eax, %edx
movq %rdx, %rdi
movq %rdx, %rsi
callq 0x11ab0
movq %rax, -0x38(%rbp)
movq -0x8(%rbp), %rdi
movq -0x38(%rbp), %rsi
callq 0x11e20
movq -0x38(%rbp), %rdi
movq -0x10(%rbp), %rsi
movq -0x18(%rbp), %rdx
callq 0x15d80
movq %rax, -0x20(%rbp)
movq %rax, -0x30(%rbp)
leaq -0x30(%rbp), %rdi
leaq -0x24(%rbp), %rsi
xorl %edx, %edx
callq 0x15e50
movb %al, -0x21(%rbp)
cmpl $0x0, 0x10c8a(%rip)     # 0x22f60
jne 0x123b5
movsbl -0x21(%rbp), %eax
cmpl $0x7c, %eax
jne 0x123b5
movswl -0x24(%rbp), %eax
cmpl $0x0, %eax
je 0x123b5
xorl %eax, %eax
movl %eax, %edx
movq %rdx, %rdi
movq %rdx, %rsi
callq 0x11ab0
movq %rax, -0x40(%rbp)
movq -0x18(%rbp), %rax
movq (%rax), %rdi
movq -0x40(%rbp), %rsi
callq 0x11e20
movq -0x40(%rbp), %rcx
movq -0x18(%rbp), %rax
movq %rcx, (%rax)
xorl %eax, %eax
movl %eax, %edx
movq %rdx, %rdi
movq %rdx, %rsi
callq 0x11ab0
movq %rax, -0x38(%rbp)
movq -0x8(%rbp), %rdi
movq -0x38(%rbp), %rsi
callq 0x11e20
movq -0x38(%rbp), %rdi
movq -0x30(%rbp), %rsi
leaq -0x40(%rbp), %rdx
callq 0x15d80
movq %rax, -0x20(%rbp)
movq %rax, -0x30(%rbp)
leaq -0x30(%rbp), %rdi
leaq -0x24(%rbp), %rsi
xorl %edx, %edx
callq 0x15e50
movb %al, -0x21(%rbp)
movq -0x40(%rbp), %rdi
movq -0x18(%rbp), %rax
movq (%rax), %rsi
callq 0x11e20
xorl %eax, %eax
cmpl $0x0, 0x10bd8(%rip)     # 0x22f60
movb %al, -0x41(%rbp)
jne 0x123a8
movsbl -0x21(%rbp), %ecx
xorl %eax, %eax
cmpl $0x7c, %ecx
movb %al, -0x41(%rbp)
jne 0x123a8
movswl -0x24(%rbp), %eax
cmpl $0x0, %eax
setne %al
movb %al, -0x41(%rbp)
movb -0x41(%rbp), %al
testb $0x1, %al
jne 0x12324
jmp 0x123b5
movq -0x20(%rbp), %rax
addq $0x50, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/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 %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq 0x10855(%rip), %rax     # 0x22f48
addq $0x1, %rax
movq %rax, 0x1084a(%rip)     # 0x22f48
movl $0x0, 0x10850(%rip)     # 0x22f58
movq $0x0, 0x1083d(%rip) # 0x22f50
movq -0x8(%rbp), %rdi
callq 0x11fe0
callq 0x11760
movslq 0x10830(%rip), %rax     # 0x22f58
shlq $0x3, %rax
movl %eax, %edi
callq 0x11520
movq %rax, 0x10816(%rip)     # 0x22f50
movslq 0x10817(%rip), %rax     # 0x22f58
shlq %rax
movl %eax, %edi
callq 0x11520
movq %rax, 0x10816(%rip)     # 0x22f68
movslq 0x107ff(%rip), %rax     # 0x22f58
shlq %rax
movl %eax, %edi
callq 0x11520
movq %rax, 0x10806(%rip)     # 0x22f70
cmpq $0x0, 0x107de(%rip)     # 0x22f50
je 0x12788
cmpq $0x0, 0x107ec(%rip)     # 0x22f68
je 0x12788
cmpq $0x0, 0x107ea(%rip)     # 0x22f70
jne 0x12796
leaq 0x88fe(%rip), %rdi      # 0x1b08d
callq 0x11890
jmp 0x127b1
movq 0x107ab(%rip), %rax     # 0x22f48
addq $0x1, %rax
movq %rax, 0x107a0(%rip)     # 0x22f48
movq -0x8(%rbp), %rdi
callq 0x11fe0
addq $0x10, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x20(%rbp)
movq -0x18(%rbp), %rax
movq %rax, %rcx
addq $0x1, %rcx
movq %rcx, -0x18(%rbp)
movsbl (%rax), %eax
andl $0xff, %eax
movl %eax, -0x2c(%rbp)
xorl %eax, %eax
cmpl $0x0, -0x2c(%rbp)
movb %al, -0x2d(%rbp)
je 0x12ca4
cmpq $0x0, -0x20(%rbp)
setne %al
movb %al, -0x2d(%rbp)
movb -0x2d(%rbp), %al
testb $0x1, %al
jne 0x12cad
jmp 0x12d23
movq -0x20(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x28(%rbp)
movq $0x0, -0x20(%rbp)
xorl %eax, %eax
cmpq $0x0, -0x28(%rbp)
movb %al, -0x2e(%rbp)
je 0x12cd7
cmpq $0x0, -0x20(%rbp)
sete %al
movb %al, -0x2e(%rbp)
movb -0x2e(%rbp), %al
testb $0x1, %al
jne 0x12ce0
jmp 0x12d07
movq -0x28(%rbp), %rax
movl (%rax), %eax
cmpl -0x2c(%rbp), %eax
jne 0x12cf7
movq -0x28(%rbp), %rax
movq 0x8(%rax), %rax
movq %rax, -0x20(%rbp)
jmp 0x12cf9
movq -0x28(%rbp), %rax
movq 0x10(%rax), %rax
movq %rax, -0x28(%rbp)
jmp 0x12cc0
jmp 0x12d09
movq -0x18(%rbp), %rax
movq %rax, %rcx
addq $0x1, %rcx
movq %rcx, -0x18(%rbp)
movsbl (%rax), %eax
movl %eax, -0x2c(%rbp)
jmp 0x12c8e
cmpq $0x0, -0x20(%rbp)
je 0x12d38
movq -0x20(%rbp), %rax
movq 0x10(%rax), %rax
movq %rax, -0x8(%rbp)
jmp 0x12d40
movq $0x0, -0x8(%rbp)
movq -0x8(%rbp), %rax
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/theovosse[P]llgen/regexp.c
// Function: RemoveNFA
void RemoveNFA(RegExp nfa) {
	RegExp aux;
	Transition tr;
	Transition auxTr;

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

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
cmpq $0x0, -0x8(%rbp)
je 0x13354
movq -0x8(%rbp), %rax
movq 0x18(%rax), %rax
movq %rax, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x18(%rbp)
cmpq $0x0, -0x18(%rbp)
je 0x132e4
movq -0x18(%rbp), %rax
movq 0x10(%rax), %rax
movq %rax, -0x20(%rbp)
movq -0x18(%rbp), %rdi
callq 0x13360
movq -0x20(%rbp), %rax
movq %rax, -0x18(%rbp)
jmp 0x132be
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rax
movq %rax, -0x18(%rbp)
cmpq $0x0, -0x18(%rbp)
je 0x13316
movq -0x18(%rbp), %rax
movq 0x10(%rax), %rax
movq %rax, -0x20(%rbp)
movq -0x18(%rbp), %rdi
callq 0x13360
movq -0x20(%rbp), %rax
movq %rax, -0x18(%rbp)
jmp 0x132f0
movq -0x8(%rbp), %rax
cmpq $0x0, 0x10(%rax)
je 0x1333e
movq -0x8(%rbp), %rax
movq 0x10(%rax), %rax
movq $0x0, 0x8(%rax)
movq -0x8(%rbp), %rax
movq 0x10(%rax), %rdi
callq 0x11d90
movq -0x8(%rbp), %rdi
callq 0x133b0
movq -0x10(%rbp), %rax
movq %rax, -0x8(%rbp)
jmp 0x1329c
addq $0x20, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/theovosse[P]llgen/regexp.c
// Function: FreeTransition
static void FreeTransition(Transition tr) {
	tr->next = oldTransitions;
	oldTransitions = tr;
	nrOldTransitions++;
	totalFree += sizeof(struct Transition);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movq 0xfbb1(%rip), %rcx      # 0x22f20
movq -0x8(%rbp), %rax
movq %rcx, 0x10(%rax)
movq -0x8(%rbp), %rax
movq %rax, 0xfb9e(%rip)      # 0x22f20
movq 0xfb87(%rip), %rax      # 0x22f10
addq $0x1, %rax
movq %rax, 0xfb7c(%rip)      # 0x22f10
movq 0xfb5d(%rip), %rax      # 0x22ef8
addq $0x18, %rax
movq %rax, 0xfb52(%rip)      # 0x22ef8
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/theovosse[P]llgen/regexp.c
// Function: FreeRegExp
static void FreeRegExp(RegExp re) {
	re->next = oldRegExps;
	oldRegExps = re;
	nrOldRegExps++;
	totalFree += sizeof(struct RegExp);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movq 0xfb59(%rip), %rcx      # 0x22f18
movq -0x8(%rbp), %rax
movq %rcx, 0x18(%rax)
movq -0x8(%rbp), %rax
movq %rax, 0xfb46(%rip)      # 0x22f18
movq 0xfb27(%rip), %rax      # 0x22f00
addq $0x1, %rax
movq %rax, 0xfb1c(%rip)      # 0x22f00
movq 0xfb0d(%rip), %rax      # 0x22ef8
addq $0x30, %rax
movq %rax, 0xfb02(%rip)      # 0x22ef8
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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 %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq 0xf935(%rip), %rax      # 0x22f48
addq $0x1, %rax
movq %rax, 0xf92a(%rip)      # 0x22f48
movq -0x8(%rbp), %rax
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rax
cmpq $0x0, 0x8(%rax)
je 0x13651
movq 0xf910(%rip), %rcx      # 0x22f48
movq -0x18(%rbp), %rax
movq (%rax), %rax
movq %rcx, 0x20(%rax)
movq -0x18(%rbp), %rax
movq 0x8(%rax), %rax
movq %rax, -0x18(%rbp)
jmp 0x13626
movq 0xf8f0(%rip), %rcx      # 0x22f48
movq -0x18(%rbp), %rax
movq (%rax), %rax
movq %rcx, 0x20(%rax)
movq -0x18(%rbp), %rax
addq $0x8, %rax
movq %rax, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x18(%rbp)
cmpq $0x0, -0x18(%rbp)
je 0x1370b
movq -0x18(%rbp), %rax
movq (%rax), %rax
movq 0x8(%rax), %rax
movq %rax, -0x20(%rbp)
cmpq $0x0, -0x20(%rbp)
je 0x136fa
movq -0x20(%rbp), %rax
movq 0x8(%rax), %rax
movq 0x20(%rax), %rax
cmpq 0xf89d(%rip), %rax      # 0x22f48
je 0x136ea
movq -0x20(%rbp), %rax
movq 0x8(%rax), %rdi
xorl %eax, %eax
movl %eax, %esi
callq 0x11cc0
movq %rax, %rcx
movq -0x10(%rbp), %rax
movq %rcx, (%rax)
movq 0xf879(%rip), %rcx      # 0x22f48
movq -0x20(%rbp), %rax
movq 0x8(%rax), %rax
movq %rcx, 0x20(%rax)
movq -0x10(%rbp), %rax
movq (%rax), %rax
addq $0x8, %rax
movq %rax, -0x10(%rbp)
jmp 0x136ec
movq -0x20(%rbp), %rax
movq 0x10(%rax), %rax
movq %rax, -0x20(%rbp)
jmp 0x13691
movq -0x18(%rbp), %rax
movq 0x8(%rax), %rax
movq %rax, -0x18(%rbp)
jmp 0x13677
movq -0x8(%rbp), %rax
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/theovosse[P]llgen/regexp.c
// Function: CollectTransitions
static ESet CollectTransitions(ESet stateSet, int ch) {
	ESet destSet = NULL;
	Transition tr;

	while (stateSet != NULL) {
		for (tr = ((RegExp) stateSet->element)->transitions; tr != NULL; tr = tr->next) {
			if (tr->transitionChar == ch && !SetMember(tr->destination, destSet)) {
				destSet = AddElement(tr->destination, destSet);
			}
		}
		stateSet = stateSet->next;
	}
	return (destSet);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movq $0x0, -0x18(%rbp)
cmpq $0x0, -0x8(%rbp)
je 0x137a8
movq -0x8(%rbp), %rax
movq (%rax), %rax
movq (%rax), %rax
movq %rax, -0x20(%rbp)
cmpq $0x0, -0x20(%rbp)
je 0x1379a
movq -0x20(%rbp), %rax
movl (%rax), %eax
cmpl -0xc(%rbp), %eax
jne 0x1378a
movq -0x20(%rbp), %rax
movq 0x8(%rax), %rdi
movq -0x18(%rbp), %rsi
callq 0x11e60
cmpw $0x0, %ax
jne 0x1378a
movq -0x20(%rbp), %rax
movq 0x8(%rax), %rdi
movq -0x18(%rbp), %rsi
callq 0x11cc0
movq %rax, -0x18(%rbp)
jmp 0x1378c
movq -0x20(%rbp), %rax
movq 0x10(%rax), %rax
movq %rax, -0x20(%rbp)
jmp 0x1374c
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rax
movq %rax, -0x8(%rbp)
jmp 0x13737
movq -0x18(%rbp), %rax
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/theovosse[P]llgen/regexp.c
// Function: Member
static RegExp Member(ESet stateSet, RegExp fa) {
	while (fa != NULL) {
		if (SetEqual(stateSet, fa->state.set)) {
			return (fa);
		}
		fa = fa->next;
	}
	return (NULL);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
cmpq $0x0, -0x18(%rbp)
je 0x13806
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rax
movq 0x28(%rax), %rsi
callq 0x11f20
cmpw $0x0, %ax
je 0x137f8
movq -0x18(%rbp), %rax
movq %rax, -0x8(%rbp)
jmp 0x1380e
movq -0x18(%rbp), %rax
movq 0x18(%rax), %rax
movq %rax, -0x18(%rbp)
jmp 0x137d0
movq $0x0, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/theovosse[P]llgen/regexp.c
// Function: CollectInfo
static ESet CollectInfo(ESet stateSet) {
	ESet info = NULL;

	while (stateSet != NULL) {
		if (((RegExp) stateSet->element)->info != NULL) {
			info = AddElement(((RegExp) stateSet->element)->info->element, info);
		}
		stateSet = stateSet->next;
	}
	return (info);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq $0x0, -0x10(%rbp)
cmpq $0x0, -0x8(%rbp)
je 0x13872
movq -0x8(%rbp), %rax
movq (%rax), %rax
cmpq $0x0, 0x10(%rax)
je 0x13864
movq -0x8(%rbp), %rax
movq (%rax), %rax
movq 0x10(%rax), %rax
movq (%rax), %rdi
movq -0x10(%rbp), %rsi
callq 0x11cc0
movq %rax, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rax
movq %rax, -0x8(%rbp)
jmp 0x13834
movq -0x10(%rbp), %rax
addq $0x10, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/theovosse[P]llgen/regexp.c
// Function: RenumberDFA
static void RenumberDFA(RegExp dfa) {
	long int dfaStateNumber = 0;
	RegExp state;

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

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq $0x0, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x18(%rbp)
cmpq $0x0, -0x18(%rbp)
je 0x138ed
movq -0x10(%rbp), %rcx
movq %rcx, %rax
addq $0x1, %rax
movq %rax, -0x10(%rbp)
movq -0x18(%rbp), %rax
movq %rcx, 0x28(%rax)
movq -0x18(%rbp), %rax
cmpq $0x0, 0x8(%rax)
je 0x138dd
movq 0xc72c(%rip), %rax      # 0x1fff8
movq (%rax), %rdi
leaq 0x7b40(%rip), %rsi      # 0x1b416
movb $0x0, %al
callq 0x3140
jmp 0x138df
movq -0x18(%rbp), %rax
movq 0x18(%rax), %rax
movq %rax, -0x18(%rbp)
jmp 0x1389c
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/theovosse[P]llgen/regexp.c
// Function: RemoveDFA
void RemoveDFA(RegExp dfa) {
	RegExp aux;
	Transition tr, auxTr;

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

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
cmpq $0x0, -0x8(%rbp)
je 0x13970
movq -0x8(%rbp), %rax
movq 0x18(%rax), %rax
movq %rax, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x18(%rbp)
cmpq $0x0, -0x18(%rbp)
je 0x13950
movq -0x18(%rbp), %rax
movq 0x10(%rax), %rax
movq %rax, -0x20(%rbp)
movq -0x18(%rbp), %rdi
callq 0x13360
movq -0x20(%rbp), %rax
movq %rax, -0x18(%rbp)
jmp 0x1392a
movq -0x8(%rbp), %rax
movq 0x10(%rax), %rdi
callq 0x11d90
movq -0x8(%rbp), %rdi
callq 0x133b0
movq -0x10(%rbp), %rax
movq %rax, -0x8(%rbp)
jmp 0x1390c
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/theovosse[P]llgen/regexp.c
// Function: FirstAnswerIdentical
static Boolean FirstAnswerIdentical(ESet info1, ESet info2) {
	int first1;
	int first2;

	if (info1 == NULL || info2 == NULL) {
		return (info1 == info2);
	}
	for (first1 = ((Answer) info1->element)->number, info1 = info1->next; info1 != NULL; info1 = info1->next) {
		if (((Answer) info1->element)->number < first1) {
			first1 = ((Answer) info1->element)->number;
		}
	}
	for (first2 = ((Answer) info2->element)->number, info2 = info2->next; info2 != NULL; info2 = info2->next) {
		if (((Answer) info2->element)->number < first2) {
			first2 = ((Answer) info2->element)->number;
		}
	}
	return (first1 == first2);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
cmpq $0x0, -0x10(%rbp)
je 0x13d0a
cmpq $0x0, -0x18(%rbp)
jne 0x13d23
movq -0x10(%rbp), %rax
cmpq -0x18(%rbp), %rax
sete %al
andb $0x1, %al
movzbl %al, %eax
movw %ax, -0x2(%rbp)
jmp 0x13dc7
movq -0x10(%rbp), %rax
movq (%rax), %rax
movl (%rax), %eax
movl %eax, -0x1c(%rbp)
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rax
movq %rax, -0x10(%rbp)
cmpq $0x0, -0x10(%rbp)
je 0x13d6c
movq -0x10(%rbp), %rax
movq (%rax), %rax
movl (%rax), %eax
cmpl -0x1c(%rbp), %eax
jge 0x13d5c
movq -0x10(%rbp), %rax
movq (%rax), %rax
movl (%rax), %eax
movl %eax, -0x1c(%rbp)
jmp 0x13d5e
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rax
movq %rax, -0x10(%rbp)
jmp 0x13d3b
movq -0x18(%rbp), %rax
movq (%rax), %rax
movl (%rax), %eax
movl %eax, -0x20(%rbp)
movq -0x18(%rbp), %rax
movq 0x8(%rax), %rax
movq %rax, -0x18(%rbp)
cmpq $0x0, -0x18(%rbp)
je 0x13db5
movq -0x18(%rbp), %rax
movq (%rax), %rax
movl (%rax), %eax
cmpl -0x20(%rbp), %eax
jge 0x13da5
movq -0x18(%rbp), %rax
movq (%rax), %rax
movl (%rax), %eax
movl %eax, -0x20(%rbp)
jmp 0x13da7
movq -0x18(%rbp), %rax
movq 0x8(%rax), %rax
movq %rax, -0x18(%rbp)
jmp 0x13d84
movl -0x1c(%rbp), %eax
cmpl -0x20(%rbp), %eax
sete %al
andb $0x1, %al
movzbl %al, %eax
movw %ax, -0x2(%rbp)
movw -0x2(%rbp), %ax
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/theovosse[P]llgen/regexp.c
// Function: AllDestinationsEqual
static Boolean AllDestinationsEqual(RegExp state1, RegExp state2) {
	int i;
	Transition tr;
	ESet d1[256], d2[256];

	for (i = 0; i != charSetSize; i++) d1[i] = d2[i] = NULL;
	for (tr = state1->transitions; tr != NULL; tr = tr->next) {
		d1[tr->transitionChar] = tr->destination->state.set;
	}
	for (tr = state2->transitions; tr != NULL; tr = tr->next) {
		d2[tr->transitionChar] = tr->destination->state.set;
	}
	for (i = 0; i != charSetSize; i++) {
		if (d1[i] != d2[i]) {
			return (false);
		}
	}
	return (true);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0xfb0, %rsp            # imm = 0xFB0
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movl $0x0, -0x1c(%rbp)
movl -0x1c(%rbp), %eax
cmpl 0xc4b1(%rip), %eax      # 0x202a4
je 0x13e20
movslq -0x1c(%rbp), %rax
movq $0x0, -0x1030(%rbp,%rax,8)
movslq -0x1c(%rbp), %rax
movq $0x0, -0x830(%rbp,%rax,8)
movl -0x1c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x1c(%rbp)
jmp 0x13dea
movq -0x10(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x28(%rbp)
cmpq $0x0, -0x28(%rbp)
je 0x13e5b
movq -0x28(%rbp), %rax
movq 0x8(%rax), %rax
movq 0x28(%rax), %rcx
movq -0x28(%rbp), %rax
movslq (%rax), %rax
movq %rcx, -0x830(%rbp,%rax,8)
movq -0x28(%rbp), %rax
movq 0x10(%rax), %rax
movq %rax, -0x28(%rbp)
jmp 0x13e2b
movq -0x18(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x28(%rbp)
cmpq $0x0, -0x28(%rbp)
je 0x13e96
movq -0x28(%rbp), %rax
movq 0x8(%rax), %rax
movq 0x28(%rax), %rcx
movq -0x28(%rbp), %rax
movslq (%rax), %rax
movq %rcx, -0x1030(%rbp,%rax,8)
movq -0x28(%rbp), %rax
movq 0x10(%rax), %rax
movq %rax, -0x28(%rbp)
jmp 0x13e66
movl $0x0, -0x1c(%rbp)
movl -0x1c(%rbp), %eax
cmpl 0xc3fe(%rip), %eax      # 0x202a4
je 0x13ed7
movslq -0x1c(%rbp), %rax
movq -0x830(%rbp,%rax,8), %rax
movslq -0x1c(%rbp), %rcx
cmpq -0x1030(%rbp,%rcx,8), %rax
je 0x13eca
movw $0x0, -0x2(%rbp)
jmp 0x13edd
jmp 0x13ecc
movl -0x1c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x1c(%rbp)
jmp 0x13e9d
movw $0xffff, -0x2(%rbp)     # imm = 0xFFFF
movw -0x2(%rbp), %ax
addq $0xfb0, %rsp            # imm = 0xFB0
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq 0x20(%rax), %rax
cmpq 0xf03d(%rip), %rax      # 0x22f48
je 0x13f4b
movq 0xf034(%rip), %rcx      # 0x22f48
movq -0x8(%rbp), %rax
movq %rcx, 0x20(%rax)
movq -0x8(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x10(%rbp)
cmpq $0x0, -0x10(%rbp)
je 0x13f49
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rdi
callq 0x13ef0
movq -0x10(%rbp), %rax
movq 0x10(%rax), %rax
movq %rax, -0x10(%rbp)
jmp 0x13f27
jmp 0x13f4b
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/theovosse[P]llgen/regexp.c
// Function: RemoveUnreachableStates
static void RemoveUnreachableStates(RegExp dfa) {
	RegExp state, auxState, prev = dfa;
	Transition tr, auxTr;

	/* Never remove the first state */
	for (state = dfa->next; state != NULL; state = auxState) {
		auxState = state->next;
		if (state->lastVisit == lastVisit) {
			prev->next = state;
			prev = state;
		} else {
			for (tr = state->transitions; tr != NULL; tr = auxTr) {
				auxTr = tr->next;
				FreeTransition(tr);
			}
			FreeRegExp(state);
		}
	}
	prev->next = NULL;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x20(%rbp)
movq -0x8(%rbp), %rax
movq 0x18(%rax), %rax
movq %rax, -0x10(%rbp)
cmpq $0x0, -0x10(%rbp)
je 0x14000
movq -0x10(%rbp), %rax
movq 0x18(%rax), %rax
movq %rax, -0x18(%rbp)
movq -0x10(%rbp), %rax
movq 0x20(%rax), %rax
cmpq 0xefa6(%rip), %rax      # 0x22f48
jne 0x13fba
movq -0x10(%rbp), %rcx
movq -0x20(%rbp), %rax
movq %rcx, 0x18(%rax)
movq -0x10(%rbp), %rax
movq %rax, -0x20(%rbp)
jmp 0x13ff4
movq -0x10(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x28(%rbp)
cmpq $0x0, -0x28(%rbp)
je 0x13feb
movq -0x28(%rbp), %rax
movq 0x10(%rax), %rax
movq %rax, -0x30(%rbp)
movq -0x28(%rbp), %rdi
callq 0x13360
movq -0x30(%rbp), %rax
movq %rax, -0x28(%rbp)
jmp 0x13fc5
movq -0x10(%rbp), %rdi
callq 0x133b0
jmp 0x13ff6
movq -0x18(%rbp), %rax
movq %rax, -0x10(%rbp)
jmp 0x13f80
movq -0x20(%rbp), %rax
movq $0x0, 0x18(%rax)
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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 %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq 0x10(%rax), %rdi
callq 0x15be0
movq %rax, -0x20(%rbp)
movq -0x20(%rbp), %rcx
movq -0x8(%rbp), %rax
movq %rcx, 0x28(%rax)
movq -0x8(%rbp), %rax
movq 0x18(%rax), %rax
movq %rax, -0x10(%rbp)
cmpq $0x0, -0x10(%rbp)
je 0x15b37
movq -0x10(%rbp), %rax
movq 0x10(%rax), %rdi
callq 0x15c60
movq %rax, -0x28(%rbp)
movq -0x28(%rbp), %rcx
movq -0x10(%rbp), %rax
movq %rcx, 0x28(%rax)
movq -0x10(%rbp), %rax
movq 0x18(%rax), %rax
movq %rax, -0x10(%rbp)
jmp 0x15b05
movq -0x8(%rbp), %rax
movq %rax, -0x10(%rbp)
cmpq $0x0, -0x10(%rbp)
je 0x15bd3
movq -0x10(%rbp), %rax
movq 0x28(%rax), %rax
movq %rax, -0x28(%rbp)
movl $0x0, -0x2c(%rbp)
movl -0x2c(%rbp), %eax
cmpl 0xa73e(%rip), %eax      # 0x202a4
je 0x15b84
movq -0x28(%rbp), %rax
movslq -0x2c(%rbp), %rcx
movq $0x0, 0x10(%rax,%rcx,8)
movl -0x2c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x2c(%rbp)
jmp 0x15b5d
movq -0x10(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x18(%rbp)
cmpq $0x0, -0x18(%rbp)
je 0x15bc0
movq -0x18(%rbp), %rax
movq 0x8(%rax), %rax
movq 0x28(%rax), %rdx
movq -0x28(%rbp), %rax
movq -0x18(%rbp), %rcx
movslq (%rcx), %rcx
movq %rdx, 0x10(%rax,%rcx,8)
movq -0x18(%rbp), %rax
movq 0x10(%rax), %rax
movq %rax, -0x18(%rbp)
jmp 0x15b8f
jmp 0x15bc2
movq -0x10(%rbp), %rax
movq 0x18(%rax), %rax
movq %rax, -0x10(%rbp)
jmp 0x15b3f
movq -0x20(%rbp), %rax
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax)