#include<cstdio>

 #include<iostream>

 #include<cstring>

 #include<algorithm>

 #include<cmath>

 #include<iomanip>

 using namespace std;

 const int n=,m=;

 bool mx[][];//数独转化过来的01矩阵

 int map[][],cnt[],head,cur,ans;

 int sqr[][]={{,,,,,,,,,},  //九宫格的编号

                {,,,,,,,,,},

                {,,,,,,,,,},

                {,,,,,,,,,},

                {,,,,,,,,,},

                {,,,,,,,,,},

                {,,,,,,,,,},

                {,,,,,,,,,},

                {,,,,,,,,,},

                {,,,,,,,,,}};

 int w[][]={{,,,,,,,,,},

                {,,,,,,,,,},

                {,,,,,,,,,},

                {,,,,,,,,,},

                {,,,,,,,,,},

                {,,,,,,,,,},

                {,,,,,,,,,},

                {,,,,,,,,,},

                {,,,,,,,,,},

                {,,,,,,,,,}};

 struct point

 {

     int row,lc,rc,up,down,col;//元素的上下左右，行号和列标

 }node[*];

 inline int id(int x,int y)

 {

     return (x-)*+y;//格子（x，y）的编号

 }

 void init(int c)//初始化列标元素

 {

     for (int i=;i<=c;i++)

     {

         node[i].lc=i-;

         node[i].rc=i+;

         node[i].up=node[i].down=node[i].col=i;

     }

     node[].lc=c;

     node[c].rc=;

 }

 void build_link()//把01矩阵中的 1 用dancing link 连接

 {

     cur=m;

     for (int i=;i<=n;i++)

     {

         int start,pre;

         start=pre=cur+;

         for (int j=;j<=m;j++)

             if (mx[i][j])

             {

                 cur++;

                 cnt[j]++;

                 node[cur].row=i;

                 node[cur].lc=pre;

                 node[cur].rc=start;

                 node[pre].rc=cur;

                 node[start].lc=cur;

                 node[cur].col=j;

                 node[cur].up=node[j].up;

                 node[cur].down=j;

                 node[node[j].up].down=cur;

                 node[j].up=cur;

                 pre=cur;

             }

     }

 }

 inline void cover(int c)//删除冲突元素

 {

     for (int i=node[c].up;i!=c;i=node[i].up)

         for (int j=node[i].rc;j!=i;j=node[j].rc)

         {

             node[node[j].up].down=node[j].down;

             node[node[j].down].up=node[j].up;

             cnt[node[j].col]--;

         }

     node[node[c].lc].rc=node[c].rc;

     node[node[c].rc].lc=node[c].lc;

 }

 inline void uncover(int c)//恢复冲突元素

 {

     for (int i=node[c].up;i!=c;i=node[i].up)

         for (int j=node[i].rc;j!=i;j=node[j].rc)

         {

             node[node[j].up].down=j;

             node[node[j].down].up=j;

             cnt[node[j].col]++;

         }

     node[node[c].lc].rc=c;

     node[node[c].rc].lc=c;

 }

 void read_data()//把数独转化成01矩阵

 {

     for (int i=;i<=;i++)

         for (int j=;j<=;j++)

         {

             scanf("%d",&map[i][j]);

             int c=id(i,j),t,k;

             if (map[i][j])//数独中本来有数，直接加入

             {

                 k=map[i][j];

                 t=(c-)*+k;

                 mx[t][c]=true;

                 mx[t][+*(i-)+k]=true;

                 mx[t][+*(j-)+k]=true;

                 mx[t][+(sqr[i][j]-)*+k]=true;

             }

             else

             {

                 for (k=;k<=;k++) //数独中本来没数，那么加入1-9的情况

                 {

                     t=(c-)*+k;

                     mx[t][c]=true;

                     mx[t][+*(i-)+k]=true;

                     mx[t][+*(j-)+k]=true;

                     mx[t][+(sqr[i][j]-)*+k]=true;

                 }

             }

         }

 }

 bool dfs(int step,int score)

 {

     if (node[head].rc==head) //已经全部覆盖

     {

         ans=max(score,ans);

         return true;

     }

     int i,j,c,t=,x,y,num,flag=;

     for (i=node[head].rc;i!=head;i=node[i].rc) //启发式，每次处理元素最少的列

         if (cnt[i]<t)

         {

             t=cnt[i];

             c=i;

         }

     if (t==)

         return false;

     cover(c);//覆盖当前列 

     for (i=node[c].down;i!=c;i=node[i].down)

     {

         for (j=node[i].lc;j!=i;j=node[j].lc)//删除冲突的行

             cover(node[j].col);

         num=(node[i].row-)/+;

         x=(num-)/+;

         y=num-*(x-);

         flag|=dfs(step+,score+w[x][y]*(node[i].row-(num-)*));

         for (j=node[i].rc;j!=i;j=node[j].rc)//恢复删除冲突的行

             uncover(node[j].col);

     }

     uncover(c);//恢复当前列

     return flag;

 }

 void solve()

 {

     init(m);

     build_link();

     int flag=;

     if (!dfs(,))

         printf("-1\n");

     else printf("%d\n",ans);

 }

 int main()

 {

     read_data();

     solve();

     return ;

 }