import java.io.*
import java.math.*
import java.security.*
import java.text.*
import java.util.*
import java.util.concurrent.*
import java.util.function.*
import java.util.regex.*
import java.util.stream.*
import kotlin.collections.*
import kotlin.comparisons.*
import kotlin.io.*
import kotlin.jvm.*
import kotlin.jvm.functions.*
import kotlin.jvm.internal.*
import kotlin.ranges.*
import kotlin.sequences.*
import kotlin.text.*

/*
 * Complete the 'formingMagicSquare' function below.
 *
 * The function is expected to return an INTEGER.
 * The function accepts 2D_INTEGER_ARRAY s as parameter.
 */

fun formingMagicSquare(initial: Array<Array<Int>>): Int {
    var minChanges = Int.MAX_VALUE
    var minSquare = arrayOf(arrayOf(0))
    val allMagicSquares = formingEveryPossibleMagicSquare()
    allMagicSquares.remove(initial)
    allMagicSquares.forEach { magicSquare ->
        val changesDone = calculateChanges(initial, magicSquare)
        if (changesDone < minChanges) {
            minChanges = changesDone
            minSquare = magicSquare
        }
    }
    return minChanges
}

fun formingEveryPossibleMagicSquare(): MutableList<Array<Array<Int>>> {
    val magicSquares: MutableList<Array<Array<Int>>> = mutableListOf()
    for (q in 1..9) {
        for (w in 1..9) {
            if (!w.isNotEqualTo(q)) continue
            for (e in 1..9) {
                if (!e.isNotEqualTo(q, w)) continue
                for (a in 1..9) {
                    if (!a.isNotEqualTo(q, w, e)) continue
                    for (s in 1..9) {
                        if (!s.isNotEqualTo(q, w, e, a)) continue
                        for (d in 1..9) {
                            if (!d.isNotEqualTo(q, w, e, a, s)) continue
                            for (z in 1..9) {
                                if (!z.isNotEqualTo(q, w, e, a, s, d)) continue
                                for (x in 1..9) {
                                    if (!x.isNotEqualTo(q, w, e, a, s, d, z)) continue
                                    for (c in 1..9) {
                                        if (!c.isNotEqualTo(q, w, e, a, s, d, z, x)) continue
                                        val row1 = arrayOf(q, w, e)
                                        val row2 = arrayOf(a, s, d)
                                        val row3 = arrayOf(z, x, c)
                                        val newSquare = arrayOf(row1, row2, row3)
                                        if (areSumsCorrect(newSquare)) {
                                            magicSquares.add(newSquare)
                                        }
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
    return magicSquares
}

fun Int.isNotEqualTo(vararg other: Int) =
    other.none { it == this }

fun calculateChanges(initial: Array<Array<Int>>, changed: Array<Array<Int>>): Int {
    var changes = 0
    for (i in 0..2) {
        for (j in 0..2) {
            val difference = initial[i][j] - changed[i][j]
            changes += Math.abs(difference)
        }
    }
    return changes
}

private fun areSumsCorrect(square: Array<Array<Int>>): Boolean {
    val allRowSums = square.map {
        it.sum()
    }
    val allColumnSums = listOf(
        square[0][0] + square[1][0] + square[2][0],
        square[0][1] + square[1][1] + square[2][1],
        square[0][2] + square[1][2] + square[2][2]
    )
    
    val diagonalSums = listOf(
        square[0][0] + square[1][1] + square[2][2],
        square[0][2] + square[1][1] + square[2][0]
    )
    val allSums = allRowSums + allColumnSums + diagonalSums
    
    return allSums.all { it == allSums[0] }
}

fun main(args: Array<String>) {

    val s = Array<Array<Int>>(3, { Array<Int>(3, { 0 }) })

    for (i in 0 until 3) {
        s[i] = readLine()!!.trimEnd().split(" ").map{ it.toInt() }.toTypedArray()
    }

    val result = formingMagicSquare(s)

    println(result)
}

        int[,,] matrix_list = new[,,] { {{8, 1, 6}, {3, 5, 7}, {4, 9, 2}}, 
                                    {{6, 1, 8}, {7, 5, 3}, {2, 9, 4}},
                                    {{4, 9, 2}, {3, 5, 7}, {8, 1, 6}},
                                    {{2, 9, 4}, {7, 5, 3}, {6, 1, 8}},
                                    {{8, 3, 4}, {1, 5, 9}, {6, 7, 2}},
                                    {{4, 3, 8}, {9, 5, 1}, {2, 7, 6}},
                                    {{6, 7, 2}, {1, 5, 9}, {8, 3, 4}},
                                    {{2, 7, 6}, {9, 5, 1}, {4, 3, 8}} };
        int minumum = Int32.MaxValue;                   
        for(int x = 0; x < 8; x++)
        {
            int toplam = 0;
            for(int i=0; i < 3; i++)
            {
                for(int j =0 ;j <3 ; j++)
                {   
                    toplam += Math.Abs((s[i][j] - matrix_list[x,i,j]));
                
                }
            }
            minumum = Math.Min(minumum, toplam);
        }
        return minumum;

public static int formingMagicSquare(List<List<Integer>> s) {
    
      final List<List<Integer>> magicSquares = Arrays.asList(
                Arrays.asList(6, 1, 8, 7, 5, 3, 2, 9, 4),
                Arrays.asList(8, 1, 6, 3, 5, 7, 4, 9, 2),
                Arrays.asList(6, 7, 2, 1, 5, 9, 8, 3, 4),
                Arrays.asList(8, 3, 4, 1, 5, 9, 6, 7, 2),
                Arrays.asList(2, 7, 6, 9, 5, 1, 4, 3, 8),
                Arrays.asList(4, 3, 8, 9, 5, 1, 2, 7, 6),
                Arrays.asList(2, 9, 4, 7, 5, 3, 6, 1, 8),
                Arrays.asList(4, 9, 2, 3, 5, 7, 8, 1, 6)); 
                
        
        
        List<Integer> flatList = s.stream().flatMap(x -> x.stream()).collect(Collectors.toList());
        
        int result = magicSquares.stream().map(x -> {

            int sum = 0;
            for (int i = 0; i < x.size(); i++) {
                int listDiff = x.get(i) - flatList.get(i);
                sum += Math.max(listDiff, listDiff * -1);
            }

            return sum;

        }).mapToInt(x -> x).min().getAsInt();
    
    return result;

    }

}

def formingMagicSquare(s):
    msp = {
    0:[8,1,6,3,5,7,4,9,2],
    1:[6,1,8,7,5,3,2,9,4],
    2:[4,9,2,3,5,7,8,1,6],
    3:[2,9,4,7,5,3,6,1,8],
    4:[8,3,4,1,5,9,6,7,2],
    5:[4,3,8,9,5,1,2,7,6],
    6:[6,7,2,1,5,9,8,3,4],
    7:[2,7,6,9,5,1,4,3,8],
    }

    box = [*s[0], *s[1], *s[2]]

    result = [0, 0, 0, 0, 0, 0, 0, 0]

    for x in range(9):
            result[0] += abs(msp[0][x] - box[x])
            result[1] += abs(msp[1][x] - box[x])
            result[2] += abs(msp[2][x] - box[x])
            result[3] += abs(msp[3][x] - box[x])
            result[4] += abs(msp[4][x] - box[x])
            result[5] += abs(msp[5][x] - box[x])
            result[6] += abs(msp[6][x] - box[x])
            result[7] += abs(msp[7][x] - box[x])
    return min(result)