LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O3/pahihu[P]mixal/main.c
// Function: assemble_file
static void assemble_file(const char *filename)
{
    FILE *infile = open_file(filename, "r");
    char line[257];

    current_file = filename, line_number = 0;
    while (fgets(line, sizeof line, infile)) {
        ++line_number;
        assemble_line(line);
        if (line[strlen(line) - 1] != '\n') {
            if (!fgets(line, sizeof line, infile))
                break;        /* the file's last line had no '\n' */
            else {
                error("Line length exceeds 256 characters");
                /* Skip the rest of the line */
                while (line[strlen(line) - 1] != '\n')
                    if (!fgets(line, sizeof line, infile))
                        break;
            }
        }
    }
    if (ferror(infile))
        error("%s: %s", filename, strerror(errno));
    fclose(infile);
    current_file = NULL;
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x108, %rsp            # imm = 0x108
movq %rdi, %rbx
cmpb $0x2d, (%rdi)
jne 0x5f99
cmpb $0x0, 0x1(%rbx)
je 0x60a9
leaq 0x339e(%rip), %rsi      # 0x933e
movq %rbx, %rdi
callq 0x3250
movq %rax, %r14
testq %rax, %rax
je 0x60b8
movq %rbx, 0xad2d(%rip)      # 0x10ce8
movl $0x0, 0xad2b(%rip)      # 0x10cf0
movq %rsp, %r15
movq %r15, %rdi
movl $0x101, %esi            # imm = 0x101
movq %r14, %rdx
callq 0x3190
testq %rax, %rax
je 0x605b
leaq 0x3891(%rip), %r12      # 0x9875
incl 0xad06(%rip)            # 0x10cf0
movq %r15, %rdi
callq 0x4204
movq %r15, %rdi
callq 0x3100
cmpb $0xa, -0x1(%rax,%r15)
je 0x6046
movq %r15, %rdi
movl $0x101, %esi            # imm = 0x101
movq %r14, %rdx
callq 0x3190
testq %rax, %rax
je 0x605b
movq %r12, %rdi
xorl %eax, %eax
callq 0x5bec
movq %r15, %rdi
callq 0x3100
cmpb $0xa, -0x1(%rax,%r15)
je 0x6046
movq %r15, %rdi
movl $0x101, %esi            # imm = 0x101
movq %r14, %rdx
callq 0x3190
testq %rax, %rax
jne 0x6021
movq %r15, %rdi
movl $0x101, %esi            # imm = 0x101
movq %r14, %rdx
callq 0x3190
testq %rax, %rax
jne 0x5fe4
movq %r14, %rdi
callq 0x30c0
testl %eax, %eax
je 0x6087
callq 0x3070
movl (%rax), %edi
callq 0x32b0
leaq 0x34aa(%rip), %rdi      # 0x9524
movq %rbx, %rsi
movq %rax, %rdx
xorl %eax, %eax
callq 0x5bec
movq %r14, %rdi
callq 0x30f0
movq $0x0, 0xac4e(%rip) # 0x10ce8
addq $0x108, %rsp            # imm = 0x108
popq %rbx
popq %r12
popq %r14
popq %r15
retq
movq 0x8f28(%rip), %rax      # 0xefd8
movq (%rax), %r14
jmp 0x5fb4
callq 0x3070
movl (%rax), %edi
callq 0x32b0
leaq 0x3459(%rip), %rdi      # 0x9524
movq %rbx, %rsi
movq %rax, %rdx
xorl %eax, %eax
callq 0x5af0
// File: /workspace/github_c_makefile_star2_O3/pahihu[P]mixal/parse.c
// Function: parse_operand
Cell parse_operand(Flag F_must_be_default, Byte default_F)
{
    Cell A = parse_A();
    Cell I = parse_I();
    Cell F = parse_F((Cell)default_F);
    if (F_must_be_default && F != (Cell)default_F)
	error("Illegal operand to extended-opcode instruction");
    return set_field(A, make_field_spec(0, 2),
	     set_field(I, make_field_spec(3, 3),
	       set_field(F, make_field_spec(4, 4), zero)));
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movl %esi, %r14d
movl %edi, %ebp
movzbl 0xa864(%rip), %eax      # 0x10d10
xorl %ebx, %ebx
movl %eax, %ecx
addl $-0x2a, %ecx
cmpl $0x3c, %ecx
ja 0x652c
movabsq $0x40000000000004b, %rdx # imm = 0x40000000000004B
btq %rcx, %rdx
jae 0x64d2
callq 0x6666
movq %rax, %rbx
jmp 0x6526
cmpq $0x13, %rcx
je 0x64ec
cmpq $0x3c, %rcx
jne 0x652c
movq 0xa83b(%rip), %rbx      # 0x10d20
callq 0x62a0
jmp 0x6513
movl $0x3d, %edi
callq 0x68b3
callq 0x65f5
movq %rax, %rbx
movl $0x3d, %edi
callq 0x68b3
movq %rbx, %rdi
callq 0x8b28
movq %rax, %rbx
leaq 0x921a(%rip), %rax      # 0xf734
movl (%rax), %esi
movq %rbx, %rdi
callq 0x8959
xorl %ebx, %ebx
movb 0xa7e4(%rip), %al       # 0x10d10
cmpb $0x2c, %al
jne 0x653f
callq 0x62a0
callq 0x6666
movq %rax, %r15
jmp 0x6542
xorl %r15d, %r15d
movl %r14d, %r12d
movq %r12, %rdi
callq 0x65cb
movq %rax, %r14
testl %ebp, %ebp
sete %al
cmpq %r12, %r14
sete %cl
orb %al, %cl
jne 0x656d
leaq 0x366a(%rip), %rdi      # 0x9bd0
xorl %eax, %eax
callq 0x5bec
xorl %edi, %edi
movl $0x2, %esi
callq 0x382a
movl %eax, %ebp
movl $0x3, %edi
movl $0x3, %esi
callq 0x382a
movl %eax, %r12d
movl $0x4, %edi
movl $0x4, %esi
callq 0x382a
movq %r14, %rdi
movl %eax, %esi
xorl %edx, %edx
callq 0x38b6
movq %r15, %rdi
movl %r12d, %esi
movq %rax, %rdx
callq 0x38b6
movq %rbx, %rdi
movl %ebp, %esi
movq %rax, %rdx
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
jmp 0x38b6
// File: /workspace/github_c_makefile_star2_O3/pahihu[P]mixal/parse.c
// Function: parse_F
static Cell parse_F(Cell default_F)
{
    if (token == '(') {
	Cell result;
	advance();
	result = parse_expr();
	expect(')');
	return result;
    } else
	return default_F;
}

// Assembly:
cmpb $0x28, 0xa73e(%rip)     # 0x10d10
jne 0x65f1
pushq %rbx
callq 0x62a0
callq 0x6666
movq %rax, %rbx
movl $0x29, %edi
callq 0x68b3
movq %rbx, %rax
popq %rbx
retq
movq %rdi, %rax
retq
// File: /workspace/github_c_makefile_star2_O3/pahihu[P]mixal/parse.c
// Function: parse_W
Cell parse_W(void)
{
    Cell result = zero;
    for (;;) {
	Cell expr = parse_expr();
	Cell F = parse_F(5);
	assert_valid_field(F);
	result = set_field(expr, (Byte) F, result);
	if (token != ',')
	    break;
	advance();
    }
    return result;
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
callq 0x6666
movq %rax, %rbx
movl $0x5, %edi
callq 0x65cb
movq %rax, %r14
movq %rax, %rdi
callq 0x39f0
movq %rbx, %rdi
movl %r14d, %esi
xorl %edx, %edx
callq 0x38b6
movq %rax, %rbx
cmpb $0x2c, 0xa6e2(%rip)     # 0x10d10
jne 0x665d
callq 0x62a0
callq 0x6666
movq %rax, %r14
movl $0x5, %edi
callq 0x65cb
movq %rax, %r15
movq %rax, %rdi
callq 0x39f0
movq %r14, %rdi
movl %r15d, %esi
movq %rbx, %rdx
jmp 0x661f
movq %rbx, %rax
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O3/pahihu[P]mixal/parse.c
// Function: parse_expr
static Cell parse_expr(void)
{
    Flag sav_overflow = overflow;       /* do not clobber overflow */

    Cell sign = ulong_to_cell(1);
    if (token == '+' || token == '-') {
	if (token == '-')
	    sign = negative(sign);
	    advance();
    }
    overflow = false;
    {
	static const char ops[] = "+-*/%:";
	static BinOp * const handlers[] = 
	       { add, sub, mul, slash, double_slash, colon };
	Cell cell = mul(sign, parse_atomic());
	for (;;) {
	    const char *s = strchr(ops, token);
	    if (s) {
		advance();
		cell = handlers[s - ops](cell, parse_atomic());
	    } else {
		if (overflow)
		    warn("Overflow in evaluation of expression");
                overflow = sav_overflow;
		return cell;
	    }
	}
    }
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
leaq 0x94c8(%rip), %r12      # 0xfb40
movl (%r12), %ebp
movl $0x1, %edi
callq 0x374c
movq %rax, %rbx
movzbl 0xa680(%rip), %eax      # 0x10d10
cmpl $0x2b, %eax
je 0x66a1
cmpl $0x2d, %eax
jne 0x66a6
xorq $0x40000000, %rbx       # imm = 0x40000000
callq 0x62a0
movl $0x0, (%r12)
callq 0x693d
movq %rbx, %rdi
movq %rax, %rsi
callq 0x3c15
movq %rax, %rbx
movsbl 0xa648(%rip), %esi      # 0x10d10
leaq 0x35f7(%rip), %r14      # 0x9cc6
movl $0x7, %edx
movq %r14, %rdi
callq 0x3180
testq %rax, %rax
je 0x6722
movq %rax, %r15
leaq 0x80c5(%rip), %r13      # 0xe7b0
callq 0x62a0
subq %r14, %r15
callq 0x693d
movq %rbx, %rdi
movq %rax, %rsi
callq *(%r13,%r15,8)
movq %rax, %rbx
movsbl 0xa603(%rip), %esi      # 0x10d10
movl $0x7, %edx
movq %r14, %rdi
callq 0x3180
movq %rax, %r15
testq %rax, %rax
jne 0x66eb
cmpl $0x0, (%r12)
je 0x6737
leaq 0x3558(%rip), %rdi      # 0x9c88
xorl %eax, %eax
callq 0x331d
movl %ebp, (%r12)
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/pahihu[P]mixal/parse.c
// Function: parse_S
static void advance_S(void)
{
    token = number;
    token_value = zero;

    if (the_string[0] == '\0') {
        token = eos;
	return;
    } else if (the_string[0] == '"') {      /* a quoted string */
	token = number;
	token_value = zero;
	++the_string;
	{
	    const char *end = strchr(the_string, '"');
	    if (!end) {
		error("Missing '\"'");
		the_string += strlen (the_string);
	    } else {
		unsigned length = end - the_string;
		if (5 < length) {
		    warn("String doesn't fit in a machine word");
		    length = 5;
		}
		{
		    unsigned i;
		    for (i = 0; i < length; ++i)
			token_value =
			  set_byte(C_char_to_mix(the_string[i]), i+1, token_value);
		}
	    }
	    the_string = end + 1;
	}
    } else {    /* read max. 5 chars */
        unsigned i;
        for (i = 0; i < 5; i++) {
            if (the_string[0] == '\0') {
                token = eos;
                break;
            }
	    token_value = set_byte(C_char_to_mix(the_string[0]), i+1, token_value);
            the_string++;
        }
    }
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movb $0x30, 0xa5b4(%rip)     # 0x10d10
movq $0x0, 0xa5b1(%rip) # 0x10d18
movq 0xa59a(%rip), %r14      # 0x10d08
movzbl (%r14), %eax
testl %eax, %eax
je 0x67c4
cmpl $0x22, %eax
jne 0x67d3
incq %r14
movq %r14, 0xa583(%rip)      # 0x10d08
movq %r14, %rdi
movl $0x22, %esi
callq 0x3110
movq %rax, %rbx
testq %rax, %rax
je 0x6821
movq %rbx, %r12
subq %r14, %r12
cmpl $0x6, %r12d
jb 0x6838
leaq 0x3493(%rip), %rdi      # 0x9c48
xorl %eax, %eax
callq 0x331d
movl $0x5, %r12d
jmp 0x683d
movb $0x7a, 0xa545(%rip)     # 0x10d10
xorl %r14d, %r14d
jmp 0x6882
movl $0x1, %ebx
movsbl %al, %edi
callq 0x4189
movq 0xa531(%rip), %rdx      # 0x10d18
movl %eax, %edi
movl %ebx, %esi
callq 0x385b
movq %rax, %r14
movq %rax, 0xa51e(%rip)      # 0x10d18
movq 0xa507(%rip), %rax      # 0x10d08
incq %rax
movq %rax, 0xa4fd(%rip)      # 0x10d08
cmpl $0x5, %ebx
je 0x6882
movb (%rax), %al
incl %ebx
testb %al, %al
jne 0x67d8
movb $0x7a, 0xa4f1(%rip)     # 0x10d10
jmp 0x6882
leaq 0x3414(%rip), %rdi      # 0x9c3c
xorl %eax, %eax
callq 0x5bec
movq 0xa4e2(%rip), %r14      # 0x10d18
jmp 0x6878
testl %r12d, %r12d
je 0x6896
andl $0x7, %r12d
xorl %r15d, %r15d
movq 0xa4bd(%rip), %rax      # 0x10d08
movsbl (%rax,%r15), %edi
callq 0x4189
incq %r15
movq 0xa4b9(%rip), %rdx      # 0x10d18
movl %eax, %edi
movl %r15d, %esi
callq 0x385b
movq %rax, 0xa4a8(%rip)      # 0x10d18
cmpq %r15, %r12
jne 0x6844
movq %rax, %r14
incq %rbx
movq %rbx, 0xa486(%rip)      # 0x10d08
callq 0x62a0
movq %r14, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
xorl %r14d, %r14d
jmp 0x6878
// File: /workspace/github_c_makefile_star2_O3/pahihu[P]mixal/parse.c
// Function: expect
static void expect(char expected_token)
{
    if (token != expected_token)
        error ("Expected '%c', not '%*.*s'",
	       expected_token,
	       the_string - token_start, the_string - token_start, token_start);
    advance();
}

// Assembly:
cmpb %dil, 0xa456(%rip)      # 0x10d10
je 0x62a0
pushq %rax
movzbl %dil, %esi
movq 0xa43c(%rip), %rcx      # 0x10d08
leaq 0x339a(%rip), %rdi      # 0x9c6d
movq %rcx, %rdx
xorl %r8d, %r8d
xorl %eax, %eax
callq 0x5bec
addq $0x8, %rsp
jmp 0x62a0
// File: /workspace/github_c_makefile_star2_O3/pahihu[P]mixal/parse.c
// Function: parse_atomic
static Cell parse_atomic(void)
{
    Cell result = zero;
    switch (token) {
	case '*':           result = address_to_cell(here); break;
	case number:        result = token_value; break;
	case defined_sym:   result = symbol_value(token_symbol); break;
	default: 
	    error("Expected an atomic value");
    }
    advance();
    return result;
}

// Assembly:
pushq %rbx
movzbl 0xa3cb(%rip), %eax      # 0x10d10
cmpl $0x64, %eax
je 0x696d
cmpl $0x30, %eax
je 0x6964
cmpl $0x2a, %eax
jne 0x697e
leaq 0x8dd9(%rip), %rax      # 0xf734
movl (%rax), %edi
callq 0x4033
jmp 0x6979
movq 0xa3ad(%rip), %rbx      # 0x10d18
jmp 0x698e
movq 0xa3ac(%rip), %rdi      # 0x10d20
callq 0x892e
movq %rax, %rbx
jmp 0x698e
leaq 0x3328(%rip), %rdi      # 0x9cad
xorl %ebx, %ebx
xorl %eax, %eax
callq 0x5bec
callq 0x62a0
movq %rbx, %rax
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O3/pahihu[P]mixal/run.c
// Function: set_initial_state
void set_initial_state(void)
{
    /* --- Initialize I/O system --- */
    io_init();

    overflow = false;
    comparison_indicator = 0;
    internal_state = (mix_config & MIXCONFIG_INTERRUPT)
            ? control_state 
            : normal_state;

    /* --- Init real-time clock --- */
    rtc_busy = 0;
    rtc_int_pending = false;
    {
    unsigned i;
    for (i = 0; i < 10; ++i)
        r[i] = zero;
    }
    pc = entry_point;       /*** need to check for no entry point */
    halting = false;
}

// Assembly:
pushq %rax
callq 0x4d5d
leaq 0x918c(%rip), %rax      # 0xfb40
xorl %ecx, %ecx
movl %ecx, (%rax)
movl %ecx, 0xa386(%rip)      # 0x10d44
movl 0xa378(%rip), %eax      # 0x10d3c
shrl %eax
andl $0x1, %eax
movl %eax, 0xa379(%rip)      # 0x10d48
movl %ecx, 0xa377(%rip)      # 0x10d4c
movb %cl, 0xa375(%rip)       # 0x10d50
xorps %xmm0, %xmm0
movaps %xmm0, 0xa37b(%rip)     # 0x10d60
movaps %xmm0, 0xa384(%rip)     # 0x10d70
movaps %xmm0, 0xa38d(%rip)     # 0x10d80
movaps %xmm0, 0xa396(%rip)     # 0x10d90
movaps %xmm0, 0xa39f(%rip)     # 0x10da0
leaq 0x8d30(%rip), %rax      # 0xf738
movl (%rax), %eax
movl %eax, 0xa3a0(%rip)      # 0x10db0
movb %cl, 0xa32a(%rip)       # 0x10d40
popq %rax
retq
// File: /workspace/github_c_makefile_star2_O3/pahihu[P]mixal/run.c
// Function: set_configuration
void set_configuration(unsigned flags)
{
    memory_size = 4000;
    INDEX_MAX = ((1L << 12) - 1);

    if (MIXCONFIG_MASTER & flags) {
        flags = (unsigned) -1;
        INDEX_MAX = ((1L << 15) - 1);
        memory_size = 32000;
    }
    mix_config |= flags;

    init_configuration();
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movl $0xfa0, 0xa387(%rip)    # imm = 0xFA0
movq $0xfff, 0xa380(%rip) # imm = 0xFFF
movl $0xfa0, %ebx            # imm = 0xFA0
testb %dil, %dil
jns 0x6a61
movq $0x7fff, 0xa36b(%rip) # imm = 0x7FFF
movl $0x7d00, 0xa35d(%rip)   # imm = 0x7D00
movl $0xffffffff, %edi       # imm = 0xFFFFFFFF
movl $0x7d00, %ebx           # imm = 0x7D00
orl %edi, 0xa2d5(%rip)      # 0x10d3c
leal (,%rbx,8), %r14d
movq %r14, %rdi
callq 0x31f0
movq %rax, 0xa34a(%rip)      # 0x10dc8
testq %rax, %rax
jne 0x6aa0
leaq 0x2a1c(%rip), %rdi      # 0x94a6
xorl %eax, %eax
callq 0x5af0
movslq 0xa31c(%rip), %rbx      # 0x10db4
leaq (,%rbx,8), %r14
movq %r14, %rdi
callq 0x31f0
movq %rax, 0xa311(%rip)      # 0x10dc0
testq %rax, %rax
jne 0x6ac9
leaq 0x29eb(%rip), %rdi      # 0x94a6
xorl %eax, %eax
callq 0x5af0
movslq 0xa2eb(%rip), %rbx      # 0x10db4
shlq $0x2, %rbx
movq %rbx, %rdi
callq 0x31f0
movq %rax, 0xa2fc(%rip)      # 0x10dd8
testq %rax, %rax
jne 0x6afa
leaq 0x29be(%rip), %rdi      # 0x94a6
xorl %eax, %eax
callq 0x5af0
movslq 0xa2be(%rip), %rbx      # 0x10db4
shlq $0x2, %rbx
movq %rbx, %rdi
callq 0x31f0
movq %rax, 0xa3c7(%rip)      # 0x10ed0
testq %rax, %rax
jne 0x6b1c
leaq 0x2991(%rip), %rdi      # 0x94a6
xorl %eax, %eax
callq 0x5af0
movl 0xa21a(%rip), %eax      # 0x10d3c
testb $0x8, %al
jne 0x6b2e
addq $0x8, %rsp
popq %rbx
popq %r14
retq
movl 0xa280(%rip), %edx      # 0x10db4
testb $0x2, %al
je 0x6b51
movq 0xa281(%rip), %rsi      # 0x10dc0
leaq 0x32e3(%rip), %rdi      # 0x9e29
callq 0x7847
movl 0xa263(%rip), %edx      # 0x10db4
movq 0xa270(%rip), %rsi      # 0x10dc8
leaq 0x32d6(%rip), %rdi      # 0x9e35
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x7847
// File: /workspace/github_c_makefile_star2_O3/pahihu[P]mixal/run.c
// Function: print_CPU_state
void print_CPU_state(void)
{
    printf ("A:");
    print_cell (r[A]);
    printf ("\t");
    {                        /* Print the index registers: */
        unsigned i;
        for (i = 1; i <= 6; ++i)
        printf ("I%u:%s  ", i, index_to_string (r[i]));
    }
    printf ("\nX:");
    print_cell (r[X]);
    printf ("\t J:%s", index_to_string (r[J])); /* (it's always nonnegative) */
    printf ("  PC:"); print_pc();
    printf ("  Flags: %-7s %-8s %-7s",
        comparison_indicator < 0 ? "less" :
        comparison_indicator == 0 ? "equal" : "greater",
    overflow ? "overflow" : "",
        control_state == internal_state ? "control" : "");
    printf (" %11lu elapsed (%lu idle)\n", elapsed_time, idle_time);
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
leaq 0x31ed(%rip), %rdi      # 0x9d64
xorl %eax, %eax
callq 0x3120
movq 0xa1db(%rip), %rdi      # 0x10d60
callq 0x3f81
movl $0x9, %edi
callq 0x3050
movl $0x1, %ebx
leaq 0xa1c0(%rip), %r15      # 0x10d60
leaq 0x31c0(%rip), %r14      # 0x9d67
movq (%r15,%rbx,8), %rdi
callq 0x3fe9
movq %r14, %rdi
movl %ebx, %esi
movq %rax, %rdx
xorl %eax, %eax
callq 0x3120
incq %rbx
cmpq $0x7, %rbx
jne 0x6ba7
leaq 0x31a1(%rip), %rdi      # 0x9d70
xorl %eax, %eax
callq 0x3120
movq 0xa1bb(%rip), %rdi      # 0x10d98
callq 0x3f81
movq 0xa1b7(%rip), %rdi      # 0x10da0
callq 0x3fe9
leaq 0x317f(%rip), %rdi      # 0x9d74
movq %rax, %rsi
xorl %eax, %eax
callq 0x3120
leaq 0x3175(%rip), %rdi      # 0x9d7b
xorl %eax, %eax
callq 0x3120
movl 0xa19d(%rip), %edi      # 0x10db0
callq 0x3fa3
leaq 0x3922(%rip), %rdi      # 0xa541
movq %rax, %rsi
xorl %eax, %eax
callq 0x3120
cmpl $0x0, 0xa114(%rip)      # 0x10d44
leaq 0x3167(%rip), %rax      # 0x9d9e
leaq 0x3166(%rip), %rcx      # 0x9da4
cmoveq %rax, %rcx
leaq 0x3150(%rip), %rsi      # 0x9d99
cmovnsq %rcx, %rsi
leaq 0x8eec(%rip), %rax      # 0xfb40
cmpl $0x0, (%rax)
leaq 0x268c(%rip), %rax      # 0x92ea
leaq 0x3147(%rip), %rdx      # 0x9dac
cmoveq %rax, %rdx
cmpl $0x1, 0xa0d8(%rip)      # 0x10d48
leaq 0x313e(%rip), %rcx      # 0x9db5
cmovneq %rax, %rcx
leaq 0x30ff(%rip), %rdi      # 0x9d81
xorl %eax, %eax
callq 0x3120
movq 0xa0a0(%rip), %rsi      # 0x10d30
leaq 0x9019(%rip), %rax      # 0xfcb0
movq (%rax), %rdx
leaq 0x311c(%rip), %rdi      # 0x9dbd
xorl %eax, %eax
popq %rbx
popq %r14
popq %r15
jmp 0x3120
// File: /workspace/github_c_makefile_star2_O3/pahihu[P]mixal/run.c
// Function: memory_fetch
Cell memory_fetch(Address address)
{
    Cell cell;

    if (memory_size <= abs(address))
        error("Address out of range");

    if (address < 0) {
        check_interrupt();
        if (normal_state == internal_state)
            error("Cannot access control store in normal state");

        cell = control_memory[-address];
    }
    else
        cell = memory[address];

    return cell;
}

// Assembly:
pushq %rbp
pushq %rbx
pushq %rax
movl %edi, %ebx
movl %edi, %ebp
negl %ebp
movl %edi, %eax
cmovnsl %ebp, %eax
cmpl %eax, 0xa0f3(%rip)      # 0x10db4
jg 0x6cd1
leaq 0x310e(%rip), %rdi      # 0x9dd8
xorl %eax, %eax
callq 0x5bec
testl %ebx, %ebx
js 0x6ce0
leaq 0xa0ec(%rip), %rax      # 0x10dc8
movl %ebx, %ebp
jmp 0x6d15
testb $0x2, 0xa055(%rip)      # 0x10d3c
jne 0x6cf7
leaq 0x3172(%rip), %rdi      # 0x9e62
xorl %eax, %eax
callq 0x5bec
cmpl $0x0, 0xa04a(%rip)      # 0x10d48
jne 0x6d0e
leaq 0x2855(%rip), %rdi      # 0x955c
xorl %eax, %eax
callq 0x5bec
leaq 0xa0ab(%rip), %rax      # 0x10dc0
movq (%rax), %rax
movl %ebp, %ecx
movq (%rax,%rcx,8), %rax
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/pahihu[P]mixal/run.c
// Function: memory_store
void memory_store(Address address, Cell cell)
{
    if (memory_size <= abs(address))
        error("Address out of range");

    if (address < 0) {
    check_interrupt();
        if (normal_state == internal_state)
            error("Cannot access control store in normal state");

        memory[-address] = cell;
        if (-10 == address)
            rtc_busy = 1000;
    } else
        memory[address] = cell;
}

// Assembly:
pushq %rbp
pushq %r14
pushq %rbx
movq %rsi, %rbx
movl %edi, %ebp
movl %edi, %r14d
negl %r14d
movl %edi, %eax
cmovnsl %r14d, %eax
cmpl %eax, 0xa074(%rip)      # 0x10db4
jg 0x6d50
leaq 0x308f(%rip), %rdi      # 0x9dd8
xorl %eax, %eax
callq 0x5bec
testl %ebp, %ebp
js 0x6d63
movq 0xa06d(%rip), %rax      # 0x10dc8
movl %ebp, %ecx
movq %rbx, (%rax,%rcx,8)
jmp 0x6dab
testb $0x2, 0x9fd2(%rip)      # 0x10d3c
jne 0x6d7a
leaq 0x30ef(%rip), %rdi      # 0x9e62
xorl %eax, %eax
callq 0x5bec
cmpl $0x0, 0x9fc7(%rip)      # 0x10d48
jne 0x6d91
leaq 0x27d2(%rip), %rdi      # 0x955c
xorl %eax, %eax
callq 0x5bec
movq 0xa030(%rip), %rax      # 0x10dc8
movq %rbx, (%rax,%r14,8)
cmpl $-0xa, %ebp
jne 0x6dab
movl $0x3e8, 0x9fa1(%rip)    # imm = 0x3E8
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/pahihu[P]mixal/run.c
// Function: print_DUMP
void print_DUMP(void)
{
    int i, j;
    Address address = 0;
    
    printf ("\n");
    printf ("CONTENTS OF MIX MEMORY (NONZERO LOCATIONS ONLY)\n\n");
    printf ("LOC        0           1           2           3                  FREQUENCY COUNTS\n");
    for (i = 0; i < memory_size / 4; i++, address += 4) {
        Flag has_nonzero = false;
        for (j = 0; !has_nonzero && j < 4; j++) {
            Cell value = memory_fetch(address + j);
            if (magnitude(value))
                has_nonzero = true;
        }
        if (!has_nonzero)
            continue;
        printf ("%s:", address_to_string(address));
        for (j = 0; j < 4; j++) {
            Cell value = memory_fetch(address + j);
            if (magnitude(value)) {
                printf (" ");
                print_cell (value);
            }
            else
                printf (" %11s", "");
        }
        printf("     ");
        for (j = 0; j < 4; j++)
            printf(" %07d", frequency[address + j]);
        printf("\n");
    }
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movl $0xa, %edi
callq 0x3050
leaq 0x3592(%rip), %rdi      # 0xa366
callq 0x30b0
leaq 0x35b7(%rip), %rdi      # 0xa397
callq 0x30b0
cmpl $0x4, 0x9fc8(%rip)      # 0x10db4
jl 0x6ee6
leaq 0x2ffe(%rip), %r13      # 0x9df7
xorl %r12d, %r12d
xorl %ebp, %ebp
xorl %r14d, %r14d
xorl %ebx, %ebx
leal (%rbx,%rbp), %edi
callq 0x6cad
testl $0x3fffffff, %eax       # imm = 0x3FFFFFFF
jne 0x6e1c
leal 0x1(%rbx), %ecx
cmpl $0x3, %ebx
movl %ecx, %ebx
jb 0x6e03
shlq $0x22, %rax
je 0x6ec1
movl %ebp, %edi
callq 0x3fa3
xorl %r15d, %r15d
leaq 0x2fb6(%rip), %rdi      # 0x9ded
movq %rax, %rsi
xorl %eax, %eax
callq 0x3120
leal (%r15,%rbp), %edi
callq 0x6cad
movq %rax, %rbx
testl $0x3fffffff, %ebx       # imm = 0x3FFFFFFF
je 0x6e69
movl $0x20, %edi
callq 0x3050
movq %rbx, %rdi
callq 0x3f81
jmp 0x6e7e
leaq 0x2f81(%rip), %rdi      # 0x9df1
leaq 0x2473(%rip), %rsi      # 0x92ea
xorl %eax, %eax
callq 0x3120
incl %r15d
cmpl $0x4, %r15d
jne 0x6e41
leaq 0x28e9(%rip), %rdi      # 0x9777
xorl %eax, %eax
callq 0x3120
xorl %ebx, %ebx
movq 0x9f3a(%rip), %rax      # 0x10dd8
addq %r12, %rax
movl (%rax,%rbx,4), %esi
movq %r13, %rdi
xorl %eax, %eax
callq 0x3120
incq %rbx
cmpq $0x4, %rbx
jne 0x6e97
movl $0xa, %edi
callq 0x3050
incl %r14d
addq $0x4, %rbp
movl 0x9ee6(%rip), %eax      # 0x10db4
leal 0x3(%rax), %ecx
testl %eax, %eax
cmovnsl %eax, %ecx
sarl $0x2, %ecx
addq $0x10, %r12
cmpl %ecx, %r14d
jl 0x6e01
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/pahihu[P]mixal/run.c
// Function: mnemonic
const char* mnemonic(Byte C, Byte F)
{
    static char buffer[5];
    const char *ret = op_table[C].mnemonic;
    
    if (*ret == '*') {
        strncpy(buffer, ret + 1 + F * 4, 4);
        buffer[4] = '\0';
        ret = buffer;
    } else if (*ret == '%') {
        strncpy(buffer, ret + 1 + (7 & F) * 4, 4);
        buffer[4] = '\0';
        ret = buffer;
    }
    return ret;
}

// Assembly:
pushq %rbx
movl %edi, %eax
leaq (%rax,%rax,2), %rax
leaq 0x78dd(%rip), %rcx      # 0xe7e0
movq 0x10(%rcx,%rax,8), %rbx
movzbl (%rbx), %eax
cmpl $0x25, %eax
je 0x6f1a
cmpl $0x2a, %eax
jne 0x6f44
shll $0x2, %esi
jmp 0x6f20
shll $0x2, %esi
andl $0x1c, %esi
movl %esi, %eax
leaq (%rbx,%rax), %rsi
incq %rsi
leaq 0x9eb0(%rip), %rbx      # 0x10de0
movl $0x4, %edx
movq %rbx, %rdi
callq 0x3080
movb $0x0, 0x9ea0(%rip)      # 0x10de4
movq %rbx, %rax
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O3/pahihu[P]mixal/run.c
// Function: stop
static void stop(const char *message, va_list args)
{
    fprintf(stderr, "RUNTIME ERROR: ");
    vfprintf(stderr, message, args);
    fprintf(stderr, "\n");
    print_CPU_state();
    exit(1);
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rsi, %rbx
movq %rdi, %r14
movq 0x7c3e(%rip), %r15      # 0xeff8
movq (%r15), %rcx
leaq 0x2f3d(%rip), %rdi      # 0xa301
movl $0xf, %esi
movl $0x1, %edx
callq 0x32a0
movq (%r15), %rdi
movq %r14, %rsi
movq %rbx, %rdx
callq 0x3260
movq (%r15), %rsi
movl $0xa, %edi
callq 0x3170
callq 0x6b6b
movl $0x1, %edi
callq 0x3290
// File: /workspace/github_c_makefile_star2_O3/pahihu[P]mixal/run.c
// Function: save_memory
static void save_memory(const char *path, Cell *store, unsigned size)
{
    FILE *fout;
    size_t cells_written;

    fout = fopen(path, "wb");
    if (NULL == fout)
        error("Cannot open %s", path);
    cells_written = fwrite(store, sizeof(Cell), size, fout);
    fclose(fout);
    if (cells_written != size)
        error("Cannot write %d cells to %s", size, path);
}

// Assembly:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
movl %edx, %ebx
movq %rsi, %r15
movq %rdi, %r14
leaq 0x2efc(%rip), %rsi      # 0xa311
callq 0x3250
movq %rax, %r12
testq %rax, %rax
jne 0x7433
leaq 0x2eeb(%rip), %rdi      # 0xa314
movq %r14, %rsi
xorl %eax, %eax
callq 0x5bec
movl %ebx, %r13d
movl $0x8, %esi
movq %r15, %rdi
movq %r13, %rdx
movq %r12, %rcx
callq 0x32a0
movq %rax, %r15
movq %r12, %rdi
callq 0x30f0
cmpq %r13, %r15
jne 0x7463
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
leaq 0x2eb9(%rip), %rdi      # 0xa323
movl %ebx, %esi
movq %r14, %rdx
xorl %eax, %eax
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
jmp 0x5bec
// File: /workspace/github_c_makefile_star2_O3/pahihu[P]mixal/run.c
// Function: save_state
static void save_state(void)
{
    Cell psw;
    Byte flags;
    int i;

    control_memory[9] = r[A];
    control_memory[8] = r[X];
    for (i = 1; i < 7; i++)
        control_memory[8 - i] = r[i];

    flags = 0;
    if (overflow)
        flags += 8;
    flags += 1 + SIGN(comparison_indicator);

    psw = set_field(r[J], make_field_spec(4, 5), zero);
    psw = set_byte(flags, 3, psw);
    psw = set_field(address_to_cell(pc), make_field_spec(1, 2), psw);

    control_memory[1] = psw;
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq 0x95e8(%rip), %rcx      # 0x10d60
movq 0x9641(%rip), %rax      # 0x10dc0
movq %rcx, 0x48(%rax)
movq 0x960e(%rip), %rcx      # 0x10d98
movq %rcx, 0x40(%rax)
movl $0x7, %ecx
leaq 0x95ce(%rip), %rdx      # 0x10d68
movq (%rdx), %rsi
movq %rsi, (%rax,%rcx,8)
decq %rcx
addq $0x8, %rdx
cmpq $0x1, %rcx
jne 0x779a
movl 0x9590(%rip), %eax      # 0x10d44
xorl %ecx, %ecx
testl %eax, %eax
setne %cl
incl %ecx
xorl %edx, %edx
testl %eax, %eax
cmovsl %edx, %ecx
leaq 0x8375(%rip), %rax      # 0xfb40
xorl %edx, %edx
cmpl $0x0, (%rax)
setne %dl
leal (%rcx,%rdx,8), %ebx
movq 0x95c3(%rip), %r14      # 0x10da0
movl $0x4, %edi
movl $0x5, %esi
callq 0x382a
movq %r14, %rdi
movl %eax, %esi
xorl %edx, %edx
callq 0x38b6
movl %ebx, %edi
movl $0x3, %esi
movq %rax, %rdx
callq 0x385b
movq %rax, %rbx
movl 0x95a0(%rip), %edi      # 0x10db0
callq 0x4033
movq %rax, %r14
movl $0x1, %edi
movl $0x2, %esi
callq 0x382a
movq %r14, %rdi
movl %eax, %esi
movq %rbx, %rdx
callq 0x38b6
movq 0x9585(%rip), %rcx      # 0x10dc0
movq %rax, 0x8(%rcx)
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O3/pahihu[P]mixal/run.c
// Function: load_memory
static void load_memory(const char *path, Cell *store, unsigned size)
{
    FILE *fin;

    fin = fopen(path, "rb");
    if (NULL == fin)
        return;
    fread(store, sizeof(Cell), size, fin);
    fclose(fin);
}

// Assembly:
pushq %rbp
pushq %r14
pushq %rbx
movl %edx, %ebp
movq %rsi, %rbx
leaq 0x1bd5(%rip), %rsi      # 0x942c
callq 0x3250
testq %rax, %rax
je 0x7882
movq %rax, %r14
movl %ebp, %edx
movl $0x8, %esi
movq %rbx, %rdi
movq %rax, %rcx
callq 0x30d0
movq %r14, %rdi
popq %rbx
popq %r14
popq %rbp
jmp 0x30f0
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/pahihu[P]mixal/run.c
// Function: do_add
static void do_add(void)
{
    if (6 == F) {
        check_float();
        r[A] = float_add(r[A], safe_fetch(cell_to_address(M)));
        elapsed_time += 2;
    } else
        r[A] = add(r[A], get_V());
}

// Assembly:
pushq %rbx
cmpl $0x6, 0x955c(%rip)      # 0x10dec
jne 0x78df
testb $0x4, 0x94a3(%rip)      # 0x10d3c
jne 0x78a9
leaq 0x296e(%rip), %rdi      # 0xa210
xorl %eax, %eax
callq 0x5bec
movq 0x94b0(%rip), %rbx      # 0x10d60
movq 0x9539(%rip), %rdi      # 0x10df0
callq 0x4037
movl %eax, %edi
callq 0x712a
movq %rbx, %rdi
movq %rax, %rsi
callq 0x40ae
movq %rax, 0x948b(%rip)      # 0x10d60
addq $0x2, 0x9453(%rip)      # 0x10d30
jmp 0x78fd
movq 0x947a(%rip), %rbx      # 0x10d60
callq 0x85ae
movq %rbx, %rdi
movq %rax, %rsi
callq 0x3ad2
movq %rax, 0x9463(%rip)      # 0x10d60
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O3/pahihu[P]mixal/run.c
// Function: do_sub
static void do_sub(void)
{
    if (6 == F) {
        check_float();
        r[A] = float_subtract(r[A], safe_fetch(cell_to_address(M)));
        elapsed_time += 2;
    } else
        r[A] = sub(r[A], get_V());
}

// Assembly:
pushq %rbx
cmpl $0x6, 0x94e5(%rip)      # 0x10dec
jne 0x7956
testb $0x4, 0x942c(%rip)      # 0x10d3c
jne 0x7920
leaq 0x28f7(%rip), %rdi      # 0xa210
xorl %eax, %eax
callq 0x5bec
movq 0x9439(%rip), %rbx      # 0x10d60
movq 0x94c2(%rip), %rdi      # 0x10df0
callq 0x4037
movl %eax, %edi
callq 0x712a
movq %rbx, %rdi
movq %rax, %rsi
callq 0x40c1
movq %rax, 0x9414(%rip)      # 0x10d60
addq $0x2, 0x93dc(%rip)      # 0x10d30
jmp 0x7974
movq 0x9403(%rip), %rbx      # 0x10d60
callq 0x85ae
movq %rbx, %rdi
movq %rax, %rsi
callq 0x3b2b
movq %rax, 0x93ec(%rip)      # 0x10d60
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O3/pahihu[P]mixal/run.c
// Function: do_mul
static void do_mul(void)
{
    if (6 == F) {
        check_float();
        r[A] = float_multiply(r[A], safe_fetch(cell_to_address(M)));
        /* NB. FMUL is 9u, MUL is 10 */
        elapsed_time -= 1;
    } else
        multiply(r[A], get_V(), &r[A], &r[X]);
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
cmpl $0x6, 0x946b(%rip)      # 0x10dec
jne 0x79d5
testb $0x4, 0x93b2(%rip)      # 0x10d3c
jne 0x799a
leaq 0x287d(%rip), %rdi      # 0xa210
xorl %eax, %eax
callq 0x5bec
movq 0x93bf(%rip), %rbx      # 0x10d60
movq 0x9448(%rip), %rdi      # 0x10df0
callq 0x4037
movl %eax, %edi
callq 0x712a
movq %rbx, %rdi
movq %rax, %rsi
callq 0x40d4
movq %rax, 0x939a(%rip)      # 0x10d60
decq 0x9363(%rip)            # 0x10d30
addq $0x8, %rsp
popq %rbx
popq %r14
retq
movq 0x9384(%rip), %rbx      # 0x10d60
leaq 0x937d(%rip), %r14      # 0x10d60
callq 0x85ae
leaq 0x93a9(%rip), %rcx      # 0x10d98
movq %rbx, %rdi
movq %rax, %rsi
movq %r14, %rdx
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x3b37
// File: /workspace/github_c_makefile_star2_O3/pahihu[P]mixal/run.c
// Function: do_div
static void do_div(void)
{
    if (6 == F) {
        check_float();
        r[A] = float_divide(r[A], safe_fetch(cell_to_address(M)));
        /* NB. FDIV is 11u, DIV is 12u */
        elapsed_time -= 1;
    } else
        divide(r[A], r[X], get_V(), &r[A], &r[X]);
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
cmpl $0x6, 0x93d9(%rip)      # 0x10dec
jne 0x7a6b
testb $0x4, 0x9320(%rip)      # 0x10d3c
jne 0x7a2c
leaq 0x27eb(%rip), %rdi      # 0xa210
xorl %eax, %eax
callq 0x5bec
movq 0x932d(%rip), %rbx      # 0x10d60
movq 0x93b6(%rip), %rdi      # 0x10df0
callq 0x4037
movl %eax, %edi
callq 0x712a
movq %rbx, %rdi
movq %rax, %rsi
callq 0x40e7
movq %rax, 0x9308(%rip)      # 0x10d60
decq 0x92d1(%rip)            # 0x10d30
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
movq 0x92ee(%rip), %rbx      # 0x10d60
leaq 0x92e7(%rip), %r14      # 0x10d60
movq 0x9318(%rip), %r15      # 0x10d98
leaq 0x9311(%rip), %r12      # 0x10d98
callq 0x85ae
movq %rbx, %rdi
movq %r15, %rsi
movq %rax, %rdx
movq %r14, %rcx
movq %r12, %r8
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
jmp 0x3c46
// File: /workspace/github_c_makefile_star2_O3/pahihu[P]mixal/run.c
// Function: do_move
static void do_move(void)
{
    Address from = cell_to_address(M);
    Address to = cell_to_address(r[1]);
    unsigned i, count = F;

    for (i = 0; i < count; i++) {
        safe_store(to + i, safe_fetch(from + i));
        elapsed_time += 2;
    }
    r[1] = address_to_cell(to + count);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movq 0x8c7d(%rip), %rdi      # 0x10df0
callq 0x4037
movl %eax, %ebx
movq 0x8be7(%rip), %rdi      # 0x10d68
callq 0x4037
movl %eax, %r14d
movl 0x8c5d(%rip), %ebp      # 0x10dec
testl %ebp, %ebp
je 0x81bd
movl %r14d, %r15d
movl %ebp, %r12d
movl %ebx, %edi
callq 0x712a
movl %r15d, %edi
movq %rax, %rsi
callq 0x8604
addq $0x2, 0x8b7d(%rip)      # 0x10d30
incl %ebx
incl %r15d
decl %r12d
jne 0x8199
addl %r14d, %ebp
movl %ebp, %edi
callq 0x4033
movq %rax, 0x8b9a(%rip)      # 0x10d68
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/pahihu[P]mixal/run.c
// Function: do_ldi
static void do_ldi(void) { 
    Cell cell = get_V();
    if (INDEX_MAX < magnitude(cell))
        error("Magnitude too large for index register: %10o", magnitude(cell));
    r[C & 7] = cell; 
}

// Assembly:
pushq %rbx
callq 0x85ae
movq %rax, %rbx
movl %ebx, %esi
andl $0x3fffffff, %esi       # imm = 0x3FFFFFFF
cmpq %rsi, 0x8bba(%rip)      # 0x10db8
jge 0x820e
leaq 0x209b(%rip), %rdi      # 0xa2a2
xorl %eax, %eax
callq 0x5bec
movl 0x8bd4(%rip), %eax      # 0x10de8
andl $0x7, %eax
leaq 0x8b42(%rip), %rcx      # 0x10d60
movq %rbx, (%rcx,%rax,8)
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O3/pahihu[P]mixal/run.c
// Function: do_ldin
static void do_ldin(void) {
    Cell cell = get_V();
    if (INDEX_MAX < magnitude(cell))
        error("Magnitude too large for index register: %10o", magnitude(cell));
    r[C & 7] = negative(cell);
}

// Assembly:
pushq %rbx
callq 0x85ae
movq %rax, %rbx
movl %ebx, %esi
andl $0x3fffffff, %esi       # imm = 0x3FFFFFFF
cmpq %rsi, 0x8b58(%rip)      # 0x10db8
jge 0x8270
leaq 0x2039(%rip), %rdi      # 0xa2a2
xorl %eax, %eax
callq 0x5bec
xorq $0x40000000, %rbx       # imm = 0x40000000
movl 0x8b6b(%rip), %eax      # 0x10de8
andl $0x7, %eax
leaq 0x8ad9(%rip), %rcx      # 0x10d60
movq %rbx, (%rcx,%rax,8)
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O3/pahihu[P]mixal/run.c
// Function: do_addr_op
static void do_addr_op(void)
{
    Cell cell;
    unsigned reg = C & 7;

    switch (F) {
    case 0: cell = add(r[reg], M); break;
    case 1: cell = sub(r[reg], M); break;
    case 2: cell = M; break;
    case 3: cell = negative(M); break;
    case 4: check_master(); compare(M); return;
    default: error("Unknown extended opcode"); cell = zero;
    }
    if (reg - 1 < 6)        /* same as: 1 <= reg && reg <= 6 */
        if (INDEX_MAX < magnitude(cell))
            error("Magnitude too large for index register: %10o", 
              magnitude(cell));
    r[reg] = cell;
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movl 0x8984(%rip), %r14d     # 0x10de8
andl $0x7, %r14d
movl 0x897e(%rip), %eax      # 0x10dec
cmpq $0x4, %rax
ja 0x8501
leaq 0x18a1(%rip), %rcx      # 0x9d20
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
leaq 0x88d1(%rip), %rax      # 0x10d60
movq (%rax,%r14,8), %rdi
movq 0x8956(%rip), %rsi      # 0x10df0
callq 0x3ad2
jmp 0x84fc
testb $-0x80, 0x8894(%rip)    # 0x10d3c
jne 0x84b8
leaq 0x1daf(%rip), %rdi      # 0xa260
xorl %eax, %eax
callq 0x5bec
movq 0x8931(%rip), %rdi      # 0x10df0
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x8727
movq 0x891e(%rip), %rbx      # 0x10df0
jmp 0x8511
movl $0x40000000, %ebx       # imm = 0x40000000
xorq 0x8910(%rip), %rbx      # 0x10df0
jmp 0x8511
movl %r14d, %eax
leaq 0x8874(%rip), %rcx      # 0x10d60
movq (%rcx,%rax,8), %rdi
movq 0x88f9(%rip), %rsi      # 0x10df0
callq 0x3b2b
movq %rax, %rbx
jmp 0x8511
leaq 0x1d2f(%rip), %rdi      # 0xa237
xorl %ebx, %ebx
xorl %eax, %eax
callq 0x5bec
leal -0x1(%r14), %eax
cmpl $0x5, %eax
ja 0x8539
movl %ebx, %esi
andl $0x3fffffff, %esi       # imm = 0x3FFFFFFF
cmpq %rsi, 0x888f(%rip)      # 0x10db8
jge 0x8539
leaq 0x1d70(%rip), %rdi      # 0xa2a2
xorl %eax, %eax
callq 0x5bec
movl %r14d, %eax
leaq 0x881d(%rip), %rcx      # 0x10d60
movq %rbx, (%rcx,%rax,8)
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O3/pahihu[P]mixal/run.c
// Function: do_compare
static void do_compare(void)
{
    Cell cell = safe_fetch(cell_to_address(M));

    if (6 == F) {
        check_float();
        comparison_indicator = float_compare(r[A], cell);
        elapsed_time += 2;
    } else
        compare(cell);
}

// Assembly:
pushq %rbx
movq 0x8899(%rip), %rdi      # 0x10df0
callq 0x4037
movl %eax, %edi
callq 0x712a
movq %rax, %rbx
cmpl $0x6, 0x887f(%rip)      # 0x10dec
jne 0x85a5
testb $0x4, 0x87c6(%rip)      # 0x10d3c
jne 0x8586
leaq 0x1c91(%rip), %rdi      # 0xa210
xorl %eax, %eax
callq 0x5bec
movq 0x87d3(%rip), %rdi      # 0x10d60
movq %rbx, %rsi
callq 0x4120
movl %eax, 0x87a9(%rip)      # 0x10d44
addq $0x2, 0x878d(%rip)      # 0x10d30
popq %rbx
retq
movq %rbx, %rdi
popq %rbx
jmp 0x8727
// File: /workspace/github_c_makefile_star2_O3/pahihu[P]mixal/run.c
// Function: flip_char
static Cell flip_char(Cell cell)
{
    Cell ret = cell;
    Byte mix_char;

    mix_char = get_byte(5, ret);
    if ((9 < mix_char) && (mix_char < 20)) {
        mix_char = mix_char + 20;
        ret = set_byte(mix_char, 5, ret);
    }
    return ret;
}

// Assembly:
pushq %rbx
movq %rdi, %rbx
movl $0x5, %edi
movq %rbx, %rsi
callq 0x3774
leal -0xa(%rax), %ecx
cmpl $0x9, %ecx
ja 0x85ff
addl $0x14, %eax
movl %eax, %edi
movl $0x5, %esi
movq %rbx, %rdx
popq %rbx
jmp 0x385b
movq %rbx, %rax
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O3/pahihu[P]mixal/run.c
// Function: branch
static void branch(unsigned condition, int sign, Cell cell)
{
    switch (condition) {
    case  0: jump(); break;
    case  1: pc = cell_to_address(M); break;
    case  2: if (overflow)  jump(); overflow = false; break;
    case  3: if (!overflow) jump(); overflow = false; break;
    case  4: if (sign <  0) jump(); break;
    case  5: if (sign == 0) jump(); break;
    case  6: if (sign  > 0) jump(); break;
    case  7: if (sign >= 0) jump(); break;
    case  8: if (sign != 0) jump(); break;
    case  9: if (sign <= 0) jump(); break;
    case 10: check_binary(); if (0 == (magnitude(cell) & 2)) jump(); break;
    case 11: check_binary(); if (1 == (magnitude(cell) & 2)) jump(); break;
    default: error("Bad branch condition");
    }
}

// Assembly:
pushq %rbx
cmpl $0xb, %edi
ja 0x8718
movl %edi, %eax
leaq 0x16e9(%rip), %rcx      # 0x9d34
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
leaq 0x74e5(%rip), %rbx      # 0xfb40
cmpl $0x0, (%rbx)
je 0x8684
movl 0x874a(%rip), %edi      # 0x10db0
callq 0x4033
movq %rax, 0x872e(%rip)      # 0x10da0
movq 0x8777(%rip), %rdi      # 0x10df0
callq 0x4037
movl %eax, 0x872c(%rip)      # 0x10db0
movl $0x0, (%rbx)
jmp 0x8716
testb $0x1, 0x86a6(%rip)      # 0x10d3c
jne 0x8716
leaq 0x1bb0(%rip), %rdi      # 0xa24f
jmp 0x871f
testl %esi, %esi
jns 0x8716
jmp 0x86f2
testl %esi, %esi
jg 0x8716
jmp 0x86f2
leaq 0x748c(%rip), %rbx      # 0xfb40
cmpl $0x0, (%rbx)
jne 0x8684
jmp 0x8660
testl %esi, %esi
jns 0x86f2
jmp 0x8716
testl %esi, %esi
jne 0x8716
jmp 0x86f2
testl %esi, %esi
jg 0x86f2
jmp 0x8716
movq %rdx, %rbx
testb $0x1, 0x8665(%rip)      # 0x10d3c
jne 0x86e7
leaq 0x1b6f(%rip), %rdi      # 0xa24f
xorl %eax, %eax
callq 0x5bec
testb $0x2, %bl
je 0x86f2
jmp 0x8716
testl %esi, %esi
je 0x8716
movl 0x86b8(%rip), %edi      # 0x10db0
callq 0x4033
movq %rax, 0x869c(%rip)      # 0x10da0
movq 0x86e5(%rip), %rdi      # 0x10df0
callq 0x4037
movl %eax, 0x869a(%rip)      # 0x10db0
popq %rbx
retq
leaq 0x1bb0(%rip), %rdi      # 0xa2cf
xorl %eax, %eax
popq %rbx
jmp 0x5bec
// File: /workspace/github_c_makefile_star2_O3/pahihu[P]mixal/run.c
// Function: compare
static void compare(Cell cell)
{
    Flag saved = overflow;

    Cell difference = sub(field(F, r[C & 7]), field(F, cell));
    comparison_indicator = sign_of_difference(difference);
    overflow = saved;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
leaq 0x7408(%rip), %r15      # 0xfb40
movl (%r15), %ebp
movl 0x86ab(%rip), %edi      # 0x10dec
movl 0x86a1(%rip), %eax      # 0x10de8
andl $0x7, %eax
leaq 0x860f(%rip), %rcx      # 0x10d60
movq (%rcx,%rax,8), %rsi
callq 0x37cd
movq %rax, %r14
movl 0x8689(%rip), %edi      # 0x10dec
movq %rbx, %rsi
callq 0x37cd
movq %r14, %rdi
movq %rax, %rsi
callq 0x3b2b
xorl %ecx, %ecx
btl $0x1e, %eax
movl $0x0, %edx
sbbl %edx, %edx
orl $0x1, %edx
testl $0x3fffffff, %eax       # imm = 0x3FFFFFFF
cmovel %ecx, %edx
movl %edx, 0x85b0(%rip)      # 0x10d44
movl %ebp, (%r15)
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O3/pahihu[P]mixal/symbol.c
// Function: string_to_symbol
Symbol string_to_symbol(const char *name)
{
    Symbol *bucket = symbol_table + hash(name);
    Symbol p = *bucket;
    for (; p; p = p->next)
	    if (stricmp(name, p->name) == 0)
	        return p;
    {                   /* Symbol doesn't exist yet. */
	    Symbol result = allot(sizeof(struct Symbol));
	    strcpy(result->name = allot(strlen(name) + 1), name);
	    result->defined = false;
	    result->references = NULL;
	    result->next = *bucket;
	    result->cell = zero;
	    *bucket = result;
	    return result;
    }
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movb (%rdi), %bpl
xorl %r12d, %r12d
testb %bpl, %bpl
movb %bpl, 0x7(%rsp)
movq %rdi, 0x8(%rsp)
je 0x880f
movq %rdi, %rbx
callq 0x3030
movq (%rax), %rax
leaq 0x1(%rbx), %rcx
movl %ebp, %edx
movl %r12d, %esi
shll $0x5, %esi
subl %r12d, %esi
movsbq %dl, %rdx
movl %esi, %r12d
addl (%rax,%rdx,4), %r12d
movb (%rcx), %dl
incq %rcx
testb %dl, %dl
jne 0x87d8
movl %r12d, %eax
movl $0xf0f0f0f1, %ecx       # imm = 0xF0F0F0F1
imulq %rax, %rcx
shrq $0x24, %rcx
movl %ecx, %eax
shll $0x4, %eax
addl %ecx, %eax
subl %eax, %r12d
leaq 0x86ca(%rip), %rax      # 0x10ee0
movq (%rax,%r12,8), %r14
testq %r14, %r14
movb 0x7(%rsp), %cl
je 0x8899
movq 0x8(%rsp), %rax
incq %rax
movq %rax, 0x10(%rsp)
movq 0x8(%r14), %r13
testb %cl, %cl
je 0x8872
movq 0x10(%rsp), %r15
movl %ecx, %ebx
movsbq (%r13), %rbp
testq %rbp, %rbp
je 0x886c
callq 0x32c0
movq (%rax), %rax
movsbq %bl, %rcx
movl (%rax,%rcx,4), %ecx
cmpl (%rax,%rbp,4), %ecx
jne 0x888d
incq %r13
movb (%r15), %bl
incq %r15
testb %bl, %bl
jne 0x883f
xorl %ebx, %ebx
movsbq %bl, %rbx
jmp 0x8874
xorl %ebx, %ebx
callq 0x32c0
movq (%rax), %rax
movl (%rax,%rbx,4), %ecx
movsbq (%r13), %rdx
cmpl (%rax,%rdx,4), %ecx
je 0x8918
movq (%r14), %r14
testq %r14, %r14
movb 0x7(%rsp), %cl
jne 0x8830
movl $0x28, %edi
callq 0x31f0
movq %rax, %r14
testq %rax, %rax
jne 0x88b9
leaq 0x1c41(%rip), %rdi      # 0xa4f3
xorl %eax, %eax
callq 0x5af0
movq 0x8(%rsp), %rbx
movq %rbx, %rdi
callq 0x3100
leaq 0x1(%rax), %rdi
callq 0x31f0
movq %rax, %r15
testq %rax, %rax
jne 0x88e5
leaq 0x1c15(%rip), %rdi      # 0xa4f3
xorl %eax, %eax
callq 0x5af0
movq %r15, 0x8(%r14)
movq %r15, %rdi
movq %rbx, %rsi
callq 0x3090
movl $0x0, 0x10(%r14)
xorl %eax, %eax
movq %rax, 0x20(%r14)
leaq 0x85d7(%rip), %rdx      # 0x10ee0
movq (%rdx,%r12,8), %rcx
movq %rcx, (%r14)
movq %rax, 0x18(%r14)
movq %r14, (%rdx,%r12,8)
movq %r14, %rax
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/pahihu[P]mixal/symbol.c
// Function: forward_reference
void forward_reference(Symbol symbol, Address address)
{
    assert(!symbol->defined);
    {
	    AddressList refs = allot(sizeof(struct AddressList));
	    refs->address = address;
	    refs->next = symbol->references;
	    symbol->references = refs;
    }
}

// Assembly:
pushq %rbp
pushq %r14
pushq %rbx
cmpl $0x0, 0x10(%rdi)
jne 0x899c
movl %esi, %ebp
movq %rdi, %rbx
movl $0x10, %edi
callq 0x31f0
movq %rax, %r14
testq %rax, %rax
jne 0x8988
leaq 0x1b72(%rip), %rdi      # 0xa4f3
xorl %eax, %eax
callq 0x5af0
movl %ebp, 0x8(%r14)
movq 0x20(%rbx), %rax
movq %rax, (%r14)
movq %r14, 0x20(%rbx)
popq %rbx
popq %r14
popq %rbp
retq
leaq 0x1ae0(%rip), %rdi      # 0xa483
leaq 0x1ab6(%rip), %rsi      # 0xa460
leaq 0x1ae3(%rip), %rcx      # 0xa494
movl $0x78, %edx
callq 0x3130
// File: /workspace/github_c_makefile_star2_O3/pahihu[P]mixal/symbol.c
// Function: define_symbol
void define_symbol(Symbol symbol, Cell cell)
{
    {   /* handle local symbols */
	    const char *name = symbol->name;
	    if (isdigit(name[0]) && strlen(name) == 2) {
            char c = toupper(name[1]);
            if (c == 'F' || c == 'B') {
                error("Definition of local ref: %s", name);
                return;
            } else if (c == 'H') {
                char new_name[3];
                Symbol nB, nF;
                strcpy(new_name, name);
                new_name[1] = 'B'; nB = string_to_symbol(new_name);
                nB->defined = true, nB->cell = cell;
                new_name[1] = 'F'; nF = string_to_symbol(new_name);
                resolve_references(nF, cell);
                nF->defined = false, nF->references = NULL;
                return;
            } else
                ;       /* not a local; fall through */
        }
    }
    if (symbol->defined)
	    warn("'%s' multiply-defined", symbol->name);
    else
	    resolve_references(symbol, cell);
    symbol->defined = true, symbol->cell = cell;
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
subq $0x10, %rsp
movq %rsi, %rbx
movq %rdi, %r14
movq 0x8(%rdi), %r15
callq 0x32d0
movq (%rax), %rax
movsbq (%r15), %rcx
testb $0x8, 0x1(%rax,%rcx,2)
je 0x8a8b
movq %r15, %rdi
callq 0x3100
cmpq $0x2, %rax
jne 0x8a8b
callq 0x3030
movq (%rax), %rax
movsbq 0x1(%r15), %rcx
movl (%rax,%rcx,4), %eax
movl %eax, %ecx
andl $0xfb, %ecx
cmpl $0x42, %ecx
jne 0x8a2e
leaq 0x1aa1(%rip), %rdi      # 0xa4bc
movq %r15, %rsi
xorl %eax, %eax
addq $0x10, %rsp
popq %rbx
popq %r14
popq %r15
jmp 0x5bec
movzbl %al, %eax
cmpl $0x48, %eax
jne 0x8a8b
leaq 0xd(%rsp), %r14
movq %r14, %rdi
movq %r15, %rsi
callq 0x3090
movb $0x42, 0x1(%r14)
movq %r14, %rdi
callq 0x87a4
movl $0x1, 0x10(%rax)
movq %rbx, 0x18(%rax)
movb $0x46, 0x1(%r14)
movq %r14, %rdi
callq 0x87a4
movq %rax, %r14
movq %rax, %rdi
movq %rbx, %rsi
callq 0x8ac6
movl $0x0, 0x10(%r14)
movq $0x0, 0x20(%r14)
jmp 0x8abc
cmpl $0x0, 0x10(%r14)
je 0x8aa5
leaq 0x1a3f(%rip), %rdi      # 0xa4d8
movq %r15, %rsi
xorl %eax, %eax
callq 0x331d
jmp 0x8ab0
movq %r14, %rdi
movq %rbx, %rsi
callq 0x8ac6
movl $0x1, 0x10(%r14)
movq %rbx, 0x18(%r14)
addq $0x10, %rsp
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O3/pahihu[P]mixal/symbol.c
// Function: resolve_references
static void resolve_references(Symbol symbol, Cell definition)
{
    AddressList refs, rest;
    assert(!symbol->defined);
    for (refs = symbol->references; refs; refs = rest) {
	    asm_store_field(refs->address, 0, 2, definition);
	    rest = refs->next;
	    free(refs);
    }
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
cmpl $0x0, 0x10(%rdi)
jne 0x8b09
movq 0x20(%rdi), %r14
testq %r14, %r14
je 0x8b03
movq %rsi, %rbx
movl 0x8(%r14), %edi
xorl %esi, %esi
movl $0x2, %edx
movq %rbx, %rcx
callq 0x361d
movq (%r14), %r15
movq %r14, %rdi
callq 0x3040
movq %r15, %r14
testq %r15, %r15
jne 0x8add
popq %rbx
popq %r14
popq %r15
retq
leaq 0x1973(%rip), %rdi      # 0xa483
leaq 0x1949(%rip), %rsi      # 0xa460
leaq 0x19e7(%rip), %rcx      # 0xa505
movl $0x87, %edx
callq 0x3130