/*
 © 2020-10-27 08:36:03 Alex0x0 All Rights Reserved
*/

#pragma GCC optimize("Ofast,no-stack-protector,unroll-loops,fast-math")
#pragma GCC target("avx,avx2,fma")
#include <bits/stdc++.h>
#define f first
#define s second
#define fore(i,a,b) for(int i = (a), ThxMK = (b); i < ThxMK; ++i)
#define pb push_back
#define all(s) begin(s), end(s)
#define _ ios_base::sync_with_stdio(0);cin.tie(0);cout.tie(0);
#define sz(s) int(s.size())
#define ENDL '\n'
using namespace std;
typedef long double ld;
typedef long long lli;
typedef pair<lli,lli> ii;
typedef vector<lli> vi;
#define deb(x) cout << #x": " << (x) << endl;

int main(){ _
  lli t;
  cin >> t;
  while (t--){
    lli l, r;
    cin >> l >> r;
    if (l > 2 && (l * 2) >= r){
      cout << "YES" << ENDL;
    }
    else{
      cout << "NO" << ENDL;
    }
  }
  return 0;
}


/*
 © 2020-10-27 08:36:03 Alex0x0 All Rights Reserved
*/

#pragma GCC optimize("Ofast,no-stack-protector,unroll-loops,fast-math")
#pragma GCC target("avx,avx2,fma")
#include <bits/stdc++.h>
#define f first
#define s second
#define fore(i,a,b) for(int i = (a), ThxMK = (b); i < ThxMK; ++i)
#define pb push_back
#define all(s) begin(s), end(s)
#define _ ios_base::sync_with_stdio(0);cin.tie(0);cout.tie(0);
#define sz(s) int(s.size())
#define ENDL '\n'
using namespace std;
typedef long double ld;
typedef long long lli;
typedef pair<lli,lli> ii;
typedef vector<lli> vi;
#define deb(x) cout << #x": " << (x) << endl;

int main(){ _
  lli t;
  cin >> t;
  while (t--){
    lli l, r;
    cin >> l >> r;
    if (l > 2 && (l * 2) >= r && l % 3 == 0){
      cout << "YES" << ENDL;
    }
    else{
      cout << "NO" << ENDL;
    }
  }
  return 0;
}


/*
 © 2020-10-27 08:36:03 Alex0x0 All Rights Reserved
*/

#pragma GCC optimize("Ofast,no-stack-protector,unroll-loops,fast-math")
#pragma GCC target("avx,avx2,fma")
#include <bits/stdc++.h>
#define f first
#define s second
#define fore(i,a,b) for(int i = (a), ThxMK = (b); i < ThxMK; ++i)
#define pb push_back
#define all(s) begin(s), end(s)
#define _ ios_base::sync_with_stdio(0);cin.tie(0);cout.tie(0);
#define sz(s) int(s.size())
#define ENDL '\n'
using namespace std;
typedef long double ld;
typedef long long lli;
typedef pair<lli,lli> ii;
typedef vector<lli> vi;
#define deb(x) cout << #x": " << (x) << endl;

int main(){ _
  lli t;
  cin >> t;
  while (t--){
    lli l, r;
    cin >> l >> r;
    if (l > 2 && r > l){
      cout << "YES" << ENDL;
    }
    else{
      cout << "NO" << ENDL;
    }
  }
  return 0;
}


/*
 © 2020-10-27 08:36:03 Alex0x0 All Rights Reserved
*/

#pragma GCC optimize("Ofast,no-stack-protector,unroll-loops,fast-math")
#pragma GCC target("avx,avx2,fma")
#include <bits/stdc++.h>
#define f first
#define s second
#define fore(i,a,b) for(int i = (a), ThxMK = (b); i < ThxMK; ++i)
#define pb push_back
#define all(s) begin(s), end(s)
#define _ ios_base::sync_with_stdio(0);cin.tie(0);cout.tie(0);
#define sz(s) int(s.size())
#define ENDL '\n'
using namespace std;
typedef long double ld;
typedef long long lli;
typedef pair<lli,lli> ii;
typedef vector<lli> vi;
#define deb(x) cout << #x": " << (x) << endl;

int main(){ _
  lli t;
  cin >> t;
  while (t--){
    lli l, r;
    cin >> l >> r;
    if ((l * 2) > r){
      cout << "YES" << ENDL;
    }
    else{
      cout << "NO" << ENDL;
    }
  }
  return 0;
}


/*
 © 2020-10-27 08:36:03 Alex0x0 All Rights Reserved
*/

#pragma GCC optimize("Ofast,no-stack-protector,unroll-loops,fast-math")
#pragma GCC target("avx,avx2,fma")
#include <bits/stdc++.h>
#define f first
#define s second
#define fore(i,a,b) for(int i = (a), ThxMK = (b); i < ThxMK; ++i)
#define pb push_back
#define all(s) begin(s), end(s)
#define _ ios_base::sync_with_stdio(0);cin.tie(0);cout.tie(0);
#define sz(s) int(s.size())
#define ENDL '\n'
using namespace std;
typedef long double ld;
typedef long long lli;
typedef pair<lli,lli> ii;
typedef vector<lli> vi;
#define deb(x) cout << #x": " << (x) << endl;

int main(){ _
  lli t;
  cin >> t;
  while (t--){
    lli l, r;
    cin >> l >> r;
    if (r > 2){
      cout << "YES" << ENDL;
    }
    else{
      cout << "NO" << ENDL;
    }
  }
  return 0;
}


/*
 © 2020-10-27 08:36:03 Alex0x0 All Rights Reserved
*/

#pragma GCC optimize("Ofast,no-stack-protector,unroll-loops,fast-math")
#pragma GCC target("avx,avx2,fma")
#include <bits/stdc++.h>
#define f first
#define s second
#define fore(i,a,b) for(int i = (a), ThxMK = (b); i < ThxMK; ++i)
#define pb push_back
#define all(s) begin(s), end(s)
#define _ ios_base::sync_with_stdio(0);cin.tie(0);cout.tie(0);
#define sz(s) int(s.size())
#define ENDL '\n'
using namespace std;
typedef long double ld;
typedef long long lli;
typedef pair<lli,lli> ii;
typedef vector<lli> vi;
#define deb(x) cout << #x": " << (x) << endl;

int main(){ _
  lli t;
  cin >> t;
  while (t--){
    lli l, r;
    cin >> l >> r;
    if (l > 2){
      cout << "YES" << ENDL;
    }
    else{
      cout << "NO" << ENDL;
    }
  }
  return 0;
}


/*
 © 2020-10-27 08:36:03 Alex0x0 All Rights Reserved
*/

#pragma GCC optimize("Ofast,no-stack-protector,unroll-loops,fast-math")
#pragma GCC target("avx,avx2,fma")
#include <bits/stdc++.h>
#define f first
#define s second
#define fore(i,a,b) for(int i = (a), ThxMK = (b); i < ThxMK; ++i)
#define pb push_back
#define all(s) begin(s), end(s)
#define _ ios_base::sync_with_stdio(0);cin.tie(0);cout.tie(0);
#define sz(s) int(s.size())
#define ENDL '\n'
using namespace std;
typedef long double ld;
typedef long long lli;
typedef pair<lli,lli> ii;
typedef vector<lli> vi;
#define deb(x) cout << #x": " << (x) << endl;

int main(){ _
  lli t;
  cin >> t;
  while (t--){
    lli l, r;
    cin >> l >> r;
    if (r > 2 && r > l){
      cout << "YES" << ENDL;
    }
    else{
      cout << "NO" << ENDL;
    }
  }
  return 0;
}


/*
 © 2020-10-27 08:36:03 Alex0x0 All Rights Reserved
*/

#pragma GCC optimize("Ofast,no-stack-protector,unroll-loops,fast-math")
#pragma GCC target("avx,avx2,fma")
#include <bits/stdc++.h>
#define f first
#define s second
#define fore(i,a,b) for(int i = (a), ThxMK = (b); i < ThxMK; ++i)
#define pb push_back
#define all(s) begin(s), end(s)
#define _ ios_base::sync_with_stdio(0);cin.tie(0);cout.tie(0);
#define sz(s) int(s.size())
#define ENDL '\n'
using namespace std;
typedef long double ld;
typedef long long lli;
typedef pair<lli,lli> ii;
typedef vector<lli> vi;
#define deb(x) cout << #x": " << (x) << endl;

int main(){ _
  lli t;
  cin >> t;
  while (t--){
    lli l, r;
    cin >> l >> r;
    bool res = false;
    fore (i,l,r){
      if (i % 3 == 0){
        res = true;
        break;
      }
    }
    if (res == true){
      cout << "YES" << ENDL;
    }
    else{
      cout << "NO" << ENDL;
    }
  }
  return 0;
}


/*
 © 2020-10-27 08:36:03 Alex0x0 All Rights Reserved
*/

#pragma GCC optimize("Ofast,no-stack-protector,unroll-loops,fast-math")
#pragma GCC target("avx,avx2,fma")
#include <bits/stdc++.h>
#define f first
#define s second
#define fore(i,a,b) for(int i = (a), ThxMK = (b); i < ThxMK; ++i)
#define pb push_back
#define all(s) begin(s), end(s)
#define _ ios_base::sync_with_stdio(0);cin.tie(0);cout.tie(0);
#define sz(s) int(s.size())
#define ENDL '\n'
using namespace std;
typedef long double ld;
typedef long long lli;
typedef pair<lli,lli> ii;
typedef vector<lli> vi;
#define deb(x) cout << #x": " << (x) << endl;

int main(){ _
  lli t;
  cin >> t;
  while (t--){
    lli l, r;
    cin >> l >> r;
    if (l > 3){
      cout << "YES" << ENDL;
    }
    else{
      cout << "NO" << ENDL;
    }
  }
  return 0;
}


#include <iostream>
#include <vector>
#include <algorithm>

using namespace std;

int main() {
	int t;

	ios_base::sync_with_stdio(0), cin.tie(0), cout.tie(0);

	cin >> t;
	while (t-- > 0) {
		int l, r;

		cin >> l >> r;
		if (l != 1)
			cout << "YES" << endl;
		else
			cout << "NO" << endl;
	}

	return 0;
}


#include <iostream>
#include <vector>
#include <algorithm>

using namespace std;

main() {
	int t;

	ios_base::sync_with_stdio(0), cin.tie(0), cout.tie(0);

	cin >> t;
	while (t-- > 0) {
		int l, r;

		cin >> l >> r;
		if (l != 1)
			cout << "YES" << endl;
		else
			cout << "NO" << endl;
	}

	return 0;
}


#include <iostream>
#include <vector>
#include <algorithm>

using namespace std;

int main() {
	int t;

	ios_base::sync_with_stdio(0), cin.tie(0), cout.tie(0);

	cin >> t;
	while (t-- > 0) {
		int l, r;

		cin >> l >> r;
		if (2 * l > r)
			cout << "YES" << endl;
		else
			cout << "NO" << endl;
	}

	return 0;
}


//#define _CRT_SECURE_NO_WARNINGS
#include <algorithm>
#include <array>
#include <bitset>
#include <chrono>
#include <cmath>
#include <cstdio>
#include <cstring>
#include <ctime>
#include <deque>
#include <fstream>
#include <iostream>
#include <map>
#include <queue>
#include <random>
#include <set>
#include <stack>
#include <string>
#include <unordered_map>
#include <unordered_set>
#include <vector>
#pragma GCC optimize("Ofast,inline,unroll-loops,no-stack-protector")
using namespace std;
#define rep(i, a, n) for (int i = a; i < n; i++)
#define per(i, a, n) for (int i = n - 1; i >= a; i--)
#define all(v) v.begin(), v.end()
//#define sz(v) ((int)(v).size())
//#define trav(a, x) for (auto& a: x)
typedef long long ll;
typedef double db;
typedef long double ld;
typedef unsigned int uint;
typedef unsigned long long ull;
//typedef string str;
typedef vector<int> vi;
const int INF = 1e9 + 7;
const int MOD = 1e9 + 7;
//const int di[4] = { 1, 0, -1, 0 };
//const int dj[4] = { 0, 1 ,0, -1 };
mt19937 rnd(chrono::steady_clock::now().time_since_epoch().count());

int main() {
	ios_base::sync_with_stdio(false);
	cin.tie(0);
	cout.tie(0);
	int t;
	cin >> t;
	while (t--) {
		int l, r;
		cin >> l >> r;
		ll val = l * 2;
		if (val > r) {
			cout << "YES\n";
		}
		else {
			cout << "NO\n";
		}
	}
}


#define _CRT_SECURE_NO_WARNINGS
#include <algorithm>
#include <iostream>
#include <cstdint>
#include <iomanip>
#include <cstdlib>
#include <string>
#include <vector>
#include <queue>
#include <deque>
#include <stack>
#include <cmath>
#include <ctime>
#include <set>
#include <map>
#include <iterator>
#include <unordered_set>
#include <unordered_map>
using namespace std;

#define _USE_MATH_DEFINES
#define pb push_back
#define mp make_pair
#define all(a) a.begin(), a.end()
typedef long long ll;
typedef unsigned long long ull;

//const ll mod = 998244353;
const ll mod = 1000000007;

ll rng(ll l, ll u) {
	double f = 1. / (RAND_MAX + 1);
	return l + rand() * f * (u - l + 1);
}

ll gcd(ll a, ll b) {
	return b ? gcd(b, a % b) : a;
}

ll lcm(ll a, ll b) {
	return a / gcd(a, b) * b;
}

ll bpow(int a, int n) {
	return n ? n & 1 ? bpow(a, n - 1) * a : bpow(a * a, n >> 1) : 1;
}

bool prime(int n) {
	if (!n || n == 1) return 0;
	for (int i = 2; i <= sqrt(n); ++i) {
		if (n % i == 0) return 0;
	}
	return 1;
}

void solve() {
	int a, b;
	cin >> a >> b;
	if (a - 1 >= b - a) {
		cout << "YES";
	}
	else {
		cout << "NO";
	}
}

int main() {
	//freopen(".in", "r", stdin); freopen("Text.txt", "w", stdout);
	ios_base::sync_with_stdio(false); cin.tie(0); cout.tie(0);
	//srand(time(NULL));
	int t; cin >> t; for (int i = 0; i < t; ++i)
	{
		solve();
		cout << '\n';
	}
	return 0;
}


// Created by BlurringShadow at 2020-10-26-上午 10:09

#ifndef _DEBUG
#define NDEBUG
#endif

constexpr auto is_debug =
#ifdef NDEBUG
    false
#else
    true
#endif
;

#include <iostream>
#include <sstream>
#include <string>
#include <type_traits>
#include <vector>

using namespace std::literals; // NOLINT(clang-diagnostic-header-hygiene)
using std::size_t;
using std::vector;
using std::string;
using std::cout;
using std::cin;

[[maybe_unused]] const auto static_ini_ = []()
{
    std::ios::sync_with_stdio(false);
    std::cin.tie(nullptr);
    return std::cout.tie(nullptr);
}();

class console_output_buffer_binder final
{
    using buf_ptr_t = std::streambuf*;

    vector<std::stringbuf> buffers_;
    const buf_ptr_t console_buf_ = cout.rdbuf();

public:
    explicit console_output_buffer_binder(const size_t additional_count = 0) noexcept :
        buffers_(additional_count + 1),
        console_buf_(std::cout.rdbuf(&buffers_.front())) { bind_to(0); }

    console_output_buffer_binder(const console_output_buffer_binder&) = delete;
    console_output_buffer_binder& operator=(const console_output_buffer_binder&) = delete;

    struct scope_binder
    {
        const buf_ptr_t new_buf_p;
        const buf_ptr_t old_buf_p;

        explicit scope_binder(std::streambuf* new_buf) : new_buf_p(new_buf), old_buf_p(cout.rdbuf(new_buf)) {}
        ~scope_binder() { cout.rdbuf(old_buf_p); }
    };

    void bind_to(const size_t i) { cout.rdbuf(&buffers_[i]); }

    auto scope_bind_to(const size_t i) { return scope_binder{&buffers_[i]}; }

    void add_to_front() { buffers_.emplace_back(); }

    auto scope_add_front()
    {
        add_to_front();
        return scope_bind_to(buffers_.size() - 1);
    }

    ~console_output_buffer_binder()
    {
        cout.rdbuf(console_buf_);
        const auto size = buffers_.size();
        for(auto i = size - 1; i < size; --i) cout << buffers_[i].str();
    }
};

template<typename From, typename To>
struct is_convertible_to_ref : std::bool_constant<
        std::is_convertible_v<From, std::decay_t<To>&&> ||
        std::is_convertible_v<From, std::decay_t<To>&>
    > {};

template<typename From, typename To>
constexpr auto is_convertible_to_ref_v = is_convertible_to_ref<From, To>::value;

#ifdef __cpp_lib_concepts
#include <concepts>
#include <ranges>

template<typename From, typename To>
concept ConvertibleToRef = is_convertible_to_ref_v<From, To>;

template<typename T, ConvertibleToRef<std::istream> InputStream, typename... Args>
requires requires(InputStream is, T t)
{
    std::constructible_from<T, Args...>;
    is >> t;
}
#else
template<
    typename T,
    typename InputStream,
    typename... Args,
    std::enable_if_t<std::is_constructible_v<T, Args...>>* = nullptr,
    std::enable_if_t<is_convertible_to_ref_v<InputStream, std::istream>>* = nullptr
>
#endif
[[nodiscard]] T get_from_stream(InputStream&& is, Args&&... args)
{
    T t(std::forward<Args>(args)...);
    is >> t;
    return t;
}

template<typename T>
struct auto_cast
{
    T&& t;

#ifdef __cpp_lib_concepts
    template<typename U> requires requires { static_cast<std::decay_t<U>>(std::forward<T>(t)); }
#else
    template<typename U, std::enable_if_t<std::is_convertible_v<T, std::decay_t<U>>>* = nullptr>
#endif
    constexpr operator U() noexcept(std::is_nothrow_constructible_v<T, std::decay_t<U>>)
    {
        return static_cast<std::decay_t<U>>(std::forward<T>(t));
    }
};

template<
    typename ReturnT,
    typename Left,
    typename Right,
    typename Op
#ifdef __cpp_lib_concepts
> requires std::convertible_to<std::conditional_t<
    std::is_convertible_v<Left, ReturnT>,
    std::invoke_result_t<Op, ReturnT, Right>,
    std::invoke_result_t<Op, Left, ReturnT>
>, ReturnT>
#else
    ,
    std::enable_if_t<std::is_convertible_v<std::conditional_t<
        std::is_convertible_v<Left, ReturnT>,
        std::invoke_result_t<Op, ReturnT, Right>,
        std::invoke_result_t<Op, Left, ReturnT>
    >, ReturnT>>* = nullptr
>
#endif
constexpr ReturnT cast_op(Left&& left, Right&& right, Op op)
{
    if constexpr(std::is_convertible_v<Left, ReturnT>)
        return op(static_cast<ReturnT>(std::forward<Left>(left)), std::forward<Right>(right));
    else return op(std::forward<Left>(left), static_cast<ReturnT>(std::forward<Right>(right)));
}

class marketing_scheme
{
    uint64_t min_, max_;

public:
    constexpr marketing_scheme(const uint64_t min, const uint64_t max) noexcept: min_(min), max_(max) {}

    constexpr void solve() const noexcept
    {
        for(auto pack = 2 * (max_ - min_); pack < min_; ++pack)
        {
            const auto half = pack / 2;
            if(pack % max_ > half && pack % min_ > half)
            {
                cout << "YES\n";
                return;
            }
        }
        cout << "NO\n";
    }

#ifdef __cpp_lib_concepts
    template<ConvertibleToRef<std::istream> InputStream>
#else
    template<
        typename InputStream,
        std::enable_if_t<std::is_convertible_v<InputStream, std::istream&&> || std::is_convertible_v<InputStream, std::istream&>>* = nullptr
    >
#endif
    static void create_from_input(InputStream&& is)
    {
        for(auto i = get_from_stream<uint64_t>(is); i > 0; --i)
            marketing_scheme{get_from_stream<uint64_t>(is), get_from_stream<uint64_t>(is)}.solve();
    }
};

int main()
{
    if constexpr(is_debug)
    {
        marketing_scheme::create_from_input(std::istringstream{"3 3 4 1 2 120 150"});
    }
    else marketing_scheme::create_from_input(cin);
    return 0;
}


// Created by BlurringShadow at 2020-10-26-上午 10:09

#ifndef _DEBUG
#define NDEBUG
#endif

constexpr auto is_debug =
#ifdef NDEBUG
    false
#else
    true
#endif
;

#include <iostream>
#include <sstream>
#include <string>
#include <type_traits>
#include <vector>

using namespace std::literals; // NOLINT(clang-diagnostic-header-hygiene)
using std::size_t;
using std::vector;
using std::string;
using std::cout;
using std::cin;

[[maybe_unused]] const auto static_ini_ = []()
{
    std::ios::sync_with_stdio(false);
    std::cin.tie(nullptr);
    return std::cout.tie(nullptr);
}();

class console_output_buffer_binder final
{
    using buf_ptr_t = std::streambuf*;

    vector<std::stringbuf> buffers_;
    const buf_ptr_t console_buf_ = cout.rdbuf();

public:
    explicit console_output_buffer_binder(const size_t additional_count = 0) noexcept :
        buffers_(additional_count + 1),
        console_buf_(std::cout.rdbuf(&buffers_.front())) { bind_to(0); }

    console_output_buffer_binder(const console_output_buffer_binder&) = delete;
    console_output_buffer_binder& operator=(const console_output_buffer_binder&) = delete;

    struct scope_binder
    {
        const buf_ptr_t new_buf_p;
        const buf_ptr_t old_buf_p;

        explicit scope_binder(std::streambuf* new_buf) : new_buf_p(new_buf), old_buf_p(cout.rdbuf(new_buf)) {}
        ~scope_binder() { cout.rdbuf(old_buf_p); }
    };

    void bind_to(const size_t i) { cout.rdbuf(&buffers_[i]); }

    auto scope_bind_to(const size_t i) { return scope_binder{&buffers_[i]}; }

    void add_to_front() { buffers_.emplace_back(); }

    auto scope_add_front()
    {
        add_to_front();
        return scope_bind_to(buffers_.size() - 1);
    }

    ~console_output_buffer_binder()
    {
        cout.rdbuf(console_buf_);
        const auto size = buffers_.size();
        for(auto i = size - 1; i < size; --i) cout << buffers_[i].str();
    }
};

template<typename From, typename To>
struct is_convertible_to_ref : std::bool_constant<
        std::is_convertible_v<From, std::decay_t<To>&&> ||
        std::is_convertible_v<From, std::decay_t<To>&>
    > {};

template<typename From, typename To>
constexpr auto is_convertible_to_ref_v = is_convertible_to_ref<From, To>::value;

#ifdef __cpp_lib_concepts
#include <concepts>
#include <ranges>

template<typename From, typename To>
concept ConvertibleToRef = is_convertible_to_ref_v<From, To>;

template<typename T, ConvertibleToRef<std::istream> InputStream, typename... Args>
requires requires(InputStream is, T t)
{
    std::constructible_from<T, Args...>;
    is >> t;
}
#else
template<
    typename T,
    typename InputStream,
    typename... Args,
    std::enable_if_t<std::is_constructible_v<T, Args...>>* = nullptr,
    std::enable_if_t<is_convertible_to_ref_v<InputStream, std::istream>>* = nullptr
>
#endif
[[nodiscard]] T get_from_stream(InputStream&& is, Args&&... args)
{
    T t(std::forward<Args>(args)...);
    is >> t;
    return t;
}

template<typename T>
struct auto_cast
{
    T&& t;

#ifdef __cpp_lib_concepts
    template<typename U> requires requires { static_cast<std::decay_t<U>>(std::forward<T>(t)); }
#else
    template<typename U, std::enable_if_t<std::is_convertible_v<T, std::decay_t<U>>>* = nullptr>
#endif
    constexpr operator U() noexcept(std::is_nothrow_constructible_v<T, std::decay_t<U>>)
    {
        return static_cast<std::decay_t<U>>(std::forward<T>(t));
    }
};

template<
    typename ReturnT,
    typename Left,
    typename Right,
    typename Op
#ifdef __cpp_lib_concepts
> requires std::convertible_to<std::conditional_t<
    std::is_convertible_v<Left, ReturnT>,
    std::invoke_result_t<Op, ReturnT, Right>,
    std::invoke_result_t<Op, Left, ReturnT>
>, ReturnT>
#else
    ,
    std::enable_if_t<std::is_convertible_v<std::conditional_t<
        std::is_convertible_v<Left, ReturnT>,
        std::invoke_result_t<Op, ReturnT, Right>,
        std::invoke_result_t<Op, Left, ReturnT>
    >, ReturnT>>* = nullptr
>
#endif
constexpr ReturnT cast_op(Left&& left, Right&& right, Op op)
{
    if constexpr(std::is_convertible_v<Left, ReturnT>)
        return op(static_cast<ReturnT>(std::forward<Left>(left)), std::forward<Right>(right));
    else return op(std::forward<Left>(left), static_cast<ReturnT>(std::forward<Right>(right)));
}

class marketing_scheme
{
    uint64_t min_, max_;

public:
    constexpr marketing_scheme(const uint64_t min, const uint64_t max) noexcept: min_(min), max_(max) {}

    constexpr void solve() const noexcept
    {
        auto pack = 2 * (max_ - min_);
        for(; (max_ / pack) != (min_ / pack); ++ pack);

        for(; pack <= 2 * min_; ++pack)
        {
            const auto half = (pack + 1) / 2;

            if(pack % max_ >= half && pack % min_ >= half)
            {
                cout << "YES\n";
                return;
            }
        }

        cout << "NO\n";
    }

#ifdef __cpp_lib_concepts
    template<ConvertibleToRef<std::istream> InputStream>
#else
    template<
        typename InputStream,
        std::enable_if_t<std::is_convertible_v<InputStream, std::istream&&> || std::is_convertible_v<InputStream, std::istream&>>* = nullptr
    >
#endif
    static void create_from_input(InputStream&& is)
    {
        for(auto i = get_from_stream<uint64_t>(is); i > 0; --i)
            marketing_scheme{get_from_stream<uint64_t>(is), get_from_stream<uint64_t>(is)}.solve();
    }
};

int main()
{
    if constexpr(is_debug)
    {
        marketing_scheme::create_from_input(std::istringstream{"3 3 4 1 2 120 150"});
    }
    else marketing_scheme::create_from_input(cin);
    return 0;
}


// Created by BlurringShadow at 2020-10-26-上午 10:09

#ifndef _DEBUG
#define NDEBUG
#endif

constexpr auto is_debug =
#ifdef NDEBUG
    false
#else
    true
#endif
;

#include <iostream>
#include <sstream>
#include <string>
#include <type_traits>
#include <vector>

using namespace std::literals; // NOLINT(clang-diagnostic-header-hygiene)
using std::size_t;
using std::vector;
using std::string;
using std::cout;
using std::cin;

[[maybe_unused]] const auto static_ini_ = []()
{
    std::ios::sync_with_stdio(false);
    std::cin.tie(nullptr);
    return std::cout.tie(nullptr);
}();

class console_output_buffer_binder final
{
    using buf_ptr_t = std::streambuf*;

    vector<std::stringbuf> buffers_;
    const buf_ptr_t console_buf_ = cout.rdbuf();

public:
    explicit console_output_buffer_binder(const size_t additional_count = 0) noexcept :
        buffers_(additional_count + 1),
        console_buf_(std::cout.rdbuf(&buffers_.front())) { bind_to(0); }

    console_output_buffer_binder(const console_output_buffer_binder&) = delete;
    console_output_buffer_binder& operator=(const console_output_buffer_binder&) = delete;

    struct scope_binder
    {
        const buf_ptr_t new_buf_p;
        const buf_ptr_t old_buf_p;

        explicit scope_binder(std::streambuf* new_buf) : new_buf_p(new_buf), old_buf_p(cout.rdbuf(new_buf)) {}
        ~scope_binder() { cout.rdbuf(old_buf_p); }
    };

    void bind_to(const size_t i) { cout.rdbuf(&buffers_[i]); }

    auto scope_bind_to(const size_t i) { return scope_binder{&buffers_[i]}; }

    void add_to_front() { buffers_.emplace_back(); }

    auto scope_add_front()
    {
        add_to_front();
        return scope_bind_to(buffers_.size() - 1);
    }

    ~console_output_buffer_binder()
    {
        cout.rdbuf(console_buf_);
        const auto size = buffers_.size();
        for(auto i = size - 1; i < size; --i) cout << buffers_[i].str();
    }
};

template<typename From, typename To>
struct is_convertible_to_ref : std::bool_constant<
        std::is_convertible_v<From, std::decay_t<To>&&> ||
        std::is_convertible_v<From, std::decay_t<To>&>
    > {};

template<typename From, typename To>
constexpr auto is_convertible_to_ref_v = is_convertible_to_ref<From, To>::value;

#ifdef __cpp_lib_concepts
#include <concepts>
#include <ranges>

template<typename From, typename To>
concept ConvertibleToRef = is_convertible_to_ref_v<From, To>;

template<typename T, ConvertibleToRef<std::istream> InputStream, typename... Args>
requires requires(InputStream is, T t)
{
    std::constructible_from<T, Args...>;
    is >> t;
}
#else
template<
    typename T,
    typename InputStream,
    typename... Args,
    std::enable_if_t<std::is_constructible_v<T, Args...>>* = nullptr,
    std::enable_if_t<is_convertible_to_ref_v<InputStream, std::istream>>* = nullptr
>
#endif
[[nodiscard]] T get_from_stream(InputStream&& is, Args&&... args)
{
    T t(std::forward<Args>(args)...);
    is >> t;
    return t;
}

template<typename T>
struct auto_cast
{
    T&& t;

#ifdef __cpp_lib_concepts
    template<typename U> requires requires { static_cast<std::decay_t<U>>(std::forward<T>(t)); }
#else
    template<typename U, std::enable_if_t<std::is_convertible_v<T, std::decay_t<U>>>* = nullptr>
#endif
    constexpr operator U() noexcept(std::is_nothrow_constructible_v<T, std::decay_t<U>>)
    {
        return static_cast<std::decay_t<U>>(std::forward<T>(t));
    }
};

template<
    typename ReturnT,
    typename Left,
    typename Right,
    typename Op
#ifdef __cpp_lib_concepts
> requires std::convertible_to<std::conditional_t<
    std::is_convertible_v<Left, ReturnT>,
    std::invoke_result_t<Op, ReturnT, Right>,
    std::invoke_result_t<Op, Left, ReturnT>
>, ReturnT>
#else
    ,
    std::enable_if_t<std::is_convertible_v<std::conditional_t<
        std::is_convertible_v<Left, ReturnT>,
        std::invoke_result_t<Op, ReturnT, Right>,
        std::invoke_result_t<Op, Left, ReturnT>
    >, ReturnT>>* = nullptr
>
#endif
constexpr ReturnT cast_op(Left&& left, Right&& right, Op op)
{
    if constexpr(std::is_convertible_v<Left, ReturnT>)
        return op(static_cast<ReturnT>(std::forward<Left>(left)), std::forward<Right>(right));
    else return op(std::forward<Left>(left), static_cast<ReturnT>(std::forward<Right>(right)));
}

class marketing_scheme
{
    uint64_t min_, max_;

public:
    constexpr marketing_scheme(const uint64_t min, const uint64_t max) noexcept: min_(min), max_(max) {}

    constexpr void solve() const noexcept
    {
        const auto offset = max_ - min_;

        for(auto pack = 2 * (max_ - min_); pack < 2 * min_; ++pack)
        {
            const auto half = (pack + 1) / 2;

            if(pack % max_ >= half && pack % min_ >= half)
            {
                cout << "YES\n";
                return;
            }
        }

        cout << "NO\n";
    }

#ifdef __cpp_lib_concepts
    template<ConvertibleToRef<std::istream> InputStream>
#else
    template<
        typename InputStream,
        std::enable_if_t<std::is_convertible_v<InputStream, std::istream&&> || std::is_convertible_v<InputStream, std::istream&>>* = nullptr
    >
#endif
    static void create_from_input(InputStream&& is)
    {
        for(auto i = get_from_stream<uint64_t>(is); i > 0; --i)
            marketing_scheme{get_from_stream<uint64_t>(is), get_from_stream<uint64_t>(is)}.solve();
    }
};

int main()
{
    if constexpr(is_debug)
    {
        marketing_scheme::create_from_input(std::istringstream{"3 3 4 1 2 120 150"});
    }
    else marketing_scheme::create_from_input(cin);
    return 0;
}


// Created by BlurringShadow at 2020-10-26-上午 10:09

#ifndef _DEBUG
#define NDEBUG
#endif

constexpr auto is_debug =
#ifdef NDEBUG
    false
#else
    true
#endif
;

#include <iostream>
#include <sstream>
#include <string>
#include <type_traits>
#include <vector>

using namespace std::literals; // NOLINT(clang-diagnostic-header-hygiene)
using std::size_t;
using std::vector;
using std::string;
using std::cout;
using std::cin;

[[maybe_unused]] const auto static_ini_ = []()
{
    std::ios::sync_with_stdio(false);
    std::cin.tie(nullptr);
    return std::cout.tie(nullptr);
}();

class console_output_buffer_binder final
{
    using buf_ptr_t = std::streambuf*;

    vector<std::stringbuf> buffers_;
    const buf_ptr_t console_buf_ = cout.rdbuf();

public:
    explicit console_output_buffer_binder(const size_t additional_count = 0) noexcept :
        buffers_(additional_count + 1),
        console_buf_(std::cout.rdbuf(&buffers_.front())) { bind_to(0); }

    console_output_buffer_binder(const console_output_buffer_binder&) = delete;
    console_output_buffer_binder& operator=(const console_output_buffer_binder&) = delete;

    struct scope_binder
    {
        const buf_ptr_t new_buf_p;
        const buf_ptr_t old_buf_p;

        explicit scope_binder(std::streambuf* new_buf) : new_buf_p(new_buf), old_buf_p(cout.rdbuf(new_buf)) {}
        ~scope_binder() { cout.rdbuf(old_buf_p); }
    };

    void bind_to(const size_t i) { cout.rdbuf(&buffers_[i]); }

    auto scope_bind_to(const size_t i) { return scope_binder{&buffers_[i]}; }

    void add_to_front() { buffers_.emplace_back(); }

    auto scope_add_front()
    {
        add_to_front();
        return scope_bind_to(buffers_.size() - 1);
    }

    ~console_output_buffer_binder()
    {
        cout.rdbuf(console_buf_);
        const auto size = buffers_.size();
        for(auto i = size - 1; i < size; --i) cout << buffers_[i].str();
    }
};

template<typename From, typename To>
struct is_convertible_to_ref : std::bool_constant<
        std::is_convertible_v<From, std::decay_t<To>&&> ||
        std::is_convertible_v<From, std::decay_t<To>&>
    > {};

template<typename From, typename To>
constexpr auto is_convertible_to_ref_v = is_convertible_to_ref<From, To>::value;

#ifdef __cpp_lib_concepts
#include <concepts>
#include <ranges>

template<typename From, typename To>
concept ConvertibleToRef = is_convertible_to_ref_v<From, To>;

template<typename T, ConvertibleToRef<std::istream> InputStream, typename... Args>
requires requires(InputStream is, T t)
{
    std::constructible_from<T, Args...>;
    is >> t;
}
#else
template<
    typename T,
    typename InputStream,
    typename... Args,
    std::enable_if_t<std::is_constructible_v<T, Args...>>* = nullptr,
    std::enable_if_t<is_convertible_to_ref_v<InputStream, std::istream>>* = nullptr
>
#endif
[[nodiscard]] T get_from_stream(InputStream&& is, Args&&... args)
{
    T t(std::forward<Args>(args)...);
    is >> t;
    return t;
}

template<typename T>
struct auto_cast
{
    T&& t;

#ifdef __cpp_lib_concepts
    template<typename U> requires requires { static_cast<std::decay_t<U>>(std::forward<T>(t)); }
#else
    template<typename U, std::enable_if_t<std::is_convertible_v<T, std::decay_t<U>>>* = nullptr>
#endif
    constexpr operator U() noexcept(std::is_nothrow_constructible_v<T, std::decay_t<U>>)
    {
        return static_cast<std::decay_t<U>>(std::forward<T>(t));
    }
};

template<
    typename ReturnT,
    typename Left,
    typename Right,
    typename Op
#ifdef __cpp_lib_concepts
> requires std::convertible_to<std::conditional_t<
    std::is_convertible_v<Left, ReturnT>,
    std::invoke_result_t<Op, ReturnT, Right>,
    std::invoke_result_t<Op, Left, ReturnT>
>, ReturnT>
#else
    ,
    std::enable_if_t<std::is_convertible_v<std::conditional_t<
        std::is_convertible_v<Left, ReturnT>,
        std::invoke_result_t<Op, ReturnT, Right>,
        std::invoke_result_t<Op, Left, ReturnT>
    >, ReturnT>>* = nullptr
>
#endif
constexpr ReturnT cast_op(Left&& left, Right&& right, Op op)
{
    if constexpr(std::is_convertible_v<Left, ReturnT>)
        return op(static_cast<ReturnT>(std::forward<Left>(left)), std::forward<Right>(right));
    else return op(std::forward<Left>(left), static_cast<ReturnT>(std::forward<Right>(right)));
}

class marketing_scheme
{
    uint64_t min_, max_;

public:
    constexpr marketing_scheme(const uint64_t min, const uint64_t max) noexcept: min_(min), max_(max) {}

    constexpr void solve() const noexcept
    {
        auto pack = 2 * (max_ - min_);
        for(; max_ / pack != min_ / pack; ++pack);

        for(; pack <= 2 * min_; ++pack)
        {
            const auto half = (pack + 1) / 2;

            if(max_ % pack >= half && min_ % pack >= half)
            {
                cout << "YES\n";
                return;
            }
        }
        cout << "NO\n";
    }

#ifdef __cpp_lib_concepts
    template<ConvertibleToRef<std::istream> InputStream>
#else
    template<
        typename InputStream,
        std::enable_if_t<std::is_convertible_v<InputStream, std::istream&&> || std::is_convertible_v<InputStream, std::istream&>>* = nullptr
    >
#endif
    static void create_from_input(InputStream&& is)
    {
        for(auto i = get_from_stream<uint64_t>(is); i > 0; --i)
            marketing_scheme{get_from_stream<uint64_t>(is), get_from_stream<uint64_t>(is)}.solve();
    }
};

int main()
{
    if constexpr(is_debug)
    {
        marketing_scheme::create_from_input(std::istringstream{"3 3 4 1 2 120 150"});
    }
    else marketing_scheme::create_from_input(cin);
    return 0;
}


// Created by BlurringShadow at 2020-10-26-上午 10:09

#ifndef _DEBUG
#define NDEBUG
#endif

constexpr auto is_debug =
#ifdef NDEBUG
    false
#else
    true
#endif
;

#include <iostream>
#include <sstream>
#include <string>
#include <type_traits>
#include <vector>

using namespace std::literals; // NOLINT(clang-diagnostic-header-hygiene)
using std::size_t;
using std::vector;
using std::string;
using std::cout;
using std::cin;

[[maybe_unused]] const auto static_ini_ = []()
{
    std::ios::sync_with_stdio(false);
    std::cin.tie(nullptr);
    return std::cout.tie(nullptr);
}();

class console_output_buffer_binder final
{
    using buf_ptr_t = std::streambuf*;

    vector<std::stringbuf> buffers_;
    const buf_ptr_t console_buf_ = cout.rdbuf();

public:
    explicit console_output_buffer_binder(const size_t additional_count = 0) noexcept :
        buffers_(additional_count + 1),
        console_buf_(std::cout.rdbuf(&buffers_.front())) { bind_to(0); }

    console_output_buffer_binder(const console_output_buffer_binder&) = delete;
    console_output_buffer_binder& operator=(const console_output_buffer_binder&) = delete;

    struct scope_binder
    {
        const buf_ptr_t new_buf_p;
        const buf_ptr_t old_buf_p;

        explicit scope_binder(std::streambuf* new_buf) : new_buf_p(new_buf), old_buf_p(cout.rdbuf(new_buf)) {}
        ~scope_binder() { cout.rdbuf(old_buf_p); }
    };

    void bind_to(const size_t i) { cout.rdbuf(&buffers_[i]); }

    auto scope_bind_to(const size_t i) { return scope_binder{&buffers_[i]}; }

    void add_to_front() { buffers_.emplace_back(); }

    auto scope_add_front()
    {
        add_to_front();
        return scope_bind_to(buffers_.size() - 1);
    }

    ~console_output_buffer_binder()
    {
        cout.rdbuf(console_buf_);
        const auto size = buffers_.size();
        for(auto i = size - 1; i < size; --i) cout << buffers_[i].str();
    }
};

template<typename From, typename To>
struct is_convertible_to_ref : std::bool_constant<
        std::is_convertible_v<From, std::decay_t<To>&&> ||
        std::is_convertible_v<From, std::decay_t<To>&>
    > {};

template<typename From, typename To>
constexpr auto is_convertible_to_ref_v = is_convertible_to_ref<From, To>::value;

#ifdef __cpp_lib_concepts
#include <concepts>
#include <ranges>

template<typename From, typename To>
concept ConvertibleToRef = is_convertible_to_ref_v<From, To>;

template<typename T, ConvertibleToRef<std::istream> InputStream, typename... Args>
requires requires(InputStream is, T t)
{
    std::constructible_from<T, Args...>;
    is >> t;
}
#else
template<
    typename T,
    typename InputStream,
    typename... Args,
    std::enable_if_t<std::is_constructible_v<T, Args...>>* = nullptr,
    std::enable_if_t<is_convertible_to_ref_v<InputStream, std::istream>>* = nullptr
>
#endif
[[nodiscard]] T get_from_stream(InputStream&& is, Args&&... args)
{
    T t(std::forward<Args>(args)...);
    is >> t;
    return t;
}

template<typename T>
struct auto_cast
{
    T&& t;

#ifdef __cpp_lib_concepts
    template<typename U> requires requires { static_cast<std::decay_t<U>>(std::forward<T>(t)); }
#else
    template<typename U, std::enable_if_t<std::is_convertible_v<T, std::decay_t<U>>>* = nullptr>
#endif
    constexpr operator U() noexcept(std::is_nothrow_constructible_v<T, std::decay_t<U>>)
    {
        return static_cast<std::decay_t<U>>(std::forward<T>(t));
    }
};

template<
    typename ReturnT,
    typename Left,
    typename Right,
    typename Op
#ifdef __cpp_lib_concepts
> requires std::convertible_to<std::conditional_t<
    std::is_convertible_v<Left, ReturnT>,
    std::invoke_result_t<Op, ReturnT, Right>,
    std::invoke_result_t<Op, Left, ReturnT>
>, ReturnT>
#else
    ,
    std::enable_if_t<std::is_convertible_v<std::conditional_t<
        std::is_convertible_v<Left, ReturnT>,
        std::invoke_result_t<Op, ReturnT, Right>,
        std::invoke_result_t<Op, Left, ReturnT>
    >, ReturnT>>* = nullptr
>
#endif
constexpr ReturnT cast_op(Left&& left, Right&& right, Op op)
{
    if constexpr(std::is_convertible_v<Left, ReturnT>)
        return op(static_cast<ReturnT>(std::forward<Left>(left)), std::forward<Right>(right));
    else return op(std::forward<Left>(left), static_cast<ReturnT>(std::forward<Right>(right)));
}

class marketing_scheme
{
    uint64_t min_, max_;

public:
    constexpr marketing_scheme(const uint64_t min, const uint64_t max) noexcept: min_(min), max_(max) {}

    constexpr void solve() const noexcept
    {
        for(auto pack = max_ + 1; ; ++pack)
        {
            const auto half = (pack + 1) / 2;

            if(half > min_) break;
            if(max_ % pack >= half && min_ % pack >= half)
            {
                cout << "YES\n";
                return;
            }
        }

        cout << "NO\n";
    }

#ifdef __cpp_lib_concepts
    template<ConvertibleToRef<std::istream> InputStream>
#else
    template<
        typename InputStream,
        std::enable_if_t<std::is_convertible_v<InputStream, std::istream&&> || std::is_convertible_v<InputStream, std::istream&>>* = nullptr
    >
#endif
    static void create_from_input(InputStream&& is)
    {
        for(auto i = get_from_stream<uint64_t>(is); i > 0; --i)
            marketing_scheme{get_from_stream<uint64_t>(is), get_from_stream<uint64_t>(is)}.solve();
    }
};

int main()
{
    if constexpr(is_debug)
    {
        marketing_scheme::create_from_input(std::istringstream{"3 3 4 1 2 120 150"});
    }
    else marketing_scheme::create_from_input(cin);
    return 0;
}


// Created by BlurringShadow at 2020-10-26-上午 10:09

#ifndef _DEBUG
#define NDEBUG
#endif

constexpr auto is_debug =
#ifdef NDEBUG
    false
#else
    true
#endif
;

#include <iostream>
#include <sstream>
#include <string>
#include <type_traits>
#include <vector>

using namespace std::literals; // NOLINT(clang-diagnostic-header-hygiene)
using std::size_t;
using std::vector;
using std::string;
using std::cout;
using std::cin;

[[maybe_unused]] const auto static_ini_ = []()
{
    std::ios::sync_with_stdio(false);
    std::cin.tie(nullptr);
    return std::cout.tie(nullptr);
}();

class console_output_buffer_binder final
{
    using buf_ptr_t = std::streambuf*;

    vector<std::stringbuf> buffers_;
    const buf_ptr_t console_buf_ = cout.rdbuf();

public:
    explicit console_output_buffer_binder(const size_t additional_count = 0) noexcept :
        buffers_(additional_count + 1),
        console_buf_(std::cout.rdbuf(&buffers_.front())) { bind_to(0); }

    console_output_buffer_binder(const console_output_buffer_binder&) = delete;
    console_output_buffer_binder& operator=(const console_output_buffer_binder&) = delete;

    struct scope_binder
    {
        const buf_ptr_t new_buf_p;
        const buf_ptr_t old_buf_p;

        explicit scope_binder(std::streambuf* new_buf) : new_buf_p(new_buf), old_buf_p(cout.rdbuf(new_buf)) {}
        ~scope_binder() { cout.rdbuf(old_buf_p); }
    };

    void bind_to(const size_t i) { cout.rdbuf(&buffers_[i]); }

    auto scope_bind_to(const size_t i) { return scope_binder{&buffers_[i]}; }

    void add_to_front() { buffers_.emplace_back(); }

    auto scope_add_front()
    {
        add_to_front();
        return scope_bind_to(buffers_.size() - 1);
    }

    ~console_output_buffer_binder()
    {
        cout.rdbuf(console_buf_);
        const auto size = buffers_.size();
        for(auto i = size - 1; i < size; --i) cout << buffers_[i].str();
    }
};

template<typename From, typename To>
struct is_convertible_to_ref : std::bool_constant<
        std::is_convertible_v<From, std::decay_t<To>&&> ||
        std::is_convertible_v<From, std::decay_t<To>&>
    > {};

template<typename From, typename To>
constexpr auto is_convertible_to_ref_v = is_convertible_to_ref<From, To>::value;

#ifdef __cpp_lib_concepts
#include <concepts>
#include <ranges>

template<typename From, typename To>
concept ConvertibleToRef = is_convertible_to_ref_v<From, To>;

template<typename T, ConvertibleToRef<std::istream> InputStream, typename... Args>
requires requires(InputStream is, T t)
{
    std::constructible_from<T, Args...>;
    is >> t;
}
#else
template<
    typename T,
    typename InputStream,
    typename... Args,
    std::enable_if_t<std::is_constructible_v<T, Args...>>* = nullptr,
    std::enable_if_t<is_convertible_to_ref_v<InputStream, std::istream>>* = nullptr
>
#endif
[[nodiscard]] T get_from_stream(InputStream&& is, Args&&... args)
{
    T t(std::forward<Args>(args)...);
    is >> t;
    return t;
}

template<typename T>
struct auto_cast
{
    T&& t;

#ifdef __cpp_lib_concepts
    template<typename U> requires requires { static_cast<std::decay_t<U>>(std::forward<T>(t)); }
#else
    template<typename U, std::enable_if_t<std::is_convertible_v<T, std::decay_t<U>>>* = nullptr>
#endif
    constexpr operator U() noexcept(std::is_nothrow_constructible_v<T, std::decay_t<U>>)
    {
        return static_cast<std::decay_t<U>>(std::forward<T>(t));
    }
};

template<
    typename ReturnT,
    typename Left,
    typename Right,
    typename Op
#ifdef __cpp_lib_concepts
> requires std::convertible_to<std::conditional_t<
    std::is_convertible_v<Left, ReturnT>,
    std::invoke_result_t<Op, ReturnT, Right>,
    std::invoke_result_t<Op, Left, ReturnT>
>, ReturnT>
#else
    ,
    std::enable_if_t<std::is_convertible_v<std::conditional_t<
        std::is_convertible_v<Left, ReturnT>,
        std::invoke_result_t<Op, ReturnT, Right>,
        std::invoke_result_t<Op, Left, ReturnT>
    >, ReturnT>>* = nullptr
>
#endif
constexpr ReturnT cast_op(Left&& left, Right&& right, Op op)
{
    if constexpr(std::is_convertible_v<Left, ReturnT>)
        return op(static_cast<ReturnT>(std::forward<Left>(left)), std::forward<Right>(right));
    else return op(std::forward<Left>(left), static_cast<ReturnT>(std::forward<Right>(right)));
}

class marketing_scheme
{
    uint64_t min_, max_;

public:
    constexpr marketing_scheme(const uint64_t min, const uint64_t max) noexcept: min_(min), max_(max) {}

    constexpr void solve() const noexcept
    {
        auto pack = 2 * (max_ - min_);
        for(; max_ / pack != min_ / pack; ++ pack);

        for(; pack <= 2 * min_; ++pack)
        {
            const auto half = (pack + 1) / 2;

            if(pack % max_ >= half && pack % min_ >= half)
            {
                cout << "YES\n";
                return;
            }
        }

        cout << "NO\n";
    }

#ifdef __cpp_lib_concepts
    template<ConvertibleToRef<std::istream> InputStream>
#else
    template<
        typename InputStream,
        std::enable_if_t<std::is_convertible_v<InputStream, std::istream&&> || std::is_convertible_v<InputStream, std::istream&>>* = nullptr
    >
#endif
    static void create_from_input(InputStream&& is)
    {
        for(auto i = get_from_stream<uint64_t>(is); i > 0; --i)
            marketing_scheme{get_from_stream<uint64_t>(is), get_from_stream<uint64_t>(is)}.solve();
    }
};

int main()
{
    if constexpr(is_debug)
    {
        marketing_scheme::create_from_input(std::istringstream{"3 3 4 1 2 120 150"});
    }
    else marketing_scheme::create_from_input(cin);
    return 0;
}


// Created by BlurringShadow at 2020-10-26-上午 10:09

#ifndef _DEBUG
#define NDEBUG
#endif

constexpr auto is_debug =
#ifdef NDEBUG
    false
#else
    true
#endif
;

#include <iostream>
#include <sstream>
#include <string>
#include <type_traits>
#include <vector>

using namespace std::literals; // NOLINT(clang-diagnostic-header-hygiene)
using std::size_t;
using std::vector;
using std::string;
using std::cout;
using std::cin;

[[maybe_unused]] const auto static_ini_ = []()
{
    std::ios::sync_with_stdio(false);
    std::cin.tie(nullptr);
    return std::cout.tie(nullptr);
}();

class console_output_buffer_binder final
{
    using buf_ptr_t = std::streambuf*;

    vector<std::stringbuf> buffers_;
    const buf_ptr_t console_buf_ = cout.rdbuf();

public:
    explicit console_output_buffer_binder(const size_t additional_count = 0) noexcept :
        buffers_(additional_count + 1),
        console_buf_(std::cout.rdbuf(&buffers_.front())) { bind_to(0); }

    console_output_buffer_binder(const console_output_buffer_binder&) = delete;
    console_output_buffer_binder& operator=(const console_output_buffer_binder&) = delete;

    struct scope_binder
    {
        const buf_ptr_t new_buf_p;
        const buf_ptr_t old_buf_p;

        explicit scope_binder(std::streambuf* new_buf) : new_buf_p(new_buf), old_buf_p(cout.rdbuf(new_buf)) {}
        ~scope_binder() { cout.rdbuf(old_buf_p); }
    };

    void bind_to(const size_t i) { cout.rdbuf(&buffers_[i]); }

    auto scope_bind_to(const size_t i) { return scope_binder{&buffers_[i]}; }

    void add_to_front() { buffers_.emplace_back(); }

    auto scope_add_front()
    {
        add_to_front();
        return scope_bind_to(buffers_.size() - 1);
    }

    ~console_output_buffer_binder()
    {
        cout.rdbuf(console_buf_);
        const auto size = buffers_.size();
        for(auto i = size - 1; i < size; --i) cout << buffers_[i].str();
    }
};

template<typename From, typename To>
struct is_convertible_to_ref : std::bool_constant<
        std::is_convertible_v<From, std::decay_t<To>&&> ||
        std::is_convertible_v<From, std::decay_t<To>&>
    > {};

template<typename From, typename To>
constexpr auto is_convertible_to_ref_v = is_convertible_to_ref<From, To>::value;

#ifdef __cpp_lib_concepts
#include <concepts>
#include <ranges>

template<typename From, typename To>
concept ConvertibleToRef = is_convertible_to_ref_v<From, To>;

template<typename T, ConvertibleToRef<std::istream> InputStream, typename... Args>
requires requires(InputStream is, T t)
{
    std::constructible_from<T, Args...>;
    is >> t;
}
#else
template<
    typename T,
    typename InputStream,
    typename... Args,
    std::enable_if_t<std::is_constructible_v<T, Args...>>* = nullptr,
    std::enable_if_t<is_convertible_to_ref_v<InputStream, std::istream>>* = nullptr
>
#endif
[[nodiscard]] T get_from_stream(InputStream&& is, Args&&... args)
{
    T t(std::forward<Args>(args)...);
    is >> t;
    return t;
}

template<typename T>
struct auto_cast
{
    T&& t;

#ifdef __cpp_lib_concepts
    template<typename U> requires requires { static_cast<std::decay_t<U>>(std::forward<T>(t)); }
#else
    template<typename U, std::enable_if_t<std::is_convertible_v<T, std::decay_t<U>>>* = nullptr>
#endif
    constexpr operator U() noexcept(std::is_nothrow_constructible_v<T, std::decay_t<U>>)
    {
        return static_cast<std::decay_t<U>>(std::forward<T>(t));
    }
};

template<
    typename ReturnT,
    typename Left,
    typename Right,
    typename Op
#ifdef __cpp_lib_concepts
> requires std::convertible_to<std::conditional_t<
    std::is_convertible_v<Left, ReturnT>,
    std::invoke_result_t<Op, ReturnT, Right>,
    std::invoke_result_t<Op, Left, ReturnT>
>, ReturnT>
#else
    ,
    std::enable_if_t<std::is_convertible_v<std::conditional_t<
        std::is_convertible_v<Left, ReturnT>,
        std::invoke_result_t<Op, ReturnT, Right>,
        std::invoke_result_t<Op, Left, ReturnT>
    >, ReturnT>>* = nullptr
>
#endif
constexpr ReturnT cast_op(Left&& left, Right&& right, Op op)
{
    if constexpr(std::is_convertible_v<Left, ReturnT>)
        return op(static_cast<ReturnT>(std::forward<Left>(left)), std::forward<Right>(right));
    else return op(std::forward<Left>(left), static_cast<ReturnT>(std::forward<Right>(right)));
}

class marketing_scheme
{
    uint64_t min_, max_;

public:
    constexpr marketing_scheme(const uint64_t min, const uint64_t max) noexcept: min_(min), max_(max) {}

    constexpr void solve() const noexcept
    {
        for(uint64_t pack = 2; pack < 2 * min_; ++pack)
        {
            const auto half = (pack + 1) / 2;

            if(pack % max_ >= half && pack % min_ >= half)
            {
                cout << "YES\n";
                return;
            }
        }

        cout << "NO\n";
    }

#ifdef __cpp_lib_concepts
    template<ConvertibleToRef<std::istream> InputStream>
#else
    template<
        typename InputStream,
        std::enable_if_t<std::is_convertible_v<InputStream, std::istream&&> || std::is_convertible_v<InputStream, std::istream&>>* = nullptr
    >
#endif
    static void create_from_input(InputStream&& is)
    {
        for(auto i = get_from_stream<uint64_t>(is); i > 0; --i)
            marketing_scheme{get_from_stream<uint64_t>(is), get_from_stream<uint64_t>(is)}.solve();
    }
};

int main()
{
    if constexpr(is_debug)
    {
        marketing_scheme::create_from_input(std::istringstream{"3 3 4 1 2 120 150"});
    }
    else marketing_scheme::create_from_input(cin);
    return 0;
}


// Created by BlurringShadow at 2020-10-26-上午 10:09

#ifndef _DEBUG
#define NDEBUG
#endif

constexpr auto is_debug =
#ifdef NDEBUG
    false
#else
    true
#endif
;

#include <iostream>
#include <sstream>
#include <string>
#include <type_traits>
#include <vector>

using namespace std::literals; // NOLINT(clang-diagnostic-header-hygiene)
using std::size_t;
using std::vector;
using std::string;
using std::cout;
using std::cin;

[[maybe_unused]] const auto static_ini_ = []()
{
    std::ios::sync_with_stdio(false);
    std::cin.tie(nullptr);
    return std::cout.tie(nullptr);
}();

class console_output_buffer_binder final
{
    using buf_ptr_t = std::streambuf*;

    vector<std::stringbuf> buffers_;
    const buf_ptr_t console_buf_ = cout.rdbuf();

public:
    explicit console_output_buffer_binder(const size_t additional_count = 0) noexcept :
        buffers_(additional_count + 1),
        console_buf_(std::cout.rdbuf(&buffers_.front())) { bind_to(0); }

    console_output_buffer_binder(const console_output_buffer_binder&) = delete;
    console_output_buffer_binder& operator=(const console_output_buffer_binder&) = delete;

    struct scope_binder
    {
        const buf_ptr_t new_buf_p;
        const buf_ptr_t old_buf_p;

        explicit scope_binder(std::streambuf* new_buf) : new_buf_p(new_buf), old_buf_p(cout.rdbuf(new_buf)) {}
        ~scope_binder() { cout.rdbuf(old_buf_p); }
    };

    void bind_to(const size_t i) { cout.rdbuf(&buffers_[i]); }

    auto scope_bind_to(const size_t i) { return scope_binder{&buffers_[i]}; }

    void add_to_front() { buffers_.emplace_back(); }

    auto scope_add_front()
    {
        add_to_front();
        return scope_bind_to(buffers_.size() - 1);
    }

    ~console_output_buffer_binder()
    {
        cout.rdbuf(console_buf_);
        const auto size = buffers_.size();
        for(auto i = size - 1; i < size; --i) cout << buffers_[i].str();
    }
};

template<typename From, typename To>
struct is_convertible_to_ref : std::bool_constant<
        std::is_convertible_v<From, std::decay_t<To>&&> ||
        std::is_convertible_v<From, std::decay_t<To>&>
    > {};

template<typename From, typename To>
constexpr auto is_convertible_to_ref_v = is_convertible_to_ref<From, To>::value;

#ifdef __cpp_lib_concepts
#include <concepts>
#include <ranges>

template<typename From, typename To>
concept ConvertibleToRef = is_convertible_to_ref_v<From, To>;

template<typename T, ConvertibleToRef<std::istream> InputStream, typename... Args>
requires requires(InputStream is, T t)
{
    std::constructible_from<T, Args...>;
    is >> t;
}
#else
template<
    typename T,
    typename InputStream,
    typename... Args,
    std::enable_if_t<std::is_constructible_v<T, Args...>>* = nullptr,
    std::enable_if_t<is_convertible_to_ref_v<InputStream, std::istream>>* = nullptr
>
#endif
[[nodiscard]] T get_from_stream(InputStream&& is, Args&&... args)
{
    T t(std::forward<Args>(args)...);
    is >> t;
    return t;
}

template<typename T>
struct auto_cast
{
    T&& t;

#ifdef __cpp_lib_concepts
    template<typename U> requires requires { static_cast<std::decay_t<U>>(std::forward<T>(t)); }
#else
    template<typename U, std::enable_if_t<std::is_convertible_v<T, std::decay_t<U>>>* = nullptr>
#endif
    constexpr operator U() noexcept(std::is_nothrow_constructible_v<T, std::decay_t<U>>)
    {
        return static_cast<std::decay_t<U>>(std::forward<T>(t));
    }
};

template<
    typename ReturnT,
    typename Left,
    typename Right,
    typename Op
#ifdef __cpp_lib_concepts
> requires std::convertible_to<std::conditional_t<
    std::is_convertible_v<Left, ReturnT>,
    std::invoke_result_t<Op, ReturnT, Right>,
    std::invoke_result_t<Op, Left, ReturnT>
>, ReturnT>
#else
    ,
    std::enable_if_t<std::is_convertible_v<std::conditional_t<
        std::is_convertible_v<Left, ReturnT>,
        std::invoke_result_t<Op, ReturnT, Right>,
        std::invoke_result_t<Op, Left, ReturnT>
    >, ReturnT>>* = nullptr
>
#endif
constexpr ReturnT cast_op(Left&& left, Right&& right, Op op)
{
    if constexpr(std::is_convertible_v<Left, ReturnT>)
        return op(static_cast<ReturnT>(std::forward<Left>(left)), std::forward<Right>(right));
    else return op(std::forward<Left>(left), static_cast<ReturnT>(std::forward<Right>(right)));
}

class marketing_scheme
{
    uint64_t min_, max_;

public:
    constexpr marketing_scheme(const uint64_t min, const uint64_t max) noexcept: min_(min), max_(max) {}

    constexpr void solve() const noexcept
    {
        const auto offset = max_ - min_;

        for(auto pack = 2 * (max_ - min_) + 1; pack < 2 * min_; ++pack)
        {
            const auto half = (pack + 1) / 2;

            if(pack % max_ >= half && pack % min_ >= half)
            {
                cout << "YES\n";
                return;
            }
        }

        cout << "NO\n";
    }

#ifdef __cpp_lib_concepts
    template<ConvertibleToRef<std::istream> InputStream>
#else
    template<
        typename InputStream,
        std::enable_if_t<std::is_convertible_v<InputStream, std::istream&&> || std::is_convertible_v<InputStream, std::istream&>>* = nullptr
    >
#endif
    static void create_from_input(InputStream&& is)
    {
        for(auto i = get_from_stream<uint64_t>(is); i > 0; --i)
            marketing_scheme{get_from_stream<uint64_t>(is), get_from_stream<uint64_t>(is)}.solve();
    }
};

int main()
{
    if constexpr(is_debug)
    {
        marketing_scheme::create_from_input(std::istringstream{"3 3 4 1 2 120 150"});
    }
    else marketing_scheme::create_from_input(cin);
    return 0;
}


// Created by BlurringShadow at 2020-10-26-上午 10:09

#ifndef _DEBUG
#define NDEBUG
#endif

constexpr auto is_debug =
#ifdef NDEBUG
    false
#else
    true
#endif
;

#include <iostream>
#include <sstream>
#include <string>
#include <type_traits>
#include <vector>

using namespace std::literals; // NOLINT(clang-diagnostic-header-hygiene)
using std::size_t;
using std::vector;
using std::string;
using std::cout;
using std::cin;

[[maybe_unused]] const auto static_ini_ = []()
{
    std::ios::sync_with_stdio(false);
    std::cin.tie(nullptr);
    return std::cout.tie(nullptr);
}();

class console_output_buffer_binder final
{
    using buf_ptr_t = std::streambuf*;

    vector<std::stringbuf> buffers_;
    const buf_ptr_t console_buf_ = cout.rdbuf();

public:
    explicit console_output_buffer_binder(const size_t additional_count = 0) noexcept :
        buffers_(additional_count + 1),
        console_buf_(std::cout.rdbuf(&buffers_.front())) { bind_to(0); }

    console_output_buffer_binder(const console_output_buffer_binder&) = delete;
    console_output_buffer_binder& operator=(const console_output_buffer_binder&) = delete;

    struct scope_binder
    {
        const buf_ptr_t new_buf_p;
        const buf_ptr_t old_buf_p;

        explicit scope_binder(std::streambuf* new_buf) : new_buf_p(new_buf), old_buf_p(cout.rdbuf(new_buf)) {}
        ~scope_binder() { cout.rdbuf(old_buf_p); }
    };

    void bind_to(const size_t i) { cout.rdbuf(&buffers_[i]); }

    auto scope_bind_to(const size_t i) { return scope_binder{&buffers_[i]}; }

    void add_to_front() { buffers_.emplace_back(); }

    auto scope_add_front()
    {
        add_to_front();
        return scope_bind_to(buffers_.size() - 1);
    }

    ~console_output_buffer_binder()
    {
        cout.rdbuf(console_buf_);
        const auto size = buffers_.size();
        for(auto i = size - 1; i < size; --i) cout << buffers_[i].str();
    }
};

template<typename From, typename To>
struct is_convertible_to_ref : std::bool_constant<
        std::is_convertible_v<From, std::decay_t<To>&&> ||
        std::is_convertible_v<From, std::decay_t<To>&>
    > {};

template<typename From, typename To>
constexpr auto is_convertible_to_ref_v = is_convertible_to_ref<From, To>::value;

#ifdef __cpp_lib_concepts
#include <concepts>
#include <ranges>

template<typename From, typename To>
concept ConvertibleToRef = is_convertible_to_ref_v<From, To>;

template<typename T, ConvertibleToRef<std::istream> InputStream, typename... Args>
requires requires(InputStream is, T t)
{
    std::constructible_from<T, Args...>;
    is >> t;
}
#else
template<
    typename T,
    typename InputStream,
    typename... Args,
    std::enable_if_t<std::is_constructible_v<T, Args...>>* = nullptr,
    std::enable_if_t<is_convertible_to_ref_v<InputStream, std::istream>>* = nullptr
>
#endif
[[nodiscard]] T get_from_stream(InputStream&& is, Args&&... args)
{
    T t(std::forward<Args>(args)...);
    is >> t;
    return t;
}

template<typename T>
struct auto_cast
{
    T&& t;

#ifdef __cpp_lib_concepts
    template<typename U> requires requires { static_cast<std::decay_t<U>>(std::forward<T>(t)); }
#else
    template<typename U, std::enable_if_t<std::is_convertible_v<T, std::decay_t<U>>>* = nullptr>
#endif
    constexpr operator U() noexcept(std::is_nothrow_constructible_v<T, std::decay_t<U>>)
    {
        return static_cast<std::decay_t<U>>(std::forward<T>(t));
    }
};

template<
    typename ReturnT,
    typename Left,
    typename Right,
    typename Op
#ifdef __cpp_lib_concepts
> requires std::convertible_to<std::conditional_t<
    std::is_convertible_v<Left, ReturnT>,
    std::invoke_result_t<Op, ReturnT, Right>,
    std::invoke_result_t<Op, Left, ReturnT>
>, ReturnT>
#else
    ,
    std::enable_if_t<std::is_convertible_v<std::conditional_t<
        std::is_convertible_v<Left, ReturnT>,
        std::invoke_result_t<Op, ReturnT, Right>,
        std::invoke_result_t<Op, Left, ReturnT>
    >, ReturnT>>* = nullptr
>
#endif
constexpr ReturnT cast_op(Left&& left, Right&& right, Op op)
{
    if constexpr(std::is_convertible_v<Left, ReturnT>)
        return op(static_cast<ReturnT>(std::forward<Left>(left)), std::forward<Right>(right));
    else return op(std::forward<Left>(left), static_cast<ReturnT>(std::forward<Right>(right)));
}

class marketing_scheme
{
    uint64_t min_, max_;

public:
    constexpr marketing_scheme(const uint64_t min, const uint64_t max) noexcept: min_(min), max_(max) {}

    void solve() const noexcept
    {
        for(auto pack = max_ + 1; ; ++pack)
        {
            const auto half = (pack + 1) / 2;

            if(half > min_) break;
            if(max_ % pack >= half && min_ % pack >= half)
            {
                cout << "YES\n";
                return;
            }
        }

        cout << "NO\n";
    }

#ifdef __cpp_lib_concepts
    template<ConvertibleToRef<std::istream> InputStream>
#else
    template<
        typename InputStream,
        std::enable_if_t<std::is_convertible_v<InputStream, std::istream&&> || std::is_convertible_v<InputStream, std::istream&>>* = nullptr
    >
#endif
    static void create_from_input(InputStream&& is)
    {
        for(auto i = get_from_stream<uint64_t>(is); i > 0; --i)
            marketing_scheme{get_from_stream<uint64_t>(is), get_from_stream<uint64_t>(is)}.solve();
    }
};

int main()
{
    if constexpr(is_debug)
    {
        marketing_scheme::create_from_input(std::istringstream{"3 3 4 1 2 120 150"});
    }
    else marketing_scheme::create_from_input(cin);
    return 0;
}


// Created by BlurringShadow at 2020-10-26-上午 10:09

#ifndef _DEBUG
#define NDEBUG
#endif

constexpr auto is_debug =
#ifdef NDEBUG
    false
#else
    true
#endif
;

#include <iostream>
#include <sstream>
#include <string>
#include <type_traits>
#include <vector>

using namespace std::literals; // NOLINT(clang-diagnostic-header-hygiene)
using std::size_t;
using std::vector;
using std::string;
using std::cout;
using std::cin;

[[maybe_unused]] const auto static_ini_ = []()
{
    std::ios::sync_with_stdio(false);
    std::cin.tie(nullptr);
    return std::cout.tie(nullptr);
}();

class console_output_buffer_binder final
{
    using buf_ptr_t = std::streambuf*;

    vector<std::stringbuf> buffers_;
    const buf_ptr_t console_buf_ = cout.rdbuf();

public:
    explicit console_output_buffer_binder(const size_t additional_count = 0) noexcept :
        buffers_(additional_count + 1),
        console_buf_(std::cout.rdbuf(&buffers_.front())) { bind_to(0); }

    console_output_buffer_binder(const console_output_buffer_binder&) = delete;
    console_output_buffer_binder& operator=(const console_output_buffer_binder&) = delete;

    struct scope_binder
    {
        const buf_ptr_t new_buf_p;
        const buf_ptr_t old_buf_p;

        explicit scope_binder(std::streambuf* new_buf) : new_buf_p(new_buf), old_buf_p(cout.rdbuf(new_buf)) {}
        ~scope_binder() { cout.rdbuf(old_buf_p); }
    };

    void bind_to(const size_t i) { cout.rdbuf(&buffers_[i]); }

    auto scope_bind_to(const size_t i) { return scope_binder{&buffers_[i]}; }

    void add_to_front() { buffers_.emplace_back(); }

    auto scope_add_front()
    {
        add_to_front();
        return scope_bind_to(buffers_.size() - 1);
    }

    ~console_output_buffer_binder()
    {
        cout.rdbuf(console_buf_);
        const auto size = buffers_.size();
        for(auto i = size - 1; i < size; --i) cout << buffers_[i].str();
    }
};

template<typename From, typename To>
struct is_convertible_to_ref : std::bool_constant<
        std::is_convertible_v<From, std::decay_t<To>&&> ||
        std::is_convertible_v<From, std::decay_t<To>&>
    > {};

template<typename From, typename To>
constexpr auto is_convertible_to_ref_v = is_convertible_to_ref<From, To>::value;

#ifdef __cpp_lib_concepts
#include <concepts>
#include <ranges>

template<typename From, typename To>
concept ConvertibleToRef = is_convertible_to_ref_v<From, To>;

template<typename T, ConvertibleToRef<std::istream> InputStream, typename... Args>
requires requires(InputStream is, T t)
{
    std::constructible_from<T, Args...>;
    is >> t;
}
#else
template<
    typename T,
    typename InputStream,
    typename... Args,
    std::enable_if_t<std::is_constructible_v<T, Args...>>* = nullptr,
    std::enable_if_t<is_convertible_to_ref_v<InputStream, std::istream>>* = nullptr
>
#endif
[[nodiscard]] T get_from_stream(InputStream&& is, Args&&... args)
{
    T t(std::forward<Args>(args)...);
    is >> t;
    return t;
}

template<typename T>
struct auto_cast
{
    T&& t;

#ifdef __cpp_lib_concepts
    template<typename U> requires requires { static_cast<std::decay_t<U>>(std::forward<T>(t)); }
#else
    template<typename U, std::enable_if_t<std::is_convertible_v<T, std::decay_t<U>>>* = nullptr>
#endif
    constexpr operator U() noexcept(std::is_nothrow_constructible_v<T, std::decay_t<U>>)
    {
        return static_cast<std::decay_t<U>>(std::forward<T>(t));
    }
};

template<
    typename ReturnT,
    typename Left,
    typename Right,
    typename Op
#ifdef __cpp_lib_concepts
> requires std::convertible_to<std::conditional_t<
    std::is_convertible_v<Left, ReturnT>,
    std::invoke_result_t<Op, ReturnT, Right>,
    std::invoke_result_t<Op, Left, ReturnT>
>, ReturnT>
#else
    ,
    std::enable_if_t<std::is_convertible_v<std::conditional_t<
        std::is_convertible_v<Left, ReturnT>,
        std::invoke_result_t<Op, ReturnT, Right>,
        std::invoke_result_t<Op, Left, ReturnT>
    >, ReturnT>>* = nullptr
>
#endif
constexpr ReturnT cast_op(Left&& left, Right&& right, Op op)
{
    if constexpr(std::is_convertible_v<Left, ReturnT>)
        return op(static_cast<ReturnT>(std::forward<Left>(left)), std::forward<Right>(right));
    else return op(std::forward<Left>(left), static_cast<ReturnT>(std::forward<Right>(right)));
}

class marketing_scheme
{
    uint64_t min_, max_;

public:
    constexpr marketing_scheme(const uint64_t min, const uint64_t max) noexcept: min_(min), max_(max) {}

    constexpr void solve() const noexcept
    {
        for(auto pack = max_ + 1; ; --pack)
        {
            const auto half = (pack + 1) / 2;

            if(half <= min_) break;
            if(max_ % pack >= half && min_ % pack >= half)
            {
                cout << "YES\n";
                return;
            }
        }

        cout << "NO\n";
    }

#ifdef __cpp_lib_concepts
    template<ConvertibleToRef<std::istream> InputStream>
#else
    template<
        typename InputStream,
        std::enable_if_t<std::is_convertible_v<InputStream, std::istream&&> || std::is_convertible_v<InputStream, std::istream&>>* = nullptr
    >
#endif
    static void create_from_input(InputStream&& is)
    {
        for(auto i = get_from_stream<uint64_t>(is); i > 0; --i)
            marketing_scheme{get_from_stream<uint64_t>(is), get_from_stream<uint64_t>(is)}.solve();
    }
};

int main()
{
    if constexpr(is_debug)
    {
        marketing_scheme::create_from_input(std::istringstream{"3 3 4 1 2 120 150"});
    }
    else marketing_scheme::create_from_input(cin);
    return 0;
}


// Created by BlurringShadow at 2020-10-26-上午 10:09

#ifndef _DEBUG
#define NDEBUG
#endif

constexpr auto is_debug =
#ifdef NDEBUG
    false
#else
    true
#endif
;

#include <iostream>
#include <sstream>
#include <string>
#include <type_traits>
#include <vector>

using namespace std::literals; // NOLINT(clang-diagnostic-header-hygiene)
using std::size_t;
using std::vector;
using std::string;
using std::cout;
using std::cin;

[[maybe_unused]] const auto static_ini_ = []()
{
    std::ios::sync_with_stdio(false);
    std::cin.tie(nullptr);
    return std::cout.tie(nullptr);
}();

class console_output_buffer_binder final
{
    using buf_ptr_t = std::streambuf*;

    vector<std::stringbuf> buffers_;
    const buf_ptr_t console_buf_ = cout.rdbuf();

public:
    explicit console_output_buffer_binder(const size_t additional_count = 0) noexcept :
        buffers_(additional_count + 1),
        console_buf_(std::cout.rdbuf(&buffers_.front())) { bind_to(0); }

    console_output_buffer_binder(const console_output_buffer_binder&) = delete;
    console_output_buffer_binder& operator=(const console_output_buffer_binder&) = delete;

    struct scope_binder
    {
        const buf_ptr_t new_buf_p;
        const buf_ptr_t old_buf_p;

        explicit scope_binder(std::streambuf* new_buf) : new_buf_p(new_buf), old_buf_p(cout.rdbuf(new_buf)) {}
        ~scope_binder() { cout.rdbuf(old_buf_p); }
    };

    void bind_to(const size_t i) { cout.rdbuf(&buffers_[i]); }

    auto scope_bind_to(const size_t i) { return scope_binder{&buffers_[i]}; }

    void add_to_front() { buffers_.emplace_back(); }

    auto scope_add_front()
    {
        add_to_front();
        return scope_bind_to(buffers_.size() - 1);
    }

    ~console_output_buffer_binder()
    {
        cout.rdbuf(console_buf_);
        const auto size = buffers_.size();
        for(auto i = size - 1; i < size; --i) cout << buffers_[i].str();
    }
};

template<typename From, typename To>
struct is_convertible_to_ref : std::bool_constant<
        std::is_convertible_v<From, std::decay_t<To>&&> ||
        std::is_convertible_v<From, std::decay_t<To>&>
    > {};

template<typename From, typename To>
constexpr auto is_convertible_to_ref_v = is_convertible_to_ref<From, To>::value;

#ifdef __cpp_lib_concepts
#include <concepts>
#include <ranges>

template<typename From, typename To>
concept ConvertibleToRef = is_convertible_to_ref_v<From, To>;

template<typename T, ConvertibleToRef<std::istream> InputStream, typename... Args>
requires requires(InputStream is, T t)
{
    std::constructible_from<T, Args...>;
    is >> t;
}
#else
template<
    typename T,
    typename InputStream,
    typename... Args,
    std::enable_if_t<std::is_constructible_v<T, Args...>>* = nullptr,
    std::enable_if_t<is_convertible_to_ref_v<InputStream, std::istream>>* = nullptr
>
#endif
[[nodiscard]] T get_from_stream(InputStream&& is, Args&&... args)
{
    T t(std::forward<Args>(args)...);
    is >> t;
    return t;
}

template<typename T>
struct auto_cast
{
    T&& t;

#ifdef __cpp_lib_concepts
    template<typename U> requires requires { static_cast<std::decay_t<U>>(std::forward<T>(t)); }
#else
    template<typename U, std::enable_if_t<std::is_convertible_v<T, std::decay_t<U>>>* = nullptr>
#endif
    constexpr operator U() noexcept(std::is_nothrow_constructible_v<T, std::decay_t<U>>)
    {
        return static_cast<std::decay_t<U>>(std::forward<T>(t));
    }
};

template<
    typename ReturnT,
    typename Left,
    typename Right,
    typename Op
#ifdef __cpp_lib_concepts
> requires std::convertible_to<std::conditional_t<
    std::is_convertible_v<Left, ReturnT>,
    std::invoke_result_t<Op, ReturnT, Right>,
    std::invoke_result_t<Op, Left, ReturnT>
>, ReturnT>
#else
    ,
    std::enable_if_t<std::is_convertible_v<std::conditional_t<
        std::is_convertible_v<Left, ReturnT>,
        std::invoke_result_t<Op, ReturnT, Right>,
        std::invoke_result_t<Op, Left, ReturnT>
    >, ReturnT>>* = nullptr
>
#endif
constexpr ReturnT cast_op(Left&& left, Right&& right, Op op)
{
    if constexpr(std::is_convertible_v<Left, ReturnT>)
        return op(static_cast<ReturnT>(std::forward<Left>(left)), std::forward<Right>(right));
    else return op(std::forward<Left>(left), static_cast<ReturnT>(std::forward<Right>(right)));
}

class marketing_scheme
{
    uint64_t min_, max_;

public:
    constexpr marketing_scheme(const uint64_t min, const uint64_t max) noexcept: min_(min), max_(max) {}

    constexpr void solve() const noexcept
    {
        for(auto pack = 2 * (max_ - min_); pack < min_; ++pack)
        {
            const auto half = (pack + 1) / 2;
            if(pack % max_ >= half && pack % min_ >= half)
            {
                cout << "YES\n";
                return;
            }
        }
        cout << "NO\n";
    }

#ifdef __cpp_lib_concepts
    template<ConvertibleToRef<std::istream> InputStream>
#else
    template<
        typename InputStream,
        std::enable_if_t<std::is_convertible_v<InputStream, std::istream&&> || std::is_convertible_v<InputStream, std::istream&>>* = nullptr
    >
#endif
    static void create_from_input(InputStream&& is)
    {
        for(auto i = get_from_stream<uint64_t>(is); i > 0; --i)
            marketing_scheme{get_from_stream<uint64_t>(is), get_from_stream<uint64_t>(is)}.solve();
    }
};

int main()
{
    if constexpr(is_debug)
    {
        marketing_scheme::create_from_input(std::istringstream{"3 3 4 1 2 120 150"});
    }
    else marketing_scheme::create_from_input(cin);
    return 0;
}


// Created by BlurringShadow at 2020-10-26-上午 10:09

#ifndef _DEBUG
#define NDEBUG
#endif

constexpr auto is_debug =
#ifdef NDEBUG
    false
#else
    true
#endif
;

#include <iostream>
#include <sstream>
#include <string>
#include <type_traits>
#include <vector>

using namespace std::literals; // NOLINT(clang-diagnostic-header-hygiene)
using std::size_t;
using std::vector;
using std::string;
using std::cout;
using std::cin;

[[maybe_unused]] const auto static_ini_ = []()
{
    std::ios::sync_with_stdio(false);
    std::cin.tie(nullptr);
    return std::cout.tie(nullptr);
}();

class console_output_buffer_binder final
{
    using buf_ptr_t = std::streambuf*;

    vector<std::stringbuf> buffers_;
    const buf_ptr_t console_buf_ = cout.rdbuf();

public:
    explicit console_output_buffer_binder(const size_t additional_count = 0) noexcept :
        buffers_(additional_count + 1),
        console_buf_(std::cout.rdbuf(&buffers_.front())) { bind_to(0); }

    console_output_buffer_binder(const console_output_buffer_binder&) = delete;
    console_output_buffer_binder& operator=(const console_output_buffer_binder&) = delete;

    struct scope_binder
    {
        const buf_ptr_t new_buf_p;
        const buf_ptr_t old_buf_p;

        explicit scope_binder(std::streambuf* new_buf) : new_buf_p(new_buf), old_buf_p(cout.rdbuf(new_buf)) {}
        ~scope_binder() { cout.rdbuf(old_buf_p); }
    };

    void bind_to(const size_t i) { cout.rdbuf(&buffers_[i]); }

    auto scope_bind_to(const size_t i) { return scope_binder{&buffers_[i]}; }

    void add_to_front() { buffers_.emplace_back(); }

    auto scope_add_front()
    {
        add_to_front();
        return scope_bind_to(buffers_.size() - 1);
    }

    ~console_output_buffer_binder()
    {
        cout.rdbuf(console_buf_);
        const auto size = buffers_.size();
        for(auto i = size - 1; i < size; --i) cout << buffers_[i].str();
    }
};

template<typename From, typename To>
struct is_convertible_to_ref : std::bool_constant<
        std::is_convertible_v<From, std::decay_t<To>&&> ||
        std::is_convertible_v<From, std::decay_t<To>&>
    > {};

template<typename From, typename To>
constexpr auto is_convertible_to_ref_v = is_convertible_to_ref<From, To>::value;

#ifdef __cpp_lib_concepts
#include <concepts>
#include <ranges>

template<typename From, typename To>
concept ConvertibleToRef = is_convertible_to_ref_v<From, To>;

template<typename T, ConvertibleToRef<std::istream> InputStream, typename... Args>
requires requires(InputStream is, T t)
{
    std::constructible_from<T, Args...>;
    is >> t;
}
#else
template<
    typename T,
    typename InputStream,
    typename... Args,
    std::enable_if_t<std::is_constructible_v<T, Args...>>* = nullptr,
    std::enable_if_t<is_convertible_to_ref_v<InputStream, std::istream>>* = nullptr
>
#endif
[[nodiscard]] T get_from_stream(InputStream&& is, Args&&... args)
{
    T t(std::forward<Args>(args)...);
    is >> t;
    return t;
}

template<typename T>
struct auto_cast
{
    T&& t;

#ifdef __cpp_lib_concepts
    template<typename U> requires requires { static_cast<std::decay_t<U>>(std::forward<T>(t)); }
#else
    template<typename U, std::enable_if_t<std::is_convertible_v<T, std::decay_t<U>>>* = nullptr>
#endif
    constexpr operator U() noexcept(std::is_nothrow_constructible_v<T, std::decay_t<U>>)
    {
        return static_cast<std::decay_t<U>>(std::forward<T>(t));
    }
};

template<
    typename ReturnT,
    typename Left,
    typename Right,
    typename Op
#ifdef __cpp_lib_concepts
> requires std::convertible_to<std::conditional_t<
    std::is_convertible_v<Left, ReturnT>,
    std::invoke_result_t<Op, ReturnT, Right>,
    std::invoke_result_t<Op, Left, ReturnT>
>, ReturnT>
#else
    ,
    std::enable_if_t<std::is_convertible_v<std::conditional_t<
        std::is_convertible_v<Left, ReturnT>,
        std::invoke_result_t<Op, ReturnT, Right>,
        std::invoke_result_t<Op, Left, ReturnT>
    >, ReturnT>>* = nullptr
>
#endif
constexpr ReturnT cast_op(Left&& left, Right&& right, Op op)
{
    if constexpr(std::is_convertible_v<Left, ReturnT>)
        return op(static_cast<ReturnT>(std::forward<Left>(left)), std::forward<Right>(right));
    else return op(std::forward<Left>(left), static_cast<ReturnT>(std::forward<Right>(right)));
}

class marketing_scheme
{
    uint64_t min_, max_;

public:
    constexpr marketing_scheme(const uint64_t min, const uint64_t max) noexcept: min_(min), max_(max) {}

    constexpr void solve() const noexcept
    {
        auto pack = 2 * (max_ - min_);
        for(; max_ / pack != min_ / pack; ++pack);

        for(; pack <= 2 * min_; ++pack)
        {
            const auto half = (pack + 1) / 2;

            if(pack % max_ >= half && pack % min_ >= half)
            {
                cout << "YES\n";
                return;
            }
        }

        cout << "NO\n";
    }

#ifdef __cpp_lib_concepts
    template<ConvertibleToRef<std::istream> InputStream>
#else
    template<
        typename InputStream,
        std::enable_if_t<std::is_convertible_v<InputStream, std::istream&&> || std::is_convertible_v<InputStream, std::istream&>>* = nullptr
    >
#endif
    static void create_from_input(InputStream&& is)
    {
        for(auto i = get_from_stream<uint64_t>(is); i > 0; --i)
            marketing_scheme{get_from_stream<uint64_t>(is), get_from_stream<uint64_t>(is)}.solve();
    }
};

int main()
{
    if constexpr(is_debug)
    {
        marketing_scheme::create_from_input(std::istringstream{"3 3 4 1 2 120 150"});
    }
    else marketing_scheme::create_from_input(cin);
    return 0;
}


// Created by BlurringShadow at 2020-10-26-上午 10:09

#ifndef _DEBUG
#define NDEBUG
#endif

constexpr auto is_debug =
#ifdef NDEBUG
    false
#else
    true
#endif
;

#include <iostream>
#include <sstream>
#include <string>
#include <type_traits>
#include <vector>

using namespace std::literals; // NOLINT(clang-diagnostic-header-hygiene)
using std::size_t;
using std::vector;
using std::string;
using std::cout;
using std::cin;

[[maybe_unused]] const auto static_ini_ = []()
{
    std::ios::sync_with_stdio(false);
    std::cin.tie(nullptr);
    return std::cout.tie(nullptr);
}();

class console_output_buffer_binder final
{
    using buf_ptr_t = std::streambuf*;

    vector<std::stringbuf> buffers_;
    const buf_ptr_t console_buf_ = cout.rdbuf();

public:
    explicit console_output_buffer_binder(const size_t additional_count = 0) noexcept :
        buffers_(additional_count + 1),
        console_buf_(std::cout.rdbuf(&buffers_.front())) { bind_to(0); }

    console_output_buffer_binder(const console_output_buffer_binder&) = delete;
    console_output_buffer_binder& operator=(const console_output_buffer_binder&) = delete;

    struct scope_binder
    {
        const buf_ptr_t new_buf_p;
        const buf_ptr_t old_buf_p;

        explicit scope_binder(std::streambuf* new_buf) : new_buf_p(new_buf), old_buf_p(cout.rdbuf(new_buf)) {}
        ~scope_binder() { cout.rdbuf(old_buf_p); }
    };

    void bind_to(const size_t i) { cout.rdbuf(&buffers_[i]); }

    auto scope_bind_to(const size_t i) { return scope_binder{&buffers_[i]}; }

    void add_to_front() { buffers_.emplace_back(); }

    auto scope_add_front()
    {
        add_to_front();
        return scope_bind_to(buffers_.size() - 1);
    }

    ~console_output_buffer_binder()
    {
        cout.rdbuf(console_buf_);
        const auto size = buffers_.size();
        for(auto i = size - 1; i < size; --i) cout << buffers_[i].str();
    }
};

template<typename From, typename To>
struct is_convertible_to_ref : std::bool_constant<
        std::is_convertible_v<From, std::decay_t<To>&&> ||
        std::is_convertible_v<From, std::decay_t<To>&>
    > {};

template<typename From, typename To>
constexpr auto is_convertible_to_ref_v = is_convertible_to_ref<From, To>::value;

#ifdef __cpp_lib_concepts
#include <concepts>
#include <ranges>

template<typename From, typename To>
concept ConvertibleToRef = is_convertible_to_ref_v<From, To>;

template<typename T, ConvertibleToRef<std::istream> InputStream, typename... Args>
requires requires(InputStream is, T t)
{
    std::constructible_from<T, Args...>;
    is >> t;
}
#else
template<
    typename T,
    typename InputStream,
    typename... Args,
    std::enable_if_t<std::is_constructible_v<T, Args...>>* = nullptr,
    std::enable_if_t<is_convertible_to_ref_v<InputStream, std::istream>>* = nullptr
>
#endif
[[nodiscard]] T get_from_stream(InputStream&& is, Args&&... args)
{
    T t(std::forward<Args>(args)...);
    is >> t;
    return t;
}

template<typename T>
struct auto_cast
{
    T&& t;

#ifdef __cpp_lib_concepts
    template<typename U> requires requires { static_cast<std::decay_t<U>>(std::forward<T>(t)); }
#else
    template<typename U, std::enable_if_t<std::is_convertible_v<T, std::decay_t<U>>>* = nullptr>
#endif
    constexpr operator U() noexcept(std::is_nothrow_constructible_v<T, std::decay_t<U>>)
    {
        return static_cast<std::decay_t<U>>(std::forward<T>(t));
    }
};

template<
    typename ReturnT,
    typename Left,
    typename Right,
    typename Op
#ifdef __cpp_lib_concepts
> requires std::convertible_to<std::conditional_t<
    std::is_convertible_v<Left, ReturnT>,
    std::invoke_result_t<Op, ReturnT, Right>,
    std::invoke_result_t<Op, Left, ReturnT>
>, ReturnT>
#else
    ,
    std::enable_if_t<std::is_convertible_v<std::conditional_t<
        std::is_convertible_v<Left, ReturnT>,
        std::invoke_result_t<Op, ReturnT, Right>,
        std::invoke_result_t<Op, Left, ReturnT>
    >, ReturnT>>* = nullptr
>
#endif
constexpr ReturnT cast_op(Left&& left, Right&& right, Op op)
{
    if constexpr(std::is_convertible_v<Left, ReturnT>)
        return op(static_cast<ReturnT>(std::forward<Left>(left)), std::forward<Right>(right));
    else return op(std::forward<Left>(left), static_cast<ReturnT>(std::forward<Right>(right)));
}

class marketing_scheme
{
    uint64_t min_, max_;

public:
    constexpr marketing_scheme(const uint64_t min, const uint64_t max) noexcept: min_(min), max_(max) {}

    void solve() const noexcept { cout << (max_ < 2 * min_ ? "YES\n" : "NO\n"); }

#ifdef __cpp_lib_concepts
    template<ConvertibleToRef<std::istream> InputStream>
#else
    template<
        typename InputStream,
        std::enable_if_t<std::is_convertible_v<InputStream, std::istream&&> || std::is_convertible_v<InputStream, std::istream&>>* = nullptr
    >
#endif
    static void create_from_input(InputStream&& is)
    {
        for(auto i = get_from_stream<uint64_t>(is); i > 0; --i)
            marketing_scheme{get_from_stream<uint64_t>(is), get_from_stream<uint64_t>(is)}.solve();
    }
};

int main()
{
    if constexpr(is_debug)
    {
        marketing_scheme::create_from_input(std::istringstream{"3 3 4 1 2 120 150"});
    }
    else marketing_scheme::create_from_input(cin);
    return 0;
}


// Created by BlurringShadow at 2020-10-26-上午 10:09

#ifndef _DEBUG
#define NDEBUG
#endif

constexpr auto is_debug =
#ifdef NDEBUG
    false
#else
    true
#endif
;

#include <iostream>
#include <sstream>
#include <string>
#include <type_traits>
#include <vector>

using namespace std::literals; // NOLINT(clang-diagnostic-header-hygiene)
using std::size_t;
using std::vector;
using std::string;
using std::cout;
using std::cin;

[[maybe_unused]] const auto static_ini_ = []()
{
    std::ios::sync_with_stdio(false);
    std::cin.tie(nullptr);
    return std::cout.tie(nullptr);
}();

class console_output_buffer_binder final
{
    using buf_ptr_t = std::streambuf*;

    vector<std::stringbuf> buffers_;
    const buf_ptr_t console_buf_ = cout.rdbuf();

public:
    explicit console_output_buffer_binder(const size_t additional_count = 0) noexcept :
        buffers_(additional_count + 1),
        console_buf_(std::cout.rdbuf(&buffers_.front())) { bind_to(0); }

    console_output_buffer_binder(const console_output_buffer_binder&) = delete;
    console_output_buffer_binder& operator=(const console_output_buffer_binder&) = delete;

    struct scope_binder
    {
        const buf_ptr_t new_buf_p;
        const buf_ptr_t old_buf_p;

        explicit scope_binder(std::streambuf* new_buf) : new_buf_p(new_buf), old_buf_p(cout.rdbuf(new_buf)) {}
        ~scope_binder() { cout.rdbuf(old_buf_p); }
    };

    void bind_to(const size_t i) { cout.rdbuf(&buffers_[i]); }

    auto scope_bind_to(const size_t i) { return scope_binder{&buffers_[i]}; }

    void add_to_front() { buffers_.emplace_back(); }

    auto scope_add_front()
    {
        add_to_front();
        return scope_bind_to(buffers_.size() - 1);
    }

    ~console_output_buffer_binder()
    {
        cout.rdbuf(console_buf_);
        const auto size = buffers_.size();
        for(auto i = size - 1; i < size; --i) cout << buffers_[i].str();
    }
};

template<typename From, typename To>
struct is_convertible_to_ref : std::bool_constant<
        std::is_convertible_v<From, std::decay_t<To>&&> ||
        std::is_convertible_v<From, std::decay_t<To>&>
    > {};

template<typename From, typename To>
constexpr auto is_convertible_to_ref_v = is_convertible_to_ref<From, To>::value;

#ifdef __cpp_lib_concepts
#include <concepts>
#include <ranges>

template<typename From, typename To>
concept ConvertibleToRef = is_convertible_to_ref_v<From, To>;

template<typename T, ConvertibleToRef<std::istream> InputStream, typename... Args>
requires requires(InputStream is, T t)
{
    std::constructible_from<T, Args...>;
    is >> t;
}
#else
template<
    typename T,
    typename InputStream,
    typename... Args,
    std::enable_if_t<std::is_constructible_v<T, Args...>>* = nullptr,
    std::enable_if_t<is_convertible_to_ref_v<InputStream, std::istream>>* = nullptr
>
#endif
[[nodiscard]] T get_from_stream(InputStream&& is, Args&&... args)
{
    T t(std::forward<Args>(args)...);
    is >> t;
    return t;
}

template<typename T>
struct auto_cast
{
    T&& t;

#ifdef __cpp_lib_concepts
    template<typename U> requires requires { static_cast<std::decay_t<U>>(std::forward<T>(t)); }
#else
    template<typename U, std::enable_if_t<std::is_convertible_v<T, std::decay_t<U>>>* = nullptr>
#endif
    constexpr operator U() noexcept(std::is_nothrow_constructible_v<T, std::decay_t<U>>)
    {
        return static_cast<std::decay_t<U>>(std::forward<T>(t));
    }
};

template<
    typename ReturnT,
    typename Left,
    typename Right,
    typename Op
#ifdef __cpp_lib_concepts
> requires std::convertible_to<std::conditional_t<
    std::is_convertible_v<Left, ReturnT>,
    std::invoke_result_t<Op, ReturnT, Right>,
    std::invoke_result_t<Op, Left, ReturnT>
>, ReturnT>
#else
    ,
    std::enable_if_t<std::is_convertible_v<std::conditional_t<
        std::is_convertible_v<Left, ReturnT>,
        std::invoke_result_t<Op, ReturnT, Right>,
        std::invoke_result_t<Op, Left, ReturnT>
    >, ReturnT>>* = nullptr
>
#endif
constexpr ReturnT cast_op(Left&& left, Right&& right, Op op)
{
    if constexpr(std::is_convertible_v<Left, ReturnT>)
        return op(static_cast<ReturnT>(std::forward<Left>(left)), std::forward<Right>(right));
    else return op(std::forward<Left>(left), static_cast<ReturnT>(std::forward<Right>(right)));
}

class marketing_scheme
{
    uint64_t min_, max_;

public:
    constexpr marketing_scheme(const uint64_t min, const uint64_t max) noexcept: min_(min), max_(max) {}

    constexpr void solve() const noexcept
    {
        const auto offset = max_ - min_;

        for(auto pack = 2 * offset; pack < 2 * min_; ++pack)
        {
            const auto half = (pack + 1) / 2;

            if(pack % max_ >= half && pack % min_ >= half)
            {
                cout << "YES\n";
                return;
            }
        }

        cout << "NO\n";
    }

#ifdef __cpp_lib_concepts
    template<ConvertibleToRef<std::istream> InputStream>
#else
    template<
        typename InputStream,
        std::enable_if_t<std::is_convertible_v<InputStream, std::istream&&> || std::is_convertible_v<InputStream, std::istream&>>* = nullptr
    >
#endif
    static void create_from_input(InputStream&& is)
    {
        for(auto i = get_from_stream<uint64_t>(is); i > 0; --i)
            marketing_scheme{get_from_stream<uint64_t>(is), get_from_stream<uint64_t>(is)}.solve();
    }
};

int main()
{
    if constexpr(is_debug)
    {
        marketing_scheme::create_from_input(std::istringstream{"3 3 4 1 2 120 150"});
    }
    else marketing_scheme::create_from_input(cin);
    return 0;
}


#pragma GCC optimize("-Ofast","-funroll-all-loops")
#include<cstdio>
#include<algorithm>
#include<iostream>
#include<cstring>
#include<math.h>
using namespace std;
#define endl '\n'
#define INF 0x3f3f3f3f
// #define int long long
#define debug(a) cout<<#a<<"="<<a<<endl;
typedef long long ll;
const double PI=acos(-1.0);
const double e=exp(1.0);
const int M=1e9+7;
const int N=2e5+7;
inline int mymax(int x,int y){return x>y?x:y;}
inline int mymin(int x,int y){return x<y?x:y;}
int l, r, a;
void solve(){
    cin>>l>>r;
    a=r+1;
    if(l%a >= (a+1)/2)  cout<<"YES"<<endl;
    else                cout<<"NO"<<endl;
	return ;
}

signed main(){
	ios::sync_with_stdio(false);
	cin.tie(0), cout.tie(0);
    int T;
    cin>>T;
    while(T--) solve();
    return 0;
}


#include <iostream>
#include <fstream>
#include <vector>
#include <set>
#include <map>
#include <unordered_map>
#include <cstring>
#include <string>
#include <cmath>
#include <cassert>
#include <ctime>
#include <algorithm>
#include <sstream>
#include <list>
#include <queue>
#include <deque>
#include <stack>
#include <cstdlib>
#include <cstdio>
#include <iterator>
#include <functional>
#include <bitset>
#include <iomanip>
#include <float.h>
#define _USE_MATH_DEFINES
#include <math.h>

#define ll long long

#define FOR(i,a,b)        for(ll i=(a);i<(b);i++)
#define REP(i,n)        FOR(i,0,n)
#define SORT(v)            sort((v).begin(),(v).end())
#define UN(v)            SORT(v),(v).erase(unique((v).begin(),(v).end()),(v).end())
#define CL(a,b)            memset(a,b,sizeof a)
#define pb                push_back

#ifndef M_PI
    #define M_PI 3.14159265358979323846
#endif

using namespace std;

//#define N 1000009
ll denom = 1e9+7;
ll powmod(ll a,ll b) {ll res=1;a%=denom; for(;b;b>>=1){if(b&1)res=res*a%denom;a=a*a%denom;}return res;}

int main(int argc, const char * argv[])
{
    ios_base::sync_with_stdio(false);
    ll t; cin >> t;
    while (t-- > 0) {
        ll l,r; cin >> l >> r;
        ll a = r+1;
        cout << (2*(l%(r+1)) >= a ? "YES" : "NO") << endl;

    }
    return 0;
}


#include <iostream>
#include <fstream>
#include <vector>
#include <set>
#include <map>
#include <unordered_map>
#include <cstring>
#include <string>
#include <cmath>
#include <cassert>
#include <ctime>
#include <algorithm>
#include <sstream>
#include <list>
#include <queue>
#include <deque>
#include <stack>
#include <cstdlib>
#include <cstdio>
#include <iterator>
#include <functional>
#include <bitset>
#include <iomanip>
#include <float.h>
#define _USE_MATH_DEFINES
#include <math.h>

#define ll long long

#define FOR(i,a,b)        for(ll i=(a);i<(b);i++)
#define REP(i,n)        FOR(i,0,n)
#define SORT(v)            sort((v).begin(),(v).end())
#define UN(v)            SORT(v),(v).erase(unique((v).begin(),(v).end()),(v).end())
#define CL(a,b)            memset(a,b,sizeof a)
#define pb                push_back

#ifndef M_PI
    #define M_PI 3.14159265358979323846
#endif

using namespace std;

//#define N 1000009
ll denom = 1e9+7;
ll powmod(ll a,ll b) {ll res=1;a%=denom; for(;b;b>>=1){if(b&1)res=res*a%denom;a=a*a%denom;}return res;}

int main(int argc, const char * argv[])
{
    ios_base::sync_with_stdio(false);
    ll t; cin >> t;
    while (t-- > 0) {
        ll l,r; cin >> l >> r;
        cout << (l > 1 ? "YES" : "NO") << endl;

    }
    return 0;
}


#include <iostream>
#include <iomanip>
#include <string>
#include <vector>
#include <map>
#include <queue>
#include <set>
#include <deque>
#include <algorithm>
#include <cmath>

#define ll long long int
#define db double

using namespace std;

int main () {
	ios::sync_with_stdio(0);
	cin.tie(0);
	cout.tie(0);

	int _;
	cin >> _;
	while (_--) {
		ll l, r;
		cin >> l >> r;
		if (l * 2 - 1 <= r) {
			cout << "NO"; }
		else {
			cout << "YES";
		}

		cout << "\n";
	}
 return 0;
}


#include <iostream>
#include <iomanip>
#include <string>
#include <vector>
#include <map>
#include <queue>
#include <set>
#include <deque>
#include <algorithm>
#include <cmath>

#define ll long long int
#define db double

using namespace std;

int main () {
	ios::sync_with_stdio(0);
	cin.tie(0);
	cout.tie(0);

	int _;
	cin >> _;
	while (_--) {
		ll l, r;
		cin >> l >> r;

		if (l % (r + 1) < ((double)r + 1) / 2) {
			cout << "NO"; }
		else {
			cout << "YES";
		}

		cout << "\n";
	}
 return 0;
}


#include<iostream>
#include<cmath>
#include<string>
#include<algorithm>
#include<cstdio>
#include<stack>
#include<queue>
#include<stdlib.h>
#include<vector>
#include<sstream>
#include<iomanip>
using namespace std;
int main()
{
	int t,c;
	cin >> t;
	int* a = new int[t];
	int* b = new int[t];
	for (int i = 0; i < t; i++)
	{
		int n=0;
		cin >> *(a+i) >> *(b+i);
		if (*(a + i) > * (b + i))
		{
			c = *(a + i);
			*(a + i) = *(b + i);
			*(b + i) = c;
		}
		if (*(a + i) == 1)
		{
			cout << "NO" << "\n";
			continue;
		}
		for (int j = 1; j <= 2 * *(a + i); j++)
		{
			for (int k = *(a + i); k <= *(b + i); k++)
			{
				if (j = *(a + i))
				{
					j = *(b + i) + 1;
				}
				if (k % j >= (j + 1) / 2)
				{
					n = n + 1;
				}
			}
			if (n == *(b + i) - *(a + i) + 1)
			{
				cout << "YES" << endl;
				break;
			}
			else if(j==2**(a+i))cout << "NO" << endl;
		}
	}
	return 0;
}


#include<iostream>
#include<cmath>
#include<string>
#include<algorithm>
#include<cstdio>
#include<stack>
#include<queue>
#include<stdlib.h>
#include<vector>
#include<sstream>
#include<iomanip>
using namespace std;
int main()
{
	int t,c;
	cin >> t;
	int* a = new int[t];
	int* b = new int[t];
	for (int i = 0; i < t; i++)
	{
		cin >> *(a+i) >> *(b+i);
		if (*(a + i) > * (b + i))
		{
			c = *(a + i);
			*(a + i) = *(b + i);
			*(b + i) = c;
		}
		if (*(a + i) == 1)
		{
			cout << "NO" << "\n";
			continue;
		}
		for (int j = 1; j <= 2 * *(a + i); j++)
		{
			int n = 0;
			for (int k = *(a + i); k <= *(b + i); k++)
			{
				if (j = *(a + i))
				{
					j = *(b + i) + 1;
				}
				if (k % j >= (j + 1) / 2)
				{
					n = n + 1;
				}
			}
			if (n == *(b + i) - *(a + i) + 1)
			{
				cout << "YES" << endl;
				break;
			}
			else if(j==2**(a+i))cout << "NO" << endl;
		}
	}
	return 0;
}


#include<iostream>
#include<cmath>
#include<string>
#include<algorithm>
#include<cstdio>
#include<stack>
#include<queue>
#include<stdlib.h>
#include<vector>
#include<sstream>
#include<iomanip>
using namespace std;
int main()
{
	int t,c;
	cin >> t;
	int* a = new int[t];
	int* b = new int[t];
	for (int i = 0; i < t; i++)
	{
		cin >> *(a+i) >> *(b+i);
		if (*(a + i) > * (b + i))
		{
			c = *(a + i);
			*(a + i) = *(b + i);
			*(b + i) = c;
		}
		if (*(a + i) == 1 || 2 * *(a + i) <= *(b + i))
		{
			cout << "NO" << "\n";
			continue;
		}
		else cout << "YES" << "\n";
	}
	return 0;
}


#include<iostream>
#include<cmath>
#include<string>
#include<algorithm>
#include<cstdio>
#include<stack>
#include<queue>
#include<stdlib.h>
#include<vector>
#include<sstream>
#include<iomanip>
using namespace std;
int main()
{
	int t,c;
	cin >> t;
	int* a = new int[t];
	int* b = new int[t];
	for (int i = 0; i < t; i++)
	{
		cin >> *(a+i) >> *(b+i);
		if (*(a + i) > * (b + i))
		{
			c = *(a + i);
			*(a + i) = *(b + i);
			*(b + i) = c;
		}
		if (2 * *(a + i) <= *(b + i))
		{
			cout << "NO" << "\n";
			continue;
		}
		else cout << "YES" << "\n";
	}
	return 0;
}


#include<iostream>
#include<cmath>
#include<string>
#include<algorithm>
#include<cstdio>
#include<stack>
#include<queue>
#include<stdlib.h>
#include<vector>
#include<sstream>
#include<iomanip>
using namespace std;
int main()
{
	int t,h,c;
	cin >> t;
	int* a = new int[t];
	int* b = new int[t];
	for (int i = 0; i < t; i++)
	{
		cin >> *(a+i) >> *(b+i);
		if (*(a + i) > * (b + i))
		{
			c = *(a + i);
			*(a + i) = *(b + i);
			*(b + i) = c;
		}
		if (*(a + i) == 1)cout << "No" << "\n";
		for (int j = *(a + i) * 2 / 3; j > 0; j--)
		{
			for ( h = 2 * *(a + i); h > * (b + i); h--)
			{
				if (h % j >= (j+1) / 2)
				{
					cout << "Yes" << "\n";
					break;
				}
				else if (j == 1 && h == *(b + i)+1)cout << "No" << "\n";

			}
			for (int k = *(a + i); k <= *(b + i); k++)
			{
				if (h % j >= (j+1 )/ 2)break;
				if (k % j >= (j+1) / 2)
				{
					cout << "Yes" << "\n";
					break;
				}
				else if (j==1&&k== *(b + i))cout << "No" << "\n";

			}
			if (h % j >= (j +1)/ 2)break;
		}
	}
	return 0;
}


#include<iostream>
#include<cmath>
#include<string>
#include<algorithm>
#include<cstdio>
#include<stack>
#include<queue>
#include<stdlib.h>
#include<vector>
#include<sstream>
#include<iomanip>
using namespace std;
int main()
{
	int t,c;
	cin >> t;
	int* a = new int[t];
	int* b = new int[t];
	for (int i = 0; i < t; i++)
	{
		cin >> *(a+i) >> *(b+i);
		if (*(a + i) > * (b + i))
		{
			c = *(a + i);
			*(a + i) = *(b + i);
			*(b + i) = c;
		}
		if (*(a + i) == 1)
		{
			cout << "NO" << "\n";
			continue;
		}
		for (int j = 1; j <= 2 * *(a + i); j++)
		{
			int n = 0;
			for (int k = *(a + i); k <= *(b + i); k++)
			{
				if (k % j >= (j + 1) / 2)
				{
					n = n + 1;
				}
			}
			if (n == *(b + i) - *(a + i) + 1)
			{
				cout << "YES" << endl;
				break;
			}
			else if(j==2**(a+i))cout << "NO" << endl;
		}
	}
	return 0;
}


#include<iostream>
#include<cmath>
#include<string>
#include<algorithm>
#include<cstdio>
#include<stack>
#include<queue>
#include<stdlib.h>
#include<vector>
#include<sstream>
#include<iomanip>
using namespace std;
int main()
{
	int t,h,c;
	cin >> t;
	int* a = new int[t];
	int* b = new int[t];
	for (int i = 0; i < t; i++)
	{
		cin >> *(a+i) >> *(b+i);
		if (*(a + i) > * (b + i))
		{
			c = *(a + i);
			*(a + i) = *(b + i);
			*(b + i) = c;
		}
		if (*(a + i) == 1)cout << "No" << "\n";
		for (int j = *(a + i) * 2 / 3; j > 0; j--)
		{
			for ( h = 2 * *(a + i); h > * (b + i); h--)
			{
				if (h % j >= j / 2)
				{
					cout << "Yes" << "\n";
					break;
				}
				else if (j == 1 && h == *(b + i)+1)cout << "No" << "\n";

			}
			for (int k = *(a + i); k <= *(b + i); k++)
			{
				if (h % j >= j / 2)break;
				if (k % j >= j / 2)
				{
					cout << "Yes" << "\n";
					break;
				}
				else if (j==1&&k== *(b + i))cout << "No" << "\n";

			}
			if (h % j >= j / 2)break;
		}
	}
	return 0;
}