priorityqueueasdf

import java.io.File;
import java.io.FileWriter;
import java.io.IOException;
import java.io.PrintWriter;
import java.util.*;
public class visitfj3 {

    static int N;
    public static void main(String[] args) throws IOException {
        Scanner in = new Scanner(new File("visitfj.in"));
        N = in.nextInt();
        int t = in.nextInt();
        int[][] squares = new int[N][N];
        Node[][][] nodes = new Node[N][N][3];
        int counter = 0;

        for(int i=0; i<N; i++) {
            for(int j=0; j<N; j++) {
                squares[i][j] = in.nextInt();
                for(int k=0; k<3; k++) {
                    nodes[i][j][k] = new Node(squares[i][j], counter, k);
                }
                counter++;
            }
        }

        for(int i=0; i<N; i++) {
            for(int j=0; j<N; j++) {
                for(int k=0; k<3; k++) {
                    if(j>0) {
                        nodes[i][j][k].addNeighbor(nodes[i][j-1][(k+1)%3]);
                    }
                    if(j<N-1) {
                        nodes[i][j][k].addNeighbor(nodes[i][j+1][(k+1)%3]);
                    }
                    if(i>0) {
                        nodes[i][j][k].addNeighbor(nodes[i-1][j][(k+1)%3]);
                    }
                    if(i<N-1) {
                        nodes[i][j][k].addNeighbor(nodes[i+1][j][(k+1)%3]);
                    }
                }
            }
        }

        Queue<Node> queue = new PriorityQueue<>();
        nodes[0][0][0].setValue(0);
        queue.add(nodes[0][0][0]);
        while(!queue.isEmpty()) {
            for(Node node :  queue.peek().neighbors) {
                if(node.getValue() == -1) {
                    queue.add(node);
                    node.setValue(queue.peek().getValue() + t + (node.getStep() % 3 == 0 ? node.getTime() : 0));
                }
                else {
                    if(node.getValue() > queue.peek().getValue() + t + (node.getStep() % 3 == 0 ? node.getTime() : 0)) {
                        queue.add(node);
                        node.setValue(queue.peek().getValue() + t + (node.getStep() % 3 == 0 ? node.getTime() : 0));
                    }
                }
            }
            queue.poll();
        }

        PrintWriter out = new PrintWriter(new FileWriter("visitfj.out"));
        out.print(Math.min(nodes[N-1][N-1][2].getValue(), Math.min(nodes[N-1][N-1][1].getValue(), nodes[N-1][N-1][0].getValue())));
        out.close();

        in.close();
    }


    public static class Node implements Comparable<Node>{
        private int value;
        private int index;
        private int time;
        private List<Node> neighbors;
        private int step;
        public Node(int time, int index, int step) {
            this.time = time;
            this.index = index;
            this.step = step;
            neighbors = new ArrayList<>();
            value = -1;
        }
        public int getValue() {
            return value;
        }
        public void setValue(int value) {
            this.value = value;
        }
        public int getIndex() {
            return index;
        }
        public void setIndex(int index) {
            this.index = index;
        }
        public int getTime() {
            return time;
        }
        public void setTime(int time) {
            this.time = time;
        }
        public List<Node> getNeighbors() {
            return neighbors;
        }
        public void addNeighbor(Node node) {
            neighbors.add(node);
        }
        public void addNeighbors(Node...nodes) {
            for(Node node : nodes) {
                neighbors.add(node);
            }
        }
        public int getStep() {
            return step;
        }
        public void setStep(int step) {
            this.step = step;
        }

        @Override
        public int compareTo(Node o) {
            return this.value - o.getValue();
        }

    }


}