using System;
using System.Linq;
using System.Collections.Generic;
using System.IO;
using static System.Console;
using System.Numerics;
using System.Text.RegularExpressions;
using System.Runtime.Serialization.Formatters.Binary;

namespace atcorder2
{
    [Serializable]
    static class  Program
    {
        public static long Read()
        {
            return long.Parse(Console.ReadLine());
        }

        public static long[] Reads()
        {
            return Console.ReadLine().Split().Select(long.Parse).ToArray();
        }


        public static long Gcd(long x,long y)
        {
            if (x < y) Gcd(y, x);
            while (y > 0)
            {
                var z = x;
                x = y;
                y = z % y;
            }
            return x;
        }

        public static long Lcm(long x,long y)
        {
            return x * y / Lcm(x, y);
        }

        public static bool IsLowercaseAlphabet(char target)
        {
            return new Regex("^[a-z]+$").IsMatch(target.ToString());
        }

        public static T DeepCopy<T>(this T src)
        {
            using (var memoryStream = new MemoryStream())
            {
                var binaryFormatter = new BinaryFormatter();
                binaryFormatter.Serialize(memoryStream, src);
                memoryStream.Seek(0, System.IO.SeekOrigin.Begin);
                return (T)binaryFormatter.Deserialize(memoryStream);
            }
        }


        static void Main(string[] args)
        {
            var sw = new StreamWriter(Console.OpenStandardOutput()) { AutoFlush = false };
            Console.SetOut(sw);

            
            var q = Reads();
            var h = q[0];
            var w = q[1];
            var k = q[2];
            var c = new char[h][];
            for (int i = 0; i < h; i++)
            {
                c[i] = ReadLine().ToArray();
            }
            var bith = new long[h];
            var bitw = new long[w];
            for (int i = 0; i < h; i++)
            {
                bith[i] = (long)Math.Pow(2, i);
            }
            for (int i = 0; i < w; i++)
            {
                bitw[i] = (long)Math.Pow(2, i);
            }
            long ans = 0;
            for (int i = 0; i < (long)Math.Pow(2,h); i++)
            {
                for (int j = 0; j < (long)Math.Pow(2,w); j++)
                {
                    long count = 0;
                    var cc = c.DeepCopy();
                    
                    
                    
                   
                    for (int l = 0; l < h; l++)
                    {         
                        if ((i & bith[l]) != 0)
                        {
                            for (int m = 0; m < w; m++)
                            {
                                cc[l][m] = 'r';
                            }
                        }
                    }
                    for (int l = 0; l < w; l++)
                    {
                        if ((j & bitw[l]) != 0)
                        {
                            for (int m = 0; m < h; m++)
                            {
                                cc[m][l] = 'r';
                            }
                        }
                    }
                    for (int l = 0; l < h; l++)
                    {
                        for (int m = 0; m <w; m++)
                        {
                            if (cc[l][m] == '#') count++;
                        }
                    }
                    
                    if (count == k) ans++;
                }
            }
            WriteLine(ans);

           


            Console.Out.Flush();
        }
    }
}



Measured memory_bytes: 24828