#include <cstdint>
#include <vector>
#include <algorithm>

class Set {
 public:
  explicit Set() = default;
  explicit Set(const std::vector<int64_t>& data) {
    for (int64_t i : data) {
      if (!this->Contains(i))
        this->data_.push_back(i);
    }
  }
  Set Union(const Set& set) const {
    Set result = Set(this->Data());
    for (int64_t i : set.Data()) {
      if (!result.Contains(i))
        result.Add(i);
    }
    return result;
  }
  Set Intersection(const Set& set) const {
    Set result = Set(std::vector<int64_t>());
    for (int64_t i : set.Data()) {
      if (this->Contains(i))
        result.Add(i);
    }
    return result;
  }
  Set Difference(const Set& set) const {
    Set result = Set(std::vector<int64_t>());
    for (int64_t i : this->data_) {
      if (!set.Contains(i))
        result.Add(i);
    }
    return result;
  }
  Set SymmetricDifference(const Set& set) const {
    Set result = Set(this->data_);
    for (int64_t i : set.Data()) {
      if (!result.Contains(i)) {
        result.Add(i);
      } else {
        result.Remove(i);
      }
    }
    return result;
  }
  void Add(int64_t elem) {
    if (!this->Contains(elem))
      this->data_.push_back(elem);
  }
  void Remove(int64_t elem) {
    auto iter = std::find(this->data_.begin(),
                          this->data_.end(),
                          elem);
    if (iter != this->data_.end()) {
      this->data_.erase(iter);
    }
  }
  bool Contains(int64_t elem) const {
    return (std::find(this->data_.begin(),
                      this->data_.end(),
                      elem) != this->data_.end());
  }
  std::vector<int64_t> Data() const {
    return this->data_;
  }
 private:
  std::vector<int64_t> data_;
};