#include<bits/stdc++.h>
using namespace std;

#define REP(i,n) for(int i=0;i<(n);i++)
#define REPR(i,n) for(int i=(n)-1;i>=0;i--)
#define int long long
#define ALL(x) (x).begin(),(x).end()
typedef pair<int, int> pii;


const double EPS=1e-12;
string A[100];
bool vis[100][100];
int num[100][100];
int H,W;
int dx[4]={0,0,-1,1},dy[4]={1,-1,0,0};
set<int>G[1010];
double g_x[1010];
int L[1010],R[1010];
int m[1010];
void init(){
    REP(i,H){
        cin>>A[i];
    }
    REP(i,H)REP(j,W){
        vis[i][j]=false;
        num[i][j]=0;
    }
    REP(i,H*W+10){
        G[i].clear();
        g_x[i]=0;
        m[i]=0;
        L[i]=1000;
        R[i]=-1;
    }
}

void bfs(int x,int y,int id,char c){
    num[x][y]=id;
    vis[x][y]=true;
    queue<pii>que;
    que.push({x,y});
    while(!que.empty()){
        pii p =que.front();
        que.pop();
        REP(k,4){
            int nx=p.first+dx[k];
            int ny=p.second+dy[k];
            if(nx>=0&&nx<H&&ny>=0&&ny<W&&!vis[nx][ny]&&A[nx][ny]==c){
                vis[nx][ny]=true;
                num[nx][ny]=id;
                que.push({nx,ny});
            }
        }
    }
}

int calc_sum(int v){
    int res = m[v];
    for(auto nxt:G[v]){
        res+=calc_sum(nxt);
    }
    return res;
}
double calc_x(int v){
    double res = g_x[v]*m[v];
    for(auto nxt:G[v]){
        res+=calc_x(nxt);
    }
    return res;
}

bool check(int v){
    int sum=calc_sum(v);
    double sum_x=calc_x(v);
    double gx=sum_x/sum;
    // cout<<"id:"<<v<<endl;
    // cout<<"gx:"<<gx<<endl;
    // cout<<"l:"<<L[v]<<"r:"<<R[v]<<endl;
    if(L[v]+EPS<gx&&gx<R[v]-EPS)return true;
    else return false;
}
void solve() {
    cin>>W>>H;
    if(H==0)exit(0);
    init();
    int id = 1;
    REP(i,H){
        REP(j,W){
            if(A[i][j]=='.'||vis[i][j])continue;
            else{
                bfs(i,j,id,A[i][j]);
                id++;
            }
        }
    }
    // REP(i,H){
    //     REP(j,W){
    //         cout<<num[i][j]<<" ";
    //     }cout<<endl;
    // }
    for(int i=H-1;i>=1;i--){
        REP(j,W){
            if(num[i][j]>0&&num[i-1][j]>0&&num[i][j]!=num[i-1][j]){
                G[num[i][j]].insert(num[i-1][j]);
            }
        }
    }
    REP(i,H){
        REP(j,W){
            m[num[i][j]]++;
            double x=j+0.5;
            g_x[num[i][j]]+=x;
        }
    }
    for(int i=H-1;i>=0;i--){
        REP(j,W){
            if(i==H-1||(num[i+1][j]>0&&num[i+1][j]!=num[i][j]))L[num[i][j]]=min(L[num[i][j]],j);
        }
    }
    for(int i=H-1;i>=0;i--){
        REPR(j,W){
            if(i==H-1||(num[i+1][j]>0&&num[i+1][j]!=num[i][j]))R[num[i][j]]=max(R[num[i][j]],j+1);
        }
    }
    REP(i,id){
        if(m[i]){
            g_x[i]/=(double)m[i];
        }
    }
    bool ok = true;
    for(int v=1;v<id;v++){
        if(!check(v)){
            ok=false;
        }
    }
    if(ok)cout<<"STABLE"<<endl;
    else cout<<"UNSTABLE"<<endl;
}

signed main() {
	while(true)solve();
}

