Petya loves lucky numbers. Everybody knows that lucky numbers are positive integers whose decimal representation contains only the lucky digits 4 and 7. For example, numbers 47, 744, 4 are lucky and 5, 17, 467 are not.

Petya has n number segments [l1; r1], [l2; r2], ..., [ln; rn]. During one move Petya can take any segment (let it be segment number i) and replace it with segment [li + 1; ri + 1] or [li - 1; ri - 1]. In other words, during one move Petya can shift any segment to the left or to the right by a unit distance. Petya calls a number full if it belongs to each segment. That is, number x is full if for any i (1 ≤ i ≤ n) the condition li ≤ x ≤ ri is fulfilled.

Petya makes no more than k moves. After that he counts the quantity of full lucky numbers. Find the maximal quantity that he can get.

Input

The first line contains two integers n and k (1 ≤ n ≤ 105, 1 ≤ k ≤ 1018) — the number of segments and the maximum number of moves. Next n lines contain pairs of integers li and ri (1 ≤ li ≤ ri ≤ 1018).

Please do not use the %lld specificator to read or write 64-bit integers in С++. It is preferred to use the %I64d specificator.

Output

Print on the single line the single number — the answer to the problem.

Examples

Input

4 7
1 4
6 9
4 7
3 5


Output

1


Input

2 7
40 45
47 74


Output

2

Note

In the first sample Petya shifts the second segment by two units to the left (it turns into [4; 7]), after that number 4 becomes full.

In the second sample Petya shifts the first segment by two units to the right (it turns into [42; 47]), and shifts the second segment by three units to the left (it turns into [44; 71]), after that numbers 44 and 47 become full.
#include <bits/stdc++.h>
using namespace std;
const int N = 1e5 + 5;
const int M = 1 << 19;
int n, m;
long long k, mn = 1e18, l[N], r[N];
long long lucky[M], dp1[M], dp2[M];
vector<int> vec[M];
inline long long Mul(long long a, long long b) {
  return a && k / a < b ? k + 10 : a * b;
}
inline void Sum(long long &a, long long b) { a = min(a + b, k + 10); }
inline bool check(int L, int R) {
  return lucky[R] - lucky[L] <= mn && dp1[L] + dp2[R] <= k;
}
inline void read_input() {
  cin >> n >> k;
  for (int i = 0; i < n; i++) {
    cin >> l[i] >> r[i];
    mn = min(mn, r[i] - l[i]);
  }
}
inline void solve() {
  int sz = 0;
  long long sum = 0;
  for (int i = 1; i < 19; i++)
    for (int j = 0; j < 1 << i; j++, m++)
      for (int p = i - 1; ~p; p--) (lucky[m] *= 10) += j >> p & 1 ? 7 : 4;
  for (int i = 0; i < n; i++)
    vec[lower_bound(lucky, lucky + m, l[i]) - lucky].push_back(i);
  for (int i = m - 1; ~i; i--) {
    Sum(sum, Mul(sz, lucky[i + 1] - lucky[i]));
    for (auto p : vec[i + 1]) {
      Sum(sum, l[p] - lucky[i]);
      sz++;
    }
    dp1[i] = sum;
  }
  for (int i = sz = sum = 0; i < m; i++) vec[i].clear();
  for (int i = 0; i < n; i++)
    vec[lower_bound(lucky, lucky + m, r[i]) - lucky].push_back(i);
  for (int i = 0; i < m; i++) {
    Sum(sum, Mul(sz, (lucky[i] - lucky[i - 1])));
    for (auto p : vec[i]) {
      Sum(sum, lucky[i] - r[p]);
      sz++;
    }
    dp2[i] = sum;
  }
}
inline void write_output() {
  int ans = 0;
  for (int i = 0; i < m; i++) {
    int L = i - 1, R = m;
    while (L + 1 < R) {
      int mid = L + R >> 1;
      (check(i, mid) ? L : R) = mid;
    }
    ans = max(ans, L - i + 1);
  }
  cout << ans;
}
int main() {
  ios::sync_with_stdio(0), cin.tie(0), cout.tie(0);
  read_input(), solve(), write_output();
  return 0;
}
