import std.stdio;

struct Deque(T) {
	T[] array;
	size_t first, last, length_;

	this(size_t maxLength) {
		array = new T[maxLength];
		first = last = maxLength / 2;
	}

	bool empty() {
		return length_ == 0;
	}

	size_t length() {
		return length_;
	}

	T back() {
		if (last == 0) {
			return array[$ - 1];
		} else {
			return array[last - 1];
		}
	}

	void popBack() {
		if (last == 0) {
			last = array.length - 1;
		} else {
			--last;
		}
		--length_;
	}
	
	void pushBack(T x) {
		if (length_ >= array.length) {
			throw new Exception("Deque is full.");
		}
		array[last] = x;
		++last;
		++length_;
		if (last >= array.length) {
			last = 0;
		}
	}



	T front() {
		return array[first];
	}

	void popFront() {
		++first;
		if (first >= array.length) {
			first = 0;
		}
		--length_;
	}

	void pushFront(T x) {
		if (length_ >= array.length) {
			throw new Exception("Deque is full.");
		}
		if (first == 0) {
			first = array.length - 1;
		} else {
			--first;
		}
		array[first] = x;
		++length_;
	}
}

void main() {
	int n, x, y;
	readf(" %s %s %s", &n, &x, &y);
	// x, yをデクリメントしてゼロオリジンにします。
	--x;
	--y;
	
	auto queue = Deque!(int)(2048);
	auto a = new int[n];
	auto answer = new int[n];

	void push(int v, int d) {
		if (a[v] != int.max) {
			return;
		}
		a[v] = d;
		queue.pushBack(v);
	}

	foreach (base;0..n) {
		a[] = int.max;

		push(base, 0);

		while (!queue.empty) {
			auto vertex = queue.front;
			queue.popFront();

			auto distance = a[vertex];
			
			if (vertex == x) {
				push(y, distance + 1);
			}
			if (vertex == y) {
				push(x, distance + 1);
			}
			if (vertex + 1 < n) {
				push(vertex + 1, distance + 1);
			}
			if (vertex - 1 >= 0) {
				push(vertex - 1, distance + 1);
			}
		}

		foreach (e;a) {
			++answer[e];
		}
	}

	foreach (e;answer[1..$]) {
		writeln(e / 2);
	}
}
