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;
long long gcd(long long a, long long b) { return b == 0 ? a : gcd(b, a % b); }
const int MAXK = 30000;
const int LGN = 16;
const int N = 1 << LGN;
const int MOD = 1000000007;
const double MYPI = acos(-1);
typedef struct Pol {
  int x[MAXK + 1];
} Pol;
int bitrev[N];
complex<double> w[N];
void prefft() {
  for (int i = (0); i < (N); ++i)
    bitrev[i] = bitrev[i >> 1] >> 1 | ((i & 1) << (LGN - 1));
  for (int i = (0); i < (N); ++i)
    w[i] = complex<double>(cos(2 * MYPI * i / N), sin(2 * MYPI * i / N));
}
void fft(complex<double> a[N]) {
  for (int i = (0); i < (N); ++i)
    if (i < bitrev[i]) swap(a[i], a[bitrev[i]]);
  for (int len = 2, step = N >> 1; len <= N; len <<= 1, step >>= 1) {
    for (int i = 0; i < N; i += len) {
      complex<double> *l = a + i, *r = l + (len >> 1), *p = w;
      for (int off = (0); off < (len >> 1); ++off) {
        complex<double> v = *r * *p;
        *r = *l - v;
        *l = *l + v;
        ++l, ++r, p += step;
      }
    }
  }
}
int inv[MAXK + 1];
int fact[MAXK + 1];
int ifact[MAXK + 1];
int ipow(int x, int n) {
  int ret = 1;
  while (true) {
    if (n & 1) ret = (long long)ret * x % MOD;
    if ((n >>= 1) == 0) return ret;
    x = (long long)x * x % MOD;
  }
}
int K;
void pmult(Pol &c, Pol &a, Pol &b) {
  static complex<double> A[N], B[N], C[N], D[N];
  for (int i = (0); i <= (K); ++i)
    A[i] = complex<double>(a.x[i] & ((1 << 15) - 1), a.x[i] >> 15);
  for (int i = (0); i <= (K); ++i)
    B[i] = complex<double>(b.x[i] & ((1 << 15) - 1), b.x[i] >> 15);
  for (int i = (K + 1); i < (N); ++i) A[i] = B[i] = complex<double>(0, 0);
  fft(A);
  fft(B);
  for (int i = (0); i < (N); ++i) {
    int j = (N - i) & (N - 1);
    complex<double> w = (A[i] + conj(A[j])) * complex<double>(.5, 0);
    complex<double> x = (A[i] - conj(A[j])) * complex<double>(0, -.5);
    complex<double> y = (B[i] + conj(B[j])) * complex<double>(.5, 0);
    complex<double> z = (B[i] - conj(B[j])) * complex<double>(0, -.5);
    C[j] = w * y + w * z * complex<double>(0, 1);
    D[j] = x * y + x * z * complex<double>(0, 1);
  }
  fft(C);
  fft(D);
  for (int i = (0); i <= (K); ++i) {
    int w = (long long)(real(C[i]) / N + .5) % MOD;
    int x = (long long)(imag(C[i]) / N + .5) % MOD;
    int y = (long long)(real(D[i]) / N + .5) % MOD;
    int z = (long long)(imag(D[i]) / N + .5) % MOD;
    c.x[i] = (w + ((long long)(x + y) << 15) + ((long long)z << 30)) % MOD;
  }
}
void pmult(Pol &a, int n2, Pol &b) {
  static Pol c;
  int step = ipow(2, n2), mlt = 1;
  for (int i = (0); i <= (K); ++i)
    c.x[i] = (long long)a.x[i] * mlt % MOD, mlt = (long long)mlt * step % MOD;
  pmult(a, c, b);
}
void ppow(Pol &a, Pol &b, int n) {
  for (int i = (0); i <= (K); ++i) a.x[i] = i == 0 ? 1 : 0;
  static Pol c;
  for (int i = (0); i <= (K); ++i) c.x[i] = b.x[i];
  int cn = 1;
  while (true) {
    if (n & 1) pmult(a, cn, c);
    if ((n >>= 1) == 0) break;
    pmult(c, cn, c), cn += cn;
  }
}
long long n;
Pol h1;
Pol hn;
void run() {
  fact[0] = 1;
  for (int i = (1); i <= (MAXK); ++i)
    fact[i] = (long long)fact[i - 1] * i % MOD;
  inv[1] = 1;
  for (int i = (2); i <= (MAXK); ++i)
    inv[i] = (MOD - (long long)(MOD / i) * inv[MOD % i] % MOD) % MOD;
  ifact[0] = 1;
  for (int i = (1); i <= (MAXK); ++i)
    ifact[i] = (long long)ifact[i - 1] * inv[i] % MOD;
  scanf("%I64d%d", &n, &K);
  if (n > K) {
    printf("0\n");
    return;
  }
  h1.x[0] = 0;
  for (int i = (1); i <= (K); ++i) h1.x[i] = ifact[i];
  prefft();
  ppow(hn, h1, n);
  int ret = 0;
  for (int i = (0); i <= (K); ++i) {
    int cur = (long long)hn.x[i] * fact[K] % MOD * ifact[K - i] % MOD;
    if ((ret += cur) >= MOD) ret -= MOD;
  }
  printf("%d\n", ret);
}
int main() {
  run();
  return 0;
}