#include <bits/stdc++.h>
using namespace std;

#define all(x) begin(x), end(x)
#ifdef CKISEKI
#define safe cerr << __PRETTY_FUNCTION__ << " line " << __LINE__ << " safe\n"
#define debug(a...) debug_(#a, a)
#define orange(a...) orange_(#a, a)
#include <experimental/iterator>
void debug_(auto s, auto ...a) {
  cerr << "\e[1;32m(" << s << ") = (";
  int f = 0;
  (..., (cerr << (f++ ? ", " : "") << a));
  cerr << ")\e[0m\n";
}
void orange_(auto s, auto L, auto R) {
  cerr << "\e[1;33m[ " << s << " ] = [ ";
  using namespace experimental;
  copy(L, R, make_ostream_joiner(cerr, ", "));
  cerr << " ]\e[0m\n";
}
#else
#define safe ((void)0)
#define debug(...) safe
#define orange(...) safe
#endif

using lld = int64_t;
const int mod = 1000000007;
int add(int a, int b) {
  return a + b >= mod ? a + b - mod : a + b;
}
int sub(int a, int b) {
  return a - b < 0 ? a - b + mod : a - b;
}
void addeq(int &x, int v) {
  x = add(x, v);
}
void subeq(int &x, int v) {
  x = sub(x, v);
}
int mul(lld a, lld b) {
  return static_cast<int>(a * b % mod);
}
int modpow(int e, int p) {
  int r = 1;
  while (p) {
    if (p & 1) r = mul(r, e);
    e = mul(e, e);
    p >>= 1;
  }
  return r;
}
int modinv(int x) {
  return modpow(x, mod - 2);
}

#define rep(x, y, z) for (int x=y; x < z; x++)
using VI = vector<int>;
using VVI = vector<VI>;
void Hessenberg(VVI &H, int N) {
  for (int i = 0; i < N - 2; ++i) {
    for (int j = i + 1; j < N; ++j) if (H[j][i]) {
      rep(k, i, N) swap(H[i + 1][k], H[j][k]);
      rep(k, 0, N) swap(H[k][i+1], H[k][j]);
      break;
    }
    if (!H[i + 1][i]) continue;
    for (int j = i + 2; j < N; ++j) {
      int co = mul(modinv(H[i + 1][i]), H[j][i]);
      rep(k, i, N) subeq(H[j][k], mul(H[i+1][k], co));
      rep(k, 0, N) addeq(H[k][i+1], mul(H[k][j], co));
    }
  }
}
VI CharacteristicPoly(VVI &A) {
  int N = (int)A.size(); Hessenberg(A, N);
  VVI P(N + 1, VI(N + 1)); P[0][0] = 1;
  for (int i = 1; i <= N; ++i) {
    rep(j, 0, i+1) P[i][j] = j ? P[i-1][j-1] : 0;
    for (int j = i - 1, val = 1; j >= 0; --j) {
      int co = mul(val, A[j][i - 1]);
      rep(k, 0, j+1) subeq(P[i][k], mul(P[j][k], co));
      if (j) val = mul(val, A[j][j - 1]);
    }
  }
  if (N & 1) for (int &x : P[N]) x = sub(0, x);
  return P[N];
}

vector<int> Mul(const VVI &M, const vector<int> &p) {
  assert(p.size() == M.size());
  vector<int> q(M[0].size());
  for (size_t i = 0; i < p.size(); i++) {
    for (size_t j = 0; j < M[i].size(); j++) {
      q[j] = add(q[j], mul(M[i][j], p[i]));
    }
  }
  return q;
}

int main() {
  cin.tie(nullptr)->sync_with_stdio(false);
  int n, m, T;
  cin >> n >> m >> T;

  vector<string> g(n);
  for (int i = 0; i < n; i++) {
    cin >> g[i];
  }

  auto M = vector(n, vector(n, 0));

  for (int i = 0; i < n; i++) {
    const int cnt = ranges::count(g[i], '1');
    const int inv = modinv(cnt);
    for (int j = 0; j < n; j++) {
      if (g[i][j] == '1')
        M[i][j] = inv;
    }
  }

  auto tM = M;
  auto r = CharacteristicPoly(tM);
  orange(all(r));
  ranges::reverse(r);
  for (int x = sub(0, modinv(r[0])); int &y : r)
    y = mul(y, x);
  orange(all(r));
  const int k = (int)r.size() - 1;

  vector<int> dp(T);
  const int ord = n;

  debug(k, ord);

  vector<vector<int>> vecs(n);
  for (int v = 0; v < n; v++) {
    vector<int> p(n);
    p[v] = 1;

    vector<int> z(ord);
    for (int j = 0; j < ord; j++) {
      int cur = p[n - 1];
      p = Mul(M, p);
      z[j] = cur;
    }
    vecs[v] = z;
  }

  // auto evt = vector(T, vector(n, vector<int>()));
  for (int i = 0; i < m; i++) {
    int t, v;
    cin >> t >> v;
    --t;
    --v;
    auto z = vecs[v];
    for (int j = ord - 1; j >= 0; j--) {
      if (t + j >= k) {
        for (int s = 1; s <= k && s <= j; s++) {
          z[j] = sub(z[j], mul(r[s], z[j - s]));
        }
      }
    }
    for (int j = 0; j < ord && t + j < T; j++) {
      dp[t + j] = add(dp[t + j], z[j]);
    }
    /*
    for (int _ = k; _ < ord; _++) {
      int s = 0;
      for (int j = 1; j < k && _ - j >= 0; j++) {
        s = add(s, mul(r[j], z[_ - j]));
      }
      debug(s, z[_]);
      assert(s == z[_]);
    }
    */
  }

  for (int i = k; i < T; i++) {
    for (int j = 1; j <= k; j++) {
      dp[i] = add(dp[i], mul(r[j], dp[i - j]));
    }
  }

  orange(all(dp));

  int ans = 0;
  for (int i = 0; i < T; i++)
    ans ^= dp[i];
  cout << ans << '\n';

  return 0;
}