Problem: Let's define the transformation P of a sequence of integers a1, a2, ..., an as b1, b2, ..., bn, where bi = a1 | a2 | ... | ai for all i = 1, 2, ..., n, where | is the bitwise OR operation.

Vasya consequently applies the transformation P to all sequences of length n consisting of integers from 1 to 2k - 1 inclusive. He wants to know how many of these sequences have such property that their transformation is a strictly increasing sequence. Help him to calculate this number modulo 109 + 7.

Input

The only line of the input contains two integers n and k (1 ≤ n ≤ 1018, 1 ≤ k ≤ 30 000).

Output

Print a single integer — the answer to the problem modulo 109 + 7.

Examples

Input

1 2


Output

3


Input

2 3


Output

30


Input

3 3


Output

48

Solution (in CPP):

Solution:
#include <bits/stdc++.h>
using namespace std;
const long double Pi = acos(-1.0);
const int MOD = 1000000007;
const int N = 130050;
template <typename T>
inline void read(T& x) {
  T f = 1, c = 0;
  char ch = getchar();
  while (ch < '0' || ch > '9') {
    if (ch == '-') f = -1;
    ch = getchar();
  }
  while (ch >= '0' && ch <= '9') {
    c = c * 10 + ch - '0';
    ch = getchar();
  }
  x = f * c;
}
long long fastpow(long long x, long long y) {
  long long ret = 1;
  while (y) {
    if (y & 1) ret = ret * x % MOD;
    x = x * x % MOD;
    y >>= 1;
  }
  return ret;
}
long long inv(long long x) { return fastpow(x, MOD - 2); }
long long n, ny[N], jc[N], jny[N], M[N];
int m;
struct cp {
  long double x, y;
  cp() {}
  cp(long double x, long double y) : x(x), y(y) {}
  cp operator+(const cp& a) const { return cp(x + a.x, y + a.y); }
  cp operator-(const cp& a) const { return cp(x - a.x, y - a.y); }
  cp operator*(const cp& a) const {
    return cp(x * a.x - y * a.y, x * a.y + y * a.x);
  }
};
int to[N], lim, L;
void init() {
  lim = 1, L = 0;
  while (lim <= (2 * m)) lim <<= 1, L++;
  for (int i = 1; i < lim; i++)
    to[i] = ((to[i >> 1] >> 1) | ((i & 1) << (L - 1)));
  M[0] = ny[1] = jc[0] = jc[1] = jny[0] = jny[1] = 1;
  M[1] = 2;
  for (int i = 2; i <= m; i++) {
    ny[i] = ((MOD - MOD / i) * ny[MOD % i] % MOD + MOD) % MOD;
    jc[i] = (jc[i - 1] * i) % MOD;
    jny[i] = (jny[i - 1] * ny[i]) % MOD;
    M[i] = (M[i - 1] * 2) % MOD;
  }
}
long long C(long long x, long long y) {
  return jc[x] * jny[y] % MOD * jny[x - y] % MOD;
}
void fft(cp* a, int len, int k) {
  for (int i = 0; i < len; i++)
    if (i > to[i]) swap(a[i], a[to[i]]);
  for (int i = 1; i < len; i <<= 1) {
    cp w0(cos(Pi / i), k * sin(Pi / i));
    for (int j = 0; j < len; j += (i << 1)) {
      cp w(1, 0);
      for (int o = 0; o < i; o++, w = w * w0) {
        cp w1 = a[j + o], w2 = a[j + o + i] * w;
        a[j + o] = w1 + w2;
        a[j + o + i] = w1 - w2;
      }
    }
  }
  if (k == -1)
    for (int i = 0; i < len; i++) a[i].x /= len;
}
long long F[N], G[N], H[N];
cp a[N], b[N], c[N], d[N], e[N], f[N], g[N], h[N];
void mul(long long y) {
  long long K = fastpow(2, y), KK = 1, M = 32768;
  for (int i = 0; i < lim; i++) a[i] = b[i] = c[i] = d[i] = cp(0, 0);
  for (int i = 0; i <= m; i++) {
    long long A = G[i] * KK % MOD, B = H[i];
    a[i].x = A / M, b[i].x = A % M;
    c[i].x = B / M, d[i].x = B % M;
    KK = KK * K % MOD;
  }
  fft(a, lim, 1), fft(b, lim, 1), fft(c, lim, 1), fft(d, lim, 1);
  for (int i = 0; i < lim; i++) {
    e[i] = a[i] * c[i], f[i] = b[i] * c[i];
    g[i] = a[i] * d[i], h[i] = b[i] * d[i];
  }
  fft(e, lim, -1), fft(f, lim, -1), fft(g, lim, -1), fft(h, lim, -1);
  for (int i = 0; i < lim; i++)
    F[i] = (((long long)(e[i].x + 0.1)) % MOD * M % MOD * M % MOD +
            ((long long)(f[i].x + 0.1)) % MOD * M % MOD +
            ((long long)(g[i].x + 0.1)) % MOD * M % MOD +
            ((long long)(h[i].x + 0.1)) % MOD) %
           MOD;
}
long long o[N], s[N];
void FastFFT() {
  long long y = 1;
  for (int i = 1; i <= m; i++) o[i] = jny[i];
  s[0] = 1;
  long long N = n;
  while (N) {
    if (N & 1) {
      memcpy(G, s, sizeof(G));
      memcpy(H, o, sizeof(H));
      mul(y);
      memcpy(s, F, sizeof(s));
    }
    memcpy(G, o, sizeof(G));
    memcpy(H, o, sizeof(H));
    mul(y);
    memcpy(o, F, sizeof(o));
    y <<= 1, N >>= 1;
  }
}
int main() {
  read(n), read(m);
  init();
  if (n > m) {
    puts("0");
    return 0;
    puts("fuck");
    return 0;
  }
  FastFFT();
  long long ans = 0;
  for (int i = n; i <= m; i++)
    (ans += s[i] * C(m, i) % MOD * jc[i] % MOD) %= MOD;
  printf("%lld\n", ans);
  return 0;
}