Problem:
Sorting Tuples

Write a program which reads $n$ items and sorts them. Each item has attributes $\{value, weight, type, date, name\}$ and they are represented by $\{$ integer, integer, upper-case letter, integer, string $\}$ respectively. Sort the items based on the following priorities.

first by value (ascending)

in case of a tie, by weight (ascending)

in case of a tie, by type (ascending in lexicographic order)

in case of a tie, by date (ascending)

in case of a tie, by name (ascending in lexicographic order)

Input

The input is given in the following format.

$n$
$v_0 \; w_0 \; t_0 \; d_0 \; s_0$
$v_1 \; w_1 \; t_1 \; d_1 \; s_1$
:
$v_{n-1} \; w_{n-1} \; t_{n-1} \; d_{n-1} \; s_{n-1}$

In the first line, the number of items $n$. In the following $n$ lines, attributes of each item are given. $v_i \; w_i \; t_i \; d_i \; s_i$ represent value, weight, type, date and name of the $i$-th item respectively.

Output

Print attributes of each item in order. Print an item in a line and adjacency attributes should be separated by a single space.

Constraints

$1 \leq n \leq 100,000$

$0 \leq v_i \leq 1,000,000,000$

$0 \leq w_i \leq 1,000,000,000$

$t_i$ is a upper-case letter

$0 \leq d_i \leq 2,000,000,000,000$

$1 \leq $ size of $s_i \leq 20$

$s_i \ne s_j$ if $(i \ne j)$

Sample Input 1

5
105 24 C 1500000000000 white
100 23 C 1500000000000 blue
105 23 A 1480000000000 pink
110 25 B 1500000000000 black
110 20 A 1300000000000 gree

Sample Output 1

100 23 C 1500000000000 blue
105 23 A 1480000000000 pink
105 24 C 1500000000000 white
110 20 A 1300000000000 gree
110 25 B 1500000000000 black

Solution in Go (judge verdict: Accepted)

package main

import (
	"fmt"

	"os"
	"io"
	"bufio"
	"bytes"

	"strings"
	"strconv"
	"sort"
)

//  長い入力を読む
func ReadLongLines(times int) ([]string, error) {
	result := make([]string, times)
	reader := bufio.NewReader(os.Stdin)
	buffer := bytes.NewBuffer(make([]byte, 0))
	readBytes := int64(2)
	for i := 0; i < times; i++ {
		for {
			readBuf, isPrefix, err := reader.ReadLine()
			// fmt.Printf("Reader.Read: %d\n", len(readBuf))
			readBytes += int64(len(readBuf) + 1)
			if err != nil {
				if err == io.EOF {
					fmt.Println("EOF")
					break
				} else {
					return result, err
				}
			}
			_, err = buffer.Write(readBuf)
			if err != nil {
				return result, err
			}
			// end of line
			if !isPrefix {
				result[i] = buffer.String()
				buffer.Reset()
				// reader = bufio.NewReader(os.Stdin)
				break
			}
		}
	}
	// 先読みしてしまうようなので、戻しておく
	os.Stdin.Seek(-int64(reader.Buffered()), os.SEEK_CUR)
	return result, nil
}

// 出力 for 競プロ
type Console struct {
	writer *bufio.Writer
}
func NewConsole() Console {
	return Console{ bufio.NewWriter(os.Stdout) }
}
func (this *Console) Printf(format string, a ...interface{}) {
	fmt.Fprintf(this.writer, format, a...)
}
func (this *Console) Println(s string) {
	fmt.Fprintln(this.writer, s)
}
func (this *Console) Close() {
	this.Flush()
}
func (this Console) Flush() {
	this.writer.Flush()
}

type Unique struct {
	arr []int
	existsMap map[int]struct{}
}


type Item struct {
	value int
	weight int
	model string
	date int
	name string
}

func main() {
	con := NewConsole()
	defer con.Flush()

	// create list
	var n int
	fmt.Scanf("%d", &n)
	lines, _ := ReadLongLines(n)
	list := make([]Item, n)
	for i := range lines {
		args := strings.Split(lines[i], " ")
		value, _ := strconv.Atoi(args[0])
		weight, _ := strconv.Atoi(args[1])
		model := args[2]
		date, _ := strconv.Atoi(args[3])
		name := args[4]
		list[i] = Item{value, weight, model, date, name}
	}

	// sort
	sort.Slice(list, func(lhs, rhs int) bool {
		l := list[lhs]
		r := list[rhs]
		if l.value != r.value {
			return l.value < r.value
		}
		if l.weight != r.weight {
			return l.weight < r.weight
		}
		if l.model != r.model {
			return l.model < r.model
		}
		if l.date != r.date {
			return l.date < r.date
		}
		return l.name < r.name
	})


	// print
	for _, v := range list {
		con.Printf("%d %d %s %d %s\n", v.value, v.weight, v.model, v.date, v.name)
	}
}