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

namespace ALDS1_6_C
{
    class Program
    {
        private static int targetCount;
        private static Card[] targetArray;
        private static Card[] targetArray2;

        static void Main(string[] args)
        {
            Program.targetCount = int.Parse(Console.ReadLine());
            Program.targetArray = new Card[Program.targetCount];
            Program.targetArray2 = new Card[Program.targetCount];

            for (int i = 0; i < Program.targetCount; i++)
            {
                string[] tmpArry = Console.ReadLine()
                                          .Split(' ');
                targetArray[i] = new Card(tmpArry[0], int.Parse(tmpArry[1]));
            }

            Program.targetArray.CopyTo(Program.targetArray2, 0);

            Program.QuickSort(0, Program.targetCount - 1);
            Program.MergeSort(0, Program.targetCount - 1);

            for (int i = 0; i < Program.targetArray.Length; i++)
            {
                if (!Program.targetArray[i].Equals(Program.targetArray2[i]))
                {
                    Console.WriteLine("Not stable");
                    break;
                }
                if (i == Program.targetArray.Length - 1)
                {
                    Console.WriteLine("Stable");
                }
            }

            foreach (var item in Program.targetArray)
            {
                Console.WriteLine(item.ToString());
            }
            Console.ReadLine();
        }

        private static int Partition(int leftInd, int rightInd)
        {
            Card partition = Program.targetArray[rightInd];
            int tmpInd = leftInd - 1;

            for (int i = leftInd; i < rightInd; i++)
            {
                //if (Program.targetArray[i] <= partition)
                if (partition.IsLarger(Program.targetArray[i]))
                {
                    tmpInd++;
                    Card tmpCard = Program.targetArray[i];
                    Program.targetArray[i] = Program.targetArray[tmpInd];
                    Program.targetArray[tmpInd] = tmpCard;
                }
            }
            tmpInd++;
            Program.targetArray[rightInd] = Program.targetArray[tmpInd];
            Program.targetArray[tmpInd] = partition;
            return tmpInd;
        }

        private static void QuickSort(int leftInd, int rightInd)
        {
            if (leftInd < rightInd)
            {
                int partitionInd = Program.Partition(leftInd, rightInd);
                Program.QuickSort(leftInd, partitionInd - 1);
                Program.QuickSort(partitionInd + 1, rightInd);
            }
            return;
        }

        private static void Merge(int leftInd, int midInd, int rightInd)
        {
            Card[] leftArry = new Card[midInd - leftInd + 1];
            Card[] rightArry = new Card[rightInd - midInd];

            for (int i = 0; i < leftArry.Length; i++)
            {
                leftArry[i] = Program.targetArray2[leftInd + i];
            }

            for (int i = 0; i < rightArry.Length; i++)
            {
                rightArry[i] = Program.targetArray2[midInd + 1 + i];
            }

            for (int l = 0, r = 0, k = leftInd; k <= rightInd; k++)
            {
                if (l < leftArry.Length && r >= rightArry.Length || l < leftArry.Length && r < rightArry.Length && rightArry[r].IsLarger(leftArry[l]))
                {
                    Program.targetArray2[k] = leftArry[l];
                    l++;
                }
                else
                {
                    Program.targetArray2[k] = rightArry[r];
                    r++;
                }
            }
        }

        private static void MergeSort(int leftInd, int rightInd)
        {
            if (leftInd < rightInd)
            {
                int midInd = (leftInd + rightInd) / 2;
                Program.MergeSort(leftInd, midInd);
                Program.MergeSort(midInd + 1, rightInd);
                Program.Merge(leftInd, midInd, rightInd);
            }
            return;
        }
    }

    class Card
    {
        private string suit;
        private int num;

        public Card(string suit, int num)
        {
            this.suit = suit;
            this.num = num;
        }

        public bool IsLarger(Card targetCard)
        {
            return targetCard.num <= this.num;
        }

        public override bool Equals(object obj)
        {
            if (obj == null || this.GetType() != obj.GetType())
            {
                return false;
            }

            Card targetCard = (Card)obj;

            return this.suit == targetCard.suit && this.num == targetCard.num;
        }

        public override string ToString()
        {
            return string.Format("{0} {1}", this.suit, this.num);
        }
    }
}



Measured memory_bytes: 35372