//////////////////////////////////////
////   Author: ABHINASH GIRI      ////
/////////////////////////////////////

#pragma GCC target ("avx2")
#pragma GCC optimization ("O3")
#pragma GCC optimization ("unroll-loops")
#pragma GCC target ("sse4")

#include<bits/stdc++.h>
using namespace std;
#define fast ios_base::sync_with_stdio(false); cin.tie(nullptr); cout.tie(nullptr)
#define PI (2*acos(0.0))
#define setbits(x)      __builtin_popcountll(x)
#define zrobits(x)      __builtin_ctzll(x)
#define pos_rt_stbt(x)   (__builtin_ffsll(x))   // return position of rightmost set bit ( 1 indexing ) pos_rt_stbt(10) = 2 ( 1010 )
#define ps(x,y)         fixed<<setprecision(y)<<x
#define w(x)            int t; cin>>t; while(t--)
#define nl "\n"
#define all(v) (v).begin(),(v).end()
#define clr(v) memset(v,0,sizeof(v));
#define sqr(x) ((x) * (x))
typedef long long ll;
typedef unsigned long long int ull;
typedef vector<int> vi;
typedef vector<long long int> vll;
typedef vector<vll> vvll;
typedef vector<unsigned long long int> vull;
typedef vector<string> vs;
typedef vector<double> vd;
typedef pair<ll, ll> pll;
typedef vector<pair<ll, ll>> vpll;
typedef vector<pair<string, string>> vpss;

//***********************************************************************************************

//CONSTANTS
const long long int inf = 1e18;
const long long int ninf = -1e18;
const long long int mod =998244353 ;
const long long int MOD =  1000000007;
//***********************************************************************************************

//Debug code

#define debug1(x)                   cout<<#x<<"="<<x<<'\n'
#define debug2(x,y)                 cout<<#x<<"="<<x<<","<<#y<<"="<<y<<'\n'
#define debug3(x,y,z)               cout<<#x<<"="<<x<<","<<#y<<"="<<y<<","<<#z<<"="<<z<<'\n'
#define debug4(p,q,r,s)               cout<<#p<<"="<<p<<","<<#q<<"="<<q<<","<<#r<<"="<<r<<","<<#s<<"="<<s<<'\n'

//***********************************************************************************************
// Printing
#define ptvs(v) for(auto &item :v) cout<<item<<" ";cout<<"\n";
#define ptp(v) for(auto &item :v) cout<<item.first<<" ----> "<<item.second<<"  "; cout<<"\n"
#define ptv(v) for(auto &item :v) cout<<item<<"\n"
#define ptb(ans) cout<<(ans?"YES\n":"NO\n")
#define pt(x) cout<<((x))<<"\n";
#define pts(x,y) cout<<x<<" "<<y<<"\n";

//Take input
#define get1(a) ll a;cin>>a
#define get2(a,b) ll a,b;cin>>a>>b
#define get3(a,b,c) ll a,b,c;cin>>a>>b>>c
#define get4(a,b,c,d) ll a,b,c,d;cin>>a>>b>>c
#define cinll(i) ll i=0;cin>>i
#define cins(s) string s;cin>>s
#define cinvll(v,start,end) vll v(end+1);for(auto i=start;i<=end;i++) {cin>>v[i];}

//***********************************************************************************************
//Sorting Comparators

// sorts in ascending order on first and on second ( if first equals)
template <typename T>
bool static asc(pair<T, T>&a, pair<T, T>&b)
{
    if (a.first == b.first)
    {return a.second > b.second;}
    return a.first < b.first;
}

template <typename T>
bool static temp(pair<T, T>&a, pair<T, T>&b)
{
    if (a.second == b.second)
    {return a.first > b.first;}
    return a.second < b.second;
}
// sorts in descending order on first and on second ( if first equals)
template <typename T>
bool desc(pair<T, T>&a, pair<T, T>&b)
{
    if (a.first == b.first)
    {return a.second > b.second;}
    return a.first > b.first;
}

//***********************************************************************************************

// Fast Exponentiation power(a,b) ==> a to the power b
template <typename T>
T  power(T  a, T  b) {
    if (b == 0)
        return 1;
    if (b == 1)
        return a;
    else {
        T  res = (power(a, b / 2));
        if (b % 2)
        {
            return (res * res * a);
        }
        else
        {return res * res;}
    }
}

// Fast Modular Exponentiation  power(a,b,m) ==> (a to the power b) modulo m
template <typename T>
T  power(T  a, T  b, T modulo)
{
    if (b == 0)
        return 1;
    if (b == 1)
        return a;
    else {
        T  res = (power(a, b / 2, modulo) % modulo);
        if (b % 2)
        {
            return ((((res % modulo) * (res % modulo)) % modulo) * (a % modulo)) % modulo;
        }
        else
        {return ((res % modulo) * (res % modulo)) % modulo;}
    }
}
// G C D
template <typename T>
T  gcd(T  a, T  b) {
    if (b == 0)
    {return a;}
    return gcd(b, a % b);
}
// L C M
template <typename T>
T lcm(T p, T q)
{return (p * q) / gcd<T>(p, q);}

//Prime factorisation
template <typename T>
void primefactorise(T n, vector<T>&vec)
{
    while (n % 2 == 0) {
        vec.emplace_back(2);
        n = n / 2;
    }
    // n must be odd at this point.  So we can skip
    // one element (Note i = i +2)
    for (int i = 3; i <= sqrt(n); i = i + 2) {
        // While i divides n, print i and divide n
        while (n % i == 0)
        {
            vec.emplace_back(i);
            n = n / i;
        }
    }
    // This condition is to handle the case when n
    // is a prime number greater than 2
    if (n > 2)
    {
        vec.emplace_back(n);
    }
}
// All factors of a number in O(sqrt(n))
template <typename T>
void all_factor(T n, vector<T>&vec)
{
    for (auto i = 1; i <= sqrt(n) ; ++i) {
        if (n % i == 0)
        {
//          Factors occurs in pairs
            vec.emplace_back(i);
            if(i!=(n/i))
            {
                vec.emplace_back(n / i);
            }

        }
    }
}

ll mulmod(ll a, ll b, ll c)
{

    if (b == 0)
    {

        return 0;
    }
    // Divide the problem into 2 parts
    ll s = mulmod(a, b / 2, c);

    // If b is odd, return
    // (a+(2*a)*((b-1)/2))%c
    if (b % 2 == 1)
    {   ll p = (a % c + 2 * (s % c)) % c;
        //cout<<" returned "<<p<<endl;
        return p;
    }
        // If b is even, return
        // ((2*a)*(b/2))%c
    else
    {   ll  p = (2 * (s % c)) % c;
        //cout<<" returned "<<p<<endl;
        return p ;
    }
}

ll mod_inv(ll a) {    return (power<ll>(a, mod - 2, mod)) % mod;    }

void factorial(vll fact,ll n)
{
    fact.resize(n + 1, 1);
    fact[0] = 1;
    fact[1] = 1;
    for (int i = 2; i <= 200002 ; ++i)
    {
        fact[i] = ((fact[i - 1] % mod) * (i % mod)) % mod;
        //cout<<" fact "<<i<<" "<<fact[i]<<nl;
    }
}

ll ncr(ll n, ll r,vll fact)
{
    return fact[n]%mod*mod_inv(fact[r])%mod*mod_inv(fact[n-r])%mod%mod%mod;
}

ll n,m,k;
ll tot=0;
char a[7][7];
bool chck(ll r,ll c)
{
    ll l=0;
    map<ll,ll>r1,c1;
    for (int i1 = 0; i1 <log2(r)+1 ; ++i1)
    {
        if(r&(1<<i1))
        {
            r1[i1]++;
        }
    }
    for (int i1 = 0; i1 <log2(c)+1 ; ++i1)
    {
        if(c&(1<<i1))
        {
            c1[i1]++;
        }
    }
//    pt(" selected ");
//   pt(" rows ");
//   for(auto &u:r1)
//   {
//       cout<<u.first<<" ";
//   }
//   cout<<nl;
//    pt(" cols ");
//    for(auto &u:c1)
//    {
//        cout<<u.first<<" ";
//    }
//    cout<<nl;

    for (int i = 0; i <n ; ++i)
    {
        for (int j = 0; j <m ; ++j)
        {
            if(r1[i] or c1[j])
            {
                continue;
            }
            if(a[i][j]=='#')
            {
                l++;
            }
        }
    }
    //debug1(l);
    return l==k;
}
int main()
{
    std::chrono::time_point<std::chrono::high_resolution_clock> start_timer, end_timer;
    start_timer = std::chrono::high_resolution_clock::now();
    bool show_time = false;  //  change it to true when needed;
    /* Building Block */
    fast;
    cin>>n>>m>>k;
    for (int i = 0; i <n ; ++i)
    {
        for (int j = 0; j <m ; ++j)
        {
            cin>>a[i][j];
            if(a[i][j]=='#')
            {
                tot++;
            }
        }
    }
    ll ans =0;
    for (ll row = 0; row <(1LL<<n) ; ++row)
    {
        for (int col = 0; col <(1LL<<m) ; ++col)
        {
            if(chck(row,col))
            {
                ans++;
            }
        }
    }
    pt(ans);
    end_timer = std::chrono::high_resolution_clock::now();
    ll elapsed_time = std::chrono::duration_cast<std::chrono::milliseconds>(end_timer - start_timer).count();
    if (show_time)
    {cout << "\nElapsed Time: " << elapsed_time << "ms\n";}

    return 0;
}






Measured memory_bytes: 3808