//Tema 8. multimi finite de numere intregi reprezentate ca liste inlantuite
#include<iostream>
using namespace std;

template <typename T>
class Node {
public:
    T val{};
    Node *next{};
    friend istream & operator >> (istream &in, Node<T> &node);
    friend ostream & operator << (ostream &out, Node<T> &node);
    Node operator + (const Node &node);
    Node operator * (const Node &node);
    // Node &operator ++ ();
    // const Node operator ++ (int);
    Node &operator += (const Node &node);
    bool operator < (const Node &node) const;
    bool operator == (const Node &node) const;
    bool operator != (const Node &node) const;
    ~Node() {
        delete [] next;
    }
};

template <typename T>
istream & operator >> (istream &in, Node<T> &node) {
    in >> node.val;
    return in;
}

template <typename T>
ostream & operator << (ostream &out, Node<T> &node) {
    out << node.val;
    return out;
}

template <typename T>
Node<T> Node<T>:: operator + (const Node<T> &node) {
    Node<T> rez{};
    rez.val = node.val + this->val;
    return rez;
}

template <typename T>
Node<T> Node<T>:: operator * (const Node<T> &node) {
    Node rez{};
    rez.val = this->val * node.val;
    return rez;
}

// Node &Node :: operator ++ () {
//     this->val += 1;
//     return *this;
// }

// const Node Node :: operator ++ (int) {
//     Node rez = *this;
//     ++(*this);
//     return rez;
// }

template <typename T>
Node<T> &Node<T>:: operator += (const Node<T> &node) {
    *this = *this + node;
    return *this;
}

template <typename T>
bool Node<T>:: operator < (const Node<T> &node) const {
    return this->val < node.val;
}

template <typename T>
bool Node<T>:: operator == (const Node<T> &node) const {
    return this->val == node.val;
}

template <typename T>
bool Node<T>:: operator != (const Node<T> &node) const {
    return this->val != node.val;
}

template<typename T>
class List {
public:
    int n{};
    Node<T> *start{}, *end{};
    friend istream & operator >> (istream &in, List &list);
    friend ostream & operator << (ostream &out, List &list);
    void sort();
};

template <typename T>
void add_node(Node<T> *node, List<T> &list) {
    if (list.start == NULL) {
        list.start = node;
        list.end = list.start;
    } else {
        list.end->next = node;
        list.end = list.end->next;
    }
}

template <typename T>
void List<T>:: sort() {
    Node<T> *node1 = this->start, *node2{};
    for (int i = 1; i < this->n ; i ++, node1 = node1->next) {
        node2 = node1->next;
        for (int j = i + 1; j <= this->n; j ++, node2 = node2->next) {
            if (*node2 < *node1) {
                swap(node1->val, node2->val);
            }
        }
    }
}

template <typename T>
ostream & operator << (ostream &out, List<T> &list) {
    for (Node<T> *node = list.start; node != NULL; node = node->next) {
        out << *node << " ";
    }
    return out;
}

template <typename T>
istream & operator >> (istream &in, List<T> &list) {
    in >> list.n;

    for (int i = 0; i < list.n; i ++) {
        Node<T> *node = new Node<T>;
        in >> *node;
        add_node(node, list);
    }
    return in;
}

template <typename T>
class Set : public List<T> {
public:
    void transform();
    Set operator + (const Set &set);
    Set operator * (const Set &set);
    Set operator - (const Set &set);
};

template <typename T>
void Set<T>::transform() {
    (*this).sort();
    Node<T> *node = this->start;
    for (int i = 1; i < this->n; i ++, node = node->next) {
        while (node->next != NULL && *node == *node->next) {
            node->next = node->next->next;
            this->n --;
        }
    }
}

template <typename T>
void copy_object(Node<T> *node, List<T> &list) {
    while (node != NULL) {
        Node<T> *aux = new Node<T>;
        aux->val = node->val;
        add_node(aux, list);
        node = node->next;
        list.n ++;
    }
}

template <typename T>
Set<T> Set<T>:: operator + (const Set<T> &set) {
    Set<T> rez{};

    copy_object(this->start, rez);
    copy_object(set.start, rez);

    rez.transform();
    return rez;
}

template <typename T>
Set<T> Set<T>:: operator * (const Set<T> &set) {
    Node<T> *node1 = this->start, *node2 = set.start;
    Set rez{};

    while (node1 != NULL && node2 != NULL) {
        if (*node1 < *node2) {
            node1 = node1->next;
        } else if (*node2 < *node1) {
            node2 = node2->next;
        } else {
            Node<T> *aux = new Node<T>;
            aux->val = node1->val;
            add_node(aux, rez);
            node1 = node1->next;
            node2 = node2->next;
            rez.n ++;
        }
    }

    rez.transform();
    return rez;
}

template <typename T>
Set<T> Set<T>:: operator - (const Set<T> &set) {
    Set<T> rez{};
    Node<T> *node1 = this->start, *node2 = set.start;

    while (node1 != NULL && node2 != NULL) {
        if (*node1 < *node2) {
            Node<T> *aux = new Node<T>;
            aux->val = node1->val;
            add_node(aux, rez);
            node1 = node1->next;
            rez.n ++;
        } else if (*node2 < *node1) {
            node2 = node2->next;
        } else {
            node1 = node1->next;
            node2 = node2->next;
        }
    }

    while (node1 != NULL) {
        Node<T> *aux = new Node<T>;
        aux->val = node1->val;
        add_node(aux, rez);
        node1 = node1->next;
        rez.n ++;
    }

    return rez;
}

//**********************************************************************************************************************
// class Pair_set;

class Pair {
    int first, second;
    friend Set<Pair>;

    friend istream &operator >>(istream &is, Pair &p) {
        is >> p.first >> p.second;
        return is;
    }

    friend ostream &operator <<(ostream &os, Pair &p) {
        os << p.first << ' ' << p.second << '\n';
        return os;
    }

public:
    bool operator ==(const Pair &other) const {
        return first == other.first && second == other.second;
    }


    bool operator <(const Pair &other) const {
        if (first == other.first) {
            return second < other.second;
        }

        return first < other.first;
    }
};

//**********************************************************************************************************************
// class Pair_set {

// };

int main() {
    List<int> set1, set2, rez{};
    cin >> set1;
    // set1.transform();
    // cin >> set2;
    // set2.transform();
    // rez = set1 * set2;
    // cout << set1 << endl << set2 << endl << rez;
    return 0;
}