```go
package main

import (
	"bufio"
	"fmt"
	"math/bits"
	"os"
	"sort"
)

type Int128 struct {
	hi, lo uint64
}

func Add(a, b Int128) Int128 {
	lo, carry := bits.Add64(a.lo, b.lo, 0)
	hi, _ := bits.Add64(a.hi, b.hi, carry)
	return Int128{hi, lo}
}

func Sub(a, b Int128) Int128 {
	lo, borrow := bits.Sub64(a.lo, b.lo, 0)
	hi, _ := bits.Sub64(a.hi, b.hi, borrow)
	return Int128{hi, lo}
}

func FromMul64(a, b uint64) Int128 {
	hi, lo := bits.Mul64(a, b)
	return Int128{hi, lo}
}

func LessEqual(a, b Int128) bool {
	if a.hi < b.hi {
		return true
	}
	if a.hi > b.hi {
		return false
	}
	return a.lo <= b.lo
}

var lucky []int64

func genLucky(current int64) {
	if current > 5000000000000000000 {
		return
	}
	if current > 0 {
		lucky = append(lucky, current)
	}
	if current > 500000000000000000 {
		return
	}
	genLucky(current*10 + 4)
	genLucky(current*10 + 7)
}

func main() {
	scanner := bufio.NewScanner(os.Stdin)
	scanner.Split(bufio.ScanWords)
	scanner.Buffer(make([]byte, 1024*1024), 1024*1024)

	scanInt64 := func() int64 {
		scanner.Scan()
		b := scanner.Bytes()
		var x int64
		for _, c := range b {
			x = x*10 + int64(c-'0')
		}
		return x
	}

	if !scanner.Scan() {
		return
	}
	var n int
	for _, c := range scanner.Bytes() {
		n = n*10 + int(c-'0')
	}
	k := scanInt64()

	ls := make([]int64, n)
	rs := make([]int64, n)
	minLen := int64(2000000000000000000)

	for i := 0; i < n; i++ {
		ls[i] = scanInt64()
		rs[i] = scanInt64()
		if rs[i]-ls[i] < minLen {
			minLen = rs[i] - ls[i]
		}
	}

	sort.Slice(ls, func(i, j int) bool { return ls[i] < ls[j] })
	sort.Slice(rs, func(i, j int) bool { return rs[i] < rs[j] })

	pSumL := make([]Int128, n+1)
	pSumR := make([]Int128, n+1)

	for i := 0; i < n; i++ {
		pSumL[i+1] = Add(pSumL[i], Int128{0, uint64(ls[i])})
		pSumR[i+1] = Add(pSumR[i], Int128{0, uint64(rs[i])})
	}

	genLucky(0)
	sort.Slice(lucky, func(i, j int) bool { return lucky[i] < lucky[j] })

	k128 := Int128{0, uint64(k)}

	calcF := func(x int64) Int128 {
		idx := sort.Search(n, func(i int) bool { return ls[i] > x })
		count := uint64(n - idx)
		if count == 0 {
			return Int128{0, 0}
		}
		sumPart := Sub(pSumL[n], pSumL[idx])
		subPart := FromMul64(count, uint64(x))
		return Sub(sumPart, subPart)
	}

	calcG := func(x int64) Int128 {
		idx := sort.Search(n, func(i int) bool { return rs[i] >= x })
		count := uint64(idx)
		if count == 0 {
			return Int128{0, 0}
		}
		term := FromMul64(count, uint64(x))
		sumPart := pSumR[idx]
		return Sub(term, sumPart)
	}

	ans := 0
	ptrLen := 0
	ptrCost := 0
	m := len(lucky)

	for right := 0; right < m; right++ {
		for lucky[right]-lucky[ptrLen] > minLen {
			ptrLen++
		}

		costG := calcG(lucky[right])
		if !LessEqual(costG, k128) {
			break
		}
		remK := Sub(k128, costG)

		for ptrCost <= right {
			if LessEqual(calcF(lucky[ptrCost]), remK) {
				break
			}
			ptrCost++
		}

		start := ptrLen
		if ptrCost > start {
			start = ptrCost
		}
		if start <= right {
			curr := right - start + 1
			if curr > ans {
				ans = curr
			}
		}
	}
	fmt.Println(ans)
}
```