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

void printmat(char **matrice, int n) {
  int **a = (int **) matrice;
  for (int i = 0; i < n; i++) {
    printf("\n");
    for (int j = 1; j < (matrice[i][0] + 1); j++){
      printf("%08X  ", a[i][j]);
    }
  }
  printf("\n");
}

void modify (char *linie, int dimensiune, int indexBytes, int valNoua, int numarBytes) {
  int lungimeL = (linie[0] + 1), i = 0, j = 0;
  char val[4];
  val[0] = valNoua & 0xFF;
  val[1] = (valNoua >> 8) & 0xFF;
  val[2] = (valNoua >> 16) & 0xFF;
  val[3] = (valNoua >> 24) & 0xFF;

  if((indexBytes) > lungimeL * 4) {
    linie = realloc (linie, (numarBytes) * sizeof(int));
    for (i = lungimeL * 4; i < numarBytes; i++) {
      linie[i] = 0;
    }
  }


  for (int i = indexBytes - dimensiune; i < indexBytes; i++) {
    linie[i]=val[j];
    j++;
    if (j == 4) {
      break;
    }
  }
}

void delete (char *linie, int indexDate, int dimensiune) {
  int j = 0;
  while(j < dimensiune) {
    linie[(indexDate-1)*dimensiune+4+j] = 0x00;
    j++;
  }
}

void swap (char *linie, int indexBytes, int dimensiune) {
  int i = 0, j = dimensiune - 1, v[5] = {0};
  int start = indexBytes;

  if (dimensiune == 1) {
    /* v[0] = linie[start];
    linie[start] = linie[start + 1];
    linie[start + 1] = v[0]; */
    return;
  } else {
    while (i < 4) {
      v[i] = linie[start + i];
      i++;
    }
  }
  i = 0;
  while(i < dimensiune) {
    linie[start+i] = v[j];
    i++;
    j--;
  }
}

int** genMat(int n) {
  FILE *f;
  f = fopen("input_task1.txt", "r");

  int **matrice, i, j, col;

  matrice = malloc(n * sizeof(int));
  for (i = 0; i < n; i++) {
    fscanf(f, "%d", &col);
    matrice[i] = calloc(col + 1, sizeof(int));
    matrice[i][0] = col;
    for (j = 1; j < col + 1; j++) {
      fscanf(f, "%x", &matrice[i][j]);
    }
  }

  return matrice;
}

char** genviz(char **matrice, int n) {
  int i, j;
  char **viz;
  viz = malloc(n * sizeof(int));
  for (i = 0; i < n; i++) {
    viz[i] = calloc((matrice[i][0] + 1), sizeof(int));
  }
  return viz;
}

void fill(char **matrice, int n, char **viz, int i, int j, int *count) {
  if (i < 0 || i >= n || j < 4 || j >= (matrice[i][0] + 1) * 4) {
    return;
  }
  if (matrice[i][j] != viz[i][j]) {
    return;
  }

  viz[i][j] += 1;
  ++*count;

  fill(matrice, n, viz, i+1, j, count);
  fill(matrice, n, viz, i-1, j, count);
  fill(matrice, n, viz, i, j+1, count);
  fill(matrice, n, viz, i, j-1, count);
}

void task_one(char **matrice, int n) {
  int i, j, s = 0, cnt = 0;

  for (i = 0; i < n; i++) {
    for (j = 4; j < (matrice[i][0] + 1) * 4; j++) {
      if (i == 0 || j == 4 || i == n - 1 || j == (matrice[i][0] + 1) * 4 - 1) {
        s += matrice[i][j];
        cnt++;
      }
    }
  }

  printf("%.7f\n", (double)s / cnt);
}

void task_two(char **matrice, int n) {
  FILE *o;
  o = fopen("input_task2.txt", "r");

  int i, k, linie, indexDate, valNoua, numarBytes, indexBytes, dimensiune;
  //Fol vector pentru a evita "stack smashing", nu am gasit alta cale
  char actiuni[4];
  fscanf(o, "%d", &k);

  while (k) {
    for (i = 0; i < 2; i++) {
      fscanf(o, "%s", &actiuni[i]);
    }
    fscanf(o, "%d%d", &linie, &indexDate);

    if (actiuni[1] == 'C') {
      dimensiune = sizeof(char);
    }
    if (actiuni[1] == 'S') {
      dimensiune = sizeof(short);
    }
    if (actiuni[1] == 'I') {
      dimensiune = sizeof(int);
    }

    indexBytes = indexDate * dimensiune + 4;
    if (indexBytes % 4 == 0) {
      numarBytes = indexBytes;
    } else {
      numarBytes = (indexBytes) + 4 - ((indexBytes) % 4);
    }

    if(actiuni[0] == 'M') {
      fscanf(o, "%x", &valNoua);
      //modify(*(matrice + linie), dimensiune, indexBytes, valNoua, numarBytes);
      int lungimeL = (matrice[linie][0] + 1), i = 0, j = 0;
      char val[4];
      val[0] = valNoua & 0xFF;
      val[1] = (valNoua >> 8) & 0xFF;
      val[2] = (valNoua >> 16) & 0xFF;
      val[3] = (valNoua >> 24) & 0xFF;
      if((indexBytes) > lungimeL * 4) {
        matrice[linie] = realloc (matrice[linie], (numarBytes) * sizeof(int));
        for (i = lungimeL * 4; i < numarBytes; i++) {
          matrice[linie][i] = 0;
        }
      }

      for (int i = indexBytes - dimensiune; i < indexBytes; i++) {
        matrice[linie][i]=val[j];
        j++;
        if (j == 4) {
          break;
        }
      }
      if(matrice[linie][0] < numarBytes / 4 - 1) {
        matrice[linie][0] = numarBytes / 4 - 1;
      }
    }

    if(actiuni[0] == 'D') {
      delete(*(matrice + linie), indexDate, dimensiune);
    }

    if(actiuni[0] == 'S') {
      swap(*(matrice + linie), indexBytes, dimensiune);
    }
    k--;
  }
}

void task_three(char **matrice, int n) {
  int i, j, *count;
  int max = 0, x, y, reset = 0;
  count = &reset;
  char **viz = genviz(matrice, n);

  for (i = 0; i < n; i++) {
    for (j = 4; j < (matrice[i][0]+1)*4; j++) {
      if (matrice[i][j] == 0 && viz[i][j] == 0) {
        fill(matrice, n, viz, i, j, count);
        if (*count > max) {
          x = i;
          y = j;
          max = *count;
        }
        reset = 0;
        count = &reset;
      }
    }
  }
  printf("%d %d %d", x, y-4, max);
}

int main(void){
  int i, j, n;

  scanf("%d", &n);

  int **a = genMat(n);
  char **matrice = (char **) a;

  printf("task 1\n");
  task_one(matrice, n);

  printf("task 2");
  task_two(matrice, n);
  printmat(matrice, n);

  printf("task 3\n");
  task_three(matrice, n);

/*   for (i = 0; i < n; i++) {
    free(a[i]);
  }
  free(a); */

  return 0;
}