LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_cpp_makefile_star2_O3/asd00012334[P]Abstract-Algebra-2018/./prime.hpp
// Function: std::pair<long long, long long> prime::extGCD<long long>(long long, long long)
std::pair<type,type> extGCD(type left, type right){
    if(!left && !right) throw std::logic_error("Return value does not exist.\n");
    std::pair<type,type> lCor(1,0), rCor(0,1);
    if(left<0) lCor.first = -1;
    if(right<0) rCor.second = -1;
    left = abs(left);
    right = abs(right);
    while(left){
        std::swap(lCor,rCor);
        std::swap(left,right);
        lCor.first -= left/right*rCor.first;
        lCor.second -= left/right*rCor.second;
        left %= right;
    }
    return rCor;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
movq %rsi, %rax
orq %rdi, %rax
je 0x5560
movq %rsi, %rcx
sarq $0x3f, %rcx
orq $0x1, %rcx
testl %edi, %edi
je 0x5553
movl %esi, %eax
negl %eax
cmovsl %esi, %eax
movl %edi, %edx
negl %edx
cmovsl %edi, %edx
sarq $0x3f, %rdi
orq $0x1, %rdi
xorl %r9d, %r9d
movq %rcx, %r8
xorl %r10d, %r10d
movq %rdx, %r11
xorl %edx, %edx
divq %r11
movq %r10, %rcx
movq %rdi, %rsi
movq %rax, %r10
imulq %rdi, %r10
movq %r9, %rdi
subq %r10, %rdi
imulq %rcx, %rax
movq %r8, %r10
subq %rax, %r10
movq %rcx, %r8
movq %rsi, %r9
movq %r11, %rax
testq %rdx, %rdx
jne 0x551e
jmp 0x5555
xorl %esi, %esi
movq %rsi, %rax
movq %rcx, %rdx
popq %rbx
popq %r14
popq %rbp
retq
movl $0x10, %edi
callq 0x20d0
movq %rax, %rbx
leaq 0x3b21(%rip), %rsi      # 0x9095
movq %rax, %rdi
callq 0x2200
movq 0x7a45(%rip), %rsi      # 0xcfc8
movq 0x7a26(%rip), %rdx      # 0xcfb0
movq %rbx, %rdi
callq 0x2280
movq %rax, %r14
movq %rbx, %rdi
callq 0x2130
movq %r14, %rdi
callq 0x22a0
nop
// File: /workspace/github_cpp_makefile_star2_O3/asd00012334[P]Abstract-Algebra-2018/main.cpp
// Function: Polynomial<prime::Zp, prime::ZpElement>::CanonicalType::__unit__() const
Polynomial __unit__()const{
            Polynomial out;
            out.canonicalType.scalar = scalar;
            out.coef.push_back(scalar->__unit__());
            return out;
        }

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
subq $0x20, %rsp
movq %rdi, %r14
movq %rdi, 0x8(%rdi)
leaq 0x10(%rdi), %rbx
xorps %xmm0, %xmm0
movups %xmm0, 0x10(%rdi)
movq $0x0, 0x20(%rdi)
movq (%rsi), %rax
movq %rax, (%rdi)
leaq -0x28(%rbp), %rcx
movq %rax, (%rcx)
movq %rax, 0x8(%rcx)
movq (%rax), %rsi
movl $0x1, %eax
xorl %edx, %edx
idivq %rsi
leaq (%rdx,%rsi), %rax
cqto
idivq %rsi
movq %rdx, 0x10(%rcx)
movq %rbx, %rdi
xorl %esi, %esi
movq %rcx, %rdx
callq 0x55a6
movq %r14, %rax
addq $0x20, %rsp
popq %rbx
popq %r14
popq %rbp
retq
movq %rax, %r14
movq (%rbx), %rdi
testq %rdi, %rdi
je 0x5ea5
callq 0x2180
movq %r14, %rdi
callq 0x22a0
nop
// File: /workspace/github_cpp_makefile_star2_O3/asd00012334[P]Abstract-Algebra-2018/main.cpp
// Function: DivisionSpecialized<quotient::FracType, quotient::fraction, true>::operator%(Polynomial<quotient::FracType, quotient::fraction>) const
Polynomial<ring,ringElement> operator%(Polynomial<ring,ringElement> p2)const{
        Polynomial<ring,ringElement> out;
        auto This = static_cast<Polynomial<ring,ringElement>const*>(this);
        out.canonicalType.scalar = This->canonicalType.scalar;
        out.coef = This->coef;

        /// Reduce to monic polynomial
        out.reduce();
        for(int i=0;i<p2.coef.size();++i)
            p2.coef[i] = p2.coef[i]/p2.coef.back();

        for(int i=out.coef.size()-1;i>=(int)p2.coef.size()-1;--i){
            auto tmp = out.coef[i];
            for(int j=0;j<p2.coef.size();++j)
                out.coef[i-j] = out.coef[i-j] - p2.coef.rbegin()[j] * tmp;
        }
        out.reduce();
        return out;
    }

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x38, %rsp
movq %rdx, %r15
movq %rdi, %r13
movq %rdi, 0x8(%rdi)
addq $0x10, %rdi
xorps %xmm0, %xmm0
movups %xmm0, 0x10(%r13)
movq $0x0, 0x20(%r13)
movq (%rsi), %rax
movq %rax, (%r13)
addq $0x10, %rsi
movq %rdi, -0x30(%rbp)
callq 0x74c8
movq %r13, %rdi
callq 0x401c
movq 0x10(%r15), %rdi
movq 0x18(%r15), %rax
cmpq %rdi, %rax
je 0x72f7
xorl %ebx, %ebx
xorl %r14d, %r14d
movq %rax, %rsi
addq %rbx, %rdi
addq $-0x10, %rsi
callq 0x75ba
movq 0x10(%r15), %rdi
movq %rax, (%rdi,%rbx)
movq %rdx, 0x8(%rdi,%rbx)
incq %r14
movq 0x18(%r15), %rsi
movq %rsi, %rcx
subq %rdi, %rcx
movq %rcx, %rax
sarq $0x4, %rax
addq $0x10, %rbx
cmpq %r14, %rax
ja 0x72b6
shrq $0x4, %rcx
decl %ecx
movq %rdi, %rax
jmp 0x72ff
movl $0xffffffff, %ecx       # imm = 0xFFFFFFFF
movq %rax, %rsi
movq 0x10(%r13), %r12
movq %r13, -0x38(%rbp)
movq 0x18(%r13), %rdx
subq %r12, %rdx
shrq $0x4, %rdx
decl %edx
cmpl %ecx, %edx
jl 0x73ae
movq %rdx, -0x40(%rbp)
movslq %edx, %r13
shlq $0x4, %r13
movups (%r12,%r13), %xmm0
movaps %xmm0, -0x60(%rbp)
movq %rsi, %rcx
subq %rax, %rcx
je 0x739d
xorl %r14d, %r14d
xorl %ebx, %ebx
leaq (%rsi,%r14), %rdi
addq $-0x10, %rdi
leaq -0x60(%rbp), %rsi
callq 0x3fb0
addq %r13, %r12
addq %r14, %r12
movq %rax, -0x50(%rbp)
movq %rdx, -0x48(%rbp)
movq %r12, %rdi
leaq -0x50(%rbp), %rsi
callq 0x7672
movq -0x30(%rbp), %rcx
movq (%rcx), %r12
leaq (%r12,%r13), %rcx
movq %rax, (%r14,%rcx)
movq %rdx, 0x8(%r14,%rcx)
incq %rbx
movq 0x10(%r15), %rax
movq 0x18(%r15), %rsi
movq %rsi, %rcx
subq %rax, %rcx
movq %rcx, %rdx
sarq $0x4, %rdx
addq $-0x10, %r14
cmpq %rbx, %rdx
ja 0x733d
movq -0x40(%rbp), %rdx
decl %edx
shrq $0x4, %rcx
decl %ecx
jmp 0x7314
movq -0x38(%rbp), %rbx
movq %rbx, %rdi
callq 0x401c
movq %rbx, %rax
addq $0x38, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
jmp 0x73d0
jmp 0x73d0
movq %rax, %r14
movq -0x30(%rbp), %rax
movq (%rax), %rdi
testq %rdi, %rdi
je 0x73e4
callq 0x2180
movq %r14, %rdi
callq 0x22a0
// File: /workspace/github_cpp_makefile_star2_O3/asd00012334[P]Abstract-Algebra-2018/main.cpp
// Function: Polynomial<prime::Zp, prime::ZpElement>::operator==(Polynomial<prime::Zp, prime::ZpElement> const&) const
bool operator==(Polynomial const& e2)const{
        int d1 = degree(), d2 = e2.degree();
        int siz = std::min(d1+1,d2+1);
        for(int i=0;i<siz;++i)
            if(!(coef[i]==e2.coef[i]))
                return false;

        return d1==d2;
    }

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rsi, %r15
movq %rdi, %r12
callq 0x4132
movl %eax, %r13d
movq %r15, %rdi
callq 0x4132
movl %eax, %r14d
leal 0x1(%r13), %ebx
leal 0x1(%r14), %eax
cmpl %ebx, %eax
cmovll %eax, %ebx
testl %ebx, %ebx
jle 0x69ca
movq 0x10(%r12), %rdi
movq 0x10(%r15), %rsi
callq 0x5734
testb %al, %al
je 0x69ce
movq %r13, -0x30(%rbp)
movl %ebx, %r13d
xorl %ebx, %ebx
incq %rbx
cmpq %r13, %rbx
je 0x69be
leaq (,%rbx,8), %rax
leaq (%rax,%rax,2), %rsi
movq 0x10(%r12), %rdi
addq %rsi, %rdi
addq 0x10(%r15), %rsi
callq 0x5734
testb %al, %al
jne 0x6995
cmpq %r13, %rbx
setae %cl
movq -0x30(%rbp), %r13
jmp 0x69d0
movb $0x1, %cl
jmp 0x69d0
xorl %ecx, %ecx
cmpl %r14d, %r13d
sete %al
andb %cl, %al
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O3/asd00012334[P]Abstract-Algebra-2018/main.cpp
// Function: Polynomial<prime::Zp, prime::ZpElement>::CanonicalType::__zero__() const
Polynomial __zero__()const{
            Polynomial out;
            out.canonicalType.scalar = scalar;
            out.coef.push_back(scalar->__zero__());
            return out;
        }

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
subq $0x20, %rsp
movq %rdi, %r14
movq %rdi, 0x8(%rdi)
leaq 0x10(%rdi), %rbx
xorps %xmm0, %xmm0
movups %xmm0, 0x10(%rdi)
xorl %eax, %eax
movq %rax, 0x20(%rdi)
movq (%rsi), %rcx
movq %rcx, (%rdi)
leaq -0x28(%rbp), %rdx
movq %rcx, (%rdx)
movq %rcx, 0x8(%rdx)
movq %rax, 0x10(%rdx)
movq %rbx, %rdi
xorl %esi, %esi
callq 0x55a6
movq %r14, %rax
addq $0x20, %rsp
popq %rbx
popq %r14
popq %rbp
retq
movq %rax, %r14
movq (%rbx), %rdi
testq %rdi, %rdi
je 0x6a46
callq 0x2180
movq %r14, %rdi
callq 0x22a0
// File: /workspace/github_cpp_makefile_star2_O3/asd00012334[P]Abstract-Algebra-2018/main.cpp
// Function: DegreeList::operator<(DegreeList) const
bool operator<(DegreeList r)const{
        int ld = degree(), rd = r.degree();
        int num = std::min(ld,rd);
        for(int i=0;i<num;++i){
            if(at(i)==r[i]) continue;
            return at(i)<r[i];
        }
        return ld<rd;
    }

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
movq (%rdi), %rax
movq 0x8(%rdi), %rdi
movq %rdi, %rdx
subq %rax, %rdx
movq %rdx, %rcx
shrq $0x2, %rcx
leal -0x1(%rcx), %r9d
movl %r9d, %r8d
sarl $0x1f, %r8d
andl %r9d, %r8d
decl %ecx
testl %ecx, %ecx
jle 0x6b55
cmpl $0x0, -0x4(%rdi)
je 0x6b47
jmp 0x6b58
movl %r8d, %ecx
movq (%rsi), %rdi
movq 0x8(%rsi), %r8
movq %r8, %rsi
subq %rdi, %rsi
shrq $0x2, %rsi
leal -0x1(%rsi), %r10d
movl %r10d, %r9d
sarl $0x1f, %r9d
andl %r10d, %r9d
decl %esi
testl %esi, %esi
jle 0x6b86
cmpl $0x0, -0x4(%r8)
je 0x6b77
jmp 0x6b89
movl %r9d, %esi
cmpl %ecx, %esi
movl %ecx, %r8d
cmovll %esi, %r8d
testl %r8d, %r8d
jle 0x6bdf
sarq $0x2, %rdx
movl %r8d, %r8d
movq %rdx, %r10
negq %r10
movq %r8, %r11
negq %r11
movb $0x1, %r9b
movl $0x1, %ebx
leaq (%r10,%rbx), %r14
cmpq $0x1, %r14
je 0x6bff
movl -0x4(%rdi,%rbx,4), %r14d
cmpl %r14d, -0x4(%rax,%rbx,4)
jne 0x6be6
cmpq %r8, %rbx
setb %r9b
leaq (%r11,%rbx), %r14
incq %r14
incq %rbx
cmpq $0x1, %r14
jne 0x6bb2
cmpl %esi, %ecx
setl %al
jmp 0x6bfa
setl %dl
xorl %eax, %eax
cmpl %esi, %ecx
setl %al
movzbl %dl, %ecx
testb $0x1, %r9b
cmovnel %ecx, %eax
popq %rbx
popq %r14
popq %rbp
retq
leaq 0x2607(%rip), %rdi      # 0x920d
movq %rdx, %rsi
xorl %eax, %eax
callq 0x2220
// File: /workspace/github_cpp_makefile_star2_O3/asd00012334[P]Abstract-Algebra-2018/./quotient.hpp
// Function: quotient::fraction::operator/(quotient::fraction const&) const
fraction operator/(fraction const& r)const{
        if(r==0) throw std::exception();
        fraction out(en*r.dn, dn*r.en);
        out.reduce();
        return out;
    }

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
movq %rsi, %r14
movq %rdi, %rbx
movl $0x1, %edx
movq %rsi, %rdi
xorl %esi, %esi
callq 0x5a5e
testb %al, %al
jne 0x7644
movq 0x8(%r14), %rdi
imulq (%rbx), %rdi
movq (%r14), %r8
imulq 0x8(%rbx), %r8
movq %rdi, %rsi
negq %rsi
cmovsq %rdi, %rsi
movq %r8, %rcx
negq %rcx
cmovsq %r8, %rcx
movq %rsi, %r9
jae 0x7619
movq %rsi, %rax
movq %rcx, %rdx
movq %rdx, %r9
xorl %edx, %edx
divq %r9
movq %r9, %rax
testq %rdx, %rdx
jne 0x7609
movslq %r9d, %r9
movq %rsi, %rax
cqto
idivq %r9
movq %rax, %rsi
movq %rcx, %rax
cqto
idivq %r9
movq %rax, %rdx
movq %rsi, %rax
negq %rax
xorq %rdi, %r8
cmovnsq %rsi, %rax
popq %rbx
popq %r14
popq %rbp
retq
movl $0x8, %edi
callq 0x20d0
movq 0x5953(%rip), %rcx      # 0xcfa8
addq $0x10, %rcx
movq %rcx, (%rax)
movq 0x5975(%rip), %rsi      # 0xcfd8
movq 0x5986(%rip), %rdx      # 0xcff0
movq %rax, %rdi
callq 0x2280
// File: /workspace/github_cpp_makefile_star2_O3/skyshore2001[P]symfind/symfind.cpp
// Function: RootExists(char const*)
bool RootExists(const char *root)
{
	SfRepoIter it(g_repos);
	while (it.Next()) {
		if (strcmp(it.Value()->root, root) == 0)
			return true;
	}
	return false;
}

// Assembly:
pushq %r14
pushq %rbx
subq $0x48, %rsp
movq %rdi, %rbx
movq 0x6bb9(%rip), %rax      # 0x9250
leaq 0x8(%rsp), %r14
movq %rax, 0x18(%r14)
xorps %xmm0, %xmm0
movups %xmm0, 0x28(%r14)
movq $0x0, 0x38(%r14)
movq 0x18(%r14), %r14
testq %r14, %r14
je 0x26c8
movq (%r14), %rdi
movq %rbx, %rsi
callq 0x2230
testl %eax, %eax
jne 0x26b0
testq %r14, %r14
setne %al
addq $0x48, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_cpp_makefile_star2_O3/skyshore2001[P]symfind/symfind.cpp
// Function: LoadRepofiles(int, char const**)
int LoadRepofiles(int filecnt, const char *files[])
{
	for (int i=0; i<filecnt; ++i) {
		FILE *fp = NULL;
		const char *file = files[i];
		int len = strlen(file);
		bool isgz = len > 3 && strcasecmp(file+len-3, ".gz") == 0;
		if (isgz) {
			char buf[1024];
			sprintf(buf, "gzip -dc \"%s\"", file);
		// 	printf("cmd: '%s'\n", buf);
			fp = popen(buf, "r");
		}
		else {
			fp = fopen(file, "r");
		}
		if (fp == NULL) {
			printf("*** cannot open repo-file \"%s\"!\n", file);
			continue;
		}
		printf("=== loading %s...\n", file);
		LoadRepofile(fp);
		if (isgz)
			pclose(fp);
		else
			fclose(fp);
	}
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x408, %rsp            # imm = 0x408
movq %rsi, %rbx
leaq 0x39d5(%rip), %r13      # 0x64f4
xorl %r14d, %r14d
movq (%rbx,%r14,8), %r12
movq %r12, %rdi
callq 0x20b0
cmpl $0x4, %eax
jl 0x2b50
andl $0x7fffffff, %eax       # imm = 0x7FFFFFFF
leaq (%r12,%rax), %rdi
addq $-0x3, %rdi
leaq 0x381b(%rip), %rsi      # 0x6362
callq 0x21b0
testl %eax, %eax
je 0x2bae
movq %r12, %rdi
movq %r13, %rsi
callq 0x21d0
movq %rax, %rbp
xorl %r15d, %r15d
testq %rbp, %rbp
je 0x2b8e
leaq 0x3828(%rip), %rdi      # 0x6395
movq %r12, %rsi
xorl %eax, %eax
callq 0x2030
movq %rbp, %rdi
callq 0x26d6
movq %rbp, %rdi
testb %r15b, %r15b
je 0x2ba1
callq 0x2240
jmp 0x2ba6
leaq 0x37df(%rip), %rdi      # 0x6374
movq %r12, %rsi
xorl %eax, %eax
callq 0x2030
jmp 0x2ba6
callq 0x2180
incq %r14
jmp 0x2b22
movq %rsp, %r15
movq %r15, %rdi
leaq 0x37ab(%rip), %rsi      # 0x6366
movq %r12, %rdx
xorl %eax, %eax
callq 0x2040
movq %r15, %rdi
movq %r13, %rsi
callq 0x2070
movq %rax, %rbp
movb $0x1, %r15b
jmp 0x2b61
// File: /workspace/github_cpp_makefile_star2_O3/skyshore2001[P]symfind/symfind.cpp
// Function: FreeRepos()
void FreeRepos()
{
	void *p;
	for (SfRepo *repo = g_repos; repo; ) {
		for (SfFolder *folder = repo->folders; folder; ) {
			for (SfFile *file = folder->files; file; ) {
				for (SfSymbol *symbol = file->symbols; symbol; ) {
					p = symbol;
					symbol = symbol->next;
					FREE(p);
				}
				FREE(file->name);
				p = file;
				file = file->next;
				FREE(p);
			}
			FREE(folder->name);
			p = folder;
			folder = folder->next;
			FREE(p);
		}
		FREE(repo->root);
		FREE(repo->tagscan_pat);
		p = repo;
		repo = repo->next;
		FREE(p);
	}
	g_repos = NULL;
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq 0x6669(%rip), %rbx      # 0x9250
testq %rbx, %rbx
je 0x2c7d
movq 0x10(%rbx), %r14
testq %r14, %r14
je 0x2c54
movq 0x8(%r14), %r15
testq %r15, %r15
je 0x2c38
movq 0x8(%r15), %rdi
testq %rdi, %rdi
je 0x2c1c
movq 0x8(%rdi), %r12
callq 0x21e0
movq %r12, %rdi
testq %r12, %r12
jne 0x2c0b
movq (%r15), %rdi
callq 0x21e0
movq 0x10(%r15), %r12
movq %r15, %rdi
callq 0x21e0
movq %r12, %r15
testq %r12, %r12
jne 0x2c02
movq (%r14), %rdi
callq 0x21e0
movq 0x10(%r14), %r15
movq %r14, %rdi
callq 0x21e0
movq %r15, %r14
testq %r15, %r15
jne 0x2bf9
movq (%rbx), %rdi
callq 0x21e0
movq 0x8(%rbx), %rdi
callq 0x21e0
movq 0x18(%rbx), %r14
movq %rbx, %rdi
callq 0x21e0
movq %r14, %rbx
testq %r14, %r14
jne 0x2bf0
movq $0x0, 0x65c8(%rip) # 0x9250
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
// File: /workspace/github_cpp_makefile_star2_O3/skyshore2001[P]symfind/symfind.cpp
// Function: GetFullName(char*, char const*, char const*, char const*)
char *GetFullName(char *buf, const char *root, const char *dirname, const char *file = NULL)
{
// 	static char buf[1024];
	// 1. replace root
	root = g_rootsubs.Substitue(root);

	char quote[2] = {0,0};
	if (file && (strchr(root, ' ') != NULL || strchr(dirname, ' ') != NULL || strchr(file, ' ') != NULL))
		quote[0] = '"';

	// 2. remove ./ at the beginning of dirname
	const char *p = dirname;
	if (*p == '.') {
		++ p;
		if (*p == '/' || *p == '\\') // './xxx'
		{
			++p;
			dirname = p;
		}
		else if (*p == 0) // '.'
			dirname = p;
	}
	if (dirname[0] == 0) {
		if (file == NULL)
			sprintf(buf, "%s%s%s", quote, root, quote);
		else 
			sprintf(buf, "%s%s%c%s%s", quote, root, SEP, file, quote);
	}
	else {
		if (file == NULL)
			sprintf(buf, "%s%s%c%s%s", quote, root, SEP, dirname, quote);
		else 
			sprintf(buf, "%s%s%c%s%c%s%s", quote, root, SEP, dirname, SEP, file, quote);
	}
	return buf;
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x28, %rsp
movq %rcx, %r12
movq %rdx, %r15
movq %rdi, %rbx
movq 0x65d9(%rip), %rdi      # 0x9288
addq $0x8, %rdi
callq 0x2dc2
movq %rax, %r14
movw $0x0, 0x26(%rsp)
testq %r12, %r12
je 0x2d02
movq %r14, %rdi
movl $0x20, %esi
callq 0x2090
testq %rax, %rax
jne 0x2cfd
movq %r15, %rdi
movl $0x20, %esi
callq 0x2090
testq %rax, %rax
jne 0x2cfd
movq %r12, %rdi
movl $0x20, %esi
callq 0x2090
testq %rax, %rax
je 0x2d02
movb $0x22, 0x26(%rsp)
movb (%r15), %al
cmpb $0x2e, %al
jne 0x2d24
movzbl 0x1(%r15), %eax
testl %eax, %eax
je 0x2d51
cmpl $0x5c, %eax
je 0x2d1c
cmpl $0x2f, %eax
jne 0x2d28
movb 0x2(%r15), %al
addq $0x2, %r15
testb %al, %al
je 0x2d51
movsbl 0x6500(%rip), %r8d      # 0x9230
leaq 0x26(%rsp), %rdx
testq %r12, %r12
je 0x2d79
movq %rdx, 0x10(%rsp)
movq %r12, 0x8(%rsp)
movl %r8d, (%rsp)
leaq 0x366b(%rip), %rsi      # 0x63ba
jmp 0x2d84
testq %r12, %r12
je 0x2da3
movsbl 0x64d2(%rip), %r8d      # 0x9230
leaq 0x26(%rsp), %rdx
movq %rdx, (%rsp)
leaq 0x3641(%rip), %rsi      # 0x63af
movq %rbx, %rdi
movq %r14, %rcx
movq %r12, %r9
jmp 0x2d8d
movq %rdx, (%rsp)
leaq 0x362b(%rip), %rsi      # 0x63af
movq %rbx, %rdi
movq %r14, %rcx
movq %r15, %r9
xorl %eax, %eax
callq 0x2040
movq %rbx, %rax
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
leaq 0x35fe(%rip), %rsi      # 0x63a8
leaq 0x26(%rsp), %rdx
movq %rbx, %rdi
movq %r14, %rcx
movq %rdx, %r8
xorl %eax, %eax
callq 0x2040
jmp 0x2d94
nop
// File: /workspace/github_cpp_makefile_star2_O3/skyshore2001[P]symfind/symfind.cpp
// Function: RootSubs::Substitue(char const*)
const char *RootSubs::Substitue(const char *s) 
{
	static char buf[1024];
	for (auto &sub: m_subs) {
		// note: windows path is case-insensitive; linux path is case-sensitive
#ifdef _WINDOWS
		const char *p = stristr(s, sub.first);
#else
		const char *p = strstr(s, sub.first);
#endif
		if (p) {
			sprintf(buf, "%.*s%s%s", p-s, s, sub.second, p+strlen(sub.first));
			return buf;
		}
	}
	return s;
}

// Assembly:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
movq %rsi, %rbx
movq 0x3e8(%rdi), %r13
movq 0x3f0(%rdi), %r12
cmpq %r12, %r13
je 0x2e3a
movq (%r13), %r15
movq %rbx, %rdi
movq %r15, %rsi
callq 0x2050
testq %rax, %rax
jne 0x2dfb
addq $0x10, %r13
jmp 0x2ddc
movq %rax, %r14
movq %rax, %r12
subq %rbx, %r12
movq 0x8(%r13), %r13
movq %r15, %rdi
callq 0x20b0
addq %rax, %r14
leaq 0x6496(%rip), %r15      # 0x92b0
leaq 0x36a5(%rip), %rsi      # 0x64c6
movq %r15, %rdi
movq %r12, %rdx
movq %rbx, %rcx
movq %r13, %r8
movq %r14, %r9
xorl %eax, %eax
callq 0x2040
movq %r15, %rbx
movq %rbx, %rax
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
// File: /workspace/github_cpp_makefile_star2_O3/skyshore2001[P]symfind/symfind.cpp
// Function: GotoResult(char const*, char const*)
void GotoResult(const char *cmd, const char *arg)
{
	int idx = g_result.curidx;
	if (arg == NULL) {
		if (cmd[0] == 'N')
			-- idx;
		else
			++ idx;
	}
	else {
		idx = atoi(arg)-1;
	}
	if (idx >= 0 && idx < g_result.items.size()) {
		g_result.curidx = idx;
		
		char buf[1024], *p = buf;
		p += sprintf(p, "%s ", EDITOR);

		const SfContext &ctx = g_result.items[idx];
		const char *line = g_result.kind == 's'? ctx.symbol->line(): NULL;
		if (line) {
			p += sprintf(p, "+%s ", line);
		}
		GetFullName(p, ctx.repo->root, ctx.folder->name, ctx.file->name);
		printf("go %d: %s\n", idx+1, buf);
		system(buf);
	}
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
subq $0x400, %rsp            # imm = 0x400
testq %rsi, %rsi
je 0x35fc
movq %rsi, %rdi
callq 0x2290
movl %eax, %ebx
jmp 0x360b
movl 0x5c76(%rip), %ebx      # 0x9278
cmpb $0x4e, (%rdi)
jne 0x36da
decl %ebx
testl %ebx, %ebx
js 0x36cd
movl %ebx, %r15d
movq 0x5c49(%rip), %rax      # 0x9268
subq 0x5c3a(%rip), %rax      # 0x9260
sarq $0x5, %rax
cmpq %r15, %rax
jbe 0x36cd
movl %ebx, 0x5c3f(%rip)      # 0x9278
leaq 0x2ddd(%rip), %rsi      # 0x641d
leaq 0x5b79(%rip), %rdx      # 0x91c0
movq %rsp, %rdi
xorl %eax, %eax
callq 0x2040
cltq
leaq (%rsp,%rax), %r14
shlq $0x5, %r15
addq 0x5bfe(%rip), %r15      # 0x9260
cmpb $0x73, 0x5bef(%rip)     # 0x9258
jne 0x3691
movq 0x18(%r15), %rax
movzwl 0x2(%rax), %ecx
leaq (%rax,%rcx), %rdx
addq $0x10, %rdx
leaq 0x2d9a(%rip), %rsi      # 0x641c
movq %r14, %rdi
xorl %eax, %eax
callq 0x2040
cltq
addq %rax, %r14
movq (%r15), %rax
movq 0x8(%r15), %rcx
movq (%rax), %rsi
movq (%rcx), %rdx
movq 0x10(%r15), %rax
movq (%rax), %rcx
movq %r14, %rdi
callq 0x2c94
incl %ebx
leaq 0x2d6b(%rip), %rdi      # 0x6421
movq %rsp, %r14
movl %ebx, %esi
movq %r14, %rdx
xorl %eax, %eax
callq 0x2030
movq %r14, %rdi
callq 0x2140
addq $0x400, %rsp            # imm = 0x400
popq %rbx
popq %r14
popq %r15
retq
incl %ebx
jmp 0x360d
// File: /workspace/github_cpp_makefile_star2_O3/skyshore2001[P]symfind/symfind.cpp
// Function: GetTagscanPats(std::vector<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, std::allocator<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>>&)
void GetTagscanPats(vector<string> &pats)
{
	pats.clear();

	// "*.cpp;*.h;" -> ["*.cpp", "*.h"]
	SfRepoIter it(g_repos);
	while (it.Next()) {
		const char *p = it.Value()->tagscan_pat, *p2 = p;
		if (p == NULL)
			continue;
		for (; *p2 != 0; ++p2) {
			if (*p2 == ';') {
				if (p2 > p)
					pats.push_back(string(p, 0, p2-p));
				p = p2 +1;
			}
		}
		if (p2 > p)
			pats.push_back(string(p, 0, p2-p));
	}
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x38, %rsp
movq %rdi, %rbx
movq (%rdi), %rsi
callq 0x4c18
movq 0x5b4f(%rip), %rbp      # 0x9250
testq %rbp, %rbp
je 0x37e1
leaq 0x18(%rsp), %r14
leaq 0xf(%rsp), %r12
movq 0x8(%rbp), %rax
movq %rax, 0x10(%rsp)
testq %rax, %rax
je 0x37d4
movq %rax, %r13
movq %rax, %r15
movzbl (%r15), %ecx
cmpl $0x3b, %ecx
je 0x373b
testl %ecx, %ecx
jne 0x3788
jmp 0x3790
cmpq %rax, %r15
jbe 0x377f
movq %r13, %rcx
subq %rax, %rcx
movq %r14, %rdi
leaq 0x10(%rsp), %rsi
xorl %edx, %edx
movq %r12, %r8
callq 0x45fa
movq %rbx, %rdi
movq %r14, %rsi
callq 0x4d00
movq 0x18(%rsp), %rdi
leaq 0x28(%rsp), %rax
cmpq %rax, %rdi
je 0x377f
movq 0x28(%rsp), %rsi
incq %rsi
callq 0x21a0
leaq 0x1(%r15), %rax
movq %rax, 0x10(%rsp)
incq %r15
incq %r13
jmp 0x372c
cmpq %rax, %r15
jbe 0x37d4
subq %rax, %r13
movq %r14, %rdi
leaq 0x10(%rsp), %rsi
xorl %edx, %edx
movq %r13, %rcx
movq %r12, %r8
callq 0x45fa
movq %rbx, %rdi
movq %r14, %rsi
callq 0x4d00
movq 0x18(%rsp), %rdi
leaq 0x28(%rsp), %rax
cmpq %rax, %rdi
je 0x37d4
movq 0x28(%rsp), %rsi
incq %rsi
callq 0x21a0
movq 0x18(%rbp), %rbp
testq %rbp, %rbp
jne 0x3714
addq $0x38, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
jmp 0x37f4
jmp 0x3815
movq %rax, %rbx
movq 0x18(%rsp), %rdi
leaq 0x28(%rsp), %rax
cmpq %rax, %rdi
je 0x3818
movq 0x28(%rsp), %rsi
incq %rsi
callq 0x21a0
jmp 0x3818
movq %rax, %rbx
movq %rbx, %rdi
callq 0x22e0
// File: /workspace/github_cpp_makefile_star2_O3/skyshore2001[P]symfind/symfind.cpp
// Function: RootSubs::Set(char const*)
void RootSubs::Set(const char *pattern) 
{
	strcpy(m_buf, pattern);
	char *p = m_buf, *p1 = m_buf, *p2 = NULL;
	m_subs.clear();
	for (; ; ++p) {
		if (*p == '=') {
			*p++ = 0;
			p2 = p;
		}
		else if (*p == ';' || *p == 0) {
			if (*p1 && p2 && *p2)
				m_subs.push_back(make_pair(p1, p2));
			if (*p == 0)
				break;
			*p++ = 0;
			p1 = p;
			p2 = NULL;
		}
	}
	if (m_subs.size() > 0)
		strcpy(this->pattern, pattern);
	else
		strcpy(this->pattern, "(empty)");
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %rsi, %r14
movq %rdi, %rbx
leaq 0x1f4(%rdi), %r13
movq %r13, %rdi
callq 0x2170
movq 0x3e8(%rbx), %rax
cmpq %rax, 0x3f0(%rbx)
je 0x3dce
movq %rax, 0x3f0(%rbx)
leaq 0x3e8(%rbx), %r15
xorl %eax, %eax
leaq 0x8(%rsp), %r12
movq %r13, %rbp
movzbl (%rbp), %ecx
testl %ecx, %ecx
je 0x3dfa
cmpl $0x3b, %ecx
je 0x3dfa
cmpl $0x3d, %ecx
jne 0x3e59
leaq 0x1(%rbp), %rax
movq %rax, %rcx
jmp 0x3e52
cmpb $0x0, (%r13)
je 0x3e45
testq %rax, %rax
je 0x3e45
cmpb $0x0, (%rax)
je 0x3e45
movq %r13, 0x8(%rsp)
movq %rax, 0x10(%rsp)
movq 0x3f0(%rbx), %rsi
cmpq 0x3f8(%rbx), %rsi
je 0x3e37
movups 0x8(%rsp), %xmm0
movups %xmm0, (%rsi)
addq $0x10, 0x3f0(%rbx)
jmp 0x3e42
movq %r15, %rdi
movq %r12, %rdx
callq 0x4f70
movb (%rbp), %cl
testb %cl, %cl
je 0x3e5e
leaq 0x1(%rbp), %r13
xorl %eax, %eax
movq %r13, %rcx
movb $0x0, (%rbp)
movq %rcx, %rbp
incq %rbp
jmp 0x3ddf
movq 0x3f0(%rbx), %rax
cmpq 0x3e8(%rbx), %rax
je 0x3e7b
movq %rbx, %rdi
movq %r14, %rsi
callq 0x2170
jmp 0x3e88
movabsq $0x297974706d6528, %rax # imm = 0x297974706D6528
movq %rax, (%rbx)
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O3/skyshore2001[P]symfind/symfind.cpp
// Function: InitSession(int)
void InitSession(int id)
{
	if (g_sessions.size() == 0) {
		Session ses;
		ses.id = 0;
		ses.maxFound = DEF_MAX_FOUND;
		g_sessions.push_back(ses);
		g_curSession = &g_sessions[0];
	}

	if (g_curSession->id == id)
		return;

	SessionIter it;
	for (it=g_sessions.begin(); it!=g_sessions.end(); ++it) {
		if (it->id == id)
			break;
	}

	// not found, create it based on session 0:
	if (it == g_sessions.end()) {
		g_sessions.push_back(g_sessions[0]);
		g_curSession = &g_sessions.back();
		g_curSession->id = id;
	}
	else {
		g_curSession = & *it;
	}
}

// Assembly:
pushq %r14
pushq %rbx
subq $0x408, %rsp            # imm = 0x408
movl %edi, %ebx
movq 0x53ee(%rip), %rax      # 0x9298
cmpq 0x53df(%rip), %rax      # 0x9290
jne 0x3f13
leaq 0x8(%rsp), %r14
leaq 0x247d(%rip), %rsi      # 0x633c
movq %r14, %rdi
callq 0x491e
movl $0x0, -0x8(%r14)
movl 0x52db(%rip), %eax      # 0x91b0
movl %eax, -0x4(%r14)
leaq 0x53b0(%rip), %rdi      # 0x9290
movq %rsp, %rsi
callq 0x46fe
movq 0x53a1(%rip), %rax      # 0x9290
movq %rax, 0x5392(%rip)      # 0x9288
movq 0x3f0(%rsp), %rdi
testq %rdi, %rdi
je 0x3f13
movq 0x400(%rsp), %rsi
subq %rdi, %rsi
callq 0x21a0
movq 0x536e(%rip), %rax      # 0x9288
cmpl %ebx, (%rax)
je 0x3f7b
movq 0x536b(%rip), %rsi      # 0x9290
movq 0x536c(%rip), %rcx      # 0x9298
movq %rsi, %rax
cmpq %rcx, %rsi
je 0x3f46
movq %rsi, %rax
cmpl %ebx, (%rax)
je 0x3f46
addq $0x408, %rax            # imm = 0x408
cmpq %rcx, %rax
jne 0x3f37
cmpq %rcx, %rax
je 0x3f54
movq %rax, 0x5336(%rip)      # 0x9288
jmp 0x3f7b
leaq 0x5335(%rip), %rdi      # 0x9290
callq 0x46fe
movq 0x5331(%rip), %rax      # 0x9298
leaq -0x408(%rax), %rcx
movq %rcx, 0x5313(%rip)      # 0x9288
movl %ebx, -0x408(%rax)
addq $0x408, %rsp            # imm = 0x408
popq %rbx
popq %r14
retq
movq %rax, %rbx
movq 0x3f0(%rsp), %rdi
testq %rdi, %rdi
je 0x3fa6
movq 0x400(%rsp), %rsi
subq %rdi, %rsi
callq 0x21a0
movq %rbx, %rdi
callq 0x22e0
// File: /workspace/github_cpp_makefile_star2_O3/skyshore2001[P]symfind/symfind.cpp
// Function: SfPattern::SfPattern(char*)
SfPattern(char *pat) {
		matchBegin =false;
		matchEnd = false;
		logicalNot = false;
		patlen = 0;

		char *p = pat;
		if (*p == '!' && *(p+1) != 0) {
			++ p;
			logicalNot = true;
		}

		if (*p == '^' && *(p+1) != 0) {
			++ p;
			matchBegin = true;
		}
		char *p1 = strchr(p, 0);
		if (p1 - p > 1 && *(p1-1) == '$') {
			*--p1 = 0;
			matchEnd = true;
		}
		patlen = p1 -p;
		this->pat = p;

		fnMatch = ContainsUpper(p)? &SfPattern::Match_case: &SfPattern::Match_icase;
	}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rsi, %r14
movq %rdi, %rbx
movw $0x0, 0x8(%rdi)
movb $0x0, 0xa(%rdi)
movl $0x0, 0xc(%rdi)
movb (%rsi), %al
cmpb $0x21, %al
jne 0x44ae
cmpb $0x0, 0x1(%r14)
je 0x44c0
incq %r14
movb $0x1, 0xa(%rbx)
movb (%r14), %al
cmpb $0x5e, %al
jne 0x44c0
cmpb $0x0, 0x1(%r14)
je 0x44c0
incq %r14
movb $0x1, 0x8(%rbx)
movq %r14, %rdi
callq 0x20b0
leaq (%r14,%rax), %rcx
cmpq $0x2, %rax
jl 0x44e2
cmpb $0x24, -0x1(%rcx)
jne 0x44e2
decq %rcx
movb $0x0, (%rcx)
movb $0x1, 0x9(%rbx)
subl %r14d, %ecx
movl %ecx, 0xc(%rbx)
movq %r14, (%rbx)
movb (%r14), %al
leaq 0x361(%rip), %r15       # 0x4856
testb %al, %al
je 0x451e
incq %r14
leaq 0x26b(%rip), %r12       # 0x476e
movsbl %al, %edi
callq 0x2110
testl %eax, %eax
jne 0x451b
movb (%r14), %al
incq %r14
testb %al, %al
jne 0x4503
jmp 0x451e
movq %r12, %r15
movq %r15, 0x10(%rbx)
movq $0x0, 0x18(%rbx)
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
// File: /workspace/github_cpp_makefile_star2_O3/skyshore2001[P]symfind/symfind.cpp
// Function: SfFileIter::Next()
SfFile *Next() {
		if (m_ctx.file && m_ctx.file->next)
			m_ctx.file = m_ctx.file->next;
		else 
			m_ctx.file = NextLink();
		return m_ctx.file;
	}

// Assembly:
pushq %rbx
movq %rdi, %rbx
movq 0x30(%rdi), %rax
testq %rax, %rax
je 0x454c
movq 0x10(%rax), %rax
testq %rax, %rax
jne 0x4561
movq %rbx, %rdi
callq 0x46c4
testq %rax, %rax
je 0x455f
movq 0x8(%rax), %rax
jmp 0x4547
xorl %eax, %eax
movq %rax, 0x30(%rbx)
popq %rbx
retq
nop
// File: /workspace/github_cpp_makefile_star2_O3/skyshore2001[P]symfind/symfind.cpp
// Function: SfSymbolIter::Next()
SfSymbol *Next() {
		if (m_ctx.symbol && m_ctx.symbol->next)
			m_ctx.symbol = m_ctx.symbol->next;
		else
			m_ctx.symbol = NextLink();
		return m_ctx.symbol;
	}

// Assembly:
pushq %rbx
movq %rdi, %rbx
movq 0x38(%rdi), %rax
testq %rax, %rax
je 0x45e4
movq 0x8(%rax), %rax
testq %rax, %rax
jne 0x45f3
movq %rbx, %rdi
callq 0x4536
testq %rax, %rax
jne 0x45db
xorl %eax, %eax
movq %rax, 0x38(%rbx)
popq %rbx
retq
nop
// File: /workspace/github_cpp_makefile_star2_O3/skyshore2001[P]symfind/symfind.cpp
// Function: SfFolderIter::Next()
SfFolder *Next() {
		if (m_ctx.folder && m_ctx.folder->next)
			m_ctx.folder = m_ctx.folder->next;
		else
			m_ctx.folder = NextLink();
		return m_ctx.folder;
	}

// Assembly:
movq 0x28(%rdi), %rax
testq %rax, %rax
je 0x46d6
movq 0x10(%rax), %rax
testq %rax, %rax
jne 0x46f9
movq 0x20(%rdi), %rcx
testq %rcx, %rcx
je 0x46f7
movq 0x18(%rcx), %rcx
movq %rcx, 0x20(%rdi)
testq %rcx, %rcx
je 0x46f7
movq 0x10(%rcx), %rax
testq %rax, %rax
je 0x46da
jmp 0x46f9
xorl %eax, %eax
movq %rax, 0x28(%rdi)
retq
// File: /workspace/github_cpp_makefile_star2_O3/skyshore2001[P]symfind/symfind.cpp
// Function: SfPattern::Match_case(char const*)
bool Match_case(const char *s) {
		if (patlen <= 0)
			return true;
		int slen = strlen(s);
		if (slen < patlen)
			return false;

		if (matchBegin || matchEnd) {
			if (matchBegin && matchEnd)
				return strcmp(s, pat) == 0;
			return BeginWith_case((matchBegin? s: s+slen-patlen), pat);
		}
		else {
			for (; *s; ++s) {
				if (*s == *pat && BeginWith_case(s+1, pat+1))
					return true;
			}
		}
		return false;
	}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movslq 0xc(%rdi), %r15
testq %r15, %r15
jle 0x484d
movq %rsi, %rbx
movq %rdi, %r14
movq %rsi, %rdi
callq 0x20b0
cmpl %eax, %r15d
jle 0x479a
xorl %eax, %eax
jmp 0x484f
movb 0x8(%r14), %cl
movb 0x9(%r14), %dl
testb %cl, %cl
je 0x47b9
testb %dl, %dl
je 0x47bd
movq (%r14), %rsi
movq %rbx, %rdi
callq 0x2230
testl %eax, %eax
jmp 0x47f3
testb %dl, %dl
je 0x47f8
movl %eax, %eax
addq %rbx, %rax
subq %r15, %rax
testb %cl, %cl
cmovneq %rbx, %rax
movq (%r14), %rcx
movb (%rax), %dl
testb %dl, %dl
je 0x47f0
incq %rax
movb (%rcx), %sil
testb %sil, %sil
je 0x47f0
cmpb %sil, %dl
jne 0x4793
incq %rcx
movb (%rax), %dl
incq %rax
testb %dl, %dl
jne 0x47d7
cmpb $0x0, (%rcx)
sete %al
jmp 0x484f
movb (%rbx), %cl
testb %cl, %cl
je 0x4793
movq (%r14), %rdx
movb (%rdx), %sil
leaq 0x1(%rdx), %rdi
cmpb %sil, %cl
movb 0x1(%rbx), %cl
jne 0x4842
movq %rdi, %rax
testb %cl, %cl
je 0x483d
movl $0x1, %eax
movl %ecx, %r8d
movb (%rdx,%rax), %r9b
testb %r9b, %r9b
je 0x484d
cmpb %r9b, %r8b
jne 0x4842
movb 0x1(%rbx,%rax), %r8b
incq %rax
testb %r8b, %r8b
jne 0x481f
addq %rdx, %rax
cmpb $0x0, (%rax)
je 0x484d
incq %rbx
xorl %eax, %eax
testb %cl, %cl
jne 0x4808
jmp 0x484f
movb $0x1, %al
popq %rbx
popq %r14
popq %r15
retq
nop
// File: /workspace/github_cpp_makefile_star2_O3/skyshore2001[P]symfind/symfind.cpp
// Function: SfPattern::Match_icase(char const*)
bool Match_icase(const char *s) {
		if (patlen <= 0)
			return true;
		int slen = strlen(s);
		if (slen < patlen)
			return false;

		if (matchBegin || matchEnd) {
			if (matchBegin && matchEnd)
				return strcasecmp(s, pat) == 0;
			return BeginWith_icase((matchBegin? s: s+slen-patlen), pat);
		}
		else {
			for (; *s; ++s) {
				if (toupper(*s) == toupper(*pat) && BeginWith_icase(s+1, pat+1))
					return true;
			}
		}
		return false;
	}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movslq 0xc(%rdi), %r15
movb $0x1, %bpl
testq %r15, %r15
jle 0x487f
movq %rsi, %rbx
movq %rdi, %r14
movq %rsi, %rdi
callq 0x20b0
cmpl %eax, %r15d
jle 0x488a
xorl %ebp, %ebp
movl %ebp, %eax
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
movb 0x8(%r14), %cl
movb 0x9(%r14), %dl
testb %cl, %cl
je 0x48ad
testb %dl, %dl
je 0x48b1
movq (%r14), %rsi
movq %rbx, %rdi
callq 0x21b0
testl %eax, %eax
sete %bpl
jmp 0x487f
testb %dl, %dl
je 0x48cf
movl %eax, %edi
addq %rbx, %rdi
subq %r15, %rdi
testb %cl, %cl
cmovneq %rbx, %rdi
movq (%r14), %rsi
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
jmp 0x250c
movb (%rbx), %r12b
testb %r12b, %r12b
je 0x487d
movq (%r14), %r14
movsbl (%r14), %edi
callq 0x2320
movl %eax, %r15d
incq %r14
incq %rbx
movsbl %r12b, %edi
callq 0x2320
cmpl %r15d, %eax
jne 0x490d
movq %rbx, %rdi
movq %r14, %rsi
callq 0x250c
testb %al, %al
jne 0x487f
movb (%rbx), %r12b
incq %rbx
testb %r12b, %r12b
jne 0x48ec
jmp 0x487d
nop
// File: /workspace/github_cpp_makefile_star2_O3/tkrobatsch[P]YAML_Maker/yaml_data.cpp
// Function: serialize_encaps(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>)
std::string serialize_encaps(std::string input) {
	std::string serialize;
	serialize += "'";
	for (int i = 0; i < input.length(); i++) {
		if (!((input[i] < 0) || (input[i] > 255))) {
			serialize += input[i];
		}
	}
	//clear any spaces at end
	serialize.erase(std::find_if(serialize.rbegin(), serialize.rend(),
		std::not1(std::ptr_fun<int, int>(std::isspace))).base(), serialize.end());
	serialize += "'";
	return serialize;
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %rsi, %r14
movq %rdi, %rbx
leaq 0x10(%rdi), %r15
movq %r15, (%rdi)
movq $0x0, 0x8(%rdi)
movb $0x0, 0x10(%rdi)
leaq 0x4b49(%rip), %rsi      # 0x7020
callq 0x2300
movq 0x8(%r14), %rax
testq %rax, %rax
je 0x250a
xorl %r12d, %r12d
movq (%r14), %rcx
movb (%rcx,%r12), %cl
testb %cl, %cl
js 0x2502
movsbl %cl, %esi
movq %rbx, %rdi
callq 0x2180
movq 0x8(%r14), %rax
incq %r12
cmpq %r12, %rax
ja 0x24e8
movq (%rbx), %rax
movq 0x8(%rbx), %rcx
addq %rax, %rcx
leaq 0x10(%rsp), %rsi
movq %rcx, (%rsi)
leaq 0x8(%rsp), %rdx
movq %rax, (%rdx)
movq 0x7a7d(%rip), %rcx      # 0x9fa8
movq %rsp, %rdi
callq 0x604b
movq (%rsp), %rax
movq %rax, %rcx
subq (%rbx), %rcx
movq %rcx, 0x8(%rbx)
movb $0x0, (%rax)
leaq 0x4ad5(%rip), %rsi      # 0x7020
movq %rbx, %rdi
callq 0x2300
movq %rbx, %rax
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
jmp 0x2566
jmp 0x2566
movq %rax, %r14
movq (%rbx), %rdi
cmpq %r15, %rdi
je 0x257c
movq (%r15), %rsi
incq %rsi
callq 0x21c0
movq %r14, %rdi
callq 0x22c0
// File: /workspace/github_cpp_makefile_star2_O3/tkrobatsch[P]YAML_Maker/yaml_data.cpp
// Function: serialize(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>)
std::string serialize(std::string input) {
	std::string serialize;
	for (int i = 0; i < input.length(); i++) {
		if (!((input[i] < 0) || (input[i] > 255))) {
			serialize += input[i];
		}
	}
	//clear any spaces at end
	serialize.erase(std::find_if(serialize.rbegin(), serialize.rend(),
		std::not1(std::ptr_fun<int, int>(std::isspace))).base(), serialize.end());
	return serialize;
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %rdi, %rbx
leaq 0x10(%rdi), %r15
movq %r15, (%rdi)
movq $0x0, 0x8(%rdi)
movb $0x0, 0x10(%rdi)
movq 0x8(%rsi), %rax
testq %rax, %rax
je 0x25df
movq %rsi, %r14
xorl %r12d, %r12d
movq (%r14), %rcx
movb (%rcx,%r12), %cl
testb %cl, %cl
js 0x25ce
movsbl %cl, %esi
movq %rbx, %rdi
callq 0x2180
movq 0x8(%r14), %rax
incq %r12
cmpq %r12, %rax
ja 0x25b4
movq (%rbx), %rcx
movq 0x8(%rbx), %rax
jmp 0x25e4
xorl %eax, %eax
movq %r15, %rcx
addq %rcx, %rax
leaq 0x10(%rsp), %rsi
movq %rax, (%rsi)
leaq 0x8(%rsp), %rdx
movq %rcx, (%rdx)
movq 0x79aa(%rip), %rcx      # 0x9fa8
movq %rsp, %rdi
callq 0x604b
movq (%rsp), %rax
movq %rax, %rcx
subq (%rbx), %rcx
movq %rcx, 0x8(%rbx)
movb $0x0, (%rax)
movq %rbx, %rax
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
jmp 0x2628
movq %rax, %r14
movq (%rbx), %rdi
cmpq %r15, %rdi
je 0x263e
movq (%r15), %rsi
incq %rsi
callq 0x21c0
movq %r14, %rdi
callq 0x22c0
// File: /workspace/github_cpp_makefile_star2_O3/sisong[P]ApkDiffPatch/src/patch/Zipper.cpp
// Function: UnZipper_file_is_nameEndWith
bool UnZipper_file_is_nameEndWith(const UnZipper* self,int fileIndex,const char* nameSuffix,int nameSuffixLen){
    int fnLen=UnZipper_file_nameLen(self,fileIndex);
    if (fnLen<nameSuffixLen) return false;
    const char* fn=UnZipper_file_nameBegin(self,fileIndex);
    return (0==memcmp(fn+fnLen-nameSuffixLen,nameSuffix,nameSuffixLen));
}

// Assembly:
movq 0x50(%rdi), %rax
movq 0x58(%rdi), %rdi
movslq %esi, %rsi
movl (%rdi,%rsi,4), %esi
movzwl 0x1c(%rax,%rsi), %edi
cmpl %ecx, %edi
jge 0x443c
xorl %eax, %eax
retq
pushq %rax
addq %rsi, %rax
addq %rax, %rdi
movslq %ecx, %rax
subq %rax, %rdi
addq $0x2e, %rdi
movq %rdx, %rsi
movq %rax, %rdx
callq 0x2210
testl %eax, %eax
sete %al
addq $0x8, %rsp
retq
// File: /workspace/github_cpp_makefile_star2_O3/wo3kie[P]calc/calc.cpp
// Function: ast::Calc::operator()(ast::Expression const&) const
double operator()( Expression const & x ) const
        {
            double state = boost::apply_visitor( *this, x.head_ );

            for( Operation const & oper : x.tail_ )
            {
                state = ( *this )( oper, state );
            }

            return state;
        }

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rsi, %rbx
movq %rdi, %r14
movq %rsi, %rdi
movq %r14, %rsi
callq 0x1291a
movq 0x10(%rbx), %r15
addq $0x10, %rbx
cmpq %rbx, %r15
je 0x9a96
leaq 0x10(%r15), %rsi
movq %r14, %rdi
callq 0x126e0
movq (%r15), %r15
jmp 0x9a80
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_cpp_makefile_star2_O3/wo3kie[P]calc/calc.cpp
// Function: void error_handler_::operator()<__gnu_cxx::__normal_iterator<char const*, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>>(boost::spirit::info const&, __gnu_cxx::__normal_iterator<char const*, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>, __gnu_cxx::__normal_iterator<char const*, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>) const
void operator()(
        qi::info const & what
      , TIterator err_pos, TIterator last ) const
    {
        std::cout
            << "Error! Expecting "
            << what
            << " here: \""
            << std::string( err_pos, last )
            << "\""
            << std::endl
        ;
    }

// Assembly:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x30, %rsp
movq %rcx, %r14
movq %rdx, %r15
movq %rsi, %r12
movq 0xbebd(%rip), %rbx      # 0x1dfc8
leaq 0x20e6(%rip), %rsi      # 0x141f8
movl $0x11, %edx
movq %rbx, %rdi
callq 0x3260
leaq 0x28(%rsp), %rax
movq %rbx, (%rax)
leaq 0x8(%rsp), %rsi
movq %rax, (%rsi)
movq %r12, 0x8(%rsi)
movl $0x0, 0x10(%rsi)
addq $0x20, %r12
movq %r12, %rdi
callq 0x1220c
leaq 0x20bd(%rip), %rsi      # 0x1420a
movl $0x8, %edx
movq %rbx, %rdi
callq 0x3260
leaq 0x18(%rsp), %r13
movq %r13, -0x10(%r13)
leaq 0x8(%rsp), %r12
movq %r12, %rdi
movq %r15, %rsi
movq %r14, %rdx
callq 0x12c70
movq (%r12), %rsi
movq 0x8(%r12), %rdx
movq %rbx, %rdi
callq 0x3260
movq %rax, %rbx
leaq 0x2080(%rip), %rsi      # 0x14211
movl $0x1, %edx
movq %rax, %rdi
callq 0x3260
movq (%rbx), %rax
movq -0x18(%rax), %rdi
addq %rbx, %rdi
movl $0xa, %esi
callq 0x31f0
movsbl %al, %esi
movq %rbx, %rdi
callq 0x3030
movq %rax, %rdi
callq 0x3160
movq 0x8(%rsp), %rdi
cmpq %r13, %rdi
je 0x121dc
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x3220
addq $0x30, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
movq %rax, %rbx
movq 0x8(%rsp), %rdi
cmpq %r13, %rdi
je 0x12204
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x3220
movq %rbx, %rdi
callq 0x3390
// File: /workspace/github_cpp_makefile_star2_O3/wo3kie[P]calc/calc.cpp
// Function: ast::Calc::operator()(ast::Signed const&) const
double operator()( Signed const & x ) const
        {
            double const rhs = boost::apply_visitor( *this, x.operand_ );

            switch( x.sign_ )
            {
                case '-':
                    return - rhs;

                case '+':
                    return + rhs;

                case '!':
                    return ( fabs( rhs ) < 0.000001 ) ? 1 : 0;

                default:
                    BOOST_ASSERT( 0 );
            }
        }

// Assembly:
pushq %rbx
movq %rsi, %rbx
movq %rdi, %rsi
leaq 0x8(%rbx), %rdi
callq 0x1291a
movzbl (%rbx), %eax
cmpl $0x21, %eax
je 0x129e4
cmpl $0x2b, %eax
je 0x12a01
cmpl $0x2d, %eax
jne 0x12a03
xorpd 0x6ce(%rip), %xmm0      # 0x130b0
jmp 0x12a01
andpd 0x6b4(%rip), %xmm0      # 0x130a0
cmpltsd 0x66b(%rip), %xmm0      # 0x13060
movsd 0x63b(%rip), %xmm1      # 0x13038
andpd %xmm1, %xmm0
popq %rbx
retq
leaq 0xfb9(%rip), %rdi       # 0x139c3
leaq 0xc86(%rip), %rsi       # 0x13697
leaq 0x1823(%rip), %rcx      # 0x1423b
movl $0xf3, %edx
callq 0x3140
// File: /workspace/github_cpp_makefile_star2_O3/lioncedric[P]cimpressGridCoverage/src/squares.cc
// Function: clear_square(int*, int, int const*)
void clear_square(int * puzzle, const int width, const int * square) {

    const int row = *(square + 1);
    const int col = *square;
    const int square_size = *(square + 2);
    const int * ptrLineMax = puzzle + col + (row + square_size) * width;
    for (int* ptrLine = puzzle + col + (row) * width; ptrLine < ptrLineMax; ptrLine += width) {
        const int * ptrColMax = ptrLine + square_size;
        for (int* ptrCol = ptrLine; ptrCol < ptrColMax; ++ptrCol) {
            *ptrCol = 1;
        }
    }

}

// Assembly:
movl 0x4(%rdx), %r8d
movslq 0x8(%rdx), %rax
leal (%rax,%r8), %r9d
imull %esi, %r9d
imull %esi, %r8d
cmpl %r9d, %r8d
jge 0x39bd
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
movslq (%rdx), %r11
leaq (%rdi,%r11,4), %rcx
movslq %r9d, %rdx
leaq (%rcx,%rdx,4), %rdx
movslq %r8d, %r10
leaq (%rcx,%r10,4), %r8
movslq %esi, %rsi
leaq (%rcx,%rax,4), %r9
leaq (,%r10,4), %r14
leaq (%r9,%r10,4), %r9
shlq $0x2, %rsi
leaq (%rcx,%r10,4), %r10
addq $0x4, %r10
notq %rdi
leaq (%r14,%r11,4), %r11
subq %r11, %rdi
movq %rsi, %r11
negq %r11
leaq (%r8,%rax,4), %rbx
notq %rcx
subq %r14, %rcx
xorl %r14d, %r14d
movdqa 0x1837(%rip), %xmm0     # 0x50a0
movdqa 0x183f(%rip), %xmm1     # 0x50b0
movdqa 0x1847(%rip), %xmm2     # 0x50c0
pcmpeqd %xmm3, %xmm3
movq %r10, %r15
cmpq %r15, %rbx
movq %r15, %r12
cmovaq %rbx, %r12
testl %eax, %eax
jle 0x399b
addq %rcx, %r12
shrq $0x2, %r12
addq $0x4, %r12
andq $-0x4, %r12
movq %rsi, %r13
imulq %r14, %r13
leaq (%r9,%r13), %rbp
addq %r10, %r13
cmpq %r13, %rbp
cmovaq %rbp, %r13
movq %r11, %rbp
imulq %r14, %rbp
addq %rdi, %rbp
addq %r13, %rbp
movq %rbp, %xmm4
pshufd $0x44, %xmm4, %xmm4     # xmm4 = xmm4[0,1,0,1]
psrlq $0x2, %xmm4
pxor %xmm2, %xmm4
xorl %r13d, %r13d
movq %r13, %xmm5
pshufd $0x44, %xmm5, %xmm5     # xmm5 = xmm5[0,1,0,1]
movdqa %xmm5, %xmm6
por %xmm1, %xmm6
pxor %xmm2, %xmm6
movdqa %xmm6, %xmm7
pcmpgtd %xmm4, %xmm7
pcmpeqd %xmm4, %xmm6
pshufd $0xf5, %xmm6, %xmm8     # xmm8 = xmm6[1,1,3,3]
pand %xmm7, %xmm8
pshufd $0xf5, %xmm7, %xmm6     # xmm6 = xmm7[1,1,3,3]
por %xmm8, %xmm6
movd %xmm6, %ebp
notl %ebp
testb $0x1, %bpl
je 0x3924
movl $0x1, (%r8,%r13,4)
pxor %xmm3, %xmm6
pextrw $0x4, %xmm6, %ebp
testb $0x1, %bpl
je 0x393c
movl $0x1, 0x4(%r8,%r13,4)
por %xmm0, %xmm5
pxor %xmm2, %xmm5
movdqa %xmm5, %xmm6
pcmpgtd %xmm4, %xmm6
pcmpeqd %xmm4, %xmm5
pshufd $0xf5, %xmm5, %xmm7     # xmm7 = xmm5[1,1,3,3]
pand %xmm6, %xmm7
pshufd $0xf5, %xmm6, %xmm5     # xmm5 = xmm6[1,1,3,3]
por %xmm7, %xmm5
pxor %xmm3, %xmm5
pextrw $0x0, %xmm5, %ebp
testb $0x1, %bpl
je 0x397a
movl $0x1, 0x8(%r8,%r13,4)
pextrw $0x4, %xmm5, %ebp
testb $0x1, %bpl
je 0x398e
movl $0x1, 0xc(%r8,%r13,4)
addq $0x4, %r13
cmpq %r13, %r12
jne 0x38d9
addq %rsi, %r8
incq %r14
addq %rsi, %rbx
addq %rsi, %r15
subq %rsi, %rcx
cmpq %rdx, %r8
jb 0x3880
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O3/jgeumlek[P]moltengamepadctl/source/main.cpp
// Function: remove_pending(int)
int remove_pending(int id) {
  std::lock_guard<std::mutex> guard(pending_lock);
  for (auto it = pending_requests.begin(); it != pending_requests.end(); it++) {
    if (*it == id) {
      pending_requests.erase(it);
      return 0;
    }
  }
  return -1;
}

// Assembly:
pushq %rbp
pushq %rbx
pushq %rax
movl %edi, %ebp
leaq 0x6cfb(%rip), %rdi      # 0x92d0
callq 0x22c0
testl %eax, %eax
jne 0x264a
movq 0x6cd3(%rip), %rdi      # 0x92b8
movq 0x6cd4(%rip), %rax      # 0x92c0
movl $0xffffffff, %ebx       # imm = 0xFFFFFFFF
cmpq %rax, %rdi
je 0x2635
movq %rax, %rdx
subq %rdi, %rdx
addq $-0x4, %rdx
cmpl %ebp, (%rdi)
je 0x2613
addq $0x4, %rdi
addq $-0x4, %rdx
cmpq %rax, %rdi
jne 0x2600
jmp 0x2635
leaq 0x4(%rdi), %rsi
cmpq %rax, %rsi
je 0x2628
callq 0x2300
movq 0x6c98(%rip), %rax      # 0x92c0
addq $-0x4, %rax
movq %rax, 0x6c8d(%rip)      # 0x92c0
xorl %ebx, %ebx
leaq 0x6c94(%rip), %rdi      # 0x92d0
callq 0x2180
movl %ebx, %eax
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
movl %eax, %edi
callq 0x2160
// File: /workspace/github_cpp_makefile_star2_O3/jgeumlek[P]moltengamepadctl/source/main.cpp
// Function: read_osc(int, oscpkt::PacketReader*)
int read_osc(int fd, oscpkt::PacketReader* pr) {
  uint32_t size;
  char buff[1024*128];
  int bytes = read(fd, &size, sizeof(size));
  if (bytes == -EAGAIN) return 0;
  if (bytes < sizeof(size) || size >=1024*128)
    return -1;
  bytes = read(fd, &buff, size);
  pr->init(&buff, bytes);
  return bytes;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
subq $0x20018, %rsp          # imm = 0x20018
movq %rsi, %rbx
movl %edi, %ebp
leaq 0xc(%rsp), %rsi
movl $0x4, %edx
callq 0x22b0
xorl %r14d, %r14d
cmpl $-0xb, %eax
je 0x2a71
testl $0xfffffffc, %eax       # imm = 0xFFFFFFFC
sete %cl
movl 0xc(%rsp), %eax
cmpl $0x20000, %eax          # imm = 0x20000
setae %dl
orb %cl, %dl
movl $0xffffffff, %r14d      # imm = 0xFFFFFFFF
jne 0x2a71
movl %eax, %edx
leaq 0x10(%rsp), %r15
movl %ebp, %edi
movq %r15, %rsi
callq 0x22b0
movq %rax, %r14
movslq %r14d, %rdx
movq %rbx, %rdi
movq %r15, %rsi
callq 0x3aa2
movl %r14d, %eax
addq $0x20018, %rsp          # imm = 0x20018
popq %rbx
popq %r14
popq %r15
popq %rbp
retq