Problem:
Problem D: Off Balance

You are working for an administration office of the International
Center for Picassonian Cubism (ICPC), which plans to build a new art
gallery for young artists. The center is organizing an architectural
design competition to find the best design for the new building.

Submitted designs will look like a screenshot of a well known
game as shown below.

This is because the center specifies that
the building should be constructed by stacking regular units
called pieces, each of which consists of four cubic blocks.
In addition, the center requires the competitors to submit designs
that satisfy the following restrictions.

All the pieces are aligned. When two pieces touch each other, the faces of
the touching blocks must be placed exactly at the same position.

All the pieces are stable. Since pieces are merely stacked,
their centers of masses must be carefully positioned so as not to
collapse.

The pieces are stacked in a tree-like form
in order to symbolize boundless potentiality of young artists.
In other words, one and only one
piece touches the ground, and each of other pieces touches one and
only one piece on its bottom faces.

The building has a flat shape.
This is because the construction site
is a narrow area located between a
straight moat and an expressway where
no more than one block can be placed
between the moat and the
expressway as illustrated below.

It will take many days to fully check stability of designs as it requires
complicated structural calculation.
Therefore, you are
asked to quickly check obviously unstable designs by focusing on
centers of masses. The rules of your quick check are as follows.

Assume the center of mass of a block is located at the center of the
block, and all blocks have the same weight.
We denote a location of a block by xy-coordinates of its
left-bottom corner. The unit length is the edge length of a block.

Among the blocks of the piece that touch another piece or the ground on their
bottom faces, let xL be the leftmost x-coordinate of
the leftmost block, and let xR be the rightmost
x-coordinate of the rightmost block.
Let the x-coordinate of its accumulated center of mass of
the piece be M, where the accumulated center of mass of a piece P
is the center of the mass of the pieces that are directly and indirectly
supported by P, in addition to P itself. Then the piece is
stable, if and only if
xL < M < xR. Otherwise, it is
unstable. A design of a building is unstable if any of its pieces is unstable.

Note that the above rules could judge some designs to be unstable even
if it would not collapse in reality. For example, the left one of the
following designs shall be judged to be unstable.

Also note that the rules judge boundary cases to be unstable. For example, the top piece in the above right design has its center of mass exactly above the right end of the bottom piece. This shall be judged to be unstable.

Write a program that judges stability of each design based on the above quick check rules.

Input

The input is a sequence of datasets. The end of the input is
indicated by a line containing two zeros separated by a space. Each
dataset, which represents a front view of a building, is formatted as follows.

w h

p0(h-1)p1(h-1)...p(w-1)(h-1)

...

p01p11...p(w-1)1

p00p10...p(w-1)0

The integers w and h separated by a space are the numbers of columns
and rows of the layout, respectively. You may assume 1 ≤ w ≤
10 and 1 ≤ h ≤ 60. The next h lines specify the placement of
the pieces. The character pxy indicates the status of a block at
(x,y), either `.', meaning empty, or one digit character between
`1' and `9', inclusive, meaning a block of a piece.
(As mentioned earlier, we denote a location of a block by xy-coordinates of its
left-bottom corner.)

When two blocks with the same number touch each other by any of their
top, bottom, left or right face, those blocks are of the same piece.
(Note that there might be two different pieces that are denoted by
the same number.)
The bottom of a block at (x,0) touches the ground.

You may assume that the pieces in each dataset are stacked in a tree-like form.

Output

For each dataset, output a line containing a word STABLE
when the design is stable with respect to the above quick check rules.
Otherwise, output UNSTABLE. The output
should be written with uppercase letters, and should not contain any other extra characters.

Sample Input

4 5
..33
..33
2222
..1.
.111
5 7
....1
.1..1
.1..1
11..1
.2222
..111
...1.
3 6
.3.
233
23.
22.
.11
.11
4 3
2222
..11
..11
4 5
.3..
33..
322.
2211
.11.
3 3
222
2.1
111
3 4
11.
11.
.2.
222
3 4
.11
.11
.2.
222
2 7
11
.1
21
22
23
.3
33
2 3
1.
11
.1
0 0

Output for the Sample Input

STABLE
STABLE
STABLE
UNSTABLE
STABLE
STABLE
UNSTABLE
UNSTABLE
UNSTABLE
UNSTABLE

Solution in JAVA (judge verdict: Accepted)

import java.util.*;
import java.awt.Point;

public class Main {
	static int[] xSums;
	static int[] wSums;
	static int[][] map;
	static List<List<Point>> blocks;

	public static void main(String[] args) {
		Scanner sc = new Scanner(System.in);

		while (true) {
			int w = sc.nextInt();
			int h = sc.nextInt();

			if (w == 0 && h == 0)
				break;

			int[][] mapTemp = new int[h][w];

			for (int y = 0; y < h; y++) {
				String str = sc.next();
				for (int x = 0; x < w; x++) {
					char c = str.charAt(x);
					mapTemp[y][x] = c == '.' ? -1 : c - '0';
				}
			}
			
			map = new int[h][w];
			for (int i = 0; i < mapTemp.length; i++)
				Arrays.fill(map[i], -1);

			Deque<Point> queue = new ArrayDeque<Point>();
			blocks = new ArrayList<List<Point>>();
			int lowestIndex = -1;

			for (int y = 0; y < h; y++) {
				for (int x = 0; x < w; x++) {
					
					int me = mapTemp[y][x];
					if (me == -1)
						;
					else if (map[y][x] == -1) {
						queue.add(new Point(x, y));
						List<Point> block = new ArrayList<Point>();
						
						while (!queue.isEmpty()) {
							Point p = queue.pollFirst();
							if (block.contains(p))
								continue;

							if (p.y == h - 1)
								lowestIndex = blocks.size();

							map[p.y][p.x] = blocks.size();
							block.add(p);

							if (p.x > 0 && mapTemp[p.y][p.x - 1] == me)
								queue.add(new Point(p.x - 1, p.y));
							if (p.x < w - 1 && mapTemp[p.y][p.x + 1] == me)
								queue.add(new Point(p.x + 1, p.y));
							if (p.y > 0 && mapTemp[p.y - 1][p.x] == me)
								queue.add(new Point(p.x, p.y - 1));
							if (p.y < h - 1 && mapTemp[p.y + 1][p.x] == me)
								queue.add(new Point(p.x, p.y + 1));
						}
						blocks.add(block);
					}
				}
			}
			xSums = new int[blocks.size()];
			wSums = new int[blocks.size()];

			setMid(lowestIndex);

			boolean isStable = true;

			for (int i = 0; i < blocks.size(); i++) {
				double gp = (double) xSums[i] / wSums[i] + 0.5;
				List<Point> block = blocks.get(i);
				int left = 1000;
				int right = 0;
				
				for (int j = 0; j < block.size(); j++) {
					Point p = block.get(j);
					if (p.y == h - 1
							|| (map[p.y + 1][p.x] != -1 && map[p.y + 1][p.x] != i)) {
						if (p.x < left)
							left = p.x;
						if (p.x + 1 > right)
							right = p.x + 1;
					}
				}
				if (gp <= left || right <= gp) {
					isStable = false;
					break;
				}
			}

			System.out.println(isStable ? "STABLE" : "UNSTABLE");
		}

	}

	static void setMid(int index) {
		List<Point> block = blocks.get(index);
		boolean[] dejavu = new boolean[blocks.size()];

		for (Point p : block) {
			wSums[index]++;
			xSums[index] += p.x;
			if (p.y != 0) {
				int aboveIndex = map[p.y - 1][p.x];
				
				if (aboveIndex != -1 && aboveIndex != index && !dejavu[aboveIndex]) {
					if (wSums[aboveIndex] == 0)
						setMid(aboveIndex);
					dejavu[aboveIndex] = true;

					wSums[index] += wSums[aboveIndex];
					xSums[index] += xSums[aboveIndex];
				}
			}
		}
	}
}