Problem:
Score : 200 points

Problem Statement

When Mr. X is away from home, he has decided to use his smartwatch to search the best route to go back home, to participate in ABC.

You, the smartwatch, has found N routes to his home.

If Mr. X uses the i-th of these routes, he will get home in time t_i at cost c_i.

Find the smallest cost of a route that takes not longer than time T.

Constraints

All values in input are integers.

1 \leq N \leq 100

1 \leq T \leq 1000

1 \leq c_i \leq 1000

1 \leq t_i \leq 1000

The pairs (c_i, t_i) are distinct.

Input

Input is given from Standard Input in the following format:

N T
c_1 t_1
c_2 t_2
:
c_N t_N

Output

Print the smallest cost of a route that takes not longer than time T.

If there is no route that takes not longer than time T, print TLE instead.

Sample Input 1

3 70
7 60
1 80
4 50

Sample Output 1

4

The first route gets him home at cost 7.

The second route takes longer than time T = 70.

The third route gets him home at cost 4.

Thus, the cost 4 of the third route is the minimum.

Sample Input 2

4 3
1 1000
2 4
3 1000
4 500

Sample Output 2

TLE

There is no route that takes not longer than time T = 3.

Sample Input 3

5 9
25 8
5 9
4 10
1000 1000
6 1

Sample Output 3

5

Solution in C (GCC 5.4.1) (judge verdict: Accepted)

#include <stdio.h>
#include <stdlib.h>
void Quicksort_rand(int A[], int L, int R);

int main(void)
{
	int i, j, N, T, cost[110], time[110], c;

	scanf("%d %d", &N, &T);
	j = 1;
	for (i = 1; i <= N; i++) {
		scanf("%d %d", &c, &time[i]);
		if (time[i] <= T) {
			cost[j] = c;
			j++;
		}
	}

	if (j == 1) {
		printf("TLE");
		return 0;
	}

	Quicksort_rand(cost, 1, j-1);
	printf("%d", cost[1]);


	return 0;
}

void Quicksort_rand(int A[], int L, int R)/*A[L]~A[R]までソート*/
{
	if (L < R)
	{
		int r, tmp, p = L, k = L + 1;

		srand(0);
		r = rand() % (R - L + 1) + L;//pivotを選択

		//pivotを先頭に置く
		tmp = A[L];
		A[L] = A[r];
		A[r] = tmp;

		//左の翼と右の翼に分ける
		while (k <= R) {
			if (A[k] < A[L]) {
				tmp = A[k];
				A[k] = A[p + 1];
				A[p + 1] = tmp;
				p++;
			}
			k++;
		}

		//pivotを左右の翼の境目に置く
		tmp = A[L];
		A[L] = A[p];
		A[p] = tmp;

		//左右の翼で再帰
		Quicksort_rand(A, L, p - 1);
		Quicksort_rand(A, p + 1, R);
	}
	return;
}