#include <stdio.h>
#include <algorithm>
#include <assert.h>
#include <cmath>
#include <deque>
#include <iostream>
#include <limits.h>
#include<functional>
#include <map>
#include <math.h>
#include <queue>
#include <set>
#include <stdlib.h>
#include <string.h>
#include <string>
#include <unordered_map>
#include <unordered_set>
#include <vector>
#include <stack>
#include <deque>
#include <tuple>
#include <float.h>
#include<time.h>

#define MOD 1000000007;
#define LL long long
#define pLL pair<LL,LL>
#define mp make_pair
#define mt make_tuple
#define pq priority_queue<LL>
#define pqg priority_queue<LL,vector<LL>,greater<LL>>
#define vecLL vector<LL>
#define vecpLL vector<pLL>
#define vecbL vector<bool>
#define mat vector<vecLL>
#define endl "\n"
#define REP(e,v) for(auto e:v)
#define rep(i, a, n) for(LL i = a; i < n;i++)
#define Arep(i, a, n) for(i = a; i < n;i++)

#define INF LLONG_MAX/2
#define DINF DBL_MAX/2
using namespace std;


/*↓マイライブラリ↓*/

//clock_t start = clock();
//
//clock_t end = clock();
//
//const double time = static_cast<double>(end - start) / CLOCKS_PER_SEC * 1000.0;
//printf("time %lf[ms]\n", time);

LL linp(){
	LL x;
	scanf("%lld",&x);
	return x;
}
template<typename T>
T numperm(T x,T y){
	LL res = 1;
	for(LL i = x; i >= y; i--){
		res = res * i;
	}
	return res;
}

LL pow(LL x,LL y){

	if(y == 1){
		return x;
	}
	LL res = pow(x*x,y/2);
	if(y % 2 == 0){
		return res;
	}
	else{
		return x*res;
	}
}

 template <LL mod>
 struct ModLL {
     LL x;
     LL y = 100;
     ModLL() : x(0) {}
     ModLL(LL x_) {
         if ((x = x_ % mod + mod) >= mod) x -= mod;
     }
     ModLL& operator+=(ModLL rhs) {
         if ((x += rhs.x) >= mod) x -= mod;
         return *this;
     }

     ModLL& operator-=(ModLL rhs) {
         if ((x -= rhs.x) < 0) x += mod;
         return *this;
     }
     ModLL& operator*=(ModLL rhs) {
         x = (unsigned long long)x * rhs.x % mod;
         return *this;
     }
     ModLL& operator/=(ModLL rhs) {
         x = (unsigned long long)x * rhs.inv().x % mod;
         return *this;
     }

     ModLL operator-() const { return -x < 0 ? mod - x : -x; }
     ModLL operator+(ModLL rhs) const { return ModLL(*this) += rhs; }
     ModLL operator-(ModLL rhs) const { return ModLL(*this) -= rhs; }
     ModLL operator*(ModLL rhs) const { return ModLL(*this) *= rhs; }
     ModLL operator/(ModLL rhs) const { return ModLL(*this) /= rhs; }
     bool operator==(ModLL rhs) const { return x == rhs.x; }
     bool operator!=(ModLL rhs) const { return x != rhs.x; }
     ModLL inv() const { return pow(*this, mod - 2); }

     friend ostream& operator<<(ostream& s, ModLL<mod> a) {
         s << a.x;
         return s;
     }
     friend istream& operator>>(istream& s, ModLL<mod>& a) {
         s >> a.x;
         return s;
     }
 };

#define mLL ModLL<1000000007>
#define mvec vector<mLL>

 template<typename T>
 struct SquareMatrix{

     vector<vector<T>> dat;
     size_t N;
     SquareMatrix() = default;
     SquareMatrix(size_t N, T val = T()):N(N){
         dat = vector<vector<T>> (N, vector<T> (N));
         for(size_t i=0;i<N;i++)
             for(size_t j=0;j<N;j++)
                 dat[i][j]=val;
     }
     SquareMatrix& operator=(const SquareMatrix& a){
         dat=a.dat;
         return (*this);
     }
     bool operator==(const SquareMatrix& a) const{
         return dat==a.dat;
     }

     size_t size() const{return N;};
     vector<T>& operator[](size_t k){return dat[k];};
     const vector<T>& operator[](size_t k) const {return dat[k];};

     SquareMatrix operator*(const SquareMatrix &B) const{
         SquareMatrix res(N, 0);
         for(size_t i=0;i<N;i++)
             for(size_t j=0;j<N;j++)
                 for(size_t k=0;k<N;k++)
                     res[i][j]=res[i][j]+(dat[i][k]*B[k][j]);
         return res;
     }

     SquareMatrix operator+(const SquareMatrix &B) const{
         SquareMatrix res(N, 0);
         for(size_t i=0;i<N;i++)
             for(size_t j=0;j<N;j++)
                 res[i][j]=dat[i][j]+B[i][j];
         return res;
     }

     SquareMatrix operator-(const SquareMatrix &B) const{
              SquareMatrix res(N, 0);
              for(size_t i=0;i<N;i++)
                  for(size_t j=0;j<N;j++)
                      res[i][j]=dat[i][j]-B[i][j];
              return res;
          }

     SquareMatrix pow(long long n) const{
         SquareMatrix a=*this;
         SquareMatrix res(N, 0);
         for(size_t i = 0; i < N; i++) res[i][i] = 1;
         while(n){
             if(n&1) res=res*a;
             a=a*a;
             n>>=1;
         }
         return res;
     }
 };

#define mmat SquareMatrix<mLL>


vecLL bit(LL i,LL N){
	vecLL biti(N);

	rep(x,0,N){
		biti[N - 1 - x] = (i >> x) & 1;
	}

	return biti;
}
template<typename T>
void swap(T &a, T &b){
	T t = a;
	a = b;
	b = t;

	return ;
}

LL digit(LL x,LL n){
	LL count = 1;

	while(x >= n){
		x = x/n;
		count++;
	}
	return count;
}

LL gcd(LL i,LL j){
	if(j != 0)
		return gcd(j, i % j);
	else
		return i;
}

bool isPrime(LL X){
	for(LL i = 2; i*i <= X;i++){
		if(X % i == 0){
			return false;
		}
	}
	return true;
}

vecLL Eratosthenes(LL n){//素数のベクトルを返す

	 bool isPrime[n];
	 fill(isPrime,isPrime+n,true);

	 isPrime[0] = isPrime[1] = false;
	 for(LL i = 2; i*i <= n;i++){
		 if(isPrime[i]){
			 for(LL j = 2*i ;j <= n ; j += i){
				 isPrime[j] = false;
			 }
		 }
	 }

	 vecLL P;

	 rep(i,2,n+1){
		 if(isPrime[i]){
			 P.push_back(i);
		 }
	 }

	 return P;
}

 map<LL,LL> factalization(LL N){
 	map<LL,LL> fac;
 	LL oriN = N;
 	LL div = 1;
 	for(LL i = 2;i*i <= N;++i){
 		while(N%i == 0){
 			fac[i]++;
 			div *= i;
 			N /= i;
 		}
 	}
 	if(oriN/div != 1){
 		fac[oriN/div]++;
 	}
 	return fac;
 }

 struct edge {//枝
	LL to,cost;
	double dcost;//コストが整数でない場合に使う
} ;


struct vertex{//頂点(枝付き)
	LL key;
	double dkey;//キーが整数でない場合に使う
	vector<edge> edges;//頂点から伸びる枝
};

class Graph{

public:

	LL V;//頂点数
	vertex* vertices;//グラフ


	Graph(LL v){//頂点数を指定してグラフの初期化
		V = v;//頂点数
		vertices = new vertex[V];//頂点集合

		rep(i,0,V){
			vertices[i].key = -1;//キー初期値は-1
			vertices[i].dkey = -1;//キー初期値は-1
		}

	}

	void setDE(LL i,LL j,LL cos){//i→jにコストcosの有向枝を加える

			edge e;
			e.to= j;
			e.cost = cos;

			vertices[i].edges.push_back(e);

			return;
	}

	void setDE(LL i,LL j,double dcos){//i→jにコストcosの有向枝を加える

				edge e;
				e.to= j;
				e.dcost = dcos;

				vertices[i].edges.push_back(e);

				return;
	}

	void setUDE(LL i,LL j,LL cos){//(i,j)にコストcosの無向枝を加える

		edge ei,ej;
		ei.to = j;
		ej.to = i;
		ei.cost = ej.cost = cos;

		vertices[i].edges.push_back(ei);
		vertices[j].edges.push_back(ej);

		return;
	}

	void setUDE(LL i,LL j,double dcos){//(i,j)にコストcosの無向枝を加える

		edge ei,ej;
		ei.to = j;
		ej.to = i;
		ei.dcost = ej.dcost = dcos;

		vertices[i].edges.push_back(ei);
		vertices[j].edges.push_back(ej);

		return;
	}

	void setKey(LL i,LL newKey){//キー変更
		vertices[i].key = newKey;
	}

	void setKey(LL i,double newKey){//キー変更
		vertices[i].key = newKey;
	}

	 edge getEdge(LL i,LL j){

		 rep(a,0,vertices[i].edges.size()){
			 if(vertices[i].edges[a].to == j){
				 return vertices[i].edges[a];
			 }
		 }

		 return (edge){j,INF,DINF};//なければ,コストINFの枝を返す
	}

	void bellman_ford(LL s,LL b[]){
		 fill(b,b+V,INF);

		 b[s] = 0;


		 while(true){

			 bool update = false;
			 rep(i,0,V){
				rep(j,0,vertices[i].edges.size()){
					edge e = vertices[i].edges[j];

					if(b[e.to] > b[i] + e.cost){
						b[e.to] = b[i] + e.cost;
						update = true;
					}

				}
			}
			if(!update)
				break;
		 }

		 return;
	}

	void dijkstra(LL s, LL d[]) {//ダイクストラ(始点を入力とし、各点への最小距離を返す)

	    priority_queue<pLL, vector<pLL>, greater<pLL> > que;

	    fill(d,d+V,INF);
	    d[s] = 0;
	    que.push(pLL(0, s));

	    while (!que.empty()) {
	        pLL p = que.top();
	        que.pop();
	        LL v = p.second;
	        if (d[v] < p.first) continue;

	        rep(i,0, vertices[v].edges.size()) {
	            edge e = vertices[v].edges[i];
	            if (d[e.to] > d[v] + e.cost) {
	                d[e.to] = d[v] + e.cost;
	                que.push(pLL(d[e.to], e.to));
	            }
	        }
	    }

	    return;

	}

	void warshall_floyd(LL **w){

		rep(i,0,V){
					rep(j,0,V){
						w[i][j] = INF;
					}
		}
		rep(i,0,V){
			rep(j,0,vertices[i].edges.size()){
				w[i][vertices[i].edges[j].to] = vertices[i].edges[j].cost;
			}
		}

		rep(i,0,V){
				w[i][i] = 0;
		}

		rep(i,0,V){
			rep(j,0,V){
				rep(k,0,V){
					w[i][j] = min(w[i][j],w[i][k]+w[k][j]);
				}
			}
		}

	}



};

class UF
{
public:
	LL N;
	LL* par;
	LL*  rank;

	UF(LL n){
		 N = n;

		 par = new LL[N];
		 rank = new LL[N];

		 rep(i,0,N){
			 par[i] = i;
			 rank[i] = i;
		 }

		 return;

	}

	LL root(LL x){
		if(x == par[x])
			return x;
		else
			return par[x] = root(par[x]);

	}

	bool same(LL x,LL y){
		return (root(x) == root(y));

	}

	void Union(LL x,LL y){
		LL rtx = root(x);
		LL rty = root(y);

		if(rank[rtx] < rank[rty]){
			par[rtx] = rty;
		}
		else{
			par[rty] = rtx;
			if(rank[rtx] == rank[rty]){
				rank[rtx]++;
			}
		}

	}

};

template<typename T>
class ST{

public:
	vector<T> value;
	LL N;
	T init;
	T (*fn)(T,T);

	ST(LL N_,T init_,T (*fn_)(T,T)){
		LL n = 1;
		while(n < N_){
			n *= 2;
		}
		N = n;
		init = init_;

		value = vector<T>(2*N-1,init);
		fn = fn_;
		cout << N;
	}

	void insert(LL i,T x){
		i += N - 1;
		value[i] = x;

		while(i > 0){
			i = (i - 1)/2;
			value[i] = fn(value[2*i+1],value[2*i+2]);
		}

	}


	T calc_(LL a,LL b,LL i,LL l,LL r){//半開区間[a,b)
		if(a <= l && r <= b){
			return value[i];
		}
		else if(r <= a || b <= l){
			return init;
		}else{
			return fn(calc_(a,b,2*i+1,l,(l + r)/2),calc_(a,b,2*i+2,(l + r)/2,r));
		}
	}

	T calc(LL a,LL b){
		return calc_(a,b,0,0,N);
	}
};

/*↑マイライブラリ↑*/

LL solveA(){
	LL a;

	cin >> a;

	LL x = 0;
	while(x < a){
		x += 1000;
	}

	cout << x - a;

	return 0;
}

LL solveB(){
	LL N;

	cin >> N;

	map<string,LL> S;
	rep(i,0,N){
		string s;
		cin >> s;
		S[s]++;
	}

	cout << "AC x " << S["AC"] << endl;
	cout << "WA x " << S["WA"] << endl;
	cout << "TLE x " << S["TLE"] << endl;
	cout << "RE x " << S["RE"] << endl;

	return 0;
}

LL solveC(){

	LL H,W,K;

	cin >> H >> W >> K;

	char c[H][W];
	char c2[H][W];

	rep(i,0,H){
		rep(j,0,W){
			cin >> c[i][j];
		}
	}

	LL ans = 0;

	rep(i,0,pow(2,H)){


//		rep(I,0,H){
//			rep(J,0,W){
//				cout << cc[I][J];
//			}
//			cout << endl;
//		}



		vecLL biti = bit(i,H);

		rep(j,0,pow(2,W)){

			LL count = 0;

			rep(a,0,H){
				rep(b,0,W){
					c2[a][b] = c[a][b];
				}
			}

			vecLL bitj = bit(j,W);



			rep(i2,0,H){
				if(biti[i2] == 1){
					rep(j3,0,W){
						c2[i2][j3] = 'a';
					}
				}
			}

			rep(j2,0,W){
				if(bitj[j2] == 1){
					rep(i3,0,H){
						c2[i3][j2] = 'a';
					}
				}
			}

			rep(A,0,H){
				rep(B,0,W){
					if(c2[A][B] == '#'){
						count++;
					}
				}
			}

			if(count == K){

				ans++;
			}
		}


	}

	cout << ans;
 	return 0;
}

LL solveD(){

	return 0;
}

LL solveE(){

	return 0;
}

LL solveF(){

	return 0;
}

signed main(){
	//solveA();
	//solveB();
	solveC();
	//solveD();
	//solveE();
	//solveF();
	return 0;
}



Measured memory_bytes: 4064