LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_cpp_makefile_star2_O2/halfflat[P]tinyopt/include/tinyopt/tinyopt.h
// Function: to::option::longest_label[abi:cxx11]() const
std::string longest_label() const {
        const std::string* p = 0;
        for (auto& k: keys) {
            if (!p || k.label.size()>p->size()) p = &k.label;
        }
        return p? *p: std::string{};
    }

// Assembly:
pushq %rbx
movq %rdi, %rbx
movq 0x20(%rsi), %rax
movq 0x28(%rsi), %rcx
xorl %esi, %esi
cmpq %rcx, %rax
je 0x418b
testq %rsi, %rsi
je 0x4182
movq 0x8(%rax), %rdx
cmpq 0x8(%rsi), %rdx
jbe 0x4185
movq %rax, %rsi
addq $0x28, %rax
jmp 0x416e
testq %rsi, %rsi
je 0x419a
movq %rbx, %rdi
callq 0x21c0
jmp 0x41aa
leaq 0x10(%rbx), %rax
movq %rax, (%rbx)
andq $0x0, 0x8(%rbx)
movb $0x0, 0x10(%rbx)
movq %rbx, %rax
popq %rbx
retq
nop
// File: /workspace/github_cpp_makefile_star2_O2/halfflat[P]tinyopt/include/tinyopt/tinyopt.h
// Function: to::impl::counted_option::match(to::state&)
maybe_keyarg match(state& st) {
            bool empty_keyset = keys.empty();

            auto try_run = [&](const std::string& label, const state::match_result& mr) -> maybe_keyarg {
                if (run(label, mr.argument)) {
                    st.consume(mr);
                    ++count;
                    return std::make_pair(empty_keyset? nullptr: label.c_str(), mr.argument);
                }
                return nothing;
            };

            if (is_flag) {
                for (auto& k: keys) if (auto m = st.match_flag(k)) return try_run(k.label, *m);
            }
            else if (!empty_keyset) {
                for (auto& k: keys) if (auto m = st.match_option(k)) return try_run(k.label, *m);
            }
            else {
                return try_run("", state::match_result{*st.argv, 1, 0});
            }

            return nothing;
        }

// Assembly:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x50, %rsp
movq %rdx, %r14
movq %rdi, %rbx
movq 0x20(%rsi), %r15
movq 0x28(%rsi), %r13
cmpq %r13, %r15
leaq 0x7(%rsp), %rax
sete (%rax)
movq %rsi, 0x28(%rsp)
movq %rdx, 0x30(%rsp)
movq %rax, 0x38(%rsp)
cmpb $0x1, 0x68(%rsi)
jne 0x4dd4
leaq 0x8(%rsp), %r12
cmpq %r13, %r15
je 0x4dfe
movq %r12, %rdi
movq %r14, %rsi
movq %r15, %rdx
callq 0x4f12
cmpb $0x1, 0x8(%rsp)
je 0x4e03
addq $0x28, %r15
jmp 0x4db4
cmpq %r13, %r15
je 0x4e1a
leaq 0x8(%rsp), %r12
cmpq %r13, %r15
je 0x4dfe
movq %r12, %rdi
movq %r14, %rsi
movq %r15, %rdx
callq 0x5018
cmpb $0x1, 0x8(%rsp)
je 0x4e03
addq $0x28, %r15
jmp 0x4dde
movb $0x0, (%rbx)
jmp 0x4e64
leaq 0x10(%rsp), %rcx
leaq 0x28(%rsp), %rsi
movq %rbx, %rdi
movq %r15, %rdx
callq 0x4fac
jmp 0x4e64
leaq 0x12af(%rip), %rsi      # 0x60d0
leaq 0x8(%rsp), %r15
leaq 0x6(%rsp), %rdx
movq %r15, %rdi
callq 0x29fc
movq 0x8(%r14), %rax
movq (%rax), %rax
leaq 0x40(%rsp), %rcx
movq %rax, (%rcx)
movq $0x1, 0x8(%rcx)
leaq 0x28(%rsp), %rsi
movq %rbx, %rdi
movq %r15, %rdx
callq 0x4fac
leaq 0x8(%rsp), %rdi
callq 0x2090
movq %rbx, %rax
addq $0x50, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
movq %rax, %rbx
leaq 0x8(%rsp), %rdi
callq 0x2090
movq %rbx, %rdi
callq 0x2220
// File: /workspace/github_cpp_makefile_star2_O2/halfflat[P]tinyopt/include/tinyopt/tinyopt.h
// Function: to::state::shift(unsigned int)
void shift(unsigned n = 1) {
        if (!n) return;

        char** skip = argv;
        while (*skip && n) ++skip, --n;

        argc -= (skip-argv);
        auto p = argv;
        do { *p++ = *skip; } while (*skip++);

        optoff = 0;
    }

// Assembly:
testl %esi, %esi
je 0x4ef4
movq 0x8(%rdi), %rax
movl %esi, %edx
xorl %ecx, %ecx
cmpq $0x0, (%rax,%rcx,8)
je 0x4ed4
cmpl %ecx, %edx
je 0x4ed4
incq %rcx
jmp 0x4ec4
movq (%rdi), %rdx
subl %ecx, (%rdx)
xorl %edx, %edx
leaq (%rax,%rdx), %rsi
movq (%rsi,%rcx,8), %rsi
movq %rsi, (%rax,%rdx)
addq $0x8, %rdx
testq %rsi, %rsi
jne 0x4edb
andl $0x0, 0x10(%rdi)
retq
nop
// File: /workspace/github_cpp_makefile_star2_O2/halfflat[P]tinyopt/include/tinyopt/tinyopt.h
// Function: to::state::match_flag(to::key const&)
maybe<match_result> match_flag(const key& k) {
        if (k.style==key::compact) {
            if (auto m = match_compact_key(k.label.c_str())) {
                if ((*argv)[optoff+*m]) 
                    return match_result{nullptr, 0, *m};
                else
                    return match_result{nullptr, 1, 0};
            }
        }
        else if (!optoff && k.label==*argv) {
            return match_result{nullptr, 1, 0};
        }

        return nothing;
    }

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
subq $0x10, %rsp
movq %rsi, %r14
movq %rdi, %rbx
cmpl $0x2, 0x20(%rdx)
jne 0x4f70
movq (%rdx), %rdx
leaq 0x8(%rsp), %r15
movq %r15, %rdi
movq %r14, %rsi
callq 0x5112
cmpb $0x1, (%r15)
jne 0x4f9c
movq 0x8(%r14), %rax
movq (%rax), %rax
movl 0xc(%rsp), %ecx
movl 0x10(%r14), %edx
addl %ecx, %edx
xorl %esi, %esi
xorl %edi, %edi
cmpb $0x0, (%rax,%rdx)
sete %dil
cmovnel %ecx, %esi
movb $0x1, (%rbx)
andq $0x0, 0x8(%rbx)
movl %edi, 0x10(%rbx)
movl %esi, 0x14(%rbx)
jmp 0x4f9f
cmpl $0x0, 0x10(%r14)
jne 0x4f9c
movq 0x8(%r14), %rax
movq (%rax), %rsi
movq %rdx, %rdi
callq 0x51c5
testb %al, %al
je 0x4f9c
movb $0x1, (%rbx)
andq $0x0, 0x8(%rbx)
movq $0x1, 0x10(%rbx)
jmp 0x4f9f
movb $0x0, (%rbx)
movq %rbx, %rax
addq $0x10, %rsp
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_cpp_makefile_star2_O2/halfflat[P]tinyopt/include/tinyopt/tinyopt.h
// Function: to::state::match_option(to::key const&)
maybe<match_result> match_option(const key& k) {
        if (k.style==key::compact) {
            if (auto m = match_compact_key(k.label.c_str())) {
                if ((*argv)[optoff+*m])
                    return match_result{*argv+optoff+*m, 1, 0};
                else
                    return match_result{argv[1], 2, 0};
            }
        }
        else if (!optoff && k.label==*argv) {
            return match_result{argv[1], 2, 0};
        }
        else if (!optoff && k.style==key::longfmt) {
            auto keylen = k.label.length();
            if (!std::strncmp(*argv, k.label.c_str(), keylen) && (*argv)[keylen]=='=') {
                return match_result{*argv+keylen+1, 1, 0};
            }
        }

        return nothing;
    }

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
subq $0x10, %rsp
movq %rdx, %r15
movq %rsi, %r14
movq %rdi, %rbx
cmpl $0x2, 0x20(%rdx)
jne 0x506b
movq (%r15), %rdx
leaq 0x8(%rsp), %r15
movq %r15, %rdi
movq %r14, %rsi
callq 0x5112
cmpb $0x1, (%r15)
jne 0x5072
movq 0x8(%r14), %rcx
movq (%rcx), %rax
movl 0x10(%r14), %edx
movl 0xc(%rsp), %esi
leal (%rsi,%rdx), %edi
cmpb $0x0, (%rax,%rdi)
je 0x50a3
addq %rdx, %rax
addq %rsi, %rax
pushq $0x1
jmp 0x50a9
cmpl $0x0, 0x10(%r14)
je 0x5077
movb $0x0, (%rbx)
jmp 0x50b8
movq 0x8(%r14), %rax
movq (%rax), %rsi
movq %r15, %rdi
callq 0x51c5
testb %al, %al
je 0x50c5
movq 0x8(%r14), %rax
movq 0x8(%rax), %rax
movb $0x1, (%rbx)
movq %rax, 0x8(%rbx)
movq $0x2, 0x10(%rbx)
jmp 0x50b8
movq 0x8(%rcx), %rax
pushq $0x2
popq %rcx
movb $0x1, (%rbx)
movq %rax, 0x8(%rbx)
movl %ecx, 0x10(%rbx)
andl $0x0, 0x14(%rbx)
movq %rbx, %rax
addq $0x10, %rsp
popq %rbx
popq %r14
popq %r15
retq
cmpl $0x0, 0x10(%r14)
jne 0x5072
cmpl $0x1, 0x20(%r15)
jne 0x5072
movq (%r15), %rsi
movq 0x8(%r15), %r15
movq 0x8(%r14), %rax
movq (%rax), %r14
movq %r14, %rdi
movq %r15, %rdx
callq 0x20a0
testl %eax, %eax
jne 0x5072
cmpb $0x3d, (%r14,%r15)
jne 0x5072
addq %r15, %r14
incq %r14
movb $0x1, (%rbx)
movq %r14, 0x8(%rbx)
movq $0x1, 0x10(%rbx)
jmp 0x50b8
// File: /workspace/github_cpp_makefile_star2_O2/halfflat[P]tinyopt/include/tinyopt/tinyopt.h
// Function: to::state::match_compact_key(char const*)
maybe<unsigned> match_compact_key(const char* k) {
        unsigned keylen = std::strlen(k);

        unsigned prefix_max = std::min(keylen-1, optoff);
        for (std::size_t l = 0; l<=prefix_max; ++l) {
            if (l && strncmp(*argv, k, l)) break;
            if (strncmp(*argv+optoff, k+l, keylen-l)) continue;

            return keylen-l;
        }

        return nothing;
    }

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %rdx, %r14
movq %rsi, %r12
movq %rdi, (%rsp)
movq %rdx, %rdi
callq 0x2080
leal -0x1(%rax), %ebx
movl 0x10(%r12), %r15d
cmpl %ebx, %r15d
cmovbl %r15d, %ebx
movq 0x8(%r12), %rcx
movq %rcx, 0x10(%rsp)
movq %rax, 0x8(%rsp)
movl %eax, %r12d
incq %rbx
xorl %r13d, %r13d
cmpq %r13, %rbx
je 0x51ae
movq 0x10(%rsp), %rax
movq (%rax), %rbp
testq %r13, %r13
je 0x517d
movq %rbp, %rdi
movq %r14, %rsi
movq %r13, %rdx
callq 0x20a0
testl %eax, %eax
jne 0x51ae
addq %r15, %rbp
leaq (%r14,%r13), %rsi
movq %rbp, %rdi
movq %r12, %rdx
callq 0x20a0
incq %r13
decq %r12
testl %eax, %eax
jne 0x5159
movq 0x8(%rsp), %rcx
subl %r13d, %ecx
incl %ecx
movq (%rsp), %rax
movl %ecx, 0x4(%rax)
movb $0x1, %cl
jmp 0x51b4
xorl %ecx, %ecx
movq (%rsp), %rax
movb %cl, (%rax)
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/iZhangHui[P]CppPrimer/CH17_SpecializedLibraryFacilities/examples/game.cc
// Function: main
int main()
{
	string resp;
	// distributions and engines have state,
    // they must be defined outside the loop!
	default_random_engine e;  

	// 50/50 odds by default
	bernoulli_distribution b(0.55); // give the house a slight edge

	do {
		bool first = b(e);    // if true, the program will go first
		cout << (first ? "We go first" 
	                   : "You get to go first") << endl;
		// play the game passing the indicator of who goes first
		cout << ((play(first)) ? "sorry, you lost" 
	                           : "congrats, you won") << endl;
		cout << "play again? Enter 'yes' or 'no'" << endl;
	} while (cin >> resp && resp[0] == 'y');

	return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x38, %rsp
leaq -0x40(%rbp), %rax
movq %rax, -0x10(%rax)
andq $0x0, -0x8(%rax)
movb $0x0, (%rax)
leaq -0x58(%rbp), %rbx
movq $0x1, (%rbx)
movq 0x2d99(%rip), %r14      # 0x3fd0
leaq 0xe54(%rip), %r15       # 0x2092
movq 0x2d9b(%rip), %r12      # 0x3fe0
leaq -0x50(%rbp), %r13
movq %rbx, %rdi
callq 0x131d
movsd %xmm0, -0x30(%rbp)
movsd 0xdaa(%rip), %xmm0      # 0x2008
ucomisd -0x30(%rbp), %xmm0
leaq 0xdf2(%rip), %rsi       # 0x205c
leaq 0xddf(%rip), %rax       # 0x2050
cmovaq %rax, %rsi
movq %r14, %rdi
callq 0x1080
movq %rax, %rdi
callq 0x1040
movsd 0xd7b(%rip), %xmm0      # 0x2008
ucomisd -0x30(%rbp), %xmm0
leaq 0xde7(%rip), %rsi       # 0x2080
leaq 0xdd0(%rip), %rax       # 0x2070
cmovaq %rax, %rsi
movq %r14, %rdi
callq 0x1080
movq %rax, %rdi
callq 0x1040
movq %r14, %rdi
movq %r15, %rsi
callq 0x1080
movq %rax, %rdi
callq 0x1040
movq %r12, %rdi
movq %r13, %rsi
callq 0x1090
movq (%rax), %rcx
movq -0x18(%rcx), %rcx
testb $0x5, 0x20(%rax,%rcx)
jne 0x12ed
movq -0x50(%rbp), %rax
cmpb $0x79, (%rax)
je 0x1249
leaq -0x50(%rbp), %rdi
callq 0x1030
xorl %eax, %eax
addq $0x38, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
jmp 0x1309
movq %rax, %rbx
leaq -0x50(%rbp), %rdi
callq 0x1030
movq %rbx, %rdi
callq 0x10b0
// File: /workspace/github_cpp_makefile_star2_O2/arwn[P]baby-shark/babyshark.cpp
// Function: Bullshit::execute_state()
void execute_state()
  {
    std::cout << sharktable[state] << ' ' << std::flush;
    std::string command =
      "aplay audio/" + sharktable[state] + ".wav 2>/dev/null >/dev/null";
    system(command.c_str());
  }

// Assembly:
pushq %rbx
subq $0x40, %rsp
movq %rdi, %rbx
movl (%rdi), %esi
shlq $0x5, %rsi
addq 0x8(%rdi), %rsi
movq 0x2fb3(%rip), %rdi      # 0x5fd8
callq 0x2110
pushq $0x20
popq %rsi
movq %rax, %rdi
callq 0x2160
movq %rax, %rdi
callq 0x20b0
movl (%rbx), %edx
shlq $0x5, %rdx
addq 0x8(%rbx), %rdx
leaq 0x106b(%rip), %rsi      # 0x40b9
leaq 0x20(%rsp), %rbx
movq %rbx, %rdi
callq 0x3110
leaq 0x1064(%rip), %rdx      # 0x40c6
movq %rsp, %rdi
movq %rbx, %rsi
callq 0x30f1
leaq 0x20(%rsp), %rdi
callq 0x2090
movq (%rsp), %rdi
callq 0x20f0
movq %rsp, %rdi
callq 0x2090
addq $0x40, %rsp
popq %rbx
retq
movq %rax, %rbx
movq %rsp, %rdi
jmp 0x309e
movq %rax, %rbx
leaq 0x20(%rsp), %rdi
callq 0x2090
movq %rbx, %rdi
callq 0x21e0
nop
// File: /workspace/github_cpp_makefile_star2_O2/jkunlin[P]maxclique/Vertices.cpp
// Function: Vertices::init(unsigned long)
void Vertices::init(size_t size) {
	Vertex v;
	for(size_t i = 0; i != size; i++) {
		v.set_index(i);
		vertices.push_back(v);
	}
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq %rdi, %r14
movq %rsp, %r15
andl $0x0, 0x4(%r15)
xorl %r12d, %r12d
cmpq %r12, %rbx
je 0x24ae
movl %r12d, (%rsp)
movq %r14, %rdi
movq %r15, %rsi
callq 0x2a96
incq %r12
jmp 0x2495
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
// File: /workspace/github_cpp_makefile_star2_O2/jkunlin[P]maxclique/Vertices.cpp
// Function: Vertices::cut_vertex_from(bool const* const*, Vertices&, int)
void Vertices::cut_vertex_from( const bool * const *conn, Vertices &v, int vertex_index ) {
	vertices.resize(0);
	for(vvec_type::const_iterator iter = v.vertices.begin(); iter != v.vertices.end(); ++iter) {
		if(conn[vertex_index][iter->get_index()])
			vertices.push_back(*iter);
	}
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movl %ecx, %ebp
movq %rdx, %rbx
movq %rsi, %r14
movq %rdi, %r15
xorl %esi, %esi
callq 0x2ab4
movq (%rbx), %r12
movslq %ebp, %r13
cmpq 0x8(%rbx), %r12
je 0x2502
movq (%r14,%r13,8), %rax
movslq (%r12), %rcx
cmpb $0x1, (%rax,%rcx)
jne 0x24fc
movq %r15, %rdi
movq %r12, %rsi
callq 0x2a96
addq $0x8, %r12
jmp 0x24dd
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O2/jkunlin[P]maxclique/Vertices.cpp
// Function: Vertices::MCR_sort(bool const* const*)
void Vertices::MCR_sort(const bool * const *conn) {
	int min_degree = vertices.size();
	vvec_type::iterator min_iter = vertices.end();

	vvec_type R;
	for(vvec_type::size_type i = 0; i != vertices.size(); ++i) {
		//find vertex with min degree
		R.resize(0);
		min_degree = vertices[0].get_degree();
		min_iter = vertices.begin();
		R.push_back(*min_iter);
		for(vvec_type::iterator iter = vertices.begin() + 1; iter != vertices.end() - i; ++iter) {
			if(iter->get_degree() == min_degree) {
				R.push_back(*iter);
			}
			else if(iter->get_degree() < min_degree) {
				min_degree = iter->get_degree();
				min_iter = iter;
			}
		}

		//regular subgraph
		if(R.size() == vertices.size() - i)
			break;
		std::swap(*min_iter, *(vertices.end() - i - 1));

		//update degrees of remain vertices
		for(vvec_type::iterator iter = vertices.begin(); iter != vertices.end() - i - 1; ++iter) {
			if(conn[iter->get_index()][(vertices.end() - i - 1) ->get_index()])
				iter->dec_degree();
		}
	}
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x28, %rsp
movq %rsi, %rbx
movq %rdi, %r14
xorps %xmm0, %xmm0
leaq 0x10(%rsp), %r15
andq $0x0, 0x10(%r15)
movaps %xmm0, (%r15)
movq (%rdi), %rcx
movq 0x8(%rdi), %rax
xorl %r9d, %r9d
subq %rcx, %rax
sarq $0x3, %rax
cmpq %rax, %r9
je 0x26b9
movq %r9, 0x8(%rsp)
movq %r15, %rdi
xorl %esi, %esi
callq 0x2ab4
movq (%r14), %r12
movl 0x4(%r12), %r13d
movq %r15, %rdi
movq %r12, %rsi
callq 0x2a96
movq %r12, (%rsp)
movq (%r14), %rsi
movq 0x8(%rsp), %rbp
negq %rbp
addq $0x8, %rsi
movq 0x8(%r14), %rcx
leaq (%rcx,%rbp,8), %rax
cmpq %rax, %rsi
je 0x264c
movl 0x4(%rsi), %eax
cmpl %r13d, %eax
jne 0x263a
leaq 0x8(%rsi), %r12
movq %r15, %rdi
callq 0x2a96
movq %r12, %rsi
jmp 0x2614
movq (%rsp), %rcx
cmovlq %rsi, %rcx
movq %rcx, (%rsp)
cmovll %eax, %r13d
jmp 0x2610
movq 0x18(%rsp), %rdx
subq 0x10(%rsp), %rdx
subq (%r14), %rcx
sarq $0x3, %rdx
sarq $0x3, %rcx
movq 0x8(%rsp), %r9
subq %r9, %rcx
cmpq %rcx, %rdx
je 0x26b9
movq (%rsp), %rsi
movq (%rsi), %rcx
movq -0x8(%rax), %rdx
movq %rdx, (%rsi)
movq %rcx, -0x8(%rax)
movq (%r14), %rcx
movq 0x8(%r14), %rax
leaq (%rax,%rbp,8), %rdx
addq $-0x8, %rdx
movq %rcx, %rsi
cmpq %rdx, %rsi
je 0x26b1
movslq (%rsi), %rdi
movq (%rbx,%rdi,8), %rdi
movslq (%rdx), %r8
cmpb $0x1, (%rdi,%r8)
jne 0x26ab
decl 0x4(%rsi)
addq $0x8, %rsi
jmp 0x2692
incq %r9
jmp 0x25cf
leaq 0x10(%rsp), %rdi
callq 0x2b78
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
jmp 0x26d4
movq %rax, %rbx
leaq 0x10(%rsp), %rdi
callq 0x2b78
movq %rbx, %rdi
callq 0x2270
// File: /workspace/github_cpp_makefile_star2_O2/jkunlin[P]maxclique/Vertices.cpp
// Function: Vertices::print()
void Vertices::print()
{
	for(vvec_type::iterator iter = vertices.begin(); iter != vertices.end(); ++iter) {
		std::cout<<iter->get_index() + 1<<"  ";
	}
	std::cout<<std::endl;

	for(vvec_type::iterator iter = vertices.begin(); iter != vertices.end(); ++iter) {
		std::cout<<iter->get_degree()<<"  ";
	}
	std::cout<<std::endl;
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rdi, %rbx
movq (%rdi), %r12
movq 0x5643(%rip), %r14      # 0x7fd8
leaq 0x2668(%rip), %r15      # 0x5004
cmpq 0x8(%rbx), %r12
je 0x29c1
movl (%r12), %esi
incl %esi
movq %r14, %rdi
callq 0x2260
movq %rax, %rdi
movq %r15, %rsi
callq 0x21d0
addq $0x8, %r12
jmp 0x299c
movq 0x5610(%rip), %r14      # 0x7fd8
movq %r14, %rdi
callq 0x20e0
movq (%rbx), %r12
leaq 0x262a(%rip), %r15      # 0x5004
cmpq 0x8(%rbx), %r12
je 0x29fe
movl 0x4(%r12), %esi
movq %r14, %rdi
callq 0x2260
movq %rax, %rdi
movq %r15, %rsi
callq 0x21d0
addq $0x8, %r12
jmp 0x29da
movq 0x55d3(%rip), %rdi      # 0x7fd8
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
jmp 0x20e0
nop
// File: /workspace/github_cpp_makefile_star2_O2/jkunlin[P]maxclique/Vertices.cpp
// Function: Vertices::print_colors()
void Vertices::print_colors(){
	int pre_color = vertices.begin()->get_degree();
	int count = 1;
	for(vvec_type::iterator iter = vertices.begin() + 1; iter != vertices.end(); ++iter) {
		if(pre_color != iter->get_degree()) {
			count = 1;
			std::cout<<count<<"  ";
			pre_color = iter->get_degree();
			continue;
		}
		++count;
	}
	std::cout<<count;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rdi, %rbx
movq (%rdi), %r13
leaq 0x4(%r13), %r12
pushq $0x1
popq %rbp
movq 0x55a3(%rip), %r14      # 0x7fd8
leaq 0x25c8(%rip), %r15      # 0x5004
movl (%r12), %eax
movq 0x8(%rbx), %rcx
addq $0xc, %r13
movq %r13, %r12
movl %ebp, %esi
leaq -0x4(%r12), %r13
cmpq %rcx, %r13
je 0x2a7c
cmpl (%r12), %eax
jne 0x2a65
incl %esi
addq $0x8, %r12
jmp 0x2a4d
movq %r14, %rdi
movl %ebp, %esi
callq 0x2260
movq %rax, %rdi
movq %r15, %rsi
callq 0x21d0
jmp 0x2a3c
movq 0x5555(%rip), %rdi      # 0x7fd8
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x2260
// File: /workspace/github_cpp_makefile_star2_O2/jkunlin[P]maxclique/main.cpp
// Function: expand(bool, bool const* const*, Vertices&)
void expand(bool MCR, const bool * const * conn, Vertices &V) {
	int min_k;
	Vertices temp;
	size_t i;
	while(!V.empty()) {
		min_k = maxclique.size() > tmpclique.size() ? maxclique.size() - tmpclique.size() : -1;
		if(V.get_color_num() > min_k) {
			i = V.pop();
			tmpclique.push_back(i);
			temp.cut_vertex_from(conn, V, i);
			if(!temp.empty()) {
		//		temp.set_degrees(conn);
		//		MCR ? temp.MCR_sort(conn) : temp.degree_sort();
		//		temp.colo_sort(conn, min_k);
				num++;
				expand(MCR, conn, temp);
			}
			else if (tmpclique.size() > maxclique.size()) {
				std::cout<<"step = "<<num<<" current max size: "<<tmpclique.size()<<std::endl;
				maxclique = tmpclique;
			}
			tmpclique.pop_back();
		}
		else {
			return;
		}
	}
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x28, %rsp
movq %rdx, %rbx
movq %rsi, %r14
movl %edi, %ebp
leaq 0x10(%rsp), %r15
movq %r15, %rdi
xorl %esi, %esi
callq 0x3948
leaq 0x4a32(%rip), %r12      # 0x81e0
movzbl %bpl, %ebp
movq 0x8(%rbx), %rax
cmpq %rax, (%rbx)
je 0x38db
movq 0x4a0a(%rip), %rcx      # 0x81d0
subq 0x49fb(%rip), %rcx      # 0x81c8
movq 0x4a14(%rip), %rdx      # 0x81e8
subq 0x4a05(%rip), %rdx      # 0x81e0
sarq $0x2, %rcx
sarq $0x2, %rdx
movl %ecx, %esi
subl %edx, %esi
cmpq %rdx, %rcx
pushq $-0x1
popq %rcx
cmovbel %ecx, %esi
cmpl %esi, -0x4(%rax)
jl 0x38db
movl -0x8(%rax), %r13d
addq $-0x8, %rax
movq %rax, 0x8(%rbx)
movl %r13d, 0xc(%rsp)
movq %r12, %rdi
leaq 0xc(%rsp), %rsi
callq 0x2e04
movq %r15, %rdi
movq %r14, %rsi
movq %rbx, %rdx
movl %r13d, %ecx
callq 0x24ba
movq 0x10(%rsp), %rax
cmpq 0x18(%rsp), %rax
je 0x384c
incl 0x49be(%rip)            # 0x81f8
movl %ebp, %edi
movq %r14, %rsi
movq %r15, %rdx
callq 0x3782
jmp 0x38ce
movq 0x4995(%rip), %rax      # 0x81e8
subq 0x4986(%rip), %rax      # 0x81e0
movq 0x496f(%rip), %rcx      # 0x81d0
subq 0x4960(%rip), %rcx      # 0x81c8
cmpq %rcx, %rax
jbe 0x38ce
movq 0x4764(%rip), %rdi      # 0x7fd8
leaq 0x18e6(%rip), %rsi      # 0x5161
callq 0x21d0
movl 0x4972(%rip), %esi      # 0x81f8
movq %rax, %rdi
callq 0x2260
movq %rax, %rdi
leaq 0x18d1(%rip), %rsi      # 0x5169
callq 0x21d0
movq 0x4944(%rip), %rsi      # 0x81e8
subq 0x4935(%rip), %rsi      # 0x81e0
sarq $0x2, %rsi
movq %rax, %rdi
callq 0x2150
movq %rax, %rdi
callq 0x20e0
leaq 0x4902(%rip), %rdi      # 0x81c8
movq %r12, %rsi
callq 0x3990
addq $-0x4, 0x4912(%rip)     # 0x81e8
jmp 0x37b2
leaq 0x10(%rsp), %rdi
callq 0x2b78
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
jmp 0x38f6
movq %rax, %rbx
leaq 0x10(%rsp), %rdi
callq 0x2b78
movq %rbx, %rdi
callq 0x2270
nop
// File: /workspace/github_cpp_makefile_star2_O2/enbock[P]Warp10Server/app/tEvent.cpp
// Function: u::tEvent::tEvent(u::Vector<u::String>)
tEvent(Vector<String> arg) : EventDispatcher()
			{
				trace("Hello " + toString());
				addEventListener(Event::COMPLETE, Callback(
					this, cb_cast(&tEvent::onEvent)
				));
				addEventListener(Event::PROGRESS, Callback(
					this, cb_cast(&tEvent::onEvent2)
				));

				dispatchEvent(new Event(Event::COMPLETE))->destroy();
				//dispatchEvent(new Event(Event::PROGRESS))->destroy();

				//programExit();
			}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
subq $0x130, %rsp            # imm = 0x130
movq %rdi, %rbx
callq 0x405cae
leaq 0x1fdaad(%rip), %rax    # 0x6025e0
movq %rax, (%rbx)
movq $0x60d6a0, %rdi         # imm = 0x60D6A0
leaq 0x191535(%rip), %rsi    # 0x596079
callq 0x474850
movq %rax, %r14
movq (%rbx), %rax
leaq 0xd8(%rsp), %rdi
movq %rbx, %rsi
callq *0x18(%rax)
leaq 0x110(%rsp), %rdx
leaq 0x191512(%rip), %rsi    # 0x59607e
leaq 0x8(%rsp), %rdi
callq 0x404ee4
leaq 0x8(%rsp), %rsi
movq %r14, %rdi
callq 0x4870d0
leaq 0x1914fb(%rip), %rsi    # 0x596085
movq %rax, %rdi
callq 0x474850
movq %rax, %rdi
callq 0x474130
leaq 0x8(%rsp), %rdi
callq 0x484750
leaq 0xd8(%rsp), %rdi
callq 0x404ab8
leaq 0x48a(%rip), %rdx       # 0x405042
leaq 0x80(%rsp), %rdi
movq %rbx, %rsi
xorl %ecx, %ecx
xorl %r8d, %r8d
callq 0x40561c
movq $0x60c5d8, %rsi         # imm = 0x60C5D8
leaq 0x80(%rsp), %rdx
movq %rbx, %rdi
callq 0x4066a2
leaq 0x80(%rsp), %rdi
callq 0x407db8
leaq 0x73a(%rip), %rdx       # 0x405332
leaq 0x28(%rsp), %rdi
movq %rbx, %rsi
xorl %ecx, %ecx
xorl %r8d, %r8d
callq 0x40561c
movq $0x60c630, %rsi         # imm = 0x60C630
leaq 0x28(%rsp), %rdx
movq %rbx, %rdi
callq 0x4066a2
leaq 0x28(%rsp), %rdi
callq 0x407db8
pushq $0x48
popq %rdi
callq 0x40b890
movq %rax, %r15
movq $0x60c5d8, %rsi         # imm = 0x60C5D8
movq %rax, %rdi
callq 0x4059b8
movq %rbx, %rdi
movq %r15, %rsi
callq 0x406818
movq (%rax), %rcx
movq %rax, %rdi
callq *(%rcx)
addq $0x130, %rsp            # imm = 0x130
popq %rbx
popq %r14
popq %r15
retq
movq %rax, %r14
pushq $0x48
popq %rsi
movq %r15, %rdi
callq 0x40a700
jmp 0x404cb4
movq %rax, %r14
leaq 0x28(%rsp), %rdi
jmp 0x404c87
movq %rax, %r14
leaq 0x80(%rsp), %rdi
callq 0x407db8
jmp 0x404cb4
movq %rax, %r14
jmp 0x404ca2
jmp 0x404cb1
movq %rax, %r14
leaq 0x8(%rsp), %rdi
callq 0x484750
leaq 0xd8(%rsp), %rdi
callq 0x404ab8
jmp 0x404cb4
movq %rax, %r14
movq %rbx, %rdi
callq 0x405e46
movq %r14, %rdi
callq 0x4b5490
// File: /workspace/github_cpp_makefile_star2_O2/enbock[P]Warp10Server/app/tEvent.cpp
// Function: u::tEvent::onEvent2(u::Object*)
void onEvent2(Object *arg)
			{
				Event *event = (Event*)arg;
				//trace("onEvent2="+event->toString());
				event->destroy();
				dispatchEvent(new Event(Event::COMPLETE))->destroy();
				dispatchEvent(new Event(Event::PROGRESS))->destroy();
				dispatchEvent(new Event(Event::COMPLETE))->destroy();
			}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
movq (%rsi), %rax
movq %rsi, %rdi
callq *(%rax)
pushq $0x48
popq %rdi
callq 0x40b890
movq %rax, %r14
movq $0x60c5d8, %rsi         # imm = 0x60C5D8
movq %rax, %rdi
callq 0x4059b8
movq %rbx, %rdi
movq %r14, %rsi
callq 0x406818
movq (%rax), %rcx
movq %rax, %rdi
callq *(%rcx)
pushq $0x48
popq %rdi
callq 0x40b890
movq %rax, %r14
movq $0x60c630, %rsi         # imm = 0x60C630
movq %rax, %rdi
callq 0x4059b8
movq %rbx, %rdi
movq %r14, %rsi
callq 0x406818
movq (%rax), %rcx
movq %rax, %rdi
callq *(%rcx)
pushq $0x48
popq %rdi
callq 0x40b890
movq %rax, %r14
movq $0x60c5d8, %rsi         # imm = 0x60C5D8
movq %rax, %rdi
callq 0x4059b8
movq %rbx, %rdi
movq %r14, %rsi
callq 0x406818
movq (%rax), %rcx
movq %rax, %rdi
addq $0x8, %rsp
popq %rbx
popq %r14
jmpq *(%rcx)
jmp 0x4053d3
jmp 0x4053d3
movq %rax, %rbx
pushq $0x48
popq %rsi
movq %r14, %rdi
callq 0x40a700
movq %rbx, %rdi
callq 0x4b5490
nop
// File: /workspace/github_cpp_makefile_star2_O2/enbock[P]Warp10Server/ulib/src/Callback.cpp
// Function: u::Callback::operator==(u::Callback const&) const
bool Callback::operator==(const Callback& other) const
{
	bool ret = true;
	if(other.target != this->target) ret = false;
	if(ret && other.function != this->function) ret = false;
	if(ret && other.arg != this->arg) ret = false;
	return ret;
}

// Assembly:
movq 0x38(%rsi), %rax
cmpq 0x38(%rdi), %rax
je 0x4056f7
xorl %eax, %eax
retq
movq 0x40(%rsi), %r8
movq 0x48(%rsi), %rax
testq %r8, %r8
sete %cl
cmpq 0x48(%rdi), %rax
sete %dl
xorl %eax, %eax
cmpq 0x40(%rdi), %r8
jne 0x4056f6
orb %dl, %cl
je 0x4056f6
movq 0x50(%rsi), %rax
cmpq 0x50(%rdi), %rax
sete %al
retq
// File: /workspace/github_cpp_makefile_star2_O2/enbock[P]Warp10Server/ulib/src/Callback.cpp
// Function: u::Callback::toString()
String Callback::toString()
{
	String str = "[" + className()
	 + " (" 
	 + ptr2string((Object *)this) 
	 + ")"
	;
	//*
	str += " target=" + (target?target->toString():"<Defunc>");
	/*/
	str += " target=" + (target?target->className():"<Defunc>");
	//*/

	//str += " function=" + (function?ptr2string(&function):"<Defunc>");
	//str += " arg=" + (arg?arg->toString():"<No Argument>");
	str += "]";
	return str;
}

// Assembly:
pushq %r14
pushq %rbx
subq $0x138, %rsp            # imm = 0x138
movq %rsi, %r14
movq %rdi, %rbx
movq (%rsi), %rax
leaq 0x88(%rsp), %rdi
callq *0x8(%rax)
leaq 0xc0(%rsp), %rdx
leaq 0x190903(%rip), %rsi    # 0x59606a
leaq 0x8(%rsp), %rdi
callq 0x404ee4
leaq 0x194b95(%rip), %rdx    # 0x59a30d
leaq 0x28(%rsp), %rdi
leaq 0x8(%rsp), %rsi
callq 0x404ec5
leaq 0xe0(%rsp), %rdi
movq %r14, %rsi
callq 0x408010
leaq 0x118(%rsp), %rdx
leaq 0x48(%rsp), %rdi
leaq 0x28(%rsp), %rsi
callq 0x405951
leaq 0x190c29(%rip), %rdx    # 0x5963de
leaq 0x68(%rsp), %rdi
leaq 0x48(%rsp), %rsi
callq 0x404ec5
leaq 0x68(%rsp), %rsi
movq %rbx, %rdi
callq 0x4081c2
leaq 0x68(%rsp), %rdi
callq 0x484750
leaq 0x48(%rsp), %rdi
callq 0x484750
leaq 0xe0(%rsp), %rdi
callq 0x404ab8
leaq 0x28(%rsp), %rdi
callq 0x484750
leaq 0x8(%rsp), %rdi
callq 0x484750
leaq 0x88(%rsp), %rdi
callq 0x404ab8
movq 0x38(%r14), %rsi
testq %rsi, %rsi
je 0x40582c
movq (%rsi), %rax
leaq 0x88(%rsp), %rdi
callq *0x18(%rax)
jmp 0x405840
leaq 0x1908c2(%rip), %rsi    # 0x5960f5
leaq 0x88(%rsp), %rdi
callq 0x40817c
leaq 0xc0(%rsp), %rdx
leaq 0x19089d(%rip), %rsi    # 0x5960ec
leaq 0xe0(%rsp), %rdi
callq 0x404ee4
leaq 0x38(%rbx), %r14
leaq 0xe0(%rsp), %rsi
movq %r14, %rdi
callq 0x485e60
leaq 0xe0(%rsp), %rdi
callq 0x484750
leaq 0x88(%rsp), %rdi
callq 0x404ab8
leaq 0x1afdf5(%rip), %rsi    # 0x5b5686
movq %r14, %rdi
callq 0x485f00
movq %rbx, %rax
addq $0x138, %rsp            # imm = 0x138
popq %rbx
popq %r14
retq
jmp 0x4058cd
movq %rax, %r14
leaq 0xe0(%rsp), %rdi
callq 0x484750
jmp 0x4058be
movq %rax, %r14
leaq 0x88(%rsp), %rdi
callq 0x404ab8
jmp 0x4058d0
movq %rax, %r14
movq %rbx, %rdi
jmp 0x405929
movq %rax, %r14
leaq 0x68(%rsp), %rdi
callq 0x484750
jmp 0x4058e7
movq %rax, %r14
leaq 0x48(%rsp), %rdi
callq 0x484750
jmp 0x4058f6
movq %rax, %r14
leaq 0xe0(%rsp), %rdi
callq 0x404ab8
jmp 0x405908
movq %rax, %r14
leaq 0x28(%rsp), %rdi
callq 0x484750
jmp 0x405917
movq %rax, %r14
leaq 0x8(%rsp), %rdi
callq 0x484750
leaq 0x88(%rsp), %rdi
callq 0x404ab8
movq %r14, %rdi
callq 0x4b5490
movq %rax, %r14
jmp 0x405921
nop
// File: /workspace/github_cpp_makefile_star2_O2/enbock[P]Warp10Server/ulib/src/Event.cpp
// Function: u::Event::toString()
String u::Event::toString()
{
	String str = "[" + className();
	str += " type=" + *_type;
	str += " target=" + (_target!=null?_target->toString():"null");
	str += "]";
	return str;
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
subq $0xa0, %rsp
movq %rsi, %r15
movq %rdi, %rbx
movq (%rsi), %rax
leaq 0x8(%rsp), %rdi
callq *0x8(%rax)
leaq 0x40(%rsp), %rdx
leaq 0x1905fd(%rip), %rsi    # 0x59606a
leaq 0x80(%rsp), %rdi
callq 0x404ee4
leaq 0x80(%rsp), %rsi
movq %rbx, %rdi
callq 0x4081c2
leaq 0x80(%rsp), %rdi
callq 0x484750
leaq 0x8(%rsp), %rdi
callq 0x404ab8
movq 0x38(%r15), %rdx
addq $0x38, %rdx
leaq 0x19068e(%rip), %rsi    # 0x59613e
leaq 0x8(%rsp), %rdi
callq 0x405bdd
leaq 0x38(%rbx), %r14
leaq 0x8(%rsp), %rsi
movq %r14, %rdi
callq 0x485e60
leaq 0x8(%rsp), %rdi
callq 0x484750
movq 0x40(%r15), %rsi
testq %rsi, %rsi
je 0x405aeb
movq (%rsi), %rax
leaq 0x8(%rsp), %rdi
callq *0x18(%rax)
jmp 0x405afc
leaq 0x1960ed(%rip), %rsi    # 0x59bbdf
leaq 0x8(%rsp), %rdi
callq 0x40817c
leaq 0x40(%rsp), %rdx
leaq 0x1905e4(%rip), %rsi    # 0x5960ec
leaq 0x60(%rsp), %rdi
callq 0x404ee4
leaq 0x60(%rsp), %rsi
movq %r14, %rdi
callq 0x485e60
leaq 0x60(%rsp), %rdi
callq 0x484750
leaq 0x8(%rsp), %rdi
callq 0x404ab8
leaq 0x1afb4c(%rip), %rsi    # 0x5b5686
movq %r14, %rdi
callq 0x485f00
movq %rbx, %rax
addq $0xa0, %rsp
popq %rbx
popq %r14
popq %r15
retq
jmp 0x405b83
movq %rax, %r14
leaq 0x60(%rsp), %rdi
callq 0x484750
jmp 0x405b66
movq %rax, %r14
leaq 0x8(%rsp), %rdi
callq 0x404ab8
jmp 0x405b86
jmp 0x405b83
movq %rax, %r14
leaq 0x8(%rsp), %rdi
callq 0x484750
jmp 0x405b86
movq %rax, %r14
movq %rbx, %rdi
jmp 0x405ba5
movq %rax, %r14
leaq 0x80(%rsp), %rdi
callq 0x484750
jmp 0x405ba0
movq %rax, %r14
leaq 0x8(%rsp), %rdi
callq 0x404ab8
movq %r14, %rdi
callq 0x4b5490
// File: /workspace/github_cpp_makefile_star2_O2/enbock[P]Warp10Server/ulib/src/EventDispatcher.cpp
// Function: u::EventDispatcher::operator=(u::EventDispatcher&)
EventDispatcher& EventDispatcher::operator=(EventDispatcher& value)
{
	int64 i, l, j, m;
	_eventVector *src;
	Vector<Callback> *dst;

	value.lock();
	lock();

	l = value._eventList.size();
	for(i=0; i<l; i++)
	{
		src = &value._eventList.at(i);
		dst = getEventVector(src->type);
		if(dst == null)
		{
			dst = addEventVector(src->type);
		}
		m = src->list.size();
		for(j=0; j<m; j++)
		{
			dst->push_back(src->list.at(j));
		}
	}

	unlock();
	value.unlock();
	return *this;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %rsi, %r14
movq %rdi, %rbx
movq %rsi, %rdi
callq 0x407cb6
movq %rbx, %rdi
callq 0x407cb6
leaq 0x70(%r14), %rax
movq %rax, 0x8(%rsp)
movq 0x78(%r14), %rax
movq %r14, (%rsp)
subq 0x70(%r14), %rax
pushq $0x58
popq %rcx
cqto
idivq %rcx
xorl %ecx, %ecx
testq %rax, %rax
cmovleq %rcx, %rax
movq %rax, 0x10(%rsp)
xorl %r13d, %r13d
cmpq 0x10(%rsp), %r13
je 0x405e23
movq 0x8(%rsp), %rdi
movq %r13, %rsi
callq 0x406d5c
movq %rax, %r15
movq (%rax), %rsi
movq %rbx, %rdi
callq 0x4065c2
movq %rax, %rbp
testq %rax, %rax
jne 0x405dce
movq (%r15), %rsi
movq %rbx, %rdi
callq 0x40661e
movq %rax, %rbp
movq %r15, %r14
addq $0x40, %r14
movq 0x48(%r15), %rax
subq 0x40(%r15), %rax
cqto
pushq $0x58
popq %rcx
idivq %rcx
movq %rax, %r15
addq $0x38, %rbp
testq %rax, %rax
movl $0x0, %eax
cmovleq %rax, %r15
xorl %r12d, %r12d
cmpq %r12, %r15
je 0x405e1b
movq %r14, %rdi
movq %r12, %rsi
callq 0x406d9a
movq %rbp, %rdi
movq %rax, %rsi
callq 0x406e02
incq %r12
jmp 0x405dfb
incq %r13
jmp 0x405d92
movq %rbx, %rdi
callq 0x407c72
movq (%rsp), %rdi
callq 0x407c72
movq %rbx, %rax
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/enbock[P]Warp10Server/ulib/src/EventDispatcher.cpp
// Function: u::EventDispatcher::delEventVector(u::String const*)
void EventDispatcher::delEventVector(const String* type)
{
	int64 i, l;

	l = _eventList.size();
	for(i=0; i<l; i++)
	{
		_eventVector* entry = &_eventList.at(i);
		if(entry->type == type)
		{
			_eventList.erase(i);
			return;
		}
	}
}

// Assembly:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
movq %rsi, %rbx
leaq 0x38(%rdi), %r14
leaq 0x70(%rdi), %r15
movq 0x78(%rdi), %rax
subq 0x70(%rdi), %rax
pushq $0x58
popq %rcx
cqto
idivq %rcx
movq %rax, %r13
xorl %r12d, %r12d
testq %rax, %rax
cmovleq %r12, %r13
cmpq %r12, %r13
je 0x4065a3
movq %r15, %rdi
movq %r12, %rsi
callq 0x406d5c
cmpq %rbx, (%rax)
je 0x4065ad
incq %r12
jmp 0x406589
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
movq %r14, %rdi
movq %r12, %rsi
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
jmp 0x406ea4
nop
// File: /workspace/github_cpp_makefile_star2_O2/enbock[P]Warp10Server/ulib/src/EventDispatcher.cpp
// Function: u::EventDispatcher::getEventVector(u::String const*)
Vector<Callback>* EventDispatcher::getEventVector(const String* type)
{
	int64 i, l;

	l = _eventList.size();
	for(i=0; i<l; i++)
	{
		_eventVector* entry = &_eventList.at(i);
		if(entry->type == type) return &(entry->list);
	}
	return null;
}

// Assembly:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
movq %rsi, %rbx
leaq 0x70(%rdi), %r14
movq 0x78(%rdi), %rax
subq 0x70(%rdi), %rax
pushq $0x58
popq %rcx
cqto
idivq %rcx
movq %rax, %r12
xorl %r15d, %r15d
testq %rax, %rax
cmovleq %r15, %r12
xorl %r13d, %r13d
cmpq %r13, %r12
je 0x406611
movq %r14, %rdi
movq %r13, %rsi
callq 0x406d5c
incq %r13
cmpq %rbx, (%rax)
jne 0x4065f2
addq $0x8, %rax
movq %rax, %r15
movq %r15, %rax
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
// File: /workspace/github_cpp_makefile_star2_O2/enbock[P]Warp10Server/ulib/src/EventDispatcher.cpp
// Function: u::EventDispatcher::addEventVector(u::String const*)
Vector<Callback>* EventDispatcher::addEventVector(const String* type)
{
	_eventVector vec;
	int64 i;

	vec.type = type;
	i = _eventList.size();
	_eventList.push_back(vec);
	return &(_eventList.at(i).list);
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x58, %rsp
movq %rsi, %rbx
movq %rdi, %r14
movq %rsp, %r15
movq %r15, %rdi
callq 0x405c54
movq %rbx, (%r15)
leaq 0x70(%r14), %rbx
movq 0x70(%r14), %r12
movq 0x78(%r14), %r14
movq %rbx, %rdi
movq %r15, %rsi
callq 0x406e78
subq %r12, %r14
pushq $0x58
popq %rcx
movq %r14, %rax
cqto
idivq %rcx
movq %rbx, %rdi
movq %rax, %rsi
callq 0x406d5c
movq %rax, %rbx
addq $0x8, %rbx
leaq 0x8(%rsp), %rdi
callq 0x406cee
movq %rbx, %rax
addq $0x58, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
movq %rax, %rbx
leaq 0x8(%rsp), %rdi
callq 0x406cee
movq %rbx, %rdi
callq 0x4b5490
// File: /workspace/github_cpp_makefile_star2_O2/enbock[P]Warp10Server/ulib/src/EventDispatcher.cpp
// Function: u::EventDispatcher::addEventListener(u::String const&, u::Callback)
void EventDispatcher::addEventListener(const String& type
		, Callback callback)
{
	int i, l;
	Vector<Callback>* vec;

	lock();

	vec = getEventVector(&type);
	if(vec == null)
	{
		vec = addEventVector(&type);
	}

	l = vec->size();

	for(i=0; i<l; i++)
	{
		if(vec->at(i).target == callback.target)
		{
			unlock();
			return;
		}
	}

	vec->push_back(callback);
	unlock();
}

// Assembly:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
movq %rdx, %r14
movq %rsi, %r15
movq %rdi, %rbx
callq 0x407cb6
movq %rbx, %rdi
movq %r15, %rsi
callq 0x4065c2
testq %rax, %rax
jne 0x4066d4
movq %rbx, %rdi
movq %r15, %rsi
callq 0x40661e
leaq 0x38(%rax), %r15
movq 0x40(%rax), %rcx
subq 0x38(%rax), %rcx
pushq $0x58
popq %rsi
movq %rcx, %rax
cqto
idivq %rsi
movq %rax, %r12
xorl %r13d, %r13d
testl %r12d, %r12d
cmovlel %r13d, %r12d
cmpq %r13, %r12
je 0x406717
movq %r15, %rdi
movq %r13, %rsi
callq 0x406d9a
movq 0x38(%rax), %rax
incq %r13
cmpq 0x38(%r14), %rax
jne 0x4066f8
jmp 0x406722
movq %r15, %rdi
movq %r14, %rsi
callq 0x406e02
movq %rbx, %rdi
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
jmp 0x407c72
nop
// File: /workspace/github_cpp_makefile_star2_O2/enbock[P]Warp10Server/ulib/src/EventDispatcher.cpp
// Function: u::EventDispatcher::removeEventListener(u::String const&, u::Callback)
void EventDispatcher::removeEventListener(const String& type
		, Callback callback)
{
	int i, l;
	Vector<Callback>* vec;

	//if(hasEventListener(type) == false) return;

	lock();

	vec = getEventVector(&type);
	if(vec == null)
	{
		unlock();
		return;
	}

	l = vec->size();

	for(i=0; i<l; i++)
	{
		if(vec->at(i) == callback)
		{
			vec->erase(i);
			break;
		}
	}

	if(vec->empty()) delEventVector(&type);

	unlock();
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rdx, %r15
movq %rsi, %r14
movq %rdi, %rbx
callq 0x407cb6
movq %rbx, %rdi
movq %r14, (%rsp)
movq %r14, %rsi
callq 0x4065c2
testq %rax, %rax
je 0x4067d0
movq %rax, %r12
movq %rax, %r13
addq $0x38, %r13
movq 0x40(%rax), %rax
subq 0x38(%r12), %rax
pushq $0x58
popq %rcx
cqto
idivq %rcx
movq %rax, %r14
xorl %ebp, %ebp
testl %r14d, %r14d
cmovlel %ebp, %r14d
cmpq %rbp, %r14
je 0x4067b8
movq %r13, %rdi
movq %rbp, %rsi
callq 0x406d9a
movq %rax, %rdi
movq %r15, %rsi
callq 0x4056ea
incq %rbp
testb %al, %al
je 0x406788
decq %rbp
movq %r12, %rdi
movq %rbp, %rsi
callq 0x406db8
movq 0x38(%r12), %rax
cmpq 0x40(%r12), %rax
jne 0x4067d0
movq %rbx, %rdi
movq (%rsp), %rsi
callq 0x406558
movq %rbx, %rdi
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x407c72
// File: /workspace/github_cpp_makefile_star2_O2/enbock[P]Warp10Server/ulib/src/EventDispatcher.cpp
// Function: u::EventDispatcher::hasEventListener(u::String const&)
bool EventDispatcher::hasEventListener(const String& type)
{
	lock();
	bool ret = getEventVector(&type) != null;
	unlock();

	return ret;
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq %rdi, %r14
callq 0x407cb6
movq %r14, %rdi
movq %rbx, %rsi
callq 0x4065c2
testq %rax, %rax
setne %bl
movq %r14, %rdi
callq 0x407c72
movl %ebx, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_cpp_makefile_star2_O2/enbock[P]Warp10Server/ulib/src/Mutex.cpp
// Function: u::Mutex::Mutex()
Mutex::Mutex()
{
	_isLocked = false;
	int ret = pthread_mutex_init(&_mutex, NULL);
#ifndef NDEBUG
	assert(ret == 0);
#endif
}

// Assembly:
pushq %rax
leaq 0x1fac58(%rip), %rax    # 0x602848
movq %rax, (%rdi)
movb $0x0, 0x30(%rdi)
addq $0x8, %rdi
xorl %esi, %esi
callq 0x4e9840
testl %eax, %eax
jne 0x407c08
popq %rax
retq
leaq 0x18e77d(%rip), %rdi    # 0x59638c
leaq 0x18e77f(%rip), %rsi    # 0x596395
leaq 0x18e786(%rip), %rcx    # 0x5963a3
pushq $0x12
popq %rdx
callq 0x4ca0f0
nop
// File: /workspace/github_cpp_makefile_star2_O2/enbock[P]Warp10Server/ulib/src/Mutex.cpp
// Function: u::Mutex::~Mutex()
Mutex::~Mutex()
{
	if(_isLocked == true) unlock();
	int ret = pthread_mutex_destroy(&_mutex);
#ifndef NDEBUG
	assert(ret == 0);
#endif
}

// Assembly:
pushq %rbx
movq %rdi, %rbx
leaq 0x1fac17(%rip), %rax    # 0x602848
movq %rax, (%rdi)
cmpb $0x1, 0x30(%rdi)
jne 0x407c42
movq %rbx, %rdi
callq 0x407c72
addq $0x8, %rbx
movq %rbx, %rdi
callq 0x4e9810
testl %eax, %eax
jne 0x407c54
popq %rbx
retq
leaq 0x18e731(%rip), %rdi    # 0x59638c
leaq 0x18e733(%rip), %rsi    # 0x596395
leaq 0x18e74c(%rip), %rcx    # 0x5963b5
pushq $0x1b
popq %rdx
callq 0x4ca0f0
nop
// File: /workspace/github_cpp_makefile_star2_O2/enbock[P]Warp10Server/ulib/src/Object.cpp
// Function: u::Object::Object()
Object::Object() : Mutex()
{
	if(!__Object_mx_validObjects) __Object_mx_validObjects = new Mutex();
	if(!__Object_validObjects) __Object_validObjects = new std::vector<void const*>();

	__Object_mx_validObjects->lock();
	__Object_validObjects->push_back((void const*)this);
	__Object_mx_validObjects->unlock();
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
subq $0x10, %rsp
movq %rdi, %rbx
callq 0x407be8
leaq 0x1fab6c(%rip), %rax    # 0x602880
movq %rax, (%rbx)
movq 0x20497a(%rip), %r14    # 0x60c698
testq %r14, %r14
jne 0x407d3d
pushq $0x38
popq %rdi
callq 0x40b890
movq %rax, %r14
movq %rax, %rdi
callq 0x407be8
movq %r14, 0x20495b(%rip)    # 0x60c698
cmpq $0x0, 0x20495b(%rip)    # 0x60c6a0
jne 0x407d61
pushq $0x18
popq %rdi
callq 0x40b890
xorps %xmm0, %xmm0
movups %xmm0, (%rax)
andq $0x0, 0x10(%rax)
movq %rax, 0x20493f(%rip)    # 0x60c6a0
movq %r14, %rdi
callq 0x407cb6
movq 0x204930(%rip), %rdi    # 0x60c6a0
leaq 0x8(%rsp), %rsi
movq %rbx, (%rsi)
callq 0x408bbe
movq 0x204914(%rip), %rdi    # 0x60c698
callq 0x407c72
addq $0x10, %rsp
popq %rbx
popq %r14
popq %r15
retq
movq %rax, %r15
pushq $0x38
popq %rsi
movq %r14, %rdi
callq 0x40a700
jmp 0x407da8
jmp 0x407da5
movq %rax, %r15
movq %rbx, %rdi
callq 0x407c26
movq %r15, %rdi
callq 0x4b5490
// File: /workspace/github_cpp_makefile_star2_O2/enbock[P]Warp10Server/ulib/src/Object.cpp
// Function: u::Object::~Object()
Object::~Object()
{
	lock();
	bool del = false;
	__Object_mx_validObjects->lock();
	int64 l, i;
	l = __Object_validObjects->size();
	for(i=0; i<l; i++)
	{
		if(__Object_validObjects->at(i) == (void const*)this)
		{
			__Object_validObjects->erase(__Object_validObjects->begin()+i);
			break;
		}
	}
	del = __Object_validObjects->size() == 0;
	__Object_mx_validObjects->unlock();
	if(del) {
		delete __Object_validObjects;
		delete __Object_mx_validObjects;
		__Object_validObjects = null;
		__Object_mx_validObjects = null;
	}
	unlock();
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rdi, %rbx
leaq 0x1faab6(%rip), %rax    # 0x602880
movq %rax, (%rdi)
callq 0x407cb6
movq 0x2048bf(%rip), %rdi    # 0x60c698
callq 0x407cb6
movq 0x2048bb(%rip), %rax    # 0x60c6a0
movq 0x8(%rax), %r15
subq (%rax), %r15
sarq $0x3, %r15
xorl %r12d, %r12d
testq %r15, %r15
cmovleq %r12, %r15
shlq $0x3, %r15
xorl %r14d, %r14d
movq %r15, %rax
addq %r12, %rax
je 0x407e38
movq 0x204890(%rip), %rdi    # 0x60c6a0
movq %r14, %rsi
callq 0x408b26
cmpq %rbx, (%rax)
je 0x407e26
incq %r14
addq $-0x8, %r12
jmp 0x407e01
movq 0x204873(%rip), %rdi    # 0x60c6a0
movq (%rdi), %rsi
subq %r12, %rsi
callq 0x408b48
movq 0x204861(%rip), %rax    # 0x60c6a0
movq (%rax), %r14
movq 0x8(%rax), %r15
movq 0x20484b(%rip), %rdi    # 0x60c698
callq 0x407c72
cmpq %r14, %r15
jne 0x407ea5
movq 0x204842(%rip), %r14    # 0x60c6a0
testq %r14, %r14
je 0x407e6b
movq %r14, %rdi
callq 0x408d70
pushq $0x18
popq %rsi
movq %r14, %rdi
callq 0x40a700
movq 0x20481b(%rip), %r14    # 0x60c698
testq %r14, %r14
je 0x407e8a
movq %r14, %rdi
callq 0x407c26
pushq $0x38
popq %rsi
movq %r14, %rdi
callq 0x40a700
andq $0x0, 0x204803(%rip)    # 0x60c6a0
andq $0x0, 0x2047f3(%rip)    # 0x60c698
movq %rbx, %rdi
callq 0x407c72
movq %rbx, %rdi
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
jmp 0x407c26
jmp 0x407ec2
movq %rax, %rdi
callq 0x404e59
// File: /workspace/github_cpp_makefile_star2_O2/enbock[P]Warp10Server/ulib/src/Object.cpp
// Function: u::String::trimRight(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&)
String String::trimRight(const std::string & t)
{
		std::string d (*this);
		std::string::size_type i (d.find_last_not_of (t));
		if (i == std::string::npos)
				return String("");
		else
				return String(d.erase (d.find_last_not_of (t) + 1)) ;
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x48, %rsp
movq %rdx, %r14
movq %rdi, %rbx
addq $0x38, %rsi
leaq 0x28(%rsp), %r15
movq %r15, %rdi
callq 0x486e30
pushq $-0x1
popq %rdx
movq %r15, %rdi
movq %r14, %rsi
callq 0x486730
cmpq $-0x1, %rax
je 0x4085c8
leaq 0x28(%rsp), %r15
pushq $-0x1
popq %r12
movq %r15, %rdi
movq %r14, %rsi
movq %r12, %rdx
callq 0x486730
leaq 0x1(%rax), %rsi
movq %r15, %rdi
movq %r12, %rdx
callq 0x484f60
leaq 0x8(%rsp), %rdi
movq %rax, %rsi
callq 0x486e30
leaq 0x8(%rsp), %rsi
movq %rbx, %rdi
callq 0x4081c2
leaq 0x8(%rsp), %rdi
callq 0x484750
jmp 0x4085d7
leaq 0x1ad0db(%rip), %rsi    # 0x5b56aa
movq %rbx, %rdi
callq 0x40817c
leaq 0x28(%rsp), %rdi
callq 0x484750
movq %rbx, %rax
addq $0x48, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
movq %rax, %rbx
leaq 0x8(%rsp), %rdi
callq 0x484750
jmp 0x408602
movq %rax, %rbx
leaq 0x28(%rsp), %rdi
callq 0x484750
movq %rbx, %rdi
callq 0x4b5490
// File: /workspace/github_cpp_makefile_star2_O2/enbock[P]Warp10Server/ulib/src/Object.cpp
// Function: u::String::replace(u::String, u::String)
void String::replace(String search, String replace)
{
	std::string * s = this;
	while(s->find(search) != std::string::npos) {
		s->replace(
			s->find(search)
			, search.length()
			, (const std::string&)replace
		);
	}
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rdx, %rbx
movq %rsi, %r14
movq %rdi, %r15
addq $0x38, %r15
leaq 0x38(%rsi), %r12
addq $0x38, %rbx
movq %r15, %rdi
movq %r12, %rsi
xorl %edx, %edx
callq 0x4862a0
cmpq $-0x1, %rax
je 0x408779
movq %r15, %rdi
movq %r12, %rsi
xorl %edx, %edx
callq 0x4862a0
movq 0x40(%r14), %rdx
movq %r15, %rdi
movq %rax, %rsi
movq %rbx, %rcx
callq 0x485860
jmp 0x408745
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
nop
// File: /workspace/github_cpp_makefile_star2_O2/enbock[P]Warp10Server/ulib/src/Object.cpp
// Function: u::String::explode(u::String)
Vector<String>* String::explode(String delimiter)
{
	std::string * s = this;
	size_t position = 0;
	Vector<String>* result = new Vector<String>;
	while (position < length()) {
		size_t found = s->find(delimiter, position);
		if(found == std::string::npos) {
			found = s->size();
		}
		result->push(String(s->substr(position, found - position)));
		position = found + delimiter.length();
	}
	return result;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x98, %rsp
movq %rsi, %rbx
movq %rdi, %r15
pushq $0x50
popq %rdi
callq 0x40b890
movq %rax, %r14
movq %rax, %rdi
callq 0x404a76
leaq 0x38(%r15), %r12
movq %rbx, 0x8(%rsp)
leaq 0x38(%rbx), %rax
movq %rax, 0x18(%rsp)
movq %r14, (%rsp)
addq $0x38, %r14
movq %r14, 0x10(%rsp)
xorl %ebp, %ebp
leaq 0x20(%rsp), %rbx
leaq 0x40(%rsp), %r14
cmpq 0x40(%r15), %rbp
jae 0x408848
movq %r12, %rdi
movq 0x18(%rsp), %rsi
movq %rbp, %rdx
callq 0x4862a0
movq %rax, %r13
cmpq $-0x1, %rax
jne 0x4087fe
movq 0x40(%r15), %r13
movq %r13, %rcx
subq %rbp, %rcx
movq %rbx, %rdi
movq %r12, %rsi
movq %rbp, %rdx
callq 0x487050
movq %r14, %rdi
movq %rbx, %rsi
callq 0x4081c2
movq 0x10(%rsp), %rdi
movq %r14, %rsi
callq 0x408e24
movq %r14, %rdi
callq 0x404ab8
movq %rbx, %rdi
callq 0x484750
movq 0x8(%rsp), %rax
addq 0x40(%rax), %r13
movq %r13, %rbp
jmp 0x4087db
movq (%rsp), %rax
addq $0x98, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
pushq $0x50
popq %rsi
movq %r14, %rdi
callq 0x40a700
jmp 0x40888a
movq %rax, %rbx
leaq 0x40(%rsp), %rdi
callq 0x404ab8
jmp 0x408880
movq %rax, %rbx
leaq 0x20(%rsp), %rdi
callq 0x484750
movq %rbx, %rdi
callq 0x4b5490
// File: /workspace/github_cpp_makefile_star2_O2/enbock[P]Warp10Server/ulib/src/Object.cpp
// Function: u::Object::valid(void const*)
bool u::Object::valid(void const* ptr)
{
	__Object_mx_validObjects->lock();
	bool ret = false;
	int64 l, i;
	l = __Object_validObjects->size();
	for(i=0; i<l; i++)
	{
		if(__Object_validObjects->at(i) == ptr)
		{
			ret = true;
			/*std::cout
				<< "\033[34;1mu::Object::valid(): " << ptr
				<< "\033[0m"
				<< std::endl
			;*/
			break;
		}
	}
	__Object_mx_validObjects->unlock();
	return ret;
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rdi, %rbx
movq 0x203c5c(%rip), %rdi    # 0x60c698
callq 0x407cb6
movq 0x203c58(%rip), %rax    # 0x60c6a0
movq 0x8(%rax), %r15
subq (%rax), %r15
sarq $0x3, %r15
xorl %ecx, %ecx
testq %r15, %r15
movl $0x0, %r12d
cmovgq %r15, %r12
movq %rcx, %r14
cmpq %rcx, %r12
je 0x408a82
movq 0x203c2f(%rip), %rdi    # 0x60c6a0
movq %r14, %rsi
callq 0x408b26
leaq 0x1(%r14), %rcx
cmpq %rbx, (%rax)
jne 0x408a62
cmpq %r15, %r14
setl %bl
movq 0x203c09(%rip), %rdi    # 0x60c698
callq 0x407c72
movl %ebx, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq