#include <bits/stdc++.h>
using namespace std;
long long mod = 1000000007;
long long inf = 1e17;
long long gainR[500011], lossR[500011], gainC[500011], lossC[500011];
int main() {
  ios_base::sync_with_stdio(0);
  cin.tie(0);
  long long n, h, w;
  cin >> n >> h >> w;
  string str;
  cin >> str;
  for (int i = 1; i <= 500010; ++i) {
    gainR[i] = inf;
    lossR[i] = inf;
    gainC[i] = inf;
    lossC[i] = inf;
  }
  long long row_gain = 0, max_row_gain = 0, max_row_loss = 0;
  for (int i = 0; i < str.length(); ++i) {
    if (str[i] == 'U') {
      --row_gain;
      if (row_gain < 0) {
        max_row_loss = max(abs(row_gain), max_row_loss);
        lossR[abs(row_gain)] = min(lossR[abs(row_gain)], (long long)(i + 1));
      }
    } else if (str[i] == 'D') {
      ++row_gain;
      max_row_gain = max(max_row_gain, row_gain);
      if (row_gain > 0)
        gainR[row_gain] = min(gainR[row_gain], (long long)(i + 1));
    }
  }
  long long col_gain = 0, max_col_gain = 0, max_col_loss = 0;
  for (int i = 0; i < str.length(); ++i) {
    if (str[i] == 'L') {
      --col_gain;
      if (col_gain < 0) {
        max_col_loss = max(abs(col_gain), max_col_loss);
        lossC[abs(col_gain)] = min(lossC[abs(col_gain)], (long long)(i + 1));
      }
    } else if (str[i] == 'R') {
      ++col_gain;
      max_col_gain = max(max_col_gain, col_gain);
      if (col_gain > 0)
        gainC[col_gain] = min(gainC[col_gain], (long long)(i + 1));
    }
  }
  bool PositiveRowGain = (row_gain > 0);
  bool PositiveColGain = (col_gain > 0);
  if (PositiveRowGain) {
    for (int i = max_row_gain + 1; i <= 500010; ++i) {
      long long num_cycles = (i - max_row_gain + row_gain - 1) / (row_gain);
      long long add_moves = (n * num_cycles);
      assert(gainR[i - (num_cycles * row_gain)] != inf);
      gainR[i] = (add_moves + gainR[i - (num_cycles * row_gain)]);
    }
  } else if (row_gain < 0) {
    long long row_loss = abs(row_gain);
    for (int i = max_row_loss + 1; i <= 500010; ++i) {
      long long num_cycles = (i - max_row_loss + row_loss - 1) / (row_loss);
      long long add_moves = (n * num_cycles);
      assert(lossR[i - (num_cycles * row_loss)] != inf);
      lossR[i] = (add_moves + lossR[i - (num_cycles * row_loss)]);
    }
  }
  if (PositiveColGain) {
    for (int i = max_col_gain + 1; i <= 500010; ++i) {
      long long num_cycles = (i - max_col_gain + col_gain - 1) / (col_gain);
      long long add_moves = (n * num_cycles);
      assert(gainC[i - (num_cycles * col_gain)] != inf);
      gainC[i] = (add_moves + gainC[i - (num_cycles * col_gain)]);
    }
  } else if (col_gain < 0) {
    long long col_loss = abs(col_gain);
    for (int i = max_col_loss + 1; i <= 500010; ++i) {
      long long num_cycles = (i - max_col_loss + col_loss - 1) / (col_loss);
      long long add_moves = (n * num_cycles);
      assert(lossC[i - (num_cycles * col_loss)] != inf);
      lossC[i] = (add_moves + lossC[i - (num_cycles * col_loss)]);
    }
  }
  bool okRow = true, okCol = true;
  for (int r = 0; r < h; ++r) {
    if (lossR[r + 1] < inf || gainR[h - r] < inf) continue;
    okRow = false;
  }
  for (int c = 0; c < w; ++c) {
    if (lossC[c + 1] < inf || gainC[w - c] < inf) continue;
    okCol = false;
  }
  if (row_gain != 0 || col_gain != 0) okCol = true;
  if (!okRow && !okCol) {
    cout << -1 << "\n";
    return 0;
  }
  vector<long long> R, C;
  for (int r = 1; r <= h; ++r) {
    R.push_back(min(lossR[r], gainR[h - r + 1]));
  }
  for (int c = 1; c <= w; ++c) {
    C.push_back(min(lossC[c], gainC[w - c + 1]));
  }
  sort(R.begin(), R.end());
  sort(C.begin(), C.end());
  long long fans = 0;
  int c_ptr = 0;
  for (int i = 0; i < R.size(); ++i) {
    if (R[i] >= inf) continue;
    while (c_ptr < C.size() && C[c_ptr] < R[i]) ++c_ptr;
    long long num_greater = (int)C.size() - c_ptr;
    fans = (fans + (num_greater * R[i]) % mod) % mod;
  }
  int r_ptr = 0;
  for (int i = 0; i < C.size(); ++i) {
    if (C[i] >= inf) continue;
    while (r_ptr < R.size() && R[r_ptr] < C[i]) ++r_ptr;
    long long num_greater = (int)R.size() - r_ptr;
    fans = (fans + (num_greater * C[i]) % mod) % mod;
  }
  cout << fans << "\n";
  return 0;
}
