LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O0/Tarsnap[P]libcperciva/perftests/http/main.c
// Function: donereq
static int
donereq(void * cookie, struct http_response * R)
{
	int * done = cookie;
	size_t i;

	/* This request is over. */
	*done = 1;

	/* Did we succeed? */
	if (R == NULL) {
		warn0("HTTP request failed");
		return (-1);
	}

	/* Print status and headers. */
	printf("HTTP status = %d\n", R->status);
	for (i = 0; i < R->nheaders; i++)
		printf("%s\n\t%s\n",
		    R->headers[i].header, R->headers[i].value);

	/* Print the body received. */
	fwrite(R->body, 1, R->bodylen, stdout);

	/* Free the body. */
	free(R->body);

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

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x20(%rbp)
movq -0x20(%rbp), %rax
movl $0x1, (%rax)
cmpq $0x0, -0x18(%rbp)
jne 0x26d0
jmp 0x26ab
leaq 0x99a7(%rip), %rdi      # 0xc059
movb $0x0, %al
callq 0xa6d0
callq 0x20a0
movl $0x0, (%rax)
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
jmp 0x277b
movq -0x18(%rbp), %rax
movl (%rax), %esi
leaq 0x9990(%rip), %rdi      # 0xc06d
movb $0x0, %al
callq 0x2150
movq $0x0, -0x28(%rbp)
movq -0x28(%rbp), %rax
movq -0x18(%rbp), %rcx
cmpq 0x8(%rcx), %rax
jae 0x2743
movq -0x18(%rbp), %rax
movq 0x10(%rax), %rax
movq -0x28(%rbp), %rcx
shlq $0x4, %rcx
addq %rcx, %rax
movq (%rax), %rsi
movq -0x18(%rbp), %rax
movq 0x10(%rax), %rax
movq -0x28(%rbp), %rcx
shlq $0x4, %rcx
addq %rcx, %rax
movq 0x8(%rax), %rdx
leaq 0x9951(%rip), %rdi      # 0xc07f
movb $0x0, %al
callq 0x2150
movq -0x28(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x28(%rbp)
jmp 0x26ec
movq -0x18(%rbp), %rax
movq 0x20(%rax), %rdi
movq -0x18(%rbp), %rax
movq 0x18(%rax), %rdx
movq 0xe87e(%rip), %rax      # 0x10fd8
movq (%rax), %rcx
movl $0x1, %esi
callq 0x2340
movq -0x18(%rbp), %rax
movq 0x20(%rax), %rdi
callq 0x2040
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
nop
// File: /workspace/github_c_makefile_star2_O0/videolan[P]bitstream/examples/mpeg_restamp.c
// Function: get_date
static uint64_t get_date(void)
{
    struct timespec ts;

    /* Try to use POSIX monotonic clock if available */
    if (clock_gettime(CLOCK_MONOTONIC, &ts) == EINVAL)
        /* Run-time fallback to real-time clock (always available) */
        (void)clock_gettime(CLOCK_REALTIME, &ts);

    return ((uint64_t)ts.tv_sec * CLOCK_FREQ)
            + ((uint64_t)ts.tv_nsec * (CLOCK_FREQ / 10000) / 100000);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movl $0x1, %edi
leaq -0x10(%rbp), %rsi
callq 0x1040
cmpl $0x16, %eax
jne 0x15c6
xorl %edi, %edi
leaq -0x10(%rbp), %rsi
callq 0x1040
imulq $0x15f90, -0x10(%rbp), %rax # imm = 0x15F90
movq %rax, -0x18(%rbp)
imulq $0x9, -0x8(%rbp), %rax
movl $0x186a0, %ecx          # imm = 0x186A0
xorl %edx, %edx
divq %rcx
movq %rax, %rcx
movq -0x18(%rbp), %rax
addq %rcx, %rax
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/videolan[P]bitstream/examples/mpeg_restamp.c
// Function: handle_pcr
static void handle_pcr(uint8_t *p_ts, uint64_t i_date)
{
    uint64_t i_pcr = tsaf_get_pcr(p_ts);
    bool b_discontinuity = tsaf_has_discontinuity(p_ts);

    if (i_last_pcr == TS_CLOCK_MAX)
        i_last_pcr = i_pcr;
    else {
        /* handle 2^33 wrap-arounds */
        uint64_t i_delta =
            (TS_CLOCK_MAX + i_pcr -
             (i_last_pcr % TS_CLOCK_MAX)) % TS_CLOCK_MAX;
        if (i_delta <= MAX_PCR_INTERVAL && !b_discontinuity)
            i_last_pcr = i_pcr;
        else {
            i_last_pcr += i_date - i_last_pcr_date;
            i_last_pcr %= TS_CLOCK_MAX;
            i_pcr_offset += TS_CLOCK_MAX + i_last_pcr - i_pcr;
            i_pcr_offset %= TS_CLOCK_MAX;
            i_last_pcr = i_pcr;
        }
    }
    i_last_pcr_date = i_date;
    if (!i_pcr_offset)
        return;

    i_pcr += i_pcr_offset;
    i_pcr %= TS_CLOCK_MAX;
    tsaf_set_pcr(p_ts, i_pcr);
    tsaf_clear_discontinuity(p_ts);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rdi
callq 0x1d00
movq %rax, -0x18(%rbp)
movq -0x8(%rbp), %rdi
callq 0x1d60
andb $0x1, %al
movb %al, -0x19(%rbp)
movabsq $0x200000000, %rax      # imm = 0x200000000
cmpq %rax, 0x298c(%rip)      # 0x4068
jne 0x16ee
movq -0x18(%rbp), %rax
movq %rax, 0x297f(%rip)      # 0x4068
jmp 0x17b7
movabsq $0x200000000, %rax      # imm = 0x200000000
addq -0x18(%rbp), %rax
movabsq $0x1ffffffff, %rcx      # imm = 0x1FFFFFFFF
andq 0x295b(%rip), %rcx      # 0x4068
subq %rcx, %rax
movabsq $0x1ffffffff, %rcx      # imm = 0x1FFFFFFFF
andq %rcx, %rax
movq %rax, -0x28(%rbp)
cmpq $0x2328, -0x28(%rbp)    # imm = 0x2328
ja 0x173e
testb $0x1, -0x19(%rbp)
jne 0x173e
movq -0x18(%rbp), %rax
movq %rax, 0x292c(%rip)      # 0x4068
jmp 0x17b5
movq -0x10(%rbp), %rax
subq 0x292f(%rip), %rax      # 0x4078
addq 0x2918(%rip), %rax      # 0x4068
movq %rax, 0x2911(%rip)      # 0x4068
movabsq $0x1ffffffff, %rax      # imm = 0x1FFFFFFFF
andq 0x2900(%rip), %rax      # 0x4068
movq %rax, 0x28f9(%rip)      # 0x4068
movabsq $0x200000000, %rax      # imm = 0x200000000
addq 0x28e8(%rip), %rax      # 0x4068
subq -0x18(%rbp), %rax
addq 0x28f5(%rip), %rax      # 0x4080
movq %rax, 0x28ee(%rip)      # 0x4080
movabsq $0x1ffffffff, %rax      # imm = 0x1FFFFFFFF
andq 0x28dd(%rip), %rax      # 0x4080
movq %rax, 0x28d6(%rip)      # 0x4080
movq -0x18(%rbp), %rax
movq %rax, 0x28b3(%rip)      # 0x4068
jmp 0x17b7
movq -0x10(%rbp), %rax
movq %rax, 0x28b6(%rip)      # 0x4078
cmpq $0x0, 0x28b6(%rip)      # 0x4080
jne 0x17ce
jmp 0x1805
movq 0x28ab(%rip), %rax      # 0x4080
addq -0x18(%rbp), %rax
movq %rax, -0x18(%rbp)
movabsq $0x1ffffffff, %rax      # imm = 0x1FFFFFFFF
andq -0x18(%rbp), %rax
movq %rax, -0x18(%rbp)
movq -0x8(%rbp), %rdi
movq -0x18(%rbp), %rsi
callq 0x1d90
movq -0x8(%rbp), %rdi
callq 0x1e30
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/videolan[P]bitstream/examples/./bitstream/mpeg/pes.h
// Function: pes_set_pts
static inline void pes_set_pts(uint8_t *p_pes, uint64_t i_pts)
{
    p_pes[7] |= 0x80;
    if (p_pes[8] < 5)
        p_pes[8] = 5;
    uint8_t marker = pes_has_dts(p_pes) ? 0x30 : 0x20;
    p_pes[9] = marker | 0x1 | ((i_pts >> 29) & 0xe);
    p_pes[10] = (i_pts >> 22) & 0xff;
    p_pes[11] = 0x1 | ((i_pts >> 14) & 0xfe);
    p_pes[12] = (i_pts >> 7) & 0xff;
    p_pes[13] = 0x1 | ((i_pts << 1) & 0xfe);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rax
movzbl 0x7(%rax), %ecx
orl $0x80, %ecx
movb %cl, 0x7(%rax)
movq -0x8(%rbp), %rax
movzbl 0x8(%rax), %eax
cmpl $0x5, %eax
jge 0x19d6
movq -0x8(%rbp), %rax
movb $0x5, 0x8(%rax)
movq -0x8(%rbp), %rdi
callq 0x1b20
movb %al, %dl
movl $0x20, %eax
movl $0x30, %ecx
testb $0x1, %dl
cmovnel %ecx, %eax
movb %al, -0x11(%rbp)
movzbl -0x11(%rbp), %eax
orl $0x1, %eax
cltq
movq -0x10(%rbp), %rcx
shrq $0x1d, %rcx
andq $0xe, %rcx
orq %rcx, %rax
movb %al, %cl
movq -0x8(%rbp), %rax
movb %cl, 0x9(%rax)
movq -0x10(%rbp), %rax
shrq $0x16, %rax
andq $0xff, %rax
movb %al, %cl
movq -0x8(%rbp), %rax
movb %cl, 0xa(%rax)
movq -0x10(%rbp), %rax
shrq $0xe, %rax
andq $0xfe, %rax
orq $0x1, %rax
movb %al, %cl
movq -0x8(%rbp), %rax
movb %cl, 0xb(%rax)
movq -0x10(%rbp), %rax
shrq $0x7, %rax
andq $0xff, %rax
movb %al, %cl
movq -0x8(%rbp), %rax
movb %cl, 0xc(%rax)
movq -0x10(%rbp), %rax
shlq %rax
andq $0xfe, %rax
orq $0x1, %rax
movb %al, %cl
movq -0x8(%rbp), %rax
movb %cl, 0xd(%rax)
addq $0x20, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/videolan[P]bitstream/examples/./bitstream/mpeg/pes.h
// Function: pes_set_dts
static inline void pes_set_dts(uint8_t *p_pes, uint64_t i_dts)
{
    p_pes[7] |= 0x40;
    if (p_pes[8] < 10)
        p_pes[8] = 10;
    p_pes[9] &= 0x0f;
    p_pes[9] |= 0x30;
    p_pes[14] = 0x11 | ((i_dts >> 29) & 0xe);
    p_pes[15] = (i_dts >> 22) & 0xff;
    p_pes[16] = 0x1 | ((i_dts >> 14) & 0xfe);
    p_pes[17] = (i_dts >> 7) & 0xff;
    p_pes[18] = 0x1 | ((i_dts << 1) & 0xfe);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rax
movzbl 0x7(%rax), %ecx
orl $0x40, %ecx
movb %cl, 0x7(%rax)
movq -0x8(%rbp), %rax
movzbl 0x8(%rax), %eax
cmpl $0xa, %eax
jge 0x1bef
movq -0x8(%rbp), %rax
movb $0xa, 0x8(%rax)
movq -0x8(%rbp), %rax
movzbl 0x9(%rax), %ecx
andl $0xf, %ecx
movb %cl, 0x9(%rax)
movq -0x8(%rbp), %rax
movzbl 0x9(%rax), %ecx
orl $0x30, %ecx
movb %cl, 0x9(%rax)
movq -0x10(%rbp), %rax
shrq $0x1d, %rax
andq $0xe, %rax
orq $0x11, %rax
movb %al, %cl
movq -0x8(%rbp), %rax
movb %cl, 0xe(%rax)
movq -0x10(%rbp), %rax
shrq $0x16, %rax
andq $0xff, %rax
movb %al, %cl
movq -0x8(%rbp), %rax
movb %cl, 0xf(%rax)
movq -0x10(%rbp), %rax
shrq $0xe, %rax
andq $0xfe, %rax
orq $0x1, %rax
movb %al, %cl
movq -0x8(%rbp), %rax
movb %cl, 0x10(%rax)
movq -0x10(%rbp), %rax
shrq $0x7, %rax
andq $0xff, %rax
movb %al, %cl
movq -0x8(%rbp), %rax
movb %cl, 0x11(%rax)
movq -0x10(%rbp), %rax
shlq %rax
andq $0xfe, %rax
orq $0x1, %rax
movb %al, %cl
movq -0x8(%rbp), %rax
movb %cl, 0x12(%rax)
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/videolan[P]bitstream/examples/./bitstream/mpeg/ts.h
// Function: tsaf_set_pcr
static inline void tsaf_set_pcr(uint8_t *p_ts, uint64_t i_pcr)
{
    p_ts[5] |= 0x10;
    p_ts[6] = (i_pcr >> 25) & 0xff;
    p_ts[7] = (i_pcr >> 17) & 0xff;
    p_ts[8] = (i_pcr >> 9) & 0xff;
    p_ts[9] = (i_pcr >> 1) & 0xff;
    p_ts[10] = 0x7e | ((i_pcr << 7) & 0x80);
    p_ts[11] = 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rax
movzbl 0x5(%rax), %ecx
orl $0x10, %ecx
movb %cl, 0x5(%rax)
movq -0x10(%rbp), %rax
shrq $0x19, %rax
andq $0xff, %rax
movb %al, %cl
movq -0x8(%rbp), %rax
movb %cl, 0x6(%rax)
movq -0x10(%rbp), %rax
shrq $0x11, %rax
andq $0xff, %rax
movb %al, %cl
movq -0x8(%rbp), %rax
movb %cl, 0x7(%rax)
movq -0x10(%rbp), %rax
shrq $0x9, %rax
andq $0xff, %rax
movb %al, %cl
movq -0x8(%rbp), %rax
movb %cl, 0x8(%rax)
movq -0x10(%rbp), %rax
shrq %rax
andq $0xff, %rax
movb %al, %cl
movq -0x8(%rbp), %rax
movb %cl, 0x9(%rax)
movq -0x10(%rbp), %rax
shlq $0x7, %rax
andq $0x80, %rax
orq $0x7e, %rax
movb %al, %cl
movq -0x8(%rbp), %rax
movb %cl, 0xa(%rax)
movq -0x8(%rbp), %rax
movb $0x0, 0xb(%rax)
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/phillbush[P]hoc/main.c
// Function: main
int
main(int argc, char *argv[])
{
	struct sigaction sa;
	FILE *fp = NULL;
	char ch;

	while ((ch = getopt(argc, argv, "")) != -1) {
		switch (ch) {
		default:
			usage();
			break;
		}
	}
	argc -= optind;
	argv += optind;

	/* assign action for SIGFPE */
	sa.sa_handler = sigfpehand;
	sa.sa_flags = 0;
	sigemptyset(&sa.sa_mask);
	if (sigaction(SIGFPE, &sa, NULL) == -1)
		err(1, "sigaction");

	/* open input file */
	if (argc) {
		if (strcmp(*argv, "-") != 0)
			if ((fp = fopen(*argv, "r")) == NULL)
				err(1, "%s", *argv);
		if (fp)
			yyin = fp;
	}

	/* initialize machine */
	init(argc, argv);

	/* parse and execute input until EOF */
	setjmp(begin);
	while (prepare(), yyparse()) {
		if (DEBUG)
			debug();
		execute(NULL);
	}

	/* cleanup machine and close input file */
	cleanup();
	if (fp)
		fclose(fp);

	return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0xc0, %rsp
movl $0x0, -0x4(%rbp)
movl %edi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq $0x0, -0xb0(%rbp)
movl -0x8(%rbp), %edi
movq -0x10(%rbp), %rsi
leaq 0x8c10(%rip), %rdx      # 0xb022
callq 0x2250
movb %al, -0xb1(%rbp)
movsbl %al, %eax
cmpl $-0x1, %eax
je 0x242c
callq 0x2580
jmp 0x2404
movq 0xdba5(%rip), %rax      # 0xffd8
movl (%rax), %ecx
movl -0x8(%rbp), %eax
subl %ecx, %eax
movl %eax, -0x8(%rbp)
movq 0xdb94(%rip), %rax      # 0xffd8
movl (%rax), %ecx
movq -0x10(%rbp), %rax
movslq %ecx, %rcx
shlq $0x3, %rcx
addq %rcx, %rax
movq %rax, -0x10(%rbp)
leaq 0x151(%rip), %rax       # 0x25b0
movq %rax, -0xa8(%rbp)
movl $0x0, -0x20(%rbp)
leaq -0xa8(%rbp), %rdi
addq $0x8, %rdi
callq 0x21b0
movl $0x8, %edi
leaq -0xa8(%rbp), %rsi
xorl %eax, %eax
movl %eax, %edx
callq 0x2080
cmpl $-0x1, %eax
jne 0x24aa
movl $0x1, %edi
leaq 0x8b61(%rip), %rsi      # 0xb004
movb $0x0, %al
callq 0x2200
cmpl $0x0, -0x8(%rbp)
je 0x2521
movq -0x10(%rbp), %rax
movq (%rax), %rdi
leaq 0x8b50(%rip), %rsi      # 0xb00e
callq 0x2190
cmpl $0x0, %eax
je 0x2504
movq -0x10(%rbp), %rax
movq (%rax), %rdi
leaq 0x8ee2(%rip), %rsi      # 0xb3b8
callq 0x2240
movq %rax, -0xb0(%rbp)
cmpq $0x0, %rax
jne 0x2502
movq -0x10(%rbp), %rax
movq (%rax), %rdx
movl $0x1, %edi
leaq 0x8c97(%rip), %rsi      # 0xb192
movb $0x0, %al
callq 0x2200
jmp 0x2504
cmpq $0x0, -0xb0(%rbp)
je 0x251f
movq -0xb0(%rbp), %rcx
leaq 0x103e4(%rip), %rax     # 0x12900
movq %rcx, (%rax)
jmp 0x2521
movl -0x8(%rbp), %edi
movq -0x10(%rbp), %rsi
callq 0x2a10
leaq 0xe22c(%rip), %rdi      # 0x10760
callq 0x2180
callq 0x2bd0
callq 0x5ea0
cmpl $0x0, %eax
je 0x2553
xorl %eax, %eax
movl %eax, %edi
callq 0x3120
jmp 0x2539
callq 0x2db0
cmpq $0x0, -0xb0(%rbp)
je 0x256e
movq -0xb0(%rbp), %rdi
callq 0x20d0
xorl %eax, %eax
addq $0xc0, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/phillbush[P]hoc/error.c
// Function: warning
void
warning(const char *fmt, ...)
{
	va_list ap;

	va_start(ap, fmt);
	(void)vsnprintf(buf, sizeof buf - 1, fmt, ap);
	warnx("line %d: %s", yylineno, buf);
	va_end(ap);
	errno = 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0xe0, %rsp
testb %al, %al
je 0x2625
movaps %xmm0, -0xa0(%rbp)
movaps %xmm1, -0x90(%rbp)
movaps %xmm2, -0x80(%rbp)
movaps %xmm3, -0x70(%rbp)
movaps %xmm4, -0x60(%rbp)
movaps %xmm5, -0x50(%rbp)
movaps %xmm6, -0x40(%rbp)
movaps %xmm7, -0x30(%rbp)
movq %r9, -0xa8(%rbp)
movq %r8, -0xb0(%rbp)
movq %rcx, -0xb8(%rbp)
movq %rdx, -0xc0(%rbp)
movq %rsi, -0xc8(%rbp)
movq %rdi, -0x8(%rbp)
leaq -0xd0(%rbp), %rax
movq %rax, -0x10(%rbp)
leaq 0x10(%rbp), %rax
movq %rax, -0x18(%rbp)
movl $0x30, -0x1c(%rbp)
movl $0x8, -0x20(%rbp)
movq -0x8(%rbp), %rdx
leaq 0xe1b8(%rip), %rdi      # 0x10830
movq %rdi, -0xd8(%rbp)
movl $0x1fff, %esi           # imm = 0x1FFF
leaq -0x20(%rbp), %rcx
callq 0x20a0
movq -0xd8(%rbp), %rdx
leaq 0xe085(%rip), %rax      # 0x10720
movl (%rax), %esi
leaq 0x8998(%rip), %rdi      # 0xb03c
xorl %eax, %eax
callq 0x2110
callq 0x2040
movl $0x0, (%rax)
addq $0xe0, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/phillbush[P]hoc/error.c
// Function: yyerror
void
yyerror(const char *fmt, ...)
{
	va_list ap;

	va_start(ap, fmt);
	(void)vsnprintf(buf, sizeof buf - 1, fmt, ap);
	warnx("line %d: %s", yylineno, buf);
	va_end(ap);
	errno = 0;
	longjmp(begin, 1);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0xd0, %rsp
testb %al, %al
je 0x26f5
movaps %xmm0, -0xa0(%rbp)
movaps %xmm1, -0x90(%rbp)
movaps %xmm2, -0x80(%rbp)
movaps %xmm3, -0x70(%rbp)
movaps %xmm4, -0x60(%rbp)
movaps %xmm5, -0x50(%rbp)
movaps %xmm6, -0x40(%rbp)
movaps %xmm7, -0x30(%rbp)
movq %r9, -0xa8(%rbp)
movq %r8, -0xb0(%rbp)
movq %rcx, -0xb8(%rbp)
movq %rdx, -0xc0(%rbp)
movq %rsi, -0xc8(%rbp)
movq %rdi, -0x8(%rbp)
leaq -0x20(%rbp), %rax
leaq -0xd0(%rbp), %rcx
movq %rcx, 0x10(%rax)
leaq 0x10(%rbp), %rcx
movq %rcx, 0x8(%rax)
movl $0x30, 0x4(%rax)
movl $0x8, (%rax)
movq -0x8(%rbp), %rdx
leaq -0x20(%rbp), %rcx
leaq 0xe0e1(%rip), %rdi      # 0x10830
movl $0x1fff, %esi           # imm = 0x1FFF
callq 0x20a0
leaq 0xdfc0(%rip), %rax      # 0x10720
movl (%rax), %esi
leaq 0x88d3(%rip), %rdi      # 0xb03c
leaq 0xe0c0(%rip), %rdx      # 0x10830
movb $0x0, %al
callq 0x2110
leaq -0x20(%rbp), %rax
callq 0x2040
movl $0x0, (%rax)
leaq 0xdfd3(%rip), %rdi      # 0x10760
movl $0x1, %esi
callq 0x2230
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/phillbush[P]hoc/code.c
// Function: lookupname
Name *
lookupname(const char *s)
{
	Name *name;

	for (name = nametab; name; name = name->next)
		if (strcmp(name->s, s) == 0)
			return name;
	return NULL;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movq 0x1007d(%rip), %rax     # 0x12830
movq %rax, -0x18(%rbp)
cmpq $0x0, -0x18(%rbp)
je 0x27ed
movq -0x18(%rbp), %rax
movq 0x8(%rax), %rdi
movq -0x10(%rbp), %rsi
callq 0x2190
cmpl $0x0, %eax
jne 0x27de
movq -0x18(%rbp), %rax
movq %rax, -0x8(%rbp)
jmp 0x27f5
jmp 0x27e0
movq -0x18(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x18(%rbp)
jmp 0x27b7
movq $0x0, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x20, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/phillbush[P]hoc/code.c
// Function: installglobalname
Name *
installglobalname(const char *s, int t)
{
	Name *name;

	name = emalloc(sizeof *name);
	name->s = estrdup(s);
	name->type = t;
	name->next = nametab;
	nametab = name;
	return name;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movl $0x20, %edi
callq 0x2860
movq %rax, -0x18(%rbp)
movq -0x8(%rbp), %rdi
callq 0x28a0
movq %rax, %rcx
movq -0x18(%rbp), %rax
movq %rcx, 0x8(%rax)
movl -0xc(%rbp), %ecx
movq -0x18(%rbp), %rax
movl %ecx, 0x10(%rax)
movq 0xffee(%rip), %rcx      # 0x12830
movq -0x18(%rbp), %rax
movq %rcx, (%rax)
movq -0x18(%rbp), %rax
movq %rax, 0xffdc(%rip)      # 0x12830
movq -0x18(%rbp), %rax
addq $0x20, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/phillbush[P]hoc/code.c
// Function: installlocalname
Name *
installlocalname(const char *s, Name *tab)
{
	Name *name;

	name = emalloc(sizeof *name);
	name->s = estrdup(s);
	name->type = VAR;
	name->next = tab;
	return name;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl $0x20, %edi
callq 0x2860
movq %rax, -0x18(%rbp)
movq -0x8(%rbp), %rdi
callq 0x28a0
movq %rax, %rcx
movq -0x18(%rbp), %rax
movq %rcx, 0x8(%rax)
movq -0x18(%rbp), %rax
movl $0x105, 0x10(%rax)      # imm = 0x105
movq -0x10(%rbp), %rcx
movq -0x18(%rbp), %rax
movq %rcx, (%rax)
movq -0x18(%rbp), %rax
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/phillbush[P]hoc/code.c
// Function: addstr
String *
addstr(char *s, int final)
{
	String **list;
	String *p;

	if ((p = malloc(sizeof *p)) == NULL) {
		free(s);
		yyerror("out of memory");
	}
	if (final) {
		list = &finalstrings;
		p->orig = FINAL;
	} else {
		list = &autostrings;
		p->orig = AUTO;
	}
	p->s = s;
	if (*list)
		(*list)->prev = p;
	p->next = *list;
	p->prev = NULL;
	p->count = 1;
	*list = p;
	return p;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movl $0x28, %edi
callq 0x2210
movq %rax, -0x20(%rbp)
cmpq $0x0, %rax
jne 0x297a
movq -0x8(%rbp), %rdi
callq 0x2030
leaq 0x87ed(%rip), %rdi      # 0xb160
movb $0x0, %al
callq 0x26c0
cmpl $0x0, -0xc(%rbp)
je 0x2998
leaq 0xfeb1(%rip), %rax      # 0x12838
movq %rax, -0x18(%rbp)
movq -0x20(%rbp), %rax
movl $0x0, 0x10(%rax)
jmp 0x29ae
leaq 0xfea1(%rip), %rax      # 0x12840
movq %rax, -0x18(%rbp)
movq -0x20(%rbp), %rax
movl $0x1, 0x10(%rax)
movq -0x8(%rbp), %rcx
movq -0x20(%rbp), %rax
movq %rcx, 0x18(%rax)
movq -0x18(%rbp), %rax
cmpq $0x0, (%rax)
je 0x29d2
movq -0x20(%rbp), %rcx
movq -0x18(%rbp), %rax
movq (%rax), %rax
movq %rcx, (%rax)
movq -0x18(%rbp), %rax
movq (%rax), %rcx
movq -0x20(%rbp), %rax
movq %rcx, 0x8(%rax)
movq -0x20(%rbp), %rax
movq $0x0, (%rax)
movq -0x20(%rbp), %rax
movq $0x1, 0x20(%rax)
movq -0x20(%rbp), %rcx
movq -0x18(%rbp), %rax
movq %rcx, (%rax)
movq -0x20(%rbp), %rax
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/phillbush[P]hoc/code.c
// Function: prepare
void
prepare(void)
{
	Frame *fp;

	continuing = breaking = returning = 0;
	prog.tail = NULL;
	prog.progp = prog.base;
	currsymtab = NULL;
	for (fp = frame.head; fp && fp != frame.tail; fp = fp->next)
		if (fp->local)
			freesymtab(&(fp->local));
	frame.tail = frame.next = frame.head;
	frame.curr = NULL;
	freestrings(&autostrings);
	freestack();
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movl $0x0, 0xfcbe(%rip)      # 0x128a0
movl $0x0, 0xfcb8(%rip)      # 0x128a4
movl $0x0, 0xfcb2(%rip)      # 0x128a8
movq $0x0, 0xfc5f(%rip) # 0x12860
movq 0xfc68(%rip), %rax      # 0x12870
movq %rax, 0xfc59(%rip)      # 0x12868
movq $0x0, 0xfc96(%rip) # 0x128b0
movq 0xfc5f(%rip), %rax      # 0x12880
movq %rax, -0x8(%rbp)
xorl %eax, %eax
cmpq $0x0, -0x8(%rbp)
movb %al, -0x9(%rbp)
je 0x2c42
movq -0x8(%rbp), %rax
cmpq 0xfc4c(%rip), %rax      # 0x12888
setne %al
movb %al, -0x9(%rbp)
movb -0x9(%rbp), %al
testb $0x1, %al
jne 0x2c4b
jmp 0x2c73
movq -0x8(%rbp), %rax
cmpq $0x0, 0x10(%rax)
je 0x2c63
movq -0x8(%rbp), %rdi
addq $0x10, %rdi
callq 0x2cb0
jmp 0x2c65
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rax
movq %rax, -0x8(%rbp)
jmp 0x2c25
movq 0xfc06(%rip), %rax      # 0x12880
movq %rax, 0xfc17(%rip)      # 0x12898
movq %rax, 0xfc00(%rip)      # 0x12888
movq $0x0, 0xfbfd(%rip) # 0x12890
leaq 0xfba6(%rip), %rdi      # 0x12840
callq 0x2d00
callq 0x2d60
addq $0x10, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/phillbush[P]hoc/code.c
// Function: freesymtab
static void
freesymtab(Symbol **symtab)
{
	Symbol *tmp, *p;

	p = *symtab;
	while (p) {
		tmp = p;
		p = p->next;
		if (DEBUG)
			fprintf(stderr, "FREED SYMBOL: %s\n", tmp->name);
		free(tmp);
	}
	*symtab = NULL;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x18(%rbp)
cmpq $0x0, -0x18(%rbp)
je 0x2cec
movq -0x18(%rbp), %rax
movq %rax, -0x10(%rbp)
movq -0x18(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x18(%rbp)
movq -0x10(%rbp), %rdi
callq 0x2030
jmp 0x2cc7
movq -0x8(%rbp), %rax
movq $0x0, (%rax)
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/phillbush[P]hoc/code.c
// Function: freestrings
static void
freestrings(String **strings)
{
	String *tmp, *p;

	p = *strings;
	while (p) {
		tmp = p;
		p = p->next;
		if (DEBUG)
			fprintf(stderr, "FREED STRING: %s\n", tmp->s);
		free(tmp->s);
		free(tmp);
	}
	*strings = NULL;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x18(%rbp)
cmpq $0x0, -0x18(%rbp)
je 0x2d4a
movq -0x18(%rbp), %rax
movq %rax, -0x10(%rbp)
movq -0x18(%rbp), %rax
movq 0x8(%rax), %rax
movq %rax, -0x18(%rbp)
movq -0x10(%rbp), %rax
movq 0x18(%rax), %rdi
callq 0x2030
movq -0x10(%rbp), %rdi
callq 0x2030
jmp 0x2d17
movq -0x8(%rbp), %rax
movq $0x0, (%rax)
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/phillbush[P]hoc/code.c
// Function: freestack
static void
freestack(void)
{
	Datum *tmp, *p = stack;

	while(p) {
		tmp = p;
		p = p->next;
		if (DEBUG)
			fprintf(stderr, "FREED STACK ENTRY (THIS SHOULD NOT OCCUR)\n");
		free(tmp);
	}
	stack = NULL;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq 0xfb51(%rip), %rax      # 0x128c0
movq %rax, -0x10(%rbp)
cmpq $0x0, -0x10(%rbp)
je 0x2d98
movq -0x10(%rbp), %rax
movq %rax, -0x8(%rbp)
movq -0x10(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x10(%rbp)
movq -0x8(%rbp), %rdi
callq 0x2030
jmp 0x2d73
movq $0x0, 0xfb1d(%rip) # 0x128c0
addq $0x10, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/phillbush[P]hoc/code.c
// Function: cleanup
void
cleanup(void)
{
	freesymtab(&global);
	freestrings(&autostrings);
	freestrings(&finalstrings);
	freenametab(&nametab);
	freestack();
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
leaq 0xfafd(%rip), %rdi      # 0x128b8
callq 0x2cb0
leaq 0xfa79(%rip), %rdi      # 0x12840
callq 0x2d00
leaq 0xfa65(%rip), %rdi      # 0x12838
callq 0x2d00
leaq 0xfa51(%rip), %rdi      # 0x12830
callq 0x2df0
callq 0x2d60
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/phillbush[P]hoc/code.c
// Function: freenametab
static void
freenametab(Name **nametab)
{
	Name *tmp, *p;

	p = *nametab;
	while (p) {
		tmp = p;
		p = p->next;
		if (DEBUG)
			fprintf(stderr, "FREED NAME: %s\n", tmp->s);
		if (tmp->type == FUNCTION || tmp->type == PROCEDURE)
			freenametab(&(tmp->u.fun->params));
		free(tmp->s);
		free(tmp);
	}
	*nametab = NULL;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x18(%rbp)
cmpq $0x0, -0x18(%rbp)
je 0x2e64
movq -0x18(%rbp), %rax
movq %rax, -0x10(%rbp)
movq -0x18(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x18(%rbp)
movq -0x10(%rbp), %rax
cmpl $0x115, 0x10(%rax)      # imm = 0x115
je 0x2e3b
movq -0x10(%rbp), %rax
cmpl $0x116, 0x10(%rax)      # imm = 0x116
jne 0x2e4c
movq -0x10(%rbp), %rax
movq 0x18(%rax), %rdi
addq $0x8, %rdi
callq 0x2df0
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rdi
callq 0x2030
movq -0x10(%rbp), %rdi
callq 0x2030
jmp 0x2e07
movq -0x8(%rbp), %rax
movq $0x0, (%rax)
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/phillbush[P]hoc/code.c
// Function: oprname
static char *
oprname(void (*opr)(void))
{
	int i;

	if (opr == NULL)
		return "STOP";
	for (i = 0; oprs[i].f; i++)
		if (opr == oprs[i].f)
			return oprs[i].s;
	return "unknown";
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x10(%rbp)
cmpq $0x0, -0x10(%rbp)
jne 0x309c
leaq 0x82e9(%rip), %rax      # 0xb37f
movq %rax, -0x8(%rbp)
jmp 0x310b
movl $0x0, -0x14(%rbp)
movslq -0x14(%rbp), %rcx
leaq 0xd372(%rip), %rax      # 0x10420
shlq $0x4, %rcx
addq %rcx, %rax
cmpq $0x0, 0x8(%rax)
je 0x3100
movq -0x10(%rbp), %rax
movslq -0x14(%rbp), %rdx
leaq 0xd355(%rip), %rcx      # 0x10420
shlq $0x4, %rdx
addq %rdx, %rcx
cmpq 0x8(%rcx), %rax
jne 0x30f3
movslq -0x14(%rbp), %rcx
leaq 0xd33d(%rip), %rax      # 0x10420
shlq $0x4, %rcx
addq %rcx, %rax
movq (%rax), %rax
movq %rax, -0x8(%rbp)
jmp 0x310b
jmp 0x30f5
movl -0x14(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x14(%rbp)
jmp 0x30a3
leaq 0x827d(%rip), %rax      # 0xb384
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/phillbush[P]hoc/code.c
// Function: execute
void
execute(Inst *ip)
{
	Inst *opc;

	if (ip == NULL)
		prog.pc = prog.base;
	else
		prog.pc = ip;
	while (prog.pc->u.opr && !breaking && !continuing) {
		opc = prog.pc;
		prog.pc = prog.pc->next;
		opc->u.opr();
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
cmpq $0x0, -0x8(%rbp)
jne 0x3143
movq 0xf736(%rip), %rax      # 0x12870
movq %rax, 0xf737(%rip)      # 0x12878
jmp 0x314e
movq -0x8(%rbp), %rax
movq %rax, 0xf72a(%rip)      # 0x12878
jmp 0x3150
movq 0xf721(%rip), %rcx      # 0x12878
xorl %eax, %eax
cmpq $0x0, 0x10(%rcx)
movb %al, -0x11(%rbp)
je 0x3180
xorl %eax, %eax
cmpl $0x0, 0xf738(%rip)      # 0x128a4
movb %al, -0x11(%rbp)
jne 0x3180
cmpl $0x0, 0xf730(%rip)      # 0x128a8
setne %al
xorb $-0x1, %al
movb %al, -0x11(%rbp)
movb -0x11(%rbp), %al
testb $0x1, %al
jne 0x3189
jmp 0x31ae
movq 0xf6e8(%rip), %rax      # 0x12878
movq %rax, -0x10(%rbp)
movq 0xf6dd(%rip), %rax      # 0x12878
movq (%rax), %rax
movq %rax, 0xf6d3(%rip)      # 0x12878
movq -0x10(%rbp), %rax
callq *0x10(%rax)
jmp 0x3150
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/phillbush[P]hoc/code.c
// Function: code
Inst *
code(Inst inst)
{
	Inst *ip;

	ip = prog.progp->next;
	prog.tail = prog.progp;
	*prog.tail = inst;
	prog.tail->next = ip;
	if (!prog.tail->next) {
		ip = emalloc(sizeof *ip);
		ip->next = NULL;
		prog.tail->next = ip;
	}
	prog.progp = prog.tail->next;
	return prog.tail;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
leaq 0x10(%rbp), %rcx
movq 0xf695(%rip), %rax      # 0x12868
movq (%rax), %rax
movq %rax, -0x8(%rbp)
movq 0xf687(%rip), %rax      # 0x12868
movq %rax, 0xf678(%rip)      # 0x12860
movq 0xf671(%rip), %rax      # 0x12860
movq (%rcx), %rdx
movq %rdx, (%rax)
movq 0x8(%rcx), %rdx
movq %rdx, 0x8(%rax)
movq 0x10(%rcx), %rcx
movq %rcx, 0x10(%rax)
movq -0x8(%rbp), %rcx
movq 0xf650(%rip), %rax      # 0x12860
movq %rcx, (%rax)
movq 0xf646(%rip), %rax      # 0x12860
cmpq $0x0, (%rax)
jne 0x3247
movl $0x18, %edi
callq 0x2860
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq $0x0, (%rax)
movq -0x8(%rbp), %rcx
movq 0xf61c(%rip), %rax      # 0x12860
movq %rcx, (%rax)
movq 0xf612(%rip), %rax      # 0x12860
movq (%rax), %rax
movq %rax, 0xf610(%rip)      # 0x12868
movq 0xf601(%rip), %rax      # 0x12860
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/phillbush[P]hoc/code.c
// Function: pop
static Datum
pop(void)
{
	Datum *tmp, d;

	if (stack == NULL)
		yyerror("stack underflow");
	tmp = stack;
	d = *stack;
	stack = stack->next;
	free(tmp);
	return d;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x18(%rbp)
movq %rdi, -0x10(%rbp)
cmpq $0x0, 0xf608(%rip)      # 0x128c0
jne 0x32c8
leaq 0x81cc(%rip), %rdi      # 0xb48d
movb $0x0, %al
callq 0x26c0
movq -0x18(%rbp), %rax
movq 0xf5ed(%rip), %rcx      # 0x128c0
movq %rcx, -0x8(%rbp)
movq 0xf5e2(%rip), %rcx      # 0x128c0
movq (%rcx), %rdx
movq %rdx, (%rax)
movq 0x8(%rcx), %rdx
movq %rdx, 0x8(%rax)
movq 0x10(%rcx), %rcx
movq %rcx, 0x10(%rax)
movq 0xf5c5(%rip), %rax      # 0x128c0
movq (%rax), %rax
movq %rax, 0xf5bb(%rip)      # 0x128c0
movq -0x8(%rbp), %rdi
callq 0x2030
movq -0x10(%rbp), %rax
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/phillbush[P]hoc/code.c
// Function: push
static void
push(Datum d)
{
	Datum *p;

	p = emalloc(sizeof *p);
	*p = d;
	p->next = stack;
	stack = p;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
leaq 0x10(%rbp), %rax
movq %rax, -0x10(%rbp)
movl $0x18, %edi
callq 0x2860
movq -0x10(%rbp), %rcx
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq (%rcx), %rdx
movq %rdx, (%rax)
movq 0x8(%rcx), %rdx
movq %rdx, 0x8(%rax)
movq 0x10(%rcx), %rcx
movq %rcx, 0x10(%rax)
movq 0xf4dd(%rip), %rcx      # 0x128c0
movq -0x8(%rbp), %rax
movq %rcx, (%rax)
movq -0x8(%rbp), %rax
movq %rax, 0xf4cb(%rip)      # 0x128c0
addq $0x10, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/phillbush[P]hoc/code.c
// Function: movstr
void
movstr(String *str)
{
	if (str->orig == FINAL) {
		str->count++;
	} else if (str->orig == AUTO) {
		if (str->next)
			str->next->prev = str->prev;
		if (str->prev)
			str->prev->next = str->next;
		else
			autostrings = str->next;
		if (finalstrings)
			finalstrings->prev = str;
		str->next = finalstrings;
		str->prev = NULL;
		str->orig = FINAL;
		str->count = 1;
		finalstrings = str;
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
cmpl $0x0, 0x10(%rax)
jne 0x34d7
movq -0x8(%rbp), %rax
movq 0x20(%rax), %rcx
addq $0x1, %rcx
movq %rcx, 0x20(%rax)
jmp 0x3586
movq -0x8(%rbp), %rax
cmpl $0x1, 0x10(%rax)
jne 0x3584
movq -0x8(%rbp), %rax
cmpq $0x0, 0x8(%rax)
je 0x3502
movq -0x8(%rbp), %rax
movq (%rax), %rcx
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rax
movq %rcx, (%rax)
movq -0x8(%rbp), %rax
cmpq $0x0, (%rax)
je 0x3521
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rcx
movq -0x8(%rbp), %rax
movq (%rax), %rax
movq %rcx, 0x8(%rax)
jmp 0x3530
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rax
movq %rax, 0xf310(%rip)      # 0x12840
cmpq $0x0, 0xf300(%rip)      # 0x12838
je 0x3548
movq -0x8(%rbp), %rcx
movq 0xf2f3(%rip), %rax      # 0x12838
movq %rcx, (%rax)
movq 0xf2e9(%rip), %rcx      # 0x12838
movq -0x8(%rbp), %rax
movq %rcx, 0x8(%rax)
movq -0x8(%rbp), %rax
movq $0x0, (%rax)
movq -0x8(%rbp), %rax
movl $0x0, 0x10(%rax)
movq -0x8(%rbp), %rax
movq $0x1, 0x20(%rax)
movq -0x8(%rbp), %rax
movq %rax, 0xf2b4(%rip)      # 0x12838
jmp 0x3586
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/phillbush[P]hoc/code.c
// Function: add
void
add(void)
{
	Datum d1, d2;

	d2 = popnum();
	d1 = popnum();
	d1.u.val += d2.u.val;
	push(d1);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x80, %rsp
leaq -0x48(%rbp), %rdi
callq 0x3620
movq -0x48(%rbp), %rax
movq %rax, -0x30(%rbp)
movq -0x40(%rbp), %rax
movq %rax, -0x28(%rbp)
movq -0x38(%rbp), %rax
movq %rax, -0x20(%rbp)
leaq -0x60(%rbp), %rdi
callq 0x3620
movq -0x60(%rbp), %rax
movq %rax, -0x18(%rbp)
movq -0x58(%rbp), %rax
movq %rax, -0x10(%rbp)
movq -0x50(%rbp), %rax
movq %rax, -0x8(%rbp)
movsd -0x28(%rbp), %xmm0
addsd -0x10(%rbp), %xmm0
movsd %xmm0, -0x10(%rbp)
leaq -0x18(%rbp), %rax
movq (%rax), %rcx
movq %rcx, (%rsp)
movq 0x8(%rax), %rcx
movq %rcx, 0x8(%rsp)
movq 0x10(%rax), %rax
movq %rax, 0x10(%rsp)
callq 0x33a0
addq $0x80, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/phillbush[P]hoc/code.c
// Function: popnum
static Datum
popnum(void)
{
	Datum d;
	double v;

	d = pop();
	if (d.isstr) {
		v = atof(d.u.str->s);
		d.u.val = v;
	}
	d.isstr = 0;
	return d;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x28(%rbp)
movq %rdi, -0x30(%rbp)
leaq -0x20(%rbp), %rdi
callq 0x32a0
movq -0x28(%rbp), %rdi
movq -0x20(%rbp), %rax
movq %rax, (%rdi)
movq -0x18(%rbp), %rax
movq %rax, 0x8(%rdi)
movq -0x10(%rbp), %rax
movq %rax, 0x10(%rdi)
cmpl $0x0, 0x10(%rdi)
je 0x367e
movq -0x28(%rbp), %rax
movq 0x8(%rax), %rax
movq 0x18(%rax), %rdi
callq 0x20b0
movq -0x28(%rbp), %rax
movsd %xmm0, -0x8(%rbp)
movsd -0x8(%rbp), %xmm0
movsd %xmm0, 0x8(%rax)
movq -0x30(%rbp), %rax
movq -0x28(%rbp), %rcx
movl $0x0, 0x10(%rcx)
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/phillbush[P]hoc/code.c
// Function: sub
void
sub(void)
{
	Datum d1, d2;

	d2 = popnum();
	d1 = popnum();
	d1.u.val -= d2.u.val;
	push(d1);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x80, %rsp
leaq -0x48(%rbp), %rdi
callq 0x3620
movq -0x48(%rbp), %rax
movq %rax, -0x30(%rbp)
movq -0x40(%rbp), %rax
movq %rax, -0x28(%rbp)
movq -0x38(%rbp), %rax
movq %rax, -0x20(%rbp)
leaq -0x60(%rbp), %rdi
callq 0x3620
movq -0x60(%rbp), %rax
movq %rax, -0x18(%rbp)
movq -0x58(%rbp), %rax
movq %rax, -0x10(%rbp)
movq -0x50(%rbp), %rax
movq %rax, -0x8(%rbp)
movsd -0x28(%rbp), %xmm1
movsd -0x10(%rbp), %xmm0
subsd %xmm1, %xmm0
movsd %xmm0, -0x10(%rbp)
leaq -0x18(%rbp), %rax
movq (%rax), %rcx
movq %rcx, (%rsp)
movq 0x8(%rax), %rcx
movq %rcx, 0x8(%rsp)
movq 0x10(%rax), %rax
movq %rax, 0x10(%rsp)
callq 0x33a0
addq $0x80, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/phillbush[P]hoc/code.c
// Function: divd
void
divd(void)
{
	Datum d1, d2;

	d2 = popnum();
	if (d2.u.val == 0.0)
		yyerror("division by zero");
	d1 = popnum();
	d1.u.val /= d2.u.val;
	push(d1);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x80, %rsp
leaq -0x48(%rbp), %rdi
callq 0x3620
movq -0x48(%rbp), %rax
movq %rax, -0x30(%rbp)
movq -0x40(%rbp), %rax
movq %rax, -0x28(%rbp)
movq -0x38(%rbp), %rax
movq %rax, -0x20(%rbp)
movsd -0x28(%rbp), %xmm0
xorps %xmm1, %xmm1
ucomisd %xmm1, %xmm0
jne 0x380a
jp 0x380a
leaq 0x79b9(%rip), %rdi      # 0xb1bc
movb $0x0, %al
callq 0x26c0
leaq -0x60(%rbp), %rdi
callq 0x3620
movq -0x60(%rbp), %rax
movq %rax, -0x18(%rbp)
movq -0x58(%rbp), %rax
movq %rax, -0x10(%rbp)
movq -0x50(%rbp), %rax
movq %rax, -0x8(%rbp)
movsd -0x28(%rbp), %xmm1
movsd -0x10(%rbp), %xmm0
divsd %xmm1, %xmm0
movsd %xmm0, -0x10(%rbp)
leaq -0x18(%rbp), %rax
movq (%rax), %rcx
movq %rcx, (%rsp)
movq 0x8(%rax), %rcx
movq %rcx, 0x8(%rsp)
movq 0x10(%rax), %rax
movq %rax, 0x10(%rsp)
callq 0x33a0
addq $0x80, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/phillbush[P]hoc/code.c
// Function: mod
void
mod(void)
{
	Datum d1, d2;

	d2 = popnum();
	if (d2.u.val == 0.0)
		yyerror("module by zero");
	d1 = popnum();
	d1.u.val = fmod(d1.u.val, d2.u.val);
	push(d1);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x80, %rsp
leaq -0x48(%rbp), %rdi
callq 0x3620
movq -0x48(%rbp), %rax
movq %rax, -0x30(%rbp)
movq -0x40(%rbp), %rax
movq %rax, -0x28(%rbp)
movq -0x38(%rbp), %rax
movq %rax, -0x20(%rbp)
movsd -0x28(%rbp), %xmm0
xorps %xmm1, %xmm1
ucomisd %xmm1, %xmm0
jne 0x38ba
jp 0x38ba
leaq 0x791a(%rip), %rdi      # 0xb1cd
movb $0x0, %al
callq 0x26c0
leaq -0x60(%rbp), %rdi
callq 0x3620
movq -0x60(%rbp), %rax
movq %rax, -0x18(%rbp)
movq -0x58(%rbp), %rax
movq %rax, -0x10(%rbp)
movq -0x50(%rbp), %rax
movq %rax, -0x8(%rbp)
movsd -0x10(%rbp), %xmm0
movsd -0x28(%rbp), %xmm1
callq 0x2140
movsd %xmm0, -0x10(%rbp)
leaq -0x18(%rbp), %rax
movq (%rax), %rcx
movq %rcx, (%rsp)
movq 0x8(%rax), %rcx
movq %rcx, 0x8(%rsp)
movq 0x10(%rax), %rax
movq %rax, 0x10(%rsp)
callq 0x33a0
addq $0x80, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/phillbush[P]hoc/code.c
// Function: power
void
power(void)
{
	Datum d1, d2;

	d2 = popnum();
	d1 = popnum();
	d1.u.val = pow(d1.u.val, d2.u.val);
	push(d1);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x80, %rsp
leaq -0x48(%rbp), %rdi
callq 0x3620
movq -0x48(%rbp), %rax
movq %rax, -0x30(%rbp)
movq -0x40(%rbp), %rax
movq %rax, -0x28(%rbp)
movq -0x38(%rbp), %rax
movq %rax, -0x20(%rbp)
leaq -0x60(%rbp), %rdi
callq 0x3620
movq -0x60(%rbp), %rax
movq %rax, -0x18(%rbp)
movq -0x58(%rbp), %rax
movq %rax, -0x10(%rbp)
movq -0x50(%rbp), %rax
movq %rax, -0x8(%rbp)
movsd -0x10(%rbp), %xmm0
movsd -0x28(%rbp), %xmm1
callq 0x20c0
movsd %xmm0, -0x10(%rbp)
leaq -0x18(%rbp), %rax
movq (%rax), %rcx
movq %rcx, (%rsp)
movq 0x8(%rax), %rcx
movq %rcx, 0x8(%rsp)
movq 0x10(%rax), %rax
movq %rax, 0x10(%rsp)
callq 0x33a0
addq $0x80, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/phillbush[P]hoc/code.c
// Function: cmdarg
void
cmdarg(void)
{
	Datum d;
	int i;

	d = popnum();
	i = (int)d.u.val;
	if (i >= 0 && i < argc) {
		d.u.str = &argvstrings[i];
		d.isstr = 1;
	} else {
		d.u.val = 0.0;
		d.isstr = 0;
	}
	push(d);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
leaq -0x38(%rbp), %rdi
callq 0x3620
movq -0x38(%rbp), %rax
movq %rax, -0x18(%rbp)
movq -0x30(%rbp), %rax
movq %rax, -0x10(%rbp)
movq -0x28(%rbp), %rax
movq %rax, -0x8(%rbp)
cvttsd2si -0x10(%rbp), %eax
movl %eax, -0x1c(%rbp)
cmpl $0x0, -0x1c(%rbp)
jl 0x3a91
movl -0x1c(%rbp), %eax
cmpl 0xedd8(%rip), %eax      # 0x12848
jge 0x3a91
movq 0xedd7(%rip), %rax      # 0x12850
movslq -0x1c(%rbp), %rcx
imulq $0x28, %rcx, %rcx
addq %rcx, %rax
movq %rax, -0x10(%rbp)
movl $0x1, -0x8(%rbp)
jmp 0x3aa0
xorps %xmm0, %xmm0
movsd %xmm0, -0x10(%rbp)
movl $0x0, -0x8(%rbp)
leaq -0x18(%rbp), %rax
movq (%rax), %rcx
movq %rcx, (%rsp)
movq 0x8(%rax), %rcx
movq %rcx, 0x8(%rsp)
movq 0x10(%rax), %rax
movq %rax, 0x10(%rsp)
callq 0x33a0
addq $0x50, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/phillbush[P]hoc/code.c
// Function: eval
void
eval(void)
{
	Symbol *sym = NULL;
	Name *name;
	Datum d;

	name = getnamearg();
	if ((sym = lookupsym(currsymtab, name->s)) == NULL)
		if ((sym = lookupsym(global, name->s)) == NULL)
			yyerror("could not find variable %s", name->s);
	d.isstr = sym->isstr;
	d.u = sym->u;
	push(d);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq $0x0, -0x8(%rbp)
callq 0x3b80
movq %rax, -0x10(%rbp)
movq 0xedc0(%rip), %rdi      # 0x128b0
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rsi
callq 0x3bb0
movq %rax, -0x8(%rbp)
cmpq $0x0, %rax
jne 0x3b3d
movq 0xedaa(%rip), %rdi      # 0x128b8
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rsi
callq 0x3bb0
movq %rax, -0x8(%rbp)
cmpq $0x0, %rax
jne 0x3b3b
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rsi
leaq 0x76a8(%rip), %rdi      # 0xb1dc
movb $0x0, %al
callq 0x26c0
jmp 0x3b3d
movq -0x8(%rbp), %rax
movl 0x18(%rax), %eax
movl %eax, -0x18(%rbp)
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rax
movq %rax, -0x20(%rbp)
leaq -0x28(%rbp), %rax
movq (%rax), %rcx
movq %rcx, (%rsp)
movq 0x8(%rax), %rcx
movq %rcx, 0x8(%rsp)
movq 0x10(%rax), %rax
movq %rax, 0x10(%rsp)
callq 0x33a0
addq $0x40, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/phillbush[P]hoc/code.c
// Function: lookupsym
static Symbol *
lookupsym(Symbol *symtab, const char *s)
{
	Symbol *sym;

	for (sym = symtab; sym; sym = sym->next)
		if (strcmp(sym->name, s) == 0)
			return sym;
	return NULL;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x20(%rbp)
cmpq $0x0, -0x20(%rbp)
je 0x3bfe
movq -0x20(%rbp), %rax
movq 0x10(%rax), %rdi
movq -0x18(%rbp), %rsi
callq 0x2190
cmpl $0x0, %eax
jne 0x3bef
movq -0x20(%rbp), %rax
movq %rax, -0x8(%rbp)
jmp 0x3c06
jmp 0x3bf1
movq -0x20(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x20(%rbp)
jmp 0x3bc8
movq $0x0, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x20, %rsp
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O0/phillbush[P]hoc/code.c
// Function: preinc
void
preinc(void)
{
	Symbol *sym;
	Datum d;

	sym = getassign(1);
	d.u.val = sym->u.val += 1.0;
	d.isstr = 0;
	push(d);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movl $0x1, %edi
callq 0x3c70
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
movsd 0x751e(%rip), %xmm0     # 0xb150
addsd 0x8(%rax), %xmm0
movsd %xmm0, 0x8(%rax)
movsd %xmm0, -0x18(%rbp)
movl $0x0, -0x10(%rbp)
leaq -0x20(%rbp), %rax
movq (%rax), %rcx
movq %rcx, (%rsp)
movq 0x8(%rax), %rcx
movq %rcx, 0x8(%rsp)
movq 0x10(%rax), %rax
movq %rax, 0x10(%rsp)
callq 0x33a0
addq $0x40, %rsp
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O0/phillbush[P]hoc/code.c
// Function: getassign
static Symbol *
getassign(int convtonum)
{
	Name *name;
	Symbol *sym;
	double v;

	name = getnamearg();
	verifyassign(name, convtonum);
	if ((sym = lookupsym(currsymtab, name->s)) == NULL)
		if ((sym = lookupsym(global, name->s)) == NULL)
			sym = installglobalsym(name->s);
	name->type = VAR;
	if (convtonum && sym->isstr) {
		v = atof(sym->u.str->s);
		dfree(sym->u.str);
		sym->u.val = v;
		sym->isstr = 0;
	}
	return sym;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movl %edi, -0x4(%rbp)
callq 0x3b80
movq %rax, -0x10(%rbp)
movq -0x10(%rbp), %rdi
movl -0x4(%rbp), %esi
callq 0x5da0
movq 0xec19(%rip), %rdi      # 0x128b0
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rsi
callq 0x3bb0
movq %rax, -0x18(%rbp)
cmpq $0x0, %rax
jne 0x3cdf
movq 0xec03(%rip), %rdi      # 0x128b8
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rsi
callq 0x3bb0
movq %rax, -0x18(%rbp)
cmpq $0x0, %rax
jne 0x3cdd
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rdi
callq 0x5e10
movq %rax, -0x18(%rbp)
jmp 0x3cdf
movq -0x10(%rbp), %rax
movl $0x105, 0x10(%rax)      # imm = 0x105
cmpl $0x0, -0x4(%rbp)
je 0x3d36
movq -0x18(%rbp), %rax
cmpl $0x0, 0x18(%rax)
je 0x3d36
movq -0x18(%rbp), %rax
movq 0x8(%rax), %rax
movq 0x18(%rax), %rdi
callq 0x20b0
movsd %xmm0, -0x20(%rbp)
movq -0x18(%rbp), %rax
movq 0x8(%rax), %rdi
callq 0x3f30
movsd -0x20(%rbp), %xmm0
movq -0x18(%rbp), %rax
movsd %xmm0, 0x8(%rax)
movq -0x18(%rbp), %rax
movl $0x0, 0x18(%rax)
movq -0x18(%rbp), %rax
addq $0x20, %rsp
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O0/phillbush[P]hoc/code.c
// Function: predec
void
predec(void)
{
	Symbol *sym;
	Datum d;

	sym = getassign(1);
	d.u.val = sym->u.val -= 1.0;
	d.isstr = 0;
	push(d);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movl $0x1, %edi
callq 0x3c70
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
movsd 0x8(%rax), %xmm0
movsd 0x73e9(%rip), %xmm1     # 0xb150
subsd %xmm1, %xmm0
movsd %xmm0, 0x8(%rax)
movsd %xmm0, -0x18(%rbp)
movl $0x0, -0x10(%rbp)
leaq -0x20(%rbp), %rax
movq (%rax), %rcx
movq %rcx, (%rsp)
movq 0x8(%rax), %rcx
movq %rcx, 0x8(%rsp)
movq 0x10(%rax), %rax
movq %rax, 0x10(%rsp)
callq 0x33a0
addq $0x40, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/phillbush[P]hoc/code.c
// Function: postinc
void
postinc(void)
{
	Symbol *sym;
	Datum d;

	sym = getassign(1);
	d.u.val = sym->u.val;
	d.isstr = 0;
	sym->u.val += 1.0;
	push(d);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movl $0x1, %edi
callq 0x3c70
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
movsd 0x8(%rax), %xmm0
movsd %xmm0, -0x18(%rbp)
movl $0x0, -0x10(%rbp)
movq -0x8(%rbp), %rax
movsd 0x7369(%rip), %xmm0     # 0xb150
addsd 0x8(%rax), %xmm0
movsd %xmm0, 0x8(%rax)
leaq -0x20(%rbp), %rax
movq (%rax), %rcx
movq %rcx, (%rsp)
movq 0x8(%rax), %rcx
movq %rcx, 0x8(%rsp)
movq 0x10(%rax), %rax
movq %rax, 0x10(%rsp)
callq 0x33a0
addq $0x40, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/phillbush[P]hoc/code.c
// Function: postdec
void
postdec(void)
{
	Symbol *sym;
	Datum d;

	sym = getassign(1);
	d.u.val = sym->u.val;
	d.isstr = 0;
	sym->u.val -= 1.0;
	push(d);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movl $0x1, %edi
callq 0x3c70
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
movsd 0x8(%rax), %xmm0
movsd %xmm0, -0x18(%rbp)
movl $0x0, -0x10(%rbp)
movq -0x8(%rbp), %rax
movsd 0x8(%rax), %xmm0
movsd 0x72f4(%rip), %xmm1     # 0xb150
subsd %xmm1, %xmm0
movsd %xmm0, 0x8(%rax)
leaq -0x20(%rbp), %rax
movq (%rax), %rcx
movq %rcx, (%rsp)
movq 0x8(%rax), %rcx
movq %rcx, 0x8(%rsp)
movq 0x10(%rax), %rax
movq %rax, 0x10(%rsp)
callq 0x33a0
addq $0x40, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/phillbush[P]hoc/code.c
// Function: assign
void
assign(void)
{
	Datum d;
	Symbol *sym;

	d = pop();
	sym = getassign(0);
	if (sym->isstr)
		dfree(sym->u.str);
	if (d.isstr)
		movstr(d.u.str);
	sym->u = d.u;
	sym->isstr = d.isstr;
	push(d);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
leaq -0x38(%rbp), %rdi
callq 0x32a0
movq -0x38(%rbp), %rax
movq %rax, -0x18(%rbp)
movq -0x30(%rbp), %rax
movq %rax, -0x10(%rbp)
movq -0x28(%rbp), %rax
movq %rax, -0x8(%rbp)
xorl %edi, %edi
callq 0x3c70
movq %rax, -0x20(%rbp)
movq -0x20(%rbp), %rax
cmpl $0x0, 0x18(%rax)
je 0x3edb
movq -0x20(%rbp), %rax
movq 0x8(%rax), %rdi
callq 0x3f30
cmpl $0x0, -0x8(%rbp)
je 0x3eea
movq -0x10(%rbp), %rdi
callq 0x34b0
movq -0x20(%rbp), %rax
movq -0x10(%rbp), %rcx
movq %rcx, 0x8(%rax)
movl -0x8(%rbp), %ecx
movq -0x20(%rbp), %rax
movl %ecx, 0x18(%rax)
leaq -0x18(%rbp), %rax
movq (%rax), %rcx
movq %rcx, (%rsp)
movq 0x8(%rax), %rcx
movq %rcx, 0x8(%rsp)
movq 0x10(%rax), %rax
movq %rax, 0x10(%rsp)
callq 0x33a0
addq $0x50, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/phillbush[P]hoc/code.c
// Function: dfree
static void
dfree(String *str)
{
	if (str->orig != FINAL)
		return;
	if (str->count > 1) {
		str->count--;
	} else {
		if (DEBUG)
			printf("FREED STRING: %s\n", str->s);
		free(str->s);
		if (str->next)
			str->next->prev = str->prev;
		if (str->prev)
			str->prev->next = str->next;
		else
			finalstrings = str->next;
		free(str);
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
cmpl $0x0, 0x10(%rax)
je 0x3f48
jmp 0x3fc6
movq -0x8(%rbp), %rax
cmpq $0x1, 0x20(%rax)
jbe 0x3f65
movq -0x8(%rbp), %rax
movq 0x20(%rax), %rcx
addq $-0x1, %rcx
movq %rcx, 0x20(%rax)
jmp 0x3fc6
movq -0x8(%rbp), %rax
movq 0x18(%rax), %rdi
callq 0x2030
movq -0x8(%rbp), %rax
cmpq $0x0, 0x8(%rax)
je 0x3f8f
movq -0x8(%rbp), %rax
movq (%rax), %rcx
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rax
movq %rcx, (%rax)
movq -0x8(%rbp), %rax
cmpq $0x0, (%rax)
je 0x3fae
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rcx
movq -0x8(%rbp), %rax
movq (%rax), %rax
movq %rcx, 0x8(%rax)
jmp 0x3fbd
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rax
movq %rax, 0xe87b(%rip)      # 0x12838
movq -0x8(%rbp), %rdi
callq 0x2030
addq $0x10, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/phillbush[P]hoc/code.c
// Function: addeq
void
addeq(void)
{
	Symbol *sym;
	Datum d;

	d = popnum();
	sym = getassign(1);
	d.u.val = sym->u.val += d.u.val;
	push(d);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
leaq -0x38(%rbp), %rdi
callq 0x3620
movq -0x38(%rbp), %rax
movq %rax, -0x20(%rbp)
movq -0x30(%rbp), %rax
movq %rax, -0x18(%rbp)
movq -0x28(%rbp), %rax
movq %rax, -0x10(%rbp)
movl $0x1, %edi
callq 0x3c70
movq %rax, -0x8(%rbp)
movsd -0x18(%rbp), %xmm0
movq -0x8(%rbp), %rax
addsd 0x8(%rax), %xmm0
movsd %xmm0, 0x8(%rax)
movsd %xmm0, -0x18(%rbp)
leaq -0x20(%rbp), %rax
movq (%rax), %rcx
movq %rcx, (%rsp)
movq 0x8(%rax), %rcx
movq %rcx, 0x8(%rsp)
movq 0x10(%rax), %rax
movq %rax, 0x10(%rsp)
callq 0x33a0
addq $0x50, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/phillbush[P]hoc/code.c
// Function: subeq
void
subeq(void)
{
	Symbol *sym;
	Datum d;

	d = popnum();
	sym = getassign(1);
	d.u.val = sym->u.val -= d.u.val;
	push(d);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
leaq -0x38(%rbp), %rdi
callq 0x3620
movq -0x38(%rbp), %rax
movq %rax, -0x20(%rbp)
movq -0x30(%rbp), %rax
movq %rax, -0x18(%rbp)
movq -0x28(%rbp), %rax
movq %rax, -0x10(%rbp)
movl $0x1, %edi
callq 0x3c70
movq %rax, -0x8(%rbp)
movsd -0x18(%rbp), %xmm1
movq -0x8(%rbp), %rax
movsd 0x8(%rax), %xmm0
subsd %xmm1, %xmm0
movsd %xmm0, 0x8(%rax)
movsd %xmm0, -0x18(%rbp)
leaq -0x20(%rbp), %rax
movq (%rax), %rcx
movq %rcx, (%rsp)
movq 0x8(%rax), %rcx
movq %rcx, 0x8(%rsp)
movq 0x10(%rax), %rax
movq %rax, 0x10(%rsp)
callq 0x33a0
addq $0x50, %rsp
popq %rbp
retq
nopl (%rax,%rax)