n = gets.chomp.to_i
ary = []
n.times do
    suit, number = gets.chomp.split(' ')
    ary.push([suit, number.to_i])
end

def partition(ary, p, r)
    x = ary[r][1]
    i = p - 1
    p.upto(r - 1) do |j|
        if ary[j][1] <= x then
            i += 1
            tmp = ary[i]
            ary[i] = ary[j]
            ary[j] = tmp
        end
    end
    tmp = ary[i + 1]
    ary[i + 1] = ary[r]
    ary[r] = tmp
    return i + 1
end

def quickSort(ary, p, r)
    if p < r then
        q = partition(ary, p, r)
        quickSort(ary, p, q - 1)
        quickSort(ary, q + 1, r)
    end
end

INF = 10 ** 9 + 5
def merge(aAry, left, mid, right)
    n1 = mid - left
    n2 = right - mid
    lAry = aAry[left, n1]
    rAry = aAry[mid, n2]
    lAry[n1] = ["Z", INF]
    rAry[n2] = ["Z", INF]
    i = 0
    j = 0
    # puts "lAry = #{lAry}, rAry = #{rAry}, left = #{left}, right = #{right}"
    (left..(right - 1)).each do |k|
        if lAry[i][1] <= rAry[j][1] then
            aAry[k] = lAry[i]
            i += 1
        else
            aAry[k] = rAry[j]
            j += 1
        end
    end
end

def mergeSort(aAry, left, right)
    if left + 1 < right then
        mid = (left + right) / 2
        mergeSort(aAry, left, mid)
        mergeSort(aAry, mid, right)
        merge(aAry, left, mid, right)
    end
end

stablySortedAry = Marshal.load(Marshal.dump(ary))
mergeSort(stablySortedAry, 0, stablySortedAry.size)
# p stablySortedAry

quickSort(ary, 0, ary.size - 1)
# p ary

puts ary == stablySortedAry ? "Stable" : "Not stable"
ary.each { |e| puts e.join(' ')}

