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

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

type Edge struct {
	w  int
	id int
}

type ResultEdge struct {
	u, v int
}

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
	}

	treeEdges := make([]Edge, 0, n-1)
	nonTreeEdges := make([]Edge, 0, m-n+1)

	for i := 0; i < m; i++ {
		var w, inTree int
		fmt.Fscan(reader, &w, &inTree)
		if inTree == 1 {
			treeEdges = append(treeEdges, Edge{w, i})
		} else {
			nonTreeEdges = append(nonTreeEdges, Edge{w, i})
		}
	}

	if len(treeEdges) != n-1 {
		fmt.Fprint(writer, "-1")
		return
	}

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

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

	results := make([]ResultEdge, m)

	// Construct the MST as a path 1-2-...-n
	// The i-th edge in sorted treeEdges connects vertex (i+1) and (i+2)
	for i, e := range treeEdges {
		results[e.id] = ResultEdge{i + 1, i + 2}
	}

	// Assign non-tree edges
	// We generate available slots (u, v) based on the tree structure.
	// For the path graph 1-2-...-n, where edges are sorted by weight,
	// the path between u and v (u < v) has max weight equal to the weight of edge (v-1, v).
	// In our 0-indexed treeEdges array, edge connecting v-1 and v is treeEdges[v-2].
	// Let k be the index in treeEdges. k goes from 1 to n-2.
	// treeEdges[k] connects k+1 and k+2.
	// This edge determines the bottleneck for paths from any u <= k to v = k+2.
	// The bottleneck weight is treeEdges[k].w.
	
	k := 1
	u := 1

	for _, e := range nonTreeEdges {
		if k >= n-1 {
			fmt.Fprint(writer, "-1")
			return
		}

		// The current slot is (u, k+2).
		// The condition for a non-tree edge is that its weight must be >= max weight on path in MST.
		// Path max weight is treeEdges[k].w
		if treeEdges[k].w > e.w {
			fmt.Fprint(writer, "-1")
			return
		}

		results[e.id] = ResultEdge{u, k + 2}

		u++
		if u > k {
			u = 1
			k++
		}
	}

	for _, r := range results {
		fmt.Fprintln(writer, r.u, r.v)
	}
}
```