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
#include <cstdio>
#include <cstring>
#include <cstdlib>
#include <cmath>
#include <ctime>
#include <cctype>

#include <algorithm>
#include <random>
#include <bitset>
#include <queue>
#include <functional>
#include <set>
#include <map>
#include <vector>
#include <chrono>
#include <iostream>
#include <limits>
#include <numeric>

#define LOG(FMT...) fprintf(stderr, FMT)

using namespace std;

typedef long long ll;
typedef unsigned long long ull;

// mt19937 rng(chrono::steady_clock::now().time_since_epoch().count());

template <class T>
istream& operator>>(istream& is, vector<T>& v) {
  for (T& x : v)
    is >> x;
  return is;
}

template <class T>
ostream& operator<<(ostream& os, const vector<T>& v) {
  if (!v.empty()) {
    os << v.front();
    for (int i = 1; i < v.size(); ++i)
      os << ' ' << v[i];
  }
  return os;
}

int main() {
#ifdef LBT
  freopen("test.in", "r", stdin);
  int nol_cl = clock();
#endif
  ios::sync_with_stdio(false);
  cin.tie(nullptr);

  int N, M, T;
  cin >> N >> M >> T;
  vector<int> x(M), y(M);
  for (int i = 0; i < M; ++i) {
    cin >> x[i] >> y[i];
    --x[i]; --y[i];
  }
  if (T == 1) {
    vector<bitset<50010>> reach(N);
    for (int i = 0; i < N; ++i) reach[i].set(i);
    for (int i = M - 1; i >= 0; --i)
      reach[x[i]] = (reach[y[i]] |= reach[x[i]]);
    bitset<50010> res = reach[0];
    for (int i = 1; i < N; ++i) res &= reach[i];
    if (res.none()) cout << "-1\n";
    else {
      int t = 0;
      while (!res[t]) ++t;
      vector<bool> vis(N);
      vis[t] = true;
      string s;
      for (int i = M - 1; i >= 0; --i) {
        if (vis[x[i]]) {
          s.push_back('^');
          vis[y[i]] = true;
        } else if (vis[y[i]]) {
          s.push_back('v');
          vis[x[i]] = true;
        } else
          s.push_back('^');
      }
      reverse(s.begin(), s.end());
      cout << s << '\n';
    }
  } else {
    if (N == 2) {
      cout << "-1\n";
    } else {
      vector<int> f(N), c(N, 1);
      iota(f.begin(), f.end(), 0);
      string s;
      for (int i = M - 1; i >= 0; --i) {
        if (c[f[x[i]]] == 1) {
          --c[f[y[i]]];
          ++c[f[x[i]]];
          f[y[i]] = f[x[i]];
          s.push_back('^');
        } else {
          --c[f[x[i]]];
          ++c[f[y[i]]];
          f[x[i]] = f[y[i]];
          s.push_back('v');
        }
      }
      reverse(s.begin(), s.end());
      cout << s << '\n';
    }
  }

#ifdef LBT
  LOG("Time: %dms\n", int ((clock()
          -nol_cl) / (double)CLOCKS_PER_SEC * 1000));
#endif
  return 0;
}
