using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Text.RegularExpressions;
using System.Threading.Tasks;

using System.Collections;

class Program
{
    static void Main()
    {
        int[] hwn = Console.ReadLine().Split(' ').Select(s => int.Parse(s)).ToArray();
        int H = hwn[0];
        int W = hwn[1];
        int N = hwn[2];

        int[] rc = Console.ReadLine().Split(' ').Select(s => int.Parse(s)).ToArray();
        int sr = rc[0];
        int sc = rc[1];

        string S = Console.ReadLine();
        string T = Console.ReadLine();

        bool isRemain = true;

        //横方向判定
        {
            int rangeSt = 1;
            int rangeEd = W;

            for (int i = S.Length - 1; i >= 0; i--)
            {
                char chT = T[i];
                char chS = S[i];

                //後手の補正
                if (chT == 'R')
                {
                    //この後手を指す直前に居ても大丈夫な範囲が左側に1増える
                    rangeSt = Math.Max(rangeSt - 1, 1);                    
                }
                else if (chT == 'L')
                {
                    //この後手を指す直前に居ても大丈夫な範囲が右側に1増える
                    rangeEd = Math.Min(rangeEd + 1, W);
                }

                //後手が始まる前にいても良い範囲がない時点で後手の負けは確定
                if (rangeEd < rangeSt)
                {
                    isRemain = false;
                }

                //先手の補正
                if (chS == 'R')
                {
                    //この先手を指す直前に居ても大丈夫な範囲が右側から1縮む
                    rangeEd--;
                }
                else if (chS == 'L')
                {
                    //この先手を指す直前にいても大丈夫な範囲が左側から1縮む
                    rangeSt++;
                }

                //先手が始まる前にいても良い範囲がない時点で後手の負けは確定
                if (rangeEd < rangeSt)
                {
                    isRemain = false;
                }
            }

            //更に初期座標が居ても良い範囲に含まれていない場合、後手の負けが確定
            if (rangeSt > sc || sc > rangeEd)
            {
                isRemain = false;
            }
        }

        //縦方向判定
        {
            int rangeSt = 1;
            int rangeEd = H;

            for (int i = S.Length - 1; i >= 0; i--)
            {
                char chT = T[i];
                char chS = S[i];

                //後手の補正
                if (chT == 'D')
                {
                    //この後手を指す直前に居ても大丈夫な範囲が上側に1増える
                    rangeSt = Math.Max(rangeSt - 1, 1);
                }
                else if (chT == 'U')
                {
                    //この後手を指す直前に居ても大丈夫な範囲が下側に1増える
                    rangeEd = Math.Min(rangeEd + 1, H);
                }

                //後手が始まる前にいても良い範囲がない時点で後手の負けは確定
                if (rangeEd < rangeSt)
                {
                    isRemain = false;
                }

                //先手の補正
                if (chS == 'D')
                {
                    //この先手を指す直前に居ても大丈夫な範囲が下側から1縮む
                    rangeEd--;
                }
                else if (chS == 'U')
                {
                    //この先手を指す直前にいても大丈夫な範囲が上側から1縮む
                    rangeSt++;
                }

                //先手が始まる前にいても良い範囲がない時点で後手の負けは確定
                if (rangeEd < rangeSt)
                {
                    isRemain = false;
                }
            }

            //更に初期座標が居ても良い範囲に含まれていない場合、後手の負けが確定
            if (rangeSt > sr || sr > rangeEd)
            {
                isRemain = false;
            }
        }

        Console.WriteLine(isRemain ? "YES" : "NO");
    }
}



static class MathUtil
{
    public static IEnumerable<IEnumerable<int>> GetPermutation(int n)
    {
        if (n == 0)
        {
            yield return Single(0);
            yield break;
        }

        for (int i = 0; i <= n; i++)
        {
            foreach (var x in GetPermutation(n - 1))
            {
                yield return Single(i).Concat(x.Select(itm => itm < i ? itm : itm + 1));
            }
        }
    }

    private static IEnumerable<int> Single(int x)
    {
        yield return x;
    }

    public static IEnumerable<int> EnumeratePrimeNumbers()
    {
        List<int> primes = new List<int>() { 2 };
        yield return 2;

        for (int i = 3; i < int.MaxValue; i++)
        {
            bool isPrime = true;
            int Sqrt = (int)Math.Sqrt(i) + 1;

            foreach (var prime in primes)
            {
                if (prime > Sqrt)
                {
                    break;
                }
                if (i % prime == 0)
                {
                    isPrime = false;
                    break;
                }
            }

            if (isPrime)
            {
                primes.Add(i);
                yield return i;
            }
        }
    }
}


Measured memory_bytes: 14688