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 Ruby (judge verdict: Accepted)

require 'set'

class Piece
	def initialize
		@blocks = []
		@children = Set.new
		@weight = 0
	end

	def add_block(y, x)
		@blocks << [y, x]
	end

	def add_child(piece)
		@children << piece
	end

	def check(root = false)
		@children.each(&:check)
		if @children.empty?
			@total_weight = 4
			@total_cg = @blocks.map(&:last).inject(:+) / 4.0 + 0.5 
		else
			@children.each do |c|
				touched = c.blocks.select{|y, x| @blocks.include?([y-1, x])}.map(&:last)
				xl, xr = touched.min, touched.max + 1
				raise if c.total_cg <= xl || xr <= c.total_cg
			end

			@total_weight = 4 + @children.map(&:total_weight).inject(:+)
			my_cg = @blocks.map(&:last).inject(:+) / 4.0 + 0.5 
			@total_cg = (my_cg * 4 + @children.map{|c| c.total_weight * c.total_cg}.inject(:+)) / @total_weight
		end

		if root
			touched = @blocks.select{|y, x| y == 0}.map(&:last)
			xl, xr = touched.min, touched.max + 1
			raise if @total_cg <= xl || xr <= @total_cg
		end
	end

	attr_reader :blocks, :total_weight, :total_cg
end


loop do
	w, h = gets.split.map &:to_i
	break if w == 0
	a = []
	h.times do
		a.unshift gets.chomp.split("")
	end

	hash = {}
	root = nil
	(0..h-1).each do |y|
		(0..w-1).each do |x|
			next if a[y][x] == ?.
			next if hash[[y, x]]
			piece = Piece.new
			hash[[y, x]] = piece
			root = piece if y == 0

			stack = [[y,x]]
			until stack.empty?
				i, j = stack.pop
				piece.add_block(i, j)

				v = [i+1, j]
				if i < h-1 && a[i][j] == a[i+1][j] && !hash[v]
					hash[v] = piece	
					stack << v
				end

				v = [i, j+1]
				if j < w-1 && a[i][j] == a[i][j+1] && !hash[v]
					hash[v] = piece	
					stack << v
				end

				v = [i, j-1]
				if j > 0 && a[i][j] == a[i][j-1] && !hash[v]
					hash[v] = piece	
					stack << v
				end
			end
		end
	end

	(0..h-2).each do |y|
		(0..w-1).each do |x|
			p_piece = hash[[y, x]]
			next if !p_piece
			if (c_piece = hash[[y+1, x]]) && (c_piece != p_piece)
				p_piece.add_child(c_piece)
			end
		end
	end

	begin
		root.check(true)
		puts 'STABLE'
	rescue
		puts 'UNSTABLE'
	end
end