LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O3/aap[P]rx-0/ww1/mach.c
// Function: examine
Word
examine(Addr a)
{
	WWI *ww = &ww1;
	if(MS_SELECT(a))
		return ww->core[a];
	else if(IS_FF(a))
		return ww->ffs[a & 037];
	else
		return ww->tss[a & 037];
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
cmpw $0x20, %di
jae 0x424e
movl 0xb3b3(%rip), %eax      # 0xf5e8
btl %edi, %eax
movzwl %di, %eax
leaq 0xb38e(%rip), %rcx      # 0xf5d0
jae 0x4264
leaq (%rcx,%rax,2), %rax
addq $0x1c, %rax
jmp 0x426c
movzwl %di, %eax
leaq 0xb378(%rip), %rcx      # 0xf5d0
leaq (%rcx,%rax,2), %rax
addq $0x9c, %rax
jmp 0x426c
leaq (%rcx,%rax,2), %rax
addq $0x5c, %rax
movzwl (%rax), %eax
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/aap[P]rx-0/ww1/mach.c
// Function: depositreg
void
depositreg(int a, Word w)
{
	switch(a){
	case REG_PC: ww1.pc = w & ADDRMASK; break;
	case REG_AC: ww1.ac = w & WORDMASK; break;
	case REG_A: ww1.ar = w & WORDMASK; break;
	case REG_B: ww1.br = w & WORDMASK; break;
	case REG_SAM:
		ww1.ac0_carry = ww1.sam = 0;
		if(w == 1)
			ww1.ac0_carry = 1;
		else if(w == 0177776)
			ww1.sam = 1;
		break;
	default:
		// Set toggle switch storage
		if(a < 32)
			ww1.tss[a] = w;
		break;
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
leal -0x20(%rdi), %eax
cmpl $0x4, %eax
ja 0x42d9
leaq 0x2fe8(%rip), %rcx      # 0x726c
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
andl $0x7ff, %esi            # imm = 0x7FF
movw %si, 0xb346(%rip)       # 0xf5e0
jmp 0x42f8
movl $0x0, 0xc3d8(%rip)      # 0x1067e
cmpl $0xfffe, %esi           # imm = 0xFFFE
je 0x42ef
cmpl $0x1, %esi
jne 0x42f8
movw $0x1, 0xc3c2(%rip)      # 0x1067e
jmp 0x42f8
movw %si, 0xc3ab(%rip)       # 0x10670
jmp 0x42f8
movw %si, 0xc3ae(%rip)       # 0x1067c
jmp 0x42f8
movw %si, 0xc3a1(%rip)       # 0x10678
jmp 0x42f8
cmpl $0x1f, %edi
jg 0x42f8
movslq %edi, %rax
leaq 0xb2e8(%rip), %rcx      # 0xf5d0
movw %si, 0x5c(%rcx,%rax,2)
jmp 0x42f8
movw $0x1, 0xc388(%rip)      # 0x10680
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/aap[P]rx-0/ww1/mach.c
// Function: examinereg
Word
examinereg(int a)
{
	word w;
	switch(a){
	case REG_PC: return ww1.pc;
	case REG_AC: return ww1.ac;
	case REG_A: return ww1.ar;
	case REG_B: return ww1.br;
	case REG_SAM:
		w = 0;
		if(ww1.ac0_carry) w |= 1;
		if(ww1.sam) w |= 0177776;
		return w;
	default:
		// Read toggle switch storage
		if(a < 32)
			return ww1.tss[a];
		break;
	}
	return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
leal -0x20(%rdi), %eax
cmpl $0x4, %eax
ja 0x4359
leaq 0x2f73(%rip), %rcx      # 0x7280
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
movzwl 0xb2c3(%rip), %eax      # 0xf5e0
jmp 0x4371
xorl %ecx, %ecx
cmpw $0x0, 0xc355(%rip)      # 0x1067e
setne %cl
movl %ecx, %eax
orl $-0x2, %eax
cmpw $0x0, 0xc347(%rip)      # 0x10680
cmovel %ecx, %eax
jmp 0x4371
movzwl 0xc32b(%rip), %eax      # 0x10670
jmp 0x4371
movzwl 0xc32e(%rip), %eax      # 0x1067c
jmp 0x4371
movzwl 0xc321(%rip), %eax      # 0x10678
jmp 0x4371
cmpl $0x1f, %edi
jg 0x436f
movslq %edi, %rax
leaq 0xb268(%rip), %rcx      # 0xf5d0
movzwl 0x5c(%rcx,%rax,2), %eax
jmp 0x4371
xorl %eax, %eax
movzwl %ax, %eax
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/aap[P]rx-0/ww1/mach.c
// Function: scope_record
void
scope_record(WWI *ww, ExUnit *eu)
{
	Scope *s = (Scope*)eu;
	if(s->fd >= 0){
		u32 cmd = 0;
		int x = ww->hdefl;
		int y = ww->vdefl;
		// Convert [-1.0,+1.0] to [0,1023]
		if(x & 02000) x++;
		if(y & 02000) y++;
		x += 02000;
		y += 02000;
		x &= 03777;
		y &= 03777;
		x >>= 1;
		y >>= 1;
		cmd = x;
		cmd |= y<<10;
		cmd |= 7<<20;
		if(write(s->fd, &cmd, 4) < 4)
			s->fd = -1;
usleep(100);
	}
	ww->interlock = 0;
	eu->active = 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
subq $0x10, %rsp
movq %rsi, %rbx
movq %rdi, %r14
movl 0x28(%rsi), %edi
testl %edi, %edi
js 0x4638
movl 0x10d8(%r14), %eax
btl $0xa, %eax
adcl $0x0, %eax
movl 0x10dc(%r14), %ecx
btl $0xa, %ecx
adcl $0x0, %ecx
shrl %eax
andl $0x3ff, %eax            # imm = 0x3FF
shll $0x9, %ecx
andl $0xffc00, %ecx          # imm = 0xFFC00
orl %eax, %ecx
xorl $0x780200, %ecx         # imm = 0x780200
leaq -0x14(%rbp), %rsi
movl %ecx, (%rsi)
movl $0x4, %edx
callq 0x20d0
cmpq $0x3, %rax
jg 0x462e
movl $0xffffffff, 0x28(%rbx) # imm = 0xFFFFFFFF
movl $0x64, %edi
callq 0x2420
xorl %eax, %eax
movl %eax, 0x10c4(%r14)
movl %eax, (%rbx)
addq $0x10, %rsp
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/aap[P]rx-0/ww1/mach.c
// Function: ptape_record
void
ptape_record(WWI *ww, ExUnit *eu)
{
	Papertape *pt = (Papertape*)eu;
	if(pt->dly){
		pt->dly--;
		return;
	}

	int u = (ww->ios>>3) & 3;
	u8 c = ww->ior>>10 & 077;
	if(pt->p7) c |= 0100;
	write(pt->out_fd[u], &c, 1);

	if(pt->wbyw) ww->ior <<= 5;
	if(ww->ioc_counter++ == 017){
		ww->interlock = 0;
		eu->active = 0;
	}

	pt->dly = 1000;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
subq $0x10, %rsp
movq %rsi, %rbx
movl 0x50(%rsi), %eax
testl %eax, %eax
je 0x46b1
decl %eax
movl %eax, 0x50(%rbx)
jmp 0x4722
movq %rdi, %r14
movl 0x10c8(%rdi), %eax
shrl $0x3, %eax
andl $0x3, %eax
movzwl 0x10b8(%rdi), %ecx
shrl $0xa, %ecx
movb %cl, -0x11(%rbp)
cmpl $0x0, 0x4c(%rbx)
je 0x46d9
orb $0x40, %cl
movb %cl, -0x11(%rbp)
movl 0x28(%rbx,%rax,4), %edi
leaq -0x11(%rbp), %rsi
movl $0x1, %edx
callq 0x20d0
cmpl $0x0, 0x48(%rbx)
je 0x46fa
shlw $0x5, 0x10b8(%r14)
movl 0x10c0(%r14), %eax
leal 0x1(%rax), %ecx
movl %ecx, 0x10c0(%r14)
cmpl $0xf, %eax
jne 0x471b
xorl %eax, %eax
movl %eax, 0x10c4(%r14)
movl %eax, (%rbx)
movl $0x3e8, 0x50(%rbx)      # imm = 0x3E8
addq $0x10, %rsp
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/aap[P]rx-0/ww1/mach.c
// Function: ptape_read
void
ptape_read(WWI *ww, ExUnit *eu)
{
	Papertape *pt = (Papertape*)eu;
	if(pt->dly){
		pt->dly--;
		return;
	}
	int u = (ww->ios>>3) & 3;
	if(eu->active && hasinput(pt->in_fd[u])){
		u8 c;
		read(pt->in_fd[u], &c, 1);
		if(pt->wbyw) ww->ior <<= 5;
		ww->ior |= c & 077;

		if(ww->ioc_counter++ == 017){
			ww->interlock = 0;
			eu->active = 0;
		}

		pt->dly = 1000;
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %rbx
movl 0x50(%rsi), %eax
testl %eax, %eax
je 0x474f
decl %eax
movl %eax, 0x50(%rbx)
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
cmpl $0x0, (%rbx)
je 0x4744
movq %rdi, %r14
movl 0x10c8(%rdi), %r15d
shrl $0x3, %r15d
andl $0x3, %r15d
movl 0x38(%rbx,%r15,4), %edi
callq 0x36a3
testl %eax, %eax
je 0x4744
movl 0x38(%rbx,%r15,4), %edi
leaq -0x19(%rbp), %r15
movl $0x1, %edx
movq %r15, %rsi
callq 0x2190
movl 0x10b8(%r14), %eax
movl %eax, %ecx
shll $0x5, %ecx
cmpl $0x0, 0x48(%rbx)
cmovel %eax, %ecx
movl 0x10c0(%r14), %eax
movzbl (%r15), %edx
andl $0x3f, %edx
orl %ecx, %edx
movw %dx, 0x10b8(%r14)
leal 0x1(%rax), %ecx
movl %ecx, 0x10c0(%r14)
cmpl $0xf, %eax
jne 0x47cf
xorl %eax, %eax
movl %eax, 0x10c4(%r14)
movl %eax, (%rbx)
movl $0x3e8, 0x50(%rbx)      # imm = 0x3E8
jmp 0x4744
// File: /workspace/github_c_makefile_star2_O3/aap[P]rx-0/ww1/mach.c
// Function: readmem
void
readmem(WWI *ww, FILE *f)
{
	char buf[100], *s;
	word a, w;

	a = 0;
	while(s = fgets(buf, 100, f)){
		while(*s){
			if(*s == ';')
				break;
			else if('0' <= *s && *s <= '7'){
				w = strtol(s, &s, 8);
				if(*s == ':'){
					a = w;
					s++;
				}else if(a < 04000)
					ww->core[a++] = w;
			}else
				s++;
		}
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x78, %rsp
movq %rsi, %rbx
movq %rdi, %r14
leaq -0xa0(%rbp), %rdi
movl $0x64, %esi
movq %rbx, %rdx
callq 0x21a0
movq %rax, -0x30(%rbp)
testq %rax, %rax
je 0x4913
xorl %ecx, %ecx
leaq -0xa0(%rbp), %r15
leaq -0x30(%rbp), %r12
movzwl %cx, %r13d
movzbl (%rax), %ecx
testl %ecx, %ecx
je 0x48a8
cmpl $0x3b, %ecx
jne 0x48c3
movq %r15, %rdi
movl $0x64, %esi
movq %rbx, %rdx
callq 0x21a0
movq %rax, -0x30(%rbp)
testq %rax, %rax
jne 0x489c
jmp 0x4913
andb $-0x8, %cl
cmpb $0x30, %cl
jne 0x48f2
movq %rax, %rdi
movq %r12, %rsi
movl $0x8, %edx
callq 0x21e0
movq %rax, %rcx
movq -0x30(%rbp), %rax
cmpb $0x3a, (%rax)
je 0x48fb
cmpl $0x7ff, %r13d           # imm = 0x7FF
ja 0x489c
jmp 0x4904
incq %rax
movq %rax, -0x30(%rbp)
jmp 0x489c
incq %rax
movq %rax, -0x30(%rbp)
jmp 0x4898
movw %cx, 0x9c(%r14,%r13,2)
leal 0x1(%r13), %ecx
jmp 0x4898
addq $0x78, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/aap[P]rx-0/ww1/mach.c
// Function: handlemsg
void
handlemsg(WWI *ww, Msg msg)
{
	switch(msg.cmd){
	case CMD_NONE:
		break;
	case CMD_SET_PC:
		ww->pc_sw = msg.arg & ADDRMASK;
		ww->pc = ww->pc_sw;
		break;
	case CMD_STEP:
		ww->order_by_order = 1;
		ww->run = 1;
		break;
	case CMD_RUN:
		ww->order_by_order = 0;
		ww->run = 1;
		break;
	case CMD_STOP:
		ww->run = 0;
		break;
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
leal -0x1(%rsi), %eax
cmpl $0x3, %eax
ja 0x4a71
leaq 0x28e2(%rip), %rcx      # 0x7314
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
shrq $0x20, %rsi
andl $0x7ff, %esi            # imm = 0x7FF
movw %si, (%rdi)
movw %si, 0x10(%rdi)
jmp 0x4a71
movabsq $0x100000000, %rax      # imm = 0x100000000
jmp 0x4a6d
movl $0x0, 0x8(%rdi)
jmp 0x4a71
movabsq $0x100000001, %rax      # imm = 0x100000001
movq %rax, 0x4(%rdi)
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/aap[P]rx-0/ww1/mach.c
// Function: handleio
void
handleio(WWI *ww)
{
	if(ww->active_unit && ww->active_unit->active){
		if(ww->ioc_out)
			ww->active_unit->record(ww, ww->active_unit);
		else
			ww->active_unit->read(ww, ww->active_unit);
	}

	if(ww->scope->fd >= 0 && hasinput(ww->scope->fd)){
		u32 input;
		if(readn(ww->scope->fd, &input, 4) < 0){
			ww->scope->fd = -1;
			return;
		}
		if(input & 0x80000000){
			// light pen/gun
			ww->scope->gunx = input & 01777;
			ww->scope->guny = (input>>10) & 01777;
			ww->scope->gun = (input>>20) & 1;
		}else{
			int id = input>>24;
			// we'll use FF register 2 for the input bits
			if(id == 0){
				ww->ffs[2] &= ~0140000;	// need upper 2 bits
				if(input & 0200) ww->ffs[2] |= 0100000;	// up
				if(input & 0100) ww->ffs[2] |= 0040000;	// down
			}else{
				ww->ffs[2] &= ~0030000;	// need next 2 bits
				if(input & 0200) ww->ffs[2] |= 0020000;	// up
				if(input & 0100) ww->ffs[2] |= 0010000;	// down
			}
		}
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %rbx
pushq %rax
movq %rdi, %rbx
movq 0x10d0(%rdi), %rsi
testq %rsi, %rsi
je 0x4aa0
cmpl $0x0, (%rsi)
je 0x4aa0
xorl %eax, %eax
cmpl $0x0, 0x10bc(%rbx)
sete %al
movq %rbx, %rdi
callq *0x18(%rsi,%rax,8)
movq 0x10e0(%rbx), %rax
movl 0x28(%rax), %edi
testl %edi, %edi
js 0x4b6a
callq 0x36a3
testl %eax, %eax
je 0x4b6a
movq 0x10e0(%rbx), %rax
movl 0x28(%rax), %edi
leaq -0xc(%rbp), %rsi
movl $0x4, %edx
callq 0x3764
testl %eax, %eax
js 0x4b0d
movl -0xc(%rbp), %eax
testl %eax, %eax
js 0x4b1d
movzwl 0x20(%rbx), %ecx
cmpl $0xffffff, %eax         # imm = 0xFFFFFF
ja 0x4b45
andl $0x3fff, %ecx           # imm = 0x3FFF
movl %eax, %edx
andl $-0x80, %edx
shll $0x8, %edx
orl %ecx, %edx
movw %dx, 0x20(%rbx)
testb $0x40, %al
je 0x4b6a
orl $0x4000, %edx           # imm = 0x4000
jmp 0x4b66
movq 0x10e0(%rbx), %rax
movl $0xffffffff, 0x28(%rax) # imm = 0xFFFFFFFF
jmp 0x4b6a
movl $0x3ff, %ecx            # imm = 0x3FF
movl %eax, %edx
andl %ecx, %edx
movq 0x10e0(%rbx), %rsi
movl %edx, 0x30(%rsi)
movl %eax, %edx
shrl $0xa, %edx
andl %ecx, %edx
movl %edx, 0x34(%rsi)
shrl $0x14, %eax
andl $0x1, %eax
movl %eax, 0x2c(%rsi)
jmp 0x4b6a
andl $0xffffcfff, %ecx       # imm = 0xFFFFCFFF
movl %eax, %edx
shll $0x6, %edx
andl $0x2000, %edx           # imm = 0x2000
orl %ecx, %edx
movw %dx, 0x20(%rbx)
testb $0x40, %al
je 0x4b6a
orl $0x1000, %edx           # imm = 0x1000
movw %dx, 0x20(%rbx)
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/aap[P]rx-0/ww1/mach.c
// Function: consthread
void*
consthread(void *arg)
{
	WWI *ww = (WWI*)arg;
	FILE *f;
	f = fdopen(ww->console_fd, "w");

	for(;;){
		fprintf(f, "\033[1J\033[H");	// clear
		fprintf(f, "CS/%02o\n", ww->cs);
		fprintf(f, "PC/%04o\n", ww->pc);
		fprintf(f, "PR/%06o\n", ww->par);
		fprintf(f, "AC/%06o\n", ww->ac);
		fprintf(f, "AR/%06o\n", ww->ar);
		fprintf(f, "BR/%06o\n", ww->br);
		usleep(50000);
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rdi, %rbx
movl 0x10f0(%rdi), %edi
leaq 0x133f(%rip), %rsi      # 0x742d
callq 0x2260
movq %rax, %r14
leaq 0x1355(%rip), %r12      # 0x7452
leaq 0x1357(%rip), %r13      # 0x745b
leaq 0x1359(%rip), %r15      # 0x7464
movl $0x7, %esi
movl $0x1, %edx
leaq 0x1313(%rip), %rdi      # 0x742f
movq %r14, %rcx
callq 0x2380
movzwl 0x14(%rbx), %edx
movq %r14, %rdi
leaq 0x1305(%rip), %rsi      # 0x7437
xorl %eax, %eax
callq 0x21d0
movzwl 0x10(%rbx), %edx
movq %r14, %rdi
leaq 0x12f9(%rip), %rsi      # 0x7440
xorl %eax, %eax
callq 0x21d0
movzwl 0x109c(%rbx), %edx
movq %r14, %rdi
leaq 0x12ea(%rip), %rsi      # 0x7449
xorl %eax, %eax
callq 0x21d0
movzwl 0x10a8(%rbx), %edx
movq %r14, %rdi
movq %r12, %rsi
xorl %eax, %eax
callq 0x21d0
movzwl 0x10a0(%rbx), %edx
movq %r14, %rdi
movq %r13, %rsi
xorl %eax, %eax
callq 0x21d0
movzwl 0x10ac(%rbx), %edx
movq %r14, %rdi
movq %r15, %rsi
xorl %eax, %eax
callq 0x21d0
movl $0xc350, %edi           # imm = 0xC350
callq 0x2420
jmp 0x610b
// File: /workspace/github_c_makefile_star2_O3/aap[P]rx-0/ww1/mach.c
// Function: cpu_start
void
cpu_start(Addr a)
{
	Msg msg;
	msg.cmd = CMD_SET_PC;
	msg.arg = a;
	chansend(cmdchan, &msg);
	msg.cmd = CMD_RUN;
	chansend(cmdchan, &msg);
	chansend(cmdchan, &msg_none);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %rbx
pushq %rax
leaq -0x10(%rbp), %rbx
movl $0x1, (%rbx)
movl %edi, 0x4(%rbx)
movq 0xa56d(%rip), %rdi      # 0x10738
movq %rbx, %rsi
callq 0x3efc
movl $0x3, (%rbx)
movq 0xa558(%rip), %rdi      # 0x10738
movq %rbx, %rsi
callq 0x3efc
movq 0xa549(%rip), %rdi      # 0x10738
leaq 0xa54a(%rip), %rsi      # 0x10740
callq 0x3efc
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/aap[P]rx-0/ww1/mach.c
// Function: cpu_setpc
void
cpu_setpc(Addr pc)
{
	Msg msg;
	msg.cmd = CMD_SET_PC;
	msg.arg = pc;
	chansend(cmdchan, &msg);
	chansend(cmdchan, &msg_none);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
leaq -0x8(%rbp), %rsi
movl $0x1, (%rsi)
movl %edi, 0x4(%rsi)
movq 0xa51a(%rip), %rdi      # 0x10738
callq 0x3efc
movq 0xa50e(%rip), %rdi      # 0x10738
leaq 0xa50f(%rip), %rsi      # 0x10740
callq 0x3efc
addq $0x10, %rsp
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/lukexi[P]eglstreams-mini/acquire-thread-one.c
// Function: AcquireThreadMain
void* AcquireThreadMain(void* Arg) {
    egl_state* EGL = Arg;

    while (1) {
        for (int DisplayIndex = 0; DisplayIndex < EGL->DisplaysCount; DisplayIndex++) {
            egl_display* Display = &EGL->Displays[DisplayIndex];
            if (Display->PageFlipPending) {
                continue;
            }
            EGLint StreamState = EGLQueryStreamState(Display->DisplayDevice, Display->Stream);
            if (StreamState == EGL_STREAM_STATE_NEW_FRAME_AVAILABLE_KHR) {
                NEWTIME(StreamAcquire);
                EGLStreamAcquire(Display);
                ENDTIME(StreamAcquire);
            }
        }

    }
    return NULL;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rdi, %rbx
movl 0x8(%rdi), %eax
leaq 0x2ac4(%rip), %r14      # 0x5028
leaq 0x2ad0(%rip), %r15      # 0x503b
testl %eax, %eax
jle 0x256b
xorl %r13d, %r13d
xorl %ebp, %ebp
movq (%rbx), %r12
cmpb $0x0, 0x50(%r12,%r13)
jne 0x25d3
movq 0x30(%r12,%r13), %rdi
movq 0x40(%r12,%r13), %rsi
callq 0x3622
cmpl $0x3218, %eax           # imm = 0x3218
jne 0x25d3
addq %r13, %r12
xorl %eax, %eax
callq 0x4295
movss %xmm0, 0x4(%rsp)
movq %r12, %rdi
callq 0x30a6
xorl %eax, %eax
callq 0x4295
subss 0x4(%rsp), %xmm0
mulss 0x2a42(%rip), %xmm0     # 0x5004
cvtss2sd %xmm0, %xmm0
movq %r14, %rdi
movq %r15, %rsi
movb $0x1, %al
callq 0x2050
incq %rbp
movslq 0x8(%rbx), %rax
addq $0x58, %r13
cmpq %rax, %rbp
jl 0x2574
jmp 0x256b
// File: /workspace/github_c_makefile_star2_O3/ksherlock[P]nroff_man/read1.c
// Function: man_warnc
void man_warnc(int e, const char *msg) {
	if (so_index >= 0) {
		fprintf(stderr, "%s:%d: ",
			so_entries[so_index].name,
			so_entries[so_index].line);
	}
	fputs(msg, stderr);
	if (e) {
		fputs(": ", stderr);
		fputs(strerror(e), stderr);
	}
	fputc('\n', stderr);
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rsi, %r14
movl %edi, %ebx
movslq 0xa14f(%rip), %rax      # 0xe340
testq %rax, %rax
js 0x4222
movq 0x9dfb(%rip), %rcx      # 0xdff8
movq (%rcx), %rdi
imulq $0x18, %rax, %rax
leaq 0xb205(%rip), %rcx      # 0xf410
movq 0x8(%rax,%rcx), %rdx
movl 0x10(%rax,%rcx), %ecx
leaq 0x53e6(%rip), %rsi      # 0x9601
xorl %eax, %eax
callq 0x4100
movq 0x9dcf(%rip), %r15      # 0xdff8
movq (%r15), %rsi
movq %r14, %rdi
callq 0x40b0
testl %ebx, %ebx
jne 0x4248
movq (%r15), %rsi
pushq $0xa
popq %rdi
popq %rbx
popq %r14
popq %r15
jmp 0x40d0
movq (%r15), %rsi
leaq 0x53b4(%rip), %rdi      # 0x9606
callq 0x40b0
movl %ebx, %edi
callq 0x41a0
movq (%r15), %rsi
movq %rax, %rdi
callq 0x40b0
jmp 0x4238
// File: /workspace/github_c_makefile_star2_O3/ksherlock[P]nroff_man/read1.c
// Function: man_warnc1s
void man_warnc1s(int e, const char *msg, const char *s) {
	if (so_index >= 0) {
		fprintf(stderr, "%s:%d: ",
			so_entries[so_index].name,
			so_entries[so_index].line);
	}
	fprintf(stderr, msg, s);
	if (e) {
		fputs(": ", stderr);
		fputs(strerror(e), stderr);
	}
	fputc('\n', stderr);
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rdx, %r14
movq %rsi, %r15
movl %edi, %ebx
movslq 0xa0be(%rip), %rax      # 0xe340
testq %rax, %rax
js 0x42b3
movq 0x9d6a(%rip), %rcx      # 0xdff8
movq (%rcx), %rdi
imulq $0x18, %rax, %rax
leaq 0xb174(%rip), %rcx      # 0xf410
movq 0x8(%rax,%rcx), %rdx
movl 0x10(%rax,%rcx), %ecx
leaq 0x5355(%rip), %rsi      # 0x9601
xorl %eax, %eax
callq 0x4100
movq 0x9d3e(%rip), %r12      # 0xdff8
movq (%r12), %rdi
movq %r15, %rsi
movq %r14, %rdx
xorl %eax, %eax
callq 0x4100
testl %ebx, %ebx
jne 0x42e6
movq (%r12), %rsi
pushq $0xa
popq %rdi
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
jmp 0x40d0
movq (%r12), %rsi
leaq 0x5315(%rip), %rdi      # 0x9606
callq 0x40b0
movl %ebx, %edi
callq 0x41a0
movq (%r12), %rsi
movq %rax, %rdi
callq 0x40b0
jmp 0x42cf
// File: /workspace/github_c_makefile_star2_O3/ksherlock[P]nroff_man/read1.c
// Function: get_arg
int get_arg(unsigned *i_ptr, unsigned type) {
	unsigned i = *i_ptr;
	uint_fast8_t c = type;

	if (type == 0) c = type = buffer[i++];
	arg_buffer[0] = 0;
	if (type == 0) return 0; /* error. */
	if (type == '[') {
		unsigned j = 0;
		for (;;) {
			c = buffer[i++];
			if (c == 0) return 0;
			if (c == ']') break;
			if (j < 31) arg_buffer[j] = c;
			++j;
		}
		if (j < 32)
			arg_buffer[j] = 0;
		else arg_buffer[31] = 0;
		*i_ptr = i;
		return j;
	}
	if (type == '(') {
		c = buffer[i++];
		if (!c) return 0;
		arg_buffer[0] = c;
		c = buffer[i++];
		if (!c) return 0;
		arg_buffer[1] = c;
		arg_buffer[2] = 0;
		*i_ptr = i;
		return 2;
	}
	arg_buffer[0] = c;
	arg_buffer[1] = 0;
	*i_ptr = i;
	return 1;
}

// Assembly:
movl (%rdi), %ecx
testl %esi, %esi
je 0x47c4
movl %esi, %eax
movl %eax, %edx
jmp 0x47d3
leaq 0x9bd5(%rip), %rax      # 0xe3a0
movb (%rcx,%rax), %dl
incl %ecx
movzbl %dl, %eax
movb $0x0, 0xabc6(%rip)      # 0xf3a0
testl %eax, %eax
je 0x4892
cmpl $0x28, %eax
je 0x4825
cmpl $0x5b, %eax
jne 0x4863
xorl %eax, %eax
leaq 0x9bab(%rip), %rsi      # 0xe3a0
leaq 0xaba4(%rip), %rdx      # 0xf3a0
movl %ecx, %r8d
movzbl (%r8,%rsi), %r8d
testl %r8d, %r8d
je 0x4890
cmpl $0x5d, %r8d
je 0x4877
cmpl $0x1e, %eax
ja 0x481f
movl %eax, %r9d
movb %r8b, (%r9,%rdx)
incl %eax
incl %ecx
jmp 0x47fc
movl %ecx, %eax
leaq 0x9b72(%rip), %rdx      # 0xe3a0
movb (%rax,%rdx), %sil
xorl %eax, %eax
testb %sil, %sil
je 0x4892
leal 0x1(%rcx), %r8d
movb %sil, 0xab5c(%rip)      # 0xf3a0
movb (%r8,%rdx), %dl
testb %dl, %dl
je 0x4892
addl $0x2, %ecx
movb %dl, 0xab4c(%rip)       # 0xf3a1
movb $0x0, 0xab46(%rip)      # 0xf3a2
movl $0x2, %eax
jmp 0x488d
movb %dl, 0xab37(%rip)       # 0xf3a0
movb $0x0, 0xab31(%rip)      # 0xf3a1
movl $0x1, %eax
jmp 0x488d
cmpl $0x20, %eax
movl %eax, %esi
movl $0x1f, %r8d
cmovbq %rsi, %r8
movb $0x0, (%r8,%rdx)
incl %ecx
movl %ecx, (%rdi)
retq
xorl %eax, %eax
retq
// File: /workspace/github_c_makefile_star2_O3/ksherlock[P]nroff_man/read1.c
// Function: read_init
void read_init(FILE *fp, const char *name) {
	int i;

	type = fp ? tkTEXT : tkEOF;
	argc = 0;
	argv[0] = NULL;

	cc = '.';
	c2 = '\'';
	ec = '\\';

	ad = 'b'; 
	fi = 1;
	na = 0;
	hy = 1;
	ns = 0;

	ti = -1;
	in = prev_in = 0;
	ll = prev_ll = 78;
	ft = prev_ft = FONT_R;
	width = 78;
	line = 1;
	ignore = 0;

	render_init();


	for (i = 0; i <= so_index; ++i) free(so_entries[i].name);
	for (i = 1; i <= so_index; ++i) fclose(so_entries[i].fp);
	so_index = -1;

	if (fp) {
		so_index = 0;
		so_entries[0].fp = fp;
		so_entries[0].name = strdup(name);
		so_entries[0].line = 0;
	}
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq %rdi, %r14
xorl %eax, %eax
testq %rdi, %rdi
setne %al
movl %eax, 0x9a5e(%rip)      # 0xe310
xorl %eax, %eax
movl %eax, 0x9aa6(%rip)      # 0xe360
movq $0x0, 0xaafb(%rip) # 0xf3c0
movb $0x2e, 0x9a70(%rip)     # 0xe33c
movb $0x27, 0x9a6a(%rip)     # 0xe33d
movb $0x5c, 0x9a64(%rip)     # 0xe33e
movl $0x62, 0x9a30(%rip)     # 0xe314
movl $0x1, %ecx
movl %ecx, 0x9a29(%rip)      # 0xe318
movl %eax, 0x9a6f(%rip)      # 0xe364
movl %ecx, 0x9a21(%rip)      # 0xe31c
movl %eax, 0x9a67(%rip)      # 0xe368
movl $0xffffffff, 0x9a1d(%rip) # imm = 0xFFFFFFFF
movl %eax, 0x9a5f(%rip)      # 0xe370
movl %eax, 0x9a55(%rip)      # 0xe36c
movl $0x4e, %edx
movl %edx, 0x9a0e(%rip)      # 0xe330
movl %edx, 0x9a04(%rip)      # 0xe32c
movl $0x83, %esi
movl %esi, 0x99f1(%rip)      # 0xe324
movl %esi, 0x99e7(%rip)      # 0xe320
movl %edx, 0x99f5(%rip)      # 0xe334
movl %ecx, 0x99f3(%rip)      # 0xe338
movl %eax, 0x9a29(%rip)      # 0xe374
callq 0x7428
movl 0x99e9(%rip), %r15d     # 0xe340
testl %r15d, %r15d
js 0x49af
leaq (%r15,%r15,2), %rax
leaq 0x18(,%rax,8), %r12
xorl %r13d, %r13d
leaq 0xaa9e(%rip), %rbp      # 0xf410
movq 0x8(%r13,%rbp), %rdi
callq 0x4040
addq $0x18, %r13
cmpq %r13, %r12
jne 0x4972
testq %r15, %r15
je 0x49af
leaq 0xaa97(%rip), %r15      # 0xf428
xorl %r12d, %r12d
movq (%r15), %rdi
callq 0x4080
movslq 0x999d(%rip), %rax      # 0xe340
incq %r12
addq $0x18, %r15
cmpq %rax, %r12
jl 0x4994
movl $0xffffffff, 0x9987(%rip) # imm = 0xFFFFFFFF
testq %r14, %r14
je 0x49e2
xorl %ebp, %ebp
movl %ebp, 0x997a(%rip)      # 0xe340
movq %r14, 0xaa43(%rip)      # 0xf410
movq %rbx, %rdi
callq 0x4190
movq %rax, 0xaa3c(%rip)      # 0xf418
movl %ebp, 0xaa3e(%rip)      # 0xf420
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/ksherlock[P]nroff_man/read2.c
// Function: font
static unsigned char *font(unsigned f) {
	int i,j,k;
	uint_fast8_t c;

	buffer[0] = f;

	type = tkTEXT;
	for(i = 0, j = 1; i <argc; ++i) {
		const unsigned char *cp = argv[i];
		if (i > 0) buffer[j++] = ' ';
		k = 0;
		while ((c = cp[k++])) buffer[j++] = c;
	}
	buffer[j++] = FONT_R;
	buffer[j++] = 0;
	return buffer;
}

// Assembly:
pushq %rbx
movb %dil, 0x928a(%rip)      # 0xf470
leaq 0x8123(%rip), %rax      # 0xe310
movl $0x1, (%rax)
leaq 0x8166(%rip), %rax      # 0xe360
movslq (%rax), %rcx
movl $0x1, %eax
testq %rcx, %rcx
jle 0x6258
xorl %edx, %edx
leaq 0x91b0(%rip), %rsi      # 0xf3c0
leaq 0x9259(%rip), %rdi      # 0xf470
testq %rdx, %rdx
je 0x6226
movslq %eax, %r8
incl %eax
movb $0x20, (%r8,%rdi)
movq (%rsi,%rdx,8), %r8
movb (%r8), %r9b
testb %r9b, %r9b
je 0x6250
movslq %eax, %r10
xorl %r11d, %r11d
leaq (%r10,%r11), %rbx
movb %r9b, (%rdi,%rbx)
movb 0x1(%r8,%r11), %r9b
incq %r11
testb %r9b, %r9b
jne 0x6238
addl %r11d, %eax
incq %rdx
cmpq %rcx, %rdx
jne 0x6217
cltq
leaq 0x920f(%rip), %rcx      # 0xf470
movw $0x83, (%rax,%rcx)
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O3/ksherlock[P]nroff_man/read2.c
// Function: fonts
static unsigned char *fonts(unsigned f1, unsigned f2) {
	unsigned i,j,k;
	uint_fast8_t c;

	type = tkTEXT;
	for (i = 0, j = 0; i < argc; ++i) {
		const unsigned char *cp = argv[i];
		buffer[j++] = i & 0x01 ? f2 : f1;
		k = 0;
		while ((c = cp[k++])) buffer[j++] = c;
	}

	buffer[j++] = FONT_R;
	buffer[j++] = 0;
	return buffer;
}

// Assembly:
pushq %r14
pushq %rbx
leaq 0x809d(%rip), %rax      # 0xe310
movl $0x1, (%rax)
leaq 0x80e0(%rip), %rax      # 0xe360
movl (%rax), %ecx
testq %rcx, %rcx
je 0x62e1
xorl %edx, %edx
leaq 0x9130(%rip), %r8       # 0xf3c0
leaq 0x91d9(%rip), %r9       # 0xf470
xorl %eax, %eax
movq (%r8,%rdx,8), %r10
testb $0x1, %dl
movl %esi, %r11d
cmovel %edi, %r11d
movl %eax, %ebx
movb %r11b, (%rbx,%r9)
movb (%r10), %bl
testb %bl, %bl
je 0x62d5
movl $0x1, %r11d
leal (%rax,%r11), %r14d
movb %bl, (%r14,%r9)
movl %r11d, %ebx
movb (%r10,%rbx), %bl
incl %r11d
testb %bl, %bl
jne 0x62ba
addl %r11d, %eax
jmp 0x62d7
incl %eax
incq %rdx
cmpq %rcx, %rdx
jne 0x6299
jmp 0x62e3
xorl %eax, %eax
movl %eax, %ecx
incl %eax
leaq 0x9182(%rip), %rdx      # 0xf470
movb $-0x7d, (%rcx,%rdx)
movb $0x0, (%rax,%rdx)
popq %rbx
popq %r14
retq
nop
// File: /workspace/github_c_makefile_star2_O3/ksherlock[P]nroff_man/read3.c
// Function: get_unit
int get_unit(const unsigned char *arg, int dv, int base) {
	double d;
	char sign = 0;
	uint_fast8_t c;
	char *cp = NULL;
	int rv;
	unsigned i;
	
	if (!arg) return dv;

	i = 0;
	while (arg[i] == ' ') ++i;
	arg += i;
	c = arg[0];
	if (!c) return dv;

	if (c == '+' || c == '-') {
		sign = c;
		++arg;
	}
	c = arg[0];
	if (!isdigit(c) && c != '.') return dv;

	errno = 0;
	d = strtod(arg, &cp);
	if (errno) return dv;

	c = *cp;
	switch (c) {
		case 'c': /* centimeter */
			d *= 94.5 / 24.0;
			break;
		case 'i': /* inch */
			d *= 10.0; /* 240.0 / 24.0; */
			break;
		case 'P': /* pica - 1/6 inch */
			d *= 10.0 / 6.0;
			break;
		case 'p': /* point - 1/72 inch */
			d *= 10.0 / 72.0;
			break;
		case 'f':
			d *= 65536.0 / 24.0;
			break;
		case 'M': /* mini em - 1/100 em */
			d  /= 100.0;
			break;

		case 'm':
		case 'n':
		case 'u':
		case 'v':
			break;
		default:
			break;
	}

	rv = (int)d;
	if (sign && base >= 0) {
		if (sign == '+') base += rv;
		else base -= rv;
		if (base < 0) return 0;
		return base;
	}
	if (sign == '-') rv = 0;

	return rv;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x10, %rsp
movl %esi, %ebp
movq $0x0, 0x8(%rsp)
testq %rdi, %rdi
je 0x67da
movl %edx, %ebx
movq %rdi, %r14
xorl %eax, %eax
movl %eax, %eax
movzbl (%r14,%rax), %r12d
cmpl $0x20, %r12d
jne 0x66da
incl %eax
jmp 0x66c9
testl %r12d, %r12d
je 0x67da
cmpl $0x2b, %r12d
je 0x66ef
cmpl $0x2d, %r12d
jne 0x66fa
addq %rax, %r14
incq %r14
movb (%r14), %r15b
jmp 0x6703
addq %rax, %r14
movl %r12d, %r15d
xorl %r12d, %r12d
callq 0x41c0
cmpb $0x2e, %r15b
je 0x6724
movq (%rax), %rax
movzbl %r15b, %ecx
movzwl (%rax,%rcx,2), %eax
andl $0x800, %eax            # imm = 0x800
je 0x67da
callq 0x4060
movq %rax, %r15
movl $0x0, (%rax)
leaq 0x8(%rsp), %rsi
movq %r14, %rdi
callq 0x4070
cmpl $0x0, (%r15)
jne 0x67da
movq 0x8(%rsp), %rax
movzbl (%rax), %eax
cmpl $0x65, %eax
jg 0x676f
cmpl $0x4d, %eax
je 0x6788
cmpl $0x50, %eax
je 0x679c
cmpl $0x63, %eax
jne 0x67ae
mulsd 0x304b(%rip), %xmm0     # 0x97b8
jmp 0x67ae
cmpl $0x66, %eax
je 0x6792
cmpl $0x69, %eax
je 0x67a6
cmpl $0x70, %eax
jne 0x67ae
mulsd 0x301a(%rip), %xmm0     # 0x97a0
jmp 0x67ae
divsd 0x3000(%rip), %xmm0     # 0x9790
jmp 0x67ae
mulsd 0x2ffe(%rip), %xmm0     # 0x9798
jmp 0x67ae
mulsd 0x3004(%rip), %xmm0     # 0x97a8
jmp 0x67ae
mulsd 0x3002(%rip), %xmm0     # 0x97b0
cvttsd2si %xmm0, %ebp
testl %ebx, %ebx
js 0x67d1
testl %r12d, %r12d
je 0x67d1
movl %ebp, %ecx
negl %ecx
cmpl $0x2b, %r12d
cmovel %ebp, %ecx
addl %ebx, %ecx
xorl %eax, %eax
testl %ecx, %ecx
cmovgl %ecx, %eax
jmp 0x67dc
xorl %eax, %eax
cmpl $0x2d, %r12d
cmovel %eax, %ebp
movl %ebp, %eax
addq $0x10, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/ksherlock[P]nroff_man/chars.c
// Function: special_char
const unsigned char *special_char(const unsigned char *s) {

	unsigned begin = 0;
	unsigned end = sizeof(char_table) / sizeof(char_table[0]);

	unsigned short target = (s[0] << 8) | (s[1] << 0);

	/* binary search */
	for (;;) {
		
		unsigned mid = (begin+end)>>1;
		unsigned key = char_table[mid].key;
		if (key == target) return char_table[mid].value;

		if (key < target) {
			begin = mid + 1;
			if (begin >= end) return "";
			continue;
		}
		/* key > target  */
		end = mid;
		if (end <= begin) return "";
		continue;
		
	}
}

// Assembly:
movzwl (%rdi), %eax
rolw $0x8, %ax
movzwl %ax, %ecx
xorl %edi, %edi
movl $0x130, %esi            # imm = 0x130
leaq 0x4adc(%rip), %rdx      # 0xbe70
leaq 0x2a97(%rip), %rax      # 0x9e32
leal (%rdi,%rsi), %r8d
shrl %r8d
leaq (%r8,%r8,2), %r9
movzwl (%rdx,%r9,8), %r10d
cmpl %r10d, %ecx
je 0x73c8
jbe 0x73bf
incl %r8d
movl %r8d, %edi
cmpl %esi, %r8d
jb 0x739b
jmp 0x73c7
movl %r8d, %esi
cmpl %edi, %r8d
ja 0x739b
retq
leaq (%rdx,%r9,8), %rax
movq 0x8(%rax), %rax
retq
// File: /workspace/github_c_makefile_star2_O3/ksherlock[P]nroff_man/chars.c
// Function: special_string
const unsigned char *special_string(const unsigned char *s) {

	unsigned begin = 0;
	unsigned end = sizeof(string_table) / sizeof(string_table[0]);

	unsigned short target = (s[0] << 8) | (s[1] << 0);

	/* binary search */
	for (;;) {
		
		unsigned mid = (begin+end)>>1;
		unsigned key = string_table[mid].key;
		if (key == target) return string_table[mid].value;

		if (key < target) {
			begin = mid + 1;
			if (begin >= end) return "";
			continue;
		}
		/* key > target  */
		end = mid;
		if (end <= begin) return "";
		continue;
		
	}
}

// Assembly:
movzwl (%rdi), %eax
rolw $0x8, %ax
movzwl %ax, %ecx
xorl %edi, %edi
movl $0x1e, %esi
leaq 0x6707(%rip), %rdx      # 0xdaf0
leaq 0x2a42(%rip), %rax      # 0x9e32
leal (%rdi,%rsi), %r8d
shrl %r8d
leaq (%r8,%r8,2), %r9
movzwl (%rdx,%r9,8), %r10d
cmpl %r10d, %ecx
je 0x741d
jbe 0x7414
incl %r8d
movl %r8d, %edi
cmpl %esi, %r8d
jb 0x73f0
jmp 0x741c
movl %r8d, %esi
cmpl %edi, %r8d
ja 0x73f0
retq
leaq (%rdx,%r9,8), %rax
movq 0x8(%rax), %rax
retq
nop
// File: /workspace/github_c_makefile_star2_O3/ksherlock[P]nroff_man/render.c
// Function: render_init
void render_init(void) {
	buffer_flip_flop = 0;
	buffer_width = 0;
	buffer_offset = 0;
	buffer_words = 0;
	buffer[0] = 0;
	prev_ftx = FONT_R;
}

// Assembly:
xorl %eax, %eax
movl %eax, 0x9580(%rip)      # 0x109b0
movl %eax, 0x957e(%rip)      # 0x109b4
movl %eax, 0x957c(%rip)      # 0x109b8
movl %eax, 0x957a(%rip)      # 0x109bc
movb $0x0, 0x9577(%rip)      # 0x109c0
movl $0x83, 0x6ef1(%rip)     # 0xe344
retq
// File: /workspace/github_c_makefile_star2_O3/ksherlock[P]nroff_man/render.c
// Function: set_font
void set_font(unsigned new_font) {


	if (new_font == FONT_P) new_font = prev_ft;

	if (new_font == FONT_X) {
		prev_ftx = ft;
	} else {
		prev_ft = ft;
	}

	if (ft == new_font) return;
	/* disable current font. */
	switch(ft) {
		case FONT_B: _(bold_end);
		case FONT_I: _(italic_end);
		case FONT_X: prev_ft = prev_ftx; break;
	}
	ft = new_font;
	switch(ft) {
		case FONT_B: _(bold_begin);
		case FONT_I: _(italic_begin);
	}
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movl %edi, %ebx
leaq 0x6ec3(%rip), %rax      # 0xe324
cmpl $0x86, %edi
jne 0x746b
movl (%rax), %ebx
cmpl $0x87, %ebx
leaq 0x6ea8(%rip), %r14      # 0xe320
movl (%r14), %ecx
leaq 0x6ec2(%rip), %rdx      # 0xe344
cmovneq %rax, %rdx
movl %ecx, (%rdx)
cmpl %ebx, %ecx
je 0x7534
cmpl $0x87, %ecx
je 0x74de
cmpl $0x85, %ecx
je 0x74b1
cmpl $0x84, %ecx
jne 0x74e6
leaq 0x87e9(%rip), %rax      # 0xfc98
jmp 0x74b8
leaq 0x87f0(%rip), %rax      # 0xfca8
movq (%rax), %rdi
testq %rdi, %rdi
je 0x74e6
leaq 0x6eb1(%rip), %rax      # 0xe378
cmpl $0x0, 0x20(%rax)
jne 0x74e6
movq 0x6aec(%rip), %rax      # 0xdfc0
movq (%rax), %rsi
callq 0x40b0
jmp 0x74e6
movl 0x6e60(%rip), %ecx      # 0xe344
movl %ecx, (%rax)
movl %ebx, (%r14)
cmpl $0x85, %ebx
je 0x7502
cmpl $0x84, %ebx
jne 0x7534
leaq 0x8790(%rip), %rax      # 0xfc90
jmp 0x7509
leaq 0x8797(%rip), %rax      # 0xfca0
movq (%rax), %rdi
testq %rdi, %rdi
je 0x7534
leaq 0x6e60(%rip), %rax      # 0xe378
cmpl $0x0, 0x20(%rax)
jne 0x7534
movq 0x6a9b(%rip), %rax      # 0xdfc0
movq (%rax), %rsi
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x40b0
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O3/ksherlock[P]nroff_man/render.c
// Function: reset_font
void reset_font(void) {
	switch(ft) {
		case FONT_B: _(bold_end);
		case FONT_I: _(italic_end);
	}
	ft = prev_ft = prev_ftx = FONT_R;
}

// Assembly:
pushq %rbx
leaq 0x6ddc(%rip), %rbx      # 0xe320
movl (%rbx), %eax
cmpl $0x85, %eax
je 0x755d
cmpl $0x84, %eax
jne 0x7588
leaq 0x873d(%rip), %rax      # 0xfc98
jmp 0x7564
leaq 0x8744(%rip), %rax      # 0xfca8
movq (%rax), %rdi
testq %rdi, %rdi
je 0x7588
leaq 0x6e05(%rip), %rax      # 0xe378
cmpl $0x0, 0x20(%rax)
jne 0x7588
movq 0x6a40(%rip), %rax      # 0xdfc0
movq (%rax), %rsi
callq 0x40b0
movl $0x83, %eax
movl %eax, 0x6db1(%rip)      # 0xe344
leaq 0x6d8a(%rip), %rcx      # 0xe324
movl %eax, (%rcx)
movl %eax, (%rbx)
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O3/ksherlock[P]nroff_man/render.c
// Function: set_in_ti
void set_in_ti(int new_in, int new_ti) {
	int lm;
	prev_in = in;
	in = new_in;
	ti = new_ti;
	lm = new_ti >= 0 ? new_ti : new_in;
	width = ll - lm;
}

// Assembly:
leaq 0x6d64(%rip), %rax      # 0xe36c
movl (%rax), %ecx
leaq 0x6d5f(%rip), %rdx      # 0xe370
movl %ecx, (%rdx)
movl %edi, (%rax)
leaq 0x6d0c(%rip), %rax      # 0xe328
movl %esi, (%rax)
testl %esi, %esi
cmovsl %edi, %esi
leaq 0x6d02(%rip), %rax      # 0xe32c
movl (%rax), %eax
subl %esi, %eax
leaq 0x6cff(%rip), %rcx      # 0xe334
movl %eax, (%rcx)
retq
// File: /workspace/github_c_makefile_star2_O3/ksherlock[P]nroff_man/render.c
// Function: set_ll
void set_ll(int new_ll) {
	int lm;
	prev_ll = ll;
	ll = new_ll;
	lm = ti >= 0 ? ti : in;
	width = ll - lm;
}

// Assembly:
leaq 0x6ced(%rip), %rax      # 0xe32c
movl (%rax), %ecx
leaq 0x6ce8(%rip), %rdx      # 0xe330
movl %ecx, (%rdx)
movl %edi, (%rax)
leaq 0x6cd5(%rip), %rax      # 0xe328
movl (%rax), %eax
testl %eax, %eax
jns 0x7662
leaq 0x6d0c(%rip), %rax      # 0xe36c
movl (%rax), %eax
subl %eax, %edi
leaq 0x6cc9(%rip), %rax      # 0xe334
movl %edi, (%rax)
retq
// File: /workspace/github_c_makefile_star2_O3/ksherlock[P]nroff_man/render.c
// Function: print
unsigned print(const unsigned char *cp, int fi) {
	unsigned i;
	uint_fast8_t prev = 0;
	unsigned length = 0;

	indent();
	for (i = 0; ;++i) {
		uint_fast8_t c = cp[i];
		if (c == 0) return length;
		switch(c) {
			case FONT_R: case FONT_B: case FONT_I: case FONT_P: case FONT_X:
				set_font(c);
				break;
			case HYPHEN: case ZWSPACE: break;
			case NBSPACE: case XSPACE: fputc(' ', stdout); length++; break;
			case ' ': case '\t':
				if (fi) {
					c = ' ';
					if (prev != ' ') { fputc(' ', stdout); length++; }
				} else {
					fputc(c, stdout); length++;
				}
				break;
			default: 
				if (flags.T == FMT_ASCII) {
					if (ft == FONT_B) {
						fputc(c, stdout);
						fputc(8, stdout);
					}
					if (ft == FONT_I) {
						fputs("_\x08", stdout);
					}
				}
				fputc(c, stdout); length++;
				break;
		}
		prev = c;
	}
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movl %esi, 0x4(%rsp)
movq %rdi, %r14
callq 0x77a3
xorl %r13d, %r13d
movl $0xf8, %ebx
xorl %eax, %eax
xorl %ebp, %ebp
movl %r13d, %ecx
movb (%r14,%rcx), %r15b
movzbl %r15b, %r12d
cmpl $0x7f, %r12d
jle 0x76e1
movl %r12d, %eax
addl $-0x80, %eax
cmpl $0x8, %eax
ja 0x770a
btl %eax, %ebx
jae 0x76bf
movl %r12d, %edi
callq 0x7454
jmp 0x7787
movl $0x3, %ecx
btl %eax, %ecx
jae 0x7787
movq 0x68ec(%rip), %rax      # 0xdfc0
movq (%rax), %rsi
movl $0x20, %edi
jmp 0x7780
cmpl $0x9, %r12d
je 0x76ed
cmpl $0x20, %r12d
jne 0x7701
cmpl $0x0, 0x4(%rsp)
je 0x7773
movb $0x20, %r15b
cmpb $0x20, %al
je 0x7787
jmp 0x76cd
testl %r12d, %r12d
je 0x7792
leaq 0x6c67(%rip), %rax      # 0xe378
cmpl $0x1, 0x20(%rax)
jne 0x7773
leaq 0x6c02(%rip), %rax      # 0xe320
movl (%rax), %eax
cmpl $0x84, %eax
jne 0x7756
movq 0x6892(%rip), %rax      # 0xdfc0
movq (%rax), %rsi
movl %r12d, %edi
callq 0x40d0
movq 0x6880(%rip), %rax      # 0xdfc0
movq (%rax), %rsi
movl $0x8, %edi
callq 0x40d0
leaq 0x6bcc(%rip), %rax      # 0xe320
movl (%rax), %eax
cmpl $0x85, %eax
jne 0x7773
movq 0x685c(%rip), %rax      # 0xdfc0
movq (%rax), %rsi
leaq 0x26c2(%rip), %rdi      # 0x9e30
callq 0x40b0
movq 0x6846(%rip), %rax      # 0xdfc0
movq (%rax), %rsi
movl %r12d, %edi
callq 0x40d0
incl %ebp
incl %r13d
movl %r15d, %eax
jmp 0x7691
movl %ebp, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/ksherlock[P]nroff_man/render.c
// Function: indent
static void indent(void) {
	int i, amt;

	if (ti >= 0) {
		amt = ti;
		ti = -1;
		width = ll - in;
	} else {
		amt = in;
	}

	if (!amt) return;

	switch(ft) {
		case FONT_B: _(bold_end);
		case FONT_I: _(italic_end);
	}
	for (i = 0; i < amt; ++i) fputc(' ', stdout);
	switch(ft) {
		case FONT_B: _(bold_begin);
		case FONT_I: _(italic_begin);
	}
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
leaq 0x6b79(%rip), %rax      # 0xe328
movl (%rax), %ebx
testl %ebx, %ebx
js 0x77d8
movl $0xffffffff, (%rax)     # imm = 0xFFFFFFFF
leaq 0x6b6a(%rip), %rax      # 0xe32c
movl (%rax), %eax
leaq 0x6ba1(%rip), %rcx      # 0xe36c
subl (%rcx), %eax
leaq 0x6b60(%rip), %rcx      # 0xe334
movl %eax, (%rcx)
jmp 0x77e1
leaq 0x6b8d(%rip), %rax      # 0xe36c
movl (%rax), %ebx
testl %ebx, %ebx
je 0x789b
leaq 0x6b30(%rip), %r14      # 0xe320
movl (%r14), %eax
cmpl $0x85, %eax
je 0x780a
cmpl $0x84, %eax
jne 0x7835
leaq 0x8490(%rip), %rax      # 0xfc98
jmp 0x7811
leaq 0x8497(%rip), %rax      # 0xfca8
movq (%rax), %rdi
testq %rdi, %rdi
je 0x7835
leaq 0x6b58(%rip), %rax      # 0xe378
cmpl $0x0, 0x20(%rax)
jne 0x7835
movq 0x6793(%rip), %rax      # 0xdfc0
movq (%rax), %rsi
callq 0x40b0
testl %ebx, %ebx
jle 0x7851
movq 0x6780(%rip), %r15      # 0xdfc0
movq (%r15), %rsi
movl $0x20, %edi
callq 0x40d0
decl %ebx
jne 0x7840
movl (%r14), %eax
cmpl $0x85, %eax
je 0x786b
cmpl $0x84, %eax
jne 0x789b
leaq 0x8427(%rip), %rax      # 0xfc90
jmp 0x7872
leaq 0x842e(%rip), %rax      # 0xfca0
movq (%rax), %rdi
testq %rdi, %rdi
je 0x789b
leaq 0x6af7(%rip), %rax      # 0xe378
cmpl $0x0, 0x20(%rax)
jne 0x789b
movq 0x6732(%rip), %rax      # 0xdfc0
movq (%rax), %rsi
popq %rbx
popq %r14
popq %r15
jmp 0x40b0
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O3/ksherlock[P]nroff_man/render.c
// Function: xstrlen
unsigned xstrlen(const unsigned char *cp) {
	unsigned length = 0;
	unsigned i;
	for (i = 0; ; ++i) {
		uint_fast8_t c = cp[i];
		if (!c) return length;
		if (c <= NBSPACE) length++;
	}
}

// Assembly:
movb (%rdi), %dl
xorl %eax, %eax
testb %dl, %dl
je 0x78bf
movl $0x1, %ecx
cmpb $-0x7f, %dl
adcl $0x0, %eax
movl %ecx, %edx
movb (%rdi,%rdx), %dl
incl %ecx
testb %dl, %dl
jne 0x78ae
retq
// File: /workspace/github_c_makefile_star2_O3/ksherlock[P]nroff_man/render.c
// Function: xstrnlen
unsigned xstrnlen(const unsigned char *cp, unsigned max) {

	unsigned length = 0;
	unsigned i;
	for (i = 0; i < max; ++i) {
		uint_fast8_t c = cp[i];
		if (!c) return length;
		if (c <= NBSPACE) length++;
	}
	return length;
}

// Assembly:
testl %esi, %esi
je 0x78e3
movl %esi, %ecx
xorl %edx, %edx
xorl %eax, %eax
movb (%rdi,%rdx), %sil
testb %sil, %sil
je 0x78e2
cmpb $-0x7f, %sil
adcl $0x0, %eax
incq %rdx
cmpq %rdx, %rcx
jne 0x78ca
retq
xorl %eax, %eax
retq
// File: /workspace/github_c_makefile_star2_O3/ksherlock[P]nroff_man/render.c
// Function: append_font
void append_font(unsigned font) {
	/* todo - check if buffer is overflowing */

	/* if there is trailing WS, this inserts a FONT_X token before the whitespace. */
	unsigned k;
	unsigned xfont = 0;

	k = buffer_offset;
	if (k == 0) {
		buffer[0] = font;
		buffer_offset++;
		return;
	}

	while (k > 0) {
		uint_fast8_t c = buffer[--k];
		if (c == ' ' || c == XSPACE) {
			buffer[k+1] = c;
			xfont = 1;
		} else break;
	}
	if (xfont) {
		buffer[k+1] = FONT_X;
		++buffer_offset;
	}
	buffer[buffer_offset++] = font;
}

// Assembly:
movl 0x90cc(%rip), %eax      # 0x109b8
testq %rax, %rax
je 0x7925
movb $0x1, %dl
leaq 0x90c6(%rip), %rcx      # 0x109c0
movq %rax, %r8
movq %r8, %rsi
movzbl -0x1(%r8,%rcx), %r9d
cmpl $0x81, %r9d
je 0x7915
cmpl $0x20, %r9d
jne 0x7937
xorl %edx, %edx
movq %rsi, %r8
movb %r9b, (%rsi,%rcx)
decq %r8
jne 0x78fd
jmp 0x793c
movb %dil, 0x9094(%rip)      # 0x109c0
movl $0x1, 0x9082(%rip)      # 0x109b8
retq
testb $0x1, %dl
jne 0x7944
movl %esi, %edx
movb $-0x79, (%rdx,%rcx)
incl %eax
movl %eax, %edx
incl %edx
movl %edx, 0x906a(%rip)      # 0x109b8
movb %dil, (%rax,%rcx)
retq
// File: /workspace/github_c_makefile_star2_O3/ksherlock[P]nroff_man/render.c
// Function: set_tag
void set_tag(const unsigned char *cp, unsigned IP) {
	/* set the tag for IP/TP */
	unsigned n;

	/* assumes buffer has been flushed */
	/* set_in_ti(LM + IP, LM); */

	n = xstrlen(cp);
	if (n >= width || n >= IP) { 
		append(cp);
		flush(0);
	} else {
		uint_fast8_t c;
		unsigned i;
		for (i = 0; ; ++i) {
			c = cp[i];
			if (c == 0) break;
			if (c == ' ' || c == '\t') c = NBSPACE;
			buffer[buffer_offset++] = c;
			if (c <= NBSPACE) buffer_width++;
		}
		buffer[buffer_offset] = 0;

		while(buffer_width < IP) {
			buffer[buffer_offset++] = NBSPACE;
			buffer_width++;
		}
		buffer[buffer_offset] = 0;
	}
}

// Assembly:
pushq %rbx
movb (%rdi), %dl
testb %dl, %dl
je 0x7f61
xorl %eax, %eax
movl $0x1, %ecx
movl %edx, %r8d
cmpb $-0x7f, %r8b
adcl $0x0, %eax
movl %ecx, %r8d
movb (%rdi,%r8), %r8b
incl %ecx
testb %r8b, %r8b
jne 0x7ecd
cmpl %esi, %eax
jae 0x7fb0
leaq 0x6443(%rip), %rcx      # 0xe334
cmpl (%rcx), %eax
jae 0x7fb0
movl 0x8ab9(%rip), %eax      # 0x109b8
movl 0x8aaf(%rip), %ecx      # 0x109b4
testb %dl, %dl
je 0x7f7d
movl $0x1, %r8d
movl $0x80, %r9d
leaq 0x8aa4(%rip), %r10      # 0x109c0
leal (%rax,%r8), %r11d
decl %r11d
cmpb $0x9, %dl
movzbl %dl, %edx
movl %edx, %ebx
cmovel %r9d, %ebx
cmpb $0x20, %dl
cmovel %r9d, %ebx
movb %bl, (%r11,%r10)
cmpb $-0x80, %bl
ja 0x7f47
incl %ecx
movl %ecx, 0x8a6d(%rip)      # 0x109b4
movl %r8d, %edx
movb (%rdi,%rdx), %dl
incl %r8d
testb %dl, %dl
jne 0x7f1c
addl %r8d, %eax
decl %eax
movl %eax, 0x8a59(%rip)      # 0x109b8
jmp 0x7f7d
testl %esi, %esi
je 0x7fb0
leaq 0x63c8(%rip), %rax      # 0xe334
cmpl $0x0, (%rax)
je 0x7fb0
movl 0x8a41(%rip), %eax      # 0x109b8
movl 0x8a37(%rip), %ecx      # 0x109b4
movl %eax, %edi
leaq 0x8a3a(%rip), %rdx      # 0x109c0
movb $0x0, (%rdi,%rdx)
cmpl %esi, %ecx
jae 0x7faa
movl %eax, %edi
incl %eax
movb $-0x80, (%rdi,%rdx)
incl %ecx
cmpl %ecx, %esi
jne 0x7f8e
movl %eax, 0x8a16(%rip)      # 0x109b8
movl %esi, 0x8a0c(%rip)      # 0x109b4
movl %eax, %edi
movb $0x0, (%rdi,%rdx)
popq %rbx
retq
callq 0x7953
xorl %edi, %edi
popq %rbx
jmp 0x7bfd
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O3/ksherlock[P]nroff_man/tbl.c
// Function: num_width
unsigned num_width(const char *cp, unsigned n, int *offset) {

	int zwsp = -1;
	int dig = -1;
	int dot = -1;
	unsigned l = 0;
	int st = 0;
	for (unsigned i = 0; i < n; ++i) {
		unsigned c = cp[i];
		if (c == ZWSPACE && zwsp < 0) zwsp = l+1;
		if (c > XSPACE) continue;
		++l;

		st <<= 2;
		if (c == '.') st |= 0b01;
		else if (isdigit(c)) {
			dig = l+1;
			st |= 0b11;
		}
		st &= 0b1111;
		if (st == 0b1101) dot = l;
		if (st == 0b0111) dot = l-1;
	}
	if (dot < 0) dot = dig;
	if (zwsp >= 0) dot = zwsp;
	*offset = dot;
	return l;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
testl %esi, %esi
je 0x8065
movq %rdi, %r13
movq %rdx, 0x10(%rsp)
movl %esi, %ecx
movl $0xffffffff, %r12d      # imm = 0xFFFFFFFF
xorl %ebx, %ebx
xorl %ebp, %ebp
xorl %r15d, %r15d
movl $0xffffffff, 0x4(%rsp)  # imm = 0xFFFFFFFF
movq %rcx, 0x8(%rsp)
movsbq (%r13,%rbx), %r14
testq %r14, %r14
js 0x804b
shll $0x2, %ebp
cmpb $0x2e, %r14b
jne 0x8013
orl $0x1, %ebp
jmp 0x8033
callq 0x41c0
movq (%rax), %rax
testb $0x8, 0x1(%rax,%r14,2)
je 0x802e
leal 0x2(%r15), %eax
movl %eax, 0x4(%rsp)
orl $0x3, %ebp
movq 0x8(%rsp), %rcx
leal 0x1(%r15), %eax
andl $0xf, %ebp
cmpl $0xd, %ebp
cmovel %eax, %r12d
cmpl $0x7, %ebp
cmovel %r15d, %r12d
movl %eax, %r15d
incq %rbx
cmpq %rbx, %rcx
jne 0x7ffa
testl %r12d, %r12d
movl 0x4(%rsp), %eax
cmovnsl %r12d, %eax
movq 0x10(%rsp), %rdx
jmp 0x806d
movl $0xffffffff, %eax       # imm = 0xFFFFFFFF
xorl %r15d, %r15d
movl %eax, (%rdx)
movl %r15d, %eax
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/liuhaotian[P]xmppsh/libstrophe/examples/basic.c
// Function: main
int main(int argc, char **argv)
{
    xmpp_ctx_t *ctx;
    xmpp_conn_t *conn;
    xmpp_log_t *log;
    char *jid, *pass, *host;

    /* take a jid and password on the command line */
    if (argc < 3 || argc > 4) {
        fprintf(stderr, "Usage: basic <jid> <pass> [<host>]\n\n");
        return 1;
    }

    jid = argv[1];
    pass = argv[2];
    host = NULL;

    if (argc == 4)
        host = argv[3];

    /* init library */
    xmpp_initialize();

    /* create a context */
    log = xmpp_get_default_logger(XMPP_LEVEL_DEBUG); /* pass NULL instead to silence output */
    ctx = xmpp_ctx_new(NULL, log);

    /* create a connection */
    conn = xmpp_conn_new(ctx);

    /* setup authentication information */
    xmpp_conn_set_jid(conn, jid);
    xmpp_conn_set_pass(conn, pass);

    /* initiate connection */
    xmpp_connect_client(conn, host, 0, conn_handler, ctx);

    /* enter the event loop -
       our connect handler will trigger an exit */
    xmpp_run(ctx);

    /* release our connection and context */
    xmpp_conn_release(conn);
    xmpp_ctx_free(ctx);

    /* final shutdown of the library */
    xmpp_shutdown();

    return 0;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
leal -0x5(%rdi), %eax
cmpl $-0x3, %eax
jbe 0x25a0
movq 0x8(%rsi), %r12
movq 0x10(%rsi), %r14
xorl %ebx, %ebx
cmpl $0x4, %edi
jne 0x251e
movq 0x18(%rsi), %r15
jmp 0x2521
xorl %r15d, %r15d
callq 0x4890
xorl %edi, %edi
callq 0x48e8
xorl %edi, %edi
movq %rax, %rsi
callq 0x4c51
movq %rax, %r13
movq %rax, %rdi
callq 0x3c68
movq %rax, %rbp
movq %rax, %rdi
movq %r12, %rsi
callq 0x42a5
movq %rbp, %rdi
movq %r14, %rsi
callq 0x42e1
leaq -0x96(%rip), %rcx       # 0x24cc
movq %rbp, %rdi
movq %r15, %rsi
xorl %edx, %edx
movq %r13, %r8
callq 0x4320
movq %r13, %rdi
callq 0x529a
movq %rbp, %rdi
callq 0x4074
movq %r13, %rdi
callq 0x4cba
callq 0x489c
movl %ebx, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
callq 0x23c4
movl $0x1, %ebx
jmp 0x258f
// File: /workspace/github_c_makefile_star2_O3/buptlxb[P]xRay/src/basic_block.cpp
// Function: BasicBlock::BasicBlock(unsigned long long, unsigned long long, Function*)
BasicBlock::BasicBlock(ADDR eip, ADDR vAddr, Function *func):
    hashNext(NULL), func(func), disasmed(false), disasm_pending(false)
    , visited(false)
{
    DISASM MyDisasm;
    memset(&MyDisasm, 0, sizeof(DISASM));
    MyDisasm.EIP = eip;
    MyDisasm.VirtualAddr = vAddr;
    MyDisasm.Archi = 64;
    MyDisasm.Options = ATSyntax|PrefixedNumeral|Tabulation;
    insts.push_back(MyDisasm);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x298, %rsp            # imm = 0x298
movq %rdx, %r12
movq %rsi, %r13
movq %rdi, %rbx
leaq 0x18(%rdi), %r14
xorps %xmm0, %xmm0
movups %xmm0, 0x40(%rdi)
movups %xmm0, 0x30(%rdi)
movups %xmm0, 0x20(%rdi)
movups %xmm0, 0x10(%rdi)
movups %xmm0, (%rdi)
leaq 0x10(%rdi), %r15
movq %rcx, 0x50(%rdi)
movw $0x0, 0x58(%rdi)
movb $0x0, 0x5a(%rdi)
leaq 0x18(%rsp), %rbp
movl $0x27d, %edx            # imm = 0x27D
movq %rbp, %rdi
xorl %esi, %esi
callq 0x80c0
movq %r13, -0x10(%rbp)
movq %r12, -0x8(%rbp)
movl $0x40, 0x44(%rbp)
movq $0x10401, 0x48(%rbp)    # imm = 0x10401
leaq 0x8(%rsp), %rdx
movq %rbx, %rdi
xorl %esi, %esi
callq 0x8b56
addq $0x298, %rsp            # imm = 0x298
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %r12
movq 0x30(%rbx), %rdi
testq %rdi, %rdi
je 0x8696
movq 0x40(%rbx), %rsi
subq %rdi, %rsi
callq 0x8170
movq %r14, %rdi
movq %rbx, %rsi
movq %r15, %rdx
callq 0x82d0
movq %r12, %rdi
callq 0x8270