Problem: There is a computer network consisting of n nodes numbered 1 through n. There are links in the network that connect pairs of nodes. A pair of nodes may have multiple links between them, but no node has a link to itself.

Each link supports unlimited bandwidth (in either direction), however a link may only transmit in a single direction at any given time. The cost of sending data across a link is proportional to the square of the bandwidth. Specifically, each link has a positive weight, and the cost of sending data across the link is the weight times the square of the bandwidth.

The network is connected (there is a series of links from any node to any other node), and furthermore designed to remain connected in the event of any single node failure.

You needed to send data from node 1 to node n at a bandwidth of some positive number k. That is, you wish to assign a bandwidth to each link so that the bandwidth into a node minus the bandwidth out of a node is  - k for node 1, k for node n, and 0 for all other nodes. The individual bandwidths do not need to be integers.

Wishing to minimize the total cost, you drew a diagram of the network, then gave the task to an intern to solve. The intern claimed to have solved the task and written the optimal bandwidths on your diagram, but then spilled coffee on it, rendering much of it unreadable (including parts of the original diagram, and the value of k).

From the information available, determine if the intern's solution may have been optimal. That is, determine if there exists a valid network, total bandwidth, and optimal solution which is a superset of the given information. Furthermore, determine the efficiency of the intern's solution (if possible), where efficiency is defined as total cost divided by total bandwidth.

Input

Input will begin with two integers n and m (2 ≤ n ≤ 200000; 0 ≤ m ≤ 200000), the number of nodes and number of known links in the network, respectively. Following this are m lines with four integers each: f, t, w, b (1 ≤ f ≤ n; 1 ≤ t ≤ n; f ≠ t; 1 ≤ w ≤ 100; 0 ≤ b ≤ 100). This indicates there is a link between nodes f and t with weight w and carrying b bandwidth. The direction of bandwidth is from f to t.

Output

If the intern's solution is definitely not optimal, print "BAD x", where x is the first link in the input that violates the optimality of the solution. If the intern's solution may be optimal, print the efficiency of the solution if it can be determined rounded to the nearest integer, otherwise print "UNKNOWN".

Examples

Input

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


Output

6


Input

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


Output

BAD 3


Input

6 4
1 3 31 41
1 5 59 26
2 6 53 58
4 6 97 93


Output

UNKNOWN


Input

7 5
1 7 2 1
2 3 1 1
4 5 1 0
6 1 10 0
1 3 1 1


Output

BAD 4

Note

Although the known weights and bandwidths happen to always be integers, the weights and bandwidths of the remaining links are not restricted to integers.

Solution (in CPP):

Solution:
#include <bits/stdc++.h>
#pragma GCC optimize("Ofast")
#pragma GCC optimize("unroll-loops")
#pragma GCC target("sse,sse2,sse3,ssse3,abm,mmx,tune=native")
using namespace std;
const int64_t INF = (int64_t)(2e18);
const int inf = (int)(1e9 + 7);
const int maxn = 500 * 1000 + 100;
chrono::time_point<chrono::steady_clock> cl;
double current_time() {
  return (double)(chrono::steady_clock::now() - cl).count() / 1e9;
}
int s, t;
int n, m;
int from[maxn];
int to[maxn];
int flow[maxn];
int cost[maxn];
int cp[maxn];
int cnts[maxn];
int cntst[maxn];
int cntsval[maxn];
int used[maxn];
int pot[maxn];
int minpot[maxn];
int maxpot[maxn];
vector<pair<int, int>> g[maxn];
vector<pair<int, int>> gt[maxn];
vector<array<int, 3>> gval[maxn];
void minmaxdfs(int v) {
  used[v] = 1;
  minpot[v] = pot[v];
  maxpot[v] = pot[v];
  for (int i = 0; i < cnts[v]; ++i) {
    auto& it = g[v][i];
    int to = it.first;
    int ind = it.second;
    if (used[to]) continue;
    minmaxdfs(to);
    minpot[v] = min(minpot[v], minpot[to]);
    maxpot[v] = max(maxpot[v], maxpot[to]);
  }
}
void dfspot(int v) {
  used[v] = 1;
  for (int i = 0; i < cntsval[v]; ++i) {
    auto& it = gval[v][i];
    int to = it[0];
    int ind = it[1];
    int mult = it[2];
    if (used[to]) continue;
    pot[to] = pot[v] - mult * flow[ind] * cost[ind];
    dfspot(to);
  }
}
bool can = true;
bool good(int k) {
  fill(minpot, minpot + n, inf);
  fill(maxpot, maxpot + n, -inf);
  fill(cnts, cnts + n, 0);
  fill(cntst, cntst + n, 0);
  fill(cntsval, cntsval + n, 0);
  for (int i = 0; i <= k; ++i) {
    ++cnts[from[i]];
    ++cntst[to[i]];
    ++cntsval[from[i]];
    ++cntsval[to[i]];
  }
  fill(used, used + n, 0);
  fill(pot, pot + n, 0);
  dfspot(s);
  for (int i = 0; i < n; ++i) {
    if (used[i] == 0) continue;
    if (i != s && pot[i] >= pot[s]) return false;
  }
  fill(used, used + n, 0);
  fill(pot, pot + n, 0);
  dfspot(t);
  for (int i = 0; i < n; ++i) {
    if (used[i] == 0) continue;
    if (i != t && pot[i] <= pot[t]) return false;
  }
  fill(used, used + n, 0);
  fill(pot, pot + n, 0);
  for (int i = 0; i < n; ++i) {
    if (used[i]) continue;
    pot[i] = 0;
    dfspot(i);
    if (i == 0) {
      can = used[t];
      for (int j = 0; j < n; ++j) cp[j] = used[j];
    }
  }
  for (int i = 0; i <= k; ++i) {
    if (pot[from[i]] - flow[i] * cost[i] != pot[to[i]]) return false;
  }
  fill(used, used + n, 0);
  for (int i = 0; i < n; ++i) {
    if (used[i]) continue;
    minmaxdfs(i);
  }
  if (can == false) return true;
  for (int i = 0; i < n; ++i) {
    int val = maxpot[i] - minpot[i];
    if (cp[i] == 0)
      if (pot[s] - pot[t] <= val) return false;
  }
  return true;
}
int32_t main() {
  cl = chrono::steady_clock::now();
  ios_base::sync_with_stdio(false);
  cout << fixed << setprecision(10);
  cin.tie(nullptr);
  cin >> n >> m;
  s = 0;
  t = n - 1;
  for (int i = 0; i < m; ++i) {
    cin >> from[i] >> to[i];
    --from[i];
    --to[i];
    cin >> flow[i] >> cost[i];
  }
  for (int i = 0; i < m; ++i) {
    g[from[i]].push_back(make_pair(to[i], i));
    gt[to[i]].push_back(make_pair(from[i], i));
    gval[from[i]].push_back({to[i], i, 1});
    gval[to[i]].push_back({from[i], i, -1});
  }
  int l = 0;
  int r = m;
  while (l < r) {
    int mid = (l + r) / 2;
    bool curres = good(mid);
    if (curres)
      l = mid + 1;
    else
      r = mid;
  }
  if (l != m) {
    cout << "BAD " << r + 1;
    return 0;
  }
  good(m - 1);
  if (can) {
    cout << pot[s] - pot[t];
  } else {
    cout << "UNKNOWN";
  }
  return 0;
}