#include <bits/stdc++.h>

using namespace std;

using ll = long long;

const int mod = 1e9 + 7;

int neg(int x) { return x ? mod - x : 0; }
int quo2(int x) { return (x + (x & 1 ? mod : 0)) >> 1; }
void add(int &x, int y) { if ((x += y - mod) < 0) x += mod; }
void sub(int &x, int y) { if ((x -= y) < 0) x += mod; }
int mpow(int a, int b) {
  int ret = 1;
  for (; b; b >>= 1) {
    if (b & 1) ret = (ll)ret * a % mod;
    a = (ll)a * a % mod;
  }
  return ret;
}

namespace Matrix {
 
  const int N = 804;
 
  template<class T>
  vector<int> charPoly(int n, T mat) {
    static int a[N + 5][N + 5], poly[N + 5][N + 5];
    for (int i = 1; i <= n; ++i) for (int j = 1; j <= n; ++j) a[i][j] = neg(mat[i][j]);
    for (int i = 1; i < n; ++i) {
      int pivot = i + 1;
      for (; pivot <= n && !a[pivot][i]; ++pivot);
      if (pivot > n) continue;
      if (pivot > i + 1) {
        for (int j = i; j <= n; ++j) swap(a[i + 1][j], a[pivot][j]);
        for (int j = 1; j <= n; ++j) swap(a[j][i + 1], a[j][pivot]);
      }
      int nv = mpow(a[i + 1][i], mod - 2);
      for (int j = i + 2; j <= n; ++j)
        if (a[j][i]) {
          int t = (ll)a[j][i] * nv % mod;
          for (int k = i; k <= n; ++k) a[j][k] = (a[j][k] + (ll)(mod - t) * a[i + 1][k]) % mod;
          for (int k = 1; k <= n; ++k) a[k][i + 1] = (a[k][i + 1] + (ll)t * a[k][j]) % mod;
        }
    }
    poly[n + 1][0] = 1;
    for (int i = n; i; --i) {
      poly[i][0] = 0;
      for (int j = 1; j <= n + 1 - i; ++j) poly[i][j] = poly[i + 1][j - 1];
      for (int j = i, t = 1; j <= n && t; t = (ll)t * a[j + 1][j] % mod, ++j) {
        int coe = (ll)t * a[i][j] % mod;
        if (!coe) continue;
        if ((i ^ j) & 1) coe = mod - coe;
        for (int k = 0; k <= n - j; ++k) poly[i][k] = (poly[i][k] + (ll)poly[j + 1][k] * coe) % mod;
      }
    }
    return vector<int>(poly[1], poly[1] + n + 1);
  }
 
  template<class T>
  int det(int n, T mat) {
    static int a[N + 5][N + 5];
    for (int i = 1; i <= n; ++i) for (int j = 1; j <= n; ++j) a[i][j] = mat[i][j];
    int ret = 1;
    for (int i = 1; i <= n; ++i) {
      int pivot = i;
      for (; pivot <= n && !a[pivot][i]; ++pivot);
      if (pivot > n) return 0;
      if (pivot > i) {
        ret = mod - ret;
        for (int j = i; j <= n; ++j) swap(a[i][j], a[pivot][j]);
      }
      int nv = mpow(a[i][i], mod - 2);
      for (int j = i + 1; j <= n; ++j)
        if (a[j][i]) {
          int t = (ll)a[j][i] * nv % mod;
          for (int k = i; k <= n; ++k) a[j][k] = (a[j][k] + (ll)(mod - t) * a[i][k]) % mod;
        }
    }
    for (int i = 1; i <= n; ++i) ret = (ll)ret * a[i][i] % mod;
    return ret;
  }
 
  template<class T>
  vector<int> det(int n, T matA, T matB) {
    static int a[N + 5][N + 5], b[N + 5][N + 5];
    for (int i = 1; i <= n; ++i) for (int j = 1; j <= n; ++j) a[i][j] = matA[i][j], b[i][j] = matB[i][j];
    int offset = 0, coe = 1;
    for (int i = 1; i <= n; ++i) {
      for (int j = 1; j < i; ++j)
        if (b[j][i]) {
          int t = mod - b[j][i];
          for (int k = 1; k <= n; ++k)
            a[k][i] = (a[k][i] + (ll)a[k][j] * t) % mod,
            b[k][i] = (b[k][i] + (ll)b[k][j] * t) % mod;
        }
      int pivot = i;
      for (; pivot <= n && !b[pivot][i]; ++pivot);
      if (pivot > n) {
        ++offset;
        for (int j = 1; j <= n; ++j) b[j][i] = a[j][i], a[j][i] = 0;
        for (int j = 1; j < i; ++j) 
          if (b[j][i]) {
            int t = mod - b[j][i];
            for (int k = 1; k <= n; ++k)
              a[k][i] = (a[k][i] + (ll)a[k][j] * t) % mod,
              b[k][i] = (b[k][i] + (ll)b[k][j] * t) % mod;
          }
        pivot = i;
        for (; pivot <= n && !b[pivot][i]; ++pivot);
        if (pivot > n) return vector<int>(n + 1, 0);
      }
      if (pivot > i) {
        coe = mod - coe;
        for (int j = 1; j <= n; ++j)
          swap(a[i][j], a[pivot][j]), swap(b[i][j], b[pivot][j]);
      }
      int nv = mpow(b[i][i], mod - 2); coe = (ll)coe * b[i][i] % mod;
      for (int j = 1; j <= n; ++j)
        a[i][j] = (ll)a[i][j] * nv % mod, b[i][j] = (ll)b[i][j] * nv % mod;
      for (int j = i + 1; j <= n; ++j)
        if (b[j][i]) {
          int t = mod - b[j][i];
          for (int k = 1; k <= n; ++k)
            a[j][k] = (a[j][k] + (ll)a[i][k] * t) % mod,
            b[j][k] = (b[j][k] + (ll)b[i][k] * t) % mod;
        }
    }
    for (int i = 1; i <= n; ++i) for (int j = 1; j <= n; ++j) a[i][j] = neg(a[i][j]), assert(b[i][j] == (i == j));
    auto res = charPoly(n, a);
    vector<int> ret(n - offset + 1);
    for (int i = 0; i <= n - offset; ++i)
      ret[i] = (ll)coe * res[i + offset] % mod;
    ret.resize(n + 1);
    return ret;
  }

  template<class T>
  vector<int> det(int n, T mat[3]) {
    static int a[3][N + 5][N + 5], b[N + 5][N + 5];
    for (int e = 0; e < 3; ++e)
      for (int i = 1; i <= n; ++i) for (int j = 1; j <= n; ++j) a[e][i][j] = mat[e][i][j];
    int offset = 0, coe = 1;
    for (int i = 1; i <= n; ++i) {
      int pivot = n + 1;
      for (int rep = 0; pivot > n && rep < 3; ++rep) {
        for (int j = 1; j < i; ++j)
          if (a[2][j][i]) {
            int t = mod - a[2][j][i];
            for (int e = 0; e < 3; ++e)
              for (int k = 1; k <= n; ++k)
                if (a[e][k][j])
                  a[e][k][i] = (a[e][k][i] + (ll)a[e][k][j] * t) % mod;
          }
        for (pivot = i; pivot <= n && !a[2][pivot][i]; ++pivot);
        if (pivot > n && rep < 2) {
          ++offset;
          for (int j = 1; j <= n; ++j) a[2][j][i] = a[1][j][i], a[1][j][i] = a[0][j][i], a[0][j][i] = 0;
        }
      }
      if (pivot > n) return vector<int>(n * 2 + 1, 0);
      if (pivot > i) {
        coe = mod - coe;
        for (int e = 0; e < 3; ++e)
          for (int j = 1; j <= n; ++j) swap(a[e][i][j], a[e][pivot][j]);
      }
      int nv = mpow(a[2][i][i], mod - 2); coe = (ll)coe * a[2][i][i] % mod;
      for (int e = 0; e < 3; ++e)
        for (int j = 1; j <= n; ++j)
          if (a[e][i][j]) a[e][i][j] = (ll)a[e][i][j] * nv % mod;
      for (int j = i + 1; j <= n; ++j)
        if (a[2][j][i]) {
          int t = mod - a[2][j][i];
          for (int e = 0; e < 3; ++e)
            for (int k = 1; k <= n; ++k)
              if (a[e][i][k]) a[e][j][k] = (a[e][j][k] + (ll)a[e][i][k] * t) % mod;
        }
    }
    for (int i = 1; i <= n; ++i) b[i][n + i] = 1;
    for (int i = 1; i <= n; ++i)
      for (int j = 1; j <= n; ++j)
        b[n + i][j] = neg(a[0][i][j]), b[n + i][n + j] = neg(a[1][i][j]);
    auto res = charPoly(n * 2, b);
    vector<int> ret(n * 2 - offset + 1);
    for (int i = 0; i < ret.size(); ++i) ret[i] = (ll)coe * res[i + offset] % mod;
    ret.resize(n * 2 + 1);
    return ret;
  }
 
}

using Matrix::det;

const int N = 402;

int n, m, k;
int a[N + 5], b[N + 5];
int s[N + 5][N + 5], pre[N + 5][N + 5];
int f[2][N + 5][N + 5], g[N + 5][N + 5];
int mat[3][N + 5][N + 5], len;
int ans[N + 5];

int main() {
  scanf("%d%d%d", &n, &m, &k);
  for (int i = 1; i <= n; ++i) scanf("%d", a + i);
  for (int i = 1; i <= m; ++i) scanf("%d", b + i);
  for (int i = 1; i <= k; ++i)
    for (int j = 1; j <= k; ++j) {
      scanf("%1d", s[i] + j);
      if (!s[i][j]) pre[i][j] = j;
      else pre[i][j] = pre[i][j - 1];
    }
  for (int i = 1; i < m; ++i)
    for (int j = i + 1; j <= m; ++j) {
      int x0 = pre[k][b[i]], x1 = max(b[i], pre[k][b[j]]);
      add(f[k & 1][b[i]][b[j]], 1),
      sub(f[k & 1][b[i]][x1], 1),
      sub(f[k & 1][x0][b[j]], 1),
      add(f[k & 1][x0][x1], 1);
    }
  for (int i = k; i; --i)
    for (int j = k; j; --j)
      add(f[k & 1][i][j], f[k & 1][i + 1][j]),
      add(f[k & 1][i][j], f[k & 1][i][j + 1]),
      sub(f[k & 1][i][j], f[k & 1][i + 1][j + 1]);
  for (int r = k - 1; r; --r) {
    memset(f[r & 1], 0, sizeof f[r & 1]);
    for (int i = 1; i < k; ++i)
      for (int j = i + 1, v; j <= k; ++j)
        if ((v = f[~r & 1][i][j]) && s[r][i] && s[r][j]) {
          int x0 = pre[r][i], x1 = max(i, pre[r][j]);
          add(f[r & 1][i][j], v),
          sub(f[r & 1][i][x1], v),
          sub(f[r & 1][x0][j], v),
          add(f[r & 1][x0][x1], v);
        }
    for (int i = k; i; --i)
      for (int j = k; j; --j)
        add(f[r & 1][i][j], f[r & 1][i + 1][j]),
        add(f[r & 1][i][j], f[r & 1][i][j + 1]),
        sub(f[r & 1][i][j], f[r & 1][i + 1][j + 1]);
  }
  for (int i = 1; i <= m; ++i) g[k][b[i]] = 1;
  for (int i = k; i; --i)
    for (int j = k; j; --j)
      if (s[i][j])
        add(g[i][j], g[i][j + 1]), add(g[i][j], g[i + 1][j]);
  len = n + 1 + (~n & 1);
  for (int i = 1; i < len; ++i)
    for (int j = i + 1; j <= len; ++j)
      mat[0][i][j] = ~(i ^ j) & 1 ? mod - 1 : 1;
  for (int i = 1; i < n; ++i)
    for (int j = i + 1; j <= n; ++j)
      mat[2][i][j] = f[1][a[i]][a[j]];
  for (int i = 1; i <= n; ++i) mat[1][i][n + 1] = g[1][a[i]];
  for (int e = 0; e < 3; ++e)
    for (int i = 1; i < len; ++i)
      for (int j = i + 1; j <= len; ++j)
        mat[e][j][i] = neg(mat[e][i][j]);
  auto res = det(len, mat);
  ans[0] = 1;
  for (int i = 1; i <= n; ++i) {
    ans[i] = res[i];
    for (int j = 1; j < i; ++j) ans[i] = (ans[i] + (ll)(mod - ans[j]) * ans[i - j]) % mod;
    ans[i] = quo2(ans[i]);
  }
  for (int i = n; i >= 0; --i)
    if (ans[i]) { printf("%d %d\n", i, ans[i]); break; }
}