```go
package main

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

type Team struct {
	Name   string
	Points int
	Scored int
	Missed int
}

func main() {
	scanner := bufio.NewScanner(os.Stdin)
	scanner.Split(bufio.ScanWords)

	if !scanner.Scan() {
		return
	}
	n, _ := strconv.Atoi(scanner.Text())

	teams := make([]*Team, n)
	teamMap := make(map[string]*Team)

	for i := 0; i < n; i++ {
		scanner.Scan()
		name := scanner.Text()
		t := &Team{Name: name}
		teams[i] = t
		teamMap[name] = t
	}

	numMatches := n * (n - 1) / 2
	for i := 0; i < numMatches; i++ {
		scanner.Scan()
		namesToken := scanner.Text()
		scanner.Scan()
		scoresToken := scanner.Text()

		dashIndex := strings.Index(namesToken, "-")
		name1 := namesToken[:dashIndex]
		name2 := namesToken[dashIndex+1:]

		colonIndex := strings.Index(scoresToken, ":")
		score1, _ := strconv.Atoi(scoresToken[:colonIndex])
		score2, _ := strconv.Atoi(scoresToken[colonIndex+1:])

		t1 := teamMap[name1]
		t2 := teamMap[name2]

		t1.Scored += score1
		t1.Missed += score2
		t2.Scored += score2
		t2.Missed += score1

		if score1 > score2 {
			t1.Points += 3
		} else if score2 > score1 {
			t2.Points += 3
		} else {
			t1.Points += 1
			t2.Points += 1
		}
	}

	sort.Slice(teams, func(i, j int) bool {
		if teams[i].Points != teams[j].Points {
			return teams[i].Points > teams[j].Points
		}
		diff1 := teams[i].Scored - teams[i].Missed
		diff2 := teams[j].Scored - teams[j].Missed
		if diff1 != diff2 {
			return diff1 > diff2
		}
		return teams[i].Scored > teams[j].Scored
	})

	result := make([]string, n/2)
	for i := 0; i < n/2; i++ {
		result[i] = teams[i].Name
	}

	sort.Strings(result)

	for _, name := range result {
		fmt.Println(name)
	}
}
```