You got a job as a marketer in a pet shop, and your current task is to boost sales of cat food. One of the strategies is to sell cans of food in packs with discounts. 

Suppose you decided to sell packs with a cans in a pack with a discount and some customer wants to buy x cans of cat food. Then he follows a greedy strategy: 

  * he buys \left⌊ x/a \right⌋ packs with a discount; 
  * then he wants to buy the remaining (x mod a) cans one by one. 



\left⌊ x/a \right⌋ is x divided by a rounded down, x mod a is the remainer of x divided by a.

But customers are greedy in general, so if the customer wants to buy (x mod a) cans one by one and it happens that (x mod a) ≥ a/2 he decides to buy the whole pack of a cans (instead of buying (x mod a) cans). It makes you, as a marketer, happy since the customer bought more than he wanted initially.

You know that each of the customers that come to your shop can buy any number of cans from l to r inclusive. Can you choose such size of pack a that each customer buys more cans than they wanted initially?

Input

The first line contains a single integer t (1 ≤ t ≤ 1000) — the number of test cases.

The first and only line of each test case contains two integers l and r (1 ≤ l ≤ r ≤ 10^9) — the range of the number of cans customers can buy.

Output

For each test case, print YES if you can choose such size of pack a that each customer buys more cans than they wanted initially. Otherwise, print NO.

You can print each character in any case.

Example

Input


3
3 4
1 2
120 150


Output


YES
NO
YES

Note

In the first test case, you can take, for example, a = 5 as the size of the pack. Then if a customer wants to buy 3 cans, he'll buy 5 instead (3 mod 5 = 3, 5/2 = 2.5). The one who wants 4 cans will also buy 5 cans.

In the second test case, there is no way to choose a.

In the third test case, you can take, for example, a = 80.
# DEFINING SOME GOOD STUFF
mod = 10**9 + 7
# _______________________________________________________________#
from math import *
import threading
import sys
def npr(n,r):
	return factorial(n)//factorial(n-r) if n >= r else 0


def lower_bound(li, num):
	answer = -1
	start = 0
	end = len(li) - 1

	while (start <= end):
		middle = (end + start) // 2
		if li[middle] >= num:
			answer = middle
			end = middle - 1
		else:
			start = middle + 1
	return answer  # index where x is not less than num


def upper_bound(li, num):
	answer = -1
	start = 0
	end = len(li) - 1

	while (start <= end):
		middle = (end + start) // 2

		if li[middle] <= num:
			answer = middle
			start = middle + 1

		else:
			end = middle - 1
	return answer  # index where x is not greater than num


def abs(x):
	return x if x >= 0 else -x


def binary_search(li, val, lb, ub):
	ans = -1
	while (lb <= ub):
		mid = (lb + ub) // 2
		# print(mid, li[mid])
		if li[mid] > val:
			ub = mid - 1
		elif val > li[mid]:	
			lb = mid + 1
		else:
			ans = mid # return index
			break
	return ans


def kadane(x):  # maximum sum contiguous subarray
	sum_so_far = 0
	current_sum = 0
	for i in x:
		current_sum += i
		if current_sum < 0:
			current_sum = 0
		else:
			sum_so_far = max(sum_so_far, current_sum)
	return sum_so_far


def pref(li):
	pref_sum = [0]
	for i in li:
		pref_sum.append(pref_sum[-1] + i)
	return pref_sum


def graph(n, m):
	adj = dict()
	for i in range(1, n + 1):
		adj.setdefault(i, 0)
	for i in range(m):
		a, b = map(int, input().split())
		adj[a] += 1
		adj[b] += 1
	return adj


def SieveOfEratosthenes(n):
	prime = [True for i in range(n+1)]
	p = 2
	li = []
	while (p * p <= n):
		if (prime[p] == True):
			for i in range(p * p, n+1, p):
				prime[i] = False
		p += 1

	for p in range(2, len(prime)):
		if prime[p]:
			li.append(p)
	return li


# _______________________________________________________________#



sys.setrecursionlimit(300000)
# threading.stack_size(10**5)  # remember it cause mle
# def main():
primes = SieveOfEratosthenes(1300000)
def fn(n):
	i = 2
	res = n-1
	val = 0
	for i in range(int(sqrt(n))+1,1,-1):
	
		val = i - 1 + int(ceil((n-i)/i))
		#print(val,res)
		if val <= res:
			#print(i)
			res = val
		else:
			break
		
	return res


def solve(a,b,c): 
	dis = (b**2) - (4 * a*c) 

	# find two results 
	ans1 = (-b-sqrt(dis))/(2 * a) 
	#ans2 = (-b + cmath.sqrt(dis))/(2 * a) 

	# printing the results 
	#print('The roots are') 
	print(int(ans1)) 
	#print(ans2) 	
	return
	

for _ in range(int(input())):
#for _ in range(1):
	#n = int(input())
	l,r = map(int, input().split())
	# s = list(input())
	# a = [int(x) for x in s]
	# s = list(input())
	#a = list(map(int, input().split()))
	#b = list(map(int,input().split()))
	#c = list(map(int,input().split()))
	# adj = graph(n,m)
	ans = r + 1
	if l >= (ans/2):
		print('YES')
	else:
		print('NO')





















'''		
t = threading.Thread(target=main)
t.start()
t.join()
'''
