LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_cpp_makefile_star2_O3/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 %rbp
pushq %r15
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 0x5f3d
movq %r14, %rdi
callq 0x62d5
movl %eax, %ebp
testl %eax, %eax
jne 0x5fcf
movq 0xd84d(%rip), %r14      # 0x13758
movq %r14, %rdi
movl $0xa, %esi
callq 0x50c0
subq %r14, %rax
leaq 0x742c(%rip), %rdi      # 0xd34e
leaq 0x7261(%rip), %rsi      # 0xd18a
xorl %ebp, %ebp
movq %rax, %rdx
movq %r14, %rcx
xorl %eax, %eax
callq 0x589a
jmp 0x5fcf
cmpl $0x5c, %edx
je 0x5f64
cmpl $0x2f, %edx
je 0x5f5f
xorl %eax, %eax
cmpl $0x24, %edx
jne 0x5fde
incq %rcx
movq %rcx, (%r14)
movl $0x7fffffff, %ebp       # imm = 0x7FFFFFFF
jmp 0x5fcf
movq %rcx, %rax
jmp 0x5fae
leaq 0x1(%rcx), %rax
movq %rax, (%r14)
movzbl 0x1(%rcx), %ecx
cmpl $0x5c, %ecx
je 0x5f79
cmpl $0xa, %ecx
jne 0x5fae
movq 0xd7d8(%rip), %r15      # 0x13758
movq %r15, %rdi
movl $0xa, %esi
callq 0x50c0
subq %r15, %rax
leaq 0x73b7(%rip), %rdi      # 0xd34e
leaq 0x71d7(%rip), %rsi      # 0xd175
movq %rax, %rdx
movq %r15, %rcx
xorl %eax, %eax
callq 0x589a
movq (%r14), %rax
leaq 0x1(%rax), %rcx
movq %rcx, (%r14)
movzbl (%rax), %edx
leaq 0xd781(%rip), %rdi      # 0x13740
movq %r14, %rsi
callq 0x7d18
movl %eax, %ebp
orl $0x80000000, %ebp       # imm = 0x80000000
movq %rbx, %rdi
movl %ebp, %esi
callq 0x6296
movl $0x1, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O3/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 %r15
pushq %r14
pushq %rbx
pushq %rax
movl %edx, %r14d
movl %esi, %ebx
movl %edi, %ebp
cmpl $0x10000, %edx          # imm = 0x10000
jb 0x60ad
movq 0xd6d6(%rip), %r15      # 0x13758
movq %r15, %rdi
movl $0xa, %esi
callq 0x50c0
subq %r15, %rax
leaq 0x72b5(%rip), %rdi      # 0xd34e
leaq 0x70a4(%rip), %rsi      # 0xd144
movq %rax, %rdx
movq %r15, %rcx
xorl %eax, %eax
callq 0x589a
movzwl %r14w, %eax
shll $0x10, %ebx
orl %ebp, %ebx
orl %eax, %ebx
orl $0xc0000000, %ebx       # imm = 0xC0000000
movl %ebx, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O3/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 0xd6be(%rip), %rax      # 0x13790
testq %rax, %rax
je 0x6197
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
cmpq 0xd6b7(%rip), %rax      # 0x137a0
jbe 0x611d
movq 0xd666(%rip), %r14      # 0x13758
movq %r14, %rdi
movl $0xa, %esi
callq 0x50c0
subq %r14, %rax
leaq 0x7245(%rip), %rdi      # 0xd34e
leaq 0x7145(%rip), %rsi      # 0xd255
movq %rax, %rdx
movq %r14, %rcx
xorl %eax, %eax
callq 0x589a
movq (%rbx), %rax
movq 0x10(%rbx), %rcx
cmpq %rax, %rcx
jae 0x6184
movq $-0x4, %rdx
movl 0x4(%rcx,%rdx), %esi
movl %esi, %edi
shrl $0x1e, %edi
addq $0x4, %rdx
cmpl $0x3, %edi
jb 0x6130
movl %esi, %edi
andl $0xff0000, %edi         # imm = 0xFF0000
cmpl $0x7b0000, %edi         # imm = 0x7B0000
jne 0x6157
addl %edx, %esi
movl %esi, (%rcx,%rdx)
movq %rcx, %rdx
movl (%rdx), %esi
movl %esi, %edi
shrl $0x1e, %edi
addq $0x4, %rdx
cmpl $0x3, %edi
jb 0x615a
movl %esi, %edi
andl $0xff0000, %edi         # imm = 0xFF0000
movzwl %si, %esi
addq %rsi, %rcx
cmpl $0x7b0000, %edi         # imm = 0x7B0000
cmoveq %rdx, %rcx
jmp 0x6124
movq 0xd615(%rip), %rdi      # 0x137a0
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x51d0
retq
// File: /workspace/github_cpp_makefile_star2_O3/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 %rbx
movq (%rdi), %rax
movq 0x10(%rdi), %r15
cmpq %rax, %r15
jae 0x6241
movq %rdi, %rbx
leaq 0x701d(%rip), %r14      # 0xd1d4
movq %r15, %rcx
movl (%rcx), %edx
addq $0x4, %rcx
cmpl $0xc0000000, %edx       # imm = 0xC0000000
jb 0x61ba
shrl $0x10, %edx
cmpb $0x74, %dl
je 0x61d8
movzbl %dl, %edx
cmpl $0x62, %edx
jne 0x620a
movslq (%rcx), %rdx
cmpq $-0x1, %rdx
je 0x6205
movq 0xd588(%rip), %rsi      # 0x13770
movq (%rsi,%rdx), %rax
cmpq $-0x1, %rax
jne 0x6208
addq %rdx, %rsi
addq $0x8, %rsi
movq %r14, %rdi
xorl %eax, %eax
callq 0x589a
jmp 0x620a
subl 0x10(%rbx), %eax
movl %eax, (%rcx)
movq %r15, %rax
movl (%rax), %ecx
movl %ecx, %edx
shrl $0x1e, %edx
addq $0x4, %rax
cmpl $0x3, %edx
jb 0x620d
movl %ecx, %edx
andl $0xff0000, %edx         # imm = 0xFF0000
movzwl %cx, %ecx
addq %rcx, %r15
cmpl $0x7b0000, %edx         # imm = 0x7B0000
cmoveq %rax, %r15
movq (%rbx), %rax
cmpq %rax, %r15
jb 0x61b7
movq 0xd528(%rip), %rdi      # 0x13770
popq %rbx
popq %r14
popq %r15
jmp 0x51d0
// File: /workspace/github_cpp_makefile_star2_O3/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:
movq %rdi, %rax
movq %rdi, %rcx
movl (%rcx), %edx
movl %edx, %esi
shrl $0x1e, %esi
addq $0x4, %rcx
cmpl $0x3, %esi
jb 0x626d
movl %edx, %esi
andl $0xff0000, %esi         # imm = 0xFF0000
movzwl %dx, %edx
addq %rdx, %rax
cmpl $0x7b0000, %esi         # imm = 0x7B0000
cmoveq %rcx, %rax
retq
// File: /workspace/github_cpp_makefile_star2_O3/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 %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
movq (%rdi), %rax
movzbl (%rax), %ecx
addl $-0x30, %ecx
xorl %r12d, %r12d
cmpl $0x9, %ecx
ja 0x635e
movq %rdi, %rbx
leaq 0x7055(%rip), %r14      # 0xd34e
leaq 0x6e66(%rip), %r15      # 0xd166
xorl %r12d, %r12d
cmpl $0xccccccc, %r12d       # imm = 0xCCCCCCC
jb 0x6339
movq 0xd445(%rip), %r13      # 0x13758
movq %r13, %rdi
movl $0xa, %esi
callq 0x50c0
subq %r13, %rax
movq %r14, %rdi
movq %r15, %rsi
movq %rax, %rdx
movq %r13, %rcx
xorl %eax, %eax
callq 0x589a
movq (%rbx), %rax
leal (%r12,%r12,4), %ecx
leaq 0x1(%rax), %rdx
movq %rdx, (%rbx)
movzbl (%rax), %esi
leal (%rsi,%rcx,2), %r12d
addl $-0x30, %r12d
movzbl 0x1(%rax), %ecx
addl $-0x30, %ecx
movq %rdx, %rax
cmpl $0xa, %ecx
jb 0x6303
movl %r12d, %eax
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
// File: /workspace/github_cpp_makefile_star2_O3/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 0x63a4
movq (%rbx), %r13
movq 0x8(%rbx), %rax
addq $-0x2, %rax
cmpq %rax, %r13
jb 0x63b8
movq %rbx, %rdi
movl $0x1, %esi
callq 0x5a81
movq (%rbx), %r13
movq 0x10(%rbx), %rbp
movq %rbp, %r15
cmpq %r13, %rbp
jae 0x63ef
movq %rbp, %r15
leaq 0x8(%r15), %r12
movq %r12, %rdi
movq %r14, %rsi
callq 0x5240
testl %eax, %eax
je 0x6441
movq %r12, %rdi
callq 0x50d0
leaq (%r12,%rax), %r15
addq $0x8, %r15
andq $-0x8, %r15
cmpq %r13, %r15
jb 0x63c3
movq %r14, %rdi
callq 0x50d0
testq %rbp, %rbp
je 0x6408
movslq %eax, %rcx
addq 0x8(%rbx), %rcx
cmpq %rcx, %r13
jb 0x6415
addl $0x11, %eax
movq %rbx, %rdi
movl %eax, %esi
callq 0x5a81
movq $-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_O3/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, 0x4(%rsp)
movq %rdi, %rbx
movq (%rdi), %rbp
movzbl (%rbp), %eax
cmpl $0x9, %eax
je 0x6476
cmpl $0x20, %eax
jne 0x647e
incq %rbp
movq %rbp, (%rbx)
jmp 0x6468
cmpl $0xa, %eax
jne 0x6488
movq %rbp, %rcx
jmp 0x64ee
leaq 0x6ebf(%rip), %r15      # 0xd34e
leaq 0x6d04(%rip), %r12      # 0xd19a
movq %rbp, %r14
movzbl %al, %r13d
movl %r13d, %edi
callq 0x52c0
cmpb $0x20, %r13b
je 0x64af
testl %eax, %eax
jne 0x64dc
movq 0xd2a2(%rip), %r13      # 0x13758
movq %r13, %rdi
movl $0xa, %esi
callq 0x50c0
subq %r13, %rax
movq %r15, %rdi
movq %r12, %rsi
movq %rax, %rdx
movq %r13, %rcx
xorl %eax, %eax
callq 0x5320
movq (%rbx), %r14
leaq 0x1(%r14), %rcx
movq %rcx, (%rbx)
movb 0x1(%r14), %al
movq %rcx, %r14
cmpb $0xa, %al
jne 0x6499
cmpq %rcx, %rbp
je 0x6549
movb $0x0, (%rcx)
leaq 0xd263(%rip), %rsi      # 0x13760
movq %rbp, %rdi
callq 0x637a
movq %rax, %r14
cmpq $-0x1, (%rax)
je 0x6551
cmpl $-0x1, 0x4(%rsp)
je 0x6559
movq 0xd23c(%rip), %r15      # 0x13758
movq %r15, %rdi
movl $0xa, %esi
callq 0x50c0
subq %r15, %rax
leaq 0x6e1b(%rip), %rdi      # 0xd34e
leaq 0x6c7c(%rip), %rsi      # 0xd1b6
movq %rax, %rdx
movq %r15, %rcx
xorl %eax, %eax
callq 0x589a
jmp 0x6559
movl $0xffffffff, %r14d      # imm = 0xFFFFFFFF
jmp 0x6568
movslq 0x4(%rsp), %rax
movq %rax, (%r14)
movq (%rbx), %rax
movb $0xa, (%rax)
movl 0xd20b(%rip), %eax      # 0x13770
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_O3/arnoldrobbins[P]mcilroy-regex/sed1.cpp
// Function: rc(Text*, Text*)
void
rc(Text *script, Text *t)
{
	uchar *u;
	if(!blank(t))
		synwarn("no space before file name");
	while(blank(t)) ;
	for(u=t->w; *t->w!='\n'; t->w++) ;
	if(u == t->w)
		syntax("missing file name");
	*t->w = 0;
	putint(script, (uchar*)lablook(u, &files) - files.s);
	*t->w = '\n';
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq %rdi, %r14
movq (%rsi), %r15
movzbl (%r15), %eax
cmpl $0x20, %eax
je 0x663a
cmpl $0x9, %eax
je 0x663a
movq 0xd14e(%rip), %r15      # 0x13758
movq %r15, %rdi
movl $0xa, %esi
callq 0x50c0
subq %r15, %rax
leaq 0x6d2d(%rip), %rdi      # 0xd34e
leaq 0x6bbe(%rip), %rsi      # 0xd1e6
movq %rax, %rdx
movq %r15, %rcx
xorl %eax, %eax
callq 0x5320
movq (%rbx), %r15
jmp 0x6640
incq %r15
movq %r15, (%rbx)
movzbl (%r15), %eax
cmpl $0x9, %eax
je 0x663a
cmpl $0x20, %eax
je 0x663a
cmpl $0xa, %eax
jne 0x6658
movq %r15, %rax
jmp 0x666b
leaq 0x1(%r15), %rax
movq %rax, (%rbx)
cmpb $0xa, (%rax)
leaq 0x1(%rax), %rax
jne 0x665c
decq %rax
cmpq %rax, %r15
jne 0x66a5
movq 0xd0e1(%rip), %r12      # 0x13758
movq %r12, %rdi
movl $0xa, %esi
callq 0x50c0
subq %r12, %rax
leaq 0x6cc0(%rip), %rdi      # 0xd34e
leaq 0x6b6b(%rip), %rsi      # 0xd200
movq %rax, %rdx
movq %r12, %rcx
xorl %eax, %eax
callq 0x589a
movq (%rbx), %rax
movb $0x0, (%rax)
leaq 0xd0c9(%rip), %rsi      # 0x13778
movq %r15, %rdi
callq 0x637a
subl 0xd0cb(%rip), %eax      # 0x13788
movq %r14, %rdi
movl %eax, %esi
callq 0x6296
movq (%rbx), %rax
movb $0xa, (%rax)
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
// File: /workspace/github_cpp_makefile_star2_O3/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 0x65e4
movq 0xd09c(%rip), %r14      # 0x13788
movq (%rbx), %rax
movslq -0x4(%rax), %rax
cmpq $-0x1, (%r14,%rax)
jne 0x6715
addq %rax, %r14
leaq 0x8(%r14), %rdi
leaq 0x6b0a(%rip), %rsi      # 0xd212
callq 0x51c0
movq %rax, (%r14)
testq %rax, %rax
je 0x671d
addq $0x8, %rsp
popq %rbx
popq %r14
retq
movq 0xd034(%rip), %rbx      # 0x13758
movq %rbx, %rdi
movl $0xa, %esi
callq 0x50c0
subq %rbx, %rax
leaq 0x6c13(%rip), %rdi      # 0xd34e
leaq 0x6ad2(%rip), %rsi      # 0xd214
movq %rax, %rdx
movq %rbx, %rcx
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x589a
// File: /workspace/github_cpp_makefile_star2_O3/arnoldrobbins[P]mcilroy-regex/sed1.cpp
// Function: Rc(Text*, Text*)
void				/* } */
Rc(Text *script, Text *t)
{
	int l;
	int *p;
	t = t;
	if(brack.w == 0 || (brack.w-=sizeof(int)) < brack.s)
		syntax("unmatched }");
	l = *(int*)brack.w;
	p = (int*)(script->s + l);
	l = script->w - script->s - l;
	if(l >= LMASK - 3*sizeof(int))	/* fixbrack could add 3 */
		syntax("{command-list} too long)");
	*p = (*p&~LMASK) | l;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
movq 0xcffc(%rip), %rax      # 0x13790
testq %rax, %rax
je 0x67ad
addq $-0x4, %rax
movq %rax, 0xcfec(%rip)      # 0x13790
cmpq 0xcff5(%rip), %rax      # 0x137a0
jae 0x67e6
movq 0xcfa4(%rip), %r14      # 0x13758
movq %r14, %rdi
movl $0xa, %esi
callq 0x50c0
subq %r14, %rax
leaq 0x6b83(%rip), %rdi      # 0xd34e
leaq 0x6a5e(%rip), %rsi      # 0xd230
movq %rax, %rdx
movq %r14, %rcx
xorl %eax, %eax
callq 0x589a
movq 0xcfaa(%rip), %rax      # 0x13790
movslq (%rax), %r14
movq 0x10(%rbx), %r15
movl (%rbx), %ebp
subl %r15d, %ebp
subl %r14d, %ebp
cmpl $0xfff3, %ebp           # imm = 0xFFF3
jb 0x682f
movq 0xcf54(%rip), %rbx      # 0x13758
movq %rbx, %rdi
movl $0xa, %esi
callq 0x50c0
subq %rbx, %rax
leaq 0x6b33(%rip), %rdi      # 0xd34e
leaq 0x6a1a(%rip), %rsi      # 0xd23c
movq %rax, %rdx
movq %rbx, %rcx
xorl %eax, %eax
callq 0x589a
movzwl 0x2(%r15,%r14), %eax
shll $0x10, %eax
orl %ebp, %eax
movl %eax, (%r15,%r14)
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O3/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 0x6860
leaq 0xce82(%rip), %rax      # 0x136dc
movl $0x1, (%rax)
movq (%rsi), %rax
cmpb $0xa, (%rax)
je 0x6877
incq %rax
movq %rax, (%rsi)
cmpb $0xa, (%rax)
leaq 0x1(%rax), %rax
jne 0x686b
retq
// File: /workspace/github_cpp_makefile_star2_O3/arnoldrobbins[P]mcilroy-regex/sed1.cpp
// Function: ac(Text*, Text*)
void
ac(Text *script, Text *t)
{
	if(*t->w++ != '\\' || *t->w++ != '\n')
		syntax("\\<newline> missing after command");
	for(;;) {
		while(bflag && blank(t)) ;
		assure(script, 2 + sizeof(int));
		switch(*t->w) {
		case 0:
			quit("bug: missed end of <text>");
		case '\n':
			*script->w++ = *t->w;
			*script->w++ = 0;
			script->w = (uchar*)intp(script->w);
			return;
		case '\\':
			t->w++;
		default:
			*script->w++ = *t->w++;
		}
	}
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rsi, %r14
movq %rdi, %rbx
movq (%rsi), %rax
leaq 0x1(%rax), %rcx
movq %rcx, (%rsi)
cmpb $0x5c, (%rax)
jne 0x68d4
leaq 0x2(%rax), %rcx
movq %rcx, (%r14)
cmpb $0xa, 0x1(%rax)
je 0x6906
movq 0xce7d(%rip), %r15      # 0x13758
movq %r15, %rdi
movl $0xa, %esi
callq 0x50c0
subq %r15, %rax
leaq 0x6a5c(%rip), %rdi      # 0xd34e
leaq 0x6978(%rip), %rsi      # 0xd271
movq %rax, %rdx
movq %r15, %rcx
xorl %eax, %eax
callq 0x589a
leaq 0xcddb(%rip), %r15      # 0x136e8
cmpl $0x0, (%r15)
je 0x6933
movq (%r14), %rax
incq %rax
movzbl -0x1(%rax), %ecx
cmpl $0x20, %ecx
je 0x6927
cmpl $0x9, %ecx
jne 0x6933
movq %rax, (%r14)
incq %rax
cmpl $0x0, (%r15)
jne 0x6919
cmpq $0x0, 0x10(%rbx)
je 0x6946
movq 0x8(%rbx), %rax
incq %rax
cmpq %rax, (%rbx)
jb 0x6953
movq %rbx, %rdi
movl $0x6, %esi
callq 0x5a81
movq (%r14), %rax
movzbl (%rax), %ecx
cmpl $0x5c, %ecx
je 0x6969
cmpl $0xa, %ecx
je 0x6996
testl %ecx, %ecx
jne 0x696c
jmp 0x6983
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 0x690d
leaq 0x6908(%rip), %rdi      # 0xd292
xorl %eax, %eax
callq 0x589a
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)
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_cpp_makefile_star2_O3/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 0xbe65(%rip), %rax      # 0x12fb0
movq (%rax), %rcx
movl $0x1, %esi
movq %rbx, %rdx
callq 0x5300
cmpq %rbx, %rax
je 0x716e
movq 0xc139(%rip), %rdi      # 0x132a0
xorl %eax, %eax
callq 0x589a
movl $0xa, %edi
popq %rbx
jmp 0x711c
// File: /workspace/github_cpp_makefile_star2_O3/arnoldrobbins[P]mcilroy-regex/sed2.cpp
// Function: execute(Text*, Text*)
void
execute(Text *script, Text *data)
{
	uchar *pc;
	int sel;
	for(pc = script->s; pc < script->w; ) {
		sel = selected(pc, data);
		if(sel) {
			int cmd = code(*instr(pc));
			if(sel==2 && cmd=='c')
				cmd = 'd';
			pc = excom[cmd](script, pc, data);
			if(pc == 0)
				return;
		} else
			pc = nexti(pc);
	}
	if(!nflag)
		writeline(data);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq 0x10(%rdi), %r15
cmpq (%rdi), %r15
jae 0x71f4
movq %rdi, %r14
movl $0x64, %r12d
leaq 0xafc0(%rip), %r13      # 0x12160
movq %r15, %rdi
movq %rbx, %rsi
callq 0x7225
movl %eax, %ebp
movq %r15, %rdi
callq 0x6252
movl (%rax), %eax
testl %ebp, %ebp
je 0x71e9
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 0x71ef
jmp 0x7200
movzwl %ax, %eax
addq %rax, %r15
cmpq (%r14), %r15
jb 0x71a0
leaq 0xc4e1(%rip), %rax      # 0x136dc
cmpl $0x0, (%rax)
je 0x720f
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 0x7138
// File: /workspace/github_cpp_makefile_star2_O3/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 0x6252
movq %rax, %r14
subq %r12, %rax
sarq $0x2, %rax
cmpq $0x3, %rax
ja 0x7323
movl (%r14), %ebx
shrl $0x18, %ebx
andl $0x1, %ebx
leaq 0x60f9(%rip), %rcx      # 0xd358
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
xorl $0x1, %ebx
jmp 0x7357
leaq 0x6109(%rip), %rdi      # 0xd380
movl $0x1, %esi
xorl %eax, %eax
callq 0x589a
movl -0x4(%r14), %ebp
movl %ebp, %r13d
notl %r13d
shrl $0x1f, %r13d
movl %ebp, %eax
andl $0x7fffffff, %eax       # imm = 0x7FFFFFFF
leaq 0xc439(%rip), %rcx      # 0x136d8
cmpl (%rcx), %eax
jge 0x7352
movl %r13d, %eax
movl (%r12,%rax,4), %edi
movq %r15, %rsi
callq 0x7368
cmpl $-0x1, %eax
je 0x733a
cmpl $0x1, %eax
leaq 0xc413(%rip), %rcx      # 0x136d8
je 0x72e0
testl %eax, %eax
jne 0x7352
callq 0x5b41
leaq 0xc3fd(%rip), %rcx      # 0x136d8
testl %r13d, %eax
je 0x7352
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 0x5b41
testl %eax, %eax
sete %cl
andb %bpl, %cl
shll %cl, %ebx
jmp 0x7357
movl (%r12), %edi
movq %r15, %rsi
callq 0x7368
xorl %ecx, %ecx
cmpl $0x1, %eax
sete %cl
xorl %ecx, %ebx
jmp 0x7357
leaq 0x6056(%rip), %rdi      # 0xd380
xorl %ebx, %ebx
movl $0x2, %esi
xorl %eax, %eax
callq 0x589a
jmp 0x7357
testl %ebp, %ebp
leaq 0xc395(%rip), %rcx      # 0x136d8
js 0x7352
movl $0x80000000, %eax       # imm = 0x80000000
orl (%rcx), %eax
movl %eax, -0x4(%r14)
jmp 0x7357
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_O3/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 0x7394
leaq 0xc365(%rip), %rax      # 0x136d8
movl (%rax), %ecx
movl $0x1, %eax
cmpl %edi, %ecx
je 0x7393
cmpl $0x7fffffff, %edi       # imm = 0x7FFFFFFF
je 0x5b41
xorl %eax, %eax
cmpl %edi, %ecx
setg %al
negl %eax
retq
pushq %rbx
movq %rsi, %rbx
callq 0x636b
movq 0x10(%rbx), %rsi
movq %rax, %rdi
xorl %edx, %edx
xorl %ecx, %ecx
xorl %r8d, %r8d
callq 0x9bac
movl %eax, %ecx
xorl %eax, %eax
testl %ecx, %ecx
sete %al
popq %rbx
retq
// File: /workspace/github_cpp_makefile_star2_O3/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 0x741e
movq (%rbx), %rdi
movq 0x8(%rbx), %rcx
movslq %esi, %r14
subq %r14, %rcx
cmpq %rcx, %rdi
jae 0x7421
jmp 0x7432
movslq %esi, %r14
incl %esi
movq %rbx, %rdi
callq 0x5a81
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_O3/arnoldrobbins[P]mcilroy-regex/sed2.cpp
// Function: De(Text*, unsigned char*, Text*)
uchar *
De(Text *script, uchar *pc, Text *data)
{
	int n;
	uchar *end = (uchar*)ustrchr(data->s, '\n');
	if(end == 0)
		return de(script, pc, data);
	end++;
	n = data->w - end;
	memmove(data->s, end, n+1);
	data->w = data->s + n;
	return script->s;
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rdx, %rbx
movq %rdi, %r14
movq 0x10(%rdx), %r15
movq %r15, %rdi
movl $0xa, %esi
callq 0x50c0
testq %rax, %rax
je 0x74d0
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 0x74da
movq %rbx, %rdi
callq 0x73bb
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
// File: /workspace/github_cpp_makefile_star2_O3/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 0xc1da(%rip), %rax      # 0x136d8
movl (%rax), %esi
leaq 0x5e8c(%rip), %rdi      # 0xd393
xorl %eax, %eax
callq 0x5050
testl %eax, %eax
jg 0x7520
movq 0xbd87(%rip), %rdi      # 0x132a0
xorl %eax, %eax
callq 0x589a
movq %rbx, %rdi
callq 0x6252
movzwl (%rax), %eax
addq %rbx, %rax
popq %rbx
retq
// File: /workspace/github_cpp_makefile_star2_O3/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, 0xc27e(%rip)      # 0x137c0
jne 0x7550
leaq 0xc265(%rip), %rdi      # 0x137b0
callq 0x73bb
movq (%r14), %rax
cmpq 0x10(%r14), %rax
jbe 0x7563
leaq 0x1(%rax), %rcx
movq %rcx, (%r14)
movb $0xa, (%rax)
leaq 0xc246(%rip), %rdi      # 0x137b0
movq %r14, %rsi
callq 0x73ee
movq %rbx, %rdi
callq 0x6252
movzwl (%rax), %eax
addq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_cpp_makefile_star2_O3/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, 0xc202(%rip)      # 0x137c0
je 0x75d7
movq 0xc1e9(%rip), %rax      # 0x137b0
movq 0xc1ea(%rip), %rcx      # 0x137b8
addq $-0x2, %rcx
cmpq %rcx, %rax
jb 0x75ef
leaq 0xc1d2(%rip), %rdi      # 0x137b0
movl $0x1, %esi
callq 0x5a81
movq 0xc1c1(%rip), %rax      # 0x137b0
leaq 0x1(%rax), %rcx
movq %rcx, 0xc1b6(%rip)      # 0x137b0
leaq 0xc1af(%rip), %rsi      # 0x137b0
movb $0xa, (%rax)
movq %r14, %rdi
callq 0x73ee
movq %rbx, %rdi
callq 0x6252
movzwl (%rax), %eax
addq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_cpp_makefile_star2_O3/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 0xc17c(%rip), %r15      # 0x137b0
movq %r15, %rdi
callq 0x73bb
movq %rbx, %rdi
movq %r15, %rsi
callq 0x73ee
movq %r14, %rdi
callq 0x6252
movzwl (%rax), %eax
addq %r14, %rax
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_cpp_makefile_star2_O3/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 0x6252
leaq 0x4(%rax), %rsi
leaq 0x5d1f(%rip), %rdi      # 0xd3a5
xorl %eax, %eax
callq 0x5050
testl %eax, %eax
jg 0x769f
movq 0xbc08(%rip), %rdi      # 0x132a0
xorl %eax, %eax
callq 0x589a
movq %rbx, %rdi
callq 0x6252
movzwl (%rax), %eax
addq %rbx, %rax
popq %rbx
retq
// File: /workspace/github_cpp_makefile_star2_O3/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 0x76df
movq (%r14), %rax
movq 0x8(%r14), %rcx
addq $-0x2, %rcx
cmpq %rcx, %rax
jb 0x76ef
movq %r14, %rdi
movl $0x1, %esi
callq 0x5a81
movq (%r14), %rax
leaq 0x1(%rax), %rcx
movq %rcx, (%r14)
movb $0xa, (%rax)
movq %r14, %rdi
callq 0x599b
testl %eax, %eax
je 0x7715
movq %rbx, %rdi
callq 0x6252
movzwl (%rax), %eax
addq %rbx, %rax
jmp 0x772d
movq (%r14), %rax
leaq -0x1(%rax), %rcx
movq %rcx, (%r14)
movb $0x0, -0x1(%rax)
movq %r14, %rdi
callq 0x73bb
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_cpp_makefile_star2_O3/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 0xbf96(%rip), %rax      # 0x136dc
cmpl $0x0, (%rax)
jne 0x7753
movq %r14, %rdi
callq 0x7138
movq %r14, %rdi
callq 0x73bb
movq %r14, %rdi
callq 0x599b
testl %eax, %eax
je 0x7777
movq %rbx, %rdi
callq 0x6252
movzwl (%rax), %eax
addq %rbx, %rax
jmp 0x7779
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_cpp_makefile_star2_O3/arnoldrobbins[P]mcilroy-regex/sed2.cpp
// Function: Pe(Text*, unsigned char*, Text*)
uchar *
Pe(Text *script, uchar *pc, Text *data)
{
	int n;
	uchar *end = ustrchr(data->s, '\n');
	if(end == 0)
		n = data->w - data->s;
	else
		n = end - data->s;
	if(fwrite(data->s, 1, n, stdout) != n)
		quit(stdouterr);
	cputchar('\n');
	script = script;
	return nexti(pc);
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rdx, %r15
movq %rsi, %rbx
movq 0x10(%rdx), %r14
movq %r14, %rdi
movl $0xa, %esi
callq 0x50c0
testq %rax, %rax
jne 0x77a5
movq (%r15), %rax
subl %r14d, %eax
movslq %eax, %r15
movq 0xb7fe(%rip), %rax      # 0x12fb0
movq (%rax), %rcx
movl $0x1, %esi
movq %r14, %rdi
movq %r15, %rdx
callq 0x5300
cmpq %r15, %rax
je 0x77d8
movq 0xbacf(%rip), %rdi      # 0x132a0
xorl %eax, %eax
callq 0x589a
movl $0xa, %edi
callq 0x711c
movq %rbx, %rdi
callq 0x6252
movzwl (%rax), %eax
addq %rbx, %rax
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_cpp_makefile_star2_O3/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 0xbeb7(%rip), %rax      # 0x136e4
cmpl $0x0, (%rax)
movl $0x0, (%rax)
je 0x784d
movq 0x10(%rdi), %r14
movq %rbx, %rdi
callq 0x6252
movslq 0x4(%rax), %rax
addq %r14, %rax
jmp 0x785b
movq %rbx, %rdi
callq 0x6252
movzwl (%rax), %eax
addq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_cpp_makefile_star2_O3/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 0xbefd(%rip), %rax      # 0x13778
movq 0x10(%rax), %r15
movslq %ecx, %rbp
movq (%r15,%rbp), %r12
movq (%rdx), %rax
movq 0x10(%rdx), %rcx
movq %rax, %r13
subq %rcx, %r13
testq %rcx, %rcx
je 0x78a5
movq 0x8(%r14), %rcx
addq $-0x2, %rcx
cmpq %rcx, %rax
jb 0x78b5
movq %r14, %rdi
movl $0x1, %esi
callq 0x5a81
movq (%r14), %rax
movb $0xa, (%rax)
movq 0x10(%r14), %rdi
incl %r13d
movslq %r13d, %r13
movl $0x1, %esi
movq %r13, %rdx
movq %r12, %rcx
callq 0x5300
cmpq %r13, %rax
jne 0x78e4
movq %r12, %rdi
callq 0x51b0
cmpl $-0x1, %eax
jne 0x78fc
addq %rbp, %r15
addq $0x4, %r15
leaq 0x5aa5(%rip), %rdi      # 0xd397
movq %r15, %rsi
xorl %eax, %eax
callq 0x589a
movq (%r14), %rax
movb $0x0, (%rax)
movq %rbx, %rdi
callq 0x6252
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_O3/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 0xbe69(%rip), %rax      # 0x137c0
testq %rax, %rax
jne 0x796f
leaq 0xbe4d(%rip), %rdi      # 0x137b0
callq 0x73bb
movq 0xbe51(%rip), %rax      # 0x137c0
movq 0x10(%r14), %rcx
movq %rax, 0x10(%r14)
movq %rcx, 0xbe42(%rip)      # 0x137c0
movaps 0xbe2b(%rip), %xmm0     # 0x137b0
movups (%r14), %xmm1
movups %xmm0, (%r14)
movaps %xmm1, 0xbe1c(%rip)     # 0x137b0
movq %rbx, %rdi
callq 0x6252
movzwl (%rax), %eax
addq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_cpp_makefile_star2_O3/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 0x6252
cmpq %r14, %r15
jae 0x79d9
movzbl (%r15), %ecx
movb 0x4(%rax,%rcx), %cl
movb %cl, (%r15)
incq %r15
cmpq %r14, %r15
jne 0x79c6
movq %rbx, %rdi
callq 0x6252
movzwl (%rax), %eax
addq %rbx, %rax
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_cpp_makefile_star2_O3/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 0x6252
movl 0x4(%rax), %edi
movl 0x8(%rax), %r12d
leaq 0xc(%rax), %r15
movl %r12d, %ebp
andl $0x3fffffff, %ebp       # imm = 0x3FFFFFFF
callq 0x636b
movq %rax, %rdi
movq %r14, %rsi
movq %r15, %rdx
movl %ebp, %ecx
callq 0x7ed3
leaq 0xbcb1(%rip), %rcx      # 0x136e4
movl %eax, (%rcx)
testl %eax, %eax
je 0x7a79
testl %r12d, %r12d
jns 0x7a4e
movq %r14, %rdi
callq 0x7138
movq %rbx, %rdi
callq 0x6252
movq %rbx, %rdi
callq 0x6252
movzwl (%rax), %eax
addq %rbx, %rax
btl $0x1e, %r12d
jae 0x7a87
movl -0x4(%rax), %ecx
movq %rbx, %rsi
movq %r14, %rdx
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
jmp 0x7863
movq %rbx, %rdi
callq 0x6252
movzwl (%rax), %eax
addq %rbx, %rax
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O3/arnoldrobbins[P]mcilroy-regex/sed2.cpp
// Function: le(Text*, unsigned char*, Text*)
uchar *
le(Text *script, uchar *pc, Text *data)
{
	int i = 0;
	int j;
	uchar *s;
	script = script;
	for(s=data->s; s<data->w; s++, i++) {
		if(i >= 60) {
			cputchar('\\');
			cputchar('\n');
			i = 0;
		}
		for(j=0; j<sizeof(digram)/sizeof(*digram); j++)
			if(*s == digram[j].p) {
				cputchar('\\');
				cputchar(digram[j].q);
				goto cont;
			}
		if(!isprint(*s)) {
			if(printf("\\%3.3o", *s) <= 0)
				quit(stdouterr);
		} else
			cputchar(*s);
	cont:	;
	}
	cputchar('$');
	cputchar('\n');
	return nexti(pc);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rsi, (%rsp)
movq 0x10(%rdx), %r12
cmpq (%rdx), %r12
jae 0x7b45
movq %rdx, %r14
leaq 0xb7fa(%rip), %r13      # 0x132b0
xorl %r15d, %r15d
cmpl $0x3c, %r15d
jl 0x7ad6
movl $0x5c, %edi
callq 0x711c
movl $0xa, %edi
callq 0x711c
xorl %r15d, %r15d
movzbl (%r12), %ebp
xorl %ebx, %ebx
movsbl (%r13,%rbx,2), %eax
cmpl %eax, %ebp
je 0x7aff
incq %rbx
cmpq $0x8, %rbx
jne 0x7add
movl %ebp, %edi
callq 0x52c0
testl %eax, %eax
je 0x7b21
movl %ebp, %edi
jmp 0x7b0f
movl $0x5c, %edi
callq 0x711c
movsbl 0x1(%r13,%rbx,2), %edi
callq 0x711c
incq %r12
incl %r15d
cmpq (%r14), %r12
jb 0x7ab9
jmp 0x7b45
leaq 0x5880(%rip), %rdi      # 0xd3a8
movl %ebp, %esi
xorl %eax, %eax
callq 0x5050
testl %eax, %eax
jg 0x7b14
movq 0xb764(%rip), %rdi      # 0x132a0
xorl %eax, %eax
callq 0x589a
jmp 0x7b14
movl $0x24, %edi
callq 0x711c
movl $0xa, %edi
callq 0x711c
movq (%rsp), %rbx
movq %rbx, %rdi
callq 0x6252
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_O3/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, 0xbc52(%rip)      # 0x137d8
je 0x7b9f
movq 0xbc39(%rip), %rax      # 0x137c8
movq 0xbc3a(%rip), %rcx      # 0x137d0
addq $-0x9, %rcx
cmpq %rcx, %rax
jb 0x7bb7
leaq 0xbc22(%rip), %rdi      # 0x137c8
movl $0x8, %esi
callq 0x5a81
movq 0xbc11(%rip), %rax      # 0x137c8
movq %rbx, (%rax)
addq $0x8, 0xbc06(%rip)      # 0x137c8
movq %rbx, %rdi
callq 0x6252
movzwl (%rax), %eax
addq %rbx, %rax
popq %rbx
retq
// File: /workspace/github_cpp_makefile_star2_O3/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 0xbbb8(%rip), %r13      # 0x137d8
testq %r13, %r13
je 0x7d08
cmpq 0xbb98(%rip), %r13      # 0x137c8
jae 0x7cee
leaq 0xbb3b(%rip), %rbp      # 0x13778
leaq 0x568e(%rip), %rbx      # 0xd2d2
leaq 0x575a(%rip), %r14      # 0xd3a5
leaq 0x572e(%rip), %r15      # 0xd380
movq (%r13), %rdi
callq 0x6252
movzbl 0x2(%rax), %ecx
cmpl $0x72, %ecx
je 0x7c8e
cmpl $0x61, %ecx
jne 0x7cc4
addq $0x4, %rax
movq %r14, %rdi
movq %rax, %rsi
xorl %eax, %eax
callq 0x5050
testl %eax, %eax
jg 0x7cdd
movq 0xb61b(%rip), %rdi      # 0x132a0
xorl %eax, %eax
callq 0x589a
jmp 0x7cdd
movq 0x10(%rbp), %rcx
movslq 0x4(%rax), %rax
leaq (%rcx,%rax), %rdi
addq $0x8, %rdi
movq %rbx, %rsi
callq 0x51c0
testq %rax, %rax
je 0x7cdd
movq %rax, %r12
movq %r12, %rdi
callq 0x50a0
cmpl $-0x1, %eax
je 0x7cd5
movl %eax, %edi
callq 0x711c
jmp 0x7cae
movq %r15, %rdi
movl $0x5, %esi
xorl %eax, %eax
callq 0x589a
jmp 0x7cdd
movq %r12, %rdi
callq 0x5160
addq $0x8, %r13
cmpq 0xbae0(%rip), %r13      # 0x137c8
jb 0x7c52
leaq 0xbad3(%rip), %rdi      # 0x137c8
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x73bb
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O3/arnoldrobbins[P]mcilroy-regex/sed3.cpp
// Function: substitute(regex_t*, Text*, unsigned char*, int)
int
substitute(regex_t *re, Text* data, uchar *rhs, int n)
{
	Text t;
	uchar *where = data->s;
	if(regexec(re, (char*)data->s, NMATCH, matches, 0))
		return 0;
	vacate(&gendata);
	if(n == 0)
		do {
			docopy(where, so);
			if(!dosub(where, rhs))
				return 0;
			where += eo;
			if(eo == so) {
				if(where < data->w)
					docopy(where++, 1);
				else
					goto done;
			}
		} while(regexec(re, (char*)where, NMATCH, matches, REG_NOTBOL) == 0);
	else {
		while(--n > 0) {
			where += eo;
			if(eo == so) {
				if(where < data->w)
					where++;
				else
					return 0;
			}
			if(regexec(re, (char*)where, NMATCH, matches, REG_NOTBOL))
				return 0;
		}
		docopy(data->s, where-data->s+so);
		if(!dosub(where, rhs))
			return 0;
		where += eo;
	}			
	eo = so = data->w - where;
	docopy(where, so);
done:
	exch(gendata, *data, t);
	return 1;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movl %ecx, %r13d
movq %rdx, %r15
movq %rsi, %rbx
movq %rdi, %r12
movq 0x10(%rsi), %r14
leaq 0xb928(%rip), %rcx      # 0x13820
xorl %ebp, %ebp
movl $0xa, %edx
movq %r14, %rsi
xorl %r8d, %r8d
callq 0x9bac
testl %eax, %eax
jne 0x805e
leaq 0xb8e7(%rip), %rdi      # 0x13800
callq 0x73bb
testl %r13d, %r13d
je 0x7f79
incl %r13d
leaq 0xb8f3(%rip), %rbp      # 0x13820
decl %r13d
cmpl $0x2, %r13d
jl 0x7fe4
movq 0xb8e7(%rip), %rax      # 0x13828
addq %rax, %r14
cmpq 0xb8d5(%rip), %rax      # 0x13820
jne 0x7f55
cmpq (%rbx), %r14
jae 0x7f72
incq %r14
movl $0xa, %edx
movq %r12, %rdi
movq %r14, %rsi
movq %rbp, %rcx
movl $0x10, %r8d
callq 0x9bac
testl %eax, %eax
je 0x7f2d
xorl %ebp, %ebp
jmp 0x805e
leaq 0xb8a0(%rip), %r13      # 0x13820
movl 0xb89a(%rip), %esi      # 0x13820
movq %r14, %rdi
callq 0x806f
movq %r14, %rdi
movq %r15, %rsi
callq 0x80dd
movq 0xb888(%rip), %rax      # 0x13828
addq %rax, %r14
cmpq 0xb876(%rip), %rax      # 0x13820
jne 0x7fc5
cmpq (%rbx), %r14
jae 0x8026
leaq 0x1(%r14), %rbp
movq %r14, %rdi
movl $0x1, %esi
callq 0x806f
movq %rbp, %r14
movl $0xa, %edx
movq %r12, %rdi
movq %r14, %rsi
movq %r13, %rcx
movl $0x10, %r8d
callq 0x9bac
testl %eax, %eax
je 0x7f80
jmp 0x800a
movq 0x10(%rbx), %rdi
movl %r14d, %esi
subl %edi, %esi
addl 0xb82d(%rip), %esi      # 0x13820
callq 0x806f
movq %r14, %rdi
movq %r15, %rsi
callq 0x80dd
addq 0xb81e(%rip), %r14      # 0x13828
movq (%rbx), %rsi
subq %r14, %rsi
movq %rsi, 0xb809(%rip)      # 0x13820
movq %rsi, 0xb80a(%rip)      # 0x13828
movq %r14, %rdi
callq 0x806f
movq 0xb7e3(%rip), %rax      # 0x13810
movq %rax, 0x10(%rsp)
movups 0xb7c7(%rip), %xmm0     # 0x13800
movaps %xmm0, (%rsp)
movq 0x10(%rbx), %rcx
movq %rcx, 0xb7c8(%rip)      # 0x13810
movups (%rbx), %xmm1
movups %xmm1, 0xb7ae(%rip)     # 0x13800
movups %xmm0, (%rbx)
movq %rax, 0x10(%rbx)
movl $0x1, %ebp
movl %ebp, %eax
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O3/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, 0xb792(%rip)      # 0x13810
je 0x809b
movq 0xb779(%rip), %rdi      # 0x13800
movq 0xb77a(%rip), %rax      # 0x13808
movslq %esi, %r14
subq %r14, %rax
cmpq %rax, %rdi
jae 0x809e
jmp 0x80b3
movslq %esi, %r14
incl %esi
leaq 0xb759(%rip), %rdi      # 0x13800
callq 0x5a81
movq 0xb74d(%rip), %rdi      # 0x13800
movq %rbx, %rsi
movq %r14, %rdx
callq 0x5290
movq 0xb73b(%rip), %rax      # 0x13800
leaq (%rax,%r14), %rcx
movq %rcx, 0xb730(%rip)      # 0x13800
movb $0x0, (%rax,%r14)
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_cpp_makefile_star2_O3/arnoldrobbins[P]mcilroy-regex/sed3.cpp
// Function: dosub(unsigned char*, unsigned char*)
int
dosub(uchar *where, uchar *rp)
{
	int c, n;
	regmatch_t *m;

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

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rsi, %r15
movq %rdi, %rbx
leaq 0xb70b(%rip), %r14      # 0x13800
leaq 0xb724(%rip), %r13      # 0x13820
leaq 0x1(%r15), %r12
movzbl (%r15), %ebp
cmpl $0x26, %ebp
je 0x8183
cmpl $0x5c, %ebp
je 0x811b
testl %ebp, %ebp
jne 0x8207
jmp 0x8285
movb 0x1(%r15), %bpl
addq $0x2, %r15
leal -0x31(%rbp), %eax
cmpb $0x8, %al
ja 0x8204
movzbl %bpl, %ebp
shll $0x4, %ebp
movq -0x2f8(%rbp,%r13), %rsi
cmpq $-0x1, %rsi
je 0x80fc
addq %r13, %rbp
movq -0x300(%rbp), %rax
subq %rax, %rsi
cmpq $0x0, 0xb6b8(%rip)      # 0x13810
je 0x8252
movq 0xb69b(%rip), %rdi      # 0x13800
movslq %esi, %r12
movq %r12, %rcx
notq %rcx
addq 0xb693(%rip), %rcx      # 0x13808
cmpq %rcx, %rdi
jae 0x8255
jmp 0x826b
cmpq $0x0, 0xb685(%rip)      # 0x13810
movq 0xb696(%rip), %rdx      # 0x13828
movq 0xb687(%rip), %rax      # 0x13820
je 0x81ba
movq 0xb65e(%rip), %rdi      # 0x13800
movq 0xb65f(%rip), %rcx      # 0x13808
subq %rdx, %rcx
movq %rax, %rsi
notq %rsi
addq %rcx, %rsi
cmpq %rsi, %rdi
jb 0x81db
subl %eax, %edx
movq %r14, %rdi
movl %edx, %esi
callq 0x5a81
movq 0xb633(%rip), %rdi      # 0x13800
movq 0xb64c(%rip), %rax      # 0x13820
movq 0xb64d(%rip), %rdx      # 0x13828
leaq (%rbx,%rax), %rsi
subq %rax, %rdx
callq 0x5290
movq 0xb63a(%rip), %rax      # 0x13828
subq 0xb62b(%rip), %rax      # 0x13820
addq %rax, 0xb604(%rip)      # 0x13800
movq %r12, %r15
jmp 0x80fc
movq %r15, %r12
cmpq $0x0, 0xb601(%rip)      # 0x13810
je 0x8228
movq 0xb5e8(%rip), %rax      # 0x13800
movq 0xb5e9(%rip), %rcx      # 0x13808
addq $-0x2, %rcx
cmpq %rcx, %rax
jb 0x823c
movq %r14, %rdi
movl $0x1, %esi
callq 0x5a81
movq 0xb5c4(%rip), %rax      # 0x13800
leaq 0x1(%rax), %rcx
movq %rcx, 0xb5b9(%rip)      # 0x13800
movb %bpl, (%rax)
movq %r12, %r15
jmp 0x80fc
movslq %esi, %r12
movq %r14, %rdi
callq 0x5a81
movq 0xb59c(%rip), %rdi      # 0x13800
movq -0x300(%rbp), %rax
addq %rbx, %rax
movq %rax, %rsi
movq %r12, %rdx
callq 0x5290
addq %r12, 0xb580(%rip)      # 0x13800
jmp 0x80fc
movl $0x1, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_cpp_makefile_star2_O3/arnoldrobbins[P]mcilroy-regex/re1.cpp
// Function: Eenv::pushpos(Rex*, unsigned char*, int)
int Eenv::pushpos(Rex *rex, uchar *p, int b_e )
{
	if(pos.assure(npos+1))	// +1 is probably superstition
		return 1;
	pos[npos].serial = rex->serial;
	pos[npos].p = p;
	pos[npos].be = b_e;
	npos++;
	return 0;
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movl %ecx, %ebx
movq %rdx, %r15
movq %rsi, %r12
movq %rdi, %r14
movl 0x20(%rdi), %eax
leal 0x1(%rax), %esi
cmpl %esi, 0x30(%rdi)
jg 0x82d5
leaq 0x28(%r14), %rdi
callq 0xa190
movl %eax, %ecx
movl $0x1, %eax
testl %ecx, %ecx
jne 0x82f8
movl 0x20(%r14), %eax
leal 0x1(%rax), %esi
movzwl 0xa(%r12), %ecx
movq 0x28(%r14), %rdx
cltq
shlq $0x4, %rax
movw %cx, 0x8(%rdx,%rax)
movq %r15, (%rdx,%rax)
movb %bl, 0xa(%rdx,%rax)
movl %esi, 0x20(%r14)
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq