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

namespace lec6C
{
    public class Card
    {
        public string mark;
        public int num;

        public Card(string c, int i)
        {
            mark = c;
            num = i;
        }
        public Card() { }
    }

    class Program
    {
        public const int INF = 2000000000;
        public const int MAX = 100000;
        public static int n;
        public static Card[] arr_l = new Card[MAX];
        public static Card[] arr_r = new Card[MAX];

        static void Main(string[] args)
        {
            Program.n = int.Parse(Console.ReadLine());
            Card[] arr_q = new Card[n];
            Card[] arr_m = new Card[n];

            for (int i = 0; i < n; i++)
            {
                string[] instr = Console.ReadLine().Split(' ');
                int ii = int.Parse(instr[1]);

                arr_q[i] = new Card(instr[0], ii);
                arr_m[i] = new Card(instr[0], ii);
            }

            for (int i= 0;i < (n/2)+3;i++)
            {
                arr_r[i] = new Card();
                arr_l[i] = new Card();
            }



            QuickSort(arr_q, 0, n - 1);
            MergeSort(arr_m, 0, n);


            String ans = "Stable";
            for (int i= 0; i < n; i++)
            {
                if (arr_m[i].mark != arr_q[i].mark) { ans = "Not stable";break; }
            }
            Console.WriteLine(ans);

            for(int  i = 0;i<n;i++)
            {
                Console.WriteLine(arr_q[i].mark + " " + arr_q[i].num);
            }

            Console.ReadLine();

        }

        static void MergeSort(Card[] arr , int l,int r)
        {
            if (l + 1 < r)
            {
                int mid = (l + r) / 2;
                MergeSort(arr,l,mid);
                MergeSort(arr, mid, r);
                Sort(arr,l,mid,r);
            }
        }

        static void Sort(Card[] arr ,int l,int mid,int r)
        {
            int i, j = 0, k=0, a = mid -l,b = r - mid;

            for (i = 0; i < a; i++)
            {
                arr_l[i].mark = arr[l + i].mark;
                arr_l[i].num = arr[ l + i].num;
            }
            for (i = 0; i < b; i++)
            {
                arr_r[i].mark = arr[mid + i].mark;
                arr_r[i].num  = arr[mid + i].num;
            }
            arr_l[a].num = INF; arr_r[b].num = INF;

            for (int m = l; m < r; m++)
            {
                 if (arr_l[j].num <= arr_r[k].num )
                {
                    arr[m].num = arr_l[j].num;
                    arr[m].mark = arr_l[j].mark;
                    j++;
                }
                else
                {
                    arr[m].num = arr_r[k].num;
                    arr[m].mark = arr_r[k].mark;
                    k++;
                }
            }
        }

        static void QuickSort(Card[] arr, int p, int r)
        {
            if (p < r)
            {
                int q = Part(arr , p, r);
                QuickSort(arr, p, q - 1);
                QuickSort(arr, q + 1, r);
            }
        }

        static int Part(Card[] arr, int p, int r)
        {
            Card x = arr[r];
            Card t;
            int j, i = p - 1;
            for (j = p; j < r; j++)
            {
                if (arr[j].num <= x.num)
                {
                    i++;
                    t = arr[i];arr[i] = arr[j];arr[j] = t;
                }
            }
            t = arr[r]; arr[r] = arr[i+1]; arr[i+1] = t;
            return i + 1;
        }
    }
}


Measured memory_bytes: 33448