using System;
using System.Text;

namespace ALDS1_6_C
{
    class Program
    {
        struct card
        {
            public string mark;
            public int nam;
            public card(string mark, int nam)
            {
                this.mark = mark;
                this.nam = nam;
            }
        }

        static void Main(string[] args)
        {
            int n = getint();
            card[] data = new card[n];
            card[] sort = new card[n];
            for (int i = 0; i < n; i++)
            {
                var s = getsplit();
                data[i].mark = s[0];
                sort[i].mark = s[0];
                data[i].nam = int.Parse(s[1]);
                sort[i].nam = int.Parse(s[1]);
            }

            mergesort(data, 0, n);

            quicksort(sort, 0, n-1);
           
            var sb = new StringBuilder();

            bool stable = true;
            for (int i = 0; i < n; i++)
            {
                if (data[i].mark != sort[i].mark)
                {
                    stable = false;
                    break;
                }
            }
                       
            if (stable)
            {
                sb.AppendLine("Stable");
            }
            else
            {
                sb.AppendLine("Not stable");
            }
            for (int i= 0; i < n; i++)
            {
                sb.AppendLine(sort[i].mark+" "+sort[i].nam);
            }
            Console.Write(sb);

        }
        static void merge(card[] A, int left, int mid, int right)
        {
            int n1 = mid - left;
            int n2 = right - mid;
            var L = new card[n1 + 1];
            var R = new card[n2 + 1];
            int i;
            for (i = 0; i < n1; i++)
            {
                L[i] = A[left + i];
            }
            for (i = 0; i < n2; i++)
            {
                R[i] = A[mid + i];
            }
            L[n1].nam = int.MaxValue;
            R[n2].nam = int.MaxValue;
            i = 0;
            int j = 0;
            for (int k = left; k < right; k++)
            {
                if (L[i].nam <= R[j].nam)
                {
                    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);
            }
        }

        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)
        {
            int x = A[r].nam;
            int i = p - 1;
            for (int j = p; j < r; j++)
            {
                if (A[j].nam <= x)
                {
                    i++;
                    card k = A[j];
                    A[j] = A[i];
                    A[i] = k;
                }
            }
            card l = A[i + 1];
            A[i + 1] = A[r];
            A[r] = l;
            return i + 1;
        }
        public static string[] getsplit()
        {
            string[] x = Console.ReadLine().Split(' ');
            return x;
        }
        public static int getint()
        {
            int x = int.Parse(Console.ReadLine());
            return x;
        }
    }
}

Measured memory_bytes: 23236