#ifdef LOCAL
#include "stdafx.h"
#else
#include <bits/stdc++.h>
#define IL inline
#define LL long long
#define eb emplace_back
#define sz(v) ((int) (v).size())
#define L(i, j, k) for (int i = (j); i <= (k); ++i)
#define R(i, j, k) for (int i = (j); i >= (k); --i)
#define FIO(FILE) freopen(FILE".in", "r", stdin), freopen(FILE".out", "w", stdout)
using namespace std;

using vi = vector<int>;
#endif

constexpr int N = 1e4 + 9;
int n, m, K, c[N], ord[N];
vi g[N];

struct nd {
  int x, y;

  bool operator < (const nd &rhs) const {
    return x ^ rhs.x ? x < rhs.x : y < rhs.y;
  }
} a[N];

IL int gts (int x) {
  int s = ~c[x] ? 1 << c[x] : 0;
  for (int y : g[x]) {
    if (~c[y]) {
      s |= 1 << c[y];
    }
  }
  return s;
}

bool vis[N];

void dfs (int u, int s) {
  vis[u] = true;
  for (int v : g[u]) {
    if (~c[v] && !vis[v] && (s >> c[v] & 1)) {
      dfs(v, s);
    }
  }
}

void clr (int u) {
  vis[u] = false;
  for (int v : g[u]) {
    if (vis[v]) {
      clr(v);
    }
  }
}

void chg (int u, int s) {
  vis[u] = false;
  c[u] ^= s;
  for (int v : g[u]) {
    if (vis[v]) {
      chg(v, s);
    }
  }
}

IL int slp (int x, int y) {
  if (y == 0) {
    return INT_MIN;
  }
  return x / y;
}

int main () {
  ios::sync_with_stdio(0), cin.tie(0);
  cin >> n >> m;
  L (i, 1, n) {
    cin >> a[i].x >> a[i].y;
  }
  L (i, 1, m) {
    int u, v;
    cin >> u >> v;
    g[u].eb(v);
    g[v].eb(u);
  }
  L (i, 1, n) {
    c[i] = -1, ord[i] = i;
  }
  sort(ord + 1, ord + n + 1, [] (int x, int y) {
    return a[x] < a[y];
  });
  L (i, 1, n) {
    int u = ord[i];
    int s = gts(u);
    if (s < 15) {
      c[u] = __builtin_ctz(~s);
      continue;
    }
    vi e;
    for (int v : g[u]) {
      if (~c[v]) {
        e.eb(v);
      }
    }
    sort(e.begin(), e.end(), [&] (int i, int j) {
      return slp(a[u].x - a[i].x, a[u].y - a[i].y) < slp(a[u].x - a[j].x, a[u].y - a[j].y);
    });
    dfs(e[0], (1 << c[e[0]]) | (1 << c[e[2]]));
    if (vis[e[2]]) {
      clr(e[0]);
      dfs(e[1], (1 << c[e[1]]) | (1 << c[e[3]]));
      assert(!vis[e[3]]);
      chg(e[1], c[e[1]] ^ c[e[3]]);
    } else {
      chg(e[0], c[e[0]] ^ c[e[2]]);
    }
    s = gts(u);
    if (s < 15) {
      c[u] = __builtin_ctz(~s);
    }
  }
  L (i, 1, n) {
    cout << c[i] + 1 << '\n';
  }
}
// I love WHQ!