package main

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

type Team struct {
	name string
	pts  int
	gd   int
	gf   int
}

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

	var n int
	fmt.Fscan(in, &n)

	names := make([]string, n)
	idx := make(map[string]int, n)
	for i := 0; i < n; i++ {
		fmt.Fscan(in, &names[i])
		idx[names[i]] = i
	}

	pts := make([]int, n)
	gd := make([]int, n)
	gf := make([]int, n)

	matches := n * (n - 1) / 2
	for i := 0; i < matches; i++ {
		var pair, score string
		fmt.Fscan(in, &pair, &score)

		p := strings.IndexByte(pair, '-')
		c := strings.IndexByte(score, ':')

		name1 := pair[:p]
		name2 := pair[p+1:]
		g1, _ := strconv.Atoi(score[:c])
		g2, _ := strconv.Atoi(score[c+1:])

		a := idx[name1]
		b := idx[name2]

		gf[a] += g1
		gf[b] += g2
		gd[a] += g1 - g2
		gd[b] += g2 - g1

		if g1 > g2 {
			pts[a] += 3
		} else if g1 < g2 {
			pts[b] += 3
		} else {
			pts[a]++
			pts[b]++
		}
	}

	teams := make([]Team, n)
	for i := 0; i < n; i++ {
		teams[i] = Team{
			name: names[i],
			pts:  pts[i],
			gd:   gd[i],
			gf:   gf[i],
		}
	}

	sort.Slice(teams, func(i, j int) bool {
		if teams[i].pts != teams[j].pts {
			return teams[i].pts > teams[j].pts
		}
		if teams[i].gd != teams[j].gd {
			return teams[i].gd > teams[j].gd
		}
		if teams[i].gf != teams[j].gf {
			return teams[i].gf > teams[j].gf
		}
		return teams[i].name < teams[j].name
	})

	ans := make([]string, n/2)
	for i := 0; i < n/2; i++ {
		ans[i] = teams[i].name
	}
	sort.Strings(ans)

	for _, s := range ans {
		fmt.Fprintln(out, s)
	}
}