1
#include<iostream>
2

3
namespace PAIR{
4
template<typename T1, typename T2>
5
class pair {
6
public:
7
    T1 first;
8
    T2 second;
9

10
    pair() : first(T1()), second(T2()) {}
11

12
    pair(const T1 &a, const T2 &b) : first(a), second(b) {}
13

14
    template<typename U, typename V>
15
    pair(const pair<U, V> &p) : first(p.first), second(p.second) {}
16

17
    pair(T1 &&a, T2 &&b) : first(std::move(a)), second(std::move(b)) {}
18

19
    inline pair &operator=(const pair &other) {
20
        if (this != &other) {
21
            first = other.first;
22
            second = other.second;
23
        }
24
        return *this;
25
    }
26

27
    template<typename U, typename V>
28
    inline pair &operator=(const pair &other) {
29
        first = other.first;
30
        second = other.second;
31
        return *this;
32
    }
33

34
    inline void swap(pair &other) noexcept {
35
        pair tmp(std::move(*this));
36
        *this = std::move(other);
37
        other = std::move(tmp);
38
    }
39

40
    inline friend std::ostream &operator<<(std::ostream &os, pair<T1, T2> &pt) {
41
        return os << "(" << pt.first << "," << pt.second << ")";
42
    }
43
};
44

45
template<typename T1, typename T2>
46
inline void swap(pair<T1, T2> &a, pair<T1, T2> &b) noexcept {
47
    a.swap(b);
48
}
49

50
template<typename T1, typename T2>
51
inline bool operator==(const pair<T1, T2> &a, const pair<T1, T2> &b) {
52
    return a.first == b.first && a.second == b.second;
53
}
54

55
template<typename T1, typename T2>
56
inline bool operator!=(const pair<T1, T2> &a, const pair<T1, T2> &b) {
57
    return !(a == b);
58
}
59

60
template<typename T1, typename T2>
61
inline bool operator<(const pair<T1, T2> &a, const pair<T1, T2> &b) {
62
    return a.first < b.first || (!(b.first < a.first) && a.second < b.second);
63
}
64

65
template<typename T1, typename T2>
66
inline bool operator>(const pair<T1, T2> &a, const pair<T1, T2> &b) {
67
    return b < a;
68
}
69

70
template<typename T1, typename T2>
71
inline bool operator<=(const pair<T1, T2> &a, const pair<T1, T2> &b) {
72
    return !(b < a);
73
}
74

75
template<typename T1, typename T2>
76
inline bool operator>=(const pair<T1, T2> &a, const pair<T1, T2> &b) {
77
    return !(a < b);
78
}
79

80
template<typename T1, typename T2>
81
constexpr pair<typename std::__decay_and_strip<T1>::__type,
82
               typename std::__decay_and_strip<T2>::__type>
83
make_pair(T1 &&a, T2 &&b) {
84
    typedef typename std::__decay_and_strip<T1>::__type __ds_type1;
85
    typedef typename std::__decay_and_strip<T2>::__type __ds_type2;
86
    typedef pair<__ds_type1, __ds_type2> __pair_type;
87
    return __pair_type(std::forward<T1>(a), std::forward<T2>(b));
88
}
89
using namespace PAIR;