Problem: Bashar was practicing for the national programming contest. Because of sitting too much in front of the computer without doing physical movements and eating a lot Bashar became much fatter. Bashar is going to quit programming after the national contest and he is going to become an actor (just like his father), so he should lose weight.

In order to lose weight, Bashar is going to run for k kilometers. Bashar is going to run in a place that looks like a grid of n rows and m columns. In this grid there are two one-way roads of one-kilometer length between each pair of adjacent by side cells, one road is going from the first cell to the second one, and the other road is going from the second cell to the first one. So, there are exactly (4 n m - 2n - 2m) roads.

Let's take, for example, n = 3 and m = 4. In this case, there are 34 roads. It is the picture of this case (arrows describe roads):

<image>

Bashar wants to run by these rules:

  * He starts at the top-left cell in the grid; 
  * In one move Bashar may go up (the symbol 'U'), down (the symbol 'D'), left (the symbol 'L') or right (the symbol 'R'). More formally, if he stands in the cell in the row i and in the column j, i.e. in the cell (i, j) he will move to: 
    * in the case 'U' to the cell (i-1, j); 
    * in the case 'D' to the cell (i+1, j); 
    * in the case 'L' to the cell (i, j-1); 
    * in the case 'R' to the cell (i, j+1); 
  * He wants to run exactly k kilometers, so he wants to make exactly k moves; 
  * Bashar can finish in any cell of the grid; 
  * He can't go out of the grid so at any moment of the time he should be on some cell; 
  * Bashar doesn't want to get bored while running so he must not visit the same road twice. But he can visit the same cell any number of times. 



Bashar asks you if it is possible to run by such rules. If it is possible, you should tell him how should he run.

You should give him a steps to do and since Bashar can't remember too many steps, a should not exceed 3000. In every step, you should give him an integer f and a string of moves s of length at most 4 which means that he should repeat the moves in the string s for f times. He will perform the steps in the order you print them.

For example, if the steps are 2 RUD, 3 UUL then the moves he is going to move are RUD + RUD + UUL + UUL + UUL = RUDRUDUULUULUUL.

Can you help him and give him a correct sequence of moves such that the total distance he will run is equal to k kilometers or say, that it is impossible?

Input

The only line contains three integers n, m and k (1 ≤ n, m ≤ 500, 1 ≤ k ≤ 10 ^{9}), which are the number of rows and the number of columns in the grid and the total distance Bashar wants to run.

Output

If there is no possible way to run k kilometers, print "NO" (without quotes), otherwise print "YES" (without quotes) in the first line.

If the answer is "YES", on the second line print an integer a (1 ≤ a ≤ 3000) — the number of steps, then print a lines describing the steps.

To describe a step, print an integer f (1 ≤ f ≤ 10^{9}) and a string of moves s of length at most 4. Every character in s should be 'U', 'D', 'L' or 'R'.

Bashar will start from the top-left cell. Make sure to move exactly k moves without visiting the same road twice and without going outside the grid. He can finish at any cell.

We can show that if it is possible to run exactly k kilometers, then it is possible to describe the path under such output constraints.

Examples

Input


3 3 4


Output


YES
2
2 R
2 L


Input


3 3 1000000000


Output


NO


Input


3 3 8


Output


YES
3
2 R
2 D
1 LLRR


Input


4 4 9


Output


YES
1
3 RLD


Input


3 4 16


Output


YES
8
3 R
3 L
1 D
3 R
1 D
1 U
3 L
1 D

Note

The moves Bashar is going to move in the first example are: "RRLL".

It is not possible to run 1000000000 kilometers in the second example because the total length of the roads is smaller and Bashar can't run the same road twice.

The moves Bashar is going to move in the third example are: "RRDDLLRR".

The moves Bashar is going to move in the fifth example are: "RRRLLLDRRRDULLLD". It is the picture of his run (the roads on this way are marked with red and numbered in the order of his running):

<image>

Solution (in CPP):

Solution:
#include <bits/stdc++.h>
#pragma comment(linker, "/stack:200000000")
#pragma GCC optimize(2)
#pragma G++ optimize(2)
using namespace std;
class PrimeSelector {
 public:
  bool* prime;
  set<int> primes;
  int n;
  PrimeSelector(bool* prime, int n) : n(n), prime(prime) {
    memset(prime, 1, sizeof(bool) * (n + 1));
    prime[0] = prime[1] = false;
    for (int i = 1; i * i <= n; i++) {
      if (!prime[i]) continue;
      for (int j = i * i; j <= n; j += i) prime[j] = false;
    }
    for (int i = 2; i <= n; i++)
      if (prime[i]) primes.insert(i);
  }
};
long long kpow(long long a, long long b) {
  long long c = 1;
  while (b) {
    if (b & 1) c = c * a;
    a = a * a;
    b >>= 1;
  }
  return c;
}
long long kpow(long long a, long long b, long long mod) {
  long long c = 1 % mod;
  while (b) {
    if (b & 1) c = c * a % mod;
    a = a * a % mod;
  }
  return c;
}
long long rev(long long a, long long mod) { return kpow(a, mod - 2, mod); }
map<long long, long long> splitPrime(long long x, bool* prime) {
  map<long long, long long> res;
  for (int i = 2; i * i <= x; i++) {
    if (!prime[i]) continue;
    while (x % i == 0) res[i]++, x /= i;
    if (res[i] == 0) res.erase(i);
  }
  if (x > 1) res[x] = 1;
  return res;
}
map<long long, long long> splitPrime(long long x, set<int>& prime) {
  map<long long, long long> res;
  for (auto i : prime) {
    if (i * i > x) break;
    while (x % i == 0) res[i]++, x /= i;
    if (res[i] == 0) res.erase(i);
  }
  if (x > 1) res[x] = 1;
  return res;
}
map<long long, long long> mul(const map<long long, long long>& m1,
                              const map<long long, long long>& m2) {
  map<long long, long long> res;
  for (auto& p : m1) res[p.first] = p.second;
  for (auto& p : m2) {
    res[p.first] += p.second;
    if (res[p.first] == 0) res.erase(p.first);
  }
  return res;
}
map<long long, long long> rev(map<long long, long long> m) {
  map<long long, long long> res;
  for (auto& p : m) res[p.first] = -p.second;
  return res;
}
long long m2L(map<long long, long long> m) {
  long long res = 1;
  for (auto& p : m) res *= kpow(p.first, p.second);
  return res;
}
vector<long long> n2B(long long n) {
  vector<long long> res;
  if (n == 0) return {0LL};
  while (n) {
    res.push_back(n % 1000000000LL);
    n /= 1000000000LL;
  }
  reverse(res.begin(), res.end());
  return res;
}
void simple(vector<long long>& res) {
  while (!res.empty() && res.back() == 0LL) res.pop_back();
  if (res.empty()) res.push_back(0LL);
}
vector<long long> add(const vector<long long>& b1,
                      const vector<long long>& b2) {
  vector<long long> res;
  res.reserve(max(b1.size(), b1.size()) + 1);
  long long up = 0LL;
  int i = b1.size() - 1, j = b2.size() - 1;
  while (i >= 0 && j >= 0) {
    long long b = b1[i--] + b2[j--] + up;
    res.push_back(b % 1000000000LL);
    up = b / 1000000000LL;
  }
  while (i >= 0) {
    long long b = b1[i--] + up;
    res.push_back(b % 1000000000LL);
    up = b / 1000000000LL;
  }
  while (j >= 0) {
    long long b = b2[j--] + up;
    res.push_back(b % 1000000000LL);
    up = b / 1000000000LL;
  }
  if (up) res.push_back(up);
  simple(res);
  reverse(res.begin(), res.end());
  return res;
}
vector<long long> mul(const vector<long long>& b1, long long i) {
  vector<long long> res;
  res.reserve(b1.size() + 1);
  long long up = 0;
  for (int j = b1.size() - 1; j >= 0; j--) {
    long long b = b1[j] * i + up;
    res.push_back(b % 1000000000LL);
    up = b / 1000000000LL;
  }
  if (up) res.push_back(up);
  simple(res);
  reverse(res.begin(), res.end());
  return res;
}
void shift(vector<long long>& b1, long long i) {
  if (b1.size() == 1 && b1[0] == 0LL) return;
  while (i--) {
    b1.push_back(0);
  }
}
vector<long long> mul(const vector<long long>& b1,
                      const vector<long long>& b2) {
  if (b1.size() < b2.size()) return mul(b2, b1);
  vector<long long> res;
  res.reserve(b1.size() + b2.size() + 1);
  res.push_back(0);
  if (b2.size() == 1 && b2[0] == 0) return res;
  int shi = 0;
  for (int j = b2.size() - 1; j >= 0; j--) {
    vector<long long> r = mul(b1, b2[j]);
    shift(r, shi++);
    res = add(res, r);
  }
  return res;
}
vector<long long> m2B(const map<long long, long long>& m) {
  if (m.empty()) return {1};
  vector<long long> res;
  res.reserve(100);
  res.push_back(1);
  for (auto& p : m) {
    vector<long long> r = n2B(p.first);
    for (int i = 0; i < p.second - 1; i++) r = mul(r, n2B(p.first));
    res = mul(res, r);
  }
  return res;
}
struct DSU {
  vector<int> par;
  vector<int> sz;
  int n;
  DSU(int n) : par(n + 1), sz(n + 1), n(n) {
    for (int i = 0; i <= n; i++) sz[i] = 1, par[i] = i;
  }
  int find(int x) {
    if (x == par[x]) return x;
    return par[x] = find(par[x]);
  }
  void uni(int x, int y) {
    int px = find(x), py = find(y);
    if (px == py) return;
    if (sz[px] < sz[py]) return uni(py, px);
    par[py] = px, sz[px] += sz[py];
  }
};
template <class T>
struct VHash {
  size_t operator()(const vector<T>& v) const {
    size_t res = 0;
    for (T i : v) res ^= i;
    return res;
  }
};
struct SHash {
  long long* presum;
  long long* po;
  long long seed;
  long long mod;
  SHash() {}
  SHash(long long seed, long long mod, long long* presum, long long* po)
      : seed(seed), mod(mod), presum(presum), po(po) {}
  void load(const string& s) {
    po[0] = 1;
    for (int i = 1; i <= (int)s.size(); i++) {
      presum[i] = (presum[i - 1] * seed + s[i - 1]) % mod;
      po[i] = po[i - 1] * seed % mod;
    }
  }
  long long get(int i, int j) {
    if (i > j) return 0;
    return (presum[j] - presum[i - 1] * po[j - i + 1] % mod + mod) % mod;
  }
};
struct SHash2 {
  long long* presum;
  long long* po;
  long long seed;
  SHash2(long long seed, long long* presum, long long* po)
      : seed(seed), presum(presum), po(po) {}
  void load(const string& s) {
    po[0] = 1;
    for (int i = 1; i <= (int)s.size(); i++) {
      presum[i] = (presum[i - 1] * seed + s[i - 1]) & 0xFFFFFFFF;
      po[i] = (po[i - 1] * seed) & 0xFFFFFFFF;
    }
  }
  long long get(int i, int j) {
    if (i > j) return 0;
    return (presum[j] - ((presum[i - 1] * po[j - i + 1]) & 0xFFFFFFFF) +
            0xFFFFFFFF) &
           0xFFFFFFFF;
  }
};
struct TrieNode {
  int next[26];
  int done;
};
struct TrieTree {
  TrieNode* nodes;
  int cnt = 0;
  char base;
  TrieTree(TrieNode* nodes, char base = 'a')
      : nodes(nodes), cnt(0), base(base) {}
  void add(const string& s) {
    int p = 0;
    for (char c : s) {
      if (!nodes[p].next[c - base]) nodes[p].next[c - base] = ++cnt;
      p = nodes[p].next[c - base];
    }
    nodes[p].done++;
  }
  int count(const string& s) {
    int res = 0, p = 0;
    for (char c : s) {
      res += nodes[p].done;
      if (!nodes[p].next[c - base]) return res;
      p = nodes[p].next[c - base];
    }
    res += nodes[p].done;
    return res;
  }
};
struct BinNode {
  int next[2];
  int done;
};
struct BinTree {
  BinNode* nodes;
  int maxn = 31;
  int cnt = 0;
  BinTree(BinNode* nodes, int maxn) : nodes(nodes), maxn(maxn), cnt(0) {}
  void add(long long l) {
    long long p = 0;
    for (int j = maxn; j >= 0; j--) {
      int b = (l >> j) & 1;
      if (!nodes[p].next[b]) nodes[p].next[b] = ++cnt;
      p = nodes[p].next[b];
    }
  }
  long long maxXor(long long x) {
    long long res = 0;
    int p = 0;
    for (int j = maxn; j >= 0; j--) {
      res <<= 1;
      long long b = (x >> j) & 1;
      if (nodes[p].next[1 ^ b])
        p = nodes[p].next[1 ^ b], res |= 1 ^ b;
      else
        p = nodes[p].next[b], res |= b;
    }
    return res;
  }
};
int minResp(const string& s) {
  int n = s.size();
  string ss = s + s;
  int i = 0, j = 1;
  while (i < n && j < n) {
    int k = 0;
    while (k < n) {
      if (ss[i + k] != ss[j + k]) break;
      k++;
    }
    if (k == n) break;
    if (ss[i + k] < ss[j + k]) {
      j = j + k + 1;
      if (i == j) j++;
    } else {
      i = i + k + 1;
      if (i == j) i++;
    }
  }
  return min(i, j);
}
struct BIT {
  long long* c;
  int n;
  BIT(long long* c, int n) : c(c), n(n) {}
  int lowbit(int x) { return x & -x; }
  void add(int x, long long v) {
    for (int i = x; i <= n; i += lowbit(i)) c[i] += v;
  }
  long long sum(int x) {
    long long res = 0;
    for (int i = x; i; i -= lowbit(i)) res += c[i];
    return res;
  }
};
struct BIT2 {
  long long* C;
  int n, m;
  BIT2(long long* C, int n, int m) : C(C), n(n), m(m) {}
  int lowbit(int x) { return x & -x; }
  void add(int r, int c, long long v) {
    for (int i = r; i <= n; i += lowbit(i))
      for (int j = c; j <= m; j += lowbit(j)) C[i * (m + 1) + j] += v;
  }
  long long sum(int r, int c) {
    long long res = 0;
    for (int i = r; i; i -= lowbit(i))
      for (int j = c; j; j -= lowbit(j)) res += C[i * (m + 1) + j];
    return res;
  }
};
int n, m, k;
vector<pair<int, string>> ans;
int yes() {
  cout << "YES" << endl;
  cout << ans.size() << endl;
  for (auto& p : ans) {
    cout << p.first << " " << p.second << endl;
  }
  return 0;
}
int no() {
  cout << "NO" << endl;
  return 0;
}
int main() {
  ios::sync_with_stdio(0), cin.tie(0), cout.tie(0);
  ;
  cin >> n >> m >> k;
  int r = 0, c = 0;
  if (k <= m - 1) {
    ans.push_back({k, "R"});
    k = 0;
  } else if (m - 1 >= 1) {
    ans.push_back({m - 1, "R"});
    k -= m - 1;
  }
  if (k <= 0) return yes();
  if (k <= m - 1) {
    ans.push_back({k, "L"});
    k = 0;
  } else if (m - 1 >= 1) {
    ans.push_back({m - 1, "L"});
    k -= m - 1;
  }
  if (k <= 0) return yes();
  r++;
  if (r >= n) return no();
  ans.push_back({1, "D"});
  k--;
  if (k <= 0) return yes();
  while (k > 0) {
    if (m - 1 >= 1) {
      if (k <= m - 1) {
        ans.push_back({k, "R"});
        k = 0;
        break;
      }
      ans.push_back({m - 1, "R"});
      k -= m - 1;
    }
    if (k <= (m - 1) * 3) {
      int p = k / 3;
      if (p) ans.push_back({p, "UDL"});
      if (k % 3) ans.push_back({1, string("UDL").substr(0, k % 3)});
      k = 0;
      break;
    }
    if (m - 1 >= 1) {
      ans.push_back({m - 1, "UDL"});
      k -= (m - 1) * 3;
    }
    r++;
    if (r >= n) {
      if (k > n - 1)
        return no();
      else {
        ans.push_back({k, "U"});
        k = 0;
        break;
      }
    }
    ans.push_back({1, "D"});
    k--;
  }
  if (k <= 0)
    return yes();
  else
    return no();
  return 0;
}