LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: arnoldrobbins[P]mcilroy-regex/re1.cpp
// Function: Anchor::parse(unsigned char*, Rex*, Eenv*)
int Anchor::parse(uchar *s, Rex *cont, Eenv *env)
{
	debug(ANCHOR, "Anchor", s);
	if(((env->flags&REG_NEWLINE) && s>env->p && s[-1]=='\n') ||
	   (!(env->flags&REG_NOTBOL) && s==env->p))
		return follow(s, cont, env);
	return NONE;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movq %rcx, -0x28(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x30(%rbp)
movq -0x28(%rbp), %rax
movl (%rax), %eax
andl $0x8, %eax
cmpl $0x0, %eax
je 0x9639
movq -0x18(%rbp), %rax
movq -0x28(%rbp), %rcx
cmpq 0x10(%rcx), %rax
jbe 0x9639
movq -0x18(%rbp), %rax
movzbl -0x1(%rax), %eax
cmpl $0xa, %eax
je 0x9655
movq -0x28(%rbp), %rax
movl (%rax), %eax
andl $0x10, %eax
cmpl $0x0, %eax
jne 0x966f
movq -0x18(%rbp), %rax
movq -0x28(%rbp), %rcx
cmpq 0x10(%rcx), %rax
jne 0x966f
movq -0x30(%rbp), %rdi
movq -0x18(%rbp), %rsi
movq -0x20(%rbp), %rdx
movq -0x28(%rbp), %rcx
callq 0xbd70
movl %eax, -0x4(%rbp)
jmp 0x9676
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x30, %rsp
popq %rbp
retq
nop
// File: arnoldrobbins[P]mcilroy-regex/re1.cpp
// Function: End::parse(unsigned char*, Rex*, Eenv*)
int End::parse(uchar *s, Rex *cont, Eenv *env)
{
	debug(END, "End", s);
	if((*s==0 && !(env->flags&REG_NOTEOL)) ||
	    ((env->flags&REG_NEWLINE) && *s=='\n'))
		return follow(s, cont, env);
	return NONE;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movq %rcx, -0x28(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x30(%rbp)
movq -0x18(%rbp), %rax
movzbl (%rax), %eax
cmpl $0x0, %eax
jne 0x96ba
movq -0x28(%rbp), %rax
movl (%rax), %eax
andl $0x20, %eax
cmpl $0x0, %eax
je 0x96d4
movq -0x28(%rbp), %rax
movl (%rax), %eax
andl $0x8, %eax
cmpl $0x0, %eax
je 0x96ee
movq -0x18(%rbp), %rax
movzbl (%rax), %eax
cmpl $0xa, %eax
jne 0x96ee
movq -0x30(%rbp), %rdi
movq -0x18(%rbp), %rsi
movq -0x20(%rbp), %rdx
movq -0x28(%rbp), %rcx
callq 0xbd70
movl %eax, -0x4(%rbp)
jmp 0x96f5
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x30, %rsp
popq %rbp
retq
nop
// File: arnoldrobbins[P]mcilroy-regex/re1.cpp
// Function: Dot::parse(unsigned char*, Rex*, Eenv*)
int Dot::parse(uchar *s, Rex *cont, Eenv *env)
{
	debug(DOT, "Dot", s);
	int n = hi;
	if(n > env->last-s)
		n = env->last-s;
	if(env->flags&REG_NEWLINE) {
		for(int i=0 ; i<n; i++)
			if(s[i] == '\n')
				n = i;
	}
	int result = NONE;
	for(s+=n; n-->=lo; s--)
		switch(follow(s, cont, env)) {
		case BEST:
			return BEST;
		case BAD:
			return BAD;
		case GOOD:
			result = GOOD;
		}
	return result;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movq %rcx, -0x28(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x40(%rbp)
movl 0x1c(%rax), %eax
movl %eax, -0x2c(%rbp)
movslq -0x2c(%rbp), %rax
movq -0x28(%rbp), %rcx
movq 0x18(%rcx), %rcx
movq -0x18(%rbp), %rdx
subq %rdx, %rcx
cmpq %rcx, %rax
jle 0x9750
movq -0x28(%rbp), %rax
movq 0x18(%rax), %rax
movq -0x18(%rbp), %rcx
subq %rcx, %rax
movl %eax, -0x2c(%rbp)
movq -0x28(%rbp), %rax
movl (%rax), %eax
andl $0x8, %eax
cmpl $0x0, %eax
je 0x9793
movl $0x0, -0x30(%rbp)
movl -0x30(%rbp), %eax
cmpl -0x2c(%rbp), %eax
jge 0x9791
movq -0x18(%rbp), %rax
movslq -0x30(%rbp), %rcx
movzbl (%rax,%rcx), %eax
cmpl $0xa, %eax
jne 0x9784
movl -0x30(%rbp), %eax
movl %eax, -0x2c(%rbp)
jmp 0x9786
movl -0x30(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x30(%rbp)
jmp 0x9765
jmp 0x9793
movl $0x0, -0x34(%rbp)
movl -0x2c(%rbp), %ecx
movq -0x18(%rbp), %rax
movslq %ecx, %rcx
addq %rcx, %rax
movq %rax, -0x18(%rbp)
movq -0x40(%rbp), %rcx
movl -0x2c(%rbp), %eax
movl %eax, %edx
addl $-0x1, %edx
movl %edx, -0x2c(%rbp)
cmpl 0x18(%rcx), %eax
jl 0x981d
movq -0x40(%rbp), %rdi
movq -0x18(%rbp), %rsi
movq -0x20(%rbp), %rdx
movq -0x28(%rbp), %rcx
callq 0xbd70
movl %eax, %ecx
movl %ecx, -0x44(%rbp)
subl $0x1, %eax
je 0x9806
jmp 0x97e0
movl -0x44(%rbp), %eax
subl $0x2, %eax
je 0x97f4
jmp 0x97ea
movl -0x44(%rbp), %eax
subl $0x3, %eax
je 0x97fd
jmp 0x980d
movl $0x2, -0x4(%rbp)
jmp 0x9823
movl $0x3, -0x4(%rbp)
jmp 0x9823
movl $0x1, -0x34(%rbp)
jmp 0x980f
movq -0x18(%rbp), %rax
addq $-0x1, %rax
movq %rax, -0x18(%rbp)
jmp 0x97ab
movl -0x34(%rbp), %eax
movl %eax, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x50, %rsp
popq %rbp
retq
nopl (%rax)
// File: arnoldrobbins[P]mcilroy-regex/re1.cpp
// Function: Onechar::parse(unsigned char*, Rex*, Eenv*)
int Onechar::parse(uchar *s, Rex *cont, Eenv *env)
{
	debug(ONECHAR, "Onechar", s);
	int n = hi;
	uchar *map = env->preg->map;
	if(n > env->last-s)
		n = env->last-s;
	int i = 0;
	for( ; i<n; i++,s++)
		if(map[*s] != c)
			break;
	int result = NONE;
	for( ; i-->=lo; s--)
		switch(follow(s, cont, env)) {
		case BEST:
			return BEST;
		case BAD:
			return BAD;
		case GOOD:
			result = GOOD;
		}
	return result;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movq %rcx, -0x28(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x48(%rbp)
movl 0x1c(%rax), %eax
movl %eax, -0x2c(%rbp)
movq -0x28(%rbp), %rax
movq 0x8(%rax), %rax
movq 0x18(%rax), %rax
movq %rax, -0x38(%rbp)
movslq -0x2c(%rbp), %rax
movq -0x28(%rbp), %rcx
movq 0x18(%rcx), %rcx
movq -0x18(%rbp), %rdx
subq %rdx, %rcx
cmpq %rcx, %rax
jle 0x9890
movq -0x28(%rbp), %rax
movq 0x18(%rax), %rax
movq -0x18(%rbp), %rcx
subq %rcx, %rax
movl %eax, -0x2c(%rbp)
movl $0x0, -0x3c(%rbp)
movl -0x3c(%rbp), %eax
cmpl -0x2c(%rbp), %eax
jge 0x98d5
movq -0x48(%rbp), %rcx
movq -0x38(%rbp), %rax
movq -0x18(%rbp), %rdx
movzbl (%rdx), %edx
movzbl (%rax,%rdx), %eax
movzbl 0x20(%rcx), %ecx
cmpl %ecx, %eax
je 0x98bc
jmp 0x98d5
jmp 0x98be
movl -0x3c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x3c(%rbp)
movq -0x18(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x18(%rbp)
jmp 0x9897
movl $0x0, -0x40(%rbp)
movq -0x48(%rbp), %rcx
movl -0x3c(%rbp), %eax
movl %eax, %edx
addl $-0x1, %edx
movl %edx, -0x3c(%rbp)
cmpl 0x18(%rcx), %eax
jl 0x994e
movq -0x48(%rbp), %rdi
movq -0x18(%rbp), %rsi
movq -0x20(%rbp), %rdx
movq -0x28(%rbp), %rcx
callq 0xbd70
movl %eax, %ecx
movl %ecx, -0x4c(%rbp)
subl $0x1, %eax
je 0x9937
jmp 0x9911
movl -0x4c(%rbp), %eax
subl $0x2, %eax
je 0x9925
jmp 0x991b
movl -0x4c(%rbp), %eax
subl $0x3, %eax
je 0x992e
jmp 0x993e
movl $0x2, -0x4(%rbp)
jmp 0x9954
movl $0x3, -0x4(%rbp)
jmp 0x9954
movl $0x1, -0x40(%rbp)
jmp 0x9940
movq -0x18(%rbp), %rax
addq $-0x1, %rax
movq %rax, -0x18(%rbp)
jmp 0x98dc
movl -0x40(%rbp), %eax
movl %eax, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x50, %rsp
popq %rbp
retq
nopl (%rax)
// File: arnoldrobbins[P]mcilroy-regex/re1.cpp
// Function: Class::parse(unsigned char*, Rex*, Eenv*)
int Class::parse(uchar *s, Rex *cont, Eenv *env)
{
	debug(CLASS, "Class", s);
	int n = hi;
	if(n > env->last-s)
		n = env->last-s;
	for(int i=0; i<n; i++)
		if(!cl.in(s[i]))
			n = i;
	int result = NONE;
	for(s+=n; n-->=lo; s--)
		switch(follow(s, cont, env)) {
		case BEST:
			return BEST;
		case BAD:
			return BAD;
		case GOOD:
			result = GOOD;
		}
	return result;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movq %rcx, -0x28(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x40(%rbp)
movl 0x1c(%rax), %eax
movl %eax, -0x2c(%rbp)
movslq -0x2c(%rbp), %rax
movq -0x28(%rbp), %rcx
movq 0x18(%rcx), %rcx
movq -0x18(%rbp), %rdx
subq %rdx, %rcx
cmpq %rcx, %rax
jle 0x99b0
movq -0x28(%rbp), %rax
movq 0x18(%rax), %rax
movq -0x18(%rbp), %rcx
subq %rcx, %rax
movl %eax, -0x2c(%rbp)
movl $0x0, -0x30(%rbp)
movl -0x30(%rbp), %eax
cmpl -0x2c(%rbp), %eax
jge 0x99f0
movq -0x40(%rbp), %rdi
addq $0x20, %rdi
movq -0x18(%rbp), %rax
movslq -0x30(%rbp), %rcx
movzbl (%rax,%rcx), %esi
callq 0xbde0
cmpl $0x0, %eax
jne 0x99e3
movl -0x30(%rbp), %eax
movl %eax, -0x2c(%rbp)
jmp 0x99e5
movl -0x30(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x30(%rbp)
jmp 0x99b7
movl $0x0, -0x34(%rbp)
movl -0x2c(%rbp), %ecx
movq -0x18(%rbp), %rax
movslq %ecx, %rcx
addq %rcx, %rax
movq %rax, -0x18(%rbp)
movq -0x40(%rbp), %rcx
movl -0x2c(%rbp), %eax
movl %eax, %edx
addl $-0x1, %edx
movl %edx, -0x2c(%rbp)
cmpl 0x18(%rcx), %eax
jl 0x9a7a
movq -0x40(%rbp), %rdi
movq -0x18(%rbp), %rsi
movq -0x20(%rbp), %rdx
movq -0x28(%rbp), %rcx
callq 0xbd70
movl %eax, %ecx
movl %ecx, -0x44(%rbp)
subl $0x1, %eax
je 0x9a63
jmp 0x9a3d
movl -0x44(%rbp), %eax
subl $0x2, %eax
je 0x9a51
jmp 0x9a47
movl -0x44(%rbp), %eax
subl $0x3, %eax
je 0x9a5a
jmp 0x9a6a
movl $0x2, -0x4(%rbp)
jmp 0x9a80
movl $0x3, -0x4(%rbp)
jmp 0x9a80
movl $0x1, -0x34(%rbp)
jmp 0x9a6c
movq -0x18(%rbp), %rax
addq $-0x1, %rax
movq %rax, -0x18(%rbp)
jmp 0x9a08
movl -0x34(%rbp), %eax
movl %eax, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x50, %rsp
popq %rbp
retq
nopl (%rax)
// File: arnoldrobbins[P]mcilroy-regex/re1.cpp
// Function: Class::icase(unsigned char*)
void Class::icase(uchar *map)
{
	if(map['A'] != map['a'])
		return;
	for(int i=0; i<256; i++)
		if(cl.in(i)) {
			cl.insert(toupper(i));
			cl.insert(tolower(i));
		}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x20(%rbp)
movq -0x10(%rbp), %rax
movzbl 0x41(%rax), %eax
movq -0x10(%rbp), %rcx
movzbl 0x61(%rcx), %ecx
cmpl %ecx, %eax
je 0x9b2e
jmp 0x9ba3
movl $0x0, -0x14(%rbp)
cmpl $0x100, -0x14(%rbp)     # imm = 0x100
jge 0x9ba3
movq -0x20(%rbp), %rdi
addq $0x20, %rdi
movl -0x14(%rbp), %eax
movzbl %al, %esi
callq 0xbde0
cmpl $0x0, %eax
je 0x9b96
movq -0x20(%rbp), %rax
addq $0x20, %rax
movq %rax, -0x30(%rbp)
movl -0x14(%rbp), %edi
callq 0x5300
movq -0x30(%rbp), %rdi
movzbl %al, %esi
callq 0x93a0
movq -0x20(%rbp), %rax
addq $0x20, %rax
movq %rax, -0x28(%rbp)
movl -0x14(%rbp), %edi
callq 0x5270
movq -0x28(%rbp), %rdi
movzbl %al, %esi
callq 0x93a0
jmp 0x9b98
movl -0x14(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x14(%rbp)
jmp 0x9b35
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax)
// File: arnoldrobbins[P]mcilroy-regex/re1.cpp
// Function: String::String(Seg, unsigned char*)
String::String(Seg s, uchar *map) : Rex(STRING), seg(s)
{
	uchar *p;
	if(map)
		for(p=seg.p; *p; p++)
			*p = map[*p];
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rsi, -0x10(%rbp)
movl %edx, -0x8(%rbp)
movq %rdi, -0x18(%rbp)
movq %rcx, -0x20(%rbp)
movq -0x18(%rbp), %rdi
movq %rdi, -0x30(%rbp)
movl $0x5, %esi
callq 0xbe30
movq -0x30(%rbp), %rax
leaq 0xcf3c(%rip), %rcx      # 0x16b20
addq $0x10, %rcx
movq %rcx, (%rax)
movq -0x10(%rbp), %rcx
movq %rcx, 0x18(%rax)
movq -0x8(%rbp), %rcx
movq %rcx, 0x20(%rax)
cmpq $0x0, -0x20(%rbp)
je 0x9c3b
movq -0x30(%rbp), %rax
movq 0x18(%rax), %rax
movq %rax, -0x28(%rbp)
movq -0x28(%rbp), %rax
cmpb $0x0, (%rax)
je 0x9c39
movq -0x20(%rbp), %rax
movq -0x28(%rbp), %rcx
movzbl (%rcx), %ecx
movb (%rax,%rcx), %cl
movq -0x28(%rbp), %rax
movb %cl, (%rax)
movq -0x28(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x28(%rbp)
jmp 0x9c0e
jmp 0x9c3b
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: arnoldrobbins[P]mcilroy-regex/re1.cpp
// Function: String::parse(unsigned char*, Rex*, Eenv*)
int String::parse(uchar *s, Rex *cont, Eenv *env)
{
	debug(STRING, "String", s);
	if(s+seg.n > env->last)
		return NONE;
	uchar *map = env->preg->map;
	uchar *p = seg.p;
	while(*p)
		if(map[*s++] != *p++)
			return NONE;
	return follow(s, cont, env);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movq %rcx, -0x28(%rbp)
movq -0x10(%rbp), %rcx
movq %rcx, -0x40(%rbp)
movq -0x18(%rbp), %rax
movslq 0x20(%rcx), %rcx
addq %rcx, %rax
movq -0x28(%rbp), %rcx
cmpq 0x18(%rcx), %rax
jbe 0x9c8e
movl $0x0, -0x4(%rbp)
jmp 0x9d06
movq -0x40(%rbp), %rax
movq -0x28(%rbp), %rcx
movq 0x8(%rcx), %rcx
movq 0x18(%rcx), %rcx
movq %rcx, -0x30(%rbp)
movq 0x18(%rax), %rax
movq %rax, -0x38(%rbp)
movq -0x38(%rbp), %rax
cmpb $0x0, (%rax)
je 0x9cee
movq -0x30(%rbp), %rax
movq -0x18(%rbp), %rcx
movq %rcx, %rdx
addq $0x1, %rdx
movq %rdx, -0x18(%rbp)
movzbl (%rcx), %ecx
movzbl (%rax,%rcx), %eax
movq -0x38(%rbp), %rcx
movq %rcx, %rdx
addq $0x1, %rdx
movq %rdx, -0x38(%rbp)
movzbl (%rcx), %ecx
cmpl %ecx, %eax
je 0x9cec
movl $0x0, -0x4(%rbp)
jmp 0x9d06
jmp 0x9caa
movq -0x40(%rbp), %rdi
movq -0x18(%rbp), %rsi
movq -0x20(%rbp), %rdx
movq -0x28(%rbp), %rcx
callq 0xbd70
movl %eax, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x40, %rsp
popq %rbp
retq
nop
// File: arnoldrobbins[P]mcilroy-regex/re1.cpp
// Function: Kmp::Kmp(Seg, int*)
Kmp::Kmp(Seg seg, int *flags) : String(seg)
{
	type = KMP;
	if(fail.assure(seg.n)) {
		*flags |= SPACE;
		return;
	}
	int q, k ;
	fail[0] = k = -1;
	for(q=1; q<seg.n; q++) {
		while(k>=0 && seg.p[k+1] != seg.p[q])
			k = fail[k];
		if(seg.p[k+1] == seg.p[q])
			k++;
		fail[q] = k;
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x90, %rsp
movq %rsi, -0x10(%rbp)
movl %edx, -0x8(%rbp)
movq %rdi, -0x18(%rbp)
movq %rcx, -0x20(%rbp)
movq -0x18(%rbp), %rdi
movq %rdi, -0x58(%rbp)
movups -0x10(%rbp), %xmm0
movaps %xmm0, -0x30(%rbp)
movq -0x30(%rbp), %rsi
movl -0x28(%rbp), %edx
xorl %eax, %eax
movl %eax, %ecx
callq 0x9bb0
movq -0x58(%rbp), %rdi
leaq 0xc91b(%rip), %rax      # 0x16670
movq %rax, (%rdi)
addq $0x28, %rdi
movq %rdi, -0x50(%rbp)
callq 0xbe60
jmp 0x9d67
movq -0x58(%rbp), %rdi
movb $0xe, 0x8(%rdi)
addq $0x28, %rdi
movl -0x8(%rbp), %esi
callq 0xbe80
movl %eax, -0x5c(%rbp)
jmp 0x9d80
movl -0x5c(%rbp), %eax
cmpl $0x0, %eax
je 0x9dc6
movq -0x20(%rbp), %rax
movl (%rax), %ecx
orl $0x400, %ecx            # imm = 0x400
movl %ecx, (%rax)
jmp 0x9ebe
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x38(%rbp)
movl %eax, -0x3c(%rbp)
jmp 0x9ec7
movq -0x50(%rbp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x38(%rbp)
movl %eax, -0x3c(%rbp)
callq 0xbee0
jmp 0x9ec7
movq -0x58(%rbp), %rdi
movl $0xffffffff, -0x44(%rbp) # imm = 0xFFFFFFFF
addq $0x28, %rdi
xorl %esi, %esi
callq 0xbec0
movq %rax, -0x68(%rbp)
jmp 0x9de2
movq -0x68(%rbp), %rax
movl $0xffffffff, (%rax)     # imm = 0xFFFFFFFF
movl $0x1, -0x40(%rbp)
movl -0x40(%rbp), %eax
cmpl -0x8(%rbp), %eax
jge 0x9ebe
jmp 0x9e01
xorl %eax, %eax
cmpl $0x0, -0x44(%rbp)
movb %al, -0x69(%rbp)
jl 0x9e31
movq -0x10(%rbp), %rax
movl -0x44(%rbp), %ecx
addl $0x1, %ecx
movslq %ecx, %rcx
movzbl (%rax,%rcx), %eax
movq -0x10(%rbp), %rcx
movslq -0x40(%rbp), %rdx
movzbl (%rcx,%rdx), %ecx
cmpl %ecx, %eax
setne %al
movb %al, -0x69(%rbp)
movb -0x69(%rbp), %al
testb $0x1, %al
jne 0x9e3a
jmp 0x9e5b
movq -0x58(%rbp), %rdi
addq $0x28, %rdi
movl -0x44(%rbp), %esi
callq 0xbec0
movq %rax, -0x78(%rbp)
jmp 0x9e50
movq -0x78(%rbp), %rax
movl (%rax), %eax
movl %eax, -0x44(%rbp)
jmp 0x9e01
movq -0x10(%rbp), %rax
movl -0x44(%rbp), %ecx
addl $0x1, %ecx
movslq %ecx, %rcx
movzbl (%rax,%rcx), %eax
movq -0x10(%rbp), %rcx
movslq -0x40(%rbp), %rdx
movzbl (%rcx,%rdx), %ecx
cmpl %ecx, %eax
jne 0x9e85
movl -0x44(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x44(%rbp)
movq -0x58(%rbp), %rdi
movl -0x44(%rbp), %eax
movl %eax, -0x84(%rbp)
addq $0x28, %rdi
movl -0x40(%rbp), %esi
callq 0xbec0
movq %rax, -0x80(%rbp)
jmp 0x9ea4
movq -0x80(%rbp), %rax
movl -0x84(%rbp), %ecx
movl %ecx, (%rax)
movl -0x40(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x40(%rbp)
jmp 0x9df3
addq $0x90, %rsp
popq %rbp
retq
movq -0x58(%rbp), %rdi
callq 0xbf30
movq -0x38(%rbp), %rdi
callq 0x52d0
nopl (%rax)
// File: arnoldrobbins[P]mcilroy-regex/re1.cpp
// Function: Trie::parse(unsigned char*, Rex*, Eenv*)
int Trie::parse(uchar *s, Rex *contin, Eenv *env)
{
	Tnode *node = root[env->preg->map[*s]&MASK];
	if(node==0 || s+min>env->last)
		return NONE;
	return parse(node, s, contin, env);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movq %rcx, -0x28(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x38(%rbp)
movq -0x28(%rbp), %rcx
movq 0x8(%rcx), %rcx
movq 0x18(%rcx), %rcx
movq -0x18(%rbp), %rdx
movzbl (%rdx), %edx
movzbl (%rcx,%rdx), %ecx
andl $0xff, %ecx
movslq %ecx, %rcx
movq 0x20(%rax,%rcx,8), %rax
movq %rax, -0x30(%rbp)
cmpq $0x0, -0x30(%rbp)
je 0xa129
movq -0x38(%rbp), %rcx
movq -0x18(%rbp), %rax
movslq 0x18(%rcx), %rcx
addq %rcx, %rax
movq -0x28(%rbp), %rcx
cmpq 0x18(%rcx), %rax
jbe 0xa132
movl $0x0, -0x4(%rbp)
jmp 0xa14e
movq -0x38(%rbp), %rdi
movq -0x30(%rbp), %rsi
movq -0x18(%rbp), %rdx
movq -0x20(%rbp), %rcx
movq -0x28(%rbp), %r8
callq 0xa160
movl %eax, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x40, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: arnoldrobbins[P]mcilroy-regex/re1.cpp
// Function: Trie::parse(Trie::Tnode*, unsigned char*, Rex*, Eenv*)
int Trie::parse(Tnode *node, uchar *s, Rex* contin, Eenv *env)
{
	debug(TRIE, "Trie", s);
	uchar *map = env->preg->map;
	for(;;) {
		if(s >= env->last)
			return NONE;
		while(node->c != map[*s]) {
			node = node->sib;
			if(node == 0)
				return NONE;
		}
		if(node->end)
			break;
		node = node->son;
		s++;
	}
	int longresult = NONE;
	if(node->son)
		longresult = parse(node->son, s+1, contin, env);
	if(longresult==BEST || longresult==BAD)
		return longresult;
	int shortresult = follow(s+1, contin, env);
	return shortresult==NONE? longresult: shortresult;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movq %rcx, -0x28(%rbp)
movq %r8, -0x30(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x48(%rbp)
movq -0x30(%rbp), %rax
movq 0x8(%rax), %rax
movq 0x18(%rax), %rax
movq %rax, -0x38(%rbp)
movq -0x20(%rbp), %rax
movq -0x30(%rbp), %rcx
cmpq 0x18(%rcx), %rax
jb 0xa1ae
movl $0x0, -0x4(%rbp)
jmp 0xa291
jmp 0xa1b0
movq -0x18(%rbp), %rax
movzbl (%rax), %eax
movq -0x38(%rbp), %rcx
movq -0x20(%rbp), %rdx
movzbl (%rdx), %edx
movzbl (%rcx,%rdx), %ecx
cmpl %ecx, %eax
je 0xa1eb
movq -0x18(%rbp), %rax
movq 0x10(%rax), %rax
movq %rax, -0x18(%rbp)
cmpq $0x0, -0x18(%rbp)
jne 0xa1e9
movl $0x0, -0x4(%rbp)
jmp 0xa291
jmp 0xa1b0
movq -0x18(%rbp), %rax
cmpb $0x0, 0x1(%rax)
je 0xa1f7
jmp 0xa211
movq -0x18(%rbp), %rax
movq 0x8(%rax), %rax
movq %rax, -0x18(%rbp)
movq -0x20(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x20(%rbp)
jmp 0xa194
movl $0x0, -0x3c(%rbp)
movq -0x18(%rbp), %rax
cmpq $0x0, 0x8(%rax)
je 0xa247
movq -0x48(%rbp), %rdi
movq -0x18(%rbp), %rax
movq 0x8(%rax), %rsi
movq -0x20(%rbp), %rdx
addq $0x1, %rdx
movq -0x28(%rbp), %rcx
movq -0x30(%rbp), %r8
callq 0xa160
movl %eax, -0x3c(%rbp)
cmpl $0x2, -0x3c(%rbp)
je 0xa253
cmpl $0x3, -0x3c(%rbp)
jne 0xa25b
movl -0x3c(%rbp), %eax
movl %eax, -0x4(%rbp)
jmp 0xa291
movq -0x48(%rbp), %rdi
movq -0x20(%rbp), %rsi
addq $0x1, %rsi
movq -0x28(%rbp), %rdx
movq -0x30(%rbp), %rcx
callq 0xbd70
movl %eax, -0x40(%rbp)
cmpl $0x0, -0x40(%rbp)
jne 0xa285
movl -0x3c(%rbp), %eax
movl %eax, -0x4c(%rbp)
jmp 0xa28b
movl -0x40(%rbp), %eax
movl %eax, -0x4c(%rbp)
movl -0x4c(%rbp), %eax
movl %eax, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x50, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: arnoldrobbins[P]mcilroy-regex/re1.cpp
// Function: Back::parse(unsigned char*, Rex*, Eenv*)
int Back::parse(uchar *s, Rex *cont, Eenv *env)
{
	regmatch_t &m = env->match[n];
	debug(BACK, "Back", s);
	if(m.rm_so < 0)
		return NONE;
	uchar *p = env->p + m.rm_so;
	long n = m.rm_eo - m.rm_so;
	if(s+n > env->last)
		return NONE;
	uchar *map = env->preg->map;
	while(--n >= 0)
		if(map[*s++] != map[*p++])
			return NONE;
	return follow(s, cont, env);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movq %rcx, -0x28(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x50(%rbp)
movq -0x28(%rbp), %rdi
addq $0x2c8, %rdi            # imm = 0x2C8
movl 0x18(%rax), %esi
callq 0xbf80
movq %rax, -0x30(%rbp)
movq -0x30(%rbp), %rax
cmpq $0x0, (%rax)
jge 0xa50d
movl $0x0, -0x4(%rbp)
jmp 0xa5cb
movq -0x28(%rbp), %rax
movq 0x10(%rax), %rax
movq -0x30(%rbp), %rcx
addq (%rcx), %rax
movq %rax, -0x38(%rbp)
movq -0x30(%rbp), %rax
movq 0x8(%rax), %rax
movq -0x30(%rbp), %rcx
subq (%rcx), %rax
movq %rax, -0x40(%rbp)
movq -0x18(%rbp), %rax
addq -0x40(%rbp), %rax
movq -0x28(%rbp), %rcx
cmpq 0x18(%rcx), %rax
jbe 0xa54e
movl $0x0, -0x4(%rbp)
jmp 0xa5cb
movq -0x28(%rbp), %rax
movq 0x8(%rax), %rax
movq 0x18(%rax), %rax
movq %rax, -0x48(%rbp)
movq -0x40(%rbp), %rax
addq $-0x1, %rax
movq %rax, -0x40(%rbp)
cmpq $0x0, %rax
jl 0xa5b3
movq -0x48(%rbp), %rax
movq -0x18(%rbp), %rcx
movq %rcx, %rdx
addq $0x1, %rdx
movq %rdx, -0x18(%rbp)
movzbl (%rcx), %ecx
movzbl (%rax,%rcx), %eax
movq -0x48(%rbp), %rcx
movq -0x38(%rbp), %rdx
movq %rdx, %rsi
addq $0x1, %rsi
movq %rsi, -0x38(%rbp)
movzbl (%rdx), %edx
movzbl (%rcx,%rdx), %ecx
cmpl %ecx, %eax
je 0xa5b1
movl $0x0, -0x4(%rbp)
jmp 0xa5cb
jmp 0xa55e
movq -0x50(%rbp), %rdi
movq -0x18(%rbp), %rsi
movq -0x20(%rbp), %rdx
movq -0x28(%rbp), %rcx
callq 0xbd70
movl %eax, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x50, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: arnoldrobbins[P]mcilroy-regex/re1.cpp
// Function: Subexp::parse(unsigned char*, Rex*, Eenv*)
int Subexp::parse(uchar *s, Rex *cont, Eenv *env)
{
	debug(SUBEXP, "Subexp", s);
	int result;
	regoff_t &so = env->match[n].rm_so;
	Subexp1 subexp1(this, cont);
	so = s - env->p;
	if(env->pushpos(this, s, BEGS))
		return BAD;
	result = rex->parse(s, &subexp1, env);
	env->poppos();
	so = -1;
	return result;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x90, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movq %rcx, -0x28(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x80(%rbp)
movq -0x28(%rbp), %rdi
addq $0x2c8, %rdi            # imm = 0x2C8
movswl 0x18(%rax), %esi
callq 0xbf80
movq -0x80(%rbp), %rsi
movq %rax, -0x38(%rbp)
movq -0x20(%rbp), %rdx
leaq -0x60(%rbp), %rdi
callq 0xbfd0
movq -0x80(%rbp), %rsi
movq -0x18(%rbp), %rcx
movq -0x28(%rbp), %rax
movq 0x10(%rax), %rax
subq %rax, %rcx
movq -0x38(%rbp), %rax
movq %rcx, (%rax)
movq -0x28(%rbp), %rdi
movq -0x18(%rbp), %rdx
movl $0x3, %ecx
callq 0x9260
movl %eax, -0x74(%rbp)
jmp 0xa65d
movl -0x74(%rbp), %eax
cmpl $0x0, %eax
je 0xa68c
movl $0x3, -0x4(%rbp)
movl $0x1, -0x70(%rbp)
jmp 0xa6dd
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x68(%rbp)
movl %eax, -0x6c(%rbp)
leaq -0x60(%rbp), %rdi
callq 0xc050
jmp 0xa6f2
movq -0x80(%rbp), %rax
movq 0x20(%rax), %rdi
movq -0x18(%rbp), %rsi
movq -0x28(%rbp), %rcx
movq (%rdi), %rax
movq 0x20(%rax), %rax
leaq -0x60(%rbp), %rdx
callq *%rax
movl %eax, -0x84(%rbp)
jmp 0xa6b1
movl -0x84(%rbp), %eax
movl %eax, -0x2c(%rbp)
movq -0x28(%rbp), %rdi
callq 0xc030
jmp 0xa6c5
movq -0x38(%rbp), %rax
movq $-0x1, (%rax)
movl -0x2c(%rbp), %eax
movl %eax, -0x4(%rbp)
movl $0x1, -0x70(%rbp)
leaq -0x60(%rbp), %rdi
callq 0xc050
movl -0x4(%rbp), %eax
addq $0x90, %rsp
popq %rbp
retq
movq -0x68(%rbp), %rdi
callq 0x52d0
nopl (%rax,%rax)
// File: arnoldrobbins[P]mcilroy-regex/re1.cpp
// Function: Subexp1::parse(unsigned char*, Rex*, Eenv*)
int Subexp1::parse(uchar *s, Rex*, Eenv *env)
{
	debug(SUBEXP, "Subexp1", s);
	int result;
	regoff_t &eo = env->match[ref->n].rm_eo;
	eo = s - env->p;
	if(env->pushpos(ref, s, ENDP))
		return BAD;
	result = follow(s, cont, env);
	env->poppos();
	eo = -1;
	return result;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movq %rcx, -0x28(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x40(%rbp)
movq -0x28(%rbp), %rdi
addq $0x2c8, %rdi            # imm = 0x2C8
movq 0x20(%rax), %rax
movswl 0x18(%rax), %esi
callq 0xbf80
movq %rax, %rcx
movq -0x40(%rbp), %rax
addq $0x8, %rcx
movq %rcx, -0x38(%rbp)
movq -0x18(%rbp), %rdx
movq -0x28(%rbp), %rcx
movq 0x10(%rcx), %rcx
subq %rcx, %rdx
movq -0x38(%rbp), %rcx
movq %rdx, (%rcx)
movq -0x28(%rbp), %rdi
movq 0x20(%rax), %rsi
movq -0x18(%rbp), %rdx
movl $0x4, %ecx
callq 0x9260
cmpl $0x0, %eax
je 0xa781
movl $0x3, -0x4(%rbp)
jmp 0xa7b3
movq -0x40(%rbp), %rdi
movq -0x18(%rbp), %rsi
movq 0x18(%rdi), %rdx
movq -0x28(%rbp), %rcx
callq 0xbd70
movl %eax, -0x2c(%rbp)
movq -0x28(%rbp), %rdi
callq 0xc030
movq -0x38(%rbp), %rax
movq $-0x1, (%rax)
movl -0x2c(%rbp), %eax
movl %eax, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x40, %rsp
popq %rbp
retq
nopl (%rax)
// File: arnoldrobbins[P]mcilroy-regex/re1.cpp
// Function: Save::Save(int, int, Eenv*)
Save::Save(int n1, int nn2, Eenv *env) : n1(n1), n2(nn2)
{
	regmatch_t *match = &env->match[0];
	if(n1 != 0) {
		int i = n2 - n1;
		if(area.assure(i)) {
			env->flags |= SPACE;
			n2 = n1;
			return;
		}
		regmatch_t *a = &area[0];
		match += n1;
		do {
			*a++ = *match;
			*match++ = NOMATCH;
		} while(--i >= 0);
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x60, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movl %edx, -0x10(%rbp)
movq %rcx, -0x18(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x50(%rbp)
movl -0xc(%rbp), %eax
movl %eax, (%rdi)
movl -0x10(%rbp), %eax
movl %eax, 0x4(%rdi)
addq $0x8, %rdi
movq %rdi, -0x48(%rbp)
callq 0xc070
movq -0x18(%rbp), %rdi
addq $0x2c8, %rdi            # imm = 0x2C8
xorl %esi, %esi
callq 0xbf80
movq %rax, -0x40(%rbp)
jmp 0xa80e
movq -0x40(%rbp), %rax
movq %rax, -0x20(%rbp)
cmpl $0x0, -0xc(%rbp)
je 0xa906
movq -0x50(%rbp), %rdi
movl 0x4(%rdi), %eax
movl -0xc(%rbp), %ecx
subl %ecx, %eax
movl %eax, -0x30(%rbp)
addq $0x8, %rdi
movl -0x30(%rbp), %esi
callq 0xc090
movl %eax, -0x54(%rbp)
jmp 0xa840
movl -0x54(%rbp), %eax
cmpl $0x0, %eax
je 0xa87f
movq -0x50(%rbp), %rax
movq -0x18(%rbp), %rcx
movl (%rcx), %edx
orl $0x400, %edx            # imm = 0x400
movl %edx, (%rcx)
movl -0xc(%rbp), %ecx
movl %ecx, 0x4(%rax)
jmp 0xa906
movq -0x48(%rbp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x28(%rbp)
movl %eax, -0x2c(%rbp)
callq 0xc0d0
jmp 0xa90c
movq -0x50(%rbp), %rdi
addq $0x8, %rdi
xorl %esi, %esi
callq 0xbf80
movq %rax, -0x60(%rbp)
jmp 0xa894
movq -0x60(%rbp), %rax
movq %rax, -0x38(%rbp)
movl -0xc(%rbp), %ecx
movq -0x20(%rbp), %rax
movslq %ecx, %rcx
shlq $0x4, %rcx
addq %rcx, %rax
movq %rax, -0x20(%rbp)
movq -0x20(%rbp), %rcx
movq -0x38(%rbp), %rax
movq %rax, %rdx
addq $0x10, %rdx
movq %rdx, -0x38(%rbp)
movq (%rcx), %rdx
movq %rdx, (%rax)
movq 0x8(%rcx), %rcx
movq %rcx, 0x8(%rax)
movq -0x20(%rbp), %rax
movq %rax, %rcx
addq $0x10, %rcx
movq %rcx, -0x20(%rbp)
movq 0xd1e8(%rip), %rcx      # 0x17ad0
movq %rcx, (%rax)
movq 0xd1e6(%rip), %rcx      # 0x17ad8
movq %rcx, 0x8(%rax)
movl -0x30(%rbp), %eax
addl $-0x1, %eax
movl %eax, -0x30(%rbp)
cmpl $0x0, %eax
jge 0xa8b1
jmp 0xa906
addq $0x60, %rsp
popq %rbp
retq
movq -0x28(%rbp), %rdi
callq 0x52d0
nopw %cs:(%rax,%rax)
// File: arnoldrobbins[P]mcilroy-regex/re1.cpp
// Function: Save::restore(Eenv*)
void Save::restore(Eenv *env)
{
	regmatch_t *match = &env->match[0];
	if(n1 != 0) {
		int i = n2 - n1;
		match += n1;
		regmatch_t *a = &area[0];
		do {
			*match++ = *a++;
		} while(--i >= 0);
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x30(%rbp)
movq -0x10(%rbp), %rdi
addq $0x2c8, %rdi            # imm = 0x2C8
xorl %esi, %esi
callq 0xbf80
movq %rax, %rcx
movq -0x30(%rbp), %rax
movq %rcx, -0x18(%rbp)
cmpl $0x0, (%rax)
je 0xa9c5
movq -0x30(%rbp), %rdi
movl 0x4(%rdi), %eax
subl (%rdi), %eax
movl %eax, -0x1c(%rbp)
movl (%rdi), %ecx
movq -0x18(%rbp), %rax
movslq %ecx, %rcx
shlq $0x4, %rcx
addq %rcx, %rax
movq %rax, -0x18(%rbp)
addq $0x8, %rdi
xorl %esi, %esi
callq 0xbf80
movq %rax, -0x28(%rbp)
movq -0x28(%rbp), %rcx
movq %rcx, %rax
addq $0x10, %rax
movq %rax, -0x28(%rbp)
movq -0x18(%rbp), %rax
movq %rax, %rdx
addq $0x10, %rdx
movq %rdx, -0x18(%rbp)
movq (%rcx), %rdx
movq %rdx, (%rax)
movq 0x8(%rcx), %rcx
movq %rcx, 0x8(%rax)
movl -0x1c(%rbp), %eax
addl $-0x1, %eax
movl %eax, -0x1c(%rbp)
cmpl $0x0, %eax
jge 0xa989
jmp 0xa9c5
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: arnoldrobbins[P]mcilroy-regex/re1.cpp
// Function: Alt1::parse(unsigned char*, Rex*, Eenv*)
int Alt1::parse(uchar *s, Rex*, Eenv *env)
{
	if(env->pushpos(this, s, ENDP))
		return BAD;
	int result = follow(s, cont, env);
	env->poppos();
	return result;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movq %rcx, -0x28(%rbp)
movq -0x10(%rbp), %rsi
movq %rsi, -0x38(%rbp)
movq -0x28(%rbp), %rdi
movq -0x18(%rbp), %rdx
movl $0x4, %ecx
callq 0x9260
cmpl $0x0, %eax
je 0xac80
movl $0x3, -0x4(%rbp)
jmp 0xaca7
movq -0x38(%rbp), %rdi
movq -0x18(%rbp), %rsi
movq 0x18(%rdi), %rdx
movq -0x28(%rbp), %rcx
callq 0xbd70
movl %eax, -0x2c(%rbp)
movq -0x28(%rbp), %rdi
callq 0xc030
movl -0x2c(%rbp), %eax
movl %eax, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x40, %rsp
popq %rbp
retq
// File: arnoldrobbins[P]mcilroy-regex/re1.cpp
// Function: Rep1::parse(unsigned char*, Rex*, Eenv*)
int Rep1::parse(uchar *s, Rex*, Eenv *env)
{
	int result;
	debug(REP, "Rep1", s);
	if(env->pushpos(this, s, ENDP))	// end BEGI
		return BAD;
	if(s==p1 && n>ref->lo)		// optional empty iteration
		if(env->flags&REG_EXTENDED || (env->flags&HARD) == 0)
			result = NONE;	// unwanted
		else if(env->pushpos(this, s, ENDP))	// end BEGR
				return BAD;
		else {
			result = follow(s, cont, env);
			env->poppos();
		}
	else
		result = ref->dorep(n, s, cont, env);
	env->poppos();
	return result;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movq %rcx, -0x28(%rbp)
movq -0x10(%rbp), %rsi
movq %rsi, -0x38(%rbp)
movq -0x28(%rbp), %rdi
movq -0x18(%rbp), %rdx
movl $0x4, %ecx
callq 0x9260
cmpl $0x0, %eax
je 0xb0f3
movl $0x3, -0x4(%rbp)
jmp 0xb1b3
movq -0x38(%rbp), %rcx
movq -0x18(%rbp), %rax
cmpq 0x20(%rcx), %rax
jne 0xb185
movq -0x38(%rbp), %rcx
movl 0x28(%rcx), %eax
movq 0x18(%rcx), %rcx
cmpl 0x18(%rcx), %eax
jle 0xb185
movq -0x28(%rbp), %rax
movl (%rax), %eax
andl $0x1, %eax
cmpl $0x0, %eax
jne 0xb133
movq -0x28(%rbp), %rax
movl (%rax), %eax
andl $0x800, %eax            # imm = 0x800
cmpl $0x0, %eax
jne 0xb13c
movl $0x0, -0x2c(%rbp)
jmp 0xb183
movq -0x38(%rbp), %rsi
movq -0x28(%rbp), %rdi
movq -0x18(%rbp), %rdx
movl $0x4, %ecx
callq 0x9260
cmpl $0x0, %eax
je 0xb160
movl $0x3, -0x4(%rbp)
jmp 0xb1b3
movq -0x38(%rbp), %rdi
movq -0x18(%rbp), %rsi
movq 0x30(%rdi), %rdx
movq -0x28(%rbp), %rcx
callq 0xbd70
movl %eax, -0x2c(%rbp)
movq -0x28(%rbp), %rdi
callq 0xc030
jmp 0xb183
jmp 0xb1a4
movq -0x38(%rbp), %rax
movq 0x18(%rax), %rdi
movl 0x28(%rax), %esi
movq -0x18(%rbp), %rdx
movq 0x30(%rax), %rcx
movq -0x28(%rbp), %r8
callq 0xae50
movl %eax, -0x2c(%rbp)
movq -0x28(%rbp), %rdi
callq 0xc030
movl -0x2c(%rbp), %eax
movl %eax, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x40, %rsp
popq %rbp
retq
nopl (%rax)
// File: arnoldrobbins[P]mcilroy-regex/re1.cpp
// Function: Rep::parse(unsigned char*, Rex*, Eenv*)
int Rep::parse(uchar *s, Rex *cont, Eenv *env)
{
	debug(REP, "Rep", s);
	if(env->pushpos(this, s, BEGR))
		return BAD;
	int result = dorep(0, s, cont, env);
	env->poppos();
	return result;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movq %rcx, -0x28(%rbp)
movq -0x10(%rbp), %rsi
movq %rsi, -0x38(%rbp)
movq -0x28(%rbp), %rdi
movq -0x18(%rbp), %rdx
xorl %ecx, %ecx
callq 0x9260
cmpl $0x0, %eax
je 0xb1fd
movl $0x3, -0x4(%rbp)
jmp 0xb226
movq -0x38(%rbp), %rdi
movq -0x18(%rbp), %rdx
movq -0x20(%rbp), %rcx
movq -0x28(%rbp), %r8
xorl %esi, %esi
callq 0xae50
movl %eax, -0x2c(%rbp)
movq -0x28(%rbp), %rdi
callq 0xc030
movl -0x2c(%rbp), %eax
movl %eax, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x40, %rsp
popq %rbp
retq
nop
// File: arnoldrobbins[P]mcilroy-regex/re1.cpp
// Function: Neg::parse(unsigned char*, Rex*, Eenv*)
int Neg::parse(uchar *s, Rex *cont, Eenv *env)
{
	debug(NEG, "Neg", s);
	int n = env->last - s;
	Neg1 neg1(s, n);
	if(rex->parse(s, &neg1, env) == BAD)
		return BAD;
	int result = NONE;
	for( ; n>=0; n--) {
		if(neg1.bittest(n))
			continue;
		int res1 = follow(s+n, cont, env);
		if(res1==BAD || res1==BEST)
			return res1;
		if(res1 == GOOD)
			result = GOOD;
	}
	return result;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0xb0, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movq %rcx, -0x28(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0xa0(%rbp)
movq -0x28(%rbp), %rax
movl 0x18(%rax), %eax
movl -0x18(%rbp), %ecx
subl %ecx, %eax
movl %eax, -0x2c(%rbp)
movq -0x18(%rbp), %rsi
movl -0x2c(%rbp), %edx
leaq -0x70(%rbp), %rdi
movq %rdi, -0x98(%rbp)
callq 0xb3c0
movq -0xa0(%rbp), %rax
movq -0x98(%rbp), %rdx
movq 0x18(%rax), %rdi
movq -0x18(%rbp), %rsi
movq -0x28(%rbp), %rcx
movq (%rdi), %rax
movq 0x20(%rax), %rax
callq *%rax
movl %eax, -0x8c(%rbp)
jmp 0xb2a7
movl -0x8c(%rbp), %eax
cmpl $0x3, %eax
jne 0xb2df
movl $0x3, -0x4(%rbp)
movl $0x1, -0x80(%rbp)
jmp 0xb39e
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x78(%rbp)
movl %eax, -0x7c(%rbp)
leaq -0x70(%rbp), %rdi
callq 0xc390
jmp 0xb3b3
movl $0x0, -0x84(%rbp)
cmpl $0x0, -0x2c(%rbp)
jl 0xb38e
movl -0x2c(%rbp), %esi
leaq -0x70(%rbp), %rdi
callq 0xc340
movl %eax, -0xa4(%rbp)
jmp 0xb307
movl -0xa4(%rbp), %eax
cmpl $0x0, %eax
je 0xb314
jmp 0xb380
movq -0xa0(%rbp), %rdi
movq -0x18(%rbp), %rsi
movslq -0x2c(%rbp), %rax
addq %rax, %rsi
movq -0x20(%rbp), %rdx
movq -0x28(%rbp), %rcx
callq 0xbd70
movl %eax, -0xa8(%rbp)
jmp 0xb33b
movl -0xa8(%rbp), %eax
movl %eax, -0x88(%rbp)
cmpl $0x3, -0x88(%rbp)
je 0xb359
cmpl $0x2, -0x88(%rbp)
jne 0xb36b
movl -0x88(%rbp), %eax
movl %eax, -0x4(%rbp)
movl $0x1, -0x80(%rbp)
jmp 0xb39e
cmpl $0x1, -0x88(%rbp)
jne 0xb37e
movl $0x1, -0x84(%rbp)
jmp 0xb380
movl -0x2c(%rbp), %eax
addl $-0x1, %eax
movl %eax, -0x2c(%rbp)
jmp 0xb2e9
movl -0x84(%rbp), %eax
movl %eax, -0x4(%rbp)
movl $0x1, -0x80(%rbp)
leaq -0x70(%rbp), %rdi
callq 0xc390
movl -0x4(%rbp), %eax
addq $0xb0, %rsp
popq %rbp
retq
movq -0x78(%rbp), %rdi
callq 0x52d0
nopl (%rax)
// File: arnoldrobbins[P]mcilroy-regex/re1.cpp
// Function: better(Pos*, Pos*, Pos*, Pos*)
static int better(Pos *os, Pos *ns, Pos *oend, Pos *nend)
{
	Pos *oe, *ne;
	int k;
	for( ; os<oend && ns<nend; os=oe+1, ns=ne+1) {
		if(ns->serial > os->serial)
			return -1;
		if(os->serial > ns->serial)
			abort();	// folk theorem bites the dust
		if(os->p > ns->p)
			return -1;
		if(ns->p > os->p)
			return 1;	// believed impossible
		oe = rpos(os);
		ne = rpos(ns);
		if(ne->p > oe->p)
			return 1;
		if(oe->p > ne->p)
			return -1;
		k = better(os+1, ns+1, oe, ne);
		if(k)
			return k;
	}
	if(ns < nend)
		abort();		// another one bites the dust
	return os < oend;		// true => inessential null
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movq %rcx, -0x28(%rbp)
movq -0x10(%rbp), %rcx
xorl %eax, %eax
cmpq -0x20(%rbp), %rcx
movb %al, -0x3d(%rbp)
jae 0xb7e5
movq -0x18(%rbp), %rax
cmpq -0x28(%rbp), %rax
setb %al
movb %al, -0x3d(%rbp)
movb -0x3d(%rbp), %al
testb $0x1, %al
jne 0xb7f1
jmp 0xb8fe
movq -0x18(%rbp), %rax
movswl 0x8(%rax), %eax
movq -0x10(%rbp), %rcx
movswl 0x8(%rcx), %ecx
cmpl %ecx, %eax
jle 0xb811
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
jmp 0xb920
movq -0x10(%rbp), %rax
movswl 0x8(%rax), %eax
movq -0x18(%rbp), %rcx
movswl 0x8(%rcx), %ecx
cmpl %ecx, %eax
jle 0xb82a
callq 0x5120
movq -0x10(%rbp), %rax
movq (%rax), %rax
movq -0x18(%rbp), %rcx
cmpq (%rcx), %rax
jbe 0xb846
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
jmp 0xb920
movq -0x18(%rbp), %rax
movq (%rax), %rax
movq -0x10(%rbp), %rcx
cmpq (%rcx), %rax
jbe 0xb862
movl $0x1, -0x4(%rbp)
jmp 0xb920
movq -0x10(%rbp), %rdi
callq 0xbc70
movq %rax, -0x30(%rbp)
movq -0x18(%rbp), %rdi
callq 0xbc70
movq %rax, -0x38(%rbp)
movq -0x38(%rbp), %rax
movq (%rax), %rax
movq -0x30(%rbp), %rcx
cmpq (%rcx), %rax
jbe 0xb898
movl $0x1, -0x4(%rbp)
jmp 0xb920
movq -0x30(%rbp), %rax
movq (%rax), %rax
movq -0x38(%rbp), %rcx
cmpq (%rcx), %rax
jbe 0xb8b1
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
jmp 0xb920
movq -0x10(%rbp), %rdi
addq $0x10, %rdi
movq -0x18(%rbp), %rsi
addq $0x10, %rsi
movq -0x30(%rbp), %rdx
movq -0x38(%rbp), %rcx
callq 0xb7b0
movl %eax, -0x3c(%rbp)
cmpl $0x0, -0x3c(%rbp)
je 0xb8df
movl -0x3c(%rbp), %eax
movl %eax, -0x4(%rbp)
jmp 0xb920
jmp 0xb8e1
movq -0x30(%rbp), %rax
addq $0x10, %rax
movq %rax, -0x10(%rbp)
movq -0x38(%rbp), %rax
addq $0x10, %rax
movq %rax, -0x18(%rbp)
jmp 0xb7c8
movq -0x18(%rbp), %rax
cmpq -0x28(%rbp), %rax
jae 0xb90d
callq 0x5120
movq -0x10(%rbp), %rax
cmpq -0x20(%rbp), %rax
setb %al
andb $0x1, %al
movzbl %al, %eax
movl %eax, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x40, %rsp
popq %rbp
retq
nopl (%rax)
// File: arnoldrobbins[P]mcilroy-regex/re1.cpp
// Function: regexec
int regexec(const regex_t *preg, const char *string, size_t nmatch,
	    regmatch_t *match, int eflags)
{
	const char *s = string;
	while(*s)
		s++;
	return regnexec(preg, string, s-string, nmatch, match, eflags);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq %rcx, -0x20(%rbp)
movl %r8d, -0x24(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x30(%rbp)
movq -0x30(%rbp), %rax
cmpb $0x0, (%rax)
je 0xbc3b
movq -0x30(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x30(%rbp)
jmp 0xbc24
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
movq -0x30(%rbp), %rdx
movq -0x10(%rbp), %rax
subq %rax, %rdx
movq -0x18(%rbp), %rcx
movq -0x20(%rbp), %r8
movl -0x24(%rbp), %r9d
callq 0xb930
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: arnoldrobbins[P]mcilroy-regex/re1.cpp
// Function: rpos(Pos*)
static Pos *rpos(Pos *a)	/* find matching right pos record */
{
	int serial = a->serial;
	int inner;
	for(inner=0;;) {
		if((++a)->serial != serial)
			continue;
		if(a->be != ENDP)
			inner++;
		else if(inner-- <= 0)
			return a;
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movswl 0x8(%rax), %eax
movl %eax, -0xc(%rbp)
movl $0x0, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq %rax, %rcx
addq $0x10, %rcx
movq %rcx, -0x8(%rbp)
movswl 0x18(%rax), %eax
cmpl -0xc(%rbp), %eax
je 0xbca4
jmp 0xbc8a
movq -0x8(%rbp), %rax
movzbl 0xa(%rax), %eax
cmpl $0x4, %eax
je 0xbcbc
movl -0x10(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x10(%rbp)
jmp 0xbcd4
movl -0x10(%rbp), %eax
movl %eax, %ecx
addl $-0x1, %ecx
movl %ecx, -0x10(%rbp)
cmpl $0x0, %eax
jg 0xbcd2
movq -0x8(%rbp), %rax
popq %rbp
retq
jmp 0xbcd4
jmp 0xbc8a
nopw %cs:(%rax,%rax)
// File: arnoldrobbins[P]mcilroy-regex/re1.cpp
// Function: Eenv::Eenv(regex_t const*, int, unsigned char*, unsigned long)
inline
Eenv::Eenv(const regex_t *preg, int eflags, uchar *string, size_t len) :
	preg(preg), p(string), last(string+len),
	flags((eflags&EFLAGS) | preg->flags)
{
	int n = preg->re_nsub;
	if(match.assure(n) || best.assure(n)) {
		flags |= SPACE;
		return;
	}
	npos = nbestpos = 0;
	best[0].rm_so = 0;
	best[0].rm_eo = -1;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x80, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl %edx, -0x14(%rbp)
movq %rcx, -0x20(%rbp)
movq %r8, -0x28(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x48(%rbp)
movl -0x14(%rbp), %eax
andl $0x30, %eax
movq -0x10(%rbp), %rcx
movl 0x10(%rcx), %ecx
orl %ecx, %eax
movl %eax, (%rdi)
movq -0x10(%rbp), %rax
movq %rax, 0x8(%rdi)
movq -0x20(%rbp), %rax
movq %rax, 0x10(%rdi)
movq -0x20(%rbp), %rax
movq -0x28(%rbp), %rcx
addq %rcx, %rax
movq %rax, 0x18(%rdi)
addq $0x28, %rdi
movq %rdi, -0x50(%rbp)
callq 0xcae0
movq -0x48(%rbp), %rdi
addq $0x178, %rdi            # imm = 0x178
movq %rdi, -0x40(%rbp)
callq 0xcae0
jmp 0xc549
movq -0x48(%rbp), %rdi
addq $0x2c8, %rdi            # imm = 0x2C8
movq %rdi, -0x58(%rbp)
callq 0xc070
jmp 0xc55f
movq -0x48(%rbp), %rdi
addq $0x418, %rdi            # imm = 0x418
movq %rdi, -0x60(%rbp)
callq 0xc070
jmp 0xc575
movq -0x48(%rbp), %rdi
movq -0x10(%rbp), %rax
movl (%rax), %eax
movl %eax, -0x38(%rbp)
addq $0x2c8, %rdi            # imm = 0x2C8
movl -0x38(%rbp), %esi
callq 0xc090
movl %eax, -0x64(%rbp)
jmp 0xc596
movl -0x64(%rbp), %eax
cmpl $0x0, %eax
jne 0xc5be
movq -0x48(%rbp), %rdi
addq $0x418, %rdi            # imm = 0x418
movl -0x38(%rbp), %esi
callq 0xc090
movl %eax, -0x68(%rbp)
jmp 0xc5b6
movl -0x68(%rbp), %eax
cmpl $0x0, %eax
je 0xc618
movq -0x48(%rbp), %rax
movl (%rax), %ecx
orl $0x400, %ecx            # imm = 0x400
movl %ecx, (%rax)
jmp 0xc66d
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x30(%rbp)
movl %eax, -0x34(%rbp)
jmp 0xc688
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x30(%rbp)
movl %eax, -0x34(%rbp)
jmp 0xc67f
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x30(%rbp)
movl %eax, -0x34(%rbp)
jmp 0xc676
movq -0x60(%rbp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x30(%rbp)
movl %eax, -0x34(%rbp)
callq 0xc0d0
jmp 0xc676
movq -0x48(%rbp), %rdi
movl $0x0, 0x24(%rdi)
movl $0x0, 0x20(%rdi)
addq $0x418, %rdi            # imm = 0x418
xorl %esi, %esi
callq 0xbf80
movq %rax, -0x70(%rbp)
jmp 0xc63e
movq -0x48(%rbp), %rdi
movq -0x70(%rbp), %rax
movq $0x0, (%rax)
addq $0x418, %rdi            # imm = 0x418
xorl %esi, %esi
callq 0xbf80
movq %rax, -0x78(%rbp)
jmp 0xc661
movq -0x78(%rbp), %rax
movq $-0x1, 0x8(%rax)
addq $0x80, %rsp
popq %rbp
retq
movq -0x58(%rbp), %rdi
callq 0xc0d0
movq -0x40(%rbp), %rdi
callq 0xcb00
movq -0x50(%rbp), %rdi
callq 0xcb00
movq -0x30(%rbp), %rdi
callq 0x52d0
nopw (%rax,%rax)
// File: arnoldrobbins[P]mcilroy-regex/./array.h
// Function: Array<Pos>::realloc(int)
int realloc(int i)	// when array must grow
	{
		i *= 2;
		T *q = new T[i];
		if(q == 0)
			return 1;
		memmove(q, p, size*sizeof(T));
		if(p != space)
			delete [] p;
		p = q;
		size = i;
		return 0;
	}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movl %esi, -0x14(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x28(%rbp)
movl -0x14(%rbp), %eax
shll %eax
movl %eax, -0x14(%rbp)
movslq -0x14(%rbp), %rax
movl $0x10, %ecx
mulq %rcx
movq %rax, %rdi
seto %cl
movq $-0x1, %rax
testb $0x1, %cl
cmovneq %rax, %rdi
callq 0x5030
movq %rax, -0x20(%rbp)
cmpq $0x0, -0x20(%rbp)
jne 0xcbc8
movl $0x1, -0x4(%rbp)
jmp 0xcc24
movq -0x28(%rbp), %rax
movq -0x20(%rbp), %rdi
movq (%rax), %rsi
movslq 0x8(%rax), %rdx
shlq $0x4, %rdx
callq 0x52b0
movq -0x28(%rbp), %rcx
movq (%rcx), %rax
addq $0x10, %rcx
cmpq %rcx, %rax
je 0xcc0c
movq -0x28(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x30(%rbp)
cmpq $0x0, %rax
je 0xcc0a
movq -0x30(%rbp), %rdi
callq 0x5210
jmp 0xcc0c
movq -0x28(%rbp), %rax
movq -0x20(%rbp), %rcx
movq %rcx, (%rax)
movl -0x14(%rbp), %ecx
movl %ecx, 0x8(%rax)
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax)
// File: arnoldrobbins[P]mcilroy-regex/re2.cpp
// Function: Cenv::Cenv(char const*, int)
Cenv::Cenv(const char *pattern, int cflags) : flags(cflags),
	parno(0), parnest(0), backref(0),
	cursor(Seg((uchar*)pattern, strlen(pattern)))
{
	if(fold[UCHAR_MAX] == 0)
		init();
	map = flags&REG_ICASE? fold: ident;

	retype = flags&REG_AUGMENTED? ARE:	// ARE=>ERE
		 flags&REG_EXTENDED? ERE:
		 BRE;
	posixkludge = retype == BRE;
	expr = cursor;
	memset(paren, 0, sizeof(paren));
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl %edx, -0x14(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x20(%rbp)
movl -0x14(%rbp), %ecx
movl %ecx, (%rax)
addq $0x8, %rax
movq %rax, -0x30(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x28(%rbp)
movq -0x10(%rbp), %rdi
callq 0x50d0
movq -0x30(%rbp), %rdi
movq -0x28(%rbp), %rsi
movl %eax, %edx
callq 0xbd40
movq -0x20(%rbp), %rdi
addq $0x18, %rdi
callq 0x10130
movq -0x20(%rbp), %rax
movl $0x0, 0x30(%rax)
movl $0x0, 0x34(%rax)
movw $0x0, 0x38(%rax)
movzbl 0xb53b(%rip), %eax      # 0x1840f
cmpl $0x0, %eax
jne 0xcede
callq 0xcf90
movq -0x20(%rbp), %rax
movl (%rax), %eax
andl $0x2, %eax
cmpl $0x0, %eax
je 0xcef9
leaq 0xb41d(%rip), %rax      # 0x18310
movq %rax, -0x38(%rbp)
jmp 0xcf06
leaq 0xb510(%rip), %rax      # 0x18410
movq %rax, -0x38(%rbp)
jmp 0xcf06
movq -0x20(%rbp), %rax
movq -0x38(%rbp), %rcx
movq %rcx, 0x28(%rax)
movl (%rax), %eax
andl $0x200, %eax            # imm = 0x200
cmpl $0x0, %eax
je 0xcf28
movl $0x2, %eax
movl %eax, -0x3c(%rbp)
jmp 0xcf41
movq -0x20(%rbp), %rax
movl (%rax), %edx
andl $0x1, %edx
xorl %eax, %eax
movl $0x1, %ecx
cmpl $0x0, %edx
cmovnel %ecx, %eax
movl %eax, -0x3c(%rbp)
movq -0x20(%rbp), %rdi
movl -0x3c(%rbp), %eax
movb %al, 0x3a(%rdi)
movzbl 0x3a(%rdi), %eax
cmpl $0x0, %eax
sete %al
andb $0x1, %al
movzbl %al, %eax
movl %eax, 0x48(%rdi)
movq 0x8(%rdi), %rax
movq %rax, 0x18(%rdi)
movl 0x10(%rdi), %eax
movl %eax, 0x20(%rdi)
addq $0x3b, %rdi
xorl %esi, %esi
movl $0xa, %edx
callq 0x5110
addq $0x40, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: arnoldrobbins[P]mcilroy-regex/re2.cpp
// Function: init()
static void
init()
{
	int i;
	for(i=0; (unsigned)i<elementsof(escape); i++)
		escindex[escape[i].key] = i;
	for(i=0; i<=UCHAR_MAX; i++) {
		ident[i] = i;
		fold[i] = toupper(i);
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
cmpq $0x19, %rax
jae 0xcfd9
movl -0x4(%rbp), %eax
movb %al, %dl
movslq -0x4(%rbp), %rcx
leaq 0xaf38(%rip), %rax      # 0x17ef0
imulq $0xe, %rcx, %rcx
addq %rcx, %rax
movzbl (%rax), %eax
movl %eax, %ecx
leaq 0xb585(%rip), %rax      # 0x18550
movb %dl, (%rax,%rcx)
movl -0x4(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x4(%rbp)
jmp 0xcf9f
movl $0x0, -0x4(%rbp)
cmpl $0xff, -0x4(%rbp)
jg 0xd01f
movl -0x4(%rbp), %eax
movb %al, %dl
movslq -0x4(%rbp), %rcx
leaq 0xb417(%rip), %rax      # 0x18410
movb %dl, (%rax,%rcx)
movl -0x4(%rbp), %edi
callq 0x5300
movb %al, %dl
movslq -0x4(%rbp), %rcx
leaq 0xb2ff(%rip), %rax      # 0x18310
movb %dl, (%rax,%rcx)
movl -0x4(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x4(%rbp)
jmp 0xcfe0
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: arnoldrobbins[P]mcilroy-regex/re2.cpp
// Function: NEWinit(Rex*, Cenv*)
Rex *NEWinit(Rex *rex, Cenv *env)
{
	if(cdebug)
		printnew(rex);
	if(env->flags&SPACE) {
		delete rex;
		return ERROR;
	} else
		return rex;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x18(%rbp), %rax
movl (%rax), %eax
andl $0x400, %eax            # imm = 0x400
cmpl $0x0, %eax
je 0xd075
movq -0x10(%rbp), %rax
movq %rax, -0x20(%rbp)
cmpq $0x0, %rax
je 0xd068
movq -0x20(%rbp), %rdi
movq (%rdi), %rax
callq *0x8(%rax)
movq 0xb4a1(%rip), %rax      # 0x18510
movq %rax, -0x8(%rbp)
jmp 0xd07d
movq -0x10(%rbp), %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x20, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: arnoldrobbins[P]mcilroy-regex/re2.cpp
// Function: addStat(Stat&, Rex*, Cenv*)
static Stat addStat(Stat &st1, Rex *rex, Cenv *env)
{
	if(rex == 0)
		return st1;
	Stat st2 = rex->stat(env);
	return addStat(st1, st2);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x60, %rsp
movq %rdi, -0x18(%rbp)
movq %rsi, -0x20(%rbp)
movq %rdx, -0x28(%rbp)
cmpq $0x0, -0x20(%rbp)
jne 0xd170
movq -0x18(%rbp), %rax
movq (%rax), %rcx
movq %rcx, -0x10(%rbp)
movq 0x8(%rax), %rax
movq %rax, -0x8(%rbp)
jmp 0xd1c4
movq -0x20(%rbp), %rdi
movq -0x28(%rbp), %rsi
movq (%rdi), %rax
movq 0x10(%rax), %rax
callq *%rax
movq %rdx, -0x40(%rbp)
movq %rax, -0x48(%rbp)
movq -0x48(%rbp), %rax
movq -0x42(%rbp), %rcx
movq %rcx, -0x32(%rbp)
movq %rax, -0x38(%rbp)
movq -0x18(%rbp), %rdi
leaq -0x38(%rbp), %rsi
callq 0xd520
movq %rdx, -0x50(%rbp)
movq %rax, -0x58(%rbp)
movq -0x58(%rbp), %rax
movq %rax, -0x10(%rbp)
movl -0x50(%rbp), %eax
movl %eax, -0x8(%rbp)
movw -0x4c(%rbp), %ax
movw %ax, -0x4(%rbp)
movq -0x10(%rbp), %rax
movq -0x8(%rbp), %rdx
addq $0x60, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: arnoldrobbins[P]mcilroy-regex/re2.cpp
// Function: Dup::stat(Cenv*)
Stat Dup::stat(Cenv *env)
{
	Stat st1;
	st1.n = lo;
	st1.s = st1.c = hi != lo;
	return addStat(st1, next, env);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movq %rdi, -0x18(%rbp)
movq %rsi, -0x20(%rbp)
movq -0x18(%rbp), %rax
movq %rax, -0x50(%rbp)
leaq -0x30(%rbp), %rdi
movq %rdi, -0x48(%rbp)
callq 0x10140
movq -0x50(%rbp), %rax
movq -0x48(%rbp), %rdi
movl 0x18(%rax), %ecx
movl %ecx, -0x30(%rbp)
movl 0x18(%rax), %edx
movl 0x1c(%rax), %ecx
subl %edx, %ecx
setne -0x2b(%rbp)
setne -0x2c(%rbp)
movq 0x10(%rax), %rsi
movq -0x20(%rbp), %rdx
callq 0xd140
movq %rdx, -0x38(%rbp)
movq %rax, -0x40(%rbp)
movq -0x40(%rbp), %rax
movq -0x3a(%rbp), %rcx
movq %rcx, -0xa(%rbp)
movq %rax, -0x10(%rbp)
movq -0x10(%rbp), %rax
movq -0x8(%rbp), %rdx
addq $0x50, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)