For problem statement at 0-999/500-599/520-529/527/problemE.txt this is a correct solution, but verifier at 0-999/500-599/520-529/527/verifierE.go ends with all 100 tests passed can you fix the verifier? ```go
package main

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

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
	}

	type Edge struct {
		u, v int
	}
	edges := make([]Edge, 0, m)
	deg := make([]int, n+1)

	for i := 0; i < m; i++ {
		var u, v int
		fmt.Fscan(reader, &u, &v)
		edges = append(edges, Edge{u, v})
		deg[u]++
		deg[v]++
	}

	adj := make([][]int, n+1)
	for _, e := range edges {
		adj[e.u] = append(adj[e.u], e.v)
		adj[e.v] = append(adj[e.v], e.u)
	}

	visited := make([]bool, n+1)

	type Component struct {
		vertices   []int
		odd_nodes  []int
		edge_count int
	}

	var comps []*Component

	for i := 1; i <= n; i++ {
		if deg[i] > 0 && !visited[i] {
			comp := &Component{}
			stack := []int{i}
			visited[i] = true
			sum_deg := 0
			for len(stack) > 0 {
				u := stack[len(stack)-1]
				stack = stack[:len(stack)-1]
				comp.vertices = append(comp.vertices, u)
				if deg[u]%2 != 0 {
					comp.odd_nodes = append(comp.odd_nodes, u)
				}
				sum_deg += deg[u]
				for _, v := range adj[u] {
					if !visited[v] {
						visited[v] = true
						stack = append(stack, v)
					}
				}
			}
			comp.edge_count = sum_deg / 2
			comps = append(comps, comp)
		}
	}

	var added_edges []Edge
	var good_comps []*Component
	var bad_comps []*Component

	for _, c := range comps {
		if len(c.odd_nodes) == 0 {
			if c.edge_count%2 == 1 {
				added_edges = append(added_edges, Edge{c.vertices[0], c.vertices[0]})
				c.edge_count++
			}
		} else {
			w := (c.edge_count + len(c.odd_nodes)/2) % 2
			if w == 0 {
				good_comps = append(good_comps, c)
			} else {
				bad_comps = append(bad_comps, c)
			}
		}
	}

	if len(bad_comps)%2 == 1 {
		b := bad_comps[len(bad_comps)-1]
		bad_comps = bad_comps[:len(bad_comps)-1]
		added_edges = append(added_edges, Edge{b.vertices[0], b.vertices[0]})
		b.edge_count++
		good_comps = append(good_comps, b)
	}

	for i := 0; i < len(bad_comps); i += 2 {
		b1 := bad_comps[i]
		b2 := bad_comps[i+1]
		added_edges = append(added_edges, Edge{b1.odd_nodes[0], b2.odd_nodes[0]})
		added_edges = append(added_edges, Edge{b1.odd_nodes[1], b2.odd_nodes[1]})

		for j := 2; j < len(b1.odd_nodes); j += 2 {
			added_edges = append(added_edges, Edge{b1.odd_nodes[j], b1.odd_nodes[j+1]})
		}
		for j := 2; j < len(b2.odd_nodes); j += 2 {
			added_edges = append(added_edges, Edge{b2.odd_nodes[j], b2.odd_nodes[j+1]})
		}
	}

	for _, c := range good_comps {
		for j := 0; j < len(c.odd_nodes); j += 2 {
			added_edges = append(added_edges, Edge{c.odd_nodes[j], c.odd_nodes[j+1]})
		}
	}

	all_edges := append(edges, added_edges...)

	fmt.Fprintln(writer, len(all_edges))

	type FinalEdge struct {
		to int
		id int
	}
	final_adj := make([][]FinalEdge, n+1)
	for i, e := range all_edges {
		final_adj[e.u] = append(final_adj[e.u], FinalEdge{e.v, i})
		final_adj[e.v] = append(final_adj[e.v], FinalEdge{e.u, i})
	}

	visited_edges := make([]bool, len(all_edges))

	for i := 1; i <= n; i++ {
		if len(final_adj[i]) > 0 {
			for len(final_adj[i]) > 0 {
				last_edge := final_adj[i][len(final_adj[i])-1]
				if visited_edges[last_edge.id] {
					final_adj[i] = final_adj[i][:len(final_adj[i])-1]
					continue
				}

				var circuit []int
				var nodes []int

				type Frame struct {
					u       int
					edge_in int
				}
				stack := []Frame{{i, -1}}

				for len(stack) > 0 {
					u := stack[len(stack)-1].u

					found := false
					for len(final_adj[u]) > 0 {
						e := final_adj[u][len(final_adj[u])-1]
						final_adj[u] = final_adj[u][:len(final_adj[u])-1]
						if !visited_edges[e.id] {
							visited_edges[e.id] = true
							stack = append(stack, Frame{e.to, e.id})
							found = true
							break
						}
					}

					if !found {
						frm := stack[len(stack)-1]
						stack = stack[:len(stack)-1]
						if frm.edge_in != -1 {
							circuit = append(circuit, frm.edge_in)
							nodes = append(nodes, frm.u)
						} else {
							nodes = append(nodes, frm.u)
						}
					}
				}

				m_len := len(circuit)
				for k := 0; k < m_len; k++ {
					edge_idx := m_len - 1 - k
					u_node := nodes[edge_idx+1]
					v_node := nodes[edge_idx]

					if k%2 == 0 {
						fmt.Fprintln(writer, u_node, v_node)
					} else {
						fmt.Fprintln(writer, v_node, u_node)
					}
				}
			}
		}
	}
}
```