#include <stdlib.h>
#include <stdio.h>

int **pl, **pr, **pd, **sl, **sr, **rh, **rd;

int** alokuj_pole(int m, int n)
{
  int **pole;
  int i;

  pole = malloc((m+2)*sizeof(int*));
  for (i=0; i<=m+1; i++)
  {
    pole[i] = malloc((n+2)*sizeof(int));
  }

  return pole;
}

int namaha_radek(int a, int xl, int yl, int xr, int yr)
{
  printf("%d %d\n", a, xl);
  return (sl[yr][a] - sl[yl-1][a] - (sl[yr][xl-1] - sl[yl-1][xl-1])
          - (pl[yr][xl-1] - pl[yl-1][xl-1])*(a+1-xl))
         +
         (sr[yr][a] - sr[yl-1][a] - (sr[yr][xr+1] - sr[yl-1][xr+1])
          - (pr[yr][xr+1] - pr[yl-1][xr+1]) * (xr+1-a));
}

int namaha_sloupec(int b, int xl, int yl, int xr, int yr)
{
  return (rh[b][xr] - rh[b][xl-1] - (rh[yl-1][xr] - rh[yl-1][xl-1])
          - (pl[yl-1][xr] - pl[yl-1][xl-1])*(b+1-yl))
	 +
         (rd[b][xr] - rd[b][xl-1] - (rd[yr+1][xr] - rd[yr+1][xl-1])
          - (pd[yr+1][xr] - pd[yr+1][xl-1]) * (yr+1-b));
}

int nejlepsi_radek(int dolni, int horni, int xl, int yl, int xr, int yr)
{
  if (horni - dolni < 2)
  {
    return (namaha_sloupec(dolni, xl, yl, xr, yr) <
              namaha_sloupec(horni, xl, yl, xr, yr) ? dolni : horni);
  }

  int y1 = (horni + dolni + 1) / 2;
  int y2 = y1 + 1;

  if (namaha_sloupec(y1, xl, yl, xr, yr) < namaha_sloupec(y2, xl, yl, xr, yr))
    return nejlepsi_radek(dolni, y1, xl, yl, xr, yr);
  else
    return nejlepsi_radek(y2, horni, xl, yl, xr, yr);
}

int nejlepsi_sloupec(int levy, int pravy, int xl, int yl, int xr, int yr)
{
  if (pravy - levy < 2)
  {
    return (namaha_radek(levy, xl, yl, xr, yr) <
              namaha_radek(pravy, xl, yl, xr, yr) ? levy : pravy);
  }

  int x1 = (pravy + levy + 1) / 2;
  int x2 = x1 + 1;

  if (namaha_radek(x1, xl, yl, xr, yr) < namaha_radek(x2, xl, yl, xr, yr))
    return nejlepsi_sloupec(levy, x1, xl, yl, xr, yr);
  else
    return nejlepsi_sloupec(x2, pravy, xl, yl, xr, yr);
}

int main(void)
{
  int m, n, k;
  int nejlepsi_x, nejlepsi_y;
  int xl, yl, xr, yr;
  int i, j, o; int soucet;
  int **hmotnosti;

  scanf("%d %d", &m, &n);

  hmotnosti = alokuj_pole(m, n);
  pl = alokuj_pole(m, n);
  pr = alokuj_pole(m, n);
  pd = alokuj_pole(m, n);
  sl = alokuj_pole(m, n);
  sr = alokuj_pole(m, n);
  rh = alokuj_pole(m, n);
  rd = alokuj_pole(m, n);

  for (i=1; i<=m; i++)
  {
    for (j=1; j<=n; j++)
    {
      scanf("%d", &hmotnosti[i][j]);
    }
  }

  for (j=0; j<=n+1; j++)
  {
    pl[0][j] = 0;
    pr[0][j] = 0;
  }

  for (i=1; i<=m; i++)
  {
    soucet = 0;
    for (j=1; j<=n; j++)
    {
      soucet += hmotnosti[i][j];
      pl[i][j] = pl[i-1][j] + soucet;
    }
  }

  for (i=1; i<=m; i++)
  {
    soucet = 0;
    for (j=n; j>=1; j--)
    {
      soucet += hmotnosti[i][j];
      pr[i][j] = pr[i-1][j] + soucet;
    }
  }

  for (i=m; i>=1; i--)
  {
    soucet = 0;
    for (j=1; j<=n; j++)
    {
      soucet += hmotnosti[i][j];
      pd[i][j] = pd[i+1][j] + soucet;
    }
  }

  for (i=0; i<=m+1; i++)
  {
    sl[i][0] = 0;
  }

  for (i=0; i<=m+1; i++)
  {
    sr[i][n+1] = 0;
  }

  for (i=1; i<=m; i++)
  {
    for (j=1; j<=n; j++)
    {
      sl[i][j] = sl[i][j-1] + pl[i][j-1];
    }
  }

  for (i=1; i<=m; i++)
  {
    for (j=n; j>=1; j--)
    {
      sr[i][j] = sr[i][j+1] + pr[i][j+1];
    }
  }

  for (j=0; j<=n+1; j++)
  {
    rh[0][j] = 0;
    rd[m+1][j] = 0;
  }

  for (i=1; i<=m; i++)
  {
    for (j=1; j<=n; j++)
    {
      rh[i][j] = rh[i-1][j] + pl[i-1][j];
    }
  }

  for (i=m; i>=1; i--)
  {
    for (j=1; j<=n; j++)
    {
      rd[i][j] = rd[i+1][j] + (pl[m][j] - pl[i][j]);
    }
  }


  scanf("%d", &k);


  for (o=0; o<k; o++)
  {
    scanf("%d %d %d %d", &xl, &yl, &xr, &yr);

    nejlepsi_x = nejlepsi_sloupec(xl, xr, xl, yl, xr, yr);
    nejlepsi_y = nejlepsi_radek(yl, yr, xl, yl, xr, yr);

    printf("%d %d %d\n", nejlepsi_x, nejlepsi_y,
                         namaha_radek(nejlepsi_x, xl, yl, xr, yr) +
                         namaha_sloupec(nejlepsi_y, xl, yl, xr, yr));
  }

  return 0;
}