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.

import static java.lang.Math.*;
import static java.util.Arrays.*;
import static java.util.Collections.*;
import java.util.*;
public class Main {
    public static void main(String[] args) {
        new Main().run();
    }

    private long mul(long a, long b) {
        // a*b > INF
        if(b > INF/a)return INF;
        return min(a*b,INF);
    }

    private long add(long a, long b) {
        return min(a+b,INF);
    }

    private void debug(Object...os) {
        System.err.println(deepToString(os));
    }
    
    class E{
        long l,r;
        E(long l,long r){
            this.l=l;this.r=r;
        }
    }
    long INF = 1001001001001001001L;
    private void run() {
        Scanner sc = new Scanner(System.in);
        int n=sc.nextInt();
        long K=sc.nextLong();
        int DIG = 18;
        E[] es = new E[n];
        for (int i = 0; i < n; i++) {
            es[i] = new E(sc.nextLong(),sc.nextLong());
        }
        int numLucky = 0;
        for (int i = 1; i <= DIG; i++) {
            for (int j = 0; j < 1<<i; j++) {
                numLucky++;
            }
        }
        long[] luckies = new long[numLucky];
        numLucky=0;
        for (int i = 1; i <= DIG; i++) {
            for (int j = 0; j < 1<<i; j++) {
                long val = 0;
                for (int k = 0; k < i; k++) {
                    val *= 10;
                    val += ((j>>k&1)==0) ? 4 : 7;
                }
                luckies[numLucky++] = val;
            }
        }
        sort(luckies);
        
        sort(es,new Comparator<E>() {
            @Override
            public int compare(E o1, E o2) {
                return Long.signum(o1.l - o2.l);
            }
        });
        long[] L = new long[numLucky];
        for (int i = numLucky-1,m = 0; i >= 0; i--) {// m : num #already moved to left.
            if(m>0){
                L[i] = add(L[i+1], mul(m, luckies[i+1]-luckies[i]));
            }
            while(m<n && luckies[i]<es[n-1-m].l){
                L[i] = add(L[i],es[n-1-m].l - luckies[i]);
                m++;
            }
        }
        sort(es,new Comparator<E>() {
            @Override
            public int compare(E o1, E o2) {
                return Long.signum(o1.r - o2.r);
            }
        });
        long[] R = new long[numLucky];
        for(int i=0,m=0;i<numLucky;i++){
            if(m>0){
                R[i] = add(R[i-1], mul(m, luckies[i]-luckies[i-1]));
            }
            while(m<n && es[m].r<luckies[i]){
                R[i] = add(R[i],luckies[i]-es[m].r); 
                m++;
            }
        }
        
        long minDist = INF;
        for(E e:es)minDist = min(minDist,e.r-e.l);
        int res = 0;
        for (int i = 0; i < numLucky; i++) {
            int can=i-1,cant=numLucky;
            do{
                int j = (can+cant)/2;
                if(luckies[j]-luckies[i]<=minDist && add(L[i],R[j])<=K)
                    can = j;
                else
                    cant = j;
            }while(cant-can>1);
            if(can>=i)res = max(res,can-i+1);
        }
        System.out.println(res);
    }
}
