LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_cpp_makefile_star2_O1/arnoldrobbins[P]mcilroy-regex/sed1.cpp
// Function: rc(Text*, Text*)
void
rc(Text *script, Text *t)
{
	uchar *u;
	if(!blank(t))
		synwarn("no space before file name");
	while(blank(t)) ;
	for(u=t->w; *t->w!='\n'; t->w++) ;
	if(u == t->w)
		syntax("missing file name");
	*t->w = 0;
	putint(script, (uchar*)lablook(u, &files) - files.s);
	*t->w = '\n';
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq %rdi, %r14
movq (%rsi), %rax
movzbl (%rax), %ecx
cmpl $0x20, %ecx
je 0x65fb
cmpl $0x9, %ecx
jne 0x6603
incq %rax
movq %rax, (%rbx)
jmp 0x6635
movq 0xd14e(%rip), %r15      # 0x13758
movq %r15, %rdi
movl $0xa, %esi
callq 0x50c0
subq %r15, %rax
leaq 0x6d30(%rip), %rdi      # 0xd351
leaq 0x6bc1(%rip), %rsi      # 0xd1e9
movq %rax, %rdx
movq %r15, %rcx
xorl %eax, %eax
callq 0x5320
movq (%rbx), %rax
incq %rax
movzbl -0x1(%rax), %ecx
cmpl $0x20, %ecx
je 0x6649
cmpl $0x9, %ecx
jne 0x664e
movq %rax, (%rbx)
jmp 0x6638
movq (%rbx), %r15
cmpb $0xa, (%r15)
movq %r15, %rax
je 0x666d
leaq 0x1(%r15), %rax
movq %rax, (%rbx)
cmpb $0xa, (%rax)
leaq 0x1(%rax), %rax
jne 0x665e
decq %rax
cmpq %rax, %r15
jne 0x66a4
movq 0xd0df(%rip), %r12      # 0x13758
movq %r12, %rdi
movl $0xa, %esi
callq 0x50c0
subq %r12, %rax
leaq 0x6cc1(%rip), %rdi      # 0xd351
leaq 0x6b6c(%rip), %rsi      # 0xd203
movq %rax, %rdx
movq %r12, %rcx
xorl %eax, %eax
callq 0x5899
movq (%rbx), %rax
movb $0x0, (%rax)
leaq 0xd0c7(%rip), %rsi      # 0x13778
movq %r15, %rdi
callq 0x6382
subl 0xd0c9(%rip), %eax      # 0x13788
movq %r14, %rdi
movl %eax, %esi
callq 0x62a4
movq (%rbx), %rax
movb $0xa, (%rax)
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
// File: /workspace/github_cpp_makefile_star2_O1/arnoldrobbins[P]mcilroy-regex/sed1.cpp
// Function: wc(Text*, Text*)
void
wc(Text *script, Text *t)
{
	intptr_t *p;
	rc(script, t);
	p = (intptr_t*)(files.s + ((int*)script->w)[-1]);
	if(*p != -1)
		return;
	*(FILE**)p = fopen((char*)(p+1), "w");
	if(*p == 0)
		syntax("can't open file for writing");
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
callq 0x65dd
movq 0xd09a(%rip), %r14      # 0x13788
movq (%rbx), %rax
movslq -0x4(%rax), %rax
cmpq $-0x1, (%r14,%rax)
jne 0x6717
addq %rax, %r14
leaq 0x8(%r14), %rdi
leaq 0x6b0b(%rip), %rsi      # 0xd215
callq 0x51c0
movq %rax, (%r14)
testq %rax, %rax
je 0x671f
addq $0x8, %rsp
popq %rbx
popq %r14
retq
movq 0xd032(%rip), %rbx      # 0x13758
movq %rbx, %rdi
movl $0xa, %esi
callq 0x50c0
subq %rbx, %rax
leaq 0x6c14(%rip), %rdi      # 0xd351
leaq 0x6ad3(%rip), %rsi      # 0xd217
movq %rax, %rdx
movq %rbx, %rcx
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x5899
// File: /workspace/github_cpp_makefile_star2_O1/arnoldrobbins[P]mcilroy-regex/sed1.cpp
// Function: Rc(Text*, Text*)
void				/* } */
Rc(Text *script, Text *t)
{
	int l;
	int *p;
	t = t;
	if(brack.w == 0 || (brack.w-=sizeof(int)) < brack.s)
		syntax("unmatched }");
	l = *(int*)brack.w;
	p = (int*)(script->s + l);
	l = script->w - script->s - l;
	if(l >= LMASK - 3*sizeof(int))	/* fixbrack could add 3 */
		syntax("{command-list} too long)");
	*p = (*p&~LMASK) | l;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
movq 0xcffa(%rip), %rax      # 0x13790
testq %rax, %rax
je 0x67af
addq $-0x4, %rax
movq %rax, 0xcfea(%rip)      # 0x13790
cmpq 0xcff3(%rip), %rax      # 0x137a0
jae 0x67e1
movq 0xcfa2(%rip), %r14      # 0x13758
movq %r14, %rdi
movl $0xa, %esi
callq 0x50c0
subq %r14, %rax
leaq 0x6b84(%rip), %rdi      # 0xd351
leaq 0x6a5f(%rip), %rsi      # 0xd233
movq %rax, %rdx
movq %r14, %rcx
xorl %eax, %eax
callq 0x5899
movq 0xcfa8(%rip), %rax      # 0x13790
movslq (%rax), %r14
movq 0x10(%rbx), %r15
movl (%rbx), %ebp
subl %r15d, %ebp
subl %r14d, %ebp
cmpl $0xfff3, %ebp           # imm = 0xFFF3
jb 0x6831
movq 0xcf52(%rip), %rbx      # 0x13758
movq %rbx, %rdi
movl $0xa, %esi
callq 0x50c0
subq %rbx, %rax
leaq 0x6b34(%rip), %rdi      # 0xd351
leaq 0x6a1b(%rip), %rsi      # 0xd23f
movq %rax, %rdx
movq %rbx, %rcx
xorl %eax, %eax
callq 0x5899
movzwl 0x2(%r15,%r14), %eax
shll $0x10, %eax
orl %ebp, %eax
movl %eax, (%r15,%r14)
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O1/arnoldrobbins[P]mcilroy-regex/sed1.cpp
// Function: Xc(Text*, Text*)
void
Xc(Text *script, Text *t)	/* # */
{
	script = script;	/* avoid use/set diagnostics */
	if(t->s[1]=='n')
		nflag = 1;
	while(*t->w != '\n')
		t->w++;
}

// Assembly:
movq 0x10(%rsi), %rax
cmpb $0x6e, 0x1(%rax)
jne 0x6862
leaq 0xce80(%rip), %rax      # 0x136dc
movl $0x1, (%rax)
movq (%rsi), %rax
cmpb $0xa, (%rax)
je 0x6879
incq %rax
movq %rax, (%rsi)
cmpb $0xa, (%rax)
leaq 0x1(%rax), %rax
jne 0x686d
retq
// File: /workspace/github_cpp_makefile_star2_O1/arnoldrobbins[P]mcilroy-regex/sed1.cpp
// Function: ac(Text*, Text*)
void
ac(Text *script, Text *t)
{
	if(*t->w++ != '\\' || *t->w++ != '\n')
		syntax("\\<newline> missing after command");
	for(;;) {
		while(bflag && blank(t)) ;
		assure(script, 2 + sizeof(int));
		switch(*t->w) {
		case 0:
			quit("bug: missed end of <text>");
		case '\n':
			*script->w++ = *t->w;
			*script->w++ = 0;
			script->w = (uchar*)intp(script->w);
			return;
		case '\\':
			t->w++;
		default:
			*script->w++ = *t->w++;
		}
	}
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rsi, %r14
movq %rdi, %rbx
movq (%rsi), %rax
leaq 0x1(%rax), %rcx
movq %rcx, (%rsi)
cmpb $0x5c, (%rax)
jne 0x68d6
leaq 0x2(%rax), %rcx
movq %rcx, (%r14)
cmpb $0xa, 0x1(%rax)
je 0x6908
movq 0xce7b(%rip), %r15      # 0x13758
movq %r15, %rdi
movl $0xa, %esi
callq 0x50c0
subq %r15, %rax
leaq 0x6a5d(%rip), %rdi      # 0xd351
leaq 0x6979(%rip), %rsi      # 0xd274
movq %rax, %rdx
movq %r15, %rcx
xorl %eax, %eax
callq 0x5899
leaq 0xcdd9(%rip), %r15      # 0x136e8
cmpl $0x0, (%r15)
je 0x6935
movq (%r14), %rax
movzbl (%rax), %ecx
cmpl $0x20, %ecx
je 0x6925
cmpl $0x9, %ecx
jne 0x692f
incq %rax
movq %rax, (%r14)
movb $0x1, %al
jmp 0x6931
xorl %eax, %eax
testb %al, %al
jne 0x690f
cmpq $0x0, 0x10(%rbx)
je 0x6948
movq 0x8(%rbx), %rax
incq %rax
cmpq %rax, (%rbx)
jb 0x6955
movq %rbx, %rdi
movl $0x6, %esi
callq 0x5a80
movq (%r14), %rcx
movzbl (%rcx), %eax
cmpl $0x5c, %eax
je 0x696b
cmpl $0xa, %eax
je 0x6999
testl %eax, %eax
jne 0x6971
jmp 0x698b
incq %rcx
movq %rcx, (%r14)
movq (%r14), %rax
leaq 0x1(%rax), %rcx
movq %rcx, (%r14)
movb (%rax), %al
movq (%rbx), %rcx
leaq 0x1(%rcx), %rdx
movq %rdx, (%rbx)
movb %al, (%rcx)
jmp 0x690f
leaq 0x6903(%rip), %rdi      # 0xd295
xorl %eax, %eax
callq 0x5899
movq (%r14), %rax
movb (%rax), %al
movq (%rbx), %rcx
leaq 0x1(%rcx), %rdx
movq %rdx, (%rbx)
movb %al, (%rcx)
movq (%rbx), %rax
leaq 0x1(%rax), %rcx
movq %rcx, (%rbx)
movb $0x0, (%rax)
movq (%rbx), %rax
addq $0x3, %rax
andq $-0x4, %rax
movq %rax, (%rbx)
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_cpp_makefile_star2_O1/arnoldrobbins[P]mcilroy-regex/sed2.cpp
// Function: writeline(Text*)
void
writeline(Text *data)
{
	int n = data->w - data->s;
	if(fwrite(data->s, 1, n, stdout) != n)
		quit(stdouterr);
	cputchar('\n');
}

// Assembly:
pushq %rbx
movl (%rdi), %eax
movq 0x10(%rdi), %rdi
subl %edi, %eax
movslq %eax, %rbx
movq 0xbfa1(%rip), %rax      # 0x12fb0
movq (%rax), %rcx
movl $0x1, %esi
movq %rbx, %rdx
callq 0x5300
cmpq %rbx, %rax
je 0x7032
movq 0xc275(%rip), %rdi      # 0x132a0
xorl %eax, %eax
callq 0x5899
movl $0xa, %edi
popq %rbx
jmp 0x6fe0
// File: /workspace/github_cpp_makefile_star2_O1/arnoldrobbins[P]mcilroy-regex/sed2.cpp
// Function: execute(Text*, Text*)
void
execute(Text *script, Text *data)
{
	uchar *pc;
	int sel;
	for(pc = script->s; pc < script->w; ) {
		sel = selected(pc, data);
		if(sel) {
			int cmd = code(*instr(pc));
			if(sel==2 && cmd=='c')
				cmd = 'd';
			pc = excom[cmd](script, pc, data);
			if(pc == 0)
				return;
		} else
			pc = nexti(pc);
	}
	if(!nflag)
		writeline(data);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq 0x10(%rdi), %r15
cmpq (%rdi), %r15
jae 0x70b8
movq %rdi, %r14
movl $0x64, %r12d
leaq 0xb0fc(%rip), %r13      # 0x12160
movq %r15, %rdi
movq %rbx, %rsi
callq 0x70e9
movl %eax, %ebp
movq %r15, %rdi
callq 0x6260
movl (%rax), %eax
testl %ebp, %ebp
je 0x70ad
shrl $0x10, %eax
movzbl %al, %eax
xorl $0x2, %ebp
movl %eax, %ecx
xorl $0x63, %ecx
orl %ebp, %ecx
cmovel %r12d, %eax
shll $0x3, %eax
movq %r14, %rdi
movq %r15, %rsi
movq %rbx, %rdx
callq *(%rax,%r13)
movq %rax, %r15
testq %rax, %rax
jne 0x70b3
jmp 0x70c4
movzwl %ax, %eax
addq %rax, %r15
cmpq (%r14), %r15
jb 0x7064
leaq 0xc61d(%rip), %rax      # 0x136dc
cmpl $0x0, (%rax)
je 0x70d3
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rbx, %rdi
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x6ffc
// File: /workspace/github_cpp_makefile_star2_O1/arnoldrobbins[P]mcilroy-regex/sed2.cpp
// Function: selected(unsigned char*, Text*)
int
selected(uchar *pc, Text *data)
{
	int active;
	int *ipc = (int*)pc;	/* points to address words */
	int *q = instr(pc);	/* points to instruction word */
	int neg = !!(*q & NEG);
	switch(q - ipc)	{
	case 0:			/* 0 address */
		return !neg;
	case 1:			/* 1 address */
		return neg ^ (sel1(ipc[0], data)==1);
	case 2:
		quit(IBUG,1);
	case 3:			/* 2 address */
		q--;		/* points to activity indicator */
		active = !(*q & INACT);
		if((*q&AMASK) < recno) {
			switch(sel1(ipc[active], data)) {
			case 0:
				if((active&ateof()) == 0)
					break;
			case 1:
				*q = recno;
				if(active)
					*q |= INACT;
				return (neg^1) << (!active&!ateof());
			case -1:
				if(active) {
					*q = recno | INACT;
					return neg;
				}
			}
		}
		return (neg^active) << 1;
	default:
		quit(IBUG,2);
		return 0;	/* dummy */
	}
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rsi, %r15
movq %rdi, %r12
callq 0x6260
movq %rax, %r14
subq %r12, %rax
sarq $0x2, %rax
cmpq $0x3, %rax
ja 0x71e7
movl (%r14), %ebx
shrl $0x18, %ebx
andl $0x1, %ebx
leaq 0x6239(%rip), %rcx      # 0xd35c
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
xorl $0x1, %ebx
jmp 0x721b
leaq 0x6249(%rip), %rdi      # 0xd384
movl $0x1, %esi
xorl %eax, %eax
callq 0x5899
movl -0x4(%r14), %ebp
movl %ebp, %r13d
notl %r13d
shrl $0x1f, %r13d
movl %ebp, %eax
andl $0x7fffffff, %eax       # imm = 0x7FFFFFFF
leaq 0xc575(%rip), %rcx      # 0x136d8
cmpl (%rcx), %eax
jge 0x7216
movl %r13d, %eax
movl (%r12,%rax,4), %edi
movq %r15, %rsi
callq 0x722c
cmpl $-0x1, %eax
je 0x71fe
cmpl $0x1, %eax
leaq 0xc54f(%rip), %rcx      # 0x136d8
je 0x71a4
testl %eax, %eax
jne 0x7216
callq 0x5b44
leaq 0xc539(%rip), %rcx      # 0x136d8
testl %r13d, %eax
je 0x7216
movl (%rcx), %eax
movl %eax, %ecx
orl $0x80000000, %ecx       # imm = 0x80000000
testl %ebp, %ebp
sets %bpl
cmovsl %eax, %ecx
movl %ecx, -0x4(%r14)
xorl $0x1, %ebx
callq 0x5b44
testl %eax, %eax
sete %cl
andb %bpl, %cl
shll %cl, %ebx
jmp 0x721b
movl (%r12), %edi
movq %r15, %rsi
callq 0x722c
xorl %ecx, %ecx
cmpl $0x1, %eax
sete %cl
xorl %ecx, %ebx
jmp 0x721b
leaq 0x6196(%rip), %rdi      # 0xd384
xorl %ebx, %ebx
movl $0x2, %esi
xorl %eax, %eax
callq 0x5899
jmp 0x721b
testl %ebp, %ebp
leaq 0xc4d1(%rip), %rcx      # 0x136d8
js 0x7216
movl $0x80000000, %eax       # imm = 0x80000000
orl (%rcx), %eax
movl %eax, -0x4(%r14)
jmp 0x721b
xorl %r13d, %ebx
addl %ebx, %ebx
movl %ebx, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O1/arnoldrobbins[P]mcilroy-regex/sed2.cpp
// Function: sel1(int, Text*)
int
sel1(int addr, Text *data)
{
	if(addr & REGADR)
		return regexec(readdr(addr),(char*)data->s,0,0,0) == 0;
	if(addr == recno)
		return 1;
	if(addr == DOLLAR)
		return ateof();
	if(addr < recno)
		return -1;
	return 0;
}

// Assembly:
testl %edi, %edi
js 0x7258
leaq 0xc4a1(%rip), %rax      # 0x136d8
movl (%rax), %ecx
movl $0x1, %eax
cmpl %edi, %ecx
je 0x7257
cmpl $0x7fffffff, %edi       # imm = 0x7FFFFFFF
je 0x5b44
xorl %eax, %eax
cmpl %edi, %ecx
setg %al
negl %eax
retq
pushq %rbx
movq %rsi, %rbx
callq 0x6373
movq 0x10(%rbx), %rsi
movq %rax, %rdi
xorl %edx, %edx
xorl %ecx, %ecx
xorl %r8d, %r8d
callq 0x9a72
movl %eax, %ecx
xorl %eax, %eax
testl %ecx, %ecx
sete %al
popq %rbx
retq
// File: /workspace/github_cpp_makefile_star2_O1/arnoldrobbins[P]mcilroy-regex/sed2.cpp
// Function: tcopy(Text*, Text*)
void
tcopy(Text *from, Text *to)
{
	int n = from->w - from->s;
	assure(to, n+1);
	memmove(to->w, from->s, n);
	to->w += n;
	*to->w = 0;
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rsi, %rbx
movq %rdi, %r14
movq (%rdi), %r15
subq 0x10(%rdi), %r15
cmpq $0x0, 0x10(%rsi)
je 0x72d8
movq 0x8(%rbx), %rax
movslq %r15d, %rcx
subq %rcx, %rax
cmpq %rax, (%rbx)
jb 0x72e4
leal 0x1(%r15), %esi
movq %rbx, %rdi
callq 0x5a80
movq (%rbx), %rdi
movq 0x10(%r14), %rsi
movslq %r15d, %r14
movq %r14, %rdx
callq 0x5290
movq (%rbx), %rax
leaq (%rax,%r14), %rcx
movq %rcx, (%rbx)
movb $0x0, (%rax,%r14)
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_cpp_makefile_star2_O1/arnoldrobbins[P]mcilroy-regex/sed2.cpp
// Function: De(Text*, unsigned char*, Text*)
uchar *
De(Text *script, uchar *pc, Text *data)
{
	int n;
	uchar *end = (uchar*)ustrchr(data->s, '\n');
	if(end == 0)
		return de(script, pc, data);
	end++;
	n = data->w - end;
	memmove(data->s, end, n+1);
	data->w = data->s + n;
	return script->s;
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rdx, %rbx
movq %rdi, %r14
movq 0x10(%rdx), %r15
movq %r15, %rdi
movl $0xa, %esi
callq 0x50c0
testq %rax, %rax
je 0x7389
incq %rax
movq (%rbx), %r12
subq %rax, %r12
leal 0x1(%r12), %ecx
movslq %ecx, %rdx
movq %r15, %rdi
movq %rax, %rsi
callq 0x5290
movslq %r12d, %rax
addq 0x10(%rbx), %rax
movq %rax, (%rbx)
movq 0x10(%r14), %rax
jmp 0x7393
movq %rbx, %rdi
callq 0x727f
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
// File: /workspace/github_cpp_makefile_star2_O1/arnoldrobbins[P]mcilroy-regex/sed2.cpp
// Function: Ee(Text*, unsigned char*, Text*)
uchar *
Ee(Text *script, uchar *pc, Text *data)
{
	script = script;
	data = data;
	if(printf("%d\n", recno) <= 0)
		quit(stdouterr);
	return nexti(pc);
}

// Assembly:
pushq %rbx
movq %rsi, %rbx
leaq 0xc321(%rip), %rax      # 0x136d8
movl (%rax), %esi
leaq 0x5fd7(%rip), %rdi      # 0xd397
xorl %eax, %eax
callq 0x5050
testl %eax, %eax
jg 0x73d9
movq 0xbece(%rip), %rdi      # 0x132a0
xorl %eax, %eax
callq 0x5899
movq %rbx, %rdi
callq 0x6260
movzwl (%rax), %eax
addq %rbx, %rax
popq %rbx
retq
// File: /workspace/github_cpp_makefile_star2_O1/arnoldrobbins[P]mcilroy-regex/sed2.cpp
// Function: Ge(Text*, unsigned char*, Text*)
uchar *
Ge(Text *script, uchar *pc, Text *data)
{
	script = script;
	if(hold.s == 0) 
		vacate(&hold);
	if(data->w > data->s)
		*data->w++ = '\n';
	tcopy(&hold, data);
	return nexti(pc);
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rdx, %r14
movq %rsi, %rbx
cmpq $0x0, 0xc3bd(%rip)      # 0x137b8
jne 0x7409
leaq 0xc3a4(%rip), %rdi      # 0x137a8
callq 0x727f
movq (%r14), %rax
cmpq 0x10(%r14), %rax
jbe 0x741c
leaq 0x1(%rax), %rcx
movq %rcx, (%r14)
movb $0xa, (%rax)
leaq 0xc385(%rip), %rdi      # 0x137a8
movq %r14, %rsi
callq 0x72b0
movq %rbx, %rdi
callq 0x6260
movzwl (%rax), %eax
addq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_cpp_makefile_star2_O1/arnoldrobbins[P]mcilroy-regex/sed2.cpp
// Function: He(Text*, unsigned char*, Text*)
uchar *
He(Text *script, uchar *pc, Text *data)
{
	script = script;
	assure(&hold, 1);
	*hold.w++ = '\n';
	tcopy(data, &hold);
	return nexti(pc);
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rdx, %r14
movq %rsi, %rbx
cmpq $0x0, 0xc341(%rip)      # 0x137b8
je 0x748d
movq 0xc330(%rip), %rax      # 0x137b0
addq $-0x2, %rax
cmpq %rax, 0xc31d(%rip)      # 0x137a8
jb 0x749e
leaq 0xc314(%rip), %rdi      # 0x137a8
movl $0x1, %esi
callq 0x5a80
leaq 0xc303(%rip), %rsi      # 0x137a8
movq 0xc2fc(%rip), %rax      # 0x137a8
leaq 0x1(%rax), %rcx
movq %rcx, 0xc2f1(%rip)      # 0x137a8
movb $0xa, (%rax)
movq %r14, %rdi
callq 0x72b0
movq %rbx, %rdi
callq 0x6260
movzwl (%rax), %eax
addq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_cpp_makefile_star2_O1/arnoldrobbins[P]mcilroy-regex/sed2.cpp
// Function: he(Text*, unsigned char*, Text*)
uchar *
he(Text *script, uchar *pc, Text *data)
{
	script = script;
	vacate(&hold);
	tcopy(data, &hold);
	return nexti(pc);
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rdx, %rbx
movq %rsi, %r14
leaq 0xc2be(%rip), %r15      # 0x137a8
movq %r15, %rdi
callq 0x727f
movq %rbx, %rdi
movq %r15, %rsi
callq 0x72b0
movq %r14, %rdi
callq 0x6260
movzwl (%rax), %eax
addq %r14, %rax
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_cpp_makefile_star2_O1/arnoldrobbins[P]mcilroy-regex/sed2.cpp
// Function: ie(Text*, unsigned char*, Text*)
uchar *
ie(Text *script, uchar *pc, Text *data)
{
	script = script;
	data = data;
	if(printf("%s", (char*)(instr(pc)+1)) <= 0)
		quit(stdouterr);
	return nexti(pc);
}

// Assembly:
pushq %rbx
movq %rsi, %rbx
movq %rsi, %rdi
callq 0x6260
leaq 0x4(%rax), %rsi
leaq 0x5e6d(%rip), %rdi      # 0xd3a9
xorl %eax, %eax
callq 0x5050
testl %eax, %eax
jg 0x7555
movq 0xbd52(%rip), %rdi      # 0x132a0
xorl %eax, %eax
callq 0x5899
movq %rbx, %rdi
callq 0x6260
movzwl (%rax), %eax
addq %rbx, %rax
popq %rbx
retq
// File: /workspace/github_cpp_makefile_star2_O1/arnoldrobbins[P]mcilroy-regex/sed2.cpp
// Function: Ne(Text*, unsigned char*, Text*)
uchar *
Ne(Text *script, uchar *pc, Text *data)
{
	assure(data, 1);
	*data->w++ = '\n';
	if(readline(data))
		return nexti(pc);
	*--data->w = 0;
	return de(script, pc, data);
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rdx, %r14
movq %rsi, %rbx
cmpq $0x0, 0x10(%rdx)
je 0x7592
movq 0x8(%r14), %rax
addq $-0x2, %rax
cmpq %rax, (%r14)
jb 0x759f
movq %r14, %rdi
movl $0x1, %esi
callq 0x5a80
movq (%r14), %rax
leaq 0x1(%rax), %rcx
movq %rcx, (%r14)
movb $0xa, (%rax)
movq %r14, %rdi
callq 0x599a
testl %eax, %eax
je 0x75c8
movq %rbx, %rdi
callq 0x6260
movzwl (%rax), %eax
addq %rbx, %rax
jmp 0x75e0
movq (%r14), %rax
leaq -0x1(%rax), %rcx
movq %rcx, (%r14)
movb $0x0, -0x1(%rax)
movq %r14, %rdi
callq 0x727f
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_cpp_makefile_star2_O1/arnoldrobbins[P]mcilroy-regex/sed2.cpp
// Function: ne(Text*, unsigned char*, Text*)
uchar *
ne(Text *script, uchar *pc, Text *data)
{
	if(!nflag)
		writeline(data);
	vacate(data);
	if(readline(data))
		return nexti(pc);
	return 0;
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rdx, %r14
movq %rsi, %rbx
leaq 0xc0e3(%rip), %rax      # 0x136dc
cmpl $0x0, (%rax)
jne 0x7606
movq %r14, %rdi
callq 0x6ffc
movq %r14, %rdi
callq 0x727f
movq %r14, %rdi
callq 0x599a
testl %eax, %eax
je 0x762a
movq %rbx, %rdi
callq 0x6260
movzwl (%rax), %eax
addq %rbx, %rax
jmp 0x762c
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_cpp_makefile_star2_O1/arnoldrobbins[P]mcilroy-regex/sed2.cpp
// Function: Pe(Text*, unsigned char*, Text*)
uchar *
Pe(Text *script, uchar *pc, Text *data)
{
	int n;
	uchar *end = ustrchr(data->s, '\n');
	if(end == 0)
		n = data->w - data->s;
	else
		n = end - data->s;
	if(fwrite(data->s, 1, n, stdout) != n)
		quit(stdouterr);
	cputchar('\n');
	script = script;
	return nexti(pc);
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rdx, %r15
movq %rsi, %rbx
movq 0x10(%rdx), %r14
movq %r14, %rdi
movl $0xa, %esi
callq 0x50c0
testq %rax, %rax
jne 0x7658
movq (%r15), %rax
subl %r14d, %eax
movslq %eax, %r15
movq 0xb94b(%rip), %rax      # 0x12fb0
movq (%rax), %rcx
movl $0x1, %esi
movq %r14, %rdi
movq %r15, %rdx
callq 0x5300
cmpq %r15, %rax
je 0x768b
movq 0xbc1c(%rip), %rdi      # 0x132a0
xorl %eax, %eax
callq 0x5899
movl $0xa, %edi
callq 0x6fe0
movq %rbx, %rdi
callq 0x6260
movzwl (%rax), %eax
addq %rbx, %rax
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_cpp_makefile_star2_O1/arnoldrobbins[P]mcilroy-regex/sed2.cpp
// Function: te(Text*, unsigned char*, Text*)
uchar *
te(Text *script, uchar *pc, Text *data)
{
	int tflag = sflag;
	sflag = 0;
	if(tflag)
		return be(script, pc, data);
	else
		return nexti(pc);
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %rbx
leaq 0xc004(%rip), %rax      # 0x136e4
cmpl $0x0, (%rax)
movl $0x0, (%rax)
je 0x7700
movq 0x10(%rdi), %r14
movq %rbx, %rdi
callq 0x6260
movslq 0x4(%rax), %rax
addq %r14, %rax
jmp 0x770e
movq %rbx, %rdi
callq 0x6260
movzwl (%rax), %eax
addq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_cpp_makefile_star2_O1/arnoldrobbins[P]mcilroy-regex/sed2.cpp
// Function: ww(Text*, unsigned char*, Text*, int)
uchar *
ww(Text *script, uchar *pc, Text *data, int offset)
{
	int *q = (int*)(files.s + offset);
	FILE *f = *(FILE**)q;
	int n = data->w - data->s;
	assure(data, 1);
	*data->w = '\n';
	if(fwrite(data->s, 1, n+1, f) != n+1 ||
	   fflush(f) == EOF)	/* in case of subsequent r */
		quit("error writing %s", (char*)(q+1));
	*data->w = 0;
	script = script;
	return nexti(pc);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rdx, %r14
movq %rsi, %rbx
leaq 0xc04a(%rip), %rax      # 0x13778
movq 0x10(%rax), %r15
movslq %ecx, %rbp
movq (%r15,%rbp), %r12
movq (%rdx), %rax
movq 0x10(%rdx), %rcx
movq %rax, %r13
subq %rcx, %r13
testq %rcx, %rcx
je 0x7758
movq 0x8(%r14), %rcx
addq $-0x2, %rcx
cmpq %rcx, %rax
jb 0x7765
movq %r14, %rdi
movl $0x1, %esi
callq 0x5a80
movq (%r14), %rax
movb $0xa, (%rax)
movq 0x10(%r14), %rdi
incl %r13d
movslq %r13d, %r13
movl $0x1, %esi
movq %r13, %rdx
movq %r12, %rcx
callq 0x5300
cmpq %r13, %rax
jne 0x7797
movq %r12, %rdi
callq 0x51b0
cmpl $-0x1, %eax
jne 0x77af
addq %rbp, %r15
addq $0x4, %r15
leaq 0x5bf6(%rip), %rdi      # 0xd39b
movq %r15, %rsi
xorl %eax, %eax
callq 0x5899
movq (%r14), %rax
movb $0x0, (%rax)
movq %rbx, %rdi
callq 0x6260
movzwl (%rax), %eax
addq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O1/arnoldrobbins[P]mcilroy-regex/sed2.cpp
// Function: xe(Text*, unsigned char*, Text*)
uchar *
xe(Text *script, uchar *pc, Text *data)
{
	uchar *t;
	script = script;
	if(hold.s == 0)
		vacate(&hold);
	exch(data->s, hold.s, t);
	exch(data->e, hold.e, t);
	exch(data->w, hold.w, t);
	return nexti(pc);
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rdx, %r14
movq %rsi, %rbx
cmpq $0x0, 0xbfad(%rip)      # 0x137b8
jne 0x7819
leaq 0xbf94(%rip), %rdi      # 0x137a8
callq 0x727f
movq 0x10(%r14), %rax
movq 0xbf94(%rip), %rcx      # 0x137b8
movq %rcx, 0x10(%r14)
movq %rax, 0xbf89(%rip)      # 0x137b8
movq 0x8(%r14), %rax
movq 0xbf76(%rip), %rcx      # 0x137b0
movq %rcx, 0x8(%r14)
movq %rax, 0xbf6b(%rip)      # 0x137b0
movq (%r14), %rax
movq 0xbf59(%rip), %rcx      # 0x137a8
movq %rcx, (%r14)
movq %rax, 0xbf4f(%rip)      # 0x137a8
movq %rbx, %rdi
callq 0x6260
movzwl (%rax), %eax
addq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_cpp_makefile_star2_O1/arnoldrobbins[P]mcilroy-regex/sed2.cpp
// Function: ye(Text*, unsigned char*, Text*)
uchar *
ye(Text *script, uchar *pc, Text *data)
{
	uchar *s = (uchar*)data->s;
	uchar *w = (uchar*)data->w;
	uchar *tbl = (uchar*)(instr(pc)+1);
	for( ; s<w; s++)
		*s = tbl[*s];
	script = script;
	return nexti(pc);
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rsi, %rbx
movq (%rdx), %r14
movq 0x10(%rdx), %r15
movq %rsi, %rdi
callq 0x6260
cmpq %r14, %r15
jae 0x789e
movzbl (%r15), %ecx
movb 0x4(%rax,%rcx), %cl
movb %cl, (%r15)
incq %r15
cmpq %r14, %r15
jne 0x788b
movq %rbx, %rdi
callq 0x6260
movzwl (%rax), %eax
addq %rbx, %rax
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_cpp_makefile_star2_O1/arnoldrobbins[P]mcilroy-regex/sed2.cpp
// Function: se(Text*, unsigned char*, Text*)
uchar *
se(Text *script, uchar *pc, Text *data)
{
	int *q = instr(pc);
	int flags = q[2];
	uchar *p = (uchar*)(q+3);
	int n = flags & ~(PFLAG|WFLAG);

	sflag = substitute(readdr(q[1]), data, p, n);
	if(!sflag)
		return nexti(pc);
	if(flags & PFLAG)
		pe(script, pc, data);
	if(flags & WFLAG)
		return ww(script, pc, data, ((int*)nexti(pc))[-1]);
	return nexti(pc);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movq %rdx, %r14
movq %rsi, %rbx
movq %rsi, %rdi
callq 0x6260
movl 0x4(%rax), %edi
movl 0x8(%rax), %r12d
leaq 0xc(%rax), %r15
movl %r12d, %ebp
andl $0x3fffffff, %ebp       # imm = 0x3FFFFFFF
callq 0x6373
movq %rax, %rdi
movq %r14, %rsi
movq %r15, %rdx
movl %ebp, %ecx
callq 0x7d90
leaq 0xbdec(%rip), %rcx      # 0x136e4
movl %eax, (%rcx)
testl %eax, %eax
je 0x793e
testl %r12d, %r12d
jns 0x7913
movq %r14, %rdi
callq 0x6ffc
movq %rbx, %rdi
callq 0x6260
movq %rbx, %rdi
callq 0x6260
movzwl (%rax), %eax
addq %rbx, %rax
btl $0x1e, %r12d
jae 0x794c
movl -0x4(%rax), %ecx
movq %rbx, %rsi
movq %r14, %rdx
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
jmp 0x7716
movq %rbx, %rdi
callq 0x6260
movzwl (%rax), %eax
addq %rbx, %rax
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O1/arnoldrobbins[P]mcilroy-regex/sed2.cpp
// Function: le(Text*, unsigned char*, Text*)
uchar *
le(Text *script, uchar *pc, Text *data)
{
	int i = 0;
	int j;
	uchar *s;
	script = script;
	for(s=data->s; s<data->w; s++, i++) {
		if(i >= 60) {
			cputchar('\\');
			cputchar('\n');
			i = 0;
		}
		for(j=0; j<sizeof(digram)/sizeof(*digram); j++)
			if(*s == digram[j].p) {
				cputchar('\\');
				cputchar(digram[j].q);
				goto cont;
			}
		if(!isprint(*s)) {
			if(printf("\\%3.3o", *s) <= 0)
				quit(stdouterr);
		} else
			cputchar(*s);
	cont:	;
	}
	cputchar('$');
	cputchar('\n');
	return nexti(pc);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq 0x10(%rdx), %r12
cmpq (%rdx), %r12
jae 0x7a0e
movq %rdx, %r14
leaq 0xb936(%rip), %r13      # 0x132b0
xorl %r15d, %r15d
cmpl $0x3c, %r15d
jl 0x799a
movl $0x5c, %edi
callq 0x6fe0
movl $0xa, %edi
callq 0x6fe0
xorl %r15d, %r15d
movzbl (%r12), %eax
xorl %ebp, %ebp
movsbl (%r13,%rbp,2), %ecx
cmpl %ecx, %eax
je 0x79c8
incq %rbp
cmpq $0x8, %rbp
jne 0x79a1
movzbl (%r12), %ebp
movl %ebp, %edi
callq 0x52c0
testl %eax, %eax
je 0x79ea
movl %ebp, %edi
jmp 0x79d8
movl $0x5c, %edi
callq 0x6fe0
movsbl 0x1(%r13,%rbp,2), %edi
callq 0x6fe0
incq %r12
incl %r15d
cmpq (%r14), %r12
jb 0x797d
jmp 0x7a0e
leaq 0x59bb(%rip), %rdi      # 0xd3ac
movl %ebp, %esi
xorl %eax, %eax
callq 0x5050
testl %eax, %eax
jg 0x79dd
movq 0xb89b(%rip), %rdi      # 0x132a0
xorl %eax, %eax
callq 0x5899
jmp 0x79dd
movl $0x24, %edi
callq 0x6fe0
movl $0xa, %edi
callq 0x6fe0
movq %rbx, %rdi
callq 0x6260
movzwl (%rax), %eax
addq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O1/arnoldrobbins[P]mcilroy-regex/sed2.cpp
// Function: ae(Text*, unsigned char*, Text*)
uchar *
ae(Text *script, uchar *pc, Text *data)
{
	script = script;
	data = data;
	assure(&todo, sizeof(uchar*));
	*(uchar**)todo.w = pc;
	todo.w += sizeof(uchar*);
	return nexti(pc);
}

// Assembly:
pushq %rbx
movq %rsi, %rbx
cmpq $0x0, 0xbd85(%rip)      # 0x137d0
je 0x7a61
movq 0xbd74(%rip), %rax      # 0x137c8
addq $-0x9, %rax
cmpq %rax, 0xbd61(%rip)      # 0x137c0
jb 0x7a72
leaq 0xbd58(%rip), %rdi      # 0x137c0
movl $0x8, %esi
callq 0x5a80
movq 0xbd47(%rip), %rax      # 0x137c0
movq %rbx, (%rax)
addq $0x8, 0xbd3c(%rip)      # 0x137c0
movq %rbx, %rdi
callq 0x6260
movzwl (%rax), %eax
addq %rbx, %rax
popq %rbx
retq
// File: /workspace/github_cpp_makefile_star2_O1/arnoldrobbins[P]mcilroy-regex/sed2.cpp
// Function: coda()
void
coda(void)
{
	int c;
	int *q;
	uchar *p;
	FILE *f;
	if(todo.s == 0)
		return;
	for(p=todo.s; p<todo.w; p+=sizeof(uchar*)) {
		q = instr(*(uchar**)p);
		switch(code(*q)) {
		case 'a':
			if(printf("%s", (char*)(q+1)) <= 0)
				quit(stdouterr);
			continue;
		case 'r':
			f = fopen((char*)(files.s+q[1]+sizeof(intptr_t)), "r");
			if(f == 0)
				continue;
			while((c=getc(f)) != EOF)
				cputchar(c);
			fclose(f);
			continue;
		default:
			quit(IBUG,5);
		}
	}
	vacate(&todo);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq 0xbcee(%rip), %r13      # 0x137d0
testq %r13, %r13
je 0x7bca
cmpq 0xbcce(%rip), %r13      # 0x137c0
jae 0x7bb0
leaq 0xbc79(%rip), %rbp      # 0x13778
leaq 0x57cf(%rip), %rbx      # 0xd2d5
leaq 0x589c(%rip), %r14      # 0xd3a9
leaq 0x5870(%rip), %r15      # 0xd384
movq (%r13), %rdi
callq 0x6260
movzbl 0x2(%rax), %ecx
cmpl $0x72, %ecx
je 0x7b50
cmpl $0x61, %ecx
jne 0x7b86
addq $0x4, %rax
movq %r14, %rdi
movq %rax, %rsi
xorl %eax, %eax
callq 0x5050
testl %eax, %eax
jg 0x7b9f
movq 0xb759(%rip), %rdi      # 0x132a0
xorl %eax, %eax
callq 0x5899
jmp 0x7b9f
movq 0x10(%rbp), %rcx
movslq 0x4(%rax), %rax
leaq (%rcx,%rax), %rdi
addq $0x8, %rdi
movq %rbx, %rsi
callq 0x51c0
testq %rax, %rax
je 0x7b9f
movq %rax, %r12
movq %r12, %rdi
callq 0x50a0
cmpl $-0x1, %eax
je 0x7b97
movl %eax, %edi
callq 0x6fe0
jmp 0x7b70
movq %r15, %rdi
movl $0x5, %esi
xorl %eax, %eax
callq 0x5899
jmp 0x7b9f
movq %r12, %rdi
callq 0x5160
addq $0x8, %r13
cmpq 0xbc16(%rip), %r13      # 0x137c0
jb 0x7b14
leaq 0xbc09(%rip), %rdi      # 0x137c0
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x727f
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_cpp_makefile_star2_O1/arnoldrobbins[P]mcilroy-regex/sed3.cpp
// Function: substitute(regex_t*, Text*, unsigned char*, int)
int
substitute(regex_t *re, Text* data, uchar *rhs, int n)
{
	Text t;
	uchar *where = data->s;
	if(regexec(re, (char*)data->s, NMATCH, matches, 0))
		return 0;
	vacate(&gendata);
	if(n == 0)
		do {
			docopy(where, so);
			if(!dosub(where, rhs))
				return 0;
			where += eo;
			if(eo == so) {
				if(where < data->w)
					docopy(where++, 1);
				else
					goto done;
			}
		} while(regexec(re, (char*)where, NMATCH, matches, REG_NOTBOL) == 0);
	else {
		while(--n > 0) {
			where += eo;
			if(eo == so) {
				if(where < data->w)
					where++;
				else
					return 0;
			}
			if(regexec(re, (char*)where, NMATCH, matches, REG_NOTBOL))
				return 0;
		}
		docopy(data->s, where-data->s+so);
		if(!dosub(where, rhs))
			return 0;
		where += eo;
	}			
	eo = so = data->w - where;
	docopy(where, so);
done:
	exch(gendata, *data, t);
	return 1;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movl %ecx, %r13d
movq %rdx, %r15
movq %rsi, %rbx
movq %rdi, %r12
movq 0x10(%rsi), %r14
leaq 0xba6b(%rip), %rcx      # 0x13820
xorl %ebp, %ebp
movl $0xa, %edx
movq %r14, %rsi
xorl %r8d, %r8d
callq 0x9a72
testl %eax, %eax
jne 0x7f1b
leaq 0xba2a(%rip), %rdi      # 0x13800
callq 0x727f
testl %r13d, %r13d
je 0x7e36
incl %r13d
leaq 0xba36(%rip), %rbp      # 0x13820
decl %r13d
cmpl $0x2, %r13d
jl 0x7ea1
movq 0xba2a(%rip), %rax      # 0x13828
addq %rax, %r14
cmpq 0xba18(%rip), %rax      # 0x13820
jne 0x7e12
cmpq (%rbx), %r14
jae 0x7e2f
incq %r14
movl $0xa, %edx
movq %r12, %rdi
movq %r14, %rsi
movq %rbp, %rcx
movl $0x10, %r8d
callq 0x9a72
testl %eax, %eax
je 0x7dea
xorl %ebp, %ebp
jmp 0x7f1b
leaq 0xb9e3(%rip), %r13      # 0x13820
movl 0xb9dd(%rip), %esi      # 0x13820
movq %r14, %rdi
callq 0x7f2c
movq %r14, %rdi
movq %r15, %rsi
callq 0x7f91
movq 0xb9cb(%rip), %rax      # 0x13828
addq %rax, %r14
cmpq 0xb9b9(%rip), %rax      # 0x13820
jne 0x7e82
cmpq (%rbx), %r14
jae 0x7ee3
leaq 0x1(%r14), %rbp
movq %r14, %rdi
movl $0x1, %esi
callq 0x7f2c
movq %rbp, %r14
movl $0xa, %edx
movq %r12, %rdi
movq %r14, %rsi
movq %r13, %rcx
movl $0x10, %r8d
callq 0x9a72
testl %eax, %eax
je 0x7e3d
jmp 0x7ec7
movq 0x10(%rbx), %rdi
movl %r14d, %esi
subl %edi, %esi
addl 0xb970(%rip), %esi      # 0x13820
callq 0x7f2c
movq %r14, %rdi
movq %r15, %rsi
callq 0x7f91
addq 0xb961(%rip), %r14      # 0x13828
movq (%rbx), %rsi
subq %r14, %rsi
movq %rsi, 0xb94c(%rip)      # 0x13820
movq %rsi, 0xb94d(%rip)      # 0x13828
movq %r14, %rdi
callq 0x7f2c
movq 0xb926(%rip), %rax      # 0x13810
movq %rax, 0x10(%rsp)
movups 0xb90a(%rip), %xmm0     # 0x13800
movaps %xmm0, (%rsp)
movq 0x10(%rbx), %rcx
movq %rcx, 0xb90b(%rip)      # 0x13810
movups (%rbx), %xmm1
movups %xmm1, 0xb8f1(%rip)     # 0x13800
movups %xmm0, (%rbx)
movq %rax, 0x10(%rbx)
movl $0x1, %ebp
movl %ebp, %eax
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O1/arnoldrobbins[P]mcilroy-regex/sed3.cpp
// Function: docopy(unsigned char*, int)
void
docopy(uchar *where, int n)
{
	assure(&gendata, n+1);
	memmove(gendata.w, where, n);
	gendata.w += n;
	*gendata.w = 0;
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %r14
cmpq $0x0, 0xb8d5(%rip)      # 0x13810
movslq %esi, %rbx
je 0x7f53
movq 0xb8c1(%rip), %rax      # 0x13808
subq %rbx, %rax
cmpq %rax, 0xb8af(%rip)      # 0x13800
jb 0x7f61
incl %esi
leaq 0xb8a4(%rip), %rdi      # 0x13800
callq 0x5a80
movq 0xb898(%rip), %rdi      # 0x13800
movq %r14, %rsi
movq %rbx, %rdx
callq 0x5290
movq 0xb886(%rip), %rax      # 0x13800
leaq (%rax,%rbx), %rcx
movq %rcx, 0xb87b(%rip)      # 0x13800
movb $0x0, (%rax,%rbx)
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_cpp_makefile_star2_O1/arnoldrobbins[P]mcilroy-regex/sed3.cpp
// Function: dosub(unsigned char*, unsigned char*)
int
dosub(uchar *where, uchar *rp)
{
	int c, n;
	regmatch_t *m;

	while((c = *rp++) != 0) {
		if(c == '\\') {
			c = *rp++;
			if (c >= '1' && c <= '9') {
				m = matches + c - '0';
				if(m->rm_eo == -1)
					continue;   /* or return 0 */
				n = m->rm_eo - m->rm_so;
				assure(&gendata, n);
				memmove(gendata.w,where+m->rm_so,n);
				gendata.w += n;
				continue;
			}
		} else if(c == '&') {
				assure(&gendata, eo-so);
				memmove(gendata.w,where+so,eo-so);
				gendata.w += eo-so;
				continue;
		}
		assure(&gendata, 1);
		*gendata.w++ = c;
	}
	return 1;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rsi, %r15
movq %rdi, %rbx
leaq 0xb857(%rip), %r14      # 0x13800
leaq 0xb870(%rip), %r13      # 0x13820
leaq 0x1(%r15), %r12
movzbl (%r15), %ebp
cmpl $0x26, %ebp
je 0x8058
cmpl $0x5c, %ebp
je 0x7fd3
testl %ebp, %ebp
jne 0x80db
jmp 0x8123
movb 0x1(%r15), %bpl
addq $0x2, %r15
leal -0x31(%rbp), %eax
cmpb $0x8, %al
ja 0x80d8
movzbl %bpl, %ebp
shll $0x4, %ebp
movq -0x2f8(%rbp,%r13), %r12
cmpq $-0x1, %r12
je 0x7fb0
addq %r13, %rbp
subq -0x300(%rbp), %r12
cmpq $0x0, 0xb803(%rip)      # 0x13810
je 0x8025
movslq %r12d, %rax
notq %rax
addq 0xb7ec(%rip), %rax      # 0x13808
cmpq %rax, 0xb7dd(%rip)      # 0x13800
jb 0x8030
movq %r14, %rdi
movl %r12d, %esi
callq 0x5a80
movq 0xb7c9(%rip), %rdi      # 0x13800
movq -0x300(%rbp), %rsi
addq %rbx, %rsi
movslq %r12d, %r12
movq %r12, %rdx
callq 0x5290
addq %r12, 0xb7ad(%rip)      # 0x13800
jmp 0x7fb0
cmpq $0x0, 0xb7b0(%rip)      # 0x13810
je 0x8086
movq 0xb79f(%rip), %rax      # 0x13808
subq 0xb7b8(%rip), %rax      # 0x13828
movq 0xb7a9(%rip), %rcx      # 0x13820
notq %rcx
addq %rax, %rcx
cmpq %rcx, 0xb77c(%rip)      # 0x13800
jb 0x809a
movl 0xb79c(%rip), %esi      # 0x13828
subl 0xb78e(%rip), %esi      # 0x13820
movq %r14, %rdi
callq 0x5a80
movq 0xb75f(%rip), %rdi      # 0x13800
movq 0xb778(%rip), %rax      # 0x13820
leaq (%rbx,%rax), %rsi
movq 0xb775(%rip), %rdx      # 0x13828
subq %rax, %rdx
callq 0x5290
movq 0xb766(%rip), %rax      # 0x13828
subq 0xb757(%rip), %rax      # 0x13820
addq %rax, 0xb730(%rip)      # 0x13800
movq %r12, %r15
jmp 0x7fb0
movq %r15, %r12
cmpq $0x0, 0xb72d(%rip)      # 0x13810
je 0x80f9
movq 0xb71c(%rip), %rax      # 0x13808
addq $-0x2, %rax
cmpq %rax, 0xb709(%rip)      # 0x13800
jb 0x8106
movq %r14, %rdi
movl $0x1, %esi
callq 0x5a80
movq 0xb6f3(%rip), %rax      # 0x13800
leaq 0x1(%rax), %rcx
movq %rcx, 0xb6e8(%rip)      # 0x13800
movb %bpl, (%rax)
movq %r12, %r15
jmp 0x7fb0
movl $0x1, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O1/arnoldrobbins[P]mcilroy-regex/re1.cpp
// Function: Eenv::pushpos(Rex*, unsigned char*, int)
int Eenv::pushpos(Rex *rex, uchar *p, int b_e )
{
	if(pos.assure(npos+1))	// +1 is probably superstition
		return 1;
	pos[npos].serial = rex->serial;
	pos[npos].p = p;
	pos[npos].be = b_e;
	npos++;
	return 0;
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movl %ecx, %ebx
movq %rdx, %r15
movq %rsi, %r12
movq %rdi, %r14
movl 0x20(%rdi), %esi
incl %esi
cmpl %esi, 0x30(%rdi)
jg 0x8169
leaq 0x28(%r14), %rdi
callq 0xa058
movl %eax, %ecx
movl $0x1, %eax
testl %ecx, %ecx
jne 0x8191
movzwl 0xa(%r12), %eax
movslq 0x20(%r14), %rcx
movq 0x28(%r14), %rdx
leal 0x1(%rcx), %esi
shlq $0x4, %rcx
movw %ax, 0x8(%rdx,%rcx)
movq %r15, (%rdx,%rcx)
movb %bl, 0xa(%rdx,%rcx)
movl %esi, 0x20(%r14)
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
nop
// File: /workspace/github_cpp_makefile_star2_O1/arnoldrobbins[P]mcilroy-regex/re1.cpp
// Function: Seg::copy()
Seg Seg::copy()
{
	Seg seg(new uchar[n+1], n);
	if(seg.p) {
		memmove(seg.p, p, (size_t)n);
		seg.p[n] = 0;
	}
	return seg;
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rdi, %rbx
movl 0x8(%rdi), %eax
movslq %eax, %r14
leaq 0x1(%r14), %rdi
callq 0x5030
movq %rax, %r15
movq (%rbx), %rsi
movq %rax, %rdi
movq %r14, %rdx
callq 0x5290
movb $0x0, (%r15,%r14)
movq %r15, %rax
movl %r14d, %edx
popq %rbx
popq %r14
popq %r15
retq
nop
// File: /workspace/github_cpp_makefile_star2_O1/arnoldrobbins[P]mcilroy-regex/re1.cpp
// Function: Anchor::parse(unsigned char*, Rex*, Eenv*)
int Anchor::parse(uchar *s, Rex *cont, Eenv *env)
{
	debug(ANCHOR, "Anchor", s);
	if(((env->flags&REG_NEWLINE) && s>env->p && s[-1]=='\n') ||
	   (!(env->flags&REG_NOTBOL) && s==env->p))
		return follow(s, cont, env);
	return NONE;
}

// Assembly:
movl (%rcx), %eax
testb $0x8, %al
je 0x82a6
cmpq %rsi, 0x10(%rcx)
jae 0x82a6
cmpb $0xa, -0x1(%rsi)
je 0x82b3
testb $0x10, %al
jne 0x82b0
cmpq %rsi, 0x10(%rcx)
je 0x82b3
xorl %eax, %eax
retq
movq 0x10(%rdi), %rdi
testq %rdi, %rdi
je 0x82c5
movq (%rdi), %rax
movq 0x20(%rax), %rax
jmpq *%rax
movq (%rdx), %rax
movq 0x20(%rax), %rax
movq %rdx, %rdi
xorl %edx, %edx
jmpq *%rax
nop
// File: /workspace/github_cpp_makefile_star2_O1/arnoldrobbins[P]mcilroy-regex/re1.cpp
// Function: End::parse(unsigned char*, Rex*, Eenv*)
int End::parse(uchar *s, Rex *cont, Eenv *env)
{
	debug(END, "End", s);
	if((*s==0 && !(env->flags&REG_NOTEOL)) ||
	    ((env->flags&REG_NEWLINE) && *s=='\n'))
		return follow(s, cont, env);
	return NONE;
}

// Assembly:
movb (%rsi), %al
testb %al, %al
jne 0x82df
testb $0x20, (%rcx)
je 0x82ea
cmpb $0xa, %al
jne 0x82fc
movl (%rcx), %eax
andl $0x8, %eax
je 0x82fc
movq 0x10(%rdi), %rdi
testq %rdi, %rdi
je 0x82ff
movq (%rdi), %rax
movq 0x20(%rax), %rax
jmpq *%rax
xorl %eax, %eax
retq
movq (%rdx), %rax
movq 0x20(%rax), %rax
movq %rdx, %rdi
xorl %edx, %edx
jmpq *%rax
nop
// File: /workspace/github_cpp_makefile_star2_O1/arnoldrobbins[P]mcilroy-regex/re1.cpp
// Function: Dot::parse(unsigned char*, Rex*, Eenv*)
int Dot::parse(uchar *s, Rex *cont, Eenv *env)
{
	debug(DOT, "Dot", s);
	int n = hi;
	if(n > env->last-s)
		n = env->last-s;
	if(env->flags&REG_NEWLINE) {
		for(int i=0 ; i<n; i++)
			if(s[i] == '\n')
				n = i;
	}
	int result = NONE;
	for(s+=n; n-->=lo; s--)
		switch(follow(s, cont, env)) {
		case BEST:
			return BEST;
		case BAD:
			return BAD;
		case GOOD:
			result = GOOD;
		}
	return result;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rcx, %rbx
movq %rdx, %r14
movq %rsi, %r15
movq %rdi, %r12
movslq 0x1c(%rdi), %rax
movq 0x18(%rcx), %r13
subq %rsi, %r13
cmpq %rax, %r13
cmovgel %eax, %r13d
testb $0x8, (%rcx)
je 0x8357
testl %r13d, %r13d
jle 0x8357
xorl %eax, %eax
cmpb $0xa, (%r15,%rax)
cmovel %eax, %r13d
incq %rax
movslq %r13d, %rcx
cmpq %rcx, %rax
jl 0x8343
xorl %eax, %eax
cmpl 0x18(%r12), %r13d
jl 0x83b4
movslq %r13d, %rax
addq %rax, %r15
incl %r13d
xorl %ebp, %ebp
movq 0x10(%r12), %rdi
testq %rdi, %rdi
je 0x8380
movq (%rdi), %rax
movq %r15, %rsi
movq %r14, %rdx
jmp 0x838b
movq (%r14), %rax
movq %r14, %rdi
movq %r15, %rsi
xorl %edx, %edx
movq %rbx, %rcx
callq *0x20(%rax)
cmpl $0x1, %eax
je 0x83a0
leal -0x2(%rax), %ecx
cmpl $0x2, %ecx
jae 0x83a5
jmp 0x83b4
movl $0x1, %ebp
decq %r15
decl %r13d
movl %ebp, %eax
cmpl 0x18(%r12), %r13d
jg 0x836b
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O1/arnoldrobbins[P]mcilroy-regex/re1.cpp
// Function: Onechar::parse(unsigned char*, Rex*, Eenv*)
int Onechar::parse(uchar *s, Rex *cont, Eenv *env)
{
	debug(ONECHAR, "Onechar", s);
	int n = hi;
	uchar *map = env->preg->map;
	if(n > env->last-s)
		n = env->last-s;
	int i = 0;
	for( ; i<n; i++,s++)
		if(map[*s] != c)
			break;
	int result = NONE;
	for( ; i-->=lo; s--)
		switch(follow(s, cont, env)) {
		case BEST:
			return BEST;
		case BAD:
			return BAD;
		case GOOD:
			result = GOOD;
		}
	return result;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rcx, %rbx
movq %rdx, %r14
movq %rdi, %r15
movslq 0x1c(%rdi), %rax
movq 0x18(%rcx), %r13
subq %rsi, %r13
cmpq %rax, %r13
cmovgel %eax, %r13d
xorl %eax, %eax
testl %r13d, %r13d
jle 0x8418
movq 0x8(%rbx), %rcx
movq 0x18(%rcx), %rdx
movb 0x20(%r15), %dil
leaq (%rsi,%r13), %r12
xorl %ecx, %ecx
movzbl (%rsi,%rcx), %r8d
cmpb %dil, (%rdx,%r8)
jne 0x8420
incq %rcx
cmpl %ecx, %r13d
jne 0x8403
jmp 0x8429
movq %rsi, %r12
xorl %r13d, %r13d
jmp 0x8429
addq %rcx, %rsi
movq %rsi, %r12
movl %ecx, %r13d
cmpl 0x18(%r15), %r13d
jl 0x847b
incl %r13d
xorl %ebp, %ebp
movq 0x10(%r15), %rdi
testq %rdi, %rdi
je 0x8448
movq (%rdi), %rax
movq %r12, %rsi
movq %r14, %rdx
jmp 0x8453
movq (%r14), %rax
movq %r14, %rdi
movq %r12, %rsi
xorl %edx, %edx
movq %rbx, %rcx
callq *0x20(%rax)
cmpl $0x1, %eax
je 0x8468
leal -0x2(%rax), %ecx
cmpl $0x2, %ecx
jae 0x846d
jmp 0x847b
movl $0x1, %ebp
decq %r12
decl %r13d
movl %ebp, %eax
cmpl 0x18(%r15), %r13d
jg 0x8434
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O1/arnoldrobbins[P]mcilroy-regex/re1.cpp
// Function: Class::parse(unsigned char*, Rex*, Eenv*)
int Class::parse(uchar *s, Rex *cont, Eenv *env)
{
	debug(CLASS, "Class", s);
	int n = hi;
	if(n > env->last-s)
		n = env->last-s;
	for(int i=0; i<n; i++)
		if(!cl.in(s[i]))
			n = i;
	int result = NONE;
	for(s+=n; n-->=lo; s--)
		switch(follow(s, cont, env)) {
		case BEST:
			return BEST;
		case BAD:
			return BAD;
		case GOOD:
			result = GOOD;
		}
	return result;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rcx, %rbx
movq %rdx, %r14
movq %rsi, %r15
movq %rdi, %r12
movslq 0x1c(%rdi), %rax
movq 0x18(%rcx), %r13
subq %rsi, %r13
cmpq %rax, %r13
cmovgel %eax, %r13d
testl %r13d, %r13d
jle 0x84df
xorl %eax, %eax
movzbl (%r15,%rax), %ecx
movl %ecx, %edx
shrl $0x3, %edx
movzbl 0x20(%r12,%rdx), %edx
andl $0x7, %ecx
btl %ecx, %edx
cmovael %eax, %r13d
incq %rax
movslq %r13d, %rcx
cmpq %rcx, %rax
jl 0x84ba
xorl %eax, %eax
cmpl 0x18(%r12), %r13d
jl 0x853c
movslq %r13d, %rax
addq %rax, %r15
incl %r13d
xorl %ebp, %ebp
movq 0x10(%r12), %rdi
testq %rdi, %rdi
je 0x8508
movq (%rdi), %rax
movq %r15, %rsi
movq %r14, %rdx
jmp 0x8513
movq (%r14), %rax
movq %r14, %rdi
movq %r15, %rsi
xorl %edx, %edx
movq %rbx, %rcx
callq *0x20(%rax)
cmpl $0x1, %eax
je 0x8528
leal -0x2(%rax), %ecx
cmpl $0x2, %ecx
jae 0x852d
jmp 0x853c
movl $0x1, %ebp
decq %r15
decl %r13d
movl %ebp, %eax
cmpl 0x18(%r12), %r13d
jg 0x84f3
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O1/arnoldrobbins[P]mcilroy-regex/re1.cpp
// Function: Class::icase(unsigned char*)
void Class::icase(uchar *map)
{
	if(map['A'] != map['a'])
		return;
	for(int i=0; i<256; i++)
		if(cl.in(i)) {
			cl.insert(toupper(i));
			cl.insert(tolower(i));
		}
}

// Assembly:
movb 0x41(%rsi), %al
cmpb 0x61(%rsi), %al
jne 0x85e7
pushq %rbp
pushq %r14
pushq %rbx
movq %rdi, %rbx
xorl %ebp, %ebp
movl $0xff, %r14d
movl %ebp, %eax
shrl $0x3, %eax
movzbl 0x20(%rbx,%rax), %eax
movl %ebp, %ecx
andl $0x7, %ecx
btl %ecx, %eax
jae 0x85d9
movl %ebp, %edi
callq 0x52e0
movl %eax, %ecx
andb $0x7, %cl
movb $0x1, %dl
shlb %cl, %dl
andl %r14d, %eax
shrl $0x3, %eax
orb %dl, 0x20(%rbx,%rax)
movl %ebp, %edi
callq 0x5250
movl %eax, %ecx
andb $0x7, %cl
movb $0x1, %dl
shlb %cl, %dl
andl %r14d, %eax
shrl $0x3, %eax
orb %dl, 0x20(%rbx,%rax)
incl %ebp
cmpl $0x100, %ebp            # imm = 0x100
jne 0x8591
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O1/arnoldrobbins[P]mcilroy-regex/re1.cpp
// Function: String::parse(unsigned char*, Rex*, Eenv*)
int String::parse(uchar *s, Rex *cont, Eenv *env)
{
	debug(STRING, "String", s);
	if(s+seg.n > env->last)
		return NONE;
	uchar *map = env->preg->map;
	uchar *p = seg.p;
	while(*p)
		if(map[*s++] != *p++)
			return NONE;
	return follow(s, cont, env);
}

// Assembly:
movslq 0x20(%rdi), %rax
addq %rsi, %rax
cmpq 0x18(%rcx), %rax
ja 0x865b
movq 0x8(%rcx), %rax
movq 0x18(%rax), %rax
movq 0x18(%rdi), %r8
movb (%r8), %r9b
testb %r9b, %r9b
je 0x865e
movzbl (%rsi), %r10d
incq %rsi
incq %r8
cmpb %r9b, (%rax,%r10)
je 0x8643
xorl %eax, %eax
retq
movq 0x10(%rdi), %rdi
testq %rdi, %rdi
je 0x8670
movq (%rdi), %rax
movq 0x20(%rax), %rax
jmpq *%rax
movq (%rdx), %rax
movq 0x20(%rax), %rax
movq %rdx, %rdi
xorl %edx, %edx
jmpq *%rax
// File: /workspace/github_cpp_makefile_star2_O1/arnoldrobbins[P]mcilroy-regex/re1.cpp
// Function: Kmp::Kmp(Seg, int*)
Kmp::Kmp(Seg seg, int *flags) : String(seg)
{
	type = KMP;
	if(fail.assure(seg.n)) {
		*flags |= SPACE;
		return;
	}
	int q, k ;
	fail[0] = k = -1;
	for(q=1; q<seg.n; q++) {
		while(k>=0 && seg.p[k+1] != seg.p[q])
			k = fail[k];
		if(seg.p[k+1] == seg.p[q])
			k++;
		fail[q] = k;
	}
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rcx, %r15
movl %edx, %ebp
movq %rsi, %rbx
movq $0x0, 0x10(%rdi)
movq %rsi, 0x18(%rdi)
movl %edx, 0x20(%rdi)
leaq 0x9f01(%rip), %rax      # 0x125a8
movq %rax, (%rdi)
leaq 0x28(%rdi), %r12
leaq 0x34(%rdi), %r13
movq %r13, 0x28(%rdi)
movl $0x14, 0x30(%rdi)
movb $0xe, 0x8(%rdi)
xorl %eax, %eax
cmpl $0x14, %edx
jl 0x86d5
movq %rdi, %r14
movq %r12, %rdi
movl %ebp, %esi
callq 0xa134
testl %eax, %eax
je 0x86e0
orb $0x4, 0x1(%r15)
jmp 0x8733
movq (%r12), %rax
movl $0xffffffff, (%rax)     # imm = 0xFFFFFFFF
cmpl $0x2, %ebp
jl 0x8733
movl %ebp, %ecx
movl $0xffffffff, %esi       # imm = 0xFFFFFFFF
movl $0x1, %edx
testl %esi, %esi
js 0x8715
movb (%rbx,%rdx), %dil
movl %esi, %r8d
cmpb %dil, 0x1(%rbx,%r8)
je 0x8715
movl (%rax,%r8,4), %esi
testl %esi, %esi
jns 0x8703
movslq %esi, %rsi
leaq 0x1(%rsi), %rdi
movb 0x1(%rbx,%rsi), %r8b
cmpb (%rbx,%rdx), %r8b
cmovel %edi, %esi
movl %esi, (%rax,%rdx,4)
incq %rdx
cmpq %rcx, %rdx
jne 0x86fb
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
movq (%r12), %rdi
cmpq %r13, %rdi
sete %al
testq %rdi, %rdi
sete %cl
orb %al, %cl
jne 0x875e
callq 0x5200
movq %r14, %rdi
callq 0x9ab2
movq %rbx, %rdi
callq 0x52b0