import java.io.*;
import java.util.*;
import java.text.*;
import java.math.*;
import java.util.regex.*;

public class Solution {
  
  
    public static void print(int[][] matrix) {
      for (int i=0; i<matrix[0].length; i++) {
        for (int j=0; j<matrix[0].length; j++) {
            System.out.print(matrix[i][j]);
            if (j < matrix[0].length-1) {
                System.out.print(" ");
            }
            if (j == matrix[0].length-1) {
                System.out.print("\n");
            }                
        }
      }
    }
    
    public static int calculate_cost(int[][] matrix, int[][] refmatrix) {
        if (matrix == null || refmatrix == null) {
            throw new RuntimeException("Invalid arguments");
        }
        
        //Both should be square matrices of the same length
        int n = matrix.length;
        int n1 = refmatrix.length;
        if (n != n1) {
          throw new RuntimeException("Invalid arguments. Cannot calculate cost for matrices of different length");
        }
        
        if (n == 0) {
            return 0;
        }
        
        int cost = 0;
        for (int i = 0; i < n; i++) {
            for (int j = 0; j < n; j++) {
                cost += Math.abs(matrix[i][j] - refmatrix[i][j]);
            }
        }
        
        return cost;
        
    }
    
    public static int[][] reflect(int[][] matrix) {
        if (matrix == null || matrix.length == 0) {
          return matrix;
        }
        
        int n = matrix.length;
        int[][] refl_matrix = new int[n][n];
        
        for (int i = 0; i < n; i++) {
            for (int j = 0; j < n; j++) {
                refl_matrix[i][j] = matrix[n-1-i][j];
            }
        }
        
        return refl_matrix;
    }
    
    public static int[][] rotate90DegreesClockwise(int[][] matrix) {
        if (matrix == null || matrix.length == 0) {
            return matrix;
        }
        
        int n = matrix.length;
        //Check if it is a square matrix
        for (int i=0; i<n; i++) {
            if (matrix[i].length != n) {
                throw new RuntimeException("Input is not a square matrix");
            }
        }
        
        int[][] rmatrix = new int[n][n];
        for (int i=0; i < n; i++) {
            for (int j=0; j < n; j++) {
                rmatrix[i][j] = matrix[n - 1 - j][i];
            }
        }
        
        return rmatrix;
    }
    
    public static void main(String[] args) {
        Scanner in = new Scanner(System.in);
        int[][] matrix = new int[3][3];
        int x = -1;
        int y = -1;        
        for (int i=0; i<9; i++) {
            y = i%3;
            x = i/3;
            matrix[x][y] = in.nextInt();
        }
        
        in.close();
        //System.out.println("=======================");
        //print(matrix);
        
        //System.out.println("=======================");
        //int[][] rmatrix = rotate90DegreesClockwise(matrix);
        //print(rmatrix);
        
        //System.out.println("=======================");
        //System.out.println("=======================");
        //System.out.println("=======================");
        //Get a perfect magic square and compare the cost
        int[][] magic_square = new int[3][3];
        magic_square[0] = new int[]{4, 9, 2};
        magic_square[1] = new int[]{3, 5, 7};
        magic_square[2] = new int[]{8, 1, 6};
        
        int mincost = calculate_cost(matrix, magic_square);
        if (mincost != 0) {
            int[][] refl = reflect(magic_square);
            int tcost = calculate_cost(matrix, refl);
            if (tcost < mincost) {
                mincost = tcost;
            }
        }
        
        if (mincost != 0) {
            for (int i = 0; i <= 3; i++) {
                //System.out.println("i="+i);
                magic_square = rotate90DegreesClockwise(magic_square);
                int tcost = calculate_cost(matrix, magic_square);
                //System.out.println("After rotate tcost="+tcost+"mincost="+mincost);
                if (tcost == 0) {
                    mincost = tcost;
                    break;
                } else if (tcost < mincost) {
                    mincost = tcost;
                }

                //Reflect the matrix and verify
                int[][] refl = reflect(magic_square);
                tcost = calculate_cost(matrix, refl);
                //System.out.println("After reflect tcost="+tcost+"mincost="+mincost);
                if (tcost == 0) {
                    mincost = tcost;
                    break;
                } else if (tcost < mincost) {
                    mincost = tcost;
                }
            }
        }
        
        System.out.println(mincost);
        
    }

}