#include <bits/stdc++.h>
using namespace std;

const int N = 6;
int M;

using Grid = array<array<int, N>, N>;
unordered_map<string, int> memo;

string grid_to_string(const Grid& A) {
    stringstream ss;
    for (int i = 0; i < N; ++i) {
        for (int j = 0; j < N; ++j) {
            ss << A[i][j] << ",";
        }
    }
    return ss.str();
}

vector<Grid> move(const Grid& A, int a) {
    vector<int> I, J;
    for (int i = 0; i < N; ++i) {
        for (int j = 0; j < N; ++j) {
            if (A[i][j] == a) {
                I.push_back(i);
                J.push_back(j);
            }
        }
    }

    vector<Grid> retu;
    if (J.front() == J.back()) {
        for (int di : {-1, 1}) {
            Grid B = A;
            bool ok = true;
            for (size_t idx = 0; idx < I.size(); ++idx) {
                B[I[idx]][J[idx]] = 0;
            }
            for (size_t idx = 0; idx < I.size(); ++idx) {
                int ni = I[idx] + di, nj = J[idx];
                if (0 <= ni && ni < N && 0 <= nj && nj < N && (B[ni][nj] == 0 || B[ni][nj] == a)) {
                    B[ni][nj] = A[I[idx]][J[idx]];
                } else {
                    ok = false;
                    break;
                }
            }
            if (ok) retu.push_back(B);
        }
    } else {
        for (int dj : {-1, 1}) {
            Grid B = A;
            bool ok = true;
            for (size_t idx = 0; idx < I.size(); ++idx) {
                B[I[idx]][J[idx]] = 0;
            }
            for (size_t idx = 0; idx < I.size(); ++idx) {
                int ni = I[idx], nj = J[idx] + dj;
                if (0 <= ni && ni < N && 0 <= nj && nj < N && (B[ni][nj] == 0 || B[ni][nj] == a)) {
                    B[ni][nj] = A[I[idx]][J[idx]];
                } else {
                    ok = false;
                    break;
                }
            }
            if (ok) retu.push_back(B);
        }
    }

    return retu;
}

int solve(Grid A, int cnt) {
    if (cnt <= 1) return -1;
    if (A[2][5] == 1 && A[2][4] == 1) return cnt - 2;

    string key = grid_to_string(A) + "," + to_string(cnt);
    if (memo.count(key)) return memo[key];

    int retu = -1;
    for (int a = 1; a <= M; ++a) {
        for (auto& B : move(A, a)) {
            retu = max(retu, solve(B, cnt - 1));
        }
    }

    return memo[key] = retu;
}

int main() {
    Grid A;
    M = 0;
    for (int i = 0; i < N; ++i) {
        for (int j = 0; j < N; ++j) {
            cin >> A[i][j];
            M = max(M, A[i][j]);
        }
    }

    int ans = solve(A, 10);
    if (ans != -1) ans = 10 - ans;
    cout << ans << endl;

    return 0;
}