const mapStateToProps = (state, ownProps) => {
  return {
    active: state.filter === ownProps.filter
  }
}

const mapDispatchToProps = (dispatch, ownProps) => {
  return {
    handleClick: () => {
      dispatch(setFilter(ownProps.filter))
    }
  }
}

const FilterLink = connect(
  mapStateToProps,
  mapDispatchToProps
)(Link)

function addTodo(text) {
  return {
    type: ADD_TODO,
    text
  }
}
dispatch(addTodo(text))

const createActionCreator = (type, ...argNames) => {
  return (...args) => {
    let action = { type }
    argNames.forEach((arg, index) => {
      action[arg] = args[index]
    })
    return action
  }
}

const addTodo = createActionCreator(ADD_TODO, 'text')
const setFilter = createActionCreator(SET_FILTER, 'filter')
const toggleTodo = createActionCreator(TOGGLE_TODO, 'id', 'to')

const todos = (state = [], action) => {
  switch (action.type) {
    case ADD_TODO:
      return  [
        ...state,
        {
          id: action.id,
          text: action.text,
          status: 0
        }
      ]
    case TOGGLE_TODO:
      return state.map(todo =>
        (todo.id === action.id) ? {...todo, status: action.to || +!todo.status} : todo
      )
    default:
      return state
  }
}

const filter = (state = 'SHOW_ALL', action) => {
  switch (action.type) {
    case SET_FILTER:
      return action.filter
    default:
      return state
  }
}

const todoApp = combineReducers({
  todos,
  filter
})

function logger(store) {
  let next = store.dispatch

  // Previously:
  // store.dispatch = function dispatchAndLog(action) {

  return function dispatchAndLog(action) {
    console.log('dispatching', action)
    let result = next(action)
    console.log('next state', store.getState())
    return result
  }
}

function applyMiddlewareByMonkeypatching(store, middlewares) {
  middlewares = middlewares.slice()
  middlewares.reverse()

  // Transform dispatch function with each middleware.
  middlewares.forEach(middleware =>
    store.dispatch = middleware(store)
  )
}

const logger = store => next => action => {
  console.log('dispatching', action)
  let result = next(action)
  console.log('next state', store.getState())
  return result
}

const crashReporter = store => next => action => {
  try {
    return next(action)
  } catch (err) {
    console.error('Caught an exception!', err)
    Raven.captureException(err, {
      extra: {
        action,
        state: store.getState()
      }
    })
    throw err
  }
}

// Warning: Naïve implementation!
// That's *not* Redux API.
function applyMiddleware(store, middlewares) {
  middlewares = middlewares.slice()
  middlewares.reverse()
  let dispatch = store.dispatch
  middlewares.forEach(middleware =>
    dispatch = middleware(store)(dispatch)
  )
  return Object.assign({}, store, { dispatch })
}

const thunk = store => next => action =>
  typeof action === 'function'
    ? action(store.dispatch, store.getState)
    : next(action)

function fetchPosts(subreddit) {
  return dispatch => {
    dispatch(requestPosts(subreddit))
    return fetch(`https://www.reddit.com/r/${subreddit}.json`)
      .then(response => response.json())
      .then(json => dispatch(receivePosts(subreddit, json)))
  }
}

function fetchPostsIfNeeded(subreddit) {
  return (dispatch, getState) => {
    if (shouldFetchPosts(getState(), subreddit)) {
      return dispatch(fetchPosts(subreddit))
    }
  }
}

dispatch(fetchPostsIfNeeded(selectedSubreddit))

class TodoList {
  id = 0
  @observable todos = []

  @computed get activeTodoCount() {
    return this.todos.filter(todo => todo.status === 0).length
  }

  saveToStorage() {
    // 第一次不会触发
    reaction(
      () => this.toJS(),
      todos => localStorage.setItem('todo-mobx', JSON.stringify({ todos }))
    )
  }

  addTodo(title) {
    this.id++;
    this.todos.push(new TodoItem({id: this.id, title, status: 0}))
  }

  toggleAll(status) {
    this.todos.forEach(todo => todo.status = +status)
  }

  delete(id) {
    let todoId = this.todos.findIndex(todo => todo.id === id)
    if (todoId !== -1) {
      this.todos.splice(todoId, 1)
    }
  }

  clearCompleted() {
    this.todos = this.todos.filter(todo => todo.status === 0)
  }

  toJS() {
    return this.todos.map(todo => todo.toJS())
  }

  static fromJS(arr) {
    const todoStore = new TodoList();
    todoStore.todos = arr.map(todo => TodoItem.from(todo))
    return todoStore
  }
}

@observer
class TodoList extends Component {
  render() {
    const { todoStore, filterStore } = this.props
    if (!todoStore.todos.length) {
      return null
    }
    return (
      <section>
        <input
          type="checkbox"
          onChange={this.toggleAll}
          checked={todoStore.activeTodoCount === 0}
        />
        <ul>
          {this.getVisibleTodos().map(todo => (
            <TodoItem
              key={todo.id}
              todo={todo}
              filterStore={filterStore}
              handleDestroy={this.handleDestroy}
            />
          ))}
        </ul>
      </section>
    )
  }

  getVisibleTodos() {
    const { todoStore, filterStore } = this.props
    return todoStore.todos.filter(todo => {
      switch (filterStore.filter) {
        case ACTIVE:
          return todo.status === 0
        case COMPLETED:
          return todo.status === 1
        case REMOVED:
          return todo.status === 2
        default:
          return true
      }
    })
  }

  toggleAll = (e) => {
    let checked = e.target.checked;
    this.props.todoStore.toggleAll(checked !== 0)
  }

  handleDestroy = (id) => {
    this.props.todoStore.delete(id)
  }
}

const Singleton = {
  prop1: "prop1"
  prop2: "prop2"
  method1() {
    console.log("I am a method.");
  }
}

const Singleton = function() {
  let privateProp = "You can't see me";

  function privateMethod() {
    console.log("You can't see me either.");
  }

  return {
    publicProp: `${privateProp}!`,
    publicMethod() {
      return privateMethod();
    }
  }
}

const Singleton = function() {
  let instance;

  function init() {
    return {
      prop: "prop",
      method() {
        console.log("I am a method.");
      }
    };
  }

  return {
    getInstance() {
      // JS单线程，不考虑锁的问题
      if (!instance) {
        instance = init();
      }
      return instance;
    }
  }
}

const Singleton = function() {
  const instance = this;

  this.prop = "prop";
  this.method = function() {
    console.log("I am a method.");
  }

  Singleton = function() {
    return instance;
  };
}

const Singleton = function() {
  // 这里不取名为instance也可以
  // 显式返回this
  if (typeof Singleton.instance === "object") {
    return Singleton.instance;
  }

  // 成员和方法
  this.prop = "prop";
  this.method = function() {
    console.log("I am a method.");
  }

  Singleton.instance = this;

  //隐式返回this
}

const mySet = new Set();
arr.forEach((val, index) => {
  if (mySet.has(val)) {
    console.log(val);
    return;
  } else {
    mySet.add(val);
  }
});

function findDuplicate(arr) {
  // 边界检测
  if (!arr || arr.length === 0) {
    return false;
  }
  for (let i = 0, len = arr.length; i < len; i++) {
    // 循环交换元素直到arr[i] == i
    while (arr[i] != i) {
      if (arr[i] === arr[arr[i]]) {
        return arr[i];
      }
      // 交换
      [arr[i], arr[arr[i]]] = [arr[arr[i]], arr[i]];
    }
  }
}

function findDuplicate(arr) {
  // 边界检测
  if (!arr || arr.length === 0) {
    return false;
  }

  function countRange (arr, start, end) {
    if (start > end) {
      return false;
    } else if (start === end) {
      return start;
    }
    const split = (start + end) / 2;
    const count = arr.reduce((last, val) => {
      return last + +(val >= start && val <= split);
    }, 0);
    if (count > split - start + 1) {
      countRange(arr, start, split);
    } else {
      countRange(arr, split + 1, end);
    }
  }

  return countRange(arr, 0, arr.length);
}

function find(arr, val) {
  if (!arr || !arr.length) {
    return false;
  }
  let [rows, columns] = [arr.length, arr[0].length];

  if (!rows || !columns) {
    return false;
  }
  let [x, y] = [columns-1, 0]
  while(x > 0 && y < rows) {
    if (arr[y][x] === val) {
      return true;
    } else if (arr[y][x] > val) {
      x--;
    } else {
      y++;
    }
  }
  return false;
}

function replace(str) {
  return str.replace(" ", "%20");
}

// 单向链表
let LinkedList2 = (function() {
  class Node {
    constructor(element) {
      this.element = element;
      this.next = null;
    }
  }

  class LinkedList {
    constructor() {
      this.length = 0;
      this.head = null;
    }

    append(element) {
      let node = new Node(element);
      if (this.head === null) {
        this.head = node;
      } else {
        let curr = this.head;
        while(curr.next) {
          curr = curr.next;
        }
        curr.next = node;
      }
      this.length++;
    }

    insert(pos, element) {
      if (pos < 0 || pos > this.length) {
        return false;
      }
      let curr = this.head,
          node = new Node(element);
      while(--pos >= 0) {
        curr = curr.next;
      }
      node.next = curr.next;
      curr.next = node;
      this.length++;
    }

    remove(pos) {
      if (pos < 0 || pos > this.length) {
        return false;
      }
      let curr = this.head;
          prev;
      while(--pos >= 0) {
        prev = curr;
        curr = curr.next;
      }
      if(isUndefined(prev)) {
        this.head = null;
      } else {
        prev.next = curr.next;
      }
      this.length--;
    }

    indexOf(element) {
      let curr = this.head,
          index = 0;
      while (curr) {
        if (element === curr.element) {
          return index;
        }
        index++;
        curr = curr.next;
      }
      return -1;
    }
  }

})();

// 双向链表
// 略

function recursivePrint(node) {
  if (node && node.next) {
    console.log(recursivePrint(node.next));
  } else {
    console.log(node.element);
  }
}

class BinaryTreeNode {
  constructor(element, left, right) {
    this.element = element;
    this.left = left;
    this.right = right;
  }
}

function constructTree(preorder, inorder) {
  if (preorder.length === 0) {
    return null;
  }

  function construct(preorder, inorder) {
    // 找到根节点元素
    let root = preorder[0];
    // 确定左右子树
    let index = inorder.indexOf(root),
        left = (index === 0 ? null : construct(preorder.slice(0, index), inorder.slice(0, index)));
        right = (index === inorder.length-1 ? null : construct(preorder.slice(index+1), inorder.slice(index+1)));

    return new BinaryTreeNode(root, left, right);
  }

  return construct(preorder, inorder);
}

class BinaryTreeNode {
  constructor(element, left, right, parent) {
    this.element = element;
    this.left = left;
    this.right = right;
    this.parent = parent;
  }
}

function findNextNode(node) {
  let curr;
  if (node.right) {
    curr = node.right;
    while(curr = curr.left) {
      ;
    }
    return curr;
  } else if (node.parent) {
    if (node.parent.left === node) {
      return node.parent;
    } else if (node.parent.right === node) {
      curr = node.parent;
      while (curr.parent && curr.parent.right === curr) {
        curr = node.parent;
      }
      if (curr.parent) {
        return curr.parent;
      }
    }
  } else {
    return null;
  }
}

class Stack {
  constructor() {
    this.stack = []
  }

  get size() {
    return this.stack.length;
  }

  push(element) {
    return this.stack.push(element);
  }

  pop() {
    return this.stack.pop();
  }

}

class Queue {
  constructor() {
    this.stack = new Stack();
    this.inverseStack = new Stack();
  }

  append(element) {
    this.stack.push(element);
    return this.stack.size + this.inverseStack.size;
  }

  delete() {
    if (!this.inverseStack.size) {
      while (!this.stack.size) {
        this.inverseStack.push(this.stack.pop());
      }
    }

    // 判断是否为空
    if (!this.inverseStack.size) {
      return this.inverseStack.pop();
    }

    console.warn("Empty queue!");
    return false;
  }
}

class Queue {
  constructor() {
    this.queue = []
  }

  get size() {
    return this.stack.length;
  }

  in(element) {
    return this.stack.push(element);
  }

  out() {
    return this.stack.shift();
  }

}

class Stack {
  constructor() {
    this.queue = new Queue();
    this.backupQueue = new Queue();
  }

  append(element) {
    if (queue.size) {
      queue.in(element);
      return queue.size;
    } else {
      backupQueue.in(element);
      return backupQueue.size;
    }
  }

  delete() {
    if (queue.size) {
      let element;
      while(queue.size > 1) {
        element = queue.out();
        backupQueue.in(element);
      }
      return queue.out();
    } else if(backQueue.size > 1) {
      let element;
      while(backupQueue.size) {
        element = backupQueue.out();
        queue.in(element);
      }
      return backupQueue.out();
    }
    console.warn("Empty stack!");
  }
}

function fibonacci(n) {
  if (n < 2) {
    return n;
  }

  let a = 0,
      b = 1,
      res = 1;
  for (let i = 2; i <= n; i++) {
    [res, a, b] = [a + b, b, res];
  }

  return res;
}

function findMin(arr) {
  if (!arr || !.arr.length) {
    return;
  }

  let lindex = 0,
      rindex = arr.length - 1,
      res = lindex;

  while (arr[lindex] >= arr[rindex]) {
    if (rindex - lindex === 1) {
      res = rindex;
    }

    res = (lindex + rindex) / 2;

    // 特殊情况
    if (arr[res] == arr[lindex] && arr[res] == arr[rindex]) {
      return arr.reduce((min, val) => {
        return Math.min(min, val);
      }, arr[0]);
    }

    if (arr[res] >= arr[lindex]) {
      lindex = res;
    } else if (arr[res] <= arr[rindex]) {
      rindex = res;
    }
  }
  return arr[res];
}

function hasPath(arr, str) {

  if (!arr || !arr.length || !str) {
    return false;
  }

  // 使用数组记录历史数据，防止交叉
  let occupied = arr.map(() => {
    return arr[0].map(() => {
      return false;
    });
  });

  let pathMath = function(i, j, str) {
    if (!str) {
      return true;
    }

    if (i < 0 || i >= arr.length || j < 0 || i >= arr[0].length) {
      return false;
    }

    if (str.substr(0, 1) == arr[i][j]) {
      occupied[i][j] = true;
      let newStr = str.substr(1),
          res = pathMath(i-1, j, newStr) || pathMath(i+1, j, newStr) || pathMath(i, j-1, newStr) || pathMath(i, j+1, newStr);

      // 回溯
      if (!res) {
        occupied[i][j] = false;
      }
    }

    return res;
  }

  arr.foreach((val, i) => {
    val.foreach((val, j) => {
      if (pathMatch(i, j, str)) {
        return true;
      }
    });
  });

  return false;
}

function gridCount(rowCount, colCount, limit) {
  if (limit < 0 || rowCount <= 0 || colCount <= 0) {
    return 0;
  }

  // 使用数组记录历史数据，减少冗余查询
  let walked = [];

  let count = function(row, col) {
    let cnt = 0;

    if (check(row, col)) {
      // 不必还原，减少重复查询
      walked[row * rowCount + col] = true;
      cnt = 1 + count(row-1, col) + count(row+1, col) + count(row, col-1) + count(row, col+1);
    }
    return cnt;
  },
    check = function () {
    return row >= 0 && col >= 0 && !walked[row * rowCount + col] && digitSum(row) + digitSum(col) <= limit;
  },
    digitSum = function(num) {
    let sum = 0;
    while(num > 0) {
      sum += num % 10;
      num /= 10;
    }
    return sum;
  };

  return count(row, col)
}

function cutRope(len) {
  if (len < 4) {
    return len - 2;
  }

  let cut = [0, 1, 2];
  for (let i = 4; i <= len; i++) {
    let max = 0;
    for (let j = 1; j <= i / 2; j++) {
      let mul = cut[j-1] * cut[i-j-1];
      if (max < mul) {
        max = mul;
      }
    }
    cut.push(max);
  }
  return cut[len-1];
}

function cutRope(len) {
  if (len < 4) {
    return len - 2;
  }

  // 多切长度为3的绳子段
  let cntOf3 = len / 3,
      cntOf2 = 1,
      remain = len % 3;
  // 长度为4时，应该切成两个2
  if (remain === 1) {
    cntOf3--;
    cntOf2 = 2;
  }

  return Math.pow(3, cntOf3) * cntOf2
}

function numOf1(n) {
  let cnt = 0,
      flag = 1;

  while(flag) {
    if (n & flag) {
      cnt++;
    }
    flag <<= 1;
  }

  return cnt;
}

function numOf1(n) {
  let cnt = 0;

  while(n) {
    ++cnt;
    n = (n-1) & n;
  }

  return cnt;
}

function pow(base, exp) {
  let isNeg = exp > 0,
      res = 1;

  if (exp == 0) {
    return 1;
  }

  if (base == 0) {
    return 0;
  }

  function unsignedPow(base, exp) {
    if (exp === 0) {
      return 1;
    }
    if (exp === 1) {
      return base;
    }

    let res = unsigned(base, exp >> 1);
    res *= res;
    if (exp & 0x1 === 1) {
      res *= base;
    }
    return res;
  }

  res = unsignedPow(base, Math.abs(exp));

  if (isNeg) {
    res = 1 / res;
  }

  return res;
}

function printNums(n) {
  function print(str, n) {
    if (1 === n) {
      for (let i = 0; i < 10; i++) {
        console.log(str + i);
      }
    } else {
      n--;
      for (let i = 0; i < 10; i++) {
        if (0 === i) {
          print(str, n);
        } else {
          print(str + i, n);
        }
      }
    }
  }

  if (n < 1) {
    return;
  }

  print('', n);
}

class LinkedListNode {
  constructor(value, next) {
    this.value = value;
    this.next = next
  }
}

function removeNode(head, node) {
  if (!head || !node) {
    return;
  }

  if (!node.next) { // 不是尾节点
    node.next = node.next.next;
    node.value = node.value;
  } else if (node == head) { // 链表只有一个节点
    head = null;
  } else { // 是尾节点，只能循环
    let n = head;
    while (n.next !== node) {
      n = n.next;
    }
    n.next = null;
  }
}

// 正则表达式
/\d/.test(str);

// 类型转换
!isNaN(+str);

function adjustArr(arr, standard) {
  if (!arr || !arr.length || arr.length < 2) {
    return arr;
  }

  let start = 0;
  let end = arr.length - 1;
  while (start < end) {
    while (start < end && !standard(arr[start])) {
      start++;
    }

    while (start < end && standard(arr[end])) {
      end--;
    }

    if (start < end) {
      [arr[start], arr[end]] = [arr[end], arr[start]];
    }
  }
}

// 在后面的标准
function standard (num) {
  return num / 2 == 0;
}

class LinkedList {
  constructor(head) {
    this.head = head;
  }
}

class Node {
  constructor(next) {
    this.next = next;
  }
}

function findLastK(head, k) {
  if (!head || k === 0) {
    return null;
  }

  let flag = head;
  while (--k > 0) {
    if (head.next) {
      head = head.next;
    } else {
      return null
    }
  }

  let res = head;
  while(flag = flag.next) {
    res = res.next;
  }

  return res;
}

function entryOfLoop(list) {
  if (!list || !list.length || !list.length < 2) {
    return null;
  }

  // 找到相遇位置
  let slow, fast, meet;
  slow = fast = list.head;

  while (!!fast && !!slow) {
    if (fast === slow) {
      meet = fast;
    }
    slow = slow.next;
    fast = fast.next;
    if (!!fast) {
      fast = fast.next;
    }
  }

  // 无环存在时跳出
  if (!!meet) {
    return null;
  }

  // 确定环的长度
  let length = 1;
  let tmpNode = meet.next;
  while (tmpNode !== meet) {
    tmpNode = tmpNode.next;
    length++;
  }

  // 先移动一个指针
  let first = list.head;
  while (length > 0) {
    first = first.next;
    length--;
  }

  // 再移动第二个指针
  let next = list.head；
  while (next !== first) {
    first = first.next;
    next = next.next;
  }

  return first;
}

function reverseList(list) {
  let node = list.head;
  let prev = null;

  while(!!node) {
    if (!node.next) {
      return node;
    }
    node.next = prev;
    prev = node;
    node = node.next;
  }
}

function merge(list1, list2) {
  if (!list1) {
    return list2;
  } else if (!list2) {
    return list1;
  }

  let node = new Node();
  let list = new List(node);
  let h1 = list1.head;
  let h2 = list2.head;

  for (!!h1 || !!h2) {
    let next;
    if (!!h1 && !h2 || h1.value < h2.value) {
      next = h1.value;
      node = node.next;
      h1 = h1.next;
    } else {
      next = h2.value;
      h2 = h2.next;
    }

    node.next = new Node(next);
    node = node.next;
  }

  list.head = list.head.next;
  return list;
}

function hasSubTree(heap, needle) {
  function match(root1, root2) {
    if (!root2) {
      return true;
    }

    if (!root1) {
      return false;
    }

    return match(root1.left, root2.left) && match(root1.right, root2.right);
  }

  let root1 = heap.root;
  let root2 = needle.root;

  let res = false;
  if (!root1 && !root2) {
    if (root1.value === root2.value) {
      res = match(root1, root2);
    }

    if (!res) {
      res = hasSubTree(root1.left, root2);
    }

    if (!res) {
      res = hasSubTree(root1.right, root2);
    }
  }

  return res;
}

function mirrorBinaryTree(root) {
  if (!root) {
    return;
  }
  // 跳过叶子节点
  if (!root.left && !root.right) {
    return;
  }

  [root.left, root.right] = [root.right, root.left];

  if (!!root.left) {
    mirrotBinaryTree(root.left);
  }

  if (!!root.right) {
    mirrotBinaryTree(root.right);
  }
}

function isSymmetrical(root) {
  function judge(root1, root2) {
    if (root1 === null && root2 === null) {
      return true;
    }
    if (root1 === null || root2 === null) {
      return false;
    }
    if (root1.value !== root2.value2) {
      return false;
    }

    return judge(root1.left, root2.right) && judge(root1.right, root2.left);
  }

  return judge(root, root);
}

function printMatrix(matrix) {
  if (!matrix || !matrix.length || !matrix[0].length) {
    return;
  }
  let top = 0;
  let left = 0;
  let bottom = matrix.length - 1;
  let right = (matrix[0].length ? matrix[0].length - 1 : 0);

  while (left <= right && top <= bottom) {
    // 向右
    for (let i = left; i <= right; i++) {
      console.log(matrix[top][i] + ' ');
    }
    top++;

    // 向下
    if (top <= bottom) {
      for (let i = top; i <= bottom; i++) {
        console.log(matrix[i][right] + ' ');
      }
      right--;
    } else {
      return;
    }

    // 向左
    if (left <= right) {
      for (let i = right; i >= left; i--) {
        console.log(matrix[bottom][i] + ' ');
      }
      bottom--;
    } else {
      return;
    }

    // 向上
    if (top <= bottom) {
      for (let i = bottom; i >= top; i--) {
        console.log(matrix[i][left] + ' ');
      }
      left++;
    } else {
      return;
    }
  }
}

function printMatrix(matrix) {
  if (!matrix || !matrix.length || !matrix[0].length) {
    return;
  }

  function print() {
    let width = column - start - 1;
    let height = rows - start - 1;

    for (let i = start; i <= width; i++) {
      console.log(matrix[start][i]);
    }

    if (start < height) {
      for (let i = 0; i <= height; i++) {
        console.log(matrix[i][width]);
      }
    }

    if (start < width && start < height) {
      for (let i = width-1; i >= start; i--) {
        console.log(matrix[height][i]);
      }
    }

    if (start < width && start < height - 1) {
      for (let i = height-1; i < start+1; i--) {
        console.log(matrix[i][start]);
      }
    }
  }

  let start = 0;
  let rows = matrix.length;
  let column = matrix[0].length;

  while (column > 2 * start && rows > 2 * start) {
    print();
    ++start;
  }
}

class Stack {
  constructor() {
    this.stack = [];
    this.minStack = [];
  }

  get min() {
    let len = this.minStack.length;
    return (len ? this.minStack[len-1] : Infinity);
  }

  push(element) {
    this.stack.push(element);
    this.minStack.push(Math.min(this.min, element));
  }

  pop() {
    this.stack.pop();
    this.minStack.pop();
  }

  top() {
    return (this.stack.length ? this.stack[this.stack.length-1] : null);
  }
}

function isPopOrder(push, pop) {
  if (push.length !== pop.length) {
    return false;
  }
  if (!push.length) {
    return true;
  }

  // 寻找当前栈内元素
  let first = pop[0];
  let index = push.indexOf(first);
  let stack = [];

  if (index === -1) {
    return false;
  }

  for (let i = 0; i <= index-1; i++) {
    stack.push(push[i]);
  }

  let rest = push.slice(index);

  for (let i = 2, len = pop.length; i < len; i++) {
    let value = pop[i];
    if (!push.length || push[push.length-1] !== value) {
      let index = rest.indexOf(value);
      if (index === -1) {
        return false;
      }
      push.push(value);
      rest.splice(index, 1);
    } else {
      push.pop();
    }
  }

  return true;
}