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

#define NMAX 1000
#define NMAX2 15

void macroboard(char v[][NMAX2], long p, long q, long n_lin_col,
                double contor[NMAX]) {
    long i, j, n, k;
    char x;
    n = n_lin_col;
    contor[1] = 0;
    contor[2] = 0;
    // varificare pe linii
    for (i = p; i < p + n; i++) {
        k = 0;
        for (j = q; j < q + n - 1; j++) {
            if (v[i][q] == 'X' || v[i][q] == '0')
                x = v[i][q];
            else
                x = 'H';
            if (v[i][j + 1] == x)
                k++;
            if (k == (n - 1)) {
                if (x == 'X')
                    contor[1]++;
                if (x == '0')
                    contor[2]++;
            }

        }
    }
    // verificare pe coloane
    for (j = q; j < q + n; j++) {
        k = 0;
        for (i = p; i < p + n - 1; i++) {
            if (v[p][j] == 'X' || v[p][j] == '0')
                x = v[p][j];
            else
                x = 'H';
            if (v[i + 1][j] == x)
                k++;
            if (k == (n - 1)) {
                if (x == 'X')
                    contor[1]++;
                if (x == '0')
                    contor[2]++;
            }
        }
    }
    // verificare diagonala principala
    k = 0;
    if (v[p][q] == 'X' || v[p][q] == '0') {
        x = v[p][q];
    } else {
        x = 'H';
    }
    for (i = 0; i < n; i++) {
        if (v[p + i][q + i] == x)
            k++;
        if (k == n) {
            if (x == 'X')
                contor[1]++;
            if (x == '0')
                contor[2]++;
        }
    }
    // verificare diagonala secundara
    k = 0;
    if (v[p][q + n - 1] == 'X' || v[p][q + n - 1] == '0')
        x = v[p][q + n - 1];
    else
        x = 'H';
    for (i = 0; i < n; i++) {
        if (x == v[p + i][q + n - 1 - i]) {
            k++;
        }
        if (k == n) {
            if (x == 'X')
                contor[1]++;
            if (x == '0')
                contor[2]++;
        }
    }
}

char castigator(char matrice[][NMAX], long p, long q, long n_lin_col) {
    long i, j, n, k;
    char x;
    n = n_lin_col;
    // varificare pe linii
    for (i = p; i < p + n; i++) {
        k = 0;
        for (j = q; j < q + n - 1; j++) {
            if (matrice[i][q] == 'X' || matrice[i][q] == '0')
                x = matrice[i][q];
            else
                x = 'H';
            if (matrice[i][j + 1] == x)
                k++;
            if (k == (n - 1))
                return x;
        }
    }
    // verificare pe coloane
    for (j = q; j < q + n; j++) {
        k = 0;
        for (i = p; i < p + n - 1; i++) {
            if (matrice[p][j] == 'X' || matrice[p][j] == '0')
                x = matrice[p][j];
            else
                x = 'H';
            if (matrice[i + 1][j] == x)
                k++;
            if (k == (n - 1))
                return x;
        }
    }
    // verificare diagonala principala
    k = 0;
    if (matrice[p][q] == 'X' || matrice[p][q] == '0') {
        x = matrice[p][q];
    } else {
        x = 'H';
    }
    for (i = 0; i < n; i++) {
        if (matrice[p + i][q + i] == x)
            k++;
        if (k == n)
            return x;
    }
    // verificare diagonala secundara
    k = 0;
    if (matrice[p][q + n - 1] == 'X' || matrice[p][q + n - 1] == '0')
        x = matrice[p][q + n - 1];
    else
        x = 'H';
    for (i = 0; i < n; i++) {
        if (x == matrice[p + i][q + n - 1 - i]) {
            k++;
        }
        if (k == n)
            return x;
    }
    return '-';
}

void
afisare_mini_matrice(char matrice[][NMAX], long p, long q, long n_lin_col) {
    long i, j, n;
    n = n_lin_col;
    for (i = p; i < p + n; i++) {
        for (j = q; j < q + n; j++) {
            printf(" %c", matrice[i][j]);
        }
        printf("\n");
    }
}

void
minimatrice(char matrice[][NMAX], long n_lin_col, char v[NMAX2][NMAX2], int ok,
            double contor[NMAX]) {
    long p, q, n, k;
    p = 0;
    q = 0;
    n = n_lin_col;
    k = 0;
    while (p < (n * n - n + 1)) {
        if (v[p / n][q / n] == '-') {
            v[p / n][q / n] = castigator(matrice, p, q, n);
            if (ok == 1) {
                if (castigator(matrice, p, q, n) == 'X') {
                    contor[7]++;
                }
                if (castigator(matrice, p, q, n) == '0') {
                    contor[8]++;
                }
            }
        }
        q = q + n;
        if (q > (n * n - n + 1)) {
            q = 0;
            p = p + n;
        }
    }
}

void verificare(char matrice[][NMAX], long n_lin_col) {
    long i, j, p = 0, q = 0, n, eror = 0;
    n = n_lin_col;
    for (i = p; i < (p + n); i++) {
        for (j = q; j < (q + n); j++) {
            printf("%c ", matrice[i][j]);
            if (j == n * n - 1)
                eror = 1;
        }
        printf("\n");
        if (i == (p + n - 1) && eror == 0) {
            q = q + n;
            i = p;
        }
        if (i == (p + n - 1) && eror == 1) {
            p = p + n;
            i = p;
            q = 0;
            eror = 0;
        }
        if (i == (n * n - 1) && eror == 1)
            break;

    }
}

void robin(char matrice[][NMAX], char jucator, long n_lin_col) {
    long i, control = 0, k;
    for (i = 0; i < n_lin_col; i++) {
        if ((matrice[i][i] != 'X') && matrice[i][i] != '0') {
            matrice[i][i] = jucator;
            control = 1;
            break;
        }
    }
    k = 1;
    while (control == 0) {
        for (i = 0; i < n_lin_col - k; i++) {
            if ((matrice[i][i + k] != 'X') && matrice[i][i + k] != '0') {
                matrice[i][i + k] = jucator;
                control = 1;
                break;
            }
        }
        if (control != 1) {
            for (i = 0; i < n_lin_col - k; i++) {
                if ((matrice[i + k][i] != 'X') && matrice[i + k][i] != '0') {
                    matrice[i + k][i] = jucator;
                    control = 1;
                    break;
                }
            }
        }
        k++;
    }
}

void incarcare_matrice(char matrice[][NMAX], long n_lin_col) {
    long i, j;
    for (i = 0; i < pow(n_lin_col, 2); i++)
        for (j = 0; j < pow(n_lin_col, 2); j++)
            matrice[i][j] = '*';
}

void afisare_matrice(char matrice[][NMAX], long n_lin_col) {
    long i, j;
    for (i = 0; i < pow(n_lin_col, 2); i++) {
        for (j = 0; j < pow(n_lin_col, 2); j++) {
            printf("%c ", matrice[i][j]);
        }
        printf("\n");
    }
}

void mutari(char matrice[][NMAX], long numar_mutari, long n_lin_col,
            char v[NMAX2][NMAX2], double contor[NMAX]) {
    long n = n_lin_col * n_lin_col, fullboard = 0;
    long i, x, y, erorr, k = 1;
    char jucator;
    int ok;
    for (i = 1; i <= numar_mutari; i++) {
        ok = 0;
        if (contor[3] + contor[4] == n * n) {
            scanf(" %c %ld %ld", &jucator, &x, &y);
            if (x < 0 || x >= n)
                fullboard = 2;
            else
                fullboard = 1;
        } else {
            erorr = 0;
            scanf(" %c %ld %ld", &jucator, &x, &y);
            k++;
            if (i % 2 == 1 && jucator == 'X') {
                if (x >= 0 && x < n && y >= 0 && y < n) {
                    if (matrice[x][y] == 'X' || matrice[x][y] == '0') {
                        printf("NOT AN EMPTY CELL\n");
                        robin(matrice, jucator, n);
                        contor[3]++;
                    } else {
                        matrice[x][y] = 'X';
                        contor[3]++;
                        ok = 1;
                    }

                } else {
                    printf("INVALID INDEX\n");
                    robin(matrice, jucator, n);
                    contor[3]++;
                }
            }
            if (i % 2 == 1 && jucator != 'X') {
                printf("NOT YOUR TURN\n");
                erorr = 1;
            }
            if (i % 2 == 0 && jucator == '0') {
                if (x >= 0 && x < n && y >= 0 && y < n) {
                    if (matrice[x][y] == 'X' || matrice[x][y] == '0') {
                        printf("NOT AN EMPTY CELL\n");
                        robin(matrice, jucator, n);
                        contor[4]++;
                    } else {
                        matrice[x][y] = '0';
                        contor[4]++;
                        ok = 1;
                    }

                } else {
                    printf("INVALID INDEX\n");
                    robin(matrice, jucator, n);
                    contor[4]++;
                }
            }
            if (i % 2 == 0 && jucator != '0') {
                printf("NOT YOUR TURN\n");
                erorr = 1;
            }
            if (erorr == 1) {
                i++;
                numar_mutari++;
            }
            if (erorr == 0)
                minimatrice(matrice, n_lin_col, v, ok, contor);
        }
    }
    if (fullboard == 1) {
        printf("NOT AN EMPTY CELL\n");
        printf("FULL BOARD\n");
    }
    if (fullboard == 2) {
        printf("INVALID INDEX\n");
        printf("FULL BOARD\n");
    }
}

int main() {
    double contor[NMAX] = {0, 0, 0, 0, 0, 0, 0, 0};
    char c[NMAX][NMAX];
    long n, m, k, fullboard = 0;
    scanf("%ld", &n);
    char v[NMAX2][NMAX2];
    scanf("%ld", &m);
    for (k = 0; k < n; k++) {
        for (long z = 0; z < n; z++) {
            v[k][z] = '-';
        }
    }
    incarcare_matrice(c, n);
    mutari(c, m, n, v, contor);

    for (k = 0; k < n; k++) {
        for (long z = 0; z < n; z++) {
            printf("%c", v[k][z]);
            if (v[k][z] == 'X') {
                contor[5]++;
            }
            if (v[k][z] == '0') {
                contor[6]++;
            }
        }
        printf("\n");
    }
    macroboard(v, 0, 0, n, contor);
    if (contor[1] > contor[2]) {
        printf("X won\n");
    }
    if (contor[2] > contor[1]) {
        printf("0 won\n");
    }
    long chr = 39;
    if (contor[1] == contor[2])
        printf("Draw again! Let%cs play darts!\n", chr);
    if (contor[3] == 0.0)
        printf("X N/A\n");
    else
        printf("X %.10lf\n", contor[7] / contor[3]);
    if (contor[4] == 0.0)
        printf("0 N/A\n");
    else
        printf("0 %.10lf\n", contor[8] / contor[4]);

    return 0;
}