Problem: A balancing network is an abstract device built up of N wires, thought of as running from left to right, and M balancers that connect pairs of wires. The wires are numbered from 1 to N from top to bottom, and the balancers are numbered from 1 to M from left to right. Balancer i connects wires x_i and y_i (x_i < y_i).

pic1-small-2acea94b.png

Each balancer must be in one of two states: up or down.

Consider a token that starts moving to the right along some wire at a point to the left of all balancers. During the process, the token passes through each balancer exactly once. Whenever the token encounters balancer i, the following happens:

* If the token is moving along wire x_i and balancer i is in the down state, the token moves down to wire y_i and continues moving to the right.
* If the token is moving along wire y_i and balancer i is in the up state, the token moves up to wire x_i and continues moving to the right.
* Otherwise, the token doesn't change the wire it's moving along.



Let a state of the balancing network be a string of length M, describing the states of all balancers. The i-th character is `^` if balancer i is in the up state, and `v` if balancer i is in the down state.

A state of the balancing network is called uniforming if a wire w exists such that, regardless of the starting wire, the token will always end up at wire w and run to infinity along it. Any other state is called non-uniforming.

You are given an integer T (1 \le T \le 2). Answer the following question:

* If T = 1, find any uniforming state of the network or determine that it doesn't exist.
* If T = 2, find any non-uniforming state of the network or determine that it doesn't exist.



Note that if you answer just one kind of questions correctly, you can get partial score.

Constraints

* 2 \leq N \leq 50000
* 1 \leq M \leq 100000
* 1 \leq T \leq 2
* 1 \leq x_i < y_i \leq N
* All input values are integers.

Input

Input is given from Standard Input in the following format:


N M T
x_1 y_1
x_2 y_2
:
x_M y_M


Output

Print any uniforming state of the given network if T = 1, or any non-uniforming state if T = 2. If the required state doesn't exist, output `-1`.

Examples

Input

4 5 1
1 3
2 4
1 2
3 4
2 3


Output

^^^^^


Input

4 5 2
1 3
2 4
1 2
3 4
2 3


Output

v^^^^


Input

3 1 1
1 2


Output

-1


Input

2 1 2
1 2


Output

-1

Solution (in CPP):

Solution:
#include <bits/stdc++.h>
using namespace std;
typedef bool boolean;

#define pii pair<int, int>

const int N = 5e4 + 5;
const int M = 1e5 + 5;

int n, m, type;
char ans[M];
int us[M], vs[M];

namespace subtask1 {

	bitset<N> f[M];
	boolean vis[M];
	int h[N], A[M], B[M];

	void F(int p, int x) {
		if (!p || vis[p]) {
			return;
		}
		vis[p] = true;
		if (x == us[p]) {
			F(A[p], x);
			F(B[p], vs[p]);
		} else {
			ans[p] = 'v';
			F(B[p], x);
			F(A[p], us[p]);
		}
	}

	void solve() {
		for (int i = 1, u, v; i <= m; i++) {
			u = us[i], v = vs[i];
			if (!h[u]) {
				f[i].set(u);	
			} else {
				f[i] = f[h[u]]; 
			}
			swap(u, v);
			if (!h[u]) {
				f[i].set(u);	
			} else {
				f[i] |= f[h[u]]; 
			}
			swap(u, v);
			A[i] = h[u], B[i] = h[v];
			h[u] = h[v] = i;
		}
		for (int i = 1; i <= m; i++)
			ans[i] = '^';
		for (int i = 1; i <= m; i++) {
			if ((signed) f[i].count() == n) {
				F(i, us[i]);
				puts(ans + 1);
				return;
			}
		}
		puts("-1");
	}

}

namespace subtask2 {
	
	const int C = 451;

	set<pii> S;
	int h[C];
	int nxt[M][C];
	bitset<C> vis[M][2];

	boolean dfs(int p, int x, int y) {
		if (x == y) {
			return false;
		}
		if (p == m + 1) {
			return true;
		}
		int sx = -1, sy = -1;
		if (x == us[p] || y == us[p]) {
			sx = 0, sy = x ^ y ^ us[p];
		} else {
			sx = 1, sy = x ^ y ^ vs[p];
		}
		if (vis[p][sx].test(sy))
			return false;
		vis[p][sx].set(sy);

		// down
		int nx = (x == us[p]) ? vs[p] : x;
		int ny = (y == us[p]) ? vs[p] : y;
		if (dfs(min(nxt[p][nx], nxt[p][ny]), nx, ny)) {
			ans[p] = 'v';
			return true;
		}

		nx = (x == vs[p]) ? us[p] : x;
		ny = (y == vs[p]) ? us[p] : y;
		if (dfs(min(nxt[p][nx], nxt[p][ny]), nx, ny)) {
			ans[p] = '^';
			return true;
		}
		return false;
	}

	void solve() {
		for (int i = 1; i <= m; i++) {
			S.insert(pii(us[i], vs[i]));
		}
		if ((signed) S.size() < 1ll * n * (n - 1) / 2) {
			for (int i = 1; i <= n; i++) {
				for (int j = i + 1; j <= n; j++) {
					if (!S.count(pii(i, j))) {
						for (int k = 1; k <= m; k++) {
							if (us[k] == i || us[k] == j) {
								ans[k] = '^';
							} else {
								ans[k] = 'v';
							}
						}
						puts(ans + 1);
						return;
					}
				}
			}
			assert(false);
			return;
		}
		assert(n < C);
		for (int i = 1; i <= m; i++)
			ans[i] = 'v';
		for (int i = 1; i <= n; i++)
			h[i] = m + 1;
		for (int i = m; i; i--) {
			memcpy(nxt[i], h, sizeof(h));
			h[us[i]] = h[vs[i]] = i;
		}
		for (int i = 1; i <= n; i++) {
			for (int j = i + 1; j <= n; j++) {
				if (dfs(min(h[i], h[j]), i, j)) {
					puts(ans + 1);
					return;
				}
			}
		}
		puts("-1");
	}

}

int main() {
	scanf("%d%d%d", &n, &m, &type);
	for (int i = 1; i <= m; i++) {
		scanf("%d%d", us + i, vs + i);;
	}
	if (type == 1) {
		subtask1::solve();
	} else {
		subtask2::solve();
	}
	return 0;
}