For problem statement at 2000-2999/2100-2199/2110-2119/2117/problemG.txt this is a correct solution, but verifier at 2000-2999/2100-2199/2110-2119/2117/verifierG.go ends with  can you fix the verifier? ```go
package main

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

type Edge struct {
	u, v int
	w    int64
}

type DSU struct {
	parent []int
	size   []int
}

func NewDSU(n int) *DSU {
	parent := make([]int, n)
	size := make([]int, n)
	for i := 0; i < n; i++ {
		parent[i] = i
		size[i] = 1
	}
	return &DSU{parent, size}
}

func (d *DSU) Find(x int) int {
	if d.parent[x] != x {
		d.parent[x] = d.Find(d.parent[x])
	}
	return d.parent[x]
}

func (d *DSU) Union(x, y int) {
	x = d.Find(x)
	y = d.Find(y)
	if x == y {
		return
	}
	if d.size[x] < d.size[y] {
		x, y = y, x
	}
	d.parent[y] = x
	d.size[x] += d.size[y]
}

func (d *DSU) Connected(x, y int) bool {
	return d.Find(x) == d.Find(y)
}

func main() {
	reader := bufio.NewReader(os.Stdin)
	writer := bufio.NewWriter(os.Stdout)
	defer writer.Flush()

	var t int
	fmt.Fscan(reader, &t)
	for tc := 0; tc < t; tc++ {
		var n, m int
		fmt.Fscan(reader, &n, &m)
		edges := make([]Edge, m)
		for i := 0; i < m; i++ {
			var u, v int
			var w int64
			fmt.Fscan(reader, &u, &v, &w)
			edges[i] = Edge{u - 1, v - 1, w}
		}

		sort.Slice(edges, func(i, j int) bool {
			return edges[i].w < edges[j].w
		})

		B := int(math.Sqrt(float64(m))) + 1
		const INF int64 = 1<<62 - 1
		ans := INF

		for start := 0; start < m; start += B {
			end := start + B
			if end > m {
				end = m
			}
			dsu := NewDSU(n)
			right := end
			for left := end - 1; left >= start; left-- {
				dsu.Union(edges[left].u, edges[left].v)
				for right < m && !dsu.Connected(0, n-1) {
					dsu.Union(edges[right].u, edges[right].v)
					right++
				}
				if dsu.Connected(0, n-1) {
					cost := edges[left].w + edges[right-1].w
					if cost < ans {
						ans = cost
					}
				}
			}
		}

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