LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_cpp_makefile_star2_O3/attractivechaos[P]udb2/robin_hood/./robin_hood.h
// Function: robin_hood::detail::Table<true, 80ul, unsigned int, unsigned int, Hash32, std::equal_to<unsigned int>>::shiftUp(unsigned long, unsigned long)
void
    shiftUp(size_t startIdx,
            size_t const insertion_idx) noexcept(std::is_nothrow_move_assignable<Node>::value) {
        auto idx = startIdx;
        ::new (static_cast<void*>(mKeyVals + idx)) Node(std::move(mKeyVals[idx - 1]));
        while (--idx != insertion_idx) {
            mKeyVals[idx] = std::move(mKeyVals[idx - 1]);
        }

        idx = startIdx;
        while (idx != insertion_idx) {
            ROBIN_HOOD_COUNT(shiftUp)
            mInfo[idx] = static_cast<uint8_t>(mInfo[idx - 1] + mInfoInc);
            if (ROBIN_HOOD_UNLIKELY(mInfo[idx] + mInfoInc > 0xFF)) {
                mMaxNumElementsAllowed = 0;
            }
            --idx;
        }
    }

// Assembly:
movq 0x8(%rdi), %rax
movq -0x8(%rax,%rsi,8), %rcx
movq %rcx, (%rax,%rsi,8)
leaq -0x1(%rsi), %rax
cmpq %rdx, %rax
je 0x1aa9
movq 0x8(%rdi), %rcx
movq -0x8(%rcx,%rax,8), %r8
movq %r8, (%rcx,%rax,8)
decq %rax
cmpq %rax, %rdx
jne 0x1a94
cmpq %rdx, %rsi
jne 0x1aaf
retq
movq 0x10(%rdi), %rax
movl 0x30(%rdi), %ecx
addb -0x1(%rax,%rsi), %cl
movb %cl, (%rax,%rsi)
movq 0x10(%rdi), %rax
movzbl (%rax,%rsi), %r8d
movl 0x30(%rdi), %ecx
addl %ecx, %r8d
cmpl $0x100, %r8d            # imm = 0x100
jae 0x1adf
decq %rsi
cmpq %rsi, %rdx
jne 0x1ab6
jmp 0x1aae
movq $0x0, 0x28(%rdi)
jmp 0x1ad5
nop
// File: /workspace/github_cpp_makefile_star2_O3/attractivechaos[P]udb2/robin_hood/./robin_hood.h
// Function: robin_hood::detail::Table<true, 80ul, unsigned int, unsigned int, Hash32, std::equal_to<unsigned int>>::initData(unsigned long)
void initData(size_t max_elements) {
        mNumElements = 0;
        mMask = max_elements - 1;
        mMaxNumElementsAllowed = calcMaxNumElementsAllowed(max_elements);

        auto const numElementsWithBuffer = calcNumElementsWithBuffer(max_elements);

        // malloc & zero mInfo. Faster than calloc everything.
        auto const numBytesTotal = calcNumBytesTotal(numElementsWithBuffer);
        ROBIN_HOOD_LOG("std::calloc " << numBytesTotal << " = calcNumBytesTotal("
                                      << numElementsWithBuffer << ")")
        mKeyVals = reinterpret_cast<Node*>(
            detail::assertNotNull<std::bad_alloc>(std::malloc(numBytesTotal)));
        mInfo = reinterpret_cast<uint8_t*>(mKeyVals + numElementsWithBuffer);
        std::memset(mInfo, 0, numBytesTotal - numElementsWithBuffer * sizeof(Node));

        // set sentinel
        mInfo[numElementsWithBuffer] = 1;

        mInfoInc = InitialInfoInc;
        mInfoHashShift = InitialInfoHashShift;
    }

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rsi, %r14
movq %rdi, %rbx
movq $0x0, 0x18(%rdi)
leaq -0x1(%rsi), %rax
movq %rax, 0x20(%rdi)
movabsq $0x28f5c28f5c28f5c, %rax # imm = 0x28F5C28F5C28F5C
cmpq %rax, %rsi
ja 0x1b95
movq %r14, %rax
shlq $0x4, %rax
leaq (%rax,%rax,4), %rax
shrq $0x2, %rax
movabsq $0x28f5c28f5c28f5c3, %rcx # imm = 0x28F5C28F5C28F5C3
mulq %rcx
shrq $0x2, %rdx
movq %rdx, 0x28(%rbx)
movl $0xff, %r12d
cmpq %r12, %rdx
cmovbq %rdx, %r12
leaq (%r12,%r14), %r15
leaq (%r15,%r15,8), %rdi
addq $0x8, %rdi
callq 0x10c0
testq %rax, %rax
je 0x1bb7
leaq (%r12,%r14), %rdx
addq $0x8, %rdx
movq %rax, 0x8(%rbx)
leaq (%rax,%r15,8), %r14
movq %r14, 0x10(%rbx)
movq %r14, %rdi
xorl %esi, %esi
callq 0x1070
movb $0x1, (%r15,%r14)
movq $0x20, 0x30(%rbx)
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
movq %r14, %rax
shrq $0x2, %rax
movabsq $0x28f5c28f5c28f5c3, %rcx # imm = 0x28F5C28F5C28F5C3
mulq %rcx
shlq $0x2, %rdx
andq $-0x10, %rdx
leaq (%rdx,%rdx,4), %rdx
jmp 0x1b37
callq 0x1d89
// File: /workspace/github_cpp_makefile_star2_O3/attractivechaos[P]udb2/robin_hood/./robin_hood.h
// Function: robin_hood::detail::Table<true, 80ul, unsigned int, unsigned int, Hash32, std::equal_to<unsigned int>>::try_increase_info()
bool try_increase_info() {
        ROBIN_HOOD_LOG("mInfoInc=" << mInfoInc << ", numElements=" << mNumElements
                                   << ", maxNumElementsAllowed="
                                   << calcMaxNumElementsAllowed(mMask + 1))
        if (mInfoInc <= 2) {
            // need to be > 2 so that shift works (otherwise undefined behavior!)
            return false;
        }
        // we got space left, try to make info smaller
        mInfoInc = static_cast<uint8_t>(mInfoInc >> 1U);

        // remove one bit of the hash, leaving more space for the distance info.
        // This is extremely fast because we can operate on 8 bytes at once.
        ++mInfoHashShift;
        auto const numElementsWithBuffer = calcNumElementsWithBuffer(mMask + 1);

        for (size_t i = 0; i < numElementsWithBuffer; i += 8) {
            auto val = unaligned_load<uint64_t>(mInfo + i);
            val = (val >> 1U) & UINT64_C(0x7f7f7f7f7f7f7f7f);
            std::memcpy(mInfo + i, &val, sizeof(val));
        }
        // update sentinel, which might have been cleared out!
        mInfo[numElementsWithBuffer] = 1;

        mMaxNumElementsAllowed = calcMaxNumElementsAllowed(mMask + 1);
        return true;
    }

// Assembly:
movl 0x30(%rdi), %ecx
cmpl $0x3, %ecx
jb 0x1c6e
movabsq $0x28f5c28f5c28f5c, %r8 # imm = 0x28F5C28F5C28F5C
movl %ecx, %eax
shrl %eax
movzbl %al, %eax
movl %eax, 0x30(%rdi)
incl 0x34(%rdi)
movq 0x20(%rdi), %r9
incq %r9
movabsq $0x28f5c28f5c28f5c3, %rsi # imm = 0x28F5C28F5C28F5C3
movq %r9, %rax
cmpq %r8, %r9
ja 0x1c75
shlq $0x4, %rax
leaq (%rax,%rax,4), %rax
shrq $0x2, %rax
mulq %rsi
shrq $0x2, %rdx
movl $0xff, %eax
cmpq %rax, %rdx
cmovbq %rdx, %rax
addq %r9, %rax
je 0x1c43
xorl %edx, %edx
movabsq $0x7f7f7f7f7f7f7f7f, %r9 # imm = 0x7F7F7F7F7F7F7F7F
movq 0x10(%rdi), %r10
movq (%r10,%rdx), %r11
shrq %r11
andq %r9, %r11
movq %r11, (%r10,%rdx)
addq $0x8, %rdx
cmpq %rax, %rdx
jb 0x1c28
movq 0x10(%rdi), %rdx
movb $0x1, (%rdx,%rax)
movq 0x20(%rdi), %rax
incq %rax
cmpq %r8, %rax
ja 0x1c8a
shlq $0x4, %rax
leaq (%rax,%rax,4), %rax
shrq $0x2, %rax
mulq %rsi
shrq $0x2, %rdx
movq %rdx, 0x28(%rdi)
cmpl $0x3, %ecx
setae %al
retq
shrq $0x2, %rax
mulq %rsi
shlq $0x2, %rdx
andq $-0x10, %rdx
leaq (%rdx,%rdx,4), %rdx
jmp 0x1c0b
shrq $0x2, %rax
mulq %rsi
shlq $0x2, %rdx
andq $-0x10, %rdx
leaq (%rdx,%rdx,4), %rdx
jmp 0x1c6a
nop
// File: /workspace/github_cpp_makefile_star2_O3/attractivechaos[P]udb2/robin_hood/./robin_hood.h
// Function: robin_hood::detail::Table<true, 80ul, unsigned int, unsigned int, Hash32, std::equal_to<unsigned int>>::rehashPowerOfTwo(unsigned long, bool)
void rehashPowerOfTwo(size_t numBuckets, bool forceFree) {
        ROBIN_HOOD_TRACE(this)

        Node* const oldKeyVals = mKeyVals;
        uint8_t const* const oldInfo = mInfo;

        const size_t oldMaxElementsWithBuffer = calcNumElementsWithBuffer(mMask + 1);

        // resize operation: move stuff
        initData(numBuckets);
        if (oldMaxElementsWithBuffer > 1) {
            for (size_t i = 0; i < oldMaxElementsWithBuffer; ++i) {
                if (oldInfo[i] != 0) {
                    // might throw an exception, which is really bad since we are in the middle of
                    // moving stuff.
                    insert_move(std::move(oldKeyVals[i]));
                    // destroy the node but DON'T destroy the data.
                    oldKeyVals[i].~Node();
                }
            }

            // this check is not necessary as it's guarded by the previous if, but it helps
            // silence g++'s overeager "attempt to free a non-heap object 'map'
            // [-Werror=free-nonheap-object]" warning.
            if (oldKeyVals != reinterpret_cast_no_cast_align_warning<Node*>(&mMask)) {
                // don't destroy old data: put it into the pool instead
                if (forceFree) {
                    std::free(oldKeyVals);
                } else {
                    DataPool::addOrFree(oldKeyVals, calcNumBytesTotal(oldMaxElementsWithBuffer));
                }
            }
        }
    }

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rdi, %rbx
movq 0x20(%rdi), %rcx
incq %rcx
movabsq $0x28f5c28f5c28f5c, %rax # imm = 0x28F5C28F5C28F5C
cmpq %rax, %rcx
ja 0x1d64
movq %rcx, %rax
shlq $0x4, %rax
leaq (%rax,%rax,4), %rax
shrq $0x2, %rax
movabsq $0x28f5c28f5c28f5c3, %rdx # imm = 0x28F5C28F5C28F5C3
mulq %rdx
shrq $0x2, %rdx
movq 0x8(%rbx), %r14
movq 0x10(%rbx), %r12
movl $0xff, %r13d
cmpq %r13, %rdx
cmovbq %rdx, %r13
addq %rcx, %r13
movq %rbx, %rdi
callq 0x1aea
cmpq $0x2, %r13
jb 0x1d55
leaq 0x20(%rbx), %rax
movq %rax, (%rsp)
xorl %ebp, %ebp
movq %r14, %r15
cmpb $0x0, (%r12,%rbp)
je 0x1d2d
movq %rbx, %rdi
movq %r15, %rsi
callq 0x1db8
incq %rbp
addq $0x8, %r15
cmpq %rbp, %r13
jne 0x1d1b
cmpq (%rsp), %r14
je 0x1d55
movq %r14, %rdi
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x10a0
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rcx, %rax
shrq $0x2, %rax
movabsq $0x28f5c28f5c28f5c3, %rdx # imm = 0x28F5C28F5C28F5C3
mulq %rdx
shlq $0x2, %rdx
andq $-0x10, %rdx
leaq (%rdx,%rdx,4), %rdx
jmp 0x1ce8
// File: /workspace/github_cpp_makefile_star2_O3/attractivechaos[P]udb2/robin_hood/./robin_hood.h
// Function: robin_hood::detail::Table<true, 80ul, unsigned int, unsigned int, Hash32, std::equal_to<unsigned int>>::insert_move(robin_hood::detail::Table<true, 80ul, unsigned int, unsigned int, Hash32, std::equal_to<unsigned int>>::DataNode<robin_hood::detail::Table<true, 80ul, unsigned int, unsigned int, Hash32, std::equal_to<unsigned int>>, true>&&)
void insert_move(Node&& keyval) {
        // we don't retry, fail if overflowing
        // don't need to check max num elements
        if (0 == mMaxNumElementsAllowed && !try_increase_info()) {
            throwOverflowError();
        }

        size_t idx{};
        InfoType info{};
        keyToIdx(keyval.getFirst(), &idx, &info);

        // skip forward. Use <= because we are certain that the element is not there.
        while (info <= mInfo[idx]) {
            idx = idx + 1;
            info += mInfoInc;
        }

        // key not found, so we are now exactly where we want to insert it.
        auto const insertion_idx = idx;
        auto const insertion_info = static_cast<uint8_t>(info);
        if (ROBIN_HOOD_UNLIKELY(insertion_info + mInfoInc > 0xFF)) {
            mMaxNumElementsAllowed = 0;
        }

        // find an empty spot
        while (0 != mInfo[idx]) {
            next(&info, &idx);
        }

        auto& l = mKeyVals[insertion_idx];
        if (idx == insertion_idx) {
            ::new (static_cast<void*>(&l)) Node(std::move(keyval));
        } else {
            shiftUp(idx, insertion_idx);
            l = std::move(keyval);
        }

        // put at empty spot
        mInfo[insertion_idx] = insertion_info;

        ++mNumElements;
    }

// Assembly:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
movq %rsi, %r14
movq %rdi, %rbx
cmpq $0x0, 0x28(%rdi)
jne 0x1de2
movq %rbx, %rdi
callq 0x1bbc
testb %al, %al
jne 0x1de2
movq %rbx, %rdi
callq 0x1936
movl (%r14), %eax
imulq (%rbx), %rax
movq %rax, %r15
shrq $0x21, %r15
xorq %rax, %r15
movl %r15d, %r12d
andl $0x1f, %r12d
movb 0x34(%rbx), %cl
shrq %cl, %r12
movl 0x30(%rbx), %ecx
shrq $0x5, %r15
andq 0x20(%rbx), %r15
addl %ecx, %r12d
movq 0x10(%rbx), %rax
movzbl (%rax,%r15), %edx
cmpl %edx, %r12d
ja 0x1e2a
addl %ecx, %r12d
movzbl 0x1(%rax,%r15), %edx
incq %r15
jmp 0x1e17
movzbl %r12b, %edx
addl %ecx, %edx
cmpl $0x100, %edx            # imm = 0x100
jae 0x1e83
movl $0x1, %ecx
decq %rcx
cmpb $0x0, (%rax,%r15)
leaq 0x1(%rax), %rax
jne 0x1e3d
movq 0x8(%rbx), %r13
testq %rcx, %rcx
je 0x1e65
movq %r15, %rsi
subq %rcx, %rsi
movq %rbx, %rdi
movq %r15, %rdx
callq 0x1a7e
movq (%r14), %rax
movq %rax, (%r13,%r15,8)
movq 0x10(%rbx), %rax
movb %r12b, (%rax,%r15)
incq 0x18(%rbx)
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
movq $0x0, 0x28(%rbx)
jmp 0x1e38
nop
// File: /workspace/github_cpp_makefile_star2_O3/attractivechaos[P]udb2/robin_hood/./robin_hood.h
// Function: robin_hood::detail::Table<true, 80ul, unsigned int, unsigned int, Hash32, std::equal_to<unsigned int>>::shiftDown(unsigned long)
void shiftDown(size_t idx) noexcept(std::is_nothrow_move_assignable<Node>::value) {
        // until we find one that is either empty or has zero offset.
        // TODO(martinus) we don't need to move everything, just the last one for the same
        // bucket.
        mKeyVals[idx].destroy(*this);

        // until we find one that is either empty or has zero offset.
        while (mInfo[idx + 1] >= 2 * mInfoInc) {
            ROBIN_HOOD_COUNT(shiftDown)
            mInfo[idx] = static_cast<uint8_t>(mInfo[idx + 1] - mInfoInc);
            mKeyVals[idx] = std::move(mKeyVals[idx + 1]);
            ++idx;
        }

        mInfo[idx] = 0;
        // don't destroy, we've moved it
        // mKeyVals[idx].destroy(*this);
        mKeyVals[idx].~Node();
    }

// Assembly:
movq 0x10(%rdi), %rax
movzbl 0x1(%rsi,%rax), %ecx
movl 0x30(%rdi), %edx
leal (%rdx,%rdx), %r8d
cmpl %ecx, %r8d
ja 0x1eca
subb %dl, %cl
movb %cl, (%rax,%rsi)
movq 0x8(%rdi), %rax
movq 0x8(%rax,%rsi,8), %rcx
movq %rcx, (%rax,%rsi,8)
movq 0x10(%rdi), %rax
movzbl 0x2(%rax,%rsi), %ecx
movl 0x30(%rdi), %edx
leal (%rdx,%rdx), %r8d
incq %rsi
jmp 0x1e9e
movb $0x0, (%rax,%rsi)
retq
// File: /workspace/github_cpp_makefile_star2_O3/henrixh[P]shittydsa/examples/fenwick.cpp
// Function: main
int main(int, char **)
{
  ios_base::sync_with_stdio(false);
  cin.tie(NULL);
  ul size, ops;
  cin >> size >> ops;

  Fenwick fen {size};

  char op;
  ul index;
  l diff;
  for (ul i {0}; i < ops; ++i) {
    cin >> op;
    if (op == '+') {
      cin >> index >> diff;
      fen.add(index, diff);
    }

    if (op == '?') {
      cin >> index;
      cout << fen.sum(0, index) << "\n";
    }
  }
  return 0;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x48, %rsp
xorl %edi, %edi
callq 0x1040
movq 0x2d78(%rip), %rdi      # 0x3fe0
movq (%rdi), %rax
movq -0x18(%rax), %rax
movq $0x0, 0xd8(%rdi,%rax)
leaq 0x40(%rsp), %rbx
movq %rbx, %rsi
callq 0x1060
leaq 0x38(%rsp), %r14
movq %rax, %rdi
movq %r14, %rsi
callq 0x1060
movq (%rbx), %rsi
leaq 0x18(%rsp), %rdi
callq 0x13d2
cmpq $0x0, (%r14)
je 0x1388
xorl %r12d, %r12d
movq 0x2d27(%rip), %rbx      # 0x3fe0
leaq 0xf(%rsp), %r14
leaq 0x10(%rsp), %r15
movq 0x2d06(%rip), %r13      # 0x3fd0
leaq 0xd5f(%rip), %rbp       # 0x2030
movq %rbx, %rdi
movq %r14, %rsi
callq 0x10e0
movb 0xf(%rsp), %al
cmpb $0x2b, %al
jne 0x1330
movq %rbx, %rdi
movq %r15, %rsi
callq 0x1060
movq %rax, %rdi
leaq 0x30(%rsp), %rsi
callq 0x10c0
movq 0x10(%rsp), %rax
movq 0x18(%rsp), %rcx
movq 0x20(%rsp), %rdx
subq %rcx, %rdx
sarq $0x3, %rdx
cmpq %rax, %rdx
jbe 0x132c
movq 0x30(%rsp), %rsi
addq %rsi, (%rcx,%rax,8)
leaq 0x1(%rax), %rdi
orq %rdi, %rax
cmpq %rdx, %rax
jb 0x131c
movb 0xf(%rsp), %al
cmpb $0x3f, %al
jne 0x137a
movq %rbx, %rdi
movq %r15, %rsi
callq 0x1060
movq 0x10(%rsp), %rax
testq %rax, %rax
je 0x1360
movq 0x18(%rsp), %rcx
xorl %esi, %esi
addq -0x8(%rcx,%rax,8), %rsi
leaq -0x1(%rax), %rdx
andq %rdx, %rax
jne 0x1350
jmp 0x1362
xorl %esi, %esi
movq %r13, %rdi
callq 0x1090
movl $0x1, %edx
movq %rax, %rdi
movq %rbp, %rsi
callq 0x10d0
incq %r12
cmpq 0x38(%rsp), %r12
jb 0x12d1
movq 0x18(%rsp), %rdi
testq %rdi, %rdi
je 0x139f
movq 0x28(%rsp), %rsi
subq %rdi, %rsi
callq 0x10b0
xorl %eax, %eax
addq $0x48, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
movq 0x18(%rsp), %rdi
testq %rdi, %rdi
je 0x13ca
movq 0x28(%rsp), %rsi
subq %rdi, %rsi
callq 0x10b0
movq %rbx, %rdi
callq 0x1100
// File: /workspace/github_cpp_makefile_star2_O3/roberty65[P]bServer/frame/testServer/src/main.cpp
// Function: main
int main(int argc, char **argv)
{
	SYSLOG_INIT("../logs/server.log", LOG_LEVEL_DEBUG, 1048576, 10);	
	
	beyondy::Async::Queue<beyondy::Async::Message> *inQ = new beyondy::Async::Queue<beyondy::Async::Message>(1024);
	beyondy::Async::Queue<beyondy::Async::Message> *outQ = new beyondy::Async::Queue<beyondy::Async::Message>(2048);

	beyondy::Async::Processor *processor = new Echo();
	processor->setSendFunc(async_send_delegator, outQ);
	int retval = processor->onInit();

	beyondy::Async::MtWorker *mtWorker = new beyondy::Async::MtWorker(inQ, processor, 10);
	mtWorker->start();

	beyondy::Async::EventManager *emgr = new beyondy::Async::EventManager(outQ, 1024);

	retval = emgr->addListener("tcp://0.0.0.0:5010", inQ, processor, 100);
	if (retval < 0) {
		SYSLOG_ERROR("addListener failed");
		return 1;
	}
/*
	int cid = emgr->addConnector("inet@localhost:5010/tcp", inQ, processor, 1);
	if (cid < 0) {
		SYSLOG_ERROR("addConnector failed");
		return 2;
	}
**/
	emgr->start();

	// nothing
	processor->onExit();

	return 0;
}

// Assembly:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
movl $0x218, %edi            # imm = 0x218
callq 0x2250
movq %rax, %rbx
leaq 0x4a45(%rip), %rsi      # 0x7004
movl $0x100000, %ecx         # imm = 0x100000
movl $0xa, %r8d
movq %rax, %rdi
movl $0x5, %edx
callq 0x5594
leaq 0x9caa(%rip), %r13      # 0xc288
movq %rbx, (%r13)
movl $0xb0, %edi
callq 0x2250
movq %rax, %rbx
movl $0x400, %esi            # imm = 0x400
movq %rax, %rdi
callq 0x2740
movl $0xb0, %edi
callq 0x2250
movq %rax, %r15
movl $0x800, %esi            # imm = 0x800
movq %rax, %rdi
callq 0x2740
movl $0x30, %edi
callq 0x2250
movq %rax, %r14
leaq 0x95ce(%rip), %rax      # 0xbbf8
leaq 0x10(%rax), %rcx
movq %rcx, (%r14)
movl $0x77359400, %ecx       # imm = 0x77359400
movq %rcx, 0x18(%r14)
movq %rcx, 0x20(%r14)
leaq 0x15b7(%rip), %rcx      # 0x3bfc
movq %rcx, 0x8(%r14)
movq %r15, 0x10(%r14)
movq %r14, %rdi
callq *0x30(%rax)
movl $0x20, %edi
callq 0x2250
movq %rax, %r12
movq %rax, %rdi
movq %rbx, %rsi
movq %r14, %rdx
movl $0xa, %ecx
callq 0x3a28
movq %r12, %rdi
callq 0x3b52
movl $0x70, %edi
callq 0x2250
movq %rax, %r12
movq %rax, %rdi
movq %r15, %rsi
movl $0x400, %edx            # imm = 0x400
callq 0x2dc8
leaq 0x4978(%rip), %rsi      # 0x7017
movq %r12, %rdi
movq %rbx, %rdx
movq %r14, %rcx
movl $0x64, %r8d
callq 0x2f58
testl %eax, %eax
js 0x26cc
movq %r12, %rdi
callq 0x392e
movq (%r14), %rax
movq %r14, %rdi
callq *0x28(%rax)
xorl %ebx, %ebx
jmp 0x26ed
movq (%r13), %rdi
movl $0x1, %ebx
cmpl $0x2, (%rdi)
jl 0x26ed
leaq 0x4949(%rip), %rdx      # 0x702a
movl $0x2, %esi
xorl %eax, %eax
callq 0x55c0
movl %ebx, %eax
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
movq %rax, %r14
movl $0x70, %esi
jmp 0x270b
movq %rax, %r14
movl $0x20, %esi
movq %r12, %rdi
jmp 0x2732
movq %rax, %r14
movl $0xb0, %esi
movq %r15, %rdi
jmp 0x2732
movq %rax, %r14
movl $0xb0, %esi
jmp 0x272f
movq %rax, %r14
movl $0x218, %esi            # imm = 0x218
movq %rbx, %rdi
callq 0x2260
movq %r14, %rdi
callq 0x2400
nop
// File: /workspace/github_cpp_makefile_star2_O3/roberty65[P]bServer/frame/testServer/src/../../../serverd/src/Echo.cpp
// Function: Echo::onInit()
int Echo::onInit()
{
	maxInputSize = 50 * 1024 * 1024;
	maxOutputSize = 50 * 1024 * 1024;

	dstFlow = getConnector("dst");
	// TODO: use more general log
	// after compile the frame with -rdynamic, lib can use tis symbols
	// SYSLOG_INIT("../logs/business.log", LOG_LEVEL_DEBUG, 10*1024*1024, 10);
	return 0;
}

// Assembly:
pushq %rbx
movq %rdi, %rbx
movl $0x3200000, %eax        # imm = 0x3200000
movq %rax, 0x18(%rdi)
movq %rax, 0x20(%rdi)
leaq 0x472a(%rip), %rdi      # 0x705e
callq 0x259c
movl %eax, 0x28(%rbx)
xorl %eax, %eax
popq %rbx
retq
// File: /workspace/github_cpp_makefile_star2_O3/roberty65[P]bServer/frame/testServer/src/../../../serverd/src/Echo.cpp
// Function: Echo::doEcho(beyondy::Async::Message*)
int Echo::doEcho(Message *req)
{
	int takenMs = 0;
	if (req->getWptr() >= (long)(sizeof(struct proto_h16_head) + sizeof(int))) {
		takenMs = *((int *)(req->data() + sizeof(struct proto_h16_head)));	
	}

	SYSLOG_DEBUG("Echo took %dms", takenMs);
	if (takenMs > 0) usleep((long)takenMs*1000);

	Message *rsp = Message::create(req->getWptr(), req->fd, req->flow);
	memcpy(rsp->data(), req->data(), req->getWptr());

	struct proto_h16_head *h = (struct proto_h16_head *)rsp->data();
	h->cmd = h->cmd + 1;

	/* set response size */
	rsp->setWptr(req->getWptr());

	Message::destroy(req);
	if (sendMessage(rsp) < 0) {
		Message::destroy(rsp);
		return -1;
	}

	return 0;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %r14
movq %rdi, %rbx
xorl %ebp, %ebp
cmpq $0x14, 0x10(%rsi)
jl 0x295e
movq (%r14), %rax
movl 0x10(%rax), %ebp
leaq 0x9923(%rip), %rax      # 0xc288
movq (%rax), %rdi
cmpl $0x5, (%rdi)
jl 0x2982
leaq 0x46ee(%rip), %rdx      # 0x7062
movl $0x5, %esi
movl %ebp, %ecx
xorl %eax, %eax
callq 0x55c0
testl %ebp, %ebp
jle 0x2991
imull $0x3e8, %ebp, %edi      # imm = 0x3E8
callq 0x2320
movq 0x10(%r14), %rdi
movl 0x24(%r14), %esi
movl 0x28(%r14), %edx
callq 0x5848
movq %rax, %r15
movq (%rax), %rdi
movq (%r14), %rsi
movq 0x10(%r14), %rdx
callq 0x2200
movq (%r15), %rax
incw 0x4(%rax)
movq 0x10(%r14), %rax
movq %rax, 0x10(%r15)
movq %r14, %rdi
callq 0x58b0
movq 0x8(%rbx), %rax
testq %rax, %rax
je 0x29e5
movq 0x10(%rbx), %rsi
movq %r15, %rdi
callq *%rax
movl %eax, %ecx
xorl %eax, %eax
testl %ecx, %ecx
jns 0x29f2
movq %r15, %rdi
callq 0x58b0
movl $0xffffffff, %eax       # imm = 0xFFFFFFFF
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O3/roberty65[P]bServer/frame/testServer/src/../../../serverd/src/Echo.cpp
// Function: Echo::doMore(beyondy::Async::Message*)
int Echo::doMore(Message *req)
{
	int takenMs = 0;
	if (req->getWptr() >= (long)(sizeof(struct proto_h16_head) + sizeof(int))) {
		takenMs = *((int *)(req->data() + sizeof(struct proto_h16_head)));	
	}

	SYSLOG_DEBUG("More took %dms", takenMs);
	if (takenMs > 0) usleep((long)takenMs*1000);

	Message *rsp = Message::create(req->getWptr(), req->fd, req->flow);
	memcpy(rsp->data(), req->data(), req->getWptr());

	struct proto_h16_head *h = (struct proto_h16_head *)rsp->data();
	h->cmd = ECHO_CMD_MORE_RSP;

	/* set response size */
	rsp->setWptr(req->getWptr());

	Message::destroy(req);
	if (sendMessage(rsp) < 0) {
		Message::destroy(rsp);
		return -1;
	}

	return 0;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %r14
movq %rdi, %rbx
xorl %ebp, %ebp
cmpq $0x14, 0x10(%rsi)
jl 0x2b74
movq (%r14), %rax
movl 0x10(%rax), %ebp
leaq 0x970d(%rip), %rax      # 0xc288
movq (%rax), %rdi
cmpl $0x5, (%rdi)
jl 0x2b98
leaq 0x4573(%rip), %rdx      # 0x70fd
movl $0x5, %esi
movl %ebp, %ecx
xorl %eax, %eax
callq 0x55c0
testl %ebp, %ebp
jle 0x2ba7
imull $0x3e8, %ebp, %edi      # imm = 0x3E8
callq 0x2320
movq 0x10(%r14), %rdi
movl 0x24(%r14), %esi
movl 0x28(%r14), %edx
callq 0x5848
movq %rax, %r15
movq (%rax), %rdi
movq (%r14), %rsi
movq 0x10(%r14), %rdx
callq 0x2200
movq (%r15), %rax
movw $0x5, 0x4(%rax)
movq 0x10(%r14), %rax
movq %rax, 0x10(%r15)
movq %r14, %rdi
callq 0x58b0
movq 0x8(%rbx), %rax
testq %rax, %rax
je 0x2bfd
movq 0x10(%rbx), %rsi
movq %r15, %rdi
callq *%rax
movl %eax, %ecx
xorl %eax, %eax
testl %ecx, %ecx
jns 0x2c0a
movq %r15, %rdi
callq 0x58b0
movl $0xffffffff, %eax       # imm = 0xFFFFFFFF
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O3/roberty65[P]bServer/frame/testServer/src/../../../serverd/src/Echo.cpp
// Function: Echo::onMessage(beyondy::Async::Message*)
int Echo::onMessage(beyondy::Async::Message *req)
{
	SYSLOG_DEBUG("Echo got a message from fd=%d flow=%d msize=%d, byte0=%ld,%d, enQ=%ld,%d, deQ=%ld,%ld", \
		req->fd, req->flow, req->getWptr(),
		req->ts_byte_first.tv_sec, req->ts_byte_first.tv_usec,
		req->ts_enqueue.tv_sec, req->ts_enqueue.tv_usec,
		req->ts_dequeue.tv_sec, req->ts_dequeue.tv_usec);
	struct proto_h16_head *h = (struct proto_h16_head *)req->data();
	int retval = 0;

	if (h->cmd == ECHO_CMD_ECHO_REQ) {
		retval = doEcho(req);
	}
	else if (h->cmd == ECHO_CMD_FORWARD_REQ || h->cmd == ECHO_CMD_MORE_RSP) {
		retval = doForward(req);
	}
	else if (h->cmd == ECHO_CMD_MORE_REQ) {
		retval = doMore(req);
	}
	else {
		SYSLOG_DEBUG("Echo uknown cmd=%d", h->cmd);
	}

	return retval;
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
subq $0x30, %rsp
movq %rsi, %rbx
movq %rdi, %r14
leaq 0x965c(%rip), %r15      # 0xc288
movq (%r15), %rdi
cmpl $0x5, (%rdi)
jl 0x2c6c
movl 0x24(%rbx), %ecx
movl 0x28(%rbx), %r8d
movq 0x10(%rbx), %r9
movups 0x30(%rbx), %xmm0
movups 0x40(%rbx), %xmm1
movups 0x50(%rbx), %xmm2
movups %xmm2, 0x20(%rsp)
movups %xmm1, 0x10(%rsp)
movups %xmm0, (%rsp)
leaq 0x44ac(%rip), %rdx      # 0x710c
movl $0x5, %esi
xorl %eax, %eax
callq 0x55c0
movq (%rbx), %rax
movzwl 0x4(%rax), %ecx
cmpq $0x5, %rcx
ja 0x2cc5
leaq 0x43c0(%rip), %rax      # 0x7040
movslq (%rax,%rcx,4), %rdx
addq %rax, %rdx
jmpq *%rdx
movq %r14, %rdi
movq %rbx, %rsi
addq $0x30, %rsp
popq %rbx
popq %r14
popq %r15
jmp 0x29fe
movq %r14, %rdi
movq %rbx, %rsi
addq $0x30, %rsp
popq %rbx
popq %r14
popq %r15
jmp 0x2942
movq %r14, %rdi
movq %rbx, %rsi
addq $0x30, %rsp
popq %rbx
popq %r14
popq %r15
jmp 0x2b58
movq (%r15), %rdi
cmpl $0x5, (%rdi)
jl 0x2ce0
leaq 0x448e(%rip), %rdx      # 0x7162
movl $0x5, %esi
xorl %eax, %eax
callq 0x55c0
xorl %eax, %eax
addq $0x30, %rsp
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_cpp_makefile_star2_O3/roberty65[P]bServer/frame/testServer/src/../../../serverd/src/Echo.cpp
// Function: Echo::onSent(beyondy::Async::Message*, int)
int Echo::onSent(Message *msg, int status)
{
	SYSLOG_DEBUG("Echo message from fd=%d flow=%d msize=%d sent status=%d, enQ=%ld,%ld, deQ=%ld,%ld, byte0=%ld,%ld, sent=%ld,%ld", \
		msg->fd, msg->flow, msg->getWptr(), status,
		msg->ts_enqueue.tv_sec, msg->ts_enqueue.tv_usec,
		msg->ts_dequeue.tv_sec, msg->ts_dequeue.tv_usec,
		msg->ts_byte_first.tv_sec, msg->ts_byte_first.tv_usec,
		msg->ts_process_end.tv_sec, msg->ts_process_end.tv_usec);
	Message::destroy(msg);
	return 0;
}

// Assembly:
pushq %rbx
subq $0x50, %rsp
movq %rsi, %rbx
leaq 0x958d(%rip), %rax      # 0xc288
movq (%rax), %rdi
cmpl $0x5, (%rdi)
jl 0x2d48
movl 0x24(%rbx), %ecx
movl 0x28(%rbx), %r8d
movq 0x10(%rbx), %r9
movups 0x40(%rbx), %xmm0
movups 0x50(%rbx), %xmm1
movups 0x30(%rbx), %xmm2
movups 0x60(%rbx), %xmm3
movups %xmm3, 0x38(%rsp)
movups %xmm2, 0x28(%rsp)
movups %xmm1, 0x18(%rsp)
movups %xmm0, 0x8(%rsp)
movl %edx, (%rsp)
leaq 0x4439(%rip), %rdx      # 0x7175
movl $0x5, %esi
xorl %eax, %eax
callq 0x55c0
movq %rbx, %rdi
callq 0x58b0
xorl %eax, %eax
addq $0x50, %rsp
popq %rbx
retq
// File: /workspace/github_cpp_makefile_star2_O3/sun98[P]Mini-DFS/datanode.cpp
// Function: DataServer::operator()()
void DataServer::operator()()
{
    while (true)
    {
        std::unique_lock<std::mutex> lk(mtx);
        cv.wait(lk, [&]() { return !this->finish; });
        if (cmd == "up")
        {
            size_ += bufSize / 1024.0 / 1024.0;
            put();
        }
        else if (cmd == "down")
            read();
        else if (cmd == "loc")
            locate();
        else if (cmd == "down_id")
            fetch();
        this->finish = true;
        lk.unlock();
        cv.notify_all();
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %rdi, %rbx
leaq 0x28(%rdi), %r13
leaq 0x50(%rdi), %r14
leaq 0x80(%rdi), %r15
leaq -0x38(%rbp), %r12
movq %r13, -0x38(%rbp)
movb $0x0, -0x30(%rbp)
movq %r12, %rdi
callq 0x5078
movb $0x1, -0x30(%rbp)
cmpb $0x1, 0xb8(%rbx)
jne 0x389e
movq %r14, %rdi
movq %r12, %rsi
callq 0x30f0
cmpb $0x0, 0xb8(%rbx)
jne 0x388a
movq %r15, %rdi
leaq 0x5772(%rip), %rsi      # 0x901a
callq 0x30e0
testl %eax, %eax
je 0x38f4
movq %r15, %rdi
leaq 0x5762(%rip), %rsi      # 0x901d
callq 0x30e0
testl %eax, %eax
je 0x3923
movq %r15, %rdi
leaq 0x5754(%rip), %rsi      # 0x9022
callq 0x30e0
testl %eax, %eax
je 0x392d
movq %r15, %rdi
leaq 0x5745(%rip), %rsi      # 0x9026
callq 0x30e0
testl %eax, %eax
jne 0x3935
movq %rbx, %rdi
callq 0x493c
jmp 0x3935
xorps %xmm0, %xmm0
cvtsi2sdl 0xa4(%rbx), %xmm0
movsd 0x5701(%rip), %xmm1     # 0x9008
mulsd %xmm1, %xmm0
mulsd %xmm1, %xmm0
addsd 0x20(%rbx), %xmm0
movsd %xmm0, 0x20(%rbx)
movq %rbx, %rdi
callq 0x396e
jmp 0x3935
movq %rbx, %rdi
callq 0x3f42
jmp 0x3935
movq %rbx, %rdi
callq 0x44ac
movb $0x1, 0xb8(%rbx)
movq %r12, %rdi
callq 0x4f0e
movq %r14, %rdi
callq 0x3460
movq %r12, %rdi
callq 0x4f40
jmp 0x386d
movq %rax, %rbx
leaq -0x38(%rbp), %rdi
callq 0x4f40
movq %rbx, %rdi
callq 0x34a0
nop
// File: /workspace/github_cpp_makefile_star2_O3/sun98[P]Mini-DFS/filetree.cpp
// Function: FileTree::insert_node(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&, bool)
bool FileTree::insert_node(const std::string &path, const bool isFile)
{
    TreeNode *parent = nullptr;
    bool isFound = find_node(path, &parent);
    if (isFound)
        return false;

    std::vector<std::string> path_folders = split(path, '/');
    TreeNode *newNode = new TreeNode(path, isFile);
    newNode->parent = parent;
    TreeNode *son = parent->firstSon;
    if (!son)
        parent->firstSon = newNode;
    else
    {
        while (son->nextSibling)
            son = son->nextSibling;
        son->nextSibling = newNode;
    }
    while (son)
        son = son->nextSibling;
    son = newNode;
    return true;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x30, %rsp
movl %edx, %r15d
movq %rsi, %r12
leaq -0x30(%rbp), %rdx
movq $0x0, (%rdx)
callq 0x5246
movl %eax, %ebx
testb %al, %al
jne 0x5213
leaq -0x21(%rbp), %rdx
movb $0x2f, (%rdx)
leaq -0x48(%rbp), %rdi
movq %r12, %rsi
callq 0x5910
movl $0x40, %edi
callq 0x3290
movq %rax, %r14
addq $0x10, %rax
movq %rax, (%r14)
movq (%r12), %rsi
movq 0x8(%r12), %rdx
addq %rsi, %rdx
movq %r14, %rdi
callq 0x4fda
movb %r15b, 0x20(%r14)
xorps %xmm0, %xmm0
movups %xmm0, 0x30(%r14)
movq -0x30(%rbp), %rax
movq %rax, 0x28(%r14)
movq 0x30(%rax), %rcx
testq %rcx, %rcx
je 0x5203
movq %rcx, %rax
movq 0x38(%rcx), %rcx
testq %rcx, %rcx
jne 0x51f1
addq $0x38, %rax
jmp 0x5207
addq $0x30, %rax
movq %r14, (%rax)
leaq -0x48(%rbp), %rdi
callq 0x53f6
xorb $0x1, %bl
movl %ebx, %eax
addq $0x30, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
movq %r14, %rdi
callq 0x3270
jmp 0x5235
movq %rax, %rbx
leaq -0x48(%rbp), %rdi
callq 0x53f6
movq %rbx, %rdi
callq 0x34a0
// File: /workspace/github_cpp_makefile_star2_O3/sun98[P]Mini-DFS/filetree.cpp
// Function: FileTree::find_node(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&, TreeNode**) const
bool FileTree::find_node(const std::string &path, TreeNode **last_node) const
{
    std::vector<std::string> path_folders = split(path, '/');
    TreeNode *node = _root->firstSon;
    *last_node = _root;
    for (const auto &name : path_folders)
    {
        while (node && node->value_ != name)
            node = node->nextSibling;
        if (!node)
            return false;
        *last_node = node;
        node = node->firstSon;
    }
    return true && node->isFile;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x28, %rsp
movq %rdx, %rbx
movq %rdi, %r14
leaq -0x29(%rbp), %rdx
movb $0x2f, (%rdx)
leaq -0x48(%rbp), %r15
movq %r15, %rdi
callq 0x5910
movq (%r14), %rax
movq 0x30(%rax), %r12
movq %rax, (%rbx)
movq (%r15), %r13
movq 0x8(%r15), %r15
cmpq %r15, %r13
je 0x52cd
testq %r12, %r12
je 0x52c9
movq 0x8(%r13), %r14
cmpq %r14, 0x8(%r12)
jne 0x52af
testq %r14, %r14
je 0x52bb
movq (%r13), %rsi
movq (%r12), %rdi
movq %r14, %rdx
callq 0x32a0
testl %eax, %eax
je 0x52bb
movq 0x38(%r12), %r12
testq %r12, %r12
jne 0x528f
jmp 0x52c9
movq %r12, (%rbx)
movq 0x30(%r12), %r12
addq $0x20, %r13
jmp 0x5281
xorl %ebx, %ebx
jmp 0x52d2
movb 0x20(%r12), %bl
leaq -0x48(%rbp), %rdi
callq 0x53f6
movl %ebx, %eax
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O3/sun98[P]Mini-DFS/filetree.cpp
// Function: FileTree::list(TreeNode*, std::map<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, std::pair<int, int>, std::less<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>, std::allocator<std::pair<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const, std::pair<int, int>>>>&)
void FileTree::list(TreeNode *node, std::map<std::string, std::pair<int, int>> &meta)
{
    static int chunkSize = 2 * 1024 * 1024;
    if (node)
    {
        std::cout << meta[node->value_].first << "\t" << (int)ceil(1.0 * meta[node->value_].second / chunkSize) << "\t\t" << node->value_ << std::endl;
        // std::cout << node->value_ << "\t" << std::endl;
        list(node->firstSon, meta);
        list(node->nextSibling, meta);
    }
}

// Assembly:
testq %rsi, %rsi
je 0x53e5
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rdx, %rbx
movq %rsi, %r14
movq %rdi, %r15
leaq 0x3e55(%rip), %r12      # 0x9168
movq %rbx, %rdi
movq %r14, %rsi
callq 0x544e
movl (%rax), %esi
movq 0x6ca1(%rip), %rdi      # 0xbfc8
callq 0x3470
movq %rax, %r13
movl $0x1, %edx
movq %rax, %rdi
leaq 0x3e2b(%rip), %rsi      # 0x9169
callq 0x32e0
movq %rbx, %rdi
movq %r14, %rsi
callq 0x544e
xorps %xmm0, %xmm0
cvtsi2sdl 0x4(%rax), %xmm0
mulsd 0x3e02(%rip), %xmm0     # 0x9160
callq 0x3090
cvttsd2si %xmm0, %esi
movq %r13, %rdi
callq 0x3470
movq %rax, %r13
movl $0x2, %edx
movq %rax, %rdi
movq %r12, %rsi
callq 0x32e0
movq (%r14), %rsi
movq 0x8(%r14), %rdx
movq %r13, %rdi
callq 0x32e0
movq %rax, %r13
movq (%rax), %rax
movq -0x18(%rax), %rdi
addq %r13, %rdi
movl $0xa, %esi
callq 0x3280
movsbl %al, %esi
movq %r13, %rdi
callq 0x3040
movq %rax, %rdi
callq 0x31b0
movq 0x30(%r14), %rsi
movq %r15, %rdi
movq %rbx, %rdx
callq 0x52ec
movq 0x38(%r14), %r14
testq %r14, %r14
jne 0x5313
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O3/sun98[P]Mini-DFS/md5.cpp
// Function: split(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&, char const&)
std::vector<std::string> split(const std::string &s, const char &delim)
{
  std::stringstream ss(s);
  std::vector<std::string> res;
  std::string str;
  while (std::getline(ss, str, delim))
    if (!str.empty())
      res.push_back(str);
  return res;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x1a8, %rsp            # imm = 0x1A8
movq %rdx, %r14
movq %rdi, %rbx
leaq -0x1d0(%rbp), %r15
movq %r15, %rdi
movl $0x18, %edx
callq 0x3410
xorl %eax, %eax
movq %rax, 0x10(%rbx)
xorps %xmm0, %xmm0
movups %xmm0, (%rbx)
leaq -0x38(%rbp), %r13
movq %r13, -0x10(%r13)
movq %rax, -0x8(%r13)
movb $0x0, (%r13)
leaq -0x48(%rbp), %r12
movsbl (%r14), %edx
movq %r15, %rdi
movq %r12, %rsi
callq 0x34d0
movq (%rax), %rcx
movq -0x18(%rcx), %rcx
testb $0x5, 0x20(%rax,%rcx)
jne 0x5990
cmpq $0x0, -0x40(%rbp)
je 0x595f
movq %rbx, %rdi
movq %r12, %rsi
callq 0x6448
jmp 0x595f
movq -0x48(%rbp), %rdi
cmpq %r13, %rdi
je 0x599e
callq 0x3270
movq 0x6603(%rip), %rsi      # 0xbfa8
leaq -0x1d0(%rbp), %rdi
callq 0x31e0
leaq -0x150(%rbp), %rdi
callq 0x3110
movq %rbx, %rax
addq $0x1a8, %rsp            # imm = 0x1A8
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %r14
movq -0x48(%rbp), %rdi
cmpq %r13, %rdi
je 0x59e3
callq 0x3270
movq %rbx, %rdi
callq 0x53f6
movq 0x65b6(%rip), %rsi      # 0xbfa8
leaq -0x1d0(%rbp), %rdi
callq 0x31e0
leaq -0x150(%rbp), %rdi
callq 0x3110
movq %r14, %rdi
callq 0x34a0
// File: /workspace/github_cpp_makefile_star2_O3/sun98[P]Mini-DFS/md5.cpp
// Function: MD5::update(unsigned char const*, unsigned long)
MD5 &MD5::update(const unsigned char *input, size_t inputLen)
{
  // compute number of bytes mod 64
  size_t index = (uint32_t)((lo >> 3) & 0x3F);

  // update the message length
  if ((lo += ((uint32_t)inputLen << 3)) < ((uint32_t)inputLen << 3))
    hi++;
  hi += ((uint32_t)inputLen >> 29);

  size_t partLen = 64 - index;

  // update the states using the new message
  size_t i;
  if (inputLen >= partLen)
  {
    memcpy(&buffer[index], input, partLen);
    transform(buffer);

    for (i = partLen; i + BLOCK_SIZE <= inputLen; i += BLOCK_SIZE)
    {
      transform(&input[i]);
    }

    index = 0;
  }
  else
  {
    i = 0;
  }

  // buffer the remainder
  memcpy(&buffer[index], &input[i], inputLen - i);

  return *this;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rdx, %r14
movq %rdi, %rbx
movl 0x60(%rdi), %eax
movl %eax, %r13d
shrl $0x3, %r13d
andl $0x3f, %r13d
leal (,%rdx,8), %ecx
shrl $0x1d, %edx
addl %eax, %ecx
movl %ecx, 0x60(%rdi)
adcl %edx, 0x64(%rdi)
movq %rsi, %r12
movl $0x40, %r15d
subq %r13, %r15
cmpq %r14, %r15
jbe 0x5a98
xorl %r15d, %r15d
jmp 0x5ade
leaq (%rbx,%r13), %rdi
movq %r12, %rsi
movq %r15, %rdx
callq 0x3210
movq %rbx, %rdi
movq %rbx, %rsi
callq 0x5b08
movl $0x80, %eax
subq %r13, %rax
cmpq %r14, %rax
ja 0x5adb
movq %r15, %r13
leaq (%r12,%r15), %rsi
movq %rbx, %rdi
callq 0x5b08
addq $0x40, %r15
subq $-0x80, %r13
cmpq %r14, %r13
jbe 0x5abf
xorl %r13d, %r13d
addq %rbx, %r13
addq %r15, %r12
subq %r15, %r14
movq %r13, %rdi
movq %r12, %rsi
movq %r14, %rdx
callq 0x3210
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O3/sun98[P]Mini-DFS/md5.cpp
// Function: MD5::finalize()
MD5 &MD5::finalize()
{
  static uint8_t PADDING[64] = {0};
  PADDING[0] = 0x80;

  if (!finalized)
  {
    // save the length
    uint8_t bits[8];
    memcpy(bits, &lo, 4);
    memcpy(bits + 4, &hi, 4);

    // pad the 1 bit and zeroes
    size_t index = (uint32_t)((lo >> 3) & 0x3f);
    size_t padLen = (index < 56) ? (56 - index) : (120 - index);
    update(PADDING, padLen);

    // append length
    update(bits, 8);

    // store the state
    memcpy(digest, state, 16);

    // wipe out sensitive data
    memset(buffer, 0, sizeof buffer);
    hi = lo = 0;

    finalized = true;
  }

  return *this;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
subq $0x10, %rsp
movq %rdi, %rbx
movb $-0x80, 0x5fff(%rip)    # 0xc2c0
cmpb $0x0, 0x68(%rdi)
jne 0x6335
movl 0x60(%rbx), %eax
leaq -0x18(%rbp), %r14
movl %eax, (%r14)
movl 0x64(%rbx), %ecx
movl %ecx, 0x4(%r14)
shrl $0x3, %eax
andl $0x3f, %eax
xorl %edx, %edx
cmpl $0x38, %eax
setae %dl
shll $0x6, %edx
orq $0x38, %rdx
subq %rax, %rdx
leaq 0x5fc9(%rip), %rsi      # 0xc2c0
movq %rbx, %rdi
callq 0x5a4e
movl $0x8, %edx
movq %rbx, %rdi
movq %r14, %rsi
callq 0x5a4e
movups 0x50(%rbx), %xmm0
movups %xmm0, 0x40(%rbx)
xorps %xmm0, %xmm0
movups %xmm0, (%rbx)
movups %xmm0, 0x10(%rbx)
movups %xmm0, 0x20(%rbx)
movups %xmm0, 0x30(%rbx)
movq $0x0, 0x60(%rbx)
movb $0x1, 0x68(%rbx)
movq %rbx, %rax
addq $0x10, %rsp
popq %rbx
popq %r14
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O3/sun98[P]Mini-DFS/md5.cpp
// Function: MD5::toString[abi:cxx11]() const
string MD5::toString() const
{
  if (!finalized)
    return string("");

  char result[33] = {0};
  for (int i = 0; i < 16; ++i)
    sprintf(result + i * 2, "%02x", digest[i]);

  return string(result);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x28, %rsp
movq %rdi, %rbx
cmpb $0x0, 0x68(%rsi)
je 0x63c1
movq %rsi, %r14
xorps %xmm0, %xmm0
leaq -0x50(%rbp), %r15
movaps %xmm0, 0x10(%r15)
movaps %xmm0, (%r15)
movb $0x0, 0x20(%r15)
leaq 0x2e05(%rip), %r12      # 0x9180
xorl %r13d, %r13d
movzbl 0x40(%r14,%r13), %edx
movq %r15, %rdi
movq %r12, %rsi
xorl %eax, %eax
callq 0x30a0
incq %r13
addq $0x2, %r15
cmpq $0x10, %r13
jne 0x637e
leaq 0x10(%rbx), %rax
movq %rax, (%rbx)
leaq -0x50(%rbp), %r14
movq %r14, %rdi
callq 0x3140
leaq (%rax,%rbp), %rdx
addq $-0x50, %rdx
movq %rbx, %rdi
movq %r14, %rsi
jmp 0x63d5
leaq 0x10(%rbx), %rax
movq %rax, (%rbx)
leaq 0x2d9b(%rip), %rdx      # 0x916a
movq %rbx, %rdi
movq %rdx, %rsi
callq 0x54ce
movq %rbx, %rax
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O3/sun98[P]Mini-DFS/md5.cpp
// Function: md5(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>)
string md5(const string str)
{
  MD5 md5 = MD5();
  md5.update(str.c_str(), str.size());
  md5.finalize();
  return md5.toString();
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
subq $0x70, %rsp
movq %rdi, %rbx
leaq -0x7c(%rbp), %r14
movq $0x0, 0x60(%r14)
movaps 0x2d63(%rip), %xmm0     # 0x9170
movups %xmm0, 0x50(%r14)
movb $0x0, 0x68(%r14)
movq (%rsi), %rax
movq 0x8(%rsi), %rdx
movq %r14, %rdi
movq %rax, %rsi
callq 0x5a4e
movq %r14, %rdi
callq 0x62ac
movq %rbx, %rdi
movq %r14, %rsi
callq 0x6342
movq %rbx, %rax
addq $0x70, %rsp
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O3/sun98[P]Mini-DFS/namenode.cpp
// Function: NameServer::parse_cmd[abi:cxx11]()
std::vector<std::string> NameServer::parse_cmd()
{
    std::cout << "Mini-DFS> ";
    std::string cmd, tmp;
    std::getline(std::cin, cmd);
    std::vector<std::string> parameters;
    std::stringstream ss(cmd);
    while (ss >> tmp)
        parameters.push_back(tmp);
    return parameters;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x1c8, %rsp            # imm = 0x1C8
movq %rdi, %rbx
movq 0x52d2(%rip), %rdi      # 0xbfc8
leaq 0x2543(%rip), %rsi      # 0x9240
movl $0xa, %edx
callq 0x32e0
leaq -0x38(%rbp), %r12
movq %r12, -0x10(%r12)
xorl %eax, %eax
movq %rax, -0x8(%r12)
movb %al, (%r12)
leaq -0x58(%rbp), %r13
movq %r13, -0x10(%r13)
movq %rax, -0x8(%r13)
movb %al, (%r13)
movq 0x52a6(%rip), %rdi      # 0xbfd8
movq (%rdi), %rax
addq -0x18(%rax), %rdi
movl $0xa, %esi
callq 0x3280
movsbl %al, %edx
movq 0x528b(%rip), %rdi      # 0xbfd8
leaq -0x48(%rbp), %rsi
callq 0x34d0
xorps %xmm0, %xmm0
movups %xmm0, (%rbx)
movq $0x0, 0x10(%rbx)
leaq -0x1f0(%rbp), %rdi
leaq -0x48(%rbp), %rsi
movl $0x18, %edx
callq 0x3410
leaq -0x1f0(%rbp), %r14
leaq -0x68(%rbp), %r15
movq %r14, %rdi
movq %r15, %rsi
callq 0x3330
movq (%rax), %rcx
movq -0x18(%rcx), %rcx
testb $0x5, 0x20(%rax,%rcx)
jne 0x6daa
movq %rbx, %rdi
movq %r15, %rsi
callq 0x6448
jmp 0x6d84
movq 0x51f7(%rip), %rsi      # 0xbfa8
leaq -0x1f0(%rbp), %rdi
callq 0x31e0
leaq -0x170(%rbp), %rdi
callq 0x3110
movq -0x68(%rbp), %rdi
cmpq %r13, %rdi
je 0x6dd7
callq 0x3270
movq -0x48(%rbp), %rdi
cmpq %r12, %rdi
je 0x6de5
callq 0x3270
movq %rbx, %rax
addq $0x1c8, %rsp            # imm = 0x1C8
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %r14
jmp 0x6e26
movq %rax, %r14
jmp 0x6e2e
movq %rax, %r14
movq 0x519a(%rip), %rsi      # 0xbfa8
leaq -0x1f0(%rbp), %rdi
callq 0x31e0
leaq -0x170(%rbp), %rdi
callq 0x3110
movq %rbx, %rdi
callq 0x53f6
movq -0x68(%rbp), %rdi
cmpq %r13, %rdi
je 0x6e3c
callq 0x3270
movq -0x48(%rbp), %rdi
cmpq %r12, %rdi
je 0x6e4a
callq 0x3270
movq %r14, %rdi
callq 0x34a0
// File: /workspace/github_cpp_makefile_star2_O3/sun98[P]Mini-DFS/./md5.h
// Function: std::vector<int, std::allocator<int>> argsort<double>(std::vector<double, std::allocator<double>> const&)
std::vector<int> argsort(const std::vector<T> &vec)
{
    std::vector<int> idx;
    for (int i = 0; i < vec.size(); ++i)
        idx.push_back(i);
    sort(idx.begin(), idx.end(), [&vec](int id1, int id2) { return vec[id1] < vec[id2]; });
    return idx;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x10, %rsp
movq %rdi, %rbx
xorps %xmm0, %xmm0
movups %xmm0, (%rdi)
movq $0x0, 0x10(%rdi)
movl $0x0, -0x24(%rbp)
movq (%rsi), %rax
movq 0x8(%rsi), %rcx
cmpq %rax, %rcx
je 0x8115
movq %rsi, %r14
xorl %edx, %edx
leaq -0x24(%rbp), %r15
movq 0x8(%rbx), %rsi
cmpq 0x10(%rbx), %rsi
je 0x80ab
movl %edx, (%rsi)
addq $0x4, %rsi
movq %rsi, 0x8(%rbx)
jmp 0x80bd
movq %rbx, %rdi
movq %r15, %rdx
callq 0x83b6
movq (%r14), %rax
movq 0x8(%r14), %rcx
movslq -0x24(%rbp), %rdx
incq %rdx
movl %edx, -0x24(%rbp)
movq %rcx, %rsi
subq %rax, %rsi
sarq $0x3, %rsi
cmpq %rdx, %rsi
ja 0x8095
movq (%rbx), %r15
movq 0x8(%rbx), %r12
cmpq %r12, %r15
je 0x8115
movq %r12, %rax
subq %r15, %rax
sarq $0x2, %rax
bsrq %rax, %rdx
xorl $0x3f, %edx
addl %edx, %edx
xorq $0x7e, %rdx
movq %r15, %rdi
movq %r12, %rsi
movq %r14, %rcx
callq 0x84ee
movq %r15, %rdi
movq %r12, %rsi
movq %r14, %rdx
callq 0x8617
movq %rbx, %rax
addq $0x10, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
jmp 0x8127
movq %rax, %r14
movq (%rbx), %rdi
testq %rdi, %rdi
je 0x8137
callq 0x3270
movq %r14, %rdi
callq 0x34a0
nop
// File: /workspace/github_cpp_makefile_star2_O3/eschwabe[P]interview-practice/src/printlastlines.cpp
// Function: main
int main(int argc, char *argv[])
{
    if(argc < 3) {
        cout << argv[0] << " FILE LINES" << endl;
        return 1;
    }
    PrintLastLines(argv[1],atoi(argv[2]));
    return 0;
}

// Assembly:
pushq %r14
pushq %rbx
subq $0x28, %rsp
movq %rsi, %rbx
cmpl $0x2, %edi
jg 0x2545
movq (%rbx), %rbx
testq %rbx, %rbx
je 0x258d
movq %rbx, %rdi
callq 0x2060
movq 0x2aa0(%rip), %rdi      # 0x4fd8
movq %rbx, %rsi
movq %rax, %rdx
callq 0x2100
jmp 0x25ab
movq 0x8(%rbx), %rsi
leaq 0x8(%rsp), %r14
leaq 0x7(%rsp), %rdx
movq %r14, %rdi
callq 0x2620
movq 0x10(%rbx), %rdi
callq 0x2130
movq %r14, %rdi
movl %eax, %esi
callq 0x22ec
leaq 0x18(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x2589
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x20f0
xorl %eax, %eax
jmp 0x25f2
movq 0x2a44(%rip), %rax      # 0x4fd8
movq (%rax), %rcx
movq -0x18(%rcx), %rcx
leaq (%rax,%rcx), %rdi
movl 0x20(%rax,%rcx), %esi
orl $0x1, %esi
callq 0x2160
movq 0x2a26(%rip), %rbx      # 0x4fd8
leaq 0xa4b(%rip), %rsi       # 0x3004
movl $0xb, %edx
movq %rbx, %rdi
callq 0x2100
movq (%rbx), %rax
movq -0x18(%rax), %rdi
addq %rbx, %rdi
movl $0xa, %esi
callq 0x20d0
movsbl %al, %esi
movq %rbx, %rdi
callq 0x2030
movq %rax, %rdi
callq 0x2080
movl $0x1, %eax
addq $0x28, %rsp
popq %rbx
popq %r14
retq
movq %rax, %rbx
leaq 0x18(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x2618
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x20f0
movq %rbx, %rdi
callq 0x2180
// File: /workspace/github_cpp_makefile_star2_O3/statgen[P]statgen/lib/tclap-1.2.0/examples/test8.cpp
// Function: main
int main(int argc, char** argv)
{

	parseOptions(argc,argv);

	cout << "for string we got : " << _stringTest<< endl
		 << "for ulabeled one we got : " << _utest << endl
		 << "for ulabeled two we got : " << _ztest << endl
		 << "for bool B we got : " << _boolTestB << endl;

}

// Assembly:
pushq %rbx
callq 0x477f
movq 0x129a7(%rip), %rbx     # 0x16fd0
leaq 0xc9f2(%rip), %rsi      # 0x11022
movl $0x14, %edx
movq %rbx, %rdi
callq 0x4200
movq 0x12bc4(%rip), %rsi     # 0x17208
movq 0x12bc5(%rip), %rdx     # 0x17210
movq %rbx, %rdi
callq 0x4200
movq %rax, %rbx
movq (%rax), %rax
movq -0x18(%rax), %rdi
addq %rbx, %rdi
movl $0xa, %esi
callq 0x41a0
movsbl %al, %esi
movq %rbx, %rdi
callq 0x4030
movq %rax, %rdi
callq 0x4140
movq %rax, %rbx
leaq 0xc9b0(%rip), %rsi      # 0x11037
movl $0x1a, %edx
movq %rax, %rdi
callq 0x4200
movq 0x12b8d(%rip), %rsi     # 0x17228
movq 0x12b8e(%rip), %rdx     # 0x17230
movq %rbx, %rdi
callq 0x4200
movq %rax, %rbx
movq (%rax), %rax
movq -0x18(%rax), %rdi
addq %rbx, %rdi
movl $0xa, %esi
callq 0x41a0
movsbl %al, %esi
movq %rbx, %rdi
callq 0x4030
movq %rax, %rdi
callq 0x4140
movq %rax, %rbx
leaq 0xc974(%rip), %rsi      # 0x11052
movl $0x1a, %edx
movq %rax, %rdi
callq 0x4200
movq 0x12b56(%rip), %rsi     # 0x17248
movq 0x12b57(%rip), %rdx     # 0x17250
movq %rbx, %rdi
callq 0x4200
movq %rax, %rbx
movq (%rax), %rax
movq -0x18(%rax), %rdi
addq %rbx, %rdi
movl $0xa, %esi
callq 0x41a0
movsbl %al, %esi
movq %rbx, %rdi
callq 0x4030
movq %rax, %rdi
callq 0x4140
movq %rax, %rbx
leaq 0xc938(%rip), %rsi      # 0x1106d
movl $0x14, %edx
movq %rax, %rdi
callq 0x4200
movzbl 0x12ab8(%rip), %esi     # 0x17201
movq %rbx, %rdi
callq 0x42d0
movq %rax, %rbx
movq (%rax), %rax
movq -0x18(%rax), %rdi
addq %rbx, %rdi
movl $0xa, %esi
callq 0x41a0
movsbl %al, %esi
movq %rbx, %rdi
callq 0x4030
movq %rax, %rdi
callq 0x4140
xorl %eax, %eax
popq %rbx
retq