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: Time Limit Exceeded)

#include <stdio.h>
#include <stdlib.h>
void quicksort(int s[], int t[], int i, int j);
int find_pivot(int s[], int i, int j);
int partition(int s[], int t[], int i, int j, int pivot);

int main(void)
{
	int n, T, err, i, s;
	int *c, *t;
	err = scanf("%d%d", &n, &T);
	if (err!=2 || (n<1||n>100) || (T<1||T>1000)) exit(1);
	c = (int *)malloc(sizeof(int)*n);
	t = (int *)malloc(sizeof(int)*n);
	for (int i = 0; i < n; ++i)
	{
		err = scanf("%d%d", &c[i], &t[i]);
		if (err!=2 || (c[i]<1||c[i]>1000) || (t[i]<1||t[i]>1000)) exit(1);
	}

	quicksort(c, t, 0, n-1);
	i == 0;
	while ((t[i] > T) && (i < n-1)) i++;
	if (t[i] <= T)
	{
		printf("%d\n", c[i]);
	}else
	{
		printf("TLE\n");
	}
	return 0;
}

void quicksort(int s[], int t[], int i, int j)
{
	int pivot, p, k;
	if (i >= j) return;
	pivot = find_pivot(s, i, j);
	p = partition(s, t, i, j, pivot);

	quicksort(s, t, i, p-1);
	quicksort(s, t, p, j);
	return;
}

int find_pivot(int s[], int i, int j)
{
	int pivot1, k;

	for (int k = i; k < j; ++k)
	{
		if (s[k]<s[k+1])
		{
			pivot1 = s[k+1];
			return pivot1;
		}else if (s[k]>s[k+1])
		{
			pivot1 = s[k];
			return pivot1;
		}
	}
	return s[j];
}

int partition(int s[], int t[], int i, int j, int pivot)
{
	int l, r, flag, swap1, swap2;
	l = i;
	r = j;
	for (;;)
	{
		while (s[l] < pivot) {l++;}
		while (s[r] > pivot) {r--;}
		if (l == r) return l;
		if (s[l] != s[r])
		{
			swap1 = s[l];
			s[l] = s[r];
			s[r] = swap1;
			swap2 = t[l];
			t[l] = t[r];
			t[r] = swap2;
		}else
		{	
			flag = 0;
			for (int k = 1; k <= l-r; ++k)
			{
				if (s[r] != s[r+k]) flag = 1;
			}
			if (flag == 0) return l;
			swap1 = s[l];
			s[l] = s[l+1];
			s[l+1] = swap1;
			swap2 = t[l];
			t[l] = t[l+1];
			t[l+1] = swap2;
			l--;
		}
	}
}