LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_cpp_makefile_star2_O2/arnoldrobbins[P]mcilroy-regex/sed0.cpp
// Function: readscript(Text*, char*)
void
readscript(Text *t, char *s)
{
	int n;
	FILE *f = aopen(s);
	for(;;) {
		assure(t, 4);
		n = fread(t->w, 1, t->e - t->w - 3, f);
		if(n <= 0)
			break;
		t->w += n;
	}
	fclose(f);
	if(t->w > t->s && t->w[-1] != '\n') {
		*t->w++ = '\n';
		warn("newline appended to script segment");
	}
	*t->w = 0;
	safescript(t);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
movq %rsi, %rdi
callq 0x59d3
movq %rax, %r14
pushq $0x4
popq %rbp
pushq $0x1
popq %r15
cmpq $0x0, 0x10(%rbx)
je 0x5623
movq (%rbx), %rdi
movq 0x8(%rbx), %rdx
leaq -0x5(%rdx), %rax
cmpq %rax, %rdi
jb 0x5634
movq %rbx, %rdi
movl %ebp, %esi
callq 0x5880
movq (%rbx), %rdi
movq 0x8(%rbx), %rdx
subq %rdi, %rdx
addq $-0x3, %rdx
movq %r15, %rsi
movq %r14, %rcx
callq 0x5270
testl %eax, %eax
jle 0x5654
andl $0x7fffffff, %eax       # imm = 0x7FFFFFFF
addq %rax, (%rbx)
jmp 0x560c
movq %r14, %rdi
callq 0x5160
movq (%rbx), %rax
cmpq 0x10(%rbx), %rax
jbe 0x5686
cmpb $0xa, -0x1(%rax)
je 0x5686
leaq 0x1(%rax), %rcx
movq %rcx, (%rbx)
movb $0xa, (%rax)
leaq 0x6a15(%rip), %rdi      # 0xc091
xorl %eax, %eax
callq 0x5911
movq (%rbx), %rax
movb $0x0, (%rax)
movq %rbx, %rdi
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
jmp 0x58ed
// File: /workspace/github_cpp_makefile_star2_O2/arnoldrobbins[P]mcilroy-regex/sed0.cpp
// Function: quit(char const*, ...)
void
quit(const char *format, ...)
{
	va_list args;
	fprintf(stderr,"sed error: ");
	va_start(args, format);
	vfprintf(stderr, format, args);
	va_end(args);
	fprintf(stderr,"\n");
	exit(1);
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
subq $0xd0, %rsp
movq %rdi, %rbx
leaq 0x20(%rsp), %r14
movq %rsi, 0x8(%r14)
movq %rdx, 0x10(%r14)
movq %rcx, 0x18(%r14)
movq %r8, 0x20(%r14)
movq %r9, 0x28(%r14)
testb %al, %al
je 0x56fe
movaps %xmm0, 0x50(%rsp)
movaps %xmm1, 0x60(%rsp)
movaps %xmm2, 0x70(%rsp)
movaps %xmm3, 0x80(%rsp)
movaps %xmm4, 0x90(%rsp)
movaps %xmm5, 0xa0(%rsp)
movaps %xmm6, 0xb0(%rsp)
movaps %xmm7, 0xc0(%rsp)
movq 0xc8d3(%rip), %r15      # 0x11fd8
movq (%r15), %rcx
leaq 0x69d3(%rip), %rdi      # 0xc0e2
pushq $0xb
popq %rsi
pushq $0x1
popq %rdx
callq 0x5300
movabsq $0x3000000008, %rax     # imm = 0x3000000008
movq %rsp, %rdx
movq %rax, (%rdx)
leaq 0xf0(%rsp), %rax
movq %rax, 0x8(%rdx)
movq %r14, 0x10(%rdx)
movq (%r15), %rdi
movq %rbx, %rsi
callq 0x5220
movq (%r15), %rsi
pushq $0xa
popq %rdi
callq 0x51f0
pushq $0x1
popq %rdi
callq 0x51e0
// File: /workspace/github_cpp_makefile_star2_O2/arnoldrobbins[P]mcilroy-regex/sed0.cpp
// Function: initinput(int, char**)
void
initinput(int argc, char **argv)
{
	input.iargc = argc;
	input.iargv = argv;
	if(input.iargc == 0) {
		input.iargc = 1;	/* for ateof() */
		input.ifile = stdin;
	} else
		input.ifile = aopen(*input.iargv);
}

// Assembly:
movl %edi, 0xcfc2(%rip)      # 0x12720
movq %rsi, 0xcfc3(%rip)      # 0x12728
testl %edi, %edi
je 0x5778
pushq %rax
movq (%rsi), %rdi
callq 0x59d3
addq $0x8, %rsp
jmp 0x578c
movl $0x1, 0xcf9e(%rip)      # 0x12720
movq 0xc847(%rip), %rax      # 0x11fd0
movq (%rax), %rax
movq %rax, 0xcf9d(%rip)      # 0x12730
retq
// File: /workspace/github_cpp_makefile_star2_O2/arnoldrobbins[P]mcilroy-regex/sed0.cpp
// Function: readline(Text*)
int
readline(Text *t)
{
	int c;
	int len = t->w - t->s;
	coda();
	if(qflag || ateof())
		return 0;
	for(;;) {
		assure(t, 2);
		getch(&c);
		if(c == '\n')
			break;
		else if(c != EOF)
			*t->w++ = c;
		else if(t->w - t->s == len)
			return 0;
		else {
			warn("newline appended");
			break;
		}
	}
	*t->w = 0;			/* for safety */
	getch(&c);			/* to identify line $ */
	if(c != EOF)
		ungetc(c, input.ifile);
	recno++;
	sflag = 0;
	return 1;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
movq (%rdi), %r15
subq 0x10(%rdi), %r15
callq 0x72e3
xorl %ebp, %ebp
cmpl $0x0, 0xcf2d(%rip)      # 0x126e0
jne 0x5873
cmpl $0x0, 0xcf60(%rip)      # 0x12720
jle 0x5873
pushq $0x2
popq %r14
cmpq $0x0, 0x10(%rbx)
je 0x57de
movq 0x8(%rbx), %rax
addq $-0x3, %rax
cmpq %rax, (%rbx)
jb 0x57e9
movq %rbx, %rdi
movl %r14d, %esi
callq 0x5880
movq 0xcf40(%rip), %rdi      # 0x12730
callq 0x50a0
cmpl $-0x1, %eax
jne 0x57ff
callq 0x5a08
cmpl $-0x1, %eax
je 0x5817
cmpl $0xa, %eax
je 0x5834
movq (%rbx), %rcx
leaq 0x1(%rcx), %rdx
movq %rdx, (%rbx)
movb %al, (%rcx)
jmp 0x57ca
movq (%rbx), %rax
subq 0x10(%rbx), %rax
movslq %r15d, %rcx
cmpq %rcx, %rax
je 0x5873
leaq 0x6887(%rip), %rdi      # 0xc0b4
xorl %eax, %eax
callq 0x5911
movq (%rbx), %rax
movb $0x0, (%rax)
movq 0xceef(%rip), %rdi      # 0x12730
callq 0x50a0
cmpl $-0x1, %eax
jne 0x5855
callq 0x5a08
cmpl $-0x1, %eax
je 0x5863
movq 0xced4(%rip), %rsi      # 0x12730
movl %eax, %edi
callq 0x5070
incl 0xce6f(%rip)            # 0x126d8
andl $0x0, 0xce74(%rip)      # 0x126e4
pushq $0x1
popq %rbp
movl %ebp, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/arnoldrobbins[P]mcilroy-regex/sed0.cpp
// Function: grow(Text*, int)
void
grow(Text *t, int n)
{
	int w = t->w - t->s;
	int e = t->e - t->s + (n/BUFSIZ+1)*BUFSIZ;
	t->s = (uchar*)realloc(t->s, e);
	if(t->s == 0)
		quit("out of space");
	t->w = t->s + w;
	t->e = t->s + e;
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movl %esi, %eax
movq %rdi, %rbx
movq (%rdi), %r12
movq 0x10(%rdi), %r14
movl 0x8(%rdi), %ecx
subl %r14d, %ecx
movl $0x2000, %esi           # imm = 0x2000
cltd
idivl %esi
shll $0xd, %eax
addl %esi, %ecx
addl %eax, %ecx
movslq %ecx, %r15
movq %r14, %rdi
movq %r15, %rsi
callq 0x52a0
movq %rax, 0x10(%rbx)
testq %rax, %rax
je 0x58df
subl %r14d, %r12d
movslq %r12d, %rcx
addq %rax, %rcx
movq %rcx, (%rbx)
addq %rax, %r15
movq %r15, 0x8(%rbx)
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
leaq 0x6783(%rip), %rdi      # 0xc069
xorl %eax, %eax
callq 0x569b
// File: /workspace/github_cpp_makefile_star2_O2/arnoldrobbins[P]mcilroy-regex/sed0.cpp
// Function: warn(char const*, ...)
void
warn(const char *format, ...)
{
	va_list args;
	fprintf(stderr,"sed warning: ");
	va_start(args, format);
	vfprintf(stderr, format, args);
	va_end(args);
	fprintf(stderr,"\n");
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
subq $0xd0, %rsp
movq %rdi, %rbx
leaq 0x20(%rsp), %r14
movq %rsi, 0x8(%r14)
movq %rdx, 0x10(%r14)
movq %rcx, 0x18(%r14)
movq %r8, 0x20(%r14)
movq %r9, 0x28(%r14)
testb %al, %al
je 0x5974
movaps %xmm0, 0x50(%rsp)
movaps %xmm1, 0x60(%rsp)
movaps %xmm2, 0x70(%rsp)
movaps %xmm3, 0x80(%rsp)
movaps %xmm4, 0x90(%rsp)
movaps %xmm5, 0xa0(%rsp)
movaps %xmm6, 0xb0(%rsp)
movaps %xmm7, 0xc0(%rsp)
movq 0xc65d(%rip), %r15      # 0x11fd8
movq (%r15), %rcx
leaq 0x674f(%rip), %rdi      # 0xc0d4
pushq $0xd
popq %rsi
pushq $0x1
popq %rdx
callq 0x5300
movabsq $0x3000000008, %rax     # imm = 0x3000000008
movq %rsp, %rdx
movq %rax, (%rdx)
leaq 0xf0(%rsp), %rax
movq %rax, 0x8(%rdx)
movq %r14, 0x10(%rdx)
movq (%r15), %rdi
movq %rbx, %rsi
callq 0x5220
movq (%r15), %rsi
pushq $0xa
popq %rdi
callq 0x51f0
addq $0xd0, %rsp
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_cpp_makefile_star2_O2/arnoldrobbins[P]mcilroy-regex/sed0.cpp
// Function: aopen(char*)
FILE *
aopen(char *s)
{
	FILE *f = fopen(s, "r");
	if(f == 0)
		quit("cannot open %s", s);
	return f;
}

// Assembly:
pushq %rbx
movq %rdi, %rbx
leaq 0x68f4(%rip), %rsi      # 0xc2d2
callq 0x51c0
testq %rax, %rax
je 0x59ea
popq %rbx
retq
leaq 0x66d4(%rip), %rdi      # 0xc0c5
movq %rbx, %rsi
xorl %eax, %eax
callq 0x569b
// File: /workspace/github_cpp_makefile_star2_O2/arnoldrobbins[P]mcilroy-regex/sed0.cpp
// Function: gopen()
int
gopen(void)
{
	int c = EOF;
	while(c==EOF && --input.iargc > 0) {
		fclose(input.ifile);
		input.ifile = aopen(*++input.iargv);
		c = getc(input.ifile);
	}
	return c;
}

// Assembly:
pushq %rax
pushq $-0x1
popq %rax
cmpl $-0x1, %eax
jne 0x5a5d
movl 0xcd09(%rip), %ecx      # 0x12720
leal -0x1(%rcx), %edx
movl %edx, 0xcd00(%rip)      # 0x12720
cmpl $0x2, %ecx
jl 0x5a5d
movq 0xcd04(%rip), %rdi      # 0x12730
callq 0x5160
movq 0xccf0(%rip), %rax      # 0x12728
leaq 0x8(%rax), %rcx
movq %rcx, 0xcce5(%rip)      # 0x12728
movq 0x8(%rax), %rdi
callq 0x59d3
movq %rax, 0xccdd(%rip)      # 0x12730
movq %rax, %rdi
callq 0x50a0
jmp 0x5a0c
popq %rcx
retq
nop
// File: /workspace/github_cpp_makefile_star2_O2/arnoldrobbins[P]mcilroy-regex/sed1.cpp
// Function: addr(Text*, Text*)
int
addr(Text *script, Text *t)
{
	int n;
	switch(*t->w) {
	default:
		return 0;
	case '$':
		t->w++;
		n = DOLLAR;
		break;
	case '\\':
		t->w++;
		if(*t->w=='\n' ||*t->w=='\\')
			syntax("bad regexp delimiter");
	case '/':
		n = recomp(&rebuf, t, *t->w++) | REGADR;
		break;
	case '0': case '1': case '2': case '3': case '4':
	case '5': case '6': case '7': case '8': case '9':
		n = number(t);
		if(n == 0)
			syntax("address is zero");
	}
	putint(script, n);
	return 1;
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %r14
movq %rdi, %rbx
movq (%rsi), %rcx
movzbl (%rcx), %edx
leal -0x30(%rdx), %eax
cmpl $0xa, %eax
jae 0x5cc6
movq %r14, %rdi
callq 0x5f73
movl %eax, %esi
testl %eax, %eax
jne 0x5d2e
leaq 0x64cd(%rip), %rdi      # 0xc18a
callq 0x5d41
xorl %esi, %esi
jmp 0x5d2e
cmpl $0x5c, %edx
je 0x5ce9
cmpl $0x2f, %edx
je 0x5ce4
xorl %eax, %eax
cmpl $0x24, %edx
jne 0x5d39
incq %rcx
movq %rcx, (%r14)
movl $0x7fffffff, %esi       # imm = 0x7FFFFFFF
jmp 0x5d2e
movq %rcx, %rax
jmp 0x5d0d
leaq 0x1(%rcx), %rax
movq %rax, (%r14)
movzbl 0x1(%rcx), %ecx
cmpl $0x5c, %ecx
je 0x5cfe
cmpl $0xa, %ecx
jne 0x5d0d
leaq 0x6470(%rip), %rdi      # 0xc175
callq 0x5d41
movq (%r14), %rax
leaq 0x1(%rax), %rcx
movq %rcx, (%r14)
movzbl (%rax), %edx
leaq 0xca22(%rip), %rdi      # 0x12740
movq %r14, %rsi
callq 0x73e4
movl %eax, %esi
orl $0x80000000, %esi       # imm = 0x80000000
movq %rbx, %rdi
callq 0x5f36
pushq $0x1
popq %rax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_cpp_makefile_star2_O2/arnoldrobbins[P]mcilroy-regex/sed1.cpp
// Function: pack(int, int, int)
int
pack(int neg, int cmd, int length)
{
	int l = length & LMASK;
	if(length != l)
		syntax("<command-list> or <text> too long");
	return IMASK | neg | cmd << 2*BYTE | l;
}

// Assembly:
pushq %rbp
pushq %r14
pushq %rbx
movl %edx, %r14d
movl %esi, %ebx
movl %edi, %ebp
cmpl $0x10000, %edx          # imm = 0x10000
jb 0x5dd8
leaq 0x6371(%rip), %rdi      # 0xc144
callq 0x5d41
movzwl %r14w, %eax
shll $0x10, %ebx
orl %ebp, %ebx
orl %eax, %ebx
orl $0xc0000000, %ebx       # imm = 0xC0000000
movl %ebx, %eax
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/arnoldrobbins[P]mcilroy-regex/sed1.cpp
// Function: fixbrack(Text*)
void
fixbrack(Text *script)
{
	uchar *p;
	int *q;
	if(brack.w == 0)
		return;
	if(brack.w > brack.s)
		syntax("unmatched {");
	for(p=script->s; p<script->w; p=succi(p)) {
		q = instr(p);
		if(code(*q) == '{')
			*q += (uchar*)q - p;
	}
	free(brack.s);
}

// Assembly:
movq 0xc999(%rip), %rax      # 0x12790
testq %rax, %rax
je 0x5e66
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
cmpq 0xc996(%rip), %rax      # 0x127a0
jbe 0x5e18
leaq 0x6442(%rip), %rdi      # 0xc255
callq 0x5d41
movq (%rbx), %r14
movq 0x10(%rbx), %rbx
cmpq %r14, %rbx
jae 0x5e53
movq %rbx, %rdi
callq 0x5efa
movl (%rax), %ecx
movl %ecx, %edx
andl $0xff0000, %edx         # imm = 0xFF0000
cmpl $0x7b0000, %edx         # imm = 0x7B0000
jne 0x5e46
movl %eax, %edx
subl %ebx, %edx
addl %edx, %ecx
movl %ecx, (%rax)
movq %rbx, %rdi
callq 0x5f0f
movq %rax, %rbx
jmp 0x5e1f
movq 0xc946(%rip), %rdi      # 0x127a0
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x51d0
retq
// File: /workspace/github_cpp_makefile_star2_O2/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 %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rdi, %rbx
movq 0x10(%rdi), %r15
leaq 0x6357(%rip), %r14      # 0xc1d4
movq (%rbx), %r12
cmpq %r12, %r15
jae 0x5ee3
movq %r15, %rdi
callq 0x5efa
movzbl 0x2(%rax), %ecx
cmpl $0x74, %ecx
je 0x5e9b
cmpl $0x62, %ecx
jne 0x5ed6
movslq 0x4(%rax), %rcx
cmpq $-0x1, %rcx
je 0x5ebb
movq 0xc8c4(%rip), %rsi      # 0x12770
movq (%rsi,%rcx), %rdx
cmpq $-0x1, %rdx
je 0x5ec5
movl %edx, 0x4(%rax)
jmp 0x5ed6
subl 0x10(%rbx), %r12d
movl %r12d, 0x4(%rax)
jmp 0x5ed6
addq %rcx, %rsi
addq $0x8, %rsi
movq %r14, %rdi
xorl %eax, %eax
callq 0x569b
movq %r15, %rdi
callq 0x5f0f
movq %rax, %r15
jmp 0x5e7d
movq 0xc886(%rip), %rdi      # 0x12770
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
jmp 0x51d0
// File: /workspace/github_cpp_makefile_star2_O2/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
pushq %r14
pushq %rbx
movq %rdi, %rbx
movq (%rdi), %rax
xorl %ebp, %ebp
leaq 0x61e0(%rip), %r14      # 0xc166
movzbl (%rax), %ecx
addl $-0x30, %ecx
cmpl $0x9, %ecx
ja 0x5fbc
cmpl $0xccccccc, %ebp        # imm = 0xCCCCCCC
jb 0x5fa4
movq %r14, %rdi
callq 0x5d41
movq (%rbx), %rax
imull $0xa, %ebp, %ecx
leaq 0x1(%rax), %rdx
movq %rdx, (%rbx)
movzbl (%rax), %eax
leal (%rcx,%rax), %ebp
addl $-0x30, %ebp
movq %rdx, %rax
jmp 0x5f86
movl %ebp, %eax
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/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
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq %rdi, %r14
movq 0x10(%rsi), %rbp
testq %rbp, %rbp
je 0x5ffc
movq (%rbx), %r13
movq 0x8(%rbx), %rax
addq $-0x2, %rax
cmpq %rax, %r13
jb 0x600e
pushq $0x1
popq %rsi
movq %rbx, %rdi
callq 0x5880
movq (%rbx), %r13
movq 0x10(%rbx), %rbp
movq %rbp, %r15
cmpq %r13, %r15
jae 0x603f
leaq 0x8(%r15), %r12
movq %r12, %rdi
movq %r14, %rsi
callq 0x5240
testl %eax, %eax
je 0x608e
movq %r12, %rdi
callq 0x50d0
leaq (%r12,%rax), %r15
addq $0x8, %r15
andq $-0x8, %r15
jmp 0x6011
movq %r14, %rdi
callq 0x50d0
testq %rbp, %rbp
je 0x6058
movslq %eax, %rcx
addq 0x8(%rbx), %rcx
cmpq %rcx, %r13
jb 0x6065
addl $0x11, %eax
movq %rbx, %rdi
movl %eax, %esi
callq 0x5880
orq $-0x1, (%r15)
leaq 0x8(%r15), %r12
movq %r12, %rdi
movq %r14, %rsi
callq 0x5150
movq %r12, %rdi
callq 0x50d0
addq %r15, %rax
addq $0x10, %rax
andq $-0x8, %rax
movq %rax, (%rbx)
movq %r15, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/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
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movl %esi, %ebp
movq %rdi, %rbx
movq %rbx, %rdi
callq 0x5c74
testl %eax, %eax
jne 0x60b0
movq (%rbx), %r14
leaq 0x60d4(%rip), %r15      # 0xc19a
movq %r14, %r13
movzbl (%r13), %r12d
cmpl $0xa, %r12d
je 0x60f9
movl %r12d, %edi
callq 0x52c0
cmpl $0x20, %r12d
je 0x60e6
testl %eax, %eax
jne 0x60f1
movq %r15, %rdi
callq 0x5d7f
movq (%rbx), %r13
incq %r13
movq %r13, (%rbx)
jmp 0x60c9
cmpq %r13, %r14
je 0x612e
movb $0x0, (%r13)
leaq 0xc656(%rip), %rsi      # 0x12760
movq %r14, %rdi
callq 0x5fd2
movq %rax, %r14
cmpq $-0x1, (%rax)
je 0x6134
cmpl $-0x1, %ebp
je 0x613a
leaq 0x608f(%rip), %rdi      # 0xc1b6
callq 0x5d41
jmp 0x613a
pushq $-0x1
popq %r14
jmp 0x6149
movslq %ebp, %rax
movq %rax, (%r14)
movq (%rbx), %rax
movb $0xa, (%rax)
movl 0xc62a(%rip), %eax      # 0x12770
subl %eax, %r14d
movl %r14d, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/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 %rbx
movq %rsi, %rbx
movq %rdi, %r14
movq %rsi, %rdi
callq 0x5c74
testl %eax, %eax
jne 0x61c3
leaq 0x6028(%rip), %rdi      # 0xc1e6
callq 0x5d7f
movq %rbx, %rdi
callq 0x5c74
testl %eax, %eax
jne 0x61c3
movq (%rbx), %r15
xorl %ecx, %ecx
movq %r15, %rax
cmpb $0xa, (%rax)
je 0x61e7
incq %rax
movq %rax, (%rbx)
decq %rcx
jmp 0x61d7
testq %rcx, %rcx
jne 0x61fb
leaq 0x600d(%rip), %rdi      # 0xc200
callq 0x5d41
movq (%rbx), %rax
movb $0x0, (%rax)
leaq 0xc573(%rip), %rsi      # 0x12778
movq %r15, %rdi
callq 0x5fd2
subl 0xc575(%rip), %eax      # 0x12788
movq %r14, %rdi
movl %eax, %esi
callq 0x5f36
movq (%rbx), %rax
movb $0xa, (%rax)
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_cpp_makefile_star2_O2/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 0x61a0
movq 0xc54c(%rip), %r14      # 0x12788
movq (%rbx), %rax
movslq -0x4(%rax), %rax
cmpq $-0x1, (%r14,%rax)
jne 0x6265
addq %rax, %r14
leaq 0x8(%r14), %rdi
leaq 0x5fba(%rip), %rsi      # 0xc212
callq 0x51c0
movq %rax, (%r14)
testq %rax, %rax
je 0x626d
addq $0x8, %rsp
popq %rbx
popq %r14
retq
leaq 0x5fa0(%rip), %rdi      # 0xc214
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x5d41
// File: /workspace/github_cpp_makefile_star2_O2/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 %r15
pushq %r14
pushq %rbx
movq %rdi, %rbx
movq 0xc4d0(%rip), %rax      # 0x12790
testq %rax, %rax
je 0x62d9
addq $-0x4, %rax
movq %rax, 0xc4c0(%rip)      # 0x12790
cmpq 0xc4c9(%rip), %rax      # 0x127a0
jae 0x62ec
leaq 0x5f50(%rip), %rdi      # 0xc230
callq 0x5d41
movq 0xc4a4(%rip), %rax      # 0x12790
movslq (%rax), %r14
movq 0x10(%rbx), %r15
movl (%rbx), %ebx
subl %r15d, %ebx
subl %r14d, %ebx
cmpl $0xfff3, %ebx           # imm = 0xFFF3
jb 0x630f
leaq 0x5f32(%rip), %rdi      # 0xc23c
callq 0x5d41
movzwl 0x2(%r15,%r14), %eax
shll $0x10, %eax
orl %ebx, %eax
movl %eax, (%r15,%r14)
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_cpp_makefile_star2_O2/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 0x633b
leaq 0xc3a7(%rip), %rax      # 0x126dc
movl $0x1, (%rax)
movq (%rsi), %rax
incq %rax
cmpb $0xa, -0x1(%rax)
je 0x634c
movq %rax, (%rsi)
jmp 0x633e
retq
// File: /workspace/github_cpp_makefile_star2_O2/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
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %r14
movq %rdi, %rbx
movq (%rsi), %rax
leaq 0x1(%rax), %rcx
movq %rcx, (%rsi)
cmpb $0x5c, (%rax)
jne 0x6383
leaq 0x2(%rax), %rcx
movq %rcx, (%r14)
cmpb $0xa, 0x1(%rax)
je 0x638f
leaq 0x5ee7(%rip), %rdi      # 0xc271
callq 0x5d41
leaq 0xc352(%rip), %r15      # 0x126e8
pushq $0x6
popq %rbp
cmpl $0x0, (%r15)
je 0x63ab
movq %r14, %rdi
callq 0x5c74
testl %eax, %eax
jne 0x6399
cmpq $0x0, 0x10(%rbx)
je 0x63be
movq 0x8(%rbx), %rax
incq %rax
cmpq %rax, (%rbx)
jb 0x63c8
movq %rbx, %rdi
movl %ebp, %esi
callq 0x5880
movq (%r14), %rax
movzbl (%rax), %ecx
cmpl $0x5c, %ecx
je 0x63de
cmpl $0xa, %ecx
je 0x640b
testl %ecx, %ecx
jne 0x63e1
jmp 0x63f8
incq %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 0x6399
leaq 0x5e93(%rip), %rdi      # 0xc292
xorl %eax, %eax
callq 0x569b
movq (%r14), %rax
movb (%rax), %cl
movq (%rbx), %rax
leaq 0x1(%rax), %rdx
movq %rdx, (%rbx)
movb %cl, (%rax)
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)
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/arnoldrobbins[P]mcilroy-regex/sed1.cpp
// Function: yc(Text*, Text*)
void
yc(Text *script, Text *t)
{
	int i;
	int delim = *t->w++;
	uchar *s = script->w;
	uchar *p, *q;
	uchar c, d;
	if(delim == '\n' || delim=='\\')
		syntax("missing delimiter");
	assure(script, 256);
	for(i=0; i<256; i++) 
		s[i] = 0;
	for(q=t->w; *q!=delim; q++)
		if(*q == '\n')
			syntax("missing delimiter");
		else if(*q=='\\' && q[1]==delim)
			q++;
	for(p=t->w, q++; *p != delim; p++, q++) {
		if(*p=='\\' && p[1]==delim)
			p++;
		if(*q == '\n')
			syntax("missing delimiter");
		if(*q == delim)
			syntax("string lengths differ");
		if(*q=='\\' && q[1]==delim)
			q++;
		if(s[*p] && s[*p]!=*q)
			syntax("ambiguous map");
		if(s[*p])
			synwarn("redundant map");
		s[*p] = *q;
	}
	if(*q++ != delim)
		syntax("string lengths differ");
	for(i=0; i<256; i++)
		if(s[i] == 0)
			s[i] = i;
	t->w = q;
	script->w += 256;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %rsi, %r13
movq %rdi, %r15
movq (%rsi), %rax
leaq 0x1(%rax), %rcx
movq %rcx, (%rsi)
movzbl (%rax), %r14d
movq (%rdi), %rbx
cmpl $0x5c, %r14d
je 0x646e
cmpl $0xa, %r14d
jne 0x647a
leaq 0x5e37(%rip), %rdi      # 0xc2ac
callq 0x5d41
cmpq $0x0, 0x10(%r15)
je 0x6491
movq $-0x101, %rax           # imm = 0xFEFF
addq 0x8(%r15), %rax
cmpq %rax, (%r15)
jb 0x649e
movq %r15, %rdi
movl $0x100, %esi            # imm = 0x100
callq 0x5880
xorl %eax, %eax
cmpq $0x100, %rax            # imm = 0x100
je 0x64b1
movb $0x0, (%rbx,%rax)
incq %rax
jmp 0x64a0
movq %r15, 0x10(%rsp)
movq (%r13), %r12
leaq 0x5deb(%rip), %r15      # 0xc2ac
movzbl (%r12), %eax
cmpb %r14b, %al
je 0x64ee
cmpl $0x5c, %eax
je 0x64df
cmpl $0xa, %eax
jne 0x64e9
movq %r15, %rdi
callq 0x5d41
jmp 0x64e9
cmpb %r14b, 0x1(%r12)
jne 0x64e9
incq %r12
incq %r12
jmp 0x64c1
movq %r13, 0x8(%rsp)
movq (%r13), %r15
leaq 0x5de4(%rip), %r13      # 0xc2e2
leaq 0x1(%r12), %rbp
movb (%r15), %al
cmpb %r14b, %al
je 0x659c
cmpb $0x5c, %al
jne 0x651c
cmpb %r14b, 0x1(%r15)
jne 0x651c
incq %r15
movb (%rbp), %al
cmpb $0xa, %al
jne 0x6532
leaq 0x5d82(%rip), %rdi      # 0xc2ac
callq 0x5d41
movb (%rbp), %al
cmpb %r14b, %al
jne 0x6546
leaq 0x5d80(%rip), %rdi      # 0xc2be
callq 0x5d41
movb (%rbp), %al
cmpb $0x5c, %al
jne 0x6551
cmpb %r14b, 0x2(%r12)
je 0x6556
movq %rbp, %r12
jmp 0x655a
addq $0x2, %r12
movzbl (%r15), %eax
movb (%rbx,%rax), %cl
testb %cl, %cl
je 0x658d
cmpb (%r12), %cl
je 0x6581
leaq 0x5d62(%rip), %rdi      # 0xc2d4
callq 0x5d41
movzbl (%r15), %eax
cmpb $0x0, (%rbx,%rax)
je 0x658d
movq %r13, %rdi
callq 0x5d7f
movzbl (%r15), %eax
movb (%r12), %cl
movb %cl, (%rbx,%rax)
incq %r15
jmp 0x64fe
cmpb %r14b, (%rbp)
je 0x65ae
leaq 0x5d15(%rip), %rdi      # 0xc2be
callq 0x5d41
xorl %eax, %eax
movq 0x10(%rsp), %rcx
movq 0x8(%rsp), %rdx
cmpq $0x100, %rax            # imm = 0x100
je 0x65d0
cmpb $0x0, (%rbx,%rax)
jne 0x65cb
movb %al, (%rbx,%rax)
incq %rax
jmp 0x65ba
addq $0x2, %r12
movq %r12, (%rdx)
addq $0x100, (%rcx)          # imm = 0x100
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/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 0xb755(%rip), %rax      # 0x11fb0
movq (%rax), %rcx
pushq $0x1
popq %rsi
movq %rbx, %rdx
callq 0x5300
cmpq %rbx, %rax
je 0x687c
movq 0xba2b(%rip), %rdi      # 0x122a0
xorl %eax, %eax
callq 0x569b
pushq $0xa
popq %rdi
popq %rbx
jmp 0x682c
// File: /workspace/github_cpp_makefile_star2_O2/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 %rdi, %r14
movq 0x10(%rdi), %r15
pushq $0x64
popq %r12
leaq 0xa8bb(%rip), %r13      # 0x11160
cmpq (%r14), %r15
jae 0x68fb
movq %r15, %rdi
movq %rbx, %rsi
callq 0x692c
movl %eax, %ebp
movq %r15, %rdi
callq 0x5efa
movl (%rax), %eax
testl %ebp, %ebp
je 0x68f3
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 0x68a5
jmp 0x6907
movzwl %ax, %eax
addq %rax, %r15
jmp 0x68a5
leaq 0xbdda(%rip), %rax      # 0x126dc
cmpl $0x0, (%rax)
je 0x6916
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 0x6848
// File: /workspace/github_cpp_makefile_star2_O2/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 0x5efa
movq %rax, %r14
subq %r12, %rax
sarq $0x2, %rax
cmpq $0x3, %rax
ja 0x6a28
movl (%r14), %ebx
shrl $0x18, %ebx
andl $0x1, %ebx
leaq 0x59f2(%rip), %rcx      # 0xc358
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
xorl $0x1, %ebx
jmp 0x6a5a
leaq 0x5a02(%rip), %rdi      # 0xc380
pushq $0x1
popq %rsi
xorl %eax, %eax
callq 0x569b
movl -0x4(%r14), %ebp
movl %ebp, %r13d
notl %r13d
shrl $0x1f, %r13d
movl %ebp, %eax
andl $0x7fffffff, %eax       # imm = 0x7FFFFFFF
leaq 0xbd34(%rip), %rcx      # 0x126d8
cmpl (%rcx), %eax
jge 0x6a55
movl %r13d, %eax
movl (%r12,%rax,4), %edi
movq %r15, %rsi
callq 0x6a6b
cmpl $-0x1, %eax
je 0x6a3d
cmpl $0x1, %eax
leaq 0xbd0e(%rip), %rcx      # 0x126d8
je 0x69e5
testl %eax, %eax
jne 0x6a55
callq 0x59fb
leaq 0xbcf8(%rip), %rcx      # 0x126d8
testl %r13d, %eax
je 0x6a55
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 0x59fb
testl %eax, %eax
sete %cl
andb %bpl, %cl
shll %cl, %ebx
jmp 0x6a5a
movl (%r12), %edi
movq %r15, %rsi
callq 0x6a6b
xorl %ecx, %ecx
cmpl $0x1, %eax
sete %cl
xorl %ecx, %ebx
jmp 0x6a5a
leaq 0x5951(%rip), %rdi      # 0xc380
xorl %ebx, %ebx
pushq $0x2
popq %rsi
xorl %eax, %eax
callq 0x569b
jmp 0x6a5a
testl %ebp, %ebp
leaq 0xbc92(%rip), %rcx      # 0x126d8
js 0x6a55
movl $0x80000000, %eax       # imm = 0x80000000
orl (%rcx), %eax
movl %eax, -0x4(%r14)
jmp 0x6a5a
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_O2/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 0x6a80
leaq 0xbc62(%rip), %rax      # 0x126d8
movl (%rax), %ecx
cmpl %edi, %ecx
jne 0x6aa7
pushq $0x1
popq %rax
retq
pushq %rbx
movq %rsi, %rbx
callq 0x5fc3
movq 0x10(%rbx), %rsi
movq %rax, %rdi
xorl %edx, %edx
xorl %ecx, %ecx
xorl %r8d, %r8d
callq 0x8cde
movl %eax, %ecx
xorl %eax, %eax
testl %ecx, %ecx
sete %al
popq %rbx
retq
cmpl $0x7fffffff, %edi       # imm = 0x7FFFFFFF
je 0x59fb
xorl %eax, %eax
cmpl %edi, %ecx
setg %al
negl %eax
retq
// File: /workspace/github_cpp_makefile_star2_O2/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, %r15
movq (%rdi), %rsi
movq 0x10(%rdi), %rax
subq %rax, %rsi
cmpq $0x0, 0x10(%rbx)
je 0x6b1e
movq (%rbx), %rdi
movq 0x8(%rbx), %rcx
movslq %esi, %r14
subq %r14, %rcx
cmpq %rcx, %rdi
jae 0x6b21
jmp 0x6b32
movslq %esi, %r14
incl %esi
movq %rbx, %rdi
callq 0x5880
movq (%rbx), %rdi
movq 0x10(%r15), %rax
movq %rax, %rsi
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_O2/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
pushq $0xa
popq %rsi
movq %r15, %rdi
callq 0x50c0
testq %rax, %rax
je 0x6bcc
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 0x6bd6
movq %rbx, %rdi
callq 0x6abd
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
// File: /workspace/github_cpp_makefile_star2_O2/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 0xbade(%rip), %rax      # 0x126d8
movl (%rax), %esi
leaq 0x5790(%rip), %rdi      # 0xc393
xorl %eax, %eax
callq 0x5050
testl %eax, %eax
jg 0x6c1c
movq 0xb68b(%rip), %rdi      # 0x122a0
xorl %eax, %eax
callq 0x569b
movq %rbx, %rdi
callq 0x5efa
movzwl (%rax), %eax
addq %rbx, %rax
popq %rbx
retq
// File: /workspace/github_cpp_makefile_star2_O2/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, 0xbb82(%rip)      # 0x127c0
jne 0x6c4c
leaq 0xbb69(%rip), %rdi      # 0x127b0
callq 0x6abd
movq (%r14), %rax
cmpq 0x10(%r14), %rax
jbe 0x6c5f
leaq 0x1(%rax), %rcx
movq %rcx, (%r14)
movb $0xa, (%rax)
leaq 0xbb4a(%rip), %rdi      # 0x127b0
movq %r14, %rsi
callq 0x6aee
movq %rbx, %rdi
callq 0x5efa
movzwl (%rax), %eax
addq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_cpp_makefile_star2_O2/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, 0xbb06(%rip)      # 0x127c0
je 0x6cd3
movq 0xbaed(%rip), %rax      # 0x127b0
movq 0xbaee(%rip), %rcx      # 0x127b8
addq $-0x2, %rcx
cmpq %rcx, %rax
jb 0x6ce9
leaq 0xbad6(%rip), %rdi      # 0x127b0
pushq $0x1
popq %rsi
callq 0x5880
movq 0xbac7(%rip), %rax      # 0x127b0
leaq 0x1(%rax), %rcx
movq %rcx, 0xbabc(%rip)      # 0x127b0
leaq 0xbab5(%rip), %rsi      # 0x127b0
movb $0xa, (%rax)
movq %r14, %rdi
callq 0x6aee
movq %rbx, %rdi
callq 0x5efa
movzwl (%rax), %eax
addq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_cpp_makefile_star2_O2/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 0xba82(%rip), %r15      # 0x127b0
movq %r15, %rdi
callq 0x6abd
movq %rbx, %rdi
movq %r15, %rsi
callq 0x6aee
movq %r14, %rdi
callq 0x5efa
movzwl (%rax), %eax
addq %r14, %rax
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_cpp_makefile_star2_O2/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 0x5efa
leaq 0x4(%rax), %rsi
leaq 0x5625(%rip), %rdi      # 0xc3a5
xorl %eax, %eax
callq 0x5050
testl %eax, %eax
jg 0x6d99
movq 0xb50e(%rip), %rdi      # 0x122a0
xorl %eax, %eax
callq 0x569b
movq %rbx, %rdi
callq 0x5efa
movzwl (%rax), %eax
addq %rbx, %rax
popq %rbx
retq
// File: /workspace/github_cpp_makefile_star2_O2/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 0x6dd9
movq (%r14), %rax
movq 0x8(%r14), %rcx
addq $-0x2, %rcx
cmpq %rcx, %rax
jb 0x6de7
pushq $0x1
popq %rsi
movq %r14, %rdi
callq 0x5880
movq (%r14), %rax
leaq 0x1(%rax), %rcx
movq %rcx, (%r14)
movb $0xa, (%rax)
movq %r14, %rdi
callq 0x5794
testl %eax, %eax
je 0x6e0d
movq %rbx, %rdi
callq 0x5efa
movzwl (%rax), %eax
addq %rbx, %rax
jmp 0x6e25
movq (%r14), %rax
leaq -0x1(%rax), %rcx
movq %rcx, (%r14)
movb $0x0, -0x1(%rax)
movq %r14, %rdi
callq 0x6abd
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_cpp_makefile_star2_O2/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 0xb89e(%rip), %rax      # 0x126dc
cmpl $0x0, (%rax)
jne 0x6e4b
movq %r14, %rdi
callq 0x6848
movq %r14, %rdi
callq 0x6abd
movq %r14, %rdi
callq 0x5794
testl %eax, %eax
je 0x6e6f
movq %rbx, %rdi
callq 0x5efa
movzwl (%rax), %eax
addq %rbx, %rax
jmp 0x6e71
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_cpp_makefile_star2_O2/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
pushq $0xa
popq %rsi
movq %r14, %rdi
callq 0x50c0
testq %rax, %rax
jne 0x6e9b
movq (%r15), %rax
subl %r14d, %eax
movslq %eax, %r15
movq 0xb108(%rip), %rax      # 0x11fb0
movq (%rax), %rcx
pushq $0x1
popq %rsi
movq %r14, %rdi
movq %r15, %rdx
callq 0x5300
cmpq %r15, %rax
je 0x6ecc
movq 0xb3db(%rip), %rdi      # 0x122a0
xorl %eax, %eax
callq 0x569b
pushq $0xa
popq %rdi
callq 0x682c
movq %rbx, %rdi
callq 0x5efa
movzwl (%rax), %eax
addq %rbx, %rax
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_cpp_makefile_star2_O2/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 0xb7c5(%rip), %rax      # 0x126e4
movl (%rax), %ecx
andl $0x0, (%rax)
testl %ecx, %ecx
je 0x6f3d
movq 0x10(%rdi), %r14
movq %rbx, %rdi
callq 0x5efa
movslq 0x4(%rax), %rax
addq %r14, %rax
jmp 0x6f4b
movq %rbx, %rdi
callq 0x5efa
movzwl (%rax), %eax
addq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_cpp_makefile_star2_O2/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 0xb80d(%rip), %rax      # 0x12778
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 0x6f95
movq 0x8(%r14), %rcx
addq $-0x2, %rcx
cmpq %rcx, %rax
jb 0x6fa3
pushq $0x1
popq %rsi
movq %r14, %rdi
callq 0x5880
movq (%r14), %rax
movb $0xa, (%rax)
movq 0x10(%r14), %rdi
incl %r13d
movslq %r13d, %r13
pushq $0x1
popq %rsi
movq %r13, %rdx
movq %r12, %rcx
callq 0x5300
cmpq %r13, %rax
jne 0x6fd0
movq %r12, %rdi
callq 0x51b0
cmpl $-0x1, %eax
jne 0x6fe8
addq %rbp, %r15
addq $0x4, %r15
leaq 0x53b9(%rip), %rdi      # 0xc397
movq %r15, %rsi
xorl %eax, %eax
callq 0x569b
movq (%r14), %rax
movb $0x0, (%rax)
movq %rbx, %rdi
callq 0x5efa
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_O2/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
movq 0xb77d(%rip), %rax      # 0x127c0
testq %rax, %rax
jne 0x705b
leaq 0xb761(%rip), %rdi      # 0x127b0
callq 0x6abd
movq 0xb765(%rip), %rax      # 0x127c0
movq 0x10(%r14), %rcx
movq %rax, 0x10(%r14)
movq %rcx, 0xb756(%rip)      # 0x127c0
movaps 0xb73f(%rip), %xmm0     # 0x127b0
movups (%r14), %xmm1
movups %xmm0, (%r14)
movaps %xmm1, 0xb730(%rip)     # 0x127b0
movq %rbx, %rdi
callq 0x5efa
movzwl (%rax), %eax
addq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_cpp_makefile_star2_O2/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 0x5efa
cmpq %r14, %r15
jae 0x70c2
movzbl (%r15), %ecx
movb 0x4(%rax,%rcx), %cl
movb %cl, (%r15)
incq %r15
jmp 0x70ad
movq %rbx, %rdi
callq 0x5efa
movzwl (%rax), %eax
addq %rbx, %rax
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_cpp_makefile_star2_O2/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 0x5efa
movl 0x4(%rax), %edi
movl 0x8(%rax), %r12d
leaq 0xc(%rax), %r15
movl %r12d, %ebp
andl $0x3fffffff, %ebp       # imm = 0x3FFFFFFF
callq 0x5fc3
movq %rax, %rdi
movq %r14, %rsi
movq %r15, %rdx
movl %ebp, %ecx
callq 0x759e
leaq 0xb5c8(%rip), %rcx      # 0x126e4
movl %eax, (%rcx)
testl %eax, %eax
je 0x715d
testl %r12d, %r12d
jns 0x7132
movq %rbx, %rsi
movq %r14, %rdx
callq 0x6ee8
movq %rbx, %rdi
callq 0x5efa
movzwl (%rax), %eax
addq %rbx, %rax
btl $0x1e, %r12d
jae 0x716b
movl -0x4(%rax), %ecx
movq %rbx, %rsi
movq %r14, %rdx
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
jmp 0x6f53
movq %rbx, %rdi
callq 0x5efa
movzwl (%rax), %eax
addq %rbx, %rax
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/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 %rdx, %r14
movq %rsi, (%rsp)
movq 0x10(%rdx), %rbx
leaq 0xb11f(%rip), %r12      # 0x122b0
xorl %r15d, %r15d
cmpq (%r14), %rbx
jae 0x7220
cmpl $0x3c, %r15d
jl 0x71b6
pushq $0x5c
popq %rdi
callq 0x682c
pushq $0xa
popq %rdi
callq 0x682c
xorl %r15d, %r15d
movzbl (%rbx), %r13d
xorl %ebp, %ebp
cmpq $0x8, %rbp
je 0x71df
movsbl (%r12,%rbp,2), %eax
incq %rbp
cmpl %eax, %r13d
jne 0x71bc
pushq $0x5c
popq %rdi
callq 0x682c
movsbl -0x1(%r12,%rbp,2), %edi
jmp 0x71ee
movl %r13d, %edi
callq 0x52c0
testl %eax, %eax
je 0x71fb
movl %r13d, %edi
callq 0x682c
incq %rbx
incl %r15d
jmp 0x7194
leaq 0x51a6(%rip), %rdi      # 0xc3a8
movl %r13d, %esi
xorl %eax, %eax
callq 0x5050
testl %eax, %eax
jg 0x71f3
movq 0xb089(%rip), %rdi      # 0x122a0
xorl %eax, %eax
callq 0x569b
jmp 0x71f3
pushq $0x24
popq %rdi
callq 0x682c
pushq $0xa
popq %rdi
callq 0x682c
movq (%rsp), %rbx
movq %rbx, %rdi
callq 0x5efa
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_O2/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, 0xb57b(%rip)      # 0x127d8
je 0x7276
movq 0xb562(%rip), %rax      # 0x127c8
movq 0xb563(%rip), %rcx      # 0x127d0
addq $-0x9, %rcx
cmpq %rcx, %rax
jb 0x728c
leaq 0xb54b(%rip), %rdi      # 0x127c8
pushq $0x8
popq %rsi
callq 0x5880
movq 0xb53c(%rip), %rax      # 0x127c8
movq %rbx, (%rax)
addq $0x8, 0xb531(%rip)      # 0x127c8
movq %rbx, %rdi
callq 0x5efa
movzwl (%rax), %eax
addq %rbx, %rax
popq %rbx
retq
// File: /workspace/github_cpp_makefile_star2_O2/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 0xb4e3(%rip), %r13      # 0x127d8
testq %r13, %r13
je 0x73d5
leaq 0x4fcd(%rip), %rbx      # 0xc2d2
leaq 0x5099(%rip), %r14      # 0xc3a5
leaq 0x506d(%rip), %r15      # 0xc380
pushq $0x5
popq %rbp
cmpq 0xb4ab(%rip), %r13      # 0x127c8
jae 0x73bb
movq (%r13), %rdi
callq 0x5efa
movzbl 0x2(%rax), %ecx
cmpl $0x72, %ecx
je 0x735f
cmpl $0x61, %ecx
jne 0x739c
addq $0x4, %rax
movq %r14, %rdi
movq %rax, %rsi
xorl %eax, %eax
callq 0x5050
testl %eax, %eax
jg 0x73b2
movq 0xaf4a(%rip), %rdi      # 0x122a0
xorl %eax, %eax
callq 0x569b
jmp 0x73b2
leaq 0xb412(%rip), %rcx      # 0x12778
movq 0x10(%rcx), %rcx
movslq 0x4(%rax), %rax
leaq (%rcx,%rax), %rdi
addq $0x8, %rdi
movq %rbx, %rsi
callq 0x51c0
testq %rax, %rax
je 0x73b2
movq %rax, %r12
movq %r12, %rdi
callq 0x50a0
cmpl $-0x1, %eax
je 0x73aa
movl %eax, %edi
callq 0x682c
jmp 0x7386
movq %r15, %rdi
movl %ebp, %esi
xorl %eax, %eax
callq 0x569b
jmp 0x73b2
movq %r12, %rdi
callq 0x5160
addq $0x8, %r13
jmp 0x7316
leaq 0xb406(%rip), %rdi      # 0x127c8
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x6abd
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/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, %rbx
cmpq $0x0, 0xb0ab(%rip)      # 0x12810
je 0x7782
movq 0xb092(%rip), %rdi      # 0x12800
movq 0xb093(%rip), %rax      # 0x12808
movslq %esi, %r14
subq %r14, %rax
cmpq %rax, %rdi
jae 0x7785
jmp 0x779a
movslq %esi, %r14
incl %esi
leaq 0xb072(%rip), %rdi      # 0x12800
callq 0x5880
movq 0xb066(%rip), %rdi      # 0x12800
movq %rbx, %rsi
movq %r14, %rdx
callq 0x5290
movq 0xb054(%rip), %rax      # 0x12800
leaq (%rax,%r14), %rcx
movq %rcx, 0xb049(%rip)      # 0x12800
movb $0x0, (%rax,%r14)
addq $0x8, %rsp
popq %rbx
popq %r14
retq