#include <iostream>
#include <cstdio>
#include <string>
#include <vector>
#include <map>
#include <set>
#include <algorithm>
using namespace std;

void debug(const vector<string>& v){
	for(int y=0 ; y < v.size() ; y++ ){
		cout << v[y] << endl;
	}
	cout << endl;
}

string to_b(char c){
	int n;
	if( 'A' <= c && c <= 'Z' ){
		n = c - 'A';
	}else if( 'a' <= c && c <= 'z' ){
		n = c - 'a' + 26;
	}else if( '0' <= c && c <= '9' ){
		n = c - '0' + 52;
	}else if( c == '+' ){
		n = 62;
	}else if( c == '/' ){
		n = 63;
	}
	string s;
	for(int i=0; i < 6 ; i++ ){
		s.push_back( (n & 1) + '0' );
		n = (n >> 1);
	};
	reverse(s.begin(), s.end());
	return s;
}

typedef unsigned long long ull;
const ull B = 100000007;
// hash[y][x] := image[y][x] から p 文字のハッシュ値が返ってくる.
ull H[1001][1001] = {0};
// b[i] := b^i;
ull b[101];
// memo[y][x] := (x,y) でマッチしたかどうか
bool memo[1001][1001];

// 任意のx,y (x = 0..w-1, y = 0..h-1)について
// image[y][x] から p 文字のハッシュ値をあらかじめ計算する
void hash(const vector<string>& s, int p){
	int h = s.size(), w = s[0].size();
	
	for(int y=0 ; y < h ; y++ ){
		for(int x=0 ; x + p <= w ; x++ ){
			H[y][x] = 0;
			if( x == 0 ){
				for(int k=0 ; k < p ; k++ ){
					H[y][x] += (s[y][x+k]-'0') * b[p-k-1];
				}
			}else{
				H[y][x] = H[y][x-1] * B - ((s[y][x-1]-'0') * b[p]) + (s[y][x+p-1]-'0');
			}
		}
	}
}

// s(w*h) から t (p*p) のパターンを検索する
int search(const vector<string>& s, const vector<string>& t){
	int h1 = s.size(), w1 = s[0].size(), h2 = t.size(), w2 = t[0].size();
	
	// 先に t[y] から p 文字(p == w2)のハッシュ値を計算しておく
	vector<ull> T(h2, 0);
	for(int y=0 ; y < h2 ; y++ ){
		for(int x=0 ; x < w2 ; x++ ){
			T[y] += (t[y][x]-'0') * b[w2-x-1];
		}
	}
	
	int res = 0;
	for(int py = 0 ; py + h2 <= h1 ; py++ ){
		for(int px = 0 ; px + w2 <= w1 ; px++ ){
			bool flag = true;
			for(int y = 0 ; y < h2 ; y++ ){
				if( H[py+y][px] != T[y] ){
					flag = false;
					break;
				}
			}
			if( flag && !memo[py][px] ){
				memo[py][px] = true;
				res++;
			}
		}
	}
	return res;
}

// 左右反転
vector<string> flip_right_left(const vector<string>& m_ ){
	vector<string> m = m_;
	int h = m.size(), w = m[0].size();
	for(int y = 0 ; y < h ; y++ ){
		for(int x = 0 ; x < w/2 ; x++ ){
			swap( m[y][x] , m[y][w-x-1] );
		}
	}
	return m;
}
// 右に 90 度回転
vector<string> right_rot(const vector<string>& m_ ){
	int w = m_[0].size(), h = m_.size();
	vector<string> m( w );
	for(int y = h-1 ; y >= 0 ; y-- ){
		for(int x = 0 ; x < w ; x++ ){
			m[x].push_back( m_[y][x] );
		}
	}
	return m;
}
// 反転と90度回転 2*4 = 8 パターンの生成
vector< vector<string> > generate_pattern(vector<string> p){
	set< vector<string> > s;
	vector< vector<string> > res;
	
	for(int i=0 ; i < 4 ; i++ ){
		s.insert( p );
		p = right_rot( p );
	}
	p = flip_right_left( p );
	for(int i=0 ; i < 4 ; i++ ){
		s.insert( p );
		p = right_rot( p );
	}
	for(set< vector<string> >::iterator it = s.begin() ; it != s.end() ; ++it ){
		res.push_back( *it );
	}
	return res;
}

// 0 or 1 のbit列に展開して w * h に切り出して返す
vector<string> decode(const vector<string>& v, int w, int h){
	vector<string> res(h), v_(h);
	for(int y=0 ; y < h ; y++ ){
		for(int x=0 ; x < v[y].size() ; x++ ){
			v_[y] += to_b( v[y][x] );
		}
	}
	for(int y=0 ; y < h ; y++ ){
		for(int x=0 ; x < w ; x++ ){
			res[y].push_back( v_[y][x] );
		}
	}
	return res;
}

int main(){
	// B^0 .. B^100 を先に計算しておく
	b[0] = 1;
	for(int i=1 ; i < 101 ; i++ ){
		b[i] = b[i-1] * B;
	}
	
	int w, h, p;
	while( cin >> w >> h >> p , w || h || p ){
		for(int y=0 ; y < 1001 ; y++ ) fill(memo[y], memo[y]+1001, false);
		vector<string> image(h), pattern(p);
		
		for(int y=0 ; y < h ; y++ ){
			cin >> image[y];
		}
		for(int y=0 ; y < p ; y++ ){
			cin >> pattern[y];
		}
		image = decode(image, w, h);
		pattern = decode(pattern, p, p);
		
		// あらかじめハッシュ値を計算
		hash(image, p);
		// 回転・左右反転の8パターンを生成
		vector< vector<string> > p = generate_pattern( pattern );
		// 探索
		int ans = 0;
		for(int i=0 ; i < p.size() ; i++ ){
			ans += search(image, p[i]);
		}
		// 解を出力
		cout << ans << endl;
	}
}

Measured memory_bytes: 12788