LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O0/pencode-lab[P]Shoit/shoit_receiver.c
// Function: receiver_free
static void receiver_free(shoit_core_t *receiver)
{
    if(receiver->bucket !=NULL){
        if(receiver->useMmap){
            ;//munmap(receiver->bucket, receiver->bucketSize);
        }else{
            free(receiver->bucket);
        }
        receiver->bucket=NULL;
    }

    if(receiver->fromFd !=-1) {
        close(receiver->fromFd);
        receiver->fromFd = -1;
    }
    if(receiver->toFd !=-1){
        close(receiver->toFd);
        receiver->toFd =-1;
    }

    if(receiver->bindHost!=NULL) {
        free(receiver->bindHost);
        receiver->bindHost=NULL;
    }
    if(receiver->errorBitmap!=NULL){
        free(receiver->errorBitmap);
        receiver->errorBitmap = NULL;
    }

    if(receiver->hashTable!=NULL){
        free(receiver->hashTable);
        receiver->hashTable = NULL;
    }

    shoit_destory_synch(receiver);
    //last free log                                                                                                                  
    SHOIT_LOG("free sender complete.\n");                                                                                            
    shoit_misc_close_log(receiver->log);     
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
cmpq $0x0, (%rax)
je 0x71bc
movq -0x8(%rbp), %rax
cmpl $0x0, 0x1a0(%rax)
je 0x71a5
jmp 0x71b1
movq -0x8(%rbp), %rax
movq (%rax), %rdi
callq 0x2040
movq -0x8(%rbp), %rax
movq $0x0, (%rax)
movq -0x8(%rbp), %rax
cmpl $-0x1, 0xf8(%rax)
je 0x71e6
movq -0x8(%rbp), %rax
movl 0xf8(%rax), %edi
callq 0x21c0
movq -0x8(%rbp), %rax
movl $0xffffffff, 0xf8(%rax) # imm = 0xFFFFFFFF
movq -0x8(%rbp), %rax
cmpl $-0x1, 0xfc(%rax)
je 0x7210
movq -0x8(%rbp), %rax
movl 0xfc(%rax), %edi
callq 0x21c0
movq -0x8(%rbp), %rax
movl $0xffffffff, 0xfc(%rax) # imm = 0xFFFFFFFF
movq -0x8(%rbp), %rax
cmpq $0x0, 0x70(%rax)
je 0x7234
movq -0x8(%rbp), %rax
movq 0x70(%rax), %rdi
callq 0x2040
movq -0x8(%rbp), %rax
movq $0x0, 0x70(%rax)
movq -0x8(%rbp), %rax
cmpq $0x0, 0xd0(%rax)
je 0x7261
movq -0x8(%rbp), %rax
movq 0xd0(%rax), %rdi
callq 0x2040
movq -0x8(%rbp), %rax
movq $0x0, 0xd0(%rax)
movq -0x8(%rbp), %rax
cmpq $0x0, 0xc8(%rax)
je 0x728e
movq -0x8(%rbp), %rax
movq 0xc8(%rax), %rdi
callq 0x2040
movq -0x8(%rbp), %rax
movq $0x0, 0xc8(%rax)
movq -0x8(%rbp), %rdi
callq 0x2bb0
movq -0x8(%rbp), %rax
movq 0xe8(%rax), %rdi
leaq 0x299a(%rip), %rsi      # 0x9c43
movb $0x0, %al
callq 0x3df0
movq -0x8(%rbp), %rax
movq 0xe8(%rax), %rdi
callq 0x3eb0
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/aap[P]pdp11/kd11a.c
// Function: reset
void
reset(KD11A *cpu)
{
	Busdev *bd;

	cpu->traps = 0;
	cpu->flags = 0;

	// KJ11
	cpu->slr = 0;

	// KT11
	cpu->sr0 = 0;
	cpu->sr2 = 0;
	cpu->mfp = 0;
	cpu->mtp = 0;

	for(bd = cpu->bus->devs; bd; bd = bd->next)
		bd->reset(bd->dev);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movl $0x0, 0x34(%rax)
movq -0x8(%rbp), %rax
movl $0x0, 0x38(%rax)
movq -0x8(%rbp), %rax
movw $0x0, 0x82(%rax)
movq -0x8(%rbp), %rax
movw $0x0, 0x138(%rax)
movq -0x8(%rbp), %rax
movw $0x0, 0x13a(%rax)
movq -0x8(%rbp), %rax
movl $0x0, 0x140(%rax)
movq -0x8(%rbp), %rax
movl $0x0, 0x144(%rax)
movq -0x8(%rbp), %rax
movq 0x28(%rax), %rax
movq (%rax), %rax
movq %rax, -0x10(%rbp)
cmpq $0x0, -0x10(%rbp)
je 0x2dca
movq -0x10(%rbp), %rax
movq 0x38(%rax), %rax
movq -0x10(%rbp), %rcx
movq 0x8(%rcx), %rdi
callq *%rax
movq -0x10(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x10(%rbp)
jmp 0x2da4
addq $0x10, %rsp
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O0/aap[P]pdp11/kd11a.c
// Function: setBA
static word
setBA(KD11A *cpu, word ba, int r, int ov, int oda)
{
	if(ov && r == SP && !(cpu->flags & FLAG_STALL))
		cpu->flags |= FLAG_CKOVF;
	else
		cpu->flags &= ~FLAG_CKOVF;
	if(oda)
		cpu->flags |= FLAG_CKODA;
	else
		cpu->flags &= ~FLAG_CKODA;
	return BA = ba;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movw %si, %ax
movq %rdi, -0x8(%rbp)
movw %ax, -0xa(%rbp)
movl %edx, -0x10(%rbp)
movl %ecx, -0x14(%rbp)
movl %r8d, -0x18(%rbp)
cmpl $0x0, -0x14(%rbp)
je 0x7433
cmpl $0x6, -0x10(%rbp)
jne 0x7433
movq -0x8(%rbp), %rax
movl 0x38(%rax), %eax
andl $0x8, %eax
cmpl $0x0, %eax
jne 0x7433
movq -0x8(%rbp), %rax
movl 0x38(%rax), %ecx
orl $0x20, %ecx
movl %ecx, 0x38(%rax)
jmp 0x7440
movq -0x8(%rbp), %rax
movl 0x38(%rax), %ecx
andl $-0x21, %ecx
movl %ecx, 0x38(%rax)
cmpl $0x0, -0x18(%rbp)
je 0x7455
movq -0x8(%rbp), %rax
movl 0x38(%rax), %ecx
orl $0x40, %ecx
movl %ecx, 0x38(%rax)
jmp 0x7462
movq -0x8(%rbp), %rax
movl 0x38(%rax), %ecx
andl $-0x41, %ecx
movl %ecx, 0x38(%rax)
movw -0xa(%rbp), %ax
movq -0x8(%rbp), %rcx
movw %ax, 0x24(%rcx)
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O0/aap[P]pdp11/kd11a.c
// Function: setMM
static void
setMM(KD11A *cpu, int mm)
{
	if(cpu->flags & FLAG_STALL){
		cpu->mode = 0;
		cpu->relocate = 0;
		return;
	}
	switch(mm&014){
	case 00: cpu->mode = cpu->cur; break;
	case 04: cpu->mode = cpu->temp; break;
	case 010: cpu->mode = cpu->mtp ? cpu->prev : cpu->cur; break;
	case 014: cpu->mode = cpu->mfp ? cpu->prev : cpu->cur; break;
	}
	cpu->relocate = (cpu->sr0&1) || (cpu->sr0&0400 && mm&1);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movq -0x8(%rbp), %rax
movl 0x38(%rax), %eax
andl $0x8, %eax
cmpl $0x0, %eax
je 0x74aa
movq -0x8(%rbp), %rax
movw $0x0, 0x84(%rax)
movq -0x8(%rbp), %rax
movl $0x0, 0x13c(%rax)
jmp 0x75da
movl -0xc(%rbp), %eax
andl $0xc, %eax
movl %eax, %ecx
movq %rcx, -0x18(%rbp)
subl $0xc, %eax
ja 0x7580
movq -0x18(%rbp), %rax
leaq 0x5cca(%rip), %rcx      # 0xd194
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
movq -0x8(%rbp), %rax
movw 0x86(%rax), %cx
movq -0x8(%rbp), %rax
movw %cx, 0x84(%rax)
jmp 0x7580
movq -0x8(%rbp), %rax
movw 0x8a(%rax), %cx
movq -0x8(%rbp), %rax
movw %cx, 0x84(%rax)
jmp 0x7580
movq -0x8(%rbp), %rax
cmpl $0x0, 0x144(%rax)
je 0x7523
movq -0x8(%rbp), %rax
movzwl 0x88(%rax), %eax
movl %eax, -0x1c(%rbp)
jmp 0x7531
movq -0x8(%rbp), %rax
movzwl 0x86(%rax), %eax
movl %eax, -0x1c(%rbp)
movl -0x1c(%rbp), %eax
movw %ax, %cx
movq -0x8(%rbp), %rax
movw %cx, 0x84(%rax)
jmp 0x7580
movq -0x8(%rbp), %rax
cmpl $0x0, 0x140(%rax)
je 0x7561
movq -0x8(%rbp), %rax
movzwl 0x88(%rax), %eax
movl %eax, -0x20(%rbp)
jmp 0x756f
movq -0x8(%rbp), %rax
movzwl 0x86(%rax), %eax
movl %eax, -0x20(%rbp)
movl -0x20(%rbp), %eax
movw %ax, %cx
movq -0x8(%rbp), %rax
movw %cx, 0x84(%rax)
movq -0x8(%rbp), %rax
movzwl 0x138(%rax), %ecx
andl $0x1, %ecx
movb $0x1, %al
cmpl $0x0, %ecx
movb %al, -0x21(%rbp)
jne 0x75c8
movq -0x8(%rbp), %rax
movzwl 0x138(%rax), %ecx
andl $0x100, %ecx            # imm = 0x100
xorl %eax, %eax
cmpl $0x0, %ecx
movb %al, -0x22(%rbp)
je 0x75c2
movl -0xc(%rbp), %eax
andl $0x1, %eax
cmpl $0x0, %eax
setne %al
movb %al, -0x22(%rbp)
movb -0x22(%rbp), %al
movb %al, -0x21(%rbp)
movb -0x21(%rbp), %al
andb $0x1, %al
movzbl %al, %ecx
movq -0x8(%rbp), %rax
movl %ecx, 0x13c(%rax)
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/aap[P]pdp11/kd11a.c
// Function: dato
static int
dato(KD11A *cpu, int b)
{
	UNIBUS_DATA = D;
trace("dato %o %06o -> %06o ", cpu->flags, cpu->bus->data, cpu->ba);
	if(remapBA(cpu, 1))
		return 1;
trace(" phys(%o)\n", PBA);

	codes(cpu);

	if(checkbus(cpu, 1, 0))
		return 1;

	if(cpu->wrpg)
		*cpu->wrpg |= 0100;	// set if writing to page

	if(dato_cpu(cpu, b))
		goto ok;

	if((b ? datob_bus : dato_bus)(cpu->bus))
		return buserr(cpu);
ok:
	return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movl %esi, -0x14(%rbp)
movq -0x10(%rbp), %rax
movw 0x22(%rax), %cx
movq -0x10(%rbp), %rax
movq 0x28(%rax), %rax
movw %cx, 0xc(%rax)
cmpl $0x0, 0x46d06(%rip)     # 0x4ed70
je 0x8095
movq -0x10(%rbp), %rax
movl 0x38(%rax), %esi
movq -0x10(%rbp), %rax
movq 0x28(%rax), %rax
movzwl 0xc(%rax), %edx
movq -0x10(%rbp), %rax
movzwl 0x24(%rax), %ecx
leaq 0x5720(%rip), %rdi      # 0xd7ae
movb $0x0, %al
callq 0x20a0
movq -0x10(%rbp), %rdi
movl $0x1, %esi
callq 0x9420
cmpl $0x0, %eax
je 0x80b4
movl $0x1, -0x4(%rbp)
jmp 0x816e
cmpl $0x0, 0x46cb5(%rip)     # 0x4ed70
je 0x80d6
movq -0x10(%rbp), %rax
movq 0x28(%rax), %rax
movl 0x8(%rax), %esi
leaq 0x56f5(%rip), %rdi      # 0xd7c4
movb $0x0, %al
callq 0x20a0
movq -0x10(%rbp), %rdi
callq 0x8000
movq -0x10(%rbp), %rdi
movl $0x1, %esi
xorl %edx, %edx
callq 0x96e0
cmpl $0x0, %eax
je 0x80fd
movl $0x1, -0x4(%rbp)
jmp 0x816e
movq -0x10(%rbp), %rax
cmpq $0x0, 0x130(%rax)
je 0x811d
movq -0x10(%rbp), %rax
movq 0x130(%rax), %rax
movl (%rax), %ecx
orl $0x40, %ecx
movl %ecx, (%rax)
movq -0x10(%rbp), %rdi
movl -0x14(%rbp), %esi
callq 0x9c00
cmpl $0x0, %eax
je 0x8130
jmp 0x8167
movl -0x14(%rbp), %edx
leaq -0x5d0a(%rip), %rax     # 0x2430
leaq -0x5ca1(%rip), %rcx     # 0x24a0
cmpl $0x0, %edx
cmovneq %rcx, %rax
movq -0x10(%rbp), %rcx
movq 0x28(%rcx), %rdi
callq *%rax
cmpl $0x0, %eax
je 0x8165
movq -0x10(%rbp), %rdi
callq 0x9ad0
movl %eax, -0x4(%rbp)
jmp 0x816e
jmp 0x8167
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x20, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/aap[P]pdp11/kd11a.c
// Function: writedest
static int
writedest(KD11A *cpu, int b)
{
	int d;
	// TODO: can we make this nicer??
	if((cpu->ir & 070) == 0){
		codes(cpu);
		d = cpu->ir & 7;
		if(d == SP && USER) d = USP;	// KT11-SP
		if(b) SETMASK(cpu->r[d], D, 0377);
		else cpu->r[d] = D;
	}else{
		if(b) D = (D<<8) | D&0377;
		setMM(cpu, 1);
		if(dato(cpu, b)) return 1;
	}
	return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movl %esi, -0x14(%rbp)
movq -0x10(%rbp), %rax
movzwl 0x26(%rax), %eax
andl $0x38, %eax
cmpl $0x0, %eax
jne 0x8808
movq -0x10(%rbp), %rdi
callq 0x8000
movq -0x10(%rbp), %rax
movzwl 0x26(%rax), %eax
andl $0x7, %eax
movl %eax, -0x18(%rbp)
cmpl $0x6, -0x18(%rbp)
jne 0x87ba
movq -0x10(%rbp), %rax
movzwl 0x86(%rax), %eax
andl $0x2, %eax
cmpl $0x0, %eax
je 0x87ba
movl $0xe, -0x18(%rbp)
cmpl $0x0, -0x14(%rbp)
je 0x87f2
movq -0x10(%rbp), %rax
movslq -0x18(%rbp), %rcx
movzwl (%rax,%rcx,2), %eax
andl $0xffffff00, %eax       # imm = 0xFFFFFF00
movq -0x10(%rbp), %rcx
movzwl 0x22(%rcx), %ecx
andl $0xff, %ecx
orl %ecx, %eax
movw %ax, %dx
movq -0x10(%rbp), %rax
movslq -0x18(%rbp), %rcx
movw %dx, (%rax,%rcx,2)
jmp 0x8806
movq -0x10(%rbp), %rax
movw 0x22(%rax), %dx
movq -0x10(%rbp), %rax
movslq -0x18(%rbp), %rcx
movw %dx, (%rax,%rcx,2)
jmp 0x885e
cmpl $0x0, -0x14(%rbp)
je 0x8834
movq -0x10(%rbp), %rax
movzwl 0x22(%rax), %eax
shll $0x8, %eax
movq -0x10(%rbp), %rcx
movzwl 0x22(%rcx), %ecx
andl $0xff, %ecx
orl %ecx, %eax
movw %ax, %cx
movq -0x10(%rbp), %rax
movw %cx, 0x22(%rax)
movq -0x10(%rbp), %rdi
movl $0x1, %esi
callq 0x7470
movq -0x10(%rbp), %rdi
movl -0x14(%rbp), %esi
callq 0x8040
cmpl $0x0, %eax
je 0x885c
movl $0x1, -0x4(%rbp)
jmp 0x8865
jmp 0x885e
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x20, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/aap[P]pdp11/kd11a.c
// Function: run
void
run(KD11A *cpu)
{
	cpu->state = STATE_RUNNING;
	while(cpu->state != STATE_HALTED){
		svc(cpu, cpu->bus);

#ifdef AUTODIAG
	extern int diagpassed;
	if(diagpassed)
		return;
#endif

		if(cpu->state == STATE_RUNNING ||
		   cpu->state == STATE_WAITING && cpu->traps){
			cpu->state = STATE_RUNNING;
			step(cpu);
		}
	}

	printstate(cpu);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movl $0x1, 0x3c(%rax)
movq -0x8(%rbp), %rax
cmpl $0x0, 0x3c(%rax)
je 0x8cf6
movq -0x8(%rbp), %rdi
movq -0x8(%rbp), %rax
movq 0x28(%rax), %rsi
callq 0x8d10
movq -0x8(%rbp), %rax
cmpl $0x1, 0x3c(%rax)
je 0x8ce0
movq -0x8(%rbp), %rax
cmpl $0x2, 0x3c(%rax)
jne 0x8cf4
movq -0x8(%rbp), %rax
cmpl $0x0, 0x34(%rax)
je 0x8cf4
movq -0x8(%rbp), %rax
movl $0x1, 0x3c(%rax)
movq -0x8(%rbp), %rdi
callq 0x2dd0
jmp 0x8ca7
movq -0x8(%rbp), %rdi
callq 0x8e60
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/aap[P]pdp11/kd11a.c
// Function: datix
static int
datix(KD11A *cpu, int pse)
{
trace("dati%s %o %06o ", pse ? "p" : "", cpu->flags, cpu->ba);
	if(remapBA(cpu, pse))
		return 1;
trace(" phys(%o) <- ", PBA);
	if(checkbus(cpu, 0, pse))
		return 1;

	if(dati_cpu(cpu))
		goto ok;

	if((pse ? datip_bus : dati_bus)(cpu->bus))
		return buserr(cpu);
ok:
	trace("%06o\n", UNIBUS_DATA);
	return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movl %esi, -0x14(%rbp)
cmpl $0x0, 0x45a6a(%rip)     # 0x4ed70
je 0x933d
movl -0x14(%rbp), %ecx
leaq 0x46c7(%rip), %rsi      # 0xd9d9
leaq 0x4444(%rip), %rax      # 0xd75d
cmpl $0x0, %ecx
cmovneq %rax, %rsi
movq -0x10(%rbp), %rax
movl 0x38(%rax), %edx
movq -0x10(%rbp), %rax
movzwl 0x24(%rax), %ecx
leaq 0x4417(%rip), %rdi      # 0xd74d
movb $0x0, %al
callq 0x20a0
movq -0x10(%rbp), %rdi
movl -0x14(%rbp), %esi
callq 0x9420
cmpl $0x0, %eax
je 0x935a
movl $0x1, -0x4(%rbp)
jmp 0x9409
cmpl $0x0, 0x45a0f(%rip)     # 0x4ed70
je 0x937c
movq -0x10(%rbp), %rax
movq 0x28(%rax), %rax
movl 0x8(%rax), %esi
leaq 0x43ea(%rip), %rdi      # 0xd75f
movb $0x0, %al
callq 0x20a0
movq -0x10(%rbp), %rdi
movl -0x14(%rbp), %edx
xorl %esi, %esi
callq 0x96e0
cmpl $0x0, %eax
je 0x9398
movl $0x1, -0x4(%rbp)
jmp 0x9409
movq -0x10(%rbp), %rdi
callq 0x9840
cmpl $0x0, %eax
je 0x93a8
jmp 0x93df
movl -0x14(%rbp), %edx
leaq -0x7012(%rip), %rax     # 0x23a0
leaq -0x6fa9(%rip), %rcx     # 0x2410
cmpl $0x0, %edx
cmovneq %rcx, %rax
movq -0x10(%rbp), %rcx
movq 0x28(%rcx), %rdi
callq *%rax
cmpl $0x0, %eax
je 0x93dd
movq -0x10(%rbp), %rdi
callq 0x9ad0
movl %eax, -0x4(%rbp)
jmp 0x9409
jmp 0x93df
cmpl $0x0, 0x4598a(%rip)     # 0x4ed70
je 0x9402
movq -0x10(%rbp), %rax
movq 0x28(%rax), %rax
movzwl 0xc(%rax), %esi
leaq 0x42f1(%rip), %rdi      # 0xd6ec
movb $0x0, %al
callq 0x20a0
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/aap[P]pdp11/kd11a.c
// Function: checkbus
static int
checkbus(KD11A *cpu, int wr, int pse)
{
	int err = 0;
	int ba = BA&~1;
	if((wr|pse) && !(cpu->mode&2) && cpu->flags&FLAG_CKOVF){
		if(ba == 0177776 ||	// PSW
#ifdef KJ11
		   ba == 0177774 ||	// SLR
#endif
		   ba == 0177570){	// SR
			cpu->flags |= FLAG_OVFLW;	// proc address
			err = ovflwerr(cpu);
// TODO: what's going on here with KT11?
		}else if((BA&0177400) < SLR){
			cpu->flags |= FLAG_OVFLW;
			err = ovflwerr(cpu);
		}else if((BA&0177400) == SLR){
			cpu->flags |= FLAG_OVFLW;	// yellow zone
			if((BA&0340)!=0340)
				err = ovflwerr(cpu);
		}
	}
	if(cpu->flags&FLAG_CKODA && BA&1)
		err = buserr(cpu);
	return err;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movl %edx, -0x10(%rbp)
movl $0x0, -0x14(%rbp)
movq -0x8(%rbp), %rax
movzwl 0x24(%rax), %eax
andl $-0x2, %eax
movl %eax, -0x18(%rbp)
movl -0xc(%rbp), %eax
orl -0x10(%rbp), %eax
cmpl $0x0, %eax
je 0x9801
movq -0x8(%rbp), %rax
movzwl 0x84(%rax), %eax
andl $0x2, %eax
cmpl $0x0, %eax
jne 0x9801
movq -0x8(%rbp), %rax
movl 0x38(%rax), %eax
andl $0x20, %eax
cmpl $0x0, %eax
je 0x9801
cmpl $0xfffe, -0x18(%rbp)    # imm = 0xFFFE
je 0x975b
cmpl $0xfffc, -0x18(%rbp)    # imm = 0xFFFC
je 0x975b
cmpl $0xff78, -0x18(%rbp)    # imm = 0xFF78
jne 0x9779
movq -0x8(%rbp), %rax
movl 0x38(%rax), %ecx
orl $0x10, %ecx
movl %ecx, 0x38(%rax)
movq -0x8(%rbp), %rdi
callq 0x9b80
movl %eax, -0x14(%rbp)
jmp 0x97ff
movq -0x8(%rbp), %rax
movzwl 0x24(%rax), %eax
andl $0xff00, %eax           # imm = 0xFF00
movq -0x8(%rbp), %rcx
movzwl 0x82(%rcx), %ecx
cmpl %ecx, %eax
jge 0x97b0
movq -0x8(%rbp), %rax
movl 0x38(%rax), %ecx
orl $0x10, %ecx
movl %ecx, 0x38(%rax)
movq -0x8(%rbp), %rdi
callq 0x9b80
movl %eax, -0x14(%rbp)
jmp 0x97fd
movq -0x8(%rbp), %rax
movzwl 0x24(%rax), %eax
andl $0xff00, %eax           # imm = 0xFF00
movq -0x8(%rbp), %rcx
movzwl 0x82(%rcx), %ecx
cmpl %ecx, %eax
jne 0x97fb
movq -0x8(%rbp), %rax
movl 0x38(%rax), %ecx
orl $0x10, %ecx
movl %ecx, 0x38(%rax)
movq -0x8(%rbp), %rax
movzwl 0x24(%rax), %eax
andl $0xe0, %eax
cmpl $0xe0, %eax
je 0x97f9
movq -0x8(%rbp), %rdi
callq 0x9b80
movl %eax, -0x14(%rbp)
jmp 0x97fb
jmp 0x97fd
jmp 0x97ff
jmp 0x9801
movq -0x8(%rbp), %rax
movl 0x38(%rax), %eax
andl $0x40, %eax
cmpl $0x0, %eax
je 0x982c
movq -0x8(%rbp), %rax
movzwl 0x24(%rax), %eax
andl $0x1, %eax
cmpl $0x0, %eax
je 0x982c
movq -0x8(%rbp), %rdi
callq 0x9ad0
movl %eax, -0x14(%rbp)
movl -0x14(%rbp), %eax
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/aap[P]pdp11/kd11a.c
// Function: buserr
static int
buserr(KD11A *cpu)
{
	if(cpu->flags & FLAG_BERR){
		cpu->flags |= FLAG_DUBBERR | FLAG_STALL;
			cpu->mode = 0;
			cpu->relocate = 0;
	}
	cpu->flags |= FLAG_BERR;
	cpu->flags &= ~(FLAG_TRAP | FLAG_INTR);
	return 1;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movl 0x38(%rax), %eax
andl $0x1, %eax
cmpl $0x0, %eax
je 0x9b12
movq -0x8(%rbp), %rax
movl 0x38(%rax), %ecx
orl $0x108, %ecx            # imm = 0x108
movl %ecx, 0x38(%rax)
movq -0x8(%rbp), %rax
movw $0x0, 0x84(%rax)
movq -0x8(%rbp), %rax
movl $0x0, 0x13c(%rax)
movq -0x8(%rbp), %rax
movl 0x38(%rax), %ecx
orl $0x1, %ecx
movl %ecx, 0x38(%rax)
movq -0x8(%rbp), %rax
movl 0x38(%rax), %ecx
andl $-0x7, %ecx
movl %ecx, 0x38(%rax)
movl $0x1, %eax
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/aap[P]pdp11/kd11a.c
// Function: ovflwerr
static int
ovflwerr(KD11A *cpu)
{
	cpu->flags |= FLAG_OVFLWERR | FLAG_STALL;
		cpu->mode = 0;
		cpu->relocate = 0;
	cpu->flags &= ~(FLAG_TRAP | FLAG_INTR);
	return 1;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movl 0x38(%rax), %ecx
orl $0x88, %ecx
movl %ecx, 0x38(%rax)
movq -0x8(%rbp), %rax
movw $0x0, 0x84(%rax)
movq -0x8(%rbp), %rax
movl $0x0, 0x13c(%rax)
movq -0x8(%rbp), %rax
movl 0x38(%rax), %ecx
andl $-0x7, %ecx
movl %ecx, 0x38(%rax)
movl $0x1, %eax
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/aap[P]pdp11/kd11a.c
// Function: wrpdr
static void
wrpdr(KD11A *cpu, int i, int b)
{
	if(!b || (BA&1)==0)
		cpu->acf[i] = UNIBUS_DATA & 016;
	if(!b || BA&1)
		cpu->plf[i] = UNIBUS_DATA>>2 & 017700;
	cpu->acf[i] &= ~0100;	// W bit
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movl %edx, -0x10(%rbp)
cmpl $0x0, -0x10(%rbp)
je 0x9f34
movq -0x8(%rbp), %rax
movzwl 0x24(%rax), %eax
andl $0x1, %eax
cmpl $0x0, %eax
jne 0x9f52
movq -0x8(%rbp), %rax
movq 0x28(%rax), %rax
movzwl 0xc(%rax), %edx
andl $0xe, %edx
movq -0x8(%rbp), %rax
movslq -0xc(%rbp), %rcx
movl %edx, 0xac(%rax,%rcx,4)
cmpl $0x0, -0x10(%rbp)
je 0x9f68
movq -0x8(%rbp), %rax
movzwl 0x24(%rax), %eax
andl $0x1, %eax
cmpl $0x0, %eax
je 0x9f8c
movq -0x8(%rbp), %rax
movq 0x28(%rax), %rax
movzwl 0xc(%rax), %edx
sarl $0x2, %edx
andl $0x1fc0, %edx           # imm = 0x1FC0
movq -0x8(%rbp), %rax
movslq -0xc(%rbp), %rcx
movl %edx, 0xec(%rax,%rcx,4)
movq -0x8(%rbp), %rax
movslq -0xc(%rbp), %rcx
movl 0xac(%rax,%rcx,4), %edx
andl $-0x41, %edx
movl %edx, 0xac(%rax,%rcx,4)
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/aap[P]pdp11/kd11a.c
// Function: wrpar
static void
wrpar(KD11A *cpu, int i, int b)
{
	if(!b || (BA&1)==0)
		cpu->par[i] = cpu->par[i]&07400 | UNIBUS_DATA&0377;
	if(!b || BA&1)
		cpu->par[i] = UNIBUS_DATA&07400 | cpu->par[i]&0377;
	cpu->acf[i] &= ~0100;	// W bit
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movl %edx, -0x10(%rbp)
cmpl $0x0, -0x10(%rbp)
je 0x9fd4
movq -0x8(%rbp), %rax
movzwl 0x24(%rax), %eax
andl $0x1, %eax
cmpl $0x0, %eax
jne 0xa010
movq -0x8(%rbp), %rax
movslq -0xc(%rbp), %rcx
movzwl 0x8c(%rax,%rcx,2), %eax
andl $0xf00, %eax            # imm = 0xF00
movq -0x8(%rbp), %rcx
movq 0x28(%rcx), %rcx
movzwl 0xc(%rcx), %ecx
andl $0xff, %ecx
orl %ecx, %eax
movw %ax, %dx
movq -0x8(%rbp), %rax
movslq -0xc(%rbp), %rcx
movw %dx, 0x8c(%rax,%rcx,2)
cmpl $0x0, -0x10(%rbp)
je 0xa026
movq -0x8(%rbp), %rax
movzwl 0x24(%rax), %eax
andl $0x1, %eax
cmpl $0x0, %eax
je 0xa062
movq -0x8(%rbp), %rax
movq 0x28(%rax), %rax
movzwl 0xc(%rax), %eax
andl $0xf00, %eax            # imm = 0xF00
movq -0x8(%rbp), %rcx
movslq -0xc(%rbp), %rdx
movzwl 0x8c(%rcx,%rdx,2), %ecx
andl $0xff, %ecx
orl %ecx, %eax
movw %ax, %dx
movq -0x8(%rbp), %rax
movslq -0xc(%rbp), %rcx
movw %dx, 0x8c(%rax,%rcx,2)
movq -0x8(%rbp), %rax
movslq -0xc(%rbp), %rcx
movl 0xac(%rax,%rcx,4), %edx
andl $-0x41, %edx
movl %edx, 0xac(%rax,%rcx,4)
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/minkcv[P]vm/main.c
// Function: readRom
uint8_t* readRom(const char* filename, int print)
{
    FILE* romfile = fopen(filename, "rb");
    if (romfile == NULL)
    {
        printf("Error reading file %s\n", filename);
        exit(1);
    }
    uint8_t* rom = malloc(sizeof(uint8_t) * 128 * MEMORY_SEGMENT_SIZE);
    memset(rom, 0, sizeof(uint8_t) * 128 * MEMORY_SEGMENT_SIZE);
    size_t bytesRead = fread(rom, sizeof(uint8_t), 128 * MEMORY_SEGMENT_SIZE, romfile);
    printf("Read %Id bytes from the rom\n", bytesRead);
    if (print)
    {
        printf("Rom:\n");
        int i;
        for (i = 0; i < bytesRead; i++)
            printf("%2X\n", rom[i]);
    }
    fclose(romfile);
    return rom;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movq -0x8(%rbp), %rdi
leaq 0x3917(%rip), %rsi      # 0x5031
callq 0x1150
movq %rax, -0x18(%rbp)
cmpq $0x0, -0x18(%rbp)
jne 0x1746
movq -0x8(%rbp), %rsi
leaq 0x38ff(%rip), %rdi      # 0x5034
movb $0x0, %al
callq 0x1040
movl $0x1, %edi
callq 0x1170
movl $0x8000, %edi           # imm = 0x8000
callq 0x1180
movq %rax, -0x20(%rbp)
movq -0x20(%rbp), %rdi
xorl %esi, %esi
movl $0x8000, %edx           # imm = 0x8000
callq 0x10a0
movq -0x20(%rbp), %rdi
movq -0x18(%rbp), %rcx
movl $0x1, %esi
movl $0x8000, %edx           # imm = 0x8000
callq 0x11b0
movq %rax, -0x28(%rbp)
movq -0x28(%rbp), %rsi
leaq 0x3921(%rip), %rdi      # 0x50ab
movb $0x0, %al
callq 0x1040
cmpl $0x0, -0xc(%rbp)
je 0x17dd
leaq 0x3902(%rip), %rdi      # 0x50a0
movb $0x0, %al
callq 0x1040
movl $0x0, -0x2c(%rbp)
movslq -0x2c(%rbp), %rax
cmpq -0x28(%rbp), %rax
jae 0x17db
movq -0x20(%rbp), %rax
movslq -0x2c(%rbp), %rcx
movzbl (%rax,%rcx), %esi
leaq 0x38dd(%rip), %rdi      # 0x50a6
movb $0x0, %al
callq 0x1040
movl -0x2c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x2c(%rbp)
jmp 0x17ac
jmp 0x17dd
movq -0x18(%rbp), %rdi
callq 0x1120
movq -0x20(%rbp), %rax
addq $0x30, %rsp
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O0/minkcv[P]vm/machine/vm.c
// Function: createVM
VM* createVM(uint16_t* code, uint8_t* rom, Display* display, int debugMode)
{
    VM* vm = (VM*)malloc(sizeof(VM));
    vm->cpu.code = code;
    vm->cpu.pc = code;
    vm->cpu.debugMode = debugMode;
    vm->cpu.breakState = 0;
    vm->cpu.step = 0;
    vm->display = display;
    vm->gpu = createGPU();
    vm->ipu = createIPU();
    memset(vm->memory, 0, sizeof(vm->memory[0][0]) * MEMORY_SEGMENT_COUNT * MEMORY_SEGMENT_SIZE);
    memset(vm->cpu.regs, 0, sizeof(vm->cpu.regs[0]) * REGISTER_COUNT);
    if (rom != NULL) // ROM is optional
        memcpy(vm->memory[128], rom, 128 * MEMORY_SEGMENT_SIZE);
    return vm;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movl %ecx, -0x1c(%rbp)
movl $0x10048, %edi          # imm = 0x10048
callq 0x1180
movq %rax, -0x28(%rbp)
movq -0x8(%rbp), %rcx
movq -0x28(%rbp), %rax
movq %rcx, 0x18(%rax)
movq -0x8(%rbp), %rcx
movq -0x28(%rbp), %rax
movq %rcx, 0x10(%rax)
movl -0x1c(%rbp), %ecx
movq -0x28(%rbp), %rax
movl %ecx, 0x20(%rax)
movq -0x28(%rbp), %rax
movl $0x0, 0x24(%rax)
movq -0x28(%rbp), %rax
movl $0x0, 0x28(%rax)
movq -0x18(%rbp), %rcx
movq -0x28(%rbp), %rax
movq %rcx, 0x10040(%rax)
callq 0x1ff0
movq %rax, %rcx
movq -0x28(%rbp), %rax
movq %rcx, 0x10030(%rax)
movb $0x0, %al
callq 0x2cd0
movq %rax, %rcx
movq -0x28(%rbp), %rax
movq %rcx, 0x10038(%rax)
movq -0x28(%rbp), %rdi
addq $0x30, %rdi
xorl %esi, %esi
movl $0x10000, %edx          # imm = 0x10000
callq 0x10a0
movq -0x28(%rbp), %rdi
xorl %esi, %esi
movl $0x10, %edx
callq 0x10a0
cmpq $0x0, -0x10(%rbp)
je 0x18cc
movq -0x28(%rbp), %rdi
addq $0x30, %rdi
addq $0x8000, %rdi           # imm = 0x8000
movq -0x10(%rbp), %rsi
movl $0x8000, %edx           # imm = 0x8000
callq 0x10e0
movq -0x28(%rbp), %rax
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/minkcv[P]vm/machine/vm.c
// Function: destroyVM
void destroyVM(VM* vm)
{
    destroyGPU(vm->gpu);
    vm->gpu = NULL;
    destroyIPU(vm->ipu);
    vm->ipu = NULL;
    free(vm);
    vm = NULL;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq 0x10030(%rax), %rdi
callq 0x2080
movq -0x8(%rbp), %rax
movq $0x0, 0x10030(%rax)
movq -0x8(%rbp), %rax
movq 0x10038(%rax), %rdi
callq 0x2df0
movq -0x8(%rbp), %rax
movq $0x0, 0x10038(%rax)
movq -0x8(%rbp), %rdi
callq 0x1160
movq $0x0, -0x8(%rbp)
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/minkcv[P]vm/machine/display.c
// Function: createDisplay
Display* createDisplay(int width, int height, int scale, int pitch)
{
    SDL_Init(SDL_INIT_VIDEO);

    Display* display = (Display*)malloc(sizeof(Display));
    display->width = width;
    display->height = height;
    display->scale = scale;
    display->pitch = pitch;
    display->window = SDL_CreateWindow("Vapor Spec", SDL_WINDOWPOS_CENTERED, SDL_WINDOWPOS_CENTERED, 
            width * scale, height * scale, 0);
    display->renderer = SDL_CreateRenderer(display->window, -1, 0);
    display->back = SDL_CreateTexture(display->renderer, 
            SDL_PIXELFORMAT_RGB24, SDL_TEXTUREACCESS_STREAMING, width, height);
    SDL_Surface* splash = SDL_LoadBMP("title.bmp");
    SDL_Texture* splashTex = SDL_CreateTextureFromSurface(display->renderer, splash);
    SDL_RenderCopy(display->renderer, splashTex, NULL, NULL);
    SDL_RenderPresent(display->renderer);
    SDL_Delay(2000); // Show splash screen for 2 seconds
    return display;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movl %edi, -0x4(%rbp)
movl %esi, -0x8(%rbp)
movl %edx, -0xc(%rbp)
movl %ecx, -0x10(%rbp)
movl $0x20, %edi
callq 0x10f0
movl $0x28, %edi
callq 0x1180
movq %rax, -0x18(%rbp)
movl -0x4(%rbp), %ecx
movq -0x18(%rbp), %rax
movl %ecx, 0x18(%rax)
movl -0x8(%rbp), %ecx
movq -0x18(%rbp), %rax
movl %ecx, 0x1c(%rax)
movl -0xc(%rbp), %ecx
movq -0x18(%rbp), %rax
movl %ecx, 0x20(%rax)
movl -0x10(%rbp), %ecx
movq -0x18(%rbp), %rax
movl %ecx, 0x24(%rax)
movl -0x4(%rbp), %ecx
imull -0xc(%rbp), %ecx
movl -0x8(%rbp), %r8d
imull -0xc(%rbp), %r8d
leaq 0x32d1(%rip), %rdi      # 0x512c
movl $0x2fff0000, %edx       # imm = 0x2FFF0000
xorl %r9d, %r9d
movl %edx, %esi
callq 0x1050
movq %rax, %rcx
movq -0x18(%rbp), %rax
movq %rcx, (%rax)
movq -0x18(%rbp), %rax
movq (%rax), %rdi
movl $0xffffffff, %esi       # imm = 0xFFFFFFFF
xorl %edx, %edx
callq 0x1030
movq %rax, %rcx
movq -0x18(%rbp), %rax
movq %rcx, 0x8(%rax)
movq -0x18(%rbp), %rax
movq 0x8(%rax), %rdi
movl -0x4(%rbp), %ecx
movl -0x8(%rbp), %r8d
movl $0x17101803, %esi       # imm = 0x17101803
movl $0x1, %edx
callq 0x11d0
movq %rax, %rcx
movq -0x18(%rbp), %rax
movq %rcx, 0x10(%rax)
leaq 0x3275(%rip), %rdi      # 0x5137
leaq 0x3168(%rip), %rsi      # 0x5031
callq 0x1090
movq %rax, %rdi
movl $0x1, %esi
callq 0x1100
movq %rax, -0x20(%rbp)
movq -0x18(%rbp), %rax
movq 0x8(%rax), %rdi
movq -0x20(%rbp), %rsi
callq 0x1190
movq %rax, -0x28(%rbp)
movq -0x18(%rbp), %rax
movq 0x8(%rax), %rdi
movq -0x28(%rbp), %rsi
xorl %eax, %eax
movl %eax, %ecx
movq %rcx, %rdx
callq 0x1140
movq -0x18(%rbp), %rax
movq 0x8(%rax), %rdi
callq 0x1070
movl $0x7d0, %edi            # imm = 0x7D0
callq 0x10c0
movq -0x18(%rbp), %rax
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/minkcv[P]vm/machine/display.c
// Function: updateDisplay
void updateDisplay(Display* display, GPU* gpu)
{
    SDL_UpdateTexture(display->back, NULL, gpu->pixels, gpu->pitch);
    SDL_RenderClear(display->renderer);
    SDL_RenderCopy(display->renderer, display->back, NULL, NULL);
    SDL_RenderPresent(display->renderer);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq 0x10(%rax), %rdi
movq -0x10(%rbp), %rax
movq 0xc00(%rax), %rdx
movq -0x10(%rbp), %rax
movl 0xc08(%rax), %ecx
xorl %eax, %eax
movl %eax, %esi
callq 0x10d0
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rdi
callq 0x1110
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rdi
movq -0x8(%rbp), %rax
movq 0x10(%rax), %rsi
xorl %eax, %eax
movl %eax, %ecx
movq %rcx, %rdx
callq 0x1140
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rdi
callq 0x1070
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/minkcv[P]vm/machine/display.c
// Function: quitDisplay
void quitDisplay(Display* display)
{
    display->window = NULL;
    display->back = NULL;
    free(display);
    display = NULL;
    SDL_Quit();
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq $0x0, (%rax)
movq -0x8(%rbp), %rax
movq $0x0, 0x10(%rax)
movq -0x8(%rbp), %rdi
callq 0x1160
movq $0x0, -0x8(%rbp)
callq 0x1060
addq $0x10, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/minkcv[P]vm/machine/gpu.c
// Function: createGPU
GPU* createGPU()
{
    GPU* gpu = (GPU*)malloc(sizeof(GPU));
    gpu->active = 1;
    gpu->bytesPerPixel = 3; // From SDL_PIXELFORMAT_RGB24 in display.c
    gpu->pitch = SCREEN_WIDTH * gpu->bytesPerPixel;
    gpu->pixels = (uint8_t *) malloc(sizeof(uint8_t) * gpu->bytesPerPixel * SCREEN_WIDTH * SCREEN_HEIGHT);
    return gpu;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movl $0xc18, %edi            # imm = 0xC18
callq 0x1180
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
movb 0xc10(%rax), %cl
andb $-0x2, %cl
orb $0x1, %cl
movb %cl, 0xc10(%rax)
movq -0x8(%rbp), %rax
movl $0x3, 0xc0c(%rax)
movq -0x8(%rbp), %rax
movl 0xc0c(%rax), %ecx
shll $0x8, %ecx
movq -0x8(%rbp), %rax
movl %ecx, 0xc08(%rax)
movq -0x8(%rbp), %rax
movslq 0xc0c(%rax), %rax
shlq $0x0, %rax
shlq $0x8, %rax
imulq $0xc0, %rax, %rdi
callq 0x1180
movq %rax, %rcx
movq -0x8(%rbp), %rax
movq %rcx, 0xc00(%rax)
movq -0x8(%rbp), %rax
addq $0x10, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/minkcv[P]vm/machine/gpu.c
// Function: updateGPU
void updateGPU(GPU* gpu, uint8_t memory[MEMORY_SEGMENT_COUNT][MEMORY_SEGMENT_SIZE])
{
    gpu->active = memory[GPU_FLAG_SEG][GPU_FLAG_OFFSET] & 0x1;
    if (gpu->active)
    {
        // Preserve other bits, only change the second bit
        gpu->refreshed = !gpu->refreshed;
        memory[GPU_FLAG_SEG][GPU_FLAG_OFFSET] &= 0xFD; // Clear the second bit
        memory[GPU_FLAG_SEG][GPU_FLAG_OFFSET] |= (gpu->refreshed << 1); // Set the second bit according to gpu->refreshed
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x10(%rbp), %rax
movzbl 0x7f11(%rax), %ecx
andl $0x1, %ecx
movq -0x8(%rbp), %rax
movb %cl, %dl
movb 0xc10(%rax), %cl
andb $0x1, %dl
andb $-0x2, %cl
orb %dl, %cl
movb %cl, 0xc10(%rax)
movq -0x8(%rbp), %rax
movb 0xc10(%rax), %al
andb $0x1, %al
movzbl %al, %eax
cmpl $0x0, %eax
je 0x216f
movq -0x8(%rbp), %rax
movb 0xc10(%rax), %al
shrb %al
andb $0x1, %al
movzbl %al, %eax
cmpl $0x0, %eax
setne %al
xorb $-0x1, %al
andb $0x1, %al
movzbl %al, %ecx
movq -0x8(%rbp), %rax
movb %cl, %dl
movb 0xc10(%rax), %cl
andb $0x1, %dl
shlb %dl
andb $-0x3, %cl
orb %dl, %cl
movb %cl, 0xc10(%rax)
movq -0x10(%rbp), %rax
movzbl 0x7f11(%rax), %ecx
andl $0xfd, %ecx
movb %cl, 0x7f11(%rax)
movq -0x8(%rbp), %rax
movb 0xc10(%rax), %al
shrb %al
andb $0x1, %al
movzbl %al, %edx
shll %edx
movq -0x10(%rbp), %rax
movzbl 0x7f11(%rax), %ecx
orl %edx, %ecx
movb %cl, 0x7f11(%rax)
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/minkcv[P]vm/machine/ipu.c
// Function: createIPU
IPU* createIPU()
{
    IPU* ipu = (IPU*)malloc(sizeof(IPU));
    JOYSTICK* js1 = (JOYSTICK*)malloc(sizeof(JOYSTICK));
    js1->buttons[0] = SDLK_UP;
    js1->buttons[1] = SDLK_DOWN;
    js1->buttons[2] = SDLK_LEFT;
    js1->buttons[3] = SDLK_RIGHT;
    js1->buttons[4] = SDLK_o;
    js1->buttons[5] = SDLK_u;
    js1->buttons[6] = SDLK_y;
    js1->buttons[7] = SDLK_h;
    js1->keysAsBits = 0;
    ipu->js1 = js1;

    JOYSTICK* js2 = (JOYSTICK*)malloc(sizeof(JOYSTICK));
    js2->buttons[0] = SDLK_w;
    js2->buttons[1] = SDLK_s;
    js2->buttons[2] = SDLK_a;
    js2->buttons[3] = SDLK_d;
    js2->buttons[4] = SDLK_q;
    js2->buttons[5] = SDLK_e;
    js2->buttons[6] = SDLK_r;
    js2->buttons[7] = SDLK_f;
    js2->keysAsBits = 0;
    ipu->js2 = js2;

    return ipu;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movl $0x10, %edi
callq 0x1180
movq %rax, -0x8(%rbp)
movl $0x24, %edi
callq 0x1180
movq %rax, -0x10(%rbp)
movq -0x10(%rbp), %rax
movl $0x40000052, (%rax)     # imm = 0x40000052
movq -0x10(%rbp), %rax
movl $0x40000051, 0x4(%rax)  # imm = 0x40000051
movq -0x10(%rbp), %rax
movl $0x40000050, 0x8(%rax)  # imm = 0x40000050
movq -0x10(%rbp), %rax
movl $0x4000004f, 0xc(%rax)  # imm = 0x4000004F
movq -0x10(%rbp), %rax
movl $0x6f, 0x10(%rax)
movq -0x10(%rbp), %rax
movl $0x75, 0x14(%rax)
movq -0x10(%rbp), %rax
movl $0x79, 0x18(%rax)
movq -0x10(%rbp), %rax
movl $0x68, 0x1c(%rax)
movq -0x10(%rbp), %rax
movb $0x0, 0x20(%rax)
movq -0x10(%rbp), %rcx
movq -0x8(%rbp), %rax
movq %rcx, (%rax)
movl $0x24, %edi
callq 0x1180
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rax
movl $0x77, (%rax)
movq -0x18(%rbp), %rax
movl $0x73, 0x4(%rax)
movq -0x18(%rbp), %rax
movl $0x61, 0x8(%rax)
movq -0x18(%rbp), %rax
movl $0x64, 0xc(%rax)
movq -0x18(%rbp), %rax
movl $0x71, 0x10(%rax)
movq -0x18(%rbp), %rax
movl $0x65, 0x14(%rax)
movq -0x18(%rbp), %rax
movl $0x72, 0x18(%rax)
movq -0x18(%rbp), %rax
movl $0x66, 0x1c(%rax)
movq -0x18(%rbp), %rax
movb $0x0, 0x20(%rax)
movq -0x18(%rbp), %rcx
movq -0x8(%rbp), %rax
movq %rcx, 0x8(%rax)
movq -0x8(%rbp), %rax
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/minkcv[P]vm/machine/ipu.c
// Function: destroyIPU
void destroyIPU(IPU* ipu)
{
    free(ipu->js1);
    ipu->js1 = NULL;
    free(ipu->js2);
    ipu->js2 = NULL;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq (%rax), %rdi
callq 0x1160
movq -0x8(%rbp), %rax
movq $0x0, (%rax)
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rdi
callq 0x1160
movq -0x8(%rbp), %rax
movq $0x0, 0x8(%rax)
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/minkcv[P]vm/machine/ipu.c
// Function: updateIPU
void updateIPU(IPU* ipu, SDL_KeyboardEvent kEvent, 
        uint8_t memory[MEMORY_SEGMENT_COUNT][MEMORY_SEGMENT_SIZE])
{
    updateJoystick(ipu->js1, kEvent);
    updateJoystick(ipu->js2, kEvent);
    memory[JOYSTICK_SEG][JOYSTICK_1_OFFSET] = ipu->js1->keysAsBits;
    memory[JOYSTICK_SEG][JOYSTICK_2_OFFSET] = ipu->js2->keysAsBits;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
leaq 0x10(%rbp), %rax
movq %rax, -0x18(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rcx
movq (%rcx), %rdi
movq (%rax), %rcx
movq %rcx, (%rsp)
movq 0x8(%rax), %rcx
movq %rcx, 0x8(%rsp)
movq 0x10(%rax), %rcx
movq %rcx, 0x10(%rsp)
movq 0x18(%rax), %rax
movq %rax, 0x18(%rsp)
callq 0x2ef0
movq -0x18(%rbp), %rax
movq -0x8(%rbp), %rcx
movq 0x8(%rcx), %rdi
movq (%rax), %rcx
movq %rcx, (%rsp)
movq 0x8(%rax), %rcx
movq %rcx, 0x8(%rsp)
movq 0x10(%rax), %rcx
movq %rcx, 0x10(%rsp)
movq 0x18(%rax), %rax
movq %rax, 0x18(%rsp)
callq 0x2ef0
movq -0x8(%rbp), %rax
movq (%rax), %rax
movb 0x20(%rax), %cl
movq -0x10(%rbp), %rax
movb %cl, 0x7f00(%rax)
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rax
movb 0x20(%rax), %cl
movq -0x10(%rbp), %rax
movb %cl, 0x7f01(%rax)
addq $0x40, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/minkcv[P]vm/machine/ipu.c
// Function: updateJoystick
void updateJoystick(JOYSTICK* js, SDL_KeyboardEvent kEvent)
{
    int i;
    uint8_t bit = 1;
    for (i = 0; i < NUM_JOYSTICK_BUTTONS; i++)
    {
        if (kEvent.keysym.sym == js->buttons[i])
        {
            if (kEvent.type == SDL_KEYDOWN)
            {
                // Leave the other bits but ensure the ith bit is 1
                js->keysAsBits |= (bit << i);
            }
            else if (kEvent.type == SDL_KEYUP)
            {
                // Leave the other bits but ensure the ith bit is 0
                js->keysAsBits &= (~(bit << i)); // Bitwise inversion
            }
        }
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
leaq 0x10(%rbp), %rax
movq %rax, -0x18(%rbp)
movq %rdi, -0x8(%rbp)
movb $0x1, -0xd(%rbp)
movl $0x0, -0xc(%rbp)
cmpl $0x8, -0xc(%rbp)
jge 0x2f7f
movq -0x18(%rbp), %rax
movl 0x14(%rax), %eax
movq -0x8(%rbp), %rcx
movslq -0xc(%rbp), %rdx
cmpl (%rcx,%rdx,4), %eax
jne 0x2f72
movq -0x18(%rbp), %rax
cmpl $0x300, (%rax)          # imm = 0x300
jne 0x2f49
movzbl -0xd(%rbp), %edx
movl -0xc(%rbp), %ecx
shll %cl, %edx
movq -0x8(%rbp), %rax
movzbl 0x20(%rax), %ecx
orl %edx, %ecx
movb %cl, 0x20(%rax)
jmp 0x2f70
movq -0x18(%rbp), %rax
cmpl $0x301, (%rax)          # imm = 0x301
jne 0x2f6e
movzbl -0xd(%rbp), %edx
movl -0xc(%rbp), %ecx
shll %cl, %edx
xorl $-0x1, %edx
movq -0x8(%rbp), %rax
movzbl 0x20(%rax), %ecx
andl %edx, %ecx
movb %cl, 0x20(%rax)
jmp 0x2f70
jmp 0x2f72
jmp 0x2f74
movl -0xc(%rbp), %eax
addl $0x1, %eax
movl %eax, -0xc(%rbp)
jmp 0x2f0b
popq %rbp
retq
nopw %cs:(%rax,%rax)
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/minkcv[P]vm/machine/cpu.c
// Function: decode
void decode(uint16_t instr, Instruction* decoded)
{
    uint16_t clean = 0x000F;
    decoded->opcode = instr >> 12 & clean;
    decoded->arg0 = instr >> 8 & clean;
    decoded->arg1 = instr >> 4 & clean;
    decoded->arg2 = instr & clean;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movw %di, %ax
movw %ax, -0x2(%rbp)
movq %rsi, -0x10(%rbp)
movw $0xf, -0x12(%rbp)
movzwl -0x2(%rbp), %ecx
sarl $0xc, %ecx
movzwl -0x12(%rbp), %eax
andl %eax, %ecx
movq -0x10(%rbp), %rax
movw %cx, %dx
movw (%rax), %cx
andw $0xf, %dx
andw $-0x10, %cx
orw %dx, %cx
movw %cx, (%rax)
movzwl -0x2(%rbp), %ecx
sarl $0x8, %ecx
movzwl -0x12(%rbp), %eax
andl %eax, %ecx
movq -0x10(%rbp), %rax
movw %cx, %dx
movw (%rax), %cx
andw $0xf, %dx
shlw $0x4, %dx
andw $0xff0f, %cx            # imm = 0xFF0F
orw %dx, %cx
movw %cx, (%rax)
movzwl -0x2(%rbp), %ecx
sarl $0x4, %ecx
movzwl -0x12(%rbp), %eax
andl %eax, %ecx
movq -0x10(%rbp), %rax
movw %cx, %dx
movw (%rax), %cx
andw $0xf, %dx
shlw $0x8, %dx
andw $0xf0ff, %cx            # imm = 0xF0FF
orw %dx, %cx
movw %cx, (%rax)
movzwl -0x2(%rbp), %ecx
movzwl -0x12(%rbp), %eax
andl %eax, %ecx
movq -0x10(%rbp), %rax
movw %cx, %dx
movw (%rax), %cx
andw $0xf, %dx
shlw $0xc, %dx
andw $0xfff, %cx             # imm = 0xFFF
orw %dx, %cx
movw %cx, (%rax)
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/minkcv[P]vm/machine/cpu.c
// Function: print_disasm_block
void print_disasm_block(CPU *cpu) {
    // Disassemble next 16 instructions
    int i;
    for (i = 0; i < 16; i++)
    {
	int instructionCount = cpu->pc - cpu->code + i;
	if (instructionCount > JUMP_SEGMENT_SIZE * JUMP_SEGMENT_SIZE)
	  continue; // End of program, can't keep reading instructions.
	int instructionSegment = instructionCount / JUMP_SEGMENT_SIZE;
	int instructionOffset = instructionCount % JUMP_SEGMENT_SIZE;
	char assembly[256];
	memset(assembly, 0, sizeof(char) * 256);
	Instruction decoded;
	decode(*(cpu->pc + i), &decoded);
	disassemble(&decoded, assembly);
	// Print star for current instruction
	if (i == 0)
	  printf("*");
	else
	  printf(" ");

	// Print disassembly with segment.offset address
	printf(" %-30s ; %03d.%03d 0x%02X.0x%02X\n", assembly,
	       instructionSegment, instructionOffset,
	       instructionSegment, instructionOffset);
      }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x130, %rsp            # imm = 0x130
movq %rdi, -0x8(%rbp)
movl $0x0, -0xc(%rbp)
cmpl $0x10, -0xc(%rbp)
jge 0x3f41
movq -0x8(%rbp), %rax
movq 0x10(%rax), %rax
movq -0x8(%rbp), %rcx
movq 0x18(%rcx), %rcx
subq %rcx, %rax
sarq %rax
movslq -0xc(%rbp), %rcx
addq %rcx, %rax
movl %eax, -0x10(%rbp)
cmpl $0x10000, -0x10(%rbp)   # imm = 0x10000
jle 0x3e8e
jmp 0x3f33
movl -0x10(%rbp), %eax
movl $0x100, %ecx            # imm = 0x100
cltd
idivl %ecx
movl %eax, -0x14(%rbp)
movl -0x10(%rbp), %eax
movl $0x100, %ecx            # imm = 0x100
cltd
idivl %ecx
movl %edx, -0x18(%rbp)
leaq -0x120(%rbp), %rdi
xorl %esi, %esi
movl $0x100, %edx            # imm = 0x100
callq 0x10a0
movq -0x8(%rbp), %rax
movq 0x10(%rax), %rax
movslq -0xc(%rbp), %rcx
leaq -0x124(%rbp), %rsi
movzwl (%rax,%rcx,2), %edi
callq 0x3530
leaq -0x120(%rbp), %rsi
leaq -0x124(%rbp), %rdi
callq 0x2f90
cmpl $0x0, -0xc(%rbp)
jne 0x3f02
leaq 0x14dd(%rip), %rdi      # 0x53d6
movb $0x0, %al
callq 0x1040
jmp 0x3f10
leaq 0x14cf(%rip), %rdi      # 0x53d8
movb $0x0, %al
callq 0x1040
leaq -0x120(%rbp), %rsi
movl -0x14(%rbp), %edx
movl -0x18(%rbp), %ecx
movl -0x14(%rbp), %r8d
movl -0x18(%rbp), %r9d
leaq 0x14ae(%rip), %rdi      # 0x53da
movb $0x0, %al
callq 0x1040
movl -0xc(%rbp), %eax
addl $0x1, %eax
movl %eax, -0xc(%rbp)
jmp 0x3e56
addq $0x130, %rsp            # imm = 0x130
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/minkcv[P]vm/machine/cpu.c
// Function: print_cpu_state
void print_cpu_state(CPU *cpu)
{
    // Print program counter as segment.offset, disassembly of current instruction, and registers
    int instructionCount = cpu->pc - cpu->code;
    int instructionSegment = instructionCount / JUMP_SEGMENT_SIZE;
    int instructionOffset = instructionCount % JUMP_SEGMENT_SIZE;
    printf("PC:  %03d.%03d 0x%02X.0x%02X\n", 
	   instructionSegment, instructionOffset,
	   instructionSegment, instructionOffset);
    char assembly[256];
    memset(assembly, 0, sizeof(char) * 256);
    Instruction decoded;
    decode(*(cpu->pc), &decoded);
    disassemble(&decoded, assembly);
    printf("ASM: %s\n", assembly);
    int i;
    for (i = 0; i < REGISTER_COUNT; i++)
	printf("r%02d: %03d (0x%02X)\n", i, cpu->regs[i], cpu->regs[i]);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x130, %rsp            # imm = 0x130
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq 0x10(%rax), %rax
movq -0x8(%rbp), %rcx
movq 0x18(%rcx), %rcx
subq %rcx, %rax
sarq %rax
movl %eax, -0xc(%rbp)
movl -0xc(%rbp), %eax
movl $0x100, %ecx            # imm = 0x100
cltd
idivl %ecx
movl %eax, -0x10(%rbp)
movl -0xc(%rbp), %eax
movl $0x100, %ecx            # imm = 0x100
cltd
idivl %ecx
movl %edx, -0x14(%rbp)
movl -0x10(%rbp), %esi
movl -0x14(%rbp), %edx
movl -0x10(%rbp), %ecx
movl -0x14(%rbp), %r8d
leaq 0x1454(%rip), %rdi      # 0x53fc
movb $0x0, %al
callq 0x1040
leaq -0x120(%rbp), %rdi
xorl %esi, %esi
movl $0x100, %edx            # imm = 0x100
callq 0x10a0
movq -0x8(%rbp), %rax
movq 0x10(%rax), %rax
leaq -0x124(%rbp), %rsi
movzwl (%rax), %edi
callq 0x3530
leaq -0x120(%rbp), %rsi
leaq -0x124(%rbp), %rdi
callq 0x2f90
leaq -0x120(%rbp), %rsi
leaq 0x1420(%rip), %rdi      # 0x541a
movb $0x0, %al
callq 0x1040
movl $0x0, -0x128(%rbp)
cmpl $0x10, -0x128(%rbp)
jge 0x4057
movl -0x128(%rbp), %esi
movq -0x8(%rbp), %rax
movslq -0x128(%rbp), %rcx
movzbl (%rax,%rcx), %edx
movq -0x8(%rbp), %rax
movslq -0x128(%rbp), %rcx
movzbl (%rax,%rcx), %ecx
leaq 0x13e4(%rip), %rdi      # 0x5423
movb $0x0, %al
callq 0x1040
movl -0x128(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x128(%rbp)
jmp 0x400b
addq $0x130, %rsp            # imm = 0x130
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O0/jwang11[P]intel_avx_perf/matrix_double.c
// Function: init
void init(void) {
  srand(time(0));
  for (int i = 0; i < row; i++) {
    for (int j = 0; j < col; j++) {
      mat[i][j] = (double)(rand() % 1000) / 300.0f;
    }   
  }
  for (int j = 0; j < col; j++) {
    mutiplier[j] = (double)(rand() % 1000) / 300.0f;
  }
}

// Assembly:
subq $0x18, %rsp
xorl %eax, %eax
movl %eax, %edi
callq 0x1060
movl %eax, %edi
callq 0x1050
movl $0x0, 0x14(%rsp)
cmpl $0x40, 0x14(%rsp)
jge 0x120b
movl $0x0, 0x10(%rsp)
cmpl $0x400, 0x10(%rsp)      # imm = 0x400
jge 0x11fc
callq 0x1070
movl $0x3e8, %ecx            # imm = 0x3E8
cltd
idivl %ecx
vcvtsi2sd %edx, %xmm0, %xmm0
vmovsd 0xe3a(%rip), %xmm1      # 0x2008
vdivsd %xmm1, %xmm0, %xmm0
movslq 0x14(%rsp), %rcx
leaq 0x2e82(%rip), %rax      # 0x4060
shlq $0xd, %rcx
addq %rcx, %rax
movslq 0x10(%rsp), %rcx
vmovsd %xmm0, (%rax,%rcx,8)
movl 0x10(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x10(%rsp)
jmp 0x11ab
jmp 0x11fe
movl 0x14(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x14(%rsp)
jmp 0x119c
movl $0x0, 0xc(%rsp)
cmpl $0x400, 0xc(%rsp)       # imm = 0x400
jge 0x1258
callq 0x1070
movl $0x3e8, %ecx            # imm = 0x3E8
cltd
idivl %ecx
vcvtsi2sd %edx, %xmm0, %xmm0
vmovsd 0xdd2(%rip), %xmm1      # 0x2008
vdivsd %xmm1, %xmm0, %xmm0
movslq 0xc(%rsp), %rcx
leaq 0x82e1a(%rip), %rax     # 0x84060
vmovsd %xmm0, (%rax,%rcx,8)
movl 0xc(%rsp), %eax
addl $0x1, %eax
movl %eax, 0xc(%rsp)
jmp 0x1213
addq $0x18, %rsp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/jwang11[P]intel_avx_perf/matrix_double.c
// Function: calc_non
void calc_non(void) {
  for(int j = 0; j < row; j++) {
    double sum = 0;
    double *vec = mat[j];

    for(int i = 0; i < col; i++)
      sum += vec[i] * mutiplier[i];

    result[j] = sum;
  }
}

// Assembly:
movl $0x0, -0x4(%rsp)
cmpl $0x40, -0x4(%rsp)
jge 0x130c
vxorps %xmm0, %xmm0, %xmm0
vmovsd %xmm0, -0x10(%rsp)
movslq -0x4(%rsp), %rcx
leaq 0x2dd7(%rip), %rax      # 0x4060
shlq $0xd, %rcx
addq %rcx, %rax
movq %rax, -0x18(%rsp)
movl $0x0, -0x1c(%rsp)
cmpl $0x400, -0x1c(%rsp)     # imm = 0x400
jge 0x12e5
movq -0x18(%rsp), %rax
movslq -0x1c(%rsp), %rcx
vmovsd (%rax,%rcx,8), %xmm1
movslq -0x1c(%rsp), %rcx
leaq 0x82d9e(%rip), %rax     # 0x84060
vmovsd (%rax,%rcx,8), %xmm0
vmovsd -0x10(%rsp), %xmm2
vfmadd213sd %xmm2, %xmm1, %xmm0 # xmm0 = (xmm1 * xmm0) + xmm2
vmovsd %xmm0, -0x10(%rsp)
movl -0x1c(%rsp), %eax
addl $0x1, %eax
movl %eax, -0x1c(%rsp)
jmp 0x129d
vmovsd -0x10(%rsp), %xmm0
movslq -0x4(%rsp), %rcx
leaq 0x84d69(%rip), %rax     # 0x86060
vmovsd %xmm0, (%rax,%rcx,8)
movl -0x4(%rsp), %eax
addl $0x1, %eax
movl %eax, -0x4(%rsp)
jmp 0x1268
retq
nopl (%rax)