For problem statement at 0-999/200-299/210-219/211/problemA.txt this is a correct solution, but verifier at 0-999/200-299/210-219/211/verifierA.go ends with case 1 invalid: color 1 assigned 0 edges, need 1
exit status 1 can you fix the verifier? ```go
package main

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

type Edge struct {
	id    int
	u     int
	v     int
	color int
}

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

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

	edges := make([]Edge, k+1)
	adj := make([][]int, n+m+1)
	deg := make([][]int, n+m+1)
	for i := range deg {
		deg[i] = make([]int, t+1)
	}

	for i := 1; i <= k; i++ {
		var u, v int
		fmt.Fscan(in, &u, &v)
		v += n
		edges[i] = Edge{id: i, u: u, v: v}
		adj[u] = append(adj[u], i)
		adj[v] = append(adj[v], i)

		min_deg_u := 1000000
		c1 := 1
		for c := 1; c <= t; c++ {
			if deg[u][c] < min_deg_u {
				min_deg_u = deg[u][c]
				c1 = c
			}
		}

		min_deg_v := 1000000
		c2 := 1
		for c := 1; c <= t; c++ {
			if deg[v][c] < min_deg_v {
				min_deg_v = deg[v][c]
				c2 = c
			}
		}

		edges[i].color = c1
		deg[u][c1]++
		deg[v][c1]++

		if c1 != c2 && deg[v][c1]-deg[v][c2] == 2 {
			queue := make([]int, 0)
			queue = append(queue, v)

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

			parentEdge := make([]int, n+m+1)
			parentNode := make([]int, n+m+1)

			sink := -1

			for len(queue) > 0 {
				curr := queue[0]
				queue = queue[1:]

				if curr != v {
					if curr <= n {
						if deg[curr][c1] > deg[curr][c2] {
							sink = curr
							break
						}
					} else {
						if deg[curr][c1] < deg[curr][c2] {
							sink = curr
							break
						}
					}
				}

				if curr > n {
					for _, edge_id := range adj[curr] {
						if edges[edge_id].color == c1 {
							nxt := edges[edge_id].u
							if !visited[nxt] {
								visited[nxt] = true
								parentEdge[nxt] = edge_id
								parentNode[nxt] = curr
								queue = append(queue, nxt)
							}
						}
					}
				} else {
					for _, edge_id := range adj[curr] {
						if edges[edge_id].color == c2 {
							nxt := edges[edge_id].v
							if !visited[nxt] {
								visited[nxt] = true
								parentEdge[nxt] = edge_id
								parentNode[nxt] = curr
								queue = append(queue, nxt)
							}
						}
					}
				}
			}

			if sink != -1 {
				curr := sink
				for curr != v {
					e_id := parentEdge[curr]
					p := parentNode[curr]

					old_c := edges[e_id].color
					new_c := c2
					if old_c == c2 {
						new_c = c1
					}

					edges[e_id].color = new_c
					deg[edges[e_id].u][old_c]--
					deg[edges[e_id].v][old_c]--
					deg[edges[e_id].u][new_c]++
					deg[edges[e_id].v][new_c]++

					curr = p
				}
			}
		}
	}

	max_w := 0
	for i := 1; i <= n+m; i++ {
		min_c := 1000000
		max_c := -1
		for c := 1; c <= t; c++ {
			if deg[i][c] < min_c {
				min_c = deg[i][c]
			}
			if deg[i][c] > max_c {
				max_c = deg[i][c]
			}
		}
		w := max_c - min_c
		if w > max_w {
			max_w = w
		}
	}

	fmt.Fprintln(out, max_w)
	for i := 1; i <= k; i++ {
		if i > 1 {
			fmt.Fprint(out, " ")
		}
		fmt.Fprint(out, edges[i].color)
	}
	fmt.Fprintln(out)
}
```