#include <iostream>
#include <vector>
#include <cstdlib>
#include <algorithm>
#include <bits/stdc++.h>
#include <unordered_map>
#include <time.h>
#include <cmath>
#include <string>
using namespace std;
#define w(t) while (t--)
#define vi(v) vector<int> v;
#define pii(p) pair<int, int> p;
#define vll vector<long long>;
#define pll pair<long long, long long>;
#define pb push_back
#define all(c) c.begin(), c.end()
#define For(i, a, b) for (size_t i = a; i < b; ++i)
#define Rof(i, a, b) for (size_t i = a; i > b; i--)
#define um unordered_map
#define F first
#define S second
#define ll long long
#define min(a, b) (a < b ? a : b)
#define max(a, b) (a > b ? a : b)
#define fast_io()                     \
    ios_base::sync_with_stdio(false); \
    cin.tie(NULL);                    \
    cout.tie(NULL);
/* ------------------------------------------------------------------------------------------------------------------------- */

int binarySearch(int arr[], int l, int r, int x)
{
    while (l <= r)
    {
        int m = l + (r - l) / 2;

        // Check if x is present at mid
        if (arr[m] == x)
            return m;

        // If x greater, ignore left half
        if (arr[m] < x)
            l = m + 1;

        // If x is smaller, ignore right half
        else
            r = m - 1;
    }

    // if we reach here, then element was
    // not present
    return -1;
}

bool findPartiion(int arr[], int n)
{
    int sum = 0;
    int i, j;

    // Calculate sum of all elements
    for (i = 0; i < n; i++)
        sum += arr[i];

    if (sum % 2 != 0)
        return false;

    bool part[sum / 2 + 1];

    // Initialze the part array
    // as 0
    for (i = 0; i <= sum / 2; i++)
    {
        part[i] = 0;
    }

    // Fill the partition table in bottom up manner

    for (i = 0; i < n; i++)
    {
        // the element to be included
        // in the sum cannot be
        // greater than the sum
        for (j = sum / 2; j >= arr[i];
             j--)
        { // check if sum - arr[i]
            // could be formed
            // from a subset
            // using elements
            // before index i
            if (part[j - arr[i]] == 1 || j == arr[i])
                part[j] = 1;
        }
    }

    return part[sum / 2];
}

string met()
{
    ll px, py;
    cin >> px >> py;
    string s;
    cin >> s;
    int l = 0, r = 0, u = 0, d = 0;
    for (int i = 0; i < s.size(); i++)
    {
        if (s[i] == 'U')
        {
            u++;
        }
        else if (s[i] == 'D')
        {
            d++;
        }
        else if (s[i] == 'L')
        {
            l++;
        }
        else if (s[i] == 'R')
        {
            r++;
        }
    }
    if (px > 0){
        if (r < px)
            return "NO";
    }
    else{
        if ( -1*l > px)
            return "NO";
    }
    if (py > 0){
        if (u < py)
            return "NO";
    }
    else{
        if (-1 * d > py)
            return "NO";
    }
    return "YES";
}

int main()
{
    fast_io();
    int t;
    cin >> t;
    while (t--)
    {

        // clock_t t;
        // t = clock();

        // each iteration takes this time
        // t = clock() - t;
        // cout << "time : " << float(t)/CLOCKS_PER_SEC << " sec" << endl;
        cout << met() << endl;
        
    }

    return 0;
}
### Prompt

Construct a CPP code solution to the problem outlined:

You were dreaming that you are traveling to a planet named Planetforces on your personal spaceship. Unfortunately, its piloting system was corrupted and now you need to fix it in order to reach Planetforces.

<image>

Space can be represented as the XY plane. You are starting at point (0, 0), and Planetforces is located in point (p_x, p_y).

The piloting system of your spaceship follows its list of orders which can be represented as a string s. The system reads s from left to right. Suppose you are at point (x, y) and current order is s_i: 

  * if s_i = U, you move to (x, y + 1); 
  * if s_i = D, you move to (x, y - 1); 
  * if s_i = R, you move to (x + 1, y); 
  * if s_i = L, you move to (x - 1, y). 



Since string s could be corrupted, there is a possibility that you won't reach Planetforces in the end. Fortunately, you can delete some orders from s but you can't change their positions.

Can you delete several orders (possibly, zero) from s in such a way, that you'll reach Planetforces after the system processes all orders?

Input

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

Each test case consists of two lines. The first line in each test case contains two integers p_x and p_y (-10^5 ≤ p_x, p_y ≤ 10^5; (p_x, p_y) ≠ (0, 0)) — the coordinates of Planetforces (p_x, p_y).

The second line contains the string s (1 ≤ |s| ≤ 10^5: |s| is the length of string s) — the list of orders.

It is guaranteed that the sum of |s| over all test cases does not exceed 10^5.

Output

For each test case, print "YES" if you can delete several orders (possibly, zero) from s in such a way, that you'll reach Planetforces. Otherwise, print "NO". You can print each letter in any case (upper or lower).

Example

Input


6
10 5
RRRRRRRRRRUUUUU
1 1
UDDDRLLL
-3 -5
LDLDLDDDR
1 2
LLLLUU
3 -2
RDULRLLDR
-1 6
RUDURUUUUR


Output


YES
YES
YES
NO
YES
NO

Note

In the first case, you don't need to modify s, since the given s will bring you to Planetforces.

In the second case, you can delete orders s_2, s_3, s_4, s_6, s_7 and s_8, so s becomes equal to "UR".

In the third test case, you have to delete order s_9, otherwise, you won't finish in the position of Planetforces.

### Response

```cpp
#include <iostream>
#include <vector>
#include <cstdlib>
#include <algorithm>
#include <bits/stdc++.h>
#include <unordered_map>
#include <time.h>
#include <cmath>
#include <string>
using namespace std;
#define w(t) while (t--)
#define vi(v) vector<int> v;
#define pii(p) pair<int, int> p;
#define vll vector<long long>;
#define pll pair<long long, long long>;
#define pb push_back
#define all(c) c.begin(), c.end()
#define For(i, a, b) for (size_t i = a; i < b; ++i)
#define Rof(i, a, b) for (size_t i = a; i > b; i--)
#define um unordered_map
#define F first
#define S second
#define ll long long
#define min(a, b) (a < b ? a : b)
#define max(a, b) (a > b ? a : b)
#define fast_io()                     \
    ios_base::sync_with_stdio(false); \
    cin.tie(NULL);                    \
    cout.tie(NULL);
/* ------------------------------------------------------------------------------------------------------------------------- */

int binarySearch(int arr[], int l, int r, int x)
{
    while (l <= r)
    {
        int m = l + (r - l) / 2;

        // Check if x is present at mid
        if (arr[m] == x)
            return m;

        // If x greater, ignore left half
        if (arr[m] < x)
            l = m + 1;

        // If x is smaller, ignore right half
        else
            r = m - 1;
    }

    // if we reach here, then element was
    // not present
    return -1;
}

bool findPartiion(int arr[], int n)
{
    int sum = 0;
    int i, j;

    // Calculate sum of all elements
    for (i = 0; i < n; i++)
        sum += arr[i];

    if (sum % 2 != 0)
        return false;

    bool part[sum / 2 + 1];

    // Initialze the part array
    // as 0
    for (i = 0; i <= sum / 2; i++)
    {
        part[i] = 0;
    }

    // Fill the partition table in bottom up manner

    for (i = 0; i < n; i++)
    {
        // the element to be included
        // in the sum cannot be
        // greater than the sum
        for (j = sum / 2; j >= arr[i];
             j--)
        { // check if sum - arr[i]
            // could be formed
            // from a subset
            // using elements
            // before index i
            if (part[j - arr[i]] == 1 || j == arr[i])
                part[j] = 1;
        }
    }

    return part[sum / 2];
}

string met()
{
    ll px, py;
    cin >> px >> py;
    string s;
    cin >> s;
    int l = 0, r = 0, u = 0, d = 0;
    for (int i = 0; i < s.size(); i++)
    {
        if (s[i] == 'U')
        {
            u++;
        }
        else if (s[i] == 'D')
        {
            d++;
        }
        else if (s[i] == 'L')
        {
            l++;
        }
        else if (s[i] == 'R')
        {
            r++;
        }
    }
    if (px > 0){
        if (r < px)
            return "NO";
    }
    else{
        if ( -1*l > px)
            return "NO";
    }
    if (py > 0){
        if (u < py)
            return "NO";
    }
    else{
        if (-1 * d > py)
            return "NO";
    }
    return "YES";
}

int main()
{
    fast_io();
    int t;
    cin >> t;
    while (t--)
    {

        // clock_t t;
        // t = clock();

        // each iteration takes this time
        // t = clock() - t;
        // cout << "time : " << float(t)/CLOCKS_PER_SEC << " sec" << endl;
        cout << met() << endl;
        
    }

    return 0;
}
```