#pragma once

#include <type_traits>
#include <utility>

// Me think, why waste time write lot code, when few code do trick.
template <typename T, std::size_t I, bool = std::is_empty_v<T> && !std::is_final_v<T>>
struct CompressedPairElement {
    CompressedPairElement(const T& v) : value(v) {
    }
    CompressedPairElement(T&& v) : value(std::move(v)) {
    }
    const T& Get() const {
        return value;
    }
    T& Get() {
        return value;
    }
    T value;
};
template <typename T, std::size_t I>
struct CompressedPairElement<T, I, true> : T {
    CompressedPairElement<T, I, true>(const T& v) {
    }
    CompressedPairElement<T, I, true>(T&& v) {
    }
    const T& Get() const {
        return *this;
    }
    T& Get() {
        return *this;
    }
};
template <typename F, typename S>
class CompressedPair : CompressedPairElement<F, 1>, CompressedPairElement<S, 2> {
public:
    CompressedPair(const F& first, const S& second)
        : CompressedPairElement<F, 1>(first), CompressedPairElement<S, 2>(second) {
    }
    CompressedPair() : CompressedPairElement<F, 1>(F()), CompressedPairElement<S, 2>(S()) {
    }

    CompressedPair(const F& first, S&& second)
        : CompressedPairElement<F, 1>(first), CompressedPairElement<S, 2>(std::move(second)) {
    }
    CompressedPair(F&& first, const S& second)
        : CompressedPairElement<F, 1>(std::move(first)), CompressedPairElement<S, 2>(second) {
    }
    CompressedPair(F&& first, S&& second)
        : CompressedPairElement<F, 1>(std::move(first)),
          CompressedPairElement<S, 2>(std::move(second)) {
    }

    const F& GetFirst() const {
        return CompressedPairElement<F, 1>::Get();
    }
    F& GetFirst() {
        return CompressedPairElement<F, 1>::Get();
    }

    const S& GetSecond() const {
        return CompressedPairElement<S, 2>::Get();
    }
    S& GetSecond() {
        return CompressedPairElement<S, 2>::Get();
    }
};