#include <bits/stdc++.h>

#define rep(...) overload_rep(__VA_ARGS__, rep_1, rep_0)(__VA_ARGS__)
#define rep_0(i, end) for(int i = 0; i < (end); ++i)
#define rep_1(i, fr, ba) for(int i = (fr); i <= (ba); ++i)
#define overload_rep(arg0, arg1, arg2, name, ...) name
#define all(box) box.begin(), box.end()

template <class T, class U> inline bool chmax(T& lhs, const U& rhs) { if (lhs < rhs) { lhs = rhs; return 1; } return 0; }
template <class T, class U> inline bool chmin(T& lhs, const U& rhs) { if (lhs > rhs) { lhs = rhs; return 1; } return 0; }

int H, W, A, B, nowA, nowB;
char grid[1000][1000];

struct grid_setup {
    grid_setup() {
        rep(i, 1000) rep(j, 1000) {
            grid[i][j] = '.';
        }
    }
} gridsetup;

void put_side(const int& i, const int& j) {
    grid[i][j] = '<';
    grid[i][j + 1] = '>';
}

void erase_side(const int& i, const int& j) {
    grid[i][j] = '.';
    grid[i][j + 1] = '.';
}

bool exist_side(const int& i, const int& j) {
    return grid[i][j] == '<' && grid[i][j + 1] == '>';
}

void put_vert(const int& i, const int& j) {
    grid[i][j] = '^';
    grid[i + 1][j] = 'v';
}

void erase_vert(const int& i, const int& j) {
    grid[i][j] = '.';
    grid[i + 1][j] = '.';
}

bool exist_vert(const int& i, const int& j) {
    return grid[i][j] == '^' && grid[i + 1][j] == 'v';
}

void unavailable() {
    puts("NO");
    exit(0);
}

void answer() {
    puts("YES");
    rep(i, H) {
        rep(j, W) std::cout << grid[i][j];
        std::cout << '\n';
    }
    exit(0);
}

void solve_h_one() {
    if(A * 2 > W || B > 0) unavailable();
    rep(i, A) put_side(0, i * 2);
    answer();
}

void solve_w_one() {
    if(B * 2 > H || A > 0) unavailable();
    rep(i, B) put_vert(i * 2, 0);
    answer();
}

void adjust_A() {
    int x = 0, y = 0, index = 0;
    while(nowA > A && nowA > (H % 2) * (W / 2)) {
        nowA--;
        erase_side(x, y);
        if(index % 2 == 1) {
            nowB += 2;
            put_vert(x - 1, y);
            put_vert(x - 1, y + 1);
        }
        x++;
        index++;
        if(x >= H - H % 2) {
            x = 0;
            y += 2;
            index = 0;
        }
    }
    x = H - 1, y = 0;
    while(nowA > A) {
        nowA--;
        erase_side(x, y);
        y += 2;
    }
}

void adjust_B() {
    if(nowB < B) unavailable();
    if(nowB == B) answer();
    rep(i, H) rep(j, W) {
        if(exist_vert(i, j)) {
            nowB--;
            erase_vert(i, j);
        }
        if(nowB == B) answer();
    }
}

void solve_w_even() {
    nowA = H * W / 2, nowB = 0;
    if(A > nowA) unavailable();
    rep(i, H) rep(j, W / 2) put_side(i, j * 2);
    adjust_A();
    adjust_B();
}

void solve_even_odd() {
    nowA = H * (W / 2), nowB = H / 2;
    if(A > nowA) unavailable();
    rep(i, H) rep(j, W / 2) put_side(i, j * 2);
    rep(i, H / 2) put_vert(i * 2, W - 1);
    adjust_A();
    adjust_B();
}

void solve_odd_odd() {
    nowA = H * (W / 2), nowB = H / 2;
    if(A > nowA) unavailable();
    rep(i, H) rep(j, W / 2) put_side(i, j * 2);
    rep(i, H / 2) put_vert(i * 2, W - 1);
    int x = 0, y = 0, index = 0;
    while(nowA > A && nowA > W / 2) {
        if(index % 2 == 0) {
            nowA--;
            nowB++;
            index++;
            erase_vert(H - 3, W - 1);
            rep(i, 1, 3) erase_side(H - i, W - 3);
            put_vert(H - 3, W - 3);
            put_vert(H - 2, W - 1);
            put_side(H - 3, W - 2);
            put_side(H - 1, W - 3);
        } else {
            nowA--;
            nowB++;
            index++;
            erase_vert(H - 3, W - 3);
            erase_vert(H - 2, W - 1);
            erase_side(H - 3, W - 2);
            erase_side(H - 1, W - 3);
            put_vert(H - 3, W - 1);
            rep(i, 1, 3) put_side(H - i, W - 3);
            rep(i, 2) erase_side(x + i, y);
            rep(i, 2) put_vert(x, y + i);
            x += 2;
            if(x == H - 1) {
                x = 0;
                y += 2;
                index = 0;
            }
        }
    }
    x = H - 1, y = 0;
    while(nowA > A) {
        nowA--;
        erase_side(x, y);
        y += 2;
    }
    adjust_B();
}

int main() {
    
    std::cin >> H >> W >> A >> B;
    if(H == 1) solve_h_one();
    if(W == 1) solve_w_one();
    if(W % 2 == 0) solve_w_even();
    if(H % 2 == 0) solve_even_odd();
    else solve_odd_odd();

}


Measured memory_bytes: 2176