LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O0/simh[P]simtools/crossassemblers/macro1/macro1.c
// Function: addsym
void
addsym(WORD32 sym, WORD32 val)
{
    char name[4];

    sym = permute(sym);
    name[0] = fiodec_to_ascii[(sym >>12) & 077];
    name[1] = fiodec_to_ascii[(sym >> 6) & 077];
    name[2] = fiodec_to_ascii[sym & 077];
    name[3] = '\0';
    defineSymbol( name, val, LABEL, 0);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movl %edi, -0x4(%rbp)
movl %esi, -0x8(%rbp)
movl -0x4(%rbp), %edi
callq 0x37d0
movl %eax, -0x4(%rbp)
movl -0x4(%rbp), %eax
sarl $0xc, %eax
andl $0x3f, %eax
movslq %eax, %rcx
leaq 0x8494(%rip), %rax      # 0xbce0
movb (%rax,%rcx), %al
movb %al, -0xc(%rbp)
movl -0x4(%rbp), %eax
sarl $0x6, %eax
andl $0x3f, %eax
movslq %eax, %rcx
leaq 0x847b(%rip), %rax      # 0xbce0
movb (%rax,%rcx), %al
movb %al, -0xb(%rbp)
movl -0x4(%rbp), %eax
andl $0x3f, %eax
movslq %eax, %rcx
leaq 0x8465(%rip), %rax      # 0xbce0
movb (%rax,%rcx), %al
movb %al, -0xa(%rbp)
movb $0x0, -0x9(%rbp)
leaq -0xc(%rbp), %rdi
movl -0x8(%rbp), %esi
movl $0x9, %edx
xorl %ecx, %ecx
callq 0x2740
addq $0x10, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/simh[P]simtools/crossassemblers/macro1/macro1.c
// Function: getExprs
WORD32 getExprs()
{
    SYM_T sym;

    sym = getExpr();
    if (sym.type == PSEUDO)
	errorMessage( &value_required, lexstart ); /* XXX wrong pointer? */

    return sym.val & 0777777;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
leaq -0x30(%rbp), %rdi
callq 0x5020
movq -0x30(%rbp), %rax
movq %rax, -0x18(%rbp)
movq -0x28(%rbp), %rax
movq %rax, -0x10(%rbp)
movq -0x20(%rbp), %rax
movq %rax, -0x8(%rbp)
cmpl $0x43, -0x18(%rbp)
jne 0x4031
movl 0xa08b(%rip), %esi      # 0xe0b0
leaq 0x7b24(%rip), %rdi      # 0xbb50
callq 0x56c0
movl -0xc(%rbp), %eax
andl $0x3ffff, %eax          # imm = 0x3FFFF
addq $0x30, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/simh[P]simtools/crossassemblers/macro1/macro1.c
// Function: lexemeToName
char *lexemeToName( char *name, WORD32 from, WORD32 term )
{
    int to;

    to = 0;
    while( from < term && to < SYMLEN-1) {
	char c = line[from++];
	if (ISOVERBAR(c))
	    continue;
	name[to++] = c;
    }
    name[to] = '\0';

    return( name );
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movl %edx, -0x10(%rbp)
movl $0x0, -0x14(%rbp)
movl -0xc(%rbp), %ecx
xorl %eax, %eax
cmpl -0x10(%rbp), %ecx
movb %al, -0x16(%rbp)
jge 0x4bac
cmpl $0x6, -0x14(%rbp)
setl %al
movb %al, -0x16(%rbp)
movb -0x16(%rbp), %al
testb $0x1, %al
jne 0x4bb5
jmp 0x4bfe
movl -0xc(%rbp), %eax
movl %eax, %ecx
addl $0x1, %ecx
movl %ecx, -0xc(%rbp)
movslq %eax, %rcx
leaq 0x9486(%rip), %rax      # 0xe050
movb (%rax,%rcx), %al
movb %al, -0x15(%rbp)
movsbl -0x15(%rbp), %eax
cmpl $0x5c, %eax
je 0x4be2
movsbl -0x15(%rbp), %eax
cmpl $0x7e, %eax
jne 0x4be4
jmp 0x4b95
movb -0x15(%rbp), %dl
movq -0x8(%rbp), %rax
movl -0x14(%rbp), %ecx
movl %ecx, %esi
addl $0x1, %esi
movl %esi, -0x14(%rbp)
movslq %ecx, %rcx
movb %dl, (%rax,%rcx)
jmp 0x4b95
movq -0x8(%rbp), %rax
movslq -0x14(%rbp), %rcx
movb $0x0, (%rax,%rcx)
movq -0x8(%rbp), %rax
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O0/simh[P]simtools/crossassemblers/macro1/macro1.c
// Function: evalSymbol
SYM_T *evalSymbol()
{
    char   name[SYMLEN];
    SYM_T *sym;

    sym = lookup( lexemeToName( name, lexstart, lexterm ), UNDEFINED);

    sym->xref_count++;			/* Count the number of references to symbol. */

    if( xref && pass == 2 && sym->xref_index >= 0)
    {
	/* Put the line number in the concordance table. */
	xreftab[sym->xref_index + sym->xref_count] = lineno;
    }

    return( sym );
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
leaq -0x7(%rbp), %rdi
movl 0x932e(%rip), %esi      # 0xe0b0
movl 0x93b4(%rip), %edx      # 0xe13c
callq 0x4b80
movq %rax, %rdi
xorl %esi, %esi
callq 0x4850
movq %rax, -0x10(%rbp)
movq -0x10(%rbp), %rax
movl 0x14(%rax), %ecx
addl $0x1, %ecx
movl %ecx, 0x14(%rax)
movzbl 0x6fba(%rip), %eax      # 0xbd69
cmpl $0x0, %eax
je 0x4de8
cmpl $0x2, 0x6fc5(%rip)      # 0xbd80
jne 0x4de8
movq -0x10(%rbp), %rax
cmpl $0x0, 0x10(%rax)
jl 0x4de8
movl 0x938f(%rip), %edx      # 0xe15c
movq 0x70e4(%rip), %rax      # 0xbeb8
movq -0x10(%rbp), %rcx
movl 0x10(%rcx), %ecx
movq -0x10(%rbp), %rsi
addl 0x14(%rsi), %ecx
movslq %ecx, %rcx
movl %edx, (%rax,%rcx,4)
movq -0x10(%rbp), %rax
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/simh[P]simtools/crossassemblers/macro1/macro1.c
// Function: eval
SYM_T eval() {
    SYM_T sym;

    switch (line[lexstart]) {
    case '-':				/* unary - */
	next(1);
	sym = eval2();			/* skip op */
	sym.val ^= 0777777;
	break;
    case '+':				/* unary + */
	next(1);			/* skip op */
	/* fall */
    default:
	sym = eval2();
    }
    return sym;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movq %rdi, -0x48(%rbp)
movq %rdi, -0x40(%rbp)
movslq 0x8949(%rip), %rax      # 0xe0b0
leaq 0x88e2(%rip), %rcx      # 0xe050
movsbl (%rax,%rcx), %eax
movl %eax, -0x34(%rbp)
subl $0x2b, %eax
je 0x57c2
jmp 0x577c
movl -0x34(%rbp), %eax
subl $0x2d, %eax
jne 0x57cc
jmp 0x5786
movl $0x1, %edi
callq 0x3e10
leaq -0x18(%rbp), %rdi
callq 0x5d00
movq -0x48(%rbp), %rax
movq -0x18(%rbp), %rcx
movq %rcx, (%rax)
movq -0x10(%rbp), %rcx
movq %rcx, 0x8(%rax)
movq -0x8(%rbp), %rcx
movq %rcx, 0x10(%rax)
movl 0xc(%rax), %ecx
xorl $0x3ffff, %ecx          # imm = 0x3FFFF
movl %ecx, 0xc(%rax)
jmp 0x57f0
movl $0x1, %edi
callq 0x3e10
leaq -0x30(%rbp), %rdi
callq 0x5d00
movq -0x48(%rbp), %rax
movq -0x30(%rbp), %rcx
movq %rcx, (%rax)
movq -0x28(%rbp), %rcx
movq %rcx, 0x8(%rax)
movq -0x20(%rbp), %rcx
movq %rcx, 0x10(%rax)
movq -0x40(%rbp), %rax
addq $0x50, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/simh[P]simtools/crossassemblers/macro1/macro1.c
// Function: moveToEndOfLine
void moveToEndOfLine()
{
    while( !ISEND( line[cc] )) cc++;	/* XXX wrong! will stop on a tab! */
    lexstart = cc;
    lexterm = cc;
    lexstartprev = lexstart;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
jmp 0x5806
movslq 0x88ab(%rip), %rcx      # 0xe0b8
leaq 0x883c(%rip), %rax      # 0xe050
movsbl (%rax,%rcx), %ecx
movb $0x1, %al
cmpl $0x0, %ecx
movb %al, -0x1(%rbp)
je 0x5859
movslq 0x888f(%rip), %rcx      # 0xe0b8
leaq 0x8820(%rip), %rax      # 0xe050
movsbl (%rax,%rcx), %ecx
movb $0x1, %al
cmpl $0xa, %ecx
movb %al, -0x1(%rbp)
je 0x5859
movslq 0x8873(%rip), %rcx      # 0xe0b8
leaq 0x8804(%rip), %rax      # 0xe050
movsbl (%rax,%rcx), %eax
cmpl $0x9, %eax
sete %al
movb %al, -0x1(%rbp)
movb -0x1(%rbp), %al
xorb $-0x1, %al
testb $0x1, %al
jne 0x5864
jmp 0x5875
movl 0x884e(%rip), %eax      # 0xe0b8
addl $0x1, %eax
movl %eax, 0x8845(%rip)      # 0xe0b8
jmp 0x5806
movl 0x883d(%rip), %eax      # 0xe0b8
movl %eax, 0x882f(%rip)      # 0xe0b0
movl 0x8831(%rip), %eax      # 0xe0b8
movl %eax, 0x88af(%rip)      # 0xe13c
movl 0x881d(%rip), %eax      # 0xe0b0
movl %eax, 0x88ab(%rip)      # 0xe144
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/simh[P]simtools/crossassemblers/macro1/macro1.c
// Function: flex
WORD32 flex()
{
    WORD32 w;
    int shift;
    int ccase;

    if (line[lexstart] == ' ')		/* always? */
	next(0);

    /* original version appears to take next 3 characters,
     * REGARDLESS of what they are (tab, newline, space?)!
     */
    w = 0;
    ccase = LC;				/* current case */
    for (shift = 12; shift >= 0; shift -= 6) {
	unsigned char c;
	if( lexstart >= maxcc )
	    break;

	c = line[lexstart];
	if (c == '\t' || c == '\n') {
	    if (ccase == LC)
		break;
	    c = CONCISE_LC;			/* shift down first */
	}
	else {
	    if (c > 0177) {		/* non-ascii */
		errorMessage( &illegal_character, lexstart );
		c = 0;
	    }

	    c = ascii_to_fiodec[c&0177];
	    if (c == BAD) {
		errorMessage( &illegal_character, lexstart );
		c = 0;
	    }

	    if (!(c & ccase)) {		/* char not in current case? */
		ccase ^= BC;		/* switch case */
		if (ccase == LC)
		    c = CONCISE_LC;	/* shift down */
		else
		    c = CONCISE_UC;	/* shift up */
	    }
	    else
		lexstart++;
	}
	w |= (c & CHARBITS) << shift;
    }
    /* error to get here w/ case == UC? nah. shift down could be next */
    return w;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movslq 0x8681(%rip), %rcx      # 0xe0b0
leaq 0x861a(%rip), %rax      # 0xe050
movsbl (%rax,%rcx), %eax
cmpl $0x20, %eax
jne 0x5a46
xorl %edi, %edi
callq 0x3e10
movl $0x0, -0x4(%rbp)
movl $0x80, -0xc(%rbp)
movl $0xc, -0x8(%rbp)
cmpl $0x0, -0x8(%rbp)
jl 0x5b67
movl 0x8645(%rip), %eax      # 0xe0b0
cmpl 0x86c3(%rip), %eax      # 0xe134
jl 0x5a78
jmp 0x5b67
movslq 0x8631(%rip), %rcx      # 0xe0b0
leaq 0x85ca(%rip), %rax      # 0xe050
movb (%rax,%rcx), %al
movb %al, -0xd(%rbp)
movzbl -0xd(%rbp), %eax
cmpl $0x9, %eax
je 0x5a9e
movzbl -0xd(%rbp), %eax
cmpl $0xa, %eax
jne 0x5ab5
cmpl $0x80, -0xc(%rbp)
jne 0x5aac
jmp 0x5b67
movb $0x3a, -0xd(%rbp)
jmp 0x5b47
movzbl -0xd(%rbp), %eax
cmpl $0x7f, %eax
jle 0x5ad4
movl 0x85ec(%rip), %esi      # 0xe0b0
leaq 0x5fc5(%rip), %rdi      # 0xba90
callq 0x56c0
movb $0x0, -0xd(%rbp)
movzbl -0xd(%rbp), %eax
andl $0x7f, %eax
movslq %eax, %rcx
leaq 0x617b(%rip), %rax      # 0xbc60
movb (%rax,%rcx), %al
movb %al, -0xd(%rbp)
movzbl -0xd(%rbp), %eax
cmpl $0xc, %eax
jne 0x5b0a
movl 0x85b6(%rip), %esi      # 0xe0b0
leaq 0x5f8f(%rip), %rdi      # 0xba90
callq 0x56c0
movb $0x0, -0xd(%rbp)
movzbl -0xd(%rbp), %eax
andl -0xc(%rbp), %eax
cmpl $0x0, %eax
jne 0x5b36
movl -0xc(%rbp), %eax
xorl $0xc0, %eax
movl %eax, -0xc(%rbp)
cmpl $0x80, -0xc(%rbp)
jne 0x5b30
movb $0x3a, -0xd(%rbp)
jmp 0x5b34
movb $0x3c, -0xd(%rbp)
jmp 0x5b45
movl 0x8574(%rip), %eax      # 0xe0b0
addl $0x1, %eax
movl %eax, 0x856b(%rip)      # 0xe0b0
jmp 0x5b47
movzbl -0xd(%rbp), %eax
andl $0x3f, %eax
movl -0x8(%rbp), %ecx
shll %cl, %eax
orl -0x4(%rbp), %eax
movl %eax, -0x4(%rbp)
movl -0x8(%rbp), %eax
subl $0x6, %eax
movl %eax, -0x8(%rbp)
jmp 0x5a5b
movl -0x4(%rbp), %eax
addq $0x10, %rsp
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O0/simh[P]simtools/crossassemblers/macro1/macro1.c
// Function: getChar
WORD32 getChar()
{
    unsigned char c, pos;

    if( cc >= maxcc )
	return 0;			/* XXX error? */
    pos = line[cc++];
    if (pos != 'l' && pos != 'm' && pos != 'r') {
	errorMessage( &illegal_character, lexstart );
	return 0;
    }

    if( cc >= maxcc )
	return 0;			/* XXX error? */

    c = line[cc++];
    if (c > 0177) {
	errorMessage( &illegal_character, lexstart );
	c = 0;
    }

    c = ascii_to_fiodec[c];
    if (c == BAD) {
	errorMessage( &illegal_character, lexstart );
	c = 0;
    }

    if (!(c & LC)) {			/* upper case only char? */
	c = CONCISE_UC;			/* take a shift up */
	cc--;				/* and leave char for next luser */
    }

    c &= CHARBITS;
    switch (pos) {
    case 'l': return c << 12;
    case 'm': return c << 6;
    case 'r': return c;
    }
    /* should not happen */
    return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movl 0x853a(%rip), %eax      # 0xe0b8
cmpl 0x85b0(%rip), %eax      # 0xe134
jl 0x5b92
movl $0x0, -0x4(%rbp)
jmp 0x5ceb
movl 0x8520(%rip), %eax      # 0xe0b8
movl %eax, %ecx
addl $0x1, %ecx
movl %ecx, 0x8515(%rip)      # 0xe0b8
movslq %eax, %rcx
leaq 0x84a3(%rip), %rax      # 0xe050
movb (%rax,%rcx), %al
movb %al, -0x6(%rbp)
movzbl -0x6(%rbp), %eax
cmpl $0x6c, %eax
je 0x5bec
movzbl -0x6(%rbp), %eax
cmpl $0x6d, %eax
je 0x5bec
movzbl -0x6(%rbp), %eax
cmpl $0x72, %eax
je 0x5bec
movl 0x84dc(%rip), %esi      # 0xe0b0
leaq 0x5eb5(%rip), %rdi      # 0xba90
callq 0x56c0
movl $0x0, -0x4(%rbp)
jmp 0x5ceb
movl 0x84c6(%rip), %eax      # 0xe0b8
cmpl 0x853c(%rip), %eax      # 0xe134
jl 0x5c06
movl $0x0, -0x4(%rbp)
jmp 0x5ceb
movl 0x84ac(%rip), %eax      # 0xe0b8
movl %eax, %ecx
addl $0x1, %ecx
movl %ecx, 0x84a1(%rip)      # 0xe0b8
movslq %eax, %rcx
leaq 0x842f(%rip), %rax      # 0xe050
movb (%rax,%rcx), %al
movb %al, -0x5(%rbp)
movzbl -0x5(%rbp), %eax
cmpl $0x7f, %eax
jle 0x5c46
movl 0x847a(%rip), %esi      # 0xe0b0
leaq 0x5e53(%rip), %rdi      # 0xba90
callq 0x56c0
movb $0x0, -0x5(%rbp)
movzbl -0x5(%rbp), %eax
movl %eax, %ecx
leaq 0x600d(%rip), %rax      # 0xbc60
movb (%rax,%rcx), %al
movb %al, -0x5(%rbp)
movzbl -0x5(%rbp), %eax
cmpl $0xc, %eax
jne 0x5c78
movl 0x8448(%rip), %esi      # 0xe0b0
leaq 0x5e21(%rip), %rdi      # 0xba90
callq 0x56c0
movb $0x0, -0x5(%rbp)
movzbl -0x5(%rbp), %eax
andl $0x80, %eax
cmpl $0x0, %eax
jne 0x5c99
movb $0x3c, -0x5(%rbp)
movl 0x8428(%rip), %eax      # 0xe0b8
addl $-0x1, %eax
movl %eax, 0x841f(%rip)      # 0xe0b8
movb -0x5(%rbp), %al
andb $0x3f, %al
movb %al, -0x5(%rbp)
movzbl -0x6(%rbp), %eax
movl %eax, -0xc(%rbp)
subl $0x6c, %eax
je 0x5cc3
jmp 0x5caf
movl -0xc(%rbp), %eax
subl $0x6d, %eax
je 0x5ccf
jmp 0x5cb9
movl -0xc(%rbp), %eax
subl $0x72, %eax
je 0x5cdb
jmp 0x5ce4
movzbl -0x5(%rbp), %eax
shll $0xc, %eax
movl %eax, -0x4(%rbp)
jmp 0x5ceb
movzbl -0x5(%rbp), %eax
shll $0x6, %eax
movl %eax, -0x4(%rbp)
jmp 0x5ceb
movzbl -0x5(%rbp), %eax
movl %eax, -0x4(%rbp)
jmp 0x5ceb
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/simh[P]simtools/crossassemblers/macro1/macro1.c
// Function: literal
WORD32
literal( WORD32 value )
{
    int i;

    if (nconst >= MAX_CONSTANTS) {
	fprintf(stderr, "too many 'constants'; increase MAX_CONSTANTS\n");
	exit(1);
    }

    if (pass == 1) {
	if (++lit_count[nconst] == MAX_LITERALS) {
	    fprintf(stderr, "too many literals; increase MAX_LITERALS\n");
	    exit(1);
	}
	return lit_count[nconst];
    }

#if 1
    /*
     * pool constants; makes for a shorter tape
     * (but "middle" constants blocks can't shrink)
     */
    for (i = 0; i < nlit; i++)
	if (litter[i] == value)
	    return lit_loc[nconst] + i;
#endif

    /* paranoia */
    if (nlit == MAX_LITERALS) {
	fprintf(stderr, "too many literals; increase MAX_LITERALS\n");
	exit(1);
    }

    /* not found, save it */
    litter[nlit] = value;

    /* use base for this block, determined on pass1 */
    return lit_loc[nconst] + nlit++;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movl %edi, -0x8(%rbp)
cmpl $0xa, 0x7f4a(%rip)      # 0xe14c
jl 0x6226
movq 0x4ded(%rip), %rax      # 0xaff8
movq (%rax), %rdi
leaq 0x26a6(%rip), %rsi      # 0x88bb
movb $0x0, %al
callq 0x2110
movl $0x1, %edi
callq 0x2190
cmpl $0x1, 0x5b53(%rip)      # 0xbd80
jne 0x628f
movslq 0x7f16(%rip), %rdx      # 0xe14c
leaq 0x8183(%rip), %rax      # 0xe3c0
movl (%rax,%rdx,4), %eax
addl $0x1, %eax
leaq 0x8176(%rip), %rcx      # 0xe3c0
movl %eax, (%rcx,%rdx,4)
cmpl $0x3e8, %eax            # imm = 0x3E8
jne 0x6276
movq 0x4d9d(%rip), %rax      # 0xaff8
movq (%rax), %rdi
leaq 0x2684(%rip), %rsi      # 0x88e9
movb $0x0, %al
callq 0x2110
movl $0x1, %edi
callq 0x2190
movslq 0x7ecf(%rip), %rcx      # 0xe14c
leaq 0x813c(%rip), %rax      # 0xe3c0
movl (%rax,%rcx,4), %eax
movl %eax, -0x4(%rbp)
jmp 0x6343
movl $0x0, -0xc(%rbp)
movl -0xc(%rbp), %eax
cmpl 0x5c11(%rip), %eax      # 0xbeb0
jge 0x62da
movslq -0xc(%rbp), %rcx
leaq 0x8144(%rip), %rax      # 0xe3f0
movl (%rax,%rcx,4), %eax
cmpl -0x8(%rbp), %eax
jne 0x62cd
movslq 0x7e91(%rip), %rcx      # 0xe14c
leaq 0x90ce(%rip), %rax      # 0xf390
movl (%rax,%rcx,4), %eax
addl -0xc(%rbp), %eax
movl %eax, -0x4(%rbp)
jmp 0x6343
jmp 0x62cf
movl -0xc(%rbp), %eax
addl $0x1, %eax
movl %eax, -0xc(%rbp)
jmp 0x6296
cmpl $0x3e8, 0x5bcc(%rip)    # imm = 0x3E8
jne 0x6308
movq 0x4d0b(%rip), %rax      # 0xaff8
movq (%rax), %rdi
leaq 0x25f2(%rip), %rsi      # 0x88e9
movb $0x0, %al
callq 0x2110
movl $0x1, %edi
callq 0x2190
movl -0x8(%rbp), %edx
movslq 0x5b9e(%rip), %rcx      # 0xbeb0
leaq 0x80d7(%rip), %rax      # 0xe3f0
movl %edx, (%rax,%rcx,4)
movslq 0x7e29(%rip), %rcx      # 0xe14c
leaq 0x9066(%rip), %rax      # 0xf390
movl (%rax,%rcx,4), %eax
movl 0x5b7d(%rip), %ecx      # 0xbeb0
movl %ecx, %edx
addl $0x1, %edx
movl %edx, 0x5b72(%rip)      # 0xbeb0
addl %ecx, %eax
movl %eax, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x10, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/simh[P]simtools/crossassemblers/macro1/macro1.c
// Function: punchLocObject
void punchLocObject( WORD32 loc, WORD32 val )
{
    if (!rim_mode) {
	if ((loc & LOADERBUFMASK) == 0 || /* full/force alignment */
	    loaderbufcount > 0 &&
	    loc != loaderbufstart + loaderbufcount) /* disjoint */
	    flushLoader();
	if (loaderbufcount == 0)
	    loaderbufstart = loc;
	loaderbuf[loaderbufcount++] = val;
    }
    else
	punchLocObjectRIM( loc, val );
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movl %edi, -0x4(%rbp)
movl %esi, -0x8(%rbp)
cmpb $0x0, 0x569d(%rip)      # 0xbd62
jne 0x6728
movl -0x4(%rbp), %eax
andl $0x3f, %eax
cmpl $0x0, %eax
je 0x66ee
cmpl $0x0, 0x7bd7(%rip)      # 0xe2b0
jle 0x66f3
movl -0x4(%rbp), %eax
movl 0x7bd0(%rip), %ecx      # 0xe2b4
addl 0x7bc6(%rip), %ecx      # 0xe2b0
cmpl %ecx, %eax
je 0x66f3
callq 0x6770
cmpl $0x0, 0x7bb6(%rip)      # 0xe2b0
jne 0x6705
movl -0x4(%rbp), %eax
movl %eax, 0x7baf(%rip)      # 0xe2b4
movl -0x8(%rbp), %edx
movl 0x7ba2(%rip), %eax      # 0xe2b0
movl %eax, %ecx
addl $0x1, %ecx
movl %ecx, 0x7b97(%rip)      # 0xe2b0
movslq %eax, %rcx
leaq 0x7b9d(%rip), %rax      # 0xe2c0
movl %edx, (%rax,%rcx,4)
jmp 0x6733
movl -0x4(%rbp), %edi
movl -0x8(%rbp), %esi
callq 0x6740
addq $0x10, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/simh[P]simtools/crossassemblers/macro1/macro1.c
// Function: flushLoader
void
flushLoader() {
    WORD32 sum;
    int i;

    if (loaderbufcount == 0)
	return;

    sum = 0;
    PW( DIO | loaderbufstart );
    PW( DIO | loaderbufstart + loaderbufcount );
    for (i = 0; i < loaderbufcount; i++)
	PW( loaderbuf[i] );

    /* roll over all the overflows at once */
    if (sum & ~0777777)
	sum = (sum & 0777777) + (sum >> 18);
    if (sum & 01000000)			/* one more time */
	sum++;
    PW( sum );

    punchLeader(5);
    loaderbufcount = 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
cmpl $0x0, 0x7b31(%rip)      # 0xe2b0
jne 0x6786
jmp 0x6871
movl $0x0, -0x4(%rbp)
movl 0x7b21(%rip), %eax      # 0xe2b4
orl $0x1a000, %eax          # imm = 0x1A000
movl %eax, -0xc(%rbp)
movl -0xc(%rbp), %eax
addl -0x4(%rbp), %eax
movl %eax, -0x4(%rbp)
movl -0xc(%rbp), %edi
callq 0x6660
movl 0x7b02(%rip), %eax      # 0xe2b4
addl 0x7af8(%rip), %eax      # 0xe2b0
orl $0x1a000, %eax          # imm = 0x1A000
movl %eax, -0x10(%rbp)
movl -0x10(%rbp), %eax
addl -0x4(%rbp), %eax
movl %eax, -0x4(%rbp)
movl -0x10(%rbp), %edi
callq 0x6660
movl $0x0, -0x8(%rbp)
movl -0x8(%rbp), %eax
cmpl 0x7acf(%rip), %eax      # 0xe2b0
jge 0x6810
movslq -0x8(%rbp), %rcx
leaq 0x7ad2(%rip), %rax      # 0xe2c0
movl (%rax,%rcx,4), %eax
movl %eax, -0x14(%rbp)
movl -0x14(%rbp), %eax
addl -0x4(%rbp), %eax
movl %eax, -0x4(%rbp)
movl -0x14(%rbp), %edi
callq 0x6660
movl -0x8(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x8(%rbp)
jmp 0x67d8
movl -0x4(%rbp), %eax
andl $0xfffc0000, %eax       # imm = 0xFFFC0000
cmpl $0x0, %eax
je 0x6830
movl -0x4(%rbp), %eax
andl $0x3ffff, %eax          # imm = 0x3FFFF
movl -0x4(%rbp), %ecx
sarl $0x12, %ecx
addl %ecx, %eax
movl %eax, -0x4(%rbp)
movl -0x4(%rbp), %eax
andl $0x40000, %eax          # imm = 0x40000
cmpl $0x0, %eax
je 0x6846
movl -0x4(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x4(%rbp)
movl -0x4(%rbp), %eax
movl %eax, -0x18(%rbp)
movl -0x18(%rbp), %eax
addl -0x4(%rbp), %eax
movl %eax, -0x4(%rbp)
movl -0x18(%rbp), %edi
callq 0x6660
movl $0x5, %edi
callq 0x2f80
movl $0x0, 0x7a3f(%rip)      # 0xe2b0
addq $0x20, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/simh[P]simtools/crossassemblers/macro1/macro1.c
// Function: isLexSymbol
BOOL isLexSymbol()
{
    int ix;

    /* XXX alpha within first 4? 3?? */
    for( ix = lexstart; ix < lexterm; ix++ )
	if(isalpha(line[ix]))
	    return TRUE;			/* any position will do! */
    return FALSE;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movl 0x77f2(%rip), %eax      # 0xe0b0
movl %eax, -0x8(%rbp)
movl -0x8(%rbp), %eax
cmpl 0x7872(%rip), %eax      # 0xe13c
jge 0x6907
callq 0x21b0
movq (%rax), %rax
movslq -0x8(%rbp), %rdx
leaq 0x7771(%rip), %rcx      # 0xe050
movsbl (%rcx,%rdx), %ecx
movslq %ecx, %rcx
movzwl (%rax,%rcx,2), %eax
andl $0x400, %eax            # imm = 0x400
cmpl $0x0, %eax
je 0x68fa
movb $0x1, -0x1(%rbp)
jmp 0x690b
jmp 0x68fc
movl -0x8(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x8(%rbp)
jmp 0x68c1
movb $0x0, -0x1(%rbp)
movb -0x1(%rbp), %al
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/simh[P]simtools/crossassemblers/macro1/macro1.c
// Function: variables
void
variables() {
    /* XXX error if "variables" already seen (in this pass) */
    /* XXX error if different address on pass 2 */
    if (pass == 2)
	printLine( line, clc, 0, LINE_LOC );
    vars_addr = clc;
    vars_end = clc = (clc + nvars) & ADDRESS_FIELD;
    if (pass == 2)
	printLine( line, clc, 0, LINE_LOC);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
cmpl $0x2, 0x4df5(%rip)      # 0xbd80
jne 0x6fa6
movl 0x7121(%rip), %esi      # 0xe0b4
leaq 0x70b6(%rip), %rdi      # 0xe050
xorl %edx, %edx
movl $0x4, %ecx
callq 0x4650
movl 0x7108(%rip), %eax      # 0xe0b4
movl %eax, 0x840a(%rip)      # 0xf3bc
movl 0x70fc(%rip), %eax      # 0xe0b4
addl 0x7192(%rip), %eax      # 0xe150
andl $0xfff, %eax            # imm = 0xFFF
movl %eax, 0x70eb(%rip)      # 0xe0b4
movl %eax, 0x83f9(%rip)      # 0xf3c8
cmpl $0x2, 0x4daa(%rip)      # 0xbd80
jne 0x6ff1
movl 0x70d6(%rip), %esi      # 0xe0b4
leaq 0x706b(%rip), %rdi      # 0xe050
xorl %edx, %edx
movl $0x4, %ecx
callq 0x4650
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/simh[P]simtools/crossassemblers/macro1/macro1.c
// Function: text
void
text(void)
{
    char delim;
    WORD32 w;
    int count;
    int ccase;
    /* XXX error in repeat!! */
    do {
	if (cc == maxcc) {
	    /* XXX EOL before delim found!!! */
	    fprintf(stderr, "FIX ME!\n");
	    return;
	}
	delim = line[cc++];
    } while (delim == ' ');		/* others? NL */

    w = count = 0;
    ccase = LC;
    for (;;) {
	int c = nextfiodec(&ccase, delim);
	if (c == -1)
	    break;
	w |= c << ((2-count)*6);
	if (++count == 3) {
	    punchOutObject(clc, w);	/* punch it! */
	    incrementClc();
	    count = w = 0;
	}
    }
    if (count > 0) {
	punchOutObject(clc, w);		/* punch remainder */
	incrementClc();
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movl 0x70aa(%rip), %eax      # 0xe0b8
cmpl 0x7120(%rip), %eax      # 0xe134
jne 0x7033
movq 0x3fdb(%rip), %rax      # 0xaff8
movq (%rax), %rdi
leaq 0x19c2(%rip), %rsi      # 0x89e9
movb $0x0, %al
callq 0x2110
jmp 0x70ea
movl 0x707f(%rip), %eax      # 0xe0b8
movl %eax, %ecx
addl $0x1, %ecx
movl %ecx, 0x7074(%rip)      # 0xe0b8
movslq %eax, %rcx
leaq 0x7002(%rip), %rax      # 0xe050
movb (%rax,%rcx), %al
movb %al, -0x1(%rbp)
movsbl -0x1(%rbp), %eax
cmpl $0x20, %eax
je 0x7008
movl $0x0, -0xc(%rbp)
movl $0x0, -0x8(%rbp)
movl $0x80, -0x10(%rbp)
movsbl -0x1(%rbp), %esi
leaq -0x10(%rbp), %rdi
callq 0x58a0
movl %eax, -0x14(%rbp)
cmpl $-0x1, -0x14(%rbp)
jne 0x708a
jmp 0x70d1
movl -0x14(%rbp), %eax
movl $0x2, %ecx
subl -0xc(%rbp), %ecx
imull $0x6, %ecx, %ecx
shll %cl, %eax
orl -0x8(%rbp), %eax
movl %eax, -0x8(%rbp)
movl -0xc(%rbp), %eax
addl $0x1, %eax
movl %eax, -0xc(%rbp)
cmpl $0x3, %eax
jne 0x70cf
movl 0x7000(%rip), %edi      # 0xe0b4
movl -0x8(%rbp), %esi
callq 0x5300
callq 0x5340
movl $0x0, -0x8(%rbp)
movl $0x0, -0xc(%rbp)
jmp 0x7072
cmpl $0x0, -0xc(%rbp)
jle 0x70ea
movl 0x6fd7(%rip), %edi      # 0xe0b4
movl -0x8(%rbp), %esi
callq 0x5300
callq 0x5340
addq $0x20, %rsp
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O0/OstCollector[P]config2c/config2c.c
// Function: make_message
const char *make_message(const char *fmt, ...)
{
	int size = 0;
	char *p = NULL;
	va_list ap;

	/* Determine required size */

	va_start(ap, fmt);
	size = vsnprintf(p, size, fmt, ap);
	va_end(ap);

	if (size < 0)
		return NULL;

	size++;		    /* For '\0' */
	p = malloc(size);
	if (p == NULL)
		return NULL;

	va_start(ap, fmt);
	size = vsnprintf(p, size, fmt, ap);
	if (size < 0) {
		free(p);
		return NULL;
	}
	va_end(ap);

	return p;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0xf0, %rsp
testb %al, %al
je 0x22fb
movaps %xmm0, -0xc0(%rbp)
movaps %xmm1, -0xb0(%rbp)
movaps %xmm2, -0xa0(%rbp)
movaps %xmm3, -0x90(%rbp)
movaps %xmm4, -0x80(%rbp)
movaps %xmm5, -0x70(%rbp)
movaps %xmm6, -0x60(%rbp)
movaps %xmm7, -0x50(%rbp)
movq %r9, -0xc8(%rbp)
movq %r8, -0xd0(%rbp)
movq %rcx, -0xd8(%rbp)
movq %rdx, -0xe0(%rbp)
movq %rsi, -0xe8(%rbp)
movq %rdi, -0x10(%rbp)
movl $0x0, -0x14(%rbp)
movq $0x0, -0x20(%rbp)
leaq -0x40(%rbp), %rax
leaq -0xf0(%rbp), %rcx
movq %rcx, 0x10(%rax)
leaq 0x10(%rbp), %rcx
movq %rcx, 0x8(%rax)
movl $0x30, 0x4(%rax)
movl $0x8, (%rax)
movq -0x20(%rbp), %rdi
movslq -0x14(%rbp), %rsi
movq -0x10(%rbp), %rdx
leaq -0x40(%rbp), %rcx
callq 0x2080
movl %eax, -0x14(%rbp)
leaq -0x40(%rbp), %rax
cmpl $0x0, -0x14(%rbp)
jge 0x2384
movq $0x0, -0x8(%rbp)
jmp 0x240c
movl -0x14(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x14(%rbp)
movslq -0x14(%rbp), %rdi
callq 0x2150
movq %rax, -0x20(%rbp)
cmpq $0x0, -0x20(%rbp)
jne 0x23ab
movq $0x0, -0x8(%rbp)
jmp 0x240c
leaq -0x40(%rbp), %rax
leaq -0xf0(%rbp), %rcx
movq %rcx, 0x10(%rax)
leaq 0x10(%rbp), %rcx
movq %rcx, 0x8(%rax)
movl $0x30, 0x4(%rax)
movl $0x8, (%rax)
movq -0x20(%rbp), %rdi
movslq -0x14(%rbp), %rsi
movq -0x10(%rbp), %rdx
leaq -0x40(%rbp), %rcx
callq 0x2080
movl %eax, -0x14(%rbp)
cmpl $0x0, -0x14(%rbp)
jge 0x2400
movq -0x20(%rbp), %rdi
callq 0x2030
movq $0x0, -0x8(%rbp)
jmp 0x240c
leaq -0x40(%rbp), %rax
movq -0x20(%rbp), %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0xf0, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/OstCollector[P]config2c/config2c.c
// Function: copy_file
void copy_file(FILE *dst, FILE *src)
{
	int c;
	while (1) {
		c = fgetc(src);
		if (c == EOF) {
			break;
		}
		if (putc(c, dst) == EOF) {
			ERR("failed to write to file.\n");
		}
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x10(%rbp), %rdi
callq 0x20d0
movl %eax, -0x14(%rbp)
cmpl $-0x1, -0x14(%rbp)
jne 0x29a4
jmp 0x29fa
movl -0x14(%rbp), %edi
movq -0x8(%rbp), %rsi
callq 0x20f0
cmpl $-0x1, %eax
jne 0x29f8
jmp 0x29b7
movq 0x18632(%rip), %rax     # 0x1aff0
movq (%rax), %rdi
leaq 0x12f29(%rip), %rsi     # 0x158f1
movb $0x0, %al
callq 0x2100
movq 0x1861a(%rip), %rax     # 0x1aff0
movq (%rax), %rdi
movq 0x18850(%rip), %rdx     # 0x1b230
leaq 0x15e48(%rip), %rsi     # 0x1882f
movb $0x0, %al
callq 0x2100
movl $0x1, %edi
callq 0x2180
jmp 0x2990
addq $0x20, %rsp
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O0/OstCollector[P]config2c/config2c.c
// Function: verify_def_list
static void verify_def_list(const struct node_type_def_list *list)
{
	for (; list; list = list->next) {
		switch (list->type) {
		case NODE_TYPE_DEF_ENUM:
			break;
		case NODE_TYPE_DEF_STRUCT:
			verify_def_struct(list->struct_def.members, 1,
					list->struct_def.name, 0);
			break;
		case NODE_TYPE_DEF_UNION:
			verify_def_union(list->union_def.alters, 1,
					list->union_def.name, 0);
			break;
		}
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
cmpq $0x0, -0x8(%rbp)
je 0x7cc2
movq -0x8(%rbp), %rax
movl 0x8(%rax), %eax
movl %eax, -0xc(%rbp)
testl %eax, %eax
je 0x7c77
jmp 0x7c63
movl -0xc(%rbp), %eax
subl $0x1, %eax
je 0x7c79
jmp 0x7c6d
movl -0xc(%rbp), %eax
subl $0x2, %eax
je 0x7c97
jmp 0x7cb3
jmp 0x7cb3
movq -0x8(%rbp), %rax
movq 0x18(%rax), %rdi
movq -0x8(%rbp), %rax
movq 0x10(%rax), %rdx
movl $0x1, %esi
xorl %ecx, %ecx
callq 0xcc50
jmp 0x7cb3
movq -0x8(%rbp), %rax
movq 0x20(%rax), %rdi
movq -0x8(%rbp), %rax
movq 0x10(%rax), %rdx
movl $0x1, %esi
xorl %ecx, %ecx
callq 0xcf60
jmp 0x7cb5
movq -0x8(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x8(%rbp)
jmp 0x7c4c
addq $0x10, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/OstCollector[P]config2c/config2c.c
// Function: parse_type_def_list
static void parse_type_def_list(const struct node_type_def_list *list)
{
	for (; list; list = list->next) {
		switch (list->type) {
		case NODE_TYPE_DEF_ENUM:
			parse_enum(list->enum_def.name, 
					list->enum_def.enums);
			break;
		case NODE_TYPE_DEF_STRUCT:
			parse_struct(list->struct_def.name,
					list->struct_def.members);
			break;
		case NODE_TYPE_DEF_UNION:
			parse_union(list->union_def.name,
					list->union_def.enum_name,
					list->union_def.alters);
			break;
		}
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
cmpq $0x0, -0x8(%rbp)
je 0x7d68
movq -0x8(%rbp), %rax
movl 0x8(%rax), %eax
movl %eax, -0xc(%rbp)
testl %eax, %eax
je 0x7d0b
jmp 0x7cf7
movl -0xc(%rbp), %eax
subl $0x1, %eax
je 0x7d22
jmp 0x7d01
movl -0xc(%rbp), %eax
subl $0x2, %eax
je 0x7d39
jmp 0x7d56
movq -0x8(%rbp), %rax
movq 0x10(%rax), %rdi
movq -0x8(%rbp), %rax
movq 0x18(%rax), %rsi
callq 0xd360
jmp 0x7d56
movq -0x8(%rbp), %rax
movq 0x10(%rax), %rdi
movq -0x8(%rbp), %rax
movq 0x18(%rax), %rsi
callq 0x4250
jmp 0x7d56
movq -0x8(%rbp), %rax
movq 0x10(%rax), %rdi
movq -0x8(%rbp), %rax
movq 0x18(%rax), %rsi
movq -0x8(%rbp), %rax
movq 0x20(%rax), %rdx
callq 0xda80
jmp 0x7d58
movq -0x8(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x8(%rbp)
jmp 0x7cdc
addq $0x10, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/OstCollector[P]config2c/config2c.c
// Function: free_type_def_list
static void free_type_def_list(const struct node_type_def_list *list)
{
	for (; list; list = list->next) {
		switch (list->type) {
		case NODE_TYPE_DEF_STRUCT:
			free_struct(list->struct_def.name,
					list->struct_def.members);
			break;
		case NODE_TYPE_DEF_UNION:
			free_union(list->union_def.name,
					list->union_def.enum_name,
					list->union_def.alters);
			break;
		}
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
cmpq $0x0, -0x8(%rbp)
je 0x7de1
movq -0x8(%rbp), %rax
movl 0x8(%rax), %eax
movl %eax, -0xc(%rbp)
subl $0x1, %eax
je 0x7d9e
jmp 0x7d94
movl -0xc(%rbp), %eax
subl $0x2, %eax
je 0x7db5
jmp 0x7dd2
movq -0x8(%rbp), %rax
movq 0x10(%rax), %rdi
movq -0x8(%rbp), %rax
movq 0x18(%rax), %rsi
callq 0x64c0
jmp 0x7dd2
movq -0x8(%rbp), %rax
movq 0x10(%rax), %rdi
movq -0x8(%rbp), %rax
movq 0x18(%rax), %rsi
movq -0x8(%rbp), %rax
movq 0x20(%rax), %rdx
callq 0xeff0
jmp 0x7dd4
movq -0x8(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x8(%rbp)
jmp 0x7d7c
addq $0x10, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/OstCollector[P]config2c/config2c.c
// Function: dump_type_def_list
static void dump_type_def_list(const struct node_type_def_list *list)
{
	while (list) {
		switch (list->type) {
		case NODE_TYPE_DEF_ENUM:
			dump_enum(list->enum_def.name,
					list->enum_def.enums);
			break;
		case NODE_TYPE_DEF_STRUCT:
			dump_struct(list->struct_def.name,
					list->struct_def.members);
			break;
		case NODE_TYPE_DEF_UNION:
			dump_union(list->union_def.name,
					list->union_def.enum_name,
					list->union_def.alters);
			break;
		}
		list = list->next;
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
cmpq $0x0, -0x8(%rbp)
je 0x7e82
movq -0x8(%rbp), %rax
movl 0x8(%rax), %eax
movl %eax, -0xc(%rbp)
testl %eax, %eax
je 0x7e27
jmp 0x7e13
movl -0xc(%rbp), %eax
subl $0x1, %eax
je 0x7e3e
jmp 0x7e1d
movl -0xc(%rbp), %eax
subl $0x2, %eax
je 0x7e55
jmp 0x7e72
movq -0x8(%rbp), %rax
movq 0x10(%rax), %rdi
movq -0x8(%rbp), %rax
movq 0x18(%rax), %rsi
callq 0xf4a0
jmp 0x7e72
movq -0x8(%rbp), %rax
movq 0x10(%rax), %rdi
movq -0x8(%rbp), %rax
movq 0x18(%rax), %rsi
callq 0x6980
jmp 0x7e72
movq -0x8(%rbp), %rax
movq 0x10(%rax), %rdi
movq -0x8(%rbp), %rax
movq 0x18(%rax), %rsi
movq -0x8(%rbp), %rax
movq 0x20(%rax), %rdx
callq 0xf740
movq -0x8(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x8(%rbp)
jmp 0x7dfc
addq $0x10, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/OstCollector[P]config2c/config2c.c
// Function: lookup_map
static const struct node_mapping *lookup_map(const char *type)
{
	const struct node_mapping *cur;
	for (cur = mapping; cur; cur = cur->next) {
		if (!strcmp(cur->name, type)) {
			return cur;
		}
	}
	return NULL;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movq 0x12955(%rip), %rax     # 0x1b2c8
movq %rax, -0x18(%rbp)
cmpq $0x0, -0x18(%rbp)
je 0x89ad
movq -0x18(%rbp), %rax
movq (%rax), %rdi
movq -0x10(%rbp), %rsi
callq 0x20e0
cmpl $0x0, %eax
jne 0x899d
movq -0x18(%rbp), %rax
movq %rax, -0x8(%rbp)
jmp 0x89b5
jmp 0x899f
movq -0x18(%rbp), %rax
movq 0x28(%rax), %rax
movq %rax, -0x18(%rbp)
jmp 0x8977
movq $0x0, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x20, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/OstCollector[P]config2c/config2c.c
// Function: decl_elem
static void decl_elem(const char *name, const struct node_vec_def *vec)
{
	switch (vec->type) {
	case NODE_TYPE_SCALE:
		out_hdr("%s;\n", name);
		break;
	case NODE_TYPE_FIX_INT:
		out_hdr("%s[%ld];\n", name, vec->len_int);
		break;
	case NODE_TYPE_FIX_STR:
		out_hdr("%s[%s];\n", name, vec->len_str);
		break;
	case NODE_TYPE_VAR_ARR:
		out_hdr("*%s;\n", name);
		break;
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x10(%rbp), %rax
movl (%rax), %eax
movq %rax, -0x18(%rbp)
subq $0x3, %rax
ja 0x8b4e
movq -0x18(%rbp), %rax
leaq 0xc6cd(%rip), %rcx      # 0x150bc
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
jmp 0x89fa
movq 0x128bf(%rip), %rdi     # 0x1b2c0
movq -0x8(%rbp), %rdx
leaq 0xdd89(%rip), %rsi      # 0x16795
movb $0x0, %al
callq 0x2100
movl %eax, %ecx
xorl %eax, %eax
cmpl %ecx, %eax
jle 0x8a44
movq 0x125ce(%rip), %rax     # 0x1aff0
movq (%rax), %rdi
leaq 0xcf28(%rip), %rsi      # 0x15954
leaq 0xcf39(%rip), %rdx      # 0x1596c
movb $0x0, %al
callq 0x2100
movl $0x1, %edi
callq 0x2180
jmp 0x8a46
jmp 0x8b4e
jmp 0x8a4d
movq 0x1286c(%rip), %rdi     # 0x1b2c0
movq -0x8(%rbp), %rdx
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rcx
leaq 0xdbed(%rip), %rsi      # 0x16654
movb $0x0, %al
callq 0x2100
movl %eax, %ecx
xorl %eax, %eax
cmpl %ecx, %eax
jle 0x8a9f
movq 0x12573(%rip), %rax     # 0x1aff0
movq (%rax), %rdi
leaq 0xcecd(%rip), %rsi      # 0x15954
leaq 0xcede(%rip), %rdx      # 0x1596c
movb $0x0, %al
callq 0x2100
movl $0x1, %edi
callq 0x2180
jmp 0x8aa1
jmp 0x8b4e
jmp 0x8aa8
movq 0x12811(%rip), %rdi     # 0x1b2c0
movq -0x8(%rbp), %rdx
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rcx
leaq 0xdb9c(%rip), %rsi      # 0x1665e
movb $0x0, %al
callq 0x2100
movl %eax, %ecx
xorl %eax, %eax
cmpl %ecx, %eax
jle 0x8afa
movq 0x12518(%rip), %rax     # 0x1aff0
movq (%rax), %rdi
leaq 0xce72(%rip), %rsi      # 0x15954
leaq 0xce83(%rip), %rdx      # 0x1596c
movb $0x0, %al
callq 0x2100
movl $0x1, %edi
callq 0x2180
jmp 0x8afc
jmp 0x8b4e
jmp 0x8b00
movq 0x127b9(%rip), %rdi     # 0x1b2c0
movq -0x8(%rbp), %rdx
leaq 0xdb55(%rip), %rsi      # 0x16667
movb $0x0, %al
callq 0x2100
movl %eax, %ecx
xorl %eax, %eax
cmpl %ecx, %eax
jle 0x8b4a
movq 0x124c8(%rip), %rax     # 0x1aff0
movq (%rax), %rdi
leaq 0xce22(%rip), %rsi      # 0x15954
leaq 0xce33(%rip), %rdx      # 0x1596c
movb $0x0, %al
callq 0x2100
movl $0x1, %edi
callq 0x2180
jmp 0x8b4c
jmp 0x8b4e
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/OstCollector[P]config2c/config2c.c
// Function: lookup_union
static const struct node_type_def_list *lookup_union(const char *name)
{
	const struct node_type_def_list *l;
	for (l = ast; l; l = l->next) {
		if (l->type == NODE_TYPE_DEF_UNION &&
				!strcmp(name, l->union_def.name)) {
			return l;
		}
	}
	return NULL;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movq 0x126b5(%rip), %rax     # 0x1b2a8
movq %rax, -0x18(%rbp)
cmpq $0x0, -0x18(%rbp)
je 0x8c37
movq -0x18(%rbp), %rax
cmpl $0x2, 0x8(%rax)
jne 0x8c28
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rax
movq 0x10(%rax), %rsi
callq 0x20e0
cmpl $0x0, %eax
jne 0x8c28
movq -0x18(%rbp), %rax
movq %rax, -0x8(%rbp)
jmp 0x8c3f
jmp 0x8c2a
movq -0x18(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x18(%rbp)
jmp 0x8bf7
movq $0x0, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/OstCollector[P]config2c/config2c.c
// Function: helper_parse
static void helper_parse(const struct node_vec_def *vec,
		const struct type_decl *decl,
		string name, const struct string_list *vars,
		const struct parse_opts *opts, int l)
{
	switch (vec->type) {
	case NODE_TYPE_SCALE:
		helper_parse_scale(decl, name, vars, opts, l);
		break;
	default:
		helper_parse_array(vec, decl, name, vars, opts, l);
		break;
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
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), %rax
movl (%rax), %eax
testl %eax, %eax
jne 0x8d17
jmp 0x8cfc
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rsi
movq -0x20(%rbp), %rdx
movq -0x28(%rbp), %rcx
movl -0x2c(%rbp), %r8d
callq 0x8d90
jmp 0x8d34
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
movq -0x18(%rbp), %rdx
movq -0x20(%rbp), %rcx
movq -0x28(%rbp), %r8
movl -0x2c(%rbp), %r9d
callq 0x9bb0
addq $0x30, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/OstCollector[P]config2c/config2c.c
// Function: helper_free
static void helper_free(const struct node_vec_def *vec,
		const struct type_decl *decl,
		const struct string_list *vars, int l)
{
	switch (vec->type) {
	case NODE_TYPE_SCALE:
		helper_free_scale(decl, vars, l);
		break;
	default:
		helper_free_array(vec, decl, vars, l);
		break;
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movl %ecx, -0x1c(%rbp)
movq -0x8(%rbp), %rax
movl (%rax), %eax
testl %eax, %eax
jne 0x8d75
jmp 0x8d63
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rsi
movl -0x1c(%rbp), %edx
callq 0xbc00
jmp 0x8d89
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
movq -0x18(%rbp), %rdx
movl -0x1c(%rbp), %ecx
callq 0xbe40
addq $0x20, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/OstCollector[P]config2c/config2c.c
// Function: out_str_list
static void out_str_list(int is_hdr, string prefix, string postfix,
		const struct string_list *list)
{
	for (; list; list = list->next) {
		if (list->next) {
			if (is_hdr) {
				out_hdr("%s%s%s, ", prefix, list->str, postfix);
			} else {
				out_src("%s%s%s, ", prefix, list->str, postfix);
			}
		} else {
			if (is_hdr) {
				out_hdr("%s%s%s", prefix, list->str, postfix);
			} else {
				out_src("%s%s%s", prefix, list->str, postfix);
			}
		}
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movl %edi, -0x4(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq %rcx, -0x20(%rbp)
cmpq $0x0, -0x20(%rbp)
je 0xbbf3
movq -0x20(%rbp), %rax
cmpq $0x0, 0x8(%rax)
je 0xbb22
cmpl $0x0, -0x4(%rbp)
je 0xbac2
jmp 0xba69
movq 0xf850(%rip), %rdi      # 0x1b2c0
movq -0x10(%rbp), %rdx
movq -0x20(%rbp), %rax
movq (%rax), %rcx
movq -0x18(%rbp), %r8
leaq 0xb30d(%rip), %rsi      # 0x16d93
movb $0x0, %al
callq 0x2100
movl %eax, %ecx
xorl %eax, %eax
cmpl %ecx, %eax
jle 0xbabe
movq 0xf554(%rip), %rax      # 0x1aff0
movq (%rax), %rdi
leaq 0x9eae(%rip), %rsi      # 0x15954
leaq 0x9ebf(%rip), %rdx      # 0x1596c
movb $0x0, %al
callq 0x2100
movl $0x1, %edi
callq 0x2180
jmp 0xbac0
jmp 0xbb1d
jmp 0xbac4
movq 0xf7d5(%rip), %rdi      # 0x1b2a0
movq -0x10(%rbp), %rdx
movq -0x20(%rbp), %rax
movq (%rax), %rcx
movq -0x18(%rbp), %r8
leaq 0xb2b2(%rip), %rsi      # 0x16d93
movb $0x0, %al
callq 0x2100
movl %eax, %ecx
xorl %eax, %eax
cmpl %ecx, %eax
jle 0xbb19
movq 0xf4f9(%rip), %rax      # 0x1aff0
movq (%rax), %rdi
leaq 0x9e53(%rip), %rsi      # 0x15954
leaq 0x9e64(%rip), %rdx      # 0x1596c
movb $0x0, %al
callq 0x2100
movl $0x1, %edi
callq 0x2180
jmp 0xbb1b
jmp 0xbb1d
jmp 0xbbe0
cmpl $0x0, -0x4(%rbp)
je 0xbb83
jmp 0xbb2a
movq 0xf78f(%rip), %rdi      # 0x1b2c0
movq -0x10(%rbp), %rdx
movq -0x20(%rbp), %rax
movq (%rax), %rcx
movq -0x18(%rbp), %r8
leaq 0xb255(%rip), %rsi      # 0x16d9c
movb $0x0, %al
callq 0x2100
movl %eax, %ecx
xorl %eax, %eax
cmpl %ecx, %eax
jle 0xbb7f
movq 0xf493(%rip), %rax      # 0x1aff0
movq (%rax), %rdi
leaq 0x9ded(%rip), %rsi      # 0x15954
leaq 0x9dfe(%rip), %rdx      # 0x1596c
movb $0x0, %al
callq 0x2100
movl $0x1, %edi
callq 0x2180
jmp 0xbb81
jmp 0xbbde
jmp 0xbb85
movq 0xf714(%rip), %rdi      # 0x1b2a0
movq -0x10(%rbp), %rdx
movq -0x20(%rbp), %rax
movq (%rax), %rcx
movq -0x18(%rbp), %r8
leaq 0xb1fa(%rip), %rsi      # 0x16d9c
movb $0x0, %al
callq 0x2100
movl %eax, %ecx
xorl %eax, %eax
cmpl %ecx, %eax
jle 0xbbda
movq 0xf438(%rip), %rax      # 0x1aff0
movq (%rax), %rdi
leaq 0x9d92(%rip), %rsi      # 0x15954
leaq 0x9da3(%rip), %rdx      # 0x1596c
movb $0x0, %al
callq 0x2100
movl $0x1, %edi
callq 0x2180
jmp 0xbbdc
jmp 0xbbde
jmp 0xbbe0
jmp 0xbbe2
movq -0x20(%rbp), %rax
movq 0x8(%rax), %rax
movq %rax, -0x20(%rbp)
jmp 0xba47
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/OstCollector[P]config2c/config2c.c
// Function: helper_dump
static void helper_dump(const struct node_vec_def *vec,
		const struct type_decl *decl,
		string name, const struct string_list *vars, int l)
{
	switch (vec->type) {
	case NODE_TYPE_SCALE:
		helper_dump_scale(decl, name, vars, l);
		break;
	default:
		helper_dump_array(vec, decl, name, vars, l);
		break;
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq %rcx, -0x20(%rbp)
movl %r8d, -0x24(%rbp)
movq -0x8(%rbp), %rax
movl (%rax), %eax
testl %eax, %eax
jne 0xc2de
jmp 0xc2c8
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rsi
movq -0x20(%rbp), %rdx
movl -0x24(%rbp), %ecx
callq 0xc300
jmp 0xc2f7
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
movq -0x18(%rbp), %rdx
movq -0x20(%rbp), %rcx
movl -0x24(%rbp), %r8d
callq 0xc630
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/OstCollector[P]config2c/config2c.c
// Function: lookup_enum
static const struct node_type_def_list *lookup_enum(const char *name)
{
	const struct node_type_def_list *l;
	for (l = ast; l; l = l->next) {
		if (l->type == NODE_TYPE_DEF_ENUM && 
				!strcmp(name, l->enum_def.name)) {
			return l;
		}
	}
	return NULL;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movq 0xe015(%rip), %rax      # 0x1b2a8
movq %rax, -0x18(%rbp)
cmpq $0x0, -0x18(%rbp)
je 0xd2d7
movq -0x18(%rbp), %rax
cmpl $0x0, 0x8(%rax)
jne 0xd2c8
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rax
movq 0x10(%rax), %rsi
callq 0x20e0
cmpl $0x0, %eax
jne 0xd2c8
movq -0x18(%rbp), %rax
movq %rax, -0x8(%rbp)
jmp 0xd2df
jmp 0xd2ca
movq -0x18(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x18(%rbp)
jmp 0xd297
movq $0x0, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/OstCollector[P]config2c/config2c.c
// Function: lookup_struct
static const struct node_type_def_list *lookup_struct(const char *name)
{
	const struct node_type_def_list *l;
	for (l = ast; l; l = l->next) {
		if (l->type == NODE_TYPE_DEF_STRUCT && 
				!strcmp(name, l->struct_def.name)) {
			return l;
		}
	}
	return NULL;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movq 0xdfa5(%rip), %rax      # 0x1b2a8
movq %rax, -0x18(%rbp)
cmpq $0x0, -0x18(%rbp)
je 0xd347
movq -0x18(%rbp), %rax
cmpl $0x1, 0x8(%rax)
jne 0xd338
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rax
movq 0x10(%rax), %rsi
callq 0x20e0
cmpl $0x0, %eax
jne 0xd338
movq -0x18(%rbp), %rax
movq %rax, -0x8(%rbp)
jmp 0xd34f
jmp 0xd33a
movq -0x18(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x18(%rbp)
jmp 0xd307
movq $0x0, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/OstCollector[P]config2c/config2cy.tab.c
// Function: yy_syntax_error_arguments
static int
yy_syntax_error_arguments (const yypcontext_t *yyctx,
                           yysymbol_kind_t yyarg[], int yyargn)
{
  /* Actual size of YYARG. */
  int yycount = 0;
  /* There are many possibilities here to consider:
     - If this state is a consistent state with a default action, then
       the only way this function was invoked is if the default action
       is an error action.  In that case, don't check for expected
       tokens because there are none.
     - The only way there can be no lookahead present (in yychar) is if
       this state is a consistent state with a default action.  Thus,
       detecting the absence of a lookahead is sufficient to determine
       that there is no unexpected or expected token to report.  In that
       case, just report a simple "syntax error".
     - Don't assume there isn't a lookahead just because this state is a
       consistent state with a default action.  There might have been a
       previous inconsistent state, consistent state with a non-default
       action, or user semantic action that manipulated yychar.
     - Of course, the expected token list depends on states to have
       correct lookahead information, and it depends on the parser not
       to perform extra reductions after fetching a lookahead from the
       scanner and before detecting a syntax error.  Thus, state merging
       (from LALR or IELR) and default reductions corrupt the expected
       token list.  However, the list is correct for canonical LR with
       one exception: it will still contain any token that will not be
       accepted due to an error action in a later state.
  */
  if (yyctx->yytoken != YYSYMBOL_YYEMPTY)
    {
      int yyn;
      if (yyarg)
        yyarg[yycount] = yyctx->yytoken;
      ++yycount;
      yyn = yypcontext_expected_tokens (yyctx,
                                        yyarg ? yyarg + 1 : yyarg, yyargn - 1);
      if (yyn == YYENOMEM)
        return YYENOMEM;
      else
        yycount += yyn;
    }
  return yycount;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movl %edx, -0x1c(%rbp)
movl $0x0, -0x20(%rbp)
movq -0x10(%rbp), %rax
cmpl $-0x2, 0x8(%rax)
je 0x141cb
cmpq $0x0, -0x18(%rbp)
je 0x1416d
movq -0x10(%rbp), %rax
movl 0x8(%rax), %edx
movq -0x18(%rbp), %rax
movslq -0x20(%rbp), %rcx
movl %edx, (%rax,%rcx,4)
movl -0x20(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x20(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x30(%rbp)
cmpq $0x0, -0x18(%rbp)
je 0x14193
movq -0x18(%rbp), %rax
addq $0x4, %rax
movq %rax, -0x38(%rbp)
jmp 0x1419b
movq -0x18(%rbp), %rax
movq %rax, -0x38(%rbp)
movq -0x30(%rbp), %rdi
movq -0x38(%rbp), %rsi
movl -0x1c(%rbp), %edx
subl $0x1, %edx
callq 0x142f0
movl %eax, -0x24(%rbp)
cmpl $-0x2, -0x24(%rbp)
jne 0x141c0
movl $0xfffffffe, -0x4(%rbp) # imm = 0xFFFFFFFE
jmp 0x141d1
movl -0x24(%rbp), %eax
addl -0x20(%rbp), %eax
movl %eax, -0x20(%rbp)
jmp 0x141cb
movl -0x20(%rbp), %eax
movl %eax, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x40, %rsp
popq %rbp
retq
nopw (%rax,%rax)