// import chie template :) {{{
import std.stdio, std.algorithm, std.array, std.string, std.math, std.conv,
  std.range, std.container, std.bigint, std.ascii, std.typecons, std.format, std.bitmanip;

// }}}
// nep.scanner {{{
class Scanner {
  import std.stdio : File, stdin;
  import std.conv : to;
  import std.array : split;
  import std.string;
  import std.traits : isSomeString;

  private File file;
  private char[][] str;
  private size_t idx;

  this(File file = stdin) {
    this.file = file;
    this.idx = 0;
  }

  this(StrType)(StrType s, File file = stdin) if (isSomeString!(StrType)) {
    this.file = file;
    this.idx = 0;
    fromString(s);
  }

  private char[] next() {
    if (idx < str.length) {
      return str[idx++];
    }

    char[] s;
    while (s.length == 0) {
      s = file.readln.strip.to!(char[]);
    }

    str = s.split;
    idx = 0;

    return str[idx++];
  }

  T next(T)() {
    return next.to!(T);
  }

  T[] nextArray(T)(size_t len) {
    T[] ret = new T[len];

    foreach (ref c; ret) {
      c = next!(T);
    }

    return ret;
  }

  void scan()() {
  }

  void scan(T, S...)(ref T x, ref S args) {
    x = next!(T);
    scan(args);
  }

  void fromString(StrType)(StrType s) if (isSomeString!(StrType)) {
    str ~= s.to!(char[]).strip.split;
  }
}
// }}}


int[2000][2000] dist;
int[][2000] G;

void main() {
  auto cin = new Scanner;
  int n, x, y;
  cin.scan(n, x, y);
  x--; y--;


  foreach (i; 0 .. n - 1) {
    G[i] ~= i + 1;
    G[i + 1] ~= i;
  }

  G[x] ~= y;
  G[y] ~= x;

  foreach (i; 0 .. 2000) {
    foreach (j; 0 .. 2000) {
      dist[i][j] = cast(int)(1e9 + 7);
    }
  }

  foreach (i; 0 .. n) {
    alias P = Tuple!(int, "cost", int, "next");
    P[] a;
    auto heap = heapify!"a.cost > b.cost"(a);
    dist[i][i] = 0;
    heap.insert(P(0, i));

    while (!heap.empty) {
      auto p = heap.front;
      heap.popFront();
      if (dist[i][p.next] < p.cost) continue;
      foreach (e; G[p.next]) {
        if (dist[i][e] > dist[i][p.next] + 1) {
          dist[i][e] = dist[i][p.next] + 1;
          heap.insert(P(dist[i][e], e));
        }
      }
    }
  }

  int[int] chie;
  foreach (i; 0 .. n) {
    foreach (j; 0 .. n) {
      chie[dist[i][j]]++;
    }
  }


  foreach (i; 1 .. n) {
    writeln(chie.get(i, 0) / 2);
  }
}
