func reorderColsByColPerm(_ s: inout [[Int]], _ x: Int) {
	let t = s
	for r in 0..<t.count {
		for c in 0..<t.count {
			s[ r ][ t[c][x]-1 ] = t[r][c]
		}
	}
}

func reorderRowsByRowPerm(_ s: inout [[Int]], _ y: Int) {
	let t = s
	for r in 0..<t.count {
		for c in 0..<t.count {
			s[ t[y][r]-1 ][ c ] = t[r][c]
		}
	}
}

func selectCol(_ s: [[Int]], _ x: Int) -> [Int] {
	s.map { row in row[x] }
}

func selectRow(_ s: [[Int]], _ y: Int) -> [Int] {
	s[y]
}

func solve(_ n: Int, _ k: Int, _ a: [[Int]], _ b: [[Int]]) -> [Int] {
	var ops: [Int] = .init(repeating: 0, count: k)
	_ = search(b, k, a, &ops)
	var ans: [Int] = []
	var s = a
	for op in ops {
		let p = if op < n {
			selectCol(s, op)
		} else {
			selectRow(s, op-n)
		}
		if op < n {
			reorderColsByColPerm(&s, op)
		} else {
			reorderRowsByRowPerm(&s, op-n)
		}
		var tmp: [Int] = []
		var z = op % n
		for _ in 1..<cycle(p) {
			z = p[z]-1
			if op < n {
				tmp.append(z)
			} else {
				tmp.append(z+n)
			}
		}
		ans.insert(contentsOf: tmp, at: 0)
	}
	return ans
}

func search(_ b: [[Int]], _ k: Int, _ t: [[Int]], _ v: inout [Int]) -> Bool {
	if k == 0 {
		return b == t
	}
	for i in 0..<b.count*2 {
		v[v.count-k] = i
		var s = t
		if i < b.count {
			reorderColsByColPerm(&s, i)
		} else {
			reorderRowsByRowPerm(&s, i-b.count)
		}
		if search(b, k-1, s, &v) {
			return true
		}
	}
	return false
}

func cycle(_ p: [Int]) -> Int {
	var t = p
	var w = p
	for cnt in 1... {
		for (i, e) in p.enumerated() {
			t[e-1] = w[i]
		}
		if p == t {
			return cnt
		}
		w = t
	}
	return 0
}

func readInts() -> [Int] {
	readLine()!.split(separator: " ").map { s in  Int(s)! }
}

func main() {
	var firstLine = readInts().makeIterator()
	let n: Int = firstLine.next()!
	let k: Int = firstLine.next()!
	let a: [[Int]] = (1...n).map { _ in readInts() }
	let b: [[Int]] = (1...n).map { _ in readInts() }
	
	let ans = solve(n, k, a, b)
	
	print(ans.count)
	for op in ans {
		if op < n {
			print("C \(op+1)")
		} else {
			print("R \(op+1-n)")
		}
	}
}

main()