class Array
  def swap!(a, b)
    raise ArgumentError unless a.between?(0, self.count-1) && b.between?(0, self.count-1)

    self[a], self[b] = self[b], self[a]

    self
  end
end

def partition(p, r)
  x = @B[r]
  i = p - 1
  (p...r).each do |j|
    if @B[j].value <= x.value
      i += 1
      @B.swap!(i, j)
    end
  end
  @B.swap!(i+1, r)
  
  i+1
end

def quick_sort(n, p, r)
  if p < r
    q = partition(p, r)
    quick_sort(n, p, q-1)
    quick_sort(n, q+1, r)
  end
end

def merge(n, left, mid, right)
  n1 = mid - left
  n2 = right - mid
  n1.times do |i|
    @L[i] = @A[left + i]
  end
  
  n2.times do |i|
    @R[i] = @A[mid + i]
  end
  
  @L[n1] = Card.new
  @R[n2] = Card.new
  @L[n1].value = SENTINEL
  @R[n2].value = SENTINEL
  
  i = 0
  j = 0
  (left...right).each do |k|    
    if @L[i].value <= @R[j].value
      @A[k] = @L[i]
      i += 1
    else
      @A[k] = @R[j]
      j += 1
    end
  end
end

def merge_sort(n, left, right)
  if left+1 < right
    mid = (left + right) / 2
    merge_sort(n, left, mid)
    merge_sort(n, mid, right)
    merge(n, left, mid, right)
  end
end

@L = []
@R = []
SENTINEL = 20000000000.freeze

Card = Struct.new(:suit, :value)
@A = []
@B = []
stable = true

n = gets.to_i

n.times do |i|
  inputs = gets.split
  @A[i] = Card.new
  @B[i] = Card.new
  @A[i].suit = inputs[0]
  @B[i].suit = inputs[0]
  @A[i].value = inputs[1].to_i
  @B[i].value = inputs[1].to_i
end

merge_sort(n, 0, n)
quick_sort(n, 0, n-1)

n.times do |i|
  stable = false if @A[i].suit != @B[i].suit
end

puts stable ? 'Stable' : 'Not stable'
@B.each do |card|
  puts "#{card.suit} #{card.value}"
end
