import strutils, sequtils, sugar

type
  Matrix = seq[seq[int]]

proc reorderColsByColPerm(s: var Matrix, x: int) =
  let t = s.dup
  for r in 0 ..< t.len:
    for c in 0 ..< t.len:
      s[ r ][ t[c][x] ] = t[r][c]

proc reorderRowsByRowPerm(s: var Matrix, y: int) =
  let t = s.dup
  for r in 0 ..< t.len:
    for c in 0 ..< t.len:
      s[ t[y][r] ][ c ] = t[r][c]

proc selectCol(s: Matrix, x: int): seq[int] = s.map(row => row[x])

proc selectRow(s: Matrix, y: int): seq[int] = s[y].dup

proc search(b: Matrix, k: int, t: Matrix, ops: var seq[int]): bool =
  if k == 0:
    return t == b
  for op in 0 ..< b.len*2:
    ops[ops.len-k] = op
    var s = t
    if op < b.len:
      s.reorderColsByColPerm(op)
    else:
      s.reorderRowsByRowPerm(op-b.len)
    if search(b, k-1, s, ops):
      return true
  return false

proc solve(n: int, k: int, a: Matrix, b: Matrix): seq[int] =
  var ops = toSeq( 0 ..< k )
  discard search(b, k, a, ops)
  var ans: seq[int] = @[]
  var s = a
  for op in ops:
    let p = if op < n: s.selectCol(op) else: s.selectRow(op-n)
    var t = toSeq(0 ..< n)
    var w = p.dup
    var z = op mod n
    var tmp: seq[int] = @[]
    while true:
      for i in 0 ..< n:
        t[p[i]] = w[i]
      if t == p:
        break
      z = p[z]
      tmp.add(if op < n: z else: (z+n))
      w = t.dup
    ans.insert(tmp, 0)
    if op < n:
      s.reorderColsByColPerm(op)
    else:
      s.reorderRowsByRowPerm(op-n)
  return ans

proc readInts(): seq[int] =
  return stdin.readLine.strip.split.map(parseInt)

let
  nk = readInts()
  n = nk[0]
  k = nk[1]
  a = toSeq(0 ..< n).mapIt(readInts().mapIt(it-1))
  b = toSeq(0 ..< n).mapIt(readInts().mapIt(it-1))
  ans = solve(n, k, a, b)

echo ans.len
for op in ans:
  if op < n:
    echo "C " & $(op+1)
  else:
    echo "R " & $(op+1-n)