class NetworkFlow
  attr_reader :graph

  Edge = Struct.new(:to, :cap, :rev)
  MAX_V = 20010

  def initialize(n = MAX_V)
    @graph = Array.new(n) { Array.new }
    @level = Array.new(MAX_V)
    @iter = Array.new(MAX_V)
  end

  def add_edge(from, to, cap)
    @graph[from].push(Edge.new(to, cap, @graph[to].size))
    @graph[to].push(Edge.new(from, 0, @graph[from].size - 1))
  end

  def max_flow(s, t)
    flow = 0

    loop do
      bfs(s)
      break if @level[t] < 0
      @iter.fill(0)

      while (f = dfs(s, t, Float::INFINITY)) > 0
        flow += f
      end
    end

    flow
  end

  private

  def bfs(s)
    @level.fill(-1)
    @level[s] = 0

    queue = []
    queue.push(s)

    until queue.empty?
      v = queue.shift

      @graph[v].each do |edge|
        next if edge.cap <= 0
        next if @level[edge.to] >= 0

        @level[edge.to] = @level[v] + 1
        queue.push(edge.to)
      end
    end
  end

  def dfs(v, t, f)
    return f if v == t

    (@iter[v]...@graph[v].size).each do |i|
      @iter[v] = i
      edge = @graph[v][i]

      next if edge.cap <= 0
      next if @level[v] >= @level[edge.to]

      d = dfs(edge.to, t, min(f, edge.cap))
      next if d <= 0

      edge.cap -= d
      @graph[edge.to][edge.rev].cap += d

      return d
    end

    0
  end

  def min(a, b)
    a < b ? a : b
  end
end

N, M = gets.split.map(&:to_i)
S = N.times.map { gets.chomp }

nf = NetworkFlow.new

DY = [-1, 0, 1, 0]
DX = [0, 1, 0, -1]

s = 2 * N * M
t = s + 1

N.times do |y|
  M.times do |x|
    next if S[y][x] == '#'

    u = y * M + x

    if (x + y) % 2 == 0
      nf.add_edge(s, u, 1)

      4.times do |i|
        ny = y + DY[i]
        nx = x + DX[i]
        v = ny * M + nx

        next if ny < 0 || nx < 0 || N <= ny || M <= nx

        nf.add_edge(u, v, 1)
      end
    else
      nf.add_edge(u, t, 1)
    end
  end
end

puts nf.max_flow(s, t)

N.times do |y|
  M.times do |x|
    next if S[y][x] == '#'
    next if (y + x) % 2 != 0

    u = y * M + x

    nf.graph[u].each do |edge|
      next if edge.cap != 0
      next if edge.to >= s

      ny = edge.to / M
      nx = edge.to % M
      v = ny * M + nx

      if (u - v).abs < M
        if x < nx
          S[y][x] = '>'
          S[ny][nx] = '<'
        else
          S[y][x] = '<'
          S[ny][nx] = '>'
        end
      else
        if y < ny
          S[y][x] = 'v'
          S[ny][nx] = '^'
        else
          S[y][x] = '^'
          S[ny][nx] = 'v'
        end
      end
    end
  end
end

puts S
