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: Runtime Error)

import java.io.*;
import java.util.Arrays;
import java.util.Random;
import java.util.StringTokenizer;

public class Main {
    FastScanner in;
    PrintWriter out;

    public static void main(String[] args) {
        new Main().runIO();
    }

    void solve() {
        int n = in.nextInt();
        int m = in.nextInt();
        int type = in.nextInt();
        if (type == 2) {
            throw new AssertionError();
        }
        long START = System.currentTimeMillis();
        int[] x = new int[m];
        int[] y = new int[m];
        for (int i = 0; i < m; i++) {
            x[i] = in.nextInt() - 1;
            y[i] = in.nextInt() - 1;
        }
        Random rnd = new Random(123);
        int[] sizes = new int[n];
        char[] res= new char[m];
        boolean[] end= new boolean[n];
        while (System.currentTimeMillis() - START < 1000) {
            Arrays.fill(sizes, 1);
            for (int i = 0; i < m; i++) {
                if (rnd.nextBoolean()) {
                    sizes[x[i]] += sizes[y[i]];
                    sizes[y[i]] = 0;
                } else {
                    sizes[y[i]] += sizes[x[i]];
                    sizes[x[i]] = 0;
                }
            }
            int id = rnd.nextInt(n);
            int toCheck = -1;
            for (int i = 0; i < n; i++) {
                id -= sizes[i];
                if (id < 0) {
                    toCheck = i;
                    break;
                }
            }
            if (toCheck == -1) {
                throw new AssertionError();
            }
            Arrays.fill(end,false);
            end[toCheck] = true;
            for (int i = m - 1; i >= 0; i--) {
                if (end[x[i]]) {
                    res[i] = '^';
                    end[y[i]]= true;
                } else if (end[y[i]]) {
                    end[x[i]] = true;
                    res[i] = 'v';
                } else {
                    res[i] = 'v';
                }
            }
            boolean allOk = true;
            for (boolean z  : end) {
                if (!z) {
                    allOk = false;
                    break;
                }
            }
            if (allOk) {
//                System.err.println(toCheck);
                out.println(new String(res));
                return;
            }
        }
        out.println(-1);
    }


    void run() {
        try {
            in = new FastScanner(new File("Main.in"));
            out = new PrintWriter(new File("Main.out"));

            solve();

            out.close();
        } catch (FileNotFoundException e) {
            e.printStackTrace();
        }
    }

    void runIO() {

        in = new FastScanner(System.in);
        out = new PrintWriter(System.out);

        solve();

        out.close();
    }

    class FastScanner {
        BufferedReader br;
        StringTokenizer st;

        public FastScanner(File f) {
            try {
                br = new BufferedReader(new FileReader(f));
            } catch (FileNotFoundException e) {
                e.printStackTrace();
            }
        }

        public FastScanner(InputStream f) {
            br = new BufferedReader(new InputStreamReader(f));
        }

        String next() {
            while (st == null || !st.hasMoreTokens()) {
                String s = null;
                try {
                    s = br.readLine();
                } catch (IOException e) {
                    e.printStackTrace();
                }
                if (s == null)
                    return null;
                st = new StringTokenizer(s);
            }
            return st.nextToken();
        }

        boolean hasMoreTokens() {
            while (st == null || !st.hasMoreTokens()) {
                String s = null;
                try {
                    s = br.readLine();
                } catch (IOException e) {
                    e.printStackTrace();
                }
                if (s == null)
                    return false;
                st = new StringTokenizer(s);
            }
            return true;
        }

        int nextInt() {
            return Integer.parseInt(next());
        }

        long nextLong() {
            return Long.parseLong(next());
        }

        double nextDouble() {
            return Double.parseDouble(next());
        }
    }
}