using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using static ConsoleReader;

class Program
{
    static void Main(string[] args)
    {
        var h = Read<int>();
        var w = Read<int>();
        var k = Read<int>();
        var a = ReadArray<string>(h);
        var rows = Enumerable.Range(0, h).ToArray();
        var cols = Enumerable.Range(0, w).ToArray();
        var rowSet = new HashSet<int>();
        var colSet = new HashSet<int>();
        var result = 0;
        foreach (var selectedrows in SubsetGenerater.GetSubsets(rows))
        {
            rowSet.Clear();
            rowSet.UnionWith(selectedrows);

            foreach (var selectedcols in SubsetGenerater.GetSubsets(cols))
            {
                colSet.Clear();
                colSet.UnionWith(selectedcols);
                var blackCount = 0;
                (h, w).Times((i, j) =>
                {
                    if (a[i][j] == '#' && !rowSet.Contains(i) && !colSet.Contains(j))
                    {
                        blackCount++;
                    }
                });
                if (blackCount == k)
                {
                    result++;
                }
            }
        }
        Console.WriteLine(result);
    }
}

public static class IntExtentions
{
    public static void Times(this int n, Action<int> action)
    {
        for (var i = 0; i < n; i++)
        {
            action(i);
        }
    }

    public static void Times(this (int n, int m) dimensions, Action<int, int> action)
    {
        var (n, m) = dimensions;
        n.Times(i => m.Times(j => action(i, j)));
    }
}

public static class ConsoleReader
{
    public static T Read<T>()
        where T : IConvertible
    {
        var inputBuffer = new StringBuilder();
        int currChar;

        while ((currChar = Console.Read()) != -1)
        {
            if (!char.IsWhiteSpace((char)currChar))
            {
                inputBuffer.Append((char)currChar);
            }
            else if (inputBuffer.Length != 0)
            {
                break;
            }
        }

        return (T)Convert.ChangeType(inputBuffer.ToString(), typeof(T));
    }

    public static T[] ReadArray<T>(int count)
        where T : IConvertible
    {
        if (count < 0)
        {
            throw new ArgumentOutOfRangeException(nameof(count), $"'{nameof(count)}' must be >= 0");
        }

        var result = new T[count];

        for (var i = 0; i < count; i++)
        {
            result[i] = Read<T>();
        }

        return result;
    }
}

public static class SubsetGenerater
{
    public static IEnumerable<T[]> GetSubsets<T>(IEnumerable<T> items)
    {
        var count = items.Count();
        var positionsToSelect = Enumerable
            .Repeat(0, count + 1)
            .ToArray();

        while (positionsToSelect[count] == 0)
        {
            yield return SelectItems(items, positionsToSelect);
            CetNextSelection(ref positionsToSelect);
        }

        //yield return SelectItems(items, positionsToSelect);
    }

    private static void CetNextSelection(ref int[] positionsToSelect)
    {
        for (var index = 0; index < positionsToSelect.Length; index++)
        {
            positionsToSelect[index] = positionsToSelect[index] == 1 ? 0 : 1;
            if (positionsToSelect[index] == 1)
            {
                break;
            }
        }
    }

    private static T[] SelectItems<T>(IEnumerable<T> items, int[] positionsToSelect)
    {
        return items
            .Where((_, index) => positionsToSelect[index] == 1)
            .ToArray();
    }
}

Measured memory_bytes: 32552