p00749 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.

<image>

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.


<image>

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.

<image> |  | <image>
---|---|---

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






Example

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

STABLE
STABLE
STABLE
UNSTABLE
STABLE
STABLE
UNSTABLE
UNSTABLE
UNSTABLE
UNSTABLE
```python
while True:
  w, h = map(int, input().split())
  if w == 0:
    break

  mp = [[0] + list(input()) + [0] for _ in range(h)]
  mp.insert(0, [0] * (w + 2))
  mp.append([0] * (w + 2))
  for y in range(1, h + 1):
    for x in range(1, w + 1):
      if mp[y][x] == ".":
        mp[y][x] = 0
      else:
        mp[y][x] = int(mp[y][x])

  last_id = 10
  vec = ((0, 1), (0, -1), (1, 0), (-1, 0))
  
  def update(last_id, target, x, y):
    if mp[y][x] != target:
      return
    mp[y][x] = last_id
    for dx, dy in vec:
      update(last_id, target, x + dx, y + dy)
  
  for y in range(1, h + 1):
    for x in range(1, w + 1):
      if 1 <= mp[y][x] <= 9:
        update(last_id, mp[y][x], x, y)
        last_id += 1

  node_num = last_id - 10

  edges = [set() for _ in range(node_num)]
  for y in range(1, h + 1):
    for x in range(1, w + 1):
      if mp[y - 1][x] != mp[y][x] and mp[y - 1][x] != 0 and mp[y][x] != 0:
        edges[mp[y][x] - 10].add(mp[y - 1][x] - 10)

  for x in range(1, w + 1):
    if mp[h][x] != 0:
      root = mp[h][x] - 10
      break
  
  center = [0] * node_num
  ground = [None] * node_num
    
  for y in range(1, h + 1):
    for x in range(1, w + 1):
      if mp[y][x] != 0:
        target = mp[y][x] - 10
        center[target] += (x + 0.5) / 4
        if mp[y + 1][x] in (0, target + 10):
          continue
        if ground[target] == None:
          ground[target] = [x, x + 1]
        else:
          ground[target][0] = min(ground[target][0], x)
          ground[target][1] = max(ground[target][1], x + 1)

  for x in range(1, w + 1):
    if mp[h][x] == root + 10:
      if ground[root] == None:
        ground[root] = [x, x + 1]
      else:
        ground[root][0] = min(ground[root][0], x)
        ground[root][1] = max(ground[root][1], x + 1)

  total_center = [None] *  node_num
  def get_total_center(node):
    mom = center[node]
    wei = 1
    for to in edges[node]:
      to_wei, to_pos = get_total_center(to)
      mom += to_wei * to_pos
      wei += to_wei

    total_center[node] = mom / wei
    return wei, total_center[node]
  
  get_total_center(root)

  for gr, cen in zip(ground, total_center):
    l, r = gr
    if not (l < cen < r):
      print("UNSTABLE")
      break
  else:
    print("STABLE")


```