#include <bits/stdc++.h>

using namespace std;

#define pb push_back

#define fi first

#define se second

#define debug(x) cerr<<#x << " := " << x << endl;

#define bug cerr<<"-----------------------"<<endl;

#define FOR(a, b, c) for(int a = b; a <= c; ++ a)

 

typedef long long ll;

typedef long double ld;

typedef pair<int, int> pii;

typedef pair<ll, ll> pll;

 

 

template<class T> void _R(T &x) { cin >> x; }

void _R(int &x) { scanf("%d", &x); }

void _R(ll &x) { scanf("%lld", &x); }

void _R(double &x) { scanf("%lf", &x); }

void _R(char &x) { scanf(" %c", &x); }

void _R(char *x) { scanf("%s", x); }

void R() {}

template<class T, class... U> void R(T &head, U &... tail) { _R(head); R(tail...); }

 

 

template<typename T>

inline T read(T&x){

    x=;int f=;char ch=getchar();

    while (ch<''||ch>'') f|=(ch=='-'),ch=getchar();

    while (ch>=''&&ch<='') x=x*+ch-'',ch=getchar();

    return x=f?-x:x;

}

 

const int inf = 0x3f3f3f3f;

 

const int mod = 1e9+;

 

/**********showtime************/

            const int maxn = ;

 

        //    vector<int>mp[maxn];

 

            int n,m,k;

            int getid(int x, int i) {

                return (x - ) * k + i + ;

            }

 

            struct E{

                int u,v;

                int nxt;

            }edge[maxn];

 

            int gtot = , head[maxn];

 

            void addedge(int u, int v) {

                edge[gtot].u = u;

                edge[gtot].v = v;

                edge[gtot].nxt = head[u];

                head[u] = gtot++;

            }

 

            set <int> dpmp[maxn];

 

            char str[];

            int dp[maxn],a[maxn];

            int belong[maxn], dfn[maxn] , low[maxn];

 

            bool vis[maxn];

            bool flag[maxn];

          //  int used[maxn];

 

            int tim, scc_cnt;

 

            //stack<int>st;

            queue<int>que;

            int st[];

            int top = ;

            inline void dfs(int u) {

                dfn[u] = low[u] = ++tim;

 

//                st.push(u);

                st[++top] = u;

                for(int i=head[u]; ~i; i=edge[i].nxt){

                    int v = edge[i].v;

                    if(!dfn[v]) dfs(v);

                    if(!belong[v]) low[u] = min(low[u], low[v]);

                }

 

                if(dfn[u] == low[u]) {

                    scc_cnt++;

                    int now;

                    while(true) {

                        now = st[top]; top--;

                        belong[now] = scc_cnt;

                        if(flag[now]) {

                            int id = (now - ) / k + ;

                            if(vis[id] == ) {

                                que.push(id);

                                vis[id] = ;

                                a[scc_cnt]++;

                            }

                        }

                        if(now == u) break;

                    }

                    while(!que.empty()) {

                        int u = que.front(); que.pop();

                        vis[u] = ;

                    }

                }

            }

 

            int ans = ;

            void cal(int s) {

                queue<int>que;

                dp[s] = a[s];

                que.push(s);

                ans = max(ans, a[s]);

 

                while(!que.empty()) {

                    int u = que.front(); que.pop();

                    vis[u] = ;

                    for(int v : dpmp[u]) {

                        dp[v] = max(dp[v], dp[u] + a[v]);

                        ans = max(ans, dp[v]);

                        if(vis[v] == ) {

                            vis[v] = ;

                            que.push(v);

                        }

                    }

                }

            }

int main(){

            memset(head, -, sizeof(head));

            R(n, m, k);

            for(int i=; i<=m; i++) {

                int u,v;

                scanf("%d%d", &u, &v);

                for(int j=; j<k; j++) {

                    addedge(getid(u, j), getid(v, (j+)%k));

                }

            }

 

            for(int i=; i<=n; i++) {

                scanf("%s", str);

                for(int j=; j<k; j++) {

                    flag[getid(i, j)] = (str[j] == '');

                }

            }

 

            for(int i=; i<=n; i++){

                for(int j=; j<k; j++)

                    if(!dfn[getid(i, j)]) dfs(getid(i, j));

            }

 

            for(int i=; i<gtot; i++){

                        int u = edge[i].u, v = edge[i].v;

                        if(belong[u] == belong[v]) continue;

                        dpmp[belong[u]].insert(belong[v]);

            }

 

            cal(belong[getid(, )]);

 

            printf("%d\n", ans);

            return ;

}