#include <cstdio>

namespace Pre{

  inline void read(int &sum){

    register char ch=getchar();

    for(sum=;ch<''||ch>'';ch=getchar());

    for(;ch>=''&&ch<='';sum=(sum<<)+(sum<<)+ch-'',ch=getchar());

  }

  inline int Max(int x,int y){

    return x>y?x:y;

  }

  inline int Abs(int x){

    return x<?-x:x;

  }

  int bin[],have[][],pos[][],val[][];

  inline void Init(){

    bin[]=;

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

      bin[i]=bin[i-]<<;

    int full=(<<)-;

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

      for(int j=;j>;j--)

        if((bin[j]&i)==){

          have[i][++have[i][]]=j;

        }

  }

  int ans;

}

namespace Handle{

  int line[],column[],big_lattice[],key[][];

}

namespace point{

  struct Point{

    int x,y;

    inline friend Point operator + (Point a,Point b);

    inline void operator += (Point a){

      *this=(*this)+a;

    }

  }S,X,Z,Y,N,Queue[];

  int len;

  inline Point operator + (Point a,Point b){

      return (Point){a.x+b.x,a.y+b.y};

  }

  inline void Init(){

    N.x=,N.y=;

    S.x=-,S.y=;

    X.x=,X.y=;

    Z.x=,Z.y=-;

    Y.x=,Y.y=;

  }

  inline Point To(){

    int Dis=Pre::Max(Pre::Abs(N.x-),Pre::Abs(N.y-));

    if(N.y==Dis+&&N.x!=Dis+)return X;

    if(N.x==Dis+&&N.y!=-Dis)return Z;

    if(N.x==-Dis&&N.y!=-Dis&&N.y!=+Dis)return Y;

    if(N.y==-Dis)return S;

  }

  inline int get_val(Point p){

    int Dis=Pre::Max(Pre::Abs(p.x-),Pre::Abs(p.y-));

    return -Dis;

  }

  inline int get_pos(Point p){

    return (p.x-)/*+(p.y-)/+;

  }

  inline void get_queue(){

    if(N.x==)return;

    if(Handle::key[N.x][N.y]){

      N+=To();

      get_queue();

      return;

    }

    Queue[++len]=N;

    N+=To();

    get_queue();

  }

}

namespace Handle{

  inline void Insert(point::Point p,int Key){

    using Pre::bin;

    using Pre::pos;

    key[p.x][p.y]=Key;

    line[p.x]|=bin[Key];

    column[p.y]|=bin[Key];

    big_lattice[pos[p.x][p.y]]|=bin[Key];

  }

  inline void Delete(point::Point p){

    using Pre::bin;

    using Pre::pos;

    line[p.x]^=bin[key[p.x][p.y]];

    column[p.y]^=bin[key[p.x][p.y]];

    big_lattice[pos[p.x][p.y]]^=bin[key[p.x][p.y]];

    key[p.x][p.y]=;

  }

}

namespace Main{

  void Init(){

    using namespace point;

    Pre::Init();

    point::Init();

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

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

        Pre::pos[i][j]=get_pos((Point){i,j}),

        Pre::val[i][j]=get_val((Point){i,j});

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

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

        Pre::read(x),Handle::Insert((Point){i,j},x),Pre::ans+=Pre::val[i][j]*x;

    get_queue();

    using namespace Handle;

    using Pre::pos;

    using Pre::val;

    using Pre::have;

  }

  void dfs(int Now,int Had){

    if(Now==){

      Pre::ans=Pre::Max(Pre::ans,Had);

      return;

    }

    using namespace point;

    using namespace Handle;

    using Pre::pos;

    using Pre::val;

    using Pre::have;

    int Can=line[Queue[Now].x]|column[Queue[Now].y]|big_lattice[pos[Queue[Now].x][Queue[Now].y]];

    for(int i=;i<=have[Can][];i++){

      Handle::Insert(Queue[Now],have[Can][i]);

      dfs(Now-,Had+have[Can][i]*val[Queue[Now].x][Queue[Now].y]);

      Handle::Delete(Queue[Now]);

    }

  }

  inline void Work(){

    int HAD=Pre::ans;

    dfs(point::len,HAD);

    if(point::len!=&&HAD==Pre::ans)Pre::ans=-;

  }

}

int main(){

  freopen("sudoku.in", "r", stdin);

  freopen("sudoku.out", "w", stdout);

  Main::Init();

  Main::Work();

  printf("%d",Pre::ans);

  return ;

}