#include <bits/stdc++.h>
using namespace std;
template <typename T>
vector<T>& operator--(vector<T>& v) {
  for (auto& i : v) --i;
  return v;
}
template <typename T>
vector<T>& operator++(vector<T>& v) {
  for (auto& i : v) ++i;
  return v;
}
template <typename T>
istream& operator>>(istream& is, vector<T>& v) {
  for (auto& i : v) is >> i;
  return is;
}
template <typename T>
ostream& operator<<(ostream& os, vector<T>& v) {
  for (auto& i : v) os << i << ' ';
  return os;
}
template <typename T, typename U>
istream& operator>>(istream& is, pair<T, U>& p) {
  is >> p.first >> p.second;
  return is;
}
template <typename T, typename U>
ostream& operator<<(ostream& os, pair<T, U>& p) {
  os << p.first << ' ' << p.second;
  return os;
}
template <typename T, typename U>
pair<T, U> operator-(pair<T, U> a, pair<T, U> b) {
  return make_pair(a.first - b.first, a.second - b.second);
}
template <typename T, typename U>
pair<T, U> operator+(pair<T, U> a, pair<T, U> b) {
  return make_pair(a.first + b.first, a.second + b.second);
}
template <typename T, typename U>
void umin(T& a, U b) {
  if (a > b) a = b;
}
template <typename T, typename U>
void umax(T& a, U b) {
  if (a < b) a = b;
}
const int N = 505;
const int LG = 11;
array<array<array<array<int, LG>, LG>, N>, N> sparse;
mt19937_64 rng(9384729);
long long rnd(long long l, long long r) {
  return (long long)(rng() % (r - l + 1)) + l;
}
long long rnd(long long r) { return rng() % r; }
long long rnd() { return rng(); }
long double rndf() { return (long double)rng() / (long double)ULLONG_MAX; }
long double rndf(long double l, long double r) { return rndf() * (r - l) + l; }
int main() {
  ios_base::sync_with_stdio(false);
  cin.tie(NULL);
  cout.tie(NULL);
  int n, m;
  cin >> n >> m;
  int q;
  cin >> q;
  vector<string> v(n);
  cin >> v;
  vector<vector<int>> f(n + 1, vector<int>(m + 1, 1));
  auto col = [&](int i, int j) {
    if (i < 0 || j < 0 || i >= n || j >= m) return 'X';
    return v[i][j];
  };
  for (int i = 0; i < n + 1; ++i) {
    for (int j = 0; j < m + 1; ++j) {
      while (true) {
        bool ok = true;
        for (int k = 0; k < f[i][j]; ++k) {
          if (col(i - f[i][j], j - 1 - k) != 'R') {
            ok = false;
            break;
          }
          if (col(i - 1 - k, j - f[i][j]) != 'R') {
            ok = false;
            break;
          }
          if (col(i - f[i][j], j + k) != 'G') {
            ok = false;
            break;
          }
          if (col(i - 1 - k, j - 1 + f[i][j]) != 'G') {
            ok = false;
            break;
          }
          if (col(i - 1 + f[i][j], j - 1 - k) != 'Y') {
            ok = false;
            break;
          }
          if (col(i + k, j - f[i][j]) != 'Y') {
            ok = false;
            break;
          }
          if (col(i - 1 + f[i][j], j + k) != 'B') {
            ok = false;
            break;
          }
          if (col(i + k, j - 1 + f[i][j]) != 'B') {
            ok = false;
            break;
          }
        }
        if (!ok) break;
        ++f[i][j];
      }
      --f[i][j];
    }
  }
  for (int i = 0; i <= n; ++i) {
    for (int j = 0; j <= m; ++j) {
      for (int k = 0; k < LG; ++k) {
        for (int u = 0; u < LG; ++u) {
          sparse[i][j][k][u] = 0;
          if (k != 0) {
            sparse[i][j][k][u] = sparse[i][j][k - 1][u];
            if (i >= (1 << (k - 1)))
              sparse[i][j][k][u] = max(sparse[i][j][k - 1][u],
                                       sparse[i - (1 << (k - 1))][j][k - 1][u]);
          } else if (u != 0) {
            sparse[i][j][k][u] = sparse[i][j][k][u - 1];
            if (j >= (1 << (u - 1)))
              sparse[i][j][k][u] = max(sparse[i][j][k][u - 1],
                                       sparse[i][j - (1 << (u - 1))][k][u - 1]);
          } else {
            sparse[i][j][k][u] = f[i][j];
          }
        }
      }
    }
  }
  auto mx = [&](int i1, int j1, int i2, int j2) {
    if (i1 > i2 || j1 > j2) return 0;
    int pi = 0;
    int pj = 0;
    while ((1 << pi) <= (i2 - i1 + 1)) ++pi;
    while ((1 << pj) <= (j2 - j1 + 1)) ++pj;
    --pi;
    --pj;
    return max({sparse[i2][j2][pi][pj], sparse[i1 + (1 << pi) - 1][j2][pi][pj],
                sparse[i2][j1 + (1 << pj) - 1][pi][pj],
                sparse[i1 + (1 << pi) - 1][j1 + (1 << pj) - 1][pi][pj]});
  };
  for (int i = 0; i < q; ++i) {
    int i1, j1, i2, j2;
    cin >> i1 >> j1 >> i2 >> j2;
    --i1;
    --i2;
    --j1;
    --j2;
    ++i2;
    ++j2;
    42;
    ;
    int l = 0, r = N;
    while (r - l > 1) {
      int c = (l + r) / 2;
      int m = mx(i1 + c, j1 + c, i2 - c, j2 - c);
      42;
      ;
      if (m >= c)
        l = c;
      else
        r = c;
    }
    cout << l * l * 4 << '\n';
  }
  return 0;
}
