jiahuimbzuai/CoQuIR huggingface dataset:
//  [java]
	public static void main(String[] args) {
		// TODO 自動生成されたメソッド・スタブ
		Scanner sc1 = new Scanner(System.in);
		String line1 = sc1.nextLine();

		String[] inputText = line1.split(" ");

		int a = Integer.parseInt(inputText[0]) + Integer.parseInt(inputText[1]);
		int b = Integer.parseInt(inputText[2]);
		int c = a - b;

		if (c < 0) {
			System.out.print("No");
		} else {
			System.out.print("Yes");
		}
	}
//  [java]
import java.util.*; import java.io.*; import java.math.*;
public class Main{
	//Don't have to see. start------------------------------------------
	static class InputIterator{
		ArrayList<String> inputLine = new ArrayList<String>(1024);
		int index = 0; int max; String read;
		InputIterator(){
			BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
			try{
				while((read = br.readLine()) != null){
					inputLine.add(read);
				}
			}catch(IOException e){}
			max = inputLine.size();
		}
		boolean hasNext(){return (index < max);}
		String next(){
			if(hasNext()){
				return inputLine.get(index++);
			}else{
				throw new IndexOutOfBoundsException("There is no more input");
			}
		}
	}
	static HashMap<Integer, String> CONVSTR = new HashMap<Integer, String>();
	static InputIterator ii = new InputIterator();//This class cannot be used in reactive problem.
	static PrintWriter out = new PrintWriter(System.out);
	static void flush(){out.flush();}
	static void myout(Object t){out.println(t);}
	static void myerr(Object t){System.err.print("debug:");System.err.println(t);}
	static String next(){return ii.next();}
	static boolean hasNext(){return ii.hasNext();}
	static int nextInt(){return Integer.parseInt(next());}
	static long nextLong(){return Long.parseLong(next());}
	static double nextDouble(){return Double.parseDouble(next());}
	static ArrayList<String> nextStrArray(){return myconv(next(), 8);}
	static ArrayList<String> nextCharArray(){return myconv(next(), 0);}
	static ArrayList<Integer> nextIntArray(){
		ArrayList<String> input = nextStrArray(); ArrayList<Integer> ret = new ArrayList<Integer>(input.size());
		for(int i = 0; i < input.size(); i++){
			ret.add(Integer.parseInt(input.get(i)));
		}
		return ret;
	}
	static ArrayList<Long> nextLongArray(){
		ArrayList<String> input = nextStrArray(); ArrayList<Long> ret = new ArrayList<Long>(input.size());
		for(int i = 0; i < input.size(); i++){
			ret.add(Long.parseLong(input.get(i)));
		}
		return ret;
	}
	static String myconv(Object list, int no){//only join
		String joinString = CONVSTR.get(no);
		if(list instanceof String[]){
			return String.join(joinString, (String[])list);
		}else if(list instanceof ArrayList){
			return String.join(joinString, (ArrayList)list);
		}else{
			throw new ClassCastException("Don't join");
		}
	}
	static ArrayList<String> myconv(String str, int no){//only split
		String splitString = CONVSTR.get(no);
		return new ArrayList<String>(Arrays.asList(str.split(splitString)));
	}
	public static void main(String[] args){
		CONVSTR.put(8, " "); CONVSTR.put(9, "\n"); CONVSTR.put(0, "");
		solve();flush();
	}
	//Don't have to see. end------------------------------------------
	static void solve(){//Here is the main function
      ArrayList<Integer> one = nextIntArray();
      int A = one.get(0);
      int B = one.get(1);
      int C = one.get(2);
      myout((A * 2 + B * 2 >= C) ? "Yes" : "No");
	}
	//Method addition frame start

  
  
	//Method addition frame end
}
//  [cpp]
#include <cstdio>

using namespace std;

int main()
{
    int a, b, c;
    scanf("%d %d %d", &a, &b, &c);

    if (a + b >= c)
        printf("Yes");
    else
        printf("No");

    return 0;
}
//  [cpp]
#include <cstdio>
int main() {
    int a,b,c;
    scanf("%d%d%d",&a,&b,&c);
    printf("%s",a+b>=c ? "Yes" : "No");
    return 0;
}
//  [cpp]
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <math.h>

int main()
{	
	int a,b,c;
	
	while (scanf("%d%d%d",&a,&b,&c)==3)
	{
		if (a+b>=c)
		{
			printf("Yes");
		}
		
		else
		{
			printf("No");
		}
	}
	
	return 0;
 }
//  [cpp]
#include <bits/stdc++.h>
#define rep(i,n) for(int i=0;i<(n);i++)
using namespace std;
using ll = long long;
int main(void){
   int A,B,C;
   cin>>A>>B>>C;
   
   if(A+B>=C){
       cout<<"Yes"<<endl;
   }
   else {
       cout<<"NO"<<endl;
   }
   
   
  
}
//  [cpp]
#include <bits/stdc++.h>

using namespace std;

int main()
{
    int a, b, c;
  	cin >> a >> b >> c;
  	if (a + b > c)
      	cout << "Yes";
  	else
      	cout << "No";
    return 0;
}
//  [cpp]
#include<iostream>
using namespace std;
int main() {
	int a, b, c; cin >> a >> b >> c;
	if (a + b <= c)cout << "Yes" << endl;
	else cout << "No" << endl;
	return 0;
}
//  [c]
#include<stdio.h>
int main()
{
int a,b,c;
  scanf("%d %d %d",&a,&b,&c);
if(a+b>=c) printf("Yes");
  else printf("No");

return 0;
}
//  [c]
#include <stdio.h>


int main(int argc, char **argv)
{
  int a,b,c;

  scanf("%d %d %d",&a,&b,&c);

  if(a + b >= c)
  {
    printf("Yes\n");
  }

  else
    printf("No\n");

  return 0;
}
//  [c]
#include <stdio.h>

int main(void) {
  int A, B, C;
  scanf("%d %d %d", &A, &B, &C);

  if (A + B >= C) {
    printf("Yes\n");
  } else {
    printf("No\n");
  }

  return 0;
}
//  [c]
#include <stdio.h>

int main(){
  int a, b, c;
  scanf("%d %d %d", &a, &b, &c);
  if(a + b < c) printf("Yes\n");
  else printf("No\n");
  return 0;
}
//  [c]
#include <stdio.h>

int main()
{
  int a, b, c;
  
  scanf("%d %d %d",&a,&b,&c);
  
  if(a+b>c)
    printf("Yes\n");
  else
    printf("No\n");
  
  return 0;
}
//  [c]
#include <stdio.h>

int main(void)
{
	int a,b,c;
	scanf("%d%d%d",&a,&b,&c);
	if(a+b > c) printf("Yes\n");
	else printf("No\n");
	return 0;
}
//  [javascript]
function main(input) {
    var a = input[0].split(" ")[0]-0;
    var b = input[0].split(" ")[1]-0;
    var c = input[0].split(" ")[2]-0;
    
    console.log(a+b>=c?"Yes":"No");
}
main(require('fs').readFileSync('/dev/stdin', 'utf8').trim().split("\n"))
//  [javascript]
"use strict"

const Main =(input)=>{
const Array=input.split(" ")
const A=parseInt(Array[0],10)
const B=parseInt(Array[1],10)
const C=parseInt(Array[2],10)
const Answer= (A+B)>=C ?"Yes":"No"
console.log(Answer)
}




Main(require('fs').readFileSync('/dev/stdin', 'utf8'));
//  [javascript]
l = require('fs').readFileSync('/dev/stdin', 'utf8').split('\n')[0].split(' ')
A = l[0] * 1
B = l[1] * 1
X = l[2] * 1
console.log(A + B >= X ? 'Yes' : 'No')
//  [javascript]
function main(input) {
  const args = input.split('\n');
  const N = parseInt(args[0], 10);
  const M = parseInt(args[N + 1], 10);
  data = {};
  let blues = [];
  let reds = [];
  let ans;
  
  for (let i = 1; i <= N; i++) {
    blues.push(args[i]);
  }
  
  for (let i = (N + 2); i <= (N + M + 1) ; i++) {
  	reds.push(args[i]);
  }
  
  for (let i = 0; i < blues.length; i++) {
    key = blues[i];
    data[key] = data[key] ? data[key] + 1 : 1;
  }
  
  for (let i = 0; i < reds.length; i++) {
  	key = reds[i];
    data[key] = data[key] ? data[key] - 1 : -1;
  }
  
  for (key in data) {
    if (!ans || data[key] > ans) { 
      ans = data[key];
    }
  }
  
  if (ans < 0) {
    console.log(0);
  } else {
    console.log(ans);
  }
}

main(require('fs').readFileSync('/dev/stdin', 'utf8'));
//  [javascript]
function main(input) {
  input = input.trim();
  const a = input.split(" ").map(Number);
 
  console.log((a[0]+a[1]>=a[2])?"YES":"NO");
 
}
main(require('fs').readFileSync('/dev/stdin', 'utf8'));
//  [javascript]
function main(input) {
  input = input.trim();
  const a = input.split(" ").map(Number);
 
  console.log((a[0]+a[1]>=a[2]) ? "YES":"NO");
 
}
main(require('fs').readFileSync('/dev/stdin', 'utf8'));
//  [go]
package main

import (
	. "fmt"
)

// func init() { Println("----------------------------------------") }

func main() {
    var a, b, c int
    Scanf("%d %d %d", &a, &b, &c)
    if a + b >= c {
        Println("Yes")
    } else {
        Println("No")
    }
}
//  [go]
package main

import (
	"fmt"
)

func main() {
	var a, b, c int
	fmt.Scan(&a, &b, &c)

	if a+b >= c {
		fmt.Println("Yes")
	} else {
		fmt.Println("No")
	}
}
//  [go]
package main

import "fmt"

func main() {
	var a, b, c int
	fmt.Scan(&a, &b, &c)
	if a+b >= c {
		fmt.Println("Yes")
	} else {
		fmt.Println("No")
	}
}
//  [go]
package main

import "fmt"

func main() {
	var a, b, c int
	fmt.Scan(&a, &b, &c)

	if 2*a + 2*b >= c {
		fmt.Println("Yes")
	}else{
		fmt.Println("No")
	}
}
//  [go]
#include <iostream>
#include <string.h>
using namespace std;

int main(int args, char *argv[])
{
    int a, b, c;
    cin >> a;
    cin >> b;
    cin >> c;

    if (a + b >= c)
    {
        cout << "Yes" << endl;
    }
    else
    {
        cout << "No" << endl;
    }
}
//  [go]
package main

import "fmt"

func main() {
	var a, b, c int
	fmt.Scan(&a, &b, &c)
	if a+b > c {
		fmt.Println("Yes")
	} else {
		fmt.Println("No")
	}
}
//  [ruby]
A,B,C = gets.split.map(&:to_i)
puts A + B >= C ? 'Yes': 'No'
//  [ruby]
a, b, c = gets.chomp.split(" ").map(&:to_i)
puts a+b >= c ? "Yes" : "No"
//  [ruby]
A,B,C = gets.chomp.split.map {|n| n.to_i}
puts (if C <= A+B then
    'Yes'
else
    'No'
end)
//  [ruby]
a, b, c = gets.split.map &:to_i
puts c - a - b > 0 ? :Yes: :No
//  [ruby]
ary = []
n = gets.to_i
blue = n.times.map{gets.chomp}.group_by(&:itself).map{|k,v|[k,v.count]}.to_h
m = gets.to_i
red = m.times.map{gets.chomp}.group_by(&:itself).map{|k,v|[k,v.count]}.to_h
blue.each_key{|k|red.include?(k) ? ary<<blue[k]-red[k] : ary<<blue[k]}
puts ary.size==1 && ary.first<=0 ? 0 : ary.max
//  [ruby]
results = Hash.new
N = gets.to_i
N.times do
  blue = gets.strip
  results[blue].nil? ? results[blue] = 1 : results[blue] += 1  
end
M = gets.to_i
M.times do
  red = gets.strip
  results[red].nil? ? results[red] = 1 : results[red] += 1  
end
answer = results.max_by { |k, v| v }
puts answer[1] < 0 ? 0 : answer[1]
//  [rust]
use std::io;

fn procon_read<T: std::str::FromStr>() ->  Vec<T> {
	let mut buf = String::new();
	io::stdin().read_line(&mut buf).expect("");
	let iter = buf.split_whitespace();
	let mut v: Vec<T> = Vec::new();
	for i in iter {
		v.push(i.parse().ok().unwrap());
	}
	v
}

fn main() {
	let v:Vec<i32> = procon_read();
	let a = v[0];
	let b = v[1];
	let c = v[2];
	if a+b < c {
		println!("No");
	}else{
		println!("Yes");
	}
}
//  [rust]
use std::io;
use std::str::FromStr;


fn main() {
    let stdin = io::stdin();
    let mut buf = String::new();
    stdin.read_line(&mut buf).ok();
    let mut it = buf.split_whitespace().map(|n| usize::from_str(n).unwrap());
    let (a, b, c) = (it.next().unwrap(), it.next().unwrap(), it.next().unwrap());
    if a + b >= c {
        println!("Yes");
    } else {
        println!("No");
    }
}
//  [rust]
use std::io::*;
use std::str::FromStr;
 
/* 
The read function reads a string according to each one. 
*/
fn read<T: FromStr>() -> T {
    let stdin = stdin();
    let stdin = stdin.lock();
    let token: String = stdin
        .bytes()
        .map(|c| c.expect("failed to read char") as char) 
        .skip_while(|c| c.is_whitespace())
        .take_while(|c| !c.is_whitespace())
        .collect();
    token.parse().ok().expect("failed to parse token")
}


//main function
fn main() {
    let a:i64 = read();
    let b:i64 = read();
    let c:i64 = read();
    if a+b>=c{
	println!("Yes");
    }else{
	println!("No");
    }
}
//  [rust]

use std::io::*;
use std::str::FromStr;

pub fn read<T: FromStr>() -> T {
  let stdin = stdin();
  let stdin = stdin.lock();
  let token: String = stdin
    .bytes()
    .map(|c| c.expect("failed to read char") as char)
    .skip_while(|c| c.is_whitespace())
    .take_while(|c| !c.is_whitespace())
    .collect();
  token.parse().ok().expect("failed to parse token")
}

use std::cmp::{max, min};
use std::collections::HashMap;

fn main() {
  let a = read::<i64>();
  let b = read::<i64>();
  let c = read::<i64>();
  let mut ans = "No";
  if c < a + b {
    ans = "Yes";
  }

  println!("{}", ans);
}
//  [rust]
use std::io::prelude::*;

fn input<T>() -> T
where
    T: std::str::FromStr,
{
    let stdin = std::io::stdin();
    let token: String = stdin
        .lock()
        .bytes()
        .map(|c| c.unwrap() as char)
        .skip_while(|c| c.is_whitespace())
        .take_while(|c| !c.is_whitespace())
        .collect();
    token.parse().ok().unwrap()
}

fn main() {
    let a: i64 = input();
    let b: i64 = input();
    let c: i64 = input();
    println!("{}", if a + b <= c { "Yes" } else { "No" });
}
//  [swift]
let i=readLine()!.characters.split(" ").map{Int(String($0))!};print(i[0]+i[1]<i[2] ?"No":"Yes")
//  [swift]
import Foundation
 
let input_line: String = readLine()!
let split: [String] = input_line.components(separatedBy: " ") //ブランクで区切られている場合
 
var A = Int(split[0])!
//String -> Intの型変換はnilが返る可能性があるので、ラップされたOptional<Int>型が返るので強制アンラップ
var B = Int(split[1])!
var C = Int(split[2])!

if (A+B >= C){
    print("Yes")
}else{
    print("No")
}
//  [swift]
//
//  main.swift
//
//  Created by sun-yryr
//  Copyright © 2019 sun-yryr. All rights reserved.
//

import Foundation

prefix operator *
prefix func * <T> (a: [T]) -> (T, T) {return (a[0], a[1])}
prefix func * <T> (a: [T]) -> (T, T, T) {return (a[0], a[1], a[2])}


func readInt(separator s: Character = " ") -> [Int] {return readLine()!.split(separator: s).map({Int($0)!})}
func readDouble(separator s: Character = " ") -> [Double] {return readLine()!.split(separator: s).map({Double($0)!})}
func readElement(separator s: Character = " ") -> [String] {return readLine()!.split(separator: s).map({String($0)})}

extension String {
    func at(_ i: Int) -> Character {
        precondition(0 <= i && i < self.count)
        return self[self.index(self.startIndex, offsetBy: i)]
    }
}

func main() {
    let (A, B, C) = *readInt()
    if (C <= (A+B)) {
        print("Yes")
    } else {
        print("No")
    }
}
main()
//  [swift]
print("YES")
//  [swift]
//
//  main.swift
//
//  Created by sun-yryr
//  Copyright © 2019 sun-yryr. All rights reserved.
//

import Foundation

prefix operator *
prefix func * <T> (a: [T]) -> (T, T) {return (a[0], a[1])}
prefix func * <T> (a: [T]) -> (T, T, T) {return (a[0], a[1], a[2])}


func readInt(separator s: Character = " ") -> [Int] {return readLine()!.split(separator: s).map({Int($0)!})}
func readDouble(separator s: Character = " ") -> [Double] {return readLine()!.split(separator: s).map({Double($0)!})}
func readElement(separator s: Character = " ") -> [String] {return readLine()!.split(separator: s).map({String($0)})}

extension String {
    func at(_ i: Int) -> Character {
        precondition(0 <= i && i < self.count)
        return self[self.index(self.startIndex, offsetBy: i)]
    }
}

func main() {
    let (A, B, C) = *readInt()
    if (C <= (A+B)) {
        print("YES")
    } else {
        print("NO")
    }
}
main()
//  [typescript]
import * as fs from 'fs'
const [input] = fs.readFileSync('/dev/stdin', 'utf8').split(/\r?\n/)
const [a, b, c] = input.split(' ').map(v => parseInt(v))

console.log(a + b >= c ? 'Yes' : 'No')
//  [typescript]
const input=require('fs').readFileSync('/dev/stdin', 'utf8').split(/[\s]/);const nin=()=>{const r = input[0];input.shift();return Number(r)};const nrin=(n)=>{const a:number[]=[];rep(n,()=>a.push(nin()));return a};const sin=()=>{const r = input[0];input.shift();return String(r)};const out=(...a)=>{console.log(...a)};const floor=(a)=>{return Math.floor(a)};const abs=(a)=>{return Math.abs(a)};const min=(...a)=>{return Math.min(...a)};const max=(...a)=>{return Math.max(...a)};const rep=(n, callback)=>{for(let i = 0;i < n; i++){callback()}};const strrep=(s, i, v)=>{return s.slice(0, i)+v+s.slice(i+1);};const permutation=({result=[],pre=[],post,n=post.length})=>{if(n>0){post.forEach((_,i)=>{const rest=[...post];const elem=rest.splice(i, 1);permutation({result, pre: [...pre,...elem],post:rest,n:n-1})})}else{result.push(pre)}return result};const sw=(s,a:any[],op:'=='|'>='|'>'|'<='|'<'='==')=>{for(let i=0;i<a.length;i+=2){if(op==='=='){if(s==a[i])return a[i+1]}else if(op==='>='){if(s>=a[i])return a[i+1]}else if(op==='<='){if(s<=a[i])return a[i+1]}else if(op==='>'){if(s>a[i])return a[i+1]}else if(op==='<'){if(s<a[i])return a[i+1]}}return a[a.length-1];};const or=(a,...b)=>{for(let i=0;i<b.length;i++)if(a==b[i])return true;return false};const maxindex=(...a)=>{return a.indexOf(Math.max.apply(null,a))};const asc=(ar:number[])=>{return ar.sort((a,b)=>{return a-b})};const desc=(ar:number[])=>{return ar.sort((a,b)=>{return b-a})};const ceil=a=>{return Math.ceil(a)};const srin=s=>{const a:string[]=[];rep(s,()=>a.push(sin()));return a};let ssinteger=-1;const ssin=()=>{ssinteger++;return input[0][ssinteger]};
const main = ()=>{
  out(nin()+nin()>=nin()?'Yes':'No')
}
main()
//  [typescript]
const stdin = require('fs').readFileSync('/dev/stdin', 'utf8')

const [a, b, c] = stdin.split('\n')[0].split(' ').map(Number)

const res = a+b >= c ? 'Yes' : 'No'

console.log(res)
//  [typescript]
declare var process: any;
process.stdin.resume();
process.stdin.setEncoding("utf8");
process.stdin.on("data", function(chunk: any) {
  var lines = chunk
    .toString()
    .split("\n")[0]
    .split(" ");
  console.log(lines[0]);
  console.log(lines[1]);
  console.log(lines[2]);
  if (parseInt(lines[0]) + parseInt(lines[1]) >= parseInt(lines[2])) {
    console.log("Yes");
  } else {
    console.log("No");
  }
});
//  [typescript]
declare var process: any;

function Main(input: string[]) {
  if (parseInt(input[4]) <= parseInt(input[2]) + parseInt(input[3])) {
    console.log("Yes");
  } else {
    console.log("No");
  }
}
Main(process.argv);
//  [typescript]
declare var process: any;

if (
  parseInt(process.argv[4]) <=
  parseInt(process.argv[2]) + parseInt(process.argv[3])
) {
  console.log("Yes");
} else {
  console.log("No");
}
//  [python]
n, T = map(int, input().split())
tm = 1001
for i in range(n):
    c, t = map(int, input().split())
    if t <= T:
        tm = min(tm, c) 
if tm == 1001:
    print("TLE")
else:
    print(tm)
//  [python]
Tmp = []
Tmp = input().rstrip().split(' ')
 
nN = int(Tmp[0])
nT = int(Tmp[1])
 
nCost = 1001
nAns = 0
 
for i in range(nN):
  Tmp = input().rstrip().split(' ')
 
  nTmpCost = int(Tmp[0])
  nTmpT = int(Tmp[1])
  
  if nTmpT <= nT and nTmpCost < nCost:
    nCost = nTmpCost
    nAns = i+1

if nAns == 0:
  print('TLE')
else:
  print(nCost)
//  [python]
N, T = map(int, input().split())
ans = []
for _ in range(N):
    c, t = map(int, input().split())
    if t <= T:
        ans.append(c)
    else:
        ans.append(999999)
ans = sorted(ans)
if ans[0] == 999999:
    print("TLE")
else:
    print(ans[0])
//  [python]
ma = lambda :map(int,input().split())
lma = lambda :list(map(int,input().split()))
tma = lambda :tuple(map(int,input().split()))
ni = lambda:int(input())
yn = lambda fl:print("Yes") if fl else print("No")
import collections
import math
import itertools
import heapq as hq
import sys
n,T = ma()
ans=10**15
for i in range(n):
    c,t=ma()
    if t<T:
        ans=min(ans,c)
if ans==10**15:
    print("TLE")
else:print(ans)
//  [python]
N,T=list(map(int, input().split()))
a=10**5
for _ in range(N):
  c,t=list(map(int, input().split()))
  if t<=T:
    a=min(c,a)
if a==10**5:
  print('TLE')
else:
  print(c)
//  [python]
N,T=list(map(int, input().split()))
a=10**5
for _ in range(N):
  c,t=list(map(int, input().split()))
  if t<=T:
    a=min(c.a)
if a==10**5:
  print('TLE')
else:
  print(c)
//  [java]
import java.io.IOException;
import java.io.InputStream;
import java.math.BigInteger;
import java.util.*;
class Main
{
    public static void main(String[] args)throws IOException
    {
        FastReader in=new FastReader(System.in);
        StringBuffer st=new StringBuffer();
       int n=in.nextInt();
       int t=in.nextInt();
       int ans=1000000,d=t;
       while(n--!=0){
         int a=in.nextInt();
         int b=in.nextInt();
         if(b<=t){
          if(a<ans){
            ans=a;
          }
         }
       }
          if(ans==1000000)
        System.out.println("TLE");
        else
        System.out.println(ans);
    }
    static class FastReader{
 
        byte[] buf = new byte[2048];
        int index, total;
        InputStream in;
 
        FastReader(InputStream is) {
            in = is;
        }
 
        int scan() throws IOException {
            if (index >= total) {
                index = 0;
                total = in.read(buf);
                if (total <= 0) {
                    return -1;
                }
            }
            return buf[index++];
        }
 
        String next() throws IOException {
            int c;
            for (c = scan(); c <= 32; c = scan());
            StringBuilder sb = new StringBuilder();
            for (; c > 32; c = scan()) {
                sb.append((char) c);
            }
            return sb.toString();
        }
 
        int nextInt() throws IOException {
            int c, val = 0;
            for (c = scan(); c <= 32; c = scan());
            boolean neg = c == '-';
            if (c == '-' || c == '+') {
                c = scan();
            }
            for (; c >= '0' && c <= '9'; c = scan()) {
                val = (val << 3) + (val << 1) + (c & 15);
            }
            return neg ? -val : val;
        }
 
        long nextLong() throws IOException {
            int c;
            long val = 0;
            for (c = scan(); c <= 32; c = scan());
            boolean neg = c == '-';
            if (c == '-' || c == '+') {
                c = scan();
            }
            for (; c >= '0' && c <= '9'; c = scan()) {
                val = (val << 3) + (val << 1) + (c & 15);
            }
            return neg ? -val : val;
        }
    }
}
//  [java]
import java.util.*;
import java.io.*;

public class Main{

	public static void main(String[] args) throws IOException {
		int N = readInt(), T = readInt();
		int min = Integer.MAX_VALUE;
		for(int i = 1; i<=N; i++) {
			int c = readInt(), t = readInt();
			if(t <= T) min  = Math.min(min, c);
		}
		println(min == Integer.MAX_VALUE ? "TLE" : min);
		exit();
	}

	final private static int BUFFER_SIZE = 1 << 16;
	private static DataInputStream din = new DataInputStream(System.in);
	private static byte[] buffer = new byte[BUFFER_SIZE];
	private static int bufferPointer = 0, bytesRead = 0;
	static PrintWriter pr = new PrintWriter(new BufferedWriter(new OutputStreamWriter(System.out)));

	public static String readLine() throws IOException {
		byte[] buf = new byte[64]; // line length
		int cnt = 0, c;
		while ((c = Read()) != -1) {
			if (c == '\n')
				break;
			buf[cnt++] = (byte) c;
		}
		return new String(buf, 0, cnt);
	}

	public static String read() throws IOException {
		byte[] ret = new byte[1024];
		int idx = 0;
		byte c = Read();
		while (c <= ' ') {
			c = Read();
		}
		do {
			ret[idx++] = c;
			c = Read();
		} while (c != -1 && c != ' ' && c != '\n' && c != '\r');
		return new String(ret, 0, idx);
	}

	public static int readInt() throws IOException {
		int ret = 0;
		byte c = Read();
		while (c <= ' ')
			c = Read();
		boolean neg = (c == '-');
		if (neg)
			c = Read();
		do {
			ret = ret * 10 + c - '0';
		} while ((c = Read()) >= '0' && c <= '9');

		if (neg)
			return -ret;
		return ret;
	}

	public static long readLong() throws IOException {
		long ret = 0;
		byte c = Read();
		while (c <= ' ')
			c = Read();
		boolean neg = (c == '-');
		if (neg)
			c = Read();
		do {
			ret = ret * 10 + c - '0';
		} while ((c = Read()) >= '0' && c <= '9');
		if (neg)
			return -ret;
		return ret;
	}

	public static double readDouble() throws IOException {
		double ret = 0, div = 1;
		byte c = Read();
		while (c <= ' ')
			c = Read();
		boolean neg = (c == '-');
		if (neg)
			c = Read();

		do {
			ret = ret * 10 + c - '0';
		} while ((c = Read()) >= '0' && c <= '9');

		if (c == '.') {
			while ((c = Read()) >= '0' && c <= '9') {
				ret += (c - '0') / (div *= 10);
			}
		}

		if (neg)
			return -ret;
		return ret;
	}

	private static void fillBuffer() throws IOException {
		bytesRead = din.read(buffer, bufferPointer = 0, BUFFER_SIZE);
		if (bytesRead == -1)
			buffer[0] = -1;
	}

	private static byte Read() throws IOException {
		if (bufferPointer == bytesRead)
			fillBuffer();
		return buffer[bufferPointer++];
	}

	static void print(Object o) {
		pr.print(o);
	}

	static void println(Object o) {
		pr.println(o);
	}

	static void flush() {
		pr.flush();
	}

	static void println() {
		pr.println();
	}

	static void exit() throws IOException {
		din.close();
		pr.close();
		System.exit(0);
	}
}
//  [java]
import java.io.IOException;
import java.io.InputStream;
import java.io.PrintWriter;
import java.util.NoSuchElementException;

public class Main {
	static FastScanner sc;
	static PrintWriter out;
	public static void main(String[] args){
		sc = new FastScanner();
		out = new PrintWriter(System.out);
		out.println(solve());
		out.flush();
	}

	static String solve(){
		int N = sc.nextInt();
		int T = sc.nextInt();
		int minCost = Integer.MAX_VALUE;
		int tmpCost;
		for(int i=0;i<N;i++){
			tmpCost = sc.nextInt();
			if(sc.nextInt()<=T && minCost > tmpCost){
				minCost = tmpCost;
			}
		}
		return (minCost == Integer.MAX_VALUE)? "TLE":String.valueOf(minCost);
	}
}

class FastScanner {
	private final InputStream in = System.in;
	private final byte[] buffer = new byte[1024];
	private int ptr = 0;
	private int buflen = 0;
	private boolean hasNextByte() {
		if (ptr < buflen) {
			return true;
		}else{
			ptr = 0;
			try {
				buflen = in.read(buffer);
			} catch (IOException e) {
				e.printStackTrace();
			}
			if (buflen <= 0) {
				return false;
			}
		}
		return true;
	}
	private int readByte() { if (hasNextByte()) return buffer[ptr++]; else return -1;}
	private static boolean isPrintableChar(int c) { return 33 <= c && c <= 126;}
	public boolean hasNext() { while(hasNextByte() && !isPrintableChar(buffer[ptr])) ptr++; return hasNextByte();}
	public String next() {
		if (!hasNext()) throw new NoSuchElementException();
		StringBuilder sb = new StringBuilder();
		int b = readByte();
		while(isPrintableChar(b)) {
			sb.appendCodePoint(b);
			b = readByte();
		}
		return sb.toString();
	}
	public long nextLong() {
		if (!hasNext()) throw new NoSuchElementException();
		long n = 0;
		boolean minus = false;
		int b = readByte();
		if (b == '-') {
			minus = true;
			b = readByte();
		}
		if (b < '0' || '9' < b) {
			throw new NumberFormatException();
		}
		while(true){
			if ('0' <= b && b <= '9') {
				n *= 10;
				n += b - '0';
			}else if(b == -1 || !isPrintableChar(b)){
				return minus ? -n : n;
			}else{
				throw new NumberFormatException();
			}
			b = readByte();
		}
	}
	public int nextInt() {
		long nl = nextLong();
		if (nl < Integer.MIN_VALUE || nl > Integer.MAX_VALUE) throw new NumberFormatException();
		return (int) nl;
	}
	public double nextDouble() { return Double.parseDouble(next());}
}
//  [java]
import java.util.*; import java.io.*; import java.math.*;
public class Main{
	//Don't have to see. start------------------------------------------
	static class InputIterator{
		ArrayList<String> inputLine = new ArrayList<String>(1024);
		int index = 0; int max; String read;
		InputIterator(){
			BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
			try{
				while((read = br.readLine()) != null){
					inputLine.add(read);
				}
			}catch(IOException e){}
			max = inputLine.size();
		}
		boolean hasNext(){return (index < max);}
		String next(){
			if(hasNext()){
				return inputLine.get(index++);
			}else{
				throw new IndexOutOfBoundsException("There is no more input");
			}
		}
	}
	static HashMap<Integer, String> CONVSTR = new HashMap<Integer, String>();
	static InputIterator ii = new InputIterator();//This class cannot be used in reactive problem.
	static PrintWriter out = new PrintWriter(System.out);
	static void flush(){out.flush();}
	static void myout(Object t){out.println(t);}
	static void myerr(Object t){System.err.print("debug:");System.err.println(t);}
	static String next(){return ii.next();}
	static boolean hasNext(){return ii.hasNext();}
	static int nextInt(){return Integer.parseInt(next());}
	static long nextLong(){return Long.parseLong(next());}
	static double nextDouble(){return Double.parseDouble(next());}
	static ArrayList<String> nextStrArray(){return myconv(next(), 8);}
	static ArrayList<String> nextCharArray(){return myconv(next(), 0);}
	static ArrayList<Integer> nextIntArray(){
		ArrayList<String> input = nextStrArray(); ArrayList<Integer> ret = new ArrayList<Integer>(input.size());
		for(int i = 0; i < input.size(); i++){
			ret.add(Integer.parseInt(input.get(i)));
		}
		return ret;
	}
	static ArrayList<Long> nextLongArray(){
		ArrayList<String> input = nextStrArray(); ArrayList<Long> ret = new ArrayList<Long>(input.size());
		for(int i = 0; i < input.size(); i++){
			ret.add(Long.parseLong(input.get(i)));
		}
		return ret;
	}
	static String myconv(Object list, int no){//only join
		String joinString = CONVSTR.get(no);
		if(list instanceof String[]){
			return String.join(joinString, (String[])list);
		}else if(list instanceof ArrayList){
			return String.join(joinString, (ArrayList)list);
		}else{
			throw new ClassCastException("Don't join");
		}
	}
	static ArrayList<String> myconv(String str, int no){//only split
		String splitString = CONVSTR.get(no);
		return new ArrayList<String>(Arrays.asList(str.split(splitString)));
	}
	public static void main(String[] args){
		CONVSTR.put(8, " "); CONVSTR.put(9, "\n"); CONVSTR.put(0, "");
		solve();flush();
	}
	//Don't have to see. end------------------------------------------
	static void solve(){//Here is the main function
		ArrayList<Integer> one = nextIntArray();
		int N = one.get(0);
		int T = one.get(1);
		TreeSet<Integer> set = new TreeSet<Integer>();
		for(int i = 0; i < N; i++){
			ArrayList<Integer> tmp = nextIntArray();
			if(tmp.get(1) <= T){
				set.add(tmp.get(0));
			}
		}
		myout(set.first());
	}
	//Method addition frame start



	//Method addition frame end
}
//  [java]
import java.util.Scanner;

public class Main {

    public static void main(String[] args) {
        Scanner sc = new Scanner(System.in);
        int n = sc.nextInt();
        int T = sc.nextInt();
        int[] c = new int[n];
        int[] t = new int[n];
        int min = Integer.MAX_VALUE;
        int ans = Integer.MAX_VALUE;
        for (int i = 0; i < n; i++) {
            c[i] = sc.nextInt();
            t[i] = sc.nextInt();
            if(T >= t[i]) {
                if(min > c[i]) {
                    min = t[i];
                    ans = c[i];
                }
            }
        }
        if(ans == Integer.MAX_VALUE) System.out.println("TLE");
        else System.out.println(ans);
    }
}
//  [java]
import java.util.Scanner;

public class Main {

    public static void main(String[] args) {
        Scanner sc = new Scanner(System.in);
        int n = sc.nextInt();
        int T = sc.nextInt();
        int[] c = new int[n];
        int[] t = new int[n];
        int min = Integer.MAX_VALUE;
        int ans = Integer.MAX_VALUE;
        for (int i = 0; i < n; i++) {
            c[i] = sc.nextInt();
            t[i] = sc.nextInt();
            if(T > t[i]) {
                if(min > c[i]) {
                    min = t[i];
                    ans = c[i];
                }
            }
        }
        if(ans == Integer.MAX_VALUE) System.out.println("TLE");
        else System.out.println(ans);
    }
}
//  [cpp]
# include <iostream>
using namespace std;


int main()
{
    int min_cost = 1001;
    int N, T;
    int ct[1100][2];

    cin >> N >> T;
    for (int i = 0; i < N; ++i) cin >> ct[i][0] >> ct[i][1];

    for (int j = 0; j < N; ++j) {
        if (ct[j][1] <= T )
            if (min_cost > ct[j][0])
                min_cost = ct[j][0];
    }

    if (min_cost == 1001) cout << "TLE";
    else cout << min_cost;

    return 0;
}
//  [cpp]
#include<bits/stdc++.h>
using namespace std;

int main(){
int N,T;
  cin>>N>>T;
 vector<int>c(N),t(N);
   for(int i=0; i<N; i++){
  cin>>c[i]>>t[i];
   }
  vector<int>filtered_c;
  for(int i=0; i<N; i++){
  if(T>=t[i]){
    filtered_c.push_back(c[i]);
  }
  }
  if(filtered_c.size()==0){
  cout<<"TLE"<<endl;
  }
  else{
  cout<<*min_element(filtered_c.begin(), filtered_c.end())<<endl;
  }
}
//  [cpp]
#include<bits/stdc++.h>
using namespace std;
int main() {
	int n, t;
	scanf("%d%d", &n, &t);
	int maxi = (-1) ^ (1 << 31);
	for (int i = 0; i < n; i++) {
		int a, b;
		scanf("%d%d", &a, &b);
		if (b <= t) maxi = min(maxi, a);
	}
	if (maxi == ((-1) ^ (1 << 31))) printf("TLE\n");
	else printf("%d\n", maxi);
}
//  [cpp]
#include<iostream>
#include<vector>
#include<string>
#include<algorithm>
#include<stack>
#include<queue>
#include<map>
#include<functional>
#include<math.h>
using namespace std;
#define rep(i,n) for(ll i=0;i<(n);i++)
#define pf(n) printf("%d\n",n)
#define pff(a,b) printf("%d  %d\n",a,b);
typedef long long ll;
typedef pair<ll, ll> p;
const int INF = 1001001001;
const double PI = acos(-1);

int main() {
	int n, T;
	cin >> n >> T;
	int ans = 1001001;
	rep(i, n) {
		int c, t;
		cin >> c >> t;
		if (t <= T and c<ans) {
			ans = c;
		}
	}
	cout << ans << endl;

	return 0;
}
//  [cpp]
#include<iostream>
using namespace std;
int main()
{
  int n,T;
  cin>>n>>T;
  int count=0;
  int a=0;
  for(int i=0;i<n;i++){
    int c,t;
    cin>>c>>t;
    if(t>T){
      count++;
    }
    else{
      if(a>c){
        a=c;
      }
    }
  }
  if(count==n){
    cout<<"TLE";
  }
  else{
    cout<<a;
  }
}
//  [cpp]
#pragma GCC optimize("Ofast")
#define _USE_MATH_DEFINES
#include "bits/stdc++.h"

using namespace std;

using u8 = uint8_t;
using u16 = uint16_t;
using u32 = uint32_t;
using u64 = uint64_t;
using i8 = int8_t;
using i16 = int16_t;
using i32 = int32_t;
using i64 = int64_t;

using vi = vector<int>;

constexpr char newl = '\n';
constexpr double eps = 1e-10;

#define FOR(i,a,b) for (int i = (a); i < (b); i++)
#define F0R(i,b) FOR(i,0,b)
#define RFO(i,a,b) for (int i = ((b)-1); i >=(a); i--)
#define RF0(i,b) RFO(i,0,b)
#define fi first
#define se second
#define show(x) cout << #x << " = " << x << '\n';
#define rng(a) a.begin(),a.end()
#define rrng(a) a.rbegin(),a.rend()
#define sz(x) (int)(x).size()
#define YesNo {cout<<"Yes";}else{cout<<"No";}
#define YESNO {cout<<"YES";}else{cout<<"NO";}
#define v(T) vector<T>

template<typename T1, typename T2> inline void chmin(T1& a, T2 b) { if (a > b) a = b; }
template<typename T1, typename T2> inline void chmax(T1& a, T2 b) { if (a < b) a = b; }
template<class T> bool lcmp(const pair<T, T>& l, const pair<T, T>& r) {
  return l.first < r.first;
}
template<class T> istream& operator>>(istream& i, v(T)& v) {
  F0R(j, sz(v)) i >> v[j];
  return i;
}
template<class T> ostream& operator<<(ostream& o, const vector<T>& v) {
  F0R(i, v.size()) {
    o << v[i] << ' ';
  }
  o << newl;
  return o;
}
template<class T1, class T2> ostream& operator<<(ostream& o, const map<T1, T2>& m) {
  for (auto& p : m) {
    o << p.first << ": " << p.second << newl;
  }
  o << newl;
  return o;
}

#if 1


// INSERT ABOVE HERE
signed main() {
  cin.tie(0);
  ios_base::sync_with_stdio(false);

  int N, T;
  cin >> N >> T;
  int mc = INT32_MAX;
  F0R(i, N) {
    int c, t;
    cin >> c >> t;
    if (t <= T) chmin(mc, c);
  }
  cout << mc;
}
#endif
//  [c]
#include<stdio.h>
int main(){
  int n,i,time,min=1001;
  scanf("%d%d",&n,&time);
  int route[n+1][2];
  for(i=0;i<n;i++){
    scanf("%d%d",&route[i][0],&route[i][1]);
    if(route[i][1]<=time && route[i][0]<min)
      min=route[i][0];
  }
  if(min==1001){
    printf("TLE\n");
    return 0;
  }
  printf("%d\n",min);
  return 0;
}
//  [c]
#include <stdio.h>

int main(void){
    int n,a;
    scanf("%d %d",&n,&a);
    int c[n];
    int t[a];
    int mincost = 1001;
    int mintime = 1001;
    for(int i = 0;i<n;i++){
        scanf("%d %d",&c[i],&t[i]);
        if(c[i] <= mincost && t[i] <= a){
            mincost = c[i];
            mintime = c[i];
        }
    }
    if(mincost == 1001){
        printf("TLE\n");
    }else{
        printf("%d\n",mincost);
    }
}
//  [c]
#include <stdio.h>

int main(void){
	int N,T;
	int c[100],t[100];
	int n = 0;
	int c_good = 1001;

	scanf("%d %d",&N,&T);

	while(scanf("%d %d",&c[n],&t[n]) != EOF){
		n++;
	}

	for(int i=0;i<=n;i++){
		if(T >= t[i] && t[i] >= 1 && t[i] <= 1000){
			if(c_good > c[i] && c[i] >= 1 && c[i] <= 1000){
				c_good = c[i];
			}
		}
	}

	if (c_good == 1001){
		printf("TLE\n");
	}else{
		printf("%d\n",c_good);
	}
	return 0;
}
//  [c]
#include<stdio.h>

int main(void) {
    int n, time_max, c[1000], t[1000], i, min = 1;
    scanf("%d %d", &n, &time_max);
    for (i = 0; i < n; i++) {
        scanf("%d %d", &c[i], &t[i]);
    }

    for (i = 0; i < n; i++) {
        if (c[min] > c[i]) {
            min = i;
        }
    }

    if (t[min] > time_max) {
        printf("TEL\n");
    }
    else {
        printf("%d", c[min]);
    }
    return 0;
}
//  [c]
#include <stdio.h>
int main(void){
    int N, T, i, cst = 9999, cnt = 0;
    int c[1000];
    int t[1000];
    
    scanf("%d %d", &N, &T);
    
    for(i = 0; i < N; i++){
        scanf("%d %d", &c[i], &t[i]);
    }
    
    for(i = 0; i < N; i++){
        if(T >= t[i] && c[i] <= cst){
            cst = c[i];
        }else{
            cnt = cnt + 1;
        }
    }
    
    if(cnt == N){
        printf("TLE\n");
    }else if(cnt < N){
        printf("%d\n", cst);
    }
//  [c]
#include <stdio.h>

int main(void)
{
        int N,T,i,s=0,index,min=1000;
        scanf("%d%d",&N,&T);
        int c[N],t[N];
        for(i=0;i<N;i++)
                scanf("%d%d",&c[i],&t[i]);

        for(i=0;i<N;i++){
                if(t[i]<=T && min>c[i]){
                        min=c[i]; s++;
                }
        }
        if(s!=0) printf("%d\n",min);
        else printf("TLE\n");
        return 0;
}
//  [javascript]
'use strict'

const main = (input) => {
    input = input.split('\n')
    let temp = input[0].split(' ').map(i => parseInt(i))
    const N = temp[0]
    const T = temp[1]
    temp = input.slice(1, N + 1)
    let minc = 10000
    let mint = 10000
    temp.forEach(t => {
        let temp = t.split(' ').map(i => parseInt(i))
        if(temp[1] <= T && temp[0] < minc){
            minc = temp[0] 
            mint = temp[1] 
        }
    })

    if(minc === 10000){
        console.log('TLE')
    }else{
        console.log(minc)
    }
}

main(require('fs').readFileSync('/dev/stdin', 'utf-8'))
//  [javascript]
function Main(input){
    limit=input.split("\n");
    eachlimit=limit[0].split(" ");
    N=Number(eachlimit[0]);
    T=Number(eachlimit[1]);
    var ans=1001;
    for(i=1;i<=N;i++){
        info=limit[i].split(" ");
        if(T>=info[1]){
            c=Number(info[0]);
            ans=Math.min(ans,c);
        }
    }
    if(ans==1001){
        console.log('TLE');
    } else{
        console.log(ans);
    }
}
Main(require("fs").readFileSync("/dev/stdin", "utf8"));
//  [javascript]
'use strict'

const main = (input) => {
    input = input.split('\n')
    let temp = input[0].split(' ').map(i => parseInt(i))
    const N = temp[0]
    const T = temp[1]
    temp = input.slice(1, N + 1)
    temp = temp.filter(t => {
        return parseInt(t.split(' ')[1]) <= T
    })

    let minc = 10000
    let mint = 10000
    temp.forEach(t => {
        let temp = t.split(' ').map(i => parseInt(i))
        if(temp[0] < minc){
            minc = temp[0] 
            mint = temp[1] 
        }
    })

    if(minc === 10000){
        console.log('TLE')
    }else{
        console.log(minc)
    }
}

main(require('fs').readFileSync('/dev/stdin', 'utf-8'))
//  [javascript]
function Main(input){
    limit=input.split("\n");
    eachlimit=limit[0].split(" ");
    N=Number(eachlimit[0]);
    T=Number(eachlimit[1]);
    var ans=1001;
    for(i=1;i<=N;i++){
        info=limit[i].aplit(" ");
        if(T>=info[1]){
            c=Number(info[0]);
            ans=Math.min(ans,c);
        }
    }
    if(ans==1001){
        console.log('TLE');
    } else{
        console.log(ans);
    }
}
Main(require("fs").readFileSync("/dev/stdin", "utf8"));
//  [javascript]
function Main(input){
    limit=input.split("\n");
    eachlimit=limit[0].split(" ");
    N=Number(eachlimit[0]);
    T=Number(eachlimit[1]);
    var ans=1001;
    for(i=1;i<=N;i++){
        info=limit[i].aplit(" ");
        if(T>=info[1]){
            c=Number(info[0]);
            ans=Math.min(ans,c);
        }
    }
    if(ans==1001){
        concole.log('TLE');
    } else{
        concole.log(ans);
    }
}
Main(require("fs").readFileSync("/dev/stdin", "utf8"));
//  [javascript]
function Main(input){
    limit=input.split("\n");
    eachlimit=input[0].split(" ");
    N=Number(eachlimit[0]);
    T=Number(eachlimit[1]);
    var ans=1001;
    for(i=1;i<=N;i++){
        info=limit[i].aplit(" ");
        if(T>=info[1]){
            c=Number(info[0]);
            ans=Math.min(ans,c);
        }
    }
    if(ans==1001){
        concole.log('TLE');
    } else{
        concole.log(ans);
    }
}
Main(require("fs").readFileSync("/dev/stdin", "utf8"));
//  [go]
package main

import (
	"bufio"
	"fmt"
	"os"
	"strconv"
)

var sc = bufio.NewScanner(os.Stdin)

func next() string {
	sc.Scan()
	return sc.Text()
}

func nextInt() int {
	sc.Scan()
	i, _ := strconv.Atoi(sc.Text())
	return i
}

func nextFloat64() float64 {
	f, _ := strconv.ParseFloat(next(), 64)
	return f
}

func nextInts(n int) []int {
	slice := make([]int, n)
	for i := 0; i < n; i++ {
		slice[i] = nextInt()
	}
	return slice
}

func main() {
	sc.Split(bufio.ScanWords)
	N, T := nextInt(), nextInt()
	minC := 1001
	for i := 0; i < N; i++ {
		c, t := nextInt(), nextInt()
		if t <= T && c <= minC {
			minC = c
		}
	}
	if minC <= 1000 {
		fmt.Println(minC)
	} else {
		fmt.Println("TLE")
	}
}
//  [go]
package main

import (
  "fmt"
  "sort"
)

func main() {
  var n, t int 
  fmt.Scan(&n, &t)
  ct := make([][2]int, n)
  for i := 0; i < n; i++ {
    fmt.Scan(&ct[i][0], &ct[i][1])
  }
  sort.Slice(ct, func(i, j int) bool {return ct[i][0] <= ct[j][0]})
  for i := 0; i < n; i++ {
    if ct[i][1] <= t {
      fmt.Println(ct[i][0])
      return
    }
  }
  fmt.Println("TLE")
  
}
//  [go]
package main

import "fmt"

func main() {
	var N, T int
	fmt.Scan(&N, &T)

	var c, t int
	min := 9999
	for i := 0; i < N; i++ {
		fmt.Scan(&c, &t)
		if t <= T && c <= min {
			min = c
		}
	}

	if min != 9999 {
		fmt.Println(min)
	}
	fmt.Println("TLE")
}
//  [ruby]
n,t = gets.split.map(&:to_i)
arr = []
n.times do
  c,time = gets.split.map(&:to_i)
  if time <= t
    arr << [c,time]
  end
end
puts arr.empty? ? :TLE : arr.sort[0][0]
//  [ruby]
#n = gets.to_s.to_i
n,l = gets.to_s.split.map{|i|i.to_i}
cts = Array.new(n){ gets.to_s.split.map{|i|i.to_i} }

ans = 10 ** 18
cts.each_with_index do |ct,i|
  c = ct[0]
  t = ct[1]
  
  # p ct
  
  next if t > l
  
  ans = c if ans > c
end

puts ans != 10 ** 18 ? ans : "TLE"
//  [ruby]
# abc112 B
n, T = gets.split.map(&:to_i)
ct = n.times.map {
  gets.split.map(&:to_i)
}

puts ct.select{|(c,t)|
  t <= T
}.sort_by{|(c,t)|c}[0]&.[](0) || 'TLE'
//  [ruby]
n,t = gets.chomp.split(' ').map(&:to_i)
min_c = 1001
n.times do
  path =  gets.chomp.split(' ').map(&:to_i)
  if path[1] <= t
    if path[0] < min
      min = path[0]
    end
  end
end
if min < 1001
  puts min
else
  puts "TLE"
end
//  [ruby]
n,t=gets.split.map(&:to_i)
ans=Float::INFINITY
n.times do
  c,ti=gets.split.map(&:to_i)
  if ti<=t
    ans=[ans,ti].min
  end
end
puts ans==Float::INFINITY ? 'TLE' : ans
//  [ruby]
a,b=gets.split.map &:to_i
s=[]
y=[]
a.times{|i|s[i],y[i]=gets.split.map &:to_i}
ans=s.zip(y).sort.bsearch{|x|x[1]<b} || "TLE"
puts ans=="TLE" ? "TLE":ans[0]
//  [rust]
use std::cmp::min;
use std::io::*;
use std::str::FromStr;

fn read<T: FromStr>() -> T {
    let stdin = stdin();
    let stdin = stdin.lock();
    let token: String = stdin
        .bytes()
        .map(|c| c.expect("filed to read char") as char)
        .skip_while(|c| c.is_whitespace())
        .take_while(|c| !c.is_whitespace())
        .collect();
    token.parse().ok().expect("failed to parse token")
}

fn main() {
    let n: u32 = read();
    let t: u32 = read();
    let mut m: u32 = 1001;
    for _ in 0..n {
        let c: u32 = read();
        let v: u32 = read();
        if t >= v {
            m = min(c, m);
        }
    }
    if m == 1001 {
        println!("TLE");
    } else {
        println!("{}", m);
    }
}
//  [rust]
use std::io::*;
use std::str::FromStr;

fn read<T: FromStr>() -> T {
    let stdin = stdin();
    let stdin = stdin.lock();
    let token: String = stdin
        .bytes()
        .map(|c| c.expect("filed to read char") as char)
        .skip_while(|c| c.is_whitespace())
        .take_while(|c| !c.is_whitespace())
        .collect();
    token.parse().ok().expect("failed to parse token")
}

fn main() {
    let n:u32 = read();
    let t:u32 = read();
    let mut min: u32 = 1001;
    for _ in 0..n {
        let c:u32 = read();
        let v:u32 = read();
        if t >= v && c < min {
            min = c;
        }
    }
    if min == 1001 {
        println!("TLE");
    } else {
        println!("{}", min);
    }
}
//  [rust]
use std::io::*;
use std::str::FromStr;

pub fn read<T: FromStr>() -> T {
    let stdin = stdin();
    let stdin = stdin.lock();
    let token: String = stdin
        .bytes()
        .map(|c| c.expect("failed to read char") as char)
        .skip_while(|c| c.is_whitespace())
        .take_while(|c| !c.is_whitespace())
        .collect();
    token.parse().ok().expect("failed to parse token")
}

fn main() {
    let n: usize = read();
    let t: usize = read();
    let mut minv = std::usize::MAX;

    for _ in 0..n {
        let c: usize = read();
        let ti: usize = read();

        if ti <= t {
            if c < minv {
                minv = c;
            }
        }
    }

    if minv == std::usize::MAX {
        println!("TLE");
        return;
    }
    println!("{}", minv);
}
//  [rust]
use std::io::*;
use std::str::FromStr;

pub fn read<T: FromStr>() -> T {
    let stdin = stdin();
    let stdin = stdin.lock();
    let token: String = stdin
        .bytes()
        .map(|c| c.expect("failed to read char") as char)
        .skip_while(|c| c.is_whitespace())
        .take_while(|c| !c.is_whitespace())
        .collect();
    token.parse().ok().expect("failed to parse token")
}

fn main() {
    let n: usize = read();
    let t: usize = read();
    let mut minv = std::usize::MAX;

    for _ in 0..n {
        let c: usize = read();
        let ti: usize = read();

        if ti <= t {
            if c < minv {
                minv = c;
            }
        }
    }
    println!("{}", minv);
}
//  [rust]
use std::cmp::min;
use std::io::*;
use std::str::FromStr;

fn read<T: FromStr>() -> T {
    let stdin = stdin();
    let stdin = stdin.lock();
    let token: String = stdin
        .bytes()
        .map(|c| c.expect("filed to read char") as char)
        .skip_while(|c| c.is_whitespace())
        .take_while(|c| !c.is_whitespace())
        .collect();
    token.parse().ok().expect("failed to parse token")
}

fn main() {
    let n: u32 = read();
    let t: u32 = read();
    let mut m: u32 = 1001;
    for _ in 0..n {
        let c: u32 = read();
        let v: u32 = read();
        if t >= v {
            m = min(c, m);
        }
    }
    if min == 1001 {
        println!("TLE");
    } else {
        println!("{}", m);
    }
}
//  [rust]
use std::cmp::min;
use std::io::*;
use std::str::FromStr;

fn read<T: FromStr>() -> T {
    let stdin = stdin();
    let stdin = stdin.lock();
    let token: String = stdin
        .bytes()
        .map(|c| c.expect("filed to read char") as char)
        .skip_while(|c| c.is_whitespace())
        .take_while(|c| !c.is_whitespace())
        .collect();
    token.parse().ok().expect("failed to parse token")
}

fn main() {
    let n: u32 = read();
    let t: u32 = read();
    let mut min: u32 = 1001;
    for _ in 0..n {
        let c: u32 = read();
        let v: u32 = read();
        if t >= v {
            min = min(c, min);
        }
    }
    if min == 1001 {
        println!("TLE");
    } else {
        println!("{}", min);
    }
}
//  [swift]
import Foundation
func toTuple<T>(_ args: [T]) -> (T, T) { (args[0], args[1]) }
func toTuple<T>(_ args: [T]) -> (T, T, T) { (args[0], args[1], args[2]) }
func toTuple<T>(_ args: [T]) -> (T, T, T, T) { (args[0], args[1], args[2], args[3]) }
func readInts() -> [Int] { readLine()!.split(separator: " ").map { Int($0)! } }
func readDoubles() -> [Double] { readLine()!.split(separator: " ").map { Double($0)! } }
func readStrings() -> [String] { readLine()!.split(separator: " ").map { String($0) } }

let (n, t) = toTuple(readInts())
var ans = 1001
for _ in 0..<n {
  let (ci, ti) = toTuple(readInts())
  guard ti <= t else { continue }
  ans = min(ans, ci)
}
print(ans == 1001 ? "TLE" : ans)