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;
int m[] = {1004535809, 998244353, 104857601};
long long qpow(long long x, long long k, int p) {
  long long ret = 1;
  while (k) {
    if (k & 1) ret = ret * x % p;
    k >>= 1;
    x = x * x % p;
  }
  return ret;
}
struct _NTT {
  int p;
  int rev[200020];
  void change(long long y[], int len) {
    for (int i = 1; i < len; ++i) {
      rev[i] = (rev[i >> 1] >> 1) + ((i & 1) * (len >> 1));
      if (i < rev[i]) swap(y[i], y[rev[i]]);
    }
  }
  void FFT(long long y[], int len, int on) {
    change(y, len);
    for (int h = 2; h <= len; h <<= 1) {
      long long wn = qpow(3, (p - 1) / h, p);
      if (on == -1) wn = qpow(wn, p - 2, p);
      for (int j = 0; j < len; j += h) {
        long long w = 1;
        for (int k = j; k < j + h / 2; ++k) {
          long long u = y[k];
          long long t = w * y[k + h / 2] % p;
          y[k] = u + t;
          if (y[k] >= p) y[k] -= p;
          y[k + h / 2] = u + p - t;
          if (y[k + h / 2] >= p) y[k + h / 2] -= p;
          w = w * wn % p;
        }
      }
    }
    if (on == -1) {
      long long inv = qpow(len, p - 2, p);
      for (int i = 0; i < len; ++i) y[i] = y[i] * inv % p;
    }
  }
  void mul(long long a[], long long b[], int len) {
    for (int i = 0; i < len; ++i) {
      a[i] %= p;
      b[i] %= p;
    }
    FFT(a, len, 1);
    FFT(b, len, 1);
    for (int i = 0; i < len; ++i) a[i] = a[i] * b[i] % p;
    FFT(a, len, -1);
  }
  void debug() {
    long long a[] = {1, 1, 0, 0};
    long long b[] = {1, 1, 0, 0};
    mul(a, b, 4);
    for (int i = 0; i < 4; ++i) printf("%lld ", a[i]);
    puts("");
  }
} ntt[3];
long long tmp[200020][3], r[3][3];
long long t1[200020], t2[200020];
long long CRT(long long a[]) {
  long long x[3];
  x[0] = a[0];
  for (int i = 1; i < 3; ++i) {
    x[i] = a[i];
    for (int j = 0; j < i; ++j) {
      x[i] = (x[i] - x[j]) % m[i];
      if (x[i] < 0) x[i] += m[i];
      x[i] = x[i] * r[j][i] % m[i];
    }
  }
  long long ret = x[3 - 1];
  for (int i = 3 - 2; i >= 0; --i) {
    ret = ret * m[i] % 1000000007;
    ret = (ret + x[i]) % 1000000007;
  }
  return ret;
}
void mul(long long a[], long long b[], int len) {
  for (int i = 0; i < 3; ++i) {
    for (int j = 0; j < len; ++j) t1[j] = a[j], t2[j] = b[j];
    ntt[i].mul(t1, t2, len);
    for (int j = 0; j < len; ++j) tmp[j][i] = t1[j];
  }
  for (int i = 0; i < len; ++i) a[i] = CRT(tmp[i]);
}
void debug() {
  long long a[] = {1, 1, 0, 0};
  long long b[] = {1, 1, 0, 0};
  mul(a, b, 4);
  for (int i = 0; i < 4; ++i) printf("%lld ", a[i]);
  puts("");
}
int k;
long long dp[200020], dp1[200020], dp2[200020];
long long f[200020], nf[200020];
int L;
long long C(int n, int m) {
  return f[n] * nf[m] % 1000000007 * nf[n - m] % 1000000007;
}
void calc(long long n) {
  if (n == 1) {
    for (int i = 1; i <= k; ++i) dp[i] = 1;
    return;
  }
  calc(n / 2);
  for (int i = 0; i < L; ++i) dp1[i] = dp2[i] = 0;
  for (int i = 1; i < k; ++i) {
    dp1[i] = dp[i] * nf[i] % 1000000007 *
             qpow(2, n / 2 % (1000000007 - 1) * i, 1000000007) % 1000000007;
    dp2[i] = dp[i] * nf[i] % 1000000007;
  }
  mul(dp1, dp2, L);
  for (int i = 1; i <= k; ++i) dp[i] = dp1[i] * f[i] % 1000000007;
  if (n & 1) {
    for (int i = 0; i < L; ++i) dp1[i] = dp2[i] = 0;
    for (int i = 1; i <= k; ++i) {
      dp1[i] = dp[i] * nf[i] % 1000000007 * qpow(2, i, 1000000007) % 1000000007;
      dp2[i] = nf[i] % 1000000007;
    }
    mul(dp1, dp2, L);
    for (int i = 1; i <= k; ++i) dp[i] = dp1[i] * f[i] % 1000000007;
  }
}
int main() {
  for (int i = 0; i < 3; ++i) {
    ntt[i].p = m[i];
    for (int j = 0; j < i; ++j) r[j][i] = qpow(m[j], m[i] - 2, m[i]);
  }
  nf[0] = f[0] = 1;
  for (int i = 1; i < 200020; ++i)
    f[i] = f[i - 1] * i % 1000000007,
    nf[i] = qpow(f[i], 1000000007 - 2, 1000000007);
  long long n;
  cin >> n >> k;
  if (n > k) {
    puts("0");
    return 0;
  }
  L = 1;
  while (L <= k * 2) L <<= 1;
  calc(n);
  long long ans = 0;
  for (int i = 1; i <= k; ++i)
    ans = (ans + dp[i] * C(k, i) % 1000000007) % 1000000007;
  cout << ans << endl;
  return 0;
}