#include <thread>

#include <mutex>
#include <future>
#include <atomic>
#include <condition_variable>

#include <memory>

#include <type_traits>
template <typename T>
struct QNode {
    std::unique_ptr<T> payload;
    volatile std::atomic<QNode*> next;

    QNode() = default;

    explicit QNode(T&& payload):
    payload(std::forward<T>(payload)) {}
};

template <typename T>
class Queue {
private:
    volatile std::atomic<QNode<T>*> head;
    volatile std::atomic<QNode<T>*> tail;
public:
    void push(T&& payload) {
        QNode<T>* node = new QNode(std::forward<T>(payload));
        node->next = node;

        QNode<T>* _tail = tail;
        QNode<T>* _next = _tail->next;

        do {
            node->next = _next;
        } while (!_tail->next.compare_exchange_weak(_next, node));

        tail.compare_exchange_strong(_tail, node);
    }
    std::unique_ptr<T> pop() {

    }
};