LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O3/mjosaarinen[P]brutus/crypto_aead/icepole128v2/ref/icepole.c
// Function: P12
void P12(ICESTATE SS, ICESTATE S)
{
    ICESTATE A;
    ICESTATE B;

    oneround(A,S,0);
    oneround(B,A,1);
    oneround(A,B,2);
    oneround(B,A,3);
    oneround(A,B,4);
    oneround(B,A,5);
    oneround(A,B,6);
    oneround(B,A,7);
    oneround(A,B,8);
    oneround(B,A,9);
    oneround(A,B,10);
    oneround(SS,A,11);
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
subq $0x140, %rsp            # imm = 0x140
movq %rdi, %rbx
leaq 0xa0(%rsp), %r14
movq %r14, %rdi
xorl %edx, %edx
callq 0x10f0
movq %rsp, %r15
movq %r15, %rdi
movq %r14, %rsi
movl $0x1, %edx
callq 0x10f0
movq %r14, %rdi
movq %r15, %rsi
movl $0x2, %edx
callq 0x10f0
movq %r15, %rdi
movq %r14, %rsi
movl $0x3, %edx
callq 0x10f0
movq %r14, %rdi
movq %r15, %rsi
movl $0x4, %edx
callq 0x10f0
movq %r15, %rdi
movq %r14, %rsi
movl $0x5, %edx
callq 0x10f0
movq %r14, %rdi
movq %r15, %rsi
movl $0x6, %edx
callq 0x10f0
movq %r15, %rdi
movq %r14, %rsi
movl $0x7, %edx
callq 0x10f0
movq %r14, %rdi
movq %r15, %rsi
movl $0x8, %edx
callq 0x10f0
movq %r15, %rdi
movq %r14, %rsi
movl $0x9, %edx
callq 0x10f0
movq %r14, %rdi
movq %r15, %rsi
movl $0xa, %edx
callq 0x10f0
movq %rbx, %rdi
movq %r14, %rsi
movl $0xb, %edx
callq 0x10f0
addq $0x140, %rsp            # imm = 0x140
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O3/mjosaarinen[P]brutus/crypto_aead/icepole128v2/ref/icepole.c
// Function: processDataBlock
void processDataBlock(
    ICESTATE S, 
    const unsigned char * source, 
    unsigned char ** dest,
    unsigned long long blocklen, 
    unsigned int frameBit
)
{
	uint64_t q;
	uint64_t snew;
	uint64_t padding;
	unsigned int qlen; 
	unsigned int i = 0;
	assert(blocklen <= ICEPOLEDATABLOCKLEN);
	    
    /* absorb the data block (and produce the ciphertext) */
	do {
        qlen = (blocklen < 8 ? (unsigned int) blocklen : 8); 
        q = load64(source, qlen);
        snew = S[i%4][i/4] ^ q;
        if (dest) {
            store64(*dest, snew, qlen);
            *dest += qlen;
        }        
        padding = qlen < 8 ? ((uint64_t)frameBit | 0x02ULL) << (8*qlen) : 0;
        S[i%4][i/4] ^= q ^ padding;
        ++i;
        source += qlen;
        blocklen -= qlen;
	} while (qlen == 8);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %rdx, (%rsp)
movq %rdi, 0x8(%rsp)
cmpq $0x80, %rcx
ja 0x1fa3
movl %r8d, %ebx
movq %rcx, %r14
movq %rsi, %r12
cmpq $0x8, %rcx
movl $0x8, %ebp
cmovbq %rcx, %rbp
movq %rsi, %rdi
movl %ebp, %esi
callq 0x1080
movq %rax, %r13
orl $0x2, %ebx
movq %rbx, 0x10(%rsp)
addq $-0x8, %r14
addq $0x8, %r12
xorl %ebx, %ebx
movl %ebx, %eax
andl $0x3, %eax
movl %ebx, %ecx
shrl $0x2, %ecx
leaq (%rax,%rax,4), %rax
movq 0x8(%rsp), %rdx
leaq (%rdx,%rax,8), %rax
leaq (%rax,%rcx,8), %r15
movq (%rsp), %rax
testq %rax, %rax
je 0x1f43
movq (%r15), %rsi
xorq %r13, %rsi
movq (%rax), %rdi
movl %ebp, %edx
callq 0x1110
movl %ebp, %eax
movq (%rsp), %rcx
addq %rax, (%rcx)
leal (,%rbp,8), %eax
shlxq %rax, 0x10(%rsp), %rax
cmpl $0x8, %ebp
movl $0x0, %ecx
cmovaeq %rcx, %rax
xorq (%r15), %rax
xorq %r13, %rax
movq %rax, (%r15)
cmpl $0x8, %ebp
jne 0x1f94
incl %ebx
cmpq $0x8, %r14
movl $0x8, %ebp
cmovbq %r14, %rbp
movq %r12, %rdi
movl %ebp, %esi
callq 0x1080
movq %rax, %r13
addq $-0x8, %r14
addq $0x8, %r12
jmp 0x1f06
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
leaq 0x12a1(%rip), %rdi      # 0x324b
leaq 0x1208(%rip), %rsi      # 0x31b9
leaq 0x12b3(%rip), %rcx      # 0x326b
movl $0xeb, %edx
callq 0x1030
// File: /workspace/github_c_makefile_star2_O3/mjosaarinen[P]brutus/crypto_aead/icepole128v2/ref/icepole.c
// Function: processDataBlockRev
void processDataBlockRev(
	ICESTATE S, 
	const unsigned char * source, 
	unsigned char ** dest,
	unsigned long long blocklen, 
	unsigned int frameBit
	)
{
	uint64_t q;
	uint64_t snew;
	uint64_t padding;
	uint64_t bitmask;
	unsigned int qlen; 
	unsigned int i = 0;
	assert(blocklen <= ICEPOLEDATABLOCKLEN);
    
	do {
		qlen = (blocklen < 8 ? (unsigned int) blocklen : 8); 
		q = load64(source, qlen);
		snew = S[i%4][i/4] ^ q;
		bitmask = (qlen==8 ? 0 : 1ULL<< 8*qlen) - 1ULL;
		snew = snew & bitmask;
		if (dest) {
			store64(*dest, snew, qlen);
			*dest += qlen;
		}        
		padding = qlen < 8 ? ((uint64_t)frameBit | 0x02ULL) << (8*qlen) : 0;
		S[i%4][i/4] ^= snew ^ padding;
		++i;
		source += qlen;
		blocklen -= qlen;
	} while (qlen == 8);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x28, %rsp
movq %rdx, 0x8(%rsp)
movq %rdi, 0x18(%rsp)
cmpq $0x80, %rcx
ja 0x20e4
movl %r8d, %ebx
movq %rcx, %r14
movq %rsi, %r15
cmpq $0x8, %rcx
movl $0x8, %ebp
cmovbq %rcx, %rbp
movq %rsi, %rdi
movl %ebp, %esi
callq 0x1080
orl $0x2, %ebx
movq %rbx, 0x20(%rsp)
addq $-0x8, %r14
addq $0x8, %r15
movq %r15, 0x10(%rsp)
xorl %ebx, %ebx
movl %ebx, %ecx
andl $0x3, %ecx
movl %ebx, %edx
shrl $0x2, %edx
leaq (%rcx,%rcx,4), %rcx
movq 0x18(%rsp), %rsi
leaq (%rsi,%rcx,8), %rcx
leaq (%rcx,%rdx,8), %r15
movq (%r15), %rcx
xorq %rcx, %rax
leal (,%rbp,8), %r12d
cmpl $0x8, %ebp
movq $-0x1, %rdx
shlxq %r12, %rdx, %r13
notq %r13
cmoveq %rdx, %r13
andq %rax, %r13
movq 0x8(%rsp), %rax
testq %rax, %rax
je 0x2084
movq (%rax), %rdi
movq %r13, %rsi
movl %ebp, %edx
callq 0x1110
movl %ebp, %eax
movq 0x8(%rsp), %rcx
addq %rax, (%rcx)
movq (%r15), %rcx
cmpl $0x8, %ebp
shlxq %r12, 0x20(%rsp), %rax
movl $0x0, %edx
cmovaeq %rdx, %rax
xorq %rcx, %rax
xorq %r13, %rax
movq %rax, (%r15)
cmpl $0x8, %ebp
jne 0x20d5
incl %ebx
cmpq $0x8, %r14
movl $0x8, %ebp
cmovbq %r14, %rbp
movq 0x10(%rsp), %r15
movq %r15, %rdi
movl %ebp, %esi
callq 0x1080
addq $-0x8, %r14
addq $0x8, %r15
movq %r15, 0x10(%rsp)
jmp 0x201e
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
leaq 0x1160(%rip), %rdi      # 0x324b
leaq 0x10c7(%rip), %rsi      # 0x31b9
leaq 0x11e4(%rip), %rcx      # 0x32dd
movl $0x111, %edx            # imm = 0x111
callq 0x1030
// File: /workspace/github_c_makefile_star2_O3/georgeweigt[P]sassafras/sassafras.c
// Function: parse_data_stmt
void
parse_data_stmt(void)
{
	struct dataset *d;

	d = (struct dataset *) xmalloc(sizeof (struct dataset));

	bzero(d, sizeof (struct dataset));

	d->next = dd;
	dd = d;

	d->max = 1000;

	scan();

	if (token == NAME) {
		d->name = strdup(strbuf); // dataset NAME
		scan();
	}

	if (token != ';')
		expected("end of statment");

	scan();
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %rbx
pushq %rax
movl $0x1, %edi
movl $0xfc0, %esi            # imm = 0xFC0
callq 0x2160
testq %rax, %rax
je 0x23f6
movq %rax, %rbx
movq 0xdce8(%rip), %rax      # 0x10090
movq %rax, (%rbx)
movq %rbx, 0xdcde(%rip)      # 0x10090
movl $0x3e8, 0x18(%rbx)      # imm = 0x3E8
callq 0x2b82
movl 0xd4e0(%rip), %eax      # 0xf8a4
cmpl $0x3e9, %eax            # imm = 0x3E9
jne 0x23e6
leaq 0xdcce(%rip), %rdi      # 0x100a0
callq 0x2220
movq %rax, 0x8(%rbx)
callq 0x2b82
movl 0xd4be(%rip), %eax      # 0xf8a4
cmpl $0x3b, %eax
jne 0x2400
addq $0x8, %rsp
popq %rbx
popq %rbp
jmp 0x2b82
movl $0x1, %edi
callq 0x2200
leaq 0x8fc5(%rip), %rdi      # 0xb3cc
callq 0x25fb
// File: /workspace/github_c_makefile_star2_O3/georgeweigt[P]sassafras/sassafras.c
// Function: parse_data_body
void
parse_data_body(void)
{
	for (;;) {

		if (token == NAME) {

			// look ahead for NAME = EXPR

			while (*inp == ' ' || *inp == '\t')
				inp++;

			if (*inp == '=') {
				parse_data_expr();
				continue;
			}
		}

		keyword();

		switch (token) {
		case 0:
		case KDATA:
		case KPROC:
		case KRUN:
			if (*dfilename == 0)
				expected("infile or datalines");
			read_data_file();
			return;
		case KDATALINES:
			if (*dfilename)
				stop("Datalines after infile?");
			datalines_stmt();
			return;
		case KINPUT:
			input_stmt();
			break;
		case KINFILE:
			infile_stmt();
			break;
		default:
			parse_default();
			break;
		}
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %rbx
pushq %rax
leaq 0x8beb(%rip), %rbx      # 0xb004
cmpl $0x3e9, 0xd481(%rip)    # imm = 0x3E9
jne 0x2452
movq 0xd47c(%rip), %rax      # 0xf8a8
incq %rax
movzbl -0x1(%rax), %ecx
cmpl $0x9, %ecx
je 0x243d
cmpl $0x20, %ecx
jne 0x2446
movq %rax, 0xd464(%rip)      # 0xf8a8
jmp 0x242c
cmpl $0x3d, %ecx
jne 0x2452
callq 0x24fa
jmp 0x2419
callq 0x259c
movl 0xd447(%rip), %eax      # 0xf8a4
cmpl $0x146, %eax            # imm = 0x146
jg 0x2486
leal -0x135(%rax), %ecx
cmpl $0x6, %ecx
ja 0x2496
movslq (%rbx,%rcx,4), %rax
addq %rbx, %rax
jmpq *%rax
callq 0x2924
jmp 0x2419
callq 0x27d7
jmp 0x2419
cmpl $0x14a, %eax            # imm = 0x14A
je 0x24a4
cmpl $0x147, %eax            # imm = 0x147
jne 0x249a
jmp 0x24a4
testl %eax, %eax
je 0x24a4
callq 0x2ac3
jmp 0x2419
cmpb $0x0, 0xcfa5(%rip)      # 0xf450
je 0x24cc
addq $0x8, %rsp
popq %rbx
popq %rbp
jmp 0x2672
cmpb $0x0, 0xcf91(%rip)      # 0xf450
jne 0x24d8
addq $0x8, %rsp
popq %rbx
popq %rbp
jmp 0x2723
leaq 0x8eab(%rip), %rdi      # 0xb37e
callq 0x25fb
callq 0xa7e0
leaq 0x8eae(%rip), %rdi      # 0xb392
callq 0x4039
leaq 0x13700(%rip), %rdi     # 0x15bf0
movl $0x1, %esi
callq 0x21c0
// File: /workspace/github_c_makefile_star2_O3/georgeweigt[P]sassafras/sassafras.c
// Function: parse_data_expr
void
parse_data_expr(void)
{
	if (dd->nvar == MAXVAR)
		stop("Too many variables");
	dd->spec[dd->nvar].name = strdup(strbuf);
	scan(); // skip over name
	scan(); // skip over equals sign
	parse_expr();
	if (token != ';')
		stop("';' expected");
	scan();
	emit(STORE);
	emit(dd->nvar);
	dd->nvar++;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
movq 0xdb88(%rip), %rbx      # 0x10090
movslq 0x10(%rbx), %r14
cmpq $0x64, %r14
je 0x256c
leaq 0xdb87(%rip), %rdi      # 0x100a0
callq 0x2220
leaq (%r14,%r14,4), %rcx
movq %rax, 0x20(%rbx,%rcx,8)
callq 0x2b82
callq 0x2b82
callq 0x3928
cmpl $0x3b, 0xd367(%rip)     # 0xf8a4
jne 0x257a
callq 0x2b82
movl $0xb, %edi
callq 0x2bf5
movq 0xdb3b(%rip), %rax      # 0x10090
movl 0x10(%rax), %edi
callq 0x2bf5
movq 0xdb2c(%rip), %rax      # 0x10090
incl 0x10(%rax)
popq %rbx
popq %r14
popq %rbp
retq
callq 0xa7e0
leaq 0x8e41(%rip), %rdi      # 0xb3b9
jmp 0x2586
callq 0xa7e0
leaq 0x8f4e(%rip), %rdi      # 0xb4d4
callq 0x4039
leaq 0x1365e(%rip), %rdi     # 0x15bf0
movl $0x1, %esi
callq 0x21c0
// File: /workspace/github_c_makefile_star2_O3/georgeweigt[P]sassafras/sassafras.c
// Function: keyword
void
keyword(void)
{
	int i, n = sizeof keytab / sizeof (struct key);
	if (token != NAME)
		return;
	for (i = 0; i < n; i++)
		if (strcmp(strbuf, keytab[i].s) == 0) {
			token = keytab[i].k;
			break;
		}
}

// Assembly:
cmpl $0x3e9, 0xd2fe(%rip)    # imm = 0x3E9
jne 0x25fa
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movl $0x8, %r14d
leaq 0xcbd1(%rip), %r15      # 0xf190
leaq 0xdada(%rip), %rbx      # 0x100a0
movq -0x8(%r14,%r15), %rsi
movq %rbx, %rdi
callq 0x2170
testl %eax, %eax
je 0x25e6
addq $0x10, %r14
cmpq $0x2a8, %r14            # imm = 0x2A8
jne 0x25c6
jmp 0x25f0
movl (%r14,%r15), %eax
movl %eax, 0xd2b4(%rip)      # 0xf8a4
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/georgeweigt[P]sassafras/sassafras.c
// Function: expected
void
expected(char *s)
{
	if (token == 0)
		snprintf(errbuf, ERRBUFLEN, "Expected %s before end of program", s);
	else if (token == ';')
		snprintf(errbuf, ERRBUFLEN, "Expected %s before end of statement", s);
	else
		snprintf(errbuf, ERRBUFLEN, "Expected %s instead of \"%s\"", s, strbuf);
	stop(errbuf);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, %rcx
movl 0xd29c(%rip), %eax      # 0xf8a4
leaq 0xd2b1(%rip), %rdi      # 0xf8c0
cmpl $0x3b, %eax
je 0x2621
testl %eax, %eax
jne 0x2636
leaq 0x947a(%rip), %rdx      # 0xba99
jmp 0x2628
leaq 0x9493(%rip), %rdx      # 0xbabb
movl $0x7d0, %esi            # imm = 0x7D0
xorl %eax, %eax
callq 0x20e0
jmp 0x2650
leaq 0x94a2(%rip), %rdx      # 0xbadf
leaq 0xda5c(%rip), %r8       # 0x100a0
movl $0x7d0, %esi            # imm = 0x7D0
xorl %eax, %eax
callq 0x20e0
callq 0xa7e0
leaq 0xd264(%rip), %rdi      # 0xf8c0
callq 0x4039
leaq 0x13588(%rip), %rdi     # 0x15bf0
movl $0x1, %esi
callq 0x21c0
// File: /workspace/github_c_makefile_star2_O3/georgeweigt[P]sassafras/sassafras.c
// Function: read_data_file
void
read_data_file(void)
{
	infile = fopen(dfilename, "r");

	if (infile == NULL) {
		snprintf(errbuf, ERRBUFLEN, "Cannot open %s", dfilename);
		stop(errbuf);
	}

	get_data();

	fclose(infile);
	infile = NULL;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %rbx
pushq %rax
leaq 0xcdd1(%rip), %rdi      # 0xf450
leaq 0x91fb(%rip), %rsi      # 0xb881
callq 0x21e0
movq %rax, 0xd21e(%rip)      # 0xf8b0
testq %rax, %rax
je 0x26ba
callq 0x2b52
movq 0xd20d(%rip), %rdi      # 0xf8b0
callq 0x20a0
movq $0x0, 0xd1fd(%rip) # 0xf8b0
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
leaq 0xd1ff(%rip), %rbx      # 0xf8c0
leaq 0x8ce2(%rip), %rdx      # 0xb3aa
leaq 0xcd81(%rip), %rcx      # 0xf450
movl $0x7d0, %esi            # imm = 0x7D0
movq %rbx, %rdi
xorl %eax, %eax
callq 0x20e0
callq 0xa7e0
movq %rbx, %rdi
callq 0x4039
leaq 0x134fe(%rip), %rdi     # 0x15bf0
movl $0x1, %esi
callq 0x21c0
// File: /workspace/github_c_makefile_star2_O3/georgeweigt[P]sassafras/sassafras.c
// Function: datalines_stmt
void
datalines_stmt(void)
{
	// don't allow garbage after datalines token

	while (isspace(*inp) && *inp != '\n' && *inp != '\r')
		inp++;

	if (*inp == ';') {
		inp++;
		while (isspace(*inp) && *inp != '\n' && *inp != '\r')
			inp++;
	}

	if (*inp != '\n' && *inp != '\r') {
		scan();
		expected("datalines data");
	}

	get_data();

	scan(); // get next token (current token is still DATALINES)
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
callq 0x2240
movq (%rax), %rsi
movq 0xd172(%rip), %rcx      # 0xf8a8
movsbq (%rcx), %rdx
movzwl (%rsi,%rdx,2), %esi
btl $0xd, %esi
jb 0x2776
cmpb $0x3b, %dl
jne 0x27ae
incq %rcx
movq %rcx, 0xd155(%rip)      # 0xf8a8
movq (%rax), %rsi
movsbq (%rcx), %rdx
movzwl (%rsi,%rdx,2), %esi
btl $0xd, %esi
jae 0x27ae
movzbl %dl, %esi
cmpl $0xa, %esi
je 0x27ae
incq %rcx
cmpl $0xd, %esi
jne 0x274c
jmp 0x27ae
movzbl %dl, %esi
cmpl $0xa, %esi
je 0x27ae
cmpl $0xd, %esi
je 0x27ae
incq %rcx
movq %rcx, 0xd11b(%rip)      # 0xf8a8
movq (%rax), %rsi
movsbq (%rcx), %rdx
movzwl (%rsi,%rdx,2), %esi
btl $0xd, %esi
jae 0x2744
movzbl %dl, %esi
cmpl $0xa, %esi
je 0x27ae
incq %rcx
cmpl $0xd, %esi
jne 0x2786
cmpb $0xa, %dl
je 0x27bb
movzbl %dl, %eax
cmpl $0xd, %eax
jne 0x27c6
callq 0x2b52
popq %rbp
jmp 0x2b82
callq 0x2b82
leaq 0x8c6c(%rip), %rdi      # 0xb43e
callq 0x25fb
// File: /workspace/github_c_makefile_star2_O3/georgeweigt[P]sassafras/sassafras.c
// Function: input_stmt
void
input_stmt(void)
{
	int n;

	scan(); // get next token after INPUT

	// scan data specifiers

	for (;;) {

		if (token != NAME)
			break;

		if (dd->nvar == MAXVAR)
			stop("Too many variables");

		n = dd->nvar++;

		dd->spec[n].name = strdup(strbuf);

		scan();

		if (token == '$') {
			dd->spec[n].max_levels = 10;
			dd->spec[n].num_levels = 0;
			dd->spec[n].ltab = (char **) xmalloc(10 * sizeof (char *));
			emit(SCAN_STR);
			emit(n);
			scan();
		} else {
			dd->spec[n].max_levels = 0;
			dd->spec[n].num_levels = 0;
			dd->spec[n].ltab = NULL;
			emit(SCAN_NUM);
			emit(n);
		}
	}

	if (token == ATAT) {
		emit(CHKBUF);
		scan();
	} else
		emit(GETBUF);

	if (token != ';')
		expected("end of statement");

	scan();
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
callq 0x2b82
leaq 0xd8b2(%rip), %rbx      # 0x100a0
movl 0xd0b0(%rip), %eax      # 0xf8a4
cmpl $0x3e9, %eax            # imm = 0x3E9
jne 0x28b4
movq 0xd88a(%rip), %r15      # 0x10090
movslq 0x10(%r15), %r14
cmpq $0x64, %r14
je 0x28ec
leal 0x1(%r14), %eax
movl %eax, 0x10(%r15)
movq %rbx, %rdi
callq 0x2220
leaq (,%r14,8), %rcx
leaq (%rcx,%rcx,4), %r12
movq %rax, 0x20(%r15,%r12)
callq 0x2b82
movq 0xd84f(%rip), %r15      # 0x10090
cmpl $0x24, 0xd05c(%rip)     # 0xf8a4
leaq 0x28(%r15,%r12), %rax
jne 0x289a
addq $0x20, %r15
movl $0xa, (%rax)
leaq (%r14,%r14,4), %r12
movl $0x0, 0xc(%r15,%r12,8)
movl $0x50, %edi
callq 0x2190
testq %rax, %rax
je 0x290e
movq %rax, 0x10(%r15,%r12,8)
movl $0x1, %edi
callq 0x2bf5
movl %r14d, %edi
callq 0x2bf5
callq 0x2b82
jmp 0x27ee
xorps %xmm0, %xmm0
movups %xmm0, (%rax)
xorl %edi, %edi
callq 0x2bf5
movl %r14d, %edi
callq 0x2bf5
jmp 0x27ee
cmpl $0x3ec, %eax            # imm = 0x3EC
jne 0x28cc
movl $0xd, %edi
callq 0x2bf5
callq 0x2b82
jmp 0x28d6
movl $0xc, %edi
callq 0x2bf5
cmpl $0x3b, 0xcfc7(%rip)     # 0xf8a4
jne 0x2918
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
jmp 0x2b82
callq 0xa7e0
leaq 0x8ac1(%rip), %rdi      # 0xb3b9
callq 0x4039
leaq 0x132ec(%rip), %rdi     # 0x15bf0
movl $0x1, %esi
callq 0x21c0
movl $0x1, %edi
callq 0x2200
leaq 0x91af(%rip), %rdi      # 0xbace
callq 0x25fb
// File: /workspace/github_c_makefile_star2_O3/georgeweigt[P]sassafras/sassafras.c
// Function: infile_stmt
void
infile_stmt(void)
{
	if (dfilename[0])
		stop("Multiple INFILE statements");

	get_next_token();

	switch (token) {
	case STRING:
		strcpy(dfilename, strbuf);
		break;
	case KCARDS:
	case KDATALINES:
		break;
	default:
		expected("file name");
	}

	for (;;) {

		scan();
		keyword();

		switch (token) {

		case ';':
			scan();
			return;

		case KDLM:
		case KDELIMITER:
			scan();
			if (token != '=')
				expected("equals sign");
			scan();
			if (token != STRING)
				expected("string");
			if (strlen(strbuf) >= sizeof delim)
				stop("string too long");
			strcpy(delim, strbuf);
			break;

		case KFIRSTOBS:
			scan();
			if (token != '=')
				expected("equals sign");
			scan();
			if (token != NUMBER)
				expected("number");
			if (sscanf(strbuf, "%d", &firstobs) != 1)
				stop("Error in number syntax");
			break;

		default:
			expected("end of statement");
		}
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
cmpb $0x0, 0xcb1b(%rip)      # 0xf450
jne 0x2972
callq 0x2b82
movl 0xcf62(%rip), %eax      # 0xf8a4
cmpl $0x3e9, %eax            # imm = 0x3E9
jne 0x2954
callq 0x259c
movl 0xcf50(%rip), %eax      # 0xf8a4
cmpl $0x130, %eax            # imm = 0x130
je 0x29ae
cmpl $0x136, %eax            # imm = 0x136
je 0x29ae
cmpl $0x3eb, %eax            # imm = 0x3EB
jne 0x2980
leaq 0xcae0(%rip), %rdi      # 0xf450
jmp 0x29a2
callq 0xa7e0
leaq 0x8a5e(%rip), %rdi      # 0xb3dc
jmp 0x298c
leaq 0x8a70(%rip), %rdi      # 0xb3f7
callq 0x25fb
callq 0x4039
leaq 0x13258(%rip), %rdi     # 0x15bf0
movl $0x1, %esi
callq 0x21c0
leaq 0xd6f7(%rip), %rsi      # 0x100a0
callq 0x2060
leaq 0xd6eb(%rip), %rbx      # 0x100a0
leaq 0x8a68(%rip), %r14      # 0xb424
leaq 0xca81(%rip), %r15      # 0xf444
callq 0x2b82
callq 0x259c
movl 0xced1(%rip), %eax      # 0xf8a4
cmpl $0x139, %eax            # imm = 0x139
jne 0x2a27
callq 0x2b82
cmpl $0x3d, 0xcebe(%rip)     # 0xf8a4
jne 0x2a93
callq 0x2b82
cmpl $0x3ea, 0xcea9(%rip)    # imm = 0x3EA
jne 0x2a9f
movq %rbx, %rdi
movq %r14, %rsi
movq %r15, %rdx
xorl %eax, %eax
callq 0x21a0
cmpl $0x1, %eax
je 0x29c3
callq 0xa7e0
leaq 0x8a05(%rip), %rdi      # 0xb427
jmp 0x298c
leal -0x137(%rax), %ecx
cmpl $0x2, %ecx
jae 0x2a7f
callq 0x2b82
cmpl $0x3d, 0xce66(%rip)     # 0xf8a4
jne 0x2a93
callq 0x2b82
cmpl $0x3eb, 0xce55(%rip)    # imm = 0x3EB
jne 0x2ab7
leaq 0xd648(%rip), %rdi      # 0x100a0
callq 0x20b0
leaq 0xcddc(%rip), %rdi      # 0xf840
cmpq $0x64, %rax
jb 0x29a2
callq 0xa7e0
leaq 0x8993(%rip), %rdi      # 0xb40d
jmp 0x298c
cmpl $0x3b, %eax
jne 0x2aab
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
jmp 0x2b82
leaq 0x8967(%rip), %rdi      # 0xb401
callq 0x25fb
leaq 0x8977(%rip), %rdi      # 0xb41d
callq 0x25fb
leaq 0x901c(%rip), %rdi      # 0xbace
callq 0x25fb
leaq 0x9062(%rip), %rdi      # 0xbb20
callq 0x25fb
// File: /workspace/github_c_makefile_star2_O3/georgeweigt[P]sassafras/sassafras.c
// Function: parse_default
void
parse_default(void)
{
	switch (token) {
	case ';':
		scan();
		break;
	case '*':
		parse_comment_stmt();
		break;
	case KTITLE:
		title_stmt();
		break;
	case KTITLE1:
		title1_stmt();
		break;
	case KTITLE2:
		title2_stmt();
		break;
	case KTITLE3:
		title3_stmt();
		break;
	default:
		stop("Unexpected token, did you mean proc?");
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movl 0xcdd7(%rip), %eax      # 0xf8a4
leal -0x151(%rax), %ecx
cmpl $0x3, %ecx
ja 0x2aee
leaq 0x8541(%rip), %rax      # 0xb020
movslq (%rax,%rcx,4), %rcx
addq %rax, %rcx
jmpq *%rcx
popq %rbp
jmp 0x40a8
cmpl $0x2a, %eax
je 0x2b04
cmpl $0x3b, %eax
jne 0x2b30
popq %rbp
jmp 0x2b82
popq %rbp
jmp 0x41b8
movq 0xcd9d(%rip), %rax      # 0xf8a8
incq %rax
movzbl -0x1(%rax), %ecx
testl %ecx, %ecx
je 0x2af8
cmpl $0x3b, %ecx
je 0x2af8
movq %rax, 0xcd86(%rip)      # 0xf8a8
jmp 0x2b0b
popq %rbp
jmp 0x4240
popq %rbp
jmp 0x4130
callq 0xa7e0
leaq 0x8a2f(%rip), %rdi      # 0xb56b
callq 0x4039
leaq 0x130a8(%rip), %rdi     # 0x15bf0
movl $0x1, %esi
callq 0x21c0
// File: /workspace/github_c_makefile_star2_O3/georgeweigt[P]sassafras/sassafras.c
// Function: get_data
void
get_data(void)
{
	alloc_data_vectors();
	getbuf();
	while (inb) {
		check_data_vectors();
		get_data1();
		dd->nobs++;
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
callq 0x2c5c
callq 0x2cb1
cmpq $0x0, 0xd920(%rip)      # 0x10488
je 0x2b80
callq 0x2d7f
callq 0x2de2
movq 0xd515(%rip), %rax      # 0x10090
incl 0x14(%rax)
jmp 0x2b60
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/georgeweigt[P]sassafras/sassafras.c
// Function: scan
void
scan(void)
{
	static int t;

	if (inp == pgm)
		t = 0; // initial state
	else
		t = token;

	token = scan1();

	// ensure last token is semicolon

	if (token == 0 && t && t != ';') {
		strbuf[0] = ';';
		strbuf[1] = 0;
		token = ';';
	}
}

// Assembly:
movq 0xcd1f(%rip), %rcx      # 0xf8a8
xorl %eax, %eax
cmpq 0x13126(%rip), %rcx     # 0x15cb8
je 0x2b9a
movl 0xcd0a(%rip), %eax      # 0xf8a4
pushq %rbp
movq %rsp, %rbp
movl %eax, 0x1311c(%rip)     # 0x15cc0
callq 0xa888
movl %eax, 0xccf5(%rip)      # 0xf8a4
testl %eax, %eax
popq %rbp
je 0x2bb5
retq
movl 0x13105(%rip), %eax     # 0x15cc0
testl %eax, %eax
je 0x2bb4
cmpl $0x3b, %eax
je 0x2bb4
movw $0x3b, 0xd4d3(%rip)     # 0x100a0
movl $0x3b, 0xcccd(%rip)     # 0xf8a4
retq
// File: /workspace/github_c_makefile_star2_O3/georgeweigt[P]sassafras/sassafras.c
// Function: xmalloc
void *
xmalloc(int size)
{
	void *p = malloc(size);
	if (p == NULL)
		exit(1);
	return p;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movslq %edi, %rdi
callq 0x2190
testq %rax, %rax
je 0x2beb
popq %rbp
retq
movl $0x1, %edi
callq 0x2200
// File: /workspace/github_c_makefile_star2_O3/georgeweigt[P]sassafras/sassafras.c
// Function: alloc_data_vectors
void
alloc_data_vectors(void)
{
	int i;
	for (i = 0; i < dd->nvar; i++)
		if (dd->spec[i].v == NULL)
			dd->spec[i].v = (double *) xmalloc(dd->max * sizeof (double));
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
movq 0xd426(%rip), %rax      # 0x10090
cmpl $0x0, 0x10(%rax)
jle 0x2cac
movl $0x40, %ebx
xorl %r14d, %r14d
cmpq $0x0, (%rax,%rbx)
jne 0x2c9c
movl 0x18(%rax), %edi
shll $0x3, %edi
callq 0x2bd8
movq 0xd3ff(%rip), %rcx      # 0x10090
movq %rax, (%rcx,%rbx)
movq 0xd3f4(%rip), %rax      # 0x10090
incq %r14
movslq 0x10(%rax), %rcx
addq $0x28, %rbx
cmpq %rcx, %r14
jl 0x2c78
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/georgeweigt[P]sassafras/sassafras.c
// Function: getbuf
void
getbuf(void)
{
	do {
		if (infile)
			for (;;) {
				inb = fgets(bigbuf, BIGBUFLEN, infile);
				if (inb == NULL || firstobs < 2)
					break;
				firstobs--;
			}
		else
			inb = get_dataline(bigbuf, BIGBUFLEN);

		if (inb == NULL)
			return;

		// skip spaces

		while (isspace(*inb))
			inb++;

	} while (*inb == 0); // skip blank lines
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
leaq 0x10211(%rip), %rbx     # 0x12ed0
movq 0xcbea(%rip), %rdx      # 0xf8b0
movq %rbx, %rdi
movl $0xfa0, %esi            # imm = 0xFA0
testq %rdx, %rdx
je 0x2d30
callq 0x2140
movq %rax, %r14
movq %rax, 0xd7a6(%rip)      # 0x10488
testq %rax, %rax
sete %cl
movl 0xc756(%rip), %eax      # 0xf444
cmpl $0x2, %eax
setl %dl
orb %cl, %dl
jne 0x2d3f
decl %eax
movl %eax, 0xc744(%rip)      # 0xf444
movq 0xcba9(%rip), %rdx      # 0xf8b0
movq %rbx, %rdi
movl $0xfa0, %esi            # imm = 0xFA0
callq 0x2140
movq %rax, %r14
movq %rax, 0xd76a(%rip)      # 0x10488
testq %rax, %rax
je 0x2d3f
movl 0xc71b(%rip), %eax      # 0xf444
cmpl $0x2, %eax
jge 0x2cf8
jmp 0x2d3f
callq 0x35eb
movq %rax, %r14
movq %rax, 0xd749(%rip)      # 0x10488
testq %r14, %r14
je 0x2d7a
callq 0x2240
movq (%rax), %rdx
movsbq (%r14), %rcx
testb $0x20, 0x1(%rdx,%rcx,2)
je 0x2d72
incq %r14
movq %r14, 0xd727(%rip)      # 0x10488
movq (%rax), %rdx
movsbq (%r14), %rcx
incq %r14
testb $0x20, 0x1(%rdx,%rcx,2)
jne 0x2d5a
testb %cl, %cl
je 0x2cbf
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/georgeweigt[P]sassafras/sassafras.c
// Function: check_data_vectors
void
check_data_vectors(void)
{
	int i;
	if (dd->nobs < dd->max)
		return;
	dd->max += 1000;
	for (i = 0; i < dd->nvar; i++)
		dd->spec[i].v = xrealloc(dd->spec[i].v, dd->max * sizeof (double));
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
movq 0xd303(%rip), %rax      # 0x10090
movl 0x18(%rax), %ecx
cmpl %ecx, 0x14(%rax)
jl 0x2ddd
addl $0x3e8, %ecx            # imm = 0x3E8
movl %ecx, 0x18(%rax)
cmpl $0x0, 0x10(%rax)
jle 0x2ddd
movl $0x40, %ebx
xorl %r14d, %r14d
movq (%rax,%rbx), %rdi
movl 0x18(%rax), %esi
shll $0x3, %esi
callq 0x35ce
movq 0xd2ce(%rip), %rcx      # 0x10090
movq %rax, (%rcx,%rbx)
incq %r14
movq 0xd2c0(%rip), %rax      # 0x10090
movslq 0x10(%rax), %rcx
addq $0x28, %rbx
cmpq %rcx, %r14
jl 0x2dac
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/georgeweigt[P]sassafras/sassafras.c
// Function: get_digits
int
get_digits(void)
{
	int n = 0;
	char *s = inb;

	// scan to decimal point

	while (strchr(delim, *s) == NULL && *s != '.')
		s++;

	if (*s != '.')
		return 0;

	while (isdigit(*++s) && n < 8)
		n++;

	return n;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq 0xd340(%rip), %r15      # 0x10488
leaq 0xc6f1(%rip), %rbx      # 0xf840
movsbl (%r15), %r14d
movq %rbx, %rdi
movl %r14d, %esi
callq 0x20c0
incq %r15
cmpl $0x2e, %r14d
je 0x316c
testq %rax, %rax
je 0x314f
xorl %eax, %eax
cmpb $0x2e, %r14b
jne 0x3198
callq 0x2240
movq (%rax), %rcx
xorl %edx, %edx
movsbq (%r15,%rdx), %rsi
leaq 0x1(%rdx), %rax
testb $0x8, 0x1(%rcx,%rsi,2)
je 0x3196
cmpl $0x8, %edx
movq %rax, %rdx
jb 0x317e
decl %eax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/georgeweigt[P]sassafras/sassafras.c
// Function: get_number
double
get_number(void)
{
	double d = NAN;

	// check end of input

	if (inb == NULL)
		return d;

	// scan leading spaces

	while (isspace(*inb))
		inb++;

	if (*inb == 0)
		return d;

	if (strchr(delim, *inb)) {
		inb++;
		return d;
	}

	// scan number

	sscanf(inb, "%lg", &d);

	// scan delimiter

	while (strchr(delim, *inb) == NULL)
		inb++;

	if (*inb)
		inb++;

	return d;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movabsq $0x7ff8000000000000, %rax # imm = 0x7FF8000000000000
movq %rax, -0x20(%rbp)
movq 0xd2c6(%rip), %rbx      # 0x10488
movsd 0x80f6(%rip), %xmm0     # 0xb2c0
testq %rbx, %rbx
je 0x32af
callq 0x2240
movq (%rax), %rdx
movsbq (%rbx), %rcx
testb $0x20, 0x1(%rdx,%rcx,2)
je 0x3204
incq %rbx
movq %rbx, 0xd298(%rip)      # 0x10488
movq (%rax), %rdx
movsbq (%rbx), %rcx
incq %rbx
testb $0x20, 0x1(%rdx,%rcx,2)
jne 0x31e9
decq %rbx
movsd 0x80b4(%rip), %xmm0     # 0xb2c0
testb %cl, %cl
je 0x32af
movsbl %cl, %esi
leaq 0xc622(%rip), %rdi      # 0xf840
callq 0x20c0
testq %rax, %rax
je 0x323c
incq %rbx
movq %rbx, 0xd256(%rip)      # 0x10488
movsd 0x8086(%rip), %xmm0     # 0xb2c0
jmp 0x32af
leaq 0x8237(%rip), %rsi      # 0xb47a
leaq -0x20(%rbp), %rdx
movq %rbx, %rdi
xorl %eax, %eax
callq 0x21a0
movq 0xd230(%rip), %r14      # 0x10488
movb (%r14), %r15b
movsbl %r15b, %esi
leaq 0xc5da(%rip), %rdi      # 0xf840
callq 0x20c0
testq %rax, %rax
jne 0x329b
incq %r14
leaq 0xc5c6(%rip), %rbx      # 0xf840
movq %r14, 0xd207(%rip)      # 0x10488
movb (%r14), %r15b
movsbl %r15b, %esi
movq %rbx, %rdi
callq 0x20c0
incq %r14
testq %rax, %rax
je 0x327a
decq %r14
testb %r15b, %r15b
je 0x32aa
incq %r14
movq %r14, 0xd1de(%rip)      # 0x10488
movsd -0x20(%rbp), %xmm0
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/georgeweigt[P]sassafras/sassafras.c
// Function: get_string
void
get_string(void)
{
	int i, n;
	char *s, *t;

	lbuf[0] = 0;

	// check end of input

	if (inb == NULL)
		return;

	// scan leading spaces

	while (isspace(*inb))
		inb++;

	if (*inb == 0)
		return;

	if (strchr(delim, *inb)) {
		inb++;
		return;
	}

	// start of string

	s = inb;

	// find end of string

	while (strchr(delim, *inb) == NULL)
		inb++;

	// skip trailing spaces

	t = inb;
	while (isspace(t[-1]))
		t--;

	n = (int) (t - s);

	if (n + 1 > sizeof lbuf)
		stop("In the observed data, a level name is too long");

	// missing data char?

	if (n == 1 && *s == '.')
		return;

	// copy the string into lbuf

	for (i = 0; i < n; i++)
		lbuf[i] = s[i];

	lbuf[n] = 0;

	// scan delimiter

	if (*inb)
		inb++;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movb $0x0, 0x10ba1(%rip)     # 0x13e70
movq 0xd1b2(%rip), %r15      # 0x10488
testq %r15, %r15
je 0x3404
callq 0x2240
movq %rax, %rbx
movq (%rax), %rcx
movsbq (%r15), %rax
testb $0x20, 0x1(%rcx,%rax,2)
je 0x3313
incq %r15
movq %r15, 0xd189(%rip)      # 0x10488
movq (%rbx), %rcx
movsbq (%r15), %rax
incq %r15
testb $0x20, 0x1(%rcx,%rax,2)
jne 0x32f8
decq %r15
testb %al, %al
je 0x3404
movsbl %al, %esi
leaq 0xc51b(%rip), %rdi      # 0xf840
callq 0x20c0
testq %rax, %rax
je 0x3337
incq %r15
jmp 0x33fd
movl $0x1, %r12d
xorl %r13d, %r13d
movabsq $-0x100000000, %r14     # imm = 0xFFFFFFFF00000000
addq %r14, %r13
leaq (%r15,%r12), %rax
movq %rax, 0xd130(%rip)      # 0x10488
movsbl (%r15,%r12), %esi
leaq 0xc4dc(%rip), %rdi      # 0xf840
callq 0x20c0
incq %r12
testq %rax, %rax
je 0x334a
movabsq $0x100000000, %rax      # imm = 0x100000000
movq (%rbx), %rdx
movq %r12, %rcx
movsbq -0x2(%r15,%rcx), %rsi
decq %rcx
addq %rax, %r13
testb $0x20, 0x1(%rdx,%rsi,2)
jne 0x3381
movabsq $-0x6200000001, %rdx    # imm = 0xFFFFFF9DFFFFFFFF
subq %r13, %rdx
movabsq $-0x6400000002, %rsi    # imm = 0xFFFFFF9BFFFFFFFE
cmpq %rsi, %rdx
jbe 0x3413
cmpl $0x1, %ecx
jne 0x33bd
cmpb $0x2e, (%r15)
jne 0x33c1
jmp 0x3404
testl %ecx, %ecx
jle 0x33e0
andl $0x7fffffff, %ecx       # imm = 0x7FFFFFFF
xorl %edx, %edx
leaq 0x10aa0(%rip), %rsi     # 0x13e70
movb (%r15,%rdx), %dil
movb %dil, (%rdx,%rsi)
incq %rdx
cmpq %rcx, %rdx
jb 0x33d0
subq %r13, %rax
sarq $0x20, %rax
leaq 0x10a82(%rip), %rcx     # 0x13e70
movb $0x0, (%rax,%rcx)
cmpb $0x0, -0x1(%r15,%r12)
je 0x3404
addq %r12, %r15
movq %r15, 0xd084(%rip)      # 0x10488
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
callq 0xa7e0
leaq 0x805f(%rip), %rdi      # 0xb47e
callq 0x4039
leaq 0x127c5(%rip), %rdi     # 0x15bf0
movl $0x1, %esi
callq 0x21c0
// File: /workspace/github_c_makefile_star2_O3/georgeweigt[P]sassafras/sassafras.c
// Function: catvar
void
catvar(int x, int obs)
{
	int i, m, n;

	// missing data?

	if (lbuf[0] == 0) {
		dd->spec[x].v[obs] = NAN;
		return;
	}

	m = dd->spec[x].max_levels;
	n = dd->spec[x].num_levels;

	// search for the level name

	for (i = 0; i < n; i++)
		if (strcmp(dd->spec[x].ltab[i], lbuf) == 0)
			break;

	// check for new level name

	if (i == n) {

		// get space for more levels if necessary

		if (m == n) {
			m += 100;
			dd->spec[x].max_levels = m;
			dd->spec[x].ltab = xrealloc(dd->spec[x].ltab, m * sizeof (char *));
		}

		dd->spec[x].ltab[i] = strdup(lbuf);
		dd->spec[x].num_levels++;
	}

	// save the level number

	dd->spec[x].v[obs] = i;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x28, %rsp
movl %esi, %r15d
movq 0xcc40(%rip), %r12      # 0x10090
cmpb $0x0, 0x10a19(%rip)     # 0x13e70
movslq %edi, %r14
je 0x34bd
leaq 0x20(%r12), %rdx
leaq (%r14,%r14,4), %rax
movl 0x8(%rdx,%rax,8), %esi
movl 0xc(%rdx,%rax,8), %ebx
testl %ebx, %ebx
jle 0x34ca
movq %rsi, -0x38(%rbp)
movq %r14, -0x48(%rbp)
movl %r15d, -0x2c(%rbp)
movq %rdx, -0x40(%rbp)
movq 0x10(%rdx,%rax,8), %r15
xorl %r13d, %r13d
leaq 0x109e0(%rip), %r14     # 0x13e70
movq (%r15,%r13,8), %rdi
movq %r14, %rsi
callq 0x2170
testl %eax, %eax
je 0x34cf
incq %r13
cmpq %r13, %rbx
jne 0x3490
movl %ebx, %r13d
movl -0x2c(%rbp), %r15d
movq -0x48(%rbp), %r14
movq -0x40(%rbp), %rdx
movq -0x38(%rbp), %rsi
jmp 0x34e4
movsd 0x7dfb(%rip), %xmm0     # 0xb2c0
jmp 0x3558
xorl %r13d, %r13d
jmp 0x34df
movl -0x2c(%rbp), %r15d
movq -0x48(%rbp), %r14
movq -0x40(%rbp), %rdx
movq -0x38(%rbp), %rsi
cmpl %ebx, %r13d
jne 0x3553
cmpl %ebx, %esi
jne 0x3526
leal 0x64(%rsi), %eax
leaq (,%r14,8), %rcx
movq %r14, %r12
leaq (%rcx,%rcx,4), %r14
movl %eax, 0x8(%rdx,%r14)
movq 0x10(%rdx,%r14), %rdi
leal 0x320(,%rsi,8), %esi
callq 0x35ce
movq 0xcb79(%rip), %rcx      # 0x10090
movq %rax, 0x30(%rcx,%r14)
movq %r12, %r14
movq 0xcb6a(%rip), %r12      # 0x10090
leaq 0x10943(%rip), %rdi     # 0x13e70
callq 0x2220
leaq (,%r14,8), %rcx
leaq (%rcx,%rcx,4), %rcx
movq 0x30(%r12,%rcx), %rdx
movq %rax, (%rdx,%rbx,8)
movq 0xcb42(%rip), %r12      # 0x10090
incl 0x2c(%r12,%rcx)
cvtsi2sd %r13d, %xmm0
leaq (%r14,%r14,4), %rax
movq 0x40(%r12,%rax,8), %rax
movslq %r15d, %rcx
movsd %xmm0, (%rax,%rcx,8)
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/georgeweigt[P]sassafras/sassafras.c
// Function: chkbuf
void
chkbuf(void)
{
	// check for end of input

	if (inb == NULL)
		return;

	// skip spaces

	while (isspace(*inb))
		inb++;

	if (*inb == 0)
		getbuf();
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %rbx
pushq %rax
movq 0xcf03(%rip), %rbx      # 0x10488
testq %rbx, %rbx
je 0x35bc
callq 0x2240
movq (%rax), %rdx
movsbq (%rbx), %rcx
testb $0x20, 0x1(%rdx,%rcx,2)
je 0x35b8
incq %rbx
movq %rbx, 0xcee1(%rip)      # 0x10488
movq (%rax), %rdx
movsbq (%rbx), %rcx
incq %rbx
testb $0x20, 0x1(%rdx,%rcx,2)
jne 0x35a0
testb %cl, %cl
je 0x35c3
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
addq $0x8, %rsp
popq %rbx
popq %rbp
jmp 0x2cb1
// File: /workspace/github_c_makefile_star2_O3/georgeweigt[P]sassafras/sassafras.c
// Function: xrealloc
void *
xrealloc(void *p, int size)
{
	p = realloc(p, size);
	if (p == NULL)
		exit(1);
	return p;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movslq %esi, %rsi
callq 0x21b0
testq %rax, %rax
je 0x35e1
popq %rbp
retq
movl $0x1, %edi
callq 0x2200
// File: /workspace/github_c_makefile_star2_O3/georgeweigt[P]sassafras/sassafras.c
// Function: get_dataline
char *
get_dataline(char *buf, int len)
{
	int i;

	// scan to end of current line

	while (*inp && *inp != ';' && *inp != '\n' && *inp != '\r')
		inp++;

	// end of input?

	if (*inp == 0 || *inp == ';')
		return NULL;

	// skip end of line

	if (inp[0] == '\r' && inp[1] == '\n')
		inp += 2;
	else
		inp += 1;

	while (isspace(*inp) && *inp != '\n' && *inp != '\r')
		inp++;

	if (*inp == 0 || *inp == ';' || *inp == '\n' || *inp == '\r')
		return NULL;

	// copy data line into buf

	for (i = 0; i < len - 1; i++) {
		buf[i] = *inp++;
		if (*inp == 0 || *inp == ';' || *inp == '\n' || *inp == '\r')
			break;
	}

	if (i == len - 1)
		stop("Buffer overrun");

	buf[i + 1] = 0;

	return buf;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movl %esi, %r14d
movq %rdi, %rbx
movq 0xc2a6(%rip), %rax      # 0xf8a8
incq %rax
movzbl -0x1(%rax), %ecx
cmpl $0xc, %ecx
jg 0x3619
testl %ecx, %ecx
je 0x368b
cmpl $0xa, %ecx
jne 0x3623
jmp 0x3636
cmpl $0xd, %ecx
je 0x362c
cmpl $0x3b, %ecx
je 0x368b
movq %rax, 0xc27e(%rip)      # 0xf8a8
jmp 0x3602
movl $0x2, %ecx
cmpb $0xa, (%rax)
je 0x363b
movl $0x1, %ecx
leaq (%rax,%rcx), %r15
decq %r15
callq 0x2240
movq %r15, 0xc25a(%rip)      # 0xf8a8
movq (%rax), %rcx
movsbq (%r15), %rsi
movzbl %sil, %edx
movzwl (%rcx,%rsi,2), %ecx
btl $0xd, %ecx
jae 0x3672
cmpl $0xa, %edx
je 0x368b
incq %r15
cmpl $0xd, %edx
jne 0x3647
jmp 0x368b
xorl %eax, %eax
movabsq $0x800000000002401, %rcx # imm = 0x800000000002401
cmpl $0x3b, %edx
ja 0x369b
movl %edx, %edx
btq %rdx, %rcx
jae 0x369b
xorl %ebx, %ebx
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
leal -0x1(%r14), %edx
cmpl $0x2, %r14d
jl 0x36dc
movl %edx, %esi
xorl %eax, %eax
leaq 0x1(%r15), %rdi
movq %rdi, 0xc1f4(%rip)      # 0xf8a8
movb (%r15), %dil
movb %dil, (%rbx,%rax)
movq 0xc1e6(%rip), %r15      # 0xf8a8
movzbl (%r15), %edi
cmpq $0x3b, %rdi
ja 0x36d2
btq %rdi, %rcx
jb 0x36dc
incq %rax
cmpq %rax, %rsi
jne 0x36a9
jmp 0x36e9
cmpl %edx, %eax
je 0x36e9
movl %eax, %eax
movb $0x0, 0x1(%rbx,%rax)
jmp 0x368d
callq 0xa7e0
leaq 0x7fa1(%rip), %rdi      # 0xb696
callq 0x4039
leaq 0x124ef(%rip), %rdi     # 0x15bf0
movl $0x1, %esi
callq 0x21c0
// File: /workspace/github_c_makefile_star2_O3/georgeweigt[P]sassafras/sassafras.c
// Function: dump_data
void
dump_data(void)
{
	int i, j;
	double d;

	printf("dump_data: %s nvar=%d\n", dd->name, dd->nvar);

	for (i = 0; i < dd->nvar; i++)
		printf(" %s", dd->spec[i].name);

	printf("\n");

	for (i = 0; i < dd->nobs; i++) {
		for (j = 0; j < dd->nvar; j++) {
			d = dd->spec[j].v[i];
			if (dd->spec[j].ltab)
				printf(" %s", dd->spec[j].ltab[(int) d]);
			else
				printf(" %g", d);
		}
		printf("\n");
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq 0xc970(%rip), %rax      # 0x10090
movq 0x8(%rax), %rsi
movl 0x10(%rax), %edx
leaq 0x7d7f(%rip), %rdi      # 0xb4ad
xorl %eax, %eax
callq 0x20d0
movq 0xc954(%rip), %rax      # 0x10090
cmpl $0x0, 0x10(%rax)
jle 0x3777
movl $0x20, %r14d
leaq 0x81b5(%rip), %rbx      # 0xb904
xorl %r15d, %r15d
movq (%rax,%r14), %rsi
movq %rbx, %rdi
xorl %eax, %eax
callq 0x20d0
incq %r15
movq 0xc926(%rip), %rax      # 0x10090
movslq 0x10(%rax), %rcx
addq $0x28, %r14
cmpq %rcx, %r15
jl 0x3752
movl $0xa, %edi
callq 0x2050
movq 0xc908(%rip), %rax      # 0x10090
cmpl $0x0, 0x14(%rax)
jle 0x381a
leaq 0x7d2b(%rip), %rbx      # 0xb4c4
leaq 0x8164(%rip), %r14      # 0xb904
xorl %r15d, %r15d
cmpl $0x0, 0x10(%rax)
jle 0x37fd
movl $0x40, %r12d
xorl %r13d, %r13d
movq -0x10(%rax,%r12), %rcx
movq (%rax,%r12), %rax
movsd (%rax,%r15,8), %xmm0
testq %rcx, %rcx
je 0x37dc
cvttsd2si %xmm0, %eax
cltq
movq (%rcx,%rax,8), %rsi
movq %r14, %rdi
xorl %eax, %eax
callq 0x20d0
jmp 0x37e6
movq %rbx, %rdi
movb $0x1, %al
callq 0x20d0
incq %r13
movq 0xc8a0(%rip), %rax      # 0x10090
movslq 0x10(%rax), %rcx
addq $0x28, %r12
cmpq %rcx, %r13
jl 0x37b2
movl $0xa, %edi
callq 0x2050
incq %r15
movq 0xc87f(%rip), %rax      # 0x10090
movslq 0x14(%rax), %rcx
cmpq %rcx, %r15
jl 0x37a3
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/georgeweigt[P]sassafras/sassafras.c
// Function: free_datasets
void
free_datasets(void)
{
	int i;
	struct dataset *t;

	while (dd) {
		t = dd;
		dd = dd->next;
		if (t->name)
			free(t->name);
		for (i = 0; i < MAXVAR; i++) {
			if (t->spec[i].name)
				free(t->spec[i].name);
			if (t->spec[i].v)
				free(t->spec[i].v);
			if (t->spec[i].ltab)
				free(t->spec[i].ltab);
		}
		free(t);
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
movq 0xc859(%rip), %rbx      # 0x10090
testq %rbx, %rbx
je 0x389d
movq (%rbx), %rax
movq %rax, 0xc84a(%rip)      # 0x10090
movq 0x8(%rbx), %rdi
testq %rdi, %rdi
je 0x3854
callq 0x2040
movl $0x40, %r14d
movq -0x20(%rbx,%r14), %rdi
testq %rdi, %rdi
je 0x3869
callq 0x2040
movq (%rbx,%r14), %rdi
testq %rdi, %rdi
je 0x3877
callq 0x2040
movq -0x10(%rbx,%r14), %rdi
testq %rdi, %rdi
je 0x3886
callq 0x2040
addq $0x28, %r14
cmpq $0xfe0, %r14            # imm = 0xFE0
jne 0x385a
movq %rbx, %rdi
callq 0x2040
jmp 0x3830
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/georgeweigt[P]sassafras/sassafras.c
// Function: select_dataset
void
select_dataset(char *s)
{
	dataset = dd;
	if (s == NULL)
		return;
	while (dataset) {
		if (dataset->name && strcmp(dataset->name, s) == 0)
			return;
		dataset = dataset->next;
	}
	snprintf(errbuf, ERRBUFLEN, "Dataset %s?", s);
	stop(errbuf);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
movq 0xc7e0(%rip), %r14      # 0x10090
movq %r14, 0x10621(%rip)     # 0x13ed8
testq %rdi, %rdi
je 0x38e5
movq %rdi, %rbx
testq %r14, %r14
je 0x38ea
movq 0x8(%r14), %rdi
testq %rdi, %rdi
je 0x38d9
movq %rbx, %rsi
callq 0x2170
testl %eax, %eax
je 0x38e5
movq (%r14), %r14
movq %r14, 0x105f5(%rip)     # 0x13ed8
jmp 0x38bf
popq %rbx
popq %r14
popq %rbp
retq
leaq 0xbfcf(%rip), %r14      # 0xf8c0
leaq 0x7bd0(%rip), %rdx      # 0xb4c8
movl $0x7d0, %esi            # imm = 0x7D0
movq %r14, %rdi
movq %rbx, %rcx
xorl %eax, %eax
callq 0x20e0
callq 0xa7e0
movq %r14, %rdi
callq 0x4039
leaq 0x122d2(%rip), %rdi     # 0x15bf0
movl $0x1, %esi
callq 0x21c0
// File: /workspace/github_c_makefile_star2_O3/georgeweigt[P]sassafras/sassafras.c
// Function: parse_term
void
parse_term(void)
{
	parse_factor();

	for (;;) {
		switch (token) {
		case '*':
			scan();
			parse_factor();
			emit(MUL);
			break;
		case '/':
			scan();
			parse_factor();
			emit(DIV);
			break;
		default:
			return;
		}
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %rbx
pushq %rax
callq 0x39d1
movl $0x5, %ebx
movl 0xbefc(%rip), %eax      # 0xf8a4
cmpl $0x2a, %eax
je 0x39b7
cmpl $0x2f, %eax
jne 0x39ca
movl $0x6, %ebx
callq 0x2b82
callq 0x39d1
movl %ebx, %edi
callq 0x2bf5
jmp 0x399d
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/georgeweigt[P]sassafras/sassafras.c
// Function: parse_factor
void
parse_factor(void)
{
	switch (token) {
	case NAME:
		if (strcmp(strbuf, "LOG") == 0)
			parse_log();
		else {
			emit_variable();
			scan();
		}
		break;
	case NUMBER:
		emit_number();
		scan();
		break;
	case '(':
		scan();
		parse_expr();
		if (token != ')')
			stop("Syntax error");
		scan();
		break;
	default:
		stop("Syntax error");
	}

	if (token == STARSTAR) {
		scan();
		switch (token) {
		case '+':
			scan();
			parse_factor();
			break;
		case '-':
			scan();
			parse_factor();
			emit(NEG);
			break;
		default:
			parse_factor();
			break;
		}
		emit(POW);
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movl 0xbec9(%rip), %eax      # 0xf8a4
cmpl $0x28, %eax
je 0x3a08
cmpl $0x3ea, %eax            # imm = 0x3EA
je 0x3a01
cmpl $0x3e9, %eax            # imm = 0x3E9
jne 0x3a1b
cmpl $0x474f4c, 0xc6a8(%rip) # imm = 0x474F4C
jne 0x3a3d
callq 0x3a95
jmp 0x3a47
callq 0x3bdd
jmp 0x3a42
callq 0x2b82
callq 0x3928
cmpl $0x29, 0xbe8b(%rip)     # 0xf8a4
je 0x3a42
callq 0xa7e0
leaq 0x7aba(%rip), %rdi      # 0xb4e1
callq 0x4039
leaq 0x121bd(%rip), %rdi     # 0x15bf0
movl $0x1, %esi
callq 0x21c0
callq 0x3b32
callq 0x2b82
cmpl $0x3ed, 0xbe53(%rip)    # imm = 0x3ED
jne 0x3a74
callq 0x2b82
movl 0xbe46(%rip), %eax      # 0xf8a4
cmpl $0x2d, %eax
je 0x3a76
cmpl $0x2b, %eax
jne 0x3a6d
callq 0x2b82
callq 0x39d1
jmp 0x3a8a
popq %rbp
retq
callq 0x2b82
callq 0x39d1
movl $0x2, %edi
callq 0x2bf5
movl $0x7, %edi
popq %rbp
jmp 0x2bf5
// File: /workspace/github_c_makefile_star2_O3/georgeweigt[P]sassafras/sassafras.c
// Function: parse_log
void
parse_log(void)
{
	// look ahead

	while (isspace(*inp) && *inp != '\n' && *inp != '\r')
		inp++;

	if (*inp != '(') {
		emit_variable();
		scan();
		return;
	}

	scan();
	scan();

	parse_expr();

	if (token != ')')
		expected(")");

	scan();

	emit(LOG);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
callq 0x2240
movq (%rax), %rsi
movq 0xbe00(%rip), %rcx      # 0xf8a8
movsbq (%rcx), %rdx
movzwl (%rsi,%rdx,2), %esi
btl $0xd, %esi
jb 0x3ae3
cmpb $0x28, %dl
jne 0x3b1b
callq 0x2b82
callq 0x2b82
callq 0x3928
cmpl $0x29, 0xbdd3(%rip)     # 0xf8a4
jne 0x3b26
callq 0x2b82
movl $0x8, %edi
popq %rbp
jmp 0x2bf5
movzbl %dl, %edx
cmpl $0xa, %edx
je 0x3b1b
cmpl $0xd, %edx
je 0x3b1b
incq %rcx
movq %rcx, 0xbdae(%rip)      # 0xf8a8
movq (%rax), %rsi
movsbq (%rcx), %rdx
movzwl (%rsi,%rdx,2), %esi
btl $0xd, %esi
jae 0x3ab6
movzbl %dl, %edx
cmpl $0xa, %edx
je 0x3b1b
incq %rcx
cmpl $0xd, %edx
jne 0x3af3
callq 0x3b32
popq %rbp
jmp 0x2b82
leaq 0x79c1(%rip), %rdi      # 0xb4ee
callq 0x25fb
// File: /workspace/github_c_makefile_star2_O3/georgeweigt[P]sassafras/sassafras.c
// Function: emit_variable
void
emit_variable(void)
{
	int i;
	for (i = 0; i < dd->nvar; i++)
		if (strcmp(dd->spec[i].name, strbuf) == 0)
			break;
	if (i == dd->nvar)
		stop("Variable not found");
	if (dd->spec[i].ltab)
		stop("An arithemetic expression cannot use a category variable");
	emit(LOAD);
	emit(i);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq 0xc549(%rip), %r15      # 0x10090
movslq 0x10(%r15), %r12
testq %r12, %r12
jle 0x3b9b
leaq 0x20(%r15), %r13
xorl %ebx, %ebx
leaq 0xc543(%rip), %r14      # 0x100a0
movq (%r13), %rdi
movq %r14, %rsi
callq 0x2170
testl %eax, %eax
je 0x3b9d
incq %rbx
addq $0x28, %r13
cmpq %rbx, %r12
jne 0x3b5d
callq 0xa7e0
leaq 0x7983(%rip), %rdi      # 0xb508
callq 0x4039
leaq 0x1205f(%rip), %rdi     # 0x15bf0
movl $0x1, %esi
callq 0x21c0
xorl %ebx, %ebx
cmpl %r12d, %ebx
je 0x3b79
movl %ebx, %eax
leaq (%rax,%rax,4), %rax
cmpq $0x0, 0x30(%r15,%rax,8)
jne 0x3bcf
movl $0xa, %edi
callq 0x2bf5
movl %ebx, %edi
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x2bf5
callq 0xa7e0
leaq 0x7940(%rip), %rdi      # 0xb51b
jmp 0x3b85
// File: /workspace/github_c_makefile_star2_O3/georgeweigt[P]sassafras/sassafras.c
// Function: main
int
main(int argc, char *argv[])
{
	char *s;

	if (argc < 2) {
		printf("usage: sassafras filename\n");
		exit(1);
	}

	s = read_file(argv[1]);

	if (s == NULL) {
		printf("error reading file %s\n", argv[1]);
		exit(1);
	}

	run(s);

	free(s);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
cmpl $0x1, %edi
jle 0x3efd
movq %rsi, %rbx
movq 0x8(%rsi), %rdi
callq 0x3f27
testq %rax, %rax
je 0x3f0b
movq %rax, %r14
movq %rax, %rdi
callq 0x3fbf
movq %r14, %rdi
callq 0x2040
xorl %eax, %eax
popq %rbx
popq %r14
popq %rbp
retq
leaq 0x7d06(%rip), %rdi      # 0xbc0a
callq 0x2070
jmp 0x3f1d
movq 0x8(%rbx), %rsi
leaq 0x763e(%rip), %rdi      # 0xb554
xorl %eax, %eax
callq 0x20d0
movl $0x1, %edi
callq 0x2200
// File: /workspace/github_c_makefile_star2_O3/georgeweigt[P]sassafras/sassafras.c
// Function: run
void
run(char *s)
{
	if (s == NULL)
		return;

	emit_line_init();

	run_nib(s);

	// clean up (always gets here, even on stop)

	if (infile) {
		fclose(infile);
		infile = NULL;
	}

	free_datasets();

	xfree(title);
	xfree(title1);
	xfree(title2);
	xfree(title3);
}

// Assembly:
testq %rdi, %rdi
je 0x4032
pushq %rbp
movq %rsp, %rbp
callq 0xa701
movq 0xb8dc(%rip), %rdi      # 0xf8b0
testq %rdi, %rdi
je 0x3fe9
callq 0x20a0
movq $0x0, 0xb8c7(%rip) # 0xf8b0
callq 0x3829
movq 0x103e3(%rip), %rdi     # 0x143d8
testq %rdi, %rdi
je 0x3fff
callq 0x2040
movq 0x103da(%rip), %rdi     # 0x143e0
testq %rdi, %rdi
je 0x4010
callq 0x2040
movq 0x103d1(%rip), %rdi     # 0x143e8
testq %rdi, %rdi
je 0x4021
callq 0x2040
movq 0x103c8(%rip), %rdi     # 0x143f0
testq %rdi, %rdi
popq %rbp
jne 0x2040
retq
// File: /workspace/github_c_makefile_star2_O3/georgeweigt[P]sassafras/sassafras.c
// Function: emit_line_center
void
emit_line_center(char *s)
{
	int i, n;

	n = strlen(s);

	n = (80 - n) / 2;

	for (i = 0; i < n; i++)
		printf(" ");

	printf("%s\n", s);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
movq %rdi, %rbx
callq 0x20b0
cmpl $0x4e, %eax
jg 0x4072
movl $0x50, %r14d
subl %eax, %r14d
shrl %r14d
movl $0x20, %edi
callq 0x2050
decl %r14d
jne 0x4063
movq %rbx, %rdi
popq %rbx
popq %r14
popq %rbp
jmp 0x2070
// File: /workspace/github_c_makefile_star2_O3/georgeweigt[P]sassafras/sassafras.c
// Function: title_stmt
void
title_stmt(void)
{
	scan();
	if (token != STRING)
		expected("string");
	if (title)
		free(title);
	if (strbuf[0] == 0)
		title = NULL;
	else
		title = strdup(strbuf);
	scan();
	if (token != ';')
		stop("';' expected");
	scan();
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
callq 0x2b82
cmpl $0x3eb, 0xb7e9(%rip)    # imm = 0x3EB
jne 0x4102
movq 0x10314(%rip), %rdi     # 0x143d8
testq %rdi, %rdi
je 0x40ce
callq 0x2040
cmpb $0x0, 0xbfcb(%rip)      # 0x100a0
je 0x40e5
leaq 0xbfc2(%rip), %rdi      # 0x100a0
callq 0x2220
jmp 0x40e7
xorl %eax, %eax
movq %rax, 0x102ea(%rip)     # 0x143d8
callq 0x2b82
cmpl $0x3b, 0xb7aa(%rip)     # 0xf8a4
jne 0x410e
popq %rbp
jmp 0x2b82
leaq 0x7a17(%rip), %rdi      # 0xbb20
callq 0x25fb
callq 0xa7e0
leaq 0x73ba(%rip), %rdi      # 0xb4d4
callq 0x4039
leaq 0x11aca(%rip), %rdi     # 0x15bf0
movl $0x1, %esi
callq 0x21c0