LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O0/theovosse[P]llgen/regexp.c
// Function: InitFRegExp
static FRegExp InitFRegExp(ESet info) {
	FRegExp fRegExp = (FRegExp) temp_malloc(sizeof(struct FRegExp));

	if (fRegExp == NULL) { 
		OutOfMemory("MakeFRegExp");
		exit(1);
	}
	totalMalloc += sizeof(struct FRegExp);
	fRegExp->info = info;
	fRegExp->next = NULL;
	currentFDfa = fRegExp;
	return (fRegExp);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movl $0x810, %edi            # imm = 0x810
callq 0x11520
movq %rax, -0x10(%rbp)
cmpq $0x0, -0x10(%rbp)
jne 0x15c17
leaq 0x582b(%rip), %rdi      # 0x1b433
callq 0x11890
movl $0x1, %edi
callq 0x31e0
movq 0xd2b2(%rip), %rax      # 0x22ed0
addq $0x810, %rax            # imm = 0x810
movq %rax, 0xd2a5(%rip)      # 0x22ed0
movq -0x8(%rbp), %rcx
movq -0x10(%rbp), %rax
movq %rcx, (%rax)
movq -0x10(%rbp), %rax
movq $0x0, 0x8(%rax)
movq -0x10(%rbp), %rax
movq %rax, 0xd32b(%rip)      # 0x22f78
movq -0x10(%rbp), %rax
addq $0x10, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/theovosse[P]llgen/regexp.c
// Function: MakeFRegExp
static FRegExp MakeFRegExp(ESet info) {
	FRegExp fRegExp = (FRegExp) temp_malloc(sizeof(struct FRegExp));

	if (fRegExp == NULL) { 
		OutOfMemory("MakeFRegExp");
		exit(1);
	}
	totalMalloc += sizeof(struct FRegExp);
	fRegExp->info = info;
	fRegExp->next = currentFDfa->next;
	currentFDfa->next = fRegExp;
	return (fRegExp);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movl $0x810, %edi            # imm = 0x810
callq 0x11520
movq %rax, -0x10(%rbp)
cmpq $0x0, -0x10(%rbp)
jne 0x15c97
leaq 0x57ab(%rip), %rdi      # 0x1b433
callq 0x11890
movl $0x1, %edi
callq 0x31e0
movq 0xd232(%rip), %rax      # 0x22ed0
addq $0x810, %rax            # imm = 0x810
movq %rax, 0xd225(%rip)      # 0x22ed0
movq -0x8(%rbp), %rcx
movq -0x10(%rbp), %rax
movq %rcx, (%rax)
movq 0xd2bb(%rip), %rax      # 0x22f78
movq 0x8(%rax), %rcx
movq -0x10(%rbp), %rax
movq %rcx, 0x8(%rax)
movq -0x10(%rbp), %rcx
movq 0xd2a4(%rip), %rax      # 0x22f78
movq %rcx, 0x8(%rax)
movq -0x10(%rbp), %rax
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/theovosse[P]llgen/regexp.c
// Function: MatchFDFA
int MatchFDFA(FRegExp fDfa, char *line, ESet *answer) {
	register FRegExp fState = fDfa;
	register unsigned char *ptr = (unsigned char *) line;
	ESet info = NULL;
	int rLen = -1;

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

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x20(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x28(%rbp)
movq $0x0, -0x30(%rbp)
movl $0xffffffff, -0x34(%rbp) # imm = 0xFFFFFFFF
cmpq $0x0, -0x20(%rbp)
je 0x15d6a
movq -0x20(%rbp), %rax
cmpq $0x0, (%rax)
je 0x15d49
movq -0x20(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x30(%rbp)
movq -0x28(%rbp), %rax
movq -0x10(%rbp), %rcx
subq %rcx, %rax
movl %eax, -0x34(%rbp)
movq -0x20(%rbp), %rax
movq -0x28(%rbp), %rcx
movq %rcx, %rdx
addq $0x1, %rdx
movq %rdx, -0x28(%rbp)
movzbl (%rcx), %ecx
movq 0x10(%rax,%rcx,8), %rax
movq %rax, -0x20(%rbp)
jmp 0x15d1f
movq -0x30(%rbp), %rcx
movq -0x18(%rbp), %rax
movq %rcx, (%rax)
movl -0x34(%rbp), %eax
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/theovosse[P]llgen/regexp.c
// Function: sequence
static char *sequence(RegExp start, char *pattern, RegExp *end) {
	RegExp startFactor = start;
	RegExp endFactor;
	char *rest = pattern;
	char *rest2;
	char nextCh;
	Boolean special;

	do {
		rest2 = rest = factor(startFactor, rest, &endFactor);
		startFactor = endFactor;
		nextCh = chardenot(&rest2, &special, false);
	}
	while (errorInExpression == 0 && *rest != '\0' && !(special && (nextCh == '|' || nextCh == ')')));
	*end = endFactor;
	return (rest);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x20(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x30(%rbp)
movq -0x20(%rbp), %rdi
movq -0x30(%rbp), %rsi
leaq -0x28(%rbp), %rdx
callq 0x16010
movq %rax, -0x30(%rbp)
movq %rax, -0x38(%rbp)
movq -0x28(%rbp), %rax
movq %rax, -0x20(%rbp)
leaq -0x38(%rbp), %rdi
leaq -0x3c(%rbp), %rsi
xorl %edx, %edx
callq 0x15e50
movb %al, -0x39(%rbp)
xorl %eax, %eax
cmpl $0x0, 0xd180(%rip)      # 0x22f60
movb %al, -0x3d(%rbp)
jne 0x15e2d
movq -0x30(%rbp), %rax
movsbl (%rax), %ecx
xorl %eax, %eax
cmpl $0x0, %ecx
movb %al, -0x3d(%rbp)
je 0x15e2d
movswl -0x3c(%rbp), %ecx
xorl %eax, %eax
cmpl $0x0, %ecx
movb %al, -0x3e(%rbp)
je 0x15e25
movsbl -0x39(%rbp), %ecx
movb $0x1, %al
cmpl $0x7c, %ecx
movb %al, -0x3f(%rbp)
je 0x15e1f
movsbl -0x39(%rbp), %eax
cmpl $0x29, %eax
sete %al
movb %al, -0x3f(%rbp)
movb -0x3f(%rbp), %al
movb %al, -0x3e(%rbp)
movb -0x3e(%rbp), %al
xorb $-0x1, %al
movb %al, -0x3d(%rbp)
movb -0x3d(%rbp), %al
testb $0x1, %al
jne 0x15da4
movq -0x28(%rbp), %rcx
movq -0x18(%rbp), %rax
movq %rcx, (%rax)
movq -0x30(%rbp), %rax
addq $0x40, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/theovosse[P]llgen/regexp.c
// Function: factor
static char *factor(RegExp start, char *pattern, RegExp *end) {
	char *rest = pattern;
	char *rest2 = rest;
	char nextCh;
	Boolean special;

	rest2 = rest = character(start, pattern, end);
	nextCh = chardenot(&rest2, &special, false);
	if (special) {
		if (nextCh == '+') {
			rest = rest2;
			ELink(*end, start);
		} else if (nextCh == '*') {
			rest = rest2;
			ELink(*end, start);
			*end = start;
		} else if (nextCh == '?') {
			rest = rest2;
			ELink(start, *end);
		} else if (nextCh == '\0' || strchr("\\(|)[].0tnr", nextCh) == NULL) {
			if (errorInExpression == 0) errorInExpression = 1; /* Illegal escape character */
		}
	}
	return (rest);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x20(%rbp)
movq -0x20(%rbp), %rax
movq %rax, -0x28(%rbp)
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
movq -0x18(%rbp), %rdx
callq 0x16130
movq %rax, -0x20(%rbp)
movq %rax, -0x28(%rbp)
leaq -0x28(%rbp), %rdi
leaq -0x2c(%rbp), %rsi
xorl %edx, %edx
callq 0x15e50
movb %al, -0x29(%rbp)
cmpw $0x0, -0x2c(%rbp)
je 0x1611d
movsbl -0x29(%rbp), %eax
cmpl $0x2b, %eax
jne 0x16090
movq -0x28(%rbp), %rax
movq %rax, -0x20(%rbp)
movq -0x18(%rbp), %rax
movq (%rax), %rdi
movq -0x8(%rbp), %rsi
callq 0x11e20
jmp 0x1611b
movsbl -0x29(%rbp), %eax
cmpl $0x2a, %eax
jne 0x160be
movq -0x28(%rbp), %rax
movq %rax, -0x20(%rbp)
movq -0x18(%rbp), %rax
movq (%rax), %rdi
movq -0x8(%rbp), %rsi
callq 0x11e20
movq -0x8(%rbp), %rcx
movq -0x18(%rbp), %rax
movq %rcx, (%rax)
jmp 0x16119
movsbl -0x29(%rbp), %eax
cmpl $0x3f, %eax
jne 0x160e1
movq -0x28(%rbp), %rax
movq %rax, -0x20(%rbp)
movq -0x8(%rbp), %rdi
movq -0x18(%rbp), %rax
movq (%rax), %rsi
callq 0x11e20
jmp 0x16117
movsbl -0x29(%rbp), %eax
cmpl $0x0, %eax
je 0x16100
movsbl -0x29(%rbp), %esi
leaq 0x52b0(%rip), %rdi      # 0x1b3a5
callq 0x30d0
cmpq $0x0, %rax
jne 0x16115
cmpl $0x0, 0xce59(%rip)      # 0x22f60
jne 0x16113
movl $0x1, 0xce4d(%rip)      # 0x22f60
jmp 0x16115
jmp 0x16117
jmp 0x16119
jmp 0x1611b
jmp 0x1611d
movq -0x20(%rbp), %rax
addq $0x30, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/theovosse[P]llgen/lang.c
// Function: cLanguageEndDoWhileLoop
static void cLanguageEndDoWhileLoop(FILE* outputFile, Boolean open, int indent) {
    if (open) {
        terminateBlock(indent);
        if (bracesOnNewLine) {
           doIndent(indent);
        } else {
            fputc(' ', outputFile);
        }
        fprintf(outputFile, "while (");
    } else {
        fprintf(outputFile, ");");
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movw %si, %ax
movq %rdi, -0x8(%rbp)
movw %ax, -0xa(%rbp)
movl %edx, -0x10(%rbp)
cmpw $0x0, -0xa(%rbp)
je 0x168fe
movl -0x10(%rbp), %edi
callq 0x40a0
leaq 0xa49c(%rip), %rax      # 0x20d68
cmpw $0x0, (%rax)
je 0x168dc
movl -0x10(%rbp), %edi
callq 0x4000
jmp 0x168ea
movq -0x8(%rbp), %rsi
movl $0x20, %edi
callq 0x3120
movq -0x8(%rbp), %rdi
leaq 0x4d09(%rip), %rsi      # 0x1b5fe
movb $0x0, %al
callq 0x3140
jmp 0x16910
movq -0x8(%rbp), %rdi
leaq 0x3380(%rip), %rsi      # 0x19c89
movb $0x0, %al
callq 0x3140
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/theovosse[P]llgen/lang.c
// Function: cLanguageArrayDeclaration
static void cLanguageArrayDeclaration(FILE* f, const char* scope, const char* type, const char* name, long int suffix, int size, Boolean init) {
    fprintf(f, "%s %s %s", scope, type, name);
    if (suffix >= 0) {
        fprintf(f, "%ld", suffix);
    }
    if (size >= 0) {
        fprintf(f, "[%d]", size);
    } else {
        fprintf(f, "[]");
    }
    if (init) {
        fprintf(f, " = ");
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movw 0x10(%rbp), %ax
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq %rcx, -0x20(%rbp)
movq %r8, -0x28(%rbp)
movl %r9d, -0x2c(%rbp)
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rdx
movq -0x18(%rbp), %rcx
movq -0x20(%rbp), %r8
leaq 0x4cab(%rip), %rsi      # 0x1b606
movb $0x0, %al
callq 0x3140
cmpq $0x0, -0x28(%rbp)
jl 0x1697f
movq -0x8(%rbp), %rdi
movq -0x28(%rbp), %rdx
leaq 0x2d47(%rip), %rsi      # 0x196bf
movb $0x0, %al
callq 0x3140
cmpl $0x0, -0x2c(%rbp)
jl 0x1699c
movq -0x8(%rbp), %rdi
movl -0x2c(%rbp), %edx
leaq 0x4c7c(%rip), %rsi      # 0x1b60f
movb $0x0, %al
callq 0x3140
jmp 0x169ae
movq -0x8(%rbp), %rdi
leaq 0x4d0c(%rip), %rsi      # 0x1b6b3
movb $0x0, %al
callq 0x3140
cmpw $0x0, 0x10(%rbp)
je 0x169c7
movq -0x8(%rbp), %rdi
leaq 0x4dc2(%rip), %rsi      # 0x1b782
movb $0x0, %al
callq 0x3140
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/theovosse[P]llgen/lang.c
// Function: cLanguageStateTransition
static void cLanguageStateTransition(FILE* f, int ch, long int destination, const char* accept) {
    fprintf(f, "{ ");
    if (ch == -1) {
        fprintf(f, "-1");
    } else if (ch == '\'' || ch == '\\') {
        fprintf(f, "'\\%c'", ch);
    } else if (' ' <= ch && ch <= '~') {
        fprintf(f, "'%c'", ch);
    } else {
        fprintf(f, "'\\x%02x'", ch);
    }
    fprintf(f, ", %ld, %s },\n", destination, accept);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movq %rdx, -0x18(%rbp)
movq %rcx, -0x20(%rbp)
movq -0x8(%rbp), %rdi
leaq 0x4b38(%rip), %rsi      # 0x1b62a
movb $0x0, %al
callq 0x3140
cmpl $-0x1, -0xc(%rbp)
jne 0x16b13
movq -0x8(%rbp), %rdi
leaq 0x4b23(%rip), %rsi      # 0x1b62d
movb $0x0, %al
callq 0x3140
jmp 0x16b76
cmpl $0x27, -0xc(%rbp)
je 0x16b1f
cmpl $0x5c, -0xc(%rbp)
jne 0x16b36
movq -0x8(%rbp), %rdi
movl -0xc(%rbp), %edx
leaq 0x4b03(%rip), %rsi      # 0x1b630
movb $0x0, %al
callq 0x3140
jmp 0x16b74
movl $0x20, %eax
cmpl -0xc(%rbp), %eax
jg 0x16b5d
cmpl $0x7e, -0xc(%rbp)
jg 0x16b5d
movq -0x8(%rbp), %rdi
movl -0xc(%rbp), %edx
leaq 0x4ae2(%rip), %rsi      # 0x1b636
movb $0x0, %al
callq 0x3140
jmp 0x16b72
movq -0x8(%rbp), %rdi
movl -0xc(%rbp), %edx
leaq 0x4ad0(%rip), %rsi      # 0x1b63b
movb $0x0, %al
callq 0x3140
jmp 0x16b74
jmp 0x16b76
movq -0x8(%rbp), %rdi
movq -0x18(%rbp), %rdx
movq -0x20(%rbp), %rcx
leaq 0x4abb(%rip), %rsi      # 0x1b644
movb $0x0, %al
callq 0x3140
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/theovosse[P]llgen/lang.c
// Function: cLanguageParameterDeclarationName
static void cLanguageParameterDeclarationName(FILE* f, const char* str, int nrSpaces) {
    if (nrFunctionParameters > 0) {
        spaces(f, firstTypeNameSpaces, 1);
        fprintf(f, " %s,", lastParameterName);
    }
    lastParameterName = str;
    lastParameterNameSpaces = nrSpaces;
    inParamType = false;
    nrFunctionParameters++;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl %edx, -0x14(%rbp)
cmpl $0x0, 0xc2e6(%rip)      # 0x22f80
jle 0x16cc9
movq -0x8(%rbp), %rdi
movl 0xc2de(%rip), %esi      # 0x22f84
movl $0x1, %edx
callq 0x18a00
movq -0x8(%rbp), %rdi
movq 0xc2cd(%rip), %rdx      # 0x22f88
leaq 0x499e(%rip), %rsi      # 0x1b660
movb $0x0, %al
callq 0x3140
movq -0x10(%rbp), %rax
movq %rax, 0xc2b4(%rip)      # 0x22f88
movl -0x14(%rbp), %eax
movl %eax, 0xc2b3(%rip)      # 0x22f90
movw $0x0, 0xc2ae(%rip)      # 0x22f94
movl 0xc294(%rip), %eax      # 0x22f80
addl $0x1, %eax
movl %eax, 0xc28b(%rip)      # 0x22f80
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/theovosse[P]llgen/lang.c
// Function: cLanguageNextDeclarationParameterSymbol
static void cLanguageNextDeclarationParameterSymbol(FILE* f, const char* str, int nrSpaces) {
    if (!inParamType) {
        spaces(f, lastParameterNameSpaces, nrFunctionParameters > 0? 1: 0);
        firstTypeNameSpaces = nrSpaces;
        inParamType = true;
    } else {
        spaces(f, nrSpaces, 0);
    }
    fputs(str, f);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl %edx, -0x14(%rbp)
cmpw $0x0, 0xc279(%rip)      # 0x22f94
jne 0x16d53
movq -0x8(%rbp), %rdi
movl 0xc269(%rip), %esi      # 0x22f90
movl 0xc253(%rip), %ecx      # 0x22f80
xorl %edx, %edx
movl $0x1, %eax
cmpl $0x0, %ecx
cmovgl %eax, %edx
callq 0x18a00
movl -0x14(%rbp), %eax
movl %eax, 0xc23c(%rip)      # 0x22f84
movw $0xffff, 0xc243(%rip)   # imm = 0xFFFF
jmp 0x16d61
movq -0x8(%rbp), %rdi
movl -0x14(%rbp), %esi
xorl %edx, %edx
callq 0x18a00
movq -0x10(%rbp), %rdi
movq -0x8(%rbp), %rsi
callq 0x3100
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/theovosse[P]llgen/lang.c
// Function: cLanguageEndFunctionDeclaration
static void cLanguageEndFunctionDeclaration(FILE* f) {
    if (nrFunctionParameters > 0) {
        spaces(f, lastParameterNameSpaces, 1);
        fprintf(f, " %s", lastParameterName);
    }
    fprintf(f, ")");
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
cmpl $0x0, 0xc1ed(%rip)      # 0x22f80
jle 0x16dc2
movq -0x8(%rbp), %rdi
movl 0xc1f1(%rip), %esi      # 0x22f90
movl $0x1, %edx
callq 0x18a00
movq -0x8(%rbp), %rdi
movq 0xc1d4(%rip), %rdx      # 0x22f88
leaq 0x49b9(%rip), %rsi      # 0x1b774
movb $0x0, %al
callq 0x3140
movq -0x8(%rbp), %rdi
leaq 0x4231(%rip), %rsi      # 0x1affe
movb $0x0, %al
callq 0x3140
addq $0x10, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/theovosse[P]llgen/lang.c
// Function: cLanguageStartFunctionCall
static void cLanguageStartFunctionCall(FILE* f, const char*functionName, const char* returnType, const char* assignTo) {
    if (returnType != NULL && assignTo != NULL) {
        fprintf(f, "%s ", returnType);
    }
    if (assignTo != NULL) {
        fprintf(f, "%s = ", assignTo);
    }
    fprintf(f, "%s(", functionName);
    nrFunctionParameters = 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq %rcx, -0x20(%rbp)
cmpq $0x0, -0x18(%rbp)
je 0x16e1c
cmpq $0x0, -0x20(%rbp)
je 0x16e1c
movq -0x8(%rbp), %rdi
movq -0x18(%rbp), %rdx
leaq 0x4850(%rip), %rsi      # 0x1b665
movb $0x0, %al
callq 0x3140
cmpq $0x0, -0x20(%rbp)
je 0x16e39
movq -0x8(%rbp), %rdi
movq -0x20(%rbp), %rdx
leaq 0x494e(%rip), %rsi      # 0x1b780
movb $0x0, %al
callq 0x3140
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rdx
leaq 0x49b6(%rip), %rsi      # 0x1b7fe
movb $0x0, %al
callq 0x3140
movl $0x0, 0xc127(%rip)      # 0x22f80
addq $0x20, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/theovosse[P]llgen/lang.c
// Function: cLanguageAssignLastSymbolTo
static void cLanguageAssignLastSymbolTo(FILE* f, int indent, Name name, Boolean noDecl) {
    if (!noDecl) {
        doIndent(indent);
        fprintf(f, "char %s[sizeof(lastSymbol)];", name->name);
    }
    doIndent(indent);
    fprintf(f, "strcpy(%s, lastSymbol);", name->name);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movw %cx, %ax
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movq %rdx, -0x18(%rbp)
movw %ax, -0x1a(%rbp)
cmpw $0x0, -0x1a(%rbp)
jne 0x16fa2
movl -0xc(%rbp), %edi
callq 0x4000
movq -0x8(%rbp), %rdi
movq -0x18(%rbp), %rax
movq (%rax), %rdx
leaq 0x46ce(%rip), %rsi      # 0x1b669
movb $0x0, %al
callq 0x3140
movl -0xc(%rbp), %edi
callq 0x4000
movq -0x8(%rbp), %rdi
movq -0x18(%rbp), %rax
movq (%rax), %rdx
leaq 0x46ca(%rip), %rsi      # 0x1b686
movb $0x0, %al
callq 0x3140
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/theovosse[P]llgen/lang.c
// Function: jsLanguageArrayDeclaration
static void jsLanguageArrayDeclaration(FILE* f, const char* scope, const char* type, const char* name, long int suffix, int size, Boolean init) {
    fprintf(f, "var %s", name);
    if (suffix >= 0) {
        fprintf(f, "%ld", suffix);
    }
    if (init) {
        fprintf(f, " = [");
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movw 0x10(%rbp), %ax
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq %rcx, -0x20(%rbp)
movq %r8, -0x28(%rbp)
movl %r9d, -0x2c(%rbp)
movq -0x8(%rbp), %rdi
movq -0x20(%rbp), %rdx
leaq 0x46a0(%rip), %rsi      # 0x1b6a3
movb $0x0, %al
callq 0x3140
cmpq $0x0, -0x28(%rbp)
jl 0x17027
movq -0x8(%rbp), %rdi
movq -0x28(%rbp), %rdx
leaq 0x269f(%rip), %rsi      # 0x196bf
movb $0x0, %al
callq 0x3140
cmpw $0x0, 0x10(%rbp)
je 0x17040
movq -0x8(%rbp), %rdi
leaq 0x4719(%rip), %rsi      # 0x1b752
movb $0x0, %al
callq 0x3140
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/theovosse[P]llgen/lang.c
// Function: jsLanguageStateTransition
static void jsLanguageStateTransition(FILE* f, int ch, long int destination, const char* accept) {
    fprintf(f, "  ");
    if (ch == -1) {
        fprintf(f, "''");
    } else if (ch == '\'' || ch == '\\') {
        fprintf(f, "'\\%c'", ch);
    } else if (' ' <= ch && ch <= '~') {
        fprintf(f, "'%c'", ch);
    } else {
        fprintf(f, "'\\x%02x'", ch);
    }
    fprintf(f, ": {");
    if (destination != -1) {
        fprintf(f, "destination:%ld", destination);
    }
    if (strcmp(accept, "undefined") != 0) {
        if (destination != -1) {
            fprintf(f, ",");
        }
        fprintf(f, "accept:%s", accept);
    }
    fprintf(f, "},\n");
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movq %rdx, -0x18(%rbp)
movq %rcx, -0x20(%rbp)
movq -0x8(%rbp), %rdi
leaq 0x25eb(%rip), %rsi      # 0x1974d
movb $0x0, %al
callq 0x3140
cmpl $-0x1, -0xc(%rbp)
jne 0x17183
movq -0x8(%rbp), %rdi
leaq 0x4554(%rip), %rsi      # 0x1b6ce
movb $0x0, %al
callq 0x3140
jmp 0x171e6
cmpl $0x27, -0xc(%rbp)
je 0x1718f
cmpl $0x5c, -0xc(%rbp)
jne 0x171a6
movq -0x8(%rbp), %rdi
movl -0xc(%rbp), %edx
leaq 0x4493(%rip), %rsi      # 0x1b630
movb $0x0, %al
callq 0x3140
jmp 0x171e4
movl $0x20, %eax
cmpl -0xc(%rbp), %eax
jg 0x171cd
cmpl $0x7e, -0xc(%rbp)
jg 0x171cd
movq -0x8(%rbp), %rdi
movl -0xc(%rbp), %edx
leaq 0x4472(%rip), %rsi      # 0x1b636
movb $0x0, %al
callq 0x3140
jmp 0x171e2
movq -0x8(%rbp), %rdi
movl -0xc(%rbp), %edx
leaq 0x4460(%rip), %rsi      # 0x1b63b
movb $0x0, %al
callq 0x3140
jmp 0x171e4
jmp 0x171e6
movq -0x8(%rbp), %rdi
leaq 0x44e0(%rip), %rsi      # 0x1b6d1
movb $0x0, %al
callq 0x3140
cmpq $-0x1, -0x18(%rbp)
je 0x17215
movq -0x8(%rbp), %rdi
movq -0x18(%rbp), %rdx
leaq 0x44c7(%rip), %rsi      # 0x1b6d5
movb $0x0, %al
callq 0x3140
movq -0x20(%rbp), %rdi
leaq 0x4344(%rip), %rsi      # 0x1b564
callq 0x3220
cmpl $0x0, %eax
je 0x17259
cmpq $-0x1, -0x18(%rbp)
je 0x17243
movq -0x8(%rbp), %rdi
leaq 0x4427(%rip), %rsi      # 0x1b663
movb $0x0, %al
callq 0x3140
movq -0x8(%rbp), %rdi
movq -0x20(%rbp), %rdx
leaq 0x4493(%rip), %rsi      # 0x1b6e5
movb $0x0, %al
callq 0x3140
movq -0x8(%rbp), %rdi
leaq 0x44ac(%rip), %rsi      # 0x1b710
movb $0x0, %al
callq 0x3140
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/theovosse[P]llgen/lang.c
// Function: jsLanguageParameterDeclarationName
static void jsLanguageParameterDeclarationName(FILE* f, const char* str, int nrSpaces) {
    if (nrFunctionParameters > 0) {
        fprintf(f, ", ");
    }
    fputs(str, f);
    nrFunctionParameters++;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl %edx, -0x14(%rbp)
cmpl $0x0, 0xbbb6(%rip)      # 0x22f80
jle 0x173de
movq -0x8(%rbp), %rdi
leaq 0x219c(%rip), %rsi      # 0x19573
movb $0x0, %al
callq 0x3140
movq -0x10(%rbp), %rdi
movq -0x8(%rbp), %rsi
callq 0x3100
movl 0xbb8f(%rip), %eax      # 0x22f80
addl $0x1, %eax
movl %eax, 0xbb86(%rip)      # 0x22f80
addq $0x20, %rsp
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O0/theovosse[P]llgen/lang.c
// Function: jsLanguageStartFunctionCall
static void jsLanguageStartFunctionCall(FILE* f, const char*functionName, const char* returnType, const char* assignTo) {
    if (returnType != NULL && assignTo != NULL) {
        fprintf(f, "var ");
    }
    if (assignTo != NULL) {
        fprintf(f, "%s = ", assignTo);
    }
    fprintf(f, "%s(", functionName);
    nrFunctionParameters = 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq %rcx, -0x20(%rbp)
cmpq $0x0, -0x18(%rbp)
je 0x17488
cmpq $0x0, -0x20(%rbp)
je 0x17488
movq -0x8(%rbp), %rdi
leaq 0x42aa(%rip), %rsi      # 0x1b72b
movb $0x0, %al
callq 0x3140
cmpq $0x0, -0x20(%rbp)
je 0x174a5
movq -0x8(%rbp), %rdi
movq -0x20(%rbp), %rdx
leaq 0x42e2(%rip), %rsi      # 0x1b780
movb $0x0, %al
callq 0x3140
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rdx
leaq 0x434a(%rip), %rsi      # 0x1b7fe
movb $0x0, %al
callq 0x3140
movl $0x0, 0xbabb(%rip)      # 0x22f80
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/theovosse[P]llgen/lang.c
// Function: jsLanguageAssignLastSymbolTo
static void jsLanguageAssignLastSymbolTo(FILE* f, int indent, Name name, Boolean noDecl) {
    doIndent(indent);
    if (noDecl) {
        fprintf(f, "%s = lastSymbol;", name->name);
    } else {
        fprintf(f, "var %s = lastSymbol;", name->name);
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movw %cx, %ax
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movq %rdx, -0x18(%rbp)
movw %ax, -0x1a(%rbp)
movl -0xc(%rbp), %edi
callq 0x4000
cmpw $0x0, -0x1a(%rbp)
je 0x175f4
movq -0x8(%rbp), %rdi
movq -0x18(%rbp), %rax
movq (%rax), %rdx
leaq 0x4149(%rip), %rsi      # 0x1b734
movb $0x0, %al
callq 0x3140
jmp 0x1760d
movq -0x8(%rbp), %rdi
movq -0x18(%rbp), %rax
movq (%rax), %rdx
leaq 0x412a(%rip), %rsi      # 0x1b730
movb $0x0, %al
callq 0x3140
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/theovosse[P]llgen/lang.c
// Function: tsLanguageArrayDeclaration
static void tsLanguageArrayDeclaration(FILE* f, const char* scope, const char* type, const char* name, long int suffix, int size, Boolean init) {
    fprintf(f, "let %s", name);
    if (suffix >= 0) {
        fprintf(f, "%ld", suffix);
    }
    if (init) {
        fprintf(f, ": %s[] = [", type);
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movw 0x10(%rbp), %ax
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq %rcx, -0x20(%rbp)
movq %r8, -0x28(%rbp)
movl %r9d, -0x2c(%rbp)
movq -0x8(%rbp), %rdi
movq -0x20(%rbp), %rdx
leaq 0x40f2(%rip), %rsi      # 0x1b745
movb $0x0, %al
callq 0x3140
cmpq $0x0, -0x28(%rbp)
jl 0x17677
movq -0x8(%rbp), %rdi
movq -0x28(%rbp), %rdx
leaq 0x204f(%rip), %rsi      # 0x196bf
movb $0x0, %al
callq 0x3140
cmpw $0x0, 0x10(%rbp)
je 0x17694
movq -0x8(%rbp), %rdi
movq -0x18(%rbp), %rdx
leaq 0x40bf(%rip), %rsi      # 0x1b74c
movb $0x0, %al
callq 0x3140
addq $0x30, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/theovosse[P]llgen/lang.c
// Function: tsLanguageParameterDeclarationName
static void tsLanguageParameterDeclarationName(FILE* f, const char* str, int nrSpaces) {
    if (nrFunctionParameters > 0) {
        fprintf(f, ",");
    }
    spaces(f, nrSpaces, nrFunctionParameters > 0? 1: 0);
    fputs(str, f);
    inParamType = false;
    nrFunctionParameters++;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl %edx, -0x14(%rbp)
cmpl $0x0, 0xb796(%rip)      # 0x22f80
jle 0x177fe
movq -0x8(%rbp), %rdi
leaq 0x3e6c(%rip), %rsi      # 0x1b663
movb $0x0, %al
callq 0x3140
movq -0x8(%rbp), %rdi
movl -0x14(%rbp), %esi
movl 0xb775(%rip), %ecx      # 0x22f80
xorl %edx, %edx
movl $0x1, %eax
cmpl $0x0, %ecx
cmovgl %eax, %edx
callq 0x18a00
movq -0x10(%rbp), %rdi
movq -0x8(%rbp), %rsi
callq 0x3100
movw $0x0, 0xb761(%rip)      # 0x22f94
movl 0xb747(%rip), %eax      # 0x22f80
addl $0x1, %eax
movl %eax, 0xb73e(%rip)      # 0x22f80
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/theovosse[P]llgen/lang.c
// Function: tsLanguageNextDeclarationParameterSymbol
static void tsLanguageNextDeclarationParameterSymbol(FILE* f, const char* str, int nrSpaces) {
    if (!inParamType) {
        fputs(":", f);
        inParamType = true;
    }
    spaces(f, nrSpaces, 0);
    fputs(str, f);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl %edx, -0x14(%rbp)
cmpw $0x0, 0xb729(%rip)      # 0x22f94
jne 0x17886
movq -0x8(%rbp), %rsi
leaq 0x3aa4(%rip), %rdi      # 0x1b31c
callq 0x3100
movw $0xffff, 0xb70e(%rip)   # imm = 0xFFFF
movq -0x8(%rbp), %rdi
movl -0x14(%rbp), %esi
xorl %edx, %edx
callq 0x18a00
movq -0x10(%rbp), %rdi
movq -0x8(%rbp), %rsi
callq 0x3100
addq $0x20, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/theovosse[P]llgen/lang.c
// Function: tsLanguageStartFunctionCall
static void tsLanguageStartFunctionCall(FILE* f, const char*functionName, const char* returnType, const char* assignTo) {
    if (returnType != NULL && assignTo != NULL) {
        fprintf(f, "let %s: %s = ", assignTo, returnType);
    } else if (assignTo != NULL) {
        fprintf(f, "%s = ", assignTo);
    }
    fprintf(f, "%s(", functionName);
    nrFunctionParameters = 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq %rcx, -0x20(%rbp)
cmpq $0x0, -0x18(%rbp)
je 0x17922
cmpq $0x0, -0x20(%rbp)
je 0x17922
movq -0x8(%rbp), %rdi
movq -0x20(%rbp), %rdx
movq -0x18(%rbp), %rcx
leaq 0x3e5f(%rip), %rsi      # 0x1b778
movb $0x0, %al
callq 0x3140
jmp 0x17941
cmpq $0x0, -0x20(%rbp)
je 0x1793f
movq -0x8(%rbp), %rdi
movq -0x20(%rbp), %rdx
leaq 0x3e48(%rip), %rsi      # 0x1b780
movb $0x0, %al
callq 0x3140
jmp 0x17941
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rdx
leaq 0x3eae(%rip), %rsi      # 0x1b7fe
movb $0x0, %al
callq 0x3140
movl $0x0, 0xb61f(%rip)      # 0x22f80
addq $0x20, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/theovosse[P]llgen/lang.c
// Function: tsLanguageAssignLastSymbolTo
static void tsLanguageAssignLastSymbolTo(FILE* f, int indent, Name name, Boolean noDecl) {
    doIndent(indent);
    if (noDecl) {
        fprintf(f, "%s = lastSymbol;", name->name);
    } else {
        fprintf(f, "let %s: string = lastSymbol;", name->name);
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movw %cx, %ax
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movq %rdx, -0x18(%rbp)
movw %ax, -0x1a(%rbp)
movl -0xc(%rbp), %edi
callq 0x4000
cmpw $0x0, -0x1a(%rbp)
je 0x179e4
movq -0x8(%rbp), %rdi
movq -0x18(%rbp), %rax
movq (%rax), %rdx
leaq 0x3d59(%rip), %rsi      # 0x1b734
movb $0x0, %al
callq 0x3140
jmp 0x179fd
movq -0x8(%rbp), %rdi
movq -0x18(%rbp), %rax
movq (%rax), %rdx
leaq 0x3d90(%rip), %rsi      # 0x1b786
movb $0x0, %al
callq 0x3140
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/theovosse[P]llgen/lang.c
// Function: goLanguageEndDoWhileLoop
static void goLanguageEndDoWhileLoop(FILE* outputFile, Boolean open, int indent) {
    if (open) {
        doIndent(indent + 1);
        fprintf(outputFile, "if !");
    } else {
        startBlock(indent + 1);
        doIndent(indent + 2);
        fputs("break", outputFile);
        terminateBlock(indent + 1);
        terminateBlock(indent);
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movw %si, %ax
movq %rdi, -0x8(%rbp)
movw %ax, -0xa(%rbp)
movl %edx, -0x10(%rbp)
cmpw $0x0, -0xa(%rbp)
je 0x17a7c
movl -0x10(%rbp), %edi
addl $0x1, %edi
callq 0x4000
movq -0x8(%rbp), %rdi
leaq 0x3d30(%rip), %rsi      # 0x1b7a3
movb $0x0, %al
callq 0x3140
jmp 0x17ab5
movl -0x10(%rbp), %edi
addl $0x1, %edi
callq 0x4050
movl -0x10(%rbp), %edi
addl $0x2, %edi
callq 0x4000
movq -0x8(%rbp), %rsi
leaq 0x3ab5(%rip), %rdi      # 0x1b552
callq 0x3100
movl -0x10(%rbp), %edi
addl $0x1, %edi
callq 0x40a0
movl -0x10(%rbp), %edi
callq 0x40a0
addq $0x10, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/theovosse[P]llgen/lang.c
// Function: goLanguageArrayDeclaration
static void goLanguageArrayDeclaration(FILE* f, const char* scope, const char* type, const char* name, long int suffix, int size, Boolean init) {
    fprintf(f, "var %s", name);
    if (suffix >= 0) {
        fprintf(f, "%ld", suffix);
    }
    if (init) {
        fprintf(f, " =");
    }
    if (size >= 0) {
        fprintf(f, " [%d]%s", size, type);
    } else {
        fprintf(f, " []%s", type);
    }
    if (init) {
        fprintf(f, "{");
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movw 0x10(%rbp), %ax
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq %rcx, -0x20(%rbp)
movq %r8, -0x28(%rbp)
movl %r9d, -0x2c(%rbp)
movq -0x8(%rbp), %rdi
movq -0x20(%rbp), %rdx
leaq 0x3bb0(%rip), %rsi      # 0x1b6a3
movb $0x0, %al
callq 0x3140
cmpq $0x0, -0x28(%rbp)
jl 0x17b17
movq -0x8(%rbp), %rdi
movq -0x28(%rbp), %rdx
leaq 0x1baf(%rip), %rsi      # 0x196bf
movb $0x0, %al
callq 0x3140
cmpw $0x0, 0x10(%rbp)
je 0x17b30
movq -0x8(%rbp), %rdi
leaq 0x3c7f(%rip), %rsi      # 0x1b7a8
movb $0x0, %al
callq 0x3140
cmpl $0x0, -0x2c(%rbp)
jl 0x17b51
movq -0x8(%rbp), %rdi
movl -0x2c(%rbp), %edx
movq -0x18(%rbp), %rcx
leaq 0x3c63(%rip), %rsi      # 0x1b7ab
movb $0x0, %al
callq 0x3140
jmp 0x17b67
movq -0x8(%rbp), %rdi
movq -0x18(%rbp), %rdx
leaq 0x3c53(%rip), %rsi      # 0x1b7b3
movb $0x0, %al
callq 0x3140
cmpw $0x0, 0x10(%rbp)
je 0x17b80
movq -0x8(%rbp), %rdi
leaq 0x3b5a(%rip), %rsi      # 0x1b6d3
movb $0x0, %al
callq 0x3140
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/theovosse[P]llgen/lang.c
// Function: goLanguageStateTransition
static void goLanguageStateTransition(FILE* f, int ch, long int destination, const char* accept) {
    fprintf(f, "{");
    if (ch == -1) {
        fprintf(f, "-1");
    } else if (ch == '\'' || ch == '\\') {
        fprintf(f, "'\\%c'", ch);
    } else if (' ' <= ch && ch <= '~') {
        fprintf(f, "'%c'", ch);
    } else {
        fprintf(f, "'\\x%02x'", ch);
    }
    if (strcmp(accept, "nil") == 0) {
        fprintf(f, ", %ld, %s},\n", destination, accept);
    } else {
        fprintf(f, ", %ld, &%s},\n", destination, accept);
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movq %rdx, -0x18(%rbp)
movq %rcx, -0x20(%rbp)
movq -0x8(%rbp), %rdi
leaq 0x39f1(%rip), %rsi      # 0x1b6d3
movb $0x0, %al
callq 0x3140
cmpl $-0x1, -0xc(%rbp)
jne 0x17d03
movq -0x8(%rbp), %rdi
leaq 0x3933(%rip), %rsi      # 0x1b62d
movb $0x0, %al
callq 0x3140
jmp 0x17d66
cmpl $0x27, -0xc(%rbp)
je 0x17d0f
cmpl $0x5c, -0xc(%rbp)
jne 0x17d26
movq -0x8(%rbp), %rdi
movl -0xc(%rbp), %edx
leaq 0x3913(%rip), %rsi      # 0x1b630
movb $0x0, %al
callq 0x3140
jmp 0x17d64
movl $0x20, %eax
cmpl -0xc(%rbp), %eax
jg 0x17d4d
cmpl $0x7e, -0xc(%rbp)
jg 0x17d4d
movq -0x8(%rbp), %rdi
movl -0xc(%rbp), %edx
leaq 0x38f2(%rip), %rsi      # 0x1b636
movb $0x0, %al
callq 0x3140
jmp 0x17d62
movq -0x8(%rbp), %rdi
movl -0xc(%rbp), %edx
leaq 0x38e0(%rip), %rsi      # 0x1b63b
movb $0x0, %al
callq 0x3140
jmp 0x17d64
jmp 0x17d66
movq -0x20(%rbp), %rdi
leaq 0x3837(%rip), %rsi      # 0x1b5a8
callq 0x3220
cmpl $0x0, %eax
jne 0x17d97
movq -0x8(%rbp), %rdi
movq -0x18(%rbp), %rdx
movq -0x20(%rbp), %rcx
leaq 0x3a4c(%rip), %rsi      # 0x1b7da
movb $0x0, %al
callq 0x3140
jmp 0x17db1
movq -0x8(%rbp), %rdi
movq -0x18(%rbp), %rdx
movq -0x20(%rbp), %rcx
leaq 0x3a3d(%rip), %rsi      # 0x1b7e7
movb $0x0, %al
callq 0x3140
addq $0x20, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/theovosse[P]llgen/lang.c
// Function: goLanguageParameterDeclarationName
static void goLanguageParameterDeclarationName(FILE* f, const char* str, int nrSpaces) {
    if (nrFunctionParameters > 0) {
        fprintf(f, ",");
    }
    spaces(f, nrSpaces, nrFunctionParameters > 0? 1: 0);
    fputs(str, f);
    nrFunctionParameters++;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl %edx, -0x14(%rbp)
cmpl $0x0, 0xb0a6(%rip)      # 0x22f80
jle 0x17eee
movq -0x8(%rbp), %rdi
leaq 0x377c(%rip), %rsi      # 0x1b663
movb $0x0, %al
callq 0x3140
movq -0x8(%rbp), %rdi
movl -0x14(%rbp), %esi
movl 0xb085(%rip), %ecx      # 0x22f80
xorl %edx, %edx
movl $0x1, %eax
cmpl $0x0, %ecx
cmovgl %eax, %edx
callq 0x18a00
movq -0x10(%rbp), %rdi
movq -0x8(%rbp), %rsi
callq 0x3100
movl 0xb060(%rip), %eax      # 0x22f80
addl $0x1, %eax
movl %eax, 0xb057(%rip)      # 0x22f80
addq $0x20, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/theovosse[P]llgen/lang.c
// Function: goLanguageStartFunctionCall
static void goLanguageStartFunctionCall(FILE* f, const char*functionName, const char* returnType, const char* assignTo) {
    if (returnType != NULL && assignTo != NULL) {
        fprintf(f, "var %s %s = ", assignTo, returnType);
    } else if (assignTo != NULL) {
        fprintf(f, "%s = ", returnType);
    }
    fprintf(f, "%s(", functionName);
    nrFunctionParameters = 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq %rcx, -0x20(%rbp)
cmpq $0x0, -0x18(%rbp)
je 0x18012
cmpq $0x0, -0x20(%rbp)
je 0x18012
movq -0x8(%rbp), %rdi
movq -0x20(%rbp), %rdx
movq -0x18(%rbp), %rcx
leaq 0x37f9(%rip), %rsi      # 0x1b802
movb $0x0, %al
callq 0x3140
jmp 0x18031
cmpq $0x0, -0x20(%rbp)
je 0x1802f
movq -0x8(%rbp), %rdi
movq -0x18(%rbp), %rdx
leaq 0x3758(%rip), %rsi      # 0x1b780
movb $0x0, %al
callq 0x3140
jmp 0x18031
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rdx
leaq 0x37be(%rip), %rsi      # 0x1b7fe
movb $0x0, %al
callq 0x3140
movl $0x0, 0xaf2f(%rip)      # 0x22f80
addq $0x20, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/theovosse[P]llgen/lang.c
// Function: goLanguageAssignLastSymbolTo
static void goLanguageAssignLastSymbolTo(FILE* f, int indent, Name name, Boolean noDecl) {
    doIndent(indent);
    if (noDecl) {
        fprintf(f, "%s = lastSymbol;", name->name);
    } else {
        fprintf(f, "var %s string = lastSymbol;", name->name);
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movw %cx, %ax
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movq %rdx, -0x18(%rbp)
movw %ax, -0x1a(%rbp)
movl -0xc(%rbp), %edi
callq 0x4000
cmpw $0x0, -0x1a(%rbp)
je 0x18184
movq -0x8(%rbp), %rdi
movq -0x18(%rbp), %rax
movq (%rax), %rdx
leaq 0x35b9(%rip), %rsi      # 0x1b734
movb $0x0, %al
callq 0x3140
jmp 0x1819d
movq -0x8(%rbp), %rdi
movq -0x18(%rbp), %rax
movq (%rax), %rdx
leaq 0x3679(%rip), %rsi      # 0x1b80f
movb $0x0, %al
callq 0x3140
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/theovosse[P]llgen/lang.c
// Function: rustLanguageArrayDeclaration
static void rustLanguageArrayDeclaration(FILE* f, const char* scope, const char* type, const char* name, long int suffix, int size, Boolean init) {
    fprintf(f, "const %s", name);
    if (suffix >= 0) {
        fprintf(f, "%ld", suffix);
    }
    if (size >= 0) {
        fprintf(f, ": [%s; %d]", type, size);
    } else {
        fprintf(f, ": [%s]", type);
    }
    if (init) {
        fprintf(f, " = [");
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movw 0x10(%rbp), %ax
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq %rcx, -0x20(%rbp)
movq %r8, -0x28(%rbp)
movl %r9d, -0x2c(%rbp)
movq -0x8(%rbp), %rdi
movq -0x20(%rbp), %rdx
leaq 0x3598(%rip), %rsi      # 0x1b82b
movb $0x0, %al
callq 0x3140
cmpq $0x0, -0x28(%rbp)
jl 0x182b7
movq -0x8(%rbp), %rdi
movq -0x28(%rbp), %rdx
leaq 0x140f(%rip), %rsi      # 0x196bf
movb $0x0, %al
callq 0x3140
cmpl $0x0, -0x2c(%rbp)
jl 0x182d8
movq -0x8(%rbp), %rdi
movq -0x18(%rbp), %rdx
movl -0x2c(%rbp), %ecx
leaq 0x3565(%rip), %rsi      # 0x1b834
movb $0x0, %al
callq 0x3140
jmp 0x182ee
movq -0x8(%rbp), %rdi
movq -0x18(%rbp), %rdx
leaq 0x3558(%rip), %rsi      # 0x1b83f
movb $0x0, %al
callq 0x3140
cmpw $0x0, 0x10(%rbp)
je 0x18307
movq -0x8(%rbp), %rdi
leaq 0x3452(%rip), %rsi      # 0x1b752
movb $0x0, %al
callq 0x3140
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/theovosse[P]llgen/lang.c
// Function: rustLanguageStateTransition
static void rustLanguageStateTransition(FILE* f, int ch, long int destination, const char* accept) {
    fprintf(f, "DFAState {ch: ");
    if (ch == -1) {
        fputs("0xff", f);
    } else {
        fprintf(f, "0x%02x", (unsigned) ch);
        switch (ch) {
            case '/': case '!':
                fprintf(f, "/* %c */", ch);
                break;
            case '\t':
                fputs("/*\\t*/", f);
                break;
            case '\n':
                fputs("/*\\n*/", f);
                break;
            case '\r':
                fputs("/*\\r*/", f);
                break;
            default:
                if (' ' <= ch && ch < 127) {
                    fprintf(f, "/*%c*/", ch);
                }
        }
    }
    if (destination == -1) {
        fprintf(f, ", next: 0xffffffff");
    } else {
        fprintf(f, ", next: %ld", destination);
    }
    if (strcmp(accept, "nil") == 0) {
        fprintf(f, ", llTokenSet: None},\n");
    } else {
        fprintf(f, ", llTokenSet: Some(%s)},\n", accept);
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movq %rdx, -0x18(%rbp)
movq %rcx, -0x20(%rbp)
movq -0x8(%rbp), %rdi
leaq 0x33ea(%rip), %rsi      # 0x1b85c
movb $0x0, %al
callq 0x3140
cmpl $-0x1, -0xc(%rbp)
jne 0x18494
movq -0x8(%rbp), %rsi
leaq 0x33e1(%rip), %rdi      # 0x1b86b
callq 0x3100
jmp 0x18544
movq -0x8(%rbp), %rdi
movl -0xc(%rbp), %edx
leaq 0x33ce(%rip), %rsi      # 0x1b870
xorl %eax, %eax
callq 0x3140
movl -0xc(%rbp), %eax
addl $-0x9, %eax
movl %eax, %ecx
movq %rcx, -0x28(%rbp)
subl $0x26, %eax
ja 0x1851b
movq -0x28(%rbp), %rax
leaq 0x2f7b(%rip), %rcx      # 0x1b440
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
movq -0x8(%rbp), %rdi
movl -0xc(%rbp), %edx
leaq 0x339b(%rip), %rsi      # 0x1b877
movb $0x0, %al
callq 0x3140
jmp 0x18542
movq -0x8(%rbp), %rsi
leaq 0x3390(%rip), %rdi      # 0x1b880
callq 0x3100
jmp 0x18542
movq -0x8(%rbp), %rsi
leaq 0x3385(%rip), %rdi      # 0x1b887
callq 0x3100
jmp 0x18542
movq -0x8(%rbp), %rsi
leaq 0x337a(%rip), %rdi      # 0x1b88e
callq 0x3100
jmp 0x18542
movl $0x20, %eax
cmpl -0xc(%rbp), %eax
jg 0x18540
cmpl $0x7f, -0xc(%rbp)
jge 0x18540
movq -0x8(%rbp), %rdi
movl -0xc(%rbp), %edx
leaq 0x335c(%rip), %rsi      # 0x1b895
movb $0x0, %al
callq 0x3140
jmp 0x18542
jmp 0x18544
cmpq $-0x1, -0x18(%rbp)
jne 0x1855f
movq -0x8(%rbp), %rdi
leaq 0x3346(%rip), %rsi      # 0x1b89c
movb $0x0, %al
callq 0x3140
jmp 0x18575
movq -0x8(%rbp), %rdi
movq -0x18(%rbp), %rdx
leaq 0x3341(%rip), %rsi      # 0x1b8af
movb $0x0, %al
callq 0x3140
movq -0x20(%rbp), %rdi
leaq 0x3028(%rip), %rsi      # 0x1b5a8
callq 0x3220
cmpl $0x0, %eax
jne 0x1859e
movq -0x8(%rbp), %rdi
leaq 0x3326(%rip), %rsi      # 0x1b8bb
movb $0x0, %al
callq 0x3140
jmp 0x185b4
movq -0x8(%rbp), %rdi
movq -0x20(%rbp), %rdx
leaq 0x3324(%rip), %rsi      # 0x1b8d1
movb $0x0, %al
callq 0x3140
addq $0x30, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/theovosse[P]llgen/lang.c
// Function: rustLanguageStartFunctionDeclaration
static void rustLanguageStartFunctionDeclaration(FILE* f, const char* functionName, const char* type) {
    if (globalIndent == 0) {
        fprintf(f, "    ");
        globalIndent = 1;
    }
    fprintf(f, "fn %s(&mut self", functionName);
    returnType = type;
    nrFunctionParameters = 1;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
leaq 0x86b5(%rip), %rax      # 0x20d40
cmpl $0x0, (%rax)
jne 0x186af
movq -0x8(%rbp), %rdi
leaq 0x302e(%rip), %rsi      # 0x1b6c9
movb $0x0, %al
callq 0x3140
leaq 0x8697(%rip), %rax      # 0x20d40
movl $0x1, (%rax)
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rdx
leaq 0x322d(%rip), %rsi      # 0x1b8eb
movb $0x0, %al
callq 0x3140
movq -0x18(%rbp), %rax
movq %rax, 0xa8c8(%rip)      # 0x22f98
movl $0x1, 0xa8a6(%rip)      # 0x22f80
addq $0x20, %rsp
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O0/theovosse[P]llgen/lang.c
// Function: rustLanguageParameterDeclarationName
static void rustLanguageParameterDeclarationName(FILE* f, const char* str, int nrSpaces) {
    if (nrFunctionParameters > 0) {
        fputc(',', f);
    }
    spaces(f, nrSpaces, nrFunctionParameters > 0? 1: 0);
    fputs(str, f);
    fputc(':', f);
    nrFunctionParameters++;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl %edx, -0x14(%rbp)
cmpl $0x0, 0xa886(%rip)      # 0x22f80
jle 0x1870a
movq -0x8(%rbp), %rsi
movl $0x2c, %edi
callq 0x3120
movq -0x8(%rbp), %rdi
movl -0x14(%rbp), %esi
movl 0xa869(%rip), %ecx      # 0x22f80
xorl %edx, %edx
movl $0x1, %eax
cmpl $0x0, %ecx
cmovgl %eax, %edx
callq 0x18a00
movq -0x10(%rbp), %rdi
movq -0x8(%rbp), %rsi
callq 0x3100
movq -0x8(%rbp), %rsi
movl $0x3a, %edi
callq 0x3120
movl 0xa836(%rip), %eax      # 0x22f80
addl $0x1, %eax
movl %eax, 0xa82d(%rip)      # 0x22f80
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/theovosse[P]llgen/lang.c
// Function: rustLanguageAssignLastSymbolTo
static void rustLanguageAssignLastSymbolTo(FILE* f, int indent, Name name, Boolean noDecl) {
    doIndent(indent);
    if (noDecl) {
        fprintf(f, "%s = lastSymbol;", name->name);
    } else {
        fprintf(f, "let %s: string = lastSymbol;", name->name);
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movw %cx, %ax
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movq %rdx, -0x18(%rbp)
movw %ax, -0x1a(%rbp)
movl -0xc(%rbp), %edi
callq 0x4000
cmpw $0x0, -0x1a(%rbp)
je 0x189b4
movq -0x8(%rbp), %rdi
movq -0x18(%rbp), %rax
movq (%rax), %rdx
leaq 0x2d89(%rip), %rsi      # 0x1b734
movb $0x0, %al
callq 0x3140
jmp 0x189cd
movq -0x8(%rbp), %rdi
movq -0x18(%rbp), %rax
movq (%rax), %rdx
leaq 0x2dc0(%rip), %rsi      # 0x1b786
movb $0x0, %al
callq 0x3140
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/theovosse[P]llgen/lang.c
// Function: spaces
static void spaces(FILE* f, int nrSpaces, int minNrSpaces) {
    if (nrSpaces < minNrSpaces) {
        nrSpaces = minNrSpaces;
    }
    for (int i = 0; i < nrSpaces; i++) {
        fputc(' ', f);
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movl %edx, -0x10(%rbp)
movl -0xc(%rbp), %eax
cmpl -0x10(%rbp), %eax
jge 0x18a20
movl -0x10(%rbp), %eax
movl %eax, -0xc(%rbp)
movl $0x0, -0x14(%rbp)
movl -0x14(%rbp), %eax
cmpl -0xc(%rbp), %eax
jge 0x18a48
movq -0x8(%rbp), %rsi
movl $0x20, %edi
callq 0x3120
movl -0x14(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x14(%rbp)
jmp 0x18a27
addq $0x20, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/openshmem-org[P]openshmem-examples/c/bar.c
// Function: main
int
main()
{
    int me, npes;
    int i;

    for (i = 0; i < SHMEM_BARRIER_SYNC_SIZE; i += 1) {
        pSync[i] = SHMEM_SYNC_VALUE;
    }

    shmem_init();
    me = shmem_my_pe();
    npes = shmem_n_pes();

    if (me == 0) {
        shmem_int_p(&x, 4, 1);
    }

    shmem_barrier(0, 0, npes, pSync);

    printf("%d: x = %d\n", me, x);

    shmem_finalize();

    return 0;
}

// Assembly:
subq $0x18, %rsp
movl $0x0, 0x14(%rsp)
movl $0x0, 0x8(%rsp)
cmpl $0x1, 0x8(%rsp)
jge 0x11dc
movslq 0x8(%rsp), %rcx
leaq 0x2ea9(%rip), %rax      # 0x4070
movq $-0x1, (%rax,%rcx,8)
movl 0x8(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x8(%rsp)
jmp 0x11b4
callq 0x1090
callq 0x1080
movl %eax, 0x10(%rsp)
callq 0x1060
movl %eax, 0xc(%rsp)
cmpl $0x0, 0x10(%rsp)
jne 0x1210
leaq 0x2e5f(%rip), %rdi      # 0x4060
movl $0x4, %esi
movl $0x1, %edx
callq 0x1040
movl 0xc(%rsp), %edx
xorl %esi, %esi
leaq 0x2e53(%rip), %rcx      # 0x4070
movl %esi, %edi
callq 0x1050
movl 0x10(%rsp), %esi
movl 0x2e32(%rip), %edx      # 0x4060
leaq 0xdcf(%rip), %rdi       # 0x2004
movb $0x0, %al
callq 0x1030
callq 0x1070
xorl %eax, %eax
addq $0x18, %rsp
retq
// File: /workspace/github_c_makefile_star2_O0/mabdi[P]bunney/bunny-exec.c
// Function: setup_signals
static void setup_signals(void) {
  struct itimerval it;

  keepalive_cont = 0;
  timeout_done   = 0;

  signal(SIGALRM,timeout);
  it.it_interval.tv_sec = 0;
  it.it_interval.tv_usec = 10000;
  it.it_value.tv_sec = 0;
  it.it_value.tv_usec = 10000;
  setitimer(ITIMER_REAL,&it,0);

  /* At least pretend to be nice. */
  signal(SIGTERM,handle_kill);
  signal(SIGINT,handle_kill);
  signal(SIGHUP,handle_kill);  

  signal(SIGUSR1,handle_input_cont);

}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movb $0x0, 0x4991(%rip)      # 0x6190
movb $0x0, 0x498b(%rip)      # 0x6191
movl $0xe, %edi
leaq 0x37e(%rip), %rsi       # 0x1b90
callq 0x1110
movq $0x0, -0x20(%rbp)
movq $0x2710, -0x18(%rbp)    # imm = 0x2710
movq $0x0, -0x10(%rbp)
movq $0x2710, -0x8(%rbp)     # imm = 0x2710
xorl %edi, %edi
leaq -0x20(%rbp), %rsi
xorl %eax, %eax
movl %eax, %edx
callq 0x11d0
movl $0xf, %edi
leaq 0x43e(%rip), %rsi       # 0x1c90
callq 0x1110
movl $0x2, %edi
leaq 0x42d(%rip), %rsi       # 0x1c90
callq 0x1110
movl $0x1, %edi
leaq 0x41c(%rip), %rsi       # 0x1c90
callq 0x1110
movl $0xa, %edi
leaq 0x4ab(%rip), %rsi       # 0x1d30
callq 0x1110
addq $0x20, %rsp
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O0/mabdi[P]bunney/bunny-exec.c
// Function: disable_timers
static void disable_timers(void) {
  struct itimerval it;

  signal(SIGALRM,SIG_IGN);
  it.it_interval.tv_sec = 0;
  it.it_interval.tv_usec = 0;
  it.it_value.tv_sec = 0;
  it.it_value.tv_usec = 0;
  setitimer(ITIMER_REAL,&it,0);

}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movl $0xe, %edi
movl $0x1, %esi
callq 0x1110
movq $0x0, -0x20(%rbp)
movq $0x0, -0x18(%rbp)
movq $0x0, -0x10(%rbp)
movq $0x0, -0x8(%rbp)
xorl %edi, %edi
leaq -0x20(%rbp), %rsi
xorl %eax, %eax
movl %eax, %edx
callq 0x11d0
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax)