Problem:
体育祭Sport Meet

秋の体育祭が行われます。種目は徒競走、ボール運び、障害物競走、リレーの4種目です。参加チームは n チームで、この4種目の合計タイムが最も小さいチームが「優勝」、次に小さいチームが「準優勝」、そして、最下位より2番目のチームを「ブービー賞」として表彰したいと思います。

各チームの成績を入力として、「優勝」、「準優勝」、「ブービー賞」のチームを出力するプログラムを作成してください。
ただし、チームにはそれぞれ 1 から n のチーム番号が割り当てられています。

Input

複数のデータセットの並びが入力として与えられます。入力の終わりはゼロひとつの行で示されます。
各データセットは以下の形式で与えられます。

n
record1
record2
:
recordn

１行目に対象となるチームの数 n (4 ≤ n ≤ 100000)、続く n 行に i 番目のチームの情報が与えられます。各チームの情報は以下の形式で与えられます。

id m1 s1 m2 s2 m3 s3 m4 s4

id (1 ≤ id ≤ n)はチーム番号、m1, s1 はそれぞれ徒競走のタイムの分と秒、m2, s2 はそれぞれボール運びのタイムの分と秒、m3, s3 はそれぞれ障害物競走のタイムの分と秒、m4, s4 はそれぞれリレーのタイムの分と秒を表します。分と秒はともに0 以上 59 以下の整数です。また、合計タイムが複数のチームで同じになるような入力はないものとします。

Output

入力データセットごとに以下の形式でチーム番号を出力します。

1 行目 優勝のチーム番号

2 行目 準優勝のチーム番号

3 行目 ブービー賞のチーム番号

Sample Input

8
34001 3 20 3 8 6 27 2 25
20941 3 5 2 41 7 19 2 42
90585 4 8 3 12 6 46 2 34
92201 3 28 2 47 6 37 2 58
10001 3 50 2 42 7 12 2 54
63812 4 11 3 11 6 53 2 22
54092 3 33 2 54 6 18 2 19
25012 3 44 2 58 6 45 2 46
4
1 3 23 1 23 1 34 4 44
2 5 12 2 12 3 41 2 29
3 5 24 1 24 2 0 3 35
4 4 49 2 22 4 41 4 23
0

Output for the Sample Input

54092
34001
10001
1
3
2

Solution in C# (judge verdict: Accepted)

using System;
using System.Collections.Generic;
using System.IO;
using System.Linq;
using System.Net;
//using static System.Console;
//using static System.Math;
//using static CS_Contest.Utils;
//using System.Numerics;
using System.Linq.Expressions;
//using Nakov.IO;
//using static Nakov.IO.Cin;

//using static CS_Contest.Library;

namespace CS_Contest {
	using Li = List<int>;
	using LLi = List<List<int>>;
	using Ll = List<long>;

	internal class Program {
		private static void Main(string[] args) {
			var sw = new StreamWriter(Console.OpenStandardOutput()) { AutoFlush = false };
			Console.SetOut(sw);
			new Calc().Solve();
			Console.Out.Flush();
		}


		public class Calc {
			public class Vector2<T1, T2> {
				public T1 Item1;
				public T2 Item2;
				public Vector2(T1 item1,T2 item2) {
					Item1 = item1;
					Item2 = item2;
				}
			}
			public void Solve() {
				int n;
				while ((n = int.Parse(Console.ReadLine())) != 0) {
					var Dic = new List<Vector2< int, int>>();
					for (int i = 0; i < n; i++) {
						var line = Console.ReadLine().Split().Select(int.Parse).ToList();
						Dic.Add(new Vector2<int, int>(line[1] * 60 + line[2] + line[3] * 60 + line[4] + line[5] * 60 + line[6] + line[7] * 60 + line[8], line[0]));
					}
					Dic = Dic.OrderBy(x => x.Item1).ToList();
					
					Console.WriteLine(Dic.First().Item2);
					Console.WriteLine(Dic[1].Item2);
					Console.WriteLine(Dic[n-2].Item2);
				}

				return;
			}


		}
	}

	//public static class Utils {
	//	public static long ModValue = (long)1e9 + 7;
	//	public static long INF = long.MaxValue;

	//	public static long Mod(long x) => x % ModValue;

	//	public static long ModPow(long x, long n) {
	//		long tmp = 1; while (n != 0) { if (n % 2 == 1) { tmp = Mod(tmp * x); } x = Mod(x * x); n /= 2; }
	//		return tmp;
	//	}

	//	public static long DivMod(long x, long y) => Mod(x * ModPow(y, (long)(1e9 + 5)));

	//	public static void WL(this object obj) => WriteLine(obj);

	//	public static void WL(this string obj) => WriteLine(obj);

	//	public static void WL<T>(this IEnumerable<T> list) => list.ToList().ForEach(x => x.WL());

	//	public static Li ReadInt() => ReadLine().Split().Select(int.Parse).ToList();

	//	public static string StringJoin<T>(this IEnumerable<T> l, string separator = "") => string.Join(separator, l);

	//	public static long GCD(long m, long n) {
	//		long tmp;
	//		if (m < n) { tmp = n; n = m; m = tmp; }
	//		while (m % n != 0) {
	//			tmp = n;
	//			n = m % n;
	//			m = tmp;
	//		}
	//		return n;
	//	}

	//	public static long LCM(long m, long n) => m * (n / GCD(m, n));

	//	public static void REP(int n, Action<int> act) {
	//		for (var i = 0; i < n; i++) {
	//			act(i);
	//		}
	//	}


	//	public static int ManhattanDistance(int x1, int y1, int x2, int y2) => Abs(x2 - x1) + Abs(y2 - y1);

	//	public struct IndexT<T> {
	//		public T Value { get; set; }
	//		public int Index { get; set; }

	//		public IndexT(T v, int i) {
	//			Value = v; Index = i;
	//		}
	//		public override string ToString() {
	//			return Value + " " + Index;
	//		}
	//	}

	//	public static IEnumerable<IndexT<T>> ToIndexEnumerable<T>(this IEnumerable<T> list) => list.Select((x, i) => new IndexT<T>(x, i));

	//	public static Queue<T> ToQueue<T>(this IEnumerable<T> iEnumerable) {
	//		var rt = new Queue<T>();
	//		foreach (var item in iEnumerable) {
	//			rt.Enqueue(item);
	//		}
	//		return rt;
	//	}

	//	public static IndexT<T> IndexOf<T>(this IEnumerable<T> ie, Func<IndexT<T>, IndexT<T>, IndexT<T>> func) =>
	//		ie.ToIndexEnumerable().Aggregate(func);


	//	public static T[] Range<T>(int range, Func<int, T> func) {
	//		var rt = new T[range];
	//		for (var i = 0; i < range; i++) rt[i] = func(i);
	//		return rt;
	//	}
	//	public static void Swap<T>(ref T x, ref T y) {
	//		var tmp = x;
	//		x = y;
	//		y = tmp;
	//	}


	//	public static Dictionary<TKey, int> CountUp<TKey>(this IEnumerable<TKey> l) {
	//		var dic = new Dictionary<TKey, int>();
	//		foreach (var item in l) {
	//			if (dic.ContainsKey(item)) dic[item]++;
	//			else dic.Add(item, 1);
	//		}
	//		return dic;
	//	}


	//	public static int Count<T>(this IEnumerable<T> l, T target) => l.Count(x => x.Equals(target));

	//	public static int UpperBound<T>(this IEnumerable<T> list, T target) where T : IComparable {
	//		var idx = list.ToList().BinarySearch(target);
	//		idx = idx < 0 ? ~idx : (idx + 1);
	//		return Min(idx, list.Count());
	//	}

	//	public static int LowerBound<T>(this IEnumerable<T> list, T target) where T : IComparable {
	//		var idx = list.ToList().BinarySearch(target);
	//		idx = idx < 0 ? ~idx : idx;
	//		return Max(0, idx - 1);
	//	}

	//}

}
//namespace Nakov.IO {
//	using System;
//	using System.Text;
//	using System.Globalization;

//	public static class Cin {
//		public static string NextToken() {
//			StringBuilder tokenChars = new StringBuilder();
//			bool tokenFinished = false;
//			bool skipWhiteSpaceMode = true;
//			while (!tokenFinished) {
//				int nextChar = Console.Read();
//				if (nextChar == -1) {
//					tokenFinished = true;
//				} else {
//					char ch = (char)nextChar;
//					if (char.IsWhiteSpace(ch)) {
//						if (!skipWhiteSpaceMode) {
//							tokenFinished = true;
//							if (ch == '\r' && (Environment.NewLine == "\r\n")) {
//								Console.Read();
//							}
//						}
//					} else {
//						skipWhiteSpaceMode = false;
//						tokenChars.Append(ch);
//					}
//				}
//			}

//			string token = tokenChars.ToString();
//			return token;
//		}

//		public static int NextInt() {
//			string token = Cin.NextToken();
//			return int.Parse(token);
//		}
//		public static long NextLong() {
//			string token = Cin.NextToken();
//			return long.Parse(token);
//		}
//		public static double NextDouble(bool acceptAnyDecimalSeparator = true) {
//			string token = Cin.NextToken();
//			if (acceptAnyDecimalSeparator) {
//				token = token.Replace(',', '.');
//				double result = double.Parse(token, CultureInfo.InvariantCulture);
//				return result;
//			} else {
//				double result = double.Parse(token);
//				return result;
//			}
//		}
//		public static decimal NextDecimal(bool acceptAnyDecimalSeparator = true) {
//			string token = Cin.NextToken();
//			if (acceptAnyDecimalSeparator) {
//				token = token.Replace(',', '.');
//				decimal result = decimal.Parse(token, CultureInfo.InvariantCulture);
//				return result;
//			} else {
//				decimal result = decimal.Parse(token);
//				return result;
//			}
//		}

//	}
//}