// Original C++ solution (slower):
#include<bits/stdc++.h>

using namespace std;

#define pfc(x) printf("Case %d: ",x)

#define sf1(x) scanf("%lld",&x)

#define sf2(x,y) scanf("%d%d",&x,&y)

#define sf3(x,y,z) scanf("%lld%lld%lld",&x,&y,&z)

#define sf4(x,y,z,m) scanf("%d%d%d%d",&x,&y,&z,&m)

#define pf1(x) printf("%d\n",x)

#define pf2(x,y) printf("%d %d\n",x,y)

#define pf3(x,y,z) printf("%d %d %d\n",x,y,z)

#define pf4(x,y,z,m) printf("%d %d %d %d\n",x,y,z,m)

#define pii pair<long long,long long>

#define pb push_back

int n,flag;

struct lol

{

    char ch;

    long long num;

} a[1000005];

int part(int p,int r)

{

    long long x=a[r].num;

    long long i=p-1;

    for(int j=p; j<r; j++)

    {

        if(a[j].num<=x)

        {

            i++;

            swap(a[i].num,a[j].num);

            char tp;

            tp=a[i].ch;

            a[i].ch=a[j].ch;

            a[j].ch=tp;



        }

    }

    swap(a[i+1].num,a[r].num);

    char tp;

    tp=a[i+1].ch;

    a[i+1].ch=a[r].ch;

    a[r].ch=tp;

    return i+1;

}

void quick(int p,int r)

{

    int q;

    if(p>=r)return ;

    if(p<r)q=part(p,r);

    quick(p,q-1);

    quick(q+1,r);

}

int main()

{

    int n;

    cin>>n;

    flag=0;

    map<long long,vector<char> >mp,rp;

    map<int,int>rr;

    vector<int>v;

    for(int i=0; i<n; i++)

    {

        cin>>a[i].ch>>a[i].num;

        mp[a[i].num].pb(a[i].ch);

        if(rr[a[i].num]==0)v.pb(a[i].num);

        rr[a[i].num]=1;



    }

    quick(0,n-1);

    flag=0;

    for(int i=0; i<n; i++)

    {

        rp[a[i].num].pb(a[i].ch);

    }

    for(int i=0;i<v.size();i++)

    {

        for(int j=0;j<mp[v[i]].size();j++)

        {

            //cout<<mp[v[i]][j]<<' '<<rp[a[i].num][j]<<endl;

            if(mp[v[i]][j]!=rp[v[i]][j])flag=1;

        }

    }



    if(flag==0)printf("Stable\n");

    else

    {

        printf("Not stable\n");

    }

    for(int i=0; i<n; i++)printf("%c %lld\n",a[i].ch,a[i].num);

    return 0;

}

// Optimized solution to the same problem (faster):
#include<stdio.h>

#define MAX 100000

#define SENTINEL 2000000000

struct C

{

	char suit;

	int value;

};

struct C L[MAX/2+2],R[MAX/2+2];

void merge(struct C A[],int n,int left,int mid,int right)

{

	int i,j,k;

	int n1=mid-left;

	int n2=right-mid;

	for(i=0;i<n1;i++)L[i]=A[left+i];

	for(i=0;i<n2;i++)R[i]=A[mid+i];

	L[n1].value=R[n2].value=SENTINEL;

	i=j=0;

	for(k=left;k<right;k++)

	{

		if(L[i].value<=R[j].value)

		A[k]=L[i++];

		else 

		A[k]=R[j++];

	}

}

void mergeSort(struct C A[],int n,int left,int right)

{

     int mid;

	if(left+1<right)

	{

		mid=(left+right)/2;

		mergeSort(A,n,left,mid);

		mergeSort(A,n,mid,right);

		merge(A,n,left,mid,right);

	}

}

int partition(struct C A[],int n,int p,int r)

{

	int i,j;

    struct C t,x;

    x=A[r];

    i=p-1;

    for(j=p;j<r;j++)

    {

    	if(A[j].value<=x.value)

        {

        	i++;

        	t=A[i];A[i]=A[j];A[j]=t;

        }

	}

	t=A[i+1];A[i+1]=A[r];A[r]=t;

	return i+1;

}

void quickSort(struct C A[],int n,int p,int r)

{

	int q;

	if(p<r)

	{

		q=partition(A,n,p,r);

		quickSort(A,n,p,q-1);

		quickSort(A,n,q+1,r);

	}

}

int main()

{

	int i,n,v;

	struct C A[MAX],B[MAX];

	char S[10];

	int stable=1;

	scanf("%d",&n);

	for(i=0;i<n;i++)

	{

		scanf("%s %d",S,&v);

		B[i].suit=S[0];

		A[i].suit=B[i].suit;

		B[i].value=v;

		A[i].value=B[i].value;

	}

	mergeSort(A,n,0,n);

	quickSort(B,n,0,n-1);

	for(i=0;i<n;i++)

	{

		if(A[i].suit!=B[i].suit)stable=0;

	}

	if(stable==1)printf("Stable\n");

	else printf("Not stable\n");

    for(i=0;i<n;i++)

    {

    	printf("%c %d\n",B[i].suit,B[i].value);

    }

	return 0;

}

// Fastest known solution for this problem: