LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_cpp_makefile_star2_O1/halfflat[P]tinyopt/include/tinyopt/tinyopt.h
// Function: to::saved_options::as_arglist() const
arglist as_arglist() const {
        arglist A;

        for (auto& a: *this) A.arg_data.push_back(const_cast<char*>(a.c_str()));
        A.arg_data.push_back(nullptr);
        A.argv = A.arg_data.data();
        A.argc = A.arg_data.size()-1;
        return A;
    }

// Assembly:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x10, %rsp
movq %rdi, %rbx
leaq 0x10(%rdi), %r14
xorps %xmm0, %xmm0
movups %xmm0, 0x10(%rdi)
movq $0x0, 0x20(%rdi)
movq (%rsi), %r12
movq 0x8(%rsi), %r13
cmpq %r13, %r12
je 0x4519
leaq 0x8(%rsp), %r15
movq (%r12), %rax
movq %rax, 0x8(%rsp)
movq %r14, %rdi
movq %r15, %rsi
callq 0x521c
addq $0x20, %r12
cmpq %r13, %r12
jne 0x44fc
leaq 0x8(%rsp), %rsi
movq $0x0, (%rsi)
movq %r14, %rdi
callq 0x521c
movq 0x10(%rbx), %rax
movq 0x18(%rbx), %rcx
movq %rax, 0x8(%rbx)
subq %rax, %rcx
shrq $0x3, %rcx
decl %ecx
movl %ecx, (%rbx)
movq %rbx, %rax
addq $0x10, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
jmp 0x4557
movq %rax, %r15
movq (%r14), %rdi
testq %rdi, %rdi
je 0x456e
movq 0x20(%rbx), %rsi
subq %rdi, %rsi
callq 0x2140
movq %r15, %rdi
callq 0x2210
// File: /workspace/github_cpp_makefile_star2_O1/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), %rcx
movq 0x28(%rsi), %rdx
xorl %eax, %eax
cmpq %rdx, %rcx
je 0x49f1
testq %rax, %rax
je 0x49e8
movq 0x8(%rcx), %rsi
cmpq 0x8(%rax), %rsi
jbe 0x49eb
movq %rcx, %rax
addq $0x28, %rcx
jmp 0x49d4
leaq 0x10(%rbx), %rcx
movq %rcx, (%rbx)
testq %rax, %rax
je 0x4a11
movq (%rax), %rsi
movq 0x8(%rax), %rdx
addq %rsi, %rdx
movq %rbx, %rdi
callq 0x36ac
jmp 0x4a1d
movq $0x0, 0x8(%rbx)
movb $0x0, 0x10(%rbx)
movq %rbx, %rax
popq %rbx
retq
// File: /workspace/github_cpp_makefile_star2_O1/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 %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x28, %rsp
movq %rdx, %r15
movq %rsi, %r14
movq %rdi, (%rsp)
movq 0x20(%rsi), %rbp
movq 0x28(%rsi), %rbx
cmpb $0x1, 0x68(%rsi)
jne 0x5761
cmpq %rbx, %rbp
je 0x578c
leaq 0x8(%rsp), %r13
movq %rbp, %r12
movq %r13, %rdi
movq %r15, %rsi
movq %r12, %rdx
callq 0x5974
cmpb $0x1, 0x8(%rsp)
je 0x57ed
addq $0x28, %r12
cmpq %rbx, %r12
jne 0x573d
jmp 0x578c
cmpq %rbx, %rbp
je 0x5798
leaq 0x8(%rsp), %r13
movq %rbp, %r12
movq %r13, %rdi
movq %r15, %rsi
movq %r12, %rdx
callq 0x5a18
cmpb $0x1, 0x8(%rsp)
je 0x57ff
addq $0x28, %r12
cmpq %rbx, %r12
jne 0x576e
movq (%rsp), %rbx
movb $0x0, (%rbx)
jmp 0x588e
leaq 0x18(%rsp), %r13
movq %r13, -0x10(%r13)
leaq 0x18ec(%rip), %rdx      # 0x7094
leaq 0x8(%rsp), %rdi
movq %rdx, %rsi
callq 0x3920
movq 0x8(%r15), %rax
movq (%rax), %r12
leaq 0x8(%rsp), %rsi
movq %r14, %rdi
movq %r12, %rdx
callq 0x5bcc
testb %al, %al
je 0x583e
movq %r15, %rdi
movl $0x1, %esi
callq 0x591c
incl 0x70(%r14)
cmpq %rbx, %rbp
je 0x5862
movq 0x8(%rsp), %rax
jmp 0x5864
movq 0x10(%rsp), %rdx
movq %r14, %rdi
movq %r12, %rsi
callq 0x5bcc
jmp 0x580f
movq 0x10(%rsp), %rdx
movq %r14, %rdi
movq %r12, %rsi
callq 0x5bcc
testb %al, %al
je 0x5836
movl 0x18(%rsp), %esi
movq %r15, %rdi
callq 0x591c
movl 0x1c(%rsp), %eax
addl %eax, 0x10(%r15)
incl 0x70(%r14)
cmpq %rbx, %rbp
je 0x5846
movq (%r12), %rax
jmp 0x5848
xorl %eax, %eax
movq (%rsp), %rbx
jmp 0x585e
xorl %eax, %eax
movq (%rsp), %rbx
jmp 0x5875
xorl %eax, %eax
movq (%rsp), %rbx
movq 0x10(%rsp), %rcx
movb $0x1, (%rbx)
movq %rax, 0x8(%rbx)
movq %rcx, 0x10(%rbx)
movb $0x1, %al
movb %al, (%rbx)
jmp 0x588e
xorl %eax, %eax
movq (%rsp), %rbx
movb $0x1, (%rbx)
movq %rax, 0x8(%rbx)
movq %r12, 0x10(%rbx)
movb $0x1, %al
movb %al, (%rbx)
movq 0x8(%rsp), %rdi
cmpq %r13, %rdi
je 0x588e
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x2140
movq %rbx, %rax
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
jmp 0x58c0
jmp 0x58c0
movq %rax, %rbx
movq 0x8(%rsp), %rdi
cmpq %r13, %rdi
je 0x58c3
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x2140
jmp 0x58c3
movq %rax, %rbx
movq %rbx, %rdi
callq 0x2210
nop
// File: /workspace/github_cpp_makefile_star2_O1/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 0x5972
movq 0x8(%rdi), %rax
cmpq $0x0, (%rax)
movq %rax, %rcx
je 0x5947
decl %esi
movq %rax, %rcx
addl $-0x1, %esi
setb %dl
cmpq $0x0, 0x8(%rcx)
leaq 0x8(%rcx), %rcx
je 0x5947
testb %dl, %dl
jne 0x5932
movq %rcx, %rdx
subq %rax, %rdx
shrq $0x3, %rdx
movq (%rdi), %rsi
subl %edx, (%rsi)
xorl %edx, %edx
movq (%rcx,%rdx), %rsi
movq %rsi, (%rax,%rdx)
cmpq $0x0, (%rcx,%rdx)
leaq 0x8(%rdx), %rdx
jne 0x5958
movl $0x0, 0x10(%rdi)
retq
nop
// File: /workspace/github_cpp_makefile_star2_O1/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 0x59d5
movq (%rdx), %rdx
leaq 0x8(%rsp), %r15
movq %r15, %rdi
movq %r14, %rsi
callq 0x5b24
cmpb $0x1, (%r15)
jne 0x59ef
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
movb $0x1, (%rbx)
movq $0x0, 0x8(%rbx)
cmovnel %ecx, %esi
movl %edi, 0x10(%rbx)
movl %esi, 0x14(%rbx)
jmp 0x59f3
cmpl $0x0, 0x10(%r14)
jne 0x59ef
movq 0x8(%r14), %rax
movq (%rax), %rsi
movq %rdx, %rdi
callq 0x2040
testl %eax, %eax
je 0x5a00
xorl %eax, %eax
movb %al, (%rbx)
movq %rbx, %rax
addq $0x10, %rsp
popq %rbx
popq %r14
popq %r15
retq
movb $0x1, (%rbx)
movq $0x0, 0x8(%rbx)
movq $0x1, 0x10(%rbx)
movb $0x1, %al
jmp 0x59f1
nop
// File: /workspace/github_cpp_makefile_star2_O1/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 0x5a75
movq (%r15), %rdx
leaq 0x8(%rsp), %r15
movq %r15, %rdi
movq %r14, %rsi
callq 0x5b24
movb (%r15), %al
cmpb $0x1, %al
jne 0x5af8
movq 0x8(%r14), %rdx
movq (%rdx), %rcx
movl 0x10(%r14), %esi
movl 0xc(%rsp), %edi
leal (%rdi,%rsi), %r8d
cmpb $0x0, (%rcx,%r8)
je 0x5ada
addq %rsi, %rcx
addq %rdi, %rcx
movl $0x1, %edx
jmp 0x5ae3
cmpl $0x0, 0x10(%r14)
jne 0x5a8f
movq 0x8(%r14), %rax
movq (%rax), %rsi
movq %r15, %rdi
callq 0x2040
testl %eax, %eax
je 0x5b09
xorl %eax, %eax
cmpl $0x0, 0x10(%r14)
jne 0x5afa
cmpl $0x1, 0x20(%r15)
jne 0x5afa
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 0x5af8
cmpb $0x3d, (%r14,%r15)
jne 0x5af8
addq %r15, %r14
incq %r14
movb $0x1, (%rbx)
movq %r14, 0x8(%rbx)
movq $0x1, 0x10(%rbx)
jmp 0x5b20
movq 0x8(%rdx), %rcx
movl $0x2, %edx
movb $0x1, (%rbx)
movq %rcx, 0x8(%rbx)
movl %edx, 0x10(%rbx)
movl $0x0, 0x14(%rbx)
testb %al, %al
jne 0x5afc
xorl %eax, %eax
movb %al, (%rbx)
movq %rbx, %rax
addq $0x10, %rsp
popq %rbx
popq %r14
popq %r15
retq
movq 0x8(%r14), %rax
movq 0x8(%rax), %rax
movb $0x1, (%rbx)
movq %rax, 0x8(%rbx)
movq $0x2, 0x10(%rbx)
movb $0x1, %al
jmp 0x5afa
// File: /workspace/github_cpp_makefile_star2_O1/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, 0x8(%rsp)
movq %rdx, %rdi
callq 0x2090
leal -0x1(%rax), %ebp
movl 0x10(%r12), %ebx
cmpl %ebp, %ebx
cmovbl %ebx, %ebp
movq 0x8(%r12), %r15
movq %rax, 0x10(%rsp)
movl %eax, %r13d
incq %rbp
xorl %r12d, %r12d
testq %r12, %r12
je 0x5b7c
movq (%r15), %rdi
movq %r14, %rsi
movq %r12, %rdx
callq 0x20a0
testl %eax, %eax
jne 0x5b9d
movq (%r15), %rdi
addq %rbx, %rdi
leaq (%r14,%r12), %rsi
movq %r13, %rdx
callq 0x20a0
testl %eax, %eax
je 0x5ba6
incq %r12
decq %r13
cmpq %r12, %rbp
jne 0x5b65
xorl %ecx, %ecx
movq 0x8(%rsp), %rax
jmp 0x5bbb
movq 0x10(%rsp), %rcx
subl %r12d, %ecx
movq 0x8(%rsp), %rax
movb $0x1, (%rax)
movl %ecx, 0x4(%rax)
movb $0x1, %cl
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_O1/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)
movq $0x0, -0x8(%rax)
movb $0x0, (%rax)
leaq -0x58(%rbp), %rbx
movq $0x1, (%rbx)
movq 0x2d76(%rip), %r14      # 0x3fd0
leaq 0xe31(%rip), %r15       # 0x2092
movq 0x2d78(%rip), %r12      # 0x3fe0
leaq -0x50(%rbp), %r13
movq %rbx, %rdi
callq 0x13dc
movsd %xmm0, -0x30(%rbp)
xorl %eax, %eax
movsd 0xd85(%rip), %xmm0      # 0x2008
ucomisd -0x30(%rbp), %xmm0
setbe %al
leaq 0xdca(%rip), %rsi       # 0x205c
leaq 0xdb7(%rip), %rcx       # 0x2050
cmovaq %rcx, %rsi
leaq 0xb(,%rax,8), %rdx
movq %r14, %rdi
callq 0x10a0
movq (%r14), %rax
movq -0x18(%rax), %rdi
addq %r14, %rdi
movl $0xa, %esi
callq 0x1080
movsbl %al, %esi
movq %r14, %rdi
callq 0x1030
movq %rax, %rdi
callq 0x1050
xorl %eax, %eax
movsd 0xd2a(%rip), %xmm0      # 0x2008
ucomisd -0x30(%rbp), %xmm0
setbe %al
leaq 0xd93(%rip), %rsi       # 0x2080
leaq 0xd7c(%rip), %rcx       # 0x2070
cmovaq %rcx, %rsi
leaq 0xf(,%rax,2), %rdx
movq %r14, %rdi
callq 0x10a0
movq (%r14), %rax
movq -0x18(%rax), %rdi
addq %r14, %rdi
movl $0xa, %esi
callq 0x1080
movsbl %al, %esi
movq %r14, %rdi
callq 0x1030
movq %rax, %rdi
callq 0x1050
movl $0x1f, %edx
movq %r14, %rdi
movq %r15, %rsi
callq 0x10a0
movq (%r14), %rax
movq -0x18(%rax), %rdi
addq %r14, %rdi
movl $0xa, %esi
callq 0x1080
movsbl %al, %esi
movq %r14, %rdi
callq 0x1030
movq %rax, %rdi
callq 0x1050
movq %r12, %rdi
movq %r13, %rsi
callq 0x10b0
movq (%rax), %rcx
movq -0x18(%rcx), %rcx
testb $0x5, 0x20(%rax,%rcx)
jne 0x138c
movq -0x50(%rbp), %rax
cmpb $0x79, (%rax)
je 0x126c
movq -0x50(%rbp), %rdi
leaq -0x40(%rbp), %rax
cmpq %rax, %rdi
je 0x13a5
movq -0x40(%rbp), %rsi
incq %rsi
callq 0x1090
xorl %eax, %eax
addq $0x38, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
jmp 0x13b8
movq %rax, %rbx
movq -0x50(%rbp), %rdi
leaq -0x40(%rbp), %rax
cmpq %rax, %rdi
je 0x13d4
movq -0x40(%rbp), %rsi
incq %rsi
callq 0x1090
movq %rbx, %rdi
callq 0x10d0
// File: /workspace/github_cpp_makefile_star2_O1/arwn[P]baby-shark/babyshark.cpp
// Function: main
int
main(void)
{
  using namespace std::chrono_literals;
  Bullshit baby_shark_machine;
  char c;
  for (int i = 0; i < 100; i++) {
    baby_shark_machine.step();
  }
  return {};
}

// Assembly:
pushq %rbp
pushq %rbx
subq $0x38, %rsp
movq %rsp, %rbx
movq %rbx, %rdi
callq 0x240a
movl $0x64, %ebp
movq %rbx, %rdi
callq 0x2ba8
decl %ebp
jne 0x23c2
leaq 0x20(%rsp), %rdi
callq 0x33e2
leaq 0x8(%rsp), %rdi
callq 0x2cca
xorl %eax, %eax
addq $0x38, %rsp
popq %rbx
popq %rbp
retq
movq %rax, %rbx
leaq 0x20(%rsp), %rdi
callq 0x33e2
leaq 0x8(%rsp), %rdi
callq 0x2cca
movq %rbx, %rdi
callq 0x21b0
// File: /workspace/github_cpp_makefile_star2_O1/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 %r14
pushq %rbx
subq $0x48, %rsp
movq %rdi, %rbx
movl (%rdi), %eax
movq 0x8(%rdi), %rcx
shlq $0x5, %rax
movq (%rcx,%rax), %rsi
movq 0x8(%rcx,%rax), %rdx
movq 0x2d92(%rip), %rdi      # 0x5fd8
callq 0x2150
leaq 0x8(%rsp), %rsi
movb $0x20, (%rsi)
movl $0x1, %edx
movq %rax, %rdi
callq 0x2150
movq %rax, %rdi
callq 0x20b0
movl (%rbx), %edx
shlq $0x5, %rdx
addq 0x8(%rbx), %rdx
leaq 0xe40(%rip), %rsi       # 0x40b9
leaq 0x28(%rsp), %rbx
movq %rbx, %rdi
callq 0x3359
leaq 0xe39(%rip), %rsi       # 0x40c6
movq %rbx, %rdi
callq 0x21d0
leaq 0x18(%rsp), %r14
movq %r14, -0x10(%r14)
movq (%rax), %rdx
movq %rax, %rcx
addq $0x10, %rcx
cmpq %rcx, %rdx
je 0x32bc
movq %rdx, 0x8(%rsp)
movq (%rcx), %rdx
movq %rdx, 0x18(%rsp)
jmp 0x32c3
movups (%rcx), %xmm0
movups %xmm0, (%r14)
movq 0x8(%rax), %rdx
movq %rdx, 0x10(%rsp)
movq %rcx, (%rax)
movq $0x0, 0x8(%rax)
movb $0x0, 0x10(%rax)
leaq 0x38(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x32f6
movq 0x38(%rsp), %rsi
incq %rsi
callq 0x2140
movq 0x8(%rsp), %rdi
callq 0x20f0
movq 0x8(%rsp), %rdi
cmpq %r14, %rdi
je 0x3317
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x2140
addq $0x48, %rsp
popq %rbx
popq %r14
retq
movq %rax, %rbx
movq 0x8(%rsp), %rdi
cmpq %r14, %rdi
je 0x3351
movq 0x18(%rsp), %rsi
jmp 0x3349
movq %rax, %rbx
leaq 0x38(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x3351
movq 0x38(%rsp), %rsi
incq %rsi
callq 0x2140
movq %rbx, %rdi
callq 0x21b0
// File: /workspace/github_cpp_makefile_star2_O1/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 0x2d34
movq (%rbx), %r12
cmpq 0x8(%rbx), %r12
je 0x265c
movslq %ebp, %r13
movq (%r14,%r13,8), %rax
movslq (%r12), %rcx
cmpb $0x1, (%rax,%rcx)
jne 0x2652
movq 0x8(%r15), %rsi
cmpq 0x10(%r15), %rsi
je 0x2647
movq (%r12), %rax
movq %rax, (%rsi)
addq $0x8, 0x8(%r15)
jmp 0x2652
movq %r15, %rdi
movq %r12, %rdx
callq 0x2f8c
addq $0x8, %r12
cmpq 0x8(%rbx), %r12
jne 0x2621
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O1/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 %r13
pushq %r12
pushq %rbx
movq %rdi, %rbx
movq (%rdi), %r12
cmpq 0x8(%rdi), %r12
je 0x2c11
movq 0x53f6(%rip), %r14      # 0x7fd8
leaq 0x241b(%rip), %r15      # 0x5004
movl (%r12), %esi
incl %esi
movq %r14, %rdi
callq 0x2270
movl $0x2, %edx
movq %rax, %rdi
movq %r15, %rsi
callq 0x2200
addq $0x8, %r12
cmpq 0x8(%rbx), %r12
jne 0x2be9
movq 0x53c0(%rip), %r14      # 0x7fd8
movq (%r14), %rax
movq -0x18(%rax), %rdi
addq %r14, %rdi
movl $0xa, %esi
callq 0x21b0
movsbl %al, %esi
movq %r14, %rdi
callq 0x2040
movq %rax, %rdi
callq 0x2140
movq (%rbx), %r13
cmpq 0x8(%rbx), %r13
je 0x2c7c
movq 0x5389(%rip), %r15      # 0x7fd8
leaq 0x23ae(%rip), %r12      # 0x5004
movl 0x4(%r13), %esi
movq %r15, %rdi
callq 0x2270
movl $0x2, %edx
movq %rax, %rdi
movq %r12, %rsi
callq 0x2200
addq $0x8, %r13
cmpq 0x8(%rbx), %r13
jne 0x2c56
movq (%r14), %rax
movq -0x18(%rax), %rdi
addq %r14, %rdi
movl $0xa, %esi
callq 0x21b0
movsbl %al, %esi
movq %r14, %rdi
callq 0x2040
movq %rax, %rdi
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
jmp 0x2140
// File: /workspace/github_cpp_makefile_star2_O1/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)
movl $0x48, %edi
callq 0x40eea0
movq %rax, %r14
movq $0x60e5d8, %rsi         # imm = 0x60E5D8
movq %rax, %rdi
callq 0x405f38
movq %rbx, %rdi
movq %r14, %rsi
callq 0x407d52
movq (%rax), %rcx
movq %rax, %rdi
callq *(%rcx)
movl $0x48, %edi
callq 0x40eea0
movq %rax, %r14
movq $0x60e630, %rsi         # imm = 0x60E630
movq %rax, %rdi
callq 0x405f38
movq %rbx, %rdi
movq %r14, %rsi
callq 0x407d52
movq (%rax), %rcx
movq %rax, %rdi
callq *(%rcx)
movl $0x48, %edi
callq 0x40eea0
movq %rax, %r14
movq $0x60e5d8, %rsi         # imm = 0x60E5D8
movq %rax, %rdi
callq 0x405f38
movq %rbx, %rdi
movq %r14, %rsi
callq 0x407d52
movq (%rax), %rcx
movq %rax, %rdi
addq $0x8, %rsp
popq %rbx
popq %r14
jmpq *(%rcx)
jmp 0x405693
jmp 0x405693
movq %rax, %rbx
movl $0x48, %esi
movq %r14, %rdi
callq 0x40dd10
movq %rbx, %rdi
callq 0x4b7f40
nop
// File: /workspace/github_cpp_makefile_star2_O1/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
sete %al
jne 0x405a29
movq 0x40(%rsi), %rax
movq 0x48(%rsi), %rcx
cmpq 0x40(%rdi), %rax
sete %dl
testq %rax, %rax
sete %r8b
cmpq 0x48(%rdi), %rcx
sete %al
orb %r8b, %al
andb %dl, %al
testb %al, %al
je 0x405a3a
movq 0x50(%rsi), %rcx
cmpq 0x50(%rdi), %rcx
sete %cl
andb %cl, %al
retq
nop
// File: /workspace/github_cpp_makefile_star2_O1/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 $0x28, %rsp
movq %rsi, %r14
movq %rdi, %rbx
movq %rsi, %rdi
callq 0x4098c2
movq %rbx, 0x8(%rsp)
movq %rbx, %rdi
callq 0x4098c2
movq 0x78(%r14), %rcx
movq %r14, 0x10(%rsp)
subq 0x70(%r14), %rcx
testq %rcx, %rcx
jle 0x406637
movq %rcx, %rax
shrq $0x3, %rax
movabsq $0x2e8ba2e8ba2e8ba3, %rbx # imm = 0x2E8BA2E8BA2E8BA3
imulq %rbx, %rax
cmpq $0x2, %rax
movl $0x1, %ecx
cmovlq %rcx, %rax
movq %rax, 0x18(%rsp)
xorl %esi, %esi
movq 0x10(%rsp), %rcx
movq 0x70(%rcx), %rax
movq 0x78(%rcx), %rdx
subq %rax, %rdx
sarq $0x3, %rdx
imulq %rbx, %rdx
cmpq %rsi, %rdx
jbe 0x406671
movq %rsi, 0x20(%rsp)
imulq $0x58, %rsi, %rcx
leaq (%rax,%rcx), %r14
movq (%rax,%rcx), %rsi
movq 0x8(%rsp), %rdi
callq 0x407a60
movq %rax, %r12
testq %rax, %rax
jne 0x4065c8
movq (%r14), %rsi
movq 0x8(%rsp), %rdi
callq 0x407ac8
movq %rax, %r12
movq 0x48(%r14), %rax
subq 0x40(%r14), %rax
testq %rax, %rax
jle 0x406624
mulq %rbx
movq %rdx, %r13
shrq $0x4, %r13
addq $0x38, %r12
cmpq $0x2, %r13
movl $0x1, %eax
cmovlq %rax, %r13
xorl %r15d, %r15d
xorl %ebp, %ebp
movq 0x40(%r14), %rsi
movq 0x48(%r14), %rdx
subq %rsi, %rdx
sarq $0x3, %rdx
imulq %rbx, %rdx
cmpq %rbp, %rdx
jbe 0x406660
addq %r15, %rsi
movq %r12, %rdi
callq 0x408708
incq %rbp
addq $0x58, %r15
cmpq %rbp, %r13
jne 0x4065f5
movq 0x20(%rsp), %rsi
incq %rsi
cmpq 0x18(%rsp), %rsi
jne 0x406574
movq 0x8(%rsp), %rbx
movq %rbx, %rdi
callq 0x40987a
movq 0x10(%rsp), %rdi
callq 0x40987a
movq %rbx, %rax
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
leaq 0x192be9(%rip), %rdi    # 0x599250
movq %rbp, %rsi
xorl %eax, %eax
callq 0x458590
leaq 0x192bd8(%rip), %rdi    # 0x599250
jmp 0x40666a
// File: /workspace/github_cpp_makefile_star2_O1/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 %rax
movq 0x70(%rdi), %rcx
movq 0x78(%rdi), %rax
subq %rcx, %rax
testq %rax, %rax
jle 0x407a3b
sarq $0x3, %rax
movabsq $0x2e8ba2e8ba2e8ba3, %rdx # imm = 0x2E8BA2E8BA2E8BA3
imulq %rax, %rdx
cmpq $0x2, %rdx
movl $0x1, %r8d
cmovgeq %rdx, %r8
xorl %eax, %eax
xorl %r9d, %r9d
cmpq %r9, %rdx
je 0x407a4e
cmpq %rsi, (%rcx,%rax)
je 0x407a3d
incq %r9
addq $0x58, %rax
cmpq %r9, %r8
jne 0x407a24
popq %rax
retq
addq 0x70(%rdi), %rax
addq $0x70, %rdi
movq %rax, %rsi
popq %rax
jmp 0x40972c
leaq 0x1917fb(%rip), %rdi    # 0x599250
movq %rdx, %rsi
xorl %eax, %eax
callq 0x458590
nop
// File: /workspace/github_cpp_makefile_star2_O1/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 %rax
movq 0x70(%rdi), %rcx
movq 0x78(%rdi), %rax
subq %rcx, %rax
testq %rax, %rax
jle 0x407ab2
sarq $0x3, %rax
movabsq $0x2e8ba2e8ba2e8ba3, %rdx # imm = 0x2E8BA2E8BA2E8BA3
imulq %rax, %rdx
cmpq $0x2, %rdx
movl $0x1, %edi
cmovgeq %rdx, %rdi
addq $0x8, %rcx
xorl %r8d, %r8d
cmpq %r8, %rdx
je 0x407ab6
cmpq %rsi, -0x8(%rcx)
cmoveq %rcx, %rax
je 0x407ab4
incq %r8
addq $0x58, %rcx
cmpq %r8, %rdi
jne 0x407a97
xorl %eax, %eax
popq %rcx
retq
leaq 0x191793(%rip), %rdi    # 0x599250
movq %rdx, %rsi
xorl %eax, %eax
callq 0x458590
nop
// File: /workspace/github_cpp_makefile_star2_O1/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 %rbx
subq $0x60, %rsp
movq %rsi, %r14
movq %rdi, %rbx
leaq 0x8(%rsp), %r15
movq %r15, %rdi
callq 0x406340
movq %r14, (%r15)
leaq 0x70(%rbx), %rdi
movq 0x78(%rbx), %r14
subq 0x70(%rbx), %r14
movq %r15, %rsi
callq 0x408734
movq %r14, %rsi
sarq $0x3, %rsi
movabsq $0x2e8ba2e8ba2e8ba3, %rcx # imm = 0x2E8BA2E8BA2E8BA3
imulq %rcx, %rsi
movq 0x70(%rbx), %rax
movq 0x78(%rbx), %rdx
subq %rax, %rdx
sarq $0x3, %rdx
imulq %rcx, %rdx
cmpq %rsi, %rdx
jbe 0x407b51
leaq (%rax,%r14), %rbx
addq $0x8, %rbx
leaq 0x10(%rsp), %rdi
callq 0x4099d0
leaq 0x48(%rsp), %rdi
callq 0x408760
movq %rbx, %rax
addq $0x60, %rsp
popq %rbx
popq %r14
popq %r15
retq
leaq 0x1916f8(%rip), %rdi    # 0x599250
xorl %eax, %eax
callq 0x458590
movq %rax, %rbx
leaq 0x10(%rsp), %rdi
callq 0x4099d0
leaq 0x48(%rsp), %rdi
callq 0x408760
movq %rbx, %rdi
callq 0x4b7f40
// File: /workspace/github_cpp_makefile_star2_O1/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 %rbx
movq %rdx, %r14
movq %rsi, %r15
movq %rdi, %rbx
callq 0x4098c2
movq %rbx, %rdi
movq %r15, %rsi
callq 0x407a60
testq %rax, %rax
jne 0x407bac
movq %rbx, %rdi
movq %r15, %rsi
callq 0x407ac8
movq 0x38(%rax), %rcx
movq 0x40(%rax), %rsi
subq %rcx, %rsi
sarq $0x3, %rsi
movabsq $0x2e8ba2e8ba2e8ba3, %rdx # imm = 0x2E8BA2E8BA2E8BA3
imulq %rsi, %rdx
testl %edx, %edx
jle 0x407bf5
movl %edx, %esi
andl $0x7fffffff, %esi       # imm = 0x7FFFFFFF
addq $0x38, %rcx
xorl %edi, %edi
cmpq %rdi, %rdx
je 0x407c11
movq (%rcx), %r8
cmpq 0x38(%r14), %r8
je 0x407c04
incq %rdi
addq $0x58, %rcx
cmpq %rdi, %rsi
jne 0x407bdb
addq $0x38, %rax
movq %rax, %rdi
movq %r14, %rsi
callq 0x408708
movq %rbx, %rdi
popq %rbx
popq %r14
popq %r15
jmp 0x40987a
leaq 0x191638(%rip), %rdi    # 0x599250
movq %rdx, %rsi
xorl %eax, %eax
callq 0x458590
// File: /workspace/github_cpp_makefile_star2_O1/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
subq $0x18, %rsp
movq %rdx, %r15
movq %rsi, %r14
movq %rdi, %rbx
callq 0x4098c2
movq %rbx, %rdi
movq %r14, 0x8(%rsp)
movq %r14, %rsi
callq 0x407a60
testq %rax, %rax
je 0x407cf9
movq %rax, %r12
movq %rbx, 0x10(%rsp)
movq 0x40(%rax), %r13
subq 0x38(%rax), %r13
sarq $0x3, %r13
movabsq $0x2e8ba2e8ba2e8ba3, %rbx # imm = 0x2E8BA2E8BA2E8BA3
imulq %rbx, %r13
testl %r13d, %r13d
jle 0x407cdb
movq %r12, %rax
addq $0x38, %rax
movq %rax, (%rsp)
andl $0x7fffffff, %r13d      # imm = 0x7FFFFFFF
xorl %ebp, %ebp
xorl %r14d, %r14d
movq 0x38(%r12), %rdi
movq 0x40(%r12), %rdx
subq %rdi, %rdx
sarq $0x3, %rdx
imulq %rbx, %rdx
cmpq %r14, %rdx
jbe 0x407d0f
addq %rbp, %rdi
movq %r15, %rsi
callq 0x4059fa
testb %al, %al
jne 0x407ccc
incq %r14
addq $0x58, %rbp
cmpq %r14, %r13
jne 0x407c95
jmp 0x407cdb
movq (%rsp), %rdi
addq (%rdi), %rbp
movq %rbp, %rsi
callq 0x409230
movq 0x38(%r12), %rax
cmpq 0x40(%r12), %rax
movq 0x10(%rsp), %rbx
jne 0x407cf9
movq %rbx, %rdi
movq 0x8(%rsp), %rsi
callq 0x4079ee
movq %rbx, %rdi
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x40987a
leaq 0x19153a(%rip), %rdi    # 0x599250
movq %r14, %rsi
xorl %eax, %eax
callq 0x458590
// File: /workspace/github_cpp_makefile_star2_O1/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 0x4098c2
movq %r14, %rdi
movq %rbx, %rsi
callq 0x407a60
testq %rax, %rax
setne %bl
movq %r14, %rdi
callq 0x40987a
movl %ebx, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_cpp_makefile_star2_O1/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 0x1fb054(%rip), %rax    # 0x604848
movq %rax, (%rdi)
movb $0x0, 0x30(%rdi)
addq $0x8, %rdi
xorl %esi, %esi
callq 0x4ec2f0
testl %eax, %eax
jne 0x40980c
popq %rax
retq
leaq 0x18fba3(%rip), %rdi    # 0x5993b6
leaq 0x18fba5(%rip), %rsi    # 0x5993bf
leaq 0x18fbac(%rip), %rcx    # 0x5993cd
movl $0x12, %edx
callq 0x4ccba0
nop
// File: /workspace/github_cpp_makefile_star2_O1/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 0x1fb011(%rip), %rax    # 0x604848
movq %rax, (%rdi)
cmpb $0x1, 0x30(%rdi)
jne 0x409848
movq %rbx, %rdi
callq 0x40987a
addq $0x8, %rbx
movq %rbx, %rdi
callq 0x4ec2c0
testl %eax, %eax
jne 0x40985a
popq %rbx
retq
leaq 0x18fb55(%rip), %rdi    # 0x5993b6
leaq 0x18fb57(%rip), %rsi    # 0x5993bf
leaq 0x18fb70(%rip), %rcx    # 0x5993df
movl $0x1b, %edx
callq 0x4ccba0
nop
// File: /workspace/github_cpp_makefile_star2_O1/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 0x4097ec
leaq 0x1faf60(%rip), %rax    # 0x604880
movq %rax, (%rbx)
cmpq $0x0, 0x204d6d(%rip)    # 0x60e698
jne 0x409949
movl $0x38, %edi
callq 0x40eea0
movq %rax, %r15
movq %rax, %rdi
callq 0x4097ec
movq %r15, 0x204d4f(%rip)    # 0x60e698
cmpq $0x0, 0x204d4f(%rip)    # 0x60e6a0
jne 0x409972
movl $0x18, %edi
callq 0x40eea0
xorps %xmm0, %xmm0
movups %xmm0, (%rax)
movq $0x0, 0x10(%rax)
movq %rax, 0x204d2e(%rip)    # 0x60e6a0
movq 0x204d1f(%rip), %rdi    # 0x60e698
callq 0x4098c2
movq 0x204d1b(%rip), %rdi    # 0x60e6a0
leaq 0x8(%rsp), %rsi
movq %rbx, (%rsi)
callq 0x40abbe
movq 0x204cff(%rip), %rdi    # 0x60e698
callq 0x40987a
addq $0x10, %rsp
popq %rbx
popq %r14
popq %r15
retq
movq %rax, %r14
movl $0x38, %esi
movq %r15, %rdi
callq 0x40dd10
jmp 0x4099bf
jmp 0x4099bc
movq %rax, %r14
movq %rbx, %rdi
callq 0x40982c
movq %r14, %rdi
callq 0x4b7f40
nop
// File: /workspace/github_cpp_makefile_star2_O1/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 %rbx
movq %rdi, %rbx
leaq 0x1faea1(%rip), %rax    # 0x604880
movq %rax, (%rdi)
callq 0x4098c2
movq 0x204caa(%rip), %rdi    # 0x60e698
callq 0x4098c2
movq 0x204ca6(%rip), %r14    # 0x60e6a0
movq (%r14), %rsi
movq 0x8(%r14), %rax
movq %rax, %rdx
subq %rsi, %rdx
movq %rdx, %rcx
sarq $0x3, %rcx
testq %rcx, %rcx
jle 0x409a43
addq $0x8, %rsi
addq $-0x8, %rdx
cmpq %rbx, -0x8(%rsi)
je 0x409a30
addq $0x8, %rsi
addq $-0x8, %rdx
decq %rcx
jne 0x409a1b
jmp 0x409a43
cmpq %rax, %rsi
je 0x409a3e
leaq -0x8(%rsi), %rdi
callq 0x401020
addq $-0x8, 0x8(%r14)
movq (%r14), %r15
movq 0x8(%r14), %r14
movq 0x204c47(%rip), %rdi    # 0x60e698
callq 0x40987a
cmpq %r15, %r14
jne 0x409ab9
movq 0x204c3e(%rip), %r14    # 0x60e6a0
testq %r14, %r14
je 0x409a88
movq (%r14), %rdi
testq %rdi, %rdi
je 0x409a7b
movq 0x10(%r14), %rsi
subq %rdi, %rsi
callq 0x40dd10
movl $0x18, %esi
movq %r14, %rdi
callq 0x40dd10
movq 0x204c09(%rip), %r14    # 0x60e698
testq %r14, %r14
je 0x409aa9
movq %r14, %rdi
callq 0x40982c
movl $0x38, %esi
movq %r14, %rdi
callq 0x40dd10
xorl %eax, %eax
movq %rax, 0x204bee(%rip)    # 0x60e6a0
movq %rax, 0x204bdf(%rip)    # 0x60e698
movq %rbx, %rdi
callq 0x40987a
movq %rbx, %rdi
popq %rbx
popq %r14
popq %r15
jmp 0x40982c
movq %rax, %rdi
callq 0x405019
// File: /workspace/github_cpp_makefile_star2_O1/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
leaq 0x18(%rsp), %r12
movq %r12, -0x10(%r12)
movq 0x38(%rsi), %rax
movq 0x40(%rsi), %rdx
addq %rax, %rdx
leaq 0x8(%rsp), %r15
movq %r15, %rdi
movq %rax, %rsi
callq 0x4091a0
movq (%r14), %rsi
movq 0x8(%r14), %rcx
movq %r15, %rdi
movq $-0x1, %rdx
callq 0x489cd0
cmpq $-0x1, %rax
je 0x40a391
movq (%r14), %rsi
movq 0x8(%r14), %rcx
leaq 0x8(%rsp), %r14
movq %r14, %rdi
movq $-0x1, %rdx
callq 0x489cd0
incq %rax
movq 0x8(%r14), %rcx
cmpq %rax, %rcx
jb 0x40a3c6
movq %rax, 0x10(%rsp)
movq 0x8(%rsp), %rcx
movb $0x0, (%rcx,%rax)
leaq 0x38(%rsp), %r14
movq %r14, -0x10(%r14)
movq 0x8(%rsp), %rsi
movq 0x10(%rsp), %rdx
addq %rsi, %rdx
leaq 0x28(%rsp), %rdi
callq 0x4091a0
leaq 0x28(%rsp), %rsi
movq %rbx, %rdi
callq 0x409ebe
movq 0x28(%rsp), %rdi
cmpq %r14, %rdi
je 0x40a3a0
movq 0x38(%rsp), %rsi
incq %rsi
callq 0x40dd10
jmp 0x40a3a0
leaq 0x1ae372(%rip), %rsi    # 0x5b870a
movq %rbx, %rdi
callq 0x409e78
movq 0x8(%rsp), %rdi
cmpq %r12, %rdi
je 0x40a3b7
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x40dd10
movq %rbx, %rax
addq $0x48, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
leaq 0x18f07d(%rip), %rdi    # 0x59944a
leaq 0x18f0ad(%rip), %rsi    # 0x599481
movq %rax, %rdx
xorl %eax, %eax
callq 0x458590
movq %rax, %rbx
movq 0x28(%rsp), %rdi
cmpq %r14, %rdi
je 0x40a3fd
movq 0x38(%rsp), %rsi
incq %rsi
callq 0x40dd10
jmp 0x40a3fd
movq %rax, %rbx
movq 0x8(%rsp), %rdi
cmpq %r12, %rdi
je 0x40a414
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x40dd10
movq %rbx, %rdi
callq 0x4b7f40
// File: /workspace/github_cpp_makefile_star2_O1/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 %rbx
movq %rdx, %rbx
movq %rsi, %r14
movq %rdi, %r15
addq $0x38, %r15
movq 0x38(%rsi), %rsi
movq 0x40(%r14), %rcx
movq %r15, %rdi
xorl %edx, %edx
callq 0x4897d0
cmpq $-0x1, %rax
je 0x40a631
movq 0x38(%r14), %rsi
movq 0x40(%r14), %rcx
movq %r15, %rdi
xorl %edx, %edx
callq 0x4897d0
movq 0x40(%r14), %rdx
movq 0x38(%rbx), %rcx
movq 0x40(%rbx), %r8
movq %r15, %rdi
movq %rax, %rsi
callq 0x488d50
movq 0x38(%r14), %rsi
jmp 0x40a5ee
popq %rbx
popq %r14
popq %r15
retq
nop
// File: /workspace/github_cpp_makefile_star2_O1/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 $0x88, %rsp
movq %rsi, %r14
movq %rdi, %rbx
movl $0x50, %edi
callq 0x40eea0
movq %rax, %r12
addq $0x38, %rax
movq %rax, (%rsp)
xorps %xmm0, %xmm0
movups %xmm0, 0x38(%r12)
movq $0x0, 0x48(%r12)
movq %r12, %rdi
callq 0x409908
leaq 0x1f9ebb(%rip), %rax    # 0x604540
movq %r12, 0x8(%rsp)
movq %rax, (%r12)
cmpq $0x0, 0x40(%rbx)
je 0x40a746
leaq 0x38(%rbx), %r13
xorl %r12d, %r12d
movq 0x38(%r14), %rsi
movq 0x40(%r14), %rcx
movq %r13, %rdi
movq %r12, %rdx
callq 0x4897d0
movq %rax, %rbp
cmpq $-0x1, %rax
jne 0x40a6c0
movq 0x40(%rbx), %rbp
movq %rbp, %rcx
subq %r12, %rcx
leaq 0x10(%rsp), %r15
movq %r15, %rdi
movq %r13, %rsi
movq %r12, %rdx
callq 0x48a590
leaq 0x30(%rsp), %r12
movq %r12, %rdi
movq %r15, %rsi
callq 0x409ebe
movq (%rsp), %rdi
movq %r12, %rsi
callq 0x40adba
movq 0x68(%rsp), %rdi
leaq 0x78(%rsp), %rax
cmpq %rax, %rdi
je 0x40a711
movq 0x78(%rsp), %rsi
incq %rsi
callq 0x40dd10
movq %r12, %rdi
callq 0x4099d0
movq 0x10(%rsp), %rdi
leaq 0x20(%rsp), %rax
cmpq %rax, %rdi
je 0x40a735
movq 0x20(%rsp), %rsi
incq %rsi
callq 0x40dd10
addq 0x40(%r14), %rbp
movq %rbp, %r12
cmpq 0x40(%rbx), %rbp
jb 0x40a6a0
movq 0x8(%rsp), %rax
addq $0x88, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
movq (%rsp), %rdi
callq 0x404d12
movl $0x50, %esi
movq %r12, %rdi
jmp 0x40a79c
movq %rax, %rbx
jmp 0x40a785
movq %rax, %rbx
leaq 0x30(%rsp), %rdi
callq 0x404a8a
movq 0x10(%rsp), %rdi
leaq 0x20(%rsp), %rax
cmpq %rax, %rdi
je 0x40a7a1
movq 0x20(%rsp), %rsi
incq %rsi
callq 0x40dd10
movq %rbx, %rdi
callq 0x4b7f40
nop
// File: /workspace/github_cpp_makefile_star2_O1/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 %rbp
pushq %rbx
pushq %rax
movq %rdi, %rbx
movq 0x203bff(%rip), %rdi    # 0x60e698
callq 0x4098c2
movq 0x203bfb(%rip), %rax    # 0x60e6a0
movq (%rax), %rcx
movq 0x8(%rax), %rax
subq %rcx, %rax
sarq $0x3, %rax
testq %rax, %rax
setg %bpl
jle 0x40aadf
cmpq %rbx, (%rcx)
je 0x40aadf
movl $0x1, %esi
movq %rsi, %rdx
cmpq %rsi, %rax
je 0x40aad8
leaq 0x1(%rdx), %rsi
cmpq %rbx, (%rcx,%rdx,8)
jne 0x40aac6
cmpq %rax, %rdx
setl %bpl
movq 0x203bb2(%rip), %rdi    # 0x60e698
callq 0x40987a
movl %ebp, %eax
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O1/enbock[P]Warp10Server/ulib/src/Thread.cpp
// Function: u::Thread::Thread(u::Callback*)
Thread::Thread(Callback *cb)
{
	_thread = 0;
	_call = *cb; //copy
	pthread_attr_init(&_attr);
	pthread_attr_setdetachstate(&_attr, PTHREAD_CREATE_DETACHED);
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq %rdi, %r14
callq 0x40596e
movq $0x0, 0x58(%r14)
movups 0x8(%rbx), %xmm0
movups 0x18(%rbx), %xmm1
movups 0x21(%rbx), %xmm2
movups %xmm0, 0x8(%r14)
movups %xmm1, 0x18(%r14)
movups %xmm2, 0x21(%r14)
movups 0x38(%rbx), %xmm0
movups 0x48(%rbx), %xmm1
movups %xmm0, 0x38(%r14)
movups %xmm1, 0x48(%r14)
addq $0x60, %r14
movq %r14, %rdi
callq 0x4ea820
movq %r14, %rdi
movl $0x1, %esi
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x4ea850
// File: /workspace/github_cpp_makefile_star2_O1/enbock[P]Warp10Server/ulib/src/Thread.cpp
// Function: u::ThreadSystem::numThreads()
int64 ThreadSystem::numThreads()
{
	_access.lock();
	int64 num = _build.size();
	num += _run.size();
	_access.unlock();
	return num;
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
leaq 0x2028f7(%rip), %rbx    # 0x60e6b0
movq %rbx, %rdi
callq 0x4098c2
movq 0x202960(%rip), %rax    # 0x60e728
subq 0x202951(%rip), %rax    # 0x60e720
sarq $0x3, %rax
movq 0x20299e(%rip), %r14    # 0x60e778
subq 0x20298f(%rip), %r14    # 0x60e770
sarq $0x3, %r14
addq %rax, %r14
movq %rbx, %rdi
callq 0x40987a
movq %r14, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
nop
// File: /workspace/github_cpp_makefile_star2_O1/enbock[P]Warp10Server/ulib/src/Thread.cpp
// Function: u::ThreadSystem::numQueuedThreads()
int64 ThreadSystem::numQueuedThreads()
{
	_access.lock();
	int64 num = _build.size();
	_access.unlock();
	return num;
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
leaq 0x2028a9(%rip), %rbx    # 0x60e6b0
movq %rbx, %rdi
callq 0x4098c2
movq 0x202912(%rip), %r14    # 0x60e728
subq 0x202903(%rip), %r14    # 0x60e720
sarq $0x3, %r14
movq %rbx, %rdi
callq 0x40987a
movq %r14, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_cpp_makefile_star2_O1/enbock[P]Warp10Server/ulib/src/Thread.cpp
// Function: u::ThreadSystem::tick()
void ThreadSystem::tick()
{
	_access.lock();

	while(threadLimit > _run.size() && _build.empty() == false)
	{
		_access.unlock();
		run(0);
		_access.lock();
	}

	_access.unlock();
}

// Assembly:
pushq %rbx
leaq 0x201c6a(%rip), %rdi    # 0x60e6b0
callq 0x4098c2
movq 0x201d26(%rip), %rax    # 0x60e778
subq 0x201d17(%rip), %rax    # 0x60e770
sarq $0x3, %rax
cmpq %rax, 0x1ff6f4(%rip)    # 0x60c158
jbe 0x40caaf
leaq 0x201c43(%rip), %rbx    # 0x60e6b0
movq 0x201cac(%rip), %rax    # 0x60e720
cmpq 0x201cad(%rip), %rax    # 0x60e728
je 0x40caaf
movq %rbx, %rdi
callq 0x40987a
xorl %edi, %edi
callq 0x40be34
movq %rbx, %rdi
callq 0x4098c2
movq 0x201cdd(%rip), %rax    # 0x60e778
subq 0x201cce(%rip), %rax    # 0x60e770
sarq $0x3, %rax
cmpq %rax, 0x1ff6ab(%rip)    # 0x60c158
ja 0x40ca6d
leaq 0x201bfa(%rip), %rdi    # 0x60e6b0
popq %rbx
jmp 0x40987a
// File: /workspace/github_cpp_makefile_star2_O1/harry830622[P]floorplanner/src/b_star_tree.cpp
// Function: BStarTree::BStarTree(int)
BStarTree::BStarTree(int num_macros)
    : root_id_(0), nodes_(num_macros, Node(-1, -1, -1)) {
  const int num_nodes = nodes_.size();

  for (int i = 0; i < num_nodes - 1; ++i) {
    nodes_[i].left_child_id_ = i + 1;
  }
  for (int i = 1; i < num_nodes; ++i) {
    nodes_[i].parent_id_ = i - 1;
  }

  /* for (int i = 0; i < num_nodes / 2 + 1; ++i) { */
  /*   const int right_child_id = (i + 1) * 2; */
  /*   const int left_child_id = right_child_id - 1; */
  /*   if (left_child_id < num_nodes) { */
  /*     nodes_[i].left_child_id_ = left_child_id; */
  /*   } */
  /*   if (right_child_id < num_nodes) { */
  /*     nodes_[i].right_child_id_ = right_child_id; */
  /*   } */
  /* } */
  /* for (int i = 1; i < num_nodes; ++i) { */
  /*   nodes_[i].parent_id_ = (i - 1) / 2; */
  /* } */
}

// Assembly:
pushq %rbx
subq $0x20, %rsp
movq %rdi, %rbx
movl $0x0, (%rdi)
addq $0x8, %rdi
movslq %esi, %rsi
leaq 0x10(%rsp), %rdx
movq $-0x1, (%rdx)
movl $0xffffffff, 0x8(%rdx)  # imm = 0xFFFFFFFF
movb $0x0, 0xc(%rdx)
leaq 0xf(%rsp), %rcx
callq 0x7518
movq 0x8(%rbx), %rax
movq 0x10(%rbx), %rcx
subq %rax, %rcx
shrq $0x4, %rcx
cmpl $0x2, %ecx
jl 0x6bed
leal -0x1(%rcx), %edx
leaq 0x4(%rax), %rsi
xorl %edi, %edi
incq %rdi
movl %edi, (%rsi)
addq $0x10, %rsi
cmpq %rdi, %rdx
jne 0x6bdf
cmpl $0x2, %ecx
jl 0x6c0f
andl $0x7fffffff, %ecx       # imm = 0x7FFFFFFF
addq $0x10, %rax
decq %rcx
xorl %edx, %edx
movl %edx, (%rax)
incq %rdx
addq $0x10, %rax
cmpq %rdx, %rcx
jne 0x6c01
addq $0x20, %rsp
popq %rbx
retq
nop
// File: /workspace/github_cpp_makefile_star2_O1/harry830622[P]floorplanner/src/b_star_tree.cpp
// Function: BStarTree::Insert(int, int, std::pair<int, int>)
void BStarTree::Insert(int inserted_node_id, int target_node_id,
                       pair<int, int> inserted_positions) {
  Node& inserted_node = node(inserted_node_id);
  Node& target_node = node(target_node_id);
  inserted_node.parent_id_ = target_node_id;
  if (inserted_positions.first % 2 == 0) {
    if (inserted_positions.second % 2 == 0) {
      inserted_node.left_child_id_ = target_node.left_child_id_;
    } else {
      inserted_node.right_child_id_ = target_node.left_child_id_;
    }
    if (target_node.left_child_id_ != -1) {
      node(target_node.left_child_id_).parent_id_ = inserted_node_id;
    }
    target_node.left_child_id_ = inserted_node_id;
  } else {
    if (inserted_positions.second % 2 == 0) {
      inserted_node.left_child_id_ = target_node.right_child_id_;
    } else {
      inserted_node.right_child_id_ = target_node.right_child_id_;
    }
    if (target_node.right_child_id_ != -1) {
      node(target_node.right_child_id_).parent_id_ = inserted_node_id;
    }
    target_node.right_child_id_ = inserted_node_id;
  }
}

// Assembly:
pushq %rax
movl %edx, %r8d
movslq %esi, %rax
movq 0x8(%rdi), %r9
movq 0x10(%rdi), %rdx
subq %r9, %rdx
sarq $0x4, %rdx
cmpq %rax, %rdx
jbe 0x74ed
movslq %r8d, %r8
cmpq %r8, %rdx
jbe 0x74f9
shlq $0x4, %rax
leaq (%r9,%rax), %r10
movq %r8, %rdi
shlq $0x4, %rdi
addq %r9, %rdi
movl %r8d, (%r9,%rax)
movq %rcx, %rax
shrq $0x20, %rax
andl $0x1, %eax
leaq 0x4(,%rax,4), %rax
testb $0x1, %cl
jne 0x74c6
leaq 0x4(%rdi), %rcx
movl 0x4(%rdi), %r8d
movl %r8d, (%r10,%rax)
movslq 0x4(%rdi), %rax
jmp 0x74d6
leaq 0x8(%rdi), %rcx
movl 0x8(%rdi), %r8d
movl %r8d, (%r10,%rax)
movslq 0x8(%rdi), %rax
cmpq $-0x1, %rax
je 0x74e9
cmpq %rax, %rdx
jbe 0x74ed
shlq $0x4, %rax
movl %esi, (%r9,%rax)
movl %esi, (%rcx)
popq %rax
retq
leaq 0x19b95(%rip), %rdi     # 0x21089
movq %rax, %rsi
jmp 0x7503
leaq 0x19b89(%rip), %rdi     # 0x21089
movq %r8, %rsi
xorl %eax, %eax
callq 0x6530