LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_cpp_makefile_star2_O1/Barath-Kannan[P]SignalsAndSlots/test/SafeQueue.hpp
// Function: BSignals::details::SafeQueue<BigThing>::dequeue()
T dequeue(void){
        std::unique_lock<std::mutex> lock(m);
        if (terminateFlag) return shutdownObject;
        while (q.empty()){
            c.wait(lock);
            if (terminateFlag) return shutdownObject;
        }
        T val = q.front();
        q.pop();
        return val;
    }

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %rsi, %r14
movq %rdi, %rbx
leaq 0x258(%rsi), %rax
leaq 0x8(%rsp), %r15
movq %rax, (%r15)
movb $0x0, 0x8(%r15)
movq %r15, %rdi
callq 0xd7bc
movb $0x1, 0x8(%r15)
cmpb $0x0, 0x200(%r14)
jne 0x1222f
leaq 0x280(%r14), %r15
leaq 0x8(%rsp), %r12
movq 0x218(%r14), %rsi
cmpq %rsi, 0x238(%r14)
jne 0x12241
movq %r15, %rdi
movq %r12, %rsi
callq 0xb150
cmpb $0x1, 0x200(%r14)
jne 0x1220a
movl $0x200, %edx            # imm = 0x200
movq %rbx, %rdi
movq %r14, %rsi
callq 0xb430
jmp 0x1225d
addq $0x208, %r14            # imm = 0x208
movl $0x200, %edx            # imm = 0x200
movq %rbx, %rdi
callq 0xb430
movq %r14, %rdi
callq 0x1adce
leaq 0x8(%rsp), %rdi
callq 0xd7a6
movq %rbx, %rax
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
// File: /workspace/github_cpp_makefile_star2_O1/Barath-Kannan[P]SignalsAndSlots/inc/BSignals/details/SignalImpl.hpp
// Function: int BSignals::details::SignalImpl<unsigned int>::connectMemberSlot<void (TestClass::*)(unsigned int), TestClass*>(BSignals::ExecutorScheme, void (TestClass::*&&)(unsigned int), TestClass*&&)
int connectMemberSlot(BSignals::ExecutorScheme scheme, F&& function, C&& instance){
        //type check assertions
        static_assert(std::is_member_function_pointer<F>::value, "function is not a member function");
        static_assert(std::is_object<std::remove_reference<C>>::value, "instance is not a class object");
        
        //Construct a bound function from the function pointer and object
        auto boundFunc = objectBind(function, instance);
        return connectSlot(scheme, boundFunc);
    }

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x58, %rsp
movl %esi, %ebx
movq %rdi, %r14
movq (%rcx), %r12
movups (%rdx), %xmm0
movaps %xmm0, 0x40(%rsp)
xorps %xmm0, %xmm0
leaq 0x20(%rsp), %r15
movaps %xmm0, 0x10(%r15)
movaps %xmm0, (%r15)
movl $0x18, %edi
callq 0xb4e0
movq %r12, (%rax)
movaps 0x40(%rsp), %xmm0
movups %xmm0, 0x8(%rax)
movq %rax, (%r15)
leaq 0x25e(%rip), %rax       # 0x12c5c
movq %rax, 0x18(%r15)
leaq 0x271(%rip), %rax       # 0x12c7a
movq %rax, 0x10(%r15)
movq %rsp, %rdi
movq %r15, %rsi
callq 0x12bf6
movq %rsp, %rdx
movq %r14, %rdi
movl %ebx, %esi
callq 0x12ab4
movl %eax, %ebx
movq 0x10(%rsp), %rax
testq %rax, %rax
je 0x12a3e
movq %rsp, %rdi
movq %rdi, %rsi
movl $0x3, %edx
callq *%rax
movq 0x30(%rsp), %rax
testq %rax, %rax
je 0x12a57
leaq 0x20(%rsp), %rdi
movq %rdi, %rsi
movl $0x3, %edx
callq *%rax
movl %ebx, %eax
addq $0x58, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
jmp 0x12aab
jmp 0x12aab
movq %rax, %rbx
movq 0x10(%rsp), %rax
testq %rax, %rax
je 0x12a8a
movq %rsp, %rdi
movq %rdi, %rsi
movl $0x3, %edx
callq *%rax
jmp 0x12a8a
jmp 0x12aab
movq %rax, %rbx
movq 0x30(%rsp), %rax
testq %rax, %rax
je 0x12aa3
leaq 0x20(%rsp), %rdi
movq %rdi, %rsi
movl $0x3, %edx
callq *%rax
movq %rbx, %rdi
callq 0xba10
movq %rax, %rdi
callq 0xd81f
nop
// File: /workspace/github_cpp_makefile_star2_O1/Barath-Kannan[P]SignalsAndSlots/inc/BSignals/details/SignalImpl.hpp
// Function: BSignals::details::SignalImpl<unsigned int>::connectSlot(BSignals::ExecutorScheme, std::function<void (unsigned int)>)
int connectSlot(BSignals::ExecutorScheme scheme, std::function<void(Args...)> slot){
        uint32_t id = currentId.fetch_add(1);
        if (enableEmissionGuard){
            std::lock_guard<std::mutex> lock(connectBufferLock);
            connectBuffer.emplace(id, ConnectDescriptor{scheme, slot});
            connectBufferDirty = true;
            return id;
        }
        else{
            return connectSlotFunction(id, scheme, slot);
        }
    }

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x50, %rsp
movq %rdx, %r12
movq %rdi, %r14
movl $0x1, %ebx
lock
xaddl %ebx, (%rdi)
movl %esi, %ebp
movl %ebx, 0x4(%rsp)
cmpb $0x1, 0x4(%rdi)
jne 0x12b4a
leaq 0xb8(%r14), %rbx
movq %rbx, %rdi
callq 0xb830
testl %eax, %eax
jne 0x12b93
leaq 0x30(%rsp), %r15
movl %ebp, -0x8(%r15)
movq %r15, %rdi
movq %r12, %rsi
callq 0x12bf6
leaq 0xe8(%r14), %rdi
leaq 0x4(%rsp), %rsi
leaq 0x28(%rsp), %rdx
callq 0x12fda
movq 0x40(%rsp), %rax
testq %rax, %rax
je 0x12b33
movq %r15, %rdi
movq %r15, %rsi
movl $0x3, %edx
callq *%rax
movb $0x1, %al
xchgb %al, 0xe0(%r14)
movl 0x4(%rsp), %ebp
movq %rbx, %rdi
callq 0xb3f0
jmp 0x12b84
leaq 0x8(%rsp), %r15
movq %r15, %rdi
movq %r12, %rsi
callq 0x12bf6
movq %r14, %rdi
movl %ebx, %esi
movl %ebp, %edx
movq %r15, %rcx
callq 0x12d0c
movl %eax, %ebp
movq 0x18(%rsp), %rax
testq %rax, %rax
je 0x12b84
leaq 0x8(%rsp), %rdi
movq %rdi, %rsi
movl $0x3, %edx
callq *%rax
movl %ebp, %eax
addq $0x50, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
movl %eax, %edi
callq 0xb370
jmp 0x12bed
jmp 0x12bed
movq %rax, %r14
movq 0x40(%rsp), %rax
testq %rax, %rax
je 0x12bbf
movq %r15, %rdi
movq %r15, %rsi
movl $0x3, %edx
callq *%rax
jmp 0x12bbf
jmp 0x12bed
movq %rax, %r14
movq %rbx, %rdi
callq 0xb3f0
jmp 0x12be5
movq %rax, %r14
movq 0x18(%rsp), %rax
testq %rax, %rax
je 0x12be5
leaq 0x8(%rsp), %rdi
movq %rdi, %rsi
movl $0x3, %edx
callq *%rax
movq %r14, %rdi
callq 0xba10
movq %rax, %rdi
callq 0xd81f
nop
// File: /workspace/github_cpp_makefile_star2_O1/Barath-Kannan[P]SignalsAndSlots/inc/BSignals/details/StrandSlot.hpp
// Function: BSignals::details::StrandSlot<unsigned int>::queueListener()
void queueListener(){
        std::tuple<Args...> tuple{};
        auto maxWait = WheeledThreadPool::getMaxWait();
        std::chrono::duration<double> waitTime = std::chrono::nanoseconds(1);
        while (!stop){
            if (strandQueue.dequeue(tuple)){
                if (!stop) this->callFuncWithTuple(tuple, std::index_sequence_for<Args...>());
                waitTime = std::chrono::nanoseconds(1);
            }
            else{
                std::this_thread::sleep_for(waitTime);
                waitTime*=2;
            }
            if (waitTime > maxWait){
                strandQueue.blockingDequeue(tuple);
                if (!stop) this->callFuncWithTuple(tuple, std::index_sequence_for<Args...>());
                waitTime = std::chrono::nanoseconds(1);
            }
        }
    }

// Assembly:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x30, %rsp
movq %rdi, %rbx
movl $0x0, 0xc(%rsp)
callq 0xdd78
movsd %xmm0, 0x28(%rsp)
cmpb $0x0, 0x238(%rbx)
jne 0x13939
leaq 0x30(%rbx), %r14
leaq 0x8(%rbx), %r15
movsd 0x357ee(%rip), %xmm1    # 0x49020
leaq 0xc(%rsp), %r12
leaq 0x18(%rsp), %r13
movsd %xmm1, 0x10(%rsp)
movq %r14, %rdi
movq %r12, %rsi
callq 0x13b02
testb %al, %al
je 0x1388c
cmpb $0x0, 0x238(%rbx)
movsd 0x357c0(%rip), %xmm1    # 0x49020
jne 0x138e8
movl 0xc(%rsp), %eax
movl %eax, 0x18(%rsp)
cmpq $0x0, 0x18(%rbx)
je 0x13947
movq %r15, %rdi
movq %r13, %rsi
callq *0x20(%rbx)
movsd 0x35796(%rip), %xmm1    # 0x49020
jmp 0x138e8
movsd 0x10(%rsp), %xmm1
ucomisd 0x3578e(%rip), %xmm1    # 0x49028
jbe 0x138e4
cvttsd2si %xmm1, %rax
xorps %xmm0, %xmm0
cvtsi2sd %rax, %xmm0
subsd %xmm0, %xmm1
mulsd 0x35753(%rip), %xmm1    # 0x49008
cvttsd2si %xmm1, %rcx
movq %rax, 0x18(%rsp)
movq %rcx, 0x20(%rsp)
movq %r13, %rdi
movq %r13, %rsi
callq 0xb160
cmpl $-0x1, %eax
jne 0x138de
callq 0xb070
cmpl $0x4, (%rax)
je 0x138c4
movsd 0x10(%rsp), %xmm1
addsd %xmm1, %xmm1
ucomisd 0x28(%rsp), %xmm1
jbe 0x1392c
movq %r14, %rdi
movq %r12, %rsi
callq 0x13b98
cmpb $0x0, 0x238(%rbx)
movsd 0x35716(%rip), %xmm1    # 0x49020
jne 0x1392c
movl 0xc(%rsp), %eax
movl %eax, 0x18(%rsp)
cmpq $0x0, 0x18(%rbx)
je 0x13947
movq %r15, %rdi
movq %r13, %rsi
callq *0x20(%rbx)
movsd 0x356f4(%rip), %xmm1    # 0x49020
cmpb $0x1, 0x238(%rbx)
jne 0x1383c
addq $0x30, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
callq 0xb1f0
// File: /workspace/github_cpp_makefile_star2_O1/Barath-Kannan[P]SignalsAndSlots/inc/BSignals/details/ThreadPooledSlot.hpp
// Function: BSignals::details::ThreadPooledSlot<unsigned int>::execute(unsigned int const&)
void execute(const Args& ... args){
        WheeledThreadPool::run([this, args...](){
            if (!checkIfValid || checkIfValid()){
                this->slotFunction(args...);
            }
        });
    }

// Assembly:
pushq %rbx
subq $0x20, %rsp
movl (%rsi), %eax
xorps %xmm0, %xmm0
movq %rsp, %rbx
movaps %xmm0, (%rbx)
movaps %xmm0, 0x10(%rbx)
movq %rdi, (%rbx)
movl %eax, 0x8(%rbx)
leaq 0x3b(%rip), %rax        # 0x14034
movq %rax, 0x18(%rbx)
leaq 0x36(%rip), %rax        # 0x1403a
movq %rax, 0x10(%rbx)
movq %rbx, %rdi
callq 0xda40
movq 0x10(%rbx), %rax
testq %rax, %rax
je 0x14026
movq %rsp, %rdi
movq %rdi, %rsi
movl $0x3, %edx
callq *%rax
addq $0x20, %rsp
popq %rbx
retq
movq %rax, %rdi
callq 0xd81f
// File: /workspace/github_cpp_makefile_star2_O1/Barath-Kannan[P]SignalsAndSlots/inc/BSignals/details/AsynchronousSlot.hpp
// Function: BSignals::details::AsynchronousSlot<BigThing>::execute(BigThing const&)
void execute(const Args& ... args){
        sem.acquire();
        std::thread slotThread([this, args...](){
            if (!checkIfValid || checkIfValid()){
                this->slotFunction(args...);
            }
            sem.release();
        });
        slotThread.detach();
    }

// Assembly:
pushq %r14
pushq %rbx
subq $0x218, %rsp            # imm = 0x218
movq %rsi, %rbx
movq %rdi, %r14
addq $0x50, %rdi
callq 0xd71a
leaq 0x18(%rsp), %rdi
movq %r14, -0x8(%rdi)
movl $0x200, %edx            # imm = 0x200
movq %rbx, %rsi
callq 0xb430
leaq 0x8(%rsp), %rbx
leaq 0x10(%rsp), %rsi
movq %rbx, %rdi
callq 0x1a2e0
movq %rbx, %rdi
callq 0xb9f0
cmpq $0x0, 0x8(%rsp)
jne 0x1a2da
addq $0x218, %rsp            # imm = 0x218
popq %rbx
popq %r14
retq
cmpq $0x0, 0x8(%rsp)
jne 0x1a2da
movq %rax, %rdi
callq 0xba10
callq 0xb130
nop
// File: /workspace/github_cpp_makefile_star2_O1/Barath-Kannan[P]SignalsAndSlots/inc/BSignals/details/SignalImpl.hpp
// Function: BSignals::details::SignalImpl<int, int>::disconnectSlot(int)
void disconnectSlot(int id){
        if (enableEmissionGuard){
            slotLock.lock_shared();
            auto it = slots.find(id);
            if (it == slots.end()) return;
            it->second->markForDeath();
            slotLock.unlock_shared();
        }
        else{
            disconnectSlotFunction(id);
        }
    }

// Assembly:
pushq %rbp
pushq %r14
pushq %rbx
movl %esi, %ebp
movq %rdi, %r14
leaq 0x18(%rdi), %rbx
cmpb $0x1, 0x4(%rdi)
jne 0x17f39
movq %rbx, %rdi
callq 0xd89e
movq 0x98(%r14), %rcx
addq $0x90, %r14
movq %r14, %rax
testq %rcx, %rcx
je 0x17f0e
movq %r14, %rax
xorl %edx, %edx
cmpl %ebp, 0x20(%rcx)
setb %dl
cmovaeq %rcx, %rax
movq 0x10(%rcx,%rdx,8), %rcx
testq %rcx, %rcx
jne 0x17ef8
movq %r14, %rcx
cmpq %r14, %rax
je 0x17f20
cmpl %ebp, 0x20(%rax)
cmovaq %r14, %rax
movq %rax, %rcx
cmpq %r14, %rcx
je 0x17fa3
movq 0x28(%rcx), %rax
movb $0x0, 0x28(%rax)
movq %rbx, %rdi
popq %rbx
popq %r14
popq %rbp
jmp 0xd8cc
movq %rbx, %rdi
callq 0xd82c
movq 0x98(%r14), %rdx
leaq 0x90(%r14), %rax
movq %rax, %rcx
testq %rdx, %rdx
je 0x17f71
movq %rax, %rcx
xorl %esi, %esi
cmpl %ebp, 0x20(%rdx)
setb %sil
cmovaeq %rdx, %rcx
movq 0x10(%rdx,%rsi,8), %rdx
testq %rdx, %rdx
jne 0x17f5a
movq %rax, %rsi
cmpq %rax, %rcx
je 0x17f83
cmpl %ebp, 0x20(%rcx)
cmovaq %rax, %rcx
movq %rcx, %rsi
cmpq %rax, %rsi
je 0x17fa3
addq $0x88, %r14
movq %r14, %rdi
callq 0x17b80
movq %rbx, %rdi
popq %rbx
popq %r14
popq %rbp
jmp 0xd88c
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O1/Barath-Kannan[P]SignalsAndSlots/inc/BSignals/details/SignalImpl.hpp
// Function: BSignals::details::SignalImpl<int, int>::invokeDeferred()
void invokeDeferred(){
        slotLock.lock_shared();
        std::pair<std::function<void()>, uint32_t> deferredInvocation;
        if (!deferredQueue) return;
        while (deferredQueue->dequeue(deferredInvocation)){
            if (!enableEmissionGuard || getIsStillConnectedFromExecutor(deferredInvocation.second)){
                deferredInvocation.first();
            }
        }
        slotLock.unlock_shared();
    }

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x30, %rsp
movq %rdi, %r14
leaq 0x18(%rdi), %rbx
movq %rbx, %rdi
callq 0xd89e
xorps %xmm0, %xmm0
movaps %xmm0, 0x10(%rsp)
movaps %xmm0, (%rsp)
movl $0x0, 0x20(%rsp)
cmpq $0x0, 0x8(%r14)
je 0x185e8
leaq 0x90(%r14), %r12
movq %rsp, %r15
movq 0x8(%r14), %rdi
movq %r15, %rsi
callq 0x1469a
testb %al, %al
je 0x185e0
cmpb $0x1, 0x4(%r14)
jne 0x185cc
movl 0x20(%rsp), %ebp
movq %rbx, %rdi
callq 0xd89e
movq 0x98(%r14), %rcx
movq %r12, %rax
testq %rcx, %rcx
je 0x1859b
movq %r12, %rax
xorl %edx, %edx
cmpl %ebp, 0x20(%rcx)
setb %dl
cmovaeq %rcx, %rax
movq 0x10(%rcx,%rdx,8), %rcx
testq %rcx, %rcx
jne 0x18585
movq %r12, %rcx
cmpq %r12, %rax
je 0x185ad
cmpl %ebp, 0x20(%rax)
cmovaq %r12, %rax
movq %rax, %rcx
cmpq %r12, %rcx
je 0x185bc
movq 0x28(%rcx), %rax
movb 0x28(%rax), %bpl
jmp 0x185be
xorl %ebp, %ebp
movq %rbx, %rdi
callq 0xd8cc
testb $0x1, %bpl
je 0x1854c
cmpq $0x0, 0x10(%rsp)
je 0x1860c
movq %r15, %rdi
callq *0x18(%rsp)
jmp 0x1854c
movq %rbx, %rdi
callq 0xd8cc
movq 0x10(%rsp), %rax
testq %rax, %rax
je 0x185ff
movq %rsp, %rdi
movq %rdi, %rsi
movl $0x3, %edx
callq *%rax
addq $0x30, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
callq 0xb1f0
jmp 0x18637
jmp 0x18615
movq %rax, %rbx
movq 0x10(%rsp), %rax
testq %rax, %rax
je 0x1862f
movq %rsp, %rdi
movq %rdi, %rsi
movl $0x3, %edx
callq *%rax
movq %rbx, %rdi
callq 0xba10
movq %rax, %rdi
callq 0xd81f
// File: /workspace/github_cpp_makefile_star2_O1/Barath-Kannan[P]SignalsAndSlots/3rdparty/googletest/inc/gtest/gtest.h
// Function: testing::WithParamInterface<std::tuple<unsigned int, unsigned int, unsigned int, unsigned int, bool, BSignals::ExecutorScheme>>::GetParam() const
const ParamType& GetParam() const {
    GTEST_CHECK_(parameter_ != NULL)
        << "GetParam() can only be called inside a value-parameterized test "
        << "-- did you intend to write TEST_P instead of TEST_F?";
    return *parameter_;
  }

// Assembly:
pushq %rbx
subq $0x10, %rsp
leaq 0x9dca4(%rip), %rbx     # 0xbda10
xorl %edi, %edi
cmpq $0x0, (%rbx)
setne %dil
callq 0x2764e
testb %al, %al
jne 0x1fdec
leaq 0x2b4f6(%rip), %rdx     # 0x4b27c
leaq 0xc(%rsp), %rdi
movl $0x3, %esi
movl $0x6dc, %ecx            # imm = 0x6DC
callq 0x46398
movq 0x4b247(%rip), %rdi     # 0x6afe8
leaq 0x2b4fa(%rip), %rsi     # 0x4b2a2
movl $0x25, %edx
callq 0xb600
movq 0x4b22f(%rip), %rdi     # 0x6afe8
leaq 0x2b508(%rip), %rsi     # 0x4b2c8
movl $0x40, %edx
callq 0xb600
movq 0x4b217(%rip), %rdi     # 0x6afe8
leaq 0x2b531(%rip), %rsi     # 0x4b309
movl $0x34, %edx
callq 0xb600
leaq 0xc(%rsp), %rdi
callq 0x464da
movq (%rbx), %rax
addq $0x10, %rsp
popq %rbx
retq
movq %rax, %rbx
leaq 0xc(%rsp), %rdi
callq 0x464da
movq %rbx, %rdi
callq 0xba10
// File: /workspace/github_cpp_makefile_star2_O1/Barath-Kannan[P]SignalsAndSlots/3rdparty/googletest/inc/gtest/internal/gtest-linked_ptr.h
// Function: testing::internal::linked_ptr_internal::join(testing::internal::linked_ptr_internal const*)
GTEST_LOCK_EXCLUDED_(g_linked_ptr_mutex) {
    MutexLock lock(&g_linked_ptr_mutex);

    linked_ptr_internal const* p = ptr;
    while (p->next_ != ptr) {
      assert(p->next_ != this &&
             "Trying to join() a linked ring we are already in. "
             "Is GMock thread safety enabled?");
      p = p->next_;
    }
    p->next_ = this;
    next_ = ptr;
  }

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq %rdi, %r14
leaq 0x9cc1f(%rip), %rdi     # 0xbdaf0
callq 0x20f2a
movq %rbx, %rax
movq (%rax), %rcx
cmpq %rbx, %rcx
je 0x20f08
movq %rcx, %rax
cmpq %r14, %rcx
jne 0x20ed9
leaq 0x2a198(%rip), %rdi     # 0x4b088
leaq 0x2a071(%rip), %rsi     # 0x4af68
leaq 0x2a1f5(%rip), %rcx     # 0x4b0f3
movl $0x74, %edx
callq 0xb360
movq %r14, (%rax)
movq %rbx, (%r14)
leaq 0x9cbdb(%rip), %rdi     # 0xbdaf0
callq 0x20fc8
addq $0x8, %rsp
popq %rbx
popq %r14
retq
movq %rax, %rdi
callq 0xd81f
// File: /workspace/github_cpp_makefile_star2_O1/Barath-Kannan[P]SignalsAndSlots/3rdparty/googletest/inc/gtest/internal/gtest-linked_ptr.h
// Function: testing::internal::linked_ptr_internal::depart()
bool depart()
      GTEST_LOCK_EXCLUDED_(g_linked_ptr_mutex) {
    MutexLock lock(&g_linked_ptr_mutex);

    if (next_ == this) return true;
    linked_ptr_internal const* p = next_;
    while (p->next_ != this) {
      assert(p->next_ != next_ &&
             "Trying to depart() a linked ring we are not in. "
             "Is GMock thread safety enabled?");
      p = p->next_;
    }
    p->next_ = next_;
    return false;
  }

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
leaq 0x9c916(%rip), %rdi     # 0xbdaf0
callq 0x20f2a
movq (%rbx), %r14
cmpq %rbx, %r14
je 0x2121c
movq %r14, %rax
movq (%rax), %rcx
cmpq %rbx, %rcx
je 0x21219
movq %rcx, %rax
cmpq %r14, %rcx
jne 0x211ea
leaq 0x29fc2(%rip), %rdi     # 0x4b1c3
leaq 0x29d60(%rip), %rsi     # 0x4af68
leaq 0x2a01e(%rip), %rcx     # 0x4b22d
movl $0x86, %edx
callq 0xb360
movq %r14, (%rax)
leaq 0x9c8cd(%rip), %rdi     # 0xbdaf0
callq 0x20fc8
cmpq %rbx, %r14
sete %al
addq $0x8, %rsp
popq %rbx
popq %r14
retq
movq %rax, %rdi
callq 0xd81f
// File: /workspace/github_cpp_makefile_star2_O1/Barath-Kannan[P]SignalsAndSlots/3rdparty/googletest/inc/gtest/gtest-printers.h
// Function: void testing::internal::TuplePrefixPrinter<5ul>::PrintPrefixTo<std::tuple<unsigned int, unsigned int, unsigned int, unsigned int, bool, BSignals::ExecutorScheme>>(std::tuple<unsigned int, unsigned int, unsigned int, unsigned int, bool, BSignals::ExecutorScheme> const&, std::ostream*)
static void PrintPrefixTo(const Tuple& t, ::std::ostream* os) {
    TuplePrefixPrinter<N - 1>::PrintPrefixTo(t, os);
    GTEST_INTENTIONAL_CONST_COND_PUSH_()
    if (N > 1) {
    GTEST_INTENTIONAL_CONST_COND_POP_()
      *os << ", ";
    }
    UniversalPrinter<
        typename TuplePolicy<Tuple>::template tuple_element<N - 1>::type>
        ::Print(TuplePolicy<Tuple>::template get<N - 1>(t), os);
  }

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq %rdi, %r14
callq 0x225f6
leaq 0x2bf0e(%rip), %rsi     # 0x4e4ca
movl $0x2, %edx
movq %rbx, %rdi
callq 0xb600
movzbl 0x4(%r14), %edx
leaq 0x28894(%rip), %rax     # 0x4ae69
leaq 0x28887(%rip), %rsi     # 0x4ae63
testq %rdx, %rdx
cmovneq %rax, %rsi
xorq $0x5, %rdx
movq %rbx, %rdi
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0xb600
// File: /workspace/github_cpp_makefile_star2_O1/Barath-Kannan[P]SignalsAndSlots/test/FunctionTimeRegular.hpp
// Function: FunctionTimeRegular<>::threadLoop()
void threadLoop(){
        auto begin = std::chrono::high_resolution_clock::now();
        std::chrono::duration<double> elapsed = std::chrono::high_resolution_clock::now() - begin;
        std::unique_lock<std::mutex> lock(m_mutex);
        for (std::chrono::duration<double> lastTime=elapsed; m_keepGoing; lastTime += m_interval){
            if (!m_tfunc())
                break;
            elapsed = std::chrono::high_resolution_clock::now() - begin;
            m_cv.wait_for(lock, m_interval - (elapsed-lastTime));
        }
    }

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x28, %rsp
movq %rdi, %rbx
callq 0xb090
movq %rax, %r14
callq 0xb090
movq %rax, %r15
leaq 0x8(%rbx), %rax
leaq 0x18(%rsp), %r12
movq %rax, (%r12)
movb $0x0, 0x8(%r12)
movq %r12, %rdi
callq 0xd7bc
movb $0x1, 0x8(%r12)
movb (%rbx), %al
testb $0x1, %al
je 0x2491f
subq %r14, %r15
cvtsi2sd %r15, %xmm0
divsd 0x2476a(%rip), %xmm0    # 0x49008
movsd %xmm0, 0x8(%rsp)
leaq 0x70(%rbx), %r15
leaq 0x30(%rbx), %r12
leaq 0x18(%rsp), %r13
leaq 0x10(%rsp), %rbp
cmpq $0x0, 0x80(%rbx)
je 0x24938
movq %r15, %rdi
callq *0x88(%rbx)
testb %al, %al
je 0x2491f
callq 0xb090
subq %r14, %rax
xorps %xmm0, %xmm0
cvtsi2sd %rax, %xmm0
divsd 0x24723(%rip), %xmm0    # 0x49008
subsd 0x8(%rsp), %xmm0
movsd 0x68(%rbx), %xmm1
subsd %xmm0, %xmm1
movsd %xmm1, 0x10(%rsp)
movq %r12, %rdi
movq %r13, %rsi
movq %rbp, %rdx
callq 0x249f0
movsd 0x8(%rsp), %xmm0
addsd 0x68(%rbx), %xmm0
movsd %xmm0, 0x8(%rsp)
movb (%rbx), %al
testb $0x1, %al
jne 0x248b6
leaq 0x18(%rsp), %rdi
callq 0xd7a6
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
callq 0xb1f0
jmp 0x24941
jmp 0x24941
movq %rax, %rbx
leaq 0x18(%rsp), %rdi
callq 0xd7a6
movq %rbx, %rdi
callq 0xba10
// File: /workspace/github_cpp_makefile_star2_O1/Barath-Kannan[P]SignalsAndSlots/3rdparty/googletest/inc/gtest/internal/gtest-param-util-generated.h
// Function: testing::internal::ValueArray7<int, int, int, int, int, int, int>::operator testing::internal::ParamGenerator<unsigned int><unsigned int>() const
operator ParamGenerator<T>() const {
    const T array[] = {static_cast<T>(v1_), static_cast<T>(v2_),
        static_cast<T>(v3_), static_cast<T>(v4_), static_cast<T>(v5_),
        static_cast<T>(v6_), static_cast<T>(v7_)};
    return ValuesIn(array);
  }

// Assembly:
pushq %rbx
subq $0x20, %rsp
movq %rdi, %rbx
movl (%rsi), %eax
leaq 0x1c(%rsp), %rdx
movl %eax, -0x1c(%rdx)
movl 0x4(%rsi), %eax
movl %eax, -0x18(%rdx)
movl 0x8(%rsi), %eax
movl %eax, -0x14(%rdx)
movl 0xc(%rsi), %eax
movl %eax, -0x10(%rdx)
movl 0x10(%rsi), %eax
movl %eax, -0xc(%rdx)
movl 0x14(%rsi), %eax
movl %eax, -0x8(%rdx)
movl 0x18(%rsi), %eax
movl %eax, -0x4(%rdx)
movq %rsp, %rsi
callq 0x24f01
movq %rbx, %rax
addq $0x20, %rsp
popq %rbx
retq
nop
// File: /workspace/github_cpp_makefile_star2_O1/Barath-Kannan[P]SignalsAndSlots/3rdparty/googletest/inc/gtest/internal/gtest-param-util.h
// Function: testing::internal::ValuesInIteratorRangeGenerator<unsigned int>::Iterator::Equals(testing::internal::ParamIteratorInterface<unsigned int> const&) const
virtual bool Equals(const ParamIteratorInterface<T>& other) const {
      // Having the same base generator guarantees that the other
      // iterator is of the same type and we can downcast.
      GTEST_CHECK_(BaseGenerator() == other.BaseGenerator())
          << "The program attempted to compare iterators "
          << "from different generators." << std::endl;
      return iterator_ ==
          CheckedDowncastToActualType<const Iterator>(&other)->iterator_;
    }

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
subq $0x10, %rsp
movq %rsi, %r14
movq %rdi, %rbx
movq (%rdi), %rax
callq *0x10(%rax)
movq %rax, %r15
movq (%r14), %rax
movq %r14, %rdi
callq *0x10(%rax)
xorl %edi, %edi
cmpq %rax, %r15
sete %dil
callq 0x2764e
testb %al, %al
jne 0x25296
leaq 0x26170(%rip), %rdx     # 0x4b372
leaq 0xc(%rsp), %rdi
movl $0x3, %esi
movl $0x155, %ecx            # imm = 0x155
callq 0x46398
movq 0x45dcb(%rip), %rdi     # 0x6afe8
leaq 0x262c9(%rip), %rsi     # 0x4b4ed
movl $0x3b, %edx
callq 0xb600
movq 0x45db3(%rip), %rdi     # 0x6afe8
leaq 0x262ed(%rip), %rsi     # 0x4b529
movl $0x2b, %edx
callq 0xb600
movq 0x45d9b(%rip), %r15     # 0x6afe8
leaq 0x26301(%rip), %rsi     # 0x4b555
movl $0x1a, %edx
movq %r15, %rdi
callq 0xb600
movq (%r15), %rax
addq -0x18(%rax), %r15
movq %r15, %rdi
movl $0xa, %esi
callq 0xb4c0
movsbl %al, %esi
movq 0x45d69(%rip), %rdi     # 0x6afe8
callq 0xb050
movq %rax, %rdi
callq 0xb390
leaq 0xc(%rsp), %rdi
callq 0x464da
movq %r14, %rdi
callq 0x25302
movq 0x10(%rbx), %rcx
cmpq 0x10(%rax), %rcx
sete %al
addq $0x10, %rsp
popq %rbx
popq %r14
popq %r15
retq
movq %rax, %rbx
leaq 0xc(%rsp), %rdi
callq 0x464da
movq %rbx, %rdi
callq 0xba10
// File: /workspace/github_cpp_makefile_star2_O1/Barath-Kannan[P]SignalsAndSlots/3rdparty/googletest/inc/gtest/internal/gtest-param-util-generated.h
// Function: testing::internal::CartesianProductGenerator6<unsigned int, unsigned int, unsigned int, unsigned int, bool, BSignals::ExecutorScheme>::Iterator::Advance()
virtual void Advance() {
      assert(!AtEnd());
      ++current6_;
      if (current6_ == end6_) {
        current6_ = begin6_;
        ++current5_;
      }
      if (current5_ == end5_) {
        current5_ = begin5_;
        ++current4_;
      }
      if (current4_ == end4_) {
        current4_ = begin4_;
        ++current3_;
      }
      if (current3_ == end3_) {
        current3_ = begin3_;
        ++current2_;
      }
      if (current2_ == end2_) {
        current2_ = begin2_;
        ++current1_;
      }
      ComputeCurrentValue();
    }

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
callq 0x26ca8
testb %al, %al
jne 0x26a89
movq 0x98(%rbx), %rdi
movq (%rdi), %rax
callq *0x18(%rax)
movq 0x90(%rbx), %rsi
movq 0x98(%rbx), %rdi
cmpq %rsi, %rdi
je 0x26960
movq (%rdi), %rax
callq *0x30(%rax)
testb %al, %al
je 0x2698c
leaq 0x98(%rbx), %r14
movq 0x88(%rbx), %rdi
movq (%rdi), %rax
callq *0x20(%rax)
movq %r14, %rdi
movq %rax, %rsi
callq 0x26d48
movq 0x80(%rbx), %rdi
movq (%rdi), %rax
callq *0x18(%rax)
movq 0x78(%rbx), %rsi
movq 0x80(%rbx), %rdi
cmpq %rsi, %rdi
je 0x269a6
movq (%rdi), %rax
callq *0x30(%rax)
testb %al, %al
je 0x269cc
leaq 0x80(%rbx), %r14
movq 0x70(%rbx), %rdi
movq (%rdi), %rax
callq *0x20(%rax)
movq %r14, %rdi
movq %rax, %rsi
callq 0x26d7e
movq 0x68(%rbx), %rdi
movq (%rdi), %rax
callq *0x18(%rax)
movq 0x60(%rbx), %rsi
movq 0x68(%rbx), %rdi
cmpq %rsi, %rdi
je 0x269e3
movq (%rdi), %rax
callq *0x30(%rax)
testb %al, %al
je 0x26a06
leaq 0x68(%rbx), %r14
movq 0x58(%rbx), %rdi
movq (%rdi), %rax
callq *0x20(%rax)
movq %r14, %rdi
movq %rax, %rsi
callq 0x26db4
movq 0x50(%rbx), %rdi
movq (%rdi), %rax
callq *0x18(%rax)
movq 0x48(%rbx), %rsi
movq 0x50(%rbx), %rdi
cmpq %rsi, %rdi
je 0x26a1d
movq (%rdi), %rax
callq *0x30(%rax)
testb %al, %al
je 0x26a40
leaq 0x50(%rbx), %r14
movq 0x40(%rbx), %rdi
movq (%rdi), %rax
callq *0x20(%rax)
movq %r14, %rdi
movq %rax, %rsi
callq 0x26db4
movq 0x38(%rbx), %rdi
movq (%rdi), %rax
callq *0x18(%rax)
movq 0x30(%rbx), %rsi
movq 0x38(%rbx), %rdi
cmpq %rsi, %rdi
je 0x26a57
movq (%rdi), %rax
callq *0x30(%rax)
testb %al, %al
je 0x26a7a
leaq 0x38(%rbx), %r14
movq 0x28(%rbx), %rdi
movq (%rdi), %rax
callq *0x20(%rax)
movq %r14, %rdi
movq %rax, %rsi
callq 0x26db4
movq 0x20(%rbx), %rdi
movq (%rdi), %rax
callq *0x18(%rax)
movq %rbx, %rdi
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x2673c
leaq 0x24d3a(%rip), %rdi     # 0x4b7ca
leaq 0x24d3c(%rip), %rsi     # 0x4b7d3
leaq 0x24d79(%rip), %rcx     # 0x4b817
movl $0xec7, %edx            # imm = 0xEC7
callq 0xb360
// File: /workspace/github_cpp_makefile_star2_O1/Barath-Kannan[P]SignalsAndSlots/3rdparty/googletest/inc/gtest/internal/gtest-param-util-generated.h
// Function: testing::internal::CartesianProductGenerator6<unsigned int, unsigned int, unsigned int, unsigned int, bool, BSignals::ExecutorScheme>::Iterator::AtEnd() const
bool AtEnd() const {
      // We must report iterator past the end of the range when either of the
      // component iterators has reached the end of its range.
      return
          current1_ == end1_ ||
          current2_ == end2_ ||
          current3_ == end3_ ||
          current4_ == end4_ ||
          current5_ == end5_ ||
          current6_ == end6_;
    }

// Assembly:
pushq %rbx
movq %rdi, %rbx
movq 0x18(%rdi), %rsi
movq 0x20(%rdi), %rdi
cmpq %rsi, %rdi
je 0x26d43
movq (%rdi), %rax
callq *0x30(%rax)
testb %al, %al
jne 0x26d43
movq 0x30(%rbx), %rsi
movq 0x38(%rbx), %rdi
cmpq %rsi, %rdi
je 0x26d43
movq (%rdi), %rax
callq *0x30(%rax)
testb %al, %al
jne 0x26d43
movq 0x48(%rbx), %rsi
movq 0x50(%rbx), %rdi
cmpq %rsi, %rdi
je 0x26d43
movq (%rdi), %rax
callq *0x30(%rax)
testb %al, %al
jne 0x26d43
movq 0x60(%rbx), %rsi
movq 0x68(%rbx), %rdi
cmpq %rsi, %rdi
je 0x26d43
movq (%rdi), %rax
callq *0x30(%rax)
testb %al, %al
jne 0x26d43
movq 0x78(%rbx), %rsi
movq 0x80(%rbx), %rdi
cmpq %rsi, %rdi
je 0x26d43
movq (%rdi), %rax
callq *0x30(%rax)
testb %al, %al
jne 0x26d43
movq 0x90(%rbx), %rsi
movq 0x98(%rbx), %rdi
cmpq %rsi, %rdi
je 0x26d43
movq (%rdi), %rax
movq 0x30(%rax), %rax
popq %rbx
jmpq *%rax
movb $0x1, %al
popq %rbx
retq
nop
// File: /workspace/github_cpp_makefile_star2_O1/Barath-Kannan[P]SignalsAndSlots/3rdparty/googletest/src/CustomTestPrinter.cpp
// Function: main
int main(int argc, char **argv) {
    InitGoogleTest(&argc, argv);
    UnitTest& unit_test = *UnitTest::GetInstance();
    TestEventListeners& listeners = unit_test.listeners();

    // Removes the default console output listener from the list so it will
    // not receive events from Google Test and won't print any output. Since
    // this operation transfers ownership of the listener to the caller we
    // have to delete it as well.
    delete listeners.Release(listeners.default_result_printer());

    // Adds the custom output listener to the list. It will now receive
    // events from Google Test and print the alternative output. We don't
    // have to worry about deleting it since Google Test assumes ownership
    // over it after adding it to the list.
    listeners.Append(new CustomTestPrinter);
    int ret_val = RUN_ALL_TESTS();
    return ret_val;
}

// Assembly:
pushq %rbx
subq $0x10, %rsp
leaq 0xc(%rsp), %rax
movl %edi, (%rax)
movq %rax, %rdi
callq 0x356ae
callq 0x277e2
movq %rax, %rdi
callq 0x2e8f6
movq %rax, %rbx
movq 0x8(%rax), %rsi
movq %rax, %rdi
callq 0x3381c
testq %rax, %rax
je 0x480e6
movq (%rax), %rcx
movq %rax, %rdi
callq *0x8(%rcx)
movl $0x8, %edi
callq 0xb4e0
leaq 0x22b81(%rip), %rcx     # 0x6ac78
addq $0x10, %rcx
movq %rcx, (%rax)
movq %rbx, %rdi
movq %rax, %rsi
callq 0x33814
callq 0x277e2
movq %rax, %rdi
callq 0x33b0a
addq $0x10, %rsp
popq %rbx
retq
// File: /workspace/github_cpp_makefile_star2_O1/Barath-Kannan[P]SignalsAndSlots/3rdparty/googletest/src/CustomTestPrinter.cpp
// Function: CustomTestPrinter::OnTestIterationStart(testing::UnitTest const&, int)
void OnTestIterationStart(const UnitTest& unit_test, int iteration) {
        if (GTEST_FLAG(repeat) != 1) {
            printf("\nRepeating all tests (iteration %d) . . .\n\n", iteration + 1);
        }
        const char* const filter = GTEST_FLAG(filter).c_str();

        // Prints the filter if it's not *.  This reminds the user that some
        // tests may be skipped.
        if (strcmp(filter, kUniversalFilter) != 0) {
            printf("Note: %s filter = %s\n", GTEST_NAME_, filter);
        }

        if (GTEST_FLAG(shuffle)) {
            printf("Note: Randomizing tests' orders with a seed of %d .\n", unit_test.random_seed());
        }

        PRINT_SEPARATOR;
        PRINT_EXTENDER;
        printf("Running %d test%s from %d test case%s.\n",
                unit_test.test_to_run_count(), unit_test.test_to_run_count() == 1 ? "" : "s",
                unit_test.test_case_to_run_count(), unit_test.test_case_to_run_count() == 1 ? "" : "s");
        PRINT_SEPARATOR;
        fflush(stdout);
    }

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rsi, %rbx
leaq 0x7595d(%rip), %rax     # 0xbda98
cmpl $0x1, (%rax)
je 0x48152
incl %edx
leaq 0x57df(%rip), %rdi      # 0x4d928
movl %edx, %esi
xorl %eax, %eax
callq 0xb080
leaq 0x758ef(%rip), %rax     # 0xbda48
movq (%rax), %r14
leaq 0x7529(%rip), %rsi      # 0x4f68c
movq %r14, %rdi
callq 0xb7b0
testl %eax, %eax
je 0x48187
leaq 0x57de(%rip), %rdi      # 0x4d954
leaq 0x52f5(%rip), %rsi      # 0x4d472
movq %r14, %rdx
xorl %eax, %eax
callq 0xb080
leaq 0x7590f(%rip), %rax     # 0xbda9d
cmpb $0x1, (%rax)
jne 0x481ab
movq %rbx, %rdi
callq 0x2f98c
leaq 0x57ec(%rip), %rdi      # 0x4d98e
movl %eax, %esi
xorl %eax, %eax
callq 0xb080
leaq 0x7486(%rip), %rdi      # 0x4f638
callq 0xb8b0
leaq 0x72fe(%rip), %rdi      # 0x4f4bc
xorl %eax, %eax
callq 0xb080
movq %rbx, %rdi
callq 0x2f998
movl %eax, %ebp
movq %rbx, %rdi
callq 0x2f998
cmpl $0x1, %eax
leaq 0x5883(%rip), %r14      # 0x4da64
leaq 0x5dad(%rip), %r15      # 0x4df95
movq %r15, %r12
cmoveq %r14, %r12
movq %rbx, %rdi
callq 0x2f9a2
movl %eax, %r13d
movq %rbx, %rdi
callq 0x2f9a2
cmpl $0x1, %eax
cmoveq %r14, %r15
leaq 0x72af(%rip), %rdi      # 0x4f4bf
movl %ebp, %esi
movq %r12, %rdx
movl %r13d, %ecx
movq %r15, %r8
xorl %eax, %eax
callq 0xb080
leaq 0x740f(%rip), %rdi      # 0x4f638
callq 0xb8b0
movq 0x22cfb(%rip), %rax     # 0x6af30
movq (%rax), %rdi
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0xb630
nop
// File: /workspace/github_cpp_makefile_star2_O1/Barath-Kannan[P]SignalsAndSlots/3rdparty/googletest/src/CustomTestPrinter.cpp
// Function: CustomTestPrinter::OnTestCaseStart(testing::TestCase const&)
void OnTestCaseStart(const TestCase& test_case) {
        PRINT_ALT_EXTENDER;
        printf("Test Case: %s", test_case.name());
        if (test_case.type_param() == NULL) {
            printf("\n");
        } else {
            printf(", where %s = %s\n", kTypeParamLabel, test_case.type_param());
        }
        PRINT_ALT_EXTENDER;
        printf("Tests: \n");
        for (int i=0; i<test_case.test_to_run_count(); i++){
            PRINT_ALT_EXTENDER;
            PRINT_LONG_EXTENDER;
            PRINT_EXTENDER;
            printf("%s\n", test_case.GetTestInfo(i)->name());
            
        }
        /*printf("%d %s from %s", test_case.test_to_run_count(), test_case.test_to_run_count() == 1 ? "test" : "tests", test_case.name());
        if (test_case.type_param() == NULL) {
            printf("\n");
        } else {
            printf(", where %s = %s\n", kTypeParamLabel, test_case.type_param());
        }*/
        PRINT_SEPARATOR;
        fflush(stdout);
    }

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movq %rsi, %rbx
leaq 0x7279(%rip), %rdi      # 0x4f4e7
xorl %eax, %eax
callq 0xb080
movq 0x8(%rbx), %rsi
leaq 0x726b(%rip), %rdi      # 0x4f4eb
xorl %eax, %eax
callq 0xb080
movq 0x28(%rbx), %rax
testq %rax, %rax
je 0x482a0
cmpq $0x0, (%rax)
je 0x482a0
testq %rax, %rax
je 0x482ac
movq (%rax), %rdx
jmp 0x482ae
movl $0xa, %edi
callq 0xb7a0
jmp 0x482c3
xorl %edx, %edx
leaq 0x5750(%rip), %rdi      # 0x4da05
leaq 0x73d2(%rip), %rsi      # 0x4f68e
xorl %eax, %eax
callq 0xb080
leaq 0x721d(%rip), %rdi      # 0x4f4e7
xorl %eax, %eax
callq 0xb080
leaq 0x72ba(%rip), %rdi      # 0x4f592
callq 0xb8b0
movq %rbx, %rdi
callq 0x293d2
testl %eax, %eax
jle 0x4833f
leaq 0x71f7(%rip), %r14      # 0x4f4e7
leaq 0x6a20(%rip), %r15      # 0x4ed17
leaq 0x71be(%rip), %r12      # 0x4f4bc
xorl %ebp, %ebp
movq %r14, %rdi
xorl %eax, %eax
callq 0xb080
movq %r15, %rdi
xorl %eax, %eax
callq 0xb080
movq %r12, %rdi
xorl %eax, %eax
callq 0xb080
movq %rbx, %rdi
movl %ebp, %esi
callq 0x2eae4
movq 0x20(%rax), %rdi
callq 0xb8b0
incl %ebp
movq %rbx, %rdi
callq 0x293d2
cmpl %eax, %ebp
jl 0x48300
leaq 0x72f2(%rip), %rdi      # 0x4f638
callq 0xb8b0
movq 0x22bde(%rip), %rax     # 0x6af30
movq (%rax), %rdi
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
jmp 0xb630
// File: /workspace/github_cpp_makefile_star2_O1/Barath-Kannan[P]SignalsAndSlots/3rdparty/googletest/src/CustomTestPrinter.cpp
// Function: CustomTestPrinter::OnTestStart(testing::TestInfo const&)
void OnTestStart(const TestInfo& test_info) {
        PRINT_LONG_EXTENDER;
        printf("Test %s.%s RUNNING", test_info.test_case_name(), test_info.name());
        printf("\n");
        PRINT_SEPARATOR;
        fflush(stdout);
    }

// Assembly:
pushq %rbx
movq %rsi, %rbx
leaq 0x69aa(%rip), %rdi      # 0x4ed17
xorl %eax, %eax
callq 0xb080
movq (%rbx), %rsi
movq 0x20(%rbx), %rdx
leaq 0x7177(%rip), %rdi      # 0x4f4f9
xorl %eax, %eax
callq 0xb080
movl $0xa, %edi
callq 0xb7a0
leaq 0x729e(%rip), %rdi      # 0x4f638
callq 0xb8b0
movq 0x22b8a(%rip), %rax     # 0x6af30
movq (%rax), %rdi
popq %rbx
jmp 0xb630
nop
// File: /workspace/github_cpp_makefile_star2_O1/Barath-Kannan[P]SignalsAndSlots/3rdparty/googletest/src/CustomTestPrinter.cpp
// Function: CustomTestPrinter::OnTestPartResult(testing::TestPartResult const&)
void OnTestPartResult(
            const TestPartResult& result) {
        // If the test part succeeded, we don't need to do anything.
        if (result.type() == TestPartResult::kSuccess)
            return;
        PRINT_FAILSTART_MARKER;
        printf("Failure in %s:%d\n%s\n",
                result.file_name(),
                result.line_number(),
                result.summary());
        PRINT_FAILEND_MARKER;
        fflush(stdout);
    }

// Assembly:
cmpl $0x0, (%rsi)
je 0x48403
pushq %rbx
movq %rsi, %rbx
leaq 0x71da(%rip), %rdi      # 0x4f59a
callq 0xb8b0
movq 0x10(%rbx), %rsi
testq %rsi, %rsi
je 0x483d2
movq 0x8(%rbx), %rsi
movl 0x28(%rbx), %edx
movq 0x30(%rbx), %rcx
leaq 0x712c(%rip), %rdi      # 0x4f50c
xorl %eax, %eax
callq 0xb080
leaq 0x71f3(%rip), %rdi      # 0x4f5e1
callq 0xb8b0
movq 0x22b36(%rip), %rax     # 0x6af30
movq (%rax), %rdi
popq %rbx
jmp 0xb630
retq
// File: /workspace/github_cpp_makefile_star2_O1/Barath-Kannan[P]SignalsAndSlots/3rdparty/googletest/src/CustomTestPrinter.cpp
// Function: CustomTestPrinter::OnTestEnd(testing::TestInfo const&)
void OnTestEnd(const TestInfo& test_info) {
        PRINT_SEPARATOR;
        PRINT_LONG_EXTENDER;
        printf("Test %s.%s %s", test_info.test_case_name(), test_info.name(), test_info.result()->Passed() ? "PASSED" : "FAILED");

        if (test_info.result()->Failed())
            PrintFullTestCommentIfPresent(test_info);

        if (GTEST_FLAG(print_time)) {
            printf(" (%ld ms)\n", (long)test_info.result()->elapsed_time());
        } else {
            printf("\n");
        }
        PRINT_SEPARATOR;
        fflush(stdout);
    }

// Assembly:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
movq %rsi, %rbx
movq %rdi, %r14
leaq 0x721e(%rip), %rdi      # 0x4f638
callq 0xb8b0
leaq 0x68f1(%rip), %rdi      # 0x4ed17
xorl %eax, %eax
callq 0xb080
movq (%rbx), %r15
movq 0x20(%rbx), %r12
leaq 0x90(%rbx), %r13
movq %r13, %rdi
callq 0x2d4d2
leaq 0x6b80(%rip), %rdx      # 0x4efca
leaq 0x70de(%rip), %rcx      # 0x4f52f
testb %al, %al
cmovneq %rdx, %rcx
leaq 0x70c3(%rip), %rdi      # 0x4f521
movq %r15, %rsi
movq %r12, %rdx
xorl %eax, %eax
callq 0xb080
movq %r13, %rdi
callq 0x2d4d2
testb %al, %al
je 0x48482
movq %r14, %rdi
movq %rbx, %rsi
callq 0x48750
leaq 0x75607(%rip), %rax     # 0xbda90
cmpb $0x1, (%rax)
jne 0x484a5
movq 0x100(%rbx), %rsi
leaq 0x709a(%rip), %rdi      # 0x4f536
xorl %eax, %eax
callq 0xb080
jmp 0x484af
movl $0xa, %edi
callq 0xb7a0
leaq 0x7182(%rip), %rdi      # 0x4f638
callq 0xb8b0
movq 0x22a6e(%rip), %rax     # 0x6af30
movq (%rax), %rdi
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
jmp 0xb630
nop
// File: /workspace/github_cpp_makefile_star2_O1/Barath-Kannan[P]SignalsAndSlots/3rdparty/googletest/src/CustomTestPrinter.cpp
// Function: CustomTestPrinter::OnTestCaseEnd(testing::TestCase const&)
void OnTestCaseEnd(const TestCase& test_case) {
        if (!GTEST_FLAG(print_time)) return;
        PRINT_ALT_EXTENDER;
        printf("%d %s from %s (%ld ms total)\n", 
                test_case.test_to_run_count(), test_case.test_to_run_count() == 1 ? "test" : "tests", test_case.name(), (long)test_case.elapsed_time());
        PRINT_SEPARATOR;
        fflush(stdout);
    }

// Assembly:
leaq 0x755b5(%rip), %rax     # 0xbda90
cmpb $0x1, (%rax)
jne 0x48554
pushq %rbp
pushq %rbx
pushq %rax
movq %rsi, %rbx
leaq 0x6ffa(%rip), %rdi      # 0x4f4e7
xorl %eax, %eax
callq 0xb080
movq %rbx, %rdi
callq 0x293d2
movl %eax, %ebp
movq %rbx, %rdi
callq 0x293d2
cmpl $0x1, %eax
leaq 0x6842(%rip), %rax      # 0x4ed52
leaq 0x54dd(%rip), %rdx      # 0x4d9f4
cmoveq %rax, %rdx
movq 0x8(%rbx), %rcx
movq 0x78(%rbx), %r8
leaq 0x7017(%rip), %rdi      # 0x4f541
movl %ebp, %esi
xorl %eax, %eax
callq 0xb080
leaq 0x70fe(%rip), %rdi      # 0x4f638
callq 0xb8b0
movq 0x229ea(%rip), %rax     # 0x6af30
movq (%rax), %rdi
addq $0x8, %rsp
popq %rbx
popq %rbp
jmp 0xb630
retq
nop
// File: /workspace/github_cpp_makefile_star2_O1/Barath-Kannan[P]SignalsAndSlots/3rdparty/googletest/src/CustomTestPrinter.cpp
// Function: CustomTestPrinter::PrintFailedTests(testing::UnitTest const&)
void PrintFailedTests(const UnitTest& unit_test) {
        const int failed_test_count = unit_test.failed_test_count();
        if (failed_test_count == 0) {
            return;
        }
        PRINT_SEPARATOR;
        printf("Failed tests: \n");
        for (int i = 0; i < unit_test.total_test_case_count(); ++i) {
            const TestCase& test_case = *unit_test.GetTestCase(i);
            if (!test_case.should_run() || (test_case.failed_test_count() == 0)) {
                continue;
            }

            for (int j = 0; j < test_case.total_test_count(); ++j) {
                const TestInfo& test_info = *test_case.GetTestInfo(j);
                if (!test_info.should_run() || test_info.result()->Passed()) {
                    continue;
                }
                PRINT_EXTENDER;
                printf("%s.%s", test_case.name(), test_info.name());
                PrintFullTestCommentIfPresent(test_info);
                printf("\n");
            }   
        }
        PRINT_SEPARATOR;
    }

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq %rdi, %r14
movq %rsi, %rdi
callq 0x3007c
testl %eax, %eax
je 0x48906
leaq 0x6e28(%rip), %rdi      # 0x4f638
callq 0xb8b0
leaq 0x6e0d(%rip), %rdi      # 0x4f629
callq 0xb8b0
movq %rbx, %rdi
callq 0x30086
testl %eax, %eax
jle 0x488ec
xorl %ebp, %ebp
movq %rbx, %rdi
movl %ebp, %esi
callq 0x3009e
cmpb $0x1, 0x70(%rax)
jne 0x488da
movq %rax, %r13
movq %rax, %rdi
callq 0x29124
testl %eax, %eax
je 0x488da
movq %r13, %rdi
callq 0x29360
testl %eax, %eax
jle 0x488da
xorl %r15d, %r15d
movq %r13, %rdi
movl %r15d, %esi
callq 0x2eae4
cmpb $0x1, 0x80(%rax)
jne 0x488ca
movq %rax, %r12
leaq 0x90(%rax), %rdi
callq 0x2d4d2
testb %al, %al
je 0x488ca
leaq 0x6c25(%rip), %rdi      # 0x4f4bc
xorl %eax, %eax
callq 0xb080
movq 0x8(%r13), %rsi
movq 0x20(%r12), %rdx
leaq 0x51b7(%rip), %rdi      # 0x4da65
xorl %eax, %eax
callq 0xb080
movq %r14, %rdi
movq %r12, %rsi
callq 0x48750
movl $0xa, %edi
callq 0xb7a0
incl %r15d
movq %r13, %rdi
callq 0x29360
cmpl %eax, %r15d
jl 0x48869
incl %ebp
movq %rbx, %rdi
callq 0x30086
cmpl %eax, %ebp
jl 0x48833
leaq 0x6d45(%rip), %rdi      # 0x4f638
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0xb8b0
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O1/mehrangoli[P]Static-Data-Extractor/main.cpp
// Function: main
int main()
{
	string DebugSymbolPath;
    cout << "Please enter the Debug Symbol path: ";
    cin >> DebugSymbolPath;
	
	ifstream InputFile(DebugSymbolPath.c_str());
	ScMain scmain;
	
	bool flag = scmain.find_scmain(InputFile);
	if (flag){
		cout << "\033[1;32mStarting XML file generation...\033[0m\n";
		scmain.print_data_XML ();
		cout <<"\033[1;32mXML file is successfully generated!\033[0m\n";
		scmain.print_data ();
	}
	else
		cout <<"\033[1;31mUnable to generate XML file!\033[0m\n";
	
	return 0;
}

// Assembly:
pushq %r14
pushq %rbx
subq $0x248, %rsp            # imm = 0x248
leaq 0x10(%rsp), %r14
movq %r14, -0x10(%r14)
movq $0x0, -0x8(%r14)
movb $0x0, (%r14)
movq 0x10a6e(%rip), %rdi     # 0x13fd0
leaq 0xbaf7(%rip), %rsi      # 0xf060
movl $0x24, %edx
callq 0x2210
movq 0x10a66(%rip), %rdi     # 0x13fe0
movq %rsp, %rsi
callq 0x2230
movq (%rsp), %rsi
leaq 0x40(%rsp), %rdi
movl $0x8, %edx
callq 0x2320
xorps %xmm0, %xmm0
leaq 0x20(%rsp), %rdi
movaps %xmm0, (%rdi)
movq $0x0, 0x10(%rdi)
leaq 0x40(%rsp), %rsi
callq 0x7cc4
testb %al, %al
je 0x35fc
movq 0x10a13(%rip), %rdi     # 0x13fd0
leaq 0xbac1(%rip), %rsi      # 0xf085
movl $0x2b, %edx
callq 0x2210
leaq 0x20(%rsp), %rdi
callq 0x3eac
movq 0x109f1(%rip), %rdi     # 0x13fd0
leaq 0xbacb(%rip), %rsi      # 0xf0b1
movl $0x2f, %edx
callq 0x2210
leaq 0x20(%rsp), %rdi
callq 0x3aec
jmp 0x3614
movq 0x109cd(%rip), %rdi     # 0x13fd0
leaq 0xbad7(%rip), %rsi      # 0xf0e1
movl $0x28, %edx
callq 0x2210
leaq 0x20(%rsp), %rdi
callq 0x372c
leaq 0x40(%rsp), %rdi
callq 0x2080
movq (%rsp), %rdi
cmpq %r14, %rdi
je 0x363e
movq 0x10(%rsp), %rsi
incq %rsi
callq 0x21d0
xorl %eax, %eax
addq $0x248, %rsp            # imm = 0x248
popq %rbx
popq %r14
retq
jmp 0x364d
movq %rax, %rbx
jmp 0x3669
movq %rax, %rbx
leaq 0x20(%rsp), %rdi
callq 0x372c
leaq 0x40(%rsp), %rdi
callq 0x2080
movq (%rsp), %rdi
cmpq %r14, %rdi
je 0x367f
movq 0x10(%rsp), %rsi
incq %rsi
callq 0x21d0
movq %rbx, %rdi
callq 0x2300
nop
// File: /workspace/github_cpp_makefile_star2_O1/mehrangoli[P]Static-Data-Extractor/SCmain.cpp
// Function: ScMain::find_element(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>)
int ScMain::find_element (string str){
	for (int i=0; i< static_data_final.size(); ++i){
		if (static_data_final[i].get_name() == str)
			return i;
	}
	return -1;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x28, %rsp
movq %rsi, %r14
movq (%rdi), %rsi
movl $0xffffffff, %eax       # imm = 0xFFFFFFFF
cmpq %rsi, 0x8(%rdi)
je 0x44ab
movq %rdi, %r15
xorl %ebp, %ebp
leaq 0x8(%rsp), %r12
xorl %ebx, %ebx
addq %rbp, %rsi
movq %r12, %rdi
callq 0xc720
movq 0x10(%rsp), %rdx
cmpq 0x8(%r14), %rdx
jne 0x444d
testq %rdx, %rdx
je 0x4452
movq (%r14), %rsi
movq 0x8(%rsp), %rdi
callq 0x21e0
testl %eax, %eax
sete %r13b
jmp 0x4455
xorl %r13d, %r13d
jmp 0x4455
movb $0x1, %r13b
movq 0x8(%rsp), %rdi
leaq 0x18(%rsp), %rax
cmpq %rax, %rdi
je 0x4471
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x21d0
testb %r13b, %r13b
jne 0x44a9
incq %rbx
movq (%r15), %rsi
movq 0x8(%r15), %rax
subq %rsi, %rax
sarq $0x4, %rax
movabsq $0x6db6db6db6db6db7, %rcx # imm = 0x6DB6DB6DB6DB6DB7
imulq %rcx, %rax
addq $0x70, %rbp
cmpq %rbx, %rax
ja 0x441d
movl $0xffffffff, %eax       # imm = 0xFFFFFFFF
jmp 0x44ab
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_O1/mehrangoli[P]Static-Data-Extractor/Define.cpp
// Function: string_finder(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>)
bool string_finder (string str1, string str2){
	size_t found = str1.find(str2);
	
	if (found!=string::npos)
		return 1;
	else
		return 0;
}

// Assembly:
pushq %rax
movq (%rsi), %rax
movq 0x8(%rsi), %rcx
movq %rax, %rsi
xorl %edx, %edx
callq 0x22f0
cmpq $-0x1, %rax
setne %al
popq %rcx
retq
// File: /workspace/github_cpp_makefile_star2_O1/mehrangoli[P]Static-Data-Extractor/Define.cpp
// Function: GotoLine(std::basic_ifstream<char, std::char_traits<char>>&, unsigned int)
void GotoLine(ifstream& file, unsigned int num){
	file.clear();
    file.seekg(0, ios::beg);
	
    for(int i=0; i < num; ++i){
        file.ignore(numeric_limits<streamsize>::max(),'\n');
    }
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movl %esi, %ebx
movq %rdi, %r14
movq (%rdi), %rax
movq -0x18(%rax), %rdi
addq %r14, %rdi
xorl %esi, %esi
callq 0x22d0
movq %r14, %rdi
xorl %esi, %esi
xorl %edx, %edx
callq 0x2250
testl %ebx, %ebx
je 0xad64
movabsq $0x7fffffffffffffff, %r15 # imm = 0x7FFFFFFFFFFFFFFF
movq %r14, %rdi
movq %r15, %rsi
movl $0xa, %edx
callq 0x2130
decl %ebx
jne 0xad50
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_cpp_makefile_star2_O1/mehrangoli[P]Static-Data-Extractor/Define.cpp
// Function: split(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&, char)
vector<string> split(const string &s, char delim) {
    vector<string> elems;
	string buff;                 //-----buffer string
    stringstream ss(s);       //-----insert the string into a stream
	
	while (getline(ss, buff, delim))
		elems.push_back(buff);
	return elems;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x1b0, %rsp            # imm = 0x1B0
movl %edx, %ebp
movq %rdi, %rbx
xorl %eax, %eax
movq %rax, 0x10(%rdi)
xorps %xmm0, %xmm0
movups %xmm0, (%rdi)
leaq 0x18(%rsp), %r12
movq %r12, -0x10(%r12)
movq %rax, -0x8(%r12)
movb $0x0, (%r12)
leaq 0x28(%rsp), %rdi
movl $0x18, %edx
callq 0x22b0
movsbl %bpl, %ebp
leaq 0x28(%rsp), %r14
leaq 0x8(%rsp), %r15
movq %r14, %rdi
movq %r15, %rsi
movl %ebp, %edx
callq 0x2330
movq (%rax), %rcx
movq -0x18(%rcx), %rcx
testb $0x5, 0x20(%rax,%rcx)
jne 0xade3
movq %rbx, %rdi
movq %r15, %rsi
callq 0xbf34
jmp 0xadbb
movq 0x91c6(%rip), %rsi      # 0x13fb0
leaq 0x28(%rsp), %rdi
callq 0x2160
leaq 0xa8(%rsp), %rdi
callq 0x20c0
movq 0x8(%rsp), %rdi
cmpq %r12, %rdi
je 0xae18
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x21d0
movq %rbx, %rax
addq $0x1b0, %rsp            # imm = 0x1B0
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %r14
jmp 0xae51
movq %rax, %r14
movq 0x9176(%rip), %rsi      # 0x13fb0
leaq 0x28(%rsp), %rdi
callq 0x2160
leaq 0xa8(%rsp), %rdi
callq 0x20c0
movq 0x8(%rsp), %rdi
cmpq %r12, %rdi
je 0xae68
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x21d0
movq %rbx, %rdi
callq 0x36d0
movq %r14, %rdi
callq 0x2300