#include <bits/stdc++.h>
#define add(x, y) x = (x + y) % Mo
int scan() {
  int x = 0; char ch = getchar();
  for (; !isdigit(ch); ch = getchar());
  for (; isdigit(ch); ch = getchar()) x = 10 * x + ch - '0';
  return x;
}
int top, stk[11];
void print(int x) {
  do stk[++top] = x % 10, x /= 10; while (x);
  while (top) putchar('0' + stk[top--]);
}
const int N = 1e5, M = 5, Mo = 1e9 + 7;
int Pow(int x, int y) {
  int res = 1;
  for (; y; y >>= 1) {
    if (y & 1) res = 1ll * res * x % Mo;
    x = 1ll * x * x % Mo;
  }
  return res;
}
const int inv100 = Pow(100, Mo - 2);
int pScan() { return 1ll * scan() * inv100 % Mo; }
int n, m, Q, mat_n, pL[N][M], pR[N][M], pU[N][M], pD[N][M];
struct Matrix {
  int a[11][11];
  Matrix() { memset(a, 0, sizeof a); }
  Matrix(int i, bool right) {
    memset(a, 0, sizeof a);
    if (right)
      for (int j = 0; j < m; ++j) {
        a[m + j][j] = 1;
        int inv = Pow(pD[i][j], Mo - 2);
        a[m + j][m + j] = inv,
        a[j][m + j] = -1ll * pU[i][j] * inv % Mo,
        a[m + (j + 1) % m][m + j] = -1ll * pR[i][j] * inv % Mo,
        a[m + (j - 1 + m) % m][m + j] = -1ll * pL[i][j] * inv % Mo,
        a[2 * m][m + j] = -inv;
      }
    else
      for (int j = 0; j < m; ++j) {
        a[j][m + j] = 1;
        int inv = Pow(pU[i][j], Mo - 2);
        a[j][j] = inv,
        a[m + j][j] = -1ll * pD[i][j] * inv % Mo,
        a[(j + 1) % m][j] = -1ll * pR[i][j] * inv % Mo,
        a[(j - 1 + m) % m][j] = -1ll * pL[i][j] * inv % Mo,
        a[2 * m][j] = -inv;
      }
    a[2 * m][2 * m] = 1;
  }
  inline Matrix operator * (const Matrix &B) const {
    Matrix C;
    for (int i = 0; i < mat_n; ++i) for (int k = 0; k < mat_n; ++k)
      for (int j = 0; j < mat_n; ++j) if (a[i][k] && B.a[k][j])
        add(C.a[i][j], 1ll * a[i][k] * B.a[k][j]);
    return C;
  }
} Unit;
struct Node { int l, r; Matrix matR, matL; } t[2 * N];
#define lc(p) (p << 1)
#define rc(p) (p << 1 | 1)
void pushup(int p) {
  t[p].matR = t[lc(p)].matR * t[rc(p)].matR,
  t[p].matL = t[rc(p)].matL * t[lc(p)].matL;
}
void build(int p, int l, int r) {
  t[p].l = l, t[p].r = r;
  if (l == r) {
    t[p].matR = Matrix(l, true), t[p].matL = Matrix(l, false); return;
  }
  int mid = (l + r) >> 1;
  build(lc(p), l, mid), build(rc(p), mid + 1, r);
  pushup(p);
}
void modify(int p, int x) {
  if (t[p].l == t[p].r) {
    t[p].matR = Matrix(x, true), t[p].matL = Matrix(x, false); return;
  }
  modify(x <= t[lc(p)].r ? lc(p) : rc(p), x);
  pushup(p);
}
Matrix queryR(int p, int l, int r) {
  if (l <= t[p].l && t[p].r <= r) return t[p].matR;
  if (r <= t[lc(p)].r) return queryR(lc(p), l, r);
  if (t[rc(p)].l <= l) return queryR(rc(p), l, r);
  return queryR(lc(p), l, r) * queryR(rc(p), l, r);
}
Matrix queryL(int p, int l, int r) {
  if (l <= t[p].l && t[p].r <= r) return t[p].matL;
  if (r <= t[lc(p)].r) return queryL(lc(p), l, r);
  if (t[rc(p)].l <= l) return queryL(rc(p), l, r);
  return queryL(rc(p), l, r) * queryL(lc(p), l, r);
}
int a[10][10], b[11];
void Guass() {
  for (int i = 0; i < 2 * m; ++i) {
    for (int j = i; j < 2 * m; ++j)
      if (a[j][i]) { std::swap(a[i], a[j]), std::swap(b[i], b[j]); break; }
    assert(a[i][i]);
    int inv = Pow(a[i][i], Mo - 2); b[i] = 1ll * b[i] * inv % Mo;
    for (int k = 0; k < 2 * m; ++k) a[i][k] = 1ll * a[i][k] * inv % Mo;
    for (int j = 0; j < 2 * m; ++j) if (j != i && a[j][i]) {
      long long base = -a[j][i];
      for (int k = 0; k < 2 * m; ++k) add(a[j][k], base * a[i][k]);
      add(b[j], base * b[i]);
    }
  }
}
int main() {
  n = scan(), m = scan(), mat_n = 2 * m + 1;
  for (int i = 0; i < mat_n; ++i) Unit.a[i][i] = 1;
  for (int i = 0; i < n; ++i) for (int j = 0; j < m; ++j) pL[i][j] = pScan();
  for (int i = 0; i < n; ++i) for (int j = 0; j < m; ++j) pR[i][j] = pScan();
  for (int i = 0; i < n; ++i) for (int j = 0; j < m; ++j) pU[i][j] = pScan();
  for (int i = 0; i < n; ++i) for (int j = 0; j < m; ++j) pD[i][j] = pScan();
  build(1, 0, n - 1);
  Q = scan();
  while (Q--) {
    int op = scan();
    if (op == 1) {
      int x = scan(), y = scan();
      pL[x][y] = pScan(), pR[x][y] = pScan(), pU[x][y] = pScan(), pD[x][y] = pScan();
      modify(1, x);
    } else {
      int sx = scan(), sy = scan(), tx = scan(), ty = scan();
      Matrix A = tx         ? queryR(1, 0, tx - 1)     : Unit,
             B = tx + 1 < n ? queryL(1, tx + 1, n - 1) : Unit;
      memset(a, 0, sizeof a), memset(b, 0, sizeof b), b[2 * m] = 1;
      for (int j = 0; j < m; ++j) {
        for (int k = 0; k < 2 * m; ++k) a[j][k] = (A.a[k][m + j] - B.a[k][j]) % Mo;
        b[j] = (B.a[2 * m][j] - A.a[2 * m][m + j]) % Mo;
        if (j == ty) {
          for (int k = 0; k < 2 * m; ++k) a[m + j][k] = A.a[k][m + j];
          b[m + j] = -A.a[2 * m][m + j];
        } else {
          for (int k = 0; k < 2 * m; ++k)
            a[m + j][k] = (- A.a[k][m + j]
                           + 1ll * pD[tx][j] * B.a[k][m + j]
                           + 1ll * pU[tx][j] * A.a[k][j]
                           + 1ll * pR[tx][j] * A.a[k][m + (j + 1) % m]
                           + 1ll * pL[tx][j] * A.a[k][m + (j - 1 + m) % m]
                          ) % Mo;
          b[m + j] = (  A.a[2 * m][m + j] - 1
                      - 1ll * pD[tx][j] * B.a[2 * m][m + j]
                      - 1ll * pU[tx][j] * A.a[2 * m][j]
                      - 1ll * pR[tx][j] * A.a[2 * m][m + (j + 1) % m]
                      - 1ll * pL[tx][j] * A.a[2 * m][m + (j - 1 + m) % m]
                     ) % Mo;
        }
      }
      Guass(); int ans = 0;
      if (sx < tx) {
        A = sx         ? queryR(1, 0, sx - 1)     : Unit;
        for (int k = 0; k < mat_n; ++k) add(ans, 1ll * A.a[k][m + sy] * b[k]);
      } else {
        B = sx + 1 < n ? queryL(1, sx + 1, n - 1) : Unit;
        for (int k = 0; k < mat_n; ++k) add(ans, 1ll * B.a[k][sy]     * b[k]);
      }
      print((ans + Mo) % Mo), putchar('\n');
    }
  }
  return 0;
}