#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;
}
