Problem: People do many crazy things to stand out in a crowd. Some of them dance, some learn by heart rules of Russian language, some try to become an outstanding competitive programmers, while others collect funny math objects.

Alis is among these collectors. Right now she wants to get one of k-special tables. In case you forget, the table n × n is called k-special if the following three conditions are satisfied:

  * every integer from 1 to n2 appears in the table exactly once; 
  * in each row numbers are situated in increasing order; 
  * the sum of numbers in the k-th column is maximum possible. 



Your goal is to help Alice and find at least one k-special table of size n × n. Both rows and columns are numbered from 1 to n, with rows numbered from top to bottom and columns numbered from left to right.

Input

The first line of the input contains two integers n and k (1 ≤ n ≤ 500, 1 ≤ k ≤ n) — the size of the table Alice is looking for and the column that should have maximum possible sum.

Output

First print the sum of the integers in the k-th column of the required table.

Next n lines should contain the description of the table itself: first line should contains n elements of the first row, second line should contain n elements of the second row and so on.

If there are multiple suitable table, you are allowed to print any.

Examples

Input

4 1


Output

28
1 2 3 4
5 6 7 8
9 10 11 12
13 14 15 16


Input

5 3


Output

85
5 6 17 18 19
9 10 23 24 25
7 8 20 21 22
3 4 14 15 16
1 2 11 12 13

Solution (in JAVA):

Solution:

import java.io.*;
import java.util.*;

public class test {
    int max = 0;
    long max1 = 0;
    boolean visited[][];
    boolean visit[];
    int parent[];
    boolean bi = true;
    StringBuilder cout = new StringBuilder("");
    int color[];
    PrintStream out = System.out;
    int signx[] = {1, -1, 0, 0, 1, -1, -1, 1};
    int signy[] = {0, 0, 1, -1, 1, -1, 1, -1};

    public static void main(String args[]) throws IOException {
        test obj = new test();
        obj.start();
    }

    // displaying Map contents key--value
    public static void printMap(Map mp) {
        Iterator it = mp.entrySet().iterator();
        while (it.hasNext()) {
            Map.Entry pair = (Map.Entry) it.next();
            System.out.println(pair.getKey() + " = " + pair.getValue());
            it.remove(); // avoids a ConcurrentModificationException
        }
    }


    //<---------------------------------------------------------------------------------------------------------------->//

    // check whether the number is prime or not
    public static boolean isPrimeNumber(int i) {
        int factors = 0;
        int j = 1;

        while (j <= i) {
            if (i % j == 0) {
                factors++;
            }
            j++;
        }
        return (factors == 2);
    }

    public boolean isPrimeNumber(long i) {
        long j = 2;

        while (j <= Math.sqrt(i)) {
            if (i % j == 0) {
                return false;
            }
            j++;
        }
        return true;
    }

    void start() throws IOException {
        Reader sc = new Reader();
        //BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
        //Scanner sc = new Scanner(System.in);
        // String s[]=br.readLine().split(" ");
        int n=sc.nextInt();
        int k=sc.nextInt();
        int arr[][]=new int[n][n];
        int t=1;

          for(int i=0;i<n;i++)
          {
              for(int j=0;j<k-1;j++)
              {
                  arr[i][j]=t++;
              }
          }
          for(int i=0;i<n;i++)
          {
              for(int j=k-1;j<n;j++)
                  arr[i][j]=t++;
          }
        int count=0;
        for(int i=0;i<n;i++)
            count+=arr[i][k-1];
        out.println(count);
        for (int i = 0; i <n ; i++) {
            for (int j = 0; j <n ; j++) {
             out.print(arr[i][j]+" ");
            }
            out.println();
        }
    }
int bfsDistance(int graph[][],int start,int end )
{
    boolean visit[]=new boolean[graph.length];
    ArrayList<Integer> queue=new ArrayList<Integer>();
    queue.add(start);
    visit[start]=true;
    int distance=0;
    while(!queue.isEmpty())
    {
        int len=queue.size();
        distance++;
        while(len-->0) {
            int current = queue.get(0);
            queue.remove(0);
            for (int i = 0; i < graph.length; i++) {
                if (graph[current][i] == 1 && !visit[i]) {
                    queue.add(i);
                    visit[i] = true;
                }
            }
        }
       if(visit[end])
           return distance;
    }
    return -1;
}

    int maximumSubArray(int a[], int p, int q) {
        if (p == q) {
            if (a[p] < 0)
                return 0;
            else
                return a[p];
        }
        int mid = (p + q) / 2;
        int sum1 = maximumSubArray(a, p, mid);
        int sum2 = maximumSubArray(a, mid + 1, q);
        int sum3 = 0;
        for (int i = mid; i >= 0; i--) {
            if (a[i] < 0)
                break;
            sum3 += a[i];
        }
        for (int i = mid + 1; i < a.length; i++) {
            if (a[i] < 0)
                break;
            sum3 += a[i];
        }
        return Math.max(sum1, Math.max(sum3, sum2));
    }


    //printing 2-d array
    private void println(int[][] a, int n, int m) {
        for (int i = 0; i < n; i++) {
            for (int j = 0; j < m; j++)
                System.out.print(a[i][j] + " ");
            System.out.println();
        }

    }

    void dfs(char a[][], char t, int i, int j, int n, int m, int p, int q) {
        //  out.print(" "+i+" "+j+" "+t);
        visited[i][j] = true;
        for (int c = 0; c < 4; c++) {
            int temp = i + signx[c];
            int temp1 = j + signy[c];
            if (temp >= 0 && temp < n && temp1 >= 0 && temp1 < m) {
                if (a[temp][temp1] == t && (temp != p || temp1 != q) && !visited[temp][temp1])
                    dfs(a, t, temp, temp1, n, m, i, j);
                else if (a[temp][temp1] == t && (temp != p || temp1 != q) && visited[temp][temp1]) {
                    max = 1;
                }
            }
        }

    }

    void println(ArrayList<Long> a) {
        for (Long b : a
                ) {
            System.out.print(b + " ");
        }
    }

    //modified dfs for chessboard, matrix
    void dfs(char a[][], int i, int j, char t, int n, int m, int d, int p, int q, boolean visited[][]) {

    }

    //constructing segment tree
    private void constructseg(long[] seg, long[] input, int p, int q, int pos) {
        if (p == q) {
            seg[pos] = input[p];
            return;
        }
        int mid = (q + p) / 2;
        constructseg(seg, input, p, mid, 2 * pos + 1);
        constructseg(seg, input, mid + 1, q, 2 * pos + 2);
        seg[pos] = seg[2 * pos + 1] + seg[2 * pos + 2];
    }

    /*  void bipartite(ArrayList<Integer> a[],int i)
      {
          int presentcolor=color[i];
          int nextcolor;
          if(color[i]==0) {
              nextcolor=1;
            b.add(i);
          }
          else
          {
              nextcolor=0;
              c.add(i);
          }
          for(int j=0;j<a[i].size();j++)
          {
              if(color[a[i].get(j)]==presentcolor)
                  bi=false;
              else if(color[a[i].get(j)]==-1)
              {
                  color[a[i].get(j)]=nextcolor;
                  bipartite(a,a[i].get(j));
              }
          }

      }*/
    //traversing through a arrayList graph
    void dfs(ArrayList<Integer> node[], int i) {

      /*  visited[i]=true;
   /*     if(cat[i]==1) {
            count++;
        }
        else
            count=0;
        if(count>k) {
            return;
        }
        if(node[i].size()==1&&i!=0) {
            max += 1;
        }
        for (int j = 0; j < node[i].size(); j++) {
            if(!visited[node[i].get(j)]) {
                max--;
                dfs(node, node[i].get(j));
            }
        }*/

    }

    //printing arraylist array
    void println(ArrayList<Integer> a[]) {
        for (ArrayList<Integer> b : a
                ) {
            System.out.println(b.toString());
        }
    }

    //sorting 2 array based on a, Complexity is O(n^2)
    void sort(int a[], int b[], int n) {
        for (int i = 1; i < n; i++) {
            int index = i;
            for (int j = i - 1; j >= 0; j--) {
                //  println(a);
                if (a[index] < a[j]) {
                    int temp = a[index];
                    int temp2 = b[index];
                    a[index] = a[j];
                    b[index] = b[j];
                    a[j] = temp;
                    b[j] = temp2;
                    index = j;

                } else
                    break;
            }
        }

    }

    // to create and initialize Integer array
    private int[] intArray(int a, Scanner sc) {
        int temp[] = new int[a];
        for (int i = 0; i < a; i++) {
            temp[i] = sc.nextInt();
        }
        return temp;
    }

    private int[] intArray(int a, Reader sc) throws IOException {
        int temp[] = new int[a];
        for (int i = 0; i < a; i++) {
            temp[i] = sc.nextInt();
        }
        return temp;
    }// / to create and initialize Long Array

    private long[] longArray(int a, Scanner sc) {
        long temp[] = new long[a];
        for (int i = 0; i < a; i++) {
            temp[i] = sc.nextLong();
        }
        return temp;
    }

    // Return arrayList of minimum factor of number
    // 24= 2*2*2*3;
    private ArrayList<Integer> minFactor(int a) {
        ArrayList<Integer> obj = new ArrayList<>();
        for (int i = 2; i <= a; i++) {
            while (a != 0 && a % i == 0) {
                obj.add(i);
                a /= i;
            }
        }
        return obj;
    }

    // creating and initializing arrayList
    private void initArrayList(ArrayList<Integer>[] tempa) {
        for (int i = 0; i < tempa.length; i++)
            tempa[i] = new ArrayList<>();
    }

    // return factorial contents as ArrayList
    private ArrayList<Integer> factdigit(int i) {
        ArrayList<Integer> temp = new ArrayList<>();
        for (int j = i; j > 1; j--) {
            temp.add(j);
        }
        return temp;
    }

    //printing Integer array
    private void println(int a[]) {
        for (int i = 0; i < a.length; i++)
            System.out.print(a[i] + " ");
    }

    int factorial(int n) {
        if (n == 0)
            return 1;
        else
            return ((n % 1000000007) * (factorial(n - 1) % 1000000007));
    }
}


class Reader {
    final private int BUFFER_SIZE = 1 << 16;
    private DataInputStream din;
    private byte[] buffer;
    private int bufferPointer, bytesRead;

    public Reader() {
        din = new DataInputStream(System.in);
        buffer = new byte[BUFFER_SIZE];
        bufferPointer = bytesRead = 0;
    }

    public Reader(String file_name) throws IOException {
        din = new DataInputStream(new FileInputStream(file_name));
        buffer = new byte[BUFFER_SIZE];
        bufferPointer = bytesRead = 0;
    }

    public String readLine() throws IOException {
        byte[] buf = new byte[300]; // line length
        int cnt = 0, c;
        while ((c = read()) != -1) {
            if (c == '\n')
                break;
            buf[cnt++] = (byte) c;
        }
        return new String(buf, 0, cnt);
    }

    public int nextInt() throws IOException {
        int ret = 0;
        byte c = read();
        while (c <= ' ')
            c = read();
        boolean neg = (c == '-');
        if (neg)
            c = read();
        do {
            ret = ret * 10 + c - '0';
        } while ((c = read()) >= '0' && c <= '9');

        if (neg)
            return -ret;
        return ret;
    }

    public long nextLong() throws IOException {
        long ret = 0;
        byte c = read();
        while (c <= ' ')
            c = read();
        boolean neg = (c == '-');
        if (neg)
            c = read();
        do {
            ret = ret * 10 + c - '0';
        }
        while ((c = read()) >= '0' && c <= '9');
        if (neg)
            return -ret;
        return ret;
    }

    public double nextDouble() throws IOException {
        double ret = 0, div = 1;
        byte c = read();
        while (c <= ' ')
            c = read();
        boolean neg = (c == '-');
        if (neg)
            c = read();

        do {
            ret = ret * 10 + c - '0';
        }
        while ((c = read()) >= '0' && c <= '9');

        if (c == '.') {
            while ((c = read()) >= '0' && c <= '9') {
                ret += (c - '0') / (div *= 10);
            }
        }

        if (neg)
            return -ret;
        return ret;
    }

    private void fillBuffer() throws IOException {
        bytesRead = din.read(buffer, bufferPointer = 0, BUFFER_SIZE);
        if (bytesRead == -1)
            buffer[0] = -1;
    }

    private byte read() throws IOException {
        if (bufferPointer == bytesRead)
            fillBuffer();
        return buffer[bufferPointer++];
    }

    public void close() throws IOException {
        if (din == null)
            return;
        din.close();
    }
}

//Pair implementation
class Pair<A, C> {
    public A a;
    public C c;

    Pair(A a, C c) {
        this.a = a;
        this.c = c;
    }

    A getKey() {
        return this.a;
    }

    C getValue() {
        return this.c;
    }

    void print() {
        System.out.println(this.a + " " + this.c);
    }
}