Problem:
Score : 1600 points

Problem Statement

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).

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.

Partial Score

800 points will be awarded for passing the testset satisfying T = 1.

800 points will be awarded for passing the testset satisfying T = 2.

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.

Sample Input 1

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

Sample Output 1

^^^^^

This state is uniforming: regardless of the starting wire, the token ends up at wire 1.

Sample Input 2

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

Sample Output 2

v^^^^

This state is non-uniforming: depending on the starting wire, the token might end up at wire 1 or wire 2.

Sample Input 3

3 1 1
1 2

Sample Output 3

-1

A uniforming state doesn't exist.

Sample Input 4

2 1 2
1 2

Sample Output 4

-1

A non-uniforming state doesn't exist.

Solution in Java8 (OpenJDK 1.8.0) (judge verdict: Accepted)

import static java.lang.Integer.parseInt;
import static java.lang.Long.parseLong;
import static java.lang.System.exit;
import static java.util.Arrays.fill;

import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;
import java.io.PrintWriter;
import java.util.StringTokenizer;

public class Main {

	static void solve() throws Exception {
		int n = scanInt(), m = scanInt(), t = scanInt();
		int x[] = new int[m], y[] = new int[m];
		for (int i = 0; i < m; i++) {
			x[i] = scanInt() - 1;
			y[i] = scanInt() - 1;
		}
		char ans[] = new char[m];
		fill(ans, '^');
		switch (t) {
		case 1:
		{
			int nn = (n + 63) >> 6;
			long sets[][] = new long[n][nn];
			for (int i = 0; i < n; i++) {
				sets[i][i >> 6] |= 1L << i;
			}
			for (int i = 0; i < m; i++) {
				long s1[] = sets[x[i]], s2[] = sets[y[i]];
				for (int j = 0; j < nn; j++) {
					s1[j] = s2[j] = s1[j] | s2[j];
				}
			}
			int o = -1;
			i: for (int i = 0; i < n; i++) {
				long s[] = sets[i];
				for (int j = 0; j < nn - 1; j++) {
					if (s[j] != -1) {
						continue i;
					}
				}
				if (s[nn - 1] != -1L >>> -n) {
					continue;
				}
				o = i;
				break;
			}
			if (o < 0) {
				out.print(-1);
				return;
			}
			boolean cur[] = new boolean[n];
			cur[o] = true;
			for (int i = m - 1; i >= 0; i--) {
				if (cur[x[i]] && !cur[y[i]]) {
					cur[y[i]] = true;
				} else if (cur[y[i]] && !cur[x[i]]) {
					cur[x[i]] = true;
					ans[i] = 'v';
				}
			}
		}
		break;
		case 2:
		{
			if (n == 2) {
				out.print(-1);
				return;
			}
			int next[] = new int[n], xNext[] = new int[m], yNext[] = new int[m];
			fill(next, -1);
			for (int i = m - 1; i >= 0; i--) {
				xNext[i] = next[x[i]];
				yNext[i] = next[y[i]];
				next[x[i]] = next[y[i]] = i;
			}
			int a = 0, b;
			for (b = 1; next[b] >= 0 && next[b] == next[a]; b++) { }
			int aNext = next[a], bNext = next[b];
			while (aNext >= 0 && bNext >= 0) {
				if (aNext < bNext) {
					if (xNext[aNext] == bNext) {
						ans[aNext] = 'v';
						aNext = yNext[aNext];
					} else {
						aNext = xNext[aNext];
					}
				} else {
					if (xNext[bNext] == aNext) {
						ans[bNext] = 'v';
						bNext = yNext[bNext];
					} else {
						bNext = xNext[bNext];
					}
				}
			}
		}
		break;
		default:
			throw new AssertionError();
		}
		out.print(ans);
	}

	static int scanInt() throws IOException {
		return parseInt(scanString());
	}

	static long scanLong() throws IOException {
		return parseLong(scanString());
	}

	static String scanString() throws IOException {
		while (tok == null || !tok.hasMoreTokens()) {
			tok = new StringTokenizer(in.readLine());
		}
		return tok.nextToken();
	}

	static BufferedReader in;
	static PrintWriter out;
	static StringTokenizer tok;

	public static void main(String[] args) {
		try {
			in = new BufferedReader(new InputStreamReader(System.in));
			out = new PrintWriter(System.out);
			solve();
			in.close();
			out.close();
		} catch (Throwable e) {
			e.printStackTrace();
			exit(1);
		}
	}
}