The only difference between easy and hard versions is constraints.

Polycarp loves to listen to music, so he never leaves the player, even on the way home from the university. Polycarp overcomes the distance from the university to the house in exactly $T$ minutes.

In the player, Polycarp stores $n$ songs, each of which is characterized by two parameters: $t_i$ and $g_i$, where $t_i$ is the length of the song in minutes ($1 \le t_i \le 15$), $g_i$ is its genre ($1 \le g_i \le 3$).

Polycarp wants to create such a playlist so that he can listen to music all the time on the way from the university to his home, and at the time of his arrival home, the playlist is over. Polycarp never interrupts songs and always listens to them from beginning to end. Thus, if he started listening to the $i$-th song, he would spend exactly $t_i$ minutes on its listening. Polycarp also does not like when two songs of the same genre play in a row (i.e. successively/adjacently) or when the songs in his playlist are repeated.

Help Polycarpus count the number of different sequences of songs (their order matters), the total duration is exactly $T$, such that there are no two consecutive songs of the same genre in them and all the songs in the playlist are different.


-----Input-----

The first line of the input contains two integers $n$ and $T$ ($1 \le n \le 15, 1 \le T \le 225$) — the number of songs in the player and the required total duration, respectively.

Next, the $n$ lines contain descriptions of songs: the $i$-th line contains two integers $t_i$ and $g_i$ ($1 \le t_i \le 15, 1 \le g_i \le 3$) — the duration of the $i$-th song and its genre, respectively.


-----Output-----

Output one integer — the number of different sequences of songs, the total length of exactly $T$, such that there are no two consecutive songs of the same genre in them and all the songs in the playlist are different. Since the answer may be huge, output it modulo $10^9 + 7$ (that is, the remainder when dividing the quantity by $10^9 + 7$).


-----Examples-----
Input
3 3
1 1
1 2
1 3

Output
6

Input
3 3
1 1
1 1
1 3

Output
2

Input
4 10
5 3
2 1
3 2
5 1

Output
10



-----Note-----

In the first example, Polycarp can make any of the $6$ possible playlist by rearranging the available songs: $[1, 2, 3]$, $[1, 3, 2]$, $[2, 1, 3]$, $[2, 3, 1]$, $[3, 1, 2]$ and $[3, 2, 1]$ (indices of the songs are given).

In the second example, the first and second songs cannot go in succession (since they have the same genre). Thus, Polycarp can create a playlist in one of $2$ possible ways: $[1, 3, 2]$ and $[2, 3, 1]$ (indices of the songs are given).

In the third example, Polycarp can make the following playlists: $[1, 2, 3]$, $[1, 3, 2]$, $[2, 1, 3]$, $[2, 3, 1]$, $[3, 1, 2]$, $[3, 2, 1]$, $[1, 4]$, $[4, 1]$, $[2, 3, 4]$ and $[4, 3, 2]$ (indices of the songs are given).

Source: codeforces | Difficulty: HARD
Tags: Dynamic programming

Bit manipulation

Combinatorics


Solutions:
from itertools import combinations

def findsum(comb):
	sum = 0
	for song in comb:
		sum += song[0]
	return sum

def finda(a, b, c):
	if a == 0:
		return 0
	if a == 1 and b == 0 and (c == 0):
		return 1
	else:
		return a * findb(a - 1, b, c) + a * findc(a - 1, b, c)

def findb(a, b, c):
	if b == 0:
		return 0
	if b == 1 and a == 0 and (c == 0):
		return 1
	else:
		return b * finda(a, b - 1, c) + b * findc(a, b - 1, c)

def findc(a, b, c):
	if c == 0:
		return 0
	if c == 1 and a == 0 and (b == 0):
		return 1
	else:
		return c * finda(a, b, c - 1) + c * findb(a, b, c - 1)
(n, T) = map(int, input().split())
songs = []
total_combinations = 0
for i in range(n):
	(t, g) = map(int, input().split())
	songs.append([t, g])
for i in range(1, n + 1):
	allcomb = list(combinations(songs, i))
	for comb in allcomb:
		sum = findsum(comb)
		if sum == T:
			a = 0
			b = 0
			c = 0
			for song in comb:
				if song[1] == 1:
					a += 1
				elif song[1] == 2:
					b += 1
				else:
					c += 1
			total_combinations += finda(a, b, c) + findb(a, b, c) + findc(a, b, c)
total_combinations = total_combinations % 1000000007
print(total_combinations)


import sys
input = sys.stdin.readline
(n, T) = map(int, input().split())
S = [list(map(int, input().split())) for i in range(n)]
DP = [[0] * 4 for i in range(T + 1)]
mod = 10 ** 9 + 7
from functools import lru_cache

@lru_cache(maxsize=None)
def calc(used, recent, time):
	ANS = 0
	for i in range(n):
		if i in used:
			continue
		if time + S[i][0] > T:
			continue
		if S[i][1] == recent:
			continue
		if time + S[i][0] == T:
			ANS += 1
		if time + S[i][0] < T:
			used2 = list(used) + [i]
			used2.sort()
			recent2 = S[i][1]
			time2 = time + S[i][0]
			ANS = (ANS + calc(tuple(used2), recent2, time2)) % mod
	return ANS
print(calc(tuple(), -1, 0) % mod)


def popcount(i):
	assert 0 <= i < 4294967296
	i = i - (i >> 1 & 1431655765)
	i = (i & 858993459) + (i >> 2 & 858993459)
	return ((i + (i >> 4) & 252645135) * 16843009 & 4294967295) >> 24
(N, T) = map(int, input().split())
TG = [list(map(int, input().split())) for _ in range(N)]
mod = 10 ** 9 + 7
dp = [[0] * 2 ** N for _ in range(4)]
for i in range(1, 4):
	dp[i][0] = 1
for S in range(2 ** N):
	if popcount(S) == 1:
		dp[TG[(S & -S).bit_length() - 1][1]][S] = 1
	for i in range(1, 4):
		for j in range(N):
			if S & 2 ** j or i == TG[j][1]:
				continue
			dp[TG[j][1]][S | 2 ** j] = (dp[TG[j][1]][S | 2 ** j] + dp[i][S]) % mod
table = [0] * 2 ** N
for S in range(2 ** N):
	table[S] = sum((TG[j][0] for j in range(N) if 2 ** j & S))
ans = 0
for S in range(2 ** N):
	if table[S] == T:
		for i in range(1, 4):
			ans = (ans + dp[i][S]) % mod
print(ans)


import sys
input = sys.stdin.readline
mod = 10 ** 9 + 7
(n, t) = map(int, input().split())
a = []
for i in range(n):
	(time, genre) = map(int, input().split())
	genre -= 1
	a.append((time, genre))
dp = [[0 for j in range(3)] for i in range(1 << n)]
for i in range(n):
	dp[1 << i][a[i][1]] = 1
for i in range(1 << n):
	for j in range(3):
		if dp[i][j] == 0:
			continue
		mask = 1
		for k in range(n):
			if i & mask or a[k][1] == j:
				mask <<= 1
				continue
			dp[i | mask][a[k][1]] = (dp[i | mask][a[k][1]] + dp[i][j]) % mod
			mask <<= 1
ans = 0
for i in range(1 << n):
	mask = 1
	duration = 0
	for j in range(n):
		if i & mask:
			duration += a[j][0]
		mask <<= 1
	if duration == t:
		ans = (ans + sum(dp[i])) % mod
print(ans)


from functools import lru_cache
P = 10 ** 9 + 7
(N, T) = map(int, input().split())
A = [[], [], []]
X = []
for _ in range(N):
	(t, g) = map(int, input().split())
	X.append((t, g))

@lru_cache(maxsize=None)
def calc(x, pr, t):
	if t < 0:
		return 0
	if t == 0:
		return 1
	if x == 0:
		return 0
	ans = 0
	for i in range(15):
		if x & 1 << i:
			if X[i][1] != pr:
				y = x ^ 1 << i
				ans = (ans + calc(y, X[i][1], t - X[i][0])) % P
	return ans
print(calc(2 ** N - 1, -1, T))


(n, tnow) = map(int, input().split())
left = int(''.join(['1' for i in range(n)]), 2)
arr = []
dp = {}
for i in range(n):
	(a, b) = map(int, input().split())
	arr.append([a, b])

def recur(tnow, prevgenre, left):
	key = str(left) + '_' + str(prevgenre)
	if tnow == 0:
		return 1
	elif key in dp:
		return dp[key]
	else:
		ans = 0
		for i in range(n):
			if left & 1 << i != 0:
				if arr[i][0] <= tnow and arr[i][1] != prevgenre:
					left = left & ~(1 << i)
					ans += recur(tnow - arr[i][0], arr[i][1], left)
					left = left | 1 << i
		dp[key] = ans
		return ans
print(recur(tnow, 4, left) % (10 ** 9 + 7))


from itertools import combinations

def out1(a, b, c):
	if a < 0 or b < 0 or c < 0:
		return 0
	if a == 1 and b == 0 and (c == 0):
		return 1
	return a * (out2(a - 1, b, c) + out3(a - 1, b, c))

def out2(a, b, c):
	if a < 0 or b < 0 or c < 0:
		return 0
	if a == 0 and b == 1 and (c == 0):
		return 1
	return b * (out1(a, b - 1, c) + out3(a, b - 1, c))

def out3(a, b, c):
	if a < 0 or b < 0 or c < 0:
		return 0
	if a == 0 and b == 0 and (c == 1):
		return 1
	return c * (out2(a, b, c - 1) + out1(a, b, c - 1))

def column(matrix, i):
	return [row[i] for row in matrix]
(N, T) = [int(x) for x in input().split()]
A = []
s = 0
for i in range(N):
	A.append([int(x) for x in input().split()])
for i in range(1, N + 1):
	comb = list(combinations(A, i))
	for x in comb:
		if sum(column(x, 0)) == T:
			a = column(x, 1).count(1)
			b = column(x, 1).count(2)
			c = column(x, 1).count(3)
			s += out1(a, b, c) + out2(a, b, c) + out3(a, b, c)
print(s % 1000000007)


import os, sys
from io import BytesIO, IOBase

def main():
	mod = 10 ** 9 + 7
	(n, T) = map(int, input().split())
	y = 1 << n
	dp = [[0] * 3 for _ in range(y)]
	peo = [list(map(int, input().split())) for _ in range(n)]
	for (ind, i) in enumerate(peo):
		peo[ind][1] -= 1
		dp[1 << ind][i[1]] = 1
	for i in range(y):
		for j in range(3):
			if not dp[i][j]:
				continue
			mask = 1
			for k in range(n):
				if i & mask or peo[k][1] == j:
					mask <<= 1
					continue
				dp[i | mask][peo[k][1]] = (dp[i | mask][peo[k][1]] + dp[i][j]) % mod
				mask <<= 1
	ans = 0
	for i in range(y):
		(ans1, mask) = (0, 1)
		for j in range(n):
			if i & mask:
				ans1 += peo[j][0]
			mask <<= 1
		if ans1 == T:
			ans = (ans + sum(dp[i])) % mod
	print(ans)
BUFSIZE = 8192

class FastIO(IOBase):
	newlines = 0

	def __init__(self, file):
		self._fd = file.fileno()
		self.buffer = BytesIO()
		self.writable = 'x' in file.mode or 'r' not in file.mode
		self.write = self.buffer.write if self.writable else None

	def read(self):
		while True:
			b = os.read(self._fd, max(os.fstat(self._fd).st_size, BUFSIZE))
			if not b:
				break
			ptr = self.buffer.tell()
			(self.buffer.seek(0, 2), self.buffer.write(b), self.buffer.seek(ptr))
		self.newlines = 0
		return self.buffer.read()

	def readline(self):
		while self.newlines == 0:
			b = os.read(self._fd, max(os.fstat(self._fd).st_size, BUFSIZE))
			self.newlines = b.count(b'\n') + (not b)
			ptr = self.buffer.tell()
			(self.buffer.seek(0, 2), self.buffer.write(b), self.buffer.seek(ptr))
		self.newlines -= 1
		return self.buffer.readline()

	def flush(self):
		if self.writable:
			os.write(self._fd, self.buffer.getvalue())
			(self.buffer.truncate(0), self.buffer.seek(0))

class IOWrapper(IOBase):

	def __init__(self, file):
		self.buffer = FastIO(file)
		self.flush = self.buffer.flush
		self.writable = self.buffer.writable
		self.write = lambda s: self.buffer.write(s.encode('ascii'))
		self.read = lambda : self.buffer.read().decode('ascii')
		self.readline = lambda : self.buffer.readline().decode('ascii')
(sys.stdin, sys.stdout) = (IOWrapper(sys.stdin), IOWrapper(sys.stdout))
input = lambda : sys.stdin.readline().rstrip('\r\n')
main()


from math import factorial

def lol(n):
	if n == 1:
		yield [0]
		yield [1]
	else:
		for p in lol(n - 1):
			p.append(0)
			yield p
			p[-1] = 1
			yield p
			p.pop()

def sp(g1, g2, g3, f):
	if g1 == 0:
		if g2 == g3:
			return 2
		elif abs(g2 - g3) == 1:
			return 1
		else:
			return 0
	elif g2 == 0:
		if g1 == g3:
			return 2
		elif abs(g1 - g3) == 1:
			return 1
		else:
			return 0
	elif g3 == 0:
		if g2 == g1:
			return 2
		elif abs(g2 - g1) == 1:
			return 1
		else:
			return 0
	elif f == 1:
		b = sp(g1, g2 - 1, g3, 2)
		c = sp(g1, g2, g3 - 1, 3)
		return b + c
	elif f == 2:
		a = sp(g1 - 1, g2, g3, 1)
		c = sp(g1, g2, g3 - 1, 3)
		return a + c
	elif f == 3:
		a = sp(g1 - 1, g2, g3, 1)
		b = sp(g1, g2 - 1, g3, 2)
		return a + b
	else:
		a = sp(g1 - 1, g2, g3, 1)
		b = sp(g1, g2 - 1, g3, 2)
		c = sp(g1, g2, g3 - 1, 3)
		return a + b + c
(n, T) = map(int, input().split())
S = []
cnt = 0
M = 10 ** 9 + 7
for i in range(n):
	S.append(list(map(int, input().split())))
for p in lol(n):
	d = 0
	(g1, g2, g3) = (0, 0, 0)
	for i in range(n):
		if p[i]:
			d += S[i][0]
			if S[i][1] == 1:
				g1 += 1
			elif S[i][1] == 2:
				g2 += 1
			elif S[i][1] == 3:
				g3 += 1
	if d == T:
		cnt += factorial(g1) * factorial(g2) * factorial(g3) * sp(g1, g2, g3, 0)
		cnt %= M
print(cnt)