For problem statement at 0-999/900-999/900-909/901/problemC.txt this is a correct solution, but verifier at 0-999/900-999/900-909/901/verifierC.go ends with All tests passed can you fix the verifier? ```go
package main

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

func main() {
	reader := bufio.NewReaderSize(os.Stdin, 64*1024)
	var nextInt func() int
	nextInt = func() int {
		res := 0
		b, err := reader.ReadByte()
		if err != nil {
			return 0
		}
		for b < '0' || b > '9' {
			b, err = reader.ReadByte()
			if err != nil {
				return 0
			}
		}
		for '0' <= b && b <= '9' {
			res = res*10 + int(b-'0')
			b, err = reader.ReadByte()
			if err != nil {
				break
			}
		}
		return res
	}

	n := nextInt()
	if n == 0 {
		return
	}
	m := nextInt()

	adj := make([][]int, n+1)
	for i := 0; i < m; i++ {
		u := nextInt()
		v := nextInt()
		adj[u] = append(adj[u], v)
		adj[v] = append(adj[v], u)
	}

	M := make([]int, n+1)
	for i := 1; i <= n; i++ {
		M[i] = n + 1
	}

	visited := make([]int, n+1)
	parent := make([]int, n+1)
	depth := make([]int, n+1)

	var dfs func(u, p, d int)
	dfs = func(u, p, d int) {
		visited[u] = 1
		parent[u] = p
		depth[u] = d
		for _, v := range adj[u] {
			if v == p {
				continue
			}
			if visited[v] == 1 {
				if depth[v] < depth[u] {
					minV := u
					maxV := u
					curr := u
					for {
						if curr < minV {
							minV = curr
						}
						if curr > maxV {
							maxV = curr
						}
						if curr == v {
							break
						}
						curr = parent[curr]
					}
					if maxV < M[minV] {
						M[minV] = maxV
					}
				}
			} else if visited[v] == 0 {
				dfs(v, u, d+1)
			}
		}
		visited[u] = 2
	}

	for i := 1; i <= n; i++ {
		if visited[i] == 0 {
			dfs(i, 0, 0)
		}
	}

	R := make([]int, n+1)
	R[n] = M[n]
	for i := n - 1; i >= 1; i-- {
		R[i] = M[i]
		if R[i+1] < R[i] {
			R[i] = R[i+1]
		}
	}

	V := make([]int, n+1)
	for i := 1; i <= n; i++ {
		V[i] = R[i] - 1
	}

	pref := make([]int64, n+1)
	for i := 1; i <= n; i++ {
		pref[i] = pref[i-1] + int64(V[i]-i+1)
	}

	q := nextInt()
	writer := bufio.NewWriterSize(os.Stdout, 64*1024)
	defer writer.Flush()

	for i := 0; i < q; i++ {
		l := nextInt()
		r := nextInt()

		k := r + 1
		left := l
		right := r
		for left <= right {
			mid := left + (right-left)/2
			if V[mid] > r {
				k = mid
				right = mid - 1
			} else {
				left = mid + 1
			}
		}

		var total int64 = 0
		if k > l {
			total += pref[k-1] - pref[l-1]
		}
		if k <= r {
			cnt := int64(r - k + 1)
			total += cnt * (cnt + 1) / 2
		}

		fmt.Fprintln(writer, total)
	}
}
```