// Verificar un producto de matrices al azar: ¿A·B = C módulo p = 10^9 + 7?
// La lectura ya está escrita. Falta el algoritmo de Freivalds, en probably_equal.
#include <cstddef>
#include <cstdint>
#include <cstdio>
#include <iostream>
#include <random>
#include <vector>

const std::uint64_t kPrime = 1'000'000'007;
const int kRounds = 30;

// Lee enteros sin signo de la entrada estándar por bloques. Con 12 millones de números, leerlos
// uno por uno con std::cin tarda más que todo el algoritmo.
struct Reader {
    std::vector<char> buffer = std::vector<char>(1 << 16);
    std::size_t size = 0;
    std::size_t position = 0;

    // El siguiente carácter de la entrada, o -1 si ya no hay más.
    int next_char() {
        if (position == size) {
            size = std::fread(buffer.data(), 1, buffer.size(), stdin);
            position = 0;
            if (size == 0) {
                return -1;
            }
        }
        return static_cast<unsigned char>(buffer[position++]);
    }

    // El siguiente número: salta lo que no sea un dígito y junta los dígitos seguidos.
    std::uint32_t next_number() {
        int c = next_char();
        while (c != -1 && (c < '0' || c > '9')) {
            c = next_char();
        }
        std::uint32_t value = 0;
        while (c >= '0' && c <= '9') {
            value = value * 10 + static_cast<std::uint32_t>(c - '0');
            c = next_char();
        }
        return value;
    }
};

// Una matriz de n×n guardada por filas en un solo vector: la entrada (i, j) está en [i·n + j].
// Las entradas son menores que p < 2^30, así que caben en 32 bits. Sus productos no.
using Matrix = std::vector<std::uint32_t>;

Matrix read_matrix(Reader& in, std::size_t n) {
    Matrix m(n * n);
    for (std::uint32_t& x : m) {
        x = in.next_number();
    }
    return m;
}

// Por hacer: kRounds rondas de Freivalds. En cada una, elegir un vector r de n ceros y unos al
// azar, calcular A·(B·r) y C·r módulo kPrime, y devolver false apenas sean distintos.
// Cuidado con el overflow: el producto de dos entradas no cabe en 32 bits.
bool probably_equal(const Matrix& a, const Matrix& b, const Matrix& c, std::size_t n, std::mt19937_64& rng) {
    // Este esqueleto no hace ninguna ronda: responde siempre "iguales", y el juez da WA en los
    // casos en que la respuesta es "distintos".
    (void)a, (void)b, (void)c, (void)n, (void)rng;  // todavía no se usan
    return true;
}

int main() {
    Reader in;
    const std::size_t n = in.next_number();
    const Matrix a = read_matrix(in, n);
    const Matrix b = read_matrix(in, n);
    const Matrix c = read_matrix(in, n);

    // Para el juez sirve cualquier semilla. Con una fija, su programa responde siempre lo mismo
    // con la misma entrada, y eso ayuda a depurar.
    std::mt19937_64 rng(1);
    std::cout << (probably_equal(a, b, c, n, rng) ? "iguales" : "distintos") << "\n";
    return 0;
}
