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 int maxn = 100010;
complex<double> a[maxn], b[maxn], c[maxn], d[maxn], A[maxn], B[maxn], C[maxn],
    w[maxn];
long long F[maxn], G[maxn], f[maxn], g[maxn];
long long fac[maxn], ifac[maxn], rev[maxn], K, N, L;
long long n;
long long power(long long a, long long b) {
  long long res = 1;
  while (b) {
    if (b & 1) res = res * a % 1000000007;
    b >>= 1;
    a = a * a % 1000000007;
  }
  return res;
}
void DFT(complex<double> *t, long long f) {
  for (int i = 0; i < N; i++)
    if (rev[i] > i) swap(t[i], t[rev[i]]);
  for (int i = 1; i < N; i <<= 1) {
    for (int j = 0; j < i; j++) {
      complex<double> tmp(cos(acos(-1.0) * j / i), f * sin(acos(-1.0) * j / i));
      w[j] = tmp;
    }
    for (int p = i << 1, j = 0; j < N; j += p) {
      for (int k = 0; k < i; k++) {
        complex<double> x = t[k + j], y = t[k + j + i] * w[k];
        t[k + j] = x + y;
        t[k + j + i] = x - y;
      }
    }
  }
}
void FFT(long long *u, long long *v, long long p) {
  complex<double> clean(0, 0);
  for (int i = 0; i < N; i++)
    a[i] = b[i] = c[i] = d[i] = A[i] = B[i] = C[i] = clean;
  for (int i = 0; i <= K; i++) {
    F[i] = u[i] * fac[K - i] % 1000000007 * power(p, i) % 1000000007;
    G[i] = v[i] * fac[K - i] % 1000000007;
  }
  for (int i = 0; i < N; i++) {
    a[i] = F[i] >> 15;
    b[i] = F[i] & ((1 << 15) - 1);
    c[i] = G[i] >> 15;
    d[i] = G[i] & ((1 << 15) - 1);
  }
  DFT(a, 1);
  DFT(b, 1);
  DFT(c, 1);
  DFT(d, 1);
  for (int i = 0; i < N; i++) {
    A[i] = a[i] * c[i];
    B[i] = a[i] * d[i] + b[i] * c[i];
    C[i] = b[i] * d[i];
  }
  DFT(A, -1);
  DFT(B, -1);
  DFT(C, -1);
  for (int i = 0; i <= K; i++) {
    long long X = (long long)(A[i].real() / N + 0.5) % 1000000007;
    long long Y = (long long)(B[i].real() / N + 0.5) % 1000000007;
    long long Z = (long long)(C[i].real() / N + 0.5) % 1000000007;
    u[i] = ((X << 30) + (Y << 15) + Z) % 1000000007;
  }
  for (int i = 0; i <= K; i++)
    u[i] = u[i] * ifac[K] % 1000000007 * ifac[K - i] % 1000000007;
}
int main() {
  scanf("%I64d%I64d", &n, &K);
  if (n > K) {
    puts("0");
    return 0;
  }
  for (N = 1, L = -1; N <= 2 * K; N <<= 1) L++;
  for (int i = 0; i < N; i++) rev[i] = (rev[i >> 1] >> 1) | ((i & 1) << L);
  fac[0] = ifac[0] = 1;
  for (long long i = 1; i <= K; i++) {
    fac[i] = fac[i - 1] * i % 1000000007;
    ifac[i] = power(fac[i], 1000000007 - 2);
  }
  g[0] = 1;
  for (long long x = 1, i = 1; i <= K; i++) {
    x = x * (K - i + 1) % 1000000007 * power(i, 1000000007 - 2) % 1000000007;
    f[i] = x;
  }
  long long p = 2;
  while (n) {
    if (n & 1) FFT(g, f, p);
    n >>= 1;
    FFT(f, f, p);
    p = p * p % 1000000007;
  }
  long long res = 0;
  for (int i = 0; i <= K; i++) res = (res + g[i]) % 1000000007;
  printf("%I64d", res);
  return 0;
}