LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O0/Tarsnap[P]kivaloo/perftests/kvldsclean/main.c
// Function: batch_set
static int
batch_set(struct wire_requestqueue * Q, size_t start, size_t N)
{
	struct many_state C;
	char buf[9];
	size_t x;
	struct kvldskey * key;

	/* Not failed or done yet.  No requests in progress yet. */
	C.failed = C.done = 0;
	C.Nip = 0;

	/* Set values. */
	for (x = start; x < start + N; x++) {
		/* Set "$x" = "$x". */
		sprintf(buf, "%08zu", x);
		if ((key = kvldskey_create((uint8_t *)buf, 8)) == NULL)
			goto err0;
		if (proto_kvlds_request_set(Q, key, key, callback_done, &C)) {
			warnp("Failed to send SET request");
			goto err1;
		}
		C.Nip += 1;
		kvldskey_free(key);
	}

	/* Spin until the requests are done. */
	if (events_spin(&C.done) || C.failed) {
		warnp("SET request failed");
		return (-1);
	}

	/* Success! */
	return (0);

err1:
	kvldskey_free(key);
err0:
	/* Failure! */
	return (-1);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movl $0x0, -0x24(%rbp)
movl $0x0, -0x28(%rbp)
movq $0x0, -0x30(%rbp)
movq -0x18(%rbp), %rax
movq %rax, -0x48(%rbp)
movq -0x48(%rbp), %rax
movq -0x18(%rbp), %rcx
addq -0x20(%rbp), %rcx
cmpq %rcx, %rax
jae 0x2a8d
leaq -0x39(%rbp), %rdi
movq -0x48(%rbp), %rdx
leaq 0xc780(%rip), %rsi      # 0xf166
movb $0x0, %al
callq 0x22e0
leaq -0x39(%rbp), %rdi
movl $0x8, %esi
callq 0x6f90
movq %rax, -0x50(%rbp)
cmpq $0x0, %rax
jne 0x2a0a
jmp 0x2af7
movq -0x10(%rbp), %rdi
movq -0x50(%rbp), %rsi
movq -0x50(%rbp), %rdx
leaq 0x273(%rip), %rcx       # 0x2c90
leaq -0x30(%rbp), %r8
callq 0x73e0
cmpl $0x0, %eax
je 0x2a67
jmp 0x2a2d
callq 0x20a0
cmpl $0x0, (%rax)
je 0x2a52
leaq 0xc72e(%rip), %rdi      # 0xf16c
movb $0x0, %al
callq 0x6b00
callq 0x20a0
movl $0x0, (%rax)
jmp 0x2a60
leaq 0xc713(%rip), %rdi      # 0xf16c
movb $0x0, %al
callq 0x6d50
jmp 0x2a62
jmp 0x2aee
movq -0x30(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x30(%rbp)
movq -0x50(%rbp), %rdi
callq 0x2040
movq -0x48(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x48(%rbp)
jmp 0x29c2
leaq -0x30(%rbp), %rdi
addq $0xc, %rdi
callq 0x2f90
cmpl $0x0, %eax
jne 0x2aa5
cmpl $0x0, -0x28(%rbp)
je 0x2ae5
jmp 0x2aa7
callq 0x20a0
cmpl $0x0, (%rax)
je 0x2acc
leaq 0xc6cf(%rip), %rdi      # 0xf187
movb $0x0, %al
callq 0x6b00
callq 0x20a0
movl $0x0, (%rax)
jmp 0x2ada
leaq 0xc6b4(%rip), %rdi      # 0xf187
movb $0x0, %al
callq 0x6d50
jmp 0x2adc
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
jmp 0x2afe
movl $0x0, -0x4(%rbp)
jmp 0x2afe
movq -0x50(%rbp), %rdi
callq 0x2040
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
movl -0x4(%rbp), %eax
addq $0x50, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/Tarsnap[P]kivaloo/perftests/kvldsclean/main.c
// Function: batch_delete
static int
batch_delete(struct wire_requestqueue * Q, size_t start, size_t N)
{
	struct many_state C;
	char buf[9];
	size_t x;
	struct kvldskey * key;

	/* Not failed or done yet.  No requests in progress yet. */
	C.failed = C.done = 0;
	C.Nip = 0;

	/* Set values. */
	for (x = start; x < start + N; x++) {
		/* Delete "$x". */
		sprintf(buf, "%08zu", x);
		if ((key = kvldskey_create((uint8_t *)buf, 8)) == NULL)
			goto err0;
		if (proto_kvlds_request_delete(Q, key, callback_done, &C)) {
			warnp("Failed to send DELETE request");
			goto err1;
		}
		C.Nip += 1;
		kvldskey_free(key);
	}

	/* Spin until the requests are done. */
	if (events_spin(&C.done) || C.failed) {
		warnp("DELETE request failed");
		return (-1);
	}

	/* Success! */
	return (0);

err1:
	kvldskey_free(key);
err0:
	/* Failure! */
	return (-1);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movl $0x0, -0x24(%rbp)
movl $0x0, -0x28(%rbp)
movq $0x0, -0x30(%rbp)
movq -0x18(%rbp), %rax
movq %rax, -0x48(%rbp)
movq -0x48(%rbp), %rax
movq -0x18(%rbp), %rcx
addq -0x20(%rbp), %rcx
cmpq %rcx, %rax
jae 0x2c09
leaq -0x39(%rbp), %rdi
movq -0x48(%rbp), %rdx
leaq 0xc600(%rip), %rsi      # 0xf166
movb $0x0, %al
callq 0x22e0
leaq -0x39(%rbp), %rdi
movl $0x8, %esi
callq 0x6f90
movq %rax, -0x50(%rbp)
cmpq $0x0, %rax
jne 0x2b8a
jmp 0x2c73
movq -0x10(%rbp), %rdi
movq -0x50(%rbp), %rsi
leaq 0xf7(%rip), %rdx        # 0x2c90
leaq -0x30(%rbp), %rcx
callq 0x7cc0
cmpl $0x0, %eax
je 0x2be3
jmp 0x2ba9
callq 0x20a0
cmpl $0x0, (%rax)
je 0x2bce
leaq 0xc5e0(%rip), %rdi      # 0xf19a
movb $0x0, %al
callq 0x6b00
callq 0x20a0
movl $0x0, (%rax)
jmp 0x2bdc
leaq 0xc5c5(%rip), %rdi      # 0xf19a
movb $0x0, %al
callq 0x6d50
jmp 0x2bde
jmp 0x2c6a
movq -0x30(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x30(%rbp)
movq -0x50(%rbp), %rdi
callq 0x2040
movq -0x48(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x48(%rbp)
jmp 0x2b42
leaq -0x30(%rbp), %rdi
addq $0xc, %rdi
callq 0x2f90
cmpl $0x0, %eax
jne 0x2c21
cmpl $0x0, -0x28(%rbp)
je 0x2c61
jmp 0x2c23
callq 0x20a0
cmpl $0x0, (%rax)
je 0x2c48
leaq 0xc584(%rip), %rdi      # 0xf1b8
movb $0x0, %al
callq 0x6b00
callq 0x20a0
movl $0x0, (%rax)
jmp 0x2c56
leaq 0xc569(%rip), %rdi      # 0xf1b8
movb $0x0, %al
callq 0x6d50
jmp 0x2c58
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
jmp 0x2c7a
movl $0x0, -0x4(%rbp)
jmp 0x2c7a
movq -0x50(%rbp), %rdi
callq 0x2040
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
movl -0x4(%rbp), %eax
addq $0x50, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/Tarsnap[P]kivaloo/perftests/kvldsclean/main.c
// Function: callback_done
static int
callback_done(void * cookie, int failed)
{
	struct many_state * C = cookie;

	/* Did we fail? */
	if (failed)
		C->failed = 1;

	C->Nip -= 1;

	/* Are we done? */
	if (C->Nip == 0)
		C->done = 1;

	/* Success! */
	return (0);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x18(%rbp)
cmpl $0x0, -0xc(%rbp)
je 0x2cb4
movq -0x18(%rbp), %rax
movl $0x1, 0x8(%rax)
movq -0x18(%rbp), %rax
movq (%rax), %rcx
subq $0x1, %rcx
movq %rcx, (%rax)
movq -0x18(%rbp), %rax
cmpq $0x0, (%rax)
jne 0x2cd7
movq -0x18(%rbp), %rax
movl $0x1, 0xc(%rax)
xorl %eax, %eax
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/ohkimur[P]the-c-programming-language-2nd-edition-solutions/chapter_1/exercise_1_11/word_count_test.c
// Function: main
int main(void)
{
  char nl;
  char nw;
  char nc;

  int state;

  nl = nw = nc = 0;
  state = OUT;

  char c;
  while ((c = getchar()) != EOF)
  {
    ++nc;

    if (c == '\n')
    {
      ++nl;
    }

    if (c == ' ' || c == '\n' || c == '\t')
    {
      state = OUT;
    }
    else if (state == OUT)
    {
      state = IN;
      ++nw;
    }
  }

  printf("lines: %d\nwords: %d\ncharacters: %d\n", nl, nw, nc);

  return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movl $0x0, -0x4(%rbp)
movb $0x0, -0x7(%rbp)
movb $0x0, -0x6(%rbp)
movb $0x0, -0x5(%rbp)
movl $0x0, -0xc(%rbp)
callq 0x1040
movb %al, -0xd(%rbp)
movsbl %al, %eax
cmpl $-0x1, %eax
je 0x11d8
movb -0x7(%rbp), %al
addb $0x1, %al
movb %al, -0x7(%rbp)
movsbl -0xd(%rbp), %eax
cmpl $0xa, %eax
jne 0x119b
movb -0x5(%rbp), %al
addb $0x1, %al
movb %al, -0x5(%rbp)
movsbl -0xd(%rbp), %eax
cmpl $0x20, %eax
je 0x11b6
movsbl -0xd(%rbp), %eax
cmpl $0xa, %eax
je 0x11b6
movsbl -0xd(%rbp), %eax
cmpl $0x9, %eax
jne 0x11bf
movl $0x0, -0xc(%rbp)
jmp 0x11d6
cmpl $0x0, -0xc(%rbp)
jne 0x11d4
movl $0x1, -0xc(%rbp)
movb -0x6(%rbp), %al
addb $0x1, %al
movb %al, -0x6(%rbp)
jmp 0x11d6
jmp 0x1172
movsbl -0x5(%rbp), %esi
movsbl -0x6(%rbp), %edx
movsbl -0x7(%rbp), %ecx
leaq 0xe19(%rip), %rdi       # 0x2004
movb $0x0, %al
callq 0x1030
xorl %eax, %eax
addq $0x10, %rsp
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O0/theovosse[P]llgen/llgen.c
// Function: nrParameters
int nrParameters(Node argList) {
	int level = 0;
	int nrParameters = argList == NULL? 0: 1;

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

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movl $0x0, -0xc(%rbp)
movq -0x8(%rbp), %rdx
movl $0x1, %eax
xorl %ecx, %ecx
cmpq $0x0, %rdx
cmovel %ecx, %eax
movl %eax, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x18(%rbp)
cmpq $0x0, -0x18(%rbp)
je 0x3509
movq -0x18(%rbp), %rax
movq 0x18(%rax), %rax
movq %rax, -0x20(%rbp)
movq -0x20(%rbp), %rdi
leaq 0x18221(%rip), %rsi     # 0x1b663
callq 0x3220
cmpl $0x0, %eax
jne 0x3460
cmpl $0x0, -0xc(%rbp)
jne 0x3460
movl -0x10(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x10(%rbp)
jmp 0x34f6
movq -0x20(%rbp), %rdi
leaq 0x18268(%rip), %rsi     # 0x1b6d3
callq 0x3220
cmpl $0x0, %eax
je 0x349f
movq -0x20(%rbp), %rdi
leaq 0x15de1(%rip), %rsi     # 0x19261
callq 0x3220
cmpl $0x0, %eax
je 0x349f
movq -0x20(%rbp), %rdi
leaq 0x182c0(%rip), %rsi     # 0x1b755
callq 0x3220
cmpl $0x0, %eax
jne 0x34aa
movl -0xc(%rbp), %eax
addl $0x1, %eax
movl %eax, -0xc(%rbp)
jmp 0x34f4
movq -0x20(%rbp), %rdi
leaq 0x15d8e(%rip), %rsi     # 0x19243
callq 0x3220
cmpl $0x0, %eax
je 0x34e9
movq -0x20(%rbp), %rdi
leaq 0x17b34(%rip), %rsi     # 0x1affe
callq 0x3220
cmpl $0x0, %eax
je 0x34e9
movq -0x20(%rbp), %rdi
leaq 0x17edd(%rip), %rsi     # 0x1b3bc
callq 0x3220
cmpl $0x0, %eax
jne 0x34f2
movl -0xc(%rbp), %eax
addl $-0x1, %eax
movl %eax, -0xc(%rbp)
jmp 0x34f4
jmp 0x34f6
jmp 0x34f8
movq -0x18(%rbp), %rax
movq 0x28(%rax), %rax
movq %rax, -0x18(%rbp)
jmp 0x3420
movl -0x10(%rbp), %eax
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/theovosse[P]llgen/llgen.c
// Function: MakeRuleResult
RuleResult MakeRuleResult(Name returnVariable, Name returnType, Name initialValue) {
	RuleResult ruleResult = (RuleResult) mmalloc(sizeof(struct RuleResult));

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

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movl $0x18, %edi
callq 0x11110
movq %rax, -0x20(%rbp)
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)
movq -0x20(%rbp), %rax
addq $0x20, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/theovosse[P]llgen/llgen.c
// Function: MakeName
Name MakeName(char *str, int index, NameType nameType, short int lineNr) {
	Name name = (Name) mmalloc(sizeof(struct Name));

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

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movw %cx, %ax
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movl %edx, -0x10(%rbp)
movw %ax, -0x12(%rbp)
movl $0x68, %edi
callq 0x11110
movq %rax, -0x20(%rbp)
movq -0x8(%rbp), %rdi
callq 0x3320
movq %rax, %rcx
movq -0x20(%rbp), %rax
movq %rcx, (%rax)
movslq -0xc(%rbp), %rcx
movq -0x20(%rbp), %rax
movq %rcx, 0x28(%rax)
movswl -0x12(%rbp), %ecx
movq -0x20(%rbp), %rax
movl %ecx, 0x20(%rax)
movq -0x20(%rbp), %rax
movw $0x0, 0x30(%rax)
movq -0x20(%rbp), %rax
movq $0x0, 0x8(%rax)
movl -0x10(%rbp), %ecx
movq -0x20(%rbp), %rax
movl %ecx, 0x38(%rax)
movq -0x20(%rbp), %rax
movq $0x0, 0x18(%rax)
movq -0x20(%rbp), %rax
movq $0x0, 0x10(%rax)
movq -0x20(%rbp), %rax
movq $0x0, 0x40(%rax)
movq -0x20(%rbp), %rax
movq $0x0, 0x50(%rax)
movq -0x20(%rbp), %rax
movq $0x0, 0x58(%rax)
movq -0x20(%rbp), %rax
movw $0x0, 0x32(%rax)
movq -0x20(%rbp), %rax
movq $0x0, 0x60(%rax)
movq -0x20(%rbp), %rax
movl $0x0, 0x48(%rax)
movq -0x20(%rbp), %rax
movw $0x0, 0x34(%rax)
movq -0x20(%rbp), %rax
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/theovosse[P]llgen/llgen.c
// Function: InsertSymbol
Name InsertSymbol(char *str, NodeList rules, Boolean lhs, NameType nameType) {
	Name name = GetInfo(FindNode(idTree, str, (TreeCmp) NameCmpStr));

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

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movw %dx, %ax
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movw %ax, -0x12(%rbp)
movl %ecx, -0x18(%rbp)
movq 0x1d6cf(%rip), %rdi     # 0x20d50
movq -0x8(%rbp), %rsi
leaq 0xa4(%rip), %rdx        # 0x3730
callq 0x10560
movq %rax, %rdi
callq 0x103d0
movq %rax, -0x20(%rbp)
cmpq $0x0, -0x20(%rbp)
jne 0x36e0
movq -0x8(%rbp), %rdi
movl -0x18(%rbp), %edx
leaq 0x1cb32(%rip), %rax     # 0x201e4
movl (%rax), %eax
movl $0xffffffff, %esi       # imm = 0xFFFFFFFF
movswl %ax, %ecx
callq 0x3570
movq %rax, -0x20(%rbp)
movq -0x20(%rbp), %rsi
movq -0x20(%rbp), %rdx
leaq 0x1d67c(%rip), %rdi     # 0x20d50
leaq 0x85(%rip), %rcx        # 0x3760
callq 0xfc60
cmpw $0x0, -0x12(%rbp)
je 0x371e
movq -0x20(%rbp), %rax
cmpq $0x0, 0x18(%rax)
jne 0x370a
movq -0x20(%rbp), %rax
cmpl $0x4, 0x38(%rax)
je 0x370a
movq -0x10(%rbp), %rcx
movq -0x20(%rbp), %rax
movq %rcx, 0x18(%rax)
jmp 0x371c
movq -0x8(%rbp), %rsi
leaq 0x15a7f(%rip), %rdi     # 0x19194
movb $0x0, %al
callq 0x37d0
jmp 0x371e
movq -0x20(%rbp), %rax
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/theovosse[P]llgen/llgen.c
// Function: yyerror
void yyerror(char *format, ...) { /* Called by yyparse on error */
	va_list args;

	errorOccurred = true;
	(void) fprintf(stderr, "%s:%d: ", inputFileName, lineNumber);
	va_start(args, format);
	vfprintf(stderr, format, args);
	fprintf(stderr, "\n");
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0xe0, %rsp
testb %al, %al
je 0x3805
movaps %xmm0, -0xa0(%rbp)
movaps %xmm1, -0x90(%rbp)
movaps %xmm2, -0x80(%rbp)
movaps %xmm3, -0x70(%rbp)
movaps %xmm4, -0x60(%rbp)
movaps %xmm5, -0x50(%rbp)
movaps %xmm6, -0x40(%rbp)
movaps %xmm7, -0x30(%rbp)
movq %r9, -0xa8(%rbp)
movq %r8, -0xb0(%rbp)
movq %rcx, -0xb8(%rbp)
movq %rdx, -0xc0(%rbp)
movq %rsi, -0xc8(%rbp)
movq %rdi, -0x8(%rbp)
movw $0xffff, 0x1d535(%rip)  # imm = 0xFFFF
movq 0x1c7bc(%rip), %rax     # 0x1fff8
movq %rax, -0xe0(%rbp)
movq (%rax), %rdi
movq 0x1c92b(%rip), %rdx     # 0x20178
leaq 0x1c990(%rip), %rax     # 0x201e4
movl (%rax), %ecx
leaq 0x15abb(%rip), %rsi     # 0x19318
xorl %eax, %eax
movb %al, -0xd1(%rbp)
callq 0x3140
movq -0xe0(%rbp), %rax
leaq -0xd0(%rbp), %rcx
movq %rcx, -0x10(%rbp)
leaq 0x10(%rbp), %rcx
movq %rcx, -0x18(%rbp)
movl $0x30, -0x1c(%rbp)
movl $0x8, -0x20(%rbp)
movq (%rax), %rdi
movq -0x8(%rbp), %rsi
leaq -0x20(%rbp), %rdx
callq 0x31b0
movq -0xe0(%rbp), %rcx
movb -0xd1(%rbp), %al
movq (%rcx), %rdi
leaq 0x17811(%rip), %rsi     # 0x1b0ca
callq 0x3140
addq $0xe0, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/theovosse[P]llgen/llgen.c
// Function: InsertString
Name InsertString(char *str) {
	Name name = GetInfo(FindNode(idTree, str, (TreeCmp) NameCmpStr));

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

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq 0x1d46d(%rip), %rdi     # 0x20d50
movq -0x8(%rbp), %rsi
leaq -0x1be(%rip), %rdx      # 0x3730
callq 0x10560
movq %rax, %rdi
callq 0x103d0
movq %rax, -0x10(%rbp)
cmpq $0x0, -0x10(%rbp)
jne 0x394e
movq -0x8(%rbp), %rdi
movl 0x1d448(%rip), %esi     # 0x20d58
addl $0x1, %esi
movl %esi, 0x1d43f(%rip)     # 0x20d58
leaq 0x1c8c4(%rip), %rax     # 0x201e4
movl (%rax), %eax
movl $0x1, %edx
movswl %ax, %ecx
callq 0x3570
movq %rax, -0x10(%rbp)
movq -0x10(%rbp), %rsi
movq -0x10(%rbp), %rdx
leaq 0x1d40e(%rip), %rdi     # 0x20d50
leaq -0x1e9(%rip), %rcx      # 0x3760
callq 0xfc60
movq -0x10(%rbp), %rax
addq $0x10, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/theovosse[P]llgen/llgen.c
// Function: AssignString
void AssignString(Name name, Name str) {
	if (name->rules == NULL && name->nameType == identifier) {
		name->nameType = token;
		name->index = str->index;
	} else {
		yyerror("token already defined as lhs %s", name->name);
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rax
cmpq $0x0, 0x18(%rax)
jne 0x39a2
movq -0x8(%rbp), %rax
cmpl $0x0, 0x38(%rax)
jne 0x39a2
movq -0x8(%rbp), %rax
movl $0x4, 0x38(%rax)
movq -0x10(%rbp), %rax
movq 0x28(%rax), %rcx
movq -0x8(%rbp), %rax
movq %rcx, 0x28(%rax)
jmp 0x39b7
movq -0x8(%rbp), %rax
movq (%rax), %rsi
leaq 0x157f8(%rip), %rdi     # 0x191a8
movb $0x0, %al
callq 0x37d0
addq $0x10, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/theovosse[P]llgen/llgen.c
// Function: KeywordString
void KeywordString(Name name, Name str, Name ident) {
    if (name->keywords != NULL || name->functions != NULL) {
		yyerror("no keyword hierarchie allowed: %s", name->name);
	} else if (name->rules == NULL && name->nameType == identifier && (ident->nameType == identifier || ident->nameType == token)) {
		name->nameType = token;
		if (str == NULL) {
			name->index = ++nodeNumber;
		} else {
			name->index = str->index;
			str->index = 0;
		}
		ident->nameType = token;
		InsertNodeSingle(&ident->keywords, str, name, (TreeCmp) NameCmp);
		AddProperty("keywords");
	} else if (ident->nameType != identifier && ident->nameType != token) {
		yyerror("identifier already defined as lhs %s", ident->name);
	} else {
		yyerror("token already defined as lhs %s", name->name);
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x8(%rbp), %rax
cmpq $0x0, 0x58(%rax)
jne 0x39ea
movq -0x8(%rbp), %rax
cmpq $0x0, 0x60(%rax)
je 0x3a04
movq -0x8(%rbp), %rax
movq (%rax), %rsi
leaq 0x157d0(%rip), %rdi     # 0x191c8
movb $0x0, %al
callq 0x37d0
jmp 0x3af8
movq -0x8(%rbp), %rax
cmpq $0x0, 0x18(%rax)
jne 0x3ab4
movq -0x8(%rbp), %rax
cmpl $0x0, 0x38(%rax)
jne 0x3ab4
movq -0x18(%rbp), %rax
cmpl $0x0, 0x38(%rax)
je 0x3a35
movq -0x18(%rbp), %rax
cmpl $0x4, 0x38(%rax)
jne 0x3ab4
movq -0x8(%rbp), %rax
movl $0x4, 0x38(%rax)
cmpq $0x0, -0x10(%rbp)
jne 0x3a63
movl 0x1d30b(%rip), %eax     # 0x20d58
addl $0x1, %eax
movl %eax, 0x1d302(%rip)     # 0x20d58
movslq %eax, %rcx
movq -0x8(%rbp), %rax
movq %rcx, 0x28(%rax)
jmp 0x3a7f
movq -0x10(%rbp), %rax
movq 0x28(%rax), %rcx
movq -0x8(%rbp), %rax
movq %rcx, 0x28(%rax)
movq -0x10(%rbp), %rax
movq $0x0, 0x28(%rax)
movq -0x18(%rbp), %rax
movl $0x4, 0x38(%rax)
movq -0x18(%rbp), %rdi
addq $0x58, %rdi
movq -0x10(%rbp), %rsi
movq -0x8(%rbp), %rdx
leaq -0x341(%rip), %rcx      # 0x3760
callq 0xfc60
leaq 0x1573d(%rip), %rdi     # 0x191ea
callq 0x3360
jmp 0x3af6
movq -0x18(%rbp), %rax
cmpl $0x0, 0x38(%rax)
je 0x3adf
movq -0x18(%rbp), %rax
cmpl $0x4, 0x38(%rax)
je 0x3adf
movq -0x18(%rbp), %rax
movq (%rax), %rsi
leaq 0x1571d(%rip), %rdi     # 0x191f3
movb $0x0, %al
callq 0x37d0
jmp 0x3af4
movq -0x8(%rbp), %rax
movq (%rax), %rsi
leaq 0x156bb(%rip), %rdi     # 0x191a8
movb $0x0, %al
callq 0x37d0
jmp 0x3af6
jmp 0x3af8
addq $0x20, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/theovosse[P]llgen/llgen.c
// Function: Function
void Function(Name name, Name fun, Name ident) {
	if (name->keywords != NULL || name->functions != NULL) {
		yyerror("no function hierarchie allowed: %s", name->name);
	} else if (name->rules == NULL && name->nameType == identifier && (ident->nameType == identifier || ident->nameType == token)) {
		name->nameType = token;
		name->index = ++nodeNumber;
		fun->index = 0;
		fun->nameType = function;
		ident->nameType = token;
		InsertNodeSingle(&ident->functions, fun, name, (TreeCmp) NameCmp);
		AddProperty("functions");
	} else if (ident->nameType != identifier && ident->nameType != token) {
		yyerror("identifier already defined as lhs %s", ident->name);
	} else {
		yyerror("token already defined as lhs %s", name->name);
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x8(%rbp), %rax
cmpq $0x0, 0x58(%rax)
jne 0x3b2a
movq -0x8(%rbp), %rax
cmpq $0x0, 0x60(%rax)
je 0x3b44
movq -0x8(%rbp), %rax
movq (%rax), %rsi
leaq 0x156e0(%rip), %rdi     # 0x19218
movb $0x0, %al
callq 0x37d0
jmp 0x3c2a
movq -0x8(%rbp), %rax
cmpq $0x0, 0x18(%rax)
jne 0x3be6
movq -0x8(%rbp), %rax
cmpl $0x0, 0x38(%rax)
jne 0x3be6
movq -0x18(%rbp), %rax
cmpl $0x0, 0x38(%rax)
je 0x3b75
movq -0x18(%rbp), %rax
cmpl $0x4, 0x38(%rax)
jne 0x3be6
movq -0x8(%rbp), %rax
movl $0x4, 0x38(%rax)
movl 0x1d1d2(%rip), %eax     # 0x20d58
addl $0x1, %eax
movl %eax, 0x1d1c9(%rip)     # 0x20d58
movslq %eax, %rcx
movq -0x8(%rbp), %rax
movq %rcx, 0x28(%rax)
movq -0x10(%rbp), %rax
movq $0x0, 0x28(%rax)
movq -0x10(%rbp), %rax
movl $0x5, 0x38(%rax)
movq -0x18(%rbp), %rax
movl $0x4, 0x38(%rax)
movq -0x18(%rbp), %rdi
addq $0x60, %rdi
movq -0x10(%rbp), %rsi
movq -0x8(%rbp), %rdx
leaq -0x473(%rip), %rcx      # 0x3760
callq 0xfc60
leaq 0x15949(%rip), %rdi     # 0x19528
callq 0x3360
jmp 0x3c28
movq -0x18(%rbp), %rax
cmpl $0x0, 0x38(%rax)
je 0x3c11
movq -0x18(%rbp), %rax
cmpl $0x4, 0x38(%rax)
je 0x3c11
movq -0x18(%rbp), %rax
movq (%rax), %rsi
leaq 0x155eb(%rip), %rdi     # 0x191f3
movb $0x0, %al
callq 0x37d0
jmp 0x3c26
movq -0x8(%rbp), %rax
movq (%rax), %rsi
leaq 0x15589(%rip), %rdi     # 0x191a8
movb $0x0, %al
callq 0x37d0
jmp 0x3c28
jmp 0x3c2a
addq $0x20, %rsp
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O0/theovosse[P]llgen/llgen.c
// Function: MakeNode
Node MakeNode(short int lineNr, NodeType nodeType, void *element, Node next) {
	Node node;

	if (oldNodes == NULL) {
		node = (Node) mmalloc(sizeof(struct Node));
	} else {
		node = oldNodes;
		oldNodes = oldNodes->next;
	}
	node->nodeType = nodeType;
	node->arglist = NULL;
	switch (nodeType) {
		case single: node->element.name = element; break;
		case option: node->element.sub = element; break;
		case sequence: node->element.sub = element; break;
		case chain: node->element.sub = element; break;
		case alternative: node->element.alternatives = element; break;
		case breakToken: node->element.name = element; break;
		case errorMessage: node->element.sub = element; break;
		// default: fprintf(stderr, "MakeNode: unknown nodetype %d\n", nodeType);
	}
	node->lineNr = lineNr;
	node->next = next;
	node->preferShift = false;
	node->empty = false;
	node->assignTo = NULL;
	return (node);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movw %di, %ax
movw %ax, -0x2(%rbp)
movl %esi, -0x8(%rbp)
movq %rdx, -0x10(%rbp)
movq %rcx, -0x18(%rbp)
cmpq $0x0, 0x1d10e(%rip)     # 0x20d60
jne 0x3c64
movl $0x30, %edi
callq 0x11110
movq %rax, -0x20(%rbp)
jmp 0x3c81
movq 0x1d0f5(%rip), %rax     # 0x20d60
movq %rax, -0x20(%rbp)
movq 0x1d0ea(%rip), %rax     # 0x20d60
movq 0x28(%rax), %rax
movq %rax, 0x1d0df(%rip)     # 0x20d60
movl -0x8(%rbp), %ecx
movq -0x20(%rbp), %rax
movl %ecx, 0x4(%rax)
movq -0x20(%rbp), %rax
movq $0x0, 0x8(%rax)
movl -0x8(%rbp), %eax
movq %rax, -0x28(%rbp)
subq $0x6, %rax
ja 0x3d18
movq -0x28(%rbp), %rax
leaq 0x15355(%rip), %rcx     # 0x19004
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
movq -0x10(%rbp), %rcx
movq -0x20(%rbp), %rax
movq %rcx, 0x18(%rax)
jmp 0x3d18
movq -0x10(%rbp), %rcx
movq -0x20(%rbp), %rax
movq %rcx, 0x18(%rax)
jmp 0x3d18
movq -0x10(%rbp), %rcx
movq -0x20(%rbp), %rax
movq %rcx, 0x18(%rax)
jmp 0x3d18
movq -0x10(%rbp), %rcx
movq -0x20(%rbp), %rax
movq %rcx, 0x18(%rax)
jmp 0x3d18
movq -0x10(%rbp), %rcx
movq -0x20(%rbp), %rax
movq %rcx, 0x18(%rax)
jmp 0x3d18
movq -0x10(%rbp), %rcx
movq -0x20(%rbp), %rax
movq %rcx, 0x18(%rax)
jmp 0x3d18
movq -0x10(%rbp), %rcx
movq -0x20(%rbp), %rax
movq %rcx, 0x18(%rax)
movw -0x2(%rbp), %cx
movq -0x20(%rbp), %rax
movw %cx, (%rax)
movq -0x18(%rbp), %rcx
movq -0x20(%rbp), %rax
movq %rcx, 0x28(%rax)
movq -0x20(%rbp), %rax
movw $0x0, 0x20(%rax)
movq -0x20(%rbp), %rax
movw $0x0, 0x22(%rax)
movq -0x20(%rbp), %rax
movq $0x0, 0x10(%rax)
movq -0x20(%rbp), %rax
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/theovosse[P]llgen/llgen.c
// Function: MakeNodeList
NodeList MakeNodeList(Node first, NodeList rest) {
	NodeList nodeList = (NodeList) mmalloc(sizeof(struct NodeList));

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

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl $0x18, %edi
callq 0x11110
movq %rax, -0x18(%rbp)
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
movw $0x0, 0x10(%rax)
movq -0x18(%rbp), %rax
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/theovosse[P]llgen/llgen.c
// Function: appendNodeList
NodeList appendNodeList(NodeList list, NodeList app) {
	if (list == NULL) {
		return app;
	} else {
		NodeList ptr = list;
		while (ptr->rest != NULL) {
			ptr = ptr->rest;
		}
		ptr->rest = app;
		return list;
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
cmpq $0x0, -0x10(%rbp)
jne 0x3dcd
movq -0x18(%rbp), %rax
movq %rax, -0x8(%rbp)
jmp 0x3e02
movq -0x10(%rbp), %rax
movq %rax, -0x20(%rbp)
movq -0x20(%rbp), %rax
cmpq $0x0, 0x8(%rax)
je 0x3dee
movq -0x20(%rbp), %rax
movq 0x8(%rax), %rax
movq %rax, -0x20(%rbp)
jmp 0x3dd5
movq -0x18(%rbp), %rcx
movq -0x20(%rbp), %rax
movq %rcx, 0x8(%rax)
movq -0x10(%rbp), %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/theovosse[P]llgen/llgen.c
// Function: containsGrammarSymbol
Boolean containsGrammarSymbol(NodeList list) {
	NodeList ptr = list;

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

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x18(%rbp)
cmpq $0x0, -0x18(%rbp)
je 0x3e53
movq -0x18(%rbp), %rax
movq (%rax), %rdi
callq 0x3e70
cmpw $0x0, %ax
je 0x3e45
movw $0xffff, -0x2(%rbp)     # imm = 0xFFFF
jmp 0x3e59
movq -0x18(%rbp), %rax
movq 0x8(%rax), %rax
movq %rax, -0x18(%rbp)
jmp 0x3e24
movw $0x0, -0x2(%rbp)
movw -0x2(%rbp), %ax
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/theovosse[P]llgen/llgen.c
// Function: nodeContainsGrammarSymbol
static Boolean nodeContainsGrammarSymbol(Node node) {
	while (node != NULL) {
		switch (node->nodeType) {
			case single:
				if (node->element.name->nameType != code && node->element.name->nameType != output) {
					return true;
				}
				break;
			case option:
				if (nodeContainsGrammarSymbol(node->element.sub)) {
					return true;
				}
				break;
			case sequence:
				if (nodeContainsGrammarSymbol(node->element.sub)) {
					return true;
				}
				break;
			case chain:
				if (nodeContainsGrammarSymbol(node->element.sub->element.sub) ||
					  nodeContainsGrammarSymbol(node->element.sub->next->element.sub)) {
					return true;
				}
			case alternative:
				if (containsGrammarSymbol(node->element.alternatives)) {
					return true;
				}
				break;
			case breakToken:
			case errorMessage:
				return true;
		}
		node = node->next;
	}
	return false;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
cmpq $0x0, -0x10(%rbp)
je 0x3f8b
movq -0x10(%rbp), %rax
movl 0x4(%rax), %eax
movq %rax, -0x18(%rbp)
subq $0x6, %rax
ja 0x3f7a
movq -0x18(%rbp), %rax
leaq 0x15179(%rip), %rcx     # 0x19020
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
movq -0x10(%rbp), %rax
movq 0x18(%rax), %rax
cmpl $0x3, 0x38(%rax)
je 0x3ed7
movq -0x10(%rbp), %rax
movq 0x18(%rax), %rax
cmpl $0x2, 0x38(%rax)
je 0x3ed7
movw $0xffff, -0x2(%rbp)     # imm = 0xFFFF
jmp 0x3f91
jmp 0x3f7a
movq -0x10(%rbp), %rax
movq 0x18(%rax), %rdi
callq 0x3e70
cmpw $0x0, %ax
je 0x3efa
movw $0xffff, -0x2(%rbp)     # imm = 0xFFFF
jmp 0x3f91
jmp 0x3f7a
movq -0x10(%rbp), %rax
movq 0x18(%rax), %rdi
callq 0x3e70
cmpw $0x0, %ax
je 0x3f17
movw $0xffff, -0x2(%rbp)     # imm = 0xFFFF
jmp 0x3f91
jmp 0x3f7a
movq -0x10(%rbp), %rax
movq 0x18(%rax), %rax
movq 0x18(%rax), %rdi
callq 0x3e70
cwtl
cmpl $0x0, %eax
jne 0x3f4b
movq -0x10(%rbp), %rax
movq 0x18(%rax), %rax
movq 0x28(%rax), %rax
movq 0x18(%rax), %rdi
callq 0x3e70
cwtl
cmpl $0x0, %eax
je 0x3f53
movw $0xffff, -0x2(%rbp)     # imm = 0xFFFF
jmp 0x3f91
jmp 0x3f55
movq -0x10(%rbp), %rax
movq 0x18(%rax), %rdi
callq 0x3e10
cmpw $0x0, %ax
je 0x3f70
movw $0xffff, -0x2(%rbp)     # imm = 0xFFFF
jmp 0x3f91
jmp 0x3f7a
movw $0xffff, -0x2(%rbp)     # imm = 0xFFFF
jmp 0x3f91
movq -0x10(%rbp), %rax
movq 0x28(%rax), %rax
movq %rax, -0x10(%rbp)
jmp 0x3e7c
movw $0x0, -0x2(%rbp)
movw -0x2(%rbp), %ax
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/theovosse[P]llgen/llgen.c
// Function: AppendNode
Node AppendNode(Node node1, Node node2) {
	Node ret = node1;

	if (node1 == NULL) {
		return (node2);
	}
	while (node1->next != NULL) {
		node1 = node1->next;
	}
	node1->next = node2;
	return (ret);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x20(%rbp)
cmpq $0x0, -0x10(%rbp)
jne 0x3fc5
movq -0x18(%rbp), %rax
movq %rax, -0x8(%rbp)
jmp 0x3ff4
jmp 0x3fc7
movq -0x10(%rbp), %rax
cmpq $0x0, 0x28(%rax)
je 0x3fe0
movq -0x10(%rbp), %rax
movq 0x28(%rax), %rax
movq %rax, -0x10(%rbp)
jmp 0x3fc7
movq -0x18(%rbp), %rcx
movq -0x10(%rbp), %rax
movq %rcx, 0x28(%rax)
movq -0x20(%rbp), %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/theovosse[P]llgen/llgen.c
// Function: doIndent
void doIndent(int level) {
    fputc('\n', outputFile);
	while (level != 0) {
		fputs("	", outputFile);
		level--;
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movl %edi, -0x4(%rbp)
movq 0x1cd26(%rip), %rsi     # 0x20d38
movl $0xa, %edi
callq 0x3120
cmpl $0x0, -0x4(%rbp)
je 0x4040
movq 0x1cd0f(%rip), %rsi     # 0x20d38
leaq 0x1520b(%rip), %rdi     # 0x1923b
callq 0x3100
movl -0x4(%rbp), %eax
addl $-0x1, %eax
movl %eax, -0x4(%rbp)
jmp 0x401c
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/theovosse[P]llgen/llgen.c
// Function: startBlock
void startBlock(int indentLevel) {
    if (bracesOnNewLine) {
        doIndent(indentLevel);
        fputs("{", outputFile);
    } else {
        fputs(" {", outputFile);
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movl %edi, -0x4(%rbp)
cmpw $0x0, 0x1cd05(%rip)     # 0x20d68
je 0x4082
movl -0x4(%rbp), %edi
callq 0x4000
movq 0x1ccc4(%rip), %rsi     # 0x20d38
leaq 0x17658(%rip), %rdi     # 0x1b6d3
callq 0x3100
jmp 0x4095
movq 0x1ccaf(%rip), %rsi     # 0x20d38
leaq 0x17642(%rip), %rdi     # 0x1b6d2
callq 0x3100
addq $0x10, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/theovosse[P]llgen/llgen.c
// Function: HasProperty
static Boolean HasProperty(char *property) {
	if (*property == '!') {
		return (FindNode(properties, property + 1, (TreeCmp) strcmp) == NULL);
	} else {
		return (FindNode(properties, property, (TreeCmp) strcmp) != NULL);
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x10(%rbp)
movq -0x10(%rbp), %rax
movsbl (%rax), %eax
cmpl $0x21, %eax
jne 0x4985
movq 0x1c3e9(%rip), %rdi     # 0x20d48
movq -0x10(%rbp), %rsi
addq $0x1, %rsi
movq 0x1b66a(%rip), %rdx     # 0x1ffd8
callq 0x10560
cmpq $0x0, %rax
sete %al
andb $0x1, %al
movzbl %al, %eax
movw %ax, -0x2(%rbp)
jmp 0x49ac
movq 0x1c3bc(%rip), %rdi     # 0x20d48
movq -0x10(%rbp), %rsi
movq 0x1b641(%rip), %rdx     # 0x1ffd8
callq 0x10560
cmpq $0x0, %rax
setne %al
andb $0x1, %al
movzbl %al, %eax
movw %ax, -0x2(%rbp)
movw -0x2(%rbp), %ax
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/theovosse[P]llgen/llgen.c
// Function: determineBaseName
static void determineBaseName(const char* str) {
    const char* lastSlash = strrchr(str, '/');
    const char* fileName = lastSlash != NULL? lastSlash + 1: str;
    const char* lastDot = strchr(fileName, '.');
    const int baseNameLength = lastDot == NULL? strlen(fileName): lastDot - fileName;

    baseName = mmalloc(baseNameLength + 1);
    strncpy(baseName, fileName, baseNameLength);
    baseName[baseNameLength] = '\0';
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
movl $0x2f, %esi
callq 0x30f0
movq %rax, -0x10(%rbp)
cmpq $0x0, -0x10(%rbp)
je 0x49f3
movq -0x10(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x30(%rbp)
jmp 0x49fb
movq -0x8(%rbp), %rax
movq %rax, -0x30(%rbp)
movq -0x30(%rbp), %rax
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rdi
movl $0x2e, %esi
callq 0x30d0
movq %rax, -0x20(%rbp)
cmpq $0x0, -0x20(%rbp)
jne 0x4a2b
movq -0x18(%rbp), %rdi
callq 0x30c0
movq %rax, -0x38(%rbp)
jmp 0x4a3a
movq -0x20(%rbp), %rax
movq -0x18(%rbp), %rcx
subq %rcx, %rax
movq %rax, -0x38(%rbp)
movq -0x38(%rbp), %rax
movl %eax, -0x24(%rbp)
movl -0x24(%rbp), %edi
addl $0x1, %edi
callq 0x11110
movq %rax, 0x1b735(%rip)     # 0x20188
movq 0x1b72e(%rip), %rdi     # 0x20188
movq -0x18(%rbp), %rsi
movslq -0x24(%rbp), %rdx
callq 0x3060
movq 0x1b71a(%rip), %rax     # 0x20188
movslq -0x24(%rbp), %rcx
movb $0x0, (%rax,%rcx)
addq $0x40, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/theovosse[P]llgen/llgen.c
// Function: HasEnums
static Boolean HasEnums(void) {
	TREE sym;
	Name name;

	for (sym = GetFirstNode(idTree); sym != NULL; sym = GetNextNode(sym)) {
		name = GetKey(sym);
		if (name->nameType == token && name->index > 0) {
			return (true);
		}
	}
	return (false);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq 0x1c2c1(%rip), %rdi     # 0x20d50
callq 0x10330
movq %rax, -0x10(%rbp)
cmpq $0x0, -0x10(%rbp)
je 0x4ada
movq -0x10(%rbp), %rdi
callq 0x10400
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rax
cmpl $0x4, 0x38(%rax)
jne 0x4ac9
movq -0x18(%rbp), %rax
cmpq $0x0, 0x28(%rax)
jle 0x4ac9
movw $0xffff, -0x2(%rbp)     # imm = 0xFFFF
jmp 0x4ae0
jmp 0x4acb
movq -0x10(%rbp), %rdi
callq 0x10430
movq %rax, -0x10(%rbp)
jmp 0x4a98
movw $0x0, -0x2(%rbp)
movw -0x2(%rbp), %ax
addq $0x20, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/theovosse[P]llgen/llgen.c
// Function: ComputeEmptyFirstFollow
static void ComputeEmptyFirstFollow(void) {
	TREE sym;

	/* Compute empty productions */	
	do {
		changes = false;
		for (sym = GetFirstNode(idTree); sym != NULL; sym = GetNextNode(sym)) {
			determineEmpty(GetKey(sym));
		}
	}
	while (changes);
	/* Compute first sets */
	do {
		changes = false;
		for (sym = GetFirstNode(idTree); sym != NULL; sym = GetNextNode(sym)) {
			DetermineFirst(GetKey(sym));
		}
	}
	while (changes);
	/* Compute follow sets */
	(void) InsertElement(&startSymbol->follow, endOfInput);
	do {
		changes = false;
		for (sym = GetFirstNode(idTree); sym != NULL; sym = GetNextNode(sym)) {
			DetermineFollow(GetKey(sym));
		}
	}
	while (changes);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movw $0x0, 0x1c27f(%rip)     # 0x20d80
movq 0x1c248(%rip), %rdi     # 0x20d50
callq 0x10330
movq %rax, -0x8(%rbp)
cmpq $0x0, -0x8(%rbp)
je 0x4b38
movq -0x8(%rbp), %rdi
callq 0x10400
movq %rax, %rdi
callq 0x56a0
movq -0x8(%rbp), %rdi
callq 0x10430
movq %rax, -0x8(%rbp)
jmp 0x4b11
jmp 0x4b3a
cmpw $0x0, 0x1c23e(%rip)     # 0x20d80
jne 0x4af8
jmp 0x4b46
movw $0x0, 0x1c231(%rip)     # 0x20d80
movq 0x1c1fa(%rip), %rdi     # 0x20d50
callq 0x10330
movq %rax, -0x8(%rbp)
cmpq $0x0, -0x8(%rbp)
je 0x4b86
movq -0x8(%rbp), %rdi
callq 0x10400
movq %rax, %rdi
callq 0x5730
movq -0x8(%rbp), %rdi
callq 0x10430
movq %rax, -0x8(%rbp)
jmp 0x4b5f
jmp 0x4b88
cmpw $0x0, 0x1c1f0(%rip)     # 0x20d80
jne 0x4b46
movq 0x1c197(%rip), %rdi     # 0x20d30
addq $0x10, %rdi
movq 0x1c1d4(%rip), %rsi     # 0x20d78
callq 0x57b0
movw $0x0, 0x1c1ce(%rip)     # 0x20d80
movq 0x1c197(%rip), %rdi     # 0x20d50
callq 0x10330
movq %rax, -0x8(%rbp)
cmpq $0x0, -0x8(%rbp)
je 0x4be9
movq -0x8(%rbp), %rdi
callq 0x10400
movq %rax, %rdi
callq 0x5820
movq -0x8(%rbp), %rdi
callq 0x10430
movq %rax, -0x8(%rbp)
jmp 0x4bc2
jmp 0x4beb
cmpw $0x0, 0x1c18d(%rip)     # 0x20d80
jne 0x4ba9
addq $0x10, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/theovosse[P]llgen/llgen.c
// Function: ShowAllRules
static void ShowAllRules(void) {
	TREE sym;
	Name name;
	NodeList rules;

	for (sym = GetFirstNode(idTree); sym != NULL; sym = GetNextNode(sym)) {
		name = GetKey(sym);
		if (name->nameType == identifier) {
			for (rules = name->rules; rules != NULL; rules = rules->rest) {
				PrintRule(stdout, name, rules->first);
			}
		}
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq 0x1c141(%rip), %rdi     # 0x20d50
callq 0x10330
movq %rax, -0x8(%rbp)
cmpq $0x0, -0x8(%rbp)
je 0x4c84
movq -0x8(%rbp), %rdi
callq 0x10400
movq %rax, -0x10(%rbp)
movq -0x10(%rbp), %rax
cmpl $0x0, 0x38(%rax)
jne 0x4c73
movq -0x10(%rbp), %rax
movq 0x18(%rax), %rax
movq %rax, -0x18(%rbp)
cmpq $0x0, -0x18(%rbp)
je 0x4c71
movq 0x1b378(%rip), %rax     # 0x1ffc8
movq (%rax), %rdi
movq -0x10(%rbp), %rsi
movq -0x18(%rbp), %rax
movq (%rax), %rdx
callq 0x4370
movq -0x18(%rbp), %rax
movq 0x8(%rax), %rax
movq %rax, -0x18(%rbp)
jmp 0x4c42
jmp 0x4c73
jmp 0x4c75
movq -0x8(%rbp), %rdi
callq 0x10430
movq %rax, -0x8(%rbp)
jmp 0x4c18
addq $0x20, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/theovosse[P]llgen/llgen.c
// Function: OpenSkeleton
static void OpenSkeleton(const char* argv0) {
    char llgenFileName[256];

    strcpy(llgenFileName, "llgen.skel.");
    strcpy(llgenFileName + 11, targetLanguage->extension);
    if ((skeletonFile = fopen(llgenFileName, "r")) == NULL) {
        char namebuf[1024];
        char* tail;
        strcpy(namebuf, argv0);
        if ((tail = strrchr(namebuf, DIR_SEP_CHAR)) != NULL) {
            strcpy(tail + 1, llgenFileName);
            skeletonFile = fopen(namebuf, "r");
        }
    }
    if (skeletonFile == NULL) {
        perror("skeleton file");
        exit(1);
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x520, %rsp            # imm = 0x520
movq %rdi, -0x8(%rbp)
leaq -0x110(%rbp), %rdi
leaq 0x14757(%rip), %rsi     # 0x19404
callq 0x3080
leaq -0x110(%rbp), %rdi
addq $0xb, %rdi
movq 0x1b4ac(%rip), %rax     # 0x20170
movq (%rax), %rsi
callq 0x3080
leaq -0x110(%rbp), %rdi
leaq 0x16852(%rip), %rsi     # 0x1b52c
callq 0x3190
movq %rax, 0x1c08a(%rip)     # 0x20d70
cmpq $0x0, %rax
jne 0x4d4d
leaq -0x510(%rbp), %rdi
movq -0x8(%rbp), %rsi
callq 0x3080
leaq -0x510(%rbp), %rdi
movl $0x2f, %esi
callq 0x30f0
movq %rax, -0x518(%rbp)
cmpq $0x0, %rax
je 0x4d4b
movq -0x518(%rbp), %rdi
addq $0x1, %rdi
leaq -0x110(%rbp), %rsi
callq 0x3080
leaq -0x510(%rbp), %rdi
leaq 0x167ed(%rip), %rsi     # 0x1b52c
callq 0x3190
movq %rax, 0x1c025(%rip)     # 0x20d70
jmp 0x4d4d
cmpq $0x0, 0x1c01b(%rip)     # 0x20d70
jne 0x4d6d
leaq 0x146b2(%rip), %rdi     # 0x19410
callq 0x31a0
movl $0x1, %edi
callq 0x31e0
addq $0x520, %rsp            # imm = 0x520
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/theovosse[P]llgen/llgen.c
// Function: determineEmpty
static void determineEmpty(Name name) {
	NodeList rules = name->rules;
	Boolean empty = false;

	if (!name->empty && name->nameType == identifier) {
		while (rules != NULL) {
			if (determineEmptyRule(rules->first)) {
				empty = true;
			}
			rules = rules->rest;
		}
		if (empty) {
			name->empty = true;
			changes = true;
		}
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq 0x18(%rax), %rax
movq %rax, -0x10(%rbp)
movw $0x0, -0x12(%rbp)
movq -0x8(%rbp), %rax
cmpw $0x0, 0x30(%rax)
jne 0x571e
movq -0x8(%rbp), %rax
cmpl $0x0, 0x38(%rax)
jne 0x571e
jmp 0x56d5
cmpq $0x0, -0x10(%rbp)
je 0x5702
movq -0x10(%rbp), %rax
movq (%rax), %rdi
callq 0x58c0
cmpw $0x0, %ax
je 0x56f4
movw $0xffff, -0x12(%rbp)    # imm = 0xFFFF
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rax
movq %rax, -0x10(%rbp)
jmp 0x56d5
cmpw $0x0, -0x12(%rbp)
je 0x571c
movq -0x8(%rbp), %rax
movw $0xffff, 0x30(%rax)     # imm = 0xFFFF
movw $0xffff, 0x1b664(%rip)  # imm = 0xFFFF
jmp 0x571e
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/theovosse[P]llgen/llgen.c
// Function: DetermineFirst
static void DetermineFirst(Name name) {
	NodeList rules = name->rules;
	TREE firsts = NULL;

	while (rules != NULL) {
		(void) collectFirst(&firsts, NULL, rules->first);
		rules = rules->rest;
	}
	if (Unite(&name->first, firsts)) {
		changes = true;
	}
	KillTree(firsts, NULL);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq 0x18(%rax), %rax
movq %rax, -0x10(%rbp)
movq $0x0, -0x18(%rbp)
cmpq $0x0, -0x10(%rbp)
je 0x5779
movq -0x10(%rbp), %rax
movq (%rax), %rdx
leaq -0x18(%rbp), %rdi
xorl %eax, %eax
movl %eax, %esi
callq 0x5ba0
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rax
movq %rax, -0x10(%rbp)
jmp 0x5750
movq -0x8(%rbp), %rdi
addq $0x8, %rdi
movq -0x18(%rbp), %rsi
callq 0x5e00
cmpw $0x0, %ax
je 0x5799
movw $0xffff, 0x1b5e7(%rip)  # imm = 0xFFFF
movq -0x18(%rbp), %rdi
xorl %eax, %eax
movl %eax, %esi
callq 0x106c0
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/theovosse[P]llgen/llgen.c
// Function: InsertElement
static Boolean InsertElement(TREE *first, Name name) {
	Name sym = GetInfo(FindNode(*first, name, (TreeCmp) NameCmp));

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

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x10(%rbp), %rax
movq (%rax), %rdi
movq -0x18(%rbp), %rsi
leaq -0x2072(%rip), %rdx     # 0x3760
callq 0x10560
movq %rax, %rdi
callq 0x103d0
movq %rax, -0x20(%rbp)
cmpq $0x0, -0x20(%rbp)
jne 0x580a
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rsi
movq -0x18(%rbp), %rdx
leaq -0x209d(%rip), %rcx     # 0x3760
callq 0xfc60
movw $0xffff, -0x2(%rbp)     # imm = 0xFFFF
jmp 0x5810
movw $0x0, -0x2(%rbp)
movw -0x2(%rbp), %ax
addq $0x20, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/theovosse[P]llgen/llgen.c
// Function: DetermineFollow
static void DetermineFollow(Name name) {
	TREE sym;
	Name lhs;
	NodeList rules;

	if (name->nameType == identifier) {
		for (sym = GetFirstNode(idTree); sym != NULL; sym = GetNextNode(sym)) {
			lhs = GetKey(sym);
			for (rules = lhs->rules; rules != NULL; rules = rules->rest) {
				DetermineFollowRule(&name->follow, rules->first, name, lhs->follow);
			}
		}
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
cmpl $0x0, 0x38(%rax)
jne 0x58ae
movq 0x1b513(%rip), %rdi     # 0x20d50
callq 0x10330
movq %rax, -0x10(%rbp)
cmpq $0x0, -0x10(%rbp)
je 0x58ac
movq -0x10(%rbp), %rdi
callq 0x10400
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rax
movq 0x18(%rax), %rax
movq %rax, -0x20(%rbp)
cmpq $0x0, -0x20(%rbp)
je 0x589b
movq -0x8(%rbp), %rdi
addq $0x10, %rdi
movq -0x20(%rbp), %rax
movq (%rax), %rsi
movq -0x8(%rbp), %rdx
movq -0x18(%rbp), %rax
movq 0x10(%rax), %rcx
callq 0x5e70
movq -0x20(%rbp), %rax
movq 0x8(%rax), %rax
movq %rax, -0x20(%rbp)
jmp 0x5866
jmp 0x589d
movq -0x10(%rbp), %rdi
callq 0x10430
movq %rax, -0x10(%rbp)
jmp 0x5846
jmp 0x58ae
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/theovosse[P]llgen/llgen.c
// Function: Unite
static Boolean Unite(TREE *set, TREE addition) {
	TREE t = GetFirstNode(addition);
	Boolean change = false;

	while (t != NULL) {
		if (InsertElement(set, GetKey(t))) {
			change = true;
		}
		t = GetNextNode(t);
	}
	return (change);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x10(%rbp), %rdi
callq 0x10330
movq %rax, -0x18(%rbp)
movw $0x0, -0x1a(%rbp)
cmpq $0x0, -0x18(%rbp)
je 0x5e62
movq -0x8(%rbp), %rax
movq %rax, -0x28(%rbp)
movq -0x18(%rbp), %rdi
callq 0x10400
movq -0x28(%rbp), %rdi
movq %rax, %rsi
callq 0x57b0
cmpw $0x0, %ax
je 0x5e53
movw $0xffff, -0x1a(%rbp)    # imm = 0xFFFF
movq -0x18(%rbp), %rdi
callq 0x10430
movq %rax, -0x18(%rbp)
jmp 0x5e23
movw -0x1a(%rbp), %ax
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/theovosse[P]llgen/llgen.c
// Function: DefineEnums
static void DefineEnums(void) {
	TREE sym;
	Name name;
	Boolean prntd = false;

	for (sym = GetFirstNode(idTree); sym != NULL; sym = GetNextNode(sym)) {
		name = GetKey(sym);
		if (name->nameType == token && name->index > 0) {
			if (prntd) fputs(",\n", outputFile);
			fprintf(outputFile, "	%s = %ld", name->name, name->index);
			prntd = true;
		}
	}
	if (prntd) fputs("\n", outputFile);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movw $0x0, -0x12(%rbp)
movq 0x1a55b(%rip), %rdi     # 0x20d50
callq 0x10330
movq %rax, -0x8(%rbp)
cmpq $0x0, -0x8(%rbp)
je 0x687c
movq -0x8(%rbp), %rdi
callq 0x10400
movq %rax, -0x10(%rbp)
movq -0x10(%rbp), %rax
cmpl $0x4, 0x38(%rax)
jne 0x686b
movq -0x10(%rbp), %rax
cmpq $0x0, 0x28(%rax)
jle 0x686b
cmpw $0x0, -0x12(%rbp)
je 0x6841
movq 0x1a503(%rip), %rsi     # 0x20d38
leaq 0x13028(%rip), %rdi     # 0x19864
callq 0x3100
movq 0x1a4f0(%rip), %rdi     # 0x20d38
movq -0x10(%rbp), %rax
movq (%rax), %rdx
movq -0x10(%rbp), %rax
movq 0x28(%rax), %rcx
leaq 0x12d59(%rip), %rsi     # 0x195b7
movb $0x0, %al
callq 0x3140
movw $0xffff, -0x12(%rbp)    # imm = 0xFFFF
jmp 0x686d
movq -0x8(%rbp), %rdi
callq 0x10430
movq %rax, -0x8(%rbp)
jmp 0x67fe
cmpw $0x0, -0x12(%rbp)
je 0x6896
movq 0x1a4ae(%rip), %rsi     # 0x20d38
leaq 0x14839(%rip), %rdi     # 0x1b0ca
callq 0x3100
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax)