For problem statement at 1000-1999/1200-1299/1210-1219/1215/problemF.txt this is a correct solution, but verifier at 1000-1999/1200-1299/1210-1219/1215/verifierF.go ends with test 1: execution failed: exit status 2
input:3 2 5 1
1 3
1 3
2 3
2 3
3 4
2 3


exit status 1 can you fix the verifier? ```go
package main

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

var scanner *bufio.Scanner

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

func nextInt() int {
	scanner.Scan()
	v, _ := strconv.Atoi(scanner.Text())
	return v
}

func main() {
	if !scanner.Scan() {
		return
	}
	n, _ := strconv.Atoi(scanner.Text())
	p := nextInt()
	M := nextInt()
	m := nextInt()

	adj := make([][]int, 2*p+1)
	for i := 0; i < n; i++ {
		x := nextInt()
		y := nextInt()
		adj[x+p] = append(adj[x+p], y)
		adj[y+p] = append(adj[y+p], x)
	}

	l := make([]int, p+1)
	r := make([]int, p+1)
	for i := 1; i <= p; i++ {
		l[i] = nextInt()
		r[i] = nextInt()
	}

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

	dfn := make([]int, 2*p+1)
	low := make([]int, 2*p+1)
	scc := make([]int, 2*p+1)
	inStack := make([]bool, 2*p+1)
	stack := make([]int, 0, 2*p+1)
	timer := 0
	sccCount := 0

	var dfs func(int)
	dfs = func(u int) {
		timer++
		dfn[u] = timer
		low[u] = timer
		stack = append(stack, u)
		inStack[u] = true

		for _, v := range adj[u] {
			if dfn[v] == 0 {
				dfs(v)
				if low[v] < low[u] {
					low[u] = low[v]
				}
			} else if inStack[v] {
				if dfn[v] < low[u] {
					low[u] = dfn[v]
				}
			}
		}

		if low[u] == dfn[u] {
			for {
				v := stack[len(stack)-1]
				stack = stack[:len(stack)-1]
				inStack[v] = false
				scc[v] = sccCount
				if u == v {
					break
				}
			}
			sccCount++
		}
	}

	for i := 1; i <= 2*p; i++ {
		if dfn[i] == 0 {
			dfs(i)
		}
	}

	for i := 1; i <= p; i++ {
		if scc[i] == scc[i+p] {
			fmt.Println("-1")
			return
		}
	}

	L_pos := make([]int, sccCount)
	R_pos := make([]int, sccCount)
	for i := 0; i < sccCount; i++ {
		L_pos[i] = 0
		R_pos[i] = M + 1
	}

	for v := 1; v <= p; v++ {
		c := scc[v]
		if l[v] > L_pos[c] {
			L_pos[c] = l[v]
		}
		if r[v] < R_pos[c] {
			R_pos[c] = r[v]
		}
	}

	adj_scc := make([][]int, sccCount)
	for u := 1; u <= 2*p; u++ {
		c := scc[u]
		for _, v := range adj[u] {
			d := scc[v]
			if c != d {
				adj_scc[c] = append(adj_scc[c], d)
			}
		}
	}

	L_prime := make([]int, sccCount)
	R_prime := make([]int, sccCount)
	for c := 0; c < sccCount; c++ {
		L_prime[c] = L_pos[c]
		R_prime[c] = R_pos[c]
		for _, d := range adj_scc[c] {
			if L_prime[d] > L_prime[c] {
				L_prime[c] = L_prime[d]
			}
			if R_prime[d] < R_prime[c] {
				R_prime[c] = R_prime[d]
			}
		}
	}

	diff := make([]int, M+2)
	clamp := func(val, min, max int) int {
		if val < min {
			return min
		}
		if val > max {
			return max
		}
		return val
	}

	for i := 1; i <= p; i++ {
		l1, r1 := l[i], r[i]
		c_neg := scc[i+p]
		l2, r2 := L_prime[c_neg], R_prime[c_neg]

		intervals := [][2]int{}
		if l2 > r2 {
			intervals = append(intervals, [2]int{l1, r1})
		} else {
			l2 = clamp(l2, 1, M)
			r2 = clamp(r2, 1, M)
			if l1 > l2 {
				l1, l2 = l2, l1
				r1, r2 = r2, r1
			}
			if l2 <= r1+1 {
				max_r := r1
				if r2 > max_r {
					max_r = r2
				}
				intervals = append(intervals, [2]int{l1, max_r})
			} else {
				intervals = append(intervals, [2]int{l1, r1})
				intervals = append(intervals, [2]int{l2, r2})
			}
		}

		for _, interval := range intervals {
			diff[interval[0]]++
			diff[interval[1]+1]--
		}
	}

	found_f := -1
	sum := 0
	for f := 1; f <= M; f++ {
		sum += diff[f]
		if sum == p {
			found_f = f
			break
		}
	}

	if found_f == -1 {
		fmt.Println("-1")
		return
	}

	for i := 1; i <= p; i++ {
		if found_f < l[i] || found_f > r[i] {
			adj[i] = append(adj[i], i+p)
		}
	}

	for i := 1; i <= 2*p; i++ {
		dfn[i] = 0
		low[i] = 0
		scc[i] = 0
		inStack[i] = false
	}
	stack = stack[:0]
	timer = 0
	sccCount = 0

	for i := 1; i <= 2*p; i++ {
		if dfn[i] == 0 {
			dfs(i)
		}
	}

	ans := make([]int, 0, p)
	for i := 1; i <= p; i++ {
		if scc[i] == scc[i+p] {
			fmt.Println("-1")
			return
		}
		if scc[i] < scc[i+p] {
			ans = append(ans, i)
		}
	}

	out := bufio.NewWriter(os.Stdout)
	fmt.Fprintf(out, "%d %d\n", len(ans), found_f)
	for i, v := range ans {
		if i > 0 {
			fmt.Fprintf(out, " ")
		}
		fmt.Fprintf(out, "%d", v)
	}
	fmt.Fprintf(out, "\n")
	out.Flush()
}
```