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 PYTHON):

Solution:
# -*- coding: utf-8 -*- 
import heapq
from itertools import combinations, permutations, product

n, k = map(int, raw_input().split())

ncr = lambda x: x*(x-1)*(x-2)*(x-3)/24

ans = []
'''
multiples = set()
i = 2
while ncr(len(ans)) < n:
    if i not in multiples:
        ans.append(i)
        multiples.update(range(i * i, n + 1, i))
    i += 2
'''
'''
nonprimes = []
i = 2
while len(ans) < 4 * n:
    if nonprimes and i == nonprimes[0][0]:
        while nonprimes[0][0] == i:
            x = nonprimes[0]
            x[0] += x[1]
            heapq.heapreplace(nonprimes, x)

    else:
        heapq.heappush(nonprimes, [i*i, i])
        ans.append(i)

    i += 1
print nonprimes
'''
'''
banned = set()
cur = 1
mans = 0
while len(ans) < n:
    t = []
    tb = set([])
    i = cur
    tcur = cur + 4
    while len(t) != 4:
        for j in t:
            
        
        t.append(i)
        banned.add(i)

        i += 1
    cur = min(min(tb), t[-1] + 1)
    ans.append(t)
    mans = max(mans, t[-1])
    #print t
'''

for i in xrange(n):
    ans.append([6 * i + z for z in [1, 2, 3, 5]])

print ans[-1][-1] * k
for i in xrange(n):
    print ' '.join(map(lambda z: str(z[0] * z[1]), zip(ans[i], [k] * 4)))
'''
i = 0
for x in combinations(ans, 4):
    if i == n:
        pass#break
    print ' '.join(map(lambda z: str(z[0] * z[1]), zip(x, [k] * 4)))
    i += 1
'''