Problem: Kuroni is the coordinator of the next Mathforces round written by the "Proof by AC" team. All the preparation has been done, and he is discussing with the team about the score distribution for the round.

The round consists of n problems, numbered from 1 to n. The problems are ordered in increasing order of difficulty, no two problems have the same difficulty. A score distribution for the round can be denoted by an array a_1, a_2, ..., a_n, where a_i is the score of i-th problem. 

Kuroni thinks that the score distribution should satisfy the following requirements:

  * The score of each problem should be a positive integer not exceeding 10^9. 
  * A harder problem should grant a strictly higher score than an easier problem. In other words, 1 ≤ a_1 < a_2 < ... < a_n ≤ 10^9. 
  * The balance of the score distribution, defined as the number of triples (i, j, k) such that 1 ≤ i < j < k ≤ n and a_i + a_j = a_k, should be exactly m. 



Help the team find a score distribution that satisfies Kuroni's requirement. In case such a score distribution does not exist, output -1.

Input

The first and single line contains two integers n and m (1 ≤ n ≤ 5000, 0 ≤ m ≤ 10^9) — the number of problems and the required balance.

Output

If there is no solution, print a single integer -1.

Otherwise, print a line containing n integers a_1, a_2, ..., a_n, representing a score distribution that satisfies all the requirements. If there are multiple answers, print any of them.

Examples

Input


5 3


Output


4 5 9 13 18

Input


8 0


Output


10 11 12 13 14 15 16 17


Input


4 10


Output


-1

Note

In the first example, there are 3 triples (i, j, k) that contribute to the balance of the score distribution. 

  * (1, 2, 3) 
  * (1, 3, 4) 
  * (2, 4, 5) 

Solution (in CPP):

Solution:
#include <bits/stdc++.h>
#pragma comment(linker, "/stack:200000000")
#pragma GCC optimize("Ofast")
#pragma GCC target("sse,sse2,sse3,ssse3,sse4,popcnt,abm,mmx,avx,tune=native")
template <class T, class T1>
class BST {
 private:
  class Node {
   public:
    T data;
    Node *leftChild;
    Node *rightChild;
    T1 leftCount, rightCount, height, totalCount;
    Node(T data) {
      this->data = data;
      this->leftChild = NULL;
      this->rightChild = NULL;
      this->leftCount = 0;
      this->rightCount = 0;
      this->height = 1;
      this->totalCount = 1;
    }
    Node(T data, T1 totalCount) {
      this->data = data;
      this->leftChild = NULL;
      this->rightChild = NULL;
      this->leftCount = 0;
      this->rightCount = 0;
      this->height = 1;
      this->totalCount = totalCount;
    }
  };
  Node *rootNode;
  Node *temporaryNode1;
  Node *temporaryNode2;
  T1 treeSize;
  bool multiCount;
  T1 getDiff(Node *temp) {
    if (temp == NULL) return 0;
    return getheight(temp->leftChild) - getheight(temp->rightChild);
  }
  T1 getheight(Node *temp) {
    if (temp == NULL) return 0;
    return temp->height;
  }
  Node *rightRotate(Node *temp) {
    temporaryNode1 = temp->leftChild;
    temporaryNode2 = temporaryNode1->rightChild;
    temporaryNode1->rightChild = temp;
    temp->leftChild = temporaryNode2;
    temp->height =
        std::max(getheight(temp->leftChild), getheight(temp->rightChild)) + 1;
    temporaryNode1->height = std::max(getheight(temporaryNode1->leftChild),
                                      getheight(temporaryNode1->rightChild)) +
                             1;
    if (temp->leftChild != NULL)
      temp->leftCount = temp->leftChild->leftCount +
                        temp->leftChild->rightCount +
                        temp->leftChild->totalCount;
    else
      temp->leftCount = 0;
    if (temp->rightChild != NULL)
      temp->rightCount = temp->rightChild->leftCount +
                         temp->rightChild->rightCount +
                         temp->rightChild->totalCount;
    else
      temp->rightCount = 0;
    if (temporaryNode1->leftChild != NULL)
      temporaryNode1->leftCount = temporaryNode1->leftChild->leftCount +
                                  temporaryNode1->leftChild->rightCount +
                                  temporaryNode1->leftChild->totalCount;
    else
      temporaryNode1->leftCount = 0;
    if (temporaryNode1->rightChild != NULL)
      temporaryNode1->rightCount = temporaryNode1->rightChild->leftCount +
                                   temporaryNode1->rightChild->rightCount +
                                   temporaryNode1->rightChild->totalCount;
    else
      temporaryNode1->rightCount = 0;
    return temporaryNode1;
  }
  Node *leftRotate(Node *temp) {
    temporaryNode1 = temp->rightChild;
    temporaryNode2 = temporaryNode1->leftChild;
    temporaryNode1->leftChild = temp;
    temp->rightChild = temporaryNode2;
    temp->height =
        std::max(getheight(temp->leftChild), getheight(temp->rightChild)) + 1;
    temporaryNode1->height = std::max(getheight(temporaryNode1->leftChild),
                                      getheight(temporaryNode1->rightChild)) +
                             1;
    if (temp->leftChild != NULL)
      temp->leftCount = temp->leftChild->leftCount +
                        temp->leftChild->rightCount +
                        temp->leftChild->totalCount;
    else
      temp->leftCount = 0;
    if (temp->rightChild != NULL)
      temp->rightCount = temp->rightChild->leftCount +
                         temp->rightChild->rightCount +
                         temp->rightChild->totalCount;
    else
      temp->rightCount = 0;
    if (temporaryNode1->leftChild != NULL)
      temporaryNode1->leftCount = temporaryNode1->leftChild->leftCount +
                                  temporaryNode1->leftChild->rightCount +
                                  temporaryNode1->leftChild->totalCount;
    else
      temporaryNode1->leftCount = 0;
    if (temporaryNode1->rightChild != NULL)
      temporaryNode1->rightCount = temporaryNode1->rightChild->leftCount +
                                   temporaryNode1->rightChild->rightCount +
                                   temporaryNode1->rightChild->totalCount;
    else
      temporaryNode1->rightCount = 0;
    return temporaryNode1;
  }
  Node *remove(Node *temp, T &data, T1 totalCount) {
    if (temp == NULL) return temp;
    if (data < temp->data)
      temp->leftChild = remove(temp->leftChild, data, totalCount);
    else if (data > temp->data)
      temp->rightChild = remove(temp->rightChild, data, totalCount);
    else {
      if (multiCount && totalCount < temp->totalCount && temp->totalCount > 1) {
        treeSize -= totalCount;
        temp->totalCount -= totalCount;
      } else {
        treeSize -= temp->totalCount;
        if (temp->leftChild == NULL && temp->rightChild == NULL)
          return NULL;
        else if (temp->leftChild == NULL)
          return temp->rightChild;
        else if (temp->rightChild == NULL)
          return temp->leftChild;
        else {
          temporaryNode1 = minValue(temp->rightChild);
          temp->data = temporaryNode1->data;
          temp->totalCount = temporaryNode1->totalCount;
          temp->rightChild = remove(temp->rightChild, temporaryNode1->data,
                                    temporaryNode1->totalCount);
          treeSize += temp->totalCount;
        }
      }
    }
    if (temp->leftChild != NULL)
      temp->leftCount = temp->leftChild->leftCount +
                        temp->leftChild->rightCount +
                        temp->leftChild->totalCount;
    else
      temp->leftCount = 0;
    if (temp->rightChild != NULL)
      temp->rightCount = temp->rightChild->leftCount +
                         temp->rightChild->rightCount +
                         temp->rightChild->totalCount;
    else
      temp->rightCount = 0;
    temp->height =
        std::max(getheight(temp->leftChild), getheight(temp->rightChild)) + 1;
    T1 diff = getDiff(temp);
    if (diff > 1) {
      if (getDiff(temp->leftChild) >= 0) {
        temp = rightRotate(temp);
      } else {
        temp->leftChild = leftRotate(temp->leftChild);
        temp = rightRotate(temp);
      }
    } else if (diff < -1) {
      if (getDiff(temp->rightChild) <= 0) {
        temp = leftRotate(temp);
      } else {
        temp->rightChild = rightRotate(temp->rightChild);
        temp = leftRotate(temp);
      }
    }
    return temp;
  }
  Node *minValue(Node *temp) {
    temporaryNode1 = temp;
    while (temporaryNode1->leftChild != NULL)
      temporaryNode1 = temporaryNode1->leftChild;
    return temporaryNode1;
  }
  Node *insert(Node *temp, T &data, T1 totalCount) {
    if (temp == NULL) {
      if (multiCount) {
        treeSize += totalCount;
        return new Node(data, totalCount);
      } else {
        treeSize++;
        return new Node(data);
      }
    }
    if (data < temp->data)
      temp->leftChild = insert(temp->leftChild, data, totalCount);
    else if (data > temp->data)
      temp->rightChild = insert(temp->rightChild, data, totalCount);
    else if (multiCount) {
      treeSize += totalCount;
      temp->totalCount += totalCount;
    }
    if (temp->leftChild != NULL)
      temp->leftCount = temp->leftChild->leftCount +
                        temp->leftChild->rightCount +
                        temp->leftChild->totalCount;
    else
      temp->leftCount = 0;
    if (temp->rightChild != NULL)
      temp->rightCount = temp->rightChild->leftCount +
                         temp->rightChild->rightCount +
                         temp->rightChild->totalCount;
    else
      temp->rightCount = 0;
    temp->height =
        std::max(getheight(temp->leftChild), getheight(temp->rightChild)) + 1;
    T1 diff = getDiff(temp);
    if (diff > 1) {
      if (data < temp->leftChild->data) {
        temp = rightRotate(temp);
      } else if (data > temp->leftChild->data) {
        temp->leftChild = leftRotate(temp->leftChild);
        temp = rightRotate(temp);
      }
    } else if (diff < -1) {
      if (data > (temp->rightChild->data)) {
        temp = leftRotate(temp);
      } else if (data < temp->rightChild->data) {
        temp->rightChild = rightRotate(temp->rightChild);
        temp = leftRotate(temp);
      }
    }
    return temp;
  }

 public:
  BST() {
    rootNode = NULL;
    treeSize = 0;
    multiCount = false;
  }
  BST(bool multiCount) {
    rootNode = NULL;
    treeSize = 0;
    this->multiCount = multiCount;
  }
  T1 lower_bound(T data) {
    temporaryNode1 = rootNode;
    T1 index = 0;
    while (temporaryNode1 != NULL) {
      if (data < temporaryNode1->data) {
        temporaryNode1 = temporaryNode1->leftChild;
      } else if (data > temporaryNode1->data) {
        index += (temporaryNode1->totalCount + temporaryNode1->leftCount);
        temporaryNode1 = temporaryNode1->rightChild;
      } else {
        index += (temporaryNode1->leftCount);
        break;
      }
    }
    return index;
  }
  T get(T1 index) {
    temporaryNode1 = rootNode;
    T1 current = 0;
    while (temporaryNode1 != NULL) {
      if (temporaryNode1->leftChild == NULL) {
        if (temporaryNode1->totalCount + current > index)
          return temporaryNode1->data;
        else {
          current += temporaryNode1->totalCount;
          temporaryNode1 = temporaryNode1->rightChild;
        }
      } else {
        if (current + temporaryNode1->leftCount > index)
          temporaryNode1 = temporaryNode1->leftChild;
        else if (current + temporaryNode1->leftCount +
                     temporaryNode1->totalCount >
                 index)
          return temporaryNode1->data;
        else {
          current += temporaryNode1->totalCount + temporaryNode1->leftCount;
          temporaryNode1 = temporaryNode1->rightChild;
        }
      }
    }
    assert("Not possible");
  }
  void insert(T data, T1 totalCount = 1) {
    if (totalCount > 0) rootNode = insert(rootNode, data, totalCount);
  }
  void remove(T data, T1 totalCount = 1) {
    if (totalCount > 0) rootNode = remove(rootNode, data, totalCount);
  }
  T1 getCount(T data) {
    temporaryNode1 = rootNode;
    while (temporaryNode1 != NULL) {
      if (data < temporaryNode1->data)
        temporaryNode1 = temporaryNode1->leftChild;
      else if (data > temporaryNode1->data)
        temporaryNode1 = temporaryNode1->rightChild;
      else
        return temporaryNode1->totalCount;
    }
    return 0;
  }
  bool contains(T data) {
    temporaryNode1 = rootNode;
    while (temporaryNode1 != NULL) {
      if (data == temporaryNode1->data)
        return true;
      else if (data < temporaryNode1->data)
        temporaryNode1 = temporaryNode1->leftChild;
      else
        temporaryNode1 = temporaryNode1->rightChild;
    }
    return false;
  }
  T1 size() { return this->treeSize; }
};
using namespace std;
class EKuroniAndTheScoreDistribution {
 public:
  void solve(std::istream &in, std::ostream &out) {
    int n, m;
    in >> n >> m;
    vector<int> ans(n + 5, -1);
    BST<int, int> bst(true);
    ans[0] = 1;
    ans[1] = 2;
    if (n <= 2) {
      if (m == 0) {
        for (int i = 0; i < n; i++) out << ans[i] << " ";
        out << "\n";
        return;
      } else {
        out << "-1\n";
        return;
      }
    }
    int temp = 0;
    int idx = -1;
    for (int i = 2; i < n; i++) {
      temp += ((i + 1) / 2 - (1 - ((i + 1) % 2)));
      ans[i] = i + 1;
      idx = i;
      if (temp >= m) {
        break;
      }
    }
    if (temp < m) {
      out << "-1\n";
      return;
    }
    while (temp > m) {
      ans[idx]++;
      if (ans[idx] % 2 == 0) temp--;
    }
    int mx = 100000;
    mx = max(mx, ans[idx] + 100000);
    int inf = 1000000000;
    for (int i = n - 1; i >= 0; i--) {
      if (ans[i] == -1) {
        ans[i] = inf;
        inf -= mx;
      }
    }
    for (int i = 0; i < n; i++) out << ans[i] << " ";
  }
};
int main() {
  EKuroniAndTheScoreDistribution solver;
  std::ios_base::sync_with_stdio(false);
  cin.tie(NULL);
  std::istream &in(std::cin);
  std::ostream &out(std::cout);
  solver.solve(in, out);
  return 0;
}