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>
using namespace std;
using ll = long long;
using ld = long double;
using str = string;
using pi = pair<int, int>;
using pl = pair<ll, ll>;
using pd = pair<ld, ld>;
template <class T>
using vec = vector<T>;
using vb = vec<bool>;
using vi = vec<int>;
using vl = vec<ll>;
using vd = vec<ld>;
using vs = vec<str>;
using vpi = vec<pi>;
using vpl = vec<pl>;
using vpd = vec<pd>;
template <class Key, class T, class Hash = hash<Key>,
          class Pred = equal_to<Key>,
          class Alloc = allocator<pair<const Key, T>>>
using umap = unordered_map<Key, T, Hash, Pred, Alloc>;
template <class Key, class Hash = hash<Key>, class Pred = equal_to<Key>,
          class Alloc = allocator<Key>>
using uset = unordered_set<Key, Hash, Pred, Alloc>;
const int MX = 5e5 + 5;
int MOD = 1e9 + 7;
ll INF = 1e18;
ld PI = acos((ld)-1), EPS = 1e-8;
template <class T>
bool ckmin(T& a, const T& b) {
  return b < a ? a = b, 1 : 0;
}
template <class T>
bool ckmax(T& a, const T& b) {
  return a < b ? a = b, 1 : 0;
}
namespace input {
template <class T>
inline void re(complex<T>& first);
template <class T1, class T2>
inline void re(pair<T1, T2>& p);
template <class T>
inline void re(vector<T>& a);
template <class T, size_t SZ>
inline void re(array<T, SZ>& a);
template <class T>
inline void re(T& first) {
  cin >> first;
}
inline void re(double& first) {
  string t;
  re(t);
  first = stod(t);
}
inline void re(ld& first) {
  string t;
  re(t);
  first = stold(t);
}
template <class T, class... Ts>
inline void re(T& t, Ts&... ts) {
  re(t);
  re(ts...);
}
template <class T>
inline void re(complex<T>& first) {
  T a, b;
  re(a, b);
  first = {a, b};
}
template <class T1, class T2>
inline void re(pair<T1, T2>& p) {
  re(p.f, p.s);
}
template <class T>
inline void re(vector<T>& a) {
  for (int i = (0); i != ((int)(a.size())); i += (0 < (int)(a.size()) ? 1 : -1))
    re(a[i]);
}
template <class T, size_t SZ>
inline void re(array<T, SZ>& a) {
  for (int i = (0); i != (SZ); i += (0 < SZ ? 1 : -1)) re(a[i]);
}
inline void setin(string s) { freopen(s.c_str(), "r", stdin); }
}  // namespace input
namespace output {
inline void pr(int first) { cout << first; }
inline void pr(long first) { cout << first; }
inline void pr(ll first) { cout << first; }
inline void pr(unsigned first) { cout << first; }
inline void pr(unsigned long first) { cout << first; }
inline void pr(unsigned long long first) { cout << first; }
inline void pr(float first) { cout << first; }
inline void pr(double first) { cout << first; }
inline void pr(ld first) { cout << first; }
inline void pr(char first) { cout << first; }
inline void pr(const char* first) { cout << first; }
inline void pr(const string& first) { cout << first; }
inline void pr(bool first) { pr(first ? "true" : "false"); }
template <class T>
inline void pr(const complex<T>& first) {
  cout << first;
}
template <class T1, class T2>
inline void pr(const pair<T1, T2>& first);
template <class T>
inline void pr(const T& first);
template <class T, class... Ts>
inline void pr(const T& t, const Ts&... ts) {
  pr(t);
  pr(ts...);
}
template <class T1, class T2>
inline void pr(const pair<T1, T2>& first) {
  pr("{", first.first, ", ", first.second, "}");
}
template <class T>
inline void pr(const T& first) {
  pr("{");
  bool fst = 1;
  for (const auto& a : first) pr(!fst ? ", " : "", a), fst = 0;
  pr("}");
}
inline void ps() { pr("\n"); }
template <class T, class... Ts>
inline void ps(const T& t, const Ts&... ts) {
  pr(t);
  if (sizeof...(ts)) pr(" ");
  ps(ts...);
}
inline void pc() { pr("]\n"); }
template <class T, class... Ts>
inline void pc(const T& t, const Ts&... ts) {
  pr(t);
  if (sizeof...(ts)) pr(", ");
  pc(ts...);
}
inline void setout(string s) { freopen(s.c_str(), "w", stdout); }
}  // namespace output
using namespace input;
using namespace output;
void solve();
int main() {
  ios::sync_with_stdio(false);
  cin.tie(0);
  cout.tie(0);
  cout << fixed << setprecision(10);
  solve();
  return 0;
}
int N, M;
void solve() {
  re(N, M);
  ll mx = 0;
  for (int i = (1); i != (N + 1); i += (1 < N + 1 ? 1 : -1)) mx += (i - 1) / 2;
  if (M > mx)
    ps(-1);
  else {
    vl res;
    ll sum = 0, i = 1, cnt = 0;
    while (i <= N && sum + (i - 1) / 2 <= M)
      res.push_back(i), pr(i, ' '), sum += (i++ - 1) / 2, cnt++;
    M -= sum;
    assert(2 * M < i);
    if (M) res.push_back(i - 1 + i - 2 * M), pr(i - 1 + i - 2 * M, ' '), cnt++;
    M += sum;
    ll rem = N - cnt;
    for (int j = (rem); j != (0); j += (rem < 0 ? 1 : -1))
      res.push_back(1000000000 - 10001 * (j - 1)),
          pr(1000000000 - 10001 * (j - 1), ' ');
    ps();
  }
}