LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_cpp_makefile_star2_O1/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
subq $0x18, %rsp
movq %rcx, %rbx
movq %rdx, 0x8(%rsp)
movq %rsi, %r13
movq %rdi, %r12
movq 0x8(%rcx), %rax
movq 0x18(%rcx), %rbp
movq 0x18(%rax), %r15
movq %rsi, 0x10(%rsp)
movslq 0x20(%r12), %rax
leaq (%rax,%r13), %rcx
cmpq %rbp, %rcx
ja 0x888c
movb $0x1, %r14b
cmpq %rbp, %r13
jae 0x8881
movq 0x18(%r12), %rcx
movq 0x28(%r12), %rdx
movl $0xffffffff, %esi       # imm = 0xFFFFFFFF
testl %esi, %esi
js 0x87e7
movzbl (%r13), %edi
movb (%r15,%rdi), %dil
movl %esi, %r8d
cmpb %dil, 0x1(%rcx,%r8)
je 0x87e7
movl (%rdx,%r8,4), %esi
testl %esi, %esi
jns 0x87d5
movslq %esi, %rsi
leaq 0x1(%rsi), %rdi
movb 0x1(%rcx,%rsi), %r8b
movzbl (%r13), %r9d
cmpb (%r15,%r9), %r8b
cmovel %edi, %esi
leal 0x1(%rsi), %edi
incq %r13
cmpl %eax, %edi
je 0x8813
cmpq %rbp, %r13
jne 0x87c8
movq %rbp, %r13
jmp 0x8881
addq 0x10(%rsp), %rax
movq %r13, %rcx
subq %rax, %rcx
movq 0x418(%rbx), %rax
movq %rcx, (%rax)
movq 0x10(%r12), %rdi
testq %rdi, %rdi
je 0x883f
movq (%rdi), %rax
movq %r13, %rsi
movq 0x8(%rsp), %rdx
jmp 0x884c
movq 0x8(%rsp), %rdi
movq (%rdi), %rax
movq %r13, %rsi
xorl %edx, %edx
movq %rbx, %rcx
callq *0x20(%rax)
leal -0x1(%rax), %ecx
cmpl $0x2, %ecx
jae 0x8864
movl $0x2, 0x4(%rsp)
jmp 0x8871
cmpl $0x3, %eax
jne 0x8876
movl $0x3, 0x4(%rsp)
xorl %r14d, %r14d
jmp 0x8881
movslq 0x20(%r12), %rax
subq %rax, %r13
incq %r13
testb %r14b, %r14b
jne 0x879b
jmp 0x8894
movl $0x0, 0x4(%rsp)
movl 0x4(%rsp), %eax
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O1/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 0x898a
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 0x8921
movq 0x10(%rsi), %rsi
testq %rsi, %rsi
jne 0x8912
jmp 0x898a
cmpb $0x0, 0x1(%rsi)
movq 0x8(%rsi), %rsi
jne 0x8935
incq %r12
cmpq %rax, %r12
jne 0x890a
jmp 0x898a
testq %rsi, %rsi
je 0x8951
leaq 0x1(%r12), %rdx
movq %r13, %rdi
movq %r15, %rcx
movq %r14, %r8
callq 0x88de
movl %eax, %ebx
jmp 0x8953
xorl %ebx, %ebx
movl %ebx, %eax
andl $-0x2, %eax
cmpl $0x2, %eax
je 0x898a
incq %r12
movq 0x10(%r13), %rdi
testq %rdi, %rdi
je 0x8974
movq (%rdi), %rax
movq %r12, %rsi
movq %r15, %rdx
jmp 0x897f
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_O1/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 0x89ce
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
movb (%rax), %cl
cmpb (%r14), %cl
jne 0x8a10
cmpb $0x0, 0x1(%r14)
je 0x8a47
incq %r14
leaq 0x8(%rax), %r15
cmpq $0x0, 0x8(%rax)
jne 0x8a0c
movl $0x18, %edi
callq 0x5170
movb (%r14), %cl
movb %cl, (%rax)
movb $0x0, 0x1(%rax)
xorps %xmm0, %xmm0
movups %xmm0, 0x8(%rax)
movq %rax, (%r15)
incl %ebp
jmp 0x8a38
leaq 0x10(%rax), %r15
cmpq $0x0, 0x10(%rax)
jne 0x8a38
movl $0x18, %edi
callq 0x5170
movb (%r14), %cl
movb %cl, (%rax)
movb $0x0, 0x1(%rax)
xorps %xmm0, %xmm0
movups %xmm0, 0x8(%rax)
movq %rax, (%r15)
movq (%r15), %rax
testq %rax, %rax
jne 0x89d3
movl $0x1, %eax
jmp 0x8a5f
cmpl 0x18(%rbx), %ebp
jge 0x8a51
movl %ebp, 0x18(%rbx)
jmp 0x8a59
cmpl 0x1c(%rbx), %ebp
jle 0x8a59
movl %ebp, 0x1c(%rbx)
movb $0x1, 0x1(%rax)
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O1/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 0x8ac2
addq %r9, %r8
movq 0x8(%r8), %r8
subq %rax, %r8
leaq (%rsi,%r8), %r9
cmpq 0x18(%rcx), %r9
ja 0x8ac2
addq 0x10(%rcx), %rax
movq 0x8(%rcx), %r9
movq 0x18(%r9), %r9
testq %r8, %r8
jle 0x8ac5
decq %r8
movzbl (%rsi), %r10d
incq %rsi
movb (%r9,%r10), %r10b
movzbl (%rax), %r11d
incq %rax
cmpb (%r9,%r11), %r10b
je 0x8aa2
xorl %eax, %eax
retq
movq 0x10(%rdi), %rdi
testq %rdi, %rdi
je 0x8ad7
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_O1/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)
movq $0x0, (%r14)
leaq 0x9cfb(%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 0x8138
testl %eax, %eax
jne 0x8b8b
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)
leaq 0x99de(%rip), %rax      # 0x12570
movq %rax, 0x10(%rsp)
cmpb $0x11, 0x18(%rsp)
je 0x8bae
movq 0x20(%rsp), %rdi
testq %rdi, %rdi
je 0x8bae
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 0x99a5(%rip), %rax      # 0x12570
movq %rax, 0x10(%rsp)
cmpb $0x11, 0x18(%rsp)
je 0x8bdf
movq %r14, %rdi
callq 0x53e2
movq %rbx, %rdi
callq 0x52b0
nop
// File: /workspace/github_cpp_makefile_star2_O1/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 0x8138
movl %eax, %ecx
movl $0x3, %eax
testl %ecx, %ecx
jne 0x8c6d
addq %r13, %r12
addq $0x8, %r12
movq 0x10(%r15), %rdi
movq 0x18(%r15), %rdx
testq %rdi, %rdi
je 0x8c51
movq (%rdi), %rax
movq %r14, %rsi
jmp 0x8c5c
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_O1/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), %r12
movq %r12, 0x8(%rdi)
movl $0x14, 0x10(%rdi)
testl %esi, %esi
je 0x8d07
movq %rcx, %r14
movl %edx, %ebx
movl %esi, %ebp
movq %rdi, %r15
addq $0x8, %rdi
movq 0x2c8(%rcx), %r13
subl %esi, %ebx
xorl %eax, %eax
cmpl $0x14, %ebx
jl 0x8cc8
movq %rdi, (%rsp)
movl %ebx, %esi
callq 0xa0c6
movq (%rsp), %rdi
testl %eax, %eax
je 0x8cd7
orb $0x4, 0x1(%r14)
movl %ebp, 0x4(%r15)
jmp 0x8d07
movq (%rdi), %rax
movslq %ebp, %rcx
shlq $0x4, %rcx
addq %rcx, %r13
incl %ebx
xorl %ecx, %ecx
pcmpeqd %xmm0, %xmm0
movups (%r13,%rcx), %xmm1
movups %xmm1, (%rax,%rcx)
movdqu %xmm0, (%r13,%rcx)
addq $0x10, %rcx
decl %ebx
testl %ebx, %ebx
jg 0x8cec
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 %r12, %rdi
sete %al
testq %rdi, %rdi
sete %cl
orb %al, %cl
jne 0x8d35
callq 0x5200
movq %rbx, %rdi
callq 0x52b0
nop
// File: /workspace/github_cpp_makefile_star2_O1/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 0x8d74
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 0x8d62
retq
nop
// File: /workspace/github_cpp_makefile_star2_O1/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 0x8c78
movl $0x3, %ebx
testb $0x4, 0x1(%r14)
jne 0x8ee0
movq %r14, %rdi
movq %r12, %rsi
movq %r15, %rdx
movl $0x2, %ecx
callq 0x8138
testl %eax, %eax
jne 0x8ee0
movzwl 0xa(%r12), %eax
leaq 0x8(%rsp), %rdx
movb $0x11, 0x8(%rdx)
movq $0x0, 0x10(%rdx)
leaq 0x9a85(%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 0x8e80
movslq 0x28(%rsp), %rsi
testq %rsi, %rsi
je 0x8e4a
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 0x8e38
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 0x8ebd
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 0x8eab
leaq 0x96ac(%rip), %rax      # 0x12570
movq %rax, 0x8(%rsp)
cmpb $0x11, 0x10(%rsp)
je 0x8ee0
movq 0x18(%rsp), %rdi
testq %rdi, %rdi
je 0x8ee0
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 0x8efe
callq 0x5200
movl %ebx, %eax
addq $0x180, %rsp            # imm = 0x180
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
jmp 0x8f13
movq %rax, %rbx
leaq 0x9653(%rip), %rax      # 0x12570
movq %rax, 0x8(%rsp)
cmpb $0x11, 0x10(%rsp)
je 0x8f3e
movq 0x18(%rsp), %rdi
testq %rdi, %rdi
je 0x8f3e
movq (%rdi), %rax
callq *0x8(%rax)
jmp 0x8f3e
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 0x8f5c
callq 0x5200
movq %rbx, %rdi
callq 0x52b0
// File: /workspace/github_cpp_makefile_star2_O1/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 0x8138
movl %eax, %ecx
movl $0x3, %eax
testl %ecx, %ecx
jne 0x8fb9
movq 0x10(%r15), %rdi
movq 0x18(%r15), %rdx
testq %rdi, %rdi
je 0x8fa5
movq (%rdi), %rax
movq %r14, %rsi
jmp 0x8fb0
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_O1/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 0x98e0(%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 0x990a(%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 0x9542(%rip), %r14      # 0x12570
movq %r14, 0x30(%rsp)
cmpb $0x11, 0x38(%rsp)
je 0x904a
movq 0x40(%rsp), %rdi
testq %rdi, %rdi
je 0x904a
movq (%rdi), %rax
callq *0x8(%rax)
movq %r14, 0x8(%rsp)
cmpb $0x11, 0x10(%rsp)
je 0x9066
movq 0x18(%rsp), %rdi
testq %rdi, %rdi
je 0x9066
movq (%rdi), %rax
callq *0x8(%rax)
movl %ebx, %eax
addq $0x60, %rsp
popq %rbx
popq %r14
popq %r15
retq
movq %rax, %rbx
leaq 0x94f4(%rip), %r15      # 0x12570
movq %r15, 0x30(%rsp)
cmpb $0x11, 0x38(%rsp)
je 0x9090
movq %r14, %rdi
callq 0x53f6
movq %r15, 0x8(%rsp)
cmpb $0x11, 0x10(%rsp)
je 0x90ac
movq 0x18(%rsp), %rdi
testq %rdi, %rdi
je 0x90ac
movq (%rdi), %rax
callq *0x8(%rax)
movq %rbx, %rdi
callq 0x52b0
// File: /workspace/github_cpp_makefile_star2_O1/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 0x8138
movl $0x3, %ebp
testl %eax, %eax
jne 0x93b4
cmpq %r14, 0x20(%r15)
jne 0x9398
movl 0x28(%r15), %eax
movq 0x18(%r15), %rcx
cmpl 0x18(%rcx), %eax
jle 0x9398
movl $0x801, %ecx            # imm = 0x801
andl (%rbx), %ecx
xorl %eax, %eax
cmpl $0x800, %ecx            # imm = 0x800
jne 0x93af
movq %rbx, %rdi
movq %r15, %rsi
movq %r14, %rdx
movl $0x4, %ecx
callq 0x8138
testl %eax, %eax
jne 0x93b4
movq 0x10(%r15), %rdi
movq 0x30(%r15), %rdx
testq %rdi, %rdi
je 0x93c1
movq (%rdi), %rax
movq %r14, %rsi
jmp 0x93cc
movq 0x18(%r15), %rdi
movl 0x28(%r15), %esi
movq 0x30(%r15), %rcx
movq %r14, %rdx
movq %rbx, %r8
callq 0x90fe
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 0x93af
nop
// File: /workspace/github_cpp_makefile_star2_O1/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 $0x58, %rsp
movq %rcx, %rbx
movq %rdx, %r14
movq %rsi, %r15
movq %rdi, %r12
movq 0x18(%rcx), %r13
subq %rsi, %r13
leaq 0x18(%rsp), %rbp
movq %rbp, %rdi
movl %r13d, %edx
callq 0x9574
movq %r12, 0x8(%rsp)
movq 0x18(%r12), %rdi
movq (%rdi), %rax
movq %r15, %rsi
movq %rbp, %rdx
movq %rbx, 0x10(%rsp)
movq %rbx, %rcx
callq *0x20(%rax)
movl $0x3, %ebp
cmpl $0x3, %eax
je 0x9500
testl %r13d, %r13d
js 0x94fe
andl $0x7fffffff, %r13d      # imm = 0x7FFFFFFF
xorl %r12d, %r12d
movl %r13d, %eax
shrl $0x3, %eax
movq 0x38(%rsp), %rcx
movzbl (%rcx,%rax), %eax
movl %r13d, %ecx
andl $0x7, %ecx
btl %ecx, %eax
jb 0x94ee
movq 0x8(%rsp), %rax
movq 0x10(%rax), %rdx
testq %rdx, %rdx
movq %rdx, %rdi
cmoveq %r14, %rdi
leaq (%r15,%r13), %rsi
cmovneq %r14, %rdx
movq (%rdi), %rax
movq 0x10(%rsp), %rcx
callq *0x20(%rax)
movl %eax, %ecx
andl $-0x2, %ecx
cmpl $0x1, %eax
movl %r12d, %edx
cmovel %eax, %edx
cmpl $0x2, %ecx
cmovnel %edx, %r12d
cmovel %eax, %ebx
movl %ebx, %ebp
je 0x9500
decq %r13
leal 0x1(%r13), %eax
movl %r12d, %ebp
testl %eax, %eax
jg 0x9492
jmp 0x9500
xorl %ebp, %ebp
leaq 0x90d9(%rip), %rax      # 0x125e0
leaq 0x44(%rsp), %rcx
movq %rax, -0x2c(%rcx)
movq -0xc(%rcx), %rdi
cmpq %rcx, %rdi
sete %al
testq %rdi, %rdi
sete %cl
orb %al, %cl
jne 0x9529
callq 0x5200
leaq 0x9040(%rip), %rax      # 0x12570
movq %rax, 0x18(%rsp)
cmpb $0x11, 0x20(%rsp)
je 0x954c
movq 0x28(%rsp), %rdi
testq %rdi, %rdi
je 0x954c
movq (%rdi), %rax
callq *0x8(%rax)
movl %ebp, %eax
addq $0x58, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
jmp 0x955f
movq %rax, %rbx
leaq 0x18(%rsp), %rdi
callq 0x9af4
movq %rbx, %rdi
callq 0x52b0
// File: /workspace/github_cpp_makefile_star2_O1/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
movq %rsi, %r14
movl (%rcx), %eax
testb %al, %al
jns 0x966d
xorl %ebp, %ebp
cmpq %r14, 0x18(%rbx)
jne 0x9776
movl $0x2, %ebp
testb $0x4, %al
jne 0x9776
movq 0x8(%rbx), %rcx
movq (%rcx), %r15
subq 0x10(%rbx), %r14
btl $0xb, %eax
jb 0x96b9
movslq %r14d, %rax
movq 0x418(%rbx), %rdi
movq %rax, 0x8(%rdi)
addq $0x10, %rdi
movq 0x2c8(%rbx), %rsi
addq $0x10, %rsi
movslq %r15d, %rdx
shlq $0x4, %rdx
callq 0x5290
jmp 0x9776
movq 0x418(%rbx), %rax
movq 0x8(%rax), %rax
testq %rax, %rax
js 0x9706
movslq %r14d, %rcx
movl $0x1, %ebp
cmpq %rax, %rcx
jl 0x9776
jne 0x9706
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 0x9783
testl %eax, %eax
jle 0x9776
movslq %r14d, %rax
movq 0x418(%rbx), %rdi
movq %rax, 0x8(%rdi)
addq $0x10, %rdi
movq 0x2c8(%rbx), %rsi
addq $0x10, %rsi
movslq %r15d, %rdx
shlq $0x4, %rdx
callq 0x5290
movl 0x20(%rbx), %ebp
cmpl %ebp, 0x180(%rbx)
jg 0x9757
leaq 0x178(%rbx), %rdi
movl %ebp, %esi
callq 0xa058
testl %eax, %eax
je 0x9757
orb $0x4, 0x1(%rbx)
movl $0x3, %ebp
jmp 0x9776
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_O1/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 0x9889
movzwl 0x8(%rsi), %ecx
movzwl 0x8(%rdi), %edx
movl $0xffffffff, %eax       # imm = 0xFFFFFFFF
cmpw %dx, %cx
jg 0x9890
jl 0x989c
movq (%rdi), %r8
movq (%rsi), %r9
cmpq %r9, %r8
ja 0x9890
movl $0x1, %eax
jb 0x9890
xorl %r8d, %r8d
movq %rdi, %r15
movq %r15, %r9
addq $0x10, %r15
cmpw %dx, 0x18(%r9)
jne 0x97e6
cmpb $0x4, 0xa(%r15)
jne 0x9809
leal -0x1(%r8), %r9d
testl %r8d, %r8d
movl %r9d, %r8d
jg 0x97e6
jmp 0x980e
incl %r8d
jmp 0x97e6
xorl %edx, %edx
movq %rsi, %r12
movq %r12, %r8
addq $0x10, %r12
cmpw %cx, 0x18(%r8)
jne 0x9813
cmpb $0x4, 0xa(%r12)
jne 0x9836
leal -0x1(%rdx), %r8d
testl %edx, %edx
movl %r8d, %edx
jg 0x9813
jmp 0x983a
incl %edx
jmp 0x9813
movq (%r12), %rcx
movq (%r15), %rdx
cmpq %rdx, %rcx
ja 0x9890
movl $0xffffffff, %eax       # imm = 0xFFFFFFFF
jb 0x9890
addq $0x10, %rdi
addq $0x10, %rsi
movq %r15, %rdx
movq %r12, %rcx
callq 0x9783
testl %eax, %eax
jne 0x9890
addq $0x10, %r15
addq $0x10, %r12
cmpq %rbx, %r12
setb %cl
cmpq %r14, %r15
setb %al
jae 0x9889
movq %r15, %rdi
movq %r12, %rsi
cmpq %rbx, %r12
jb 0x97aa
testb %cl, %cl
jne 0x989c
movzbl %al, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
callq 0x5110
// File: /workspace/github_cpp_makefile_star2_O1/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 0x9977
movq %r8, %rbx
movq %rcx, %r12
movq %rdx, %r8
movq %rsi, %r15
movq %rdi, %r14
leaq 0x10(%rsp), %r13
movq %r13, %rdi
movq %r14, %rsi
movl %r9d, %edx
movq %r15, %rcx
callq 0x9b42
movl (%r13), %eax
movl $0xc, %ebp
btl $0xa, %eax
jb 0x99c8
movq %rbx, 0x8(%rsp)
xorl %r13d, %r13d
testb $0x4, %al
cmoveq %r12, %r13
testq %r13, %r13
je 0x992e
xorl %eax, %eax
pcmpeqd %xmm0, %xmm0
xorl %ecx, %ecx
cmpq %rcx, (%r14)
jb 0x992e
movq 0x2d8(%rsp), %rdx
movdqu %xmm0, (%rdx,%rax)
incq %rcx
addq $0x10, %rax
cmpq %rcx, %r13
jne 0x9910
leaq 0x9f8b(%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 0x9981
btl $0xc, %ecx
jb 0x99c8
incq %r15
cmpq 0x28(%rsp), %r15
ja 0x99c8
movq 0x428(%rsp), %rax
incq (%rax)
jmp 0x993f
movl $0x2, %ebp
jmp 0x9a49
btl $0xa, %ecx
movl $0xc, %ebp
jb 0x99c8
testq %r13, %r13
je 0x99c6
movq 0x428(%rsp), %rax
xorl %ecx, %ecx
pcmpeqd %xmm0, %xmm0
xorl %edx, %edx
movq 0x8(%rsp), %rsi
cmpq %rdx, (%r14)
jae 0x99b2
movdqu %xmm0, (%rsi,%rcx)
jmp 0x99ba
movups (%rax,%rcx), %xmm1
movups %xmm1, (%rsi,%rcx)
incq %rdx
addq $0x10, %rcx
cmpq %rdx, %r13
jne 0x99a6
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 0x99e9
callq 0x5200
leaq 0x2e8(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
sete %al
testq %rdi, %rdi
sete %cl
orb %al, %cl
jne 0x9a0a
callq 0x5200
leaq 0x198(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
sete %al
testq %rdi, %rdi
sete %cl
orb %al, %cl
jne 0x9a2b
callq 0x5200
leaq 0x48(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
sete %al
testq %rdi, %rdi
sete %cl
orb %al, %cl
jne 0x9a49
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 0x9ca4
movq %rbx, %rdi
callq 0x52b0
// File: /workspace/github_cpp_makefile_star2_O1/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
andl $0x30, %edx
orl 0x10(%rsi), %edx
movq %rdi, %rbx
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, %ecx
movl %ecx, 0x30(%rdi)
leaq 0x188(%rdi), %r15
movq %r15, 0x178(%rdi)
movl %ecx, 0x180(%rdi)
leaq 0x2c8(%rdi), %rax
movq %rax, 0x8(%rsp)
leaq 0x2d8(%rdi), %r13
movq %r13, 0x2c8(%rdi)
movl %ecx, 0x2d0(%rdi)
leaq 0x418(%rdi), %r12
leaq 0x428(%rdi), %r14
movq %r14, 0x418(%rdi)
movl %ecx, 0x420(%rdi)
movl (%rsi), %ebp
xorl %eax, %eax
cmpl %ecx, %ebp
jl 0x9be2
movq 0x8(%rsp), %rdi
movl %ebp, %esi
callq 0xa0c6
testl %eax, %eax
jne 0x9bfe
xorl %eax, %eax
cmpl %ebp, 0x420(%rbx)
jg 0x9bfa
movq %r12, %rdi
movl %ebp, %esi
callq 0xa0c6
testl %eax, %eax
je 0x9c11
orb $0x4, 0x1(%rbx)
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
xorl %eax, %eax
movq %rax, 0x20(%rbx)
movq 0x418(%rbx), %rcx
movq %rax, (%rcx)
movq $-0x1, 0x8(%rcx)
jmp 0x9c02
movq %rax, %rbp
movq (%r12), %rdi
cmpq %r14, %rdi
sete %al
testq %rdi, %rdi
sete %cl
orb %al, %cl
jne 0x9c47
callq 0x5200
movq 0x8(%rsp), %rax
movq (%rax), %rdi
cmpq %r13, %rdi
sete %al
testq %rdi, %rdi
sete %cl
orb %al, %cl
jne 0x9c64
callq 0x5200
movq 0x178(%rbx), %rdi
cmpq %r15, %rdi
sete %al
testq %rdi, %rdi
sete %cl
orb %al, %cl
jne 0x9c80
callq 0x5200
movq 0x28(%rbx), %rdi
cmpq 0x10(%rsp), %rdi
sete %al
testq %rdi, %rdi
sete %cl
orb %al, %cl
jne 0x9c9b
callq 0x5200
movq %rbp, %rdi
callq 0x52b0
nop
// File: /workspace/github_cpp_makefile_star2_O1/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
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
leal (%rsi,%rsi), %ebp
movslq %ebp, %rax
shlq $0x4, %rax
testl %esi, %esi
movq $-0x1, %rdi
cmovnsq %rax, %rdi
callq 0x5030
movq %rax, %r14
movq (%rbx), %r15
movslq 0x8(%rbx), %rdx
shlq $0x4, %rdx
movq %rax, %rdi
movq %r15, %rsi
callq 0x5290
leaq 0x10(%rbx), %rax
cmpq %rax, %r15
sete %al
testq %r15, %r15
sete %cl
orb %al, %cl
jne 0xa0b3
movq %r15, %rdi
callq 0x5200
movq %r14, (%rbx)
movl %ebp, 0x8(%rbx)
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O1/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 %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
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, 0x9796(%rip)      # 0x139cf
jne 0xa28b
leaq 0x332e(%rip), %rax      # 0xd570
xorl %ecx, %ecx
leaq 0x98b5(%rip), %rdx      # 0x13b00
movzbl (%rax), %esi
movb %cl, (%rsi,%rdx)
incq %rcx
addq $0xe, %rax
cmpq $0x19, %rcx
jne 0xa24b
xorl %r14d, %r14d
leaq 0x9768(%rip), %r12      # 0x139d0
leaq 0x9661(%rip), %r13      # 0x138d0
movb %r14b, (%r14,%r12)
movl %r14d, %edi
callq 0x52e0
movb %al, (%r14,%r13)
incq %r14
cmpq $0x100, %r14            # imm = 0x100
jne 0xa26f
movl (%rbx), %eax
testb $0x2, %al
leaq 0x973a(%rip), %rcx      # 0x139d0
leaq 0x9633(%rip), %rdx      # 0x138d0
cmoveq %rcx, %rdx
movl %eax, %ecx
andb $0x1, %cl
btl $0x9, %eax
movzbl %cl, %eax
movl $0x2, %ecx
cmovael %eax, %ecx
movq %rdx, 0x28(%rbx)
movb %cl, 0x3a(%rbx)
xorl %eax, %eax
testb %cl, %cl
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)
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
// File: /workspace/github_cpp_makefile_star2_O1/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 0xa393
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 0xa54f
movq %rdx, %rcx
movabsq $0xffffffffffff, %rdx   # imm = 0xFFFFFFFFFFFF
andq %rcx, %rdx
jmp 0xa39a
movq (%rbx), %rax
movq 0x8(%rbx), %rdx
addq $0x10, %rsp
popq %rbx
retq
// File: /workspace/github_cpp_makefile_star2_O1/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
xorps %xmm0, %xmm0
movq %rsp, %rax
movaps %xmm0, (%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 0xa34f
movabsq $0xffffffffffff, %rcx   # imm = 0xFFFFFFFFFFFF
andq %rcx, %rdx
addq $0x18, %rsp
retq
// File: /workspace/github_cpp_makefile_star2_O1/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)
shrq $0x20, %rdx
movw %dx, 0x14(%rsp)
movswl 0x38(%rbx), %eax
movl 0x18(%r14), %ecx
btl %ecx, %eax
jae 0xa463
movb $0x1, 0x1a(%r14)
incb 0x14(%rsp)
jne 0xa46e
orb $0x1, 0x15(%rsp)
movq 0x10(%r14), %rsi
leaq 0x8(%rsp), %rdi
movq %rbx, %rdx
callq 0xa34f
movabsq $0xffffffffffff, %rcx   # imm = 0xFFFFFFFFFFFF
andq %rcx, %rdx
addq $0x18, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_cpp_makefile_star2_O1/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 %r12
pushq %rbx
subq $0x38, %rsp
movq %rsi, %rbx
movq %rdi, %r14
movq 0x20(%rdi), %rdi
movq (%rdi), %rax
callq *0x10(%rax)
leaq 0x28(%rsp), %r15
movq %rax, (%r15)
movl %edx, 0x8(%r15)
shrq $0x20, %rdx
movw %dx, 0xc(%r15)
movq 0x28(%r14), %rdi
movq (%rdi), %rax
movq %rbx, %rsi
callq *0x10(%rax)
leaq 0x18(%rsp), %r12
movq %rax, (%r12)
movl %edx, 0x8(%r12)
shrq $0x20, %rdx
movw %dx, 0xc(%r12)
movq %r15, %rdi
movq %r12, %rsi
callq 0xa54f
movq %rax, 0x8(%rsp)
movq %rdx, %rax
shrq $0x20, %rax
movw %ax, 0x14(%rsp)
movl (%r15), %eax
movl (%r12), %ecx
cmpl %ecx, %eax
cmovll %eax, %ecx
movl %ecx, 0x8(%rsp)
leal 0x1(%rdx), %eax
movl %eax, 0x10(%rsp)
testl %edx, %edx
jns 0xa525
orb $0x1, 0x15(%rsp)
movq 0x10(%r14), %rsi
leaq 0x8(%rsp), %rdi
movq %rbx, %rdx
callq 0xa34f
movabsq $0xffffffffffff, %rcx   # imm = 0xFFFFFFFFFFFF
andq %rcx, %rdx
addq $0x38, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
// File: /workspace/github_cpp_makefile_star2_O1/arnoldrobbins[P]mcilroy-regex/re2.cpp
// Function: addStat(Stat&, Stat&)
static Stat addStat(Stat &st1, Stat &st2)
{	
	Stat st = st1;
	st.n += st2.n;
	st.s += st2.s;
	st.c += st2.c;
	st.b += st2.b;
	st.a += st2.a;
	st.p += st2.p;
	st.t += st2.t;
	if(st.n<st1.n || st.c<st1.c || st.b<st1.b ||
	   st.a<st1.a || st.p<st1.p || st.t<st1.t)
		st.o |= 1;
	return st;
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movq (%rdi), %rcx
movq %rcx, %r8
shrq $0x28, %r8
movq %rcx, %r9
shrq $0x30, %r9
movq %rcx, %r10
shrq $0x38, %r10
movq 0x8(%rdi), %rdx
movl (%rsi), %eax
addl %ecx, %eax
addb 0x5(%rsi), %r8b
addb 0x6(%rsi), %r9b
movl 0x8(%rsi), %r11d
addl %edx, %r11d
movl %r11d, %ebx
movabsq $-0x10000000000, %r14   # imm = 0xFFFFFF0000000000
andq %rdx, %r14
movabsq $0xfe0000000000, %r15   # imm = 0xFE0000000000
andq %rdx, %r15
shrq $0x20, %rdx
addb 0xc(%rsi), %dl
movzbl %dl, %r12d
movq %r12, %rdx
shlq $0x20, %rdx
orq %rbx, %rdx
orq %r14, %rdx
addb 0x7(%rsi), %r10b
movabsq $-0xff0000000001, %rbx  # imm = 0xFFFF00FFFFFFFFFF
andq %rdx, %rbx
orq %r15, %rbx
btsq $0x28, %rbx
cmpb 0x7(%rdi), %r10b
cmovbq %rbx, %rdx
cmpb 0xc(%rdi), %r12b
cmovbq %rbx, %rdx
cmpl 0x8(%rdi), %r11d
cmovlq %rbx, %rdx
cmpb 0x6(%rdi), %r9b
cmovbq %rbx, %rdx
cmpb 0x5(%rdi), %r8b
cmovbq %rbx, %rdx
cmpl (%rdi), %eax
cmovlq %rbx, %rdx
shrq $0x20, %rcx
addb 0x4(%rsi), %cl
movzbl %r10b, %esi
shlq $0x38, %rsi
movzbl %r9b, %edi
shlq $0x30, %rdi
orq %rsi, %rdi
movzbl %r8b, %esi
shlq $0x28, %rsi
orq %rdi, %rsi
movzbl %cl, %ecx
shlq $0x20, %rcx
orq %rsi, %rcx
orq %rcx, %rax
popq %rbx
popq %r12
popq %r14
popq %r15
retq
nop
// File: /workspace/github_cpp_makefile_star2_O1/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)
shrq $0x20, %rdx
movw %dx, 0x14(%rsp)
cmpl $0x1, %eax
jne 0xa6e2
movb 0xe(%rsp), %cl
orb 0xd(%rsp), %cl
jne 0xa6e2
incb 0xc(%rsp)
incb 0xd(%rsp)
sete %cl
imull 0x18(%r14), %eax
movl %eax, 0x8(%rsp)
testl %eax, %eax
sets %al
orb %cl, %al
testb $0x1, %al
je 0xa702
orb $0x1, 0x15(%rsp)
movq 0x10(%r14), %rsi
leaq 0x8(%rsp), %rdi
movq %rbx, %rdx
callq 0xa34f
movabsq $0xffffffffffff, %rcx   # imm = 0xFFFFFFFFFFFF
andq %rcx, %rdx
addq $0x18, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_cpp_makefile_star2_O1/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 0xa7cc
retq
movb 0x7(%rdi), %cl
cmpb $0x1, %cl
ja 0xa7da
cmpb $0x0, 0x5(%rdi)
je 0xa7e6
testb %cl, %cl
jne 0xa7cb
movb 0x5(%rdi), %cl
cmpb $0x2, %cl
jae 0xa7e9
xorl %eax, %eax
retq
xorl %eax, %eax
cmpb %cl, 0x4(%rdi)
setne %al
shll $0xb, %eax
retq
nop
// File: /workspace/github_cpp_makefile_star2_O1/arnoldrobbins[P]mcilroy-regex/re2.cpp
// Function: Alt::serialize(int)
int Alt::serialize(int n)
{
	serial = n++;
	n = left->serialize(n);
	rserial = 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 0x20(%rdi), %rdi
movq (%rdi), %rcx
movl %eax, %esi
callq *0x18(%rcx)
movl %eax, 0x30(%rbx)
leal 0x1(%rax), %esi
movq 0x28(%rbx), %rdi
movq (%rdi), %rax
callq *0x18(%rax)
movq 0x10(%rbx), %rdi
testq %rdi, %rdi
je 0xa87e
movq (%rdi), %rcx
movq 0x18(%rcx), %rcx
movl %eax, %esi
popq %rbx
jmpq *%rcx
popq %rbx
retq
// File: /workspace/github_cpp_makefile_star2_O1/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 0xa8b8
movq (%rdi), %rcx
movq 0x18(%rcx), %rcx
movl %eax, %esi
popq %rbx
jmpq *%rcx
popq %rbx
retq
// File: /workspace/github_cpp_makefile_star2_O1/arnoldrobbins[P]mcilroy-regex/re2.cpp
// Function: regAlt(int, Cenv*)
static Rex *
regAlt(int n1, Cenv *env) // n1= no. of 1st subexpr in alt
{
	if(cdebug)
		printf("regAlt %lx.%d parno=%d\n",
			(unsigned long)env->cursor.p, env->cursor.n, env->parno);
	Rex *e = regConj(env);
	if(e == ERROR)
		return e;
	else if(token(env) != T_BAR)
		return e;
	eat(env);
	Rex *f = regAlt(n1, env);
	if(f == ERROR) {
		delete e;
		return f;
	}
	Rex *g = regTrie(e, f, env);
	if(g != ERROR)
		return g;
	if(e->type==OK || f->type==OK)
		goto bad;
	g = NEW(Alt(n1, env->parno, e, f));
	if(g != ERROR)
		return g;
bad:
	delete e;
	delete f;
	return ERROR;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movq %rsi, %r15
movl %edi, %ebp
movq %rsi, %rdi
callq 0xaf03
testq %rax, %rax
je 0xad00
movq %rax, %rbx
movq %r15, %rdi
callq 0xafe8
cmpl $0x10e, %eax            # imm = 0x10E
jne 0xacef
movq 0x8(%r15), %rax
xorl %ecx, %ecx
cmpb $0x5c, (%rax)
sete %cl
addq %rcx, %rax
incq %rax
movq %rax, 0x8(%r15)
notl %ecx
addl %ecx, 0x10(%r15)
movl %ebp, %edi
movq %r15, %rsi
callq 0xabf4
testq %rax, %rax
je 0xacf4
movq %rax, %r14
movq %rbx, %rdi
movq %rax, %rsi
movq %r15, %rdx
callq 0xadf7
movq %rax, %r12
testq %rax, %rax
jne 0xad03
cmpb $0x0, 0x8(%rbx)
je 0xace4
cmpb $0x0, 0x8(%r14)
je 0xace4
movl $0x38, %edi
callq 0x5170
movq %rax, %r12
movl 0x30(%r15), %eax
movb $0xa, 0x8(%r12)
movq $0x0, 0x10(%r12)
leaq 0x7f08(%rip), %rcx      # 0x12bb0
movq %rcx, (%r12)
movl %ebp, 0x18(%r12)
movl %eax, 0x1c(%r12)
movq %rbx, 0x20(%r12)
movq %r14, 0x28(%r12)
testb $0x4, 0x1(%r15)
je 0xacdf
movq %r12, %rdi
callq 0xc0ba
movl $0x38, %esi
movq %r12, %rdi
callq 0x5180
xorl %r12d, %r12d
testq %r12, %r12
jne 0xad03
movq (%rbx), %rax
movq %rbx, %rdi
callq *0x8(%rax)
jmp 0xacf7
movq %rbx, %r12
jmp 0xad03
movq %rbx, %r14
movq (%r14), %rax
movq %r14, %rdi
callq *0x8(%rax)
xorl %r12d, %r12d
movq %r12, %rax
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O1/arnoldrobbins[P]mcilroy-regex/re2.cpp
// Function: regcomb
int
regcomb(regex_t *preg0, regex_t *preg1)
{
	if(cdebug)
		printf("regcomb\n");
	Rex *rex0 = preg0->rex;
	Rex *rex1 = preg1->rex;
	Cenv env(preg0->flags);
	if(rex0==ERROR || rex0->next ||
	   rex1==ERROR || rex1->next)
		return 0;
	Rex *g = regTrie(rex1, rex0, &env);
	if(g == 0)
		return 0;
	preg0->rex = g;
	if((preg0->flags&REG_ANCH) == 0)
		preg0->flags &= ~ONCE;
	preg1->rex = ERROR;
	return 1;
}

// Assembly:
pushq %rbp
pushq %r14
pushq %rbx
subq $0x50, %rsp
movq %rsi, %rbx
movq %rdi, %r14
movq 0x8(%rdi), %rsi
movq 0x8(%rbx), %rdi
movl 0x10(%r14), %eax
movl %eax, (%rsp)
xorl %ebp, %ebp
testq %rsi, %rsi
je 0xadec
cmpq $0x0, 0x10(%rsi)
setne %al
testq %rdi, %rdi
sete %cl
orb %al, %cl
jne 0xadec
cmpq $0x0, 0x10(%rdi)
jne 0xadec
movq %rsp, %rdx
callq 0xadf7
testq %rax, %rax
je 0xadec
movq %rax, 0x8(%r14)
movl 0x10(%r14), %eax
testb %al, %al
js 0xaddf
andl $0xffffef7f, %eax       # imm = 0xFFFFEF7F
movl %eax, 0x10(%r14)
movq $0x0, 0x8(%rbx)
movl $0x1, %ebp
movl %ebp, %eax
addq $0x50, %rsp
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O1/arnoldrobbins[P]mcilroy-regex/re2.cpp
// Function: regTrie(Rex*, Rex*, Cenv*)
static Rex *
regTrie(Rex *e, Rex *f, Cenv *env)
{
	Trie *g = (Trie*)f;
	if(e->next || f->next || !isstring(e))
		return ERROR;
	if(isstring(f)) {
		g = (Trie*)NEW(Trie());		// env is used here
		if(g == ERROR)
			return ERROR;
		if(insert(f, g))
			goto nospace;
	} else if(f->type != TRIE)
		return ERROR;
	if(insert(e, g))
		goto nospace;
	delete e;
	if(f != g)
		delete f;
	return g;
nospace:
	if(g != f)
		delete g;
	return ERROR;
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
cmpq $0x0, 0x10(%rdi)
jne 0xae10
movq %rsi, %r14
cmpq $0x0, 0x10(%rsi)
je 0xae21
xorl %ebx, %ebx
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
movq %rdx, %r12
movq %rdi, %r15
callq 0xbf39
testl %eax, %eax
je 0xae10
movq %r14, %rdi
callq 0xbf39
testl %eax, %eax
je 0xaeaf
movl $0x820, %edi            # imm = 0x820
callq 0x5170
movq %rax, %rbx
movb $0x6, 0x8(%rax)
movq $0x0, 0x10(%rax)
leaq 0x7c64(%rip), %rax      # 0x12ac0
movq %rax, (%rbx)
movl $0x7fffffff, 0x18(%rbx) # imm = 0x7FFFFFFF
leaq 0x1c(%rbx), %rdi
movl $0x804, %edx            # imm = 0x804
xorl %esi, %esi
callq 0x5100
testb $0x4, 0x1(%r12)
je 0xae95
movq %rbx, %rdi
callq 0xbfe0
movl $0x820, %esi            # imm = 0x820
movq %rbx, %rdi
callq 0x5180
xorl %ebx, %ebx
testq %rbx, %rbx
je 0xae10
movq %r14, %rdi
movq %rbx, %rsi
callq 0xbf66
testl %eax, %eax
jne 0xaecc
jmp 0xaebd
cmpb $0x6, 0x8(%r14)
movq %r14, %rbx
jne 0xae10
movq %r15, %rdi
movq %rbx, %rsi
callq 0xbf66
testl %eax, %eax
je 0xaee3
cmpq %r14, %rbx
je 0xae10
movq (%rbx), %rax
movq %rbx, %rdi
callq *0x8(%rax)
jmp 0xae10
movq (%r15), %rax
movq %r15, %rdi
callq *0x8(%rax)
cmpq %r14, %rbx
je 0xae12
movq (%r14), %rax
movq %r14, %rdi
callq *0x8(%rax)
jmp 0xae12
// File: /workspace/github_cpp_makefile_star2_O1/arnoldrobbins[P]mcilroy-regex/re2.cpp
// Function: regConj(Cenv*)
static Rex*
regConj(Cenv *env)
{
	if(cdebug)
		printf("regConj %lx.%d parno=%d\n",
			(unsigned long)env->cursor.p, env->cursor.n, env->parno);
	Rex *e = regSeq(env);
	if(env->retype != ARE)
		return e;
	if(e == ERROR)
		return e;
	if(token(env) != T_AND)
		return e;
	eat(env);
	Rex *f = regConj(env);
	if(f == ERROR) {
		delete e;
		return f;
	}
	Rex *g = NEW(Conj(e, f));
	if(g == ERROR){
		delete e;
		delete f;
	}
	return g;
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rdi, %r14
callq 0xb108
movq %rax, %rbx
cmpb $0x2, 0x3a(%r14)
jne 0xafd9
testq %rbx, %rbx
je 0xafc6
movq %r14, %rdi
callq 0xafe8
cmpl $0x10f, %eax            # imm = 0x10F
jne 0xafd9
movq 0x8(%r14), %rax
xorl %ecx, %ecx
cmpb $0x5c, (%rax)
sete %cl
addq %rcx, %rax
incq %rax
movq %rax, 0x8(%r14)
notl %ecx
addl %ecx, 0x10(%r14)
movq %r14, %rdi
callq 0xaf03
testq %rax, %rax
je 0xafca
movq %rax, %r12
movl $0x28, %edi
callq 0x5170
movq %rax, %r15
movb $0xb, 0x8(%rax)
movq $0x0, 0x10(%rax)
leaq 0x7c77(%rip), %rax      # 0x12c00
movq %rax, (%r15)
movq %rbx, 0x18(%r15)
movq %r12, 0x20(%r15)
testb $0x4, 0x1(%r14)
je 0xafb3
movq %r15, %rdi
callq 0xc108
movl $0x28, %esi
movq %r15, %rdi
callq 0x5180
xorl %r15d, %r15d
testq %r15, %r15
jne 0xafd6
movq (%rbx), %rax
movq %rbx, %rdi
callq *0x8(%rax)
movq %r12, %rbx
jmp 0xafcd
xorl %ebx, %ebx
jmp 0xafd9
xorl %r15d, %r15d
movq (%rbx), %rax
movq %rbx, %rdi
callq *0x8(%rax)
movq %r15, %rbx
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq