LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_cpp_makefile_star2_O2/arnoldrobbins[P]mcilroy-regex/sed3.cpp
// Function: dosub(unsigned char*, unsigned char*)
int
dosub(uchar *where, uchar *rp)
{
	int c, n;
	regmatch_t *m;

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

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rsi, %r15
movq %rdi, %rbx
leaq 0xb024(%rip), %r14      # 0x12800
pushq $0x1
popq %rbp
leaq 0x1(%r15), %r12
movzbl (%r15), %r13d
cmpl $0x26, %r13d
je 0x787d
cmpl $0x5c, %r13d
je 0x7805
testl %r13d, %r13d
jne 0x7901
jmp 0x797c
movb 0x1(%r15), %r13b
addq $0x2, %r15
leal -0x31(%r13), %eax
cmpb $0x8, %al
ja 0x78fe
movzbl %r13b, %r13d
shll $0x4, %r13d
leaq 0xaff8(%rip), %rax      # 0x12820
movq -0x2f8(%r13,%rax), %rsi
cmpq $-0x1, %rsi
je 0x77df
leaq 0xafe3(%rip), %rax      # 0x12820
addq %rax, %r13
movq -0x300(%r13), %rax
subq %rax, %rsi
cmpq $0x0, 0xafbe(%rip)      # 0x12810
je 0x7949
movq 0xafa1(%rip), %rdi      # 0x12800
movslq %esi, %r12
movq %r12, %rcx
notq %rcx
addq 0xaf99(%rip), %rcx      # 0x12808
cmpq %rcx, %rdi
jae 0x794c
jmp 0x7962
cmpq $0x0, 0xaf8b(%rip)      # 0x12810
movq 0xaf9c(%rip), %rdx      # 0x12828
movq 0xaf8d(%rip), %rax      # 0x12820
je 0x78b4
movq 0xaf64(%rip), %rdi      # 0x12800
movq 0xaf65(%rip), %rcx      # 0x12808
subq %rdx, %rcx
movq %rax, %rsi
notq %rsi
addq %rcx, %rsi
cmpq %rsi, %rdi
jb 0x78d5
subl %eax, %edx
movq %r14, %rdi
movl %edx, %esi
callq 0x5880
movq 0xaf39(%rip), %rdi      # 0x12800
movq 0xaf52(%rip), %rax      # 0x12820
movq 0xaf53(%rip), %rdx      # 0x12828
leaq (%rbx,%rax), %rsi
subq %rax, %rdx
callq 0x5290
movq 0xaf40(%rip), %rax      # 0x12828
subq 0xaf31(%rip), %rax      # 0x12820
addq %rax, 0xaf0a(%rip)      # 0x12800
movq %r12, %r15
jmp 0x77df
movq %r15, %r12
cmpq $0x0, 0xaf07(%rip)      # 0x12810
je 0x7922
movq 0xaeee(%rip), %rax      # 0x12800
movq 0xaeef(%rip), %rcx      # 0x12808
addq $-0x2, %rcx
cmpq %rcx, %rax
jb 0x7933
movq %r14, %rdi
movl %ebp, %esi
callq 0x5880
movq 0xaecd(%rip), %rax      # 0x12800
leaq 0x1(%rax), %rcx
movq %rcx, 0xaec2(%rip)      # 0x12800
movb %r13b, (%rax)
movq %r12, %r15
jmp 0x77df
movslq %esi, %r12
movq %r14, %rdi
callq 0x5880
movq 0xaea5(%rip), %rdi      # 0x12800
movq -0x300(%r13), %rax
addq %rbx, %rax
movq %rax, %rsi
movq %r12, %rdx
callq 0x5290
addq %r12, 0xae89(%rip)      # 0x12800
jmp 0x77df
pushq $0x1
popq %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O2/arnoldrobbins[P]mcilroy-regex/re1.cpp
// Function: Eenv::pushpos(Rex*, unsigned char*, int)
int Eenv::pushpos(Rex *rex, uchar *p, int b_e )
{
	if(pos.assure(npos+1))	// +1 is probably superstition
		return 1;
	pos[npos].serial = rex->serial;
	pos[npos].p = p;
	pos[npos].be = b_e;
	npos++;
	return 0;
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movl %ecx, %ebx
movq %rdx, %r15
movq %rsi, %r12
movq %rdi, %r14
addq $0x28, %rdi
movl 0x20(%r14), %esi
incl %esi
callq 0x8d46
testl %eax, %eax
je 0x79bb
pushq $0x1
popq %rax
jmp 0x79e3
movzwl 0xa(%r12), %eax
movslq 0x20(%r14), %rcx
movq 0x28(%r14), %rdx
leal 0x1(%rcx), %esi
shlq $0x4, %rcx
movw %ax, 0x8(%rdx,%rcx)
movq %r15, (%rdx,%rcx)
movb %bl, 0xa(%rdx,%rcx)
movl %esi, 0x20(%r14)
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
nop
// File: /workspace/github_cpp_makefile_star2_O2/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
testb %al, %al
sete %r9b
movl (%rcx), %r8d
testb $0x20, %r8b
sete %r10b
testb %r10b, %r9b
jne 0x8d52
testb $0x8, %r8b
sete %r8b
cmpb $0xa, %al
setne %al
orb %r8b, %al
je 0x8d52
xorl %eax, %eax
retq
nop
// File: /workspace/github_cpp_makefile_star2_O2/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)
jne 0x7b7a
movslq %r13d, %rcx
addq %rcx, %r15
xorl %ebp, %ebp
cmpl 0x18(%r12), %r13d
jl 0x7b94
movq %r12, %rdi
movq %r15, %rsi
movq %r14, %rdx
movq %rbx, %rcx
callq 0x8d52
cmpl $0x1, %eax
je 0x7b6f
leal -0x2(%rax), %ecx
cmpl $0x2, %ecx
jae 0x7b72
jmp 0x7b92
pushq $0x1
popq %rbp
decq %r15
decl %r13d
jmp 0x7b48
xorl %eax, %eax
movslq %r13d, %rcx
cmpq %rcx, %rax
jge 0x7b43
cmpb $0xa, (%r15,%rax)
cmovel %eax, %r13d
incq %rax
jmp 0x7b7c
movl %eax, %ebp
movl %ebp, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O2/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), %rcx
movq 0x8(%rbx), %rax
movq 0x18(%rbx), %r13
movq 0x18(%rax), %rax
subq %rsi, %r13
cmpq %rcx, %r13
cmovgel %ecx, %r13d
movb 0x20(%rdi), %dl
xorl %ecx, %ecx
testl %r13d, %r13d
cmovlel %ecx, %r13d
leaq (%rsi,%r13), %r12
cmpl %ecx, %r13d
je 0x7c00
movzbl (%rsi,%rcx), %edi
cmpb %dl, (%rax,%rdi)
jne 0x7bf7
incq %rcx
jmp 0x7be4
addq %rcx, %rsi
movq %rsi, %r12
movl %ecx, %r13d
xorl %ebp, %ebp
cmpl 0x18(%r15), %r13d
jl 0x7c35
movq %r15, %rdi
movq %r12, %rsi
movq %r14, %rdx
movq %rbx, %rcx
callq 0x8d52
cmpl $0x1, %eax
je 0x7c28
leal -0x2(%rax), %ecx
cmpl $0x2, %ecx
jae 0x7c2b
jmp 0x7c33
pushq $0x1
popq %rbp
decq %r12
decl %r13d
jmp 0x7c02
movl %eax, %ebp
movl %ebp, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/arnoldrobbins[P]mcilroy-regex/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), %rcx
movq 0x18(%rbx), %rax
subq %rsi, %rax
cmpq %rcx, %rax
cmovgel %ecx, %eax
xorl %ecx, %ecx
movslq %eax, %r13
cmpq %r13, %rcx
jge 0x7c96
movzbl (%r15,%rcx), %edx
movl %edx, %esi
shrl $0x3, %esi
movzbl 0x20(%r12,%rsi), %esi
andl $0x7, %edx
btl %edx, %esi
cmovael %ecx, %eax
incq %rcx
jmp 0x7c70
xorl %ebp, %ebp
cmpl 0x18(%r12), %r13d
jl 0x7cca
leaq (%r15,%r13), %rsi
movq %r12, %rdi
movq %r14, %rdx
movq %rbx, %rcx
callq 0x8d52
cmpl $0x1, %eax
je 0x7cc0
leal -0x2(%rax), %ecx
cmpl $0x2, %ecx
jae 0x7cc3
jmp 0x7cc8
pushq $0x1
popq %rbp
decq %r13
jmp 0x7c98
movl %eax, %ebp
movl %ebp, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O2/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 0x7d77
pushq %rbp
pushq %r14
pushq %rbx
movq %rdi, %rbx
xorl %ebp, %ebp
movl $0xff, %r14d
cmpl $0x100, %ebp            # imm = 0x100
je 0x7d73
movl %ebp, %eax
shrl $0x3, %eax
movzbl 0x20(%rbx,%rax), %eax
movl %ebp, %ecx
andl $0x7, %ecx
btl %ecx, %eax
jae 0x7d6f
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
jmp 0x7d1f
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/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 0x7de3
movq 0x8(%rcx), %rax
movq 0x18(%rax), %rax
movq 0x18(%rdi), %r8
movb (%r8), %r9b
testb %r9b, %r9b
je 0x8d52
movzbl (%rsi), %r10d
incq %rsi
incq %r8
cmpb %r9b, (%rax,%r10)
je 0x7dc7
xorl %eax, %eax
retq
// File: /workspace/github_cpp_makefile_star2_O2/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 %r12
pushq %rbx
movq %rcx, %r15
movl %edx, %ebp
movq %rsi, %rbx
movq %rdi, %r14
andq $0x0, 0x10(%rdi)
movq %rsi, 0x18(%rdi)
movl %edx, 0x20(%rdi)
leaq 0x979c(%rip), %rax      # 0x115a8
movq %rax, (%rdi)
leaq 0x28(%rdi), %r12
leaq 0x34(%rdi), %rax
movq %rax, 0x28(%rdi)
movl $0x14, 0x30(%rdi)
movb $0xe, 0x8(%rdi)
movq %r12, %rdi
movl %edx, %esi
callq 0x8d72
testl %eax, %eax
je 0x7e42
orb $0x4, 0x1(%r15)
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
movq (%r12), %rax
orl $-0x1, (%rax)
movslq %ebp, %rcx
pushq $-0x1
popq %rsi
pushq $0x1
popq %rdx
cmpq %rcx, %rdx
jge 0x7e39
testl %esi, %esi
js 0x7e6f
movl %esi, %r8d
movb 0x1(%rbx,%r8), %dil
cmpb (%rbx,%rdx), %dil
je 0x7e73
movl (%rax,%r8,4), %esi
jmp 0x7e57
movb (%rbx,%rdx), %dil
movslq %esi, %r8
leaq 0x1(%r8), %r9
cmpb %dil, 0x1(%rbx,%r8)
cmovnel %esi, %r9d
movl %r9d, (%rax,%rdx,4)
incq %rdx
movl %r9d, %esi
jmp 0x7e52
movq %rax, %rbx
movq %r12, %rdi
callq 0x8d7e
movq %r14, %rdi
callq 0x8d9e
movq %rbx, %rdi
callq 0x52b0
// File: /workspace/github_cpp_makefile_star2_O2/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, 0x10(%rsp)
movq %rsi, %r13
movq %rdi, %r12
movq 0x8(%rcx), %rax
movq 0x18(%rcx), %rbp
movq 0x18(%rax), %r14
movl 0x20(%rdi), %eax
pushq $-0x1
popq %r15
movq %rsi, 0x8(%rsp)
movslq %eax, %rcx
movq 0x18(%r12), %rdx
movq 0x28(%r12), %rsi
leaq (%rcx,%r13), %rdi
cmpq %rbp, %rdi
ja 0x7f84
movl %r15d, %edi
cmpq %rbp, %r13
jae 0x7eeb
testl %edi, %edi
js 0x7f1d
movl %edi, %r9d
movb 0x1(%rdx,%r9), %r8b
movzbl (%r13), %r10d
cmpb (%r14,%r10), %r8b
je 0x7f26
movl (%rsi,%r9,4), %edi
jmp 0x7f00
movzbl (%r13), %r8d
movb (%r14,%r8), %r8b
movslq %edi, %r9
leaq 0x1(%r9), %r10
cmpb %r8b, 0x1(%rdx,%r9)
cmovnel %edi, %r10d
leal 0x1(%r10), %r8d
incq %r13
movl %r10d, %edi
cmpl %eax, %r8d
jne 0x7efb
addq 0x8(%rsp), %rcx
movq %r13, %rax
subq %rcx, %rax
movq 0x418(%rbx), %rcx
movq %rax, (%rcx)
movq %r12, %rdi
movq %r13, %rsi
movq 0x10(%rsp), %rdx
movq %rbx, %rcx
callq 0x8d52
decl %eax
cmpl $0x3, %eax
jb 0x7f88
movslq 0x20(%r12), %rax
subq %rax, %r13
incq %r13
jmp 0x7ede
xorl %eax, %eax
jmp 0x7f94
movl %eax, %eax
leaq 0x450f(%rip), %rcx      # 0xc4a0
movl (%rcx,%rax,4), %eax
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O2/arnoldrobbins[P]mcilroy-regex/re1.cpp
// Function: Trie::parse(Trie::Tnode*, unsigned char*, Rex*, Eenv*)
int Trie::parse(Tnode *node, uchar *s, Rex* contin, Eenv *env)
{
	debug(TRIE, "Trie", s);
	uchar *map = env->preg->map;
	for(;;) {
		if(s >= env->last)
			return NONE;
		while(node->c != map[*s]) {
			node = node->sib;
			if(node == 0)
				return NONE;
		}
		if(node->end)
			break;
		node = node->son;
		s++;
	}
	int longresult = NONE;
	if(node->son)
		longresult = parse(node->son, s+1, contin, env);
	if(longresult==BEST || longresult==BAD)
		return longresult;
	int shortresult = follow(s+1, contin, env);
	return shortresult==NONE? longresult: shortresult;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movq %r8, %rbx
movq %rcx, %r14
movq %rdx, %r15
movq %rdi, %r12
movq 0x8(%r8), %rcx
movq 0x18(%r8), %rax
movq 0x18(%rcx), %rcx
xorl %ebp, %ebp
cmpq %rax, %r15
jae 0x8064
movzbl (%r15), %edx
movb (%rcx,%rdx), %dl
cmpb %dl, (%rsi)
je 0x8017
movq 0x10(%rsi), %rsi
testq %rsi, %rsi
jne 0x8008
jmp 0x8064
cmpb $0x0, 0x1(%rsi)
movq 0x8(%rsi), %rsi
jne 0x8026
incq %r15
jmp 0x7ffc
testq %rsi, %rsi
je 0x8049
leaq 0x1(%r15), %rdx
movq %r12, %rdi
movq %r14, %rcx
movq %rbx, %r8
callq 0x7fda
movl %eax, %ebp
andl $-0x2, %eax
cmpl $0x2, %eax
jne 0x804b
jmp 0x8064
xorl %ebp, %ebp
incq %r15
movq %r12, %rdi
movq %r15, %rsi
movq %r14, %rdx
movq %rbx, %rcx
callq 0x8d52
testl %eax, %eax
cmovnel %eax, %ebp
movl %ebp, %eax
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O2/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 %r12
pushq %rbx
movq %rsi, %r14
movq %rdi, %rbx
movzbl (%rsi), %r15d
movq 0x20(%rdi,%r15,8), %rax
testq %rax, %rax
jne 0x80a7
pushq $0x18
popq %rdi
callq 0x5170
movb %r15b, (%rax)
movb $0x0, 0x1(%rax)
xorps %xmm0, %xmm0
movups %xmm0, 0x8(%rax)
movq %rax, 0x20(%rbx,%r15,8)
pushq $0x1
popq %rbp
pushq $0x18
popq %r15
movq %rax, %r12
movb (%rax), %al
cmpb (%r14), %al
je 0x80e1
movq 0x10(%r12), %rax
testq %rax, %rax
jne 0x80ae
movq %r15, %rdi
callq 0x5170
movb (%r14), %cl
movb %cl, (%rax)
movb $0x0, 0x1(%rax)
xorps %xmm0, %xmm0
movups %xmm0, 0x8(%rax)
movq %rax, 0x10(%r12)
jmp 0x80ae
cmpb $0x0, 0x1(%r14)
je 0x8116
incq %r14
movq 0x8(%r12), %rax
testq %rax, %rax
jne 0x8112
movq %r15, %rdi
callq 0x5170
movb (%r14), %cl
movb %cl, (%rax)
movb $0x0, 0x1(%rax)
xorps %xmm0, %xmm0
movups %xmm0, 0x8(%rax)
movq %rax, 0x8(%r12)
incl %ebp
jmp 0x80ae
cmpl 0x18(%rbx), %ebp
jge 0x8120
movl %ebp, 0x18(%rbx)
jmp 0x8128
cmpl 0x1c(%rbx), %ebp
jle 0x8128
movl %ebp, 0x1c(%rbx)
movb $0x1, 0x1(%r12)
xorl %eax, %eax
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O2/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 0x8196
addq %r9, %r8
movq 0x8(%r8), %r8
subq %rax, %r8
leaq (%rsi,%r8), %r9
cmpq 0x18(%rcx), %r9
ja 0x8196
addq 0x10(%rcx), %rax
movq 0x8(%rcx), %r9
movq 0x18(%r9), %r9
testq %r8, %r8
jle 0x8d52
decq %r8
movzbl (%rsi), %r10d
incq %rsi
movb (%r9,%r10), %r10b
movzbl (%rax), %r11d
incq %rax
cmpb (%r9,%r11), %r10b
je 0x8172
xorl %eax, %eax
retq
nop
// File: /workspace/github_cpp_makefile_star2_O2/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 $0x28, %rsp
movq %rcx, %rbx
movq %rsi, %r14
movq %rdi, %r15
movswq 0x18(%rdi), %r13
movq 0x2c8(%rcx), %r12
shlq $0x4, %r13
movb $0x11, 0x8(%rsp)
leaq 0x9653(%rip), %rax      # 0x11820
movq %rax, (%rsp)
movq %rdx, 0x18(%rsp)
movq %rdi, 0x20(%rsp)
movq 0x10(%rdi), %rax
movq %rax, 0x10(%rsp)
movq %rsi, %rax
subq 0x10(%rcx), %rax
movq %rax, (%r12,%r13)
pushq $0x3
popq %rbp
movq %rcx, %rdi
movq %r15, %rsi
movq %r14, %rdx
movl %ebp, %ecx
callq 0x7990
testl %eax, %eax
jne 0x8226
movq 0x20(%r15), %rdi
movq (%rdi), %rax
movq %rsp, %rdx
movq %r14, %rsi
movq %rbx, %rcx
callq *0x20(%rax)
movl %eax, %ebp
decl 0x20(%rbx)
addq %r13, %r12
orq $-0x1, (%r12)
movq %rsp, %rdi
callq 0x8cfa
movl %ebp, %eax
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
movq %rsp, %rdi
callq 0x8cfa
movq %rbx, %rdi
callq 0x52b0
// File: /workspace/github_cpp_makefile_star2_O2/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)
pushq $0x4
popq %rcx
movq %rbx, %rdi
movq %r14, %rdx
callq 0x7990
testl %eax, %eax
je 0x829b
pushq $0x3
popq %rax
jmp 0x82bc
addq %r13, %r12
addq $0x8, %r12
movq 0x18(%r15), %rdx
movq %r15, %rdi
movq %r14, %rsi
movq %rbx, %rcx
callq 0x8d52
decl 0x20(%rbx)
orq $-0x1, (%r12)
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
// File: /workspace/github_cpp_makefile_star2_O2/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), %rax
movq %rax, 0x8(%rdi)
movl $0x14, 0x10(%rdi)
testl %esi, %esi
je 0x834a
movq %rcx, %r14
movl %edx, %ebx
movl %esi, %ebp
movq %rdi, %r15
leaq 0x8(%rdi), %r12
movq 0x2c8(%rcx), %r13
subl %esi, %ebx
movq %r12, %rdi
movl %ebx, %esi
callq 0x8dc8
testl %eax, %eax
je 0x8319
orb $0x4, 0x1(%r14)
movl %ebp, 0x4(%r15)
jmp 0x834a
movq (%r12), %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 0x832f
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
movq %r12, %rdi
callq 0x8dd4
movq %rbx, %rdi
callq 0x52b0
// File: /workspace/github_cpp_makefile_star2_O2/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 0x83a2
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 0x8390
retq
nop
// File: /workspace/github_cpp_makefile_star2_O2/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, %rbx
movq %rdx, %r13
movq %rsi, %r15
movq %rdi, %r12
movl 0x18(%rdi), %esi
movl 0x1c(%rdi), %edx
leaq 0x28(%rsp), %rdi
callq 0x82c6
pushq $0x3
popq %r14
testb $0x4, 0x1(%rbx)
jne 0x8498
pushq $0x2
popq %rcx
movq %rbx, %rdi
movq %r12, %rsi
movq %r15, %rdx
callq 0x7990
testl %eax, %eax
jne 0x8498
movzwl 0xa(%r12), %eax
leaq 0x8(%rsp), %rdx
movb $0x11, 0x8(%rdx)
andq $0x0, 0x10(%rdx)
leaq 0x945e(%rip), %rcx      # 0x11870
movq %rcx, (%rdx)
movq %r13, 0x18(%rdx)
movw %ax, 0xa(%rdx)
movq 0x20(%r12), %rdi
movq (%rdi), %rax
movq %r15, %rsi
movq %rbx, %rcx
callq *0x20(%rax)
movl %eax, %r14d
leal -0x4(%r14), %eax
cmpl $-0x3, %eax
ja 0x847e
leaq 0x28(%rsp), %rdi
movq %rbx, %rsi
callq 0x836c
movzwl 0x30(%r12), %eax
movslq 0x20(%rbx), %rcx
movq 0x28(%rbx), %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 %rbx, %rcx
callq *0x20(%rax)
testl %eax, %eax
cmovnel %eax, %r14d
decl 0x20(%rbx)
leaq 0x28(%rsp), %rdi
movq %rbx, %rsi
callq 0x836c
leaq 0x8(%rsp), %rdi
callq 0x8cfa
leaq 0x30(%rsp), %rdi
callq 0x8dd4
movl %r14d, %eax
addq $0x180, %rsp            # imm = 0x180
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
jmp 0x84b8
movq %rax, %rbx
leaq 0x8(%rsp), %rdi
callq 0x8cfa
jmp 0x84ca
movq %rax, %rbx
leaq 0x30(%rsp), %rdi
callq 0x8dd4
movq %rbx, %rdi
callq 0x52b0
// File: /workspace/github_cpp_makefile_star2_O2/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 %rbx
subq $0x60, %rsp
movq 0x10(%rdi), %rax
movb $0x11, %r8b
leaq 0x8(%rsp), %r9
movb %r8b, 0x8(%r9)
leaq 0x9384(%rip), %r10      # 0x118c0
movq %r10, (%r9)
movq %rdx, 0x20(%r9)
movq %rax, 0x10(%r9)
movq 0x20(%rdi), %rax
leaq 0x30(%rsp), %rdx
movb %r8b, 0x8(%rdx)
andq $0x0, 0x10(%rdx)
leaq 0x93b0(%rip), %r8       # 0x11910
movq %r8, (%rdx)
movq %rsi, 0x18(%rdx)
movq %rax, 0x20(%rdx)
movq %r9, 0x28(%rdx)
movq 0x18(%rdi), %rdi
movq (%rdi), %rax
callq *0x20(%rax)
movl %eax, %ebx
leaq 0x30(%rsp), %rdi
callq 0x8cfa
leaq 0x8(%rsp), %rdi
callq 0x8cfa
movl %ebx, %eax
addq $0x60, %rsp
popq %rbx
retq
movq %rax, %rbx
leaq 0x30(%rsp), %rdi
callq 0x8cfa
leaq 0x8(%rsp), %rdi
callq 0x8cfa
movq %rbx, %rdi
callq 0x52b0
// File: /workspace/github_cpp_makefile_star2_O2/arnoldrobbins[P]mcilroy-regex/re1.cpp
// Function: Rep::dorep(int, unsigned char*, Rex*, Eenv*)
int Rep::dorep(int n, uchar *s, Rex *cont, Eenv *env)
{
	int result = NONE;
	if(hi > n) {
		Rep1 rep1(this, s, n+1, cont);
		Save save(n1, n2, env);
		if(env->flags&SPACE)
			return BAD;
		if(env->pushpos(this, s, BEGI))	
			return BAD;
		result = rex->parse(s, &rep1, env);
		env->poppos();
		save.restore(env);
	}
	if(result==BEST || result==BAD || lo>n)
		return result;
	if(env->pushpos(this, s, ENDP))	// end BEGR
		return BAD;
	int res1 = follow(s, cont, env);
	env->poppos();
	return res1==NONE? result: res1;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x1a8, %rsp            # imm = 0x1A8
movq %r8, %rbx
movq %rcx, %r15
movl %esi, %r13d
movq %rdi, %r12
xorl %ebp, %ebp
pushq $0x3
popq %r14
cmpl %esi, 0x1c(%rdi)
jle 0x86e9
leal 0x1(%r13), %eax
movb $0x11, 0x20(%rsp)
leaq 0x9342(%rip), %rcx      # 0x11960
movq %rcx, 0x18(%rsp)
movq %r12, 0x30(%rsp)
movq %rdx, 0x8(%rsp)
movq %rdx, 0x38(%rsp)
movl %eax, 0x40(%rsp)
movq %r15, 0x10(%rsp)
movq %r15, 0x48(%rsp)
movq 0x10(%r12), %rax
movq %rax, 0x28(%rsp)
movzwl 0xa(%r12), %eax
movw %ax, 0x22(%rsp)
movl 0x20(%r12), %esi
movl 0x24(%r12), %edx
leaq 0x50(%rsp), %rdi
movq %rbx, %rcx
callq 0x82c6
xorl %ebp, %ebp
testb $0x4, 0x1(%rbx)
movl $0x0, %r15d
jne 0x86c6
pushq $0x1
popq %rcx
movq %rbx, %rdi
movq %r12, %rsi
movq 0x8(%rsp), %rdx
callq 0x7990
xorl %ebp, %ebp
movl $0x0, %r15d
testl %eax, %eax
jne 0x86c6
movq 0x28(%r12), %rdi
movq (%rdi), %rax
leaq 0x18(%rsp), %rdx
movq 0x8(%rsp), %rsi
movq %rbx, %rcx
callq *0x20(%rax)
movl %eax, %ebp
decl 0x20(%rbx)
leaq 0x50(%rsp), %rdi
movq %rbx, %rsi
callq 0x836c
movb $0x1, %r15b
leaq 0x58(%rsp), %rdi
callq 0x8dd4
leaq 0x18(%rsp), %rdi
callq 0x8cfa
testb %r15b, %r15b
movq 0x10(%rsp), %r15
movq 0x8(%rsp), %rdx
je 0x872b
movl %ebp, %eax
andl $-0x2, %eax
cmpl $0x2, %eax
je 0x8728
cmpl %r13d, 0x18(%r12)
jg 0x8728
pushq $0x4
popq %rcx
movq %rbx, %rdi
movq %r12, %rsi
movq %rdx, %r13
callq 0x7990
testl %eax, %eax
jne 0x872b
movq %r12, %rdi
movq %r13, %rsi
movq %r15, %rdx
movq %rbx, %rcx
callq 0x8d52
decl 0x20(%rbx)
testl %eax, %eax
cmovnel %eax, %ebp
movl %ebp, %r14d
movl %r14d, %eax
addq $0x1a8, %rsp            # imm = 0x1A8
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
leaq 0x58(%rsp), %rdi
callq 0x8dd4
jmp 0x8752
movq %rax, %rbx
leaq 0x18(%rsp), %rdi
callq 0x8cfa
movq %rbx, %rdi
callq 0x52b0
// File: /workspace/github_cpp_makefile_star2_O2/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
pushq $0x4
popq %rcx
movq %rbx, %rdi
movq %r15, %rsi
movq %r14, %rdx
callq 0x7990
pushq $0x3
popq %rbp
testl %eax, %eax
jne 0x87fa
cmpq %r14, 0x20(%r15)
je 0x879c
movq 0x18(%r15), %rdi
movl 0x28(%r15), %esi
jmp 0x87e6
movl 0x28(%r15), %esi
movq 0x18(%r15), %rdi
cmpl 0x18(%rdi), %esi
jle 0x87e6
movl $0x801, %ecx            # imm = 0x801
andl (%rbx), %ecx
xorl %eax, %eax
cmpl $0x800, %ecx            # imm = 0x800
jne 0x87f5
pushq $0x4
popq %rcx
movq %rbx, %rdi
movq %r15, %rsi
movq %r14, %rdx
callq 0x7990
testl %eax, %eax
jne 0x87fa
movq 0x30(%r15), %rdx
movq %r15, %rdi
movq %r14, %rsi
movq %rbx, %rcx
callq 0x8d52
decl 0x20(%rbx)
jmp 0x87f5
movq 0x30(%r15), %rcx
movq %r14, %rdx
movq %rbx, %r8
callq 0x85e2
decl 0x20(%rbx)
movl %eax, %ebp
movl %ebp, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O2/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, %rbx
movq %rdx, %r14
movq %rsi, %r15
movq %rdi, %r12
movl 0x18(%rcx), %ebp
subl %r15d, %ebp
leaq 0x8(%rsp), %r13
movq %r13, %rdi
movl %ebp, %edx
callq 0x8924
movq 0x18(%r12), %rdi
movq (%rdi), %rax
movq %r15, %rsi
movq %r13, %rdx
movq %rbx, %rcx
callq *0x20(%rax)
cmpl $0x3, %eax
jne 0x88a6
pushq $0x3
popq %r13
jmp 0x88f0
xorl %r13d, %r13d
testl %ebp, %ebp
js 0x88f0
movl %ebp, %eax
shrl $0x3, %eax
movq 0x28(%rsp), %rcx
movzbl (%rcx,%rax), %eax
movl %ebp, %ecx
andl $0x7, %ecx
btl %ecx, %eax
jb 0x88e9
movl %ebp, %esi
addq %r15, %rsi
movq %r12, %rdi
movq %r14, %rdx
movq %rbx, %rcx
callq 0x8d52
movl %eax, %ecx
andl $-0x2, %ecx
cmpl $0x1, %eax
cmovel %eax, %r13d
cmpl $0x2, %ecx
je 0x88ed
decl %ebp
jmp 0x88a9
movl %eax, %r13d
leaq 0x8(%rsp), %rdi
callq 0x8df4
movl %r13d, %eax
addq $0x48, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
jmp 0x890e
movq %rax, %rbx
leaq 0x8(%rsp), %rdi
callq 0x8df4
movq %rbx, %rdi
callq 0x52b0
nop
// File: /workspace/github_cpp_makefile_star2_O2/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 %r12
pushq %rbx
movq %rcx, %r14
movl (%rcx), %eax
testb %al, %al
jns 0x89e3
xorl %ebx, %ebx
cmpq %rsi, 0x18(%r14)
jne 0x8ab8
pushq $0x2
popq %rbx
testb $0x4, %al
jne 0x8ab8
movq 0x8(%r14), %rcx
movq (%rcx), %r15
subq 0x10(%r14), %rsi
btl $0xb, %eax
jb 0x8a2d
movslq %esi, %rax
movq 0x418(%r14), %rdi
movq %rax, 0x8(%rdi)
addq $0x10, %rdi
movq 0x2c8(%r14), %rsi
addq $0x10, %rsi
movslq %r15d, %rdx
shlq $0x4, %rdx
callq 0x5290
jmp 0x8ab8
movq 0x418(%r14), %rdi
movq 0x8(%rdi), %rax
movslq %esi, %r12
pushq $0x1
popq %rbx
testq %rax, %rax
js 0x8a7b
cmpq %rax, %r12
jl 0x8ab8
jne 0x8a7b
movq 0x28(%r14), %rsi
movq 0x178(%r14), %rdi
movslq 0x24(%r14), %rdx
shlq $0x4, %rdx
addq %rdi, %rdx
movslq 0x20(%r14), %rcx
shlq $0x4, %rcx
addq %rsi, %rcx
callq 0x8ada
testl %eax, %eax
jle 0x8ab8
movq 0x418(%r14), %rdi
movq %r12, 0x8(%rdi)
addq $0x10, %rdi
movq 0x2c8(%r14), %rsi
addq $0x10, %rsi
movslq %r15d, %rdx
shlq $0x4, %rdx
callq 0x5290
movl 0x20(%r14), %ebp
leaq 0x178(%r14), %rdi
movl %ebp, %esi
callq 0x8d46
testl %eax, %eax
je 0x8ac3
orb $0x4, 0x1(%r14)
pushq $0x3
popq %rbx
movl %ebx, %eax
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
movslq %ebp, %rdx
movl %ebp, 0x24(%r14)
movq 0x28(%r14), %rsi
movq 0x178(%r14), %rdi
jmp 0x8a1f
// File: /workspace/github_cpp_makefile_star2_O2/arnoldrobbins[P]mcilroy-regex/re1.cpp
// Function: better(Pos*, Pos*, Pos*, Pos*)
static int better(Pos *os, Pos *ns, Pos *oend, Pos *nend)
{
	Pos *oe, *ne;
	int k;
	for( ; os<oend && ns<nend; os=oe+1, ns=ne+1) {
		if(ns->serial > os->serial)
			return -1;
		if(os->serial > ns->serial)
			abort();	// folk theorem bites the dust
		if(os->p > ns->p)
			return -1;
		if(ns->p > os->p)
			return 1;	// believed impossible
		oe = rpos(os);
		ne = rpos(ns);
		if(ne->p > oe->p)
			return 1;
		if(oe->p > ne->p)
			return -1;
		k = better(os+1, ns+1, oe, ne);
		if(k)
			return k;
	}
	if(ns < nend)
		abort();		// another one bites the dust
	return os < oend;		// true => inessential null
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rcx, %r15
movq %rdx, %r14
movq %rsi, %rbx
movq %rdi, %r12
cmpq %r14, %r12
jae 0x8b90
cmpq %r15, %rbx
jae 0x8b90
movzwl 0x8(%rbx), %eax
movzwl 0x8(%r12), %ecx
cmpw %cx, %ax
jg 0x8b7a
jl 0x8b9f
movq (%r12), %rax
movq (%rbx), %rcx
cmpq %rcx, %rax
ja 0x8b7a
jb 0x8b7e
movq %r12, %rdi
callq 0x8d1a
movq %rax, %rbp
movq %rbx, %rdi
callq 0x8d1a
movq %rax, %r13
movq (%rax), %rax
movq (%rbp), %rcx
cmpq %rcx, %rax
ja 0x8b7e
jb 0x8b7a
addq $0x10, %r12
addq $0x10, %rbx
movq %r12, %rdi
movq %rbx, %rsi
movq %rbp, %rdx
movq %r13, %rcx
callq 0x8ada
testl %eax, %eax
jne 0x8b81
addq $0x10, %rbp
addq $0x10, %r13
movq %r13, %rbx
movq %rbp, %r12
jmp 0x8af1
pushq $-0x1
jmp 0x8b80
pushq $0x1
popq %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
cmpq %r15, %rbx
jb 0x8b9f
xorl %eax, %eax
cmpq %r14, %r12
setb %al
jmp 0x8b81
callq 0x5110
// File: /workspace/github_cpp_makefile_star2_O2/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 $0x568, %rsp            # imm = 0x568
cmpq $0x0, 0x8(%rdi)
je 0x8c1e
movq %r8, %r14
movq %rcx, %r15
movq %rdx, %r8
movq %rsi, %r13
movq %rdi, %r12
movq %rsp, %rbx
movq %rbx, %rdi
movq %r12, %rsi
movl %r9d, %edx
movq %r13, %rcx
callq 0x8e40
movl (%rbx), %ecx
pushq $0xc
popq %rbx
btl $0xa, %ecx
jb 0x8caf
xorl %eax, %eax
testb $0x4, %cl
cmovneq %rax, %r15
pcmpeqd %xmm0, %xmm0
xorl %ecx, %ecx
cmpq %rcx, %r15
je 0x8c26
cmpq %rcx, (%r12)
jb 0x8c26
movq 0x2c8(%rsp), %rdx
movdqu %xmm0, (%rdx,%rax)
incq %rcx
addq $0x10, %rax
jmp 0x8bfd
pushq $0x2
popq %rbx
jmp 0x8cb7
leaq 0x9c93(%rip), %rbx      # 0x128c0
movq %rsp, %rbp
movq 0x8(%r12), %rdi
movq (%rbx), %rdx
movq (%rdi), %rax
movq %r13, %rsi
movq %rbp, %rcx
callq *0x20(%rax)
movl (%rsp), %ecx
testl %eax, %eax
jne 0x8c6f
btl $0xc, %ecx
jb 0x8c68
incq %r13
cmpq 0x18(%rsp), %r13
ja 0x8c68
movq 0x418(%rsp), %rax
incq (%rax)
jmp 0x8c30
pushq $0x1
popq %rax
movl %eax, %ebx
jmp 0x8caf
btl $0xa, %ecx
pushq $0xc
popq %rbx
jb 0x8caf
movq 0x418(%rsp), %rax
xorl %ebx, %ebx
pcmpeqd %xmm0, %xmm0
xorl %ecx, %ecx
xorl %edx, %edx
cmpq %rdx, %r15
je 0x8caf
cmpq %rdx, (%r12)
jae 0x8c9d
movdqu %xmm0, (%r14,%rcx)
jmp 0x8ca6
movups (%rax,%rcx), %xmm1
movups %xmm1, (%r14,%rcx)
incq %rdx
addq $0x10, %rcx
jmp 0x8c8a
movq %rsp, %rdi
callq 0x8f3c
movl %ebx, %eax
addq $0x568, %rsp            # imm = 0x568
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
movq %rsp, %rdi
callq 0x8f3c
movq %rbx, %rdi
callq 0x52b0
// File: /workspace/github_cpp_makefile_star2_O2/arnoldrobbins[P]mcilroy-regex/re1.cpp
// Function: rpos(Pos*)
static Pos *rpos(Pos *a)	/* find matching right pos record */
{
	int serial = a->serial;
	int inner;
	for(inner=0;;) {
		if((++a)->serial != serial)
			continue;
		if(a->be != ENDP)
			inner++;
		else if(inner-- <= 0)
			return a;
	}
}

// Assembly:
movq %rdi, %rax
movzwl 0x8(%rdi), %ecx
xorl %edx, %edx
movq %rax, %rsi
addq $0x10, %rax
cmpw %cx, 0x18(%rsi)
jne 0x8d23
cmpb $0x4, 0xa(%rax)
jne 0x8d41
leal -0x1(%rdx), %esi
testl %edx, %edx
movl %esi, %edx
jg 0x8d23
jmp 0x8d45
incl %edx
jmp 0x8d23
retq
// File: /workspace/github_cpp_makefile_star2_O2/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
pushq %rax
andl $0x30, %edx
orl 0x10(%rsi), %edx
movq %rdi, %r14
movl %edx, (%rdi)
movq %rsi, 0x8(%rdi)
movq %rcx, 0x10(%rdi)
addq %rcx, %r8
movq %r8, 0x18(%rdi)
leaq 0x28(%rdi), %rbx
leaq 0x38(%rdi), %rax
movq %rax, 0x28(%rdi)
pushq $0x14
popq %rax
movl %eax, 0x30(%rdi)
leaq 0x178(%rdi), %r15
leaq 0x188(%rdi), %rcx
movq %rcx, 0x178(%rdi)
movl %eax, 0x180(%rdi)
leaq 0x2c8(%rdi), %r12
leaq 0x2d8(%rdi), %rcx
movq %rcx, 0x2c8(%rdi)
movl %eax, 0x2d0(%rdi)
leaq 0x418(%rdi), %r13
leaq 0x428(%rdi), %rcx
movq %rcx, 0x418(%rdi)
movl %eax, 0x420(%rdi)
movl (%rsi), %ebp
movq %r12, %rdi
movl %ebp, %esi
callq 0x8dc8
testl %eax, %eax
jne 0x8ee6
movq %r13, %rdi
movl %ebp, %esi
callq 0x8dc8
testl %eax, %eax
je 0x8efa
orb $0x4, 0x1(%r14)
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
andq $0x0, 0x20(%r14)
movq 0x418(%r14), %rax
andq $0x0, (%rax)
orq $-0x1, 0x8(%rax)
jmp 0x8eeb
movq %rax, %r14
movq %r13, %rdi
callq 0x8dd4
movq %r12, %rdi
callq 0x8dd4
movq %r15, %rdi
callq 0x90c8
movq %rbx, %rdi
callq 0x90c8
movq %r14, %rdi
callq 0x52b0
// File: /workspace/github_cpp_makefile_star2_O2/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
pushq $-0x1
popq %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 0x913f
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_O2/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)
andq $0x0, 0x30(%rbx)
andw $0x0, 0x38(%rbx)
cmpb $0x0, 0x9712(%rip)      # 0x129cf
jne 0x9315
leaq 0x32ba(%rip), %rax      # 0xc580
xorl %ecx, %ecx
leaq 0x9831(%rip), %rdx      # 0x12b00
cmpq $0x19, %rcx
je 0x92e4
movzbl (%rax), %esi
movb %cl, (%rsi,%rdx)
incq %rcx
addq $0xe, %rax
jmp 0x92cf
xorl %r14d, %r14d
leaq 0x96e2(%rip), %r12      # 0x129d0
leaq 0x95db(%rip), %r13      # 0x128d0
cmpq $0x100, %r14            # imm = 0x100
je 0x9313
movb %r14b, (%r14,%r12)
movl %r14d, %edi
callq 0x52e0
movb %al, (%r14,%r13)
incq %r14
jmp 0x92f5
movl (%rbx), %ebp
testb $0x2, %bpl
leaq 0x96b0(%rip), %rax      # 0x129d0
leaq 0x95a9(%rip), %rcx      # 0x128d0
cmoveq %rax, %rcx
movq %rcx, 0x28(%rbx)
movl %ebp, %eax
andb $0x1, %al
btl $0x9, %ebp
movzbl %al, %eax
pushq $0x2
popq %rcx
cmovael %eax, %ecx
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)
andq $0x0, 0x3b(%rbx)
andw $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_O2/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 0x943c
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 0x9630
movq %rdx, %rcx
movabsq $0xffffffffffff, %rdx   # imm = 0xFFFFFFFFFFFF
andq %rcx, %rdx
jmp 0x9443
movq (%rbx), %rax
movq 0x8(%rbx), %rdx
addq $0x10, %rsp
popq %rbx
retq
nop
// File: /workspace/github_cpp_makefile_star2_O2/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
andl $0x0, 0xc(%rax)
andq $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 0x93f8
movabsq $0xffffffffffff, %rcx   # imm = 0xFFFFFFFFFFFF
andq %rcx, %rdx
addq $0x18, %rsp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O2/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 0x9538
movb $0x1, 0x1a(%r14)
incb %al
movb %al, 0x14(%rsp)
jne 0x954b
shrq $0x28, %rdx
orb $0x1, %dl
movb %dl, 0x15(%rsp)
movq 0x10(%r14), %rsi
leaq 0x8(%rsp), %rdi
movq %rbx, %rdx
callq 0x93f8
movabsq $0xffffffffffff, %rcx   # imm = 0xFFFFFFFFFFFF
andq %rcx, %rdx
addq $0x18, %rsp
popq %rbx
popq %r14
retq
nop
// File: /workspace/github_cpp_makefile_star2_O2/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 0x9630
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 0x9606
shrq $0x28, %rdx
orb $0x1, %dl
movb %dl, 0xd(%rsp)
movq 0x10(%r14), %rsi
movq %rsp, %rdi
movq %rbx, %rdx
callq 0x93f8
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_O2/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 %rbp
pushq %r15
pushq %r14
pushq %rbx
movq (%rdi), %rcx
movq 0x8(%rdi), %r11
movq %rcx, %rdi
shrq $0x28, %rdi
movq %rcx, %r8
shrq $0x30, %r8
movq %rcx, %r9
shrq $0x38, %r9
movl 0x8(%rsi), %eax
addb 0x5(%rsi), %dil
setb %r10b
addb 0x6(%rsi), %r8b
setb %bl
leal (%r11,%rax), %r14d
movabsq $-0x10000000000, %r15   # imm = 0xFFFFFF0000000000
andq %r11, %r15
movq %r11, %rdx
shrq $0x20, %rdx
addb 0xc(%rsi), %dl
setb %bpl
movzbl %dl, %edx
shlq $0x20, %rdx
orq %r14, %rdx
orq %r15, %rdx
addb 0x7(%rsi), %r9b
setb %r14b
movabsq $0xfe0000000000, %r15   # imm = 0xFE0000000000
andq %r11, %r15
movabsq $-0xff0000000001, %r11  # imm = 0xFFFF00FFFFFFFFFF
andq %rdx, %r11
orq %r15, %r11
btsq $0x28, %r11
testb $0x1, %r14b
cmovneq %r11, %rdx
testb $0x1, %bpl
cmovneq %r11, %rdx
testl %eax, %eax
cmovsq %r11, %rdx
movl (%rsi), %r14d
testb $0x1, %bl
cmovneq %r11, %rdx
leal (%r14,%rcx), %eax
testb $0x1, %r10b
cmovneq %r11, %rdx
testl %r14d, %r14d
cmovsq %r11, %rdx
shrq $0x20, %rcx
addb 0x4(%rsi), %cl
movzbl %r9b, %esi
shlq $0x38, %rsi
movzbl %r8b, %r8d
shlq $0x30, %r8
orq %rsi, %r8
movzbl %dil, %esi
shlq $0x28, %rsi
orq %r8, %rsi
movzbl %cl, %ecx
shlq $0x20, %rcx
orq %rsi, %rcx
orq %rcx, %rax
popq %rbx
popq %r14
popq %r15
popq %rbp
retq