#include "bits/stdc++.h"
#define _USE_MATH_DEFINES
#include <math.h>
 
using namespace std;
 
using LL = long long;
using VLL = std::vector<LL>;
using VVLL = std::vector<VLL>;
using VVVLL = std::vector<VVLL>;
using LD = long double;
using VLD = std::vector<LD>;
using VVLD = std::vector<VLD>;
using VVVLD = std::vector<VVLD>;
using BL = bool;
using VBL = std::vector<BL>;
using VVBL = std::vector<VBL>;
using VVVBL = std::vector<VVBL>;


template<class T> inline bool chmax(T &a, T b) { if (a < b) { a = b; return true; }return false; }
template<class T> inline bool chmin(T &a, T b) { if (a > b) { a = b; return true; }return false; }

//template<class T=LL> inline vector<T> cinv(LL N){ vector<T> v(N); REP(i, N)cin>>v[i]; return move(v);}
//template<class T=LL> inline vector<T> cinv(LL N){ vector<T> v(N); REP(i, N)cin>>v[i]; return move(v);}
#define REP(i,n) for(LL (i)=0;(i)<(n);(i)++)
#define REPM(i,n,m) for(LL (i)=m;(i)<(n);(i)++)
#define ALL(v) v.begin(), v.end()
#define PRINTLN(v) {LL i=0; for(auto (a): v ){   cerr <<i << " : "<<  a << endl; i++;}}
//#define PRLLSP(v) for(auto (a): v ) {cerr << a << " ";} cerr << endl

template<class T> 
void PRINTSP(vector<T> v, size_t w=3){
  for(auto (a): v ) {cerr <<setw(w)<< a << " ";} cerr << endl;
} 

template<typename TTT>
vector<LL> arg_sort(vector<TTT> A, bool ascend = true) {
  vector<LL> index(A.size());
  iota(index.begin(), index.end(), 0);
  if (ascend) {
    std::sort(index.begin(), index.end(), [&A](TTT i1, TTT i2) {
      return A[i1] < A[i2];
      });
  }
  else {
    std::sort(index.begin(), index.end(), [&A](TTT i1, TTT i2) {
      return A[i1] > A[i2];
      });
  }

  return index;
}

struct UinonFindTree {
private:
  vector<LL> UFT;
public:
  UinonFindTree(LL N) {
    UFT.resize(N);
    for (LL i = 0; i < N; i++) {
      UFT[i] = -1; 
    }
  }

  LL root(LL i) { 
    if (UFT[i] < 0) {
      return i;
    }
    else {
      LL j = root(UFT[i]);
      UFT[i] = j;
      return j;
    }
  }

  bool same(LL i, LL j) {
    return (root(i) == root(j));
  }

  void unite(LL i, LL j)
  {
    LL root_i = root(i);
    LL root_j = root(j);
    if (root_i != root_j) {
      if (size(root_i) < size(root_j)) {
        swap(root_i, root_j);
      }
      UFT[root_i] += UFT[root_j];
      UFT[root_j] = root_i;
    }
  }

  LL size(LL i) {
    return -UFT[root(i)];
  }

  LL get_root_num() {
    set<LL> roots;
    for (LL i = 0; i < (LL)UFT.size(); ++i) {
      roots.insert(root(i));
    }
    return (LL)roots.size();
  }

  map<LL, vector<LL>> get_root_child() {
    map<LL, vector<LL>> a;
    for (LL i = 0; i < (LL)UFT.size(); ++i) {
      LL j = root(i);
      a[j].push_back(i);
    }
    return a;
  }

  void prLL() { 
    for (LL i = 0; i < (LL)UFT.size(); ++i) {
      cerr << root(i) << " ";
    }
    cerr << endl;
  }
};



#define cmax(a,b) {if(a<b){a=b;}}
#define cmin(a,b) {if(a>b){a=b;}}
#define EACH(a,A) for(auto a: A)
//#define cmax(a,b) a = (a>b ? a:b)
//#define cmin(a,b) a = (a<b ? a:b) 
//cin,cout高速化のおまじない＋桁数指定
inline VLL cinvll(LL N, LL minus = 0){
  VLL A(N);
  REP(i,N){
    cin >> A[i];
    A[i] -= minus;
  }
  return move(A);
}
inline VVLL zerosll(LL H, LL W, LL val=0){
  VVLL A(H,VLL(W,val));
  return move(A);
}

#define repi(itr, ds) for (auto itr = ds.begin(); itr != ds.end(); itr++)
 
// vector
template <typename T>
istream &operator>>(istream &is, vector<T> &vec) {
    for (T &x : vec) is >> x;
    return is;
}
// pair
template <typename T, typename U>
ostream &operator<<(ostream &os, pair<T, U> &pair_var) {
    os << "(" << pair_var.first << ", " << pair_var.second << ")";
    return os;
}
// vector
template <typename T>
ostream &operator<<(ostream &os, const vector<T> &vec) {
 
  for (LL i = 0; i < (LL)vec.size(); i++) {
    os << setw(3) << vec[i];
  } 
  os << endl;
  return os;
    
#if 0    
    os << "{";
    for (LL i = 0; i < (LL)vec.size(); i++) {
        os << vec[i] << (i + 1 == (LL)vec.size() ? "" : ", ");
    }
    os << "}";
    return os;
#endif
}
// map
template <typename T, typename U>
ostream &operator<<(ostream &os, map<T, U> &map_var) {
    os << "{";
    repi(itr, map_var) {
        os << *itr;
        itr++;
        if (itr != map_var.end()) os << ", ";
        itr--;
    }
    os << "}";
    return os;
}
// set
template <typename T>
ostream &operator<<(ostream &os, set<T> &set_var) {
    os << "{";
    repi(itr, set_var) {
        os << *itr;
        itr++;
        if (itr != set_var.end()) os << ", ";
        itr--;
    }
    os << "}";
    
    return os;
}
 
#define DUMPOUT cerr
#define DUMPCOLOR ("\033[36m")
 
void dump_func() {
    DUMPOUT << endl;
}
template <class Head, class... Tail>
void dump_func(Head &&head, Tail &&... tail) {
    DUMPOUT << DUMPCOLOR;
    DUMPOUT << head;
    if (sizeof...(Tail) > 0) {
        DUMPOUT << ", ";
    }
    dump_func(std::move(tail)...);
    DUMPOUT << "\033[m";
}
#ifdef DEBUG_
#define DEB
#define dump(...)                                                              \
    DUMPOUT << DUMPCOLOR                                                      \
            << "" << string(#__VA_ARGS__) << ": "                            \
            << "[" << to_string(__LINE__) << ":" << __FUNCTION__ << "]"        \
            << endl                                                            \
            << "\033[m"                                                        \
            << "",                                                         \
        dump_func(__VA_ARGS__)
#else
#define DEB if (false)
#define dump(...)
#endif

struct Fast{
	Fast(){
		cin.tie(0);
		ios::sync_with_stdio(false);
		cout << fixed << setprecision(std::numeric_limits<double>::max_digits10);
	}
} fast;

#if 0 
LL GCD(LL m, LL n) {

  if (m < n) {
    swap(m, n);
  }

  while (n != 0) {
    LL n_new = m % n;
    m = n;
    n = n_new;
  }

  return m;

}

VLL B;
VVLL T;
LL cnt=0;
void dfs(LL me,LL oya){

  for(LL i=0;i<T[me].size();i++){
    LL ko = T[me][i];
    if(ko==oya){
      continue;
    }
    cnt += min(B[me],B[ko]);
    dfs(ko,me);
  }

}
#endif 

bool func_(VLL &Z1,VLL &Z2,LL W, LL sx){

  dump(W,sx);
  //dump(Z1);
  //dump(Z2);
  LL N = Z1.size();
  LL l=0;
  LL r=W;
  if(Z1[N-1]==1){
    r--;
  }
  else if(Z1[N-1]==-1){
    l++;
  }
  dump(l,r);
  for(LL i=N-2;i>=0; i--){
    if(     Z1[i]== 1 and Z2[i]== 1){
      r--;
      l--;
    }
    else if(Z1[i]== 1 and Z2[i]==-1){
      chmin(r,W-1);
    }
    else if(Z1[i]== 1 and Z2[i]== 0){
      r--;
    }
    else if(Z1[i]==-1 and Z2[i]== 1){
      chmax(l,1LL);      
    }
    else if(Z1[i]==-1 and Z2[i]==-1){
      r++;
      l++;
    }
    else if(Z1[i]==-1 and Z2[i]== 0){
      l++;
    }
    else if(Z1[i]== 0 and Z2[i]== 1){
      l--;
    }
    else if(Z1[i]== 0 and Z2[i]== 1){
      r++;
    }
    else if(Z1[i]== 0 and Z2[i]== 0){
      
    }
    if(i>500){
      dump(i,sx ,l,r);
    }
    chmax(l,0LL);
    chmin(r,W);
    //dump(i,sx ,l,r);
    if(l>=r){
      return false;
    }


  }
  dump(W,sx);
  dump(sx ,l,r);

  if(sx>=l and sx< r){
    return true;
  }
  else{
    return false;
  }
}

void func(){
  LL H,W,N;
  cin >>H >> W >>N;
  LL sy,sx;
  cin >> sy >> sx;
  sx--;
  sy--;
  string S,T;
  cin >> S;
  cin >> T;

  LL u = 0;
  LL d = H;
  LL l = 0;
  LL r = W;
  if(S[N-1]=='U'){
    u++;
  }
  if(S[N-1]=='D'){
    d--;
  }
  if(S[N-1]=='L'){
    l++;
  }
  if(S[N-1]=='R'){
    r--;
  }
  dump(u,d,l,r);

  for(LL i=N-2;i>=0;i--){
    if(S[i]=='U'){
      u++;
    }    
    if(S[i]=='D'){
      d--;
    }
    if(S[i]=='L'){
      l++;
    }
    if(S[i]=='R'){
      r--;
    }
    if(T[i]=='U'){
      d++;
    }    
    if(T[i]=='D'){
      u--;
    }
    if(T[i]=='L'){
      r++;
    }
    if(T[i]=='R'){
      l--;
    }

    if(S[i]=='U' and T[i]=='D' and u==0){
      u++;
    }
    if(S[i]=='D' and T[i]=='U' and d==H){
      d--;
    }
    if(S[i]=='L' and T[i]=='R' and l==0){
      l++;
    }
    if(S[i]=='R' and T[i]=='L' and r==W){
      r--;
    }

    chmax(u,0LL);
    chmax(l,0LL);
    chmin(d,H);
    chmin(r,W);
    dump(i,S[i],T[i],u,d,l,r);
    if(u>=d or l>=r){
      cout << "NO";
      return;
    }
  }

  if(sy>=u and sy<d and sx>=l and sx<r ){
    cout << "YES";
  }
  else{
    cout << "NO";
  }

  //RLDRRUD
  //URRDRLL
}

int main()
{
  func();
  return 0;
}
 

Measured memory_bytes: 920