package main

import (
	"bufio"
	"fmt"
	"os"
	"sort"
)

type Segment struct {
	v, t int
}

func main() {
	reader := bufio.NewReader(os.Stdin)
	var n, s int
	if _, err := fmt.Fscan(reader, &n, &s); err != nil {
		return
	}

	segments := make([][]Segment, n)
	var X []int
	X = append(X, 0)
	X = append(X, s)

	for i := 0; i < n; i++ {
		var k int
		fmt.Fscan(reader, &k)
		segments[i] = make([]Segment, k)
		curX := 0
		for j := 0; j < k; j++ {
			fmt.Fscan(reader, &segments[i][j].v, &segments[i][j].t)
			curX += segments[i][j].v * segments[i][j].t
			if curX < s {
				X = append(X, curX)
			}
		}
	}

	sort.Ints(X)
	var uniqueX []int
	for i, x := range X {
		if i == 0 || x != X[i-1] {
			uniqueX = append(uniqueX, x)
		}
	}

	times := make([][][2]int64, n)
	for i := 0; i < n; i++ {
		times[i] = make([][2]int64, len(uniqueX))
		segIdx := 0
		curX := 0
		curT := 0

		for k, x := range uniqueX {
			for segIdx < len(segments[i]) {
				seg := segments[i][segIdx]
				if x <= curX+seg.v*seg.t {
					break
				}
				curX += seg.v * seg.t
				curT += seg.t
				segIdx++
			}

			if segIdx == len(segments[i]) {
				segIdx--
			}

			seg := segments[i][segIdx]
			num := int64(curT)*int64(seg.v) + int64(x-curX)
			den := int64(seg.v)
			times[i][k] = [2]int64{num, den}
		}
	}

	totalOvertakes := 0
	for i := 0; i < n; i++ {
		for j := i + 1; j < n; j++ {
			changes := 0
			lastSign := 0
			for k := 0; k < len(uniqueX); k++ {
				n1, d1 := times[i][k][0], times[i][k][1]
				n2, d2 := times[j][k][0], times[j][k][1]

				lhs := n1 * d2
				rhs := n2 * d1

				sign := 0
				if lhs > rhs {
					sign = 1
				} else if lhs < rhs {
					sign = -1
				}

				if sign != 0 {
					if lastSign != 0 && sign != lastSign {
						changes++
					}
					lastSign = sign
				}
			}
			totalOvertakes += changes
		}
	}

	fmt.Println(totalOvertakes)
}