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

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

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

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rcx, %rbx
movq %rdx, %r14
movq %rsi, %r15
movq %rdi, %r12
movslq 0x1c(%rdi), %rax
movq 0x18(%rcx), %r13
subq %rsi, %r13
cmpq %rax, %r13
cmovgel %eax, %r13d
testb $0x8, (%rcx)
je 0x84d7
testl %r13d, %r13d
jle 0x84d7
xorl %eax, %eax
cmpb $0xa, (%r15,%rax)
cmovel %eax, %r13d
incq %rax
movslq %r13d, %rcx
cmpq %rcx, %rax
jl 0x84c3
xorl %eax, %eax
cmpl 0x18(%r12), %r13d
jl 0x8534
movslq %r13d, %rax
addq %rax, %r15
incl %r13d
xorl %ebp, %ebp
movq 0x10(%r12), %rdi
testq %rdi, %rdi
je 0x8500
movq (%rdi), %rax
movq %r15, %rsi
movq %r14, %rdx
jmp 0x850b
movq (%r14), %rax
movq %r14, %rdi
movq %r15, %rsi
xorl %edx, %edx
movq %rbx, %rcx
callq *0x20(%rax)
cmpl $0x1, %eax
je 0x8520
leal -0x2(%rax), %ecx
cmpl $0x2, %ecx
jae 0x8525
jmp 0x8534
movl $0x1, %ebp
decq %r15
decl %r13d
movl %ebp, %eax
cmpl 0x18(%r12), %r13d
jg 0x84eb
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/re1.cpp
// Function: Onechar::parse(unsigned char*, Rex*, Eenv*)
int Onechar::parse(uchar *s, Rex *cont, Eenv *env)
{
	debug(ONECHAR, "Onechar", s);
	int n = hi;
	uchar *map = env->preg->map;
	if(n > env->last-s)
		n = env->last-s;
	int i = 0;
	for( ; i<n; i++,s++)
		if(map[*s] != c)
			break;
	int result = NONE;
	for( ; i-->=lo; s--)
		switch(follow(s, cont, env)) {
		case BEST:
			return BEST;
		case BAD:
			return BAD;
		case GOOD:
			result = GOOD;
		}
	return result;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rcx, %rbx
movq %rdx, %r14
movq %rdi, %r15
movslq 0x1c(%rdi), %rax
movq 0x18(%rcx), %r13
subq %rsi, %r13
cmpq %rax, %r13
cmovgel %eax, %r13d
xorl %eax, %eax
testl %r13d, %r13d
jle 0x8598
movq 0x8(%rbx), %rcx
movq 0x18(%rcx), %rdx
movb 0x20(%r15), %dil
leaq (%rsi,%r13), %r12
xorl %ecx, %ecx
movzbl (%rsi,%rcx), %r8d
cmpb %dil, (%rdx,%r8)
jne 0x85a0
incq %rcx
cmpl %ecx, %r13d
jne 0x8583
jmp 0x85a9
movq %rsi, %r12
xorl %r13d, %r13d
jmp 0x85a9
addq %rcx, %rsi
movq %rsi, %r12
movl %ecx, %r13d
cmpl 0x18(%r15), %r13d
jl 0x85fb
incl %r13d
xorl %ebp, %ebp
movq 0x10(%r15), %rdi
testq %rdi, %rdi
je 0x85c8
movq (%rdi), %rax
movq %r12, %rsi
movq %r14, %rdx
jmp 0x85d3
movq (%r14), %rax
movq %r14, %rdi
movq %r12, %rsi
xorl %edx, %edx
movq %rbx, %rcx
callq *0x20(%rax)
cmpl $0x1, %eax
je 0x85e8
leal -0x2(%rax), %ecx
cmpl $0x2, %ecx
jae 0x85ed
jmp 0x85fb
movl $0x1, %ebp
decq %r12
decl %r13d
movl %ebp, %eax
cmpl 0x18(%r15), %r13d
jg 0x85b4
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/re1.cpp
// Function: Class::parse(unsigned char*, Rex*, Eenv*)
int Class::parse(uchar *s, Rex *cont, Eenv *env)
{
	debug(CLASS, "Class", s);
	int n = hi;
	if(n > env->last-s)
		n = env->last-s;
	for(int i=0; i<n; i++)
		if(!cl.in(s[i]))
			n = i;
	int result = NONE;
	for(s+=n; n-->=lo; s--)
		switch(follow(s, cont, env)) {
		case BEST:
			return BEST;
		case BAD:
			return BAD;
		case GOOD:
			result = GOOD;
		}
	return result;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rcx, %rbx
movq %rdx, %r14
movq %rsi, %r15
movq %rdi, %r12
movslq 0x1c(%rdi), %rax
movq 0x18(%rcx), %r13
subq %rsi, %r13
cmpq %rax, %r13
cmovgel %eax, %r13d
testl %r13d, %r13d
jle 0x865f
xorl %eax, %eax
movzbl (%r15,%rax), %ecx
movl %ecx, %edx
shrl $0x3, %edx
movzbl 0x20(%r12,%rdx), %edx
andl $0x7, %ecx
btl %ecx, %edx
cmovael %eax, %r13d
incq %rax
movslq %r13d, %rcx
cmpq %rcx, %rax
jl 0x863a
xorl %eax, %eax
cmpl 0x18(%r12), %r13d
jl 0x86bc
movslq %r13d, %rax
addq %rax, %r15
incl %r13d
xorl %ebp, %ebp
movq 0x10(%r12), %rdi
testq %rdi, %rdi
je 0x8688
movq (%rdi), %rax
movq %r15, %rsi
movq %r14, %rdx
jmp 0x8693
movq (%r14), %rax
movq %r14, %rdi
movq %r15, %rsi
xorl %edx, %edx
movq %rbx, %rcx
callq *0x20(%rax)
cmpl $0x1, %eax
je 0x86a8
leal -0x2(%rax), %ecx
cmpl $0x2, %ecx
jae 0x86ad
jmp 0x86bc
movl $0x1, %ebp
decq %r15
decl %r13d
movl %ebp, %eax
cmpl 0x18(%r12), %r13d
jg 0x8673
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/re1.cpp
// Function: Class::icase(unsigned char*)
void Class::icase(uchar *map)
{
	if(map['A'] != map['a'])
		return;
	for(int i=0; i<256; i++)
		if(cl.in(i)) {
			cl.insert(toupper(i));
			cl.insert(tolower(i));
		}
}

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

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

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movl %edx, %ebp
movq %rsi, %rbx
movq $0x0, 0x10(%rdi)
movq %rsi, 0x18(%rdi)
movl %edx, 0x20(%rdi)
leaq 0x9d72(%rip), %rax      # 0x125a8
movq %rax, (%rdi)
leaq 0x34(%rdi), %r13
movq %r13, 0x28(%rdi)
movl $0x14, 0x30(%rdi)
movb $0xe, 0x8(%rdi)
cmpl $0x14, %edx
jge 0x8860
movl $0xffffffff, (%r13)     # imm = 0xFFFFFFFF
cmpl $0x2, %ebp
jge 0x888b
jmp 0x88cb
movq %rcx, %r15
movq %rdi, %r14
leaq 0x28(%rdi), %r12
movq %r12, %rdi
movl %ebp, %esi
callq 0xa26c
testl %eax, %eax
je 0x887f
orb $0x4, 0x1(%r15)
jmp 0x88cb
movq (%r12), %r13
movl $0xffffffff, (%r13)     # imm = 0xFFFFFFFF
movl %ebp, %eax
movl $0xffffffff, %edx       # imm = 0xFFFFFFFF
movl $0x1, %ecx
movb (%rbx,%rcx), %sil
testl %edx, %edx
js 0x88af
movl %edx, %edi
cmpb %sil, 0x1(%rbx,%rdi)
je 0x88af
movl (%r13,%rdi,4), %edx
jmp 0x889b
movslq %edx, %rdx
leaq 0x1(%rdx), %rdi
cmpb %sil, 0x1(%rbx,%rdx)
cmovel %edi, %edx
movl %edx, (%r13,%rcx,4)
incq %rcx
cmpq %rax, %rcx
jne 0x8897
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
movq (%r12), %rdi
cmpq %r13, %rdi
sete %al
testq %rdi, %rdi
sete %cl
orb %al, %cl
jne 0x88f6
callq 0x5200
movq %r14, %rdi
callq 0x9bec
movq %rbx, %rdi
callq 0x52b0
// File: /workspace/github_cpp_makefile_star2_O3/arnoldrobbins[P]mcilroy-regex/re1.cpp
// Function: Kmp::parse(unsigned char*, Rex*, Eenv*)
int Kmp::parse(uchar *s, Rex* cont, Eenv *env)
{
	debug(KMP, "Kmp", s);
	uchar *map = env->preg->map;
	uchar *t = s;
	uchar *last = env->last;
	while(t+seg.n <= last) {
		int k = -1;
		for( ; t<last; t++) {
			while(k>=0 && seg.p[k+1] != map[*t])
				k = fail[k];
			if(seg.p[k+1] == map[*t])
				k++;
			if(k+1 == seg.n) {
				env->best[0].rm_so = ++t - s - seg.n;
				switch(follow(t, cont, env)) {
				case GOOD:
				case BEST:
					return BEST;
				case BAD:
					return BAD;
				}
				t -= seg.n - 1;
				break;
			}
		}
	}
	return NONE;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rcx, %rbx
movq %rdx, (%rsp)
movq 0x18(%rcx), %rbp
movl 0x20(%rdi), %eax
movslq %eax, %rcx
leaq (%rsi,%rcx), %rdx
cmpq %rbp, %rdx
ja 0x89f8
movq %rsi, %r15
movq %rdi, %r12
movq 0x8(%rbx), %rdx
movq 0x18(%rdx), %r14
movq %rsi, %r13
cmpq %rbp, %r13
jae 0x89e8
movq 0x18(%r12), %rdx
movq 0x28(%r12), %rsi
movl $0xffffffff, %edi       # imm = 0xFFFFFFFF
movzbl (%r13), %r8d
movb (%r14,%r8), %r8b
testl %edi, %edi
js 0x8975
movl %edi, %r9d
cmpb %r8b, 0x1(%rdx,%r9)
je 0x8975
movl (%rsi,%r9,4), %edi
jmp 0x8961
movslq %edi, %rdi
leaq 0x1(%rdi), %r9
cmpb %r8b, 0x1(%rdx,%rdi)
cmovel %r9d, %edi
leal 0x1(%rdi), %r8d
incq %r13
cmpl %eax, %r8d
je 0x899b
cmpq %rbp, %r13
jne 0x8958
movq %rbp, %r13
jmp 0x89e8
addq %r15, %rcx
movq %r13, %rax
subq %rcx, %rax
movq 0x418(%rbx), %rcx
movq %rax, (%rcx)
movq 0x10(%r12), %rdi
testq %rdi, %rdi
je 0x89c4
movq (%rdi), %rax
movq %r13, %rsi
movq (%rsp), %rdx
jmp 0x89d0
movq (%rsp), %rdi
movq (%rdi), %rax
movq %r13, %rsi
xorl %edx, %edx
movq %rbx, %rcx
callq *0x20(%rax)
decl %eax
cmpl $0x3, %eax
jb 0x8a09
movslq 0x20(%r12), %rax
subq %rax, %r13
incq %r13
movslq %eax, %rcx
leaq (%rcx,%r13), %rdx
cmpq %rbp, %rdx
jbe 0x8940
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movl %eax, %eax
leaq 0x4a8e(%rip), %rcx      # 0xd4a0
movl (%rcx,%rax,4), %eax
jmp 0x89fa
nop
// File: /workspace/github_cpp_makefile_star2_O3/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 %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
movq 0x18(%r8), %rax
xorl %ebx, %ebx
cmpq %rdx, %rax
jbe 0x8af8
movq %r8, %r14
movq %rcx, %r15
movq %rdx, %r12
movq %rdi, %r13
movq 0x8(%r8), %rcx
movq 0x18(%rcx), %rcx
movzbl (%r12), %edx
movb (%rcx,%rdx), %dl
cmpb %dl, (%rsi)
je 0x8a91
movq 0x10(%rsi), %rsi
testq %rsi, %rsi
jne 0x8a82
jmp 0x8af8
cmpb $0x0, 0x1(%rsi)
movq 0x8(%rsi), %rsi
jne 0x8aa5
incq %r12
cmpq %rax, %r12
jne 0x8a7a
jmp 0x8af8
testq %rsi, %rsi
je 0x8ac9
leaq 0x1(%r12), %rdx
movq %r13, %rdi
movq %r15, %rcx
movq %r14, %r8
callq 0x8a4e
movl %eax, %ebx
andl $-0x2, %eax
cmpl $0x2, %eax
jne 0x8acb
jmp 0x8af8
xorl %ebx, %ebx
incq %r12
movq 0x10(%r13), %rdi
testq %rdi, %rdi
je 0x8ae2
movq (%rdi), %rax
movq %r12, %rsi
movq %r15, %rdx
jmp 0x8aed
movq (%r15), %rax
movq %r15, %rdi
movq %r12, %rsi
xorl %edx, %edx
movq %r14, %rcx
callq *0x20(%rax)
testl %eax, %eax
cmovnel %eax, %ebx
movl %ebx, %eax
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
// File: /workspace/github_cpp_makefile_star2_O3/arnoldrobbins[P]mcilroy-regex/re1.cpp
// Function: Trie::insert(unsigned char*)
int Trie::insert(uchar *s)
{
	int len;
	Tnode *node = root[*s&MASK];
	if(node == 0)
		node = root[*s&MASK] = new Tnode(*s);
	for(len=1; ; ) {
		if(node == 0)
			return 1;
		if(node->c == *s) {
			if(s[1] == 0)
				break;
			if(node->son == 0)
				node->son = new Tnode(s[1]);
			node = node->son;
			len++;
			s++;
		} else {
			if(node->sib == 0)
				node->sib = new Tnode(*s);
			node = node->sib;
		}	
	}
	if(len < min)
		min = len;
	else if(len > max)
		max = len;
	node->end = 1;
	return 0;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %r14
movq %rdi, %rbx
movzbl (%rsi), %r15d
movq 0x20(%rdi,%r15,8), %rax
testq %rax, %rax
jne 0x8b3c
movl $0x18, %edi
callq 0x5170
movb %r15b, (%rax)
movb $0x0, 0x1(%rax)
xorps %xmm0, %xmm0
movups %xmm0, 0x8(%rax)
movq %rax, 0x20(%rbx,%r15,8)
movl $0x1, %ebp
movq %rax, %r15
movb (%rax), %al
cmpb (%r14), %al
je 0x8b74
movq 0x10(%r15), %rax
testq %rax, %rax
jne 0x8b41
movl $0x18, %edi
callq 0x5170
movb (%r14), %cl
movb %cl, (%rax)
movb $0x0, 0x1(%rax)
xorps %xmm0, %xmm0
movups %xmm0, 0x8(%rax)
movq %rax, 0x10(%r15)
jmp 0x8b41
cmpb $0x0, 0x1(%r14)
je 0x8ba9
incq %r14
movq 0x8(%r15), %rax
testq %rax, %rax
jne 0x8ba5
movl $0x18, %edi
callq 0x5170
movb (%r14), %cl
movb %cl, (%rax)
movb $0x0, 0x1(%rax)
xorps %xmm0, %xmm0
movups %xmm0, 0x8(%rax)
movq %rax, 0x8(%r15)
incl %ebp
jmp 0x8b41
cmpl 0x18(%rbx), %ebp
jge 0x8bb3
movl %ebp, 0x18(%rbx)
jmp 0x8bbb
cmpl 0x1c(%rbx), %ebp
jle 0x8bbb
movl %ebp, 0x1c(%rbx)
movb $0x1, 0x1(%r15)
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O3/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:
movslq 0x18(%rdi), %r9
movq 0x2c8(%rcx), %r8
shlq $0x4, %r9
movq (%r8,%r9), %rax
testq %rax, %rax
js 0x8c26
addq %r9, %r8
movq 0x8(%r8), %r8
subq %rax, %r8
leaq (%rsi,%r8), %r9
cmpq 0x18(%rcx), %r9
ja 0x8c26
addq 0x10(%rcx), %rax
movq 0x8(%rcx), %r9
movq 0x18(%r9), %r9
testq %r8, %r8
jle 0x8c29
decq %r8
movzbl (%rsi), %r10d
incq %rsi
movb (%r9,%r10), %r10b
movzbl (%rax), %r11d
incq %rax
cmpb (%r9,%r11), %r10b
je 0x8c06
xorl %eax, %eax
retq
movq 0x10(%rdi), %rdi
testq %rdi, %rdi
je 0x8c3b
movq (%rdi), %rax
movq 0x20(%rax), %rax
jmpq *%rax
movq (%rdx), %rax
movq 0x20(%rax), %rax
movq %rdx, %rdi
xorl %edx, %edx
jmpq *%rax
nop
// File: /workspace/github_cpp_makefile_star2_O3/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
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x38, %rsp
movq %rcx, %rbx
movq %rsi, %r15
movq %rdi, %r12
movswq 0x18(%rdi), %rbp
movq 0x2c8(%rcx), %r13
shlq $0x4, %rbp
leaq 0x20(%rsp), %r14
movb $0x11, -0x8(%r14)
leaq 0x9b9e(%rip), %rax      # 0x12820
movq %rax, -0x10(%r14)
movq %rdx, 0x8(%r14)
movq %rdi, 0x10(%r14)
movq 0x10(%rdi), %rax
movq %rax, (%r14)
movq %rsi, %rax
subq 0x10(%rcx), %rax
movq %rax, (%r13,%rbp)
movl $0x3, 0xc(%rsp)
movq %rcx, %rdi
movq %r12, %rsi
movq %r15, %rdx
movl $0x3, %ecx
callq 0x829c
testl %eax, %eax
jne 0x8d0b
movq 0x20(%r12), %rdi
movq (%rdi), %rax
leaq 0x10(%rsp), %rdx
movq %r15, %rsi
movq %rbx, %rcx
callq *0x20(%rax)
movl %eax, 0xc(%rsp)
addq %rbp, %r13
decl 0x20(%rbx)
movq $-0x1, (%r13)
cmpb $0x11, 0x18(%rsp)
leaq 0x987c(%rip), %rax      # 0x12570
movq %rax, 0x10(%rsp)
je 0x8d0b
movq 0x20(%rsp), %rdi
testq %rdi, %rdi
je 0x8d0b
movq (%rdi), %rax
callq *0x8(%rax)
movl 0xc(%rsp), %eax
addq $0x38, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
leaq 0x9848(%rip), %rax      # 0x12570
movq %rax, 0x10(%rsp)
cmpb $0x11, 0x18(%rsp)
je 0x8d3c
movq %r14, %rdi
callq 0x53e2
movq %rbx, %rdi
callq 0x52b0
// File: /workspace/github_cpp_makefile_star2_O3/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 %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
movq %rcx, %rbx
movq %rsi, %r14
movq %rdi, %r15
movq 0x20(%rdi), %rsi
movswq 0x18(%rsi), %r12
movq 0x2c8(%rcx), %r13
shlq $0x4, %r12
movq %r14, %rax
subq 0x10(%rcx), %rax
movq %rax, 0x8(%r13,%r12)
movq %rcx, %rdi
movq %r14, %rdx
movl $0x4, %ecx
callq 0x829c
movl %eax, %ecx
movl $0x3, %eax
testl %ecx, %ecx
jne 0x8dc9
addq %r13, %r12
addq $0x8, %r12
movq 0x10(%r15), %rdi
movq 0x18(%r15), %rdx
testq %rdi, %rdi
je 0x8dad
movq (%rdi), %rax
movq %r14, %rsi
jmp 0x8db8
movq (%rdx), %rax
movq %rdx, %rdi
movq %r14, %rsi
xorl %edx, %edx
movq %rbx, %rcx
callq *0x20(%rax)
decl 0x20(%rbx)
movq $-0x1, (%r12)
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
nop
// File: /workspace/github_cpp_makefile_star2_O3/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
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movl %esi, (%rdi)
movl %edx, 0x4(%rdi)
leaq 0x18(%rdi), %r13
movq %r13, 0x8(%rdi)
movl $0x14, 0x10(%rdi)
testl %esi, %esi
je 0x8e61
movq %rcx, %r14
movl %edx, %ebx
movl %esi, %ebp
movq 0x2c8(%rcx), %r12
subl %esi, %ebx
cmpl $0x14, %ebx
jl 0x8e34
movq %rdi, %r15
addq $0x8, %rdi
movq %rdi, (%rsp)
movl %ebx, %esi
callq 0xa1fe
testl %eax, %eax
je 0x8e2d
orb $0x4, 0x1(%r14)
movl %ebp, 0x4(%r15)
jmp 0x8e61
movq (%rsp), %rax
movq (%rax), %r13
movslq %ebp, %rax
shlq $0x4, %rax
addq %rax, %r12
incl %ebx
xorl %eax, %eax
pcmpeqd %xmm0, %xmm0
movups (%r12,%rax), %xmm1
movups %xmm1, (%r13,%rax)
movdqu %xmm0, (%r12,%rax)
addq $0x10, %rax
decl %ebx
testl %ebx, %ebx
jg 0x8e46
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
movq (%rsp), %rax
movq (%rax), %rdi
cmpq %r13, %rdi
sete %al
testq %rdi, %rdi
sete %cl
orb %al, %cl
jne 0x8e8f
callq 0x5200
movq %rbx, %rdi
callq 0x52b0
nop
// File: /workspace/github_cpp_makefile_star2_O3/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:
movslq (%rdi), %r8
testq %r8, %r8
je 0x8ece
movl 0x4(%rdi), %eax
movq %r8, %rcx
shlq $0x4, %rcx
addq 0x2c8(%rsi), %rcx
movq 0x8(%rdi), %rdx
subl %r8d, %eax
incl %eax
xorl %esi, %esi
movups (%rdx,%rsi), %xmm0
movups %xmm0, (%rcx,%rsi)
addq $0x10, %rsi
decl %eax
testl %eax, %eax
jg 0x8ebc
retq
nop
// File: /workspace/github_cpp_makefile_star2_O3/arnoldrobbins[P]mcilroy-regex/re1.cpp
// Function: Alt::parse(unsigned char*, Rex*, Eenv*)
int Alt::parse(uchar *s, Rex *cont, Eenv *env)
{
	debug(ALT, "Altl", s);
	Save save(n1, n2, env);
	if(env->flags&SPACE)
		return BAD;
	if(env->pushpos(this, s, BEGA))
		return BAD;
	Alt1 alt1(cont, serial);
	int result = left->parse(s, &alt1, env);
	if(result!=BEST && result!=BAD) {
		debug(ALT, "Altr", s);
		save.restore(env);
		env->pos[env->npos-1].serial = rserial;
		alt1.serial = rserial;
		int rightresult = right->parse(s, &alt1, env);
		if(rightresult != NONE)
			result = rightresult;
	}
	env->poppos();
	save.restore(env);
	return result;
}

// Assembly:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x180, %rsp            # imm = 0x180
movq %rcx, %r14
movq %rdx, %r13
movq %rsi, %r15
movq %rdi, %r12
movl 0x18(%rdi), %esi
movl 0x1c(%rdi), %edx
leaq 0x28(%rsp), %rdi
callq 0x8dd4
movl $0x3, %ebx
testb $0x4, 0x1(%r14)
jne 0x903a
movq %r14, %rdi
movq %r12, %rsi
movq %r15, %rdx
movl $0x2, %ecx
callq 0x829c
testl %eax, %eax
jne 0x903a
movzwl 0xa(%r12), %eax
leaq 0x8(%rsp), %rdx
movb $0x11, 0x8(%rdx)
movq $0x0, 0x10(%rdx)
leaq 0x992b(%rip), %rcx      # 0x12870
movq %rcx, (%rdx)
movq %r13, 0x18(%rdx)
movw %ax, 0xa(%rdx)
movq 0x20(%r12), %rdi
movq (%rdi), %rax
movq %r15, %rsi
movq %r14, %rcx
callq *0x20(%rax)
movl %eax, %ebx
leal -0x4(%rbx), %eax
cmpl $-0x3, %eax
ja 0x8fda
movslq 0x28(%rsp), %rsi
testq %rsi, %rsi
je 0x8fa4
movl 0x2c(%rsp), %eax
movq %rsi, %rcx
shlq $0x4, %rcx
addq 0x2c8(%r14), %rcx
movq 0x30(%rsp), %rdx
subl %esi, %eax
incl %eax
xorl %esi, %esi
movups (%rdx,%rsi), %xmm0
movups %xmm0, (%rcx,%rsi)
addq $0x10, %rsi
decl %eax
testl %eax, %eax
jg 0x8f92
movzwl 0x30(%r12), %eax
movslq 0x20(%r14), %rcx
movq 0x28(%r14), %rdx
shlq $0x4, %rcx
movw %ax, -0x8(%rdx,%rcx)
leaq 0x8(%rsp), %rdx
movw %ax, 0xa(%rdx)
movq 0x28(%r12), %rdi
movq (%rdi), %rax
movq %r15, %rsi
movq %r14, %rcx
callq *0x20(%rax)
testl %eax, %eax
cmovnel %eax, %ebx
decl 0x20(%r14)
movslq 0x28(%rsp), %rsi
testq %rsi, %rsi
je 0x9017
movl 0x2c(%rsp), %eax
movq %rsi, %rcx
shlq $0x4, %rcx
addq 0x2c8(%r14), %rcx
movq 0x30(%rsp), %rdx
subl %esi, %eax
incl %eax
xorl %esi, %esi
movups (%rdx,%rsi), %xmm0
movups %xmm0, (%rcx,%rsi)
addq $0x10, %rsi
decl %eax
testl %eax, %eax
jg 0x9005
leaq 0x9552(%rip), %rax      # 0x12570
movq %rax, 0x8(%rsp)
cmpb $0x11, 0x10(%rsp)
je 0x903a
movq 0x18(%rsp), %rdi
testq %rdi, %rdi
je 0x903a
movq (%rdi), %rax
callq *0x8(%rax)
leaq 0x40(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
sete %al
testq %rdi, %rdi
sete %cl
orb %al, %cl
jne 0x9058
callq 0x5200
movl %ebx, %eax
addq $0x180, %rsp            # imm = 0x180
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
jmp 0x906d
movq %rax, %rbx
leaq 0x94f9(%rip), %rax      # 0x12570
movq %rax, 0x8(%rsp)
cmpb $0x11, 0x10(%rsp)
je 0x9098
movq 0x18(%rsp), %rdi
testq %rdi, %rdi
je 0x9098
movq (%rdi), %rax
callq *0x8(%rax)
jmp 0x9098
movq %rax, %rbx
leaq 0x40(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
sete %al
testq %rdi, %rdi
sete %cl
orb %al, %cl
jne 0x90b6
callq 0x5200
movq %rbx, %rdi
callq 0x52b0
// File: /workspace/github_cpp_makefile_star2_O3/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 %r15
pushq %r14
pushq %rbx
movq %rcx, %rbx
movq %rsi, %r14
movq %rdi, %r15
movq %rcx, %rdi
movq %r15, %rsi
movq %r14, %rdx
movl $0x4, %ecx
callq 0x829c
movl %eax, %ecx
movl $0x3, %eax
testl %ecx, %ecx
jne 0x9113
movq 0x10(%r15), %rdi
movq 0x18(%r15), %rdx
testq %rdi, %rdi
je 0x90ff
movq (%rdi), %rax
movq %r14, %rsi
jmp 0x910a
movq (%rdx), %rax
movq %rdx, %rdi
movq %r14, %rsi
xorl %edx, %edx
movq %rbx, %rcx
callq *0x20(%rax)
decl 0x20(%rbx)
popq %rbx
popq %r14
popq %r15
retq
nop
// File: /workspace/github_cpp_makefile_star2_O3/arnoldrobbins[P]mcilroy-regex/re1.cpp
// Function: Conj::parse(unsigned char*, Rex*, Eenv*)
int Conj::parse(uchar *s, Rex *cont, Eenv *env)
{
	debug(CONJ, "Conjl", s);
	Conj2 conj2(cont, next);
	Conj1 conj1(s, right, &conj2);
	return left->parse(s, &conj1, env);
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
subq $0x60, %rsp
movq 0x10(%rdi), %rax
movb $0x11, %r8b
leaq 0x8(%rsp), %r9
movb %r8b, 0x8(%r9)
leaq 0x9786(%rip), %r10      # 0x128c0
movq %r10, (%r9)
movq %rdx, 0x20(%r9)
movq %rax, 0x10(%r9)
movq 0x20(%rdi), %rax
leaq 0x40(%rsp), %r14
movb %r8b, -0x8(%r14)
movq $0x0, (%r14)
leaq 0x97b0(%rip), %rdx      # 0x12910
movq %rdx, -0x10(%r14)
movq %rsi, 0x8(%r14)
movq %rax, 0x10(%r14)
movq %r9, 0x18(%r14)
movq 0x18(%rdi), %rdi
movq (%rdi), %rax
leaq 0x30(%rsp), %rdx
callq *0x20(%rax)
movl %eax, %ebx
leaq 0x93e8(%rip), %r14      # 0x12570
movq %r14, 0x30(%rsp)
cmpb $0x11, 0x38(%rsp)
je 0x91a4
movq 0x40(%rsp), %rdi
testq %rdi, %rdi
je 0x91a4
movq (%rdi), %rax
callq *0x8(%rax)
movq %r14, 0x8(%rsp)
cmpb $0x11, 0x10(%rsp)
je 0x91c0
movq 0x18(%rsp), %rdi
testq %rdi, %rdi
je 0x91c0
movq (%rdi), %rax
callq *0x8(%rax)
movl %ebx, %eax
addq $0x60, %rsp
popq %rbx
popq %r14
popq %r15
retq
movq %rax, %rbx
leaq 0x939a(%rip), %r15      # 0x12570
movq %r15, 0x30(%rsp)
cmpb $0x11, 0x38(%rsp)
je 0x91ea
movq %r14, %rdi
callq 0x53f6
movq %r15, 0x8(%rsp)
cmpb $0x11, 0x10(%rsp)
je 0x9206
movq 0x18(%rsp), %rdi
testq %rdi, %rdi
je 0x9206
movq (%rdi), %rax
callq *0x8(%rax)
movq %rbx, %rdi
callq 0x52b0
// File: /workspace/github_cpp_makefile_star2_O3/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
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rcx, %rbx
movq %rsi, %r14
movq %rdi, %r15
movq %rcx, %rdi
movq %r15, %rsi
movq %r14, %rdx
movl $0x4, %ecx
callq 0x829c
movl $0x3, %ebp
testl %eax, %eax
jne 0x9508
cmpq %r14, 0x20(%r15)
je 0x94aa
movq 0x18(%r15), %rdi
movl 0x28(%r15), %esi
jmp 0x94f4
movl 0x28(%r15), %esi
movq 0x18(%r15), %rdi
cmpl 0x18(%rdi), %esi
jle 0x94f4
movl $0x801, %ecx            # imm = 0x801
andl (%rbx), %ecx
xorl %eax, %eax
cmpl $0x800, %ecx            # imm = 0x800
jne 0x9503
movq %rbx, %rdi
movq %r15, %rsi
movq %r14, %rdx
movl $0x4, %ecx
callq 0x829c
testl %eax, %eax
jne 0x9508
movq 0x10(%r15), %rdi
movq 0x30(%r15), %rdx
testq %rdi, %rdi
je 0x9515
movq (%rdi), %rax
movq %r14, %rsi
jmp 0x9520
movq 0x30(%r15), %rcx
movq %r14, %rdx
movq %rbx, %r8
callq 0x9258
decl 0x20(%rbx)
movl %eax, %ebp
movl %ebp, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
movq (%rdx), %rax
movq %rdx, %rdi
movq %r14, %rsi
xorl %edx, %edx
movq %rbx, %rcx
callq *0x20(%rax)
decl 0x20(%rbx)
jmp 0x9503
nop
// File: /workspace/github_cpp_makefile_star2_O3/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
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x48, %rsp
movq %rcx, %r14
movq %rdx, %r15
movq %rsi, %r12
movq %rdi, %r13
movq 0x18(%rcx), %rbp
subq %rsi, %rbp
leaq 0x8(%rsp), %rbx
movq %rbx, %rdi
movl %ebp, %edx
callq 0x96a4
movq 0x18(%r13), %rdi
movq (%rdi), %rax
movq %r12, %rsi
movq %rbx, %rdx
movq %r14, %rcx
callq *0x20(%rax)
movl $0x3, %ebx
cmpl $0x3, %eax
je 0x9630
testl %ebp, %ebp
js 0x962a
andl $0x7fffffff, %ebp       # imm = 0x7FFFFFFF
xorl %ebx, %ebx
movl %ebp, %eax
shrl $0x3, %eax
movq 0x28(%rsp), %rcx
movzbl (%rcx,%rax), %eax
movl %ebp, %ecx
andl $0x7, %ecx
btl %ecx, %eax
jb 0x961e
movq 0x10(%r13), %rdx
testq %rdx, %rdx
movq %rdx, %rdi
cmoveq %r15, %rdi
leaq (%r12,%rbp), %rsi
cmovneq %r15, %rdx
movq (%rdi), %rax
movq %r14, %rcx
callq *0x20(%rax)
movl %eax, %ecx
andl $-0x2, %ecx
cmpl $0x1, %eax
cmovel %eax, %ebx
cmpl $0x2, %ecx
je 0x962e
decq %rbp
leal 0x1(%rbp), %eax
testl %eax, %eax
jg 0x95d7
jmp 0x9630
xorl %ebx, %ebx
jmp 0x9630
movl %eax, %ebx
leaq 0x8fa9(%rip), %rax      # 0x125e0
leaq 0x34(%rsp), %rcx
movq %rax, -0x2c(%rcx)
movq -0xc(%rcx), %rdi
cmpq %rcx, %rdi
sete %al
testq %rdi, %rdi
sete %cl
orb %al, %cl
jne 0x9659
callq 0x5200
leaq 0x8f10(%rip), %rax      # 0x12570
movq %rax, 0x8(%rsp)
cmpb $0x11, 0x10(%rsp)
je 0x967c
movq 0x18(%rsp), %rdi
testq %rdi, %rdi
je 0x967c
movq (%rdi), %rax
callq *0x8(%rax)
movl %ebx, %eax
addq $0x48, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
jmp 0x968f
movq %rax, %rbx
leaq 0x8(%rsp), %rdi
callq 0x9c2e
movq %rbx, %rdi
callq 0x52b0
// File: /workspace/github_cpp_makefile_star2_O3/arnoldrobbins[P]mcilroy-regex/re1.cpp
// Function: Done::parse(unsigned char*, Rex*, Eenv*)
int Done::parse(uchar *s, Rex*, Eenv *env)
{
	if(edebug & (1<<DONE)) {
		dprint("Done", s);
		printpos(&env->pos[0], env->npos, env);
	}
	if(env->flags&REG_ANCH && s!=env->last)
		return NONE;
	if(env->flags & REG_NOSUB)
		return BEST;
	int n = s - env->p;
	int nsub = env->preg->re_nsub;
	if((env->flags&HARD) == 0) {
		env->best[0].rm_eo = n;
		memmove(&env->best[1], &env->match[1],
			nsub*sizeof(regmatch_t));
		return BEST;
	}
	if(env->best[0].rm_eo >= 0) {	/* only happens on HARD */
		long d = env->best[0].rm_eo;
		if(n < d)
			return GOOD;
		if(n == d) {
			if(edebug & (1<<DONE))
				printpos(&env->bestpos[0],
					 env->nbestpos, env);
		   	d = better(&env->bestpos[0],
				   &env->pos[0],
				   &env->bestpos[env->nbestpos],
				   &env->pos[env->npos]);
			if(d <= 0)
				return GOOD;
		}
	}
	env->best[0].rm_eo = n;
	memmove(&env->best[1], &env->match[1],
		nsub*sizeof(regmatch_t));
	n = env->npos;
	if(env->bestpos.assure(n)) {
		env->flags |= SPACE;
		return BAD;
	}
	env->nbestpos = n;
	memmove(&env->bestpos[0], &env->pos[0], n*sizeof(Pos));
	return GOOD;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rcx, %rbx
movl (%rcx), %eax
testb %al, %al
jns 0x979e
xorl %ebp, %ebp
cmpq %rsi, 0x18(%rbx)
jne 0x98a4
movl $0x2, %ebp
testb $0x4, %al
jne 0x98a4
movq 0x8(%rbx), %rcx
movq (%rcx), %r14
subq 0x10(%rbx), %rsi
btl $0xb, %eax
jb 0x97ea
movslq %esi, %rax
movq 0x418(%rbx), %rdi
movq %rax, 0x8(%rdi)
addq $0x10, %rdi
movq 0x2c8(%rbx), %rsi
addq $0x10, %rsi
movslq %r14d, %rdx
shlq $0x4, %rdx
callq 0x5290
jmp 0x98a4
movq 0x418(%rbx), %rdi
movq 0x8(%rdi), %rax
movslq %esi, %r15
testq %rax, %rax
js 0x983e
movl $0x1, %ebp
cmpq %rax, %r15
jl 0x98a4
jne 0x983e
movq 0x28(%rbx), %rsi
movq 0x178(%rbx), %rdi
movslq 0x24(%rbx), %rdx
shlq $0x4, %rdx
addq %rdi, %rdx
movslq 0x20(%rbx), %rcx
shlq $0x4, %rcx
addq %rsi, %rcx
callq 0x98b1
testl %eax, %eax
jle 0x98a4
movq 0x418(%rbx), %rdi
movq %r15, 0x8(%rdi)
addq $0x10, %rdi
movq 0x2c8(%rbx), %rsi
addq $0x10, %rsi
movslq %r14d, %rdx
shlq $0x4, %rdx
callq 0x5290
movl 0x20(%rbx), %ebp
cmpl %ebp, 0x180(%rbx)
jg 0x9885
leaq 0x178(%rbx), %rdi
movl %ebp, %esi
callq 0xa190
testl %eax, %eax
je 0x9885
orb $0x4, 0x1(%rbx)
movl $0x3, %ebp
jmp 0x98a4
movslq %ebp, %rdx
movl %ebp, 0x24(%rbx)
movq 0x28(%rbx), %rsi
movq 0x178(%rbx), %rdi
shlq $0x4, %rdx
callq 0x5290
movl $0x1, %ebp
movl %ebp, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O3/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 %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rcx, %rbx
movq %rdx, %r14
cmpq %rdx, %rdi
setb %al
cmpq %rcx, %rsi
setb %cl
movl %eax, %edx
andb %cl, %dl
cmpb $0x1, %dl
jne 0x99b7
movzwl 0x8(%rsi), %ecx
movzwl 0x8(%rdi), %edx
movl $0xffffffff, %eax       # imm = 0xFFFFFFFF
cmpw %dx, %cx
jg 0x99be
jl 0x99ca
movq (%rdi), %r8
movq (%rsi), %r9
cmpq %r9, %r8
ja 0x99be
movl $0x1, %eax
jb 0x99be
xorl %r8d, %r8d
movq %rdi, %r15
movq %r15, %r9
addq $0x10, %r15
cmpw %dx, 0x18(%r9)
jne 0x9914
cmpb $0x4, 0xa(%r15)
jne 0x9937
leal -0x1(%r8), %r9d
testl %r8d, %r8d
movl %r9d, %r8d
jg 0x9914
jmp 0x993c
incl %r8d
jmp 0x9914
xorl %edx, %edx
movq %rsi, %r12
movq %r12, %r8
addq $0x10, %r12
cmpw %cx, 0x18(%r8)
jne 0x9941
cmpb $0x4, 0xa(%r12)
jne 0x9964
leal -0x1(%rdx), %r8d
testl %edx, %edx
movl %r8d, %edx
jg 0x9941
jmp 0x9968
incl %edx
jmp 0x9941
movq (%r12), %rcx
movq (%r15), %rdx
cmpq %rdx, %rcx
ja 0x99be
movl $0xffffffff, %eax       # imm = 0xFFFFFFFF
jb 0x99be
addq $0x10, %rdi
addq $0x10, %rsi
movq %r15, %rdx
movq %r12, %rcx
callq 0x98b1
testl %eax, %eax
jne 0x99be
addq $0x10, %r15
addq $0x10, %r12
cmpq %rbx, %r12
setb %cl
cmpq %r14, %r15
setb %al
jae 0x99b7
movq %r15, %rdi
movq %r12, %rsi
cmpq %rbx, %r12
jb 0x98d8
testb %cl, %cl
jne 0x99ca
movzbl %al, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
callq 0x5110
// File: /workspace/github_cpp_makefile_star2_O3/arnoldrobbins[P]mcilroy-regex/re1.cpp
// Function: regnexec
int regnexec(const regex_t *preg, const char *string, size_t len,
	     size_t nmatch, regmatch_t *match, int eflags)
{
	int i;
	if(preg->rex == 0)	// not required, but kind
		return REG_BADPAT;
	Eenv env(preg, eflags, (uchar*)string, len);
	if(env.flags&SPACE)
		return REG_ESPACE;
	if(env.flags&REG_NOSUB)
		nmatch = 0;
	for(i=0; (unsigned)i<nmatch && (unsigned)i<=preg->re_nsub; i++)
		env.match[i] = NOMATCH;

	while(preg->rex->parse((uchar*)string,Done::done,&env) == NONE) {
		if(env.flags & ONCE)
			return REG_NOMATCH;
		if((uchar*)++string > env.last)
			return REG_NOMATCH;
		env.best[0].rm_so++;
	}
	if(env.flags & SPACE)
		return REG_ESPACE;

	for(i=0; (unsigned)i<nmatch; i++)
		if((unsigned)i <= preg->re_nsub)
			match[i] = env.best[i];
		else
			match[i] = NOMATCH;
	return 0;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x578, %rsp            # imm = 0x578
cmpq $0x0, 0x8(%rdi)
je 0x9aa5
movq %rcx, %r12
movq %rdx, %rax
movq %rsi, %r15
movq %rdi, %r14
movq %r8, 0x8(%rsp)
leaq 0x10(%rsp), %r13
movq %r13, %rdi
movq %r14, %rsi
movl %r9d, %edx
movq %r15, %rcx
movq %rax, %r8
callq 0x9c7c
movl (%r13), %eax
movl $0xc, %ebp
btl $0xa, %eax
jb 0x9b02
xorl %r13d, %r13d
testb $0x4, %al
cmoveq %r12, %r13
testq %r13, %r13
je 0x9a5c
xorl %eax, %eax
pcmpeqd %xmm0, %xmm0
xorl %ecx, %ecx
cmpq %rcx, (%r14)
jb 0x9a5c
movq 0x2d8(%rsp), %rdx
movdqu %xmm0, (%rdx,%rax)
incq %rcx
addq $0x10, %rax
cmpq %rcx, %r13
jne 0x9a3e
leaq 0x9e5d(%rip), %rbx      # 0x138c0
leaq 0x10(%rsp), %r12
movl $0x1, %ebp
movq 0x8(%r14), %rdi
movq (%rbx), %rdx
movq (%rdi), %rax
movq %r15, %rsi
movq %r12, %rcx
callq *0x20(%rax)
movl 0x10(%rsp), %ecx
testl %eax, %eax
jne 0x9aaf
btl $0xc, %ecx
jb 0x9b02
incq %r15
cmpq 0x28(%rsp), %r15
ja 0x9b02
movq 0x428(%rsp), %rax
incq (%rax)
jmp 0x9a6d
movl $0x2, %ebp
jmp 0x9b83
testq %r13, %r13
sete %al
shrl $0xa, %ecx
andl $0x1, %ecx
orb %cl, %al
testl %ecx, %ecx
movl $0xc, %ebp
cmovel %ecx, %ebp
testb %al, %al
jne 0x9b02
movq 0x428(%rsp), %rax
xorl %ecx, %ecx
pcmpeqd %xmm0, %xmm0
xorl %edx, %edx
movq 0x8(%rsp), %rsi
cmpq %rdx, (%r14)
jae 0x9aec
movdqu %xmm0, (%rsi,%rcx)
jmp 0x9af4
movups (%rax,%rcx), %xmm1
movups %xmm1, (%rsi,%rcx)
incq %rdx
addq $0x10, %rcx
cmpq %rdx, %r13
jne 0x9ae0
xorl %ebp, %ebp
leaq 0x438(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
sete %al
testq %rdi, %rdi
sete %cl
orb %al, %cl
jne 0x9b23
callq 0x5200
leaq 0x2e8(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
sete %al
testq %rdi, %rdi
sete %cl
orb %al, %cl
jne 0x9b44
callq 0x5200
leaq 0x198(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
sete %al
testq %rdi, %rdi
sete %cl
orb %al, %cl
jne 0x9b65
callq 0x5200
leaq 0x48(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
sete %al
testq %rdi, %rdi
sete %cl
orb %al, %cl
jne 0x9b83
callq 0x5200
movl %ebp, %eax
addq $0x578, %rsp            # imm = 0x578
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
leaq 0x10(%rsp), %rdi
callq 0x9ddc
movq %rbx, %rdi
callq 0x52b0
// File: /workspace/github_cpp_makefile_star2_O3/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
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %rdi, %rbx
andl $0x30, %edx
orl 0x10(%rsi), %edx
movl %edx, (%rdi)
movq %rsi, 0x8(%rdi)
movq %rcx, 0x10(%rdi)
addq %rcx, %r8
movq %r8, 0x18(%rdi)
leaq 0x38(%rdi), %rax
movq %rax, 0x10(%rsp)
movq %rax, 0x28(%rdi)
movl $0x14, %eax
movl %eax, 0x30(%rdi)
leaq 0x188(%rdi), %r15
movq %r15, 0x178(%rdi)
movl %eax, 0x180(%rdi)
leaq 0x2c8(%rdi), %rcx
movq %rcx, 0x8(%rsp)
leaq 0x2d8(%rdi), %r13
movq %r13, 0x2c8(%rdi)
movl %eax, 0x2d0(%rdi)
leaq 0x418(%rdi), %r12
leaq 0x428(%rdi), %r14
movq %r14, 0x418(%rdi)
movl %eax, 0x420(%rdi)
movl (%rsi), %ebp
cmpl %eax, %ebp
jl 0x9d24
movq 0x8(%rsp), %rdi
movl %ebp, %esi
callq 0xa1fe
testl %eax, %eax
jne 0x9d36
movl 0x420(%rbx), %eax
cmpl %ebp, %eax
jg 0x9d3c
movq %r12, %rdi
movl %ebp, %esi
callq 0xa1fe
testl %eax, %eax
je 0x9d3c
orb $0x4, 0x1(%rbx)
jmp 0x9d54
xorl %eax, %eax
movq %rax, 0x20(%rbx)
movq 0x418(%rbx), %rcx
movq %rax, (%rcx)
movq $-0x1, 0x8(%rcx)
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbp
movq (%r12), %rdi
cmpq %r14, %rdi
sete %al
testq %rdi, %rdi
sete %cl
orb %al, %cl
jne 0x9d7f
callq 0x5200
movq 0x8(%rsp), %rax
movq (%rax), %rdi
cmpq %r13, %rdi
sete %al
testq %rdi, %rdi
sete %cl
orb %al, %cl
jne 0x9d9c
callq 0x5200
movq 0x178(%rbx), %rdi
cmpq %r15, %rdi
sete %al
testq %rdi, %rdi
sete %cl
orb %al, %cl
jne 0x9db8
callq 0x5200
movq 0x28(%rbx), %rdi
cmpq 0x10(%rsp), %rdi
sete %al
testq %rdi, %rdi
sete %cl
orb %al, %cl
jne 0x9dd3
callq 0x5200
movq %rbp, %rdi
callq 0x52b0
nop
// File: /workspace/github_cpp_makefile_star2_O3/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
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movl %edx, %ebp
movq %rsi, %r14
movq %rdi, %rbx
movl %edx, (%rdi)
leaq 0x8(%rdi), %r15
movq %rsi, %rdi
callq 0x50d0
movq %r14, 0x8(%rbx)
movl %eax, 0x10(%rbx)
movq $0x0, 0x30(%rbx)
movw $0x0, 0x38(%rbx)
cmpb $0x0, 0x965a(%rip)      # 0x139cf
jne 0xa3c9
leaq 0x3202(%rip), %rax      # 0xd580
xorl %ecx, %ecx
leaq 0x9779(%rip), %rdx      # 0x13b00
movzbl (%rax), %esi
movb %cl, (%rsi,%rdx)
incq %rcx
addq $0xe, %rax
cmpq $0x19, %rcx
jne 0xa387
xorl %r14d, %r14d
leaq 0x962c(%rip), %r12      # 0x139d0
leaq 0x9525(%rip), %r13      # 0x138d0
movb %r14b, (%r14,%r12)
movl %r14d, %edi
callq 0x52e0
movb %al, (%r14,%r13)
incq %r14
cmpq $0x100, %r14            # imm = 0x100
jne 0xa3ab
movl (%rbx), %ebp
testb $0x2, %bpl
leaq 0x95fc(%rip), %rax      # 0x139d0
leaq 0x94f5(%rip), %rcx      # 0x138d0
cmoveq %rax, %rcx
movl %ebp, %eax
andb $0x1, %al
btl $0x9, %ebp
movzbl %al, %eax
movl $0x2, %edx
cmovael %eax, %edx
movq %rcx, 0x28(%rbx)
movb %dl, 0x3a(%rbx)
xorl %eax, %eax
testb %dl, %dl
sete %al
movl %eax, 0x48(%rbx)
movq (%r15), %rax
movq %rax, 0x18(%rbx)
movl 0x8(%r15), %eax
movl %eax, 0x20(%rbx)
movq $0x0, 0x3b(%rbx)
movw $0x0, 0x43(%rbx)
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/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 %rbx
subq $0x10, %rsp
movq %rdi, %rbx
testq %rsi, %rsi
je 0xa4d5
movq (%rsi), %rax
movq %rsi, %rdi
movq %rdx, %rsi
callq *0x10(%rax)
movq %rsp, %rsi
movq %rax, (%rsi)
movl %edx, 0x8(%rsi)
shrq $0x20, %rdx
movw %dx, 0xc(%rsi)
movq %rbx, %rdi
callq 0xa6ac
movq %rdx, %rcx
movabsq $0xffffffffffff, %rdx   # imm = 0xFFFFFFFFFFFF
andq %rcx, %rdx
jmp 0xa4dc
movq (%rbx), %rax
movq 0x8(%rbx), %rdx
addq $0x10, %rsp
popq %rbx
retq
// File: /workspace/github_cpp_makefile_star2_O3/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:
subq $0x18, %rsp
leaq 0x8(%rsp), %rax
movl $0x0, 0xc(%rax)
movq $0x0, 0x4(%rax)
movl 0x18(%rdi), %ecx
movl %ecx, (%rax)
cmpl %ecx, 0x1c(%rdi)
movq %rsi, %rdx
setne 0x5(%rax)
setne 0x4(%rax)
movq 0x10(%rdi), %rsi
movq %rax, %rdi
callq 0xa491
movabsq $0xffffffffffff, %rcx   # imm = 0xFFFFFFFFFFFF
andq %rcx, %rdx
addq $0x18, %rsp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O3/arnoldrobbins[P]mcilroy-regex/re2.cpp
// Function: Subexp::stat(Cenv*)
Stat Subexp::stat(Cenv *env)
{
	Stat st = rex->stat(env);
	if(env->backref & 1<<n)     // sole reason stat() has env param
		used = 1;
	if(++st.p <= 0)
		st.o |= 1;
	return addStat(st, next, env);
}

// Assembly:
pushq %r14
pushq %rbx
subq $0x18, %rsp
movq %rsi, %rbx
movq %rdi, %r14
movq 0x20(%rdi), %rdi
movq (%rdi), %rax
callq *0x10(%rax)
movq %rax, 0x8(%rsp)
movl %edx, 0x10(%rsp)
movq %rdx, %rax
shrq $0x20, %rax
movw %ax, 0x14(%rsp)
movswl 0x38(%rbx), %ecx
movl 0x18(%r14), %esi
btl %esi, %ecx
jae 0xa5b4
movb $0x1, 0x1a(%r14)
incb %al
movb %al, 0x14(%rsp)
jne 0xa5c7
shrq $0x28, %rdx
orb $0x1, %dl
movb %dl, 0x15(%rsp)
movq 0x10(%r14), %rsi
leaq 0x8(%rsp), %rdi
movq %rbx, %rdx
callq 0xa491
movabsq $0xffffffffffff, %rcx   # imm = 0xFFFFFFFFFFFF
andq %rcx, %rdx
addq $0x18, %rsp
popq %rbx
popq %r14
retq
nop
// File: /workspace/github_cpp_makefile_star2_O3/arnoldrobbins[P]mcilroy-regex/re2.cpp
// Function: Alt::stat(Cenv*)
Stat Alt::stat(Cenv *env)
{
	Stat st1 = left->stat(env);
	Stat st2 = right->stat(env);
	Stat st = addStat(st1, st2);
	st.n = st1.n<=st2.n? st1.n: st2.n;
	if(++st.a <= 0)
		st.o |= 1;
	return addStat(st, next, env);
}

// Assembly:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x30, %rsp
movq %rsi, %rbx
movq %rdi, %r14
movq 0x20(%rdi), %rdi
movq (%rdi), %rax
callq *0x10(%rax)
movq %rax, %r15
leaq 0x20(%rsp), %r12
movq %rax, (%r12)
movl %edx, 0x8(%r12)
shrq $0x20, %rdx
movw %dx, 0xc(%r12)
movq 0x28(%r14), %rdi
movq (%rdi), %rax
movq %rbx, %rsi
callq *0x10(%rax)
movq %rax, %r13
leaq 0x10(%rsp), %rsi
movq %rax, (%rsi)
movl %edx, 0x8(%rsi)
shrq $0x20, %rdx
movw %dx, 0xc(%rsi)
movq %r12, %rdi
callq 0xa6ac
movq %rax, (%rsp)
movq %rdx, %rax
shrq $0x20, %rax
movw %ax, 0xc(%rsp)
cmpl %r13d, %r15d
cmovll %r15d, %r13d
movl %r13d, (%rsp)
leal 0x1(%rdx), %eax
movl %eax, 0x8(%rsp)
testl %edx, %edx
jns 0xa682
shrq $0x28, %rdx
orb $0x1, %dl
movb %dl, 0xd(%rsp)
movq 0x10(%r14), %rsi
movq %rsp, %rdi
movq %rbx, %rdx
callq 0xa491
movabsq $0xffffffffffff, %rcx   # imm = 0xFFFFFFFFFFFF
andq %rcx, %rdx
addq $0x30, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
// File: /workspace/github_cpp_makefile_star2_O3/arnoldrobbins[P]mcilroy-regex/re2.cpp
// Function: Rep::stat(Cenv*)
Stat Rep::stat(Cenv *env)
{
	Stat st = rex->stat(env);
	if(st.n == 1 && st.c+st.b == 0)
		st.s++;
	st.c++;
	st.n *= lo;
	if(st.n<0 || st.c<=0)
		st.o |= 1;
	return addStat(st, next, env);
}

// Assembly:
pushq %r14
pushq %rbx
subq $0x18, %rsp
movq %rsi, %rbx
movq %rdi, %r14
movq 0x28(%rdi), %rdi
movq (%rdi), %rax
callq *0x10(%rax)
movq %rax, 0x8(%rsp)
movl %edx, 0x10(%rsp)
movq %rdx, %rcx
shrq $0x20, %rcx
movw %cx, 0x14(%rsp)
movq %rax, %rcx
shrq $0x28, %rcx
cmpl $0x1, %eax
jne 0xa85f
movq %rax, %rsi
shrq $0x30, %rsi
orb %cl, %sil
jne 0xa85f
movq %rax, %rsi
shrq $0x20, %rsi
incb %sil
movb %sil, 0xc(%rsp)
incb %cl
setne %sil
movb %cl, 0xd(%rsp)
movl 0x18(%r14), %ecx
imull %eax, %ecx
movl %ecx, 0x8(%rsp)
testl %ecx, %ecx
setns %al
testb %sil, %al
jne 0xa889
shrq $0x28, %rdx
orb $0x1, %dl
movb %dl, 0x15(%rsp)
movq 0x10(%r14), %rsi
leaq 0x8(%rsp), %rdi
movq %rbx, %rdx
callq 0xa491
movabsq $0xffffffffffff, %rcx   # imm = 0xFFFFFFFFFFFF
andq %rcx, %rdx
addq $0x18, %rsp
popq %rbx
popq %r14
retq
nop
// File: /workspace/github_cpp_makefile_star2_O3/arnoldrobbins[P]mcilroy-regex/re2.cpp
// Function: hard(Stat*)
int hard(Stat *stat)
{
	if(stat->a | stat->b)
		return HARD;
	else if(stat->t <=1 && stat->c == 0)
		return EASY;
	else if(stat->t)
		return HARD;
	else if(stat->c<=1 || stat->s==stat->c)
		return EASY;
	else
		return HARD;
}

// Assembly:
movzbl 0x6(%rdi), %ecx
movl $0x800, %eax            # imm = 0x800
orl 0x8(%rdi), %ecx
je 0xa95e
retq
movb 0x7(%rdi), %dl
cmpb $0x1, %dl
ja 0xa95d
movb 0x5(%rdi), %cl
testb %cl, %cl
je 0xa987
testb %dl, %dl
jne 0xa95d
movl $0x0, %eax
cmpb $0x1, %cl
je 0xa95d
xorl %eax, %eax
cmpb %cl, 0x4(%rdi)
setne %al
shll $0xb, %eax
retq
xorl %eax, %eax
retq
// File: /workspace/github_cpp_makefile_star2_O3/arnoldrobbins[P]mcilroy-regex/re2.cpp
// Function: Conj::serialize(int)
int Conj::serialize(int n)
{
	serial = n++;
	n = left->serialize(n);
	n = right->serialize(n);
	return next? next->serialize(n): n;
}

// Assembly:
pushq %rbx
movq %rdi, %rbx
leal 0x1(%rsi), %eax
movw %si, 0xa(%rdi)
movq 0x18(%rdi), %rdi
movq (%rdi), %rcx
movl %eax, %esi
callq *0x18(%rcx)
movq 0x20(%rbx), %rdi
movq (%rdi), %rcx
movl %eax, %esi
callq *0x18(%rcx)
movq 0x10(%rbx), %rdi
testq %rdi, %rdi
je 0xaa4c
movq (%rdi), %rcx
movq 0x18(%rcx), %rcx
movl %eax, %esi
popq %rbx
jmpq *%rcx
popq %rbx
retq