#include <bits/stdc++.h>
using namespace std;
const int N = 510, LOG = 10;
int st[N][N][LOG][LOG], lg[N];
int n, m, q;
void build() {
  lg[1] = 0;
  for (int i = 2; i < N; i++) {
    lg[i] = lg[i - 1];
    if ((1 << (lg[i] + 1)) == i) lg[i]++;
  }
  for (int k = 1; k < LOG; k++) {
    for (int i = 0; i + (1 << k) <= n; i++) {
      for (int j = 0; j < m; j++) {
        st[i][j][k][0] =
            max(st[i][j][k - 1][0], st[i + (1 << (k - 1))][j][k - 1][0]);
      }
    }
  }
  for (int l = 1; l < LOG; l++) {
    for (int k = 0; k < LOG; k++) {
      for (int i = 0; i + (1 << k) <= n; i++) {
        for (int j = 0; j + (1 << l) <= m; j++) {
          st[i][j][k][l] =
              max(st[i][j][k][l - 1], st[i][j + (1 << (l - 1))][k][l - 1]);
        }
      }
    }
  }
}
inline int getmax(int r1, int c1, int r2, int c2) {
  if (r2 < r1 || c2 < c1 || r1 < 0 || r2 >= n || c1 < 0 || c2 >= m)
    return -1000000010;
  int a = lg[(r2 - r1) + 1];
  int b = lg[(c2 - c1) + 1];
  return max(max(st[r1][c1][a][b], st[r2 - (1 << a) + 1][c1][a][b]),
             max(st[r1][c2 - (1 << b) + 1][a][b],
                 st[r2 - (1 << a) + 1][c2 - (1 << b) + 1][a][b]));
}
void dp(vector<vector<int>>& dp, vector<string>& grid, char key, int dx,
        int dy) {
  int init_i = dx == 1 ? 0 : dp.size() - 1;
  int init_j = dy == 1 ? 0 : dp[0].size() - 1;
  auto bounds = [&](int i, int j) {
    return 0 <= i && i < dp.size() && 0 <= j && j < dp[0].size();
  };
  for (int i = init_i; i < dp.size() && i >= 0; i += dx) {
    for (int j = init_j; j < dp[0].size() && j >= 0; j += dy) {
      if (grid[i][j] != key) continue;
      int mn = INT_MAX;
      mn = bounds(i - dx, j) ? min(mn, dp[i - dx][j]) : 0;
      mn = bounds(i, j - dy) ? min(mn, dp[i][j - dy]) : 0;
      mn = bounds(i - dx, j - dy) ? min(mn, dp[i - dx][j - dy]) : 0;
      dp[i][j] = mn + 1;
    }
  }
}
int main() {
  ios_base::sync_with_stdio(false), cin.tie(NULL);
  cin >> n >> m >> q;
  vector<string> grid(n);
  for (int i = 0; i < n; ++i) {
    cin >> grid[i];
  }
  vector<vector<int>> R(n, vector<int>(m));
  vector<vector<int>> G(n, vector<int>(m));
  vector<vector<int>> Y(n, vector<int>(m));
  vector<vector<int>> B(n, vector<int>(m));
  dp(R, grid, 'R', 1, 1);
  dp(G, grid, 'G', 1, -1);
  dp(Y, grid, 'Y', -1, 1);
  dp(B, grid, 'B', -1, -1);
  for (int i = 0; i < n - 1; ++i) {
    for (int j = 0; j < m - 1; ++j) {
      int h = R[i][j];
      h = min(h, G[i][j + 1]);
      h = min(h, Y[i + 1][j]);
      h = min(h, B[i + 1][j + 1]);
      st[i][j][0][0] = h;
    }
  }
  build();
  while (q--) {
    int r1, c1, r2, c2;
    cin >> r1 >> c1 >> r2 >> c2;
    --r1, --c1, --r2, --c2;
    int lo = 0, hi = (n >> 1), res = 0;
    while (lo < hi) {
      int mid = (lo + hi + 1) >> 1;
      if (getmax(r1 + mid - 1, c1 + mid - 1, r2 - mid, c2 - mid) >= mid) {
        lo = mid;
      } else {
        hi = mid - 1;
      }
    }
    cout << 4 * lo * lo << '\n';
  }
}
