For problem statement at 0-999/200-299/200-209/200/problemC.txt this is a correct solution, but verifier at 0-999/200-299/200-209/200/verifierC.go ends with All 20 tests passed can you fix the verifier? ```go
package main

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

type TeamStats struct {
	points int
	scored int
	missed int
}

type Team struct {
	name   string
	points int
	scored int
	missed int
}

func main() {
	scanner := bufio.NewScanner(os.Stdin)
	stats := make(map[string]*TeamStats)
	counts := make(map[string]int)

	for i := 0; i < 5; i++ {
		if !scanner.Scan() {
			break
		}
		line := scanner.Text()
		parts := strings.Fields(line)
		if len(parts) != 3 {
			continue
		}
		t1 := parts[0]
		t2 := parts[1]
		score := parts[2]
		sp := strings.Split(score, ":")
		if len(sp) != 2 {
			continue
		}
		g1, _ := strconv.Atoi(sp[0])
		g2, _ := strconv.Atoi(sp[1])

		if stats[t1] == nil {
			stats[t1] = &TeamStats{}
		}
		if stats[t2] == nil {
			stats[t2] = &TeamStats{}
		}
		counts[t1]++
		counts[t2]++

		stats[t1].scored += g1
		stats[t1].missed += g2
		stats[t2].scored += g2
		stats[t2].missed += g1

		if g1 > g2 {
			stats[t1].points += 3
		} else if g1 < g2 {
			stats[t2].points += 3
		} else {
			stats[t1].points += 1
			stats[t2].points += 1
		}
	}

	var opponent string
	for k, v := range counts {
		if v == 2 && k != "BERLAND" {
			opponent = k
		}
	}

	for diff := 1; diff <= 100; diff++ {
		for Y := 0; Y <= 100; Y++ {
			X := Y + diff

			var teams []Team
			for k, v := range stats {
				teams = append(teams, Team{
					name:   k,
					points: v.points,
					scored: v.scored,
					missed: v.missed,
				})
			}

			for i := range teams {
				if teams[i].name == "BERLAND" {
					teams[i].points += 3
					teams[i].scored += X
					teams[i].missed += Y
				} else if teams[i].name == opponent {
					teams[i].scored += Y
					teams[i].missed += X
				}
			}

			sort.Slice(teams, func(i, j int) bool {
				if teams[i].points != teams[j].points {
					return teams[i].points > teams[j].points
				}
				diffI := teams[i].scored - teams[i].missed
				diffJ := teams[j].scored - teams[j].missed
				if diffI != diffJ {
					return diffI > diffJ
				}
				if teams[i].scored != teams[j].scored {
					return teams[i].scored > teams[j].scored
				}
				return teams[i].name < teams[j].name
			})

			if teams[0].name == "BERLAND" || teams[1].name == "BERLAND" {
				fmt.Printf("%d:%d\n", X, Y)
				return
			}
		}
	}
	fmt.Println("IMPOSSIBLE")
}
```