For problem statement at 0-999/700-799/730-739/731/problemD.txt this is a correct solution, but verifier at 0-999/700-799/730-739/731/verifierD.go ends with test 1 failed
input:
3 5
4 3 5 5 5
4 4 1 1 1
1 5
expected:
0
but got:
4 can you fix the verifier? ```go
package main

import (
	"bufio"
	"io"
	"os"
	"strconv"
)

type FastScanner struct {
	data []byte
	idx  int
	n    int
}

func (fs *FastScanner) NextInt() int {
	for fs.idx < fs.n {
		b := fs.data[fs.idx]
		if b >= '0' && b <= '9' {
			break
		}
		fs.idx++
	}
	val := 0
	for fs.idx < fs.n {
		b := fs.data[fs.idx]
		if b < '0' || b > '9' {
			break
		}
		val = val*10 + int(b-'0')
		fs.idx++
	}
	return val
}

func readWord(fs *FastScanner, buf []int) []int {
	l := fs.NextInt()
	if cap(buf) < l {
		buf = make([]int, l)
	} else {
		buf = buf[:l]
	}
	for i := 0; i < l; i++ {
		buf[i] = fs.NextInt()
	}
	return buf
}

func main() {
	data, _ := io.ReadAll(os.Stdin)
	fs := FastScanner{data: data, n: len(data)}

	n := fs.NextInt()
	c := fs.NextInt()

	diff := make([]int, c+3)
	L, R := 1, c

	prev := readWord(&fs, nil)
	var cur []int

	out := bufio.NewWriterSize(os.Stdout, 1<<20)
	defer out.Flush()

	for i := 1; i < n; i++ {
		cur = readWord(&fs, cur)

		m := len(prev)
		if len(cur) < m {
			m = len(cur)
		}

		j := 0
		for j < m && prev[j] == cur[j] {
			j++
		}

		if j == m {
			if len(prev) > len(cur) {
				out.WriteString("-1")
				return
			}
		} else {
			a, b := prev[j], cur[j]
			if a < b {
				diff[a]++
				diff[b]--
			} else {
				if b > L {
					L = b
				}
				if a-1 < R {
					R = a - 1
				}
				if L > R {
					out.WriteString("-1")
					return
				}
			}
		}

		prev, cur = cur, prev
	}

	curBad := 0
	for t := 1; t <= c; t++ {
		curBad += diff[t]
		if t >= L && t <= R && curBad == 0 {
			out.WriteString(strconv.Itoa(c - t))
			return
		}
	}

	out.WriteString("-1")
}
```