import Foundation

extension String {
    func wordsMap<T>(_ f: (Substring) -> T?) -> [T] {
        return self.split(separator: " ").compactMap(f)
    }
}

private func readWords<T>(_ f: (Substring) -> T?) -> [T] {
    return readLine()!.wordsMap(f)
}

extension Optional {
    func pleaseAC(){
        print(self!)
    }
}

readLine().map { line -> Any in 
    let hwk = line.wordsMap { Int($0) }
    let H = hwk[0]
    let W = hwk[1]
    let K = hwk[2]

    var count = 0
    let grid = (0..<H).map { _ -> [Character] in 
        let row = Array(readLine()!)
        count += row.filter { $0 == "#" }.count
        return row
    }

    var points = [[Int]]()
    for h in 0..<H {
        points.append([h, -1])
    }

    for w in 0..<W {
        points.append([-1, w])
    }

    var ans = 0
    if count == K {
        ans += 1
    }
    for i in 1...H+W {
        for comb in Combinations(points, i) {
            var tmp = 0
            let reds = Set(comb)
            for h in 0..<H {
                for w in 0..<W {
                    if reds.contains([h, -1]) || reds.contains([-1, w]) {
                        continue
                    }
                    if grid[h][w] == "#" {
                        tmp += 1
                    }
                }   
            }
            if tmp == K {
                ans += 1
            }
        }
        
    }
    return ans

}
.pleaseAC()

struct Combinations<Seq: Sequence>: Sequence, IteratorProtocol {
    let pool: [Seq.Element]
    let r: Int

    var indecies: [Int]
    var first = true

    init(_ seq: Seq, _ r: Int) {
        self.pool = [Seq.Element](seq)
        self.r = r
        self.indecies = [Int](0..<r)
    }

    mutating func next() -> [Seq.Element]? {
        let n = pool.count
        guard 0...n ~= r else { return nil }
        guard !first else {
            first = false
            return indecies.map { pool[$0] }
        }

        var i = r - 1
        while indecies[i] == i + n - r {
            if i > 0 {
                i -= 1
            } else {
                return nil
            }
        }

        indecies[i] += 1
        for j in i+1..<r {
            indecies[j] = indecies[j - 1] + 1
        }

        return indecies.map { pool[$0] }
    }
}