using System;

namespace ALDS1_6_C
{
    class Program
    {
        static void Main(string[] args)
        {
            int N = int.Parse(Console.ReadLine());
            char[] list_c = new char[N];
            int[] list_i = new int[N];
            for (int i = 0; i < N; i++)
            {
                string[] num = Console.ReadLine().Split(' ');
                list_c[i] = char.Parse(num[0]);
                list_i[i] = int.Parse(num[1]);
            }
            char[] ref_c = new char[N];
            int[] ref_i = new int[N];
            list_c.CopyTo(ref_c, 0);
            list_i.CopyTo(ref_i, 0);

            quickSort(list_c, list_i, 0, N - 1);

            if (judge(list_c, list_i, ref_c, ref_i))
            {
                Console.WriteLine("Stable");
            }
            else
            {
                Console.WriteLine("Not stable");
            }

            for (int i = 0; i < N; i++)
            {
                Console.WriteLine("{0} {1}", list_c[i], list_i[i]);
            }

            while (true)
            {
                if (string.IsNullOrEmpty(Console.ReadLine())) break;
            }
        }

        public static void quickSort(char[] arr_c, int[]arr_i, int p, int r)
        {
            if (p < r)
            {
                int q = partition(arr_c, arr_i, p, r);
                quickSort(arr_c, arr_i, p, q - 1);
                quickSort(arr_c, arr_i, q + 1, r);
            }
        }
        public static int partition(char[] arr_c, int[] arr_i, int p, int r)
        {
            int x = arr_i[r];
            int i = p - 1;
            int tmp_i = 0;
            char tmp_c;
            for (int j = p; j < r; j++)
            {
                if (arr_i[j] <= x)
                {
                    i++;
                    tmp_i = arr_i[i];
                    arr_i[i] = arr_i[j];
                    arr_i[j] = tmp_i;

                    tmp_c = arr_c[i];
                    arr_c[i] = arr_c[j];
                    arr_c[j] = tmp_c;
                }
            }
            tmp_i = arr_i[i + 1];
            arr_i[i + 1] = arr_i[r];
            arr_i[r] = tmp_i;

            tmp_c = arr_c[i + 1];
            arr_c[i + 1] = arr_c[r];
            arr_c[r] = tmp_c;
            return i + 1;
        }

        public static bool judge(char[] before_c,int[] before_i,char[] after_c,int[] after_i)
        {
            int N = before_c.Length;

            for (int i = 0; i < N; i++)
            {
                for (int j = i + 1; j < N; j++)
                {
                    if (before_i[i] == before_i[j])
                    {
                        for (int p = 0; p < N; p++)
                        {
                            if (after_i[p] != before_i[i]) continue;
                            for (int q = p + 1; q < N; q++)
                            {
                                if (after_i[q] != before_i[i]) continue;
                                if (before_c[i] == after_c[q] && before_c[j] == after_c[p]) return false;
                            }
                        }
                    }
                }
            }
            return true;
        }

    }
}

Measured memory_bytes: 11256