class object{
  public:
  ~object() = default;
  static std::unique_ptr<object>& get_instance();
  private:
  object() = default; ///< 构造函数写为private，防止其他调用者单独构造该对象实例。
};

std::unique_ptr<object>& object::get_instance();
  static std::unique_ptr<object> instance;  ///< 该对象的唯一实例
  static std::once_flag flag; ///< 标志位, 标记只调用一次
  std::call_once(flag, [&](){
    instance = std::make_unique<object>();  ///< C++14以后版本的方法
    /*
    instance = std::unique_ptr<object>(new object()); ///< C++14 到 C++11 可用的方法
    */
  });
  return instance;
}

object* object::get_instance() {
  object* instance = nullptr;
  if(instance == nullptr) {
    instance = new object();
  }
  return instance;
}

object* object::get_instance(){
  static std::mutex mt;
  volatile object* instance = nullptr;  ///< volatile关键字为了防止编译器优化
  if(instance == nullptr) { ///< #1 读操作
    std::lock_guard<std::mutex> lock(mt);
    if(instance == nullptr) {
        instance = new object();  ///< #2 写操作
    }
  }
  return instance;
}

#include <iostream>

template <typename T>
class queue {
 public:
  queue(size_t size) : size_(size), front_(0), end_(0) { data_ = new T[size]; }
  ~queue() { delete[] data_; }
  queue(const queue& other) = delete;
  queue(queue&& other) = delete;
  queue operator=(const queue& other) = delete;
  queue operator=(queue&& other) = delete;

  bool is_empty() { return front_ == end_; }
  bool is_full() { return front_ = (end_ + 1) % size_; }

  const T& front() const { return data_[front_]; }

  void push(const T& val) {
    if ((end_ + 1) % size_ != front_) {
      data_[end_] = val;
      end_ = (end_ + 1) % size_;
    }
  }

  void pop() {
    if (front_ != end_) {
      front_ = (front_ + 1) % size_;
    }
  }

 private:
  size_t front_;
  size_t end_;
  size_t size_;
  T* data_;
};

int main() {
  queue<int> q(5);
  q.push(1);
  q.push(2);
  q.push(3);
  q.push(4);
  q.push(5);
  q.pop();
  q.pop();
  q.push(6);
  q.push(7);
  q.push(8);
  while (!q.is_empty()) {
    std::cout << q.front() << std::endl;
    q.pop();
  }
  return 0;
}

template <typename T>
class circular_q {
  size_t max_items_ = 0;
  typename std::vector<T>::size_type head_ = 0;
  typename std::vector<T>::size_type tail_ = 0;
  size_t overrun_counter_ = 0;
  std::vector<T> v_;

 public:
  using value_type = T;

  // empty ctor - create a disabled queue with no elements allocated at all
  circular_q() = default;

  explicit circular_q(size_t max_items)
      : max_items_(max_items + 1)  // one item is reserved as marker for full q
        ,
        v_(max_items_) {}

  circular_q(const circular_q &) = default;
  circular_q &operator=(const circular_q &) = default;

  // move cannot be default,
  // since we need to reset head_, tail_, etc to zero in the moved object
  circular_q(circular_q &&other) noexcept {
    copy_moveable(std::move(other));
  }

  circular_q &operator=(circular_q &&other) noexcept {
    copy_moveable(std::move(other));
    return *this;
  }

  // push back, overrun (oldest) item if no room left
  void push_back(T &&item) {
    if (max_items_ > 0) {
      v_[tail_] = std::move(item);
      tail_ = (tail_ + 1) % max_items_;

      if (tail_ == head_)  // overrun last item if full
      {
        head_ = (head_ + 1) % max_items_;
        ++overrun_counter_;
      }
    }
  }

  // Return reference to the front item.
  // If there are no elements in the container, the behavior is undefined.
  const T &front() const { return v_[head_]; }

  T &front() { return v_[head_]; }

  // Return number of elements actually stored
  size_t size() const {
    if (tail_ >= head_) {
      return tail_ - head_;
    } else {
      return max_items_ - (head_ - tail_);
    }
  }

  // Return const reference to item by index.
  // If index is out of range 0…size()-1, the behavior is undefined.
  const T &at(size_t i) const {
    assert(i < size());
    return v_[(head_ + i) % max_items_];
  }

  // Pop item from front.
  // If there are no elements in the container, the behavior is undefined.
  void pop_front() { head_ = (head_ + 1) % max_items_; }

  bool empty() const { return tail_ == head_; }

  bool full() const {
    // head is ahead of the tail by 1
    if (max_items_ > 0) {
      return ((tail_ + 1) % max_items_) == head_;
    }
    return false;
  }

  size_t overrun_counter() const { return overrun_counter_; }

 private:
  // copy from other&& and reset it to disabled state
  void copy_moveable(circular_q &&other) noexcept {
    max_items_ = other.max_items_;
    head_ = other.head_;
    tail_ = other.tail_;
    overrun_counter_ = other.overrun_counter_;
    v_ = std::move(other.v_);

    // put &&other in disabled, but valid state
    other.max_items_ = 0;
    other.head_ = other.tail_ = 0;
    other.overrun_counter_ = 0;
  }
};

#include <algorithm>
#include <atomic>
#include <cassert>
#include <iostream>
#include <map>
#include <mutex>
#include <vector>

class Container {
 public:
  Container() {
      std::lock_guard<std::mutex> lock(mut);
      auto it = uuid.load();
      uuid.store(++it);
      serial_number_ = it;
      container_map.insert({ serial_number_, this });
  }

  virtual int get_fluid_capacity() = 0;

  friend int totalFluidCapacity() {
    std::lock_guard<std::mutex> lock(mut);
    int result = 0;
    for (auto& it : container_map) {
      result += it.second->get_fluid_capacity();
    }
    return result;
  }

  friend Container* find_container(size_t serial_number) {
    std::lock_guard<std::mutex> lock(mut);
    if(container_map.find(serial_number) != container_map.end()) {
      return container_map[serial_number];
    } else {
      return nullptr;
    }
  }
  inline static std::mutex mut;
  inline static std::atomic<size_t> uuid;
  inline static std::map<size_t, Container*> container_map;

 protected:
  size_t serial_number_;
};

int totalFluidCapacity();
Container* find_container(size_t serial_number);

class Buckets : public Container {
  static constexpr double pi = 3.1415926;

 public:
  Buckets(int height, int radius) : height_(height), radius_(radius) {}
  virtual int get_fluid_capacity() override final {
    return static_cast<int>(radius_ * radius_ * height_ * pi);
  }

 private:
  int height_;
  int radius_;
};

class Boxes : public Container {
 public:
  enum class material_type : int {
    m = 0,  /// for metal
    c = 1,  /// for cardboard
  };

  Boxes(const int length, const int width, const int height, material_type type)
      : length_(length), width_(width), height_(height), type_(type) {}
  virtual int get_fluid_capacity() override final {
    if (type_ == material_type::c) {
      return length_ * width_ * height_;
    } else {
      return 0;
    }
  }

 private:
  int length_;
  int width_;
  int height_;
  material_type type_;
};

int main() {
  Boxes box_c(1, 1, 1, Boxes::material_type::c);
  Boxes box_m(1, 1, 1, Boxes::material_type::m);

  Buckets bucket(1, 1);

  auto capa = totalFluidCapacity();
  assert(capa == 4);

  auto p_container = find_container(2);
  assert(p_container == & box_m);
  return 0;
}

struct TreeNode {
  int val;
  TreeNode* left;
  TreeNode* right;
  TreeNode(int x) : val(x), left(nullptr), right(nullptr) {}
};

inline std::string serialize(TreeNode* root) {
  if (root == nullptr) {
    return "null";
  }
  std::vector<TreeNode*> queue;
  std::vector<std::vector<std::string>> result;
  queue.push_back(root);
  int height = 0;
  while (!queue.empty() &&
    !std::all_of(queue.begin(), queue.end(),
      [](const TreeNode* node) { return node == nullptr; })) {
    std::vector<std::string> temp;
    int count = static_cast<int>(std::pow(2, height));
    while (count-- != 0) {
      auto front = queue.front();
      queue.erase(queue.begin());
      if (front == nullptr) {
        temp.push_back("null");
        queue.push_back(nullptr);
        queue.push_back(nullptr);
      }
      else {
        temp.push_back(std::to_string(front->val));
        queue.push_back(front->left);
        queue.push_back(front->right);
      }
    }
    result.push_back(temp);
    ++height;
  }

  std::string str = "[";
  /// 组装字符串
  for (auto& it : result) {
    for (auto& it1 : it) {
      str += it1 + ",";
    }
  }
  if (str.back() == ',') {
    str.erase(std::prev(str.end()));
    str += "]";
  }
  return str;
}

inline void split(const std::string& s, std::vector<std::string>& tokens,
  const std::string& delimiters = " ") {
  std::string::size_type lastPos = s.find_first_not_of(delimiters, 0);
  std::string::size_type pos = s.find_first_of(delimiters, lastPos);
  while (std::string::npos != pos || std::string::npos != lastPos) {
    tokens.push_back(s.substr(lastPos, pos - lastPos));
    lastPos = s.find_first_not_of(delimiters, pos);
    pos = s.find_first_of(delimiters, lastPos);
  }
}
// Decodes your encoded data to tree.
inline TreeNode* deserialize(std::string data) {
  if (data.front() != '[' || data.back() != ']') {
    return nullptr;
  }
  data.erase(data.begin());
  data.erase(std::prev(data.end()));
  std::vector<std::string> vec_str;
  split(data, vec_str, ",");
  if (vec_str.empty() || vec_str.front() == "null") {
    return nullptr;
  }

  std::vector<TreeNode*> result;
  for (const auto& it : vec_str) {
    if (it == "null") {
      result.push_back(nullptr);
    }
    else {
      result.push_back(new TreeNode(std::stoi(it)));
    }
  }

  for (size_t i = 0; i < result.size(); ++i) {
    if(result.at(i) != nullptr){
      if (result.size() > i * 2 + 2) {
      result.at(i)->left = result.at(i*2+1);
      result.at(i)->right = result.at(i*2+2);
      }
    }
  }

  return result.at(0);
}

#include <cassert>

int main(){

  auto result = deserialize("[5,null,7,null,null,6,8]");
  assert(serialize(result) == "[5,null,7,null,null,6,8]");

  auto string =
      "[0,1,2,3,4,5,6,7,8,9,10,11,12,13,14,15,16,17,18,19,20,21,22,23,24,25,26,"
      "27,28,29,30,31,32,33,34,35,36,37,38,39,40,41,42,43,44,45,46,47,48,49,50,"
      "51,52,53,54,55,56,57,58,59,60,61,62,63,64,65,66,67,68,69,70,71,72,73,74,"
      "75,76,77,78,79,80,81,82,83,84,85,86,87,88,89,90,91,92,93,94,95,96,97,98,"
      "99,100,101,102,103,104,105,106,107,108,109,110,111,112,113,114,115,116,"
      "117,118,119,120,121,122,123,124,125,126]";
  auto result3 = deserialize(string);
  assert(serialize(result3) == string);
}

/**
 * Definition for a binary tree node.
 * struct TreeNode {
 *     int val;
 *     TreeNode *left;
 *     TreeNode *right;
 *     TreeNode(int x) : val(x), left(NULL), right(NULL) {}
 * };
 */
class Codec {
 public:
  // Encodes a tree to a single string.
  string serialize(TreeNode* root) {
    std::string res = "[";
    std::queue<TreeNode*> q;
    q.push(root);
    while (!q.empty()) {
      auto temp = q.front();
      q.pop();
      if (temp == nullptr) {
        res += "null,";
      } else {
        res += std::to_string(temp->val) + ",";
        q.push(temp->left);
        q.push(temp->right);
      }
    }
    res += "]";
    return res;
  }

  // Decodes your encoded data to tree.
  TreeNode* deserialize(string data) {
    /// 去除首尾的'[]'
    data.erase(data.begin());
    data.erase(std::prev(data.end()));
    /// 把字符串解析成数组
    auto begin = 0;
    auto lastPos = data.find_first_not_of(',', 0);
    auto pos = data.find_first_of(',', lastPos);
    std::queue<std::string> q;
    while (pos != std::string::npos || std::string::npos != lastPos) {
      q.push(data.substr(lastPos, pos - lastPos));
      lastPos = data.find_first_not_of(',', pos);
      pos = data.find_first_of(',', lastPos);
    }
    /// 遍历数组建立树
    auto head = q.front();
    std::queue<TreeNode*> q_ceng;
    std::queue<TreeNode*> q_next_ceng;
    TreeNode* r = nullptr;
    if (head != "null") {
      auto thead = new TreeNode(std::atoi(head.c_str()));
      q_ceng.push(thead);
      r = thead;
    }
    q.pop();
    while (!q.empty()) {
      while (!q_ceng.empty()) {
        auto t = q_ceng.front();
        q_ceng.pop();
        auto l_t = q.front();
        q.pop();
        auto r_t = q.front();
        q.pop();
        if (l_t != "null") {
          t->left = new TreeNode(std::atoi(l_t.c_str()));
          q_next_ceng.push(t->left);
        }
        if (r_t != "null") {
          t->right = new TreeNode(std::atoi(r_t.c_str()));
          q_next_ceng.push(t->right);
        }
      }
      while (!q_next_ceng.empty()) {
        q_ceng.push(q_next_ceng.front());
        q_next_ceng.pop();
      }
    }
    return r;
  }
};

#include <iostream>
#include <map>
#include <string>
#include <vector>

/**
 * @brief           把字符串前后的字符串给去除
 * @param           s       [in]    要剪切的字符串
 * @param           chars   [in]    要去除什么的字符串
 * @return          std::string& 剪切后的字符串
 * @author          lijiancong(lijiancong@gbcom.com.cn)
 * @note
 */
static std::string& strip(std::string& s, const std::string& chars = " ") {
  s.erase(0, s.find_first_not_of(chars.c_str()));
  s.erase(s.find_last_not_of(chars.c_str()) + 1);
  return s;
}

/**
 * @brief           以特定符号为分隔符，切分字符串并放入vector里
 * @param           s           [in]    原字符串
 * @param           tokens      [out]   剪切后的子字符串
 * @param           delimiters  [in]    分隔符
 * @author          lijiancong(lijiancong@gbcom.com.cn)
 * @note
 */
static void split(const std::string& s, std::vector<std::string>& tokens,
                  const std::string& delimiters = " ") {
  std::string::size_type lastPos = s.find_first_not_of(delimiters, 0);
  std::string::size_type pos = s.find_first_of(delimiters, lastPos);
  while (std::string::npos != pos || std::string::npos != lastPos) {
    tokens.push_back(s.substr(lastPos, pos - lastPos));
    lastPos = s.find_first_not_of(delimiters, pos);
    pos = s.find_first_of(delimiters, lastPos);
  }
}

static void parse(std::string& s, std::map<std::string, std::string>& items) {
  std::vector<std::string> elements;
  s.erase(0, s.find_first_not_of(" {"));
  s.erase(s.find_last_not_of("} ") + 1);
  split(s, elements, ",");
  for (auto& iter : elements) {
    std::vector<std::string> kv;
    split(iter, kv, ":");
    if (kv.size() != 2) continue;
    items[strip(kv[0], " \"")] = strip(kv[1], " \"");
  }
}

int main() {
  std::string data =
      "  {  \"key1\"  :  \"data1\"  ,  \"key2\"  :  \"data2\"    }  ";
  std::map<std::string, std::string> items;
  parse(data, items);

  for (const auto& iter:items){
    std::cout << "key=" << iter.first << ",value=" << iter.second << std::endl;
  }
  system("pause");
}

//
// Rotating file sink based on size
//
template<typename Mutex>
class rotating_file_sink final : public base_sink<Mutex>
{
public:
    rotating_file_sink(filename_t base_filename, std::size_t max_size, std::size_t max_files, bool rotate_on_open = false);
    static filename_t calc_filename(const filename_t &filename, std::size_t index);
    filename_t filename();

protected:
    void sink_it_(const details::log_msg &msg) override;
    void flush_() override;

private:
    // Rotate files:
    // log.txt -> log.1.txt
    // log.1.txt -> log.2.txt
    // log.2.txt -> log.3.txt
    // log.3.txt -> delete
    void rotate_();

    // delete the target if exists, and rename the src file  to target
    // return true on success, false otherwise.
    bool rename_file_(const filename_t &src_filename, const filename_t &target_filename);

    filename_t base_filename_;          ///< 基础文件名称
    std::size_t max_size_;              ///< 最大单个文件大小
    std::size_t max_files_;             ///< 最大日志文件数量
    std::size_t current_size_;          ///< 当前文件的大小
    details::file_helper file_helper_;  ///< 用于辅助写文件的对象
};

/// @name     rotating_file_sink
/// @brief    构造本对象，
///           1. 打开日志文件
///           2. 获取当前文件大小
///           3. 如果超出了单个文件大小，则重新创建文件并打开
///
/// @param    base_filename   [in]  基础的文件名
/// @param    max_size        [in]  最大单个文件大小
/// @param    max_files       [in]  最大的文件
/// @param    rotate_on_open  [in]  是否在文件打开时rotate
///
/// @date     2020-07-04 21:51:27
rotating_file_sink(std::string base_filename, std::size_t max_size,
                   std::size_t max_files, bool rotate_on_open = false)
    : base_filename_(std::move(base_filename)),
      max_size_(max_size),
      max_files_(max_files) {
  /// 打开当前应该写入的文件，并由file_helper对象来持有这个文件指针
  file_helper_.open(calc_filename(base_filename_, 0));
  /// 该函数时间执行时间很长，在这里只执行一次。
  current_size_ = file_helper_.size();
  /// 假如允许rotate且当前文件大小大于零
  if (rotate_on_open && current_size_ > 0) {
    /// 执行一次rotate
    rotate_();
  }
}

/// @name     rotate_
/// @brief    执行循环日志文件的创建
/// @details
/// Rotate files:
/// log.txt -> log.1.txt
/// log.1.txt -> log.2.txt
/// log.2.txt -> log.3.txt
/// log.3.txt -> delete
///
/// @param    NONE
///
/// @return   NONE
///
/// @date     2020-07-04 21:58:24
inline void rotate_() {
  /// 首先关闭该文件
  file_helper_.close();
  /// 开始查找要创建的下一个日志文件名称
  for (auto i = max_files_; i > 0; --i) {
    /// 拼装出上一个该文件名称
    std::string src = calc_filename(base_filename_, i - 1);
    if (!path_exists(src)) {
      /// 该文件如果不存在则到下一个循环
      continue;
    }
    /// 这里找到要创建的日志名称了日志文件的名称
    std::string target = calc_filename(base_filename_, i);

    /// 把上一个文件改名为当前的文件名
    if (!rename_file_(src, target)) {
      /// 如果失败则在一个短暂的延迟后再次尝试
      sleep_for_millis(100);
      if (!rename_file_(src, target)) {
        /// 关闭并打开这个日志文件，防止它增长超出限制
        file_helper_.reopen(true);
        current_size_ = 0;
        /// 抛出异常
        throw("rotating_file_sink: failed renaming ");
      }
    }
  }
  /// 以追加模式("a")重新打开这个文件
  file_helper_.reopen(true);
}

/// @name   sink_it_
/// @brief  写文件日志的函数，如果写入日志大于最大文件大小则创建下一个文件
///
/// @param  msg [in]  写入的日志信息
///
/// @return
///
/// @date     2020-07-05 09:33:12
void sink_it_(const details::log_msg &msg) override {
  std::string formatted;
  /// 拼装日志信息
  base_sink<Mutex>::formatter_->format(msg, formatted);
  /// 计算这条日志加上原本大小是否超过了最大文件大小
  current_size_ += formatted.size();
  if (current_size_ > max_size_) {
    /// 超过了就创建下一个文件
    rotate_();
    /// 更新为当前文件大小为这个日志信息的大小
    current_size_ = formatted.size();
  }
  /// 如果没有超过最大大小则继续写该文件
  file_helper_.write(formatted);
}

/// @name     flush_
/// @brief    刷新文件
///
/// @param    NONE
///
/// @return   NONE
///
/// @date     2020-07-05 09:36:23
void flush_() override { file_helper_.flush(); }

template <typename T>
Blob<T>::Blob(std::initializer_list<T> il)
try
 : data(std::make_shared<std::vector<T>>(il))
{/** ... */}
catch (const std::bad_alloc &e)
{
    handle_out_of_memory(e);
}

void recoup() noexcept; /** 不会抛出异常 */
void alloc();           /** 可能会抛出异常 */

void recoup() noexcept(true);	/** 不会抛出异常 */
void alloc() noexcept(false);	/** 可能抛出异常 */

noexcept(recoup())	/** 如果recoup不跑出异常则结果为true；否则结果为false */
noexcept(e)	/** 等价于上一句 */

void f() noexcept(noexcept(g()));	// f 和 g的异常说明一致

#include <iostream>
#include <compare>

struct Rational_2 {
    int num;
    int den; // > 0
};

constexpr std::weak_ordering operator<=>(Rational_2 lhs, Rational_2 rhs)
{
    return lhs.num * rhs.den <=> rhs.num * lhs.den;
}

void print(std::weak_ordering value)
{
    if (value == 0)
        std::cout << "equal\n";
    else if (value < 0)
        std::cout << "less\n";
    else
        std::cout << "greater\n";
}

int main()
{
    Rational_2 c{6,5};
    Rational_2 d{8,7};
    print(c <=> d);
    print(std::compare_three_way{}(c,d));
}

#include <iostream>
#include <compare>
struct Basics {
  int i;
  char c;
  float f;
  double d;
  auto operator<=>(const Basics&) const = default;
};

struct Arrays {
  int ai[1];
  char ac[2];
  float af[3];
  double ad[2][2];
  auto operator<=>(const Arrays&) const = default;
};

struct Bases : Basics, Arrays {
  auto operator<=>(const Bases&) const = default;
};

int main() {
  constexpr Bases a = { { 0, 'c', 1.f, 1. },
                        { { 1 }, { 'a', 'b' }, { 1.f, 2.f, 3.f }, { { 1., 2. }, { 3., 4. } } } };
  constexpr Bases b = { { 0, 'c', 1.f, 1. },
                        { { 1 }, { 'a', 'b' }, { 1.f, 2.f, 3.f }, { { 1., 2. }, { 3., 4. } } } };
  static_assert(a == b);
  static_assert(!(a != b));
  static_assert(!(a < b));
  static_assert(a <= b);
  static_assert(!(a > b));
  static_assert(a >= b);
}

// 一个定义std::set<struct>的例子
#include <set>
#include <iostream>

struct ORDERING_EXAMPLE
{
    int x;
    int y;
    int z;

    /// 重载遵循严格弱序的运算符<
    bool operator < (const ORDERING_EXAMPLE& OtherStruct) const
    {
        if (this->x < OtherStruct.x)
            return true;
        if (OtherStruct.x < this->x)
            return false;

        // x == x则比较y
        if (this->y < OtherStruct.y)
            return true;
        if (OtherStruct.y < this->y)
            return false;

        // y == y则比较z
        if (this->z < OtherStruct.z)
            return true;

        return false;
    }
};

int main()
{
    std::set<ORDERING_EXAMPLE> setOrderingExample;

    ORDERING_EXAMPLE stOrderingExample0 = { 0, 0, 0 };
    ORDERING_EXAMPLE stOrderingExample1 = { 0, 1, 2 };
    ORDERING_EXAMPLE stOrderingExample2 = { 0, 1, 3 };
    ORDERING_EXAMPLE stOrderingExample3 = { 0, 1, 3 };

    setOrderingExample.insert(stOrderingExample0);
    setOrderingExample.insert(stOrderingExample1);
    setOrderingExample.insert(stOrderingExample2);
    setOrderingExample.insert(stOrderingExample3);

    return 0;
}

#include <algorithm>
#include <iostream>
#include <vector>

int main() {
  std::vector<int> temp(5, 1);
  std::vector<std::vector<int>> vec(5, temp);
  std::sort(vec.begin(), vec.end(),
            [](const std::vector<int> &l, const std::vector<int> &r) {
              if (l.size() == r.size()) {
                for (size_t i = 0; i < l.size(); ++i) {
                  if (l.at(i) == r.at(i)) {
                    continue;
                  } else {
                    return l.at(i) < r.at(i);
                  }
                }
                return true;  /// 这里会崩溃，改为false则不会而不会崩溃(遵循严格弱序)
              } else {
                return l.size() < r.size();
              }
            });
}

class key
{
public:
    int x;
    int y;

    bool operator<(const key& stOther)
    {
        if (x < stOther.x)
        {
            return true;
        }
        else if (x > stOther.x)
        {
            return false;
        }
        else if (y < stOther.y)
        {
            return true;
        }
        else if (y > stOther.y)
        {
            return false;
        }
        else
        {
            return false;
        }
    }
};

class key
{
public:
    int x;
    std::string y;

    bool operator<(const key& stOther)
    {
        if (x < stOther.x)
        {
            return true;
        }
        else if (x > stOther.x)
        {
            return false;
        }
        else if (y < stOther.y)
        {
            return true;
        }
        else if (y > stOther.y)
        {
            return false;
        }
        else
        {
            return false;
        }
    }
};