package main

import (
	"bufio"
	"fmt"
	"io"
	"os"
)

const MOD = 998244353

func min(a, b int) int {
	if a < b {
		return a
	}
	return b
}

func main() {
	data, _ := io.ReadAll(os.Stdin)
	idx := 0
	nextInt := func() int {
		for idx < len(data) && (data[idx] < '0' || data[idx] > '9') && data[idx] != '-' {
			idx++
		}
		sign := 1
		if data[idx] == '-' {
			sign = -1
			idx++
		}
		val := 0
		for idx < len(data) && data[idx] >= '0' && data[idx] <= '9' {
			val = val*10 + int(data[idx]-'0')
			idx++
		}
		return val * sign
	}

	n := nextInt()
	m := nextInt()

	l := make([]int, n)
	r := make([]int, n)
	minR := m
	sumL0 := 0
	for i := 0; i < n; i++ {
		l[i] = nextInt()
		r[i] = nextInt()
		if r[i] < minR {
			minR = r[i]
		}
		sumL0 += l[i]
	}

	if sumL0 > m || m < n {
		fmt.Println(0)
		return
	}

	limit := min(minR, m/n)
	if limit == 0 {
		fmt.Println(0)
		return
	}

	mu := make([]int, limit+1)
	isComp := make([]bool, limit+1)
	primes := make([]int, 0)
	mu[1] = 1
	for i := 2; i <= limit; i++ {
		if !isComp[i] {
			primes = append(primes, i)
			mu[i] = -1
		}
		for _, p := range primes {
			v := i * p
			if v > limit {
				break
			}
			isComp[v] = true
			if i%p == 0 {
				mu[v] = 0
				break
			}
			mu[v] = -mu[i]
		}
	}

	arr1 := make([]int, m+1)
	arr2 := make([]int, m+1)
	widths := make([]int, n)

	ans := 0

	for d := 1; d <= limit; d++ {
		md := mu[d]
		if md == 0 {
			continue
		}

		S := m / d
		sumL := 0
		ok := true

		for i := 0; i < n; i++ {
			L := (l[i] + d - 1) / d
			U := r[i] / d
			if U < L {
				ok = false
				break
			}
			widths[i] = U - L
			sumL += L
			if sumL > S {
				ok = false
				break
			}
		}

		if !ok {
			continue
		}

		T := S - sumL
		dp := arr1
		ndp := arr2
		dp[0] = 1
		maxSum := 0

		for i := 0; i < n; i++ {
			w := widths[i]
			newMax := maxSum + w
			if newMax > T {
				newMax = T
			}
			window := 0
			for s := 0; s <= newMax; s++ {
				if s <= maxSum {
					window += dp[s]
					if window >= MOD {
						window -= MOD
					}
				}
				rem := s - w - 1
				if rem >= 0 && rem <= maxSum {
					window -= dp[rem]
					if window < 0 {
						window += MOD
					}
				}
				ndp[s] = window
			}
			dp, ndp = ndp, dp
			maxSum = newMax
		}

		cnt := 0
		for s := 0; s <= maxSum; s++ {
			cnt += dp[s]
			if cnt >= MOD {
				cnt -= MOD
			}
		}

		if md == 1 {
			ans += cnt
			if ans >= MOD {
				ans -= MOD
			}
		} else {
			ans -= cnt
			if ans < 0 {
				ans += MOD
			}
		}
	}

	out := bufio.NewWriterSize(os.Stdout, 1<<20)
	fmt.Fprint(out, ans)
	out.Flush()
}