For problem statement at 0-999/600-699/600-609/603/problemE.txt this is a correct solution, but verifier at 0-999/600-699/600-609/603/verifierE.go ends with All tests passed can you fix the verifier? ```go
package main

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

type Edge struct {
	u, v, w, id int
}

type DSUState struct {
	u, v, odd int
}

type RollbackDSU struct {
	parent  []int
	size    []int
	odd     int
	history []DSUState
}

func NewRollbackDSU(n int) *RollbackDSU {
	p := make([]int, n+1)
	sz := make([]int, n+1)
	for i := 1; i <= n; i++ {
		p[i] = i
		sz[i] = 1
	}
	return &RollbackDSU{
		parent:  p,
		size:    sz,
		odd:     n,
		history: make([]DSUState, 0, 1000000),
	}
}

func (d *RollbackDSU) find(i int) int {
	for d.parent[i] != i {
		i = d.parent[i]
	}
	return i
}

func (d *RollbackDSU) merge(u, v int) {
	u = d.find(u)
	v = d.find(v)
	if u == v {
		d.history = append(d.history, DSUState{-1, -1, d.odd})
		return
	}
	if d.size[u] < d.size[v] {
		u, v = v, u
	}
	oldOdd := d.odd
	if d.size[u]%2 != 0 && d.size[v]%2 != 0 {
		d.odd -= 2
	}
	d.parent[v] = u
	d.size[u] += d.size[v]
	d.history = append(d.history, DSUState{u, v, oldOdd})
}

func (d *RollbackDSU) getState() int {
	return len(d.history)
}

func (d *RollbackDSU) rollback(target int) {
	for len(d.history) > target {
		state := d.history[len(d.history)-1]
		d.history = d.history[:len(d.history)-1]
		if state.u != -1 {
			u := state.u
			v := state.v
			d.size[u] -= d.size[v]
			d.parent[v] = v
		}
		d.odd = state.odd
	}
}

var (
	edges         []Edge
	S             []Edge
	edgeWeightIdx []int
	ans           []int
	dsu           *RollbackDSU
)

func solve(tL, tR, wL, wR int) {
	if tL > tR {
		return
	}
	tMid := (tL + tR) / 2

	state0 := dsu.getState()

	for i := tL; i <= tMid; i++ {
		if edgeWeightIdx[i] < wL {
			dsu.merge(edges[i].u, edges[i].v)
		}
	}

	state1 := dsu.getState()

	optMid := -1
	for j := wL; j <= wR; j++ {
		if S[j].id <= tMid {
			dsu.merge(S[j].u, S[j].v)
		}
		if dsu.odd == 0 {
			optMid = j
			break
		}
	}

	ans[tMid] = S[optMid].w

	dsu.rollback(state1)

	solve(tMid+1, tR, wL, optMid)

	dsu.rollback(state0)

	state2 := dsu.getState()
	for j := wL; j < optMid; j++ {
		if S[j].id < tL {
			dsu.merge(S[j].u, S[j].v)
		}
	}

	solve(tL, tMid-1, optMid, wR)

	dsu.rollback(state2)
}

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

	var n, m int
	if _, err := fmt.Fscan(reader, &n, &m); err != nil {
		return
	}

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

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

	edgeWeightIdx = make([]int, m+1)
	for i := 0; i < m; i++ {
		edgeWeightIdx[S[i].id] = i
	}

	ans = make([]int, m+1)
	for i := 1; i <= m; i++ {
		ans[i] = -1
	}

	tempDSU := NewRollbackDSU(n)
	T_valid := -1
	for i := 1; i <= m; i++ {
		tempDSU.merge(edges[i].u, edges[i].v)
		if tempDSU.odd == 0 {
			T_valid = i
			break
		}
	}

	if T_valid != -1 {
		dsu = NewRollbackDSU(n)
		solve(T_valid, m, 0, m-1)
	}

	for i := 1; i <= m; i++ {
		fmt.Fprintln(writer, ans[i])
	}
}
```