Problem:
Score : 900 points

Problem Statement

Takahashi has an N \times M grid, with N horizontal rows and M vertical columns.
Determine if we can place A 1 \times 2 tiles (1 vertical, 2 horizontal) and B 2 \times 1 tiles (2 vertical, 1 horizontal) satisfying the following conditions, and construct one arrangement of the tiles if it is possible:

All the tiles must be placed on the grid.

Tiles must not stick out of the grid, and no two different tiles may intersect.

Neither the grid nor the tiles may be rotated.

Every tile completely covers exactly two squares.

Constraints

1 \leq N,M \leq 1000

0 \leq A,B \leq 500000

N, M, A and B are integers.

Input

Input is given from Standard Input in the following format:

N M A B

Output

If it is impossible to place all the tiles, print NO.
Otherwise, print the following:

YES
c_{11}...c_{1M}
:
c_{N1}...c_{NM}

Here, c_{ij} must be one of the following characters: ., <, >, ^ and v. Represent an arrangement by using each of these characters as follows:

When c_{ij} is ., it indicates that the square at the i-th row and j-th column is empty;

When c_{ij} is <, it indicates that the square at the i-th row and j-th column is covered by the left half of a 1 \times 2 tile;

When c_{ij} is >, it indicates that the square at the i-th row and j-th column is covered by the right half of a 1 \times 2 tile;

When c_{ij} is ^, it indicates that the square at the i-th row and j-th column is covered by the top half of a 2 \times 1 tile;

When c_{ij} is v, it indicates that the square at the i-th row and j-th column is covered by the bottom half of a 2 \times 1 tile.

Sample Input 1

3 4 4 2

Sample Output 1

YES
<><>
^<>^
v<>v

This is one example of a way to place four 1 \times 2 tiles and three 2 \times 1 tiles on a 3 \times 4 grid.

Sample Input 2

4 5 5 3

Sample Output 2

YES
<>..^
^.<>v
v<>.^
<><>v

Sample Input 3

7 9 20 20

Sample Output 3

NO

Solution in C# (Mono 4.6.2.0) (judge verdict: Accepted)

using System;
using System.Collections;
using System.Collections.Generic;
using System.Diagnostics;
using System.IO;
using System.Linq;
using System.Numerics;
using System.Text;
using static System.Convert;
using static System.Math;
using static Constants;
using static Extensions;
using static MathExtensions;

public static class Program
{
    enum State
    {
        Blank, ALeft, ARight, BUpper, BLower
    }

    public static void Solve()
    {
        var n = I;
        var m = I;
        var a = I;
        var b = I;

        if (n == 1 && b > 0) Answer(NO);
        if (m == 1 && a > 0) Answer(NO);

        var x = (m / 2) * (n / 2);
        var y = 0;
        var field = new State[n, m];
        var i = 0;
        var j = 0;

        if (n % 2 == 1 && m % 2 == 1)
        {
            i = n - 1;
            j = 0;

            for (; j <= m - 3 && a > 0; j += 2)
            {
                field[i, j] = State.ALeft;
                field[i, j + 1] = State.ARight;
                a--;
            }

            i = 1;
            j = m - 1;

            for (; i <= n - 2 && b > 0; i += 2)
            {
                field[i, j] = State.BUpper;
                field[i + 1, j] = State.BLower;
                b--;
            }

            x--;
            y = 1;
        }
        else if (n % 2 == 1)
        {
            i = n - 1;
            j = 0;

            for (; j <= m - 2 && a > 0; j += 2)
            {
                field[i, j] = State.ALeft;
                field[i, j + 1] = State.ARight;
                a--;
            }
        }
        else if (m % 2 == 1)
        {
            i = 0;
            j = m - 1;

            for (; i <= n - 2 && b > 0; i += 2)
            {
                field[i, j] = State.BUpper;
                field[i + 1, j] = State.BLower;
                b--;
            }
        }

        i = j = 0;

        while (x > 0 && (a > 0 || b > 0))
        {
            if (i == 0 && j == m - (m % 2) - 2 && y == 1)
            {
                i += 2;
            }

            if (a >= b && a > 0)
            {
                if (i > n - (n % 2) - 2) goto exitLoop;

                if (a >= 2)
                {
                    field[i + 1, j] = State.ALeft;
                    field[i + 1, j + 1] = State.ARight;
                    a--;
                }

                field[i, j] = State.ALeft;
                field[i, j + 1] = State.ARight;
                a--;
                x--;
            }
            else if (b > 0)
            {
                if (j > m - (m % 2) - 2) goto exitLoop;

                if (b >= 2)
                {
                    field[i, j + 1] = State.BUpper;
                    field[i + 1, j + 1] = State.BLower;
                    b--;
                }

                field[i, j] = State.BUpper;
                field[i + 1, j] = State.BLower;
                b--;
                x--;
            }

            if ((i += 2) >= n - (n % 2))
            {
                i = 0;
                j += 2;
            }
        }

        exitLoop:

        if (y == 0 && (a > 0 || b > 0)) Answer(NO);

        if (a == 2)
        {
            i = 0;
            j = m - (m % 2) - 2;
            field[i, j] = field[i + 1, j] = State.ALeft;
            field[i, j + 1] = field[i + 1, j + 1] = State.ARight;
            a -= 2;
        }
        else if (b == 2)
        {
            i = 0;
            j = m - (m % 2) - 2;
            field[i, j] = field[i, j + 1] = State.BUpper;
            field[i + 1, j] = field[i + 1, j + 1] = State.BLower;
            b -= 2;
        }
        else if (a <= 1 && b <= 1)
        {
            if (a == 1)
            {
                i = 0;
                j = m - (m % 2) - 1;
                field[i, j] = State.ALeft;
                field[i, j + 1] = State.ARight;
                a--;
            }

            if (b == 1)
            {
                i = 0;
                j = m - (m % 2) - 2;
                field[i, j] = State.BUpper;
                field[i + 1, j] = State.BLower;
                b--;
            }
        }
        else
        {
            Answer(NO);
        }

        if (a > 0 || b > 0) Answer(NO);

        Console.WriteLine(YES);

        foreach (var p in Range(n))
        {
            foreach (var q in Range(m))
            {
                switch (field[p, q])
                {
                    case State.Blank:
                    {
                        Console.Write('.');
                        break;
                    }
                    case State.ALeft:
                    {
                        Console.Write('<');
                        break;
                    }
                    case State.ARight:
                    {
                        Console.Write('>');
                        break;
                    }
                    case State.BUpper:
                    {
                        Console.Write('^');
                        break;
                    }
                    case State.BLower:
                    {
                        Console.Write('v');
                        break;
                    }
                }
            }

            Console.WriteLine();
        }
    }

    #region Scanners
    static TextScanner _ts;

    static char C => char.Parse(_ts.Next());
    static string S => _ts.Next();
    static int I => int.Parse(_ts.Next());
    static long L => long.Parse(_ts.Next());
    static BigInteger B => BigInteger.Parse(_ts.Next());
    static double D => double.Parse(_ts.Next());

    static char[] Cs(int count) => Repeat(count, () => C).ToArray();
    static string[] Ss(int count) => Repeat(count, () => S).ToArray();
    static int[] Is(int count) => Repeat(count, () => I).ToArray();
    static long[] Ls(int count) => Repeat(count, () => L).ToArray();
    static BigInteger[] Bs(int count) => Repeat(count, () => B).ToArray();
    static double[] Ds(int count) => Repeat(count, () => D).ToArray();
    #endregion

    public static void Main()
    {
        var sw = new StreamWriter(Console.OpenStandardOutput());
        sw.NewLine = "\n";
#if DEBUG
        sw.AutoFlush = true;
#else
        sw.AutoFlush = false;
#endif
        Console.SetOut(sw);
        _ts = new TextScanner(Console.In);
        Solve();
        Console.Out.Flush();
    }
}

public static partial class Extensions
{
    public static T[] Sort<T>(this T[] array)
        where T : IComparable<T>
    {
        Array.Sort(array);
        return array;
    }

    public static T[] SortDescending<T>(this T[] array)
        where T : IComparable<T>
    {
        Array.Sort(array, Comparer<T>.Create((x, y) => y.CompareTo(x)));
        return array;
    }

    public static T[] SortBy<T, TKey>(this T[] array, Func<T, TKey> keySelector)
        where TKey : IComparable<TKey>
    {
        Array.Sort(array, Comparer<T>.Create((x, y) => keySelector(x).CompareTo(keySelector(y))));
        return array;
    }

    public static T[] SortByDescending<T, TKey>(this T[] array, Func<T, TKey> keySelector)
        where TKey : IComparable<TKey>
    {
        Array.Sort(array, Comparer<T>.Create((x, y) => keySelector(y).CompareTo(keySelector(x))));
        return array;
    }
}

#region Library
public class TextScanner
{
    private readonly TextReader _tr;

    public TextScanner(TextReader tr)
    {
        _tr = tr;
    }

    public string Next()
    {
        var sb = new StringBuilder();
        int i;
        do
        {
            i = _tr.Read();
            if (i == -1) throw new EndOfStreamException();
        }
        while (char.IsWhiteSpace((char)i));
        while (i != -1 && !char.IsWhiteSpace((char)i))
        {
            sb.Append((char)i);
            i = _tr.Read();
        }
        return sb.ToString();
    }
}

public static class Constants
{
    public const int AnswerToLifeTheUniverseAndEverything = 42;
    public const string Yes = "Yes";
    public const string No = "No";
    public const string YES = "YES";
    public const string NO = "NO";
    public const string Possible = "Possible";
    public const string Impossible = "Impossible";
    public const string POSSIBLE = "POSSIBLE";
    public const string IMPOSSIBLE = "IMPOSSIBLE";
}

[DebuggerStepThrough]
public static partial class Extensions
{
    public static void Answer(object value)
    {
        Console.WriteLine(value);
        Exit(0);
    }

    public static void Assert(bool condition)
    {
        if (!condition) throw new Exception("Assertion failed");
    }

    public static string AsString(this IEnumerable<char> source) => new string(source.ToArray());

    public static Dictionary<T, int> Bucket<T>(this IEnumerable<T> source) where T : IEquatable<T>
    {
        var dict = new Dictionary<T, int>();
        foreach (var item in source) if (dict.ContainsKey(item)) dict[item]++; else dict[item] = 1;
        return dict;
    }

    public static int[] Bucket<T>(this IEnumerable<T> source, int maxValue, Func<T, int> selector)
    {
        var arr = new int[maxValue + 1];
        foreach (var item in source) arr[selector(item)]++;
        return arr;
    }

    public static IComparer<T> CreateDescendingComparer<T>()
        where T : IComparable<T>
        => Comparer<T>.Create((x, y) => y.CompareTo(x));

    public static IEnumerable<int> CumSum(this IEnumerable<int> source)
    {
        var sum = 0;
        foreach (var item in source) yield return sum += item;
    }

    public static IEnumerable<long> CumSum(this IEnumerable<long> source)
    {
        var sum = 0L;
        foreach (var item in source) yield return sum += item;
    }

    public static void Exit(int exitCode)
    {
        Console.Out.Flush();
        Environment.Exit(exitCode);
    }

    public static void ForEach<T>(this IEnumerable<T> source, Action<T> action)
    {
        foreach (var item in source) action(item);
    }

    public static void ForEach<T, _>(this IEnumerable<T> source, Func<T, _> func)
    {
        foreach (var item in source) func(item);
    }

    public static void ForEach<T>(this IEnumerable<T> source, Action<T, int> action)
    {
        var i = 0;
        foreach (var item in source) action(item, i++);
    }

    public static void ForEach<T, _>(this IEnumerable<T> source, Func<T, int, _> func)
    {
        var i = 0;
        foreach (var item in source) func(item, i++);
    }

    // [l, r)
    public static bool IsIn<T>(this T value, T l, T r)
        where T : IComparable<T>
    {
        if (l.CompareTo(r) > 0) throw new ArgumentException();
        return l.CompareTo(value) <= 0 && value.CompareTo(r) < 0;
    }

    public static IEnumerable<int> Range(int start, int end, int step = 1)
    {
        for (var i = start; i < end; i += step) yield return i;
    }

    public static IEnumerable<int> Range(int end) => Range(0, end);

    public static void Repeat(int count, Action action)
    {
        for (var i = 0; i < count; i++) action();
    }

    public static void Repeat(int count, Action<int> action)
    {
        for (var i = 0; i < count; i++) action(i);
    }

    public static IEnumerable<T> Repeat<T>(int count, Func<T> func)
    {
        for (var i = 0; i < count; i++) yield return func();
    }

    public static IEnumerable<T> Repeat<T>(int count, Func<int, T> func)
    {
        for (var i = 0; i < count; i++) yield return func(i);
    }

    public static void Swap<T>(ref T x, ref T y)
    {
        var tmp = x; x = y; y = tmp;
    }
}

[DebuggerStepThrough]
public static class MathExtensions
{
    public static int DivCeil(int left, int right)
        => left / right + (left % right == 0 ? 0 : 1);

    public static long DivCeil(long left, long right)
        => left / right + (left % right == 0L ? 0L : 1L);

    public static int Gcd(int left, int right)
    {
        int r;
        while ((r = left % right) != 0) { left = right; right = r; }
        return right;
    }

    public static long Gcd(long left, long right)
    {
        long r;
        while ((r = left % right) != 0L) { left = right; right = r; }
        return right;
    }

    public static BigInteger Gcd(BigInteger left, BigInteger right)
        => BigInteger.GreatestCommonDivisor(left, right);

    public static int HighestOneBit(int x)
    {
        x |= x >> 01;
        x |= x >> 02;
        x |= x >> 04;
        x |= x >> 08;
        x |= x >> 16;
        return x - (x >> 1);
    }

    public static long HighestOneBit(long x)
    {
        x |= x >> 01;
        x |= x >> 02;
        x |= x >> 04;
        x |= x >> 08;
        x |= x >> 16;
        x |= x >> 32;
        return x - (x >> 1);
    }

    public static int Lcm(int left, int right) => left / Gcd(left, right) * right;

    public static long Lcm(long left, long right) => left / Gcd(left, right) * right;

    public static BigInteger Lcm(BigInteger left, BigInteger right)
        => left / Gcd(left, right) * right;

    public static int Pow(int value, int exponent)
    {
        var r = 1;
        while (exponent > 0)
        {
            if ((exponent & 1) == 1) r *= value;
            value *= value;
            exponent >>= 1;
        }
        return r;
    }

    public static long Pow(long value, int exponent)
    {
        var r = 1L;
        while (exponent > 0)
        {
            if ((exponent & 1) == 1) r *= value;
            value *= value;
            exponent >>= 1;
        }
        return r;
    }

    public static long Fact(int value)
    {
        var r = 1L;
        for (var i = 2; i <= value; i++) r *= i;
        return r;
    }
}
#endregion