INT_LARGE = 100000
 
def succ(char)
   char == nil ? 'a' : char.succ
end
 
def solve(map, h, w)
   result = Array.new(h)
   h.times do |i|
      result[i] = Array.new(w)
   end
 
   cur = nil
   #cur = 'a'
   #result[0][0] = cur.dup
 
   (1..h).each do |y|
      (1..w).each do |x|
         min = map[y][x]
         yy = y
         xx = x
 
         # North
         if min > map[y-1][x] #and map[y-1][x] == nil
            min = map[y-1][x]
            yy = y-1
            xx = x
         end
 
         # West
         if min > map[y][x-1] #and map[y][x-1] == nil
            min = map[y][x-1]
            yy = y
            xx = x-1
         end
 
         # East
         if min > map[y][x+1] #and map[y][x+1] == nil
            min = map[y][x+1]
            yy = y
            xx = x+1
         end
 
         # South
         if min > map[y+1][x] #and map[y+1][x] == nil
            min = map[y+1][x]
            yy = y+1
            xx = x
         end
 
   
         if min == map[y][x]
            if result[y-1][x-1] == nil
               cur = succ(cur)
               p "nil : #{cur}"
               result[y-1][x-1] = cur.dup
            else
               p 'something'
            end
 
            next
         end
 
         if result[y-1][x-1] == nil
            if result[yy-1][xx-1] == nil
               cur = succ(cur)
               p "#{y},#{x} -> #{yy},#{xx} : #{cur}"
               result[y-1][x-1] = cur.dup
            else
               result[y-1][x-1] = result[yy-1][xx-1].dup
            end
         end
 
         result[yy-1][xx-1] = result[y-1][x-1].dup
      end
   end
 
   result
end
 
T = ARGF.gets.to_i
 
T.times do |i|
   h, w = ARGF.gets.split(/\s/).map {|x| x.to_i}
 
   map = Array.new(h+2)
   h.times do |j|
      map[j+1] = ARGF.gets.split(/\s/).map {|x| x.to_i}
 
      map[j+1].unshift INT_LARGE
      map[j+1].push INT_LARGE
   end
 
   map[0] = Array.new(w+2, INT_LARGE)
   map[h+1] = Array.new(w+2, INT_LARGE)
   
   puts "Case ##{i+1}:"
   solve(map, h, w).each do |row|
      puts row.join ' '
   end
end
 
=begin
words = Array.new(D)
D.times do |i|
   words[i] = ARGF.gets.chomp
end
 
N.times do |i|
   puts "Case ##{i+1}: #{solve(words, ARGF.gets.chomp)}"
end
=end