remove hpp

8 files changed, 0 insertions, 1841 deletions

diff --git a/meowpp/dsa/BinaryIndexTree.hpp b/meowpp/dsa/BinaryIndexTree.hpp
deleted file mode 100644
index f84a931..0000000
--- a/meowpp/dsa/BinaryIndexTree.hpp
+++ /dev/null
@@ -1,51 +0,0 @@
-#include "BinaryIndexTree.h"
-
-#include <cstdlib>
-
-#include <vector>
-#include <algorithm>
-
-
-namespace meow{
-  template<class Value>
-  inline
-  BinaryIndexTree<Value>::BinaryIndexTree():
-  _array(0){
-  }
-  template<class Value>
-  inline
-  BinaryIndexTree<Value>::BinaryIndexTree(size_t __size, Value const& __value):
-  _array(__size, __value){
-  }
-  template<class Value>
-  inline
-  BinaryIndexTree<Value>::BinaryIndexTree(BinaryIndexTree const& __tree2):
-  _array(__tree2._array){
-  }
-  //
-  template<class Value>
-  inline void
-  BinaryIndexTree<Value>::reset(size_t __size, Value const& __init){
-    _array.clear();
-    _array.resize(__size, __init);
-  }
-  //
-  template<class Value>
-  inline void
-  BinaryIndexTree<Value>::update(size_t __index, Value const& __value){
-    __index++;
-    for( ; __index <= _array.size(); __index += (__index & -__index)){
-      _array[__index - 1] = _array[__index - 1] +  __value;
-    }
-  }
-  template<class Value>
-  inline Value
-  BinaryIndexTree<Value>::query(ssize_t __index) const{
-    __index = std::min(__index + 1, (ssize_t)_array.size());
-    Value ret(0);
-    for( ; 0 < __index; __index -= (__index & -__index)){
-      ret = ret + _array[__index - 1];
-    }
-    return ret;
-  }
-}
diff --git a/meowpp/dsa/DisjointSet.hpp b/meowpp/dsa/DisjointSet.hpp
deleted file mode 100644
index 98b2b98..0000000
--- a/meowpp/dsa/DisjointSet.hpp
+++ /dev/null
@@ -1,55 +0,0 @@
-#include "DisjointSet.h"
-
-
-#include <vector>
-#include <cstdlib>
-
-namespace meow{
-  inline size_t DisjointSet::_root(size_t now){
-    if(father[now] == now) return now;
-    return (father[now] = _root(father[now]));
-  }
-  inline size_t DisjointSet::_merge(size_t a, size_t b){
-    a = _root(a);
-    b = _root(b);
-    if(a == b) return a;
-    if(depth[a] > depth[b]){
-      father[b] = a;
-      return a;
-    }else{
-      father[a] = b;
-      if(depth[a] == depth[b]){
-        depth[b]++;
-      }
-      return b;
-    }
-  }
-  //
-  inline DisjointSet::DisjointSet(): n(0){ }
-  inline DisjointSet::DisjointSet(size_t _n): n(0){
-    reset(_n);
-  }
-  inline DisjointSet::DisjointSet(DisjointSet const& dsj){
-    n      = dsj.n;
-    father = dsj.father;
-    depth  = dsj.depth;
-  }
-  //
-  inline size_t DisjointSet::root(size_t a) const{
-    return ((DisjointSet*)this)->_root(a);
-  }
-  inline size_t DisjointSet::size() const{ return n; }
-  //
-  inline void DisjointSet::reset(size_t _n){
-    n = _n;
-    father.resize(n);
-    depth .resize(n);
-    for(size_t i = 0; i < n; i++){
-      father[i] = i;
-      depth [i] = 1;
-    }
-  }
-  inline size_t DisjointSet::merge(size_t a, size_t b){
-    return _merge(a, b);
-  }
-}
diff --git a/meowpp/dsa/KD_Tree.hpp b/meowpp/dsa/KD_Tree.hpp
deleted file mode 100644
index 824b917..0000000
--- a/meowpp/dsa/KD_Tree.hpp
+++ /dev/null
@@ -1,272 +0,0 @@
-#include "KD_Tree.h"
-
-
-#include "../utility.h"
-#include "../math/utility.h"
-
-#include <cstdlib>
-
-#include <vector>
-#include <algorithm>
-#include <queue>
-
-namespace meow{
-  ////////////////////////////////////////////////////////////////////
-  //                          **# Node #**                          //
-  ////////////////////////////////////////////////////////////////////
-  template<class Vector, class Scalar>
-  inline
-  KD_Tree<Vector, Scalar>::Node::Node(Vector __vector,
-                                      ssize_t __lChild, ssize_t __rChild):
-  _vector(__vector), _lChild(__lChild), _rChild(__rChild){
-  }
-  ////////////////////////////////////////////////////////////////////
-  //                         **# Sorter #**                         //
-  ////////////////////////////////////////////////////////////////////
-  template<class Vector, class Scalar>
-  inline
-  KD_Tree<Vector, Scalar>::Sorter::Sorter(Nodes const* __nodes, size_t __cmp):
-  _nodes(__nodes), _cmp(__cmp){
-  }
-  template<class Vector, class Scalar>
-  inline bool
-  KD_Tree<Vector, Scalar>::Sorter::operator()(size_t const& __a,
-                                              size_t const& __b) const{
-    if((*_nodes)[__a]._vector[_cmp] != (*_nodes)[__b]._vector[_cmp]){
-      return ((*_nodes)[__a]._vector[_cmp] < (*_nodes)[__b]._vector[_cmp]);
-    }
-    return ((*_nodes)[__a]._vector < (*_nodes)[__b]._vector);
-  }
-  ////////////////////////////////////////////////////////////////////
-  //             **# Answer / Answer's Compare class #**            //
-  ////////////////////////////////////////////////////////////////////
-  template<class Vector, class Scalar>
-  inline
-  KD_Tree<Vector, Scalar>::Answer::Answer(ssize_t __index, Scalar __dist2):
-  _index(__index), _dist2(__dist2){
-  }
-  template<class Vector, class Scalar>
-  inline
-  KD_Tree<Vector, Scalar>::Answer::Answer(Answer const& __answer2):
-  _index(__answer2._index), _dist2(__answer2._dist2){
-  }
-  //
-  template<class Vector, class Scalar>
-  inline
-  KD_Tree<Vector, Scalar>::AnswerCompare::AnswerCompare(Nodes const* __nodes,
-                                                        bool __cmpValue):
-  _nodes(__nodes), _cmpValue(__cmpValue){
-  }
-  template<class Vector, class Scalar>
-  inline bool
-  KD_Tree<Vector, Scalar>::AnswerCompare::operator()(Answer const& __a,
-                                                     Answer const& __b) const{
-    if(_cmpValue == true && __a._dist2 == __b._dist2){
-      return ((*_nodes)[__a._index]._vector < (*_nodes)[__b._index]._vector);
-    }
-    return (__a._dist2 < __b._dist2);
-  }
-  ////////////////////////////////////////////////////////////////////
-  //                     **# distance2() #**                        //
-  ////////////////////////////////////////////////////////////////////
-  template<class Vector, class Scalar>
-  inline Scalar
-  KD_Tree<Vector, Scalar>::distance2(Vector const& __v1,
-                                     Vector const& __v2) const{
-    Scalar ret(0);
-    for(size_t i = 0; i < _dimension; i++){
-      ret += squ(__v1[i] - __v2[i]);
-    }
-    return ret;
-  }
-  ////////////////////////////////////////////////////////////////////
-  //                        **# query() #**                         //
-  ////////////////////////////////////////////////////////////////////
-  template<class Vector, class Scalar>
-  inline void
-  KD_Tree<Vector, Scalar>::query(Vector const&        __vector,
-                                 size_t               __nearestNumber,
-                                 AnswerCompare const& __answerCompare,
-                                 ssize_t              __index,
-                                 int                  __depth,
-                                 std::vector<Scalar>& __dist2Vector,
-                                 Scalar               __dist2Minimum,
-                                 Answers*             __out) const{
-    if(__index == _NIL) return ;
-    size_t cmp = __depth % _dimension;
-    ssize_t this_side, that_side;
-    if(!(_nodes[__index]._vector[cmp] < __vector[cmp])){
-      this_side = _nodes[__index]._lChild;
-      that_side = _nodes[__index]._rChild;
-    }else{
-      this_side = _nodes[__index]._rChild;
-      that_side = _nodes[__index]._lChild;
-    }
-    query(__vector, __nearestNumber, __answerCompare,
-          this_side, __depth + 1,
-          __dist2Vector, __dist2Minimum,
-          __out);
-    Answer my_ans(__index, distance2(_nodes[__index]._vector, __vector));
-    if(__out->size() < __nearestNumber ||
-       __answerCompare(my_ans, __out->top())){
-      __out->push(my_ans);
-      if(__out->size() > __nearestNumber) __out->pop();
-    }
-    Scalar dist2_old = __dist2Vector[cmp];
-    __dist2Vector[cmp] = squ(_nodes[__index]._vector[cmp] - __vector[cmp]);
-    Scalar dist2Minimum = __dist2Minimum + __dist2Vector[cmp] - dist2_old;
-    if(__out->size() < __nearestNumber ||
-       !(__out->top()._dist2 < dist2Minimum)){
-      query(__vector, __nearestNumber, __answerCompare,
-            that_side, __depth + 1,
-            __dist2Vector, dist2Minimum,
-            __out);
-    }
-    __dist2Vector[cmp] = dist2_old;
-  }
-  ////////////////////////////////////////////////////////////////////
-  //                        **# build() #**                         //
-  ////////////////////////////////////////////////////////////////////
-  template<class Vector, class Scalar>
-  inline ssize_t
-  KD_Tree<Vector, Scalar>::build(ssize_t              __beg,
-                                 ssize_t              __end,
-                                 std::vector<size_t>* __orders,
-                                 int                  __depth){
-    if(__beg > __end) return _NIL;
-    size_t tmp_order  = _dimension;
-    size_t which_side = _dimension + 1;
-    ssize_t mid = (__beg + __end) / 2;
-    size_t  cmp = __depth % _dimension;
-    for(ssize_t i = __beg; i <= mid; i++){
-      __orders[which_side][__orders[cmp][i]] = 0;
-    }
-    for(ssize_t i = mid + 1; i <= __end; i++){
-      __orders[which_side][__orders[cmp][i]] = 1;
-    }
-    for(size_t i = 0; i < _dimension; i++){
-      if(i == cmp) continue;
-      size_t left = __beg, right = mid + 1;
-      for(int j = __beg; j <= __end; j++){
-        size_t ask = __orders[i][j];
-        if(ask == __orders[cmp][mid]){
-          __orders[tmp_order][mid] = ask;
-        }else if(__orders[which_side][ask] == 1){
-          __orders[tmp_order][right++] = ask;
-        }else{
-          __orders[tmp_order][left++] = ask;
-        }
-      }
-      for(int j = __beg; j <= __end; j++){
-        __orders[i][j] = __orders[tmp_order][j];
-      }
-    }
-    _nodes[__orders[cmp][mid]]._lChild=build(__beg,mid-1,__orders,__depth+1);
-    _nodes[__orders[cmp][mid]]._rChild=build(mid+1,__end,__orders,__depth+1);
-    return __orders[cmp][mid];
-  }
-  ////////////////////////////////////////////////////////////////////
-  //             **# constructures/destructures #**                 //
-  ////////////////////////////////////////////////////////////////////
-  template<class Vector, class Scalar>
-  inline
-  KD_Tree<Vector, Scalar>::KD_Tree():
-  _NIL(-1), _root(_NIL), _needRebuild(false), _dimension(1){
-  }
-  template<class Vector, class Scalar>
-  inline
-  KD_Tree<Vector, Scalar>::KD_Tree(size_t __dimension):
-  _NIL(-1), _root(_NIL), _needRebuild(false), _dimension(__dimension){
-  }
-  template<class Vector, class Scalar>
-  inline
-  KD_Tree<Vector, Scalar>::~KD_Tree(){
-  }
-  ////////////////////////////////////////////////////////////////////
-  //                       **# insert, build #**                    //
-  ////////////////////////////////////////////////////////////////////
-  template<class Vector, class Scalar>
-  inline void
-  KD_Tree<Vector, Scalar>::insert(Vector const& __vector){
-    _nodes.push_back(Node(__vector, _NIL, _NIL));
-    _needRebuild = true;
-  }
-  template<class Vector, class Scalar>
-  inline bool
-  KD_Tree<Vector, Scalar>::erase(Vector const& __vector){
-    for(size_t i = 0, I = _nodes.size(); i < I; i++){
-      if(_nodes[i] == __vector){
-        if(i != I - 1){
-          std::swap(_nodes[i], _nodes[I - 1]);
-        }
-        _needRebuild = true;
-        return true;
-      }
-    }
-    return false;
-  }
-  template<class Vector, class Scalar>
-  inline void
-  KD_Tree<Vector, Scalar>::build(){
-    if(_needRebuild){
-      forceBuild();
-    }
-  }
-  template<class Vector, class Scalar>
-  inline void
-  KD_Tree<Vector, Scalar>::forceBuild(){
-    std::vector<size_t> *orders = new std::vector<size_t>[_dimension + 2];
-    for(size_t j = 0; j < _dimension + 2; j++){
-      orders[j].resize(_nodes.size());
-    }
-    for(size_t j = 0; j < _dimension; j++){
-      for(size_t i = 0, I = _nodes.size(); i < I; i++){
-        orders[j][i] = i;
-      }
-      std::sort(orders[j].begin(), orders[j].end(), Sorter(&_nodes, j));
-    }
-    _root = build(0, (ssize_t)_nodes.size() - 1, orders, 0);
-    delete [] orders;
-    _needRebuild = false;
-  }
-  ////////////////////////////////////////////////////////////////////
-  //                          **# query #**                         //
-  ////////////////////////////////////////////////////////////////////
-  template<class Vector, class Scalar>
-  inline typename KD_Tree<Vector, Scalar>::Vectors
-  KD_Tree<Vector, Scalar>::query(Vector const& __vector,
-                                 size_t        __nearestNumber,
-                                 bool          __compareWholeVector) const{
-    ((KD_Tree*)this)->build();
-    AnswerCompare answer_compare(&_nodes, __compareWholeVector);
-    Answers       answer_set(answer_compare);
-    std::vector<Scalar> tmp(_dimension, 0);
-    query(__vector, __nearestNumber,
-          answer_compare,
-          _root, 0,
-          tmp, Scalar(0),
-          &answer_set);
-    Vectors ret(answer_set.size());
-    for(int i = (ssize_t)answer_set.size() - 1; i >= 0; i--){
-      ret[i] = _nodes[answer_set.top()._index]._vector;
-      answer_set.pop();
-    }
-    return ret;
-  }
-  ////////////////////////////////////////////////////////////////////
-  //                       **# clear, reset #**                     //
-  ////////////////////////////////////////////////////////////////////
-  template<class Vector, class Scalar>
-  inline void
-  KD_Tree<Vector, Scalar>::clear(){
-    _root = _NIL;
-    _nodes.clear();
-    _needRebuild = false;
-  }
-  template<class Vector, class Scalar>
-  inline void
-  KD_Tree<Vector, Scalar>::reset(size_t __dimension){
-    clear();
-    _dimension = __dimension;
-  }
-}
diff --git a/meowpp/dsa/MergeableHeap.hpp b/meowpp/dsa/MergeableHeap.hpp
deleted file mode 100644
index 1470ac3..0000000
--- a/meowpp/dsa/MergeableHeap.hpp
+++ /dev/null
@@ -1,127 +0,0 @@
-#include "MergeableHeap.h"
-
-#include <cstdlib>
-
-#include <algorithm>
-
-namespace meow{
-  //////////////////////////////////////////////////////////
-  //      **# MergeableHeap--Node-- constructor #**       //
-  //////////////////////////////////////////////////////////
-  template<class Element>
-  inline MergeableHeap<Element>::Node::Node(Element const& _value): // Node
-  value(_value), l_child(NULL), r_child(NULL), weight(1){ }
-  
-  //////////////////////////////////////////////////////////
-  //      **# MergeableHeap -- clear, duplicate #**       //
-  //////////////////////////////////////////////////////////
-  template<class Element>
-  inline void MergeableHeap<Element>::clear(Node* _node){           //clear
-    if(_node != NULL){
-      clear(_node->l_child);
-      clear(_node->r_child);
-      delete _node;
-    }
-  }
-  template<class Element>
-  inline typename MergeableHeap<Element>::Node*
-  MergeableHeap<Element>::dup(Node* _node2){                    // dup
-    if(_node2 == NULL) return NULL;
-    Node* ret = new Node(_node2->value);
-    ret->l_child = dup(_node2->l_child);
-    ret->r_child = dup(_node2->r_child);
-    ret->weight = 1;
-    ret->weight += (ret->l_child == NULL ? 0 : ret->l_child->weight);
-    ret->weight += (ret->r_child == NULL ? 0 : ret->r_child->weight);
-    return ret;
-  }
-  
-  //////////////////////////////////////////////////////////
-  //           **# MergeableHeap -- merge #**             //
-  //////////////////////////////////////////////////////////
-  template<class Element>
-  inline typename MergeableHeap<Element>::Node*
-  MergeableHeap<Element>::merge(Node* _left, Node* _right){     //merge
-    if(_left  == NULL) return _right;
-    if(_right == NULL) return _left;
-    if(_left->value < _right->value){
-      std::swap(_left, _right);
-    }
-    _left->r_child = merge(_left->r_child, _right);
-    size_t lw = (_left->l_child == NULL ? 0 : _left->l_child->weight);
-    size_t rw = (_left->r_child == NULL ? 0 : _left->r_child->weight);
-    if(lw < rw){
-      std::swap(_left->l_child, _left->r_child);
-    }
-    _left->weight = 1 + lw + rw;
-    return _left;
-  }
-  
-  //////////////////////////////////////////////////////////
-  //   **# MergeableHeap -- constrctors/destructors #**   //
-  //////////////////////////////////////////////////////////
-  template<class Element>
-  inline MergeableHeap<Element>::MergeableHeap():       //MergeableHeap
-  root(NULL){ }
-  template<class Element>
-  inline MergeableHeap<Element>::MergeableHeap(MergeableHeap const& _heap2):
-  root(NULL){ root = dup(_heap2.root); }
-  template<class Element>
-  inline MergeableHeap<Element>::~MergeableHeap(){      //~MergeableHeap
-    clear(root);
-  }
-  
-  //////////////////////////////////////////////////////////
-  //**# MergeableHeap -- copy operation/data transform #**//
-  //////////////////////////////////////////////////////////
-  template<class Element>
-  inline MergeableHeap<Element>&
-  MergeableHeap<Element>::operator=(MergeableHeap const& _heap2){ // =
-    root = dup(_heap2.root);
-    return *this;
-  }
-  template<class Element>
-  inline void MergeableHeap<Element>::moveTo(MergeableHeap* _heap2){ // moveTo
-    _heap2->clear();
-    _heap2->root = root;
-    root = NULL;
-  }
-  //////////////////////////////////////////////////////////
-  //  **# MergeableHeap -- access: top, size, emtpy #**   //
-  //////////////////////////////////////////////////////////
-  template<class Element>                                   // top
-  inline Element const& MergeableHeap<Element>::top()const{return root->value;}
-  template<class Element>                                   // size
-  inline size_t MergeableHeap<Element>::size() const{
-    return (root == NULL ? 0 : root->weight);
-  }
-  template<class Element>                                   // empty
-  inline bool MergeableHeap<Element>::empty() const{ return (size() == 0); }
-  //////////////////////////////////////////////////////////
-  //  **# MergeableHeap -- update: push, pop, merge #**   //
-  //////////////////////////////////////////////////////////
-  template<class Element>
-  inline void MergeableHeap<Element>::push(Element const& _value){  // push
-    root = merge(root, new Node(_value));
-  }
-  template<class Element>
-  inline void MergeableHeap<Element>::pop(){                      // pop
-    Node* l = root->l_child;
-    Node* r = root->r_child;
-    delete root;
-    root = merge(l, r);
-  }
-  template<class Element>
-  inline void MergeableHeap<Element>::merge(MergeableHeap* _heap2){ // merge
-    root = merge(root, _heap2->root);
-    _heap2->root = NULL;
-  }
-  //////////////////////////////////////////////////////////
-  //      **# MergeableHeap -- refresh: clear #**         //
-  //////////////////////////////////////////////////////////
-  template<class Element>
-  inline void MergeableHeap<Element>::clear(){                // clear
-    clear(root);
-    root = NULL;
-  }
-}
diff --git a/meowpp/dsa/SegmentTree.hpp b/meowpp/dsa/SegmentTree.hpp
deleted file mode 100644
index 15ac0ef..0000000
--- a/meowpp/dsa/SegmentTree.hpp
+++ /dev/null
@@ -1,117 +0,0 @@
-#include "SegmentTree.h"
-
-
-#include "../math/utility.h"
-
-#include <cstdlib>
-
-#include <vector>
-#include <algorithm>
-
-namespace meow{
-  
-  template<class Value>
-  inline void
-  SegmentTree<Value>::update(size_t __i, size_t __size, Value const& __value,
-                             bool __over){
-    if(__over){
-      _nodes[__i]._value    = __value * __size;
-      _nodes[__i]._offset   = __value;
-      _nodes[__i]._sameFlag = true;
-    }else{
-      _nodes[__i]._value  = _nodes[__i]._value  + __value * __size;
-      _nodes[__i]._offset = _nodes[__i]._offset + __value;
-    }
-  }
-  template<class Value>
-  inline void
-  SegmentTree<Value>::update(size_t __l, size_t __r, size_t __L, size_t __R,
-                             size_t __i, Value const& __value,
-                             bool   __over){
-    if(__l == __L && __r == __R){
-      update(__i, __R - __L + 1, __value, __over);
-      return ;
-    }
-    size_t mid = (__L + __R) / 2;
-    if(__L < __R){
-      update(__i*2+1, mid-__L+1, _nodes[__i]._offset, _nodes[__i]._sameFlag);
-      update(__i*2+2, __R - mid, _nodes[__i]._offset, _nodes[__i]._sameFlag);
-      _nodes[__i]._offset = Value(0);
-      _nodes[__i]._sameFlag = false;
-    }
-    if     (__r   <= mid) update(__l,__r, __L  ,mid, __i*2+1, __value, __over);
-    else if(mid+1 <= __l) update(__l,__r, mid+1,__R, __i*2+2, __value, __over);
-    else{
-      update(__l,mid       , __L,mid  ,      __i*2+1, __value, __over);
-      update(    mid+1, __r,     mid+1, __R, __i*2+2, __value, __over);
-    }
-    _nodes[__i]._value = (
-      (_nodes[__i * 2 + 1]._value | _nodes[__i * 2 + 2]._value)
-      + _nodes[__i]._offset
-    );
-  }
-  template<class Value>
-  inline Value
-  SegmentTree<Value>::query(size_t __l, size_t __r, size_t __L, size_t __R,
-                            size_t __i){
-    if(__l == __L && __r == __R) return _nodes[__i]._value;
-    Value off = _nodes[__i]._offset * (__r - __l + 1);
-    if(_nodes[__i]._sameFlag) return off;
-    size_t mid = (__L + __R) / 2;
-    if     (__r   <= mid) return query(__l,__r, __L  , mid, __i*2+1) + off;
-    else if(mid+1 <= __l) return query(__l,__r, mid+1, __R, __i*2+2) + off;
-    else{
-      return (  query(__l, mid       , __L,  mid,        __i*2+1)
-              | query(     mid+1, __r,       mid+1, __R, __i*2+2)
-              ) + off;
-    }
-  }
-  //
-  template<class Value>
-  inline bool
-  SegmentTree<Value>::rangeCorrect(ssize_t* __first, ssize_t* __last) const{
-    if(*__last<*__first || *__last<0 || (ssize_t)_size-1<*__first) return false;
-    *__first = inRange((ssize_t)0, (ssize_t)_size - 1, *__first);
-    *__last  = inRange((ssize_t)0, (ssize_t)_size - 1, *__last );
-    return true;
-  }
-  //
-  template<class Value>
-  inline SegmentTree<Value>::SegmentTree(){ reset(1); }
-  template<class Value>
-  inline SegmentTree<Value>::SegmentTree(size_t __size){ reset(__size); }
-  template<class Value>
-  inline SegmentTree<Value>::SegmentTree(SegmentTree const& __tree2):
-  _size(__tree2._size), _nodes(__tree2._nodes){ }
-  //
-  template<class Value>
-  inline void
-  SegmentTree<Value>::reset(size_t __size){
-    _size = std::max(__size, (size_t)1);
-    _nodes.resize(__size * 4);
-    _nodes[0]._sameFlag = true;
-    _nodes[0]._value  = Value(0);
-    _nodes[0]._offset = Value(0);
-  }
-  template<class Value>
-  inline Value
-  SegmentTree<Value>::query(ssize_t __first, ssize_t __last) const{
-    if(rangeCorrect(&__first, &__last) == false) return Value();
-    return ((SegmentTree*)this)->query(__first, __last, 0, _size - 1, 0);
-  }
-  template<class Value>
-  inline void
-  SegmentTree<Value>::override(ssize_t __first, ssize_t __last,
-                               Value const& __value){
-    if(rangeCorrect(&__first, &__last) == false) return ;
-    update(__first, __last, 0, _size - 1, 0, __value, true);
-  }
-  template<class Value>
-  inline void
-  SegmentTree<Value>::offset(ssize_t __first, ssize_t __last,
-                             Value const& __delta){
-    if(rangeCorrect(&__first, &__last) == false) return ;
-    update(__first, __last, 0, _size - 1, 0, __delta, false);
-  }
-}
-
diff --git a/meowpp/dsa/SplayTree.hpp b/meowpp/dsa/SplayTree.hpp
deleted file mode 100644
index 3b08c14..0000000
--- a/meowpp/dsa/SplayTree.hpp
+++ /dev/null
@@ -1,437 +0,0 @@
-#include "SplayTree.h"
-
-
-#include <cstdlib>
-
-#include <utility>
-
-namespace meow{
-  ///////////////////////////// **# Node #** /////////////////////////
-  //////////////////// **# Node -- Constructure #** //////////////////
-  template<class Key, class Value>
-  inline
-  SplayTree<Key, Value>::Node::Node(Key   const& __key, Value const& __value):
-  _key(__key), _keyOffset(0), _value(__value){
-    _size     = 1;
-    _parent   = NULL;
-    _child[0] = NULL;
-    _child[1] = NULL;
-  }
-  //////////////////////// **# Node -- Offset #** ////////////////////
-  template<class Key, class Value>
-  inline void
-  SplayTree<Key, Value>::Node::keyOffset(Key const& __delta){
-    _key       = _key       + __delta;
-    _keyOffset = _keyOffset + __delta;
-  }
-  //////////////////////// **# Node -- sync #** //////////////////////
-  template<class Key, class Value>
-  inline void
-  SplayTree<Key, Value>::Node::syncDown() const{
-    for(size_t i = 0; i < 2; i++){
-      if(_child[i] == NULL) continue;
-      _child[i]->keyOffset(_keyOffset);
-    }
-    ((Node*)this)->_keyOffset = Key(0);
-  }
-  template<class Key, class Value>
-  inline void
-  SplayTree<Key, Value>::Node::syncUp() const{
-    ((Node*)this)->_size = 1;
-    for(size_t i = 0; i < 2; i++){
-      if(_child[i] == NULL) continue;
-      ((Node*)this)->_size += _child[i]->_size;
-    }
-  }
-  ////////////////////////// **# SplayTree #** ///////////////////////
-  ///////////////////// **# connection, splay #** ////////////////////
-  template<class Key, class Value>
-  inline void
-  SplayTree<Key, Value>::connect(Node const* __parent, size_t __left_right,
-                                 Node const* __child) const{
-    Node* parent = (Node*)__parent;
-    Node* child  = (Node*)__child;
-    if(parent != NULL) parent->_child[__left_right] = child;
-    if(child  != NULL) child ->_parent              = parent;
-  }
-  template<class Key, class Value>
-  inline typename SplayTree<Key, Value>::Node const*
-  SplayTree<Key, Value>::splay(Node const* __node) const{
-    if(__node != NULL && __node->_parent != NULL){
-      for(const Node *g_grand, *grand, *parent, *child = __node; ; ){
-        g_grand = (grand = parent = child->_parent)->_parent;
-        size_t pc = (parent->_child[0] == child ? 0 : 1);
-        connect(parent,  pc, child->_child[!pc]);
-        connect(child , !pc, parent);
-        if(g_grand != NULL){
-          g_grand = (grand = g_grand)->_parent;
-          size_t gp = (grand->_child[0] == parent ? 0 : 1);
-          Node const* who = (pc == gp ? parent : child);
-          connect(grand,  gp, who->_child[!gp]);
-          connect(who  , !gp, grand);
-          grand->syncUp();
-        }
-        parent->syncUp();
-        child ->syncUp();
-        if(g_grand == NULL){
-          connect(NULL, 0, child);
-          break;
-        }
-        connect(g_grand, (g_grand->_child[0] == grand ?  0 : 1), child);
-      }
-    }
-    return (((SplayTree*)this)->_root = (Node*)__node);
-  }
-  ///////////////////////// **# clear, dup #** ///////////////////////
-  template<class Key, class Value>
-  inline void
-  SplayTree<Key, Value>::clear(Node* __node){
-    if(__node == NULL) return ;
-    clear(__node->_child[0]);
-    clear(__node->_child[1]);
-    delete __node;
-  }
-  template<class Key, class Value>
-  inline typename SplayTree<Key, Value>::Node*
-  SplayTree<Key, Value>::dup(Node* __node){
-    if(__node == NULL) return NULL;
-    __node->syncDown();
-    Node* node = new Node(__node->_key, __node->_value);
-    connect(node, 0, dup(__node->_child[0]));
-    connect(node, 1, dup(__node->_child[1]));
-    node->syncUp();
-    return node;
-  }
-  /////////////////////////// **# find #** ///////////////////////////
-  template<class Key, class Value>
-  inline typename SplayTree<Key, Value>::Node const*
-  SplayTree<Key, Value>::findKey(Node const* __node, Key const& __key) const{
-    Node const* ret = __node;
-    while(__node != NULL){
-      __node->syncDown();
-      ret = __node;
-      if(!(__key < __node->_key)){
-        if(!(__node->_key< __key)) break;
-        __node = __node->_child[1];
-      }else{
-        __node = __node->_child[0];
-      }
-    }
-    return ret;
-  }
-  template<class Key, class Value>
-  inline typename SplayTree<Key, Value>::Node const*
-  SplayTree<Key, Value>::findMinMax(Node const* __node, bool __minimum) const{
-    Node const* ret = __node;
-    for(int i = __minimum ? 0 : 1; __node != NULL; __node = __node->_child[i]){
-      __node->syncDown();
-      ret = __node;
-    }
-    return ret;
-  }
-  template<class Key, class Value>
-  inline typename SplayTree<Key, Value>::Node const*
-  SplayTree<Key, Value>::findOrder(Node const* __node, size_t __order) const{
-    Node const* ret = __node;
-    while(__node != NULL){
-      __node->syncDown();
-      ret = __node;
-      size_t ord = 1 + (__node->_child[0]==NULL ? 0:__node->_child[0]->_size);
-      if     (ord == __order) return ret;
-      else if(ord <  __order){ __node = __node->_child[1]; __order -= ord; }
-      else                   { __node = __node->_child[0];                 }
-    }
-    return ret;
-  }
-  /////////////////////// **# split, merge #** ///////////////////////
-  template<class Key, class Value>
-  inline void
-  SplayTree<Key, Value>::split(Node* __root, Node** __left, Node** __right){
-    if(__root == NULL){ *__left  = NULL; *__right = NULL; return ; }
-    __root->syncDown();
-    *__left  = __root;
-    *__right = __root->_child[1];
-    if(*__right != NULL){
-      (*__left )->_child[1] = NULL;
-      (*__right)->_parent   = NULL;
-      (*__left )->syncUp();
-    }
-  }
-  template<class Key, class Value>
-  inline typename SplayTree<Key, Value>::Node*
-  SplayTree<Key, Value>::merge(Node* __left, Node* __right){
-    if(__left  == NULL) return __right;
-    if(__right == NULL) return __left ;
-    __left->syncDown();
-    connect(__left, 1, __right);
-    __left->syncUp();
-    return __left;
-  }
-  ///////////////////////// **# Element ##* //////////////////////////
-  template<class Key, class Value>
-  inline void SplayTree<Key, Value>::Element::reset(Node* __node){
-    _node = __node;
-    delete _entry;
-    if(__node == NULL) _entry = NULL;
-    else               _entry = new Entry(__node->_key, __node->_value);
-  }
-  //
-  template<class Key, class Value>
-  inline
-  SplayTree<Key, Value>::Element::Element():
-  _entry(NULL), _node(NULL){
-  }
-  template<class Key, class Value>
-  inline
-  SplayTree<Key, Value>::Element::Element(Node* __node):
-  _entry(NULL), _node(NULL){
-    reset(__node);
-  }
-  template<class Key, class Value>
-  inline
-  SplayTree<Key, Value>::Element::Element(Element const& __element2):
-  _entry(NULL), _node(NULL){
-    reset(__element2._node);
-  }
-  template<class Key, class Value>
-  inline
-  SplayTree<Key, Value>::Element::~Element(){
-    delete _entry;
-  }
-  template<class Key, class Value>
-  inline typename SplayTree<Key, Value>::Element&
-  SplayTree<Key, Value>::Element::operator=(Element const& __e2){
-    reset(__e2._node);
-    return *this;
-  }
-  //////////////////// **# Element operations #** ////////////////////
-  template<class Key, class Value>
-  inline typename SplayTree<Key, Value>::Element::Entry*
-  SplayTree<Key, Value>::Element::operator->(){ return  _entry; }
-  template<class Key, class Value>
-  inline typename SplayTree<Key, Value>::Element::Entry&
-  SplayTree<Key, Value>::Element::operator*(){ return *_entry; }
-  //
-  template<class Key, class Value>
-  inline bool
-  SplayTree<Key, Value>::Element::operator==(Element const& __e2) const{
-    return (_node == __e2._node);
-  }
-  template<class Key, class Value>
-  inline bool
-  SplayTree<Key, Value>::Element::operator!=(Element const& __e2) const{
-    return (_node != __e2._node);
-  }
-  /////// **# Splay tree constructure/destructure/copy oper #** //////
-  template<class Key, class Value>
-  inline
-  SplayTree<Key, Value>::SplayTree(): _root(NULL){
-  }
-  template<class Key, class Value>
-  inline
-  SplayTree<Key, Value>::SplayTree(SplayTree const& __tree2): _root(NULL){
-    _root = dup((Node*)(__tree2._root));
-  }
-  template<class Key, class Value>
-  inline
-  SplayTree<Key, Value>::~SplayTree(){
-    clear(_root);
-  }
-  template<class Key, class Value>
-  inline SplayTree<Key, Value>&
-  SplayTree<Key, Value>::operator=(SplayTree const& __tree2){
-    clear(_root);
-    _root = dup((Node*)(__tree2._root));
-    return *this;
-  }
-  template<class Key, class Value>
-  inline void
-  SplayTree<Key, Value>::moveTo(SplayTree* __tree2){
-    __tree2->clear();
-    __tree2->_root = _root;
-    _root = NULL;
-  }
-  //////////////////////// **# Bounding #** //////////////////////////
-  template<class Key, class Value>
-  inline typename SplayTree<Key, Value>::Element
-  SplayTree<Key, Value>::lowerBound(Key const& __key) const{
-    splay(findKey(_root, __key));
-    if(_root == NULL || !(_root->_key < __key)) return Element(_root);
-    if(_root->_child[1] == NULL) return Element(NULL);
-    splay(findMinMax(_root->_child[1], true));
-    return Element(_root);
-  }
-  template<class Key, class Value>
-  inline typename SplayTree<Key, Value>::Element
-  SplayTree<Key, Value>::upperBound(Key const& __key) const{
-    splay(findKey(_root, __key));
-    if(_root == NULL || __key < _root->_key) return Element(_root);
-    if(_root->_child[1] == NULL) return Element(NULL);
-    splay(findMinMax(_root->_child[1], true));
-    return Element(_root);
-  }
-  template<class Key, class Value>
-  inline typename SplayTree<Key, Value>::Element
-  SplayTree<Key, Value>::rLowerBound(Key const& __key) const{
-    splay(findKey(_root, __key));
-    if(_root == NULL || !(__key < _root->_key)) return Element(_root);
-    if(_root->_child[0] == NULL) return Element(NULL);
-    splay(findMinMax(_root->_child[0], false));
-    return Element(_root);
-  }
-  template<class Key, class Value>
-  inline typename SplayTree<Key, Value>::Element
-  SplayTree<Key, Value>::rUpperBound(Key const& __key) const{
-    splay(findKey(_root, __key));
-    if(_root == NULL || _root->_key < __key) return Element(_root);
-    if(_root->_child[0] == NULL) return Element(NULL);
-    splay(findMinMax(_root->_child[0], false));
-    return Element(_root);
-  }
-  ////////////// **# find / order / first / last / end #** ////////////
-  template<class Key, class Value>
-  inline typename SplayTree<Key, Value>::Element
-  SplayTree<Key, Value>::find(Key const& __key) const{
-    splay(findKey(_root, __key));
-    if(_root != NULL && !(__key < _root->_key) && !(_root->_key < __key)){
-      return Element(_root);
-    }
-    return Element(NULL);
-  }
-  template<class Key, class Value>
-  inline typename SplayTree<Key, Value>::Element
-  SplayTree<Key, Value>::order(size_t __order) const{
-    if(_root == NULL || __order >= _root->_size) return Element(NULL);
-    splay(findOrder(_root, __order + 1));
-    return Element(_root);
-  }
-  template<class Key, class Value>
-  inline typename SplayTree<Key, Value>::Element
-  SplayTree<Key, Value>::first() const{
-    splay(findMinMax(_root, true));
-    return Element(_root);
-  }
-  template<class Key, class Value>
-  inline typename SplayTree<Key, Value>::Element
-  SplayTree<Key, Value>::last() const{
-    splay(findMinMax(_root, false));
-    return Element(_root);
-  }
-  template<class Key, class Value>
-  inline typename SplayTree<Key, Value>::Element
-  SplayTree<Key, Value>::end() const{ return Element(NULL); }
-  //////////////////// **# size, empty, clear #** ////////////////////
-  template<class Key, class Value>
-  inline size_t SplayTree<Key, Value>::size() const{
-    return (_root == NULL ? 0 : _root->_size);
-  }
-  template<class Key, class Value>
-  inline bool SplayTree<Key, Value>::empty() const{
-    return (size() == 0);
-  }
-  //
-  template<class Key, class Value>
-  inline void SplayTree<Key, Value>::clear(){
-    clear(_root);
-    _root = NULL;
-  }
-  ////////////// **# insert, erase, keyOffset, oper[] #** ////////////
-  template<class Key, class Value>
-  inline bool SplayTree<Key, Value>::insert(Key const& __key,
-                                            Value const& __value){
-    if(_root == NULL){
-      _root = new Node(__key, __value);
-    }else{
-      Node* parent = (Node*)findKey(_root, __key);
-      if(!(parent->_key < __key) && !(__key < parent->_key)){
-        splay(parent);
-        return false;
-      }
-      Node* new_node = new Node(__key, __value);
-      connect(parent, (parent->_key < __key ? 1 : 0), new_node);
-      parent->syncUp();
-      splay(new_node);
-    }
-    return true;
-  }
-  template<class Key, class Value>
-  inline bool SplayTree<Key, Value>::erase(Key const& __key){
-    if(_root == NULL) return false;
-    Node* body = (Node*)findKey(_root, __key);
-    if(body->_key < __key || __key < body->_key){
-      splay(body);
-      return false;
-    }
-    Node* ghost;
-    if(body->_child[1] == NULL){
-      ghost = body->_child[0];
-      if(ghost != NULL) ghost->syncDown();
-    }else{
-      ghost = (Node*)findMinMax(body->_child[1], true);
-      connect(ghost, 0, body->_child[0]);
-      if(ghost != body->_child[1]){
-        connect(ghost->_parent, 0, ghost->_child[1]);
-        connect(ghost, 1, body->_child[1]);
-        for(Node* a = ghost->_parent; a != ghost; a = a->_parent)
-          a->syncUp();
-      }
-      ghost->syncUp();
-    }
-    Node* parent = body->_parent;
-    connect(parent, parent != NULL && parent->_child[0] == body ? 0 : 1,
-            ghost);
-    delete body;
-    splay(ghost != NULL ? ghost : parent);
-    return true;
-  }
-  template<class Key, class Value>
-  inline void SplayTree<Key, Value>::keyOffset(Key const& __delta){
-    if(_root != NULL){
-      _root->keyOffset(__delta);
-    }
-  }
-  template<class Key, class Value>
-  inline Value&
-  SplayTree<Key, Value>::operator[](Key const& __key){
-    if(find(__key) == end()) insert(__key, Value());
-    return _root->_value;
-  }
-  /////////////////////// **# split, merge #** ///////////////////////
-  template<class Key, class Value>
-  inline void
-  SplayTree<Key, Value>::splitOut(Key const& __upper_bound, SplayTree* __right){
-    __right->clear();
-    if(rLowerBound(__upper_bound) != end()){
-      split(_root, &_root, &(__right->_root));
-    }else{
-      __right->_root = _root;
-      _root = NULL;
-    }
-  }
-  template<class Key, class Value>
-  inline bool
-  SplayTree<Key, Value>::mergeAfter(SplayTree* __tree2){
-    if(_root == NULL || __tree2->_root == NULL ||
-       last()->first < __tree2->first()->first){
-      _root = merge(_root, __tree2->_root);
-      __tree2->_root = NULL;
-      return true;
-    }
-    return false;
-  }
-  template<class Key, class Value>
-  inline bool
-  SplayTree<Key, Value>::merge(SplayTree* __tree2){
-    if(_root == NULL || __tree2->_root == NULL ||
-       last()->first < __tree2->first()->first){
-      _root = merge(_root, __tree2->_root);
-    }else if(__tree2->last()->first < first()->first){
-      _root = merge(__tree2->_root, _root);
-    }else{
-      return false;
-    }
-    __tree2->_root = NULL;
-    return true;
-  }
-}
-
diff --git a/meowpp/dsa/SplayTree_Range.hpp b/meowpp/dsa/SplayTree_Range.hpp
deleted file mode 100644
index def7ef7..0000000
--- a/meowpp/dsa/SplayTree_Range.hpp
+++ /dev/null
@@ -1,506 +0,0 @@
-#include "SplayTree_Range.h"
-
-
-#include <cstdlib>
-
-#include <utility>
-
-#include "../math/utility.h"
-
-namespace meow{
-  ///////////////////////////// **# Node #** /////////////////////////
-  //////////////////// **# Node -- Constructure #** //////////////////
-  template<class Key, class Value>
-  inline
-  SplayTree_Range<Key, Value>::Node::Node(Key const& __key,
-                                          Value const& __value):
-  _key(__key), _keyOffset(0), _value(__value), _valueOffset(0), _range(__value){
-    _same     = false;
-    _size     = 1;
-    _parent   = NULL;
-    _child[0] = NULL;
-    _child[1] = NULL;
-  }
-  ///////////////// **# Node -- Offset / Override #** ////////////////
-  template<class Key, class Value>
-  inline void
-  SplayTree_Range<Key, Value>::Node::keyOffset(Key const& __delta){
-    _key       = _key       + __delta;
-    _keyOffset = _keyOffset + __delta;
-  }
-  template<class Key, class Value>
-  inline void
-  SplayTree_Range<Key, Value>::Node::valueUpdate(Value const& __delta,
-                                                 bool __over){
-    if(__over){
-      _value       = __delta * _size;
-      _valueOffset = __delta;
-      _range       = __delta * _size;
-      _same = true;
-    }else{
-      _value       = _value       + __delta * _size;
-      _valueOffset = _valueOffset + __delta;
-      _range       = _range       + __delta * _size;
-    }
-  }
-  //////////////////////// **# Node -- sync #** //////////////////////
-  template<class Key, class Value>
-  inline void
-  SplayTree_Range<Key, Value>::Node::syncDown() const{
-    for(size_t i = 0; i < 2; i++){
-      if(_child[i] == NULL) continue;
-      _child[i]->keyOffset  (_keyOffset);
-      _child[i]->valueUpdate(_valueOffset, _same);
-    }
-    ((Node*)this)->_keyOffset   = Key(0);
-    ((Node*)this)->_valueOffset = Value(0);
-    ((Node*)this)->_same        = false;
-  }
-  template<class Key, class Value>
-  inline void
-  SplayTree_Range<Key, Value>::Node::syncUp() const{
-    ((Node*)this)->_size = 1;
-    Value* v[3] = {&(((Node*)this)->_value), NULL, NULL};
-    size_t vct = 1;
-    for(size_t i = 0; i < 2; i++){
-      if(_child[i] == NULL) continue;
-      ((Node*)this)->_size += _child[i]->_size;
-      v[vct++] = &(_child[i]->_range);
-    }
-    if     (vct == 1) ((Node*)this)->_range = (*v[0]);
-    else if(vct == 2) ((Node*)this)->_range = (*v[0]) | (*v[1]);
-    else              ((Node*)this)->_range = (*v[0]) | (*v[1]) | (*v[2]);
-  }
-  ////////////////////////// **# SplayTree_Range #** ///////////////////////
-  ///////////////////// **# connection, splay #** ////////////////////
-  template<class Key, class Value>
-  inline void
-  SplayTree_Range<Key, Value>::connect(Node const* __parent,
-                                       size_t __left_right,
-                                       Node const* __child) const{
-    Node* parent = (Node*)__parent;
-    Node* child  = (Node*)__child;
-    if(parent != NULL) parent->_child[__left_right] = child;
-    if(child  != NULL) child ->_parent              = parent;
-  }
-  template<class Key, class Value>
-  inline typename SplayTree_Range<Key, Value>::Node const*
-  SplayTree_Range<Key, Value>::splay(Node const* __node) const{
-    if(__node != NULL && __node->_parent != NULL){
-      for(const Node *g_grand, *grand, *parent, *child = __node; ; ){
-        g_grand = (grand = parent = child->_parent)->_parent;
-        size_t pc = (parent->_child[0] == child ? 0 : 1);
-        connect(parent,  pc, child->_child[!pc]);
-        connect(child , !pc, parent);
-        if(g_grand != NULL){
-          g_grand = (grand = g_grand)->_parent;
-          size_t gp = (grand->_child[0] == parent ? 0 : 1);
-          Node const* who = (pc == gp ? parent : child);
-          connect(grand,  gp, who->_child[!gp]);
-          connect(who  , !gp, grand);
-          grand->syncUp();
-        }
-        parent->syncUp();
-        child ->syncUp();
-        if(g_grand == NULL){
-          connect(NULL, 0, child);
-          break;
-        }
-        connect(g_grand, (g_grand->_child[0] == grand ?  0 : 1), child);
-      }
-    }
-    return (((SplayTree_Range*)this)->_root = (Node*)__node);
-  }
-  ///////////////////////// **# clear, dup #** ///////////////////////
-  template<class Key, class Value>
-  inline void
-  SplayTree_Range<Key, Value>::clear(Node* __node){
-    if(__node == NULL) return ;
-    clear(__node->_child[0]);
-    clear(__node->_child[1]);
-    delete __node;
-  }
-  template<class Key, class Value>
-  inline typename SplayTree_Range<Key, Value>::Node*
-  SplayTree_Range<Key, Value>::dup(Node* __node){
-    if(__node == NULL) return NULL;
-    __node->syncDown();
-    Node* node = new Node(__node->_key, __node->_value);
-    connect(node, 0, dup(__node->_child[0]));
-    connect(node, 1, dup(__node->_child[1]));
-    node->syncUp();
-    return node;
-  }
-  /////////////////////////// **# find #** ///////////////////////////
-  template<class Key, class Value>
-  inline typename SplayTree_Range<Key, Value>::Node const*
-  SplayTree_Range<Key, Value>::findKey(Node const* __node,
-                                       Key const& __key) const{
-    Node const* ret = __node;
-    while(__node != NULL){
-      __node->syncDown();
-      ret = __node;
-      if(!(__key < __node->_key)){
-        if(!(__node->_key< __key)) break;
-        __node = __node->_child[1];
-      }else{
-        __node = __node->_child[0];
-      }
-    }
-    return ret;
-  }
-  template<class Key, class Value>
-  inline typename SplayTree_Range<Key, Value>::Node const*
-  SplayTree_Range<Key, Value>::findMinMax(Node const* __node,
-                                          bool __minimum) const{
-    Node const* ret = __node;
-    for(int i = __minimum ? 0 : 1; __node != NULL; __node = __node->_child[i]){
-      __node->syncDown();
-      ret = __node;
-    }
-    return ret;
-  }
-  template<class Key, class Value>
-  inline typename SplayTree_Range<Key, Value>::Node const*
-  SplayTree_Range<Key, Value>::findOrder(Node const* __node,
-                                         size_t __order) const{
-    Node const* ret = __node;
-    while(__node != NULL){
-      __node->syncDown();
-      ret = __node;
-      size_t ord = 1 + (__node->_child[0]==NULL ? 0:__node->_child[0]->_size);
-      if     (ord == __order) return ret;
-      else if(ord <  __order){ __node = __node->_child[1]; __order -= ord; }
-      else                   { __node = __node->_child[0];                 }
-    }
-    return ret;
-  }
-  /////////////////////// **# split, merge #** ///////////////////////
-  template<class Key, class Value>
-  inline void
-  SplayTree_Range<Key, Value>::split(Node* __root, Node** __left,
-                                     Node** __right){
-    if(__root == NULL){ *__left  = NULL; *__right = NULL; return ; }
-    __root->syncDown();
-    *__left  = __root;
-    *__right = __root->_child[1];
-    if(*__right != NULL){
-      (*__left )->_child[1] = NULL;
-      (*__right)->_parent   = NULL;
-      (*__left )->syncUp();
-    }
-  }
-  template<class Key, class Value>
-  inline typename SplayTree_Range<Key, Value>::Node*
-  SplayTree_Range<Key, Value>::merge(Node* __left, Node* __right){
-    if(__left  == NULL) return __right;
-    if(__right == NULL) return __left ;
-    __left->syncDown();
-    connect(__left, 1, __right);
-    __left->syncUp();
-    return __left;
-  }
-  ///////////////////////// **# Element ##* //////////////////////////
-  template<class Key, class Value>
-  inline void SplayTree_Range<Key, Value>::Element::reset(Node* __node){
-    _node = __node;
-    delete _entry;
-    if(__node == NULL) _entry = NULL;
-    else               _entry = new Entry(__node->_key, __node->_value);
-  }
-  //
-  template<class Key, class Value>
-  inline
-  SplayTree_Range<Key, Value>::Element::Element():
-  _entry(NULL), _node(NULL){
-  }
-  template<class Key, class Value>
-  inline
-  SplayTree_Range<Key, Value>::Element::Element(Node* __node):
-  _entry(NULL), _node(NULL){
-    reset(__node);
-  }
-  template<class Key, class Value>
-  inline
-  SplayTree_Range<Key, Value>::Element::Element(Element const& __element2):
-  _entry(NULL), _node(NULL){
-    reset(__element2._node);
-  }
-  template<class Key, class Value>
-  inline
-  SplayTree_Range<Key, Value>::Element::~Element(){
-    delete _entry;
-  }
-  template<class Key, class Value>
-  inline typename SplayTree_Range<Key, Value>::Element&
-  SplayTree_Range<Key, Value>::Element::operator=(Element const& __e2){
-    reset(__e2._node);
-    return *this;
-  }
-  //////////////////// **# Element operations #** ////////////////////
-  template<class Key, class Value>
-  inline typename SplayTree_Range<Key, Value>::Element::Entry*
-  SplayTree_Range<Key, Value>::Element::operator->(){ return  _entry; }
-  template<class Key, class Value>
-  inline typename SplayTree_Range<Key, Value>::Element::Entry&
-  SplayTree_Range<Key, Value>::Element::operator*(){ return *_entry; }
-  //
-  template<class Key, class Value>
-  inline bool
-  SplayTree_Range<Key, Value>::Element::operator==(Element const& __e2) const{
-    return (_node == __e2._node);
-  }
-  template<class Key, class Value>
-  inline bool
-  SplayTree_Range<Key, Value>::Element::operator!=(Element const& __e2) const{
-    return (_node != __e2._node);
-  }
-  /////// **# Splay tree constructure/destructure/copy oper #** //////
-  template<class Key, class Value>
-  inline
-  SplayTree_Range<Key, Value>::SplayTree_Range(): _root(NULL){
-  }
-  template<class Key, class Value>
-  inline
-  SplayTree_Range<Key, Value>::SplayTree_Range(SplayTree_Range const& __tree2):
-  _root(NULL){
-    _root = dup((Node*)(__tree2._root));
-  }
-  template<class Key, class Value>
-  inline
-  SplayTree_Range<Key, Value>::~SplayTree_Range(){
-    clear(_root);
-  }
-  template<class Key, class Value>
-  inline SplayTree_Range<Key, Value>&
-  SplayTree_Range<Key, Value>::operator=(SplayTree_Range const& __tree2){
-    clear(_root);
-    _root = dup((Node*)(__tree2._root));
-    return *this;
-  }
-  template<class Key, class Value>
-  inline void
-  SplayTree_Range<Key, Value>::moveTo(SplayTree_Range* __tree2){
-    __tree2->clear();
-    __tree2->_root = _root;
-    _root = NULL;
-  }
-  //////////////////////// **# Bounding #** //////////////////////////
-  template<class Key, class Value>
-  inline typename SplayTree_Range<Key, Value>::Element
-  SplayTree_Range<Key, Value>::lowerBound(Key const& __key) const{
-    splay(findKey(_root, __key));
-    if(_root == NULL || !(_root->_key < __key)) return Element(_root);
-    if(_root->_child[1] == NULL) return Element(NULL);
-    splay(findMinMax(_root->_child[1], true));
-    return Element(_root);
-  }
-  template<class Key, class Value>
-  inline typename SplayTree_Range<Key, Value>::Element
-  SplayTree_Range<Key, Value>::upperBound(Key const& __key) const{
-    splay(findKey(_root, __key));
-    if(_root == NULL || __key < _root->_key) return Element(_root);
-    if(_root->_child[1] == NULL) return Element(NULL);
-    splay(findMinMax(_root->_child[1], true));
-    return Element(_root);
-  }
-  template<class Key, class Value>
-  inline typename SplayTree_Range<Key, Value>::Element
-  SplayTree_Range<Key, Value>::rLowerBound(Key const& __key) const{
-    splay(findKey(_root, __key));
-    if(_root == NULL || !(__key < _root->_key)) return Element(_root);
-    if(_root->_child[0] == NULL) return Element(NULL);
-    splay(findMinMax(_root->_child[0], false));
-    return Element(_root);
-  }
-  template<class Key, class Value>
-  inline typename SplayTree_Range<Key, Value>::Element
-  SplayTree_Range<Key, Value>::rUpperBound(Key const& __key) const{
-    splay(findKey(_root, __key));
-    if(_root == NULL || _root->_key < __key) return Element(_root);
-    if(_root->_child[0] == NULL) return Element(NULL);
-    splay(findMinMax(_root->_child[0], false));
-    return Element(_root);
-  }
-  ////////////// **# find / order / first / last / end #** ////////////
-  template<class Key, class Value>
-  inline typename SplayTree_Range<Key, Value>::Element
-  SplayTree_Range<Key, Value>::find(Key const& __key) const{
-    splay(findKey(_root, __key));
-    if(_root != NULL && !(__key < _root->_key) && !(_root->_key < __key)){
-      return Element(_root);
-    }
-    return Element(NULL);
-  }
-  template<class Key, class Value>
-  inline typename SplayTree_Range<Key, Value>::Element
-  SplayTree_Range<Key, Value>::order(size_t __order) const{
-    if(_root == NULL || __order >= _root->_size) return Element(NULL);
-    splay(findOrder(_root, __order + 1));
-    return Element(_root);
-  }
-  template<class Key, class Value>
-  inline typename SplayTree_Range<Key, Value>::Element
-  SplayTree_Range<Key, Value>::first() const{
-    splay(findMinMax(_root, true));
-    return Element(_root);
-  }
-  template<class Key, class Value>
-  inline typename SplayTree_Range<Key, Value>::Element
-  SplayTree_Range<Key, Value>::last() const{
-    splay(findMinMax(_root, false));
-    return Element(_root);
-  }
-  template<class Key, class Value>
-  inline typename SplayTree_Range<Key, Value>::Element
-  SplayTree_Range<Key, Value>::end() const{ return Element(NULL); }
-  //////////////////// **# query, range query #** ////////////////////
-  template<class Key, class Value>
-  inline Value
-  SplayTree_Range<Key, Value>::query() const{
-    if(_root == NULL) return Value(0);
-    return _root->_range;
-  }
-  template<class Key, class Value>
-  inline Value
-  SplayTree_Range<Key, Value>::query(Key const& __first,
-                                     Key const& __last) const{
-    SplayTree_Range* self = (SplayTree_Range*)this;
-    Node* tmp;
-    rUpperBound(__first);
-    self->split(self->_root, &tmp, &(self->_root));
-    upperBound(__last);
-    Value ret(0);
-    if(_root != NULL && _root->_child[0] != NULL){
-      ret = _root->_child[0]->_range;
-    }
-    self->_root = self->merge(tmp, self->_root);
-    return ret;
-  }
-  //////////////////// **# size, empty, clear #** ////////////////////
-  template<class Key, class Value>
-  inline size_t SplayTree_Range<Key, Value>::size() const{
-    return (_root == NULL ? 0 : _root->_size);
-  }
-  template<class Key, class Value>
-  inline bool SplayTree_Range<Key, Value>::empty() const{
-    return (size() == 0);
-  }
-  //
-  template<class Key, class Value>
-  inline void SplayTree_Range<Key, Value>::clear(){
-    clear(_root);
-    _root = NULL;
-  }
-  ////////////// **# insert, erase, keyOffset, oper[] #** ////////////
-  template<class Key, class Value>
-  inline bool SplayTree_Range<Key, Value>::insert(Key const& __key,
-                                                  Value const& __value){
-    if(_root == NULL){
-      _root = new Node(__key, __value);
-    }else{
-      Node* parent = (Node*)findKey(_root, __key);
-      if(!(parent->_key < __key) && !(__key < parent->_key)){
-        splay(parent);
-        return false;
-      }
-      Node* new_node = new Node(__key, __value);
-      connect(parent, (parent->_key < __key ? 1 : 0), new_node);
-      parent->syncUp();
-      splay(new_node);
-    }
-    return true;
-  }
-  template<class Key, class Value>
-  inline bool SplayTree_Range<Key, Value>::erase(Key const& __key){
-    if(_root == NULL) return false;
-    Node* body = (Node*)findKey(_root, __key);
-    if(body->_key < __key || __key < body->_key){
-      splay(body);
-      return false;
-    }
-    Node* ghost;
-    if(body->_child[1] == NULL){
-      ghost = body->_child[0];
-      if(ghost != NULL) ghost->syncDown();
-    }else{
-      ghost = (Node*)findMinMax(body->_child[1], true);
-      connect(ghost, 0, body->_child[0]);
-      if(ghost != body->_child[1]){
-        connect(ghost->_parent, 0, ghost->_child[1]);
-        connect(ghost, 1, body->_child[1]);
-        for(Node* a = ghost->_parent; a != ghost; a = a->_parent)
-          a->syncUp();
-      }
-      ghost->syncUp();
-    }
-    Node* parent = body->_parent;
-    connect(parent, parent != NULL && parent->_child[0] == body ? 0 : 1,
-            ghost);
-    delete body;
-    splay(ghost != NULL ? ghost : parent);
-    return true;
-  }
-  template<class Key, class Value>
-  inline void SplayTree_Range<Key, Value>::keyOffset(Key const& __delta){
-    if(_root != NULL){
-      _root->keyOffset(__delta);
-    }
-  }
-  template<class Key, class Value>
-  inline void SplayTree_Range<Key, Value>::valueOffset(Value const& __delta){
-    if(_root != NULL){
-      _root->valueUpdate(__delta, false);
-    }
-  }
-  template<class Key, class Value>
-  inline void SplayTree_Range<Key, Value>::valueOverride(Value const& __value){
-    if(_root != NULL){
-      _root->valueUpdate(__value, true);
-    }
-  }
-  template<class Key, class Value>
-  inline Value&
-  SplayTree_Range<Key, Value>::operator[](Key const& __key){
-    if(find(__key) == end()) insert(__key, Value());
-    return _root->_value;
-  }
-  /////////////////////// **# split, merge #** ///////////////////////
-  template<class Key, class Value>
-  inline void
-  SplayTree_Range<Key, Value>::splitOut(Key const& __upper_bound, SplayTree_Range* __right){
-    __right->clear();
-    if(rLowerBound(__upper_bound) != end()){
-      split(_root, &_root, &(__right->_root));
-    }else{
-      __right->_root = _root;
-      _root = NULL;
-    }
-  }
-  template<class Key, class Value>
-  inline bool
-  SplayTree_Range<Key, Value>::mergeAfter(SplayTree_Range* __tree2){
-    if(_root == NULL || __tree2->_root == NULL ||
-       last()->first < __tree2->first()->first){
-      _root = merge(_root, __tree2->_root);
-      __tree2->_root = NULL;
-      return true;
-    }
-    return false;
-  }
-  template<class Key, class Value>
-  inline bool
-  SplayTree_Range<Key, Value>::merge(SplayTree_Range* __tree2){
-    if(_root == NULL || __tree2->_root == NULL ||
-       last()->first < __tree2->first()->first){
-      _root = merge(_root, __tree2->_root);
-    }else if(__tree2->last()->first < first()->first){
-      _root = merge(__tree2->_root, _root);
-    }else{
-      return false;
-    }
-    __tree2->_root = NULL;
-    return true;
-  }
-}
-
diff --git a/meowpp/dsa/VP_Tree.hpp b/meowpp/dsa/VP_Tree.hpp
deleted file mode 100644
index bb6b5f1..0000000
--- a/meowpp/dsa/VP_Tree.hpp
+++ /dev/null
@@ -1,276 +0,0 @@
-#include "VP_Tree.h"
-
-#include <cstdlib>
-
-#include <algorithm>
-#include <stack>
-#include "../math/utility.h"
-
-namespace meow{
-  ///////////////////// **# Node #** ///////////////////////
-  template<class Vector, class Scalar>
-  inline
-  VP_Tree<Vector, Scalar>::Node::Node(size_t __index):
-  _index(__index), _nearChild(NULL), _farChild(NULL){
-  }
-  ///////////////////// **# Answer #** /////////////////////
-  template<class Vector, class Scalar>
-  inline
-  VP_Tree<Vector, Scalar>::Answer::Answer(size_t __index,
-                                          Scalar const& __dist2):
-  _index(__index), _dist2(__dist2){
-  }
-  template<class Vector, class Scalar>
-  inline
-  VP_Tree<Vector, Scalar>::Answer::Answer(Answer const& __answer2):
-  _index(__answer2._index), _dist2(__answer2._dist2){
-  }
-  template<class Vector, class Scalar>
-  inline
-  VP_Tree<Vector, Scalar>::AnswerCompare::AnswerCompare
-  (Vectors const* __vectors, bool __cmpValue):
-  _vectors(__vectors), _cmpValue(__cmpValue){
-  }
-  template<class Vector, class Scalar>
-  inline bool
-  VP_Tree<Vector, Scalar>::AnswerCompare::operator()(Answer const& __a,
-                                                     Answer const& __b) const{
-    if(__a._dist2 < __b._dist2) return true;
-    if(__b._dist2 < __a._dist2) return false;
-    return (_cmpValue && ((*_vectors)[__a._index] < (*_vectors)[__b._index]));
-  }
-  //////// **# distance2, distanceCompare, split #** ///////
-  template<class Vector, class Scalar>
-  inline Scalar
-  VP_Tree<Vector, Scalar>::distance2(Vector const& __v1,
-                                     Vector const& __v2) const{
-    Scalar ret(0);
-    for(size_t i = 0; i < _dimension; i++) ret += squ(__v1[i] - __v2[i]);
-    return ret;
-  }
-  template<class Vector, class Scalar>
-  inline int
-  VP_Tree<Vector, Scalar>::distanceCompare(Scalar const& __a2,
-                                           Scalar const& __b2,
-                                           Scalar const& __c2) const{
-    // test if  sqrt(__a2) +- sqrt(|__b2|) <= sqrt(__c2)
-    if(__b2 < 0){
-      return -distanceCompare(__c2, -__b2, __a2);
-    }
-    Scalar cab(__c2 - __a2 - __b2);
-    if(cab < Scalar(0)) return 1;
-    Scalar ab2(Scalar(4) * __a2 * __b2), cab2(squ(cab));
-    if     ( ab2 < cab2) return -1;
-    else if(cab2 <  ab2) return  1;
-    else                 return  0;
-  }
-  template<class Vector, class Scalar>
-  inline Scalar
-  VP_Tree<Vector, Scalar>::split(ssize_t __first, ssize_t __last,
-                                 size_t __order, Vector const& __center){
-    ssize_t first0 = __first;
-    std::vector<Scalar> dist2(__last - __first + 1);
-    for(ssize_t i = __first; i <= __last; i++){
-      dist2[i - first0] = distance2(_vectors[i], __center);
-    }
-    while(__first < __last){
-      size_t threshold_index = __first + rand() % (__last - __first + 1);
-      Scalar threshold(dist2[threshold_index - first0]);
-      size_t large_first = __last + 1;
-      for(ssize_t i=__first; __first<=(ssize_t)large_first-1; large_first--){
-        if(threshold < dist2[large_first - 1 - first0]) continue;
-        while(i < (ssize_t)large_first-1&&!(threshold < dist2[i-first0])) i++;
-        if(i < (ssize_t)large_first - 1){
-          std::swap(dist2   [large_first - 1 - first0], dist2   [i - first0]);
-          std::swap(_vectors[large_first - 1         ], _vectors[i         ]);
-          i++;
-        }else{
-          break;
-        }
-      }
-      if(large_first == (size_t)__last + 1){
-        std::swap(dist2   [threshold_index-first0], dist2   [__last-first0]);
-        std::swap(_vectors[threshold_index       ], _vectors[__last       ]);
-        if((ssize_t)__order == __last - __first){
-          __first = __last;
-          break;
-        }
-        __last--;
-      }else{
-        if(__order < large_first - __first){
-          __last = large_first - 1;
-        }else{
-          __order -= large_first - __first;
-          __first = large_first;
-        }
-      }
-    }
-    return dist2[__first - first0];
-  }
-  ////////////////////// **# build() #** ///////////////////
-  template<class Vector, class Scalar>
-  inline typename VP_Tree<Vector, Scalar>::Node* 
-  VP_Tree<Vector, Scalar>::build(ssize_t __first, ssize_t __last){
-    if(__first > __last) return NULL;
-    Node* ret = new Node(__first);
-    if(__first < __last){
-      std::swap(_vectors[__first],
-                _vectors[__first + rand() % (__last - __first + 1)]);
-      ssize_t mid = (__first + 1 + __last + 1) / 2;
-      ret->_threshold = split(__first + 1, __last, mid - (__first + 1),
-                              _vectors[__first]);
-      ret->_nearChild = build(__first + 1, mid - 1        );
-      ret->_farChild  = build(             mid    , __last);
-    }
-    return ret;
-  }
-  ////////////////////// **# query() #** ///////////////////
-  template<class Vector, class Scalar>
-  inline void
-  VP_Tree<Vector, Scalar>::query(Vector const&        __vector,
-                                 size_t               __k,
-                                 AnswerCompare const& __cmp,
-                                 Node const*          __node,
-                                 Answers*             __out) const{
-    if(__node == NULL) return ;
-    Scalar dist2 = distance2(__vector, _vectors[__node->_index]);
-    Answer my_ans(__node->_index, dist2);
-    if(__out->size() < __k || __cmp(my_ans, __out->top())){
-      __out->push(my_ans);
-      if(__out->size() > __k){
-        __out->pop();
-      }
-    }
-    if(__node->_nearChild == NULL && __node->_farChild == NULL) return ;
-    if(__out->size() < __k || distanceCompare(dist2, -__out->top()._dist2,
-                                              __node->_threshold) <= 0){
-      query(__vector, __k, __cmp, __node->_nearChild, __out);
-    }
-    if(__out->size() < __k || distanceCompare(dist2,  __out->top()._dist2,
-                                              __node->_threshold) >= 0){
-      query(__vector, __k, __cmp, __node->_farChild, __out);
-    }
-  }
-  ///////////////// **# clear(), dup() #** /////////////////
-  template<class Vector, class Scalar>
-  inline void
-  VP_Tree<Vector, Scalar>::clear(Node* __root){
-    if(__root == NULL) return ;
-    clear(__root->_nearChild);
-    clear(__root->_farChild);
-    delete __root;
-  }
-  template<class Vector, class Scalar>
-  inline typename VP_Tree<Vector, Scalar>::Node*
-  VP_Tree<Vector, Scalar>::dup(Node* __root){
-    if(__root == NULL) return ;
-    Node* ret = new Node(__root->_index);
-    ret->_threshold = __root->_threshold;
-    ret->_nearChild = dup(__root->_nearChild);
-    ret->_farChild  = dup(__root->_farChild );
-    return ret;
-  }
-  ///////// **# construre/destructure/copy oper #** ////////
-  template<class Vector, class Scalar>
-  inline
-  VP_Tree<Vector, Scalar>::VP_Tree():
-  _root(NULL), _vectors(0), _dimension(0), _needRebuild(false){
-    reset(0);
-  }
-  template<class Vector, class Scalar>
-  inline
-  VP_Tree<Vector, Scalar>::VP_Tree(VP_Tree<Vector, Scalar> const& __tree2):
-  _vectors(__tree2._vectors),
-  _root(dup(__tree2._root)),
-  _dimension(__tree2._dimension),
-  _needRebuild(__tree2._needRebuild){
-  }
-  template<class Vector, class Scalar>
-  inline
-  VP_Tree<Vector, Scalar>::VP_Tree(size_t __dimension):
-  _vectors(0),
-  _root(NULL),
-  _dimension(0),
-  _needRebuild(false){
-    reset(__dimension);
-  }
-  template<class Vector, class Scalar>
-  inline
-  VP_Tree<Vector, Scalar>::~VP_Tree(){
-    clear(_root);
-  }
-  template<class Vector, class Scalar>
-  inline VP_Tree<Vector, Scalar>&
-  VP_Tree<Vector, Scalar>::operator=(VP_Tree const& __tree2){
-    reset(__tree2._dimension);
-    _vectors     = __tree2._vectors;
-    _root        = dup(__tree2._root);
-    _needRebuild = __tree2._needRebuild;
-  }
-  ////////////////// **# insert, erase #** /////////////////
-  template<class Vector, class Scalar>
-  inline void
-  VP_Tree<Vector, Scalar>::insert(Vector const& __vector){
-    _vectors.push_back(__vector);
-    _needRebuild = true;
-  }
-  template<class Vector, class Scalar>
-  inline bool
-  VP_Tree<Vector, Scalar>::erase(Vector const& __vector){
-    for(ssize_t i = 0, I = _vectors.size(); i < I; i++){
-      if(_vectors[i] == __vector){
-        if(i != I - 1) std::swap(_vectors[i], _vectors[I - 1]);
-        _needRebuild = true;
-        _vectors.pop_back();
-        return true;
-      }
-    }
-    return false;
-  }
-  ////////////////// **# build, forceBuild #** /////////////
-  template<class Vector, class Scalar>
-  inline void
-  VP_Tree<Vector, Scalar>::build(){
-    if(_needRebuild){
-      forceBuild();
-    }
-  }
-  template<class Vector, class Scalar>
-  inline void
-  VP_Tree<Vector, Scalar>::forceBuild(){
-    _root = build(0, (size_t)_vectors.size() - 1);
-    _needRebuild = false;
-  }
-  ////////////////////// **# query #** /////////////////////
-  template<class Vector, class Scalar>
-  inline typename VP_Tree<Vector, Scalar>::Vectors
-  VP_Tree<Vector, Scalar>::query(Vector const& __vector,
-                                 size_t        __nearestNumber,
-                                 bool          __compareWholeVector) const{
-    ((VP_Tree*)this)->build();
-    AnswerCompare cmp(&_vectors, __compareWholeVector);
-    Answers answers(cmp);
-    query(__vector, __nearestNumber, cmp, _root, &answers);
-    std::stack<Answer> rev;
-    for( ; !answers.empty(); answers.pop()) rev.push(answers.top());
-    Vectors ret;
-    for( ; !rev.empty(); rev.pop()) ret.push_back(_vectors[rev.top()._index]);
-    return ret;
-  }
-  /////////////////// **# clear, reset #** /////////////////
-  template<class Vector, class Scalar>
-  void
-  VP_Tree<Vector, Scalar>::clear(){
-    clear(_root);
-    _vectors.clear();
-    _root = NULL;
-    _needRebuild = false;
-  }
-  template<class Vector, class Scalar>
-  size_t
-  VP_Tree<Vector, Scalar>::reset(size_t __dimension){
-    clear();
-    _dimension = std::max((size_t)1, __dimension);
-    return _dimension;
-  }
-};