package main

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

type Rule struct {
	idx int
	asc bool
}

func main() {
	scanner := bufio.NewScanner(os.Stdin)
	scanner.Buffer(make([]byte, 1024), 1<<20)

	var lines []string
	for scanner.Scan() {
		lines = append(lines, strings.TrimRight(scanner.Text(), "\r"))
	}

	if len(lines) < 2 {
		return
	}

	cols := strings.Fields(lines[0])
	colIndex := make(map[string]int, len(cols))
	for i, col := range cols {
		colIndex[col] = i
	}

	var rules []Rule
	if strings.TrimSpace(lines[1]) != "" {
		parts := strings.Split(lines[1], ", ")
		rules = make([]Rule, 0, len(parts))
		for _, part := range parts {
			f := strings.Fields(part)
			if len(f) == 2 {
				rules = append(rules, Rule{
					idx: colIndex[f[0]],
					asc: f[1] == "ASC",
				})
			}
		}
	}

	var rows [][]string
	for _, line := range lines[2:] {
		if strings.TrimSpace(line) == "" {
			continue
		}
		rows = append(rows, strings.Fields(line))
	}

	sort.SliceStable(rows, func(i, j int) bool {
		a, b := rows[i], rows[j]
		for _, r := range rules {
			if a[r.idx] == b[r.idx] {
				continue
			}
			if r.asc {
				return a[r.idx] < b[r.idx]
			}
			return a[r.idx] > b[r.idx]
		}
		return false
	})

	out := bufio.NewWriter(os.Stdout)
	for i, row := range rows {
		if i > 0 {
			out.WriteByte('\n')
		}
		out.WriteString(strings.Join(row, " "))
	}
	out.Flush()
}