using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;

namespace Practice
{
    class Program
    {
        public struct Card
        {
            public char c;
            public int d;
        }
        static void Main(string[] args)
        {
            SolveA(args);
            //SolveB(args);
            //SolveC(args);
            //SolveD(args);


        }
        static void SolveA(string[] args)
        {
            int n =int.Parse(Console.ReadLine());
            Card[] mergeSort = new Card[n];
            Card[] s = new Card[n];
            for(int i=0;i<n;++i)
            {
                var c = new Card();
                string[] szarr = Console.ReadLine().Split(' ');
                c.c = szarr[0][0];
                c.d = int.Parse(szarr[1]);
                mergeSort[i] = c;
                s[i] = c;
            }
            MergeSort(mergeSort, 0, mergeSort.Length);
            QuickSort(s, 0, s.Length-1);

            bool stable = true;
            for(int i=0;i<n;++i)
            {
                if(mergeSort[i].c != s[i].c || mergeSort[i].d != s[i].d)
                {
                    stable = false;
                    break;
                }
            }
            Console.WriteLine(stable ? "Stable" : "Not stable");

            for(int i=0;i<s.Length;++i)
            {
                var c = s[i];
                Console.WriteLine(c.c + " " + c.d);
            }
        }
        static void QuickSort(Card[] a, int p, int r)
        {
            if( p < r)
            {
                int q = Partition(a, p, r);
                QuickSort(a, p, q - 1);
                QuickSort(a, q + 1, r);
            }
        }
        static int Partition(Card[] a, int p, int r)
        {
            Card x = a[r];
            int i = p - 1;
            for(int j=p;j<r;++j)
            {
                if( a[j].d <= x.d)
                {
                    i = i + 1;
                    Card tmp = a[i];
                    a[i] = a[j];
                    a[j] = tmp;
                }


            }
            Card tmp2 = a[i + 1];
            a[i + 1] = a[r];
            a[r] = tmp2;
            return i + 1;
        }
        static void Merge(Card[] a, int left, int mid, int right)
        {
            int n1 = mid - left;
            int n2 = right - mid;
            Card[] L = new Card[n1 + 1];
            Card[] R = new Card[n2 + 1];
            for (int i = 0; i < n1; ++i)
            {
                L[i] = a[left + i];
            }
            for (int i = 0; i < n2; ++i)
            {
                R[i] = a[mid + i];
            }
            L[n1].d = int.MaxValue;
            R[n2].d = int.MaxValue;

            {
                int i = 0;
                int j = 0;
                for (int k = left; k < right; ++k)
                {
                    if (L[i].d <= R[j].d)
                    {
                        a[k] = L[i];
                        i = i + 1;
                    }
                    else
                    {
                        a[k] = R[j];
                        j = j + 1;
                    }
                }
            }
        }
        static void MergeSort(Card[] a, int left, int right)
        {
            if (left + 1 < right)
            {
                int mid = (left + right) / 2;
                MergeSort(a, left, mid);
                MergeSort(a, mid, right);
                Merge(a, left, mid, right);
            }
        }
    }

}



Measured memory_bytes: 13144