LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: arnoldrobbins[P]mcilroy-regex/sed1.cpp
// Function: fixlabels(Text*)
void
fixlabels(Text *script)
{
	uchar *p;
	int *q;
	for(p=script->s; p<script->w; p=succi(p)) {
		q = instr(p);
		switch(code(*q)) {
		case 't':
		case 'b':
			if(q[1] == -1)
				q[1] = script->w - script->s;
			else if(*(intptr_t*)(labels.s+q[1]) != -1)
				q[1] = *(intptr_t*)(labels.s+q[1]);
			else
				quit("undefined label: ",
					labels.s+q[1]+sizeof(intptr_t));
		}
	}
	free(labels.s);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq 0x10(%rax), %rax
movq %rax, -0x10(%rbp)
movq -0x10(%rbp), %rax
movq -0x8(%rbp), %rcx
cmpq (%rcx), %rax
jae 0x64dd
movq -0x10(%rbp), %rdi
callq 0x64f0
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rax
movzbl 0x2(%rax), %eax
movl %eax, -0x1c(%rbp)
subl $0x62, %eax
je 0x6446
jmp 0x6438
movl -0x1c(%rbp), %eax
subl $0x74, %eax
jne 0x64c9
jmp 0x6446
movq -0x18(%rbp), %rax
cmpl $-0x1, 0x4(%rax)
jne 0x646d
movq -0x8(%rbp), %rax
movq (%rax), %rax
movq -0x8(%rbp), %rcx
movq 0x10(%rcx), %rcx
subq %rcx, %rax
movl %eax, %ecx
movq -0x18(%rbp), %rax
movl %ecx, 0x4(%rax)
jmp 0x64c7
movq 0x11d3c(%rip), %rax     # 0x181b0
movq -0x18(%rbp), %rcx
movslq 0x4(%rcx), %rcx
cmpq $-0x1, (%rax,%rcx)
je 0x64a1
movq 0x11d26(%rip), %rax     # 0x181b0
movq -0x18(%rbp), %rcx
movslq 0x4(%rcx), %rcx
movq (%rax,%rcx), %rax
movl %eax, %ecx
movq -0x18(%rbp), %rax
movl %ecx, 0x4(%rax)
jmp 0x64c5
movq 0x11d08(%rip), %rsi     # 0x181b0
movq -0x18(%rbp), %rax
movslq 0x4(%rax), %rax
addq %rax, %rsi
addq $0x8, %rsi
leaq 0xaf20(%rip), %rdi      # 0x113de
movb $0x0, %al
callq 0x5820
jmp 0x64c7
jmp 0x64c9
jmp 0x64cb
movq -0x10(%rbp), %rdi
callq 0x6530
movq %rax, -0x10(%rbp)
jmp 0x6408
movq 0x11ccc(%rip), %rdi     # 0x181b0
callq 0x51f0
addq $0x20, %rsp
popq %rbp
retq
nop
// File: arnoldrobbins[P]mcilroy-regex/sed1.cpp
// Function: instr(unsigned char*)
int *
instr(uchar *p)		/* get address of command word */
{
	int *q = (int*)p;
	while((*q & IMASK) != IMASK)
		q++;
	return q;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x10(%rbp)
movq -0x10(%rbp), %rax
movl (%rax), %eax
andl $0xc0000000, %eax       # imm = 0xC0000000
cmpl $0xc0000000, %eax       # imm = 0xC0000000
je 0x6520
movq -0x10(%rbp), %rax
addq $0x4, %rax
movq %rax, -0x10(%rbp)
jmp 0x6500
movq -0x10(%rbp), %rax
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: arnoldrobbins[P]mcilroy-regex/sed1.cpp
// Function: succi(unsigned char*)
uchar *
succi(uchar *p)
{
	int *q = instr(p);
	if(code(*q) == '{')
		return (uchar*)(q+1);
	else
		return p + (*q & LMASK);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movq -0x10(%rbp), %rdi
callq 0x64f0
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rax
movl (%rax), %eax
sarl $0x10, %eax
andl $0xff, %eax
cmpl $0x7b, %eax
jne 0x656a
movq -0x18(%rbp), %rax
addq $0x4, %rax
movq %rax, -0x8(%rbp)
jmp 0x6584
movq -0x10(%rbp), %rax
movq -0x18(%rbp), %rcx
movl (%rcx), %ecx
andl $0xffff, %ecx           # imm = 0xFFFF
movslq %ecx, %rcx
addq %rcx, %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x20, %rsp
popq %rbp
retq
nop
// File: arnoldrobbins[P]mcilroy-regex/sed1.cpp
// Function: number(Text*)
int
number(Text *t)
{
	unsigned n = 0;
	while(isdigit(*t->w)) {
		if(n > (INT_MAX-9)/10)
			syntax("number too big");
		n = n*10 + *t->w++ - '0';
	}
	return n;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movl $0x0, -0xc(%rbp)
movq -0x8(%rbp), %rax
movq (%rax), %rax
movzbl (%rax), %edi
callq 0x5160
cmpl $0x0, %eax
je 0x665e
cmpl $0xccccccb, -0xc(%rbp)  # imm = 0xCCCCCCB
jbe 0x663c
leaq 0xad39(%rip), %rdi      # 0x11370
callq 0x6220
imull $0xa, -0xc(%rbp), %eax
movq -0x8(%rbp), %rdx
movq (%rdx), %rcx
movq %rcx, %rsi
addq $0x1, %rsi
movq %rsi, (%rdx)
movzbl (%rcx), %ecx
addl %ecx, %eax
subl $0x30, %eax
movl %eax, -0xc(%rbp)
jmp 0x6613
movl -0xc(%rbp), %eax
addq $0x10, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: arnoldrobbins[P]mcilroy-regex/sed1.cpp
// Function: lablook(unsigned char*, Text*)
intptr_t *
lablook(uchar *l, Text *labels)
{
	uchar *p, *q;
	int n;
	assure(labels, 1);
	for(p = labels->s; p < labels->w; ) {
		q = p + sizeof(intptr_t);
		if(ustrcmp(q, l) == 0)
			return (intptr_t*)p;
		q += ustrlen(q) + 1;
		p = (uchar*)intptrp(q);
	}
	n = ustrlen(l);
	assure(labels, sizeof(intptr_t)+n+1+sizeof(intptr_t));
	*(intptr_t*)p = -1;
	q = p + sizeof(intptr_t);
	ustrcpy(q, l);
	q += ustrlen(q) + 1;
	labels->w = (uchar*)intptrp(q);
	return (intptr_t*)p;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x18(%rbp), %rax
cmpq $0x0, 0x10(%rax)
je 0x66c7
movq -0x18(%rbp), %rax
movq (%rax), %rax
movq -0x18(%rbp), %rcx
movq 0x8(%rcx), %rcx
addq $-0x1, %rcx
addq $-0x1, %rcx
cmpq %rcx, %rax
jb 0x66d7
movq -0x18(%rbp), %rdi
movl $0x1, %esi
callq 0x5ae0
jmp 0x66d9
jmp 0x66d9
movq -0x18(%rbp), %rax
movq 0x10(%rax), %rax
movq %rax, -0x20(%rbp)
movq -0x20(%rbp), %rax
movq -0x18(%rbp), %rcx
cmpq (%rcx), %rax
jae 0x6760
movq -0x20(%rbp), %rax
addq $0x8, %rax
movq %rax, -0x28(%rbp)
movq -0x28(%rbp), %rdi
movq -0x10(%rbp), %rsi
callq 0x5250
cmpl $0x0, %eax
jne 0x671d
movq -0x20(%rbp), %rax
movq %rax, -0x8(%rbp)
jmp 0x6831
movq -0x28(%rbp), %rdi
callq 0x50d0
addq $0x1, %rax
addq -0x28(%rbp), %rax
movq %rax, -0x28(%rbp)
movq -0x28(%rbp), %rax
addq $0x8, %rax
addq $-0x1, %rax
movq -0x28(%rbp), %rdx
addq $0x8, %rdx
addq $-0x1, %rdx
subq $0x0, %rdx
andq $0x7, %rdx
xorl %ecx, %ecx
subq %rdx, %rcx
addq %rcx, %rax
movq %rax, -0x20(%rbp)
jmp 0x66e5
movq -0x10(%rbp), %rdi
callq 0x50d0
movl %eax, -0x2c(%rbp)
movq -0x18(%rbp), %rax
cmpq $0x0, 0x10(%rax)
je 0x67a2
movq -0x18(%rbp), %rax
movq (%rax), %rax
movq -0x18(%rbp), %rcx
movq 0x8(%rcx), %rcx
addq $-0x8, %rcx
movslq -0x2c(%rbp), %rdx
addq %rdx, %rcx
addq $0x1, %rcx
addq $0x8, %rcx
addq $-0x1, %rcx
cmpq %rcx, %rax
jb 0x67bf
movq -0x18(%rbp), %rdi
movslq -0x2c(%rbp), %rax
addq $0x8, %rax
addq $0x1, %rax
addq $0x8, %rax
movl %eax, %esi
callq 0x5ae0
jmp 0x67c1
jmp 0x67c1
movq -0x20(%rbp), %rax
movq $-0x1, (%rax)
movq -0x20(%rbp), %rax
addq $0x8, %rax
movq %rax, -0x28(%rbp)
movq -0x28(%rbp), %rdi
movq -0x10(%rbp), %rsi
callq 0x5180
movq -0x28(%rbp), %rdi
callq 0x50d0
addq $0x1, %rax
addq -0x28(%rbp), %rax
movq %rax, -0x28(%rbp)
movq -0x28(%rbp), %rcx
addq $0x8, %rcx
addq $-0x1, %rcx
movq -0x28(%rbp), %rdx
addq $0x8, %rdx
addq $-0x1, %rdx
subq $0x0, %rdx
andq $0x7, %rdx
xorl %eax, %eax
subq %rdx, %rax
addq %rax, %rcx
movq -0x18(%rbp), %rax
movq %rcx, (%rax)
movq -0x20(%rbp), %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: arnoldrobbins[P]mcilroy-regex/sed1.cpp
// Function: getlab(Text*, int)
int
getlab(Text *t, int i)
{
	intptr_t *p;
	uchar *u;
	while(blank(t));	/* not exactly posix */
	for(u=t->w; *t->w!='\n'; t->w++)
		if(!isprint(*t->w) || *t->w==' ')
			synwarn("invisible character in name");
	if(u == t->w)
		return -1;
	*t->w = 0;
	p = lablook(u, &labels);
	if(*p == -1)
		*p = i;
	else if(i != -1)
		syntax("duplicate label");
	*t->w = '\n';
	return (uchar*)p - labels.s;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movl %esi, -0x14(%rbp)
movq -0x10(%rbp), %rdi
callq 0x60c0
cmpl $0x0, %eax
je 0x685f
jmp 0x684f
movq -0x10(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x28(%rbp)
movq -0x10(%rbp), %rax
movq (%rax), %rax
movzbl (%rax), %eax
cmpl $0xa, %eax
je 0x68ba
movq -0x10(%rbp), %rax
movq (%rax), %rax
movzbl (%rax), %edi
callq 0x52e0
cmpl $0x0, %eax
je 0x689c
movq -0x10(%rbp), %rax
movq (%rax), %rax
movzbl (%rax), %eax
cmpl $0x20, %eax
jne 0x68a8
leaq 0xab01(%rip), %rdi      # 0x113a4
callq 0x62a0
jmp 0x68aa
movq -0x10(%rbp), %rax
movq (%rax), %rcx
addq $0x1, %rcx
movq %rcx, (%rax)
jmp 0x686a
movq -0x28(%rbp), %rax
movq -0x10(%rbp), %rcx
cmpq (%rcx), %rax
jne 0x68d0
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
jmp 0x6934
movq -0x10(%rbp), %rax
movq (%rax), %rax
movb $0x0, (%rax)
movq -0x28(%rbp), %rdi
leaq 0x118bb(%rip), %rsi     # 0x181a0
callq 0x6690
movq %rax, -0x20(%rbp)
movq -0x20(%rbp), %rax
cmpq $-0x1, (%rax)
jne 0x6905
movslq -0x14(%rbp), %rcx
movq -0x20(%rbp), %rax
movq %rcx, (%rax)
jmp 0x6919
cmpl $-0x1, -0x14(%rbp)
je 0x6917
leaq 0xaaae(%rip), %rdi      # 0x113c0
callq 0x6220
jmp 0x6919
movq -0x10(%rbp), %rax
movq (%rax), %rax
movb $0xa, (%rax)
movq -0x20(%rbp), %rax
movq 0x11882(%rip), %rcx     # 0x181b0
subq %rcx, %rax
movl %eax, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax)
// File: 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 %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x10(%rbp), %rdi
callq 0x60c0
cmpl $0x0, %eax
jne 0x69fa
leaq 0xa9fb(%rip), %rdi      # 0x113f0
callq 0x62a0
jmp 0x69fc
movq -0x10(%rbp), %rdi
callq 0x60c0
cmpl $0x0, %eax
je 0x6a0c
jmp 0x69fc
movq -0x10(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x18(%rbp)
movq -0x10(%rbp), %rax
movq (%rax), %rax
movzbl (%rax), %eax
cmpl $0xa, %eax
je 0x6a38
jmp 0x6a28
movq -0x10(%rbp), %rax
movq (%rax), %rcx
addq $0x1, %rcx
movq %rcx, (%rax)
jmp 0x6a17
movq -0x18(%rbp), %rax
movq -0x10(%rbp), %rcx
cmpq (%rcx), %rax
jne 0x6a51
leaq 0xa9be(%rip), %rdi      # 0x1140a
callq 0x6220
movq -0x10(%rbp), %rax
movq (%rax), %rax
movb $0x0, (%rax)
movq -0x8(%rbp), %rax
movq %rax, -0x20(%rbp)
movq -0x18(%rbp), %rdi
leaq 0x1174a(%rip), %rsi     # 0x181b8
callq 0x6690
movq -0x20(%rbp), %rdi
movq 0x1174a(%rip), %rcx     # 0x181c8
subq %rcx, %rax
movl %eax, %esi
callq 0x6590
movq -0x10(%rbp), %rax
movq (%rax), %rax
movb $0xa, (%rax)
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: 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 %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
callq 0x69d0
movq 0x11704(%rip), %rax     # 0x181c8
movq -0x8(%rbp), %rcx
movq (%rcx), %rcx
movslq -0x4(%rcx), %rcx
addq %rcx, %rax
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rax
cmpq $-0x1, (%rax)
je 0x6ae2
jmp 0x6b16
movq -0x18(%rbp), %rdi
addq $0x8, %rdi
leaq 0xa92b(%rip), %rsi      # 0x1141c
callq 0x51e0
movq %rax, %rcx
movq -0x18(%rbp), %rax
movq %rcx, (%rax)
movq -0x18(%rbp), %rax
cmpq $0x0, (%rax)
jne 0x6b16
leaq 0xa90d(%rip), %rdi      # 0x1141e
callq 0x6220
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax)
// File: 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
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x10(%rbp)
cmpq $0x0, 0x11640(%rip)     # 0x181d0
je 0x6bad
movq 0x11637(%rip), %rax     # 0x181d0
addq $-0x4, %rax
movq %rax, 0x1162c(%rip)     # 0x181d0
cmpq 0x11635(%rip), %rax     # 0x181e0
jae 0x6bb9
leaq 0xa886(%rip), %rdi      # 0x1143a
callq 0x6220
movq 0x11610(%rip), %rax     # 0x181d0
movl (%rax), %eax
movl %eax, -0x14(%rbp)
movq -0x8(%rbp), %rax
movq 0x10(%rax), %rax
movslq -0x14(%rbp), %rcx
addq %rcx, %rax
movq %rax, -0x20(%rbp)
movq -0x8(%rbp), %rax
movq (%rax), %rax
movq -0x8(%rbp), %rcx
movq 0x10(%rcx), %rcx
subq %rcx, %rax
movslq -0x14(%rbp), %rcx
subq %rcx, %rax
movl %eax, -0x14(%rbp)
movslq -0x14(%rbp), %rax
cmpq $0xfff3, %rax           # imm = 0xFFF3
jb 0x6c0c
leaq 0xa83f(%rip), %rdi      # 0x11446
callq 0x6220
movq -0x20(%rbp), %rax
movl (%rax), %ecx
andl $0xffff0000, %ecx       # imm = 0xFFFF0000
orl -0x14(%rbp), %ecx
movq -0x20(%rbp), %rax
movl %ecx, (%rax)
addq $0x20, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: 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:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x8(%rbp)
movq -0x10(%rbp), %rax
movq 0x10(%rax), %rax
movzbl 0x1(%rax), %eax
cmpl $0x6e, %eax
jne 0x6c62
leaq 0x114c0(%rip), %rax     # 0x1811c
movl $0x1, (%rax)
jmp 0x6c64
movq -0x10(%rbp), %rax
movq (%rax), %rax
movzbl (%rax), %eax
cmpl $0xa, %eax
je 0x6c83
movq -0x10(%rbp), %rax
movq (%rax), %rcx
addq $0x1, %rcx
movq %rcx, (%rax)
jmp 0x6c64
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: 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 %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x10(%rbp), %rcx
movq (%rcx), %rax
movq %rax, %rdx
addq $0x1, %rdx
movq %rdx, (%rcx)
movzbl (%rax), %eax
cmpl $0x5c, %eax
jne 0x6d32
movq -0x10(%rbp), %rcx
movq (%rcx), %rax
movq %rax, %rdx
addq $0x1, %rdx
movq %rdx, (%rcx)
movzbl (%rax), %eax
cmpl $0xa, %eax
je 0x6d3e
leaq 0xa742(%rip), %rdi      # 0x1147b
callq 0x6220
jmp 0x6d40
jmp 0x6d42
xorl %eax, %eax
leaq 0x113dd(%rip), %rcx     # 0x18128
cmpl $0x0, (%rcx)
movb %al, -0x11(%rbp)
je 0x6d65
movq -0x10(%rbp), %rdi
callq 0x60c0
cmpl $0x0, %eax
setne %al
movb %al, -0x11(%rbp)
movb -0x11(%rbp), %al
testb $0x1, %al
jne 0x6d6e
jmp 0x6d70
jmp 0x6d42
movq -0x8(%rbp), %rax
cmpq $0x0, 0x10(%rax)
je 0x6d9b
movq -0x8(%rbp), %rax
movq (%rax), %rax
movq -0x8(%rbp), %rcx
movq 0x8(%rcx), %rcx
addq $-0x2, %rcx
addq $0x4, %rcx
addq $-0x1, %rcx
cmpq %rcx, %rax
jb 0x6dab
movq -0x8(%rbp), %rdi
movl $0x6, %esi
callq 0x5ae0
jmp 0x6dad
jmp 0x6dad
movq -0x10(%rbp), %rax
movq (%rax), %rax
movzbl (%rax), %eax
movl %eax, -0x18(%rbp)
testl %eax, %eax
je 0x6dd7
jmp 0x6dc0
movl -0x18(%rbp), %eax
subl $0xa, %eax
je 0x6de5
jmp 0x6dca
movl -0x18(%rbp), %eax
subl $0x5c, %eax
je 0x6e50
jmp 0x6e5e
leaq 0xa6be(%rip), %rdi      # 0x1149c
movb $0x0, %al
callq 0x5820
movq -0x10(%rbp), %rax
movq (%rax), %rax
movb (%rax), %cl
movq -0x8(%rbp), %rdx
movq (%rdx), %rax
movq %rax, %rsi
addq $0x1, %rsi
movq %rsi, (%rdx)
movb %cl, (%rax)
movq -0x8(%rbp), %rcx
movq (%rcx), %rax
movq %rax, %rdx
addq $0x1, %rdx
movq %rdx, (%rcx)
movb $0x0, (%rax)
movq -0x8(%rbp), %rax
movq (%rax), %rcx
addq $0x4, %rcx
addq $-0x1, %rcx
movq -0x8(%rbp), %rax
movq (%rax), %rdx
addq $0x4, %rdx
addq $-0x1, %rdx
subq $0x0, %rdx
andq $0x3, %rdx
xorl %eax, %eax
subq %rdx, %rax
addq %rax, %rcx
movq -0x8(%rbp), %rax
movq %rcx, (%rax)
addq $0x20, %rsp
popq %rbp
retq
movq -0x10(%rbp), %rax
movq (%rax), %rcx
addq $0x1, %rcx
movq %rcx, (%rax)
movq -0x10(%rbp), %rcx
movq (%rcx), %rax
movq %rax, %rdx
addq $0x1, %rdx
movq %rdx, (%rcx)
movb (%rax), %cl
movq -0x8(%rbp), %rdx
movq (%rdx), %rax
movq %rax, %rsi
addq $0x1, %rsi
movq %rsi, (%rdx)
movb %cl, (%rax)
jmp 0x6d40
nopl (%rax)
// File: 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 %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq (%rax), %rax
movq -0x8(%rbp), %rcx
movq 0x10(%rcx), %rcx
subq %rcx, %rax
movl %eax, -0xc(%rbp)
movq -0x8(%rbp), %rax
movq 0x10(%rax), %rdi
movslq -0xc(%rbp), %rdx
movq 0xfa7c(%rip), %rax      # 0x16fb0
movq (%rax), %rcx
movl $0x1, %esi
callq 0x5320
movslq -0xc(%rbp), %rcx
cmpq %rcx, %rax
je 0x7558
movq 0x1015f(%rip), %rdi     # 0x176b0
movb $0x0, %al
callq 0x5820
movl $0xa, %edi
callq 0x74d0
addq $0x10, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: 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
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq 0x10(%rax), %rax
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rax
movq -0x8(%rbp), %rcx
cmpq (%rcx), %rax
jae 0x7637
movq -0x18(%rbp), %rdi
movq -0x10(%rbp), %rsi
callq 0x7660
movl %eax, -0x1c(%rbp)
cmpl $0x0, -0x1c(%rbp)
je 0x7608
movq -0x18(%rbp), %rdi
callq 0x64f0
movl (%rax), %eax
sarl $0x10, %eax
andl $0xff, %eax
movl %eax, -0x20(%rbp)
cmpl $0x2, -0x1c(%rbp)
jne 0x75dc
cmpl $0x63, -0x20(%rbp)
jne 0x75dc
movl $0x64, -0x20(%rbp)
movslq -0x20(%rbp), %rcx
leaq 0x100d9(%rip), %rax     # 0x176c0
movq (%rax,%rcx,8), %rax
movq -0x8(%rbp), %rdi
movq -0x18(%rbp), %rsi
movq -0x10(%rbp), %rdx
callq *%rax
movq %rax, -0x18(%rbp)
cmpq $0x0, -0x18(%rbp)
jne 0x7606
jmp 0x764c
jmp 0x7632
movq -0x18(%rbp), %rax
movq %rax, -0x28(%rbp)
movq -0x18(%rbp), %rdi
callq 0x64f0
movq %rax, %rcx
movq -0x28(%rbp), %rax
movl (%rcx), %ecx
andl $0xffff, %ecx           # imm = 0xFFFF
movslq %ecx, %rcx
addq %rcx, %rax
movq %rax, -0x18(%rbp)
jmp 0x758c
leaq 0x10ade(%rip), %rax     # 0x1811c
cmpl $0x0, (%rax)
jne 0x764c
movq -0x10(%rbp), %rdi
callq 0x7500
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: 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:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movl %edi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl -0x8(%rbp), %eax
andl $0x80000000, %eax       # imm = 0x80000000
cmpl $0x0, %eax
je 0x78be
movl -0x8(%rbp), %edi
callq 0x6670
movq %rax, %rdi
movq -0x10(%rbp), %rax
movq 0x10(%rax), %rsi
xorl %eax, %eax
movl %eax, %ecx
xorl %r8d, %r8d
movq %rcx, %rdx
callq 0xbc00
cmpl $0x0, %eax
sete %al
andb $0x1, %al
movzbl %al, %eax
movl %eax, -0x4(%rbp)
jmp 0x7906
movl -0x8(%rbp), %eax
leaq 0x10850(%rip), %rcx     # 0x18118
cmpl (%rcx), %eax
jne 0x78d5
movl $0x1, -0x4(%rbp)
jmp 0x7906
cmpl $0x7fffffff, -0x8(%rbp) # imm = 0x7FFFFFFF
jne 0x78e8
callq 0x5d30
movl %eax, -0x4(%rbp)
jmp 0x7906
movl -0x8(%rbp), %eax
leaq 0x10826(%rip), %rcx     # 0x18118
cmpl (%rcx), %eax
jge 0x78ff
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
jmp 0x7906
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x10, %rsp
popq %rbp
retq
nop
// File: 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 %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq (%rax), %rax
movq -0x8(%rbp), %rcx
movq 0x10(%rcx), %rcx
subq %rcx, %rax
movl %eax, -0x14(%rbp)
movq -0x10(%rbp), %rax
cmpq $0x0, 0x10(%rax)
je 0x79d8
movq -0x10(%rbp), %rax
movq (%rax), %rax
movq -0x10(%rbp), %rcx
movq 0x8(%rcx), %rcx
movslq -0x14(%rbp), %rsi
xorl %edx, %edx
subq %rsi, %rdx
addq %rdx, %rcx
addq $0x1, %rcx
addq $-0x1, %rcx
cmpq %rcx, %rax
jb 0x79e9
movq -0x10(%rbp), %rdi
movl -0x14(%rbp), %esi
addl $0x1, %esi
callq 0x5ae0
jmp 0x79eb
jmp 0x79eb
movq -0x10(%rbp), %rax
movq (%rax), %rdi
movq -0x8(%rbp), %rax
movq 0x10(%rax), %rsi
movslq -0x14(%rbp), %rdx
callq 0x52b0
movl -0x14(%rbp), %edx
movq -0x10(%rbp), %rax
movq (%rax), %rcx
movslq %edx, %rdx
addq %rdx, %rcx
movq %rcx, (%rax)
movq -0x10(%rbp), %rax
movq (%rax), %rax
movb $0x0, (%rax)
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: arnoldrobbins[P]mcilroy-regex/sed2.cpp
// Function: vv(Text*, unsigned char*, Text*)
uchar *
vv(Text *script, uchar *pc, Text *data)
{
	script = script;
	pc = pc;
	data = data;
	quit(IBUG,3);
	return 0;	/* dummy */
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x8(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x10(%rbp)
movq -0x18(%rbp), %rax
movq %rax, -0x18(%rbp)
leaq 0x9b29(%rip), %rdi      # 0x1158c
movl $0x3, %esi
movb $0x0, %al
callq 0x5820
xorl %eax, %eax
addq $0x20, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: 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 %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movq -0x20(%rbp), %rax
movq 0x10(%rax), %rdi
movl $0xa, %esi
callq 0x50c0
movq %rax, -0x30(%rbp)
cmpq $0x0, -0x30(%rbp)
jne 0x7b18
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rsi
movq -0x20(%rbp), %rdx
callq 0x7b80
movq %rax, -0x8(%rbp)
jmp 0x7b71
movq -0x30(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x30(%rbp)
movq -0x20(%rbp), %rax
movq (%rax), %rax
movq -0x30(%rbp), %rcx
subq %rcx, %rax
movl %eax, -0x24(%rbp)
movq -0x20(%rbp), %rax
movq 0x10(%rax), %rdi
movq -0x30(%rbp), %rsi
movl -0x24(%rbp), %eax
addl $0x1, %eax
movslq %eax, %rdx
callq 0x52b0
movq -0x20(%rbp), %rax
movq 0x10(%rax), %rcx
movslq -0x24(%rbp), %rax
addq %rax, %rcx
movq -0x20(%rbp), %rax
movq %rcx, (%rax)
movq -0x10(%rbp), %rax
movq 0x10(%rax), %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: 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 %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x8(%rbp)
movq -0x18(%rbp), %rax
movq %rax, -0x18(%rbp)
leaq 0x1053d(%rip), %rax     # 0x18118
movl (%rax), %esi
leaq 0x99bb(%rip), %rdi      # 0x1159f
movb $0x0, %al
callq 0x5050
cmpl $0x0, %eax
jg 0x7bfe
movq 0xfab9(%rip), %rdi      # 0x176b0
movb $0x0, %al
callq 0x5820
movq -0x10(%rbp), %rax
movq %rax, -0x20(%rbp)
movq -0x10(%rbp), %rdi
callq 0x64f0
movq %rax, %rcx
movq -0x20(%rbp), %rax
movl (%rcx), %ecx
andl $0xffff, %ecx           # imm = 0xFFFF
movslq %ecx, %rcx
addq %rcx, %rax
addq $0x20, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: 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 %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x8(%rbp)
cmpq $0x0, 0x105a4(%rip)     # 0x181f8
jne 0x7c62
leaq 0x1058b(%rip), %rdi     # 0x181e8
callq 0x7910
movq -0x18(%rbp), %rax
movq (%rax), %rax
movq -0x18(%rbp), %rcx
cmpq 0x10(%rcx), %rax
jbe 0x7c87
movq -0x18(%rbp), %rcx
movq (%rcx), %rax
movq %rax, %rdx
addq $0x1, %rdx
movq %rdx, (%rcx)
movb $0xa, (%rax)
movq -0x18(%rbp), %rsi
leaq 0x10556(%rip), %rdi     # 0x181e8
callq 0x7980
movq -0x10(%rbp), %rax
movq %rax, -0x20(%rbp)
movq -0x10(%rbp), %rdi
callq 0x64f0
movq %rax, %rcx
movq -0x20(%rbp), %rax
movl (%rcx), %ecx
andl $0xffff, %ecx           # imm = 0xFFFF
movslq %ecx, %rcx
addq %rcx, %rax
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: 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 %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x8(%rbp)
cmpq $0x0, 0x104c4(%rip)     # 0x181f8
je 0x7d51
movq 0x104ab(%rip), %rax     # 0x181e8
movq 0x104ac(%rip), %rcx     # 0x181f0
addq $-0x1, %rcx
addq $-0x1, %rcx
cmpq %rcx, %rax
jb 0x7d64
leaq 0x10490(%rip), %rdi     # 0x181e8
movl $0x1, %esi
callq 0x5ae0
jmp 0x7d66
jmp 0x7d66
movq 0x1047b(%rip), %rax     # 0x181e8
movq %rax, %rcx
addq $0x1, %rcx
movq %rcx, 0x1046d(%rip)     # 0x181e8
movb $0xa, (%rax)
movq -0x18(%rbp), %rdi
leaq 0x1045f(%rip), %rsi     # 0x181e8
callq 0x7980
movq -0x10(%rbp), %rax
movq %rax, -0x20(%rbp)
movq -0x10(%rbp), %rdi
callq 0x64f0
movq %rax, %rcx
movq -0x20(%rbp), %rax
movl (%rcx), %ecx
andl $0xffff, %ecx           # imm = 0xFFFF
movslq %ecx, %rcx
addq %rcx, %rax
addq $0x20, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: 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 %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x8(%rbp)
leaq 0x10405(%rip), %rdi     # 0x181e8
callq 0x7910
movq -0x18(%rbp), %rdi
leaq 0x103f5(%rip), %rsi     # 0x181e8
callq 0x7980
movq -0x10(%rbp), %rax
movq %rax, -0x20(%rbp)
movq -0x10(%rbp), %rdi
callq 0x64f0
movq %rax, %rcx
movq -0x20(%rbp), %rax
movl (%rcx), %ecx
andl $0xffff, %ecx           # imm = 0xFFFF
movslq %ecx, %rcx
addq %rcx, %rax
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: 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 %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x8(%rbp)
movq -0x18(%rbp), %rax
movq %rax, -0x18(%rbp)
movq -0x10(%rbp), %rdi
callq 0x64f0
movq %rax, %rsi
addq $0x4, %rsi
leaq 0x96f6(%rip), %rdi      # 0x115b1
movb $0x0, %al
callq 0x5050
cmpl $0x0, %eax
jg 0x7ed5
movq 0xf7e2(%rip), %rdi      # 0x176b0
movb $0x0, %al
callq 0x5820
movq -0x10(%rbp), %rax
movq %rax, -0x20(%rbp)
movq -0x10(%rbp), %rdi
callq 0x64f0
movq %rax, %rcx
movq -0x20(%rbp), %rax
movl (%rcx), %ecx
andl $0xffff, %ecx           # imm = 0xFFFF
movslq %ecx, %rcx
addq %rcx, %rax
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: 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 %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movq -0x20(%rbp), %rax
cmpq $0x0, 0x10(%rax)
je 0x7f8b
movq -0x20(%rbp), %rax
movq (%rax), %rax
movq -0x20(%rbp), %rcx
movq 0x8(%rcx), %rcx
addq $-0x1, %rcx
addq $-0x1, %rcx
cmpq %rcx, %rax
jb 0x7f9b
movq -0x20(%rbp), %rdi
movl $0x1, %esi
callq 0x5ae0
jmp 0x7f9d
jmp 0x7f9d
movq -0x20(%rbp), %rcx
movq (%rcx), %rax
movq %rax, %rdx
addq $0x1, %rdx
movq %rdx, (%rcx)
movb $0xa, (%rax)
movq -0x20(%rbp), %rdi
callq 0x5970
cmpl $0x0, %eax
je 0x7feb
movq -0x18(%rbp), %rax
movq %rax, -0x28(%rbp)
movq -0x18(%rbp), %rdi
callq 0x64f0
movq %rax, %rcx
movq -0x28(%rbp), %rax
movl (%rcx), %ecx
andl $0xffff, %ecx           # imm = 0xFFFF
movslq %ecx, %rcx
addq %rcx, %rax
movq %rax, -0x8(%rbp)
jmp 0x8015
movq -0x20(%rbp), %rcx
movq (%rcx), %rax
movq %rax, %rdx
addq $-0x1, %rdx
movq %rdx, (%rcx)
movb $0x0, -0x1(%rax)
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rsi
movq -0x20(%rbp), %rdx
callq 0x7b80
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x30, %rsp
popq %rbp
retq
nop
// File: 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 %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
leaq 0x100e1(%rip), %rax     # 0x1811c
cmpl $0x0, (%rax)
jne 0x8049
movq -0x20(%rbp), %rdi
callq 0x7500
movq -0x20(%rbp), %rdi
callq 0x7910
movq -0x20(%rbp), %rdi
callq 0x5970
cmpl $0x0, %eax
je 0x808c
movq -0x18(%rbp), %rax
movq %rax, -0x28(%rbp)
movq -0x18(%rbp), %rdi
callq 0x64f0
movq %rax, %rcx
movq -0x28(%rbp), %rax
movl (%rcx), %ecx
andl $0xffff, %ecx           # imm = 0xFFFF
movslq %ecx, %rcx
addq %rcx, %rax
movq %rax, -0x8(%rbp)
jmp 0x8094
movq $0x0, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x30, %rsp
popq %rbp
retq
nop
// File: 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 %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x18(%rbp), %rax
movq 0x10(%rax), %rdi
movl $0xa, %esi
callq 0x50c0
movq %rax, -0x28(%rbp)
cmpq $0x0, -0x28(%rbp)
jne 0x80e8
movq -0x18(%rbp), %rax
movq (%rax), %rax
movq -0x18(%rbp), %rcx
movq 0x10(%rcx), %rcx
subq %rcx, %rax
movl %eax, -0x1c(%rbp)
jmp 0x80fa
movq -0x28(%rbp), %rax
movq -0x18(%rbp), %rcx
movq 0x10(%rcx), %rcx
subq %rcx, %rax
movl %eax, -0x1c(%rbp)
movq -0x18(%rbp), %rax
movq 0x10(%rax), %rdi
movslq -0x1c(%rbp), %rdx
movq 0xeea3(%rip), %rax      # 0x16fb0
movq (%rax), %rcx
movl $0x1, %esi
callq 0x5320
movslq -0x1c(%rbp), %rcx
cmpq %rcx, %rax
je 0x8131
movq 0xf586(%rip), %rdi      # 0x176b0
movb $0x0, %al
callq 0x5820
movl $0xa, %edi
callq 0x74d0
movq -0x8(%rbp), %rax
movq %rax, -0x8(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x30(%rbp)
movq -0x10(%rbp), %rdi
callq 0x64f0
movq %rax, %rcx
movq -0x30(%rbp), %rax
movl (%rcx), %ecx
andl $0xffff, %ecx           # imm = 0xFFFF
movslq %ecx, %rcx
addq %rcx, %rax
addq $0x30, %rsp
popq %rbp
retq
nop
// File: arnoldrobbins[P]mcilroy-regex/sed2.cpp
// Function: qe(Text*, unsigned char*, Text*)
uchar *
qe(Text *script, uchar *pc, Text *data)
{
	pc = pc;
	data = data;
	qflag++;
	return script->w;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x10(%rbp)
movq -0x18(%rbp), %rax
movq %rax, -0x18(%rbp)
leaq 0xff29(%rip), %rax      # 0x18120
movl (%rax), %ecx
addl $0x1, %ecx
leaq 0xff1d(%rip), %rax      # 0x18120
movl %ecx, (%rax)
movq -0x8(%rbp), %rax
movq (%rax), %rax
popq %rbp
retq
nop
// File: 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 %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
leaq 0xfef9(%rip), %rax      # 0x18124
movl (%rax), %eax
movl %eax, -0x24(%rbp)
leaq 0xfeed(%rip), %rax      # 0x18124
movl $0x0, (%rax)
cmpl $0x0, -0x24(%rbp)
je 0x825a
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rsi
movq -0x20(%rbp), %rdx
callq 0x7a80
movq %rax, -0x8(%rbp)
jmp 0x8284
movq -0x18(%rbp), %rax
movq %rax, -0x30(%rbp)
movq -0x18(%rbp), %rdi
callq 0x64f0
movq %rax, %rcx
movq -0x30(%rbp), %rax
movl (%rcx), %ecx
andl $0xffff, %ecx           # imm = 0xFFFF
movslq %ecx, %rcx
addq %rcx, %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x30, %rsp
popq %rbp
retq
nop
// File: 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
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movl %ecx, -0x1c(%rbp)
leaq 0xff0a(%rip), %rax      # 0x181b8
movq 0x10(%rax), %rax
movslq -0x1c(%rbp), %rcx
addq %rcx, %rax
movq %rax, -0x28(%rbp)
movq -0x28(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x30(%rbp)
movq -0x18(%rbp), %rax
movq (%rax), %rax
movq -0x18(%rbp), %rcx
movq 0x10(%rcx), %rcx
subq %rcx, %rax
movl %eax, -0x34(%rbp)
movq -0x18(%rbp), %rax
cmpq $0x0, 0x10(%rax)
je 0x8304
movq -0x18(%rbp), %rax
movq (%rax), %rax
movq -0x18(%rbp), %rcx
movq 0x8(%rcx), %rcx
addq $-0x1, %rcx
addq $-0x1, %rcx
cmpq %rcx, %rax
jb 0x8314
movq -0x18(%rbp), %rdi
movl $0x1, %esi
callq 0x5ae0
jmp 0x8316
jmp 0x8316
movq -0x18(%rbp), %rax
movq (%rax), %rax
movb $0xa, (%rax)
movq -0x18(%rbp), %rax
movq 0x10(%rax), %rdi
movl -0x34(%rbp), %eax
addl $0x1, %eax
movslq %eax, %rdx
movq -0x30(%rbp), %rcx
movl $0x1, %esi
callq 0x5320
movl -0x34(%rbp), %ecx
addl $0x1, %ecx
movslq %ecx, %rcx
cmpq %rcx, %rax
jne 0x835b
movq -0x30(%rbp), %rdi
callq 0x51d0
cmpl $-0x1, %eax
jne 0x8371
movq -0x28(%rbp), %rsi
addq $0x4, %rsi
leaq 0x9239(%rip), %rdi      # 0x115a3
movb $0x0, %al
callq 0x5820
movq -0x18(%rbp), %rax
movq (%rax), %rax
movb $0x0, (%rax)
movq -0x8(%rbp), %rax
movq %rax, -0x8(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x40(%rbp)
movq -0x10(%rbp), %rdi
callq 0x64f0
movq %rax, %rcx
movq -0x40(%rbp), %rax
movl (%rcx), %ecx
andl $0xffff, %ecx           # imm = 0xFFFF
movslq %ecx, %rcx
addq %rcx, %rax
addq $0x40, %rsp
popq %rbp
retq
nop
// File: 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 %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x8(%rbp)
cmpq $0x0, 0xfdd4(%rip)      # 0x181f8
jne 0x8432
leaq 0xfdbb(%rip), %rdi      # 0x181e8
callq 0x7910
movq -0x18(%rbp), %rax
movq 0x10(%rax), %rax
movq %rax, -0x20(%rbp)
movq 0xfdb3(%rip), %rcx      # 0x181f8
movq -0x18(%rbp), %rax
movq %rcx, 0x10(%rax)
movq -0x20(%rbp), %rax
movq %rax, 0xfda0(%rip)      # 0x181f8
movq -0x18(%rbp), %rax
movq 0x8(%rax), %rax
movq %rax, -0x20(%rbp)
movq 0xfd85(%rip), %rcx      # 0x181f0
movq -0x18(%rbp), %rax
movq %rcx, 0x8(%rax)
movq -0x20(%rbp), %rax
movq %rax, 0xfd72(%rip)      # 0x181f0
movq -0x18(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x20(%rbp)
movq 0xfd58(%rip), %rcx      # 0x181e8
movq -0x18(%rbp), %rax
movq %rcx, (%rax)
movq -0x20(%rbp), %rax
movq %rax, 0xfd46(%rip)      # 0x181e8
movq -0x10(%rbp), %rax
movq %rax, -0x28(%rbp)
movq -0x10(%rbp), %rdi
callq 0x64f0
movq %rax, %rcx
movq -0x28(%rbp), %rax
movl (%rcx), %ecx
andl $0xffff, %ecx           # imm = 0xFFFF
movslq %ecx, %rcx
addq %rcx, %rax
addq $0x30, %rsp
popq %rbp
retq
nop
// File: 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 %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x18(%rbp), %rax
movq 0x10(%rax), %rax
movq %rax, -0x20(%rbp)
movq -0x18(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x28(%rbp)
movq -0x10(%rbp), %rdi
callq 0x64f0
addq $0x4, %rax
movq %rax, -0x30(%rbp)
movq -0x20(%rbp), %rax
cmpq -0x28(%rbp), %rax
jae 0x8538
movq -0x30(%rbp), %rax
movq -0x20(%rbp), %rcx
movzbl (%rcx), %ecx
movb (%rax,%rcx), %cl
movq -0x20(%rbp), %rax
movb %cl, (%rax)
movq -0x20(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x20(%rbp)
jmp 0x850c
movq -0x8(%rbp), %rax
movq %rax, -0x8(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x38(%rbp)
movq -0x10(%rbp), %rdi
callq 0x64f0
movq %rax, %rcx
movq -0x38(%rbp), %rax
movl (%rcx), %ecx
andl $0xffff, %ecx           # imm = 0xFFFF
movslq %ecx, %rcx
addq %rcx, %rax
addq $0x40, %rsp
popq %rbp
retq
nopl (%rax)
// File: 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
movq %rsp, %rbp
subq $0x70, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movq -0x18(%rbp), %rdi
callq 0x64f0
movq %rax, -0x28(%rbp)
movq -0x28(%rbp), %rax
movl 0x8(%rax), %eax
movl %eax, -0x2c(%rbp)
movq -0x28(%rbp), %rax
addq $0xc, %rax
movq %rax, -0x38(%rbp)
movl -0x2c(%rbp), %eax
andl $0x3fffffff, %eax       # imm = 0x3FFFFFFF
movl %eax, -0x3c(%rbp)
movq -0x28(%rbp), %rax
movl 0x4(%rax), %edi
callq 0x6670
movq %rax, %rdi
movq -0x20(%rbp), %rsi
movq -0x38(%rbp), %rdx
movl -0x3c(%rbp), %ecx
callq 0x8cf0
movl %eax, %ecx
leaq 0xfb4a(%rip), %rax      # 0x18124
movl %ecx, (%rax)
leaq 0xfb41(%rip), %rax      # 0x18124
cmpl $0x0, (%rax)
jne 0x8617
movq -0x18(%rbp), %rax
movq %rax, -0x48(%rbp)
movq -0x18(%rbp), %rdi
callq 0x64f0
movq %rax, %rcx
movq -0x48(%rbp), %rax
movl (%rcx), %ecx
andl $0xffff, %ecx           # imm = 0xFFFF
movslq %ecx, %rcx
addq %rcx, %rax
movq %rax, -0x8(%rbp)
jmp 0x86c2
movl -0x2c(%rbp), %eax
andl $0x80000000, %eax       # imm = 0x80000000
cmpl $0x0, %eax
je 0x8635
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rsi
movq -0x20(%rbp), %rdx
callq 0x8170
movl -0x2c(%rbp), %eax
andl $0x40000000, %eax       # imm = 0x40000000
cmpl $0x0, %eax
je 0x8698
movq -0x10(%rbp), %rax
movq %rax, -0x68(%rbp)
movq -0x18(%rbp), %rax
movq %rax, -0x60(%rbp)
movq -0x20(%rbp), %rax
movq %rax, -0x58(%rbp)
movq -0x18(%rbp), %rax
movq %rax, -0x50(%rbp)
movq -0x18(%rbp), %rdi
callq 0x64f0
movq -0x68(%rbp), %rdi
movq -0x60(%rbp), %rsi
movq -0x58(%rbp), %rdx
movq %rax, %rcx
movq -0x50(%rbp), %rax
movl (%rcx), %ecx
andl $0xffff, %ecx           # imm = 0xFFFF
movslq %ecx, %rcx
movl -0x4(%rax,%rcx), %ecx
callq 0x8290
movq %rax, -0x8(%rbp)
jmp 0x86c2
movq -0x18(%rbp), %rax
movq %rax, -0x70(%rbp)
movq -0x18(%rbp), %rdi
callq 0x64f0
movq %rax, %rcx
movq -0x70(%rbp), %rax
movl (%rcx), %ecx
andl $0xffff, %ecx           # imm = 0xFFFF
movslq %ecx, %rcx
addq %rcx, %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x70, %rsp
popq %rbp
retq
nopl (%rax)
// File: 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
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movl $0x0, -0x1c(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x8(%rbp)
movq -0x18(%rbp), %rax
movq 0x10(%rax), %rax
movq %rax, -0x28(%rbp)
movq -0x28(%rbp), %rax
movq -0x18(%rbp), %rcx
cmpq (%rcx), %rax
jae 0x87ef
cmpl $0x3c, -0x1c(%rbp)
jl 0x8731
movl $0x5c, %edi
callq 0x74d0
movl $0xa, %edi
callq 0x74d0
movl $0x0, -0x1c(%rbp)
movl $0x0, -0x20(%rbp)
movslq -0x20(%rbp), %rax
cmpq $0x8, %rax
jae 0x878a
movq -0x28(%rbp), %rax
movzbl (%rax), %eax
movslq -0x20(%rbp), %rdx
leaq 0xf36c(%rip), %rcx      # 0x17ac0
movsbl (%rcx,%rdx,2), %ecx
cmpl %ecx, %eax
jne 0x877d
movl $0x5c, %edi
callq 0x74d0
movslq -0x20(%rbp), %rcx
leaq 0xf34f(%rip), %rax      # 0x17ac0
movsbl 0x1(%rax,%rcx,2), %edi
callq 0x74d0
jmp 0x87d3
jmp 0x877f
movl -0x20(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x20(%rbp)
jmp 0x8738
movq -0x28(%rbp), %rax
movzbl (%rax), %edi
callq 0x52e0
cmpl $0x0, %eax
jne 0x87c5
movq -0x28(%rbp), %rax
movzbl (%rax), %esi
leaq 0x8e0b(%rip), %rdi      # 0x115b4
movb $0x0, %al
callq 0x5050
cmpl $0x0, %eax
jg 0x87c3
movq 0xeef4(%rip), %rdi      # 0x176b0
movb $0x0, %al
callq 0x5820
jmp 0x87d1
movq -0x28(%rbp), %rax
movzbl (%rax), %edi
callq 0x74d0
jmp 0x87d3
jmp 0x87d5
movq -0x28(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x28(%rbp)
movl -0x1c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x1c(%rbp)
jmp 0x86ff
movl $0x24, %edi
callq 0x74d0
movl $0xa, %edi
callq 0x74d0
movq -0x10(%rbp), %rax
movq %rax, -0x30(%rbp)
movq -0x10(%rbp), %rdi
callq 0x64f0
movq %rax, %rcx
movq -0x30(%rbp), %rax
movl (%rcx), %ecx
andl $0xffff, %ecx           # imm = 0xFFFF
movslq %ecx, %rcx
addq %rcx, %rax
addq $0x30, %rsp
popq %rbp
retq
nop
// File: 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 %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x8(%rbp)
movq -0x18(%rbp), %rax
movq %rax, -0x18(%rbp)
cmpq $0x0, 0xf9b4(%rip)      # 0x18210
je 0x8879
movq 0xf99b(%rip), %rax      # 0x18200
movq 0xf99c(%rip), %rcx      # 0x18208
addq $-0x8, %rcx
addq $-0x1, %rcx
cmpq %rcx, %rax
jb 0x888c
leaq 0xf980(%rip), %rdi      # 0x18200
movl $0x8, %esi
callq 0x5ae0
jmp 0x888e
jmp 0x888e
movq -0x10(%rbp), %rcx
movq 0xf967(%rip), %rax      # 0x18200
movq %rcx, (%rax)
movq 0xf95d(%rip), %rax      # 0x18200
addq $0x8, %rax
movq %rax, 0xf952(%rip)      # 0x18200
movq -0x10(%rbp), %rax
movq %rax, -0x20(%rbp)
movq -0x10(%rbp), %rdi
callq 0x64f0
movq %rax, %rcx
movq -0x20(%rbp), %rax
movl (%rcx), %ecx
andl $0xffff, %ecx           # imm = 0xFFFF
movslq %ecx, %rcx
addq %rcx, %rax
addq $0x20, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: 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
movq %rsp, %rbp
subq $0x30, %rsp
cmpq $0x0, 0xf8c0(%rip)      # 0x18210
jne 0x8957
jmp 0x8a5a
movq 0xf8b2(%rip), %rax      # 0x18210
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rax
cmpq 0xf893(%rip), %rax      # 0x18200
jae 0x8a4e
movq -0x18(%rbp), %rax
movq (%rax), %rdi
callq 0x64f0
movq %rax, -0x10(%rbp)
movq -0x10(%rbp), %rax
movzbl 0x2(%rax), %eax
movl %eax, -0x24(%rbp)
subl $0x61, %eax
je 0x89a2
jmp 0x8995
movl -0x24(%rbp), %eax
subl $0x72, %eax
je 0x89cd
jmp 0x8a28
movq -0x10(%rbp), %rsi
addq $0x4, %rsi
leaq 0x8c00(%rip), %rdi      # 0x115b1
movb $0x0, %al
callq 0x5050
cmpl $0x0, %eax
jg 0x89cb
movq 0xecec(%rip), %rdi      # 0x176b0
movb $0x0, %al
callq 0x5820
jmp 0x8a3d
leaq 0xf7e4(%rip), %rax      # 0x181b8
movq 0x10(%rax), %rdi
movq -0x10(%rbp), %rax
movslq 0x4(%rax), %rax
addq %rax, %rdi
addq $0x8, %rdi
leaq 0x8aee(%rip), %rsi      # 0x114dc
callq 0x51e0
movq %rax, -0x20(%rbp)
cmpq $0x0, -0x20(%rbp)
jne 0x8a00
jmp 0x8a3d
jmp 0x8a02
movq -0x20(%rbp), %rdi
callq 0x50a0
movl %eax, -0x4(%rbp)
cmpl $-0x1, %eax
je 0x8a1d
movl -0x4(%rbp), %edi
callq 0x74d0
jmp 0x8a02
movq -0x20(%rbp), %rdi
callq 0x5190
jmp 0x8a3d
leaq 0x8b5d(%rip), %rdi      # 0x1158c
movl $0x5, %esi
movb $0x0, %al
callq 0x5820
jmp 0x8a3d
movq -0x18(%rbp), %rax
addq $0x8, %rax
movq %rax, -0x18(%rbp)
jmp 0x8962
leaq 0xf7ab(%rip), %rdi      # 0x18200
callq 0x7910
addq $0x30, %rsp
popq %rbp
retq
// File: 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 %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
cmpq $0x0, 0xf2a9(%rip)      # 0x18250
je 0x8fd0
movq 0xf290(%rip), %rax      # 0x18240
movq 0xf291(%rip), %rcx      # 0x18248
movslq -0xc(%rbp), %rsi
xorl %edx, %edx
subq %rsi, %rdx
addq %rdx, %rcx
addq $0x1, %rcx
addq $-0x1, %rcx
cmpq %rcx, %rax
jb 0x8fe4
movl -0xc(%rbp), %esi
addl $0x1, %esi
leaq 0xf263(%rip), %rdi      # 0x18240
callq 0x5ae0
jmp 0x8fe6
jmp 0x8fe6
movq 0xf253(%rip), %rdi      # 0x18240
movq -0x8(%rbp), %rsi
movslq -0xc(%rbp), %rdx
callq 0x52b0
movl -0xc(%rbp), %ecx
movq 0xf23c(%rip), %rax      # 0x18240
movslq %ecx, %rcx
addq %rcx, %rax
movq %rax, 0xf22f(%rip)      # 0x18240
movq 0xf228(%rip), %rax      # 0x18240
movb $0x0, (%rax)
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: 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 %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movl %ecx, -0x24(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x30(%rbp)
movq %rax, %rdi
addq $0x28, %rdi
movl 0x20(%rax), %esi
addl $0x1, %esi
callq 0xbce0
cmpl $0x0, %eax
je 0x92a2
movl $0x1, -0x4(%rbp)
jmp 0x9327
movq -0x30(%rbp), %rax
movq -0x18(%rbp), %rcx
movw 0xa(%rcx), %cx
movw %cx, -0x42(%rbp)
movq %rax, %rdi
addq $0x28, %rdi
movl 0x20(%rax), %esi
callq 0xbd20
movw -0x42(%rbp), %dx
movq %rax, %rcx
movq -0x30(%rbp), %rax
movw %dx, 0x8(%rcx)
movq -0x20(%rbp), %rcx
movq %rcx, -0x40(%rbp)
movq %rax, %rdi
addq $0x28, %rdi
movl 0x20(%rax), %esi
callq 0xbd20
movq -0x40(%rbp), %rdx
movq %rax, %rcx
movq -0x30(%rbp), %rax
movq %rdx, (%rcx)
movl -0x24(%rbp), %ecx
movb %cl, -0x31(%rbp)
movq %rax, %rdi
addq $0x28, %rdi
movl 0x20(%rax), %esi
callq 0xbd20
movb -0x31(%rbp), %dl
movq %rax, %rcx
movq -0x30(%rbp), %rax
movb %dl, 0xa(%rcx)
movl 0x20(%rax), %ecx
addl $0x1, %ecx
movl %ecx, 0x20(%rax)
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x50, %rsp
popq %rbp
retq
// File: 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 %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x18(%rbp)
movq -0x18(%rbp), %rax
movq %rax, -0x20(%rbp)
movl 0x8(%rax), %eax
addl $0x1, %eax
movslq %eax, %rdi
callq 0x5030
movq %rax, %rsi
movq -0x20(%rbp), %rax
movl 0x8(%rax), %edx
leaq -0x10(%rbp), %rdi
callq 0xbd40
cmpq $0x0, -0x10(%rbp)
je 0x9390
movq -0x20(%rbp), %rax
movq -0x10(%rbp), %rdi
movq (%rax), %rsi
movslq 0x8(%rax), %rdx
callq 0x52b0
movq -0x20(%rbp), %rcx
movq -0x10(%rbp), %rax
movslq 0x8(%rcx), %rcx
movb $0x0, (%rax,%rcx)
movq -0x10(%rbp), %rax
movl -0x8(%rbp), %edx
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax)