LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: Barath-Kannan[P]SignalsAndSlots/test/SafeQueue.hpp
// Function: BSignals::details::SafeQueue<BigThing>::enqueue(BigThing const&)
void enqueue(const T &t){
        std::unique_lock<std::mutex> lock(m);
        q.push(t);
        lock.unlock();
        c.notify_one();
    }

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rsi
movq %rsi, -0x38(%rbp)
addq $0x258, %rsi            # imm = 0x258
leaq -0x20(%rbp), %rdi
callq 0x10630
movq -0x38(%rbp), %rdi
addq $0x208, %rdi            # imm = 0x208
movq -0x10(%rbp), %rsi
callq 0x2c010
jmp 0x1bfee
leaq -0x20(%rbp), %rdi
callq 0x10890
jmp 0x1bff9
movq -0x38(%rbp), %rdi
addq $0x280, %rdi            # imm = 0x280
callq 0xd320
leaq -0x20(%rbp), %rdi
callq 0x10730
addq $0x40, %rsp
popq %rbp
retq
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x28(%rbp)
movl %eax, -0x2c(%rbp)
leaq -0x20(%rbp), %rdi
callq 0x10730
movq -0x28(%rbp), %rdi
callq 0xdcb0
nopw %cs:(%rax,%rax)
// File: 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 %rbp
movq %rsp, %rbp
subq $0x60, %rsp
movq %rdi, -0x48(%rbp)
movq %rdi, -0x40(%rbp)
movq %rsi, -0x8(%rbp)
movq -0x8(%rbp), %rsi
movq %rsi, -0x38(%rbp)
addq $0x258, %rsi            # imm = 0x258
leaq -0x18(%rbp), %rdi
callq 0x10630
movq -0x38(%rbp), %rax
testb $0x1, 0x200(%rax)
je 0x1cb17
movq -0x38(%rbp), %rsi
movq -0x48(%rbp), %rdi
movl $0x200, %edx            # imm = 0x200
callq 0xd530
movl $0x1, -0x1c(%rbp)
jmp 0x1cbcd
jmp 0x1cb19
movq -0x38(%rbp), %rdi
addq $0x208, %rdi            # imm = 0x208
callq 0x42530
movb %al, -0x49(%rbp)
jmp 0x1cb2e
movb -0x49(%rbp), %al
testb $0x1, %al
jne 0x1cb37
jmp 0x1cb8c
movq -0x38(%rbp), %rdi
addq $0x280, %rdi            # imm = 0x280
leaq -0x18(%rbp), %rsi
callq 0xd1a0
movq -0x38(%rbp), %rax
testb $0x1, 0x200(%rax)
je 0x1cb8a
movq -0x38(%rbp), %rsi
movq -0x48(%rbp), %rdi
movl $0x200, %edx            # imm = 0x200
callq 0xd530
movl $0x1, -0x1c(%rbp)
jmp 0x1cbcd
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x28(%rbp)
movl %eax, -0x2c(%rbp)
leaq -0x18(%rbp), %rdi
callq 0x10730
jmp 0x1cbe0
jmp 0x1cb19
movq -0x38(%rbp), %rdi
addq $0x208, %rdi            # imm = 0x208
callq 0x42550
movq %rax, -0x58(%rbp)
jmp 0x1cba2
movq -0x58(%rbp), %rsi
movq -0x48(%rbp), %rdi
movl $0x200, %edx            # imm = 0x200
callq 0xd530
movq -0x38(%rbp), %rdi
addq $0x208, %rdi            # imm = 0x208
callq 0x42570
jmp 0x1cbc6
movl $0x1, -0x1c(%rbp)
leaq -0x18(%rbp), %rdi
callq 0x10730
movq -0x40(%rbp), %rax
addq $0x60, %rsp
popq %rbp
retq
movq -0x28(%rbp), %rdi
callq 0xdcb0
nopl (%rax)
// File: 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 %rbp
movq %rsp, %rbp
subq $0x90, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movq %rdx, -0x18(%rbp)
movq %rcx, -0x20(%rbp)
movq -0x8(%rbp), %rsi
movq %rsi, -0x80(%rbp)
movq -0x18(%rbp), %rdx
movq -0x20(%rbp), %rax
movq (%rax), %rcx
leaq -0x40(%rbp), %rdi
movq %rdi, -0x78(%rbp)
callq 0x1eb20
movq -0x78(%rbp), %rsi
movl -0xc(%rbp), %eax
movl %eax, -0x70(%rbp)
leaq -0x60(%rbp), %rdi
callq 0x1edd0
jmp 0x1eaaf
movl -0x70(%rbp), %esi
movq -0x80(%rbp), %rdi
leaq -0x60(%rbp), %rdx
callq 0x1eb60
movl %eax, -0x84(%rbp)
jmp 0x1eac7
leaq -0x60(%rbp), %rdi
callq 0x1ee80
leaq -0x40(%rbp), %rdi
callq 0x1ee80
movl -0x84(%rbp), %eax
addq $0x90, %rsp
popq %rbp
retq
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x68(%rbp)
movl %eax, -0x6c(%rbp)
jmp 0x1eb0b
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x68(%rbp)
movl %eax, -0x6c(%rbp)
leaq -0x60(%rbp), %rdi
callq 0x1ee80
leaq -0x40(%rbp), %rdi
callq 0x1ee80
movq -0x68(%rbp), %rdi
callq 0xdcb0
nopl (%rax)
// File: 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 %rbp
movq %rsp, %rbp
subq $0x70, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x70(%rbp)
leaq -0xc(%rbp), %rdi
callq 0x219f0
callq 0x118a0
movsd %xmm0, -0x18(%rbp)
movq 0x83d0a(%rip), %rax     # 0xa5098
movq %rax, -0x20(%rbp)
movq -0x70(%rbp), %rax
movb 0x238(%rax), %al
xorb $-0x1, %al
testb $0x1, %al
jne 0x213a7
jmp 0x21492
movq -0x70(%rbp), %rdi
addq $0x30, %rdi
leaq -0xc(%rbp), %rsi
callq 0x21aa0
testb $0x1, %al
jne 0x213be
jmp 0x21403
movq -0x70(%rbp), %rax
testb $0x1, 0x238(%rax)
jne 0x213d8
movq -0x70(%rbp), %rdi
leaq -0xc(%rbp), %rsi
callq 0x21af0
movl $0x1, -0x3c(%rbp)
leaq -0x38(%rbp), %rdi
leaq -0x3c(%rbp), %rsi
callq 0x12180
leaq -0x30(%rbp), %rdi
leaq -0x38(%rbp), %rsi
callq 0x10040
movq -0x30(%rbp), %rax
movq %rax, -0x20(%rbp)
jmp 0x21426
leaq -0x20(%rbp), %rdi
callq 0x121d0
movsd 0x83d8c(%rip), %xmm0    # 0xa51a0
movsd %xmm0, -0x48(%rbp)
leaq -0x20(%rbp), %rdi
leaq -0x48(%rbp), %rsi
callq 0x12280
leaq -0x20(%rbp), %rdi
leaq -0x18(%rbp), %rsi
callq 0x122b0
testb $0x1, %al
jne 0x21439
jmp 0x2148d
movq -0x70(%rbp), %rdi
addq $0x30, %rdi
leaq -0xc(%rbp), %rsi
callq 0x21b30
movq -0x70(%rbp), %rax
testb $0x1, 0x238(%rax)
jne 0x21464
movq -0x70(%rbp), %rdi
leaq -0xc(%rbp), %rsi
callq 0x21af0
movl $0x1, -0x64(%rbp)
leaq -0x60(%rbp), %rdi
leaq -0x64(%rbp), %rsi
callq 0x12180
leaq -0x58(%rbp), %rdi
leaq -0x60(%rbp), %rsi
callq 0x10040
movq -0x58(%rbp), %rax
movq %rax, -0x20(%rbp)
jmp 0x21392
addq $0x70, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: Barath-Kannan[P]SignalsAndSlots/inc/BSignals/details/SignalImpl.hpp
// Function: BSignals::details::SignalImpl<unsigned int>::getIsStillConnectedFromExecutor(unsigned int) const
inline bool getIsStillConnectedFromExecutor(uint32_t id) const{
        slotLock.lock_shared();
        auto it = slots.find(id);
        bool retVal = (it != slots.end() && it->second->isAlive());
        slotLock.unlock_shared();
        return retVal;
    }

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x38(%rbp)
addq $0x18, %rdi
callq 0x10b60
movq -0x38(%rbp), %rdi
addq $0x88, %rdi
leaq -0xc(%rbp), %rsi
callq 0x24220
movq -0x38(%rbp), %rdi
movq %rax, -0x18(%rbp)
addq $0x88, %rdi
callq 0x24280
movq %rax, -0x28(%rbp)
leaq -0x18(%rbp), %rdi
leaq -0x28(%rbp), %rsi
callq 0x24250
movb %al, %cl
xorl %eax, %eax
testb $0x1, %cl
movb %al, -0x29(%rbp)
jne 0x241d7
jmp 0x241f7
leaq -0x18(%rbp), %rdi
callq 0x242b0
movq %rax, %rdi
addq $0x8, %rdi
callq 0x242d0
movq %rax, %rdi
callq 0x242f0
movb %al, -0x29(%rbp)
movq -0x38(%rbp), %rdi
movb -0x29(%rbp), %al
andb $0x1, %al
movb %al, -0x19(%rbp)
addq $0x18, %rdi
callq 0x10f40
movb -0x19(%rbp), %al
andb $0x1, %al
addq $0x40, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: Barath-Kannan[P]SignalsAndSlots/inc/BSignals/details/ThreadPooledSlot.hpp
// Function: BSignals::details::ThreadPooledSlot<unsigned int>::execute(unsigned int const&)::'lambda'()::operator()() const
void execute(const Args& ... args){
        WheeledThreadPool::run([this, args...](){
            if (!checkIfValid || checkIfValid()){
                this->slotFunction(args...);
            }
        });
    }

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x18(%rbp)
movq (%rax), %rdi
movq %rdi, -0x10(%rbp)
addq $0x30, %rdi
callq 0x249e0
testb $0x1, %al
jne 0x24c5a
jmp 0x24c6d
movq -0x10(%rbp), %rdi
addq $0x30, %rdi
callq 0x24c90
testb $0x1, %al
jne 0x24c6d
jmp 0x24c81
movq -0x18(%rbp), %rax
movq -0x10(%rbp), %rdi
addq $0x8, %rdi
movl 0x8(%rax), %esi
callq 0x227e0
addq $0x20, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: Barath-Kannan[P]SignalsAndSlots/inc/BSignals/details/AsynchronousSlot.hpp
// Function: BSignals::details::AsynchronousSlot<unsigned int>::execute(unsigned int 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 %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x48(%rbp)
addq $0x50, %rdi
callq 0x10470
movq -0x48(%rbp), %rax
movq %rax, -0x28(%rbp)
movq -0x10(%rbp), %rax
movl (%rax), %eax
movl %eax, -0x20(%rbp)
leaq -0x18(%rbp), %rdi
movq %rdi, -0x40(%rbp)
leaq -0x28(%rbp), %rsi
callq 0x257b0
movq -0x40(%rbp), %rdi
callq 0xdca0
jmp 0x2577e
leaq -0x18(%rbp), %rdi
callq 0x12ca0
addq $0x50, %rsp
popq %rbp
retq
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x30(%rbp)
movl %eax, -0x34(%rbp)
leaq -0x18(%rbp), %rdi
callq 0x12ca0
movq -0x30(%rbp), %rdi
callq 0xdcb0
nopl (%rax,%rax)
// File: 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
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x30(%rbp)
testb $0x1, 0x4(%rax)
je 0x37991
movq -0x30(%rbp), %rdi
addq $0x18, %rdi
callq 0x10b60
movq -0x30(%rbp), %rdi
addq $0x88, %rdi
movl -0xc(%rbp), %eax
movl %eax, -0x1c(%rbp)
leaq -0x1c(%rbp), %rsi
callq 0x379b0
movq -0x30(%rbp), %rdi
movq %rax, -0x18(%rbp)
addq $0x88, %rdi
callq 0x2fc10
movq %rax, -0x28(%rbp)
leaq -0x18(%rbp), %rdi
leaq -0x28(%rbp), %rsi
callq 0x36440
testb $0x1, %al
jne 0x37963
jmp 0x37965
jmp 0x3799d
leaq -0x18(%rbp), %rdi
callq 0x36ee0
movq %rax, %rdi
addq $0x8, %rdi
callq 0x32f80
movq %rax, %rdi
callq 0x379e0
movq -0x30(%rbp), %rdi
addq $0x18, %rdi
callq 0x10f40
jmp 0x3799d
movq -0x30(%rbp), %rdi
movl -0xc(%rbp), %esi
callq 0x37a10
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
nopl (%rax)
// File: Barath-Kannan[P]SignalsAndSlots/inc/BSignals/details/SignalImpl.hpp
// Function: BSignals::details::SignalImpl<int, int>::disconnectSlotFunction(unsigned int)
inline void disconnectSlotFunction(uint32_t id){
        slotLock.lock();
        auto it = slots.find(id);
        if (it == slots.end()) return;
        slots.erase(it);
        slotLock.unlock();
    }

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x38(%rbp)
addq $0x18, %rdi
callq 0x10920
movq -0x38(%rbp), %rdi
addq $0x88, %rdi
leaq -0xc(%rbp), %rsi
callq 0x379b0
movq -0x38(%rbp), %rdi
movq %rax, -0x18(%rbp)
addq $0x88, %rdi
callq 0x2fc10
movq %rax, -0x20(%rbp)
leaq -0x18(%rbp), %rdi
leaq -0x20(%rbp), %rsi
callq 0x36440
testb $0x1, %al
jne 0x37a6f
jmp 0x37a71
jmp 0x37a9e
movq -0x38(%rbp), %rdi
addq $0x88, %rdi
movq -0x18(%rbp), %rax
movq %rax, -0x28(%rbp)
movq -0x28(%rbp), %rsi
callq 0x36f00
movq -0x38(%rbp), %rdi
movq %rax, -0x30(%rbp)
addq $0x18, %rdi
callq 0x10a60
addq $0x40, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
nop
// File: 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
movq %rsp, %rbp
subq $0x60, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x50(%rbp)
addq $0x18, %rdi
callq 0x10b60
leaq -0x30(%rbp), %rdi
callq 0x26330
movq -0x50(%rbp), %rdi
addq $0x8, %rdi
callq 0x25e90
testb $0x1, %al
jne 0x38313
movl $0x1, -0x34(%rbp)
jmp 0x3839c
jmp 0x38315
movq -0x50(%rbp), %rdi
addq $0x8, %rdi
callq 0x27970
movq %rax, %rdi
leaq -0x30(%rbp), %rsi
callq 0x267a0
movb %al, -0x51(%rbp)
jmp 0x38333
movb -0x51(%rbp), %al
testb $0x1, %al
jne 0x3833c
jmp 0x38386
movq -0x50(%rbp), %rax
testb $0x1, 0x4(%rax)
je 0x38360
movq -0x50(%rbp), %rdi
movl -0x10(%rbp), %esi
callq 0x32e20
movb %al, -0x52(%rbp)
jmp 0x38357
movb -0x52(%rbp), %al
testb $0x1, %al
jne 0x38360
jmp 0x38384
leaq -0x30(%rbp), %rdi
callq 0x12140
jmp 0x3836b
jmp 0x38384
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x40(%rbp)
movl %eax, -0x44(%rbp)
leaq -0x30(%rbp), %rdi
callq 0x26360
jmp 0x383ab
jmp 0x38315
movq -0x50(%rbp), %rdi
addq $0x18, %rdi
callq 0x10f40
jmp 0x38395
movl $0x0, -0x34(%rbp)
leaq -0x30(%rbp), %rdi
callq 0x26360
addq $0x60, %rsp
popq %rbp
retq
movq -0x40(%rbp), %rdi
callq 0xdcb0
nopw %cs:(%rax,%rax)
nop
// File: 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 %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x8(%rbp)
leaq 0xfaf55(%rip), %rax     # 0x14db98
cmpq $0x0, (%rax)
setne %al
movzbl %al, %edi
andl $0x1, %edi
callq 0x6c7c0
testb $0x1, %al
jne 0x52c5b
jmp 0x52c60
jmp 0x52ce6
leaq 0x54b3f(%rip), %rdx     # 0xa77a6
leaq -0xc(%rbp), %rdi
movq %rdi, -0x30(%rbp)
movl $0x3, %esi
movl $0x6dc, %ecx            # imm = 0x6DC
callq 0xa19e0
movq -0x30(%rbp), %rdi
callq 0x55090
movq %rax, %rdi
leaq 0x54b3b(%rip), %rsi     # 0xa77cc
callq 0xd640
movq %rax, -0x28(%rbp)
jmp 0x52c9c
movq -0x28(%rbp), %rdi
leaq 0x54b4b(%rip), %rsi     # 0xa77f2
callq 0xd640
movq %rax, -0x38(%rbp)
jmp 0x52cb2
movq -0x38(%rbp), %rdi
leaq 0x54b76(%rip), %rsi     # 0xa7833
callq 0xd640
jmp 0x52cc4
leaq -0xc(%rbp), %rdi
callq 0xa1b20
jmp 0x52ce6
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x18(%rbp)
movl %eax, -0x1c(%rbp)
leaq -0xc(%rbp), %rdi
callq 0xa1b20
jmp 0x52cf6
leaq 0xfaeab(%rip), %rax     # 0x14db98
movq (%rax), %rax
addq $0x40, %rsp
popq %rbp
retq
movq -0x18(%rbp), %rdi
callq 0xdcb0
nop
// File: Barath-Kannan[P]SignalsAndSlots/3rdparty/googletest/inc/gtest/internal/gtest-linked_ptr.h
// Function: void testing::internal::linked_ptr<testing::internal::ParameterizedTestCaseInfo<SignalTestParametrized>::TestInfo>::copy<testing::internal::ParameterizedTestCaseInfo<SignalTestParametrized>::TestInfo>(testing::internal::linked_ptr<testing::internal::ParameterizedTestCaseInfo<SignalTestParametrized>::TestInfo> const*)
void copy(linked_ptr<U> const* ptr) {
    value_ = ptr->get();
    if (value_)
      link_.join(&ptr->link_);
    else
      link_.join_new();
  }

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x18(%rbp)
movq -0x10(%rbp), %rdi
callq 0x54e60
movq %rax, %rcx
movq -0x18(%rbp), %rax
movq %rcx, (%rax)
cmpq $0x0, (%rax)
je 0x54e48
movq -0x18(%rbp), %rdi
addq $0x8, %rdi
movq -0x10(%rbp), %rsi
addq $0x8, %rsi
callq 0x54e80
jmp 0x54e55
movq -0x18(%rbp), %rdi
addq $0x8, %rdi
callq 0x54f30
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: 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 %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x28(%rbp)
leaq -0x18(%rbp), %rdi
leaq 0xf8dd5(%rip), %rsi     # 0x14dc78
callq 0x54f50
movq -0x10(%rbp), %rax
movq %rax, -0x20(%rbp)
movq -0x20(%rbp), %rax
movq (%rax), %rax
cmpq -0x10(%rbp), %rax
je 0x54f0d
movq -0x28(%rbp), %rdx
movq -0x20(%rbp), %rcx
xorl %eax, %eax
cmpq %rdx, (%rcx)
movb %al, -0x29(%rbp)
je 0x54ed6
movb $0x1, %al
movb %al, -0x29(%rbp)
jmp 0x54ed6
movb -0x29(%rbp), %al
testb $0x1, %al
jne 0x54edf
jmp 0x54ee1
jmp 0x54f00
leaq 0x5267a(%rip), %rdi     # 0xa7562
leaq 0x52501(%rip), %rsi     # 0xa73f0
movl $0x74, %edx
leaq 0x526d2(%rip), %rcx     # 0xa75cd
callq 0xd430
movq -0x20(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x20(%rbp)
jmp 0x54eb0
movq -0x28(%rbp), %rax
movq -0x20(%rbp), %rcx
movq %rax, (%rcx)
movq -0x10(%rbp), %rcx
movq %rcx, (%rax)
leaq -0x18(%rbp), %rdi
callq 0x54f80
addq $0x30, %rsp
popq %rbp
retq
nop
// File: 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 %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x10(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x30(%rbp)
leaq -0x18(%rbp), %rdi
leaq 0xf8369(%rip), %rsi     # 0x14dc78
callq 0x54f50
movq -0x30(%rbp), %rax
cmpq %rax, (%rax)
jne 0x5592d
movb $0x1, -0x1(%rbp)
movl $0x1, -0x1c(%rbp)
jmp 0x559b1
movq -0x30(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x28(%rbp)
movq -0x30(%rbp), %rcx
movq -0x28(%rbp), %rax
cmpq %rcx, (%rax)
je 0x55998
movq -0x30(%rbp), %rdx
movq -0x28(%rbp), %rax
movq (%rax), %rcx
xorl %eax, %eax
cmpq (%rdx), %rcx
movb %al, -0x31(%rbp)
je 0x55961
movb $0x1, %al
movb %al, -0x31(%rbp)
jmp 0x55961
movb -0x31(%rbp), %al
testb $0x1, %al
jne 0x5596a
jmp 0x5596c
jmp 0x5598b
leaq 0x51d7a(%rip), %rdi     # 0xa76ed
leaq 0x51a76(%rip), %rsi     # 0xa73f0
movl $0x86, %edx
leaq 0x51dd1(%rip), %rcx     # 0xa7757
callq 0xd430
movq -0x28(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x28(%rbp)
jmp 0x55938
movq -0x30(%rbp), %rax
movq (%rax), %rcx
movq -0x28(%rbp), %rax
movq %rcx, (%rax)
movb $0x0, -0x1(%rbp)
movl $0x1, -0x1c(%rbp)
leaq -0x18(%rbp), %rdi
callq 0x54f80
movb -0x1(%rbp), %al
andb $0x1, %al
addq $0x40, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
nop
// File: Barath-Kannan[P]SignalsAndSlots/3rdparty/googletest/inc/gtest/internal/gtest-param-util.h
// Function: testing::internal::ParameterizedTestCaseInfo<SignalTestParametrized>::IsValidParamName(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&)
static bool IsValidParamName(const std::string& name) {
    // Check for empty string
    if (name.empty())
      return false;

    // Check for invalid characters
    for (std::string::size_type index = 0; index < name.size(); ++index) {
      if (!isalnum(name[index]) && name[index] != '_')
        return false;
    }

    return true;
  }

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movq -0x10(%rbp), %rdi
callq 0xdc00
testb $0x1, %al
jne 0x57a2b
jmp 0x57a31
movb $0x0, -0x1(%rbp)
jmp 0x57a9f
movq $0x0, -0x18(%rbp)
movq -0x18(%rbp), %rax
movq %rax, -0x20(%rbp)
movq -0x10(%rbp), %rdi
callq 0xd470
movq %rax, %rcx
movq -0x20(%rbp), %rax
cmpq %rcx, %rax
jae 0x57a9b
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rsi
callq 0xd760
movsbl (%rax), %edi
callq 0xd6a0
cmpl $0x0, %eax
jne 0x57a8b
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rsi
callq 0xd760
movsbl (%rax), %eax
cmpl $0x5f, %eax
je 0x57a8b
movb $0x0, -0x1(%rbp)
jmp 0x57a9f
jmp 0x57a8d
movq -0x18(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x18(%rbp)
jmp 0x57a39
movb $0x1, -0x1(%rbp)
movb -0x1(%rbp), %al
andb $0x1, %al
addq $0x20, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: Barath-Kannan[P]SignalsAndSlots/3rdparty/googletest/inc/gtest/gtest-printers.h
// Function: void testing::internal::TuplePrefixPrinter<6ul>::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 %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
callq 0x58d10
movq -0x10(%rbp), %rdi
leaq 0x51f6a(%rip), %rsi     # 0xaac52
callq 0xd640
movq -0x8(%rbp), %rdi
callq 0x58d90
movq %rax, %rdi
movq -0x10(%rbp), %rsi
callq 0x58d60
addq $0x10, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: 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
movq %rsp, %rbp
subq $0xb0, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x80(%rbp)
callq 0xd0a0
movq %rax, -0x10(%rbp)
callq 0xd0a0
movq %rax, -0x28(%rbp)
leaq -0x28(%rbp), %rdi
leaq -0x10(%rbp), %rsi
callq 0xfff0
movq %rax, -0x20(%rbp)
leaq -0x18(%rbp), %rdi
leaq -0x20(%rbp), %rsi
callq 0x10040
movq -0x80(%rbp), %rsi
addq $0x8, %rsi
leaq -0x38(%rbp), %rdi
callq 0x10630
movq -0x18(%rbp), %rax
movq %rax, -0x40(%rbp)
movq -0x80(%rbp), %rdi
callq 0x111b0
testb $0x1, %al
jne 0x62ca2
jmp 0x62dbb
movq -0x80(%rbp), %rdi
addq $0x70, %rdi
callq 0x24c90
movb %al, -0x81(%rbp)
jmp 0x62cb7
movb -0x81(%rbp), %al
testb $0x1, %al
jne 0x62ce2
jmp 0x62cc3
jmp 0x62dbb
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x48(%rbp)
movl %eax, -0x4c(%rbp)
leaq -0x38(%rbp), %rdi
callq 0x10730
jmp 0x62dcd
callq 0xd0a0
movq %rax, -0x68(%rbp)
leaq -0x68(%rbp), %rdi
leaq -0x10(%rbp), %rsi
callq 0xfff0
movq %rax, -0x90(%rbp)
jmp 0x62d01
movq -0x90(%rbp), %rax
movq %rax, -0x60(%rbp)
leaq -0x58(%rbp), %rdi
leaq -0x60(%rbp), %rsi
callq 0x10040
jmp 0x62d1b
movq -0x80(%rbp), %rax
movq -0x58(%rbp), %rcx
movq %rcx, -0x18(%rbp)
movq %rax, %rcx
addq $0x30, %rcx
movq %rcx, -0xa8(%rbp)
addq $0x68, %rax
movq %rax, -0xa0(%rbp)
leaq -0x18(%rbp), %rdi
leaq -0x40(%rbp), %rsi
callq 0x63030
movsd %xmm0, -0x98(%rbp)
jmp 0x62d57
movq -0xa0(%rbp), %rdi
movsd -0x98(%rbp), %xmm0
movsd %xmm0, -0x78(%rbp)
leaq -0x78(%rbp), %rsi
callq 0x63030
movsd %xmm0, -0xb0(%rbp)
jmp 0x62d7e
movq -0xa8(%rbp), %rdi
movsd -0xb0(%rbp), %xmm0
movsd %xmm0, -0x70(%rbp)
leaq -0x38(%rbp), %rsi
leaq -0x70(%rbp), %rdx
callq 0x62fc0
jmp 0x62da1
jmp 0x62da3
movq -0x80(%rbp), %rsi
addq $0x68, %rsi
leaq -0x40(%rbp), %rdi
callq 0x630a0
jmp 0x62db6
jmp 0x62c90
leaq -0x38(%rbp), %rdi
callq 0x10730
addq $0xb0, %rsp
popq %rbp
retq
movq -0x48(%rbp), %rdi
callq 0xdcb0
nopw %cs:(%rax,%rax)
// File: 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 %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, %rax
movq %rax, -0x38(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x10(%rbp), %rax
movl (%rax), %ecx
movl %ecx, -0x30(%rbp)
movl 0x4(%rax), %ecx
movl %ecx, -0x2c(%rbp)
movl 0x8(%rax), %ecx
movl %ecx, -0x28(%rbp)
movl 0xc(%rax), %ecx
movl %ecx, -0x24(%rbp)
movl 0x10(%rax), %ecx
movl %ecx, -0x20(%rbp)
movl 0x14(%rax), %ecx
movl %ecx, -0x1c(%rbp)
movl 0x18(%rax), %eax
movl %eax, -0x18(%rbp)
leaq -0x30(%rbp), %rsi
callq 0x65f30
movq -0x38(%rbp), %rax
addq $0x40, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: 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 %rbp
movq %rsp, %rbp
subq $0x60, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x38(%rbp)
movq (%rdi), %rax
callq *0x10(%rax)
movq %rax, -0x30(%rbp)
movq -0x10(%rbp), %rdi
movq (%rdi), %rax
callq *0x10(%rax)
movq %rax, %rcx
movq -0x30(%rbp), %rax
cmpq %rcx, %rax
sete %al
movzbl %al, %edi
andl $0x1, %edi
callq 0x6c7c0
testb $0x1, %al
jne 0x65aca
jmp 0x65acf
jmp 0x65b6b
leaq 0x41dc6(%rip), %rdx     # 0xa789c
leaq -0x14(%rbp), %rdi
movq %rdi, -0x48(%rbp)
movl $0x3, %esi
movl $0x155, %ecx            # imm = 0x155
callq 0xa19e0
movq -0x48(%rbp), %rdi
callq 0x55090
movq %rax, %rdi
leaq 0x41f17(%rip), %rsi     # 0xa7a17
callq 0xd640
movq %rax, -0x40(%rbp)
jmp 0x65b0b
movq -0x40(%rbp), %rdi
leaq 0x41f3d(%rip), %rsi     # 0xa7a53
callq 0xd640
movq %rax, -0x50(%rbp)
jmp 0x65b21
movq -0x50(%rbp), %rdi
leaq 0x41f53(%rip), %rsi     # 0xa7a7f
callq 0xd640
movq %rax, -0x58(%rbp)
jmp 0x65b37
movq -0x58(%rbp), %rdi
movq 0x9544e(%rip), %rsi     # 0xfaf90
callq 0xd6e0
jmp 0x65b49
leaq -0x14(%rbp), %rdi
callq 0xa1b20
jmp 0x65b6b
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x20(%rbp)
movl %eax, -0x24(%rbp)
leaq -0x14(%rbp), %rdi
callq 0xa1b20
jmp 0x65b98
movq -0x38(%rbp), %rax
addq $0x10, %rax
movq %rax, -0x60(%rbp)
movq -0x10(%rbp), %rdi
callq 0x65da0
movq -0x60(%rbp), %rdi
movq %rax, %rsi
addq $0x10, %rsi
callq 0x65d60
andb $0x1, %al
addq $0x60, %rsp
popq %rbp
retq
movq -0x20(%rbp), %rdi
callq 0xdcb0
nopw %cs:(%rax,%rax)
nopl (%rax,%rax)
// File: 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 %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x10(%rbp)
callq 0x6a5d0
xorb $-0x1, %al
testb $0x1, %al
jne 0x69f81
jmp 0x69f83
jmp 0x69fa2
leaq 0x3dd6a(%rip), %rdi     # 0xa7cf4
leaq 0x3dd6c(%rip), %rsi     # 0xa7cfd
movl $0xec7, %edx            # imm = 0xEC7
leaq 0x3dda4(%rip), %rcx     # 0xa7d41
callq 0xd430
movq -0x10(%rbp), %rdi
addq $0x98, %rdi
callq 0x6aee0
movq -0x10(%rbp), %rsi
movq %rsi, %rdi
addq $0x98, %rdi
addq $0x90, %rsi
callq 0x6a8d0
testb $0x1, %al
jne 0x69fd2
jmp 0x69ffc
movq -0x10(%rbp), %rdi
movq %rdi, %rsi
addq $0x88, %rsi
addq $0x98, %rdi
callq 0x6af10
movq -0x10(%rbp), %rdi
addq $0x80, %rdi
callq 0x6af60
movq -0x10(%rbp), %rsi
movq %rsi, %rdi
addq $0x80, %rdi
addq $0x78, %rsi
callq 0x6a860
testb $0x1, %al
jne 0x6a019
jmp 0x6a03d
movq -0x10(%rbp), %rdi
movq %rdi, %rsi
addq $0x70, %rsi
addq $0x80, %rdi
callq 0x6af90
movq -0x10(%rbp), %rdi
addq $0x68, %rdi
callq 0x6afe0
movq -0x10(%rbp), %rsi
movq %rsi, %rdi
addq $0x68, %rdi
addq $0x60, %rsi
callq 0x6a7f0
testb $0x1, %al
jne 0x6a057
jmp 0x6a078
movq -0x10(%rbp), %rdi
movq %rdi, %rsi
addq $0x58, %rsi
addq $0x68, %rdi
callq 0x6b010
movq -0x10(%rbp), %rdi
addq $0x50, %rdi
callq 0x6afe0
movq -0x10(%rbp), %rsi
movq %rsi, %rdi
addq $0x50, %rdi
addq $0x48, %rsi
callq 0x6a7f0
testb $0x1, %al
jne 0x6a092
jmp 0x6a0b3
movq -0x10(%rbp), %rdi
movq %rdi, %rsi
addq $0x40, %rsi
addq $0x50, %rdi
callq 0x6b010
movq -0x10(%rbp), %rdi
addq $0x38, %rdi
callq 0x6afe0
movq -0x10(%rbp), %rsi
movq %rsi, %rdi
addq $0x38, %rdi
addq $0x30, %rsi
callq 0x6a7f0
testb $0x1, %al
jne 0x6a0cd
jmp 0x6a0ee
movq -0x10(%rbp), %rdi
movq %rdi, %rsi
addq $0x28, %rsi
addq $0x38, %rdi
callq 0x6b010
movq -0x10(%rbp), %rdi
addq $0x20, %rdi
callq 0x6afe0
movq -0x10(%rbp), %rdi
callq 0x69d10
addq $0x10, %rsp
popq %rbp
retq
nopl (%rax)
// File: 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 %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rsi
movq %rsi, -0x18(%rbp)
movq %rsi, %rdi
addq $0x20, %rdi
addq $0x18, %rsi
callq 0x6a7f0
movb %al, %cl
movb $0x1, %al
testb $0x1, %cl
movb %al, -0x9(%rbp)
jne 0x6a6a8
movq -0x18(%rbp), %rsi
movq %rsi, %rdi
addq $0x38, %rdi
addq $0x30, %rsi
callq 0x6a7f0
movb %al, %cl
movb $0x1, %al
testb $0x1, %cl
movb %al, -0x9(%rbp)
jne 0x6a6a8
movq -0x18(%rbp), %rsi
movq %rsi, %rdi
addq $0x50, %rdi
addq $0x48, %rsi
callq 0x6a7f0
movb %al, %cl
movb $0x1, %al
testb $0x1, %cl
movb %al, -0x9(%rbp)
jne 0x6a6a8
movq -0x18(%rbp), %rsi
movq %rsi, %rdi
addq $0x68, %rdi
addq $0x60, %rsi
callq 0x6a7f0
movb %al, %cl
movb $0x1, %al
testb $0x1, %cl
movb %al, -0x9(%rbp)
jne 0x6a6a8
movq -0x18(%rbp), %rsi
movq %rsi, %rdi
addq $0x80, %rdi
addq $0x78, %rsi
callq 0x6a860
movb %al, %cl
movb $0x1, %al
testb $0x1, %cl
movb %al, -0x9(%rbp)
jne 0x6a6a8
movq -0x18(%rbp), %rsi
movq %rsi, %rdi
addq $0x98, %rdi
addq $0x90, %rsi
callq 0x6a8d0
movb %al, -0x9(%rbp)
movb -0x9(%rbp), %al
andb $0x1, %al
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
nopl (%rax)
// File: 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 %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movl $0x0, -0x4(%rbp)
movl %edi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x10(%rbp), %rsi
leaq -0x8(%rbp), %rdi
callq 0x7eee0
callq 0x6c9a0
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rdi
callq 0x760a0
movq %rax, -0x20(%rbp)
movq -0x20(%rbp), %rax
movq %rax, -0x38(%rbp)
movq -0x20(%rbp), %rdi
callq 0xa4220
movq -0x38(%rbp), %rdi
movq %rax, %rsi
callq 0x7c420
movq %rax, -0x30(%rbp)
cmpq $0x0, %rax
je 0xa41da
movq -0x30(%rbp), %rdi
movq (%rdi), %rax
callq *0x8(%rax)
movq -0x20(%rbp), %rax
movq %rax, -0x48(%rbp)
movl $0x8, %edi
callq 0xd660
movq %rax, %rdi
movq %rdi, -0x40(%rbp)
callq 0xa4240
movq -0x48(%rbp), %rdi
movq -0x40(%rbp), %rsi
callq 0x7c3f0
callq 0xa4280
movl %eax, -0x24(%rbp)
movl -0x24(%rbp), %eax
addq $0x50, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: 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
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl %edx, -0x14(%rbp)
leaq 0xa9916(%rip), %rax     # 0x14dc20
cmpl $0x1, (%rax)
je 0xa4323
movl -0x14(%rbp), %esi
addl $0x1, %esi
leaq 0x5cc3(%rip), %rdi      # 0xa9fdf
movb $0x0, %al
callq 0xd090
leaq 0xa98a6(%rip), %rdi     # 0x14dbd0
callq 0xd260
movq %rax, -0x20(%rbp)
movq -0x20(%rbp), %rdi
leaq 0x7df7(%rip), %rsi      # 0xac135
callq 0xda20
cmpl $0x0, %eax
je 0xa4361
movq -0x20(%rbp), %rdx
leaq 0x5cb8(%rip), %rdi      # 0xaa00b
leaq 0x57cf(%rip), %rsi      # 0xa9b29
movb $0x0, %al
callq 0xd090
leaq 0xa98bd(%rip), %rax     # 0x14dc25
testb $0x1, (%rax)
je 0xa4386
movq -0x10(%rbp), %rdi
callq 0x77510
movl %eax, %esi
leaq 0x5cc6(%rip), %rdi      # 0xaa045
movb $0x0, %al
callq 0xd090
leaq 0x7bd3(%rip), %rdi      # 0xabf60
movb $0x0, %al
callq 0xd090
leaq 0x7c1a(%rip), %rdi      # 0xabfb5
movb $0x0, %al
callq 0xd090
movq -0x10(%rbp), %rdi
callq 0x77570
movl %eax, -0x34(%rbp)
movq -0x10(%rbp), %rdi
callq 0x77570
movl %eax, %edx
leaq 0x6330(%rip), %rax      # 0xaa6f0
leaq 0x5d6f(%rip), %rcx      # 0xaa136
cmpl $0x1, %edx
cmoveq %rcx, %rax
movq %rax, -0x30(%rbp)
movq -0x10(%rbp), %rdi
callq 0x775e0
movl %eax, -0x24(%rbp)
movq -0x10(%rbp), %rdi
callq 0x775e0
movl -0x34(%rbp), %esi
movq -0x30(%rbp), %rdx
movl -0x24(%rbp), %ecx
movl %eax, %edi
leaq 0x62f6(%rip), %r8       # 0xaa6f0
leaq 0x5d35(%rip), %rax      # 0xaa136
cmpl $0x1, %edi
cmoveq %rax, %r8
leaq 0x7ba9(%rip), %rdi      # 0xabfb8
movb $0x0, %al
callq 0xd090
leaq 0x7b43(%rip), %rdi      # 0xabf60
movb $0x0, %al
callq 0xd090
movq 0x56b55(%rip), %rax     # 0xfaf80
movq (%rax), %rdi
callq 0xd830
addq $0x40, %rsp
popq %rbp
retq
nopl (%rax)
// File: 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
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
leaq 0x7b59(%rip), %rdi      # 0xabfe0
movb $0x0, %al
callq 0xd090
movq -0x10(%rbp), %rdi
callq 0x83920
movq %rax, %rsi
leaq 0x7b43(%rip), %rdi      # 0xabfe4
movb $0x0, %al
callq 0xd090
movq -0x10(%rbp), %rdi
callq 0x83940
cmpq $0x0, %rax
jne 0xa44c7
leaq 0x5c77(%rip), %rdi      # 0xaa135
movb $0x0, %al
callq 0xd090
jmp 0xa44e8
movq -0x10(%rbp), %rdi
callq 0x83940
movq %rax, %rdx
leaq 0x5bfd(%rip), %rdi      # 0xaa0d7
leaq 0x7c56(%rip), %rsi      # 0xac137
movb $0x0, %al
callq 0xd090
leaq 0x7af1(%rip), %rdi      # 0xabfe0
movb $0x0, %al
callq 0xd090
leaq 0x7af5(%rip), %rdi      # 0xabff2
movb $0x0, %al
callq 0xd090
movl $0x0, -0x14(%rbp)
movl -0x14(%rbp), %eax
movl %eax, -0x18(%rbp)
movq -0x10(%rbp), %rdi
callq 0x6ee40
movl %eax, %ecx
movl -0x18(%rbp), %eax
cmpl %ecx, %eax
jge 0xa457d
leaq 0x7ab6(%rip), %rdi      # 0xabfe0
movb $0x0, %al
callq 0xd090
leaq 0x6ef5(%rip), %rdi      # 0xab42d
movb $0x0, %al
callq 0xd090
leaq 0x7a6f(%rip), %rdi      # 0xabfb5
movb $0x0, %al
callq 0xd090
movq -0x10(%rbp), %rdi
movl -0x14(%rbp), %esi
callq 0x763f0
movq %rax, %rdi
callq 0x825f0
movq %rax, %rsi
leaq 0x7afc(%rip), %rdi      # 0xac067
movb $0x0, %al
callq 0xd090
movl -0x14(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x14(%rbp)
jmp 0xa450b
leaq 0x79dc(%rip), %rdi      # 0xabf60
movb $0x0, %al
callq 0xd090
movq 0x569ee(%rip), %rax     # 0xfaf80
movq (%rax), %rdi
callq 0xd830
addq $0x20, %rsp
popq %rbp
retq
// File: 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 %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
leaq 0x6e76(%rip), %rdi      # 0xab42d
movb $0x0, %al
callq 0xd090
movq -0x10(%rbp), %rdi
callq 0x826f0
movq %rax, -0x18(%rbp)
movq -0x10(%rbp), %rdi
callq 0x825f0
movq -0x18(%rbp), %rsi
movq %rax, %rdx
leaq 0x7a19(%rip), %rdi      # 0xabffb
movb $0x0, %al
callq 0xd090
leaq 0x5b45(%rip), %rdi      # 0xaa135
movb $0x0, %al
callq 0xd090
leaq 0x7962(%rip), %rdi      # 0xabf60
movb $0x0, %al
callq 0xd090
movq 0x56974(%rip), %rax     # 0xfaf80
movq (%rax), %rdi
callq 0xd830
addq $0x20, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: 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:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x10(%rbp), %rdi
callq 0x7fb80
cmpl $0x0, %eax
jne 0xa4640
jmp 0xa46a5
leaq 0x79c7(%rip), %rdi      # 0xac00e
movb $0x0, %al
callq 0xd090
movq -0x10(%rbp), %rdi
callq 0x84130
movq %rax, -0x20(%rbp)
movq -0x10(%rbp), %rdi
callq 0x84180
movl %eax, -0x14(%rbp)
movq -0x10(%rbp), %rdi
callq 0x841a0
movq -0x20(%rbp), %rsi
movl -0x14(%rbp), %edx
movq %rax, %rcx
leaq 0x79d5(%rip), %rdi      # 0xac056
movb $0x0, %al
callq 0xd090
leaq 0x79dc(%rip), %rdi      # 0xac06b
movb $0x0, %al
callq 0xd090
movq 0x568e3(%rip), %rax     # 0xfaf80
movq (%rax), %rdi
callq 0xd830
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: 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 %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x28(%rbp)
leaq 0x7891(%rip), %rdi      # 0xabf60
movb $0x0, %al
callq 0xd090
leaq 0x6d50(%rip), %rdi      # 0xab42d
movb $0x0, %al
callq 0xd090
movq -0x10(%rbp), %rdi
callq 0x826f0
movq %rax, -0x20(%rbp)
movq -0x10(%rbp), %rdi
callq 0x825f0
movq %rax, -0x18(%rbp)
movq -0x10(%rbp), %rdi
callq 0x839c0
movq %rax, %rdi
callq 0x839e0
testb $0x1, %al
jne 0xa4715
jmp 0xa4722
leaq 0x79a6(%rip), %rax      # 0xac0c2
movq %rax, -0x30(%rbp)
jmp 0xa472f
leaq 0x6fbe(%rip), %rax      # 0xab6e7
movq %rax, -0x30(%rbp)
jmp 0xa472f
movq -0x18(%rbp), %rdx
movq -0x20(%rbp), %rsi
movq -0x30(%rbp), %rcx
leaq 0x7972(%rip), %rdi      # 0xac0b4
movb $0x0, %al
callq 0xd090
movq -0x10(%rbp), %rdi
callq 0x839c0
movq %rax, %rdi
callq 0x749c0
testb $0x1, %al
jne 0xa4760
jmp 0xa476d
movq -0x28(%rbp), %rdi
movq -0x10(%rbp), %rsi
callq 0xa4b10
leaq 0xa94a4(%rip), %rax     # 0x14dc18
testb $0x1, (%rax)
je 0xa479d
movq -0x10(%rbp), %rdi
callq 0x839c0
movq %rax, %rdi
callq 0x83a80
movq %rax, %rsi
leaq 0x7935(%rip), %rdi      # 0xac0c9
movb $0x0, %al
callq 0xd090
jmp 0xa47ab
leaq 0x5991(%rip), %rdi      # 0xaa135
movb $0x0, %al
callq 0xd090
leaq 0x77ae(%rip), %rdi      # 0xabf60
movb $0x0, %al
callq 0xd090
movq 0x567c0(%rip), %rax     # 0xfaf80
movq (%rax), %rdi
callq 0xd830
addq $0x30, %rsp
popq %rbp
retq
nop
// File: 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:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
leaq 0xa9431(%rip), %rax     # 0x14dc18
testb $0x1, (%rax)
jne 0xa47f1
jmp 0xa487e
leaq 0x77e8(%rip), %rdi      # 0xabfe0
movb $0x0, %al
callq 0xd090
movq -0x10(%rbp), %rdi
callq 0x6ee40
movl %eax, -0x24(%rbp)
movq -0x10(%rbp), %rdi
callq 0x6ee40
movl %eax, %edx
leaq 0x4fd5(%rip), %rax      # 0xa97f2
leaq 0x6c44(%rip), %rcx      # 0xab468
cmpl $0x1, %edx
cmoveq %rcx, %rax
movq %rax, -0x20(%rbp)
movq -0x10(%rbp), %rdi
callq 0x83920
movq %rax, -0x18(%rbp)
movq -0x10(%rbp), %rdi
callq 0x83aa0
movl -0x24(%rbp), %esi
movq -0x20(%rbp), %rdx
movq -0x18(%rbp), %rcx
movq %rax, %r8
leaq 0x787a(%rip), %rdi      # 0xac0d4
movb $0x0, %al
callq 0xd090
leaq 0x76f8(%rip), %rdi      # 0xabf60
movb $0x0, %al
callq 0xd090
movq 0x5670a(%rip), %rax     # 0xfaf80
movq (%rax), %rdi
callq 0xd830
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
nop