LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O1/pahihu[P]mixal/io.c
// Function: read_line
static void read_line(FILE* file, Address buffer, unsigned size)
{
    unsigned i, b;
    Flag past_end = false;

    for (i = 0; i < size; ++i) {
        Cell cell = zero;
        for (b = 1; b <= 5; ++b) {
            Byte mix_char;
            if (past_end)
                mix_char = (Byte) 0;
            else {
                int c = fgetc(file);
                if (c == '\n' || c == EOF) {
                    past_end = true, mix_char = (Byte) 0;
                } else
                    mix_char = C_char_to_mix((char) c);
            }
            cell = set_byte(mix_char, b, cell);
        }
        if (dbg) {
            printf("read_line: %3d = ", buffer + i);
            write_cell (cell, stdout, true);
            printf("\n");
        }
        memory_store(buffer + i, cell);
    }
    if (false == past_end) {
        int c = fgetc(file);
        if (c != '\n' && c != EOF)
            error("Line not terminated (%d)", c);
    }
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %rsi, 0x10(%rsp)
movq %rdi, %rbx
movl %edx, 0xc(%rsp)
testl %edx, %edx
je 0x5a80
xorl %r13d, %r13d
xorl %r14d, %r14d
movl $0x1, %r12d
xorl %r15d, %r15d
xorl %ebp, %ebp
movl $0x0, %edi
testl %r14d, %r14d
movl $0x1, %r14d
je 0x5a27
movl %r12d, %esi
movq %r15, %rdx
callq 0x387b
movq %rax, %r15
incl %r12d
cmpl $0x6, %r12d
jne 0x59fc
jmp 0x5a5c
movq %rbx, %rdi
callq 0x3150
xorl %ebp, %ebp
movl $0x1, %r14d
cmpl $-0x1, %eax
je 0x5a58
movl $0x0, %edi
cmpl $0xa, %eax
je 0x5a0e
movsbl %al, %edi
callq 0x41b1
movl %eax, %edi
xorl %r14d, %r14d
movb $0x1, %bpl
jmp 0x5a0e
xorl %edi, %edi
jmp 0x5a0e
movq 0x10(%rsp), %rax
leal (%rax,%r13), %edi
movq %r15, %rsi
callq 0x6ceb
incl %r13d
cmpl 0xc(%rsp), %r13d
jne 0x59f3
testb %bpl, %bpl
je 0x5a92
movq %rbx, %rdi
callq 0x3150
cmpl $-0x1, %eax
je 0x5a92
cmpl $0xa, %eax
jne 0x5aa1
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
leaq 0x3c01(%rip), %rdi      # 0x96a9
movl %eax, %esi
xorl %eax, %eax
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x5bbc
nop
// File: /workspace/github_c_makefile_star2_O1/pahihu[P]mixal/main.c
// Function: fatal_error
void fatal_error(const char *message, ...)
{
    va_list args;

    if (current_file)   /*** of course, the error may not have anything to do with the file... */
        fprintf(stderr, "FATAL ERROR (%s, line %u): ", current_file, line_number);
    else
        fprintf(stderr, "FATAL ERROR: ");

    va_start(args, message);
    vfprintf(stderr, message, args);
    va_end(args);
    fprintf(stderr, "\n");

    io_shutdown();
    exit(1);
}

// Assembly:
pushq %r14
pushq %rbx
subq $0xd8, %rsp
movq %rdi, %rbx
movq %rsi, 0x28(%rsp)
movq %rdx, 0x30(%rsp)
movq %rcx, 0x38(%rsp)
movq %r8, 0x40(%rsp)
movq %r9, 0x48(%rsp)
testb %al, %al
je 0x5b21
movaps %xmm0, 0x50(%rsp)
movaps %xmm1, 0x60(%rsp)
movaps %xmm2, 0x70(%rsp)
movaps %xmm3, 0x80(%rsp)
movaps %xmm4, 0x90(%rsp)
movaps %xmm5, 0xa0(%rsp)
movaps %xmm6, 0xb0(%rsp)
movaps %xmm7, 0xc0(%rsp)
movq 0xb1c0(%rip), %rdx      # 0x10ce8
movq 0x94c9(%rip), %r14      # 0xeff8
movq (%r14), %rcx
testq %rdx, %rdx
jne 0x5b4f
leaq 0x3cc2(%rip), %rdi      # 0x9800
movl $0xd, %esi
movl $0x1, %edx
callq 0x32a0
jmp 0x5b68
movl 0xb19b(%rip), %eax      # 0x10cf0
leaq 0x3c88(%rip), %rsi      # 0x97e4
movq %rcx, %rdi
movl %eax, %ecx
xorl %eax, %eax
callq 0x31c0
leaq 0x20(%rsp), %rax
movq %rsp, %rdx
movq %rax, 0x10(%rdx)
leaq 0xf0(%rsp), %rax
movq %rax, 0x8(%rdx)
movabsq $0x3000000008, %rax     # imm = 0x3000000008
movq %rax, (%rdx)
movq (%r14), %rdi
movq %rbx, %rsi
callq 0x3260
movq (%r14), %rsi
movl $0xa, %edi
callq 0x3170
callq 0x4dff
movl $0x1, %edi
callq 0x3290
// File: /workspace/github_c_makefile_star2_O1/pahihu[P]mixal/main.c
// Function: error
void error(const char *message, ...)
{
    va_list args;

    fflush(stdout);

    ++num_errors;
    va_start(args, message);
    if (error_handler)
        error_handler(message, args);
    else
        fatal_error("No error handler installed");
    va_end(args);
}

// Assembly:
pushq %r14
pushq %rbx
subq $0xd8, %rsp
movq %rdi, %rbx
leaq 0x20(%rsp), %r14
movq %rsi, 0x8(%r14)
movq %rdx, 0x10(%r14)
movq %rcx, 0x18(%r14)
movq %r8, 0x20(%r14)
movq %r9, 0x28(%r14)
testb %al, %al
je 0x5c1d
movaps %xmm0, 0x50(%rsp)
movaps %xmm1, 0x60(%rsp)
movaps %xmm2, 0x70(%rsp)
movaps %xmm3, 0x80(%rsp)
movaps %xmm4, 0x90(%rsp)
movaps %xmm5, 0xa0(%rsp)
movaps %xmm6, 0xb0(%rsp)
movaps %xmm7, 0xc0(%rsp)
movq 0x93ac(%rip), %rax      # 0xefd0
movq (%rax), %rdi
callq 0x3200
incl 0xb0ce(%rip)            # 0x10d00
movabsq $0x3000000008, %rax     # imm = 0x3000000008
movq %rax, (%rsp)
leaq 0xf0(%rsp), %rax
movq %rax, 0x8(%rsp)
movq %r14, 0x10(%rsp)
movq 0xb09f(%rip), %rax      # 0x10cf8
testq %rax, %rax
je 0x5c71
movq %rsp, %rsi
movq %rbx, %rdi
callq *%rax
addq $0xd8, %rsp
popq %rbx
popq %r14
retq
leaq 0x3b96(%rip), %rdi      # 0x980e
xorl %eax, %eax
callq 0x5ac0
// File: /workspace/github_c_makefile_star2_O1/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
leaq 0x33f3(%rip), %rsi      # 0x9351
callq 0x31b0
testl %eax, %eax
je 0x5f9e
leaq 0x33d0(%rip), %rsi      # 0x933e
movq %rbx, %rdi
callq 0x3250
movq %rax, %r14
testq %rax, %rax
jne 0x5fa8
callq 0x3070
movl (%rax), %edi
callq 0x32b0
leaq 0x3593(%rip), %rdi      # 0x9524
movq %rbx, %rsi
movq %rax, %rdx
xorl %eax, %eax
callq 0x5ac0
movq 0x9033(%rip), %rax      # 0xefd8
movq (%rax), %r14
movq %rbx, 0xad39(%rip)      # 0x10ce8
movl $0x0, 0xad37(%rip)      # 0x10cf0
movq %rsp, %r15
movq %r15, %rdi
movl $0x101, %esi            # imm = 0x101
movq %r14, %rdx
callq 0x3190
testq %rax, %rax
je 0x604f
leaq 0x389d(%rip), %r12      # 0x9875
incl 0xad12(%rip)            # 0x10cf0
movq %r15, %rdi
callq 0x422c
movq %r15, %rdi
callq 0x3100
cmpb $0xa, -0x1(%rax,%r15)
je 0x603a
movq %r15, %rdi
movl $0x101, %esi            # imm = 0x101
movq %r14, %rdx
callq 0x3190
testq %rax, %rax
je 0x604f
movq %r12, %rdi
xorl %eax, %eax
callq 0x5bbc
movq %r15, %rdi
callq 0x3100
cmpb $0xa, -0x1(%rax,%r15)
je 0x603a
movq %r15, %rdi
movl $0x101, %esi            # imm = 0x101
movq %r14, %rdx
callq 0x3190
testq %rax, %rax
jne 0x6015
movq %r15, %rdi
movl $0x101, %esi            # imm = 0x101
movq %r14, %rdx
callq 0x3190
testq %rax, %rax
jne 0x5fd8
movq %r14, %rdi
callq 0x30c0
testl %eax, %eax
je 0x607b
callq 0x3070
movl (%rax), %edi
callq 0x32b0
leaq 0x34b6(%rip), %rdi      # 0x9524
movq %rbx, %rsi
movq %rax, %rdx
xorl %eax, %eax
callq 0x5bbc
movq %r14, %rdi
callq 0x30f0
movq $0x0, 0xac5a(%rip) # 0x10ce8
addq $0x108, %rsp            # imm = 0x108
popq %rbx
popq %r12
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O1/pahihu[P]mixal/main.c
// Function: usage
static void usage()
{
    fprintf(stderr, "  usage: mixal [options...] [source...]\n");
    fprintf(stderr, "options:\n");
    fprintf(stderr, "         -a             assemble only\n");
    fprintf(stderr, "         -b             binary MIX installed\n");
    fprintf(stderr, "         -c             core memory: mixcore.dat, mixcore.ctl\n");
    fprintf(stderr, "         -d             dump non-zero memory locations\n");
    fprintf(stderr, "         -e address     set entry point\n");
    fprintf(stderr, "         -f             floating-point attachment installed\n");
    fprintf(stderr, "         -g [devnum]    push GO button, [and set GO device]\n");
    fprintf(stderr, "         -h             print help\n");
    fprintf(stderr, "         -i             interrupt facility installed\n");
    fprintf(stderr, "         -m             Mixmaster installed\n");
    fprintf(stderr, "         -o             punch object deck\n");
    fprintf(stderr, "         -r             redirect reader/punch/printer\n");
    fprintf(stderr, "         -t n           trace instructions n times\n");
    fprintf(stderr, "         -x             double/indirect-indexing attachment installed\n");
    fprintf(stderr, "         -v             verbose assembler output\n");
    exit(1);
}

// Assembly:
pushq %rbx
movq 0x8f53(%rip), %rbx      # 0xeff8
movq (%rbx), %rcx
leaq 0x37e9(%rip), %rdi      # 0x9898
movl $0x28, %esi
movl $0x1, %edx
callq 0x32a0
movq (%rbx), %rcx
leaq 0x37f9(%rip), %rdi      # 0x98c1
movl $0x9, %esi
movl $0x1, %edx
callq 0x32a0
movq (%rbx), %rcx
leaq 0x37ea(%rip), %rdi      # 0x98cb
movl $0x26, %esi
movl $0x1, %edx
callq 0x32a0
movq (%rbx), %rcx
leaq 0x37f8(%rip), %rdi      # 0x98f2
movl $0x2d, %esi
movl $0x1, %edx
callq 0x32a0
movq (%rbx), %rcx
leaq 0x380d(%rip), %rdi      # 0x9920
movl $0x3e, %esi
movl $0x1, %edx
callq 0x32a0
movq (%rbx), %rcx
leaq 0x3833(%rip), %rdi      # 0x995f
movl $0x37, %esi
movl $0x1, %edx
callq 0x32a0
movq (%rbx), %rcx
leaq 0x3852(%rip), %rdi      # 0x9997
movl $0x28, %esi
movl $0x1, %edx
callq 0x32a0
movq (%rbx), %rcx
leaq 0x3862(%rip), %rdi      # 0x99c0
movl $0x3c, %esi
movl $0x1, %edx
callq 0x32a0
movq (%rbx), %rcx
leaq 0x3886(%rip), %rdi      # 0x99fd
movl $0x3c, %esi
movl $0x1, %edx
callq 0x32a0
movq (%rbx), %rcx
leaq 0x38aa(%rip), %rdi      # 0x9a3a
movl $0x23, %esi
movl $0x1, %edx
callq 0x32a0
movq (%rbx), %rcx
leaq 0x38b5(%rip), %rdi      # 0x9a5e
movl $0x35, %esi
movl $0x1, %edx
callq 0x32a0
movq (%rbx), %rcx
leaq 0x38d2(%rip), %rdi      # 0x9a94
movl $0x2c, %esi
movl $0x1, %edx
callq 0x32a0
movq (%rbx), %rcx
leaq 0x38e6(%rip), %rdi      # 0x9ac1
movl $0x2a, %esi
movl $0x1, %edx
callq 0x32a0
movq (%rbx), %rcx
leaq 0x38f8(%rip), %rdi      # 0x9aec
movl $0x36, %esi
movl $0x1, %edx
callq 0x32a0
movq (%rbx), %rcx
leaq 0x3916(%rip), %rdi      # 0x9b23
movl $0x33, %esi
movl $0x1, %edx
callq 0x32a0
movq (%rbx), %rcx
leaq 0x3931(%rip), %rdi      # 0x9b57
movl $0x46, %esi
movl $0x1, %edx
callq 0x32a0
movq (%rbx), %rcx
leaq 0x395f(%rip), %rdi      # 0x9b9e
movl $0x31, %esi
movl $0x1, %edx
callq 0x32a0
movl $0x1, %edi
callq 0x3290
// File: /workspace/github_c_makefile_star2_O1/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 0xa87d(%rip), %eax      # 0x10d10
xorl %ebx, %ebx
addl $-0x2a, %eax
cmpl $0x3c, %eax
ja 0x650b
movabsq $0x40000000000004b, %rcx # imm = 0x40000000000004B
btq %rax, %rcx
jae 0x64b7
callq 0x664a
movq %rax, %rbx
jmp 0x650b
cmpq $0x13, %rax
je 0x64d1
cmpq $0x3c, %rax
jne 0x650b
movq 0xa856(%rip), %rbx      # 0x10d20
callq 0x6264
jmp 0x64f8
movl $0x3d, %edi
callq 0x689c
callq 0x65d9
movq %rax, %rbx
movl $0x3d, %edi
callq 0x689c
movq %rbx, %rdi
callq 0x8b08
movq %rax, %rbx
leaq 0x9235(%rip), %rax      # 0xf734
movl (%rax), %esi
movq %rbx, %rdi
callq 0x8938
xorl %ebx, %ebx
cmpb $0x2c, 0xa7fe(%rip)     # 0x10d10
jne 0x6523
callq 0x6264
callq 0x664a
movq %rax, %r15
jmp 0x6526
xorl %r15d, %r15d
movl %r14d, %r12d
movq %r12, %rdi
callq 0x65af
movq %rax, %r14
testl %ebp, %ebp
sete %al
cmpq %r12, %r14
sete %cl
orb %al, %cl
jne 0x6551
leaq 0x3686(%rip), %rdi      # 0x9bd0
xorl %eax, %eax
callq 0x5bbc
xorl %edi, %edi
movl $0x2, %esi
callq 0x384a
movl %eax, %ebp
movl $0x3, %edi
movl $0x3, %esi
callq 0x384a
movl %eax, %r12d
movl $0x4, %edi
movl $0x4, %esi
callq 0x384a
movq %r14, %rdi
movl %eax, %esi
xorl %edx, %edx
callq 0x38d6
movq %r15, %rdi
movl %r12d, %esi
movq %rax, %rdx
callq 0x38d6
movq %rbx, %rdi
movl %ebp, %esi
movq %rax, %rdx
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
jmp 0x38d6
// File: /workspace/github_c_makefile_star2_O1/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, 0xa75a(%rip)     # 0x10d10
jne 0x65d5
pushq %rbx
callq 0x6264
callq 0x664a
movq %rax, %rbx
movl $0x29, %edi
callq 0x689c
movq %rbx, %rax
popq %rbx
retq
movq %rdi, %rax
retq
// File: /workspace/github_c_makefile_star2_O1/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 0x664a
movq %rax, %rbx
movl $0x5, %edi
callq 0x65af
movq %rax, %r14
movq %rax, %rdi
callq 0x3a15
movq %rbx, %rdi
movl %r14d, %esi
xorl %edx, %edx
callq 0x38d6
movq %rax, %rbx
cmpb $0x2c, 0xa6fe(%rip)     # 0x10d10
jne 0x6641
callq 0x6264
callq 0x664a
movq %rax, %r14
movl $0x5, %edi
callq 0x65af
movq %rax, %r15
movq %rax, %rdi
callq 0x3a15
movq %r14, %rdi
movl %r15d, %esi
movq %rbx, %rdx
jmp 0x6603
movq %rbx, %rax
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O1/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 0x94e4(%rip), %r14      # 0xfb40
movl (%r14), %eax
movl %eax, 0x4(%rsp)
movl $0x1, %edi
callq 0x376c
movq %rax, %rbx
movzbl 0xa699(%rip), %eax      # 0x10d10
cmpl $0x2b, %eax
je 0x6688
cmpl $0x2d, %eax
jne 0x668d
xorq $0x40000000, %rbx       # imm = 0x40000000
callq 0x6264
movl $0x0, (%r14)
callq 0x6926
movq %rbx, %rdi
movq %rax, %rsi
callq 0x3c37
movq %rax, %r15
leaq 0x3618(%rip), %rbx      # 0x9cc6
leaq 0x80fb(%rip), %r14      # 0xe7b0
movsbl 0xa654(%rip), %esi      # 0x10d10
movl $0x7, %edx
movq %rbx, %rdi
callq 0x3180
movq %rax, %rbp
testq %rax, %rax
je 0x66f0
callq 0x6264
movq %rbp, %r13
subq %rbx, %r13
callq 0x6926
movq %r15, %rdi
movq %rax, %rsi
callq *(%r14,%r13,8)
movq %rax, %r15
jmp 0x6717
leaq 0x9449(%rip), %r12      # 0xfb40
cmpl $0x0, (%r12)
je 0x670c
leaq 0x3583(%rip), %rdi      # 0x9c88
xorl %eax, %eax
callq 0x331d
movl 0x4(%rsp), %eax
movl %eax, (%r12)
movq %r15, %r12
testq %rbp, %rbp
jne 0x66b5
movq %r12, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/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 %rbx
movb $0x30, 0xa5d6(%rip)     # 0x10d10
movq $0x0, 0xa5d3(%rip) # 0x10d18
movq 0xa5bc(%rip), %r14      # 0x10d08
movzbl (%r14), %eax
testl %eax, %eax
je 0x6835
cmpl $0x22, %eax
jne 0x67f4
movb $0x30, 0xa5a8(%rip)     # 0x10d10
movq $0x0, 0xa5a5(%rip) # 0x10d18
incq %r14
movq %r14, 0xa58b(%rip)      # 0x10d08
movq %r14, %rdi
movl $0x22, %esi
callq 0x3110
movq %rax, %rbx
testq %rax, %rax
je 0x683e
movl %ebx, %eax
subl %r14d, %eax
cmpl $0x6, %eax
jb 0x67b3
leaq 0x34a1(%rip), %rdi      # 0x9c48
xorl %eax, %eax
callq 0x331d
movl $0x5, %eax
testl %eax, %eax
je 0x6865
movl %eax, %r15d
xorl %r14d, %r14d
movq 0xa540(%rip), %rax      # 0x10d08
movsbl (%rax,%r14), %edi
callq 0x41b1
incq %r14
movq 0xa53c(%rip), %rdx      # 0x10d18
movl %eax, %edi
movl %r14d, %esi
callq 0x387b
movq %rax, 0xa52b(%rip)      # 0x10d18
cmpq %r14, %r15
jne 0x67c1
jmp 0x6865
movl $0x1, %ebx
movq 0xa508(%rip), %rax      # 0x10d08
movb (%rax), %al
testb %al, %al
je 0x6835
movsbl %al, %edi
callq 0x41b1
movq 0xa503(%rip), %rdx      # 0x10d18
movl %eax, %edi
movl %ebx, %esi
callq 0x387b
incq 0xa4e3(%rip)            # 0x10d08
movq %rax, 0xa4ec(%rip)      # 0x10d18
incl %ebx
cmpl $0x6, %ebx
jne 0x67f9
jmp 0x686f
movb $0x7a, 0xa4d4(%rip)     # 0x10d10
jmp 0x686f
leaq 0x33f7(%rip), %rdi      # 0x9c3c
xorl %eax, %eax
callq 0x5bbc
movq 0xa4b5(%rip), %r14      # 0x10d08
movq %r14, %rdi
callq 0x3100
addq %r14, %rax
movq %rax, 0xa4a3(%rip)      # 0x10d08
incq %rbx
movq %rbx, 0xa499(%rip)      # 0x10d08
movq 0xa4a2(%rip), %rbx      # 0x10d18
callq 0x6264
movq %rbx, %rax
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O1/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, 0xa46d(%rip)      # 0x10d10
je 0x6264
pushq %rax
movzbl %dil, %esi
movq 0xa453(%rip), %rcx      # 0x10d08
leaq 0x33b1(%rip), %rdi      # 0x9c6d
movq %rcx, %rdx
xorl %r8d, %r8d
xorl %eax, %eax
callq 0x5bbc
addq $0x8, %rsp
jmp 0x6264
// File: /workspace/github_c_makefile_star2_O1/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 0xa3e2(%rip), %eax      # 0x10d10
cmpl $0x64, %eax
je 0x6956
cmpl $0x30, %eax
je 0x694d
cmpl $0x2a, %eax
jne 0x6967
leaq 0x8df0(%rip), %rax      # 0xf734
movl (%rax), %edi
callq 0x405a
jmp 0x6962
movq 0xa3c4(%rip), %rbx      # 0x10d18
jmp 0x6977
movq 0xa3c3(%rip), %rdi      # 0x10d20
callq 0x890d
movq %rax, %rbx
jmp 0x6977
leaq 0x333f(%rip), %rdi      # 0x9cad
xorl %ebx, %ebx
xorl %eax, %eax
callq 0x5bbc
callq 0x6264
movq %rbx, %rax
popq %rbx
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O1/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 0x4d19
leaq 0x91a0(%rip), %rax      # 0xfb40
xorl %ecx, %ecx
movl %ecx, (%rax)
movl %ecx, 0xa39a(%rip)      # 0x10d44
movl 0xa38c(%rip), %eax      # 0x10d3c
shrl %eax
andl $0x1, %eax
movl %eax, 0xa38d(%rip)      # 0x10d48
movl %ecx, 0xa38b(%rip)      # 0x10d4c
movb %cl, 0xa389(%rip)       # 0x10d50
xorps %xmm0, %xmm0
movaps %xmm0, 0xa38f(%rip)     # 0x10d60
movaps %xmm0, 0xa398(%rip)     # 0x10d70
movaps %xmm0, 0xa3a1(%rip)     # 0x10d80
movaps %xmm0, 0xa3aa(%rip)     # 0x10d90
movaps %xmm0, 0xa3b3(%rip)     # 0x10da0
leaq 0x8d44(%rip), %rax      # 0xf738
movl (%rax), %eax
movl %eax, 0xa3b4(%rip)      # 0x10db0
movb %cl, 0xa33e(%rip)       # 0x10d40
popq %rax
retq
// File: /workspace/github_c_makefile_star2_O1/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 %rax
movl $0xfa0, 0xa39e(%rip)    # imm = 0xFA0
movq $0xfff, 0xa397(%rip) # imm = 0xFFF
testb %dil, %dil
jns 0x6a40
movq $0x7fff, 0xa387(%rip) # imm = 0x7FFF
movl $0x7d00, 0xa379(%rip)   # imm = 0x7D00
movl $0xffffffff, %edi       # imm = 0xFFFFFFFF
orl %edi, 0xa2f6(%rip)      # 0x10d3c
movslq 0xa367(%rip), %rdi      # 0x10db4
shlq $0x3, %rdi
callq 0x31f0
movq %rax, 0xa36b(%rip)      # 0x10dc8
testq %rax, %rax
jne 0x6a70
leaq 0x2a3d(%rip), %rdi      # 0x94a6
xorl %eax, %eax
callq 0x5ac0
movslq 0xa33d(%rip), %rdi      # 0x10db4
shlq $0x3, %rdi
callq 0x31f0
movq %rax, 0xa339(%rip)      # 0x10dc0
testq %rax, %rax
jne 0x6a9a
leaq 0x2a13(%rip), %rdi      # 0x94a6
xorl %eax, %eax
callq 0x5ac0
movslq 0xa313(%rip), %rdi      # 0x10db4
shlq $0x2, %rdi
callq 0x31f0
movq %rax, 0xa327(%rip)      # 0x10dd8
testq %rax, %rax
jne 0x6ac4
leaq 0x29e9(%rip), %rdi      # 0x94a6
xorl %eax, %eax
callq 0x5ac0
movslq 0xa2e9(%rip), %rdi      # 0x10db4
shlq $0x2, %rdi
callq 0x31f0
movq %rax, 0xa3f5(%rip)      # 0x10ed0
testq %rax, %rax
jne 0x6aee
leaq 0x29bf(%rip), %rdi      # 0x94a6
xorl %eax, %eax
callq 0x5ac0
movl 0xa248(%rip), %eax      # 0x10d3c
testb $0x8, %al
jne 0x6afa
popq %rax
retq
testb $0x2, %al
je 0x6b17
movq 0xa2bb(%rip), %rsi      # 0x10dc0
movl 0xa2a9(%rip), %edx      # 0x10db4
leaq 0x3317(%rip), %rdi      # 0x9e29
callq 0x7824
movq 0xa2aa(%rip), %rsi      # 0x10dc8
movl 0xa290(%rip), %edx      # 0x10db4
leaq 0x330a(%rip), %rdi      # 0x9e35
popq %rax
jmp 0x7824
// File: /workspace/github_c_makefile_star2_O1/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 0x3227(%rip), %rdi      # 0x9d64
xorl %eax, %eax
callq 0x3120
movq 0xa215(%rip), %rdi      # 0x10d60
callq 0x3fa8
movl $0x9, %edi
callq 0x3050
movl $0x1, %ebx
leaq 0xa1fa(%rip), %r15      # 0x10d60
leaq 0x31fa(%rip), %r14      # 0x9d67
movq (%r15,%rbx,8), %rdi
callq 0x4010
movq %r14, %rdi
movl %ebx, %esi
movq %rax, %rdx
xorl %eax, %eax
callq 0x3120
incq %rbx
cmpq $0x7, %rbx
jne 0x6b6d
leaq 0x31db(%rip), %rdi      # 0x9d70
xorl %eax, %eax
callq 0x3120
movq 0xa1f5(%rip), %rdi      # 0x10d98
callq 0x3fa8
movq 0xa1f1(%rip), %rdi      # 0x10da0
callq 0x4010
leaq 0x31b9(%rip), %rdi      # 0x9d74
movq %rax, %rsi
xorl %eax, %eax
callq 0x3120
leaq 0x31af(%rip), %rdi      # 0x9d7b
xorl %eax, %eax
callq 0x3120
movl 0xa1d7(%rip), %edi      # 0x10db0
callq 0x3fca
leaq 0x395c(%rip), %rdi      # 0xa541
movq %rax, %rsi
xorl %eax, %eax
callq 0x3120
cmpl $0x0, 0xa14e(%rip)      # 0x10d44
leaq 0x31a1(%rip), %rax      # 0x9d9e
leaq 0x31a0(%rip), %rcx      # 0x9da4
cmoveq %rax, %rcx
leaq 0x318a(%rip), %rsi      # 0x9d99
cmovnsq %rcx, %rsi
leaq 0x8f26(%rip), %rax      # 0xfb40
cmpl $0x0, (%rax)
leaq 0x26c6(%rip), %rax      # 0x92ea
leaq 0x3181(%rip), %rdx      # 0x9dac
cmoveq %rax, %rdx
cmpl $0x1, 0xa112(%rip)      # 0x10d48
leaq 0x3178(%rip), %rcx      # 0x9db5
cmovneq %rax, %rcx
leaq 0x3139(%rip), %rdi      # 0x9d81
xorl %eax, %eax
callq 0x3120
movq 0xa0da(%rip), %rsi      # 0x10d30
leaq 0x9053(%rip), %rax      # 0xfcb0
movq (%rax), %rdx
leaq 0x3156(%rip), %rdi      # 0x9dbd
xorl %eax, %eax
popq %rbx
popq %r14
popq %r15
jmp 0x3120
// File: /workspace/github_c_makefile_star2_O1/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, 0xa12d(%rip)      # 0x10db4
jg 0x6c97
leaq 0x3148(%rip), %rdi      # 0x9dd8
xorl %eax, %eax
callq 0x5bbc
testl %ebx, %ebx
js 0x6ca6
leaq 0xa126(%rip), %rax      # 0x10dc8
movl %ebx, %ebp
jmp 0x6cdb
testb $0x2, 0xa08f(%rip)      # 0x10d3c
jne 0x6cbd
leaq 0x31ac(%rip), %rdi      # 0x9e62
xorl %eax, %eax
callq 0x5bbc
cmpl $0x0, 0xa084(%rip)      # 0x10d48
jne 0x6cd4
leaq 0x288f(%rip), %rdi      # 0x955c
xorl %eax, %eax
callq 0x5bbc
leaq 0xa0e5(%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_O1/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, 0xa0ae(%rip)      # 0x10db4
jg 0x6d16
leaq 0x30c9(%rip), %rdi      # 0x9dd8
xorl %eax, %eax
callq 0x5bbc
testl %ebp, %ebp
js 0x6d29
movq 0xa0a7(%rip), %rax      # 0x10dc8
movl %ebp, %ecx
movq %rbx, (%rax,%rcx,8)
jmp 0x6d71
testb $0x2, 0xa00c(%rip)      # 0x10d3c
jne 0x6d40
leaq 0x3129(%rip), %rdi      # 0x9e62
xorl %eax, %eax
callq 0x5bbc
cmpl $0x0, 0xa001(%rip)      # 0x10d48
jne 0x6d57
leaq 0x280c(%rip), %rdi      # 0x955c
xorl %eax, %eax
callq 0x5bbc
movq 0xa06a(%rip), %rax      # 0x10dc8
movq %rbx, (%rax,%r14,8)
cmpl $-0xa, %ebp
jne 0x6d71
movl $0x3e8, 0x9fdb(%rip)    # imm = 0x3E8
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/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 0x35cc(%rip), %rdi      # 0xa366
callq 0x30b0
leaq 0x35f1(%rip), %rdi      # 0xa397
callq 0x30b0
cmpl $0x4, 0xa002(%rip)      # 0x10db4
jl 0x6ec5
movl $0x1, %r12d
leaq 0x3032(%rip), %r13      # 0x9df7
xorl %r14d, %r14d
xorl %ebp, %ebp
xorl %edx, %edx
movl %edx, 0x4(%rsp)
xorl %r15d, %r15d
xorl %ebx, %ebx
leal (%r15,%rbp), %edi
callq 0x6c73
shlq $0x22, %rax
cmovnel %r12d, %ebx
testl %ebx, %ebx
jne 0x6df7
leal 0x1(%r15), %eax
cmpl $0x3, %r15d
movl %eax, %r15d
jb 0x6dd5
testl %ebx, %ebx
movl 0x4(%rsp), %edx
je 0x6ea2
movl %ebp, %edi
callq 0x3fca
xorl %r15d, %r15d
leaq 0x2fd9(%rip), %rdi      # 0x9ded
movq %rax, %rsi
xorl %eax, %eax
callq 0x3120
leal (%r15,%rbp), %edi
callq 0x6c73
movq %rax, %rbx
testl $0x3fffffff, %ebx       # imm = 0x3FFFFFFF
je 0x6e46
movl $0x20, %edi
callq 0x3050
movq %rbx, %rdi
callq 0x3fa8
jmp 0x6e5b
leaq 0x2fa4(%rip), %rdi      # 0x9df1
leaq 0x2496(%rip), %rsi      # 0x92ea
xorl %eax, %eax
callq 0x3120
incl %r15d
cmpl $0x4, %r15d
jne 0x6e1e
leaq 0x290c(%rip), %rdi      # 0x9777
xorl %eax, %eax
callq 0x3120
xorl %ebx, %ebx
movq 0x9f5d(%rip), %rax      # 0x10dd8
addq %r14, %rax
movl (%rax,%rbx,4), %esi
movq %r13, %rdi
xorl %eax, %eax
callq 0x3120
incq %rbx
cmpq $0x4, %rbx
jne 0x6e74
movl $0xa, %edi
callq 0x3050
movl 0x4(%rsp), %edx
incl %edx
addq $0x4, %rbp
movl 0x9f06(%rip), %eax      # 0x10db4
leal 0x3(%rax), %ecx
testl %eax, %eax
cmovnsl %eax, %ecx
sarl $0x2, %ecx
addq $0x10, %r14
cmpl %ecx, %edx
jl 0x6dcc
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/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 0x78fe(%rip), %rcx      # 0xe7e0
movq 0x10(%rcx,%rax,8), %rbx
movzbl (%rbx), %eax
cmpl $0x25, %eax
je 0x6ef9
cmpl $0x2a, %eax
jne 0x6f23
shll $0x2, %esi
jmp 0x6eff
shll $0x2, %esi
andl $0x1c, %esi
movl %esi, %eax
leaq (%rbx,%rax), %rsi
incq %rsi
leaq 0x9ed1(%rip), %rbx      # 0x10de0
movl $0x4, %edx
movq %rbx, %rdi
callq 0x3080
movb $0x0, 0x9ec1(%rip)      # 0x10de4
movq %rbx, %rax
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O1/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 0x7c65(%rip), %r15      # 0xeff8
movq (%r15), %rcx
leaq 0x2f64(%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 0x6b31
movl $0x1, %edi
callq 0x3290
// File: /workspace/github_c_makefile_star2_O1/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 0x2f23(%rip), %rsi      # 0xa311
callq 0x3250
movq %rax, %r12
testq %rax, %rax
jne 0x740c
leaq 0x2f12(%rip), %rdi      # 0xa314
movq %r14, %rsi
xorl %eax, %eax
callq 0x5bbc
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 0x743c
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
leaq 0x2ee0(%rip), %rdi      # 0xa323
movl %ebx, %esi
movq %r14, %rdx
xorl %eax, %eax
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
jmp 0x5bbc
// File: /workspace/github_c_makefile_star2_O1/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 0x960b(%rip), %rcx      # 0x10d60
movq 0x9664(%rip), %rax      # 0x10dc0
movq %rcx, 0x48(%rax)
movq 0x9631(%rip), %rcx      # 0x10d98
movq %rcx, 0x40(%rax)
movl $0x7, %ecx
leaq 0x95f1(%rip), %rdx      # 0x10d68
movq (%rdx), %rsi
movq %rsi, (%rax,%rcx,8)
decq %rcx
addq $0x8, %rdx
cmpq $0x1, %rcx
jne 0x7777
movl 0x95b3(%rip), %eax      # 0x10d44
xorl %ecx, %ecx
testl %eax, %eax
setne %cl
incl %ecx
xorl %edx, %edx
testl %eax, %eax
cmovsl %edx, %ecx
leaq 0x8398(%rip), %rax      # 0xfb40
xorl %edx, %edx
cmpl $0x0, (%rax)
setne %dl
leal (%rcx,%rdx,8), %ebx
movq 0x95e6(%rip), %r14      # 0x10da0
movl $0x4, %edi
movl $0x5, %esi
callq 0x384a
movq %r14, %rdi
movl %eax, %esi
xorl %edx, %edx
callq 0x38d6
movl %ebx, %edi
movl $0x3, %esi
movq %rax, %rdx
callq 0x387b
movq %rax, %rbx
movl 0x95c3(%rip), %edi      # 0x10db0
callq 0x405a
movq %rax, %r14
movl $0x1, %edi
movl $0x2, %esi
callq 0x384a
movq %r14, %rdi
movl %eax, %esi
movq %rbx, %rdx
callq 0x38d6
movq 0x95a8(%rip), %rcx      # 0x10dc0
movq %rax, 0x8(%rcx)
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O1/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 0x1bf8(%rip), %rsi      # 0x942c
callq 0x3250
testq %rax, %rax
je 0x785f
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_O1/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, 0x957f(%rip)      # 0x10dec
jne 0x78bc
testb $0x4, 0x94c6(%rip)      # 0x10d3c
jne 0x7886
leaq 0x2991(%rip), %rdi      # 0xa210
xorl %eax, %eax
callq 0x5bbc
movq 0x94d3(%rip), %rbx      # 0x10d60
movq 0x955c(%rip), %rdi      # 0x10df0
callq 0x405e
movl %eax, %edi
callq 0x7109
movq %rbx, %rdi
movq %rax, %rsi
callq 0x40d5
movq %rax, 0x94ae(%rip)      # 0x10d60
addq $0x2, 0x9476(%rip)      # 0x10d30
jmp 0x78da
movq 0x949d(%rip), %rbx      # 0x10d60
callq 0x8597
movq %rbx, %rdi
movq %rax, %rsi
callq 0x3b00
movq %rax, 0x9486(%rip)      # 0x10d60
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O1/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, 0x9508(%rip)      # 0x10dec
jne 0x7933
testb $0x4, 0x944f(%rip)      # 0x10d3c
jne 0x78fd
leaq 0x291a(%rip), %rdi      # 0xa210
xorl %eax, %eax
callq 0x5bbc
movq 0x945c(%rip), %rbx      # 0x10d60
movq 0x94e5(%rip), %rdi      # 0x10df0
callq 0x405e
movl %eax, %edi
callq 0x7109
movq %rbx, %rdi
movq %rax, %rsi
callq 0x40e8
movq %rax, 0x9437(%rip)      # 0x10d60
addq $0x2, 0x93ff(%rip)      # 0x10d30
jmp 0x7951
movq 0x9426(%rip), %rbx      # 0x10d60
callq 0x8597
movq %rbx, %rdi
movq %rax, %rsi
callq 0x3b59
movq %rax, 0x940f(%rip)      # 0x10d60
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O1/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, 0x948e(%rip)      # 0x10dec
jne 0x79b2
testb $0x4, 0x93d5(%rip)      # 0x10d3c
jne 0x7977
leaq 0x28a0(%rip), %rdi      # 0xa210
xorl %eax, %eax
callq 0x5bbc
movq 0x93e2(%rip), %rbx      # 0x10d60
movq 0x946b(%rip), %rdi      # 0x10df0
callq 0x405e
movl %eax, %edi
callq 0x7109
movq %rbx, %rdi
movq %rax, %rsi
callq 0x40fb
movq %rax, 0x93bd(%rip)      # 0x10d60
decq 0x9386(%rip)            # 0x10d30
addq $0x8, %rsp
popq %rbx
popq %r14
retq
movq 0x93a7(%rip), %rbx      # 0x10d60
leaq 0x93a0(%rip), %r14      # 0x10d60
callq 0x8597
leaq 0x93cc(%rip), %rcx      # 0x10d98
movq %rbx, %rdi
movq %rax, %rsi
movq %r14, %rdx
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x3b65
// File: /workspace/github_c_makefile_star2_O1/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, 0x93fc(%rip)      # 0x10dec
jne 0x7a48
testb $0x4, 0x9343(%rip)      # 0x10d3c
jne 0x7a09
leaq 0x280e(%rip), %rdi      # 0xa210
xorl %eax, %eax
callq 0x5bbc
movq 0x9350(%rip), %rbx      # 0x10d60
movq 0x93d9(%rip), %rdi      # 0x10df0
callq 0x405e
movl %eax, %edi
callq 0x7109
movq %rbx, %rdi
movq %rax, %rsi
callq 0x410e
movq %rax, 0x932b(%rip)      # 0x10d60
decq 0x92f4(%rip)            # 0x10d30
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
movq 0x9311(%rip), %rbx      # 0x10d60
leaq 0x930a(%rip), %r14      # 0x10d60
movq 0x933b(%rip), %r15      # 0x10d98
leaq 0x9334(%rip), %r12      # 0x10d98
callq 0x8597
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 0x3c68
// File: /workspace/github_c_makefile_star2_O1/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 0x8c94(%rip), %rdi      # 0x10df0
callq 0x405e
movl %eax, %ebx
movq 0x8bfe(%rip), %rdi      # 0x10d68
callq 0x405e
movl %eax, %r14d
movl 0x8c74(%rip), %ebp      # 0x10dec
testl %ebp, %ebp
je 0x81a6
movl %r14d, %r15d
movl %ebp, %r12d
movl %ebx, %edi
callq 0x7109
movl %r15d, %edi
movq %rax, %rsi
callq 0x85ed
addq $0x2, 0x8b94(%rip)      # 0x10d30
incl %ebx
incl %r15d
decl %r12d
jne 0x8182
addl %r14d, %ebp
movl %ebp, %edi
callq 0x405a
movq %rax, 0x8bb1(%rip)      # 0x10d68
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/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 0x8597
movq %rax, %rbx
movl %ebx, %esi
andl $0x3fffffff, %esi       # imm = 0x3FFFFFFF
cmpq %rsi, 0x8bd1(%rip)      # 0x10db8
jge 0x81f7
leaq 0x20b2(%rip), %rdi      # 0xa2a2
xorl %eax, %eax
callq 0x5bbc
movl 0x8beb(%rip), %eax      # 0x10de8
andl $0x7, %eax
leaq 0x8b59(%rip), %rcx      # 0x10d60
movq %rbx, (%rcx,%rax,8)
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O1/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 0x8597
movq %rax, %rbx
movl %ebx, %esi
andl $0x3fffffff, %esi       # imm = 0x3FFFFFFF
cmpq %rsi, 0x8b6f(%rip)      # 0x10db8
jge 0x8259
leaq 0x2050(%rip), %rdi      # 0xa2a2
xorl %eax, %eax
callq 0x5bbc
xorq $0x40000000, %rbx       # imm = 0x40000000
movl 0x8b82(%rip), %eax      # 0x10de8
andl $0x7, %eax
leaq 0x8af0(%rip), %rcx      # 0x10d60
movq %rbx, (%rcx,%rax,8)
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O1/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 0x899b(%rip), %r14d     # 0x10de8
andl $0x7, %r14d
movl 0x8995(%rip), %eax      # 0x10dec
cmpq $0x4, %rax
ja 0x84ea
leaq 0x18b8(%rip), %rcx      # 0x9d20
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
leaq 0x88e8(%rip), %rax      # 0x10d60
movq (%rax,%r14,8), %rdi
movq 0x896d(%rip), %rsi      # 0x10df0
callq 0x3b00
jmp 0x84e5
testb $-0x80, 0x88ab(%rip)    # 0x10d3c
jne 0x84a1
leaq 0x1dc6(%rip), %rdi      # 0xa260
xorl %eax, %eax
callq 0x5bbc
movq 0x8948(%rip), %rdi      # 0x10df0
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x8710
movq 0x8935(%rip), %rbx      # 0x10df0
jmp 0x84fa
movl $0x40000000, %ebx       # imm = 0x40000000
xorq 0x8927(%rip), %rbx      # 0x10df0
jmp 0x84fa
movl %r14d, %eax
leaq 0x888b(%rip), %rcx      # 0x10d60
movq (%rcx,%rax,8), %rdi
movq 0x8910(%rip), %rsi      # 0x10df0
callq 0x3b59
movq %rax, %rbx
jmp 0x84fa
leaq 0x1d46(%rip), %rdi      # 0xa237
xorl %ebx, %ebx
xorl %eax, %eax
callq 0x5bbc
leal -0x1(%r14), %eax
cmpl $0x5, %eax
ja 0x8522
movl %ebx, %esi
andl $0x3fffffff, %esi       # imm = 0x3FFFFFFF
cmpq %rsi, 0x88a6(%rip)      # 0x10db8
jge 0x8522
leaq 0x1d87(%rip), %rdi      # 0xa2a2
xorl %eax, %eax
callq 0x5bbc
movl %r14d, %eax
leaq 0x8834(%rip), %rcx      # 0x10d60
movq %rbx, (%rcx,%rax,8)
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O1/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 0x88b0(%rip), %rdi      # 0x10df0
callq 0x405e
movl %eax, %edi
callq 0x7109
movq %rax, %rbx
cmpl $0x6, 0x8896(%rip)      # 0x10dec
jne 0x858e
testb $0x4, 0x87dd(%rip)      # 0x10d3c
jne 0x856f
leaq 0x1ca8(%rip), %rdi      # 0xa210
xorl %eax, %eax
callq 0x5bbc
movq 0x87ea(%rip), %rdi      # 0x10d60
movq %rbx, %rsi
callq 0x4147
movl %eax, 0x87c0(%rip)      # 0x10d44
addq $0x2, 0x87a4(%rip)      # 0x10d30
popq %rbx
retq
movq %rbx, %rdi
popq %rbx
jmp 0x8710
// File: /workspace/github_c_makefile_star2_O1/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 0x3794
leal -0xa(%rax), %ecx
cmpl $0x9, %ecx
ja 0x85e8
addl $0x14, %eax
movl %eax, %edi
movl $0x5, %esi
movq %rbx, %rdx
popq %rbx
jmp 0x387b
movq %rbx, %rax
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O1/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 0x8701
movl %edi, %eax
leaq 0x1700(%rip), %rcx      # 0x9d34
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
leaq 0x74fc(%rip), %rbx      # 0xfb40
cmpl $0x0, (%rbx)
je 0x866d
movl 0x8761(%rip), %edi      # 0x10db0
callq 0x405a
movq %rax, 0x8745(%rip)      # 0x10da0
movq 0x878e(%rip), %rdi      # 0x10df0
callq 0x405e
movl %eax, 0x8743(%rip)      # 0x10db0
movl $0x0, (%rbx)
jmp 0x86ff
testb $0x1, 0x86bd(%rip)      # 0x10d3c
jne 0x86ff
leaq 0x1bc7(%rip), %rdi      # 0xa24f
jmp 0x8708
testl %esi, %esi
jns 0x86ff
jmp 0x86db
testl %esi, %esi
jg 0x86ff
jmp 0x86db
leaq 0x74a3(%rip), %rbx      # 0xfb40
cmpl $0x0, (%rbx)
jne 0x866d
jmp 0x8649
testl %esi, %esi
jns 0x86db
jmp 0x86ff
testl %esi, %esi
jne 0x86ff
jmp 0x86db
testl %esi, %esi
jg 0x86db
jmp 0x86ff
movq %rdx, %rbx
testb $0x1, 0x867c(%rip)      # 0x10d3c
jne 0x86d0
leaq 0x1b86(%rip), %rdi      # 0xa24f
xorl %eax, %eax
callq 0x5bbc
testb $0x2, %bl
je 0x86db
jmp 0x86ff
testl %esi, %esi
je 0x86ff
movl 0x86cf(%rip), %edi      # 0x10db0
callq 0x405a
movq %rax, 0x86b3(%rip)      # 0x10da0
movq 0x86fc(%rip), %rdi      # 0x10df0
callq 0x405e
movl %eax, 0x86b1(%rip)      # 0x10db0
popq %rbx
retq
leaq 0x1bc7(%rip), %rdi      # 0xa2cf
xorl %eax, %eax
popq %rbx
jmp 0x5bbc