For problem statement at 1000-1999/1900-1999/1980-1989/1981/problemE.txt this is a correct solution, but verifier at 1000-1999/1900-1999/1980-1989/1981/verifierE.go ends with All 100 tests passed can you fix the verifier? ```go
package main

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

type Edge struct {
	u int32
	v int32
	w int64
}

type Node struct {
	a int64
	i int
	p uint32
	l *Node
	r *Node
}

type DSU struct {
	p  []int
	sz []int
}

func NewDSU(n int) *DSU {
	p := make([]int, n)
	sz := make([]int, n)
	for i := range p {
		p[i] = i
		sz[i] = 1
	}
	return &DSU{p: p, sz: sz}
}

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

func (d *DSU) Union(a, b int) bool {
	ra := d.Find(a)
	rb := d.Find(b)
	if ra == rb {
		return false
	}
	if d.sz[ra] < d.sz[rb] {
		ra, rb = rb, ra
	}
	d.p[rb] = ra
	d.sz[ra] += d.sz[rb]
	return true
}

var rng uint64 = 88172645463393265

func rand32() uint32 {
	rng ^= rng << 7
	rng ^= rng >> 9
	return uint32(rng & 0xffffffff)
}

func lessKey(a1 int64, i1 int, a2 int64, i2 int) bool {
	if a1 != a2 {
		return a1 < a2
	}
	return i1 < i2
}

func rotateRight(y *Node) *Node {
	x := y.l
	y.l = x.r
	x.r = y
	return x
}

func rotateLeft(x *Node) *Node {
	y := x.r
	x.r = y.l
	y.l = x
	return y
}

func insert(root *Node, node *Node) *Node {
	if root == nil {
		return node
	}
	if lessKey(node.a, node.i, root.a, root.i) {
		root.l = insert(root.l, node)
		if root.l.p < root.p {
			root = rotateRight(root)
		}
	} else {
		root.r = insert(root.r, node)
		if root.r.p < root.p {
			root = rotateLeft(root)
		}
	}
	return root
}

func deleteKey(root *Node, a int64, i int) *Node {
	if root == nil {
		return nil
	}
	if lessKey(a, i, root.a, root.i) {
		root.l = deleteKey(root.l, a, i)
	} else if lessKey(root.a, root.i, a, i) {
		root.r = deleteKey(root.r, a, i)
	} else {
		if root.l == nil {
			return root.r
		} else if root.r == nil {
			return root.l
		} else {
			if root.l.p < root.r.p {
				root = rotateRight(root)
				root.r = deleteKey(root.r, a, i)
			} else {
				root = rotateLeft(root)
				root.l = deleteKey(root.l, a, i)
			}
		}
	}
	return root
}

func findPredSucc(root *Node, a int64, i int) (pred *Node, succ *Node) {
	cur := root
	for cur != nil {
		if lessKey(a, i, cur.a, cur.i) {
			succ = cur
			cur = cur.l
		} else if lessKey(cur.a, cur.i, a, i) {
			pred = cur
			cur = cur.r
		} else {
			if cur.l != nil {
				t := cur.l
				for t.r != nil {
					t = t.r
				}
				pred = t
			}
			if cur.r != nil {
				t := cur.r
				for t.l != nil {
					t = t.l
				}
				succ = t
			}
			break
		}
	}
	return
}

type Event struct {
	x   int64
	typ int8
	idx int
}

type FastScanner struct {
	r *bufio.Reader
}

func NewFastScanner() *FastScanner {
	return &FastScanner{r: bufio.NewReaderSize(os.Stdin, 1<<20)}
}

func (fs *FastScanner) NextInt64() int64 {
	var sign int64 = 1
	var val int64 = 0
	b, _ := fs.r.ReadByte()
	for (b < '0' || b > '9') && b != '-' {
		b, _ = fs.r.ReadByte()
	}
	if b == '-' {
		sign = -1
		b, _ = fs.r.ReadByte()
	}
	for b >= '0' && b <= '9' {
		val = val*10 + int64(b-'0')
		b, _ = fs.r.ReadByte()
	}
	return val * sign
}

func abs64(x int64) int64 {
	if x < 0 {
		return -x
	}
	return x
}

func main() {
	in := NewFastScanner()
	out := bufio.NewWriterSize(os.Stdout, 1<<20)
	defer out.Flush()

	t := int(in.NextInt64())
	for ; t > 0; t-- {
		n := int(in.NextInt64())
		l := make([]int64, n)
		r := make([]int64, n)
		a := make([]int64, n)
		for i := 0; i < n; i++ {
			l[i] = in.NextInt64()
			r[i] = in.NextInt64()
			a[i] = in.NextInt64()
		}

		events := make([]Event, 0, 2*n)
		for i := 0; i < n; i++ {
			events = append(events, Event{x: l[i], typ: 0, idx: i})
			events = append(events, Event{x: r[i], typ: 1, idx: i})
		}
		sort.Slice(events, func(i, j int) bool {
			if events[i].x != events[j].x {
				return events[i].x < events[j].x
			}
			return events[i].typ < events[j].typ
		})

		nodes := make([]Node, n)
		for i := 0; i < n; i++ {
			nodes[i] = Node{a: a[i], i: i, p: rand32()}
		}

		edges := make([]Edge, 0, 3*n)
		appendEdge := func(i, j int) {
			if i == j {
				return
			}
			u := int32(i)
			v := int32(j)
			if u > v {
				u, v = v, u
			}
			w := abs64(a[i] - a[j])
			edges = append(edges, Edge{u: u, v: v, w: w})
		}

		var root *Node
		activeCount := 0
		components := 0

		for _, ev := range events {
			i := ev.idx
			if ev.typ == 0 {
				if activeCount == 0 {
					components++
				}
				pred, succ := findPredSucc(root, a[i], i)
				if pred != nil {
					appendEdge(i, pred.i)
				}
				if succ != nil {
					appendEdge(i, succ.i)
				}
				root = insert(root, &nodes[i])
				activeCount++
			} else {
				pred, succ := findPredSucc(root, a[i], i)
				if pred != nil && succ != nil {
					appendEdge(pred.i, succ.i)
				}
				root = deleteKey(root, a[i], i)
				activeCount--
			}
		}

		if components != 1 {
			out.WriteString("-1\n")
			continue
		}

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

		dsu := NewDSU(n)
		var ans int64 = 0
		merged := 0
		for _, e := range edges {
			if dsu.Union(int(e.u), int(e.v)) {
				ans += e.w
				merged++
				if merged == n-1 {
					break
				}
			}
		}

		if merged != n-1 {
			out.WriteString("-1\n")
		} else {
			buf := []byte{}
			if ans == 0 {
				buf = append(buf, '0', '\n')
			} else {
				var tmp [32]byte
				pos := len(tmp)
				x := ans
				for x > 0 {
					pos--
					tmp[pos] = byte('0' + x%10)
					x /= 10
				}
				buf = append(buf, tmp[pos:]...)
				buf = append(buf, '\n')
			}
			out.Write(buf)
		}
	}
}
```