Problem: Dreamoon likes to play with sets, integers and <image>. <image> is defined as the largest positive integer that divides both a and b.

Let S be a set of exactly four distinct integers greater than 0. Define S to be of rank k if and only if for all pairs of distinct elements si, sj from S, <image>.

Given k and n, Dreamoon wants to make up n sets of rank k using integers from 1 to m such that no integer is used in two different sets (of course you can leave some integers without use). Calculate the minimum m that makes it possible and print one possible solution.

Input

The single line of the input contains two space separated integers n, k (1 ≤ n ≤ 10 000, 1 ≤ k ≤ 100).

Output

On the first line print a single integer — the minimal possible m. 

On each of the next n lines print four space separated integers representing the i-th set.

Neither the order of the sets nor the order of integers within a set is important. If there are multiple possible solutions with minimal m, print any one of them.

Examples

Input

1 1


Output

5
1 2 3 5


Input

2 2


Output

22
2 4 6 22
14 18 10 16

Note

For the first example it's easy to see that set {1, 2, 3, 4} isn't a valid set of rank 1 since <image>.

Solution (in JAVA):

Solution:
import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;
import java.util.*;

public class ProblemB2 {
    private boolean[] used;
    BufferedReader rd;
    int fc, n, mp;
    private int[][] fours;

    private ProblemB2() throws IOException {
        rd = new BufferedReader(new InputStreamReader(System.in));
        int[] a = intarr();
        n = a[0];
        int k = a[1];
        fours = new int[n][4];
        used = new boolean[100000];
        start();
        out(mp*k);
        for(int i=0;i<fc;i++) {
            StringBuilder buf = new StringBuilder();
            for(int t=0;t<4;t++) {
                if(t > 0) {
                    buf.append(' ');
                }
                buf.append(k*fours[i][t]);
            }
            out(buf);
        }
    }

    private void start() {
        List<int[]> unused = new ArrayList<>();
        int p=0;
        while(true) {
            p++;
            if(used[p]) {
                continue;
            }
            unused.add(new int[] { 1, p, 0, 0, 0 });
            boolean found = false;
            for(int[] e: unused) {
                boolean ok = true;
                for(int i=0;i<e[0];i++) {
                    if(!wp(e[i+1],p) || e[i+1] == p) {
                        ok = false;
                    }
                }
                if(ok) {
                    e[0]++;
                    e[e[0]] = p;
                    if(e[0] == 4) {
                        System.arraycopy(e,1,fours[fc],0,4);
                        for(int i=1;i<=4;i++) {
                            used[i] = true;
                        }
                        fc++;
                        if(fc == n) {
                            mp = p;
                            return;
                        }
                        found = true;
                        break;
                    }
                }
            }
            if(found) {
                SortedSet<Integer> idxToRemove = new TreeSet<>(new Comparator<Integer>() {
                    @Override
                    public int compare(Integer o1, Integer o2) {
                        return o2.compareTo(o1);
                    }
                });
                for(int i: fours[fc-1]) {
                    for(int k=0;k<unused.size();k++) {
                        int[] e = unused.get(k);
                        for(int j=0;j<e[0];j++) {
                            if(e[j+1] == i) {
                                idxToRemove.add(k);
                                break;
                            }
                        }
                    }
                }
                for(Integer idx: idxToRemove) {
                    unused.remove(idx.intValue());
                }
            }
        }
    }

    private boolean wp(int a, int b) {
        return gcd(a,b) == 1;
    }

    private int gcd(int a, int b) {
        while (b > 0) {
            int c = a % b;
            a = b;
            b = c;
        }
        return a;
    }

    private int[] intarr() throws IOException {
        return intarr(rd.readLine());
    }

    private int[] intarr(String s) {
        String[] q = s.split(" ");
        int n = q.length;
        int[] a = new int[n];
        for(int i=0;i<n;i++) {
            a[i] = Integer.parseInt(q[i]);
        }
        return a;
    }

    private static void out(Object x) {
        System.out.println(x);
    }

    public static void main(String[] args) throws IOException {
        new ProblemB2();
    }
}