#include <bits/stdc++.h>
using namespace std;
int read() {
  int x = 0;
  char ch = getchar();
  while (ch < '0' || ch > '9') ch = getchar();
  while (ch >= '0' && ch <= '9') {
    x = (x << 3) + (x << 1) + ch - '0';
    ch = getchar();
  }
  return x;
}
int MAX(int x, int y) { return x > y ? x : y; }
int MIN(int x, int y) { return x < y ? x : y; }
int n, m;
int cnt;
class Queue {
 private:
  int head, tail, a[1000010], num[1000010];

 public:
  void push(int x, int id) {
    while (head <= tail && x > a[tail]) tail--;
    tail++;
    a[tail] = x;
    num[tail] = id;
  }
  void pop(int id, int len) {
    int x = id - len;
    while (head <= tail && num[head] < x) head++;
  }
  int top() { return a[head]; }
  void clear() {
    head = 1;
    tail = 0;
  }
  bool empty() { return head > tail; }
} q;
class Stack {
 private:
  int tail, a[1000010];

 public:
  void push(int x) { a[tail++] = x; }
  void pop() { tail--; }
  int top() { return a[tail - 1]; }
  void clear() { tail = 0; }
  bool empty() { return tail == 0; }
} s;
class Tree {
 private:
  int head[1000010 << 2], next[1000010 << 2], ver[1000010 << 2], tot;
  bool bo[1000010];
  int l[1000010], g[1000010], fir[1000010], sec[1000010], firfrom[1000010];
  int num[1000010], dp[1000010];
  void DP(int u, int pre) {
    g[u]--;
    int id = 0, v, len = l[u] / 2;
    q.clear();
    for (int j = 0; j < 2; j++)
      for (int i = head[u]; i; i = next[i]) {
        num[++id] = v = ver[i];
        if (v == pre)
          dp[id] = g[u];
        else
          dp[id] = fir[v];
        q.pop(id, len);
        if (v != pre && !q.empty()) g[v] = MAX(g[v], id + q.top());
        q.push(dp[id] - id, id);
      }
    q.clear();
    for (int i = id; i; i--) {
      q.pop(-i, len);
      if (num[i] != pre && !q.empty()) g[num[i]] = MAX(g[num[i]], q.top() - i);
      q.push(dp[i] + i, -i);
    }
  }

 public:
  void set_square(int x) { bo[x] = true; }
  void add(int x, int y) {
    ver[++tot] = y;
    next[tot] = head[x];
    head[x] = tot;
    ver[++tot] = x;
    next[tot] = head[y];
    head[y] = tot;
    l[x]++;
    l[y]++;
  }
  void dfs1(int u, int pre) {
    for (int i = head[u], v; i; i = next[i]) {
      v = ver[i];
      if (v == pre) continue;
      dfs1(v, u);
      if (bo[u]) continue;
      if (fir[v] + 1 > fir[u]) {
        sec[u] = fir[u];
        fir[u] = fir[v] + 1;
        firfrom[u] = v;
      } else if (fir[v] + 1 > sec[u])
        sec[u] = fir[v] + 1;
    }
    if (bo[u]) {
      int sum = 0;
      for (int i = head[u], v; i; i = next[i]) {
        v = ver[i];
        sum++;
        if (v == pre) continue;
        fir[u] = MAX(fir[u], fir[v] + MIN(l[u] - sum, sum));
      }
      fir[u]--;
    }
  }
  void dfs2(int u, int pre) {
    if (bo[u]) DP(u, pre);
    for (int i = head[u], v; i; i = next[i]) {
      v = ver[i];
      if (v == pre) continue;
      if (!bo[u]) {
        g[v] = MAX(g[v], g[u] + 1);
        if (firfrom[u] == v)
          g[v] = MAX(g[v], sec[u] + 1);
        else
          g[v] = MAX(g[v], fir[u] + 1);
      }
      dfs2(v, u);
    }
    g[u] = MAX(fir[u], g[u]);
  }
  void PrintAns() {
    for (int i = 1; i <= n; i++) printf("%d ", g[i]);
  }
} T;
class Cactus {
 private:
  int head[1000010 << 2], next[1000010 << 2], ver[1000010 << 2], tot;
  int dfn[1000010], low[1000010], tim;

 public:
  Cactus() { tim = 0; }
  void add(int x, int y) {
    ver[++tot] = y;
    next[tot] = head[x];
    head[x] = tot;
    ver[++tot] = x;
    next[tot] = head[y];
    head[y] = tot;
  }
  void Tarjan(int u, int pre) {
    dfn[u] = low[u] = ++tim;
    for (int i = head[u], v; i; i = next[i]) {
      v = ver[i];
      if (v == pre) continue;
      if (!dfn[v]) {
        s.push(i);
        Tarjan(v, u);
        if (low[v] > dfn[u]) {
          T.add(v, u);
          s.pop();
        }
        if (low[v] == dfn[u]) {
          T.set_square(++cnt);
          while (!s.empty() && s.top() != i) {
            T.add(cnt, ver[s.top()]);
            s.pop();
          }
          T.add(cnt, ver[s.top()]);
          s.pop();
        }
        low[u] = MIN(low[u], low[v]);
      } else if (dfn[v] < low[u]) {
        s.push(i);
        low[u] = dfn[v];
      }
    }
  }
} C;
int main() {
  s.clear();
  q.clear();
  n = read();
  m = read();
  for (int i = 1; i <= m; i++) C.add(read(), read());
  cnt = n;
  C.Tarjan(1, 0);
  T.dfs1(1, 0);
  T.dfs2(1, 0);
  T.PrintAns();
  return 0;
}
