object Main extends App {
  import collection.mutable.ArrayBuffer
  
  case class Card(c: String, n: Int, index: Int) extends Ordered[Card]{
    override def compare(that: Card): Int = this.n - that.n
    override def toString: String = this.c + " " + this.n
  }
  implicit def toCard(x: (String, Int)): Card = Card(x._1.substring(0,1), x._1.substring(2).toInt, x._2)

  val n = io.StdIn.readLine().toInt
  val buf: ArrayBuffer[Card] = ArrayBuffer.empty[Card]
  for (i <- 1 to n) {val x = (io.StdIn.readLine(), i); buf += x}
  val arr: Array[Card] = buf.toArray

  def partition(a: Array[Card], pv: Int, r:Int): Int = {
    var p: Int = pv

    for(i <- p until r) {
      val (ai, ap, ar) = (a(i), a(p), a(r))
      if (i == p) {if (ai <= ar) p += 1}
      else {if (ai <= ar && ai < ap) {a(i) = ap; a(p) = ai; p += 1}}
    }
    val ap = a(p)
    a(p) = a(r); a(r) = ap
    p
  }

  def qsort(a: Array[Card], p: Int, r: Int): Unit =
    if (p < r) {
      val q: Int = partition(a, p, r)
      qsort(a, p, q-1)
      qsort(a, q+1, r)
    }

  qsort(arr, 0, n-1)
  val sb: StringBuilder = new StringBuilder
  var flag: Boolean = true
  sb ++= arr(0).toString + "\n"
  for (i <- 1 until n) {if (arr(i-1).index > arr(i).index) flag = false; sb ++= arr(i).toString + "\n"}

  println(if (flag) "Stable" else "Not stable")
  print(sb.toString())
}