LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O0/ughman[P]c2c/src/bios.c
// Function: BIOS_MemChr
uint32_t BIOS_MemChr(uint32_t str,uint8_t value,uint32_t len)
{
	for (uint32_t i = 0;i < len;i++)
	{
		if (EMU_ReadU8(str + i) == value)
			return str + i;
	}
	return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movb %sil, %al
movl %edi, -0x8(%rbp)
movb %al, -0x9(%rbp)
movl %edx, -0x10(%rbp)
movl $0x0, -0x14(%rbp)
movl -0x14(%rbp), %eax
cmpl -0x10(%rbp), %eax
jae 0x3197e1
movl -0x8(%rbp), %edi
addl -0x14(%rbp), %edi
callq 0x31a7b0
movzbl %al, %eax
movzbl -0x9(%rbp), %ecx
cmpl %ecx, %eax
jne 0x3197d4
movl -0x8(%rbp), %eax
addl -0x14(%rbp), %eax
movl %eax, -0x4(%rbp)
jmp 0x3197e8
jmp 0x3197d6
movl -0x14(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x14(%rbp)
jmp 0x3197ab
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/ughman[P]c2c/src/bios.c
// Function: BIOS_DeliverEvent
void BIOS_DeliverEvent(uint32_t evclass,uint32_t spec)
{
	for (int i = 0;i < BIOS_MAXEVENTS;i++)
	{
		struct biosevent *event = &events[i];
		if (!event->enabled)
			continue;
		if (event->evclass != evclass)
			continue;
		if (event->spec != spec)
			continue;
		if (event->mode == 0x1000)
			EMU_Invoke(event->func,0);
		else
			event->busy = 0;
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movl %edi, -0x4(%rbp)
movl %esi, -0x8(%rbp)
movl $0x0, -0xc(%rbp)
cmpl $0x10, -0xc(%rbp)
jge 0x319890
movslq -0xc(%rbp), %rcx
leaq 0xcf0a(%rip), %rax      # 0x326730
imulq $0x1c, %rcx, %rcx
addq %rcx, %rax
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rax
cmpl $0x0, 0x4(%rax)
jne 0x31983d
jmp 0x319885
movq -0x18(%rbp), %rax
movl 0xc(%rax), %eax
cmpl -0x4(%rbp), %eax
je 0x31984b
jmp 0x319885
movq -0x18(%rbp), %rax
movl 0x10(%rax), %eax
cmpl -0x8(%rbp), %eax
je 0x319859
jmp 0x319885
movq -0x18(%rbp), %rax
cmpl $0x1000, 0x14(%rax)     # imm = 0x1000
jne 0x319878
movq -0x18(%rbp), %rax
movl 0x18(%rax), %edi
xorl %esi, %esi
movb $0x0, %al
callq 0x31dad0
jmp 0x319883
movq -0x18(%rbp), %rax
movl $0x0, 0x8(%rax)
jmp 0x319885
movl -0xc(%rbp), %eax
addl $0x1, %eax
movl %eax, -0xc(%rbp)
jmp 0x319815
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/ughman[P]c2c/src/bios.c
// Function: BIOS_OpenEvent
uint32_t BIOS_OpenEvent(uint32_t evclass,uint32_t spec,uint32_t mode,uint32_t func)
{
	for (int i = 0;i < BIOS_MAXEVENTS;i++)
	{
		struct biosevent *event = &events[i];
		if (!event->allocated)
		{
			event->allocated = 1;
			event->busy = 1;
			event->evclass = evclass;
			event->spec = spec;
			event->mode = mode;
			event->func = func;
			return i;
		}
	}
	abort();
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movl %edi, -0x4(%rbp)
movl %esi, -0x8(%rbp)
movl %edx, -0xc(%rbp)
movl %ecx, -0x10(%rbp)
movl $0x0, -0x14(%rbp)
cmpl $0x10, -0x14(%rbp)
jge 0x319933
movslq -0x14(%rbp), %rcx
leaq 0xce64(%rip), %rax      # 0x326730
imulq $0x1c, %rcx, %rcx
addq %rcx, %rax
movq %rax, -0x20(%rbp)
movq -0x20(%rbp), %rax
cmpl $0x0, (%rax)
jne 0x319926
movq -0x20(%rbp), %rax
movl $0x1, (%rax)
movq -0x20(%rbp), %rax
movl $0x1, 0x8(%rax)
movl -0x4(%rbp), %ecx
movq -0x20(%rbp), %rax
movl %ecx, 0xc(%rax)
movl -0x8(%rbp), %ecx
movq -0x20(%rbp), %rax
movl %ecx, 0x10(%rax)
movl -0xc(%rbp), %ecx
movq -0x20(%rbp), %rax
movl %ecx, 0x14(%rax)
movl -0x10(%rbp), %ecx
movq -0x20(%rbp), %rax
movl %ecx, 0x18(%rax)
movl -0x14(%rbp), %eax
addq $0x20, %rsp
popq %rbp
retq
jmp 0x319928
movl -0x14(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x14(%rbp)
jmp 0x3198bb
callq 0x1070
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/ughman[P]c2c/src/bios.c
// Function: BIOS_TestEvent
int BIOS_TestEvent(uint32_t event)
{
	if (event >= BIOS_MAXEVENTS)
		abort();
	if (!events[event].enabled)
		return 0;
	if (events[event].busy)
		return 0;
	events[event].busy = 1;
	return 1;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movl %edi, -0x8(%rbp)
cmpl $0x10, -0x8(%rbp)
jb 0x319956
callq 0x1070
movl -0x8(%rbp), %eax
movl %eax, %ecx
leaq 0xcdce(%rip), %rax      # 0x326730
imulq $0x1c, %rcx, %rcx
addq %rcx, %rax
cmpl $0x0, 0x4(%rax)
jne 0x319978
movl $0x0, -0x4(%rbp)
jmp 0x3199bb
movl -0x8(%rbp), %eax
movl %eax, %ecx
leaq 0xcdac(%rip), %rax      # 0x326730
imulq $0x1c, %rcx, %rcx
addq %rcx, %rax
cmpl $0x0, 0x8(%rax)
je 0x31999a
movl $0x0, -0x4(%rbp)
jmp 0x3199bb
movl -0x8(%rbp), %eax
movl %eax, %ecx
leaq 0xcd8a(%rip), %rax      # 0x326730
imulq $0x1c, %rcx, %rcx
addq %rcx, %rax
movl $0x1, 0x8(%rax)
movl $0x1, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/ughman[P]c2c/src/bios.c
// Function: BIOS_EnableEvent
int BIOS_EnableEvent(uint32_t event)
{
	if (event >= BIOS_MAXEVENTS)
		abort();
	events[event].enabled = 1;
	return 1;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movl %edi, -0x4(%rbp)
cmpl $0x10, -0x4(%rbp)
jb 0x3199e6
callq 0x1070
movl -0x4(%rbp), %eax
movl %eax, %ecx
leaq 0xcd3e(%rip), %rax      # 0x326730
imulq $0x1c, %rcx, %rcx
addq %rcx, %rax
movl $0x1, 0x4(%rax)
movl $0x1, %eax
addq $0x10, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/ughman[P]c2c/src/emu.c
// Function: EMU_Init
void EMU_Init(void)
{
	extern void ZZ_Init(void);
	PCSX_Init();
	EMU_codemap[0x28] = BIOS_Execute;
	EMU_codemap[0x2C] = BIOS_Execute;
	EMU_codemap[0x30] = BIOS_Execute;
	EMU_codemap[0x221] = EMU_DummyMethod;
	for (int i = 0;i < EMU_RAMWORDS;i++)
	{
		if (!EMU_codemap[i])
			EMU_codemap[i] = EMU_ExecuteUnrecognizedCode;
	}
	ZZ_Init();
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
callq 0x31a060
leaq -0xcf4(%rip), %rax      # 0x319a10
movq %rax, 0xc415(%rip)      # 0x326b20
leaq -0xd02(%rip), %rax      # 0x319a10
movq %rax, 0xc427(%rip)      # 0x326b40
leaq -0xd10(%rip), %rax      # 0x319a10
movq %rax, 0xc439(%rip)      # 0x326b60
leaq -0x5e(%rip), %rax       # 0x31a6d0
movq %rax, 0xd3b3(%rip)      # 0x327ae8
movl $0x0, -0x4(%rbp)
cmpl $0x80000, -0x4(%rbp)    # imm = 0x80000
jge 0x31a77a
movslq -0x4(%rbp), %rcx
leaq 0xc290(%rip), %rax      # 0x3269e0
cmpq $0x0, (%rax,%rcx,8)
jne 0x31a76d
movslq -0x4(%rbp), %rcx
leaq 0xc27e(%rip), %rax      # 0x3269e0
leaq -0xf9(%rip), %rdx       # 0x31a670
movq %rdx, (%rax,%rcx,8)
jmp 0x31a76f
movl -0x4(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x4(%rbp)
jmp 0x31a73c
callq 0x1490
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/ughman[P]c2c/src/emu.c
// Function: EMU_WriteLeft
void EMU_WriteLeft(uint32_t address,uint32_t value)
{
	static uint32_t mask[4] = {0xFFFFFF00,0xFFFF0000,0xFF000000,0};
	static int shift[4] = {24,16,8,0};
	uint32_t memvalue = EMU_ReadU32(address & ~3);
	memvalue &= mask[address & 3];
	memvalue |= value >> shift[address & 3];
	EMU_Write32(address & ~3,memvalue);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movl %edi, -0x4(%rbp)
movl %esi, -0x8(%rbp)
movl -0x4(%rbp), %edi
andl $-0x4, %edi
callq 0x31bba0
movl %eax, -0xc(%rbp)
movl -0x4(%rbp), %eax
andl $0x3, %eax
movl %eax, %eax
movl %eax, %ecx
leaq 0x8883(%rip), %rax      # 0x3260e0
movl (%rax,%rcx,4), %eax
andl -0xc(%rbp), %eax
movl %eax, -0xc(%rbp)
movl -0x8(%rbp), %eax
movl -0x4(%rbp), %ecx
andl $0x3, %ecx
movl %ecx, %ecx
movl %ecx, %edx
leaq 0x8876(%rip), %rcx      # 0x3260f0
movl (%rcx,%rdx,4), %ecx
shrl %cl, %eax
orl -0xc(%rbp), %eax
movl %eax, -0xc(%rbp)
movl -0x4(%rbp), %edi
andl $-0x4, %edi
movl -0xc(%rbp), %esi
callq 0x31d3f0
addq $0x10, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/ughman[P]c2c/src/emu.c
// Function: EMU_WriteRight
void EMU_WriteRight(uint32_t address,uint32_t value)
{
	static uint32_t mask[4] = {0,0xFF,0xFFFF,0xFFFFFF};
	static int shift[4] = {0,8,16,24};
	uint32_t memvalue = EMU_ReadU32(address & ~3);
	memvalue &= mask[address & 3];
	memvalue |= value << shift[address & 3];
	EMU_Write32(address & ~3,memvalue);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movl %edi, -0x4(%rbp)
movl %esi, -0x8(%rbp)
movl -0x4(%rbp), %edi
andl $-0x4, %edi
callq 0x31bba0
movl %eax, -0xc(%rbp)
movl -0x4(%rbp), %eax
andl $0x3, %eax
movl %eax, %eax
movl %eax, %ecx
leaq 0x8833(%rip), %rax      # 0x326100
movl (%rax,%rcx,4), %eax
andl -0xc(%rbp), %eax
movl %eax, -0xc(%rbp)
movl -0x8(%rbp), %eax
movl -0x4(%rbp), %ecx
andl $0x3, %ecx
movl %ecx, %ecx
movl %ecx, %edx
leaq 0x8826(%rip), %rcx      # 0x326110
movl (%rcx,%rdx,4), %ecx
shll %cl, %eax
orl -0xc(%rbp), %eax
movl %eax, -0xc(%rbp)
movl -0x4(%rbp), %edi
andl $-0x4, %edi
movl -0xc(%rbp), %esi
callq 0x31d3f0
addq $0x10, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/ughman[P]c2c/src/emu.c
// Function: EMU_SDivide
void EMU_SDivide(int32_t a,int32_t b)
{
	if (b)
	{
		LO = a / b;
		HI = a % b;
	}
	else
	{
		LO = 0xFFFFFFFF;
		HI = a;
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movl %edi, -0x4(%rbp)
movl %esi, -0x8(%rbp)
cmpl $0x0, -0x8(%rbp)
je 0x31da3c
movl -0x4(%rbp), %eax
cltd
idivl -0x8(%rbp)
movl %eax, %ecx
movq 0x8fb0(%rip), %rax      # 0x3269d0
movl %ecx, 0x80(%rax)
movl -0x4(%rbp), %eax
cltd
idivl -0x8(%rbp)
movq 0x8f9c(%rip), %rax      # 0x3269d0
movl %edx, 0x84(%rax)
jmp 0x31da5d
movq 0x8f8d(%rip), %rax      # 0x3269d0
movl $0xffffffff, 0x80(%rax) # imm = 0xFFFFFFFF
movl -0x4(%rbp), %ecx
movq 0x8f79(%rip), %rax      # 0x3269d0
movl %ecx, 0x84(%rax)
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/ughman[P]c2c/src/emu.c
// Function: EMU_UDivide
void EMU_UDivide(uint32_t a,uint32_t b)
{
	if (b)
	{
		LO = a / b;
		HI = a % b;
	}
	else
	{
		LO = 0xFFFFFFFF;
		HI = a;
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movl %edi, -0x4(%rbp)
movl %esi, -0x8(%rbp)
cmpl $0x0, -0x8(%rbp)
je 0x31da9e
movl -0x4(%rbp), %eax
xorl %edx, %edx
divl -0x8(%rbp)
movl %eax, %ecx
movq 0x8f4f(%rip), %rax      # 0x3269d0
movl %ecx, 0x80(%rax)
movl -0x4(%rbp), %eax
xorl %edx, %edx
divl -0x8(%rbp)
movq 0x8f3a(%rip), %rax      # 0x3269d0
movl %edx, 0x84(%rax)
jmp 0x31dabf
movq 0x8f2b(%rip), %rax      # 0x3269d0
movl $0xffffffff, 0x80(%rax) # imm = 0xFFFFFFFF
movl -0x4(%rbp), %ecx
movq 0x8f17(%rip), %rax      # 0x3269d0
movl %ecx, 0x84(%rax)
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/ughman[P]c2c/src/emu.c
// Function: EMU_NativeCall
void EMU_NativeCall(void *method)
{
	static uint32_t stackbuffer[16];
	memcpy(stackbuffer,(uint8_t *)EMU_ram + (SP & 0x1FFFFF),sizeof(stackbuffer));
	stackbuffer[0] = A0;
	stackbuffer[1] = A1;
	stackbuffer[2] = A2;
	stackbuffer[3] = A3;
	__asm__
	(
		"movl %2,%%ecx;"
		"subl %%ecx,%%esp;"
		"shr $2,%%ecx;"
		"movl %%esp,%%edi;"
		"rep movsd;"
		"call *%1;"
		"addl %2,%%esp;"
		: "=a"(V0)
		: "m"(method),"i"(sizeof(stackbuffer)),"S"(stackbuffer)
		: "%ecx","%edx","%edi","flags","memory"
	);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq 0x408b0d(%rip), %rsi    # 0x7269e0
movq 0x8af6(%rip), %rax      # 0x3269d0
movl 0x74(%rax), %eax
andl $0x1fffff, %eax         # imm = 0x1FFFFF
movl %eax, %eax
addq %rax, %rsi
leaq 0x408b02(%rip), %rdi    # 0x7269f0
movl $0x40, %edx
callq 0x10a0
movq 0x8ad1(%rip), %rax      # 0x3269d0
movl 0x10(%rax), %eax
movl %eax, 0x408ae8(%rip)    # 0x7269f0
movq 0x8ac1(%rip), %rax      # 0x3269d0
movl 0x14(%rax), %eax
movl %eax, 0x408adc(%rip)    # 0x7269f4
movq 0x8ab1(%rip), %rax      # 0x3269d0
movl 0x18(%rax), %eax
movl %eax, 0x408ad0(%rip)    # 0x7269f8
movq 0x8aa1(%rip), %rax      # 0x3269d0
movl 0x1c(%rax), %eax
movl %eax, 0x408ac4(%rip)    # 0x7269fc
movq 0x8a91(%rip), %rax      # 0x3269d0
movq %rax, -0x10(%rbp)
leaq 0x408aa6(%rip), %rsi    # 0x7269f0
movl $0x40, %ecx
subl %ecx, %esp
shrl $0x2, %ecx
movl %esp, %edi
rep  movsl (%rsi), %es:(%rdi)
callq *-0x8(%rbp)
addl $0x40, %esp
movl %eax, %ecx
movq -0x10(%rbp), %rax
movl %ecx, 0x8(%rax)
addq $0x10, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/ughman[P]c2c/src/emu.c
// Function: EMU_RunInterrupts
void EMU_RunInterrupts(void)
{
	uint32_t pc = PCSX_RunInterrupts(0xDEADBEEF);
	while (pc != 0xDEADBEEF)
	{
		if (pc & 3)
			SDL_LogError(LOG_EMU,"Program counter is unaligned");
		pc = EMU_codemap[(pc & 0x1FFFFF) >> 2](pc);
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movl $0xdeadbeef, %edi       # imm = 0xDEADBEEF
leaq 0x89c4(%rip), %rax      # 0x326968
callq *(%rax)
movl %eax, -0x4(%rbp)
cmpl $0xdeadbeef, -0x4(%rbp) # imm = 0xDEADBEEF
je 0x31dff4
movl -0x4(%rbp), %eax
andl $0x3, %eax
cmpl $0x0, %eax
je 0x31dfd0
movl $0x13, %edi
leaq 0x4823(%rip), %rsi      # 0x3227ec
movb $0x0, %al
callq 0x10d0
movl -0x4(%rbp), %eax
andl $0x1fffff, %eax         # imm = 0x1FFFFF
shrl $0x2, %eax
movl %eax, %eax
movl %eax, %ecx
leaq 0x89fa(%rip), %rax      # 0x3269e0
movq (%rax,%rcx,8), %rax
movl -0x4(%rbp), %edi
callq *%rax
movl %eax, -0x4(%rbp)
jmp 0x31dfa9
addq $0x10, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/ughman[P]c2c/src/gool_mips.cc
// Function: GOOL_MIPS_ExecuteOnce(goolenv*, unsigned int)
void GOOL_MIPS_ExecuteOnce(struct goolenv *env,uint32_t instruction)
{
	goolexechandler_t handler = GOOL_mips_table[M_OPCODE];
	if (!handler)
		handler = GOOL_MIPS_OP_Invalid;
	handler(env,instruction);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movl -0xc(%rbp), %eax
shrl $0x1a, %eax
andl $0x3f, %eax
movl %eax, %eax
movl %eax, %ecx
leaq 0x776d(%rip), %rax      # 0x326120
movq (%rax,%rcx,8), %rax
movq %rax, -0x18(%rbp)
cmpq $0x0, -0x18(%rbp)
jne 0x31e9cd
leaq 0x17(%rip), %rax        # 0x31e9e0
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rax
movq -0x8(%rbp), %rdi
movl -0xc(%rbp), %esi
callq *%rax
addq $0x20, %rsp
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O0/ughman[P]c2c/src/gool_mips.cc
// Function: GOOL_MIPS_ExecuteFromZZ
void GOOL_MIPS_ExecuteFromZZ(uint32_t pc)
{
	struct goolenv env;
	env.pc = pc;
	env.pcfar = pc + 4;
	env.language = env.languagefar = GOOL_LANGUAGE_MIPS;
	RA = 0xDEADBEEF;
	while (env.pc != 0xDEADBEEF)
	{
		uint32_t instruction = EMU_ReadU32(env.pc);
		env.oldpc = env.pc;
		env.pc = env.pcfar;
		env.pcfar = env.pcfar + 4;
		env.language = env.languagefar;
		GOOL_MIPS_ExecuteOnce(&env,instruction);
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movl %edi, -0x4(%rbp)
movl -0x4(%rbp), %eax
movl %eax, -0x14(%rbp)
movl -0x4(%rbp), %eax
addl $0x4, %eax
movl %eax, -0x10(%rbp)
movl $0x1, -0x8(%rbp)
movl $0x1, -0xc(%rbp)
leaq 0x7f81(%rip), %rax      # 0x3269d0
movq (%rax), %rax
movl $0xdeadbeef, 0x7c(%rax) # imm = 0xDEADBEEF
cmpl $0xdeadbeef, -0x14(%rbp) # imm = 0xDEADBEEF
je 0x31ea96
movl -0x14(%rbp), %edi
callq 0x31bba0
movl %eax, -0x1c(%rbp)
movl -0x14(%rbp), %eax
movl %eax, -0x18(%rbp)
movl -0x10(%rbp), %eax
movl %eax, -0x14(%rbp)
movl -0x10(%rbp), %eax
addl $0x4, %eax
movl %eax, -0x10(%rbp)
movl -0x8(%rbp), %eax
movl %eax, -0xc(%rbp)
movl -0x1c(%rbp), %esi
leaq -0x18(%rbp), %rdi
callq 0x31e990
jmp 0x31ea59
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/ughman[P]c2c/src/gool_mips.cc
// Function: GOOL_MIPS_OP_Special(goolenv*, unsigned int)
static void GOOL_MIPS_OP_Special(struct goolenv *env,uint32_t instruction)
{
	goolexechandler_t handler = GOOL_mips_table_special[M_FUNCT];
	if (!handler)
		handler = GOOL_MIPS_OP_Invalid;
	handler(env,instruction);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movl -0xc(%rbp), %eax
andl $0x3f, %eax
movl %eax, %eax
movl %eax, %ecx
leaq 0x7860(%rip), %rax      # 0x326320
movq (%rax,%rcx,8), %rax
movq %rax, -0x18(%rbp)
cmpq $0x0, -0x18(%rbp)
jne 0x31eada
leaq -0xf6(%rip), %rax       # 0x31e9e0
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rax
movq -0x8(%rbp), %rdi
movl -0xc(%rbp), %esi
callq *%rax
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/ughman[P]c2c/src/gool_mips.cc
// Function: GOOL_MIPS_OP_RegImm(goolenv*, unsigned int)
static void GOOL_MIPS_OP_RegImm(struct goolenv *env,uint32_t instruction)
{
	goolexechandler_t handler = GOOL_mips_table_regimm[M_RT_NUM];
	if (!handler)
		handler = GOOL_MIPS_OP_Invalid;
	handler(env,instruction);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movl -0xc(%rbp), %eax
shrl $0x10, %eax
andl $0x1f, %eax
movl %eax, %eax
movl %eax, %ecx
leaq 0x7a0d(%rip), %rax      # 0x326520
movq (%rax,%rcx,8), %rax
movq %rax, -0x18(%rbp)
cmpq $0x0, -0x18(%rbp)
jne 0x31eb2d
leaq -0x149(%rip), %rax      # 0x31e9e0
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rax
movq -0x8(%rbp), %rdi
movl -0xc(%rbp), %esi
callq *%rax
addq $0x20, %rsp
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O0/ughman[P]c2c/src/ns.cc
// Function: NS_1254C
int32_t NS_1254C(emuptr<struct nspage> nspage)
{
	if (nspage->type == 0x1)
	{
		return -255;
	}
	if (nspage->magic != 0x1234)
	{
		return -18;
	}
	for (int32_t i = nspage->entrycount - 1;i >= 0;i--)
	{
		*(uint32_t *)&nspage->entries[i] += (uint32_t)nspage;
		for (int32_t ii = nspage->entries[i]->itemcount;ii >= 0;ii--)
		{
			*(uint32_t *)&nspage->entries[i]->items[ii] += (uint32_t)nspage->entries[i];
		}
	}
	*(uint32_t *)&nspage->entries[nspage->entrycount] += (uint32_t)nspage;
	return -255;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movl %edi, -0x8(%rbp)
leaq -0x8(%rbp), %rdi
callq 0x31ffd0
movzwl 0x2(%rax), %eax
cmpl $0x1, %eax
jne 0x31f8d9
movl $0xffffff01, -0x4(%rbp) # imm = 0xFFFFFF01
jmp 0x31fa10
leaq -0x8(%rbp), %rdi
callq 0x31ffd0
movzwl (%rax), %eax
cmpl $0x1234, %eax           # imm = 0x1234
je 0x31f8f8
movl $0xffffffee, -0x4(%rbp) # imm = 0xFFFFFFEE
jmp 0x31fa10
leaq -0x8(%rbp), %rdi
callq 0x31ffd0
movl 0x8(%rax), %eax
subl $0x1, %eax
movl %eax, -0xc(%rbp)
cmpl $0x0, -0xc(%rbp)
jl 0x31f9d1
leaq -0x8(%rbp), %rdi
callq 0x31fff0
movl %eax, -0x14(%rbp)
leaq -0x8(%rbp), %rdi
callq 0x31ffd0
movl -0x14(%rbp), %edx
movslq -0xc(%rbp), %rcx
addl 0x10(%rax,%rcx,4), %edx
movl %edx, 0x10(%rax,%rcx,4)
leaq -0x8(%rbp), %rdi
callq 0x31ffd0
movq %rax, %rdi
addq $0x10, %rdi
movslq -0xc(%rbp), %rax
shlq $0x2, %rax
addq %rax, %rdi
callq 0x320000
movl 0xc(%rax), %eax
movl %eax, -0x10(%rbp)
cmpl $0x0, -0x10(%rbp)
jl 0x31f9c1
leaq -0x8(%rbp), %rdi
callq 0x31ffd0
movq %rax, %rdi
addq $0x10, %rdi
movslq -0xc(%rbp), %rax
shlq $0x2, %rax
addq %rax, %rdi
callq 0x320020
movl %eax, -0x18(%rbp)
leaq -0x8(%rbp), %rdi
callq 0x31ffd0
movq %rax, %rdi
addq $0x10, %rdi
movslq -0xc(%rbp), %rax
shlq $0x2, %rax
addq %rax, %rdi
callq 0x320000
movl -0x18(%rbp), %edx
movslq -0x10(%rbp), %rcx
addl 0x10(%rax,%rcx,4), %edx
movl %edx, 0x10(%rax,%rcx,4)
movl -0x10(%rbp), %eax
addl $-0x1, %eax
movl %eax, -0x10(%rbp)
jmp 0x31f95e
jmp 0x31f9c3
movl -0xc(%rbp), %eax
addl $-0x1, %eax
movl %eax, -0xc(%rbp)
jmp 0x31f90a
leaq -0x8(%rbp), %rdi
callq 0x31fff0
movl %eax, -0x24(%rbp)
leaq -0x8(%rbp), %rdi
callq 0x31ffd0
movq %rax, -0x20(%rbp)
leaq -0x8(%rbp), %rdi
callq 0x31ffd0
movl -0x24(%rbp), %edx
movq %rax, %rcx
movq -0x20(%rbp), %rax
movslq 0x8(%rcx), %rcx
addl 0x10(%rax,%rcx,4), %edx
movl %edx, 0x10(%rax,%rcx,4)
movl $0xffffff01, -0x4(%rbp) # imm = 0xFFFFFF01
movl -0x4(%rbp), %eax
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/ughman[P]c2c/src/core.cc
// Function: CORE_Main
int CORE_Main(void)
{
	EMU_Invoke(0x80049E6C,0);
	EMU_Write32(0x8005F43C,1);
	EMU_Invoke(0x80015738,0);
	CORE_Loop(0x3C);
	EMU_Invoke(0x800158C4,0);
	return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movl $0x80049e6c, %edi       # imm = 0x80049E6C
xorl %esi, %esi
movb $0x0, %al
callq 0x31dad0
movl $0x8005f43c, %edi       # imm = 0x8005F43C
movl $0x1, %esi
callq 0x31d3f0
movl $0x80015738, %edi       # imm = 0x80015738
xorl %esi, %esi
movb $0x0, %al
callq 0x31dad0
movl $0x3c, %edi
callq 0x320210
movl $0x800158c4, %edi       # imm = 0x800158C4
xorl %esi, %esi
movb $0x0, %al
callq 0x31dad0
xorl %eax, %eax
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/ughman[P]c2c/src/core.cc
// Function: CORE_Start
void CORE_Start(void)
{
	for (uint32_t i = 0x8005F53C;i < 0x8006F488;i += 4)
	{
		EMU_Write32(i,0);
	}
	V0 = EMU_ReadU32(0x8005F420);
	V0 = EMU_CheckedAdd(V0,-8);
	SP = V0 | 0x80000000;
	A1 = V0 - EMU_ReadU32(0x8005F41C) - 0x6F488;
	EMU_Write32(0x8005CDC4,A1);
	EMU_Write32(0x8005CDC0,0x8006F488);
	EMU_Write32(0x8005F5B8,RA); // $RA is garbage here
	GP = 0x8005F414;
	FP = SP;
	EMU_Invoke(0x8001144C,2,0x8006F48C,A1);
	CORE_Main();
	EMU_Break(1);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movl $0x8005f53c, -0x4(%rbp) # imm = 0x8005F53C
cmpl $0x8006f488, -0x4(%rbp) # imm = 0x8006F488
jae 0x3211dd
movl -0x4(%rbp), %edi
xorl %esi, %esi
callq 0x31d3f0
movl -0x4(%rbp), %eax
addl $0x4, %eax
movl %eax, -0x4(%rbp)
jmp 0x3211bf
movl $0x8005f420, %edi       # imm = 0x8005F420
callq 0x31bba0
movl %eax, %ecx
leaq 0x57e0(%rip), %rax      # 0x3269d0
movq (%rax), %rax
movl %ecx, 0x8(%rax)
leaq 0x57d3(%rip), %rax      # 0x3269d0
movq (%rax), %rax
movl 0x8(%rax), %ecx
addl $-0x8, %ecx
leaq 0x57c3(%rip), %rax      # 0x3269d0
movq (%rax), %rax
movl %ecx, 0x8(%rax)
leaq 0x57b6(%rip), %rax      # 0x3269d0
movq (%rax), %rax
movl 0x8(%rax), %ecx
orl $0x80000000, %ecx       # imm = 0x80000000
leaq 0x57a3(%rip), %rax      # 0x3269d0
movq (%rax), %rax
movl %ecx, 0x74(%rax)
leaq 0x5796(%rip), %rax      # 0x3269d0
movq (%rax), %rax
movl 0x8(%rax), %eax
movl %eax, -0x8(%rbp)
movl $0x8005f41c, %edi       # imm = 0x8005F41C
callq 0x31bba0
movl -0x8(%rbp), %ecx
subl %eax, %ecx
subl $0x6f488, %ecx          # imm = 0x6F488
leaq 0x5771(%rip), %rax      # 0x3269d0
movq (%rax), %rax
movl %ecx, 0x14(%rax)
leaq 0x5764(%rip), %rax      # 0x3269d0
movq (%rax), %rax
movl 0x14(%rax), %esi
movl $0x8005cdc4, %edi       # imm = 0x8005CDC4
callq 0x31d3f0
movl $0x8005cdc0, %edi       # imm = 0x8005CDC0
movl $0x8006f488, %esi       # imm = 0x8006F488
callq 0x31d3f0
leaq 0x573e(%rip), %rax      # 0x3269d0
movq (%rax), %rax
movl 0x7c(%rax), %esi
movl $0x8005f5b8, %edi       # imm = 0x8005F5B8
callq 0x31d3f0
leaq 0x5727(%rip), %rax      # 0x3269d0
movq (%rax), %rax
movl $0x8005f414, 0x70(%rax) # imm = 0x8005F414
leaq 0x5716(%rip), %rax      # 0x3269d0
movq (%rax), %rax
movl 0x74(%rax), %ecx
leaq 0x5709(%rip), %rax      # 0x3269d0
movq (%rax), %rax
movl %ecx, 0x78(%rax)
leaq 0x56fc(%rip), %rax      # 0x3269d0
movq (%rax), %rax
movl 0x14(%rax), %ecx
movl $0x8001144c, %edi       # imm = 0x8001144C
movl $0x2, %esi
movl $0x8006f48c, %edx       # imm = 0x8006F48C
movb $0x0, %al
callq 0x31dad0
callq 0x3201c0
movl $0x1, %edi
callq 0x31deb0
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/ughman[P]c2c/src/core.cc
// Function: CORE_VSync
void CORE_VSync(int32_t count,int32_t timeout)
{
	timeout <<= 15;
	while ((int32_t)EMU_ReadU32(0x8005DF30) < count)
	{
		if (!timeout--)
		{
			EMU_Invoke(0x80049424,1,0x80010CE0);
			EMU_Invoke(0x8004A054,1,0);
			EMU_Invoke(0x8004A900,2,3,0);
			break;
		}
		EMU_Cycle(20);
		EMU_RunInterrupts();
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movl %edi, -0x4(%rbp)
movl %esi, -0x8(%rbp)
movl -0x8(%rbp), %eax
shll $0xf, %eax
movl %eax, -0x8(%rbp)
movl $0x8005df30, %edi       # imm = 0x8005DF30
callq 0x31bba0
cmpl -0x4(%rbp), %eax
jge 0x32139a
movl -0x8(%rbp), %eax
movl %eax, %ecx
addl $-0x1, %ecx
movl %ecx, -0x8(%rbp)
cmpl $0x0, %eax
jne 0x321389
movl $0x80049424, %edi       # imm = 0x80049424
movl $0x1, %esi
movl $0x80010ce0, %edx       # imm = 0x80010CE0
movb $0x0, %al
callq 0x31dad0
movl $0x8004a054, %edi       # imm = 0x8004A054
movl $0x1, %esi
xorl %edx, %edx
movb $0x0, %al
callq 0x31dad0
movl $0x8004a900, %edi       # imm = 0x8004A900
movl $0x2, %esi
movl $0x3, %edx
xorl %ecx, %ecx
movb $0x0, %al
callq 0x31dad0
jmp 0x32139a
movl $0x14, %edi
callq 0x31df70
callq 0x31df90
jmp 0x321327
addq $0x10, %rsp
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O0/ohkimur[P]the-c-programming-language-2nd-edition-solutions/chapter_2/exercise_2_07/invert.c
// Function: invert
unsigned int invert(int x, int p, int n)
{
  ++p; // First position is 0

  unsigned int mask1 = ~(~0 << n) << p;
  unsigned int mask2 = ~mask1 & x;

  return mask2 | ~x;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movl %edi, -0x4(%rbp)
movl %esi, -0x8(%rbp)
movl %edx, -0xc(%rbp)
movl -0x8(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x8(%rbp)
movl -0xc(%rbp), %ecx
movl $0xffffffff, %eax       # imm = 0xFFFFFFFF
shll %cl, %eax
xorl $-0x1, %eax
movl -0x8(%rbp), %ecx
shll %cl, %eax
movl %eax, -0x10(%rbp)
movl -0x10(%rbp), %eax
xorl $-0x1, %eax
andl -0x4(%rbp), %eax
movl %eax, -0x14(%rbp)
movl -0x14(%rbp), %eax
movl -0x4(%rbp), %ecx
xorl $-0x1, %ecx
orl %ecx, %eax
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O0/cinemast[P]sudoku/sudoku.c
// Function: findmoves
static
int
findmoves (void)
{
    int el;

    idx_possible = 0;
    for (el = 0; el < 9; ++el) {
        if (-1 == singles(el, idx_row, HINT_ROW)        ||
            -1 == singles(el, idx_column, HINT_COLUMN)  ||
            -1 == singles(el, idx_block, HINT_BLOCK)) {
            return -1;
        }
    }
    return idx_possible;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movl $0x0, 0xfdfe(%rip)      # 0x12470
movl $0x0, -0x8(%rbp)
cmpl $0x9, -0x8(%rbp)
jge 0x26f2
movl -0x8(%rbp), %edi
leaq 0xf7(%rip), %rsi        # 0x2780
movl $0x1000000, %edx        # imm = 0x1000000
callq 0x5750
movl %eax, %ecx
movl $0xffffffff, %eax       # imm = 0xFFFFFFFF
cmpl %ecx, %eax
je 0x26dc
movl -0x8(%rbp), %edi
leaq 0x2c8(%rip), %rsi       # 0x2970
movl $0x2000000, %edx        # imm = 0x2000000
callq 0x5750
movl %eax, %ecx
movl $0xffffffff, %eax       # imm = 0xFFFFFFFF
cmpl %ecx, %eax
je 0x26dc
movl -0x8(%rbp), %edi
leaq 0x2c9(%rip), %rsi       # 0x2990
movl $0x4000000, %edx        # imm = 0x4000000
callq 0x5750
movl %eax, %ecx
movl $0xffffffff, %eax       # imm = 0xFFFFFFFF
cmpl %ecx, %eax
jne 0x26e5
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
jmp 0x26fb
jmp 0x26e7
movl -0x8(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x8(%rbp)
jmp 0x2679
movl 0xfd78(%rip), %eax      # 0x12470
movl %eax, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/cinemast[P]sudoku/sudoku.c
// Function: count_set_digits
static
void
count_set_digits (int el, int (*idx_fn)(int, int))
{
    int i;
    memset(counts, 0x00, sizeof(counts));
    for (i = 0; i < 9; ++i) {
        digits[i] = numset(board[(*idx_fn)(el, i)]);
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movl %edi, -0x4(%rbp)
movq %rsi, -0x10(%rbp)
leaq 0xfd5a(%rip), %rdi      # 0x12480
xorl %esi, %esi
movl $0x24, %edx
callq 0x2180
movl $0x0, -0x14(%rbp)
cmpl $0x9, -0x14(%rbp)
jge 0x2778
movq -0x10(%rbp), %rax
movl -0x4(%rbp), %edi
movl -0x14(%rbp), %esi
callq *%rax
movslq %eax, %rcx
leaq 0xfd5b(%rip), %rax      # 0x124b0
movl (%rax,%rcx,4), %edi
callq 0x59e0
movl %eax, %edx
movslq -0x14(%rbp), %rcx
leaq 0xfe96(%rip), %rax      # 0x12600
movl %edx, (%rax,%rcx,4)
movl -0x14(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x14(%rbp)
jmp 0x2739
addq $0x20, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/cinemast[P]sudoku/sudoku.c
// Function: block
static
void
block (int el)
{
    int i, idx, row, col;

    /* Find first unknown square */
    for (i = 0; i < 9 && !IS_EMPTY(idx = idx_block(el, i)); ++i) {
       ;
    }
    if (i < 9) {
        assert(IS_EMPTY(idx));
        row = ROW(idx);
        col = COLUMN(idx);
        for (++i; i < 9; ++i) {
            idx = idx_block(el, i);
            if (IS_EMPTY(idx)) {
                if (ROW(idx) != row) {
                    row = -1;
                }
                if (COLUMN(idx) != col) {
                    col = -1;
                }
            }
        }
        if (0 <= row) {
            exblock(el, row, idx_row);
        }
        if (0 <= col) {
            exblock(el, col, idx_column);
        }
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movl %edi, -0x4(%rbp)
movl $0x0, -0x8(%rbp)
xorl %eax, %eax
cmpl $0x9, -0x8(%rbp)
movb %al, -0x15(%rbp)
jge 0x2a3d
movl -0x4(%rbp), %edi
movl -0x8(%rbp), %esi
callq 0x2990
movl %eax, -0xc(%rbp)
movslq %eax, %rcx
leaq 0xfa8b(%rip), %rax      # 0x124b0
movl (%rax,%rcx,4), %ecx
andl $0xf0000, %ecx          # imm = 0xF0000
sarl $0x10, %ecx
xorl %eax, %eax
cmpl %ecx, %eax
sete %al
xorb $-0x1, %al
movb %al, -0x15(%rbp)
movb -0x15(%rbp), %al
testb $0x1, %al
jne 0x2a46
jmp 0x2a53
jmp 0x2a48
movl -0x8(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x8(%rbp)
jmp 0x2a02
cmpl $0x9, -0x8(%rbp)
jge 0x2b62
movslq -0xc(%rbp), %rcx
leaq 0xfa48(%rip), %rax      # 0x124b0
movl (%rax,%rcx,4), %ecx
andl $0xf0000, %ecx          # imm = 0xF0000
sarl $0x10, %ecx
xorl %eax, %eax
cmpl %ecx, %eax
jne 0x2a7c
jmp 0x2a9b
leaq 0xa569(%rip), %rdi      # 0xcfec
leaq 0xa267(%rip), %rsi      # 0xccf1
movl $0x496, %edx            # imm = 0x496
leaq 0xa564(%rip), %rcx      # 0xcffa
callq 0x2150
movl -0xc(%rbp), %eax
movl $0x9, %ecx
cltd
idivl %ecx
movl %eax, -0x10(%rbp)
movl -0xc(%rbp), %eax
movl $0x9, %ecx
cltd
idivl %ecx
movl %edx, -0x14(%rbp)
movl -0x8(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x8(%rbp)
cmpl $0x9, -0x8(%rbp)
jge 0x2b2e
movl -0x4(%rbp), %edi
movl -0x8(%rbp), %esi
callq 0x2990
movl %eax, -0xc(%rbp)
movslq -0xc(%rbp), %rcx
leaq 0xf9d1(%rip), %rax      # 0x124b0
movl (%rax,%rcx,4), %ecx
andl $0xf0000, %ecx          # imm = 0xF0000
sarl $0x10, %ecx
xorl %eax, %eax
cmpl %ecx, %eax
jne 0x2b21
movl -0xc(%rbp), %eax
movl $0x9, %ecx
cltd
idivl %ecx
cmpl -0x10(%rbp), %eax
je 0x2b08
movl $0xffffffff, -0x10(%rbp) # imm = 0xFFFFFFFF
movl -0xc(%rbp), %eax
movl $0x9, %ecx
cltd
idivl %ecx
cmpl -0x14(%rbp), %edx
je 0x2b1f
movl $0xffffffff, -0x14(%rbp) # imm = 0xFFFFFFFF
jmp 0x2b21
jmp 0x2b23
movl -0x8(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x8(%rbp)
jmp 0x2ac0
xorl %eax, %eax
cmpl -0x10(%rbp), %eax
jg 0x2b47
movl -0x4(%rbp), %edi
movl -0x10(%rbp), %esi
leaq -0x3c2(%rip), %rdx      # 0x2780
callq 0x5a60
xorl %eax, %eax
cmpl -0x14(%rbp), %eax
jg 0x2b60
movl -0x4(%rbp), %edi
movl -0x14(%rbp), %esi
leaq -0x1eb(%rip), %rdx      # 0x2970
callq 0x5a60
jmp 0x2b62
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/cinemast[P]sudoku/sudoku.c
// Function: reapply
static
int
reapply (void)
{
    int digit, idx, j;
    int allok = 0;
    memset(board, 0x00, sizeof(board));
    for (j = 0; j < idx_history; ++j) {
        if (!(history[j] & IGNORED) && 0 != GET_DIGIT(history[j])) {
            idx = GET_INDEX(history[j]);
            digit = GET_DIGIT(history[j]);
            if (!IS_EMPTY(idx) || DISALLOWED(idx, digit)) {
                allok = -1;
            }
            board[idx] = SET_DIGIT(digit);
            if (history[j] & FIXED) {
                board[idx] |= FIXED;
            }
            update(idx);
        }
    }
    return allok;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movl $0x0, -0x10(%rbp)
leaq 0xf77a(%rip), %rdi      # 0x124b0
xorl %esi, %esi
movl $0x144, %edx            # imm = 0x144
callq 0x2180
movl $0x0, -0xc(%rbp)
movl -0xc(%rbp), %eax
cmpl 0xf8d2(%rip), %eax      # 0x12624
jge 0x2e6c
movslq -0xc(%rbp), %rcx
leaq 0xf8cd(%rip), %rax      # 0x12630
movl (%rax,%rcx,4), %eax
andl $0x400000, %eax         # imm = 0x400000
cmpl $0x0, %eax
jne 0x2e5c
movslq -0xc(%rbp), %rcx
leaq 0xf8b1(%rip), %rax      # 0x12630
movl (%rax,%rcx,4), %ecx
andl $0xf0000, %ecx          # imm = 0xF0000
sarl $0x10, %ecx
xorl %eax, %eax
cmpl %ecx, %eax
je 0x2e5c
movslq -0xc(%rbp), %rcx
leaq 0xf890(%rip), %rax      # 0x12630
movl (%rax,%rcx,4), %eax
andl $0x7f, %eax
movl %eax, -0x8(%rbp)
movslq -0xc(%rbp), %rcx
leaq 0xf87c(%rip), %rax      # 0x12630
movl (%rax,%rcx,4), %eax
andl $0xf0000, %eax          # imm = 0xF0000
sarl $0x10, %eax
movl %eax, -0x4(%rbp)
movslq -0x8(%rbp), %rcx
leaq 0xf6e3(%rip), %rax      # 0x124b0
movl (%rax,%rcx,4), %ecx
andl $0xf0000, %ecx          # imm = 0xF0000
sarl $0x10, %ecx
xorl %eax, %eax
cmpl %ecx, %eax
jne 0x2e03
movslq -0x8(%rbp), %rcx
leaq 0xf6c6(%rip), %rax      # 0x124b0
movl (%rax,%rcx,4), %eax
movl -0x4(%rbp), %ecx
addl $0x6, %ecx
movl $0x1, %edx
shll %cl, %edx
movl %edx, %ecx
andl %ecx, %eax
cmpl $0x0, %eax
je 0x2e0a
movl $0xffffffff, -0x10(%rbp) # imm = 0xFFFFFFFF
movl -0x4(%rbp), %edx
shll $0x10, %edx
movslq -0x8(%rbp), %rcx
leaq 0xf695(%rip), %rax      # 0x124b0
movl %edx, (%rax,%rcx,4)
movslq -0xc(%rbp), %rcx
leaq 0xf807(%rip), %rax      # 0x12630
movl (%rax,%rcx,4), %eax
andl $0x100000, %eax         # imm = 0x100000
cmpl $0x0, %eax
je 0x2e54
movslq -0x8(%rbp), %rcx
leaq 0xf66f(%rip), %rax      # 0x124b0
movl (%rax,%rcx,4), %edx
orl $0x100000, %edx         # imm = 0x100000
leaq 0xf65f(%rip), %rax      # 0x124b0
movl %edx, (%rax,%rcx,4)
movl -0x8(%rbp), %edi
callq 0x5bd0
jmp 0x2e5e
movl -0xc(%rbp), %eax
addl $0x1, %eax
movl %eax, -0xc(%rbp)
jmp 0x2d49
movl -0x10(%rbp), %eax
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/cinemast[P]sudoku/sudoku.c
// Function: clear_hints
static
void
clear_hints (void)
{
    int i;
    for (i = 0; i < 9; ++i) {
        mvaddch(TOP + 1 + i + i / 3, LEFT - 2, ' ');
        mvaddch(TOP + 1 + i + i / 3, RIGHT + 2, ' ');
        mvaddch(TOP - 1, LEFT + 2 + 2 * (i + i / 3), ' ');
        mvaddch(BOTTOM + 1, LEFT + 2 + 2 * (i + i / 3), ' ');
    }
    have_hint = 0;
    move_to(curx, cury);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movl $0x0, -0x4(%rbp)
cmpl $0x9, -0x4(%rbp)
jge 0x32cf
movq 0xde28(%rip), %rax      # 0x10fd8
movq (%rax), %rdi
movl -0x4(%rbp), %esi
addl $0x7, %esi
movl -0x4(%rbp), %eax
movl $0x3, %ecx
cltd
idivl %ecx
addl %eax, %esi
movl $0x19, %edx
callq 0x22b0
cmpl $-0x1, %eax
jne 0x31d7
jmp 0x31eb
movq 0xddfa(%rip), %rax      # 0x10fd8
movq (%rax), %rdi
movl $0x20, %esi
callq 0x22e0
movq 0xdde6(%rip), %rax      # 0x10fd8
movq (%rax), %rdi
movl -0x4(%rbp), %esi
addl $0x7, %esi
movl -0x4(%rbp), %eax
movl $0x3, %ecx
cltd
idivl %ecx
addl %eax, %esi
movl $0x35, %edx
callq 0x22b0
cmpl $-0x1, %eax
jne 0x3219
jmp 0x322d
movq 0xddb8(%rip), %rax      # 0x10fd8
movq (%rax), %rdi
movl $0x20, %esi
callq 0x22e0
movq 0xdda4(%rip), %rax      # 0x10fd8
movq (%rax), %rdi
movl -0x4(%rbp), %eax
movl %eax, -0x8(%rbp)
movl -0x4(%rbp), %eax
movl $0x3, %ecx
cltd
idivl %ecx
movl -0x8(%rbp), %edx
addl %eax, %edx
shll %edx
addl $0x1d, %edx
movl $0x5, %esi
callq 0x22b0
cmpl $-0x1, %eax
jne 0x3263
jmp 0x3277
movq 0xdd6e(%rip), %rax      # 0x10fd8
movq (%rax), %rdi
movl $0x20, %esi
callq 0x22e0
movq 0xdd5a(%rip), %rax      # 0x10fd8
movq (%rax), %rdi
movl -0x4(%rbp), %eax
movl %eax, -0xc(%rbp)
movl -0x4(%rbp), %eax
movl $0x3, %ecx
cltd
idivl %ecx
movl -0xc(%rbp), %edx
addl %eax, %edx
shll %edx
addl $0x1d, %edx
movl $0x13, %esi
callq 0x22b0
cmpl $-0x1, %eax
jne 0x32ad
jmp 0x32c1
movq 0xdd24(%rip), %rax      # 0x10fd8
movq (%rax), %rdi
movl $0x20, %esi
callq 0x22e0
movl -0x4(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x4(%rbp)
jmp 0x319f
movl $0x0, 0xe07f(%rip)      # 0x11358
movl 0xf71d(%rip), %edi      # 0x129fc
movl 0xf71b(%rip), %esi      # 0x12a00
callq 0x5d10
addq $0x10, %rsp
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O0/cinemast[P]sudoku/sudoku.c
// Function: set_status
static
void
set_status (const char * txt)
{
    mvaddstr(STATUS_LINE,
             (int)((LINE_SIZE - strlen(txt)) / 2),
             (char *)txt);

    move_to(curx, cury);
    wrefresh(stdscr);
    have_status = 1;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq 0xdcd5(%rip), %rax      # 0x10fd8
movq (%rax), %rax
movq %rax, -0x10(%rbp)
movq -0x8(%rbp), %rdi
callq 0x20f0
movq -0x10(%rbp), %rdi
movq %rax, %rcx
movl $0x50, %eax
subq %rcx, %rax
shrq %rax
movl %eax, %edx
movl $0x14, %esi
callq 0x22b0
cmpl $-0x1, %eax
jne 0x3338
jmp 0x3350
movq 0xdc99(%rip), %rax      # 0x10fd8
movq (%rax), %rdi
movq -0x8(%rbp), %rsi
movl $0xffffffff, %edx       # imm = 0xFFFFFFFF
callq 0x2330
movl 0xf6a6(%rip), %edi      # 0x129fc
movl 0xf6a4(%rip), %esi      # 0x12a00
callq 0x5d10
movq 0xdc70(%rip), %rax      # 0x10fd8
movq (%rax), %rdi
callq 0x2170
movl $0x1, 0xf68a(%rip)      # 0x12a04
addq $0x10, %rsp
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O0/cinemast[P]sudoku/sudoku.c
// Function: row_hint
static
void
row_hint (int row)
{
    mvaddch(TOP + 1 + row + row / 3, LEFT - 2, '>');
    mvaddch(TOP + 1 + row + row / 3, RIGHT + 2, '<');
    move_to(curx, cury);
    have_hint = 1;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movl %edi, -0x4(%rbp)
movq 0xdc46(%rip), %rax      # 0x10fd8
movq (%rax), %rdi
movl -0x4(%rbp), %esi
addl $0x7, %esi
movl -0x4(%rbp), %eax
movl $0x3, %ecx
cltd
idivl %ecx
addl %eax, %esi
movl $0x19, %edx
callq 0x22b0
cmpl $-0x1, %eax
jne 0x33b9
jmp 0x33cd
movq 0xdc18(%rip), %rax      # 0x10fd8
movq (%rax), %rdi
movl $0x3e, %esi
callq 0x22e0
movq 0xdc04(%rip), %rax      # 0x10fd8
movq (%rax), %rdi
movl -0x4(%rbp), %esi
addl $0x7, %esi
movl -0x4(%rbp), %eax
movl $0x3, %ecx
cltd
idivl %ecx
addl %eax, %esi
movl $0x35, %edx
callq 0x22b0
cmpl $-0x1, %eax
jne 0x33fb
jmp 0x340f
movq 0xdbd6(%rip), %rax      # 0x10fd8
movq (%rax), %rdi
movl $0x3c, %esi
callq 0x22e0
movl 0xf5e7(%rip), %edi      # 0x129fc
movl 0xf5e5(%rip), %esi      # 0x12a00
callq 0x5d10
movl $0x1, 0xdf2e(%rip)      # 0x11358
addq $0x10, %rsp
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O0/cinemast[P]sudoku/sudoku.c
// Function: column_hint
static
void
column_hint (int col)
{
    mvaddch(TOP - 1, LEFT + 2 + 2 * (col + col / 3), 'v');
    mvaddch(BOTTOM + 1, LEFT + 2 + 2 * (col + col / 3), '^');
    move_to(curx, cury);
    have_hint = 1;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movl %edi, -0x4(%rbp)
movq 0xdb96(%rip), %rax      # 0x10fd8
movq (%rax), %rdi
movl -0x4(%rbp), %eax
movl %eax, -0x8(%rbp)
movl -0x4(%rbp), %eax
movl $0x3, %ecx
cltd
idivl %ecx
movl -0x8(%rbp), %edx
addl %eax, %edx
shll %edx
addl $0x1d, %edx
movl $0x5, %esi
callq 0x22b0
cmpl $-0x1, %eax
jne 0x3471
jmp 0x3485
movq 0xdb60(%rip), %rax      # 0x10fd8
movq (%rax), %rdi
movl $0x76, %esi
callq 0x22e0
movq 0xdb4c(%rip), %rax      # 0x10fd8
movq (%rax), %rdi
movl -0x4(%rbp), %eax
movl %eax, -0xc(%rbp)
movl -0x4(%rbp), %eax
movl $0x3, %ecx
cltd
idivl %ecx
movl -0xc(%rbp), %edx
addl %eax, %edx
shll %edx
addl $0x1d, %edx
movl $0x13, %esi
callq 0x22b0
cmpl $-0x1, %eax
jne 0x34bb
jmp 0x34cf
movq 0xdb16(%rip), %rax      # 0x10fd8
movq (%rax), %rdi
movl $0x5e, %esi
callq 0x22e0
movl 0xf527(%rip), %edi      # 0x129fc
movl 0xf525(%rip), %esi      # 0x12a00
callq 0x5d10
movl $0x1, 0xde6e(%rip)      # 0x11358
addq $0x10, %rsp
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O0/cinemast[P]sudoku/sudoku.c
// Function: block_hint
static
void
block_hint (int block)
{
    int i, j;
    for (i = 0; i < 3; ++i) {
        j = 3 * (block / 3) + i;
        mvaddch(TOP + 1 + j + j / 3, LEFT - 2, '>');
        mvaddch(TOP + 1 + j + j / 3, RIGHT + 2, '<');
        j = 3 * (block % 3) + i;
        mvaddch(TOP - 1, LEFT + 2 + 2 * (j + j / 3), 'v');
        mvaddch(BOTTOM + 1, LEFT + 2 + 2 * (j + j / 3), '^');
    }
    move_to(curx, cury);
    have_hint = 1;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movl %edi, -0x4(%rbp)
movl $0x0, -0x8(%rbp)
cmpl $0x3, -0x8(%rbp)
jge 0x365a
movl -0x4(%rbp), %eax
movl $0x3, %ecx
cltd
idivl %ecx
imull $0x3, %eax, %eax
addl -0x8(%rbp), %eax
movl %eax, -0xc(%rbp)
movq 0xdab1(%rip), %rax      # 0x10fd8
movq (%rax), %rdi
movl -0xc(%rbp), %esi
addl $0x7, %esi
movl -0xc(%rbp), %eax
movl $0x3, %ecx
cltd
idivl %ecx
addl %eax, %esi
movl $0x19, %edx
callq 0x22b0
cmpl $-0x1, %eax
jne 0x354e
jmp 0x3562
movq 0xda83(%rip), %rax      # 0x10fd8
movq (%rax), %rdi
movl $0x3e, %esi
callq 0x22e0
movq 0xda6f(%rip), %rax      # 0x10fd8
movq (%rax), %rdi
movl -0xc(%rbp), %esi
addl $0x7, %esi
movl -0xc(%rbp), %eax
movl $0x3, %ecx
cltd
idivl %ecx
addl %eax, %esi
movl $0x35, %edx
callq 0x22b0
cmpl $-0x1, %eax
jne 0x3590
jmp 0x35a4
movq 0xda41(%rip), %rax      # 0x10fd8
movq (%rax), %rdi
movl $0x3c, %esi
callq 0x22e0
movl -0x4(%rbp), %eax
movl $0x3, %ecx
cltd
idivl %ecx
imull $0x3, %edx, %eax
addl -0x8(%rbp), %eax
movl %eax, -0xc(%rbp)
movq 0xda19(%rip), %rax      # 0x10fd8
movq (%rax), %rdi
movl -0xc(%rbp), %eax
movl %eax, -0x10(%rbp)
movl -0xc(%rbp), %eax
movl $0x3, %ecx
cltd
idivl %ecx
movl -0x10(%rbp), %edx
addl %eax, %edx
shll %edx
addl $0x1d, %edx
movl $0x5, %esi
callq 0x22b0
cmpl $-0x1, %eax
jne 0x35ee
jmp 0x3602
movq 0xd9e3(%rip), %rax      # 0x10fd8
movq (%rax), %rdi
movl $0x76, %esi
callq 0x22e0
movq 0xd9cf(%rip), %rax      # 0x10fd8
movq (%rax), %rdi
movl -0xc(%rbp), %eax
movl %eax, -0x14(%rbp)
movl -0xc(%rbp), %eax
movl $0x3, %ecx
cltd
idivl %ecx
movl -0x14(%rbp), %edx
addl %eax, %edx
shll %edx
addl $0x1d, %edx
movl $0x13, %esi
callq 0x22b0
cmpl $-0x1, %eax
jne 0x3638
jmp 0x364c
movq 0xd999(%rip), %rax      # 0x10fd8
movq (%rax), %rdi
movl $0x5e, %esi
callq 0x22e0
movl -0x8(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x8(%rbp)
jmp 0x3502
movl 0xf39c(%rip), %edi      # 0x129fc
movl 0xf39a(%rip), %esi      # 0x12a00
callq 0x5d10
movl $0x1, 0xdce3(%rip)      # 0x11358
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/cinemast[P]sudoku/sudoku.c
// Function: open_precanned
static
int
open_precanned (const char * filename)
{
    n_precanned = 0;
    precanned = fopen(filename, "r");
    if (0 != precanned) {
        while (0 == read_board(precanned, 0)) {
            ++n_precanned;
        }
    }
    /* return 0 on success, -1 on failure. */
    return (n_precanned > 0) - 1;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movl $0x0, 0xe78a(%rip)      # 0x123d0
movq -0x8(%rbp), %rdi
leaq 0x9deb(%rip), %rsi      # 0xda3c
callq 0x22a0
movq %rax, 0xd763(%rip)      # 0x113c0
xorl %eax, %eax
cmpq 0xd75a(%rip), %rax      # 0x113c0
je 0x3c93
jmp 0x3c6a
movq 0xd74f(%rip), %rdi      # 0x113c0
xorl %esi, %esi
callq 0x5d90
movl %eax, %ecx
xorl %eax, %eax
cmpl %ecx, %eax
jne 0x3c91
movl 0xe74a(%rip), %eax      # 0x123d0
addl $0x1, %eax
movl %eax, 0xe741(%rip)      # 0x123d0
jmp 0x3c6a
jmp 0x3c93
cmpl $0x0, 0xe736(%rip)      # 0x123d0
setg %al
andb $0x1, %al
movzbl %al, %eax
subl $0x1, %eax
addq $0x10, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/cinemast[P]sudoku/sudoku.c
// Function: open_template
static
void
open_template (const char * filename)
{
    n_tmplt = 0;
    ftmplt = topen(filename, "r");
    if (0 != ftmplt) {
        while (0 == read_board(ftmplt, 1)) {
            ++n_tmplt;
        }
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movl $0x0, 0xe74a(%rip)      # 0x12410
movq -0x8(%rbp), %rdi
leaq 0x9d6b(%rip), %rsi      # 0xda3c
callq 0x6770
movq %rax, 0xe71b(%rip)      # 0x123f8
xorl %eax, %eax
cmpq 0xe712(%rip), %rax      # 0x123f8
je 0x3d16
jmp 0x3cea
movq 0xe707(%rip), %rdi      # 0x123f8
movl $0x1, %esi
callq 0x5d90
movl %eax, %ecx
xorl %eax, %eax
cmpl %ecx, %eax
jne 0x3d14
movl 0xe707(%rip), %eax      # 0x12410
addl $0x1, %eax
movl %eax, 0xe6fe(%rip)      # 0x12410
jmp 0x3cea
jmp 0x3d16
addq $0x10, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/cinemast[P]sudoku/sudoku.c
// Function: write_default_template
static
int
write_default_template(const char *     template_path)
{
    int     ret = -1;
    FILE *  f   = fopen(template_path, "r");
    if (0 == f) {
        f = fopen(template_path, "w");
        if (0 != f) {
            size_t i;
            for (i = 0; i < sizeof(default_template); ++i) {
                unsigned char ch = default_template[i];
                int j;
                for (j = 0; j < 4; ++j) {
                    fprintf(f, "%c", dtct[ch & 3]);
                    ch >>= 2;
                }
            }
            ret = fclose(f);
        }
    } else {
        fclose(f);
    }
    return ret;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movl $0xffffffff, -0xc(%rbp) # imm = 0xFFFFFFFF
movq -0x8(%rbp), %rdi
leaq 0x9cfe(%rip), %rsi      # 0xda3c
callq 0x22a0
movq %rax, -0x18(%rbp)
xorl %eax, %eax
cmpq -0x18(%rbp), %rax
jne 0x3dfd
movq -0x8(%rbp), %rdi
leaq 0x92f4(%rip), %rsi      # 0xd052
callq 0x22a0
movq %rax, -0x18(%rbp)
xorl %eax, %eax
cmpq -0x18(%rbp), %rax
je 0x3dfb
movq $0x0, -0x20(%rbp)
cmpq $0x1773, -0x20(%rbp)    # imm = 0x1773
jae 0x3def
movq -0x20(%rbp), %rcx
leaq 0x77d0(%rip), %rax      # 0xb560
movb (%rax,%rcx), %al
movb %al, -0x21(%rbp)
movl $0x0, -0x28(%rbp)
cmpl $0x4, -0x28(%rbp)
jge 0x3ddf
movq -0x18(%rbp), %rdi
movzbl -0x21(%rbp), %eax
andl $0x3, %eax
movslq %eax, %rcx
leaq 0x8f1b(%rip), %rax      # 0xccd3
movsbl (%rax,%rcx), %edx
leaq 0x9291(%rip), %rsi      # 0xd054
movb $0x0, %al
callq 0x2200
movzbl -0x21(%rbp), %eax
sarl $0x2, %eax
movb %al, -0x21(%rbp)
movl -0x28(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x28(%rbp)
jmp 0x3d9d
jmp 0x3de1
movq -0x20(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x20(%rbp)
jmp 0x3d7b
movq -0x18(%rbp), %rdi
callq 0x20d0
movl %eax, -0xc(%rbp)
jmp 0x3e06
movq -0x18(%rbp), %rdi
callq 0x20d0
movl -0xc(%rbp), %eax
addq $0x30, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/cinemast[P]sudoku/sudoku.c
// Function: cleanup_curses_and_more
static
void
cleanup_curses_and_more (void)
{
    if (opened != NULL) {
        fclose(opened);
        opened = NULL;
    }
    if (precanned != NULL) {
        fclose(precanned);
        precanned = NULL;
    }
    tclose(ftmplt);
    ftmplt = NULL;
    move(LAST_LINE, 0);
    wrefresh(stdscr);
    endwin();
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
cmpq $0x0, 0xeb1c(%rip)      # 0x12c88
je 0x4185
movq 0xeb13(%rip), %rdi      # 0x12c88
callq 0x20d0
movq $0x0, 0xeb03(%rip) # 0x12c88
cmpq $0x0, 0xd233(%rip)      # 0x113c0
je 0x41a6
movq 0xd22a(%rip), %rdi      # 0x113c0
callq 0x20d0
movq $0x0, 0xd21a(%rip) # 0x113c0
movq 0xe24b(%rip), %rdi      # 0x123f8
callq 0x6800
movq $0x0, 0xe23b(%rip) # 0x123f8
movq 0xce14(%rip), %rax      # 0x10fd8
movq (%rax), %rdi
movl $0x17, %esi
xorl %edx, %edx
callq 0x22b0
movq 0xcdfe(%rip), %rax      # 0x10fd8
movq (%rax), %rdi
callq 0x2170
callq 0x2320
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/cinemast[P]sudoku/sudoku.c
// Function: print
static
void
print (FILE * f, const char * title)
{
    switch (opt_format) {
        case fStandard:
        case fCompact:
        case fCSV:
            text(f, title);
            break;
        case fPostScript:
            postscript(f, title);
            break;
        case fHTML:
            html(f, title);
            break;
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl 0xdd5e(%rip), %eax      # 0x123e4
movl %eax, -0x14(%rbp)
subl $0x3, %eax
jb 0x46a4
jmp 0x4690
movl -0x14(%rbp), %eax
subl $0x3, %eax
je 0x46b3
jmp 0x469a
movl -0x14(%rbp), %eax
subl $0x4, %eax
je 0x46c2
jmp 0x46cf
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
callq 0x7770
jmp 0x46cf
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
callq 0x79b0
jmp 0x46cf
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
callq 0x7b60
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)