#include<iostream>
#include<vector>
#include<cmath>
#include<queue>
#include<set>
#include<cstdlib>

#define H 64
#define W 16

using namespace std;

const int dx[4] = {-1,0,1,0};
const int dy[4] = {0,1,0,-1};

bool inside(int w, int h, int x, int y){
  return 0<=y&&y<h&&0<=x&&x<w;
}

struct Block{
  vector< pair<int,int> > v;
  set<int> child;
  int xl,xr;
  int miny;
  Block(){
    xl=W+1;
    xr=-1;
    miny=H+1;
  }
  double centerOfGravity(){
    double ret=0;
    for(int i = 0; i < (int)v.size(); ++i){
      ret += v[i].first+0.5;
    }
    return ret / v.size();
  }
};

void dfs(int w, int h, int x, int y, char c, char M[W][H], Block &b){
  M[x][y]='.';
  b.v.push_back(make_pair(x,y));
  for(int k = 0; k < 4; ++k){
    int nx = x + dx[k];
    int ny = y + dy[k];
    if(inside(w,h,nx,ny)){
      if(M[nx][ny]==c){
	dfs(w,h,nx,ny,c,M,b);
      }
    }
  }
}

inline bool ison(const pair<int,int> &a, const pair<int,int> &b){
  // a on b
  if(a.first==b.first){
    return a.second - 1 == b.second;
  }
  return false;
}

inline bool istouched(const pair<int,int> &a, const pair<int,int> &b){
  int x = abs(a.first-b.first);
  int y = abs(a.second-b.second);
  if( x==0 && y==1 )return true;
  if( x==1 && y==0 )return true;
  return false;
}

int main()
{
  while(true){
    int w,h;
    vector<Block> G;
    cin >> w >> h;
    if(w==0&&h==0)break;
    char M[W][H];
    for(int i = 0; i < h; ++i){
      for(int j = 0; j < w; ++j){
	cin >> M[j][h-1-i];
      }
    }

    for(int y=0;y<h;++y){
      for(int x=0;x<w;++x){
	if(M[x][y]!='.'){
	  Block t;
	  int miny=H+1;

	  dfs(w,h,x,y,M[x][y],M,t);

	  for(int i = 0; i < (int)t.v.size(); ++i){
	    miny = min( miny, t.v[i].second );
	  }
	  if(miny==0){
	    for(int i = 0; i < (int)t.v.size(); ++i){
	      if( t.v[i].second == miny ){
		t.xl = min( t.xl, t.v[i].first );
		t.xr = max( t.xr, t.v[i].first+1 );
	      }
	    }
	  }
	  t.miny = miny;
	  G.push_back( t );
	}
      }
    }

    for(int i = 0; i < (int)G.size(); ++i){
      for(int j = i+1; j < (int)G.size(); ++j){
	for(int k = 0; k < (int)G[i].v.size(); ++k){
	  for(int l = 0; l < (int)G[j].v.size(); ++l){
	    if( ison(G[i].v[k],G[j].v[l] ) ){
	      G[i].xl = min( G[i].xl, G[i].v[k].first );
	      G[i].xr = max( G[i].xr, G[i].v[k].first + 1 );
	      G[j].child.insert(i);	     
	    }else if(ison(G[j].v[l],G[i].v[k])){
	      G[j].xl = min( G[j].xl, G[j].v[l].first );
	      G[j].xr = max( G[j].xr, G[j].v[l].first + 1 );
	      G[i].child.insert(j);
	    }
	  }
	}
      }
    }
    /*
    for(int i = 0; i < (int)G.size(); ++i){
      cout << i << " : ";
      for(int j = 0; j < (int)G[i].child.size(); ++j){
	cout << G[i].child[j] << ' ';
      }
      cout << endl;
    }
    */

    bool stable = true;
    for(int i = 0; i < (int)G.size(); ++i){
      queue< int > Q;
      double M = 0;
      int num = 0;
      Q.push(i);
      while(!Q.empty()){
	int now = Q.front(); Q.pop();
	M += G[now].centerOfGravity();
	++num;
	for(set<int>::iterator itj = G[now].child.begin(); itj != G[now].child.end(); ++itj){
	  Q.push( *itj );
	}
      }
      M /= (double)num;
      //cout << i << " cog x : " << M << " xl : " << G[i].xl << " xr : " << G[i].xr << endl;
      if( M <= G[i].xl || M >= G[i].xr ){
	stable=false;
      }
    }
    
    if( stable ){
      cout << "STABLE" << endl;
    }else{
      cout << "UNSTABLE" << endl;
    }
  }
  return 0;
}

Measured memory_bytes: 0