#include<bits/stdc++.h>

#define rep(i,n) for(int i=0;i<(int)n;i++)
#define all(c) (c).begin(),(c).end()
#define mp make_pair
#define pb push_back
#define each(i,c) for(__typeof((c).begin()) i=(c).begin();i!=(c).end();i++)
#define dbg(x) cerr<<__LINE__<<": "<<#x<<" = "<<(x)<<endl

using namespace std;

typedef long long ll;
typedef vector<int> vi;
typedef pair<int,int> pi;
const int inf = (int)1e9;
const double INF = 1e12, EPS = 1e-9;

template<class T>struct costflowGraph{
	typedef pair<T, int> P;
	struct edge{
		int to, cap, rev;
		T cost;
		edge(int to, int cap, T cost, int rev) :
			to(to), cap(cap), cost(cost), rev(rev){
			}
	};
	
	int n, *prevv, *preve;
	T *dist;
	vector<vector<edge> > G;
	
	costflowGraph(int sz) : n(sz){
		G.resize(n);
		dist = new T[n];
		prevv = new int[n]; preve = new int[n];
	}
	~costflowGraph(){
		delete dist;
		delete prevv; delete preve;
	}
	
	void add(int s, int t, int cap, T cost){
		G[s].pb(edge(t, cap, cost, G[t].size()));
		G[t].pb(edge(s, 0, -cost, G[s].size() - 1));
	}
	pi min_cost_flow(int s, int t){
		T res = 0;
		int f = 0;
		while(1){
			fill(dist, dist + n, inf);
			dist[s] = 0;
			while(1){
				bool update = 0;
				rep(v, n){
					if(dist[v] == inf) continue;
					rep(i, G[v].size()){
						edge &e = G[v][i];
						if(e.cap > 0 && dist[e.to] > dist[v] + e.cost + EPS){
							dist[e.to] = dist[v] + e.cost;
							prevv[e.to] = v;
							preve[e.to] = i;
							update = 1;
						}
					}
				}
				if(!update) break;
			}
			if(dist[t] == inf) return mp(f, res);
		
			int d = inf;
			for(int v = t; v != s; v = prevv[v]) d = min(d, G[prevv[v]][preve[v]].cap);
			f += d;
			res += d * dist[t];
			for(int v = t; v != s; v = prevv[v]){
				edge &e = G[prevv[v]][preve[v]];
				e.cap -= d;
				G[v][e.rev].cap += d;
			}
			assert(d > 0);
		}
	}
};

int cost[500][500];

int main(){
	int n, m, k; cin >> n >> m >> k;
	rep(i, n){
		string s; cin >> s;
		rep(j, m) if(s[j] == '1') cost[i][j + n]++;
	}
	rep(i, m){
		string s; cin >> s;
		rep(j, n) if(s[j] == '1') cost[j][i + n]++;
	}
	
	costflowGraph<int> g(n + m + 2);
	rep(i, n) rep(j, m) if(cost[i][j + n] < 2) g.add(i, j + n, 1, cost[i][j + n]);
	rep(i, n) g.add(n + m, i, 1, 0);
	rep(i, m) g.add(i + n, n + m + 1, 1, 0);
	
	pi res = g.min_cost_flow(n + m, n + m + 1);
	
	//cerr<<res.first<<" "<<res.second<<endl;
	
	int ans = res.first;
	if(res.second < k) ans = min(min(n, m), ans + (k - res.second) / 2);
	else ans = max(0, ans - (res.second - k));
	
	cout << ans << endl;
	
	return 0;
}